L1TdeCSCTF Class Reference

#include <L1TdeCSCTF.h>

Inheritance diagram for L1TdeCSCTF:

Public Member Functions
	L1TdeCSCTF (edm::ParameterSet const &pset)
	~L1TdeCSCTF () override
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &iSetup) override
void	bookHistograms (DQMStore::IBooker &ibooker, edm::Run const &, edm::EventSetup const &) override
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

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
std::unique_ptr< 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
edm::ParameterSet	ptLUTset
MonitorElement *	qualComp
MonitorElement *	qualComp_1d

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T...>
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T...>
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr < DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Definition at line 40 of file L1TdeCSCTF.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 37 of file L1TdeCSCTF.cc.

References edm::ParameterSet::empty(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and produceTPGParameters_beamv6_transparency_spikekill_2016_script::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"));

  ptLUTset = pset.getParameter<ParameterSet>("PTLUT");

  outFile = pset.getUntrackedParameter<string>("outFile", "");
  if (!outFile.empty()) {
    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 = std::make_unique<CSCTFDTReceiver>();
}

L1TdeCSCTF::~L1TdeCSCTF ( )

inlineoverride

Definition at line 71 of file L1TdeCSCTF.h.

{}

Member Function Documentation

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 243 of file L1TdeCSCTF.cc.

References funct::abs(), CSCTriggerContainer< T >::get(), edm::Event::getByToken(), edm::HandleBase::isValid(), HLT_FULL_cff::muon, edm::Handle< T >::product(), CSCTriggerContainer< T >::push_many(), and 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]);
      }
    }
  }
}

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 85 of file L1TdeCSCTF.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::impl::MonitorElement::setAxisTitle(), and dqm::implementation::NavigatorBase::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);
}

Member Data Documentation

MonitorElement * L1TdeCSCTF::badDtStubSector

private

Definition at line 54 of file L1TdeCSCTF.h.

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

private

Definition at line 44 of file L1TdeCSCTF.h.

edm::EDGetTokenT<L1CSCTrackCollection> L1TdeCSCTF::dataTrackProducer

private

Definition at line 42 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::dtStubPhi

private

Definition at line 54 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::dtStubPhi_1d

private

Definition at line 58 of file L1TdeCSCTF.h.

edm::EDGetTokenT<L1MuDTChambPhContainer> L1TdeCSCTF::emulStubProducer

private

Definition at line 45 of file L1TdeCSCTF.h.

edm::EDGetTokenT<L1CSCTrackCollection> L1TdeCSCTF::emulTrackProducer

private

Definition at line 43 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::etaComp

private

Definition at line 52 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::etaComp_1d

private

Definition at line 56 of file L1TdeCSCTF.h.

std::string L1TdeCSCTF::m_dirName

private

Definition at line 62 of file L1TdeCSCTF.h.

std::unique_ptr<CSCTFDTReceiver> L1TdeCSCTF::my_dtrc

private

Definition at line 48 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::occComp

private

Definition at line 52 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::occComp_1d

private

Definition at line 56 of file L1TdeCSCTF.h.

std::string L1TdeCSCTF::outFile

private

Definition at line 63 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::phiComp

private

Definition at line 52 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::phiComp_1d

private

Definition at line 56 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::pt1Comp

private

Definition at line 53 of file L1TdeCSCTF.h.

MonitorElement* L1TdeCSCTF::pt1Comp_1d

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt2Comp

private

Definition at line 53 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt2Comp_1d

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt3Comp

private

Definition at line 53 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt3Comp_1d

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt4Comp

private

Definition at line 53 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt4Comp_1d

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt5Comp

private

Definition at line 53 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt5Comp_1d

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt6Comp

private

Definition at line 53 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::pt6Comp_1d

private

Definition at line 57 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::ptComp

private

Definition at line 52 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::ptComp_1d

private

Definition at line 56 of file L1TdeCSCTF.h.

edm::ParameterSet L1TdeCSCTF::ptLUTset

private

Definition at line 47 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::qualComp

private

Definition at line 52 of file L1TdeCSCTF.h.

MonitorElement * L1TdeCSCTF::qualComp_1d

private

Definition at line 56 of file L1TdeCSCTF.h.