#include <MultiTrackValidatorGenPs.h>

Inheritance diagram for MultiTrackValidatorGenPs:

Public Member Functions
void	dqmAnalyze (const edm::Event &, const edm::EventSetup &, const Histograms &) const override
	Method called once per event. More...

	MultiTrackValidatorGenPs (const edm::ParameterSet &pset)
	Constructor. More...

	~MultiTrackValidatorGenPs () override
	Destructor. More...

Public Member Functions inherited from MultiTrackValidator
void	bookHistograms (DQMStore::ConcurrentBooker &, edm::Run const &, edm::EventSetup const &, Histograms &) const override
	Method called to book the DQM histograms. More...

void	dqmAnalyze (const edm::Event &, const edm::EventSetup &, const Histograms &) const override
	Method called once per event. More...

	MultiTrackValidator (const edm::ParameterSet &pset)
	Constructor. More...

	~MultiTrackValidator () override
	Destructor. More...

Public Member Functions inherited from edm::global::EDAnalyzer< edm::RunCache< MultiTrackValidatorHistograms > >
	EDAnalyzer ()=default

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () 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

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)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
edm::EDGetTokenT< reco::GenToRecoCollection >	associatormapGtR

edm::EDGetTokenT< reco::RecoToGenCollection >	associatormapRtG

GenParticleCustomSelector	gpSelector

edm::EDGetTokenT< reco::TrackToGenParticleAssociator >	label_gen_associator

Additional Inherited Members
Public Types inherited from MultiTrackValidator
using	Histograms = MultiTrackValidatorHistograms

Public Types inherited from edm::global::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 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)

Protected Attributes inherited from MultiTrackValidator
std::vector< edm::InputTag >	associators

edm::EDGetTokenT< reco::BeamSpot >	bsSrc

const bool	calculateDrSingleCollection_

const bool	dodEdxPlots_

const bool	doMVAPlots_

const bool	doPlotsOnlyForTruePV_

const bool	doPVAssociationPlots_

const bool	doRecoTrackPlots_

std::vector< bool >	doResolutionPlots_

const bool	doSeedPlots_

const bool	doSimPlots_

const bool	doSimTrackPlots_

const bool	doSummaryPlots_

std::unique_ptr< MTVHistoProducerAlgoForTracker >	histoProducerAlgo_

const bool	ignoremissingtkcollection_

std::vector< edm::InputTag >	label

edm::EDGetTokenT< std::vector< PileupSummaryInfo > >	label_pileupinfo

edm::EDGetTokenT< TrackingParticleCollection >	label_tp_effic

edm::EDGetTokenT< TrackingParticleRefVector >	label_tp_effic_refvector

edm::EDGetTokenT< TrackingParticleCollection >	label_tp_fake

edm::EDGetTokenT< TrackingParticleRefVector >	label_tp_fake_refvector

edm::EDGetTokenT< TrackingVertexCollection >	label_tv

std::vector< edm::EDGetTokenT< edm::View< reco::Track > > >	labelToken

std::vector< edm::EDGetTokenT< edm::View< TrajectorySeed > > >	labelTokenSeed

edm::EDGetTokenT< edm::ValueMap< reco::DeDxData > >	m_dEdx1Tag

edm::EDGetTokenT< edm::ValueMap< reco::DeDxData > >	m_dEdx2Tag

std::string	parametersDefiner

const bool	parametersDefinerIsCosmic_

std::vector< edm::EDGetTokenT< std::vector< PSimHit > > >	simHitTokens_

const bool	useAssociators_

Detailed Description

Class that prodecs histrograms to validate Track Reconstruction performances

Author: cerati

Definition at line 14 of file MultiTrackValidatorGenPs.h.

Constructor & Destructor Documentation

MultiTrackValidatorGenPs::MultiTrackValidatorGenPs ( const edm::ParameterSet & pset )

Constructor.

Definition at line 38 of file MultiTrackValidatorGenPs.cc.

