Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-06-13 03:24:05 

0001 // Author: Felice Pantaleo,Marco Rovere - felice.pantaleo@cern.ch,marco.rovere@cern.ch
0002 // Date: 09/2018
0003 
0004 // user include files
0005 #include <vector>
0006 
0007 #include "FWCore/Framework/interface/ESHandle.h"
0008 #include "FWCore/Framework/interface/Event.h"
0009 #include "FWCore/Framework/interface/Frameworkfwd.h"
0010 #include "FWCore/Framework/interface/MakerMacros.h"
0011 #include "FWCore/Framework/interface/stream/EDProducer.h"
0012 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0013 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0014 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0015 #include "FWCore/ParameterSet/interface/PluginDescription.h"
0016 
0017 #include "DataFormats/CaloRecHit/interface/CaloCluster.h"
0018 #include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
0019 
0020 #include "DataFormats/HGCalReco/interface/Trackster.h"
0021 #include "DataFormats/HGCalReco/interface/TICLLayerTile.h"
0022 #include "DataFormats/HGCalReco/interface/TICLSeedingRegion.h"
0023 
0024 #include "RecoHGCal/TICL/plugins/PatternRecognitionPluginFactory.h"
0025 
0026 #include "PhysicsTools/TensorFlow/interface/TfGraphRecord.h"
0027 #include "PhysicsTools/TensorFlow/interface/TensorFlow.h"
0028 #include "PhysicsTools/TensorFlow/interface/TfGraphDefWrapper.h"
0029 
0030 using namespace ticl;
0031 
0032 class TrackstersProducer : public edm::stream::EDProducer<> {
0033 public:
0034   explicit TrackstersProducer(const edm::ParameterSet&);
0035   ~TrackstersProducer() override {}
0036   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0037 
0038   void produce(edm::Event&, const edm::EventSetup&) override;
0039 
0040   // static methods for handling the global cache
0041   static std::unique_ptr<TrackstersCache> initializeGlobalCache(const edm::ParameterSet&);
0042   static void globalEndJob(TrackstersCache*);
0043 
0044 private:
0045   std::string detector_;
0046   bool doNose_;
0047   const std::string tfDnnLabel_;
0048   const edm::ESGetToken<TfGraphDefWrapper, TfGraphRecord> tfDnnToken_;
0049   const tensorflow::Session* tfSession_;
0050   std::unique_ptr<PatternRecognitionAlgoBaseT<TICLLayerTiles>> myAlgo_;
0051   std::unique_ptr<PatternRecognitionAlgoBaseT<TICLLayerTilesHFNose>> myAlgoHFNose_;
0052 
0053   const edm::EDGetTokenT<std::vector<reco::CaloCluster>> clusters_token_;
0054   const edm::EDGetTokenT<std::vector<float>> filtered_layerclusters_mask_token_;
0055   const edm::EDGetTokenT<std::vector<float>> original_layerclusters_mask_token_;
0056   const edm::EDGetTokenT<edm::ValueMap<std::pair<float, float>>> clustersTime_token_;
0057   edm::EDGetTokenT<TICLLayerTiles> layer_clusters_tiles_token_;
0058   edm::EDGetTokenT<TICLLayerTilesHFNose> layer_clusters_tiles_hfnose_token_;
0059   const edm::EDGetTokenT<std::vector<TICLSeedingRegion>> seeding_regions_token_;
0060   const std::string itername_;
0061   ticl::Trackster::IterationIndex iterIndex_ = ticl::Trackster::IterationIndex(0);
0062 };
0063 DEFINE_FWK_MODULE(TrackstersProducer);
0064 
0065 TrackstersProducer::TrackstersProducer(const edm::ParameterSet& ps)
0066     : detector_(ps.getParameter<std::string>("detector")),
0067       doNose_(detector_ == "HFNose"),
0068       tfDnnLabel_(ps.getParameter<std::string>("tfDnnLabel")),
0069       tfDnnToken_(esConsumes(edm::ESInputTag("", tfDnnLabel_))),
0070       tfSession_(nullptr),
0071       clusters_token_(consumes<std::vector<reco::CaloCluster>>(ps.getParameter<edm::InputTag>("layer_clusters"))),
0072       filtered_layerclusters_mask_token_(consumes<std::vector<float>>(ps.getParameter<edm::InputTag>("filtered_mask"))),
0073       original_layerclusters_mask_token_(consumes<std::vector<float>>(ps.getParameter<edm::InputTag>("original_mask"))),
0074       clustersTime_token_(
0075           consumes<edm::ValueMap<std::pair<float, float>>>(ps.getParameter<edm::InputTag>("time_layerclusters"))),
0076       seeding_regions_token_(
0077           consumes<std::vector<TICLSeedingRegion>>(ps.getParameter<edm::InputTag>("seeding_regions"))),
0078       itername_(ps.getParameter<std::string>("itername")) {
0079   auto plugin = ps.getParameter<std::string>("patternRecognitionBy");
0080   auto pluginPSet = ps.getParameter<edm::ParameterSet>("pluginPatternRecognitionBy" + plugin);
0081   if (doNose_) {
0082     myAlgoHFNose_ = PatternRecognitionHFNoseFactory::get()->create(
0083         ps.getParameter<std::string>("patternRecognitionBy"), pluginPSet, consumesCollector());
0084     layer_clusters_tiles_hfnose_token_ =
0085         consumes<TICLLayerTilesHFNose>(ps.getParameter<edm::InputTag>("layer_clusters_hfnose_tiles"));
0086   } else {
0087     myAlgo_ = PatternRecognitionFactory::get()->create(
0088         ps.getParameter<std::string>("patternRecognitionBy"), pluginPSet, consumesCollector());
0089     layer_clusters_tiles_token_ = consumes<TICLLayerTiles>(ps.getParameter<edm::InputTag>("layer_clusters_tiles"));
0090   }
0091 
0092   if (itername_ == "TrkEM")
0093     iterIndex_ = ticl::Trackster::TRKEM;
0094   else if (itername_ == "EM")
0095     iterIndex_ = ticl::Trackster::EM;
0096   else if (itername_ == "Trk")
0097     iterIndex_ = ticl::Trackster::TRKHAD;
0098   else if (itername_ == "HAD")
0099     iterIndex_ = ticl::Trackster::HAD;
0100   else if (itername_ == "MIP")
0101     iterIndex_ = ticl::Trackster::MIP;
0102 
0103   produces<std::vector<Trackster>>();
0104   produces<std::vector<float>>();  // Mask to be applied at the next iteration
0105 }
0106 
0107 void TrackstersProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0108   // hgcalMultiClusters
0109   edm::ParameterSetDescription desc;
0110   desc.add<std::string>("detector", "HGCAL");
0111   desc.add<edm::InputTag>("layer_clusters", edm::InputTag("hgcalMergeLayerClusters"));
0112   desc.add<edm::InputTag>("filtered_mask", edm::InputTag("filteredLayerClusters", "iterationLabelGoesHere"));
0113   desc.add<edm::InputTag>("original_mask", edm::InputTag("hgcalMergeLayerClusters", "InitialLayerClustersMask"));
0114   desc.add<edm::InputTag>("time_layerclusters", edm::InputTag("hgcalMergeLayerClusters", "timeLayerCluster"));
0115   desc.add<edm::InputTag>("layer_clusters_tiles", edm::InputTag("ticlLayerTileProducer"));
0116   desc.add<edm::InputTag>("layer_clusters_hfnose_tiles", edm::InputTag("ticlLayerTileHFNose"));
0117   desc.add<edm::InputTag>("seeding_regions", edm::InputTag("ticlSeedingRegionProducer"));
0118   desc.add<std::string>("patternRecognitionBy", "CA");
0119   desc.add<std::string>("itername", "unknown");
0120   desc.add<std::string>("tfDnnLabel", "tracksterSelectionTf");
0121 
0122   // CA Plugin
0123   edm::ParameterSetDescription pluginDesc;
0124   pluginDesc.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "CA", true));
0125   desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByCA", pluginDesc);
0126   //
0127   // CLUE3D Plugin
0128   edm::ParameterSetDescription pluginDescClue3D;
0129   pluginDescClue3D.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "CLUE3D", true));
0130   desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByCLUE3D", pluginDescClue3D);
0131 
0132   // FastJet Plugin
0133   edm::ParameterSetDescription pluginDescFastJet;
0134   pluginDescFastJet.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "FastJet", true));
0135   desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByFastJet", pluginDescFastJet);
0136 
0137   // PassThrough Plugin
0138   edm::ParameterSetDescription pluginDescPassThrough;
0139   pluginDescPassThrough.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "Passthrough", true));
0140   desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByPassthrough", pluginDescPassThrough);
0141 
0142   descriptions.add("trackstersProducer", desc);
0143 }
0144 
0145 void TrackstersProducer::produce(edm::Event& evt, const edm::EventSetup& es) {
0146   auto result = std::make_unique<std::vector<Trackster>>();
0147   auto output_mask = std::make_unique<std::vector<float>>();
0148 
0149   const std::vector<float>& original_layerclusters_mask = evt.get(original_layerclusters_mask_token_);
0150   const auto& layerClusters = evt.get(clusters_token_);
0151   const auto& inputClusterMask = evt.get(filtered_layerclusters_mask_token_);
0152   const auto& layerClustersTimes = evt.get(clustersTime_token_);
0153   const auto& seeding_regions = evt.get(seeding_regions_token_);
0154 
0155   tfSession_ = es.getData(tfDnnToken_).getSession();
0156 
0157   std::unordered_map<int, std::vector<int>> seedToTrackstersAssociation;
0158   // if it's regional iteration and there are seeding regions
0159   if (!seeding_regions.empty() and seeding_regions[0].index != -1) {
0160     auto numberOfSeedingRegions = seeding_regions.size();
0161     for (unsigned int i = 0; i < numberOfSeedingRegions; ++i) {
0162       seedToTrackstersAssociation.emplace(seeding_regions[i].index, 0);
0163     }
0164   }
0165 
0166   if (doNose_) {
0167     const auto& layer_clusters_hfnose_tiles = evt.get(layer_clusters_tiles_hfnose_token_);
0168     const typename PatternRecognitionAlgoBaseT<TICLLayerTilesHFNose>::Inputs inputHFNose(evt,
0169                                                                                          es,
0170                                                                                          layerClusters,
0171                                                                                          inputClusterMask,
0172                                                                                          layerClustersTimes,
0173                                                                                          layer_clusters_hfnose_tiles,
0174                                                                                          seeding_regions,
0175                                                                                          tfSession_);
0176 
0177     myAlgoHFNose_->makeTracksters(inputHFNose, *result, seedToTrackstersAssociation);
0178 
0179   } else {
0180     const auto& layer_clusters_tiles = evt.get(layer_clusters_tiles_token_);
0181     const typename PatternRecognitionAlgoBaseT<TICLLayerTiles>::Inputs input(
0182         evt, es, layerClusters, inputClusterMask, layerClustersTimes, layer_clusters_tiles, seeding_regions, tfSession_);
0183 
0184     myAlgo_->makeTracksters(input, *result, seedToTrackstersAssociation);
0185   }
0186   // Now update the global mask and put it into the event
0187   output_mask->reserve(original_layerclusters_mask.size());
0188   // Copy over the previous state
0189   std::copy(
0190       std::begin(original_layerclusters_mask), std::end(original_layerclusters_mask), std::back_inserter(*output_mask));
0191 
0192   for (auto& trackster : *result) {
0193     trackster.setIteration(iterIndex_);
0194     // Mask the used elements, accordingly
0195     for (auto const v : trackster.vertices()) {
0196       // TODO(rovere): for the moment we mask the layer cluster completely. In
0197       // the future, properly compute the fraction of usage.
0198       (*output_mask)[v] = 0.;
0199     }
0200   }
0201 
0202   evt.put(std::move(result));
0203   evt.put(std::move(output_mask));
0204 }
[ 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!