d3/d62/TrackAssociatorByHits_8cc_source.html

 //

 //

 #include "FWCore/Framework/interface/Frameworkfwd.h"

 #include "FWCore/Framework/interface/Event.h"

 #include "FWCore/Framework/interface/EventSetup.h"

 #include "FWCore/Framework/interface/ESHandle.h"

 #include "FWCore/ParameterSet/interface/ParameterSet.h"

 #include "DataFormats/Common/interface/EDProduct.h"

 #include "DataFormats/Common/interface/Ref.h"

 #include "SimTracker/TrackAssociation/interface/TrackAssociatorByHits.h"

 #include "SimTracker/TrackerHitAssociation/interface/TrackerHitAssociator.h"

 #include "FWCore/MessageLogger/interface/MessageLogger.h"

 #include "FWCore/Utilities/interface/Exception.h"


 //reco track

 #include "DataFormats/TrackReco/interface/TrackFwd.h"

 #include "DataFormats/TrackReco/interface/Track.h"

 #include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"

 //TrackingParticle

 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"

 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"

 #include "SimDataFormats/EncodedEventId/interface/EncodedEventId.h"

 //##---new stuff

 #include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"

 #include "DataFormats/DetId/interface/DetId.h"

 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"

 #include "DataFormats/SiStripDetId/interface/StripSubdetector.h"

 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"

 #include "DataFormats/SiStripDetId/interface/TECDetId.h"

 #include "DataFormats/SiStripDetId/interface/TIBDetId.h"

 #include "DataFormats/SiStripDetId/interface/TIDDetId.h"

 #include "DataFormats/SiStripDetId/interface/TOBDetId.h"

 #include "DataFormats/SiPixelDetId/interface/PXBDetId.h"

 #include "DataFormats/SiPixelDetId/interface/PXFDetId.h"

 using namespace reco;

 using namespace std;


 /* Constructor */

 TrackAssociatorByHits::TrackAssociatorByHits (const edm::ParameterSet& conf) :

   conf_(conf),

   AbsoluteNumberOfHits(conf_.getParameter<bool>("AbsoluteNumberOfHits")),

   SimToRecoDenominator(denomnone),

   quality_SimToReco(conf_.getParameter<double>("Quality_SimToReco")),

   purity_SimToReco(conf_.getParameter<double>("Purity_SimToReco")),

   cut_RecoToSim(conf_.getParameter<double>("Cut_RecoToSim")),

   UsePixels(conf_.getParameter<bool>("UsePixels")),

   UseGrouped(conf_.getParameter<bool>("UseGrouped")),

   UseSplitting(conf_.getParameter<bool>("UseSplitting")),

   ThreeHitTracksAreSpecial(conf_.getParameter<bool>("ThreeHitTracksAreSpecial"))

 {

   std::string tmp = conf_.getParameter<string>("SimToRecoDenominator");

   if (tmp=="sim") {

     SimToRecoDenominator = denomsim;

   } else if (tmp == "reco") {

     SimToRecoDenominator = denomreco;

   }


   if (SimToRecoDenominator == denomnone) {

     throw cms::Exception("TrackAssociatorByHits") << "SimToRecoDenominator not specified as sim or reco";

   }


 }


 /* Destructor */

 TrackAssociatorByHits::~TrackAssociatorByHits()

 {

   //do cleanup here

 }


 //

 //---member functions

 //


 RecoToSimCollection

 TrackAssociatorByHits::associateRecoToSim(const edm::RefToBaseVector<reco::Track>& tC,

                       const edm::RefVector<TrackingParticleCollection>& TPCollectionH,

                       const edm::Event * e,

                                           const edm::EventSetup *setup ) const{


   //edm::LogVerbatim("TrackAssociator") << "Starting TrackAssociatorByHits::associateRecoToSim - #tracks="<<tC.size()<<" #TPs="<<TPCollectionH.size();

   int nshared = 0;

   float quality=0;//fraction or absolute number of shared hits

   std::vector< SimHitIdpr> SimTrackIds;

   std::vector< SimHitIdpr> matchedIds;

   RecoToSimCollection  outputCollection;


   TrackerHitAssociator * associate = new TrackerHitAssociator(*e, conf_);


   TrackingParticleCollection tPC;

   if (TPCollectionH.size()!=0)  tPC = *const_cast<TrackingParticleCollection*>(TPCollectionH.product());


   //get the ID of the recotrack  by hits

   int tindex=0;

   for (edm::RefToBaseVector<reco::Track>::const_iterator track=tC.begin(); track!=tC.end(); track++, tindex++){

     matchedIds.clear();

     int ri=0;//valid rechits

     //LogTrace("TrackAssociator") << "\nNEW TRACK - track number " << tindex <<" with pt =" << (*track)->pt() << " # valid=" << (*track)->found();

     getMatchedIds<trackingRecHit_iterator>(matchedIds, SimTrackIds, ri, (*track)->recHitsBegin(), (*track)->recHitsEnd(), associate);


     //LogTrace("TrackAssociator") << "MATCHED IDS LIST BEGIN" ;

     //for(size_t j=0; j<matchedIds.size(); j++){

     //  LogTrace("TrackAssociator") << "matchedIds[j].first=" << matchedIds[j].first;

     //}

     //LogTrace("TrackAssociator") << "MATCHED IDS LIST END" ;

     //LogTrace("TrackAssociator") << "#matched ids=" << matchedIds.size() << " #tps=" << tPC.size();


     //save id for the track

     std::vector<SimHitIdpr> idcachev;

     if(!matchedIds.empty()){


       int tpindex =0;

       for (TrackingParticleCollection::iterator t = tPC.begin(); t != tPC.end(); ++t, ++tpindex) {

         //int nsimhit = t->trackPSimHit(DetId::Tracker).size();

     //LogTrace("TrackAssociator") << "TP number " << tpindex << " pdgId=" << t->pdgId() << " with number of PSimHits: "  << nsimhit;

     idcachev.clear();

     nshared = getShared(matchedIds, idcachev, t);


     //if electron subtract double counting

     if (abs(t->pdgId())==11&&(t->g4Track_end()-t->g4Track_begin())>1){

       nshared-=getDoubleCount<trackingRecHit_iterator>((*track)->recHitsBegin(), (*track)->recHitsEnd(), associate, t);

     }


     if (AbsoluteNumberOfHits) quality = static_cast<double>(nshared);

     else if(ri!=0) quality = (static_cast<double>(nshared)/static_cast<double>(ri));

     else quality = 0;

     //cut on the fraction

         //float purity = 1.0*nshared/ri;

     if(quality > cut_RecoToSim && !(ThreeHitTracksAreSpecial && ri==3 && nshared<3)){

       //if a track has just 3 hits we require that all 3 hits are shared

       outputCollection.insert(tC[tindex],

                   std::make_pair(edm::Ref<TrackingParticleCollection>(TPCollectionH, tpindex),

                          quality));

 //          LogTrace("TrackAssociator") << "reco::Track number " << tindex  << " with #hits=" << ri <<" pt=" << (*track)->pt()

 //                                      << " associated to TP (pdgId, nb segments, p) = "

 //                                      << (*t).pdgId() << " " << (*t).g4Tracks().size()

 //                                      << " " << (*t).momentum() << " #hits=" << nsimhit

 //                                      << " TP index=" << tpindex<< " with quality =" << quality;

     } else {

 //          LogTrace("TrackAssociator") <<"reco::Track number " << tindex << " with #hits=" << ri

 //                                      << " NOT associated with quality =" << quality;

     }

       }//TP loop

     }

   }

   //LogTrace("TrackAssociator") << "% of Assoc Tracks=" << ((double)outputCollection.size())/((double)tC.size());

   delete associate;

   outputCollection.post_insert();

   return outputCollection;

 }


 SimToRecoCollection

 TrackAssociatorByHits::associateSimToReco(const edm::RefToBaseVector<reco::Track>& tC,

                       const edm::RefVector<TrackingParticleCollection>& TPCollectionH,

                       const edm::Event * e,

                                           const edm::EventSetup *setup ) const{

 //  edm::LogVerbatim("TrackAssociator") << "Starting TrackAssociatorByHits::associateSimToReco - #tracks="<<tC.size()<<" #TPs="<<TPCollectionH.size();

   float quality=0;//fraction or absolute number of shared hits

   int nshared = 0;

   std::vector< SimHitIdpr> SimTrackIds;

   std::vector< SimHitIdpr> matchedIds;

   SimToRecoCollection  outputCollection;


   TrackerHitAssociator * associate = new TrackerHitAssociator(*e, conf_);


   TrackingParticleCollection tPC;

   if (TPCollectionH.size()!=0)  tPC = *const_cast<TrackingParticleCollection*>(TPCollectionH.product());


   //for (TrackingParticleCollection::const_iterator t = tPC.begin(); t != tPC.end(); ++t) {

   //  LogTrace("TrackAssociator") << "NEW TP DUMP";

   //  for (TrackingParticle::g4t_iterator g4T = t -> g4Track_begin();g4T !=  t -> g4Track_end(); ++g4T) {

   //    LogTrace("TrackAssociator") << "(*g4T).trackId()=" <<(*g4T).trackId() ;

   //  }

   //}


   //get the ID of the recotrack  by hits

   int tindex=0;

   for (edm::RefToBaseVector<reco::Track>::const_iterator track=tC.begin(); track!=tC.end(); track++, tindex++){

     //LogTrace("TrackAssociator") << "\nNEW TRACK - hits of track number " << tindex <<" with pt =" << (*track)->pt() << " # valid=" << (*track)->found();

     int ri=0;//valid rechits

     getMatchedIds<trackingRecHit_iterator>(matchedIds, SimTrackIds, ri, (*track)->recHitsBegin(), (*track)->recHitsEnd(), associate);


     //save id for the track

     std::vector<SimHitIdpr> idcachev;

     if(!matchedIds.empty()){


       int tpindex =0;

       for (TrackingParticleCollection::iterator t = tPC.begin(); t != tPC.end(); ++t, ++tpindex) {

     idcachev.clear();

         std::vector<PSimHit> trackerPSimHit( t->trackPSimHit(DetId::Tracker) );

         //int nsimhit = trackerPSimHit.size();

     float totsimhit = 0;

     std::vector<PSimHit> tphits;

     //LogTrace("TrackAssociator") << "TP number " << tpindex << " pdgId=" << t->pdgId() << " with number of PSimHits: "  << nsimhit;


     nshared = getShared(matchedIds, idcachev, t);


     //for(std::vector<PSimHit>::const_iterator TPhit = t->trackerPSimHit_begin(); TPhit != t->trackerPSimHit_end(); TPhit++){

     //  unsigned int detid = TPhit->detUnitId();

     //  DetId detId = DetId(TPhit->detUnitId());

     //  LogTrace("TrackAssociator") <<  " hit trackId= " << TPhit->trackId() << " det ID = " << detid

     //                    << " SUBDET = " << detId.subdetId() << " layer = " << LayerFromDetid(detId);

     //}


     if (nshared!=0) {//do not waste time recounting when it is not needed!!!!


       //count the TP simhit

       //LogTrace("TrackAssociator") << "recounting of tp hits";

       for(std::vector<PSimHit>::const_iterator TPhit = trackerPSimHit.begin(); TPhit != trackerPSimHit.end(); TPhit++){

         DetId dId = DetId(TPhit->detUnitId());


         unsigned int subdetId = static_cast<unsigned int>(dId.subdetId());

         if (!UsePixels && (subdetId==PixelSubdetector::PixelBarrel || subdetId==PixelSubdetector::PixelEndcap) )

           continue;


         //unsigned int dRawId = dId.rawId();

         SiStripDetId* stripDetId = 0;

         if (subdetId==SiStripDetId::TIB||subdetId==SiStripDetId::TOB||

         subdetId==SiStripDetId::TID||subdetId==SiStripDetId::TEC)

           stripDetId= new SiStripDetId(dId);

             //LogTrace("TrackAssociator") << "consider hit SUBDET = " << subdetId

             //                            << " layer = " << LayerFromDetid(dId)

             //                            << " id = " << dId.rawId();

         bool newhit = true;

         for(std::vector<PSimHit>::const_iterator TPhitOK = tphits.begin(); TPhitOK != tphits.end(); TPhitOK++){

           DetId dIdOK = DetId(TPhitOK->detUnitId());

           //unsigned int dRawIdOK = dIdOK.rawId();

               //LogTrace("TrackAssociator") << "\t\tcompare with SUBDET = " << dIdOK.subdetId()

               //                            << " layer = " << LayerFromDetid(dIdOK)

               //                            << " id = " << dIdOK.rawId();

           //no grouped, no splitting

           if (!UseGrouped && !UseSplitting)

         if (LayerFromDetid(dId)==LayerFromDetid(dIdOK) &&

             dId.subdetId()==dIdOK.subdetId()) newhit = false;

           //no grouped, splitting

           if (!UseGrouped && UseSplitting)

         if (LayerFromDetid(dId)==LayerFromDetid(dIdOK) &&

             dId.subdetId()==dIdOK.subdetId() &&

             (stripDetId==0 || stripDetId->partnerDetId()!=dIdOK.rawId()))

           newhit = false;

           //grouped, no splitting

           if (UseGrouped && !UseSplitting)

         if (LayerFromDetid(dId)==LayerFromDetid(dIdOK) &&

             dId.subdetId()==dIdOK.subdetId() &&

             stripDetId!=0 && stripDetId->partnerDetId()==dIdOK.rawId())

           newhit = false;

           //grouped, splitting

           if (UseGrouped && UseSplitting)

         newhit = true;

         }

         if (newhit) {

           //LogTrace("TrackAssociator") << "\t\tok";

           tphits.push_back(*TPhit);

         }

         //else LogTrace("TrackAssociator") << "\t\tno";

         delete stripDetId;

       }

       totsimhit = tphits.size();

     }


     if (AbsoluteNumberOfHits) quality = static_cast<double>(nshared);

     else if(SimToRecoDenominator == denomsim && totsimhit!=0) quality = ((double) nshared)/((double)totsimhit);

     else if(SimToRecoDenominator == denomreco && ri!=0) quality = ((double) nshared)/((double)ri);

     else quality = 0;

     //LogTrace("TrackAssociator") << "Final count: nhit(TP) = " << nsimhit << " re-counted = " << totsimhit

     //<< " nshared = " << nshared << " nrechit = " << ri;


     float purity = 1.0*nshared/ri;

     if (quality>quality_SimToReco && !(ThreeHitTracksAreSpecial && totsimhit==3 && nshared<3) && (AbsoluteNumberOfHits||(purity>purity_SimToReco))) {

       //if a track has just 3 hits we require that all 3 hits are shared

       outputCollection.insert(edm::Ref<TrackingParticleCollection>(TPCollectionH, tpindex),

                   std::make_pair(tC[tindex],quality));

 //          LogTrace("TrackAssociator") << "TrackingParticle number " << tpindex << " with #hits=" << nsimhit

 //                                      << " re-counted = "  << totsimhit << " nshared = " << nshared

 //                                      << " associated to track number " << tindex << " with pt=" << (*track)->pt()

 //                                      << " with hit quality =" << quality ;

     } else {

 //          LogTrace("TrackAssociator") << "TrackingParticle number " << tpindex << " with #hits=" << nsimhit

 //                                      << " re-counted = "  << totsimhit << " nshared = " << nshared

 //                                      << " NOT associated with quality =" << quality;

     }

       }

     }

   }

   //LogTrace("TrackAssociator") << "% of Assoc TPs=" << ((double)outputCollection.size())/((double)TPCollectionH.size());

   delete associate;

   outputCollection.post_insert();

   return outputCollection;

 }


 int TrackAssociatorByHits::LayerFromDetid(const DetId& detId ) const

 {

   int layerNumber=0;

   unsigned int subdetId = static_cast<unsigned int>(detId.subdetId());

   if ( subdetId == StripSubdetector::TIB)

     {

       TIBDetId tibid(detId.rawId());

       layerNumber = tibid.layer();

     }

   else if ( subdetId ==  StripSubdetector::TOB )

     {

       TOBDetId tobid(detId.rawId());

       layerNumber = tobid.layer();

     }

   else if ( subdetId ==  StripSubdetector::TID)

     {

       TIDDetId tidid(detId.rawId());

       layerNumber = tidid.wheel();

     }

   else if ( subdetId ==  StripSubdetector::TEC )

     {

       TECDetId tecid(detId.rawId());

       layerNumber = tecid.wheel();

     }

   else if ( subdetId ==  PixelSubdetector::PixelBarrel )

     {

       PXBDetId pxbid(detId.rawId());

       layerNumber = pxbid.layer();

     }

   else if ( subdetId ==  PixelSubdetector::PixelEndcap )

     {

       PXFDetId pxfid(detId.rawId());

       layerNumber = pxfid.disk();

     }

   else

     LogTrace("TrackAssociator") << "Unknown subdetid: " <<  subdetId;


   return layerNumber;

 }


 RecoToSimCollectionSeed

 TrackAssociatorByHits::associateRecoToSim(edm::Handle<edm::View<TrajectorySeed> >& seedCollectionH,

                       edm::Handle<TrackingParticleCollection>&  TPCollectionH,

                       const edm::Event * e,

                                           const edm::EventSetup *setup ) const{


   edm::LogVerbatim("TrackAssociator") << "Starting TrackAssociatorByHits::associateRecoToSim - #seeds="

                       <<seedCollectionH->size()<<" #TPs="<<TPCollectionH->size();

   int nshared = 0;

   float quality=0;//fraction or absolute number of shared hits

   std::vector< SimHitIdpr> SimTrackIds;

   std::vector< SimHitIdpr> matchedIds;

   RecoToSimCollectionSeed  outputCollection;


   TrackerHitAssociator * associate = new TrackerHitAssociator(*e, conf_);


   const TrackingParticleCollection tPC   = *(TPCollectionH.product());


   const edm::View<TrajectorySeed> sC = *(seedCollectionH.product());


   //get the ID of the recotrack  by hits

   int tindex=0;

   for (edm::View<TrajectorySeed>::const_iterator seed=sC.begin(); seed!=sC.end(); seed++, tindex++) {

     matchedIds.clear();

     int ri=0;//valid rechits

     int nsimhit = seed->recHits().second-seed->recHits().first;

     LogTrace("TrackAssociator") << "\nNEW SEED - seed number " << tindex << " # valid=" << nsimhit;

     getMatchedIds<edm::OwnVector<TrackingRecHit>::const_iterator>(matchedIds, SimTrackIds, ri, seed->recHits().first, seed->recHits().second, associate );


     //save id for the track

     std::vector<SimHitIdpr> idcachev;

     if(!matchedIds.empty()){


       int tpindex =0;

       for (TrackingParticleCollection::const_iterator t = tPC.begin(); t != tPC.end(); ++t, ++tpindex) {

     LogTrace("TrackAssociator") << "TP number " << tpindex << " pdgId=" << t->pdgId() << " with number of PSimHits: "  << nsimhit;

     idcachev.clear();

     nshared = getShared(matchedIds, idcachev, t);


     //if electron subtract double counting

     if (abs(t->pdgId())==11&&(t->g4Track_end()-t->g4Track_begin())>1){

       nshared-=getDoubleCount<edm::OwnVector<TrackingRecHit>::const_iterator>(seed->recHits().first, seed->recHits().second, associate, t);

     }


     if (AbsoluteNumberOfHits) quality = static_cast<double>(nshared);

     else if(ri!=0) quality = (static_cast<double>(nshared)/static_cast<double>(ri));

     else quality = 0;

     //cut on the fraction

     if(quality > cut_RecoToSim && !(ThreeHitTracksAreSpecial && ri==3 && nshared<3) ){

       //if a track has just 3 hits we require that all 3 hits are shared

       outputCollection.insert(edm::RefToBase<TrajectorySeed>(seedCollectionH,tindex),

                   std::make_pair(edm::Ref<TrackingParticleCollection>(TPCollectionH, tpindex),quality));

       LogTrace("TrackAssociator") << "Seed number " << tindex << " with #hits=" << ri

                       << "associated to TP (pdgId, nb segments, p) = "

                       << (*t).pdgId() << " " << (*t).g4Tracks().size()

                       << " " << (*t).momentum() <<" number " << tpindex << " with quality =" << quality;

     } else {

       LogTrace("TrackAssociator") <<"Seed number " << tindex << " with #hits=" << ri << " NOT associated with quality =" << quality;

     }

       }//TP loop

     }

   }

   LogTrace("TrackAssociator") << "% of Assoc Seeds=" << ((double)outputCollection.size())/((double)seedCollectionH->size());

   delete associate;

   outputCollection.post_insert();

   return outputCollection;

 }


 SimToRecoCollectionSeed

 TrackAssociatorByHits::associateSimToReco(edm::Handle<edm::View<TrajectorySeed> >& seedCollectionH,

                       edm::Handle<TrackingParticleCollection>& TPCollectionH,

                       const edm::Event * e,

                                           const edm::EventSetup *setup ) const{


   edm::LogVerbatim("TrackAssociator") << "Starting TrackAssociatorByHits::associateSimToReco - #seeds="

                       <<seedCollectionH->size()<<" #TPs="<<TPCollectionH->size();

   float quality=0;//fraction or absolute number of shared hits

   int nshared = 0;

   std::vector< SimHitIdpr> SimTrackIds;

   std::vector< SimHitIdpr> matchedIds;

   SimToRecoCollectionSeed  outputCollection;


   TrackerHitAssociator * associate = new TrackerHitAssociator(*e, conf_);


   TrackingParticleCollection tPC =*const_cast<TrackingParticleCollection*>(TPCollectionH.product());


   const edm::View<TrajectorySeed> sC = *(seedCollectionH.product());


   //get the ID of the recotrack  by hits

   int tindex=0;

   for (edm::View<TrajectorySeed>::const_iterator seed=sC.begin(); seed!=sC.end(); seed++, tindex++) {

     int ri=0;//valid rechits

     LogTrace("TrackAssociator") << "\nNEW SEED - seed number " << tindex << " # valid=" << seed->recHits().second-seed->recHits().first;

     getMatchedIds<edm::OwnVector<TrackingRecHit>::const_iterator>(matchedIds, SimTrackIds, ri, seed->recHits().first, seed->recHits().second, associate );


     //save id for the track

     std::vector<SimHitIdpr> idcachev;

     if(!matchedIds.empty()){

       int tpindex =0;

       for (TrackingParticleCollection::iterator t = tPC.begin(); t != tPC.end(); ++t, ++tpindex) {

     idcachev.clear();

         int nsimhit = t->trackPSimHit(DetId::Tracker).size();

     LogTrace("TrackAssociator") << "TP number " << tpindex << " pdgId=" << t->pdgId() << " with number of PSimHits: "  << nsimhit;

     nshared = getShared(matchedIds, idcachev, t);


     if (AbsoluteNumberOfHits) quality = static_cast<double>(nshared);

     else if(ri!=0) quality = ((double) nshared)/((double)ri);

     else quality = 0;

     //LogTrace("TrackAssociator") << "Final count: nhit(TP) = " << nsimhit

     //<< " nshared = " << nshared

     //<< " nrechit = " << ri;

     if(quality > quality_SimToReco && !(ThreeHitTracksAreSpecial && ri==3 && nshared<3) ){

       outputCollection.insert(edm::Ref<TrackingParticleCollection>(TPCollectionH, tpindex),

                   std::make_pair(edm::RefToBase<TrajectorySeed>(seedCollectionH,tindex), quality));

       LogTrace("TrackAssociator") << "TrackingParticle number " << tpindex << " with #hits=" << nsimhit

                       << " associated to seed number " << tindex << " with #hits=" << ri

                       << " with hit quality =" << quality ;

     }

     else {

       LogTrace("TrackAssociator") << "TrackingParticle number " << tpindex << " with #hits=" << nsimhit << " NOT associated with quality =" << quality;

     }

       }

     }

   }

   LogTrace("TrackAssociator") << "% of Assoc TPs=" << ((double)outputCollection.size())/((double)TPCollectionH->size());

   delete associate;

   outputCollection.post_insert();

   return outputCollection;

 }


 template<typename iter>

 void TrackAssociatorByHits::getMatchedIds(std::vector<SimHitIdpr>& matchedIds,

                       std::vector<SimHitIdpr>& SimTrackIds,

                       int& ri,

                       iter begin,

                       iter end,

                       TrackerHitAssociator* associate ) const {

     matchedIds.clear();

     ri=0;//valid rechits

     for (iter it = begin;  it != end; it++){

       const TrackingRecHit *hit=getHitPtr(it);

       if (hit->isValid()){

     ri++;

     uint32_t t_detID=  hit->geographicalId().rawId();

     SimTrackIds.clear();

     associate->associateHitId(*hit, SimTrackIds);

     //save all the id of matched simtracks

     if(!SimTrackIds.empty()){

      for(size_t j=0; j<SimTrackIds.size(); j++){

        LogTrace("TrackAssociator") << " hit # " << ri << " valid=" << hit->isValid()

                        << " det id = " << t_detID << " SimId " << SimTrackIds[j].first

                        << " evt=" << SimTrackIds[j].second.event()

                        << " bc=" << SimTrackIds[j].second.bunchCrossing();

        matchedIds.push_back(SimTrackIds[j]);

      }

     }

     //****to be used when the crossing frame is in the event and with flag TrackAssociatorByHitsESProducer.associateRecoTracks = false

     //std::vector<PSimHit> tmpSimHits = associate->associateHit(*getHitPtr(it));

     //for(size_t j=0; j<tmpSimHits.size(); j++) {

     //  LogTrace("TrackAssociator") << " hit # " << ri << " valid=" << getHitPtr(it)->isValid()

     //                              << " det id = " << t_detID << " SimId " << SimTrackIds[j].first

     //                              << " evt=" << SimTrackIds[j].second.event()

     //                              << " bc=" << SimTrackIds[j].second.bunchCrossing()

     //                              << " process=" << tmpSimHits[j].processType()

     //                              << " eloss=" << tmpSimHits[j].energyLoss()

     //                              << " part type=" << tmpSimHits[j].particleType()

     //                              << " pabs=" << tmpSimHits[j].pabs()

     //                              << " trId=" << tmpSimHits[j].trackId();

     //}

       }else{

     LogTrace("TrackAssociator") <<"\t\t Invalid Hit On "<<hit->geographicalId().rawId();

       }

     }//trackingRecHit loop

 }


 int TrackAssociatorByHits::getShared(std::vector<SimHitIdpr>& matchedIds,

                      std::vector<SimHitIdpr>& idcachev,

                      TrackingParticleCollection::const_iterator t) const {

   int nshared = 0;

   if (t->trackPSimHit().size()==0) return nshared;//should use trackerPSimHit but is not const


   for(size_t j=0; j<matchedIds.size(); j++){

     //LogTrace("TrackAssociator") << "now matchedId=" << matchedIds[j].first;

     if(find(idcachev.begin(), idcachev.end(),matchedIds[j]) == idcachev.end() ){

       //only the first time we see this ID

       idcachev.push_back(matchedIds[j]);


       for (TrackingParticle::g4t_iterator g4T = t -> g4Track_begin(); g4T !=  t -> g4Track_end(); ++g4T) {

 //  LogTrace("TrackAssociator") << " TP   (ID, Ev, BC) = " << (*g4T).trackId()

 //                  << ", " << t->eventId().event() << ", "<< t->eventId().bunchCrossing()

 //                  << " Match(ID, Ev, BC) = " <<  matchedIds[j].first

 //                  << ", " << matchedIds[j].second.event() << ", "

 //                  << matchedIds[j].second.bunchCrossing() ;

                                 //<< "\t G4  Track Momentum " << (*g4T).momentum()

                                 //<< " \t reco Track Momentum " << track->momentum();

     if((*g4T).trackId() == matchedIds[j].first && t->eventId() == matchedIds[j].second){

         int countedhits = std::count(matchedIds.begin(), matchedIds.end(), matchedIds[j]);

         nshared += countedhits;


 //      LogTrace("TrackAssociator") << "hits shared by this segment : " << countedhits;

 //      LogTrace("TrackAssociator") << "hits shared so far : " << nshared;

     }

       }//g4Tracks loop

     }

   }

   return nshared;

 }


 template<typename iter>

 int TrackAssociatorByHits::getDoubleCount(iter begin,

                       iter end,

                       TrackerHitAssociator* associate,

                       TrackingParticleCollection::const_iterator t) const {

   int doublecount = 0 ;

   std::vector<SimHitIdpr> SimTrackIdsDC;

   //  cout<<begin-end<<endl;

   for (iter it = begin;  it != end; it++){

     int idcount = 0;

     SimTrackIdsDC.clear();

     associate->associateHitId(*getHitPtr(it), SimTrackIdsDC);

     //    cout<<SimTrackIdsDC.size()<<endl;

     if(SimTrackIdsDC.size()>1){

       //     cout<<(t->g4Track_end()-t->g4Track_begin())<<endl;

       for (TrackingParticle::g4t_iterator g4T = t -> g4Track_begin(); g4T !=  t -> g4Track_end(); ++g4T) {

     if(find(SimTrackIdsDC.begin(), SimTrackIdsDC.end(),SimHitIdpr((*g4T).trackId(), SimTrackIdsDC.begin()->second)) != SimTrackIdsDC.end() ){

       idcount++;

     }

       }

     }

     if (idcount>1) doublecount+=(idcount-1);

   }

   return doublecount;

 }

