CSCTriggerPrimitivesReader Class Reference

#include <CSCTriggerPrimitivesReader.h>

Inheritance diagram for CSCTriggerPrimitivesReader:

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &setup)
	Does the job. More...
int	chamberIX (CSCDetId id)
int	chamberIXi (CSCDetId id)
int	chamberSerial (CSCDetId id)
	CSCTriggerPrimitivesReader (const edm::ParameterSet &conf)
	Constructor. More...
void	endJob ()
	Write to ROOT file, make plots, etc. More...
void	HotWires (const edm::Event &iEvent)
virtual	~CSCTriggerPrimitivesReader ()
	Destructor. More...
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
	~EDAnalyzer () 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
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
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)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Private Types
enum	{ MAXPAGES = 20 }
enum	trig_cscs { MAX_ENDCAPS = 2, MAX_STATIONS = 4, CSC_TYPES = 10 }

Private Member Functions
void	bookALCTHistos ()
void	bookCLCTHistos ()
void	bookCompHistos ()
void	bookEfficHistos ()
void	bookHotWireHistos ()
void	bookLCTMPCHistos ()
void	bookLCTTMBHistos ()
void	bookResolHistos ()
void	calcEfficiency (const CSCALCTDigiCollection *alcts, const CSCCLCTDigiCollection *clcts, const edm::PSimHitContainer &allSimHits)
void	calcResolution (const CSCALCTDigiCollection *alcts, const CSCCLCTDigiCollection *clcts, const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const edm::PSimHitContainer &allSimHits)
void	compare (const CSCALCTDigiCollection *alcts_data, const CSCALCTDigiCollection *alcts_emul, const CSCCLCTDigiCollection *clcts_data, const CSCCLCTDigiCollection *clcts_emul, const CSCCLCTPreTriggerDigiCollection *pretrigs_emul, const CSCCorrelatedLCTDigiCollection *lcts_data, const CSCCorrelatedLCTDigiCollection *lcts_emul)
void	compareALCTs (const CSCALCTDigiCollection *alcts_data, const CSCALCTDigiCollection *alcts_emul)
void	compareCLCTs (const CSCCLCTDigiCollection *clcts_data, const CSCCLCTDigiCollection *clcts_emul, const CSCCLCTPreTriggerDigiCollection *pretrigs_emul)
void	compareLCTs (const CSCCorrelatedLCTDigiCollection *lcts_data, const CSCCorrelatedLCTDigiCollection *lcts_emul, const CSCALCTDigiCollection *alcts_data, const CSCCLCTDigiCollection *clcts_data)
void	compareMPCLCTs (const CSCCorrelatedLCTDigiCollection *lcts_data, const CSCCorrelatedLCTDigiCollection *lcts_emul, const CSCALCTDigiCollection *alcts_data, const CSCCLCTDigiCollection *clcts_data)
int	convertBXofLCT (const int emul_bx, const CSCDetId &detid, const CSCALCTDigiCollection *alcts_data, const CSCCLCTDigiCollection *clcts_data)
bool	doesALCTCrossCLCT (CSCDetId id, int key_wg, int key_hs) const
void	drawALCTHistos ()
void	drawCLCTHistos ()
void	drawCompHistos ()
void	drawEfficHistos ()
void	drawHistosForTalks ()
void	drawLCTMPCHistos ()
void	drawLCTTMBHistos ()
void	drawResolHistos ()
void	fillALCTHistos (const CSCALCTDigiCollection *alcts)
void	fillCLCTHistos (const CSCCLCTDigiCollection *clcts)
void	fillLCTMPCHistos (const CSCCorrelatedLCTDigiCollection *lcts)
void	fillLCTTMBHistos (const CSCCorrelatedLCTDigiCollection *lcts)
int	getCSCType (const CSCDetId &id)
GlobalPoint	getGlobalPosition (unsigned int rawId, int keWg, int keyHS) const
double	getHsPerRad (const int idh)
int	maxRing (int station)
void	MCStudies (const edm::Event &ev, const CSCALCTDigiCollection *alcts, const CSCCLCTDigiCollection *clcts)
void	setRootStyle ()

Private Attributes
edm::EDGetTokenT< CSCALCTDigiCollection >	alcts_d_token_
edm::EDGetTokenT< CSCALCTDigiCollection >	alcts_e_token_
const CSCBadChambers *	badChambers_
bool	checkBadChambers_
edm::EDGetTokenT< CSCCLCTDigiCollection >	clcts_d_token_
edm::EDGetTokenT< CSCCLCTDigiCollection >	clcts_e_token_
edm::EDGetTokenT< CSCComparatorDigiCollection >	compDigi_token_
edm::InputTag	compDigiProducer_
bool	dataIsAnotherMC_
bool	dataLctsIn_
bool	debug
bool	emulLctsIn_
int	Event_
TTree *	event_tree [6]
int	eventsAnalyzed
bool	gangedME1a
const CSCGeometry *	geom_
TH1F *	hAlctAccel
TH1F *	hAlctBXN
TH1F *	hAlctCollis
TH1F *	hAlctCompFound
TH2F *	hAlctCompFound2
TH2F *	hAlctCompFound2i
TH2F *	hAlctCompFound2x
TH1F *	hAlctCompFoundCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hAlctCompMatch
TH2F *	hAlctCompMatch2
TH2F *	hAlctCompMatch2i
TH2F *	hAlctCompMatch2x
TH1F *	hAlctCompMatchCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hAlctCompSameN
TH2F *	hAlctCompSameN2
TH2F *	hAlctCompSameN2i
TH2F *	hAlctCompSameN2x
TH1F *	hAlctCompSameNCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hAlctCompTotal
TH2F *	hAlctCompTotal2
TH2F *	hAlctCompTotal2i
TH2F *	hAlctCompTotal2x
TH1F *	hAlctCompTotalCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hAlctCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hAlctKeyGroup
TH1F *	hAlctKeyGroupME11
TH1F *	hAlctPerChamber
TH1F *	hAlctPerCSC
TH1F *	hAlctPerEvent
TH1F *	hAlctQuality
TH1F *	hAlctValid
TH1F *	hAlctVsEta [MAX_STATIONS]
TH1F *	hClctBendCsc [CSC_TYPES][2]
TH1F *	hClctBXN
TH1F *	hClctCFEB
TH1F *	hClctCompFound
TH2F *	hClctCompFound2
TH2F *	hClctCompFound2i
TH2F *	hClctCompFound2x
TH1F *	hClctCompFoundCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hClctCompMatch
TH2F *	hClctCompMatch2
TH2F *	hClctCompMatch2i
TH2F *	hClctCompMatch2x
TH1F *	hClctCompMatchCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hClctCompSameN
TH2F *	hClctCompSameN2
TH2F *	hClctCompSameN2i
TH2F *	hClctCompSameN2x
TH1F *	hClctCompSameNCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hClctCompTotal
TH2F *	hClctCompTotal2
TH2F *	hClctCompTotal2i
TH2F *	hClctCompTotal2x
TH1F *	hClctCompTotalCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hClctCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hClctKeyStrip [2]
TH1F *	hClctKeyStripCsc [CSC_TYPES]
TH1F *	hClctKeyStripME11
TH1F *	hClctPattern [2]
TH1F *	hClctPerChamber
TH1F *	hClctPerCSC
TH1F *	hClctPerEvent
TH1F *	hClctQuality
TH1F *	hClctSign
TH1F *	hClctStripType
TH1F *	hClctValid
TH1F *	hClctVsPhi [MAX_STATIONS]
TH1F *	hCorrLctMPCPerCSC
TH1F *	hCorrLctTMBPerCSC
TH1F *	hEfficALCTEta [MAX_STATIONS]
TH1F *	hEfficALCTEtaCsc [CSC_TYPES]
TH1F *	hEfficCLCTEta [MAX_STATIONS]
TH1F *	hEfficCLCTEtaCsc [CSC_TYPES]
TH1F *	hEfficHitsEta [MAX_STATIONS]
TH1F *	hEfficHitsEtaCsc [CSC_TYPES]
TH1F *	hEtaDiffCsc [CSC_TYPES][3]
TH1F *	hEtaDiffVsEta [MAX_STATIONS]
TH2F *	hEtaDiffVsWireCsc [CSC_TYPES]
TH2F *	hEtaRecVsSim
TH1F *	hHotCham1
TH1F *	hHotWire1
TH1F *	hLCTCompFound
TH2F *	hLCTCompFound2
TH2F *	hLCTCompFound2i
TH2F *	hLCTCompFound2x
TH1F *	hLctCompFoundCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hLCTCompMatch
TH2F *	hLCTCompMatch2
TH2F *	hLCTCompMatch2i
TH2F *	hLCTCompMatch2x
TH1F *	hLctCompMatchCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hLCTCompSameN
TH2F *	hLCTCompSameN2
TH2F *	hLCTCompSameN2i
TH2F *	hLCTCompSameN2x
TH1F *	hLctCompSameNCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hLCTCompTotal
TH2F *	hLCTCompTotal2
TH2F *	hLCTCompTotal2i
TH2F *	hLCTCompTotal2x
TH1F *	hLctCompTotalCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hLctMPCBend
TH1F *	hLctMPCBXN
TH1F *	hLctMPCChamber [MAX_STATIONS]
TH1F *	hLctMPCEndcap
TH1F *	hLctMPCKeyGroup
TH1F *	hLctMPCKeyGroupME11
TH1F *	hLctMPCKeyStrip
TH1F *	hLctMPCKeyStripME11
TH1F *	hLctMPCPattern
TH1F *	hLctMPCPerCSC
TH1F *	hLctMPCPerEvent
TH1F *	hLctMPCQuality
TH1F *	hLctMPCRing
TH1F *	hLctMPCSector
TH1F *	hLctMPCStation
TH1F *	hLctMPCStripType
TH1F *	hLctMPCValid
TH1F *	hLctTMBBend
TH1F *	hLctTMBBXN
TH1F *	hLctTMBChamber [MAX_STATIONS]
TH1F *	hLctTMBCsc [MAX_ENDCAPS][CSC_TYPES]
TH1F *	hLctTMBEndcap
TH1F *	hLctTMBKeyGroup
TH1F *	hLctTMBKeyGroupME11
TH1F *	hLctTMBKeyStrip
TH1F *	hLctTMBKeyStripME11
TH1F *	hLctTMBPattern
TH1F *	hLctTMBPerChamber
TH1F *	hLctTMBPerCSC
TH1F *	hLctTMBPerEvent
TH1F *	hLctTMBQuality
TH1F *	hLctTMBRing
TH1F *	hLctTMBSector
TH1F *	hLctTMBStation
TH1F *	hLctTMBStripType
TH1F *	hLctTMBValid
TH1F *	hPhiDiffCsc [CSC_TYPES][5]
TH1F *	hPhiDiffPattern [CSCConstants::NUM_CLCT_PATTERNS]
TH1F *	hPhiDiffVsPhi [MAX_STATIONS]
TH2F *	hPhiDiffVsStripCsc [CSC_TYPES][2]
TH2F *	hPhiRecVsSim
TH1F *	hResolDeltaDS
TH1F *	hResolDeltaEta
TH1F *	hResolDeltaHS
TH1F *	hResolDeltaPhi
TH1F *	hResolDeltaPhiDS
TH1F *	hResolDeltaPhiHS
TH1F *	hResolDeltaWG
TH1F *	hTrueBendCsc [CSC_TYPES]
std::string	lctProducerData_
std::string	lctProducerEmul_
edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	lcts_mpc_d_token_
edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	lcts_mpc_e_token_
edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	lcts_tmb_d_token_
edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	lcts_tmb_e_token_
std::string	mpclctProducerData_
TreePerStub	perStub [6]
bool	plotME1A
bool	plotME42
edm::EDGetTokenT< CSCCLCTPreTriggerDigiCollection >	pretrigs_e_token_
std::string	resultsFileNamesPrefix_
std::string	rootFileName
int	RUN_
edm::EDGetTokenT< edm::PSimHitContainer >	simHit_token_
edm::InputTag	simHitProducer_
TTree *	stub_tree [4]
MyStubComparison	stubs_comparison [4]
edm::EDGetTokenT< CSCWireDigiCollection >	wireDigi_token_
edm::InputTag	wireDigiProducer_

Static Private Attributes
static bool	bookedALCTHistos = false
static bool	bookedCLCTHistos = false
static bool	bookedCompHistos = false
static bool	bookedEfficHistos = false
static bool	bookedHotWireHistos = false
static bool	bookedLCTMPCHistos = false
static bool	bookedLCTTMBHistos = false
static bool	bookedResolHistos = false
static const std::string	csc_type [CSC_TYPES]
static const std::string	csc_type_minus [CSC_TYPES]
static const std::string	csc_type_plus [CSC_TYPES]
static const int	lut_wg_vs_hs_me1a [48][2]
static const int	lut_wg_vs_hs_me1ag [48][2]
static const int	lut_wg_vs_hs_me1b [48][2]
static const int	MAX_HS [CSC_TYPES]
static const int	MAX_WG [CSC_TYPES]
static const int	NCHAMBERS [CSC_TYPES]
static int	numALCT = 0
static int	numCLCT = 0
static int	numLCTMPC = 0
static int	numLCTTMB = 0
static bool	printps = false
static const int	ptype_TMB07 [CSCConstants::NUM_CLCT_PATTERNS]
static const double	TWOPI = 2.*M_PI

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
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)

Detailed Description

Basic analyzer class which accesses ALCTs, CLCTs, and correlated LCTs and plot various quantities.

Author

Slava Valuev, UCLA.

Definition at line 122 of file CSCTriggerPrimitivesReader.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
MAXPAGES

Definition at line 206 of file CSCTriggerPrimitivesReader.h.

{MAXPAGES = 20};      // max. number of pages in postscript files

enum CSCTriggerPrimitivesReader::trig_cscs

private

Enumerator
MAX_ENDCAPS
MAX_STATIONS
CSC_TYPES

Definition at line 205 of file CSCTriggerPrimitivesReader.h.

{MAX_ENDCAPS = 2, MAX_STATIONS = 4, CSC_TYPES = 10};

Constructor & Destructor Documentation

CSCTriggerPrimitivesReader::CSCTriggerPrimitivesReader ( const edm::ParameterSet &  conf )

explicit

Constructor.

Definition at line 303 of file CSCTriggerPrimitivesReader.cc.

References alcts_d_token_, alcts_e_token_, TreePerStub::bookTree(), MyStubComparison::bookTree(), checkBadChambers_, clcts_d_token_, clcts_e_token_, compDigi_token_, compDigiProducer_, dataIsAnotherMC_, dataLctsIn_, debug, emulLctsIn_, event_tree, gangedME1a, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), lctProducerData_, lctProducerEmul_, lcts_mpc_d_token_, lcts_mpc_e_token_, lcts_tmb_d_token_, lcts_tmb_e_token_, mpclctProducerData_, perStub, plotME1A, plotME42, pretrigs_e_token_, printps, resultsFileNamesPrefix_, setRootStyle(), simHit_token_, simHitProducer_, stub_tree, stubs_comparison, wireDigi_token_, and wireDigiProducer_.

                                                                                  : eventsAnalyzed(0) {
  edm::Service<TFileService> fs;
  //  rootFileName = conf.getUntrackedParameter<string>("rootFileName","TPEHists.root");
  // Create the root file for the histograms
  //  theFile = new TFile(rootFileName.c_str(), "RECREATE");
  //  theFile->cd();

  // Various input parameters.

  printps = conf.getParameter<bool>("printps");
  dataLctsIn_ = conf.getParameter<bool>("dataLctsIn");
  emulLctsIn_ = conf.getParameter<bool>("emulLctsIn");
  edm::ParameterSet commonParams =
    conf.getParameter<edm::ParameterSet>("commonParam");

  // Switch for a new (2007) version of the TMB firmware.
  gangedME1a = commonParams.getParameter<bool>("gangedME1a");

  // is it (non-upgrade algorithm) run along with upgrade one?
  plotME1A = true;
  plotME42 = true;
  lctProducerData_ = conf.getUntrackedParameter<string>("CSCLCTProducerData",
                                                        "cscunpacker");
  mpclctProducerData_ = conf.getUntrackedParameter<string>("CSCMPCLCTProducerData",
                                                           "csctfDigis");
  lctProducerEmul_ = conf.getUntrackedParameter<string>("CSCLCTProducerEmul",
                                                        "cscTriggerPrimitiveDigis");

  simHitProducer_ = conf.getParameter<edm::InputTag>("CSCSimHitProducer");
  wireDigiProducer_ = conf.getParameter<edm::InputTag>("CSCWireDigiProducer");
  compDigiProducer_ = conf.getParameter<edm::InputTag>("CSCComparatorDigiProducer");

  simHit_token_     = consumes<edm::PSimHitContainer>(simHitProducer_);
  wireDigi_token_   = consumes<CSCWireDigiCollection>(wireDigiProducer_);
  compDigi_token_   = consumes<CSCComparatorDigiCollection>(compDigiProducer_);

  alcts_d_token_    = consumes<CSCALCTDigiCollection>(edm::InputTag(lctProducerData_, "MuonCSCALCTDigi"));
  clcts_d_token_    = consumes<CSCCLCTDigiCollection>(edm::InputTag(lctProducerData_, "MuonCSCCLCTDigi"));
  lcts_tmb_d_token_ = consumes<CSCCorrelatedLCTDigiCollection>(edm::InputTag(lctProducerData_, "MuonCSCCorrelatedLCTDigi"));
  lcts_mpc_d_token_ = consumes<CSCCorrelatedLCTDigiCollection>(edm::InputTag(mpclctProducerData_));

  alcts_e_token_    = consumes<CSCALCTDigiCollection>(edm::InputTag(lctProducerEmul_));
  clcts_e_token_    = consumes<CSCCLCTDigiCollection>(edm::InputTag(lctProducerEmul_));
  pretrigs_e_token_ = consumes<CSCCLCTPreTriggerDigiCollection>(edm::InputTag(lctProducerEmul_));
  lcts_tmb_e_token_ = consumes<CSCCorrelatedLCTDigiCollection>(edm::InputTag(lctProducerEmul_));
  lcts_mpc_e_token_ = consumes<CSCCorrelatedLCTDigiCollection>(edm::InputTag(lctProducerEmul_, "MPCSORTED"));

  consumesMany<edm::HepMCProduct>();
  resultsFileNamesPrefix_ = conf.getUntrackedParameter<string>("resultsFileNamesPrefix","");
  checkBadChambers_ = conf.getUntrackedParameter<bool>("checkBadChambers",true);
  debug = conf.getUntrackedParameter<bool>("debug", false);
  dataIsAnotherMC_ = conf.getUntrackedParameter<bool>("dataIsAnotherMC", false);

  //rootFileName = conf.getUntrackedParameter<string>("rootFileName");
  // Create the root file.
  // Not sure we really need it - comment out for now. -Slava.
  //theFile = new TFile(rootFileName.c_str(), "RECREATE");
  //theFile->cd();
  stub_tree[0] = stubs_comparison[0].bookTree(stub_tree[0],"alcttree");
  stub_tree[1] = stubs_comparison[1].bookTree(stub_tree[1],"clcttree");
  stub_tree[2] = stubs_comparison[2].bookTree(stub_tree[2],"lcttree");
  stub_tree[3] = stubs_comparison[3].bookTree(stub_tree[3],"mpclcttree");
  // Per event TTree
  event_tree[0] = perStub[0].bookTree(event_tree[0],"Ev_alcttree");
  event_tree[1] = perStub[1].bookTree(event_tree[1],"Ev_emul_alcttree");
  event_tree[2] = perStub[2].bookTree(event_tree[2],"Ev_clcttree");
  event_tree[3] = perStub[3].bookTree(event_tree[3],"Ev_emul_clcttree");
  event_tree[4] = perStub[4].bookTree(event_tree[4],"Ev_lcttree");
  event_tree[5] = perStub[5].bookTree(event_tree[5],"Ev_emul_lcttree");
  // My favourite ROOT settings.
  setRootStyle();
}

