Inheritance diagram for CandOneToOneDeltaRMatcher:

Public Member Functions
	CandOneToOneDeltaRMatcher (const edm::ParameterSet &)

	~CandOneToOneDeltaRMatcher () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
std::vector< int >	AlgoBruteForce (int, int)

std::vector< int >	AlgoSwitchMethod (int, int)

double	lenght (const std::vector< int > &)

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

Private Attributes
std::string	algoMethod_

std::vector< std::vector< float > >	AllDist

edm::EDGetTokenT< reco::CandidateView >	matchedToken_

edm::EDGetTokenT< reco::CandidateView >	sourceToken_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 18 of file CandOneToOneDeltaRMatcher.cc.

Constructor & Destructor Documentation

CandOneToOneDeltaRMatcher::CandOneToOneDeltaRMatcher ( const edm::ParameterSet & cfg )

Definition at line 60 of file CandOneToOneDeltaRMatcher.cc.

                                                                                :
   sourceToken_( consumes<CandidateView>( cfg.getParameter<InputTag>( "src" ) ) ),
   matchedToken_( consumes<CandidateView>( cfg.getParameter<InputTag>( "matched" ) ) ),
   algoMethod_( cfg.getParameter<string>( "algoMethod" ) ) {
   produces<CandViewMatchMap>("src2mtc");
   produces<CandViewMatchMap>("mtc2src");
 }

CandOneToOneDeltaRMatcher::~CandOneToOneDeltaRMatcher ( )

override

Definition at line 68 of file CandOneToOneDeltaRMatcher.cc.

68 {

69 }

Member Function Documentation

vector< int > CandOneToOneDeltaRMatcher::AlgoBruteForce	(	int	nMin,
		int	nMax
	)

private

Definition at line 220 of file CandOneToOneDeltaRMatcher.cc.

References lenght(), and stdcomb::next_combination().

Referenced by produce().

                                                                           {
 
   vector<int> ca;
   vector<int> cb;
   vector<int> bestCB;
   float totalDeltaR=0;
   float BestTotalDeltaR=1000;
 
   for(int i1=0; i1<nMax; i1++) ca.push_back(i1);
   for(int i1=0; i1<nMin; i1++) cb.push_back(i1);
 
   do
     {
       //do your processing on the new combination here
       for(int cnt=0;cnt<TMath::Factorial(nMin); cnt++)
     {
       totalDeltaR = lenght(cb);
       if ( totalDeltaR < BestTotalDeltaR ) {
         BestTotalDeltaR = totalDeltaR;
         bestCB=cb;
       }
       next_permutation( cb.begin() , cb.end() );
     }
     }
   while(next_combination( ca.begin() , ca.end() , cb.begin() , cb.end() ));
 
   return bestCB;
 }

vector< int > CandOneToOneDeltaRMatcher::AlgoSwitchMethod	(	int	nMin,
		int	nMax
	)

private

Definition at line 260 of file CandOneToOneDeltaRMatcher.cc.

References AllDist, and DEFINE_FWK_MODULE.

Referenced by produce().

                                                                             {
 
   vector<int> bestCB;
   for(int i1=0; i1<nMin; i1++) {
     int minInd=0;
     for(int i2=1; i2<nMax; i2++) if( AllDist[i1][i2] < AllDist[i1][minInd] ) minInd = i2;
     bestCB.push_back(minInd);
   }
 
   bool inside = true;
   while( inside ) {
     inside = false;
     for(int i1=0;i1<nMin;i1++){
       for(int i2=i1+1;i2<nMin;i2++){
     if ( bestCB[i1] == bestCB[i2] ) {
       inside = true;
       if ( AllDist[i1][(bestCB[i1])] <= AllDist[i2][(bestCB[i2])]) {
         AllDist[i2][(bestCB[i2])]= 1000;
         int minInd=0;
         for(int i3=1; i3<nMax; i3++) if( AllDist[i2][i3] < AllDist[i2][minInd] ) minInd = i3;
         bestCB[i2]= minInd;
       }  else {
         AllDist[i1][(bestCB[i1])]= 1000;
         int minInd=0;
         for(int i3=1; i3<nMax; i3++) if( AllDist[i1][i3] < AllDist[i1][minInd] ) minInd = i3;
         bestCB[i1]= minInd;
       }
     } // End if
       }
     }
   } // End while
 
   return bestCB;
 
 }

double CandOneToOneDeltaRMatcher::lenght ( const std::vector< int > & best )

private

Definition at line 201 of file CandOneToOneDeltaRMatcher.cc.

References AllDist.

Referenced by AlgoBruteForce().

                                                                 {
   double myLenght=0;
   int row=0;
   for(vector<int>::const_iterator it=best.begin(); it!=best.end(); it++ ) {
     myLenght+=AllDist[row][*it];
     row++;
   }
   return myLenght;
 }

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

overrideprivate

Definition at line 71 of file CandOneToOneDeltaRMatcher.cc.

