BPHWriteSpecificDecay.h

Go to the documentation of this file.

#ifndef HeavyFlavorAnalysis_SpecificDecay_BPHWriteSpecificDecay_h
#define HeavyFlavorAnalysis_SpecificDecay_BPHWriteSpecificDecay_h

#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHAnalyzerTokenWrapper.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHPlusMinusCandidate.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoCandidate.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHTrackReference.h"

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/PatCandidates/interface/GenericParticle.h"
#include "DataFormats/PatCandidates/interface/CompositeCandidate.h"

#include "RecoVertex/KinematicFitPrimitives/interface/RefCountedKinematicParticle.h"
#include "RecoVertex/KinematicFitPrimitives/interface/RefCountedKinematicVertex.h"

#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <fstream>

class TH1F;
class BPHRecoCandidate;

class BPHWriteSpecificDecay:
      public BPHAnalyzerWrapper<BPHModuleWrapper::one_producer> {

 public:

  explicit BPHWriteSpecificDecay( const edm::ParameterSet& ps );
  ~BPHWriteSpecificDecay() override;

  static void fillDescriptions( edm::ConfigurationDescriptions& descriptions );

  void beginJob() override;
  void produce( edm::Event& ev, const edm::EventSetup& es ) override;
  virtual void fill( edm::Event& ev, const edm::EventSetup& es );
  void endJob() override;

 private:

  std::string pVertexLabel;
  std::string patMuonLabel;
  std::string ccCandsLabel;
  std::string pfCandsLabel;
  std::string pcCandsLabel;
  std::string gpCandsLabel;

  // token wrappers to allow running both on "old" and "new" CMSSW versions
  BPHTokenWrapper< std::vector<reco::Vertex                > > pVertexToken;
  BPHTokenWrapper< pat::MuonCollection                       > patMuonToken;
  BPHTokenWrapper< std::vector<pat::CompositeCandidate     > > ccCandsToken;
  BPHTokenWrapper< std::vector<reco::PFCandidate           > > pfCandsToken;
  BPHTokenWrapper< std::vector<BPHTrackReference::candidate> > pcCandsToken;
  BPHTokenWrapper< std::vector<pat::GenericParticle        > > gpCandsToken;

  bool usePV;
  bool usePM;
  bool useCC;
  bool usePF;
  bool usePC;
  bool useGP;

  std::string oniaName;
  std::string   sdName;
  std::string   ssName;
  std::string   buName;
  std::string   bdName;
  std::string   bsName;

  enum recoType { Onia, Pmm , Psi1, Psi2, Ups , Ups1, Ups2, Ups3,
                  Kx0, Pkk, Bu, Bd, Bs };
  enum  parType { ptMin, etaMax,
                  mPsiMin, mPsiMax, mKx0Min, mKx0Max, mPhiMin, mPhiMax, 
                  massMin, massMax, probMin, mFitMin, mFitMax,
                  constrMass, constrSigma, constrMJPsi, writeCandidate };
  std::map<std::string,recoType> rMap;
  std::map<std::string, parType> pMap;
  std::map<std::string, parType> fMap;
  std::map< recoType, std::map<parType,double> > parMap;

  bool recoOnia;
  bool recoKx0;
  bool recoPkk;
  bool recoBu;
  bool recoBd;
  bool recoBs;

  bool writeOnia;
  bool writeKx0;
  bool writePkk;
  bool writeBu;
  bool writeBd;
  bool writeBs;

  bool writeVertex;
  bool writeMomentum;

  std::vector<BPHPlusMinusConstCandPtr> lFull;
  std::vector<BPHPlusMinusConstCandPtr> lJPsi;
  std::vector<BPHRecoConstCandPtr> lSd;
  std::vector<BPHRecoConstCandPtr> lSs;
  std::vector<BPHRecoConstCandPtr> lBu;
  std::vector<BPHRecoConstCandPtr> lBd;
  std::vector<BPHRecoConstCandPtr> lBs;

  std::map<const BPHRecoCandidate*,const BPHRecoCandidate*> jPsiOMap;
  typedef edm::Ref< std::vector<reco::Vertex> > vertex_ref;
  std::map<const BPHRecoCandidate*,vertex_ref> pvRefMap;
  typedef edm::Ref< pat::CompositeCandidateCollection > compcc_ref;
  std::map<const BPHRecoCandidate*,compcc_ref> ccRefMap;

  void setRecoParameters( const edm::ParameterSet& ps );

  template <class T>
  edm::OrphanHandle<pat::CompositeCandidateCollection> write( edm::Event& ev,
              const std::vector<T>& list, const std::string& name ) {
    pat::CompositeCandidateCollection* ccList =
      new pat::CompositeCandidateCollection;
    int i;
    int n = list.size();
    std::map<const BPHRecoCandidate*,
             const BPHRecoCandidate*>::const_iterator jpoIter;
    std::map<const BPHRecoCandidate*,
             const BPHRecoCandidate*>::const_iterator jpoIend = jPsiOMap.end();
    std::map<const BPHRecoCandidate*,vertex_ref>::const_iterator pvrIter;
    std::map<const BPHRecoCandidate*,vertex_ref>::const_iterator pvrIend =
                                                                 pvRefMap.end();
    std::map<const BPHRecoCandidate*,compcc_ref>::const_iterator ccrIter;
    std::map<const BPHRecoCandidate*,compcc_ref>::const_iterator ccrIend =
                                                                 ccRefMap.end();
    for ( i = 0; i < n; ++i ) {
      const T& ptr = list[i];
      ccList->push_back( ptr->composite() );
      pat::CompositeCandidate& cc = ccList->back();
      if ( ( pvrIter = pvRefMap.find( ptr.get() ) ) != pvrIend )
           cc.addUserData ( "primaryVertex", pvrIter->second );
      const std::vector<std::string>& cNames = ptr->compNames();
      int j = 0;
      int m = cNames.size();
      while ( j < m ) {
        const std::string& compName = cNames[j++];
        const BPHRecoCandidate* cptr = ptr->getComp( compName ).get();
        if ( ( ccrIter = ccRefMap.find( cptr ) ) == ccrIend ) {
          if ( ( jpoIter = jPsiOMap.find( cptr ) ) != jpoIend )
               cptr = jpoIter->second;
          else cptr = nullptr;
        }
        if ( ( ccrIter = ccRefMap.find( cptr ) ) != ccrIend ) {
          compcc_ref cref = ccrIter->second;
          if ( cref.isNonnull() ) cc.addUserData ( "refTo" + compName, cref );
        }
      }
      const BPHPlusMinusCandidate* pmp =
            dynamic_cast<const BPHPlusMinusCandidate*>( ptr.get() );
      if ( pmp != nullptr ) cc.addUserData( "cowboy", pmp->isCowboy() );
      if ( ptr->isEmpty() ) {
        if ( writeVertex ) cc.addUserData( "vertex" , ptr->vertex() );
        continue;
      }
      if ( writeVertex ) cc.addUserData( "fitVertex",
                         reco::Vertex( *ptr->currentDecayVertex() ) );
      if ( ptr->isValidFit() ) {
        const RefCountedKinematicParticle kinPart = ptr->currentParticle();
        const           KinematicState    kinStat = kinPart->currentState();
        cc.addUserFloat( "fitMass", kinStat.mass() );
        if ( writeMomentum ) cc.addUserData ( "fitMomentum",
                             kinStat.kinematicParameters().momentum() );
      }

    }
    typedef std::unique_ptr<pat::CompositeCandidateCollection> ccc_pointer;
    edm::OrphanHandle<pat::CompositeCandidateCollection> ccHandle =
    ev.put( ccc_pointer( ccList ), name );
    for ( i = 0; i < n; ++i ) {
      const BPHRecoCandidate* ptr = list[i].get();
      edm::Ref<pat::CompositeCandidateCollection> ccRef( ccHandle, i );
      ccRefMap[ptr] = ccRef;
    }
    return ccHandle;
  }

};

#endif