compareCands< T > Class Template Reference

#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 20 of file compareCands.h.

Constructor & Destructor Documentation

compareCands()

template<class T >

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

Definition at line 38 of file compareCands.h.

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

~compareCands()

template<class T >

compareCands< T >::~compareCands

(

)

Definition at line 44 of file compareCands.h.

                               {
  //anything need destructing?
}

Member Function Documentation

doCompare()

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 49 of file compareCands.h.

References GCT_OBJECT_QUANTA, mps_fire::i, dqmiolumiharvest::j, and muonTagProbeFilters_cff::matched.

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 = false;
  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)) = true;  //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 = true;                               //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 = true;                              //set the errorFlag (if it's not already)
      }
    }
  }

  return errorFlag;
}

Member Data Documentation

data_

template<class T >

T compareCands< T >::data_

private

Definition at line 32 of file compareCands.h.

emu_

template<class T >

T compareCands< T >::emu_

private

Definition at line 32 of file compareCands.h.

mbxparams_

template<class T >

GctErrorAnalyzerMBxInfo compareCands< T >::mbxparams_

private

Definition at line 33 of file compareCands.h.