#include <L1TdeCSCTF.h>

Inheritance diagram for L1TdeCSCTF:

Public Member Functions
	L1TdeCSCTF (edm::ParameterSet const &pset)

virtual	~L1TdeCSCTF ()

Public Member Functions inherited from thread_unsafe::DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

	DQMEDAnalyzer (void)

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &iSetup)

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	bookHistograms (DQMStore::IBooker &ibooker, edm::Run const &, edm::EventSetup const &) override

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

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)

Private Attributes
MonitorElement *	badDtStubSector

edm::EDGetTokenT < CSCTriggerContainer < csctf::TrackStub > >	dataStubProducer

edm::EDGetTokenT < L1CSCTrackCollection >	dataTrackProducer

MonitorElement *	dtStubPhi

MonitorElement *	dtStubPhi_1d

edm::EDGetTokenT < L1MuDTChambPhContainer >	emulStubProducer

edm::EDGetTokenT < L1CSCTrackCollection >	emulTrackProducer

MonitorElement *	etaComp

MonitorElement *	etaComp_1d

std::string	m_dirName

CSCTFDTReceiver *	my_dtrc

MonitorElement *	occComp

MonitorElement *	occComp_1d

std::string	outFile

MonitorElement *	phiComp

MonitorElement *	phiComp_1d

MonitorElement *	pt1Comp

MonitorElement *	pt1Comp_1d

MonitorElement *	pt2Comp

MonitorElement *	pt2Comp_1d

MonitorElement *	pt3Comp

MonitorElement *	pt3Comp_1d

MonitorElement *	pt4Comp

MonitorElement *	pt4Comp_1d

MonitorElement *	pt5Comp

MonitorElement *	pt5Comp_1d

MonitorElement *	pt6Comp

MonitorElement *	pt6Comp_1d

MonitorElement *	ptComp

MonitorElement *	ptComp_1d

CSCTFPtLUT *	ptLUT_

edm::ParameterSet	ptLUTset

MonitorElement *	qualComp

MonitorElement *	qualComp_1d

const L1MuTriggerScales *	ts

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Detailed Description

Definition at line 42 of file L1TdeCSCTF.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 40 of file L1TdeCSCTF.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and GetRecoTauVFromDQM_MC_cff::outFile.

                                                {
   dataTrackProducer = consumes<L1CSCTrackCollection>(pset.getParameter<InputTag>("dataTrackProducer"));
   emulTrackProducer = consumes<L1CSCTrackCollection>(pset.getParameter<InputTag>("emulTrackProducer"));
   dataStubProducer  = consumes<CSCTriggerContainer<csctf::TrackStub> >(pset.getParameter<InputTag>("dataStubProducer"));
   emulStubProducer  = consumes<L1MuDTChambPhContainer>(pset.getParameter<InputTag>("emulStubProducer"));
     
   m_dirName         = pset.getUntrackedParameter("DQMFolder", string("L1TEMU/CSCTFexpert"));
 
   ts=0;
   ptLUT_ = 0;
     
   ptLUTset = pset.getParameter<ParameterSet>("PTLUT");
     
   outFile = pset.getUntrackedParameter<string>("outFile", "");
   if( outFile.size() != 0 )
   {
       LogWarning("L1TdeCSCTF")
         << "L1T Monitoring histograms will be saved to " 
         << outFile.c_str() 
         << endl;
   }
     
   bool disable = pset. getUntrackedParameter<bool>("disableROOToutput", false);
   if(disable){
         outFile="";
   }
     
     /*bzero(srLUTs_, sizeof(srLUTs_));
     //int endcap =1, sector =1;
     bool TMB07=true;
     ParameterSet srLUTset;
     srLUTset.addUntrackedParameter<bool>("ReadLUTs", false);
     srLUTset.addUntrackedParameter<bool>("Binary",   false);
     srLUTset.addUntrackedParameter<string>("LUTPath", "./");
     for(int endcapItr = CSCDetId::minEndcapId(); endcapItr <= CSCDetId::maxEndcapId(); endcapItr++)
     {
         for(int sectorItr = CSCTriggerNumbering::minTriggerSectorId();sectorItr <= CSCTriggerNumbering::maxTriggerSectorId();sectorItr++)
         {
             for(int stationItr = 1; stationItr <= 4; stationItr++)
             {
                 if(stationItr == 1)
                 {
                     for(int subsectorItr = 0; subsectorItr < 2; subsectorItr++)
                     {
                         srLUTs_[endcapItr-1][sectorItr-1][subsectorItr] = new CSCSectorReceiverLUT(endcapItr, sectorItr, subsectorItr+1, stationItr, srLUTset, TMB07); 
                     }
                 } else {
                     srLUTs_[endcapItr-1][sectorItr-1][stationItr] = new CSCSectorReceiverLUT(endcapItr, sectorItr, 0, stationItr, srLUTset, TMB07); 
                 } //if for station 1 or 234
             } // stationItr loop
         } // sectorItr loop
     } // endcapItr loop
     */
   my_dtrc = new CSCTFDTReceiver();
 }