References associatormapGtR, associatormapRtG, MultiTrackValidator::associators, edm::ParameterSet::getParameter(), gpSelector, kTrackAssociatorByChi2(), label_gen_associator, TrackRefitter_38T_cff::src, and MultiTrackValidator::useAssociators_.

                                                                              :MultiTrackValidator(pset){
 
   gpSelector = GenParticleCustomSelector(pset.getParameter<double>("ptMinGP"),
                      pset.getParameter<double>("minRapidityGP"),
                      pset.getParameter<double>("maxRapidityGP"),
                      pset.getParameter<double>("tipGP"),
                      pset.getParameter<double>("lipGP"),
                      pset.getParameter<bool>("chargedOnlyGP"),
                      pset.getParameter<int>("statusGP"),
                      pset.getParameter<std::vector<int> >("pdgIdGP"));
 
   if(useAssociators_) {
     for(auto const& src: associators) {
       if( src.label() == kTrackAssociatorByChi2) {
         label_gen_associator = consumes<reco::TrackToGenParticleAssociator>(src);
         break;
       }
     }
   }
   else {
     for (auto const& src: associators) {
       associatormapGtR = consumes<reco::GenToRecoCollection>(src);
       associatormapRtG = consumes<reco::RecoToGenCollection>(src);
       break;
     }
   }
 }

MultiTrackValidatorGenPs::~MultiTrackValidatorGenPs ( )

override

Destructor.

Definition at line 66 of file MultiTrackValidatorGenPs.cc.

66 {}

Member Function Documentation

void MultiTrackValidatorGenPs::dqmAnalyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup,
		const Histograms &	histograms
	)		const

override

Method called once per event.