ExpressReco_HICollisions_FallBack.e
tuple e
Definition: ExpressReco_HICollisions_FallBack.py:1068

edm::ParameterSet::getParameter
T getParameter(std::string const &) const

TrackAssociatorByHits::cut_RecoToSim
const double cut_RecoToSim
Definition: TrackAssociatorByHits.h:92

TrackAssociatorByHits::TrackAssociatorByHits
TrackAssociatorByHits(const edm::ParameterSet &)
Definition: TrackAssociatorByHits.cc:39

TrackAssociatorByHits::getMatchedIds
void getMatchedIds(std::vector< SimHitIdpr > &, std::vector< SimHitIdpr > &, int &, iter, iter, TrackerHitAssociator *) const
Definition: TrackAssociatorByHits.cc:464

edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86

prof2calltree.count
list count
Definition: prof2calltree.py:146

ExpressReco_HICollisions_FallBack.track
tuple track
Definition: ExpressReco_HICollisions_FallBack.py:4641

MessageLogger.h

StripSubdetector::TIB
Definition: StripSubdetector.h:14

TOBDetId::layer
unsigned int layer() const
layer id
Definition: TOBDetId.h:39

TrackAssociatorByHits::UseGrouped
const bool UseGrouped
Definition: TrackAssociatorByHits.h:94