CSCTriggerPrimitivesReader::~CSCTriggerPrimitivesReader ( )

virtual

Destructor.

Definition at line 379 of file CSCTriggerPrimitivesReader.cc.

                                                        {
  //  histos->writeHists(theFile);
  //  theFile->Close();
  //delete theFile;
}

Member Function Documentation

void CSCTriggerPrimitivesReader::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

Does the job.

Definition at line 396 of file CSCTriggerPrimitivesReader.cc.

References alcts_d_token_, alcts_e_token_, badChambers_, checkBadChambers_, clcts_d_token_, clcts_e_token_, compare(), dataLctsIn_, emulLctsIn_, edm::EventID::event(), Event_, eventsAnalyzed, fillALCTHistos(), fillCLCTHistos(), fillLCTTMBHistos(), geom_, edm::EventSetup::get(), edm::Event::getByToken(), HotWires(), edm::EventBase::id(), edm::HandleBase::isValid(), lcts_mpc_d_token_, lcts_mpc_e_token_, lcts_tmb_d_token_, lcts_tmb_e_token_, LogTrace, MCStudies(), pretrigs_e_token_, edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::EventID::run(), and RUN_.

                                                                     {
  ++eventsAnalyzed;
  //if (ev.id().event()%10 == 0)
  LogTrace("CSCTriggerPrimitivesReader")
    << "\n** CSCTriggerPrimitivesReader: processing run #"
    << ev.id().run() << " event #" << ev.id().event()
    << "; events so far: " << eventsAnalyzed << " **";
  RUN_ = ev.id().run();
  Event_ = ev.id().event();

  // Find the geometry for this event & cache it.  Needed in LCTAnalyzer
  // modules.
  edm::ESHandle<CSCGeometry> cscGeom;
  setup.get<MuonGeometryRecord>().get(cscGeom);
  geom_ = &*cscGeom;

  // Find conditions data for bad chambers & cache it.  Needed for efficiency
  // calculations.
  if (checkBadChambers_) {
    edm::ESHandle<CSCBadChambers> pBad;
    setup.get<CSCBadChambersRcd>().get(pBad);
    badChambers_ = pBad.product();
  }

  // Get the collections of ALCTs, CLCTs, and correlated LCTs from event.
  edm::Handle<CSCALCTDigiCollection> alcts_data;
  edm::Handle<CSCCLCTDigiCollection> clcts_data;
  edm::Handle<CSCCorrelatedLCTDigiCollection> lcts_tmb_data;
  edm::Handle<CSCCorrelatedLCTDigiCollection> lcts_mpc_data;
  edm::Handle<CSCALCTDigiCollection> alcts_emul;
  edm::Handle<CSCCLCTDigiCollection> clcts_emul;
  edm::Handle<CSCCLCTPreTriggerDigiCollection> pretrigs_emul;
  edm::Handle<CSCCorrelatedLCTDigiCollection> lcts_tmb_emul;
  edm::Handle<CSCCorrelatedLCTDigiCollection> lcts_mpc_emul;

  // Data
  if (dataLctsIn_) {
    HotWires(ev);
    //    ev.getByLabel(lctProducerData_,  alcts_data);
    //    ev.getByLabel(lctProducerData_,  clcts_data);
    //    ev.getByLabel(lctProducerData_,  lcts_tmb_data);
    ev.getByToken(alcts_d_token_, alcts_data);
    ev.getByToken(clcts_d_token_, clcts_data);
    ev.getByToken(lcts_tmb_d_token_, lcts_tmb_data);
    ev.getByToken(lcts_mpc_d_token_, lcts_mpc_data);

    if (!alcts_data.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of ALCTs with label MuonCSCALCTDigi"
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    if (!clcts_data.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of CLCTs with label MuonCSCCLCTDigi"
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    if (!lcts_tmb_data.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of correlated LCTs with label"
        << " MuonCSCCorrelatedLCTDigi requested, but not found in the"
        << " event... Skipping the rest +++\n";
      return;
    }
    /*
      if (!lcts_mpc_data.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
      << "+++ Warning: Collection of MPC correlated LCTs with label"
      << " MuonCSCCorrelatedLCTDigi + MCPSorted requested, but not found in the"
      << " event... Skipping the rest +++\n";
      //return;
      }*/
  }

  // Emulator
  if (emulLctsIn_) {
    //    ev.getByLabel(lctProducerEmul_,              alcts_emul);
    //    ev.getByLabel(lctProducerEmul_,              clcts_emul);
    //    ev.getByLabel(lctProducerEmul_,              lcts_tmb_emul);
    //    ev.getByLabel(lctProducerEmul_, "MPCSORTED", lcts_mpc_emul);
    ev.getByToken(alcts_e_token_, alcts_emul);
    ev.getByToken(clcts_e_token_, clcts_emul);
    ev.getByToken(pretrigs_e_token_, pretrigs_emul);
    ev.getByToken(lcts_tmb_e_token_, lcts_tmb_emul);
    ev.getByToken(lcts_mpc_e_token_, lcts_mpc_emul);

    if (!alcts_emul.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of emulated ALCTs"
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    if (!clcts_emul.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of emulated CLCTs"
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    if (!lcts_tmb_emul.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of emulated correlated LCTs"
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    /*
      if (!lcts_mpc_emul.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
      << "+++ Warning: Collection of emulated correlated LCTs (MPCs)"
      << " requested, but not found in the event... Skipping the rest +++\n";
      //return;
      }*/
  }

  // Fill histograms with reconstructed or emulated quantities.  If both are
  // present, plot LCTs in data.
  if (dataLctsIn_) {
    fillALCTHistos(alcts_data.product());
    fillCLCTHistos(clcts_data.product());
    fillLCTTMBHistos(lcts_tmb_data.product());
  }
  else if (emulLctsIn_) {
    fillALCTHistos(alcts_emul.product());
    fillCLCTHistos(clcts_emul.product());
    fillLCTTMBHistos(lcts_tmb_emul.product());
    //fillLCTMPCHistos(lcts_mpc_emul.product());
  }

  // Compare LCTs in the data with the ones produced by the emulator.
  if (dataLctsIn_ && emulLctsIn_) {
    compare(alcts_data.product(), alcts_emul.product(),
            clcts_data.product(), clcts_emul.product(),
            pretrigs_emul.product(), lcts_tmb_data.product(), lcts_tmb_emul.product()
            );
  }
  // Fill MC-based resolution/efficiency histograms, if needed.
  if (emulLctsIn_) {
    MCStudies(ev, alcts_emul.product(), clcts_emul.product());
  }
} // analyze

void CSCTriggerPrimitivesReader::bookALCTHistos ( )

private

Definition at line 675 of file CSCTriggerPrimitivesReader.cc.

References bookedALCTHistos, gather_cfg::cout, csc_type_minus, csc_type_plus, CSC_TYPES, hAlctAccel, hAlctBXN, hAlctCollis, hAlctCsc, hAlctKeyGroup, hAlctKeyGroupME11, hAlctPerChamber, hAlctPerCSC, hAlctPerEvent, hAlctQuality, hAlctValid, mps_fire::i, TFileService::make(), MAX_ENDCAPS, NCHAMBERS, and alignCSCRings::s.

Referenced by fillALCTHistos().

                                                {
  string s;

  edm::Service<TFileService> fs;
  hAlctPerEvent  = fs->make<TH1F>("ALCTs_per_event", "ALCTs per event",     31, -0.5,  30.5);
  hAlctPerChamber= fs->make<TH1F>("ALCTs_per_chamber", "ALCTs per chamber",    4, -0.5,   3.5);
  hAlctPerCSC    = fs->make<TH1F>("ALCTs_per_CSCtype", "ALCTs per CSC type",  10, -0.5,   9.5);
  for (int i = 0; i < MAX_ENDCAPS; i++) { // endcaps
    for (int j = 0; j < CSC_TYPES; j++) { // station/ring
      float csc_max = NCHAMBERS[j] + 0.5;
      char asdf[256];
      sprintf(asdf,"ALCTs_%i",i*CSC_TYPES+j);
      if (i == 0) s = "ALCTs, " + csc_type_plus[j];
      else        s = "ALCTs, " + csc_type_minus[j];
      hAlctCsc[i][j] = fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
    }
  }

  hAlctValid     = fs->make<TH1F>("ALCT_validity", "ALCT validity",        3, -0.5,   2.5);
  hAlctQuality   = fs->make<TH1F>("ALCT_quality", "ALCT quality",         5, -0.5,   4.5);
  hAlctAccel     = fs->make<TH1F>("ALCT_accel_flag", "ALCT accel. flag",     3, -0.5,   2.5);
  hAlctCollis    = fs->make<TH1F>("ALCT_collision_flag", "ALCT collision. flag", 3, -0.5,   2.5);
  hAlctKeyGroup  = fs->make<TH1F>("ALCT_key_wiregroup", "ALCT key wiregroup", 120, -0.5, 119.5);
  hAlctBXN       = fs->make<TH1F>("ALCT_bx", "ALCT bx",             20, -0.5,  19.5);

  hAlctKeyGroupME11 = fs->make<TH1F>("hAlctKeyGroupME11", "ALCT key wiregroup ME1/1", 50, -0.5, 49.5);

  bookedALCTHistos = true;
  std::cout <<" bookedALCTHistos " << std::endl;
}

void CSCTriggerPrimitivesReader::bookCLCTHistos ( )

private

Definition at line 706 of file CSCTriggerPrimitivesReader.cc.

References bookedCLCTHistos, gather_cfg::cout, csc_type, csc_type_minus, csc_type_plus, CSC_TYPES, hClctBendCsc, hClctBXN, hClctCFEB, hClctCsc, hClctKeyStrip, hClctKeyStripCsc, hClctKeyStripME11, hClctPattern, hClctPerChamber, hClctPerCSC, hClctPerEvent, hClctQuality, hClctSign, hClctStripType, hClctValid, mps_fire::i, TFileService::make(), MAX_ENDCAPS, MAX_HS, NCHAMBERS, alignCSCRings::s, and indexGen::s2.

Referenced by fillCLCTHistos().

                                                {
  string s;

  edm::Service<TFileService> fs;
  hClctPerEvent  = fs->make<TH1F>("CLCTs_per_event", "CLCTs per event",    31, -0.5, 30.5);
  hClctPerChamber= fs->make<TH1F>("CLCTs_per_chamber", "CLCTs per chamber",   3, -0.5,  2.5);
  hClctPerCSC    = fs->make<TH1F>("CLCTs_per_CSCtype", "CLCTs per CSC type", 10, -0.5,  9.5);
  for (int i = 0; i < MAX_ENDCAPS; i++) { // endcaps
    for (int j = 0; j < CSC_TYPES; j++) { // station/ring
      char asdf[256];
      sprintf(asdf,"CLCTs_%i",i*CSC_TYPES+j);
      float csc_max = NCHAMBERS[j] + 0.5;
      if (i == 0) s = "CLCTs, " + csc_type_plus[j];
      else        s = "CLCTs, " + csc_type_minus[j];
      hClctCsc[i][j] = fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
    }
  }

  hClctValid     = fs->make<TH1F>("CLCT_validity", "CLCT validity",       3, -0.5,  2.5);
  hClctQuality   = fs->make<TH1F>("CLCT_layers_hit", "CLCT layers hit",     9, -0.5,  8.5);
  hClctStripType = fs->make<TH1F>("CLCT_strip_type", "CLCT strip type",     3, -0.5,  2.5);
  hClctSign      = fs->make<TH1F>("CLCT_sing_(L/R)", "CLCT sign (L/R)",     3, -0.5,  2.5);
  hClctCFEB      = fs->make<TH1F>("CLCT_cfeb_#", "CLCT cfeb #",         6, -0.5,  5.5);
  hClctBXN       = fs->make<TH1F>("CLCT_bx", "CLCT bx",            20, -0.5, 19.5);

  hClctKeyStrip[0] = fs->make<TH1F>("CLCT_keystrip_distrips","CLCT keystrip, distrips",   40, -0.5,  39.5);
  //hClctKeyStrip[0] = fs->make<TH1F>("","CLCT keystrip, distrips",  160, -0.5, 159.5);
  hClctKeyStrip[1] = fs->make<TH1F>("CLCT_keystrip_halfstrips","CLCT keystrip, halfstrips",160, -0.5, 159.5);
  hClctPattern[0]  = fs->make<TH1F>("CLCT_pattern_distrips","CLCT pattern, distrips",    13, -0.5,  12.5);
  hClctPattern[1]  = fs->make<TH1F>("CLCT_pattern_halfstrips","CLCT pattern, halfstrips",  13, -0.5,  12.5);

  for (int i = 0; i < CSC_TYPES; i++) {
    char asdf[256];
    string s1 = "CLCT bend, " + csc_type[i];
    sprintf(asdf,"CLCT_bend0_%i",i+1);
    hClctBendCsc[i][0] = fs->make<TH1F>(asdf, s1.c_str(),  5, -0.5, 4.5);
    sprintf(asdf,"CLCT_bend1_%i",i+1);
    hClctBendCsc[i][1] = fs->make<TH1F>(asdf, s1.c_str(),  5, -0.5, 4.5);

    sprintf(asdf,"CLCT_keystrip_%i",i+1);
    string s2 = "CLCT keystrip, " + csc_type[i];
    int max_ds = MAX_HS[i]/4;
    hClctKeyStripCsc[i]   = fs->make<TH1F>(asdf, s2.c_str(), max_ds, 0., max_ds);
  }

  hClctKeyStripME11 = fs->make<TH1F>("hClctKeyStripME11","CLCT keystrip, halfstrips ME1/1",161, -0.5, 160.5);

  bookedCLCTHistos = true;
  std::cout <<" bookedCLCTHistos " << std::endl;
}

void CSCTriggerPrimitivesReader::bookCompHistos ( )

private

Definition at line 887 of file CSCTriggerPrimitivesReader.cc.

References bookedCompHistos, gather_cfg::cout, csc_type_minus, csc_type_plus, CSC_TYPES, debug, hAlctCompFound, hAlctCompFound2, hAlctCompFound2i, hAlctCompFound2x, hAlctCompFoundCsc, hAlctCompMatch, hAlctCompMatch2, hAlctCompMatch2i, hAlctCompMatch2x, hAlctCompMatchCsc, hAlctCompSameN, hAlctCompSameN2, hAlctCompSameN2i, hAlctCompSameN2x, hAlctCompSameNCsc, hAlctCompTotal, hAlctCompTotal2, hAlctCompTotal2i, hAlctCompTotal2x, hAlctCompTotalCsc, hClctCompFound, hClctCompFound2, hClctCompFound2i, hClctCompFound2x, hClctCompFoundCsc, hClctCompMatch, hClctCompMatch2, hClctCompMatch2i, hClctCompMatch2x, hClctCompMatchCsc, hClctCompSameN, hClctCompSameN2, hClctCompSameN2i, hClctCompSameN2x, hClctCompSameNCsc, hClctCompTotal, hClctCompTotal2, hClctCompTotal2i, hClctCompTotal2x, hClctCompTotalCsc, hLCTCompFound, hLCTCompFound2, hLCTCompFound2i, hLCTCompFound2x, hLctCompFoundCsc, hLCTCompMatch, hLCTCompMatch2, hLCTCompMatch2i, hLCTCompMatch2x, hLctCompMatchCsc, hLCTCompSameN, hLCTCompSameN2, hLCTCompSameN2i, hLCTCompSameN2x, hLctCompSameNCsc, hLCTCompTotal, hLCTCompTotal2, hLCTCompTotal2i, hLCTCompTotal2x, hLctCompTotalCsc, mps_fire::i, LogTrace, TFileService::make(), MAX_ENDCAPS, NCHAMBERS, and alignCSCRings::s.

Referenced by compare().

                                                {
  string s;



  edm::Service<TFileService> fs;
  //  hAlctCompMatch;

  hAlctCompFound = fs->make<TH1F>("h_ALCT_found","h_ALCT_found",600,0.5,600.5);
  hAlctCompFound2 = fs->make<TH2F>("h_ALCT_found2","h_ALCT_found2",19,-9.5,9.5,36,0.5,36.5);
  hAlctCompFound2x = fs->make<TH2F>("h_ALCT_found2x","h_ALCT_found2x",19,-9.5,9.5,18,0.5,36.5);


  hAlctCompSameN = fs->make<TH1F>("h_ALCT_SameN","h_ALCT_SameN",600,0.5,600.5);
  hAlctCompSameN2 = fs->make<TH2F>("h_ALCT_SameN2","h_ALCT_SameN2",19,-9.5,9.5,36,0.5,36.5);
  hAlctCompSameN2x = fs->make<TH2F>("h_ALCT_SameN2x","h_ALCT_SameN2x",19,-9.5,9.5,18,0.5,36.5);


  hAlctCompMatch = fs->make<TH1F>("h_ALCT_match","h_ALCT_match",600,0.5,600.5);
  hAlctCompMatch2 = fs->make<TH2F>("h_ALCT_match2","h_ALCT_match2",19,-9.5,9.5,36,0.5,36.5);
  hAlctCompMatch2x = fs->make<TH2F>("h_ALCT_match2x","h_ALCT_match2x",19,-9.5,9.5,18,0.5,36.5);

  hAlctCompTotal = fs->make<TH1F>("h_ALCT_total","h_ALCT_total",600,0.5,600.5);
  hAlctCompTotal2 = fs->make<TH2F>("h_ALCT_total2","h_ALCT_total2",19,-9.5,9.5,36,0.5,36.5);
  hAlctCompTotal2x = fs->make<TH2F>("h_ALCT_total2x","h_ALCT_total2x",19,-9.5,9.5,18,0.5,36.5);

  hClctCompFound = fs->make<TH1F>("h_CLCT_found","h_CLCT_found",600,0.5,600.5);
  hClctCompFound2 = fs->make<TH2F>("h_CLCT_found2","h_CLCT_found2",19,-9.5,9.5,36,0.5,36.5);
  hClctCompFound2x = fs->make<TH2F>("h_CLCT_found2x","h_CLCT_found2x",19,-9.5,9.5,18,0.5,36.5);

  hClctCompSameN = fs->make<TH1F>("h_CLCT_SameN","h_CLCT_SameN",600,0.5,600.5);
  hClctCompSameN2 = fs->make<TH2F>("h_CLCT_SameN2","h_CLCT_SameN2",19,-9.5,9.5,36,0.5,36.5);
  hClctCompSameN2x = fs->make<TH2F>("h_CLCT_SameN2x","h_CLCT_SameN2x",19,-9.5,9.5,18,0.5,36.5);

  hClctCompMatch = fs->make<TH1F>("h_CLCT_match","h_CLCT_match",600,0.5,600.5);
  hClctCompMatch2 = fs->make<TH2F>("h_CLCT_match2","h_CLCT_match2",19,-9.5,9.5,36,0.5,36.5);
  hClctCompMatch2x = fs->make<TH2F>("h_CLCT_match2x","h_CLCT_match2x",19,-9.5,9.5,18,0.5,36.5);

  hClctCompTotal = fs->make<TH1F>("h_CLCT_total","h_CLCT_total",600,0.5,600.5);
  hClctCompTotal2 = fs->make<TH2F>("h_CLCT_total2","h_CLCT_total2",19,-9.5,9.5,36,0.5,36.5);
  hClctCompTotal2x = fs->make<TH2F>("h_CLCT_total2x","h_CLCT_total2x",19,-9.5,9.5,18,0.5,36.5);

  hLCTCompFound = fs->make<TH1F>("h_LCT_found","h_LCT_found",600,0.5,600.5);
  hLCTCompFound2 = fs->make<TH2F>("h_LCT_found2","h_LCT_found2",19,-9.5,9.5,36,0.5,36.5);
  hLCTCompFound2x = fs->make<TH2F>("h_LCT_found2x","h_LCT_found2x",19,-9.5,9.5,18,0.5,36.5);

  hLCTCompSameN = fs->make<TH1F>("h_LCT_SameN","h_LCT_SameN",600,0.5,600.5);
  hLCTCompSameN2 = fs->make<TH2F>("h_LCT_SameN2","h_LCT_SameN2",19,-9.5,9.5,36,0.5,36.5);
  hLCTCompSameN2x = fs->make<TH2F>("h_LCT_SameN2x","h_LCT_SameN2x",19,-9.5,9.5,18,0.5,36.5);

  hLCTCompMatch = fs->make<TH1F>("h_LCT_match","h_LCT_match",600,0.5,600.5);
  hLCTCompMatch2 = fs->make<TH2F>("h_LCT_match2","h_LCT_match2",19,-9.5,9.5,36,0.5,36.5);
  hLCTCompMatch2x = fs->make<TH2F>("h_LCT_match2x","h_LCT_match2x",19,-9.5,9.5,18,0.5,36.5);

  hLCTCompTotal = fs->make<TH1F>("h_LCT_total","h_LCT_total",600,0.5,600.5);
  hLCTCompTotal2 = fs->make<TH2F>("h_LCT_total2","h_LCT_total2",19,-9.5,9.5,36,0.5,36.5);
  hLCTCompTotal2x = fs->make<TH2F>("h_LCT_total2x","h_LCT_total2x",19,-9.5,9.5,18,0.5,36.5);

  //Chad's improved historgrams
  hAlctCompFound2i = fs->make<TH2F>("h_ALCT_found2i","h_ALCT_found2i",18,0,18,36,0.5,36.5);
  hAlctCompSameN2i = fs->make<TH2F>("h_ALCT_SameN2i","h_ALCT_SameN2i",18,0,18,36,0.5,36.5);
  hAlctCompMatch2i = fs->make<TH2F>("h_ALCT_match2i","h_ALCT_match2i",18,0,18,36,0.5,36.5);
  hAlctCompTotal2i = fs->make<TH2F>("h_ALCT_total2i","h_ALCT_total2i",18,0,18,36,0.5,36.5);
  hClctCompFound2i = fs->make<TH2F>("h_CLCT_found2i","h_CLCT_found2i",18,0,18,36,0.5,36.5);
  hClctCompSameN2i = fs->make<TH2F>("h_CLCT_SameN2i","h_CLCT_SameN2i",18,0,18,36,0.5,36.5);
  hClctCompMatch2i = fs->make<TH2F>("h_CLCT_match2i","h_CLCT_match2i",18,0,18,36,0.5,36.5);
  hClctCompTotal2i = fs->make<TH2F>("h_CLCT_total2i","h_CLCT_total2i",18,0,18,36,0.5,36.5);
  hLCTCompFound2i = fs->make<TH2F>("h_LCT_found2i","h_LCT_found2i",18,0,18,36,0.5,36.5);
  hLCTCompSameN2i = fs->make<TH2F>("h_LCT_SameN2i","h_LCT_SameN2i",18,0,18,36,0.5,36.5);
  hLCTCompMatch2i = fs->make<TH2F>("h_LCT_match2i","h_LCT_match2i",18,0,18,36,0.5,36.5);
  hLCTCompTotal2i = fs->make<TH2F>("h_LCT_total2i","h_LCT_total2i",18,0,18,36,0.5,36.5);

  //  hAlctCompFound = fs->make<TH1F>("h_ALCT_found","h_ALCT_found",600,0.5,600.5);

  // ALCTs.
  for (int i = 0; i < MAX_ENDCAPS; i++) { // endcaps
    for (int j = 0; j < CSC_TYPES; j++) { // station/ring
      char asdf[256];

      float csc_max = NCHAMBERS[j] + 0.5;
      if (i == 0) s = "Comp_ALCTs, " + csc_type_plus[j];
      else        s = "Comp_ALCTs, " + csc_type_minus[j];
      sprintf(asdf,"Comp_ALCTsFound_%i",i*CSC_TYPES+j);
      hAlctCompFoundCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"Comp_ALCTsSame_%i",i*CSC_TYPES+j);
      hAlctCompSameNCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"Comp_ALCTsTotal_%i",i*CSC_TYPES+j);
      hAlctCompTotalCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"Comp_ALCTsMatch_%i",i*CSC_TYPES+j);
      hAlctCompMatchCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      hAlctCompFoundCsc[i][j]->Sumw2();
      hAlctCompSameNCsc[i][j]->Sumw2();
      hAlctCompTotalCsc[i][j]->Sumw2();
      hAlctCompMatchCsc[i][j]->Sumw2();
    }
  }

  // CLCTs.
  for (int i = 0; i < MAX_ENDCAPS; i++) { // endcaps
    for (int j = 0; j < CSC_TYPES; j++) { // station/ring
      float csc_max = NCHAMBERS[j] + 0.5;
      char asdf[256];
      if (i == 0) s = "Comp_CLCTs, " + csc_type_plus[j];
      else        s = "Comp_CLCTs, " + csc_type_minus[j];
      sprintf(asdf,"Comp_CLCTsFound_%i",i*CSC_TYPES+j);
      hClctCompFoundCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"Comp_CLCTsSame_%i",i*CSC_TYPES+j);
      hClctCompSameNCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"Comp_CLCTsTotal_%i",i*CSC_TYPES+j);
      hClctCompTotalCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"Comp_CLCTsMatch_%i",i*CSC_TYPES+j);
      hClctCompMatchCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      hClctCompFoundCsc[i][j]->Sumw2();
      hClctCompSameNCsc[i][j]->Sumw2();
      hClctCompTotalCsc[i][j]->Sumw2();
      hClctCompMatchCsc[i][j]->Sumw2();
    }
  }

  // Correlated LCTs.
  for (int i = 0; i < MAX_ENDCAPS; i++) { // endcaps
    for (int j = 0; j < CSC_TYPES; j++) { // station/ring
      float csc_max = NCHAMBERS[j] + 0.5;
      char asdf[256];
      if (i == 0) s = "LCTs, " + csc_type_plus[j];
      else        s = "LCTs, " + csc_type_minus[j];
      sprintf(asdf,"LCTs_CompFound_%i",i*CSC_TYPES+j);
      hLctCompFoundCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"LCTs_CompSame_%i",i*CSC_TYPES+j);
      hLctCompSameNCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"LCTs_CompTotal_%i",i*CSC_TYPES+j);
      hLctCompTotalCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      sprintf(asdf,"LCTs_CompMatch_%i",i*CSC_TYPES+j);
      hLctCompMatchCsc[i][j] =
        fs->make<TH1F>(asdf, s.c_str(), NCHAMBERS[j], 0.5, csc_max);
      hLctCompFoundCsc[i][j]->Sumw2();
      hLctCompSameNCsc[i][j]->Sumw2();
      hLctCompTotalCsc[i][j]->Sumw2();
      hLctCompMatchCsc[i][j]->Sumw2();
    }
  }

  bookedCompHistos = true;
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               <<"bookedCompHistos  ";
  std::cout <<"bookCompHistos "<< std::endl;
}