References AlgoBruteForce(), algoMethod_, AlgoSwitchMethod(), AllDist, edm::View< T >::begin(), EnergyCorrector::c, HiRegitMuonDetachedTripletStep_cff::DeltaR, edm::View< T >::end(), Exception, edm::Event::getByToken(), createfilelist::int, electrons_cff::matched, matchedToken_, SiStripPI::max, min(), eostools::move(), edm::Event::put(), edm::View< T >::refAt(), edm::View< T >::size(), source, and sourceToken_.

                                                                           {
 
   Handle<CandidateView> source;
   Handle<CandidateView> matched;
   evt.getByToken( sourceToken_, source ) ;
   evt.getByToken( matchedToken_, matched ) ;
 
   edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "======== Source Collection =======";
   for( CandidateView::const_iterator c = source->begin(); c != source->end(); ++c ) {
     edm::LogVerbatim("CandOneToOneDeltaRMatcher") << " pt source  " << c->pt() << " " << c->eta() << " " << c->phi()  << endl;
   }
   edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "======== Matched Collection =======";
   for( CandidateView::const_iterator c = matched->begin(); c != matched->end(); ++c ) {
     edm::LogVerbatim("CandOneToOneDeltaRMatcher") << " pt source  " << c->pt() << " " << c->eta() << " " << c->phi()  << endl;
   }
 
   const int nSrc = source->size();
   const int nMtc = matched->size();
 
   const int nMin = min( source->size() , matched->size() );
   const int nMax = max( source->size() , matched->size() );
   if( nMin < 1 ) return;
 
   if( nSrc <= nMtc ) {
     for(CandidateView::const_iterator iSr  = source->begin();
     iSr != source->end();
     iSr++) {
       vector <float> tempAllDist;
       for(CandidateView::const_iterator iMt  = matched->begin();
       iMt != matched->end();
       iMt++) {
     tempAllDist.push_back(DeltaR( iSr->p4() , iMt->p4() ) );
       }
       AllDist.push_back(tempAllDist);
       tempAllDist.clear();
     }
   } else {
     for(CandidateView::const_iterator iMt  = matched->begin();
     iMt != matched->end();
     iMt++) {
       vector <float> tempAllDist;
       for(CandidateView::const_iterator iSr  = source->begin();
       iSr != source->end();
       iSr++) {
     tempAllDist.push_back(DeltaR( iSr->p4() , iMt->p4() ) );
       }
       AllDist.push_back(tempAllDist);
       tempAllDist.clear();
     }
   }
 
   /*
   edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "======== The DeltaR Matrix =======";
   for(int m0=0; m0<nMin; m0++) {
     //    for(int m1=0; m1<nMax; m1++) {
       edm::LogVerbatim("CandOneToOneDeltaRMatcher") << setprecision(2) << fixed << (m1 AllDist[m0][m1] ;
     //}
     edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "\n";
   }
   */
 
   // Loop size if Brute Force
   int nLoopToDo = (int) ( TMath::Factorial(nMax) / TMath::Factorial(nMax - nMin) );
   edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "nLoop:" << nLoopToDo << endl;
   edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "Choosen Algo is:" << algoMethod_ ;
   vector<int> bestCB;
 
   // Algo is Brute Force
   if( algoMethod_ == "BruteForce") {
 
     bestCB = AlgoBruteForce(nMin,nMax);
 
   // Algo is Switch Method
   } else if( algoMethod_ == "SwitchMode" ) {
 
     bestCB = AlgoSwitchMethod(nMin,nMax);
 
   // Algo is Brute Force if nLoop < 10000
   } else if( algoMethod_ == "MixMode" ) {
 
     if( nLoopToDo < 10000 ) {
       bestCB = AlgoBruteForce(nMin,nMax);
     } else {
       bestCB = AlgoSwitchMethod(nMin,nMax);
     }
 
   } else {
     throw cms::Exception("OneToOne Constructor") << "wrong matching method in ParameterSet";
   }
 
   for(int i1=0; i1<nMin; i1++) edm::LogVerbatim("CandOneToOneDeltaRMatcher") << "min: " << i1 << " " << bestCB[i1] << " " << AllDist[i1][bestCB[i1]];
 
 /*
   auto matchMapSrMt = std::make_unique<CandViewMatchMap>(CandViewMatchMap::ref_type( CandidateRefProd( source  ),
                                                                                              CandidateRefProd( matched ) ) );
   auto matchMapMtSr = std::make_unique<CandViewMatchMap>(CandViewMatchMap::ref_type( CandidateRefProd( matched ),
                                                                                              CandidateRefProd( source ) ) );
 */
 
   auto matchMapSrMt = std::make_unique<CandViewMatchMap>();
   auto matchMapMtSr = std::make_unique<CandViewMatchMap>();
 
   for( int c = 0; c != nMin; c ++ ) {
     if( source->size() <= matched->size() ) {
       matchMapSrMt->insert( source ->refAt(c         ), matched->refAt(bestCB[c] ) );
       matchMapMtSr->insert( matched->refAt(bestCB[c] ), source ->refAt(c         ) );
     } else {
       matchMapSrMt->insert( source ->refAt(bestCB[c] ), matched->refAt(c         ) );
       matchMapMtSr->insert( matched->refAt(c         ), source ->refAt(bestCB[c] ) );
     }
   }
 
 /*
   for( int c = 0; c != nMin; c ++ ) {
     if( source->size() <= matched->size() ) {
       matchMapSrMt->insert( CandidateRef( source,  c         ), CandidateRef( matched, bestCB[c] ) );
       matchMapMtSr->insert( CandidateRef( matched, bestCB[c] ), CandidateRef( source, c          ) );
     } else {
       matchMapSrMt->insert( CandidateRef( source,  bestCB[c] ), CandidateRef( matched, c         ) );
       matchMapMtSr->insert( CandidateRef( matched, c         ), CandidateRef( source,  bestCB[c] ) );
     }
   }
 */
   evt.put(std::move(matchMapSrMt), "src2mtc" );
   evt.put(std::move(matchMapMtSr), "mtc2src" );
 
   AllDist.clear();
 }