TrackAssociatorByHits::purity_SimToReco
const double purity_SimToReco
Definition: TrackAssociatorByHits.h:91

TrackAssociatorByHits::~TrackAssociatorByHits
~TrackAssociatorByHits()
Definition: TrackAssociatorByHits.cc:66

edm::RefVector::product
C const * product() const
Accessor for product collection.
Definition: RefVector.h:268

TrackAssociatorByHits::getShared
int getShared(std::vector< SimHitIdpr > &, std::vector< SimHitIdpr > &, TrackingParticleCollection::const_iterator) const
Definition: TrackAssociatorByHits.cc:512

Event.h

align::tib::layerNumber
unsigned int layerNumber(align::ID)
Layer number increases with rho from 1 to 8.
Definition: TIBNameSpace.h:85

EventSetup.h

edm::View
Definition: AssociativeIterator.h:47

edm::RefToBaseVector::end
const_iterator end() const
Definition: RefToBaseVector.h:226

TIDDetId
Definition: TIDDetId.h:16

edm::reftobase::BaseVectorHolder::const_iterator
Definition: BaseVectorHolder.h:51

abs
#define abs(x)
Definition: mlp_lapack.h:159

TrackAssociatorByHits::denomsim
Definition: TrackAssociatorByHits.h:26

TrackingRecHit
Definition: TrackingRecHit.h:10