Definition at line 69 of file MultiTrackValidatorGenPs.cc.

                                                                                                                                {
   using namespace reco;
   
   edm::LogInfo("TrackValidator") << "\n====================================================" << "\n"
                  << "Analyzing new event" << "\n"
                  << "====================================================\n" << "\n";
 
   edm::ESHandle<ParametersDefinerForTP> parametersDefinerTP; 
   setup.get<TrackAssociatorRecord>().get(parametersDefiner,parametersDefinerTP);    
   
   edm::ESHandle<TrackerTopology> httopo;
   setup.get<TrackerTopologyRcd>().get(httopo);
   const TrackerTopology& ttopo = *httopo;
 
   edm::Handle<GenParticleCollection>  TPCollectionHeff ;
   event.getByToken(label_tp_effic,TPCollectionHeff);
   const GenParticleCollection tPCeff = *(TPCollectionHeff.product());
   
   edm::Handle<GenParticleCollection>  TPCollectionHfake ;
   event.getByToken(label_tp_fake,TPCollectionHfake);
   const GenParticleCollection tPCfake = *(TPCollectionHfake.product());
   
   //if (tPCeff.size()==0) {edm::LogInfo("TrackValidator") 
   //<< "TP Collection for efficiency studies has size = 0! Skipping Event." ; return;}
   //if (tPCfake.size()==0) {edm::LogInfo("TrackValidator") 
   //<< "TP Collection for fake rate studies has size = 0! Skipping Event." ; return;}
   
   edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
   event.getByToken(bsSrc,recoBeamSpotHandle);
   reco::BeamSpot bs = *recoBeamSpotHandle;      
   
   edm::Handle< vector<PileupSummaryInfo> > puinfoH;
   event.getByToken(label_pileupinfo,puinfoH);
   PileupSummaryInfo puinfo;      
   
   for (unsigned int puinfo_ite=0;puinfo_ite<(*puinfoH).size();++puinfo_ite){ 
     if ((*puinfoH)[puinfo_ite].getBunchCrossing()==0){
       puinfo=(*puinfoH)[puinfo_ite];
       break;
     }
   }
 
   const reco::TrackToGenParticleAssociator* trackGenAssociator =nullptr;
   if(useAssociators_) {
     if(label_gen_associator.isUninitialized()) {
       return;
     }
     else {
       edm::Handle<reco::TrackToGenParticleAssociator> trackGenAssociatorH;
       event.getByToken(label_gen_associator,trackGenAssociatorH);
       trackGenAssociator = trackGenAssociatorH.product();
     }
   }
   else if(associatormapGtR.isUninitialized()) {
     return;
   }
 
   // dE/dx
   // at some point this could be generalized, with a vector of tags and a corresponding vector of Handles
   // I'm writing the interface such to take vectors of ValueMaps
   std::vector<const edm::ValueMap<reco::DeDxData> *> v_dEdx;
   if(dodEdxPlots_) {
     edm::Handle<edm::ValueMap<reco::DeDxData> > dEdx1Handle;
     edm::Handle<edm::ValueMap<reco::DeDxData> > dEdx2Handle;
     event.getByToken(m_dEdx1Tag, dEdx1Handle);
     event.getByToken(m_dEdx2Tag, dEdx2Handle);
     v_dEdx.push_back(dEdx1Handle.product());
     v_dEdx.push_back(dEdx2Handle.product());
   }
 
   std::vector<float> mvaDummy;
 
   int w=0; //counter counting the number of sets of histograms
   for (unsigned int www=0;www<label.size();www++){
     //
     //get collections from the event
     //
     edm::Handle<View<Track> >  trackCollection;
     if(!event.getByToken(labelToken[www], trackCollection)&&ignoremissingtkcollection_)continue;
     //if (trackCollection->size()==0) 
     //edm::LogInfo("TrackValidator") << "TrackCollection size = 0!" ; 
     //continue;
     //}
     reco::RecoToGenCollection recGenColl;
     reco::GenToRecoCollection genRecColl;
     //associate tracks
     if(useAssociators_){
       edm::LogVerbatim("TrackValidator") << "Analyzing " 
                                          << label[www].process()<<":"
                                          << label[www].label()<<":"
                                          << label[www].instance()<<" with "
                                          << kTrackAssociatorByChi2 <<"\n";
       
       LogTrace("TrackValidator") << "Calling associateRecoToGen method" << "\n";
       recGenColl=trackGenAssociator->associateRecoToGen(trackCollection,
                             TPCollectionHfake);
       LogTrace("TrackValidator") << "Calling associateGenToReco method" << "\n";
       genRecColl=trackGenAssociator->associateGenToReco(trackCollection,
                             TPCollectionHeff);
     }
     else{
       edm::LogVerbatim("TrackValidator") << "Analyzing " 
                                          << label[www].process()<<":"
                                          << label[www].label()<<":"
                                          << label[www].instance()<<" with "
                                          << associators[0] << "\n";
       
       Handle<reco::GenToRecoCollection > gentorecoCollectionH;
       event.getByToken(associatormapGtR,gentorecoCollectionH);
       genRecColl= *(gentorecoCollectionH.product()); 
       
       Handle<reco::RecoToGenCollection > recotogenCollectionH;
       event.getByToken(associatormapRtG,recotogenCollectionH);
       recGenColl= *(recotogenCollectionH.product()); 
     }
 
 
 
     // ########################################################
     // fill simulation histograms (LOOP OVER TRACKINGPARTICLES)
     // ########################################################
     
     //compute number of tracks per eta interval
     //
     edm::LogVerbatim("TrackValidator") << "\n# of GenParticles: " << tPCeff.size() << "\n";
     int ats(0);       //This counter counts the number of simTracks that are "associated" to recoTracks
     int st(0);        //This counter counts the number of simulated tracks passing the MTV selection (i.e. tpSelector(tp) )
     unsigned sts(0);   //This counter counts the number of simTracks surviving the bunchcrossing cut 
     unsigned asts(0);  //This counter counts the number of simTracks that are "associated" to recoTracks surviving the bunchcrossing cut
     for (GenParticleCollection::size_type i=0; i<tPCeff.size(); i++){ //loop over TPs collection for tracking efficiency
       GenParticleRef tpr(TPCollectionHeff, i);
       GenParticle* tp=const_cast<GenParticle*>(tpr.get());
       TrackingParticle::Vector momentumTP; 
       TrackingParticle::Point vertexTP;
       double dxyGen(0);
       double dzGen(0);
       
       
       //---------- THIS PART HAS TO BE CLEANED UP. THE PARAMETER DEFINER WAS NOT MEANT TO BE USED IN THIS WAY ----------
       //If the GenParticle is collison like, get the momentum and vertex at production state
       if(!parametersDefinerIsCosmic_)
         {
           //fixme this one shold be implemented
           if(! gpSelector(*tp)) continue;
           momentumTP = tp->momentum();
           vertexTP = tp->vertex();
           //Calcualte the impact parameters w.r.t. PCA
           TrackingParticle::Vector momentum = parametersDefinerTP->momentum(event,setup,*tp);
           TrackingParticle::Point vertex = parametersDefinerTP->vertex(event,setup,*tp);
           dxyGen = (-vertex.x()*sin(momentum.phi())+vertex.y()*cos(momentum.phi()));
           dzGen = vertex.z() - (vertex.x()*momentum.x()+vertex.y()*momentum.y())/sqrt(momentum.perp2()) 
             * momentum.z()/sqrt(momentum.perp2());
         }
       //If the GenParticle is comics, get the momentum and vertex at PCA
       else
         {
           //if(! cosmictpSelector(*tp,&bs,event,setup)) continue;   
           momentumTP = parametersDefinerTP->momentum(event,setup,*tp);
           vertexTP = parametersDefinerTP->vertex(event,setup,*tp);
           dxyGen = (-vertexTP.x()*sin(momentumTP.phi())+vertexTP.y()*cos(momentumTP.phi()));
           dzGen = vertexTP.z() - (vertexTP.x()*momentumTP.x()+vertexTP.y()*momentumTP.y())/sqrt(momentumTP.perp2()) 
             * momentumTP.z()/sqrt(momentumTP.perp2());
         }
       //---------- THE PART ABOVE HAS TO BE CLEANED UP. THE PARAMETER DEFINER WAS NOT MEANT TO BE USED IN THIS WAY ----------
       
       st++;   //This counter counts the number of simulated tracks passing the MTV selection (i.e. tpSelector(tp) )
       
       // in the coming lines, histos are filled using as input
       // - momentumTP 
       // - vertexTP 
       // - dxyGen
       // - dzGen
       
       if(doSimPlots_ && w == 0) {
         histoProducerAlgo_->fill_generic_simTrack_histos(histograms.histoProducerAlgo,momentumTP,vertexTP, tp->collisionId());//fixme: check meaning of collisionId
       }
       if(!doSimTrackPlots_)
         continue;
       
       
       // ##############################################
       // fill RecoAssociated GenTracks' histograms
       // ##############################################
       // bool isRecoMatched(false); // UNUSED
       const reco::Track* matchedTrackPointer=nullptr;
       std::vector<std::pair<RefToBase<Track>, double> > rt;
       if(genRecColl.find(tpr) != genRecColl.end()){
         rt = (std::vector<std::pair<RefToBase<Track>, double> >) genRecColl[tpr];
         if (!rt.empty()) {
           ats++; //This counter counts the number of simTracks that have a recoTrack associated
           // isRecoMatched = true; // UNUSED
           matchedTrackPointer = rt.begin()->first.get();
           edm::LogVerbatim("TrackValidator") << "GenParticle #" << st 
                                              << " with pt=" << sqrt(momentumTP.perp2()) 
                                              << " associated with quality:" << rt.begin()->second <<"\n";
         }
       }else{
         edm::LogVerbatim("TrackValidator") 
           << "GenParticle #" << st
           << " with pt,eta,phi: " 
           << sqrt(momentumTP.perp2()) << " , "
           << momentumTP.eta() << " , "
           << momentumTP.phi() << " , "
           << " NOT associated to any reco::Track" << "\n";
       }
       
       
       
       int nSimHits = 0;
       histoProducerAlgo_->fill_recoAssociated_simTrack_histos(histograms.histoProducerAlgo,w,*tp,momentumTP,vertexTP,dxyGen,dzGen,nSimHits,matchedTrackPointer,puinfo.getPU_NumInteractions());
       
       sts++;
       if (matchedTrackPointer) asts++;
       
       
       
       
     } // End  for (GenParticleCollection::size_type i=0; i<tPCeff.size(); i++){
     
     if(doSimPlots_ && w == 0) {
       histoProducerAlgo_->fill_simTrackBased_histos(histograms.histoProducerAlgo,st);
     }
     
     
       // ##############################################
       // fill recoTracks histograms (LOOP OVER TRACKS)
       // ##############################################
     if(!doRecoTrackPlots_)
       continue;
     edm::LogVerbatim("TrackValidator") << "\n# of reco::Tracks with "
                                        << label[www].process()<<":"
                                        << label[www].label()<<":"
                                        << label[www].instance()
                                        << ": " << trackCollection->size() << "\n";
     
     //int sat(0); //This counter counts the number of recoTracks that are associated to GenTracks from Signal only
     int at(0); //This counter counts the number of recoTracks that are associated to GenTracks
     int rT(0); //This counter counts the number of recoTracks in general
     
     for(View<Track>::size_type i=0; i<trackCollection->size(); ++i){
       
       RefToBase<Track> track(trackCollection, i);
       rT++;
       
       bool isSigGenMatched(false);
       bool isGenMatched(false);
       bool isChargeMatched(true);
       int numAssocRecoTracks = 0;
       int nSimHits = 0;
       double sharedFraction = 0.;
       std::vector<std::pair<GenParticleRef, double> > tp;
       if(recGenColl.find(track) != recGenColl.end()){
         tp = recGenColl[track];
         if (!tp.empty()) {
           /*
         std::vector<PSimHit> simhits=tp[0].first->trackPSimHit(DetId::Tracker);
             nSimHits = simhits.end()-simhits.begin();
           */
           sharedFraction = tp[0].second;
           isGenMatched = true;
           if (tp[0].first->charge() != track->charge()) isChargeMatched = false;
           if(genRecColl.find(tp[0].first) != genRecColl.end()) numAssocRecoTracks = genRecColl[tp[0].first].size();
           //std::cout << numAssocRecoTracks << std::endl;
           at++;
           for (unsigned int tp_ite=0;tp_ite<tp.size();++tp_ite){ 
             GenParticle trackpart = *(tp[tp_ite].first);
             /*
           if ((trackpart.eventId().event() == 0) && (trackpart.eventId().bunchCrossing() == 0)){
               isSigGenMatched = true;
               sat++;
               break;
           }
             */
           }
           edm::LogVerbatim("TrackValidator") << "reco::Track #" << rT << " with pt=" << track->pt() 
                                              << " associated with quality:" << tp.begin()->second <<"\n";
         }
       } else {
         edm::LogVerbatim("TrackValidator") << "reco::Track #" << rT << " with pt=" << track->pt()
                                            << " NOT associated to any GenParticle" << "\n";       
       }
       
       
       double dR=0;//fixme: plots vs dR not implemented for now
       histoProducerAlgo_->fill_generic_recoTrack_histos(histograms.histoProducerAlgo,w,*track, ttopo, bs.position(), nullptr, nullptr, isGenMatched,isSigGenMatched, isChargeMatched, numAssocRecoTracks, puinfo.getPU_NumInteractions(), nSimHits, sharedFraction, dR, mvaDummy, 0, 0);
       
       // dE/dx
       if (dodEdxPlots_) histoProducerAlgo_->fill_dedx_recoTrack_histos(histograms.histoProducerAlgo,w,track, v_dEdx);
       
       
       //Fill other histos
       //try{ //Is this really necessary ????
       
       if (tp.empty()) continue; 
       
       histoProducerAlgo_->fill_simAssociated_recoTrack_histos(histograms.histoProducerAlgo,w,*track);
       
       GenParticleRef tpr = tp.begin()->first;
       
       /* TO BE FIXED LATER
          if (associators[ww]=="TrackAssociatorByChi2"){
          //association chi2
          double assocChi2 = -tp.begin()->second;//in association map is stored -chi2
          h_assochi2[www]->Fill(assocChi2);
          h_assochi2_prob[www]->Fill(TMath::Prob((assocChi2)*5,5));
          }
          else if (associators[ww]=="quickTrackAssociatorByHits"){
          double fraction = tp.begin()->second;
          h_assocFraction[www]->Fill(fraction);
          h_assocSharedHit[www]->Fill(fraction*track->numberOfValidHits());
     }
       */
       
       
       //Get tracking particle parameters at point of closest approach to the beamline
       TrackingParticle::Vector momentumTP = parametersDefinerTP->momentum(event,setup,*(tpr.get()));
       TrackingParticle::Point vertexTP = parametersDefinerTP->vertex(event,setup,*(tpr.get()));          
       int chargeTP = tpr->charge();
       
       histoProducerAlgo_->fill_ResoAndPull_recoTrack_histos(histograms.histoProducerAlgo,w,momentumTP,vertexTP,chargeTP,
                                                             *track,bs.position());
       
       
       //TO BE FIXED
       //std::vector<PSimHit> simhits=tpr.get()->trackPSimHit(DetId::Tracker);
       //nrecHit_vs_nsimHit_rec2sim[w]->Fill(track->numberOfValidHits(), (int)(simhits.end()-simhits.begin() ));
       
       /*
         } // End of try{
         catch (cms::Exception e){
         LogTrace("TrackValidator") << "exception found: " << e.what() << "\n";
         }
       */
       
     } // End of for(View<Track>::size_type i=0; i<trackCollection->size(); ++i){
     
     histoProducerAlgo_->fill_trackBased_histos(histograms.histoProducerAlgo,w,at,rT,rT,st);
     
     edm::LogVerbatim("TrackValidator") << "Total Simulated: " << st << "\n"
                                        << "Total Associated (genToReco): " << ats << "\n"
                                        << "Total Reconstructed: " << rT << "\n"
                                        << "Total Associated (recoToGen): " << at << "\n"
                                        << "Total Fakes: " << rT-at << "\n";
     
     w++;
   } // End of  for (unsigned int www=0;www<label.size();www++){
 }