void CSCTriggerPrimitivesReader::bookEfficHistos ( )

private

Definition at line 1130 of file CSCTriggerPrimitivesReader.cc.

References bookedEfficHistos, gather_cfg::cout, csc_type, CSC_TYPES, debug, hEfficALCTEta, hEfficALCTEtaCsc, hEfficCLCTEta, hEfficCLCTEtaCsc, hEfficHitsEta, hEfficHitsEtaCsc, mps_fire::i, LogTrace, TFileService::make(), MAX_STATIONS, and genVertex_cff::t0.

Referenced by calcEfficiency().

                                                 {
  edm::Service<TFileService> fs;

  // Efficiencies per station.
  char histname[60];
  for (int i = 0; i < MAX_STATIONS; i++) {
    sprintf(histname, "SimHits vs eta, station %d", i+1);
    hEfficHitsEta[i] = fs->make<TH1F>("", histname, 66, 0.875, 2.525);

    sprintf(histname, "ALCTs vs eta, station %d", i+1);
    hEfficALCTEta[i] = fs->make<TH1F>("", histname, 66, 0.875, 2.525);

    sprintf(histname, "CLCTs vs eta, station %d", i+1);
    hEfficCLCTEta[i] = fs->make<TH1F>("", histname, 66, 0.875, 2.525);
  }

  // Efficiencies per chamber type.
  for (int i = 0; i < CSC_TYPES; i++) {
    string t0 = "SimHits vs eta, " + csc_type[i];
    hEfficHitsEtaCsc[i] = fs->make<TH1F>("", t0.c_str(), 66, 0.875, 2.525);
    string t1 = "ALCTs vs eta, " + csc_type[i];
    hEfficALCTEtaCsc[i] = fs->make<TH1F>("", t1.c_str(), 66, 0.875, 2.525);
    string t2 = "CLCTs vs eta, " + csc_type[i];
    hEfficCLCTEtaCsc[i] = fs->make<TH1F>("", t1.c_str(), 66, 0.875, 2.525);
  }

  bookedEfficHistos = true;
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               <<"bookedEfficHistos  ";
  std::cout <<" bookedEfficHistos " << std::endl;
}

void CSCTriggerPrimitivesReader::bookHotWireHistos ( )

private

Definition at line 668 of file CSCTriggerPrimitivesReader.cc.

References bookedHotWireHistos, hHotCham1, hHotWire1, and TFileService::make().

Referenced by HotWires().

                                                   {
  edm::Service<TFileService> fs;
  hHotWire1  = fs->make<TH1F>("hHotWire1", "hHotWire1",570*6*112,0,570*6*112);
  hHotCham1  = fs->make<TH1F>("hHotCham1", "hHotCham1",570,0,570);
  bookedHotWireHistos = true;
}

void CSCTriggerPrimitivesReader::bookLCTMPCHistos ( )

private

Definition at line 851 of file CSCTriggerPrimitivesReader.cc.

References bookedLCTMPCHistos, gather_cfg::cout, debug, hCorrLctMPCPerCSC, hLctMPCBend, hLctMPCBXN, hLctMPCChamber, hLctMPCEndcap, hLctMPCKeyGroup, hLctMPCKeyGroupME11, hLctMPCKeyStrip, hLctMPCKeyStripME11, hLctMPCPattern, hLctMPCPerCSC, hLctMPCPerEvent, hLctMPCQuality, hLctMPCRing, hLctMPCSector, hLctMPCStation, hLctMPCStripType, hLctMPCValid, LogTrace, TFileService::make(), and MAX_STATIONS.

Referenced by fillLCTMPCHistos().

                                                  {
  edm::Service<TFileService> fs;
  hLctMPCPerEvent  = fs->make<TH1F>("MPC_per_event", "LCTs per event",    31, -0.5, 30.5);
  hLctMPCPerCSC    = fs->make<TH1F>("MPC_per_CSCtype", "LCTs per CSC type", 10, -0.5,  9.5);
  hCorrLctMPCPerCSC= fs->make<TH1F>("CorrMPC_per_CSCtype", "Corr. LCTs per CSC type", 10, -0.5,9.5);
  hLctMPCEndcap    = fs->make<TH1F>("MPC_Endcap", "Endcap",             4, -0.5,  3.5);
  hLctMPCStation   = fs->make<TH1F>("MPC_Station", "Station",            6, -0.5,  5.5);
  hLctMPCSector    = fs->make<TH1F>("MPC_Sector", "Sector",             8, -0.5,  7.5);
  hLctMPCRing      = fs->make<TH1F>("MPC_Ring", "Ring",               5, -0.5,  4.5);

  hLctMPCValid     = fs->make<TH1F>("MPC_validity", "LCT validity",        3, -0.5,   2.5);
  hLctMPCQuality   = fs->make<TH1F>("MPC_quality", "LCT quality",        17, -0.5,  16.5);
  hLctMPCKeyGroup  = fs->make<TH1F>("MPC_key_wiregroup", "LCT key wiregroup", 120, -0.5, 119.5);
  hLctMPCKeyStrip  = fs->make<TH1F>("MPC_key_strip", "LCT key strip",     160, -0.5, 159.5);
  hLctMPCStripType = fs->make<TH1F>("MPC_strip_type", "LCT strip type",      3, -0.5,   2.5);
  hLctMPCPattern   = fs->make<TH1F>("MPC_pattern", "LCT pattern",        13, -0.5,  12.5);
  hLctMPCBend      = fs->make<TH1F>("MPC_bend", "LCT L/R bend",        3, -0.5,   2.5);
  hLctMPCBXN       = fs->make<TH1F>("MPC_bx", "LCT bx",             20, -0.5,  19.5);

  // LCT quantities per station
  char histname[60];
  for (int istat = 0; istat < MAX_STATIONS; istat++) {
    sprintf(histname, "MPC_CSCId, station %d", istat+1);
    hLctMPCChamber[istat] = fs->make<TH1F>("", histname,  10, -0.5, 9.5);
  }

  hLctMPCKeyGroupME11  = fs->make<TH1F>("hLctMPCKeyGroupME11", "MPC LCT key wiregroup ME1/1", 50, -0.5, 49.5);
  hLctMPCKeyStripME11  = fs->make<TH1F>("hLctMPCKeyStripME11", "MPC LCT key strip ME1/1",     161, -0.5, 160.5);

  bookedLCTMPCHistos = true;
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               <<"bookedLCTMPCHistos  ";
  std::cout <<" bookedLCTMPCHistos " << std::endl;

}

void CSCTriggerPrimitivesReader::bookLCTTMBHistos ( )