TrackFwd.h

edm::RefToBase< TrajectorySeed >

TrackAssociatorByHits::LayerFromDetid
int LayerFromDetid(const DetId &) const
Definition: TrackAssociatorByHits.cc:292

TrackingParticle.h

edm::Handle
Definition: AssociativeIterator.h:48

SiStripDetId::TOB
Definition: SiStripDetId.h:36

spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:7

EDProduct.h

TrackerHitAssociator::associateHitId
std::vector< SimHitIdpr > associateHitId(const TrackingRecHit &thit)
Definition: TrackerHitAssociator.cc:280

Frameworkfwd.h

StripSubdetector::TEC
Definition: StripSubdetector.h:14

PXBDetId::layer
unsigned int layer() const
layer id
Definition: PXBDetId.h:35

TrackAssociatorByHits::UsePixels
const bool UsePixels
Definition: TrackAssociatorByHits.h:93

PXBDetId
Definition: PXBDetId.h:16

TrackerHitAssociator.h

ParameterSet.h

DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45

TrackAssociatorByHits.h

TrackAssociatorByHits::getHitPtr
const TrackingRecHit * getHitPtr(edm::OwnVector< TrackingRecHit >::const_iterator iter) const
Definition: TrackAssociatorByHits.h:99

TrackerHitAssociator
Definition: TrackerHitAssociator.h:55

