#include <compareCands.h>

Public Member Functions
	compareCands (const T &data, const T &emu, const GctErrorAnalyzerMBxInfo &mbxparams)

bool	doCompare (TH1I errorFlag_hist_, TH1I mismatchD_Rank, TH2I mismatchD_EtEtaPhi, TH1I mismatchE_Rank, TH2I *mismatchE_EtEtaPhi)

	~compareCands ()

Private Attributes
T	data_

T	emu_

GctErrorAnalyzerMBxInfo	mbxparams_

Detailed Description

template<class T>
class compareCands< T >

Definition at line 21 of file compareCands.h.

Constructor & Destructor Documentation

template<class T >

compareCands< T >::compareCands	(	const T &	data,
		const T &	emu,
		const GctErrorAnalyzerMBxInfo &	mbxparams
	)

Definition at line 36 of file compareCands.h.

                                                                                                    :
   data_(data),
   emu_(emu),
   mbxparams_(mbxparams)
 {
   //std::cout << "initialising..." << std::endl;
 }

template<class T >

compareCands< T >::~compareCands ( )

Definition at line 45 of file compareCands.h.

                                {
   //anything need destructing?
 }

Member Function Documentation

template<class T >

bool compareCands< T >::doCompare	(	TH1I *	errorFlag_hist_,
		TH1I *	mismatchD_Rank,
		TH2I *	mismatchD_EtEtaPhi,
		TH1I *	mismatchE_Rank,
		TH2I *	mismatchE_EtEtaPhi
	)

Definition at line 50 of file compareCands.h.

References compareCands< T >::data_, compareCands< T >::emu_, GctErrorAnalyzerMBxInfo::EmuTrigBx, GCT_OBJECT_QUANTA, GctErrorAnalyzerMBxInfo::GCTTrigBx, mps_fire::i, electronMatch_cfi::matched, and compareCands< T >::mbxparams_.

Referenced by GctErrorAnalyzer::analyze().

                                                                                                                                                      {
 
   //this code has now been patched to be multiple_bx compliant. However, this still means that only 1 comparison will happen per event, and this has to be
   //matched such that the RCTTrigBx(=0) data is run over the emulator and the EmuTrigBx analysis (Bx=0) corresponds to the GCTTrigBx (Bx=0) analysis
   //These TrigBx parameters are set in the configuration to make things more flexible if things change later
 
   //define some temporary local variables
   bool errorFlag=0;
   unsigned int i=0, j=0;
   std::vector<bool> matched(GCT_OBJECT_QUANTA);
   //this makes a vector of GCT_OBJECT_QUANTA=4 bools, all set to false
   //remember that pushing back will make the vector larger!
 
   for(i=0; i < data_->size(); i++) {
 
     //The first thing to check is that the BX of the data corresponds to the trig Bx (we expect these to be contiguous i.e. data sorted in Bx)
     if(data_->at(i).bx() != mbxparams_.GCTTrigBx) continue;
     
     //If the data candidate has zero rank, move to the next data candidate
     //since all the candidates are ranked in order of rank, this implies all the remaining data candidates also have rank = 0
     if(data_->at(i).rank() == 0 ) continue;
 
     for(j=0; j < emu_->size(); j++) {
 
       //Again, the first thing to check in this loop is that the BX of the emulator data corresponds to the trig Bx
       if(emu_->at(j).bx() != mbxparams_.EmuTrigBx) continue;
 
       if(   data_->at(i).rank() == emu_->at(j).rank()
         && data_->at(i).regionId().ieta() == emu_->at(j).regionId().ieta()
         && data_->at(i).regionId().iphi() == emu_->at(j).regionId().iphi()
         && matched.at((j % GCT_OBJECT_QUANTA)) == 0 ) {
     //this means that the ith data candidate matches the jth emulator candidate
     errorFlag_hist_->Fill(0); //fill the errorflag histo in the matched bin
     matched.at((j % GCT_OBJECT_QUANTA)) = 1; //set emulator candidate to matched so it doesn't get re-used
     break; //matched the current data candidate, now move to the next
       }
 
       if( (j % GCT_OBJECT_QUANTA) + 1 == GCT_OBJECT_QUANTA) {
     errorFlag_hist_->Fill(1); //fill the errorflag histo in the unmatched data candidate bin
     mismatchD_Rank->Fill(data_->at(i).rank()); //fill the rank histogram of mismatched data candidates
     mismatchD_EtEtaPhi->Fill(data_->at(i).regionId().ieta(),data_->at(i).regionId().iphi(),data_->at(i).rank()); //fill the EtEtaPhi dist for mismatched candidates
     errorFlag=1; //set the errorFlag to true
       }
 
     }
   }
 
 //loop over the matched boolean vector and see if there are any rank>0 unmatched emu candidates - if there are populate the histogram in the emulator mismatched bin
   for(i=0; i<matched.size(); i++) {
     //the first thing to check is that the matched flag for object i out of 0,1,2,3 (0 -> GCT_OBJECT_QUANTA-1) is not set - then we can check that the corresponding
     //emulator candidates either have rank = 0 (which is good) or rank > 0 (which is bad)
     if(matched.at(i)) continue;
 
     //now loop over the emulator candidates
     for(j=0; j< emu_->size(); j++) {
       //check that the bx of the emulator candidates is the trigbx
       if(emu_->at(j).bx() != mbxparams_.EmuTrigBx) continue;
       
       //now check that the j%GCT_OBJECT_QUANTA is the same as the index of the false entry in the bool_matched vector so that we are looking at the right candidate
       if((j%GCT_OBJECT_QUANTA == i) && (emu_->at(j).rank()>0) ) {
     errorFlag_hist_->Fill(2); //increment emulator mismatched bin
     mismatchE_Rank->Fill(emu_->at(j).rank()); //fill the rank histogram for unmatched emulator
     mismatchE_EtEtaPhi->Fill(emu_->at(j).regionId().ieta(),emu_->at(j).regionId().iphi(),emu_->at(j).rank()); //fill EtEtaPhi for unmatched emu cands
     errorFlag=1; //set the errorFlag (if it's not already)
       }
     }
   }
 
   return errorFlag;
 }