private

Definition at line 757 of file CSCTriggerPrimitivesReader.cc.

References bookedLCTTMBHistos, gather_cfg::cout, csc_type_minus, csc_type_plus, CSC_TYPES, hCorrLctTMBPerCSC, hLctTMBBend, hLctTMBBXN, hLctTMBChamber, hLctTMBCsc, hLctTMBEndcap, hLctTMBKeyGroup, hLctTMBKeyGroupME11, hLctTMBKeyStrip, hLctTMBKeyStripME11, hLctTMBPattern, hLctTMBPerChamber, hLctTMBPerCSC, hLctTMBPerEvent, hLctTMBQuality, hLctTMBRing, hLctTMBSector, hLctTMBStation, hLctTMBStripType, hLctTMBValid, mps_fire::i, TFileService::make(), MAX_ENDCAPS, MAX_STATIONS, NCHAMBERS, and alignCSCRings::s.

Referenced by fillLCTTMBHistos().

                                                  {
  string s;

  edm::Service<TFileService> fs;
  hLctTMBPerEvent  = fs->make<TH1F>("LCTs_per_event", "LCTs per event",    31, -0.5, 30.5);
  hLctTMBPerChamber= fs->make<TH1F>("LCTs_per_chamber", "LCTs per chamber",   3, -0.5,  2.5);
  hLctTMBPerCSC    = fs->make<TH1F>("LCTs_per_CSCtype", "LCTs per CSC type", 10, -0.5,  9.5);
  hCorrLctTMBPerCSC= fs->make<TH1F>("CorrLCTs_per_CSCtype", "Corr. LCTs per CSC type", 10, -0.5, 9.5);
  hLctTMBEndcap    = fs->make<TH1F>("LCTS_endcap", "Endcap",             4, -0.5,  3.5);
  hLctTMBStation   = fs->make<TH1F>("LCTS_station", "Station",            6, -0.5,  5.5);
  hLctTMBSector    = fs->make<TH1F>("LCTS_sector", "Sector",             8, -0.5,  7.5);
  hLctTMBRing      = fs->make<TH1F>("LCTS_ring", "Ring",               5, -0.5,  4.5);
  for (int i = 0; i < MAX_ENDCAPS; i++) { // endcaps
    for (int j = 0; j < CSC_TYPES; j++) { // station/ring
      char asdf[256];
      float csc_max = NCHAMBERS[j] + 0.5;
      if (i == 0) s = "LCTs, " + csc_type_plus[j];
      else        s = "LCTs, " + csc_type_minus[j];
      sprintf(asdf,"LCTs_%i",i*CSC_TYPES+j);
      hLctTMBCsc[i][j] = fs->make<TH1F>(s.c_str(), s.c_str(), NCHAMBERS[j], 0.5, csc_max);
    }
  }

  hLctTMBValid     = fs->make<TH1F>("LCT_validity", "LCT validity",        3, -0.5,   2.5);
  hLctTMBQuality   = fs->make<TH1F>("LCT_quality", "LCT quality",        17, -0.5,  16.5);
  hLctTMBKeyGroup  = fs->make<TH1F>("LCT_key_wiregroup", "LCT key wiregroup", 120, -0.5, 119.5);
  hLctTMBKeyStrip  = fs->make<TH1F>("LCT_key_strip", "LCT key strip",     160, -0.5, 159.5);
  hLctTMBStripType = fs->make<TH1F>("LCT_strip_type", "LCT strip type",      3, -0.5,   2.5);
  hLctTMBPattern   = fs->make<TH1F>("LCT_pattern", "LCT pattern",        13, -0.5,  12.5);
  hLctTMBBend      = fs->make<TH1F>("LCT_bend", "LCT L/R bend",        3, -0.5,   2.5);
  hLctTMBBXN       = fs->make<TH1F>("LCT_bx", "LCT bx",             20, -0.5,  19.5);

  // LCT quantities per station
  char histname[60];
  for (int istat = 0; istat < MAX_STATIONS; istat++) {
    sprintf(histname, "LCT_CSCId, station %d", istat+1);
    hLctTMBChamber[istat] = fs->make<TH1F>("", histname,  10, -0.5, 9.5);
  }

  hLctTMBKeyGroupME11  = fs->make<TH1F>("hLctTMBKeyGroupME11", "LCT key wiregroup ME1/1", 50, -0.5, 49.5);
  hLctTMBKeyStripME11  = fs->make<TH1F>("hLctTMBKeyStripME11", "LCT key strip ME1/1",     161, -0.5, 160.5);

  bookedLCTTMBHistos = true;
  std::cout <<" bookedLCTTMBHistos " << std::endl;
}

void CSCTriggerPrimitivesReader::bookResolHistos ( )

private

Definition at line 1046 of file CSCTriggerPrimitivesReader.cc.

References bookedResolHistos, csc_type, CSC_TYPES, debug, hAlctVsEta, hClctVsPhi, hEtaDiffCsc, hEtaDiffVsEta, hEtaDiffVsWireCsc, hEtaRecVsSim, hPhiDiffCsc, hPhiDiffPattern, hPhiDiffVsPhi, hPhiDiffVsStripCsc, hPhiRecVsSim, hResolDeltaDS, hResolDeltaEta, hResolDeltaHS, hResolDeltaPhi, hResolDeltaPhiDS, hResolDeltaPhiHS, hResolDeltaWG, hTrueBendCsc, mps_fire::i, LogTrace, TFileService::make(), MAX_HS, MAX_STATIONS, MAX_WG, CSCConstants::NUM_CLCT_PATTERNS, ptype_TMB07, genVertex_cff::t0, TWOPI, MetAnalyzer::u1, and MetAnalyzer::u2.

Referenced by calcResolution().

                                                 {
  edm::Service<TFileService> fs;

  // Limits for resolution histograms
  const double EDMIN = -0.05; // eta min
  const double EDMAX =  0.05; // eta max
  const double PDMIN = -5.0;  // phi min (mrad)
  const double PDMAX =  5.0;  // phi max (mrad)

  hResolDeltaWG = fs->make<TH1F>("", "Delta key wiregroup", 10, -5., 5.);

  hResolDeltaHS = fs->make<TH1F>("", "Delta key halfstrip", 10, -5., 5.);
  hResolDeltaDS = fs->make<TH1F>("", "Delta key distrip",   10, -5., 5.);

  hResolDeltaEta   = fs->make<TH1F>("", "#eta_rec-#eta_sim", 100, EDMIN, EDMAX);
  hResolDeltaPhi   = fs->make<TH1F>("", "#phi_rec-#phi_sim (mrad)", 100, -10., 10.);
  hResolDeltaPhiHS = fs->make<TH1F>("", "#phi_rec-#phi_sim (mrad), halfstrips", 100, -10., 10.);
  hResolDeltaPhiDS = fs->make<TH1F>("", "#phi_rec-#phi_sim (mrad), distrips", 100, -10., 10.);

  hEtaRecVsSim = fs->make<TH2F>("", "#eta_rec vs #eta_sim", 64, 0.9,  2.5,  64, 0.9,  2.5);
  hPhiRecVsSim = fs->make<TH2F>("", "#phi_rec vs #phi_sim", 100, 0., TWOPI, 100, 0., TWOPI);

  // LCT quantities per station
  char histname[60];
  for (int i = 0; i < MAX_STATIONS; i++) {
    sprintf(histname, "ALCTs vs eta, station %d", i+1);
    hAlctVsEta[i]    = fs->make<TH1F>("", histname, 66, 0.875, 2.525);

    sprintf(histname, "CLCTs vs phi, station %d", i+1);
    hClctVsPhi[i]    = fs->make<TH1F>("", histname, 100, 0.,   TWOPI);

    sprintf(histname, "#LT#eta_rec-#eta_sim#GT, station %d", i+1);
    hEtaDiffVsEta[i] = fs->make<TH1F>("", histname, 66, 0.875, 2.525);

    sprintf(histname, "#LT#phi_rec-#phi_sim#GT, station %d", i+1);
    hPhiDiffVsPhi[i] = fs->make<TH1F>("", histname, 100, 0.,   TWOPI);
  }

  for (int i = 0; i < CSC_TYPES; i++) {
    string t0 = "#eta_rec-#eta_sim, " + csc_type[i];
    hEtaDiffCsc[i][0] = fs->make<TH1F>("", t0.c_str(), 100, EDMIN, EDMAX);
    string t1 = t0 + ", endcap1";
    hEtaDiffCsc[i][1] = fs->make<TH1F>("", t1.c_str(), 100, EDMIN, EDMAX);
    string t2 = t0 + ", endcap2";
    hEtaDiffCsc[i][2] = fs->make<TH1F>("", t2.c_str(), 100, EDMIN, EDMAX);

    string t4 = "#eta_rec-#eta_sim vs wiregroup, " + csc_type[i];
    hEtaDiffVsWireCsc[i] =
      fs->make<TH2F>("", t4.c_str(), MAX_WG[i], 0., MAX_WG[i], 100, EDMIN, EDMAX);

    string u0 = "#phi_rec-#phi_sim, " + csc_type[i];
    hPhiDiffCsc[i][0] = fs->make<TH1F>("", u0.c_str(), 100, PDMIN, PDMAX);
    string u1 = u0 + ", endcap1";
    hPhiDiffCsc[i][1] = fs->make<TH1F>("", u1.c_str(), 100, PDMIN, PDMAX);
    string u2 = u0 + ", endcap2";
    hPhiDiffCsc[i][2] = fs->make<TH1F>("", u2.c_str(), 100, PDMIN, PDMAX);
    hPhiDiffCsc[i][3] = fs->make<TH1F>("", u0.c_str(), 100, PDMIN, PDMAX);
    hPhiDiffCsc[i][4] = fs->make<TH1F>("", u0.c_str(), 100, PDMIN, PDMAX);

    int MAX_DS = MAX_HS[i]/4;
    string u5 = "#phi_rec-#phi_sim (mrad) vs distrip, " + csc_type[i];
    hPhiDiffVsStripCsc[i][0] =
      fs->make<TH2F>("", u5.c_str(), MAX_DS,    0., MAX_DS,    100, PDMIN, PDMAX);
    string u6 = "#phi_rec-#phi_sim (mrad) vs halfstrip, " + csc_type[i];
    hPhiDiffVsStripCsc[i][1] =
      fs->make<TH2F>("", u6.c_str(), MAX_HS[i], 0., MAX_HS[i], 100, PDMIN, PDMAX);

    string u7 = "#phi(layer 1)-#phi(layer 6), mrad, " + csc_type[i];
    hTrueBendCsc[i] =fs->make<TH1F>("", u7.c_str(), 100, -10., 10.);
  }

  int max_patterns, phibend;
  max_patterns = CSCConstants::NUM_CLCT_PATTERNS;
  for (int i = 0; i < max_patterns; i++) {
    phibend = ptype_TMB07[i];
    sprintf(histname, "#phi_rec-#phi_sim, bend = %d", phibend);
    hPhiDiffPattern[i] = fs->make<TH1F>("", histname, 100, PDMIN, PDMAX);
  }

  bookedResolHistos = true;
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               <<"bookedResolHistos  ";
}

void CSCTriggerPrimitivesReader::calcEfficiency ( const CSCALCTDigiCollection *  alcts, const CSCCLCTDigiCollection *  clcts, const edm::PSimHitContainer &  allSimHits  )

private

Definition at line 2979 of file CSCTriggerPrimitivesReader.cc.

References funct::abs(), badChambers_, bookedEfficHistos, bookEfficHistos(), relativeConstraints::chamber, CSCDetId::chamber(), checkBadChambers_, CSCDetId::endcap(), makeMuonMisalignmentScenario::endcap, PV3DBase< T, PVType, FrameType >::eta(), geom_, getCSCType(), hEfficALCTEta, hEfficALCTEtaCsc, hEfficCLCTEta, hEfficCLCTEtaCsc, hEfficHitsEta, hEfficHitsEtaCsc, CSCBadChambers::isInBadChamber(), CSCDetId::layer(), CSCGeometry::layer(), LogTrace, MuonTCMETValueMapProducer_cff::nLayers, CSCConstants::NUM_LAYERS, plotME1A, relativeConstraints::ring, CSCDetId::ring(), relativeConstraints::station, CSCDetId::station(), and GeomDet::toGlobal().

Referenced by MCStudies().

                                                                                       {

  // Book histos when called for the first time.
  if (!bookedEfficHistos) bookEfficHistos();

  // Create list of chambers having SimHits.
  vector<CSCDetId> chamberIds;
  vector<CSCDetId>::const_iterator chamberIdIt;
  for (const auto& simHitIt : allSimHits) {
    // Find detId where simHit is located.
    bool sameId = false;
    CSCDetId hitId = (CSCDetId) simHitIt.detUnitId();
    // Skip chambers marked as bad (includes most of ME4/2 chambers).
    if (checkBadChambers_ && badChambers_->isInBadChamber(hitId)) continue;
    //if (hitId.ring() == 4) continue; // skip ME1/A for now.
    if (!plotME1A && hitId.ring() == 4) continue;
    for (const auto& chamberId : chamberIds) {
      if (chamberId.endcap()  == hitId.endcap() &&
          chamberId.station() == hitId.station() &&
          chamberId.ring()    == hitId.ring() &&
          chamberId.chamber() == hitId.chamber()) {
        sameId = true;
        break;
      }
    }
    if (!sameId) {
      CSCDetId newChamberId(hitId.endcap(), hitId.station(), hitId.ring(),
                            hitId.chamber(), 0);
      chamberIds.push_back(newChamberId);
    }
  }
  LogTrace("CSCTriggerPrimitivesReader")
    << "Found SimHits in " << chamberIds.size() << " CSCs";

  bool used[CSCConstants::NUM_LAYERS];
  vector<PSimHit> simHitsV[CSCConstants::NUM_LAYERS];
  for (const auto& chamberId : chamberIds) {
    // Find out how many layers of this chamber have SimHits.
    int nLayers = 0;
    for (int ilayer = 0; ilayer < CSCConstants::NUM_LAYERS; ilayer++) {
      used[ilayer] = false;
      simHitsV[ilayer].clear();
    }

    int endcap  = chamberId.endcap();
    int station = chamberId.station();
    int ring    = chamberId.ring();
    int chamber = chamberId.chamber();
    for (const auto& simHitIt : allSimHits) {
      CSCDetId hitId = (CSCDetId) simHitIt.detUnitId();
      if (hitId.endcap() == endcap && hitId.station() == station &&
          hitId.ring()   == ring   && hitId.chamber() == chamber) {
        int layer = hitId.layer() - 1;
        if (!used[layer] && abs(simHitIt.particleType()) == 13) {
          nLayers++;
          used[layer] = true;
          simHitsV[layer].push_back(simHitIt);
        }
      }
    }
    LogTrace("CSCTriggerPrimitivesReader")
      << "CSC in ME" << ((endcap == 1) ? "+" : "-")
      << station << "/" << ring << "/" << chamber
      << " has muon hits in " << nLayers << " layers";

    // If the number of layers with hits is above threshold, look for
    // a presence of LCTs.
    if (nLayers > 3) { // Should be a parameter.
      // Start with the key layer and take the eta of the first hit.
      // Really crude; should be improved.
      double hitEta = -999.;
      for (int ilayer = 2; ilayer < CSCConstants::NUM_LAYERS; ilayer++) {
        vector<PSimHit> layerSimHitsV = simHitsV[ilayer];
        if (layerSimHitsV.size() > 0) {
          LocalPoint hitLP = layerSimHitsV[0].localPosition();
          CSCDetId layerId = (CSCDetId)(layerSimHitsV[0]).detUnitId();
          const CSCLayer* csclayer = geom_->layer(layerId);
          GlobalPoint hitGP = csclayer->toGlobal(hitLP);
          hitEta = hitGP.eta();
          break;
        }
      }
      if (hitEta < -3.) {
        edm::LogWarning("L1CSCTPEmulatorWrongValues")
          << "+++ Warning in calcEfficiency(): no SimHit found"
          << " where there must be at least " << nLayers << "! +++\n";
        continue;
      }
      int csctype = getCSCType(*chamberIdIt);
      hEfficHitsEta[station-1]->Fill(fabs(hitEta));
      hEfficHitsEtaCsc[csctype]->Fill(fabs(hitEta));

      bool isALCT = false;
      for (auto adetUnitIt = alcts->begin(); adetUnitIt != alcts->end();
           adetUnitIt++) {
        const CSCDetId& id = (*adetUnitIt).first;
        if (id == (*chamberIdIt)) {
          const auto& range = (*adetUnitIt).second;
          for (auto digiIt = range.first;
               digiIt != range.second; digiIt++) {
            if (digiIt->isValid()) {
              // Check the distance??
              LogTrace("CSCTriggerPrimitivesReader") << "ALCT was found";
              isALCT = true;
              break;
            }
          }
        }
        if (isALCT) break;
      }
      if (isALCT) {
        hEfficALCTEta[station-1]->Fill(fabs(hitEta));
        hEfficALCTEtaCsc[csctype]->Fill(fabs(hitEta));
      }
      else {
        LogTrace("CSCTriggerPrimitivesReader") << "ALCT was not found";
      }

      bool isCLCT = false;
      for (auto cdetUnitIt = clcts->begin(); cdetUnitIt != clcts->end();
           cdetUnitIt++) {
        const CSCDetId& id = (*cdetUnitIt).first;
        if (id == (*chamberIdIt)) {
          const auto& range = (*cdetUnitIt).second;
          for (auto digiIt = range.first;
               digiIt != range.second; digiIt++) {
            if (digiIt->isValid()) {
              // Check the distance??
              LogTrace("CSCTriggerPrimitivesReader") << "CLCT was found";
              isCLCT = true;
              break;
            }
          }
        }
        if (isCLCT) break;
      }
      if (isCLCT) {
        hEfficCLCTEta[station-1]->Fill(fabs(hitEta));
        hEfficCLCTEtaCsc[csctype]->Fill(fabs(hitEta));
      }
      else {
        LogTrace("CSCTriggerPrimitivesReader") << "CLCT was not found";
      }

    }
  }
}

void CSCTriggerPrimitivesReader::calcResolution ( const CSCALCTDigiCollection *  alcts, const CSCCLCTDigiCollection *  clcts, const CSCWireDigiCollection *  wiredc, const CSCComparatorDigiCollection *  compdc, const edm::PSimHitContainer &  allSimHits  )

private

Definition at line 2787 of file CSCTriggerPrimitivesReader.cc.

References funct::abs(), badChambers_, bookedResolHistos, bookResolHistos(), relativeConstraints::chamber, checkBadChambers_, debug, spr::deltaEta, hiPixelPairStep_cff::deltaPhi, makeMuonMisalignmentScenario::endcap, geom_, getCSCType(), getHsPerRad(), CSCAnodeLCTAnalyzer::getSimInfo(), CSCCathodeLCTAnalyzer::getSimInfo(), CSCCathodeLCTAnalyzer::getStripPhi(), CSCAnodeLCTAnalyzer::getWGEta(), hAlctVsEta, hClctVsPhi, hEtaDiffCsc, hEtaDiffVsEta, hEtaDiffVsWireCsc, hEtaRecVsSim, hPhiDiffCsc, hPhiDiffPattern, hPhiDiffVsPhi, hPhiDiffVsStripCsc, hPhiRecVsSim, hResolDeltaDS, hResolDeltaEta, hResolDeltaHS, hResolDeltaPhi, hResolDeltaPhiDS, hResolDeltaPhiHS, hResolDeltaWG, hTrueBendCsc, CSCBadChambers::isInBadChamber(), CSCConstants::KEY_ALCT_LAYER, CSCConstants::KEY_CLCT_LAYER, CSCDetId::layer(), CSCGeometry::layer(), LogTrace, M_PI, CSCCathodeLCTAnalyzer::nearestHS(), CSCAnodeLCTAnalyzer::nearestWG(), phi, relativeConstraints::ring, CSCAnodeLCTAnalyzer::setGeometry(), CSCCathodeLCTAnalyzer::setGeometry(), relativeConstraints::station, digitizers_cfi::strip, and GeomDet::toGlobal().

Referenced by MCStudies().

                                                                                       {

  // Book histos when called for the first time.
  if (!bookedResolHistos) bookResolHistos();

  // ALCT resolution
  CSCAnodeLCTAnalyzer alct_analyzer;
  alct_analyzer.setGeometry(geom_);

  for (auto adetUnitIt = alcts->begin(); adetUnitIt != alcts->end(); adetUnitIt++) {
    const CSCDetId& id = (*adetUnitIt).first;
    if (checkBadChambers_ && badChambers_->isInBadChamber(id)) continue;
    const auto& range = (*adetUnitIt).second;
    for (auto digiIt = range.first;
         digiIt != range.second; digiIt++) {

      bool alct_valid = (*digiIt).isValid();
      if (alct_valid) {
        vector<CSCAnodeLayerInfo> alctInfo =
          alct_analyzer.getSimInfo(*digiIt, id, wiredc, &allSimHits);

        double hitPhi = -999.0, hitEta = -999.0;
        int hitWG = alct_analyzer.nearestWG(alctInfo, hitPhi, hitEta);
        if (hitWG >= 0.) {
          // Key wire group and key layer id.
          int wiregroup = (*digiIt).getKeyWG();

          CSCDetId layerId(id.endcap(), id.station(), id.ring(),
                           id.chamber(), CSCConstants::KEY_ALCT_LAYER);
          int endc    = id.endcap();
          int stat    = id.station();
          int csctype = getCSCType(id);

          double alctEta  = alct_analyzer.getWGEta(layerId, wiregroup);
          double deltaEta = alctEta - hitEta;
          hResolDeltaEta->Fill(deltaEta);

          double deltaWG = wiregroup - hitWG;
          if (debug) LogTrace("CSCTriggerPrimitivesReader")
                       << "WG: MC = " << hitWG << " rec = " << wiregroup
                       << " delta = " << deltaWG;
          hResolDeltaWG->Fill(deltaWG);

          hEtaRecVsSim->Fill(fabs(hitEta), fabs(alctEta));
          hEtaDiffCsc[csctype][0]->Fill(deltaEta);
          hEtaDiffCsc[csctype][endc]->Fill(deltaEta);
          hAlctVsEta[stat-1]->Fill(fabs(alctEta));
          hEtaDiffVsEta[stat-1]->Fill(fabs(alctEta), fabs(deltaEta));
          hEtaDiffVsWireCsc[csctype]->Fill(wiregroup, deltaEta);
        }
        // should I comment out this "else"?
        //else {
        //  edm::LogWarning("L1CSCTPEmulatorWrongInput")
        //    << "+++ Warning in calcResolution(): no matched SimHit"
        //    << " found! +++\n";
        //}
      }
    }
  }

  // CLCT resolution
  static const int key_layer = CSCConstants::KEY_CLCT_LAYER;
  CSCCathodeLCTAnalyzer clct_analyzer;
  clct_analyzer.setGeometry(geom_);

  for (auto cdetUnitIt = clcts->begin(); cdetUnitIt != clcts->end(); cdetUnitIt++) {
    const CSCDetId& id = (*cdetUnitIt).first;
    if (checkBadChambers_ && badChambers_->isInBadChamber(id)) continue;
    const auto& range = (*cdetUnitIt).second;
    for (auto digiIt = range.first;
         digiIt != range.second; digiIt++) {

      bool clct_valid = (*digiIt).isValid();
      if (clct_valid) {
        vector<CSCCathodeLayerInfo> clctInfo =
          clct_analyzer.getSimInfo(*digiIt, id, compdc, &allSimHits);

        double hitPhi = -999.0, hitEta = -999.0, deltaStrip = -999.0;
        int hitHS = clct_analyzer.nearestHS(clctInfo, hitPhi, hitEta);
        if (hitHS >= 0.) {
          // Key strip and key layer id.
          int halfstrip = (*digiIt).getKeyStrip();
          int strip     = halfstrip/2;
          int distrip   = halfstrip/4;
          int stripType = (*digiIt).getStripType();

          CSCDetId layerId(id.endcap(), id.station(), id.ring(),
                           id.chamber(), key_layer);
          int endc    = id.endcap();
          int stat    = id.station();
          int csctype = getCSCType(id);

          // 'float strip' is in the units of 'strip', i.e., angular
          // widths of each strip. The counting is from 0.0 at the extreme
          // edge of the 'first' strip at one edge of the detector.
          float fstrip = -999.;
          if (stripType == 0) { // di-strip CLCT
            fstrip = strip + 1.;
          }
          else {                // half-strip CLCT
            fstrip = strip + 0.5*(halfstrip%2) + 0.25;
          }
          double clctPhi = clct_analyzer.getStripPhi(layerId, fstrip);
          double deltaPhi = clctPhi - hitPhi;
          if      (deltaPhi < -M_PI) deltaPhi += 2.*M_PI;
          else if (deltaPhi >  M_PI) deltaPhi -= 2.*M_PI;
          deltaPhi *= 1000; // in mrad
          if      (hitPhi  < 0) hitPhi  += 2.*M_PI;
          if      (clctPhi < 0) clctPhi += 2.*M_PI;
          if (debug) LogTrace("CSCTriggerPrimitivesReader")
                       << " clctPhi = " << clctPhi << " hitPhi = " << hitPhi
                       << " deltaPhi = " << deltaPhi;

          hResolDeltaPhi->Fill(deltaPhi);
          if (stripType == 0) { // di-strip CLCT
            deltaStrip = distrip - hitHS/4;
            hResolDeltaDS->Fill(deltaStrip);
            hResolDeltaPhiDS->Fill(deltaPhi);
            hPhiDiffVsStripCsc[csctype][0]->Fill(distrip,   deltaPhi);
          }
          else {                // half-strip CLCT
            deltaStrip = halfstrip - hitHS;
            hResolDeltaHS->Fill(deltaStrip);
            hResolDeltaPhiHS->Fill(deltaPhi);
            hPhiDiffVsStripCsc[csctype][1]->Fill(halfstrip, deltaPhi);
          }
          if (debug) LogTrace("CSCTriggerPrimitivesReader")
                       << "Half-strip: MC = " << hitHS << " rec = " << halfstrip
                       << " pattern type = " << stripType << " delta = " << deltaStrip;

          hPhiRecVsSim->Fill(hitPhi, clctPhi);
          hPhiDiffCsc[csctype][0]->Fill(deltaPhi);
          hPhiDiffCsc[csctype][endc]->Fill(deltaPhi);
          hPhiDiffCsc[csctype][stripType+3]->Fill(deltaPhi);
          hClctVsPhi[stat-1]->Fill(clctPhi);
          hPhiDiffVsPhi[stat-1]->Fill(clctPhi, fabs(deltaPhi));

          // Histograms to check phi offsets for various pattern types
          if (stripType == 1) { // half-strips
            double hsperrad = getHsPerRad(csctype); // halfstrips-per-radian
            if((endc == 1 && (stat == 1 || stat == 2)) ||
               (endc == 2 && (stat == 3 || stat == 4))) {
              hPhiDiffPattern[(*digiIt).getPattern()]->Fill(deltaPhi/1000*hsperrad);
            }
          }
        }
        // should I comment out this "else"?
        //else {
        //  edm::LogWarning("L1CSCTPEmulatorWrongInput")
        //    << "+++ Warning in calcResolution(): no matched SimHit"
        //    << " found! +++\n";
        //}

        // "True bend", defined as difference in phi between muon hit
        // positions in the first and in the sixth layers.
        double phi1 = -999.0, phi6 = -999.0;
        vector<CSCCathodeLayerInfo>::const_iterator pli;
        for (pli = clctInfo.begin(); pli != clctInfo.end(); pli++) {
          CSCDetId layerId = pli->getId();
          int layer = layerId.layer();
          if (layer == 1 || layer == 6) {
            // Get simHits in this layer.
            for (const auto& psh : allSimHits) {
              // Find detId where simHit is located.
              CSCDetId hitId = (CSCDetId)psh.detUnitId();
              if (hitId == layerId &&
                  abs(psh.particleType()) == 13) { // muon hits only
                const CSCLayer* csclayer = geom_->layer(layerId);
                const auto& thisPoint = csclayer->toGlobal(psh.localPosition());
                double phi = thisPoint.phi();
                if (layer == 1)      phi1 = phi;
                else if (layer == 6) phi6 = phi;
                break; // simply take the first suitable hit.
              }
            }
          }
        }
        if (phi1 > -99. && phi6 > -99.) {
          double deltaPhi = phi1 - phi6;
          if (deltaPhi > M_PI)       deltaPhi -= 2.*M_PI;
          else if (deltaPhi < -M_PI) deltaPhi += 2.*M_PI;
          int csctype = getCSCType(id);
          hTrueBendCsc[csctype]->Fill(deltaPhi*1000.); // in mrad
        }
      }
    }
  }
}

int CSCTriggerPrimitivesReader::chamberIX

(

CSCDetId

id

)

Definition at line 818 of file CSCTriggerPrimitivesReader.cc.

References makeMuonMisalignmentScenario::endcap, and relativeConstraints::station.

Referenced by compareALCTs(), compareCLCTs(), and compareLCTs().

                                                     {
  int ix=1;
  if(id.station()!=1) {
    ix=(id.station()-2)*2+3+1;
  }
  ix+=id.ring()-1;
  if(id.endcap()==2) {
    ix*=-1;
  }
  return ix;
}

int CSCTriggerPrimitivesReader::chamberIXi

(

CSCDetId

id

)

Definition at line 803 of file CSCTriggerPrimitivesReader.cc.

References makeMuonMisalignmentScenario::endcap, and relativeConstraints::station.

Referenced by compareALCTs(), compareCLCTs(), and compareLCTs().

                                                      {
  //    1/1 1/2 1/3 2/1 2/2 3/1 3/2 4/1 4/2 -1/1 -1/2 -1/3 -2/1 -2/2 -3/1 -3/2 -4/1 -4/2
  //ix= 0   1   2   3   4   5   6   7   8    9    10   11   12   13   14   15   16   17
  int ix=0;
  if(id.station()!=1) {

    ix=(id.station()-2)*2+3;
  }
  ix+=id.ring()-1;
  if(id.endcap()==2) {
    ix+=9;
  }
  return ix;
}

int CSCTriggerPrimitivesReader::chamberSerial

(

CSCDetId

id

)

Definition at line 830 of file CSCTriggerPrimitivesReader.cc.

References RecoEcal_EventContent_cff::ec.

Referenced by compareALCTs(), and HotWires().

                                                           {
  int st = id.station();
  int ri = id.ring();
  int ch = id.chamber();
  int ec = id.endcap();
  int kSerial = ch;
  if (st == 1 && ri == 1) kSerial = ch;
  if (st == 1 && ri == 2) kSerial = ch + 36;
  if (st == 1 && ri == 3) kSerial = ch + 72;
  if (st == 1 && ri == 4) kSerial = ch;
  if (st == 2 && ri == 1) kSerial = ch + 108;
  if (st == 2 && ri == 2) kSerial = ch + 126;
  if (st == 3 && ri == 1) kSerial = ch + 162;
  if (st == 3 && ri == 2) kSerial = ch + 180;
  if (st == 4 && ri == 1) kSerial = ch + 216;
  if (st == 4 && ri == 2) kSerial = ch + 234;  // one day...
  if (ec == 2) kSerial = kSerial + 300;
  return kSerial;
}

void CSCTriggerPrimitivesReader::compare ( const CSCALCTDigiCollection *  alcts_data, const CSCALCTDigiCollection *  alcts_emul, const CSCCLCTDigiCollection *  clcts_data, const CSCCLCTDigiCollection *  clcts_emul, const CSCCLCTPreTriggerDigiCollection *  pretrigs_emul, const CSCCorrelatedLCTDigiCollection *  lcts_data, const CSCCorrelatedLCTDigiCollection *  lcts_emul  )

private

Definition at line 1410 of file CSCTriggerPrimitivesReader.cc.

References bookCompHistos(), bookedCompHistos, compareALCTs(), compareCLCTs(), and compareLCTs().

Referenced by analyze().

                                                                                         {

  // Book histos when called for the first time.
  if (!bookedCompHistos) bookCompHistos();

  // Comparisons
  compareALCTs(alcts_data, alcts_emul);
  compareCLCTs(clcts_data, clcts_emul, pretrigs_emul);
  compareLCTs(lcts_data,  lcts_emul, alcts_data, clcts_data);
  //compareMPCLCTs(mpclcts_data,  mpclcts_emul, alcts_data, clcts_data);
}

void CSCTriggerPrimitivesReader::compareALCTs ( const CSCALCTDigiCollection *  alcts_data, const CSCALCTDigiCollection *  alcts_emul  )

private

Definition at line 1428 of file CSCTriggerPrimitivesReader.cc.

References funct::abs(), badChambers_, MyStubComparison::bx_corr_emul, MyStubComparison::bx_data, MyStubComparison::bx_emul, relativeConstraints::cham, CSCDetId::chamber(), MyStubComparison::chamber, chamberIX(), chamberIXi(), chamberSerial(), MyStubComparison::chambertype, checkBadChambers_, dataIsAnotherMC_, debug, MyStubComparison::endcap, CSCDetId::endcap(), PV3DBase< T, PVType, FrameType >::eta(), MyStubComparison::eta_data, MyStubComparison::eta_emul, Event_, event_tree, eventsAnalyzed, MyStubComparison::firstfill, MyStubComparison::fullbx_data, MyStubComparison::fullbx_emul, getCSCType(), getGlobalPosition(), hAlctCompFound, hAlctCompFound2, hAlctCompFound2i, hAlctCompFound2x, hAlctCompFoundCsc, hAlctCompMatch, hAlctCompMatch2, hAlctCompMatch2i, hAlctCompMatch2x, hAlctCompMatchCsc, hAlctCompSameN2, hAlctCompSameN2i, hAlctCompSameN2x, hAlctCompSameNCsc, hAlctCompTotal, hAlctCompTotal2, hAlctCompTotal2i, hAlctCompTotal2x, hAlctCompTotalCsc, MyStubComparison::has_data, MyStubComparison::has_emul, mps_fire::i, CSCDetId::iChamberType(), TreePerStub::init(), MyStubComparison::init(), CSCBadChambers::isInBadChamber(), MyStubComparison::key_WG_data, MyStubComparison::key_WG_emul, LogTrace, maxRing(), MyStubComparison::nEvents, MyStubComparison::nStub_data, MyStubComparison::nStub_emul, or, perStub, MyStubComparison::quality_data, MyStubComparison::quality_emul, DetId::rawId(), relativeConstraints::ring, CSCDetId::ring(), MyStubComparison::ring, RUN_, trackingPlots::stat, MyStubComparison::station, CSCDetId::station(), stub_tree, stubs_comparison, TreePerStub::t_chamber, TreePerStub::t_endcap, TreePerStub::t_EventNumberAnalyzed, TreePerStub::t_nStubs, TreePerStub::t_nStubs_readout, TreePerStub::t_ring, TreePerStub::t_station, MyStubComparison::totStubs_data, MyStubComparison::totStubs_emul, MyStubComparison::totStubs_emul_readout, CSCDetId::triggerCscId(), CSCDetId::triggerSector(), MyStubComparison::trknmb_data, and MyStubComparison::trknmb_emul.