DetId::Tracker
Definition: DetId.h:26

TrackingRecHit.h

dt_offlineAnalysis_common_cff.reco
tuple reco
Definition: dt_offlineAnalysis_common_cff.py:54

TrackAssociatorByHits::quality_SimToReco
const double quality_SimToReco
Definition: TrackAssociatorByHits.h:90

edm::AssociationMap::post_insert
void post_insert()
post insert action
Definition: AssociationMap.h:135

TrackAssociatorByHits::denomreco
Definition: TrackAssociatorByHits.h:26

matplotRender.t
tuple t
Definition: matplotRender.py:569

TrackAssociatorByHits::UseSplitting
const bool UseSplitting
Definition: TrackAssociatorByHits.h:95

TrackAssociatorByHits::denomnone
Definition: TrackAssociatorByHits.h:26

SiStripDetId::partnerDetId
virtual uint32_t partnerDetId() const
Definition: SiStripDetId.h:156

StripSubdetector.h

ESHandle.h

j
int j
Definition: DBlmapReader.cc:9

TIBDetId
Definition: TIBDetId.h:16

edm::AssociationMap< edm::OneToManyWithQualityGeneric< edm::View< reco::Track >, TrackingParticleCollection, double > >

edm::RefToBaseVector
Definition: EDProductfwd.h:26