virtual L1TdeCSCTF::~L1TdeCSCTF ( )

inlinevirtual

Definition at line 78 of file L1TdeCSCTF.h.

78 {}

Member Function Documentation

void L1TdeCSCTF::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	iSetup
	)

protectedvirtual

Implements edm::EDAnalyzer.

Definition at line 262 of file L1TdeCSCTF.cc.

References funct::abs(), CSCTriggerContainer< T >::get(), edm::Event::getByToken(), edm::HandleBase::isValid(), metsig::muon, edm::Handle< T >::product(), CSCTriggerContainer< T >::push_many(), and testEve_cfg::tracks.

                                                             {
    // Initialize Arrays
   unsigned int nDataMuons = 0;
   unsigned int nEmulMuons = 0;
   int dataMuonArray[8][10], emuMuonArray[8][10];
   for(int muon=0; muon<8; muon++)
   {
     for(int par=0; par<3; par++)
     {
       dataMuonArray[muon][par]=0;
       emuMuonArray[muon][par] =0;
     }
     emuMuonArray[muon][3] =-1;
     dataMuonArray[muon][3]=-1;
         
     emuMuonArray[muon][4]=7;
     dataMuonArray[muon][4]=7;
         
     for(int par2=5; par2<10; par2++)
     {
       emuMuonArray[muon][par2]= -1;
       dataMuonArray[muon][par2]= -1;
     }
   }
     // Get Hardware information, and check output of PtLUT
   if( !dataTrackProducer.isUninitialized())
   {
     Handle<L1CSCTrackCollection> tracks;
     e.getByToken(dataTrackProducer,tracks);
 
     // check validity of input collection
     if(!tracks.isValid()) {
       LogWarning("L1TdeCSCTF")
        << "\n No valid [data tracks] product found: "
            << " L1CSCTrackCollection"
            << endl;
       return;
   }
 
 
   for(L1CSCTrackCollection::const_iterator trk=tracks.product()->begin(); trk!=tracks.product()->end(); trk++)
   {
     if (nDataMuons>=8)
       break;
       if ( (trk->first.BX() <2) && (trk->first.BX() > -1) )
         {
       //int mOdE = (trk->first.ptLUTAddress()>>16)&0xf; 
       //cout << "D->Mode: " << mOdE << ", Rank " << trk->first.rank() << endl;
       dataMuonArray[nDataMuons][0] = trk->first.ptLUTAddress();  
           dataMuonArray[nDataMuons][1] = trk->first.sector();
           dataMuonArray[nDataMuons][2] = trk->first.endcap();
           dataMuonArray[nDataMuons][8] = trk->first.outputLink();
           dataMuonArray[nDataMuons][4] = trk->first.BX();
           dataMuonArray[nDataMuons][5] = trk->first.rank();
           dataMuonArray[nDataMuons][6] = trk->first.localPhi();
           dataMuonArray[nDataMuons][7] = trk->first.eta_packed();
           dataMuonArray[nDataMuons][9] = trk->first.modeExtended();
           nDataMuons++;
         }
     }
   }
   // Get Emulator information
   if( !emulTrackProducer.isUninitialized() )
   {
     Handle<L1CSCTrackCollection> tracks;
     e.getByToken(emulTrackProducer,tracks);
 
     // check validity of input collection
     if(!tracks.isValid()) {
       LogWarning("L1TdeCSCTF")
        << "\n No valid [emulator tracks] product found: "
            << " L1CSCTrackCollection"
            << endl;
       return;
   }
 
   for(L1CSCTrackCollection::const_iterator trk=tracks.product()->begin(); trk!=tracks.product()->end(); trk++)
   {
      if(nEmulMuons>=8)
        break;
        if((trk->first.BX() <2) && (trk->first.BX() >-1))
          {
         //int mOdE = (trk->first.ptLUTAddress()>>16)&0xf; 
         //cout << "E->Mode: " << mOdE << ", Rank " << trk->first.rank() << endl;
         emuMuonArray[nEmulMuons][0] = trk->first.ptLUTAddress();
         emuMuonArray[nEmulMuons][1] = trk->first.sector();
         emuMuonArray[nEmulMuons][2] = trk->first.endcap();
         emuMuonArray[nEmulMuons][4] = trk->first.BX();
         emuMuonArray[nEmulMuons][5] = trk->first.rank();
         emuMuonArray[nEmulMuons][6] = trk->first.localPhi();
         emuMuonArray[nEmulMuons][7] = trk->first.eta_packed();
         emuMuonArray[nEmulMuons][9] = trk->first.modeExtended();
         nEmulMuons++;
      }
     }
   }
     //Fill Occupancy M.E.
   if( (nDataMuons!=0)||(nEmulMuons!=0) ) {
     occComp->Fill(nDataMuons,nEmulMuons);
     (nDataMuons==nEmulMuons) ? occComp_1d->Fill(0) : occComp_1d->Fill(1);
   }
     // Match Tracks by sector & mode in the case of multiple tracks
   if(nDataMuons==nEmulMuons)
   {
     //First, find EXACT address matches in a given sector, endcap
     for(unsigned int mu1=0; mu1<nDataMuons; mu1++)
     {
       for(unsigned int mu2=0; mu2<nEmulMuons; mu2++)
         if((emuMuonArray[mu2][1]==dataMuonArray[mu1][1])&&(emuMuonArray[mu2][2]==dataMuonArray[mu1][2]))
     {
       if(emuMuonArray[mu2][0]==dataMuonArray[mu1][0])
       {
         emuMuonArray[mu2][3]=mu1;
         dataMuonArray[mu1][3]=1;
       }
         }
     }
     //Next, try to match unmapped 
     for(unsigned int c2a=0; c2a<nEmulMuons; c2a++)
     {
       if(emuMuonArray[c2a][3]==-1)
       {
         for(unsigned int cor_a=0; cor_a<nDataMuons; cor_a++)
     {
       if( (dataMuonArray[cor_a][1]==emuMuonArray[c2a][1]) && (dataMuonArray[cor_a][2]==emuMuonArray[c2a][2]))// && (dataMuonArray[cor_a][3]==-1))
       {
         emuMuonArray[c2a][3]=cor_a;
         dataMuonArray[cor_a][3]=1;
       }
     }
       }
     }
     //Check that a single emulator track is not mapped to multiple data tracks
     bool multiMap = false;
     if(nEmulMuons>1)
     {
       for(unsigned int c1a=0; c1a<(nEmulMuons-1); c1a++)
       {
         for(unsigned int c1b=(c1a+1); c1b<nEmulMuons; c1b++)
         {
           if(emuMuonArray[c1a][3]==emuMuonArray[c1b][3])
           {
         //cout << "Error: Multiple Emulator Muons Mapped to the same Data Muon." << endl;
         multiMap = true;
         break;
       }
     }
     if (multiMap)
       break;
       }
     }
     //Fill histograms based on matched Tracks
     for(unsigned int mu3=0; mu3<nEmulMuons; mu3++)
     {
       int mapping = emuMuonArray[mu3][3];
       if((mapping!=-1)&&(multiMap==false))
       {
     //Decode LUT Address for more meaningful comparison
     int emuPhi12 = (0x0000ff & emuMuonArray[mu3][0]);
     int datPhi12 = (0x0000ff & dataMuonArray[mapping][0]);
     int emuPhi23 = (0x000f00 & emuMuonArray[mu3][0])>>8;
     int datPhi23 = (0x000f00 & dataMuonArray[mapping][0])>>8;
     int emuEta   = (0x00f000 & emuMuonArray[mu3][0])>>12;
     int datEta   = (0x00f000 & dataMuonArray[mapping][0])>>12;
     //int emuMode = (0x0f0000 & emuMuonArray[mu3][0])>>16;
     //int datMode = (0x0f0000 & dataMuonArray[mapping][0])>>16;
         int emuFrSin = (0xf00000 & emuMuonArray[mu3][0])>>20;
         int datFrSin = (0xf00000 & dataMuonArray[mapping][0])>>20;
     //Decode Rank for more meaningful comparison
         int emuQual  = emuMuonArray[mu3][5]>>5;
         int datQual  = dataMuonArray[mapping][5]>>5;
         int emuPt    = 0x1f & emuMuonArray[mu3][5];
         int datPt    = 0x1f & dataMuonArray[mapping][5];
         int emuModeExtended = emuMuonArray[mu3][9];
         int datModeExtended = dataMuonArray[mapping][9];
                 
         //Fill mode M.E., one of (the most important) PtLUT address field
         pt4Comp->Fill(datModeExtended,emuModeExtended);
         (datModeExtended==emuModeExtended) ? pt4Comp_1d->Fill(0) : pt4Comp_1d->Fill(1);
         //To disentagle problems, only fill histograms if mode matches
     if(emuModeExtended==datModeExtended)
     {
       //Fill Pt LUT address field M.E.
       pt1Comp->Fill(datPhi12,emuPhi12); (datPhi12==emuPhi12) ? pt1Comp_1d->Fill(0) : pt1Comp_1d->Fill(1);
       pt2Comp->Fill(datPhi23,emuPhi23); (datPhi23==emuPhi23) ? pt2Comp_1d->Fill(0) : pt2Comp_1d->Fill(1);
       pt3Comp->Fill(datEta,emuEta);     (datEta==emuEta)     ? pt3Comp_1d->Fill(0) : pt3Comp_1d->Fill(1);
       pt5Comp->Fill(datFrSin,emuFrSin); (datFrSin==emuFrSin) ? pt5Comp_1d->Fill(0) : pt5Comp_1d->Fill(1);
                     //Fill Track value M.E.
       if(dataMuonArray[mapping][8]==1) //Rank Comparison available for Link 1 only due to readout limitation
       {
         ptComp->Fill(datPt,emuPt);      (datPt==emuPt)     ? ptComp_1d->Fill(0)   : ptComp_1d->Fill(1);
         qualComp->Fill(datQual,emuQual);(datQual==emuQual) ? qualComp_1d->Fill(0) : qualComp_1d->Fill(1);
           }
           phiComp->Fill(dataMuonArray[mapping][6],emuMuonArray[mu3][6]);
           etaComp->Fill(dataMuonArray[mapping][7],emuMuonArray[mu3][7]);
 
           (dataMuonArray[mapping][6]==emuMuonArray[mu3][6]) ? phiComp_1d->Fill(0) : phiComp_1d->Fill(1); 
           (dataMuonArray[mapping][7]==emuMuonArray[mu3][7]) ? etaComp_1d->Fill(0) : etaComp_1d->Fill(1);
         }
       }
     }
   }
     
   //Compare DT stubs to check transmission quality
   //Declare arrays, initialize
   int eDtStub[7][15];
   int dDtStub[8][15];
   int eDtCounter = 0;
   int dDtCounter = 0;
   for(int dJ=0; dJ<7; dJ++)
   {
     for(int dK=0; dK<15; dK++)
     {
       eDtStub[dJ][dK] = -55;
       dDtStub[dJ][dK] = -55;
       dDtStub[7][dK] = -55;
     }
   }
     
   // Get Daq Recorded Stub Information
   if( !dataStubProducer.isUninitialized() )
   {
     Handle<CSCTriggerContainer<csctf::TrackStub> > dtTrig;
     e.getByToken(dataStubProducer,dtTrig);
     // check validity of input collection
     if(!dtTrig.isValid()) {
       LogWarning("L1TdeCSCTF")
              << "\n No valid [Data Stubs] product found: "
              << " L1CSCTrackCollection"
              << endl;
       return;
     }
     const CSCTriggerContainer<csctf::TrackStub>* dt_stubs = dtTrig.product();
     CSCTriggerContainer<csctf::TrackStub> stub_list;
     stub_list.push_many(*dt_stubs);
     vector<csctf::TrackStub> stuList = stub_list.get();
     vector<csctf::TrackStub>::const_iterator stu= stuList.begin();
     for(; stu!=stuList.end(); stu++)
     {
       if(dDtCounter>=15)
         break;
         if((stu->BX()>4) && (stu->BX()<9))
         {
           dDtStub[0][dDtCounter] = stu->phiPacked();
       dDtStub[1][dDtCounter] = stu->getQuality();
       dDtStub[2][dDtCounter] = stu->endcap();
       dDtStub[3][dDtCounter] = stu->sector();
       dDtStub[4][dDtCounter] = stu->subsector();
       dDtCounter++;
     }
     }
   }
     
   // Get Daq Recorded Stub Information
   if( !emulStubProducer.isUninitialized() )
   {
       // Get Emulated Stub Information
     Handle<L1MuDTChambPhContainer> pCon;
     e.getByToken(emulStubProducer,pCon);
     // check validity of input collection
     if(!pCon.isValid()) {
       LogWarning("L1TdeCSCTF")
            << "\n No valid [Data Stubs] product found: "
            << " L1CSCTrackCollection"
            << endl;
       return;
     }
     CSCTriggerContainer<csctf::TrackStub> emulStub = my_dtrc->process(pCon.product());
     vector<csctf::TrackStub> emuList = emulStub.get();
     vector<csctf::TrackStub>::const_iterator eStu=emuList.begin();
     for(; eStu!=emuList.end(); eStu++)
     {       
       if (eDtCounter>=15)
         break;
     if((eStu->BX()>4) && (eStu->BX()<9) )
     {
       eDtStub[0][eDtCounter] = eStu->phiPacked();
       eDtStub[1][eDtCounter] = eStu->getQuality();
       eDtStub[2][eDtCounter] = eStu->endcap();
       eDtStub[3][eDtCounter] = eStu->sector();
       eDtStub[4][eDtCounter] = eStu->subsector();
       eDtCounter++;
     }
     }
   }
     
   //cout << "Num Tracks match eDtCounter: " << eDtCounter << ", dDt: " << dDtCounter << endl;
   //First find perfect matches
   for(int eS=0; eS<eDtCounter; eS++)
   {
     //cout << "es Loop" <<  endl;
     for(int dS=0; dS<dDtCounter; dS++)
     {
       //cout << "ds Loop" << endl;
       if(eDtStub[2][eS]==dDtStub[2][dS])
       {
         //cout << "end match" << endl;
     if(eDtStub[3][eS]==dDtStub[3][dS])
     {
       //cout << "sec match" << endl;
       if(eDtStub[4][eS]==dDtStub[4][dS]) 
       {
         //cout << "First match loop, eS: " << eS << ", dS" << dS << endl;
             if( (eDtStub[0][eS]==dDtStub[0][dS]) && (eDtStub[1][eS]==dDtStub[1][dS]) && (eDtStub[6][eS]!=1) && (dDtStub[6][dS]!=1) )
             {
               //cout << "Passed fist matching." << endl;
               eDtStub[5][eS] = dS;
           eDtStub[6][eS] = 1;
           dDtStub[5][dS] = eS;
           dDtStub[6][dS] = 1;
         }
       }
     }
       }
     }
   }
 
   //Now find imperfect matches
   for(int eS2=0; eS2<eDtCounter; eS2++)
   {
     for(int dS2=0; dS2<dDtCounter; dS2++)
     {
             //cout << "1: " << eDtStub[2][eS2] << ", " << dDtStub[2][dS2] << ", " << eDtStub[3][eS2] << ", " << dDtStub[3][dS2] << ", " << eDtStub[4][eS2] << ", " << dDtStub[4][dS2] << endl;
       if( (eDtStub[2][eS2]==dDtStub[2][dS2]) && (eDtStub[3][eS2]==dDtStub[3][dS2]) && (eDtStub[4][eS2]==dDtStub[4][dS2]) )
       {
                 //cout << "2: " << dDtStub[7][eS2] << ", " << dDtStub[7][dS2] << ", " << abs(eDtStub[0][eS2]-dDtStub[0][dS2]) << ", " << ", " << eDtStub[6][eS2] << ", " << dDtStub[6][dS2] << endl;
         if( ((dDtStub[7][eS2]==-55) || (dDtStub[7][dS2]>(abs(eDtStub[0][eS2]-dDtStub[0][dS2]))) ) && (eDtStub[6][eS2]!=1) && (dDtStub[6][dS2]!=1)  )
         {
           //cout << "Imperfect match found" << endl;
           dDtStub[5][dS2] = eS2;
           dDtStub[6][dS2] = 2;
           eDtStub[5][eS2] = dS2;
           eDtStub[6][eS2] = 2;
           dDtStub[7][dS2] = abs(eDtStub[0][eS2]-dDtStub[0][dS2]);
         }
       }
     }
   }
         
   //Debug time!
   bool dtSMulti = false;
   int dtUnmap  = 0;
   if(eDtCounter>1)
     for(int eS3a=0; eS3a<eDtCounter-1; eS3a++)
       for(int eS3b=eS3a+1; eS3b<eDtCounter; eS3b++)
       {
         if( eDtStub[5][eS3a]==eDtStub[5][eS3b] ) dtSMulti=true;
         if( eDtStub[5][eS3a]==-55 || eDtStub[5][eS3b]==-55 ) dtUnmap++;
       }
                 
   if(dDtCounter>1)
     for(int dS3a=0; dS3a<dDtCounter-1; dS3a++)
       for(int dS3b=dS3a+1; dS3b<dDtCounter; dS3b++)
       {
         if( dDtStub[5][dS3a]==dDtStub[5][dS3b] ) dtSMulti=true;
         if( dDtStub[5][dS3a]==-55||dDtStub[5][dS3b]==-55 ) dtUnmap++;
       }
     /*if(dtSMulti==true)
         cout << "Multiple DT stubs mapped to the same stub" << endl;
     if(dtUnmap!=0)
         cout << "Unmapped DT stubs:" << dtUnmap << endl;*/
     
   if(dtSMulti==false && dtUnmap==0)
   {
     for(int phil=0; phil<eDtCounter; phil++)
     {
       if(eDtStub[6][phil]==1 || eDtStub[6][phil]==2)
       {
         int indexFil = eDtStub[3][phil]*2+eDtStub[4][phil]-1;
         dtStubPhi->Fill(eDtStub[0][phil],  dDtStub[0][ eDtStub[5][phil] ]);
         (eDtStub[0][phil] ==  dDtStub[0][ eDtStub[5][phil] ]) ? dtStubPhi_1d->Fill(0) : dtStubPhi_1d->Fill(1);
         if( eDtStub[0][phil] != dDtStub[0][ eDtStub[5][phil] ])
                     badDtStubSector->Fill(indexFil,eDtStub[2][phil]);
       }
     }
   }
   if(ptLUT_) delete ptLUT_;
 }       

