#include <CleanAndMergeProducer.h>

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 17 of file CleanAndMergeProducer.h.

Constructor & Destructor Documentation

◆ CleanAndMergeProducer()

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

Definition at line 51 of file CleanAndMergeProducer.cc.

                                                                       {
   // 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_);
 }

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

◆ ~CleanAndMergeProducer()

CleanAndMergeProducer::~CleanAndMergeProducer ( )

override

Definition at line 74 of file CleanAndMergeProducer.cc.

74 { ; }

Member Function Documentation

◆ produce()

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

override

Definition at line 76 of file CleanAndMergeProducer.cc.

                                                                           {
   // 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! :-)";
 }