SiStripDetId::TEC
Definition: SiStripDetId.h:36

edm::EventSetup
Definition: EventSetup.h:44

PXBDetId.h

PXFDetId.h

end
#define end
Definition: vmac.h:38

edm::LogVerbatim
Definition: MessageLogger.h:232

DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:39

PixelSubdetector::PixelBarrel
Definition: PixelSubdetector.h:11

LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:511

PXFDetId::disk
unsigned int disk() const
disk id
Definition: PXFDetId.h:43

PixelSubdetector.h

dbtoconf.conf
tuple conf
Definition: dbtoconf.py:185

GeomDetUnit.h

TrackingParticle::g4t_iterator
std::vector< SimTrack >::const_iterator g4t_iterator
Definition: TrackingParticle.h:36

SiStripDetId
Detector identifier class for the strip tracker.
Definition: SiStripDetId.h:17

DetId
Definition: DetId.h:20

Exception.h

TrackAssociatorByHits::associateSimToReco
reco::SimToRecoCollection associateSimToReco(const edm::RefToBaseVector< reco::Track > &, const edm::RefVector< TrackingParticleCollection > &, const edm::Event *event=0, const edm::EventSetup *setup=0) const
Association Sim To Reco with Collections.
Definition: TrackAssociatorByHits.cc:154

edm::hlt::Exception
error
Definition: HLTenums.h:24

SimHitIdpr
std::pair< uint32_t, EncodedEventId > SimHitIdpr
Definition: TrackerHitAssociator.h:53

edm::AssociationMap::size
size_type size() const
map size
Definition: AssociationMap.h:79

SiStripDetId::TIB
Definition: SiStripDetId.h:36

edm::AssociationMap::insert
void insert(const key_type &k, const data_type &v)
insert an association
Definition: AssociationMap.h:83

Ref.h

StripSubdetector::TOB
Definition: StripSubdetector.h:14

TrackAssociatorByHits::AbsoluteNumberOfHits
const bool AbsoluteNumberOfHits
Definition: TrackAssociatorByHits.h:88

edm::RefVector< TrackingParticleCollection >

TrackingRecHit::isValid
bool isValid() const
Definition: TrackingRecHit.h:63

TrackAssociatorByHits::conf_
const edm::ParameterSet & conf_
Definition: TrackAssociatorByHits.h:87

TrackAssociatorByHits::getDoubleCount
int getDoubleCount(iter, iter, TrackerHitAssociator *, TrackingParticleCollection::const_iterator) const
Definition: TrackAssociatorByHits.cc:547

edm::Handle::product
T const * product() const
Definition: Handle.h:74

TECDetId.h

TECDetId::wheel
unsigned int wheel() const
wheel id
Definition: TECDetId.h:52

edm::RefToBaseVector::begin
const_iterator begin() const
Definition: RefToBaseVector.h:218

hit
Definition: SiStripHitEffFromCalibTree.cc:87

TIBDetId::layer
unsigned int layer() const
layer id
Definition: TIBDetId.h:41

StripSubdetector::TID
Definition: StripSubdetector.h:14

tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100

begin
#define begin
Definition: vmac.h:31

TrackerGeometry.h

TrackAssociatorByHits::ThreeHitTracksAreSpecial
const bool ThreeHitTracksAreSpecial
Definition: TrackAssociatorByHits.h:96

TECDetId
Definition: TECDetId.h:16

edm::RefVector::size
size_type size() const
Size of the RefVector.
Definition: RefVector.h:85

TrackAssociatorByHits::associateRecoToSim
reco::RecoToSimCollection associateRecoToSim(const edm::RefToBaseVector< reco::Track > &, const edm::RefVector< TrackingParticleCollection > &, const edm::Event *event=0, const edm::EventSetup *setup=0) const
Association Reco To Sim with Collections.
Definition: TrackAssociatorByHits.cc:76

TIBDetId.h

edm::View::begin
const_iterator begin() const

TIDDetId.h

edm::ParameterSet
Definition: ParameterSet.h:31

edm::View::end
const_iterator end() const

EncodedEventId.h

TrackingParticleCollection
std::vector< TrackingParticle > TrackingParticleCollection
Definition: TrackingParticleFwd.h:8

TrackingRecHit::geographicalId
DetId geographicalId() const
Definition: TrackingRecHit.h:53

TrackingParticleFwd.h

TOBDetId.h

edm::Event
Definition: Event.h:49

Track.h

TrackAssociatorByHits::SimToRecoDenominator
SimToRecoDenomType SimToRecoDenominator
Definition: TrackAssociatorByHits.h:89

PXFDetId
Definition: PXFDetId.h:15

DetId.h

edm::Ref< TrackingParticleCollection >

PixelSubdetector::PixelEndcap
Definition: PixelSubdetector.h:11

TIDDetId::wheel
unsigned int wheel() const
wheel id
Definition: TIDDetId.h:50

SiStripDetId::TID
Definition: SiStripDetId.h:36

TOBDetId
Definition: TOBDetId.h:16