Referenced by compare().

                                                                                       {
  int emul_corr_bx;

  // Should be taken from config. parameters.
  int fifo_pretrig     = 10;
  int fpga_latency     =  6;
  int l1a_window_width =  7;
  // Time offset of raw hits w.r.t. the full 12-bit BXN.
  int rawhit_tbin_offset =
    (fifo_pretrig - fpga_latency) + (l1a_window_width-1)/2;
  // Extra difference due to additional register stages; determined
  // empirically.
  int register_delay =  2;
  // Loop over all chambers in search for ALCTs.
  std::vector<CSCALCTDigi>::const_iterator pd, pe;
  for (int endc = 1; endc <= 2; endc++) {
    for (int stat = 1; stat <= 4; stat++) {
      for (int ring = 1; ring <= maxRing(stat); ring++) {
        for (int cham = 1; cham <= 36; cham++) {
          // Calculate DetId.  0th layer means whole chamber.
          CSCDetId detid(endc, stat, ring, cham, 0);

          // Skip chambers marked as bad.
          if (checkBadChambers_ && badChambers_->isInBadChamber(detid)) continue;
          std::vector<CSCALCTDigi> alctV_data, alctV_emul;
          const auto& drange = alcts_data->get(detid);
          for (auto digiIt = drange.first; digiIt != drange.second; digiIt++) {
            if ((*digiIt).isValid()) {
              alctV_data.push_back(*digiIt);
            }
          }

          const auto& erange = alcts_emul->get(detid);
          std::vector<bool> bookedalctV_emul;
          for (auto digiIt = erange.first; digiIt != erange.second; digiIt++) {
            if ((*digiIt).isValid()) {
              alctV_emul.push_back(*digiIt);
              bookedalctV_emul.push_back(false);
            }
          }

          int ndata = alctV_data.size();
          int nemul = alctV_emul.size();

          if (ndata == 0 && nemul == 0) continue;
          bool firstfill = true;

          if (debug or (stat == 1 and ring== 1 and (ndata != nemul)) ) {
            ostringstream strstrm;
            strstrm << "\n--- ME" << ((detid.endcap() == 1) ? "+" : "-")
                    << detid.station() << "/" << detid.ring() << "/"
                    << detid.chamber()
                    << " (sector "  << detid.triggerSector()
                    << " trig id. " << detid.triggerCscId() << "):\n";
            strstrm << "  **** " << ndata << " valid data ALCTs found:\n";
            for (pd = alctV_data.begin(); pd != alctV_data.end(); pd++) {
              strstrm << "     " << (*pd)
                      << " Full BX = " << (*pd).getFullBX() << "\n";
            }
            strstrm << "  **** " << nemul << " valid emul ALCTs found:\n";
            for (pe = alctV_emul.begin(); pe != alctV_emul.end(); pe++) {
              strstrm << "     " << (*pe);
              for (pd = alctV_data.begin(); pd != alctV_data.end(); pd++) {
                if ((*pd).getTrknmb() == (*pe).getTrknmb()) {
                  int emul_bx = (*pe).getBX();
                  emul_corr_bx =
                    emul_bx - rawhit_tbin_offset + register_delay;
                  strstrm << " Corr BX = " << emul_corr_bx;
                  break;
                }
              }
              strstrm << "\n";
            }
            LogTrace("CSCTriggerPrimitivesReader") << strstrm.str();
            //if (stat==1 && ring==1)
            //  std::cout <<"ME11  CompareALCTs "<< strstrm.str()<< std::endl;
          }

          //Data, add HS quality later
          int perEv_nStub_data = 0;
          int perEv_nStub_emul = 0;
          perStub[0].init(RUN_, Event_);
          perStub[1].init(RUN_, Event_);
          for (pd = alctV_data.begin(); pd != alctV_data.end(); pd++){
            perEv_nStub_data++;
          }
          perStub[0].t_endcap = endc;
          perStub[0].t_station = stat;
          perStub[0].t_chamber = cham;
          perStub[0].t_ring = ring;
          perStub[0].t_EventNumberAnalyzed = eventsAnalyzed;
          perStub[0].t_nStubs              = ndata;
          perStub[0].t_nStubs_readout              = ndata;
          event_tree[0]->Fill();
          //Emul
          for (pe = alctV_emul.begin(); pe != alctV_emul.end(); pe++){
            perEv_nStub_emul++;
          }
          perStub[1].t_endcap = endc;
          perStub[1].t_station = stat;
          perStub[1].t_chamber = cham;
          perStub[1].t_ring = ring;
          perStub[1].t_EventNumberAnalyzed = eventsAnalyzed;
          perStub[1].t_nStubs              = nemul;
          perStub[1].t_nStubs_readout      = nemul;
          event_tree[1]->Fill();

          int csctype = getCSCType(detid);
          hAlctCompFoundCsc[endc-1][csctype]->Fill(cham);
          int mychamber = chamberSerial(detid);
          hAlctCompFound->Fill(mychamber);
          int ix = chamberIX(detid);
          int ix2 = chamberIXi(detid);
          //      printf("station %i, ring %i, chamber %i, ix+(detid.ring()-1) %i\n",
          //         detid.station(),detid.ring(),detid.chamber(),ix);
          if(detid.station()>1 && detid.ring()==1) {
            hAlctCompFound2x->Fill(ix,detid.chamber()*2);
          }
          else {
            hAlctCompFound2->Fill(ix,detid.chamber());
          }
          hAlctCompFound2i->Fill(ix2,detid.chamber());

          if (ndata != nemul) {
            LogTrace("CSCTriggerPrimitivesReader")
              << "   +++ Different numbers of ALCTs found in ME"
              << ((endc == 1) ? "+" : "-") << stat << "/"
              << ring << "/" << cham
              << ": data = " << ndata << " emulator = " << nemul << " +++\n";
          }
          else {
            hAlctCompSameNCsc[endc-1][csctype]->Fill(cham);
            if(detid.station()>1 && detid.ring()==1) {
              hAlctCompSameN2x->Fill(ix,detid.chamber()*2);
            }
            else {
              hAlctCompSameN2->Fill(ix,detid.chamber());
            }
            hAlctCompSameN2i->Fill(ix2,detid.chamber());
          }

          for (int i = 0; i < ndata; i++) {
            if (alctV_data[i].isValid() == 0) continue;
            int data_trknmb    = alctV_data[i].getTrknmb();
            //int data_quality   = alctV_data[i].getQuality();
            //int data_accel     = alctV_data[i].getAccelerator();
            //int data_collB     = alctV_data[i].getCollisionB();
            int data_wiregroup = alctV_data[i].getKeyWG();
            int data_bx        = alctV_data[i].getBX();

            stubs_comparison[0].init(RUN_, Event_);
            stubs_comparison[0].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[0].nEvents = eventsAnalyzed;
            stubs_comparison[0].endcap = endc;
            stubs_comparison[0].station = stat;
            stubs_comparison[0].ring = ring;
            stubs_comparison[0].chamber = cham;
            stubs_comparison[0].chambertype = detid.iChamberType();
            stubs_comparison[0].totStubs_data = ndata;
            stubs_comparison[0].totStubs_emul = nemul;
            stubs_comparison[0].totStubs_emul_readout = nemul;
            stubs_comparison[0].nStub_data = i+1;
            stubs_comparison[0].has_data = true;
            stubs_comparison[0].quality_data = alctV_data[i].getQuality();
            stubs_comparison[0].key_WG_data = alctV_data[i].getKeyWG();
            stubs_comparison[0].bx_data = data_bx;
            stubs_comparison[0].fullbx_data = alctV_data[i].getFullBX();
            stubs_comparison[0].trknmb_data = data_trknmb;
            GlobalPoint gp_alct_data(getGlobalPosition(detid.rawId(), data_wiregroup, 60));
            stubs_comparison[0].eta_data = gp_alct_data.eta();
            for (int j=0; j<nemul; j++){
              if (alctV_emul[j].isValid() == 0) continue;
              if (bookedalctV_emul[j]) continue; //used alct

              int emul_trknmb    = alctV_emul[j].getTrknmb();
              //int emul_quality   = alctV_emul[j].getQuality();
              //int emul_accel     = alctV_emul[j].getAccelerator();
              //int emul_collB     = alctV_emul[j].getCollisionB();
              int emul_wiregroup = alctV_emul[j].getKeyWG();
              int emul_bx        = alctV_emul[j].getBX();
              // Emulator BX re-calculated for comparison with BX in the data.
              emul_corr_bx = emul_bx - rawhit_tbin_offset + register_delay;
              if (dataIsAnotherMC_)
                emul_corr_bx = emul_bx;

              if (ndata == nemul) {
                hAlctCompTotal->Fill(mychamber);
                hAlctCompTotalCsc[endc-1][csctype]->Fill(cham);
                if(detid.station()>1 && detid.ring()==1) {
                  hAlctCompTotal2x->Fill(ix,detid.chamber()*2);
                }
                else {
                  hAlctCompTotal2->Fill(ix,detid.chamber());
                }
                hAlctCompTotal2i->Fill(ix2,detid.chamber());
              }
              if (data_trknmb    == emul_trknmb )  {
                if (abs(data_wiregroup - emul_wiregroup) <= 2){
                  hAlctCompMatchCsc[endc-1][csctype]->Fill(cham);
                  hAlctCompMatch->Fill(mychamber);
                  if(detid.station()>1 && detid.ring()==1) {
                    hAlctCompMatch2x->Fill(ix,detid.chamber()*2);
                  }
                  else {
                    hAlctCompMatch2->Fill(ix,detid.chamber());
                  }
                  hAlctCompMatch2i->Fill(ix2,detid.chamber());
                }
                if (debug) LogTrace("CSCTriggerPrimitivesReader")
                             << "       Identical ALCTs #" << data_trknmb;
                stubs_comparison[0].nStub_emul = j+1;
                stubs_comparison[0].has_emul = true;
                stubs_comparison[0].quality_emul = alctV_emul[j].getQuality();
                stubs_comparison[0].key_WG_emul = alctV_emul[j].getKeyWG();
                stubs_comparison[0].bx_emul = alctV_emul[j].getBX();
                stubs_comparison[0].trknmb_emul = emul_trknmb;
                GlobalPoint gp_alct_emul(getGlobalPosition(detid.rawId(), emul_wiregroup, 60));
                stubs_comparison[0].eta_emul = gp_alct_emul.eta();
                stubs_comparison[0].bx_corr_emul = emul_corr_bx;
                bookedalctV_emul[j] = true;
                break;
              }
              else {
                LogTrace("CSCTriggerPrimitivesReader")
                  << "       Different ALCTs #" << data_trknmb << " in ME"
                  << ((endc == 1) ? "+" : "-") << stat << "/"
                  << ring << "/" << cham;
              }

            }//loop emul
            if (debug and stubs_comparison[0].key_WG_data != stubs_comparison[0].key_WG_emul)
              LogTrace("CSCTriggerPrimitivesReader")
                <<" not matched ALCT from data "<< alctV_data[i]
                <<" stubs_comparison 0 key_WG_data "<<stubs_comparison[0].key_WG_data <<" key_WG_emul "<< stubs_comparison[0].key_WG_emul;
            //if (stat==1) std::cout <<" stub_tree filled , ring "<< stubs_comparison[0].ring << std::endl;
            //cout <<"ALCT data BX "<< stubs_comparison[0].bx_data <<" WG "<< stubs_comparison[0].key_WG_data <<" emul BX "<< stubs_comparison[0].bx_emul<<" emul BX corrected "<< stubs_comparison[0].bx_corr_emul <<" WG "<< stubs_comparison[0].key_WG_emul << endl;
            stub_tree[0]->Fill();
          }//loop data
          for (int i = 0; i<nemul; i++){
            if (alctV_emul[i].isValid() == 0 or bookedalctV_emul[i]) continue;
            int emul_bx        = alctV_emul[i].getBX();
            stubs_comparison[0].init(RUN_, Event_);
            stubs_comparison[0].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[0].nEvents = eventsAnalyzed;
            stubs_comparison[0].endcap = endc;
            stubs_comparison[0].station = stat;
            stubs_comparison[0].ring = ring;
            stubs_comparison[0].chamber = cham;
            stubs_comparison[0].chambertype = detid.iChamberType();
            stubs_comparison[0].totStubs_data = ndata;
            stubs_comparison[0].totStubs_emul = nemul;
            stubs_comparison[0].totStubs_emul_readout = nemul;
            stubs_comparison[0].nStub_data = -1;
            stubs_comparison[0].nStub_emul = i+1;
            stubs_comparison[0].has_data = false;
            stubs_comparison[0].has_emul = true;
            stubs_comparison[0].trknmb_emul = alctV_emul[i].getTrknmb();
            stubs_comparison[0].quality_emul = alctV_emul[i].getQuality();
            stubs_comparison[0].key_WG_emul = alctV_emul[i].getKeyWG();
            stubs_comparison[0].bx_emul = alctV_emul[i].getBX();
            stubs_comparison[0].fullbx_emul = alctV_emul[i].getFullBX();
            GlobalPoint gp_alct_emul(getGlobalPosition(detid.rawId(), alctV_emul[i].getKeyWG(), 60));
            stubs_comparison[0].eta_emul = gp_alct_emul.eta();
            // Emulator BX re-calculated for comparison with BX in the data.
            emul_corr_bx = emul_bx - rawhit_tbin_offset + register_delay;
            if (dataIsAnotherMC_)
              emul_corr_bx = emul_bx;
            stubs_comparison[0].bx_corr_emul = emul_corr_bx;
            stub_tree[0]->Fill();
            if (debug)
              LogTrace("CSCTriggerPrimitivesReader")
                <<"not matched ALCT from emulation "<< alctV_emul[i];

          }//loop emul
        }
      }
    }
  }
}// compare ALCT

void CSCTriggerPrimitivesReader::compareCLCTs ( const CSCCLCTDigiCollection *  clcts_data, const CSCCLCTDigiCollection *  clcts_emul, const CSCCLCTPreTriggerDigiCollection *  pretrigs_emul  )

private

Definition at line 1711 of file CSCTriggerPrimitivesReader.cc.

References funct::abs(), badChambers_, MyStubComparison::bend_data, MyStubComparison::bend_emul, MyStubComparison::bend_pretrig, MyStubComparison::bx_corr_emul, MyStubComparison::bx_data, MyStubComparison::bx_emul, MyStubComparison::bx_pretrig, relativeConstraints::cham, CSCDetId::chamber(), MyStubComparison::chamber, chamberIX(), chamberIXi(), MyStubComparison::chambertype, checkBadChambers_, dataIsAnotherMC_, debug, MyStubComparison::endcap, CSCDetId::endcap(), Event_, event_tree, eventsAnalyzed, MyStubComparison::firstfill, MyStubComparison::fullbx_data, MyStubComparison::fullbx_emul, MuonDigiCollection< IndexType, DigiType >::get(), getCSCType(), getGlobalPosition(), MyStubComparison::has_data, MyStubComparison::has_emul, hClctCompFound2, hClctCompFound2i, hClctCompFound2x, hClctCompFoundCsc, hClctCompMatch2, hClctCompMatch2i, hClctCompMatch2x, hClctCompMatchCsc, hClctCompSameN2, hClctCompSameN2i, hClctCompSameN2x, hClctCompSameNCsc, hClctCompTotal2, hClctCompTotal2i, hClctCompTotal2x, hClctCompTotalCsc, mps_fire::i, CSCDetId::iChamberType(), TreePerStub::init(), MyStubComparison::init(), CSCBadChambers::isInBadChamber(), gen::k, MyStubComparison::key_hs_data, MyStubComparison::key_hs_emul, MyStubComparison::key_hs_pretrig, LogTrace, MyStubComparison::maxpattern_pretrig, MyStubComparison::maxquality_pretrig, maxRing(), MyStubComparison::nEvents, MyStubComparison::npretrig, MyStubComparison::nStub_data, MyStubComparison::nStub_emul, or, MyStubComparison::pattern_data, MyStubComparison::pattern_emul, MyStubComparison::pattern_pretrig, perStub, PV3DBase< T, PVType, FrameType >::phi(), MyStubComparison::phi_data, MyStubComparison::phi_emul, MyStubComparison::quality_data, MyStubComparison::quality_emul, MyStubComparison::quality_pretrig, DetId::rawId(), relativeConstraints::ring, CSCDetId::ring(), MyStubComparison::ring, RUN_, trackingPlots::stat, MyStubComparison::station, CSCDetId::station(), stub_tree, stubs_comparison, TreePerStub::t_chamber, TreePerStub::t_endcap, TreePerStub::t_EventNumberAnalyzed, TreePerStub::t_nStubs, TreePerStub::t_nStubs_readout, TreePerStub::t_ring, TreePerStub::t_station, MyStubComparison::totStubs_data, MyStubComparison::totStubs_emul, MyStubComparison::totStubs_emul_readout, CSCDetId::triggerCscId(), CSCDetId::triggerSector(), MyStubComparison::trknmb_data, and MyStubComparison::trknmb_emul.

Referenced by compare().

                                                                                                    {
  // Number of Tbins before pre-trigger for raw cathode hits.
  const int tbin_cathode_offset = 7;
  //const int tbin_cathode_offset = 8;//in MC, it became 8, Tao
  const int pretrig_trig_zone = 5;// max distance between CLCT key hs and pretrigger hs

  // Loop over all chambers in search for CLCTs.
  std::vector<CSCCLCTDigi>::const_iterator pd, pe;
  std::vector<CSCCLCTPreTriggerDigi>::const_iterator pretrig;
  perStub[2].init(RUN_, Event_);
  perStub[3].init(RUN_, Event_);
  for (int endc = 1; endc <= 2; endc++) {
    for (int stat = 1; stat <= 4; stat++) {
      for (int ring = 1; ring <= maxRing(stat); ring++) {
        for (int cham = 1; cham <= 36; cham++) {
          // Calculate DetId.  0th layer means whole chamber.
          CSCDetId detid(endc, stat, ring, cham, 0);

          // Skip chambers marked as bad.
          if (checkBadChambers_ && badChambers_->isInBadChamber(detid)) continue;

          std::vector<CSCCLCTDigi> clctV_data, clctV_emul;
          const auto& drange = clcts_data->get(detid);
          for (auto digiIt = drange.first; digiIt != drange.second; digiIt++) {
            if ((*digiIt).isValid()) {
              clctV_data.push_back(*digiIt);
            }
          }

          const auto& erange = clcts_emul->get(detid);
          std::vector<bool> bookedclctV_emul;
          for (auto digiIt = erange.first; digiIt != erange.second; digiIt++) {
            if ((*digiIt).isValid()) {
              for (auto pclct : clctV_emul){
                if (digiIt->getBX() != pclct.getBX() and abs(digiIt->getBX() - pclct.getBX())< 5)
                  LogTrace("CSCTriggerPrimitivesReader") <<"Two CLCTs very close in timing!!! Special event: first clct "<< pclct <<" second clct "<<*digiIt << std::endl;
              }
              clctV_emul.push_back(*digiIt);
              bookedclctV_emul.push_back(false);
            }
          }

          std::vector<CSCCLCTPreTriggerDigi> pretrigV_emul;
          const auto& pretrigrange = pretrigs_emul->get(detid);
          for (auto pretrigIt = pretrigrange.first; pretrigIt != pretrigrange.second; pretrigIt++){
            if ((*pretrigIt).isValid()){
              pretrigV_emul.push_back(*pretrigIt);
            }
          }

          int ndata = clctV_data.size();
          int nemul = clctV_emul.size();
          if (ndata == 0 && nemul == 0) continue;
          bool firstfill = true;
          int nemul_readout = 0;
          for (pe = clctV_emul.begin(); pe != clctV_emul.end(); pe++) {
            for (pd = clctV_data.begin(); pd != clctV_data.end(); pd++) {
              int emul_bx = (*pe).getBX();
              int corr_bx =
                ((*pd).getFullBX() + emul_bx - tbin_cathode_offset) & 0x03;
              int bx_data = pd->getBX();
              //if (corr_bx == bx_data or abs(pe->getKeyStrip() - pd->getKeyStrip())<=1){//if emulated BX after correction is same as data bx, it will be readout
              if (corr_bx == bx_data){//if emulated BX after correction is same as data bx, it will be readout
                nemul_readout++;
                break;
              }
            }
          }

          if (debug or nemul>ndata or (ndata != nemul) or ndata != nemul_readout) {
            LogTrace("CSCTriggerPrimitivesReader") << " CLCTs from data "<< ndata <<" CLCTs from emul "<< nemul <<" readout "<< nemul_readout;
            ostringstream strstrm;
            strstrm << "\n--- ME" << ((detid.endcap() == 1) ? "+" : "-")
                    << detid.station() << "/" << detid.ring() << "/"
                    << detid.chamber()
                    << " (sector "  << detid.triggerSector()
                    << " trig id. " << detid.triggerCscId() << "):\n";
            strstrm << "  **** " << ndata << " valid data CLCTs found:\n";
            for (pd = clctV_data.begin(); pd != clctV_data.end(); pd++) {
              strstrm << "     " << (*pd)
                      << " Full BX = " << (*pd).getFullBX() << "\n";
            }
            strstrm << "  **** " << nemul << " valid emul CLCTs found:\n";
            for (pe = clctV_emul.begin(); pe != clctV_emul.end(); pe++) {
              strstrm << "     " << (*pe);
              for (pd = clctV_data.begin(); pd != clctV_data.end(); pd++) {
                if ((*pd).getTrknmb() == (*pe).getTrknmb() or abs((*pe).getKeyStrip() - (*pd).getKeyStrip())<5) {
                  int emul_bx = (*pe).getBX();
                  int corr_bx =
                    ((*pd).getFullBX() + emul_bx - tbin_cathode_offset) & 0x03;
                  strstrm << " Corr BX = " << corr_bx;
                  break;
                }
              }
              strstrm << "\n";
            }
            LogTrace("CSCTriggerPrimitivesReader") << strstrm.str();
          }
          if (nemul_readout > 2){ //reduce nemul_readout to 2 by hand
            //cout <<"CLCT matching nemul readout is "<< nemul_readout <<", larger than 2. reduce it to 2 by hand"<<endl;
            nemul_readout = 2;
          }


          //Per event Fill, From Luca
          //Data, add HS quality later
          int perEv_nStub_data = 0;
          int perEv_nStub_emul = 0;
          perStub[2].init(RUN_, Event_);
          perStub[3].init(RUN_, Event_);
          for (pd = clctV_data.begin(); pd != clctV_data.end(); pd++){
            perEv_nStub_data++;
          }
          perStub[2].t_endcap = endc;
          perStub[2].t_station = stat;
          perStub[2].t_chamber = cham;
          perStub[2].t_ring = ring;
          perStub[2].t_EventNumberAnalyzed = eventsAnalyzed;
          perStub[2].t_nStubs              = ndata;
          perStub[2].t_nStubs_readout              = ndata;
          event_tree[2]->Fill();
          //Emul
          for (pe = clctV_emul.begin(); pe != clctV_emul.end(); pe++){
            perEv_nStub_emul++;
          }
          perStub[3].t_endcap = endc;
          perStub[3].t_station = stat;
          perStub[3].t_chamber = cham;
          perStub[3].t_ring = ring;
          perStub[3].t_EventNumberAnalyzed = eventsAnalyzed;
          perStub[3].t_nStubs              = nemul;
          perStub[3].t_nStubs_readout      = nemul_readout;
          event_tree[3]->Fill();


          int csctype = getCSCType(detid);
          hClctCompFoundCsc[endc-1][csctype]->Fill(cham);
          int ix = chamberIX(detid);
          int ix2 = chamberIXi(detid);
          if(detid.station()>1 && detid.ring()==1) {
            hClctCompFound2x->Fill(ix,detid.chamber()*2);
          }
          else {
            hClctCompFound2->Fill(ix,detid.chamber());
          }
          hClctCompFound2i->Fill(ix2,detid.chamber());
          if (ndata != nemul) {
            LogTrace("CSCTriggerPrimitivesReader")
              //cerr
              << "   +++ Different numbers of CLCTs found in ME"
              << ((endc == 1) ? "+" : "-") << stat << "/"
              << ring << "/" << cham
              << ": data = " << ndata << " emulator = " << nemul << " +++\n";
          }
          else {
            hClctCompSameNCsc[endc-1][csctype]->Fill(cham);
            if(detid.station()>1 && detid.ring()==1) {
              hClctCompSameN2x->Fill(ix,detid.chamber()*2);
            }
            else {
              hClctCompSameN2->Fill(ix,detid.chamber());
            }
            hClctCompSameN2i->Fill(ix2,detid.chamber());
          }
          int i=-1;
          int testwg = 20;
          for (pd = clctV_data.begin(); pd != clctV_data.end(); pd++) {
            i++;
            if ((*pd).isValid() == 0) continue;
            int data_trknmb    = (*pd).getTrknmb();
            int data_quality   = (*pd).getQuality();
            int data_pattern   = (*pd).getPattern();
            int data_striptype = (*pd).getStripType();
            int data_bend      = (*pd).getBend();
            int data_keystrip  = (*pd).getKeyStrip();
            int data_cfeb      = (*pd).getCFEB();
            int data_bx        = (*pd).getBX();
            int fullBX = (*pd).getFullBX(); // 12-bit full BX

            if (data_keystrip >= 128 and stat == 1 and ring == 1) testwg=5;
            else testwg = 20;

            stubs_comparison[1].init(RUN_, Event_);
            stubs_comparison[1].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[1].nEvents = eventsAnalyzed;
            stubs_comparison[1].endcap = endc;
            stubs_comparison[1].station = stat;
            stubs_comparison[1].ring = ring;
            stubs_comparison[1].chamber = cham;
            stubs_comparison[1].chambertype = detid.iChamberType();
            stubs_comparison[1].totStubs_data = ndata;
            stubs_comparison[1].totStubs_emul = nemul;
            stubs_comparison[1].totStubs_emul_readout = nemul_readout;
            stubs_comparison[1].nStub_data = i+1;
            stubs_comparison[1].has_data = true;
            stubs_comparison[1].quality_data = (*pd).getQuality();
            stubs_comparison[1].key_hs_data = (*pd).getKeyStrip();
            stubs_comparison[1].bend_data = (*pd).getBend();
            stubs_comparison[1].pattern_data = (*pd).getPattern();
            stubs_comparison[1].bx_data = (*pd).getBX();
            stubs_comparison[1].fullbx_data = (*pd).getFullBX();
            stubs_comparison[1].trknmb_data = data_trknmb;
            GlobalPoint gp_clct_data(getGlobalPosition(detid.rawId(), testwg, (*pd).getKeyStrip()));
            stubs_comparison[1].phi_data = gp_clct_data.phi();

            int j=-1;
            for (pe = clctV_emul.begin(); pe != clctV_emul.end(); pe++) {
              j++;
              if ((*pe).isValid() == 0) continue;
              if (bookedclctV_emul[j]) continue; //used alct
              int emul_trknmb    = (*pe).getTrknmb();
              int emul_quality   = (*pe).getQuality();
              int emul_pattern   = (*pe).getPattern();
              int emul_striptype = (*pe).getStripType();
              int emul_bend      = (*pe).getBend();
              int emul_keystrip  = (*pe).getKeyStrip();
              int emul_cfeb      = (*pe).getCFEB();
              int emul_bx        = (*pe).getBX();

              if (abs(data_keystrip - emul_keystrip) <= 2){
                // Emulator BX re-calculated using 12-bit full BX number.
                // Used for comparison with BX in the data.
                int emul_corr_bx =
                  (fullBX + emul_bx - tbin_cathode_offset) & 0x03;
                //std::cout <<"CLCT data_bx "<< data_bx <<" emul_corr_bx "<< emul_corr_bx << std::endl;
                if (dataIsAnotherMC_)
                  emul_corr_bx = (emul_bx & 0x03);
                if (ndata == nemul) {
                  hClctCompTotalCsc[endc-1][csctype]->Fill(cham);
                  if(detid.station()>1 && detid.ring()==1) {
                    hClctCompTotal2x->Fill(ix,detid.chamber()*2);
                  }
                  else {
                    hClctCompTotal2->Fill(ix,detid.chamber());
                  }
                  hClctCompTotal2i->Fill(ix2,detid.chamber());
                }
                if (data_quality   == emul_quality   &&
                    data_pattern   == emul_pattern   &&
                    data_striptype == emul_striptype &&
                    data_bend      == emul_bend      &&
                    data_keystrip  == emul_keystrip  &&
                    data_cfeb      == emul_cfeb      ){
                  if (ndata == nemul) {
                    hClctCompMatchCsc[endc-1][csctype]->Fill(cham);
                    if(detid.station()>1 && detid.ring()==1) {
                      hClctCompMatch2x->Fill(ix,detid.chamber()*2);
                    }
                    else {
                      hClctCompMatch2->Fill(ix,detid.chamber());
                    }
                    hClctCompMatch2i->Fill(ix2,detid.chamber());
                  }
                  if (debug) LogTrace("CSCTriggerPrimitivesReader")
                               << "       Identical CLCTs #" << data_trknmb;
                }
                else {
                  LogTrace("CSCTriggerPrimitivesReader")
                    << "       Different CLCTs #" << data_trknmb << " in ME"
                    << ((endc == 1) ? "+" : "-") << stat << "/"
                    << ring << "/" << cham <<" data_bx "<< data_bx <<" emul_corr_bx "<< emul_corr_bx;
                }
                stubs_comparison[1].nStub_emul = j+1;
                stubs_comparison[1].has_emul = true;
                stubs_comparison[1].quality_emul = (*pe).getQuality();
                stubs_comparison[1].key_hs_emul = (*pe).getKeyStrip();
                stubs_comparison[1].bend_emul = (*pe).getBend();
                stubs_comparison[1].pattern_emul = (*pe).getPattern();
                stubs_comparison[1].bx_emul = (*pe).getBX();
                stubs_comparison[1].bx_corr_emul = emul_corr_bx;
                stubs_comparison[1].trknmb_emul = emul_trknmb;
                GlobalPoint gp_clct_emul(getGlobalPosition(detid.rawId(), testwg, (*pe).getKeyStrip()));
                stubs_comparison[1].phi_emul = gp_clct_emul.phi();
                bookedclctV_emul[j]  = true;

                //int mingap_trig_pretrig = pretrig_trig_zone*2;
                int num_pretrig = 0;
                for (pretrig = pretrigV_emul.begin(); pretrig != pretrigV_emul.end(); pretrig++){
                  if ((*pretrig).getBX() != (*pe).getBX()) continue;
                  int hsgap = std::abs((*pretrig).getKeyStrip() - (*pe).getKeyStrip());
                  bool samechamber = true;
                  if (stat == 1 and ring == 1)
                    samechamber = (((*pretrig).getKeyStrip() <128 and (*pe).getKeyStrip() <128 ) || ((*pretrig).getKeyStrip() >= 128 and (*pe).getKeyStrip() >=128 ));
                  if (not samechamber)
                    continue;

                  if (hsgap <= pretrig_trig_zone)
                    num_pretrig ++;
                  else
                    continue;
                  if ((*pretrig).getPattern() > stubs_comparison[1].maxpattern_pretrig)
                    stubs_comparison[1].maxpattern_pretrig = (*pretrig).getPattern();
                  if ((*pretrig).getQuality() > stubs_comparison[1].maxquality_pretrig){
                    stubs_comparison[1].quality_pretrig = (*pretrig).getQuality();
                    stubs_comparison[1].key_hs_pretrig = (*pretrig).getKeyStrip();
                    stubs_comparison[1].bend_pretrig = (*pretrig).getBend();
                    stubs_comparison[1].pattern_pretrig = (*pretrig).getPattern();
                    stubs_comparison[1].bx_pretrig = (*pretrig).getBX();
                  }
                }
                stubs_comparison[1].npretrig = num_pretrig;
                break;
              }//if (data_trknmb == emul_trknmb)
            }//loop emul
            if (debug and stubs_comparison[1].key_hs_data != stubs_comparison[1].key_hs_emul)
              LogTrace("CSCTriggerPrimitivesReader")
                <<"CSCDetid "<< detid <<" not matched CLCT from data "<<  (*pd)
                <<" stubs_comparison 1 key_hs_data "<<stubs_comparison[1].key_hs_data <<" key_hs_emul "<< stubs_comparison[1].key_hs_emul << endl;
            //cout <<"CLCT data BX "<< stubs_comparison[1].bx_data <<" emul BX "<< stubs_comparison[1].bx_emul<<" emul BX corrected "<< stubs_comparison[1].bx_corr_emul << endl;
            stub_tree[1]->Fill();
          }//loop data
          for (int k=0; k<nemul; k++){
            if (clctV_emul[i].isValid() == 0) continue;
            if (bookedclctV_emul[k]) continue;
            stubs_comparison[1].init(RUN_, Event_);
            stubs_comparison[1].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[1].nEvents = eventsAnalyzed;
            stubs_comparison[1].endcap = endc;
            stubs_comparison[1].station = stat;
            stubs_comparison[1].ring = ring;
            stubs_comparison[1].chamber = cham;
            stubs_comparison[1].chambertype = detid.iChamberType();
            stubs_comparison[1].totStubs_data = ndata;
            stubs_comparison[1].totStubs_emul = nemul;
            stubs_comparison[1].totStubs_emul_readout = nemul_readout;
            stubs_comparison[1].trknmb_emul = clctV_emul[i].getTrknmb();
            stubs_comparison[1].nStub_data =-1;
            stubs_comparison[1].has_data = false;
            stubs_comparison[1].nStub_emul = k+1;
            stubs_comparison[1].has_emul = true;
            stubs_comparison[1].quality_emul = clctV_emul[k].getQuality();
            stubs_comparison[1].key_hs_emul = clctV_emul[k].getKeyStrip();
            stubs_comparison[1].bend_emul = clctV_emul[k].getBend();
            stubs_comparison[1].pattern_emul = clctV_emul[k].getPattern();
            stubs_comparison[1].bx_emul = clctV_emul[k].getBX();
            stubs_comparison[1].fullbx_emul = clctV_emul[k].getFullBX();
            if (clctV_emul[k].getKeyStrip()>= 128 and stat == 1 and ring == 1) testwg=5;
            else testwg = 20;
            // Emulator BX NOT Known from  the data.
            GlobalPoint gp_clct_emul(getGlobalPosition(detid.rawId(), testwg, clctV_emul[k].getKeyStrip()));
            stubs_comparison[1].phi_emul = gp_clct_emul.phi();
            bookedclctV_emul[k] = true;
            stub_tree[1]->Fill();
          }
        }
      }
    }
  } // for all chambers
} // compareCLCTs

void CSCTriggerPrimitivesReader::compareLCTs ( const CSCCorrelatedLCTDigiCollection *  lcts_data, const CSCCorrelatedLCTDigiCollection *  lcts_emul, const CSCALCTDigiCollection *  alcts_data, const CSCCLCTDigiCollection *  clcts_data  )

private

Definition at line 2065 of file CSCTriggerPrimitivesReader.cc.

References funct::abs(), badChambers_, MyStubComparison::bend_data, MyStubComparison::bend_emul, MyStubComparison::bx_corr_emul, MyStubComparison::bx_data, MyStubComparison::bx_emul, relativeConstraints::cham, CSCDetId::chamber(), MyStubComparison::chamber, chamberIX(), chamberIXi(), MyStubComparison::chambertype, checkBadChambers_, convertBXofLCT(), dataIsAnotherMC_, debug, doesALCTCrossCLCT(), MyStubComparison::endcap, CSCDetId::endcap(), PV3DBase< T, PVType, FrameType >::eta(), MyStubComparison::eta_data, MyStubComparison::eta_emul, Event_, event_tree, eventsAnalyzed, MyStubComparison::firstfill, getCSCType(), getGlobalPosition(), MyStubComparison::has_data, MyStubComparison::has_emul, hLCTCompFound2, hLCTCompFound2i, hLCTCompFound2x, hLctCompFoundCsc, hLCTCompMatch2, hLCTCompMatch2i, hLCTCompMatch2x, hLctCompMatchCsc, hLCTCompSameN2, hLCTCompSameN2i, hLCTCompSameN2x, hLctCompSameNCsc, hLCTCompTotal2, hLCTCompTotal2i, hLCTCompTotal2x, hLctCompTotalCsc, mps_fire::i, CSCDetId::iChamberType(), TreePerStub::init(), MyStubComparison::init(), CSCBadChambers::isInBadChamber(), gen::k, MyStubComparison::key_hs_data, MyStubComparison::key_hs_emul, MyStubComparison::key_WG_data, MyStubComparison::key_WG_emul, LogTrace, maxRing(), MyStubComparison::nEvents, MyStubComparison::nStub_data, MyStubComparison::nStub_emul, or, MyStubComparison::pattern_data, MyStubComparison::pattern_emul, perStub, PV3DBase< T, PVType, FrameType >::phi(), MyStubComparison::phi_data, MyStubComparison::phi_emul, MyStubComparison::quality_data, MyStubComparison::quality_emul, DetId::rawId(), relativeConstraints::ring, CSCDetId::ring(), MyStubComparison::ring, RUN_, trackingPlots::stat, MyStubComparison::station, CSCDetId::station(), stub_tree, stubs_comparison, TreePerStub::t_chamber, TreePerStub::t_endcap, TreePerStub::t_EventNumberAnalyzed, TreePerStub::t_nStubs, TreePerStub::t_nStubs_readout, TreePerStub::t_ring, TreePerStub::t_station, MyStubComparison::totStubs_data, MyStubComparison::totStubs_emul, MyStubComparison::totStubs_emul_readout, CSCDetId::triggerCscId(), CSCDetId::triggerSector(), MyStubComparison::trknmb_data, MyStubComparison::trknmb_emul, MyStubComparison::WGcrossHS_data, and MyStubComparison::WGcrossHS_emul.

Referenced by compare().

                                                                                      {
  // Need ALCT and CLCT digi collections to convert emulator bx into
  // hardware bx.
  // Loop over all chambers in search for correlated LCTs.
  std::vector<CSCCorrelatedLCTDigi>::const_iterator pd, pe;
  for (int endc = 1; endc <= 2; endc++) {
    for (int stat = 1; stat <= 4; stat++) {
      for (int ring = 1; ring <= maxRing(stat); ring++) {
        for (int cham = 1; cham <= 36; cham++) {
          // Calculate DetId.  0th layer means whole chamber.
          CSCDetId detid(endc, stat, ring, cham, 0);

          // Skip chambers marked as bad.
          if (checkBadChambers_ && badChambers_->isInBadChamber(detid)) continue;

          std::vector<CSCCorrelatedLCTDigi> lctV_data, lctV_emul;
          std::vector<bool> bookedlctV_emul;
          const auto& drange = lcts_data->get(detid);
          for (auto digiIt = drange.first; digiIt != drange.second; digiIt++) {
            if ((*digiIt).isValid()) {
              lctV_data.push_back(*digiIt);
            }
          }

          const auto& erange = lcts_emul->get(detid);
          for (auto digiIt = erange.first; digiIt != erange.second; digiIt++) {
            if ((*digiIt).isValid()) {
              lctV_emul.push_back(*digiIt);
              bookedlctV_emul.push_back(false);
            }
          }

          int ndata = lctV_data.size();
          int nemul = lctV_emul.size();
          if (ndata == 0 && nemul == 0) continue;
          bool firstfill = true;
          int nemul_readout = 0;
          for (pe = lctV_emul.begin(); pe != lctV_emul.end(); pe++) {
            for (pd = lctV_data.begin(); pd != lctV_data.end(); pd++) {
              int bx_data = pd->getBX();
              int bx_corr = convertBXofLCT((*pe).getBX(), detid,
                                           alcts_data, clcts_data);
              if ((bx_data == bx_corr) or (abs(pe->getKeyWG() - pd->getKeyWG())<=2 ) ){
                nemul_readout++;
                break;
              }

            }
          }

          if (debug or nemul>ndata or (nemul_readout != ndata) or nemul != ndata) {

            LogTrace("CSCTriggerPrimitivesReader") << " LCTs from data "<< ndata <<" LCTs from emul "<< nemul <<" readout "<< nemul_readout;
            ostringstream strstrm;
            strstrm << "\n--- ME" << ((detid.endcap() == 1) ? "+" : "-")
                    << detid.station() << "/" << detid.ring() << "/"
                    << detid.chamber()
                    << " (sector "  << detid.triggerSector()
                    << " trig id. " << detid.triggerCscId() << "):\n";
            strstrm << "  **** " << ndata << " valid data LCTs found:\n";
            for (pd = lctV_data.begin(); pd != lctV_data.end(); pd++) {
              strstrm << "     " << (*pd);
            }
            strstrm << "\n  **** " << nemul << " valid emul LCTs found:\n";
            for (pe = lctV_emul.begin(); pe != lctV_emul.end(); pe++) {
              strstrm << "     " << (*pe);
              strstrm << "    corr BX = "
                      << convertBXofLCT((*pe).getBX(), detid,
                                        alcts_data, clcts_data);
              strstrm << " LCT pattern = " << (*pe).getPattern();
              strstrm << "\n";

            }
            LogTrace("CSCTriggerPrimitivesReader") << strstrm.str();
            //std::cout <<"CompareLCTs "<< strstrm.str()<< std::endl;
          }
          if (nemul_readout > 2){//reduce nemul_readout to 2 by hand
            //cout <<"LCT matching nemul readout is "<< nemul_readout <<", larger than 2. reduce it to 2 by hand"<<endl;
            nemul_readout = 2;
          }

          //
          //Data, add HS quality later
          int perEv_nStub_data = 0;
          int perEv_nStub_emul = 0;
          perStub[4].init(RUN_, Event_);
          perStub[5].init(RUN_, Event_);
          for (pd = lctV_data.begin(); pd != lctV_data.end(); pd++){
            perEv_nStub_data++;
          }
          perStub[4].t_endcap = endc;
          perStub[4].t_station = stat;
          perStub[4].t_chamber = cham;
          perStub[4].t_ring = ring;
          perStub[4].t_EventNumberAnalyzed = eventsAnalyzed;
          perStub[4].t_nStubs              = ndata;
          perStub[4].t_nStubs_readout              = ndata;
          event_tree[4]->Fill();
          //Emul
          for (pe = lctV_emul.begin(); pe != lctV_emul.end(); pe++){
            perEv_nStub_emul++;
          }
          perStub[5].t_endcap = endc;
          perStub[5].t_station = stat;
          perStub[5].t_chamber = cham;
          perStub[5].t_ring = ring;
          perStub[5].t_EventNumberAnalyzed = eventsAnalyzed;
          perStub[5].t_nStubs              = nemul;
          perStub[5].t_nStubs_readout      = nemul_readout;
          event_tree[5]->Fill();

          int csctype = getCSCType(detid);
          hLctCompFoundCsc[endc-1][csctype]->Fill(cham);
          int ix = chamberIX(detid);
          int ix2 = chamberIXi(detid);
          if(detid.station()>1 && detid.ring()==1) {
            hLCTCompFound2x->Fill(ix,detid.chamber()*2);
          }
          else {
            hLCTCompFound2->Fill(ix,detid.chamber());
          }
          hLCTCompFound2i->Fill(ix2,detid.chamber());
          if (ndata != nemul) {
            LogTrace("CSCTriggerPrimitivesReader")
              //cerr
              << "   +++ Different numbers of LCTs found in ME"
              << ((endc == 1) ? "+" : "-") << stat << "/"
              << ring << "/" << cham
              << ": data = " << ndata << " emulator = " << nemul << " +++\n";
          }
          else {
            hLctCompSameNCsc[endc-1][csctype]->Fill(cham);
            if(detid.station()>1 && detid.ring()==1) {
              hLCTCompSameN2x->Fill(ix,detid.chamber()*2);
            }
            else {
              hLCTCompSameN2->Fill(ix,detid.chamber());
            }
            hLCTCompSameN2i->Fill(ix2,detid.chamber());
          }
          int i =-1;
          for (pd = lctV_data.begin(); pd != lctV_data.end(); pd++) {
            i++;
            if ((*pd).isValid() == 0) continue;
            int data_trknmb    = (*pd).getTrknmb();
            int data_quality   = (*pd).getQuality();
            int data_wiregroup = (*pd).getKeyWG();
            int data_keystrip  = (*pd).getStrip();
            int data_pattern   = (*pd).getCLCTPattern();
            int data_striptype = (*pd).getStripType();
            int data_bend      = (*pd).getBend();
            int data_bx        = (*pd).getBX();

            stubs_comparison[2].init(RUN_, Event_);
            stubs_comparison[2].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[2].nEvents = eventsAnalyzed;
            stubs_comparison[2].endcap = endc;
            stubs_comparison[2].station = stat;
            stubs_comparison[2].ring = ring;
            stubs_comparison[2].chamber = cham;
            stubs_comparison[2].chambertype = detid.iChamberType();
            stubs_comparison[2].totStubs_data = ndata;
            stubs_comparison[2].totStubs_emul = nemul;
            stubs_comparison[2].totStubs_emul_readout = nemul_readout;
            stubs_comparison[2].nStub_data = i+1;
            stubs_comparison[2].has_data = true;
            stubs_comparison[2].quality_data = (*pd).getQuality();
            stubs_comparison[2].key_WG_data = (*pd).getKeyWG();
            stubs_comparison[2].key_hs_data = (*pd).getStrip();
            //cout <<" CSC detid "<< detid <<" LCT in data "<< (*pd) <<" do doesALCTCrossCLCT "<< endl;
            stubs_comparison[2].WGcrossHS_data = doesALCTCrossCLCT(detid,  (*pd).getKeyWG(),  (*pd).getStrip());
            stubs_comparison[2].bend_data = (*pd).getBend();
            stubs_comparison[2].pattern_data = (*pd).getCLCTPattern();
            stubs_comparison[2].bx_data = (*pd).getBX();
            stubs_comparison[2].trknmb_data = data_trknmb;
            GlobalPoint gp_lct_data(getGlobalPosition(detid.rawId(), (*pd).getKeyWG(), (*pd).getStrip()));
            stubs_comparison[2].eta_data = gp_lct_data.eta();
            stubs_comparison[2].phi_data = gp_lct_data.phi();
            int j=-1;
            for (pe = lctV_emul.begin(); pe != lctV_emul.end(); pe++) {
              j++;
              if ((*pe).isValid() == 0) continue;
              if (bookedlctV_emul[j]) continue; //used alct
              int emul_trknmb    = (*pe).getTrknmb();
              int emul_quality   = (*pe).getQuality();
              int emul_wiregroup = (*pe).getKeyWG();
              int emul_keystrip  = (*pe).getStrip();
              int emul_pattern   = (*pe).getCLCTPattern();
              int emul_striptype = (*pe).getStripType();
              int emul_bend      = (*pe).getBend();
              int emul_bx        = (*pe).getBX();
              if (abs(data_keystrip - emul_keystrip) <= 2 || abs(data_wiregroup - emul_wiregroup) <= 2){
                // Convert emulator BX into hardware BX using full 12-bit
                // BX words in ALCT and CLCT digi collections.
                int emul_corr_bx = convertBXofLCT(emul_bx, detid,
                                                  alcts_data, clcts_data);
                //std::cout <<"LCT data_bx "<< data_bx <<" emul_corr_bx "<< emul_corr_bx << std::endl;
                if (dataIsAnotherMC_)
                  emul_corr_bx = (emul_bx & 0x01);

                if (ndata == nemul) {
                  hLctCompTotalCsc[endc-1][csctype]->Fill(cham);
                  if(detid.station()>1 && detid.ring()==1) {
                    hLCTCompTotal2x->Fill(ix,detid.chamber()*2);
                  }
                  else {
                    hLCTCompTotal2->Fill(ix,detid.chamber());
                  }
                  hLCTCompTotal2i->Fill(ix2,detid.chamber());
                }
                if (data_quality   == emul_quality   &&
                    data_wiregroup == emul_wiregroup &&
                    data_keystrip  == emul_keystrip  &&
                    data_pattern   == emul_pattern   &&
                    data_striptype == emul_striptype &&
                    data_bend      == emul_bend      ){
                  if (ndata == nemul) {
                    hLctCompMatchCsc[endc-1][csctype]->Fill(cham);
                    if(detid.station()>1 && detid.ring()==1) {
                      hLCTCompMatch2x->Fill(ix,detid.chamber()*2);
                    }
                    else {
                      hLCTCompMatch2->Fill(ix,detid.chamber());
                    }
                    hLCTCompMatch2i->Fill(ix2,detid.chamber());
                  }
                  if (debug) LogTrace("CSCTriggerPrimitivesReader")
                               << "       Identical LCTs #" << data_trknmb;
                }
                else {
                  LogTrace("CSCTriggerPrimitivesReader")
                    << "       Different LCTs #" << data_trknmb << " in ME"
                    << ((endc == 1) ? "+" : "-") << stat << "/"
                    << ring << "/" << cham <<" data_lct bx "<< data_bx<< " emul bx "<< emul_corr_bx;
                }
                stubs_comparison[2].nStub_emul = j+1;
                stubs_comparison[2].has_emul = true;
                stubs_comparison[2].quality_emul = (*pe).getQuality();
                stubs_comparison[2].key_WG_emul = (*pe).getKeyWG();
                stubs_comparison[2].key_hs_emul = (*pe).getStrip();
                stubs_comparison[2].bend_emul = (*pe).getBend();
                stubs_comparison[2].pattern_emul = (*pe).getCLCTPattern();
                stubs_comparison[2].bx_emul = (*pe).getBX();
                //cout <<" CSC detid "<< detid <<" LCT in emul "<< (*pe) <<" do doesALCTCrossCLCT "<< endl;
                stubs_comparison[2].WGcrossHS_emul = doesALCTCrossCLCT(detid,  (*pe).getKeyWG(),  (*pe).getStrip());
                stubs_comparison[2].bx_corr_emul = emul_corr_bx;
                stubs_comparison[2].trknmb_emul = emul_trknmb;
                GlobalPoint gp_lct_emul(getGlobalPosition(detid.rawId(), (*pe).getKeyWG(), (*pe).getStrip()));
                stubs_comparison[2].eta_emul = gp_lct_emul.eta();
                stubs_comparison[2].phi_emul = gp_lct_emul.phi();
                bookedlctV_emul[j]  = true;
                break;
              }//if (data_trknmb == emul_trknmb)
            }//loop emul
            if (debug and stubs_comparison[2].key_hs_data != stubs_comparison[2].key_hs_emul)
              LogTrace("CSCTriggerPrimitivesReader")
                <<"CSCDetid "<< detid <<" not matched LCT from Data "<< (*pd)
                <<" stubs_comparison 2 key_hs_data "<<stubs_comparison[2].key_hs_data <<" key_hs_emul "<< stubs_comparison[2].key_hs_emul << endl;
            stub_tree[2]->Fill();
          }//loop data
          for (int k=0; k<nemul; k++){
            if (bookedlctV_emul[k]) continue;
            if (lctV_emul[i].isValid() == 0) continue;
            stubs_comparison[2].init(RUN_, Event_);
            stubs_comparison[2].nEvents = eventsAnalyzed;
            stubs_comparison[2].endcap = endc;
            stubs_comparison[2].station = stat;
            stubs_comparison[2].ring = ring;
            stubs_comparison[2].chamber = cham;
            stubs_comparison[2].chambertype = detid.iChamberType();
            stubs_comparison[2].totStubs_data = ndata;
            stubs_comparison[2].totStubs_emul = nemul;
            stubs_comparison[2].totStubs_emul_readout = nemul_readout;
            stubs_comparison[2].trknmb_emul = lctV_emul[i].getTrknmb();
            stubs_comparison[2].nStub_data =-1;
            stubs_comparison[2].has_data = false;
            stubs_comparison[2].nStub_emul = k+1;
            stubs_comparison[2].has_emul = true;
            stubs_comparison[2].WGcrossHS_emul = doesALCTCrossCLCT(detid,  lctV_emul[k].getKeyWG(),  lctV_emul[k].getStrip());
            stubs_comparison[2].quality_emul = lctV_emul[k].getQuality();
            stubs_comparison[2].key_WG_emul = lctV_emul[k].getKeyWG();
            stubs_comparison[2].key_hs_emul = lctV_emul[k].getStrip();
            stubs_comparison[2].bend_emul = lctV_emul[k].getBend();
            stubs_comparison[2].pattern_emul = lctV_emul[k].getCLCTPattern();
            stubs_comparison[2].bx_emul = lctV_emul[k].getBX();
            //stubs_comparison[2].fullbx_emul = lctV_emul[k].getFullBX();
            // Emulator BX NOT Known from  the data.
            GlobalPoint gp_lct_emul(getGlobalPosition(detid.rawId(), lctV_emul[k].getKeyWG(), lctV_emul[k].getStrip()));
            stubs_comparison[2].eta_emul = gp_lct_emul.eta();
            stubs_comparison[2].phi_emul = gp_lct_emul.phi();
            bookedlctV_emul[k] = true;
            stub_tree[2]->Fill();

          }
        }
      }
    }
  }
}