Inheritance diagram for CleanAndMergeProducer:

Public Member Functions
	CleanAndMergeProducer (const edm::ParameterSet &ps)

void	produce (edm::Event &, const edm::EventSetup &) override

	~CleanAndMergeProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
std::string	bcCollection_

edm::EDGetTokenT< reco::SuperClusterCollection >	cleanScToken_

std::string	refScCollection_

std::string	scCollection_

edm::EDGetTokenT< reco::SuperClusterCollection >	uncleanScToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 32 of file CleanAndMergeProducer.cc.

Constructor & Destructor Documentation

◆ CleanAndMergeProducer()

CleanAndMergeProducer::CleanAndMergeProducer ( const edm::ParameterSet & ps )

Definition at line 68 of file CleanAndMergeProducer.cc.

References bcCollection_, cleanScToken_, edm::ParameterSet::getParameter(), refScCollection_, scCollection_, AlCaHLTBitMon_QueryRunRegistry::string, and uncleanScToken_.

                                                                       {
   // get the parameters
   // the cleaned collection:
   cleanScToken_ = consumes<reco::SuperClusterCollection>(ps.getParameter<edm::InputTag>("cleanScInputTag"));
   uncleanScToken_ = consumes<reco::SuperClusterCollection>(ps.getParameter<edm::InputTag>("uncleanScInputTag"));
 
   // the names of the products to be produced:
   bcCollection_ = ps.getParameter<std::string>("bcCollection");
   scCollection_ = ps.getParameter<std::string>("scCollection");
   refScCollection_ = ps.getParameter<std::string>("refScCollection");
 
   std::map<std::string, double> providedParameters;
   providedParameters.insert(std::make_pair("LogWeighted", ps.getParameter<bool>("posCalc_logweight")));
   providedParameters.insert(std::make_pair("T0_barl", ps.getParameter<double>("posCalc_t0")));
   providedParameters.insert(std::make_pair("W0", ps.getParameter<double>("posCalc_w0")));
   providedParameters.insert(std::make_pair("X0", ps.getParameter<double>("posCalc_x0")));
 
   // the products:
   produces<reco::BasicClusterCollection>(bcCollection_);
   produces<reco::SuperClusterCollection>(scCollection_);
   produces<reco::SuperClusterRefVector>(refScCollection_);
 }

◆ ~CleanAndMergeProducer()

CleanAndMergeProducer::~CleanAndMergeProducer ( )

override

Definition at line 91 of file CleanAndMergeProducer.cc.

91 { ; }

Member Function Documentation

◆ produce()

void CleanAndMergeProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 93 of file CleanAndMergeProducer.cc.

References bcCollection_, cleanScToken_, HCALHighEnergyHPDFilter_cfi::energy, dqmdumpme::first, edm::Event::getByToken(), mps_fire::i, edm::OrphanHandleBase::isValid(), LogDebug, LogTrace, eostools::move(), edm::RefVector< C, T, F >::push_back(), edm::PtrVector< T >::push_back(), edm::Event::put(), refScCollection_, scCollection_, fileCollector::seed, edm::RefVector< C, T, F >::size(), HLT_2023v12_cff::superClusters, and uncleanScToken_.

                                                                           {
   // get the input collections
   // ______________________________________________________________________________________
   //
   // cluster collections:
 
   edm::Handle<reco::SuperClusterCollection> pCleanSC;
   edm::Handle<reco::SuperClusterCollection> pUncleanSC;
 
   evt.getByToken(cleanScToken_, pCleanSC);
   evt.getByToken(uncleanScToken_, pUncleanSC);
 
   //
   // collections are all taken now _____________________________________________________
   //
   //
   // the collections to be produced:
   reco::BasicClusterCollection basicClusters;
   reco::SuperClusterCollection superClusters;
   reco::SuperClusterRefVector* scRefs = new reco::SuperClusterRefVector;
 
   //
   // run over the uncleaned SC and check how many of them are matched to the cleaned ones
   // if you find a matched one, create a reference to the cleaned collection and store it
   // if you find an unmatched one, then keep all its basic clusters in the basic Clusters
   // vector
   int uncleanSize = pUncleanSC->size();
   int cleanSize = pCleanSC->size();
 
   LogTrace("EcalCleaning") << "Size of Clean Collection: " << cleanSize << ", uncleanSize: " << uncleanSize
                            << std::endl;
   //
   // keep whether the SC in unique in the uncleaned collection
   std::vector<int> isUncleanOnly;      // 1 if unique in the uncleaned
   std::vector<int> basicClusterOwner;  // contains the index of the SC that owns that BS
   std::vector<int> isSeed;             // if this basic cluster is a seed it is 1
   for (int isc = 0; isc < uncleanSize; ++isc) {
     reco::SuperClusterRef unscRef(pUncleanSC, isc);
     const std::vector<std::pair<DetId, float> >& uhits = unscRef->hitsAndFractions();
     int uhitsSize = uhits.size();
     bool foundTheSame = false;
     for (int jsc = 0; jsc < cleanSize; ++jsc) {  // loop over the cleaned SC
       reco::SuperClusterRef cscRef(pCleanSC, jsc);
       const std::vector<std::pair<DetId, float> >& chits = cscRef->hitsAndFractions();
       int chitsSize = chits.size();
       foundTheSame = true;
       if (unscRef->seed()->seed() == cscRef->seed()->seed() && chitsSize == uhitsSize) {
         // if the clusters are exactly the same then because the clustering
         // algorithm works in a deterministic way, the order of the rechits
         // will be the same
         for (int i = 0; i < chitsSize; ++i) {
           if (uhits[i].first != chits[i].first) {
             foundTheSame = false;
             break;
           }
         }
         if (foundTheSame) {  // ok you have found it!
           // make the reference
           //scRefs->push_back( edm::Ref<reco::SuperClusterCollection>(pCleanSC, jsc) );
           scRefs->push_back(cscRef);
           isUncleanOnly.push_back(0);
           break;
         }
       }
     }
     if (not foundTheSame) {
       // mark it as unique in the uncleaned
       isUncleanOnly.push_back(1);
       // keep all its basic clusters
       for (reco::CaloCluster_iterator bciter = unscRef->clustersBegin(); bciter != unscRef->clustersEnd(); ++bciter) {
         // the basic clusters
         basicClusters.push_back(**bciter);
         basicClusterOwner.push_back(isc);
       }
     }
   }
   int bcSize = basicClusters.size();
 
   LogDebug("EcalCleaning") << "Found cleaned SC: " << cleanSize << " uncleaned SC: " << uncleanSize << " from which "
                            << scRefs->size() << " will become refs to the cleaned collection";
 
   // now you have the collection of basic clusters of the SC to be remain in the
   // in the clean collection, export them to the event
   // you will need to reread them later in order to make correctly the refs to the SC
   auto basicClusters_p = std::make_unique<reco::BasicClusterCollection>();
   basicClusters_p->assign(basicClusters.begin(), basicClusters.end());
   edm::OrphanHandle<reco::BasicClusterCollection> bccHandle = evt.put(std::move(basicClusters_p), bcCollection_);
   if (!(bccHandle.isValid())) {
     edm::LogWarning("MissingInput") << "could not get a handle on the BasicClusterCollection!" << std::endl;
     return;
   }
 
   LogDebug("EcalCleaning") << "Got the BasicClusters from the event again";
   // now you have to create again your superclusters
   // you run over the uncleaned SC, but now you know which of them are
   // the ones that are needed and which are their basic clusters
   for (int isc = 0; isc < uncleanSize; ++isc) {
     if (isUncleanOnly[isc] == 1) {  // look for sc that are unique in the unclean collection
       // make the basic cluster collection
       reco::CaloClusterPtrVector clusterPtrVector;
       reco::CaloClusterPtr seed;  // the seed is the basic cluster with the highest energy
       double energy = -1;
       for (int jbc = 0; jbc < bcSize; ++jbc) {
         if (basicClusterOwner[jbc] == isc) {
           reco::CaloClusterPtr currentClu = reco::CaloClusterPtr(bccHandle, jbc);
           clusterPtrVector.push_back(currentClu);
           if (energy < currentClu->energy()) {
             energy = currentClu->energy();
             seed = currentClu;
           }
         }
       }
       reco::SuperClusterRef unscRef(pUncleanSC, isc);
       reco::SuperCluster newSC(unscRef->energy(), unscRef->position(), seed, clusterPtrVector);
       superClusters.push_back(newSC);
     }
   }
   // export the collection of references to the clean collection
   std::unique_ptr<reco::SuperClusterRefVector> scRefs_p(scRefs);
   evt.put(std::move(scRefs_p), refScCollection_);
 
   // the collection of basic clusters is already in the event
   // the collection of uncleaned SC
   auto superClusters_p = std::make_unique<reco::SuperClusterCollection>();
   superClusters_p->assign(superClusters.begin(), superClusters.end());
   evt.put(std::move(superClusters_p), scCollection_);
   LogDebug("EcalCleaning") << "Hybrid Clusters (Basic/Super) added to the Event! :-)";
 }