void L1TdeCSCTF::beginLuminosityBlock	(	edm::LuminosityBlock const &	l,
		edm::EventSetup const &	c
	)

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 98 of file L1TdeCSCTF.cc.

98 {

99 }

void L1TdeCSCTF::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotectedvirtual

Implements thread_unsafe::DQMEDAnalyzer.

Definition at line 101 of file L1TdeCSCTF.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), MonitorElement::setAxisTitle(), and DQMStore::IBooker::setCurrentFolder().

 {
   //Histograms booking
 
   // DQM Directory Structure //
   
   ibooker.setCurrentFolder(m_dirName);
 
   // Define Monitor Elements //
   //Monitor Elements for Pt Lut Address Field
   pt1Comp = ibooker.book2D("pt1Comp","Hardware Vs. Emulator #Delta #phi_{12}",256,0,256,256,0,256);
   pt1Comp->setAxisTitle("Hardware #Delta #phi_{12}",1);
   pt1Comp->setAxisTitle("Emulator #Delta #phi_{12}",2);
   pt2Comp = ibooker.book2D("pt2Comp","Hardware Vs. Emulator #Delta #phi_{23}",16,0,16,16,0,16);
   pt2Comp->setAxisTitle("Hardware #Delta #phi_{23}",1);
   pt2Comp->setAxisTitle("Emulator #Delta #phi_{23}",2);
   pt3Comp = ibooker.book2D("pt3Comp","Hardware Vs. Emulator #eta",16,0,16,16,0,16);
   pt3Comp->setAxisTitle("Hardware #eta",1);
   pt3Comp->setAxisTitle("Emulator #eta",2);
   pt4Comp = ibooker.book2D("pt4Comp","Hardware Vs. Emulator Mode",19,0,19,19,0,19);
   pt4Comp->setAxisTitle("Hardware Mode",1);
   pt4Comp->setAxisTitle("Emulator Mode",2);
   //Hardware Bin Titles
   pt4Comp->setBinLabel(1,"No Track",1);
   pt4Comp->setBinLabel(2,"Bad Phi/Single",1);
   pt4Comp->setBinLabel(3,"ME1-2-3",1);
   pt4Comp->setBinLabel(4,"ME1-2-4",1);
   pt4Comp->setBinLabel(5,"ME1-3-4",1);
   pt4Comp->setBinLabel(6,"ME2-3-4",1);
   pt4Comp->setBinLabel(7,"ME1-2",1);
   pt4Comp->setBinLabel(8,"ME1-3",1);
   pt4Comp->setBinLabel(9,"ME2-3",1);
   pt4Comp->setBinLabel(10,"ME2-4",1);
   pt4Comp->setBinLabel(11,"ME3-4",1);
   pt4Comp->setBinLabel(12,"MB1-ME3",1);
   pt4Comp->setBinLabel(13,"MB1-ME2",1);
   pt4Comp->setBinLabel(14,"ME1-4",1);
   pt4Comp->setBinLabel(15,"MB1-ME1",1);
   pt4Comp->setBinLabel(16,"Halo Trigger",1);
   pt4Comp->setBinLabel(17,"MB1-ME1-2",1);
   pt4Comp->setBinLabel(18,"MB1-ME1-3",1);
   pt4Comp->setBinLabel(19,"MB1-ME2-3",1);
   //Emu Bin Titles
   pt4Comp->setBinLabel(1,"No Track",2);
   pt4Comp->setBinLabel(2,"Bad Phi/Single",2);
   pt4Comp->setBinLabel(3,"ME1-2-3",2);
   pt4Comp->setBinLabel(4,"ME1-2-4",2);
   pt4Comp->setBinLabel(5,"ME1-3-4",2);
   pt4Comp->setBinLabel(6,"ME2-3-4",2);
   pt4Comp->setBinLabel(7,"ME1-2",2);
   pt4Comp->setBinLabel(8,"ME1-3",2);
   pt4Comp->setBinLabel(9,"ME2-3",2);
   pt4Comp->setBinLabel(10,"ME2-4",2);
   pt4Comp->setBinLabel(11,"ME3-4",2);
   pt4Comp->setBinLabel(12,"MB1-ME3",2);
   pt4Comp->setBinLabel(13,"MB1-ME2",2);
   pt4Comp->setBinLabel(14,"ME1-4",2);
   pt4Comp->setBinLabel(15,"MB1-ME1",2);
   pt4Comp->setBinLabel(16,"Halo Trigger",2);
   pt4Comp->setBinLabel(17,"MB1-ME1-2",2);
   pt4Comp->setBinLabel(18,"MB1-ME1-3",2);
   pt4Comp->setBinLabel(19,"MB1-ME2-3",2);
 
   pt5Comp = ibooker.book2D("pt5Comp","Hardware Vs. Emulator Sign, FR",4,0,4,4,0,4);
   pt5Comp->setAxisTitle("Hardware Sign<<1|FR",1);
   pt5Comp->setAxisTitle("Emulator Sign<<1|FR",2);
         
   //Monitor Elements for track variables
   phiComp = ibooker.book2D("phiComp","Hardware Vs. Emulator Track #phi",32,0,32,32,0,32);
   phiComp->setAxisTitle("Hardware #phi",1);
   phiComp->setAxisTitle("Emulator #phi",2);
   etaComp = ibooker.book2D("etaComp","Hardware Vs. Emulator Track #eta",32,0,32,32,0,32);
   etaComp->setAxisTitle("Hardware #eta",1);
   etaComp->setAxisTitle("Emulator #eta",2);
   occComp = ibooker.book2D("occComp","Hardware Vs. Emulator Track Occupancy",5,0,5,5,0,5);
   occComp->setAxisTitle("Hardware Occupancy",1);
   occComp->setAxisTitle("Emulator Occupancy",2);
   ptComp  = ibooker.book2D("ptComp","Hardware Vs. Emulator Pt",32,0,32,32,0,32);
   ptComp->setAxisTitle("Hardware P_{t}",1);
   ptComp->setAxisTitle("Emulator P_{t}",2);
   qualComp= ibooker.book2D("qualComp","Hardware Vs. Emulator Quality",4,0,4,4,0,4);
   qualComp->setAxisTitle("Hardware Quality",1);
   qualComp->setAxisTitle("Emulator Quality",2);
         
         
   //Monitor Elemens for Dt Stubs
   dtStubPhi = ibooker.book2D("dtStubPhi","Hardware Vs. Emulator DT Stub #phi",200,400,2400,200,400,2400);
   dtStubPhi->setAxisTitle("Hardware Stub #phi",1);
   dtStubPhi->setAxisTitle("Emulator Stub #phi",2);
   badDtStubSector = ibooker.book2D("badDtStubSector","Dt Sector for bad Dt stub #phi",6,1,7,2,1,3);
   badDtStubSector->setAxisTitle("Dt stub sector, subsector",1);
   badDtStubSector->setAxisTitle("Dt Stub Endcap",2);
 
   //***********************************//
   //* F O R   Q U A L I T Y   T E S T *//
   //***********************************//
   //1D plots for the quality test
   //Monitor Elements for Pt Lut Address Field
   pt1Comp_1d = ibooker.book1D("pt1Comp_1d","Hardware Vs. Emulator #Delta #phi_{12}",2,0,2);
   pt1Comp_1d->setAxisTitle("#Delta #phi_{12}",1);
   pt1Comp_1d->setBinLabel(1, "Agree", 1);
   pt1Comp_1d->setBinLabel(2, "Disagree", 1);
 
   pt2Comp_1d = ibooker.book1D("pt2Comp_1d","Hardware Vs. Emulator #Delta #phi_{23}",2,0,2);
   pt2Comp_1d->setAxisTitle("#Delta #phi_{23}",1);
   pt2Comp_1d->setBinLabel(1, "Agree", 1);
   pt2Comp_1d->setBinLabel(2, "Disagree", 1);
 
   pt3Comp_1d = ibooker.book1D("pt3Comp_1d","Hardware Vs. Emulator #eta",2,0,2);
   pt3Comp_1d->setAxisTitle("#eta",1);
   pt3Comp_1d->setBinLabel(1, "Agree", 1);
   pt3Comp_1d->setBinLabel(2, "Disagree", 1);
 
   pt4Comp_1d = ibooker.book1D("pt4Comp_1d","Hardware Vs. Emulator Mode",2,0,2);
   pt4Comp_1d->setAxisTitle("Mode",1);
   pt4Comp_1d->setBinLabel(1, "Agree", 1);
   pt4Comp_1d->setBinLabel(2, "Disagree", 1);
 
   pt5Comp_1d = ibooker.book1D("pt5Comp_1d","Hardware Vs. Emulator Sign, FR",2,0,2);
   pt5Comp_1d->setAxisTitle("Sign<<1|FR",1);
   pt5Comp_1d->setBinLabel(1, "Agree", 1);
   pt5Comp_1d->setBinLabel(2, "Disagree", 1);
                
         
   //Monitor Elements for track variables
   phiComp_1d = ibooker.book1D("phiComp_1d","Hardware Vs. Emulator Track #phi",2,0,2);
   phiComp_1d->setAxisTitle("#phi",1);
   phiComp_1d->setBinLabel(1, "Agree", 1);
   phiComp_1d->setBinLabel(2, "Disagree", 1);
 
   etaComp_1d = ibooker.book1D("etaComp_1d","Hardware Vs. Emulator Track #eta",2,0,2);
   etaComp_1d->setAxisTitle("#eta",1);
   etaComp_1d->setBinLabel(1, "Agree", 1);
   etaComp_1d->setBinLabel(2, "Disagree", 1);
 
   occComp_1d = ibooker.book1D("occComp_1d","Hardware Vs. Emulator Track Occupancy",2,0,2);
   occComp_1d->setAxisTitle("Occupancy",1);
   occComp_1d->setBinLabel(1, "Agree", 1);
   occComp_1d->setBinLabel(2, "Disagree", 1);
 
   ptComp_1d  = ibooker.book1D("ptComp_1d","Hardware Vs. Emulator Pt",2,0,2);
   ptComp_1d->setAxisTitle("P_{t}",1);
   ptComp_1d->setBinLabel(1, "Agree", 1);
   ptComp_1d->setBinLabel(2, "Disagree", 1);
 
   qualComp_1d= ibooker.book1D("qualComp_1d","Hardware Vs. Emulator Quality",2,0,2);
   qualComp_1d->setAxisTitle("Quality",1);
   qualComp_1d->setBinLabel(1, "Agree", 1);
   qualComp_1d->setBinLabel(2, "Disagree", 1);
 
   //Monitor Elemens for Dt Stubs
   dtStubPhi_1d = ibooker.book1D("dtStubPhi_1d","Hardware Vs. Emulator DT Stub #phi",2,0,2);
   dtStubPhi_1d->setAxisTitle("DT Stub #phi",1);
   dtStubPhi_1d->setBinLabel(1, "Agree", 1);
   dtStubPhi_1d->setBinLabel(2, "Disagree", 1); 
 }

