Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-05-02 05:10:04 

0001 #include "TauAnalysis/MCEmbeddingTools/plugins/CollectionMerger.h"
0002 #include "FWCore/Framework/interface/MakerMacros.h"
0003 
0004 #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
0005 #include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
0006 
0007 #include "DataFormats/Common/interface/SortedCollection.h"
0008 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
0009 
0010 #include "DataFormats/EgammaReco/interface/SuperCluster.h"
0011 #include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
0012 
0013 #include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
0014 #include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
0015 
0016 #include "DataFormats/CaloRecHit/interface/CaloCluster.h"
0017 
0018 #include "DataFormats/DTRecHit/interface/DTRecHit1DPair.h"
0019 #include "DataFormats/DTRecHit/interface/DTSLRecCluster.h"
0020 #include "DataFormats/MuonDetId/interface/DTLayerId.h"
0021 
0022 #include "DataFormats/CSCRecHit/interface/CSCRecHit2D.h"
0023 #include "DataFormats/HcalRecHit/interface/ZDCRecHit.h"
0024 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
0025 #include "DataFormats/MuonDetId/interface/RPCDetId.h"
0026 #include "DataFormats/RPCRecHit/interface/RPCRecHit.h"
0027 
0028 #include "DataFormats/TrackReco/interface/Track.h"
0029 #include "DataFormats/TrackReco/interface/TrackFwd.h"
0030 #include "DataFormats/TrackReco/interface/TrackToTrackMap.h"
0031 
0032 #include "DataFormats/EgammaReco/interface/ElectronSeed.h"
0033 #include "DataFormats/ParticleFlowReco/interface/PreId.h"
0034 
0035 #include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
0036 
0037 #include "DataFormats/EgammaCandidates/interface/Conversion.h"
0038 
0039 #include "DataFormats/Candidate/interface/VertexCompositeCandidate.h"
0040 #include "DataFormats/VertexReco/interface/Vertex.h"
0041 
0042 #include "DataFormats/Common/interface/OwnVector.h"
0043 #include "DataFormats/Common/interface/RangeMap.h"
0044 
0045 typedef CollectionMerger<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> PixelColMerger;
0046 typedef CollectionMerger<edmNew::DetSetVector<SiStripCluster>, SiStripCluster> StripColMerger;
0047 
0048 typedef CollectionMerger<std::vector<reco::ElectronSeed>, reco::ElectronSeed> ElectronSeedColMerger;
0049 typedef CollectionMerger<std::vector<reco::ElectronSeed>, reco::ElectronSeed> EcalDrivenElectronSeedColMerger;
0050 typedef CollectionMerger<edm::SortedCollection<EcalRecHit>, EcalRecHit> EcalRecHitColMerger;
0051 typedef CollectionMerger<edm::SortedCollection<HBHERecHit>, HBHERecHit> HBHERecHitColMerger;
0052 typedef CollectionMerger<edm::SortedCollection<HFRecHit>, HFRecHit> HFRecHitColMerger;
0053 typedef CollectionMerger<edm::SortedCollection<HORecHit>, HORecHit> HORecHitColMerger;
0054 typedef CollectionMerger<edm::SortedCollection<ZDCRecHit>, ZDCRecHit> ZDCRecHitColMerger;
0055 
0056 typedef CollectionMerger<edm::RangeMap<DTLayerId, edm::OwnVector<DTRecHit1DPair>>, DTRecHit1DPair> DTRecHitColMerger;
0057 typedef CollectionMerger<edm::RangeMap<CSCDetId, edm::OwnVector<CSCRecHit2D>>, CSCRecHit2D> CSCRecHitColMerger;
0058 typedef CollectionMerger<edm::RangeMap<RPCDetId, edm::OwnVector<RPCRecHit>>, RPCRecHit> RPCRecHitColMerger;
0059 
0060 template <typename T1, typename T2>
0061 CollectionMerger<T1, T2>::CollectionMerger(const edm::ParameterSet &iConfig) {
0062   std::vector<edm::InputTag> inCollections = iConfig.getParameter<std::vector<edm::InputTag>>("mergCollections");
0063   for (auto const &inCollection : inCollections) {
0064     inputs_[inCollection.instance()].push_back(consumes<MergeCollection>(inCollection));
0065   }
0066   willconsume(iConfig);
0067   for (const auto &toproduce : inputs_) {
0068     std::string alias(iConfig.getParameter<std::string>("@module_label"));
0069     willproduce(toproduce.first, alias);
0070   }
0071 }
0072 
0073 template <typename T1, typename T2>
0074 CollectionMerger<T1, T2>::~CollectionMerger() {
0075   // nothing to be done yet...
0076 }
0077 
0078 template <typename T1, typename T2>
0079 void CollectionMerger<T1, T2>::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) {
0080   for (auto input_ : inputs_) {
0081     std::unique_ptr<MergeCollection> output(new MergeCollection());
0082     std::vector<edm::Handle<MergeCollection>> inputCollections;
0083     inputCollections.resize(input_.second.size());
0084     for (unsigned id = 0; id < input_.second.size(); id++) {
0085       iEvent.getByToken(input_.second[id], inputCollections[id]);
0086     }
0087     fill_output_obj(iEvent, output, inputCollections);
0088     iEvent.put(std::move(output), input_.first);
0089   }
0090 }
0091 
0092 template <typename T1, typename T2>
0093 void CollectionMerger<T1, T2>::willconsume(const edm::ParameterSet &iConfig) {}
0094 
0095 template <typename T1, typename T2>
0096 void CollectionMerger<T1, T2>::willproduce(std::string instance, std::string alias) {
0097   produces<MergeCollection>(instance);
0098 }
0099 
0100 // -------- Here Tracker Merger -----------
0101 template <typename T1, typename T2>
0102 void CollectionMerger<T1, T2>::fill_output_obj_tracker(std::unique_ptr<MergeCollection> &output,
0103                                                        std::vector<edm::Handle<MergeCollection>> &inputCollections,
0104                                                        bool print_pixel) {
0105   std::map<uint32_t, std::vector<BaseHit>> output_map;
0106   // First merge the collections with the help of the output map
0107   for (auto const &inputCollection : inputCollections) {
0108     for (typename MergeCollection::const_iterator clustSet = inputCollection->begin();
0109          clustSet != inputCollection->end();
0110          ++clustSet) {
0111       DetId detIdObject(clustSet->detId());
0112       for (typename edmNew::DetSet<BaseHit>::const_iterator clustIt = clustSet->begin(); clustIt != clustSet->end();
0113            ++clustIt) {
0114         output_map[detIdObject.rawId()].push_back(*clustIt);
0115       }
0116     }
0117   }
0118   // Now save it into the standard CMSSW format, with the standard Filler
0119   for (typename std::map<uint32_t, std::vector<BaseHit>>::const_iterator outHits = output_map.begin();
0120        outHits != output_map.end();
0121        ++outHits) {
0122     DetId detIdObject(outHits->first);
0123     typename MergeCollection::FastFiller spc(*output, detIdObject);
0124     for (const auto &Hit : outHits->second) {
0125       spc.push_back(Hit);
0126     }
0127   }
0128 }
0129 
0130 template <typename T1, typename T2>
0131 void CollectionMerger<T1, T2>::fill_output_obj_calo(std::unique_ptr<MergeCollection> &output,
0132                                                     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0133   std::map<uint32_t, BaseHit> output_map;
0134   // First merge the two collections again
0135   for (auto const &inputCollection : inputCollections) {
0136     for (typename MergeCollection::const_iterator recHit = inputCollection->begin(); recHit != inputCollection->end();
0137          ++recHit) {
0138       DetId detIdObject(recHit->detid().rawId());
0139       T2 *akt_calo_obj = &output_map[detIdObject.rawId()];
0140       float new_energy = akt_calo_obj->energy() + recHit->energy();
0141       T2 newRecHit(*recHit);
0142       newRecHit.setEnergy(new_energy);
0143       *akt_calo_obj = newRecHit;
0144     }
0145   }
0146   // Now save it into the standard CMSSW format
0147   for (typename std::map<uint32_t, BaseHit>::const_iterator outHits = output_map.begin(); outHits != output_map.end();
0148        ++outHits) {
0149     output->push_back(outHits->second);
0150   }
0151   output->sort();  // Do a sort for this collection
0152 }
0153 
0154 // -------- Here Muon Chamber Merger -----------
0155 template <typename T1, typename T2>
0156 void CollectionMerger<T1, T2>::fill_output_obj_muonchamber(
0157     std::unique_ptr<MergeCollection> &output, std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0158   std::map<uint32_t, std::vector<BaseHit>> output_map;
0159   // First merge the collections with the help of the output map
0160   for (auto const &inputCollection : inputCollections) {
0161     for (typename MergeCollection::const_iterator recHit = inputCollection->begin(); recHit != inputCollection->end();
0162          ++recHit) {
0163       DetId detIdObject(recHit->geographicalId());
0164       output_map[detIdObject].push_back(*recHit);
0165     }
0166   }
0167   // Now save it into the standard CMSSW format, with the standard Filler
0168   for (typename std::map<uint32_t, std::vector<BaseHit>>::const_iterator outHits = output_map.begin();
0169        outHits != output_map.end();
0170        ++outHits) {
0171     output->put((typename T1::id_iterator::value_type)outHits->first,
0172                 outHits->second.begin(),
0173                 outHits->second.end());  // The DTLayerId misses the automatic type cast
0174   }
0175 }
0176 
0177 // -------- Here Electron Seed Merger -----------
0178 // TODO: move seed merger to TrackMerger class
0179 template <>
0180 void CollectionMerger<std::vector<reco::ElectronSeed>, reco::ElectronSeed>::willconsume(
0181     const edm::ParameterSet &iConfig) {
0182   // track refs for trackerdriven seeds
0183   inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("generalTracks"));
0184   inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
0185 
0186   // sc refs for ecaldriven seeds
0187   inputs_scEB_ = consumes<reco::SuperClusterCollection>(
0188       edm::InputTag("particleFlowSuperClusterECAL:particleFlowSuperClusterECALBarrel"));
0189   inputs_scEE_ = consumes<reco::SuperClusterCollection>(
0190       edm::InputTag("particleFlowSuperClusterECAL:particleFlowSuperClusterECALEndcapWithPreshower"));
0191 }
0192 
0193 template <>
0194 void CollectionMerger<std::vector<reco::ElectronSeed>, reco::ElectronSeed>::willproduce(std::string instance,
0195                                                                                         std::string alias) {
0196   produces<MergeCollection>(instance);
0197 }
0198 
0199 template <typename T1, typename T2>
0200 void CollectionMerger<T1, T2>::fill_output_obj_seed(edm::Event &iEvent,
0201                                                     std::unique_ptr<MergeCollection> &output,
0202                                                     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0203   // track to track map for trackerdriven seed fix
0204   edm::Handle<TrackToTrackMapnew> track_ref_map;
0205   iEvent.getByToken(inputs_fixtrackrefs_, track_ref_map);
0206 
0207   edm::Handle<reco::TrackCollection> track_new_col;
0208   iEvent.getByToken(inputs_fixtrackcol_, track_new_col);
0209   std::map<reco::TrackRef, reco::TrackRef> simple_track_to_track_map;
0210   for (unsigned abc = 0; abc < track_new_col->size(); ++abc) {
0211     reco::TrackRef trackRef(track_new_col, abc);
0212     simple_track_to_track_map[((*track_ref_map)[trackRef])[0]] = trackRef;
0213   }
0214 
0215   // ECAL barrel supercluster collection
0216   edm::Handle<reco::SuperClusterCollection> scEB;
0217   iEvent.getByToken(inputs_scEB_, scEB);
0218   auto bScEB = scEB->cbegin();
0219   auto eScEB = scEB->cend();
0220 
0221   // ECAL endcap supercluster collection
0222   edm::Handle<reco::SuperClusterCollection> scEE;
0223   iEvent.getByToken(inputs_scEE_, scEE);
0224   auto bScEE = scEE->cbegin();
0225   auto eScEE = scEE->cend();
0226 
0227   // First merge the two collections again
0228   for (auto const &inputCollection : inputCollections) {
0229     for (typename MergeCollection::const_iterator seed = inputCollection->begin(); seed != inputCollection->end();
0230          ++seed) {
0231       T2 newSeed(*seed);
0232 
0233       // fix reference to supercluster if seed is ecal driven
0234       if (seed->isEcalDriven()) {
0235         const reco::ElectronSeed::CaloClusterRef &seedCcRef(seed->caloCluster());
0236         if (seedCcRef.isNonnull()) {
0237           // find corresponding supercluster in ECAL barrel and endcap
0238           float dx, dy, dz, dr;
0239           float drMin = std::numeric_limits<float>::infinity();
0240           reco::ElectronSeed::CaloClusterRef ccRefMin;
0241           for (auto sc = bScEB; sc != eScEB; ++sc) {
0242             const reco::SuperClusterRef &scRef(reco::SuperClusterRef(scEB, std::distance(bScEB, sc)));
0243             dx = fabs(scRef->x() - seedCcRef->x());
0244             dy = fabs(scRef->y() - seedCcRef->y());
0245             dz = fabs(scRef->z() - seedCcRef->z());
0246             dr = sqrt(dx * dx + dy * dy + dz * dz);
0247             if (dr < drMin) {
0248               drMin = dr;
0249               ccRefMin = reco::ElectronSeed::CaloClusterRef(scRef);
0250             }
0251           }
0252           for (auto sc = bScEE; sc != eScEE; ++sc) {
0253             const reco::SuperClusterRef &scRef(reco::SuperClusterRef(scEE, std::distance(bScEE, sc)));
0254             dx = fabs(scRef->x() - seedCcRef->x());
0255             dy = fabs(scRef->y() - seedCcRef->y());
0256             dz = fabs(scRef->z() - seedCcRef->z());
0257             dr = sqrt(dx * dx + dy * dy + dz * dz);
0258             if (dr < drMin) {
0259               drMin = dr;
0260               ccRefMin = reco::ElectronSeed::CaloClusterRef(scRef);
0261             }
0262           }
0263           // set new calocluster if new ref was found
0264           if (drMin < 10.0) {
0265             newSeed.setCaloCluster(ccRefMin);
0266           }
0267         }
0268       }
0269       if (seed->isTrackerDriven()) {
0270         const reco::ElectronSeed::CtfTrackRef &ctfTrackRef(seed->ctfTrack());
0271         if (ctfTrackRef.isNonnull()) {
0272           newSeed.setCtfTrack(simple_track_to_track_map[ctfTrackRef]);
0273         }
0274       }
0275       output->push_back(newSeed);
0276     }
0277   }
0278 }
0279 
0280 // Here some overloaded functions, which are needed such that the right merger function is called for the indivudal Collections
0281 template <typename T1, typename T2>
0282 void CollectionMerger<T1, T2>::fill_output_obj(edm::Event &iEvent,
0283                                                std::unique_ptr<MergeCollection> &output,
0284                                                std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0285   assert(0);
0286 }
0287 
0288 // Start with the Tracker collections
0289 template <>
0290 void CollectionMerger<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster>::fill_output_obj(
0291     edm::Event &iEvent,
0292     std::unique_ptr<MergeCollection> &output,
0293     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0294   fill_output_obj_tracker(output, inputCollections, true);
0295 }
0296 
0297 template <>
0298 void CollectionMerger<edmNew::DetSetVector<SiStripCluster>, SiStripCluster>::fill_output_obj(
0299     edm::Event &iEvent,
0300     std::unique_ptr<MergeCollection> &output,
0301     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0302   fill_output_obj_tracker(output, inputCollections);
0303 }
0304 
0305 template <>
0306 void CollectionMerger<edm::SortedCollection<EcalRecHit>, EcalRecHit>::fill_output_obj(
0307     edm::Event &iEvent,
0308     std::unique_ptr<MergeCollection> &output,
0309     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0310   fill_output_obj_calo(output, inputCollections);
0311 }
0312 
0313 template <>
0314 void CollectionMerger<edm::SortedCollection<HBHERecHit>, HBHERecHit>::fill_output_obj(
0315     edm::Event &iEvent,
0316     std::unique_ptr<MergeCollection> &output,
0317     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0318   fill_output_obj_calo(output, inputCollections);
0319 }
0320 
0321 template <>
0322 void CollectionMerger<edm::SortedCollection<HFRecHit>, HFRecHit>::fill_output_obj(
0323     edm::Event &iEvent,
0324     std::unique_ptr<MergeCollection> &output,
0325     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0326   fill_output_obj_calo(output, inputCollections);
0327 }
0328 
0329 template <>
0330 void CollectionMerger<edm::SortedCollection<HORecHit>, HORecHit>::fill_output_obj(
0331     edm::Event &iEvent,
0332     std::unique_ptr<MergeCollection> &output,
0333     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0334   fill_output_obj_calo(output, inputCollections);
0335 }
0336 
0337 template <>
0338 void CollectionMerger<edm::SortedCollection<ZDCRecHit>, ZDCRecHit>::fill_output_obj(
0339     edm::Event &iEvent,
0340     std::unique_ptr<MergeCollection> &output,
0341     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0342   fill_output_obj_calo(output, inputCollections);
0343 }
0344 
0345 template <>
0346 void CollectionMerger<edm::RangeMap<DTLayerId, edm::OwnVector<DTRecHit1DPair>>, DTRecHit1DPair>::fill_output_obj(
0347     edm::Event &iEvent,
0348     std::unique_ptr<MergeCollection> &output,
0349     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0350   fill_output_obj_muonchamber(output, inputCollections);
0351 }
0352 
0353 template <>
0354 void CollectionMerger<edm::RangeMap<CSCDetId, edm::OwnVector<CSCRecHit2D>>, CSCRecHit2D>::fill_output_obj(
0355     edm::Event &iEvent,
0356     std::unique_ptr<MergeCollection> &output,
0357     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0358   fill_output_obj_muonchamber(output, inputCollections);
0359 }
0360 
0361 template <>
0362 void CollectionMerger<edm::RangeMap<RPCDetId, edm::OwnVector<RPCRecHit>>, RPCRecHit>::fill_output_obj(
0363     edm::Event &iEvent,
0364     std::unique_ptr<MergeCollection> &output,
0365     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0366   fill_output_obj_muonchamber(output, inputCollections);
0367 }
0368 
0369 template <>
0370 void CollectionMerger<std::vector<reco::ElectronSeed>, reco::ElectronSeed>::fill_output_obj(
0371     edm::Event &iEvent,
0372     std::unique_ptr<MergeCollection> &output,
0373     std::vector<edm::Handle<MergeCollection>> &inputCollections) {
0374   fill_output_obj_seed(iEvent, output, inputCollections);
0375 }
0376 
0377 DEFINE_FWK_MODULE(PixelColMerger);
0378 DEFINE_FWK_MODULE(StripColMerger);
0379 
0380 DEFINE_FWK_MODULE(ElectronSeedColMerger);
0381 DEFINE_FWK_MODULE(EcalDrivenElectronSeedColMerger);
0382 
0383 DEFINE_FWK_MODULE(EcalRecHitColMerger);
0384 DEFINE_FWK_MODULE(HBHERecHitColMerger);
0385 DEFINE_FWK_MODULE(HFRecHitColMerger);
0386 DEFINE_FWK_MODULE(HORecHitColMerger);
0387 DEFINE_FWK_MODULE(ZDCRecHitColMerger);
0388 
0389 DEFINE_FWK_MODULE(DTRecHitColMerger);
0390 DEFINE_FWK_MODULE(CSCRecHitColMerger);
0391 DEFINE_FWK_MODULE(RPCRecHitColMerger);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!