void L1TdeCSCTF::dqmBeginRun	(	edm::Run const &	r,
		edm::EventSetup const &	c
	)

protectedvirtual

Reimplemented from thread_unsafe::DQMEDAnalyzer.

Definition at line 95 of file L1TdeCSCTF.cc.

95 {

96 }

Member Data Documentation

MonitorElement * L1TdeCSCTF::badDtStubSector

private

Definition at line 58 of file L1TdeCSCTF.h.

edm::EDGetTokenT<CSCTriggerContainer<csctf::TrackStub> > L1TdeCSCTF::dataStubProducer

private

Definition at line 46 of file L1TdeCSCTF.h.

edm::EDGetTokenT<L1CSCTrackCollection> L1TdeCSCTF::dataTrackProducer

private

Definition at line 44 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::dtStubPhi

private

Definition at line 58 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::dtStubPhi_1d

private

Definition at line 62 of file L1TdeCSCTF.h.

edm::EDGetTokenT<L1MuDTChambPhContainer> L1TdeCSCTF::emulStubProducer

private

Definition at line 47 of file L1TdeCSCTF.h.

edm::EDGetTokenT<L1CSCTrackCollection> L1TdeCSCTF::emulTrackProducer

private

Definition at line 45 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::etaComp

private

Definition at line 56 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::etaComp_1d

private

Definition at line 60 of file L1TdeCSCTF.h.

std::string L1TdeCSCTF::m_dirName

private

Definition at line 66 of file L1TdeCSCTF.h.

CSCTFDTReceiver* L1TdeCSCTF::my_dtrc

private

Definition at line 52 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::occComp

private

Definition at line 56 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::occComp_1d

private

Definition at line 60 of file L1TdeCSCTF.h.

std::string L1TdeCSCTF::outFile

private

Definition at line 67 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::phiComp

private

Definition at line 56 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::phiComp_1d

private

Definition at line 60 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::pt1Comp

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::pt1Comp_1d

private

Definition at line 61 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt2Comp

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt2Comp_1d

private

Definition at line 61 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt3Comp

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt3Comp_1d

private

Definition at line 61 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt4Comp

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt4Comp_1d

private

Definition at line 61 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt5Comp

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt5Comp_1d

private

Definition at line 61 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt6Comp

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt6Comp_1d

private

Definition at line 61 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::ptComp

private

Definition at line 56 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::ptComp_1d

private

Definition at line 60 of file L1TdeCSCTF.h.

CSCTFPtLUT* L1TdeCSCTF::ptLUT_

private

Definition at line 50 of file L1TdeCSCTF.h.

edm::ParameterSet L1TdeCSCTF::ptLUTset

private

Definition at line 51 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::qualComp

private

Definition at line 56 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::qualComp_1d

private

Definition at line 60 of file L1TdeCSCTF.h.

const L1MuTriggerScales* L1TdeCSCTF::ts

private

Definition at line 49 of file L1TdeCSCTF.h.

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation