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 cscNeutronWriter_cfi::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, cscNeutronWriter_cfi::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();

          }
        }
      }
    }
  }
}

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

private

Definition at line 2370 of file CSCTriggerPrimitivesReader.cc.

References badChambers_, MyStubComparison::bend_data, MyStubComparison::bend_emul, MyStubComparison::bx_corr_emul, MyStubComparison::bx_data, MyStubComparison::bx_emul, relativeConstraints::cham, CSCDetId::chamber(), MyStubComparison::chamber, MyStubComparison::chambertype, checkBadChambers_, convertBXofLCT(), dataIsAnotherMC_, debug, doesALCTCrossCLCT(), MyStubComparison::endcap, CSCDetId::endcap(), PV3DBase< T, PVType, FrameType >::eta(), MyStubComparison::eta_data, MyStubComparison::eta_emul, Event_, eventsAnalyzed, MyStubComparison::firstfill, getGlobalPosition(), MyStubComparison::has_data, MyStubComparison::has_emul, mps_fire::i, CSCDetId::iChamberType(), 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, MyStubComparison::pattern_data, MyStubComparison::pattern_emul, 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, MyStubComparison::totStubs_data, MyStubComparison::totStubs_emul, CSCDetId::triggerCscId(), CSCDetId::triggerSector(), MyStubComparison::trknmb_data, MyStubComparison::trknmb_emul, MyStubComparison::WGcrossHS_data, and MyStubComparison::WGcrossHS_emul.

                                                                                         {

  // 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;

          if (debug) {
            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;
          }

          //int ix = chamberIX(detid);
          //int ix2 = chamberIXi(detid);
          if (ndata != nemul) {
            LogTrace("CSCTriggerPrimitivesReader")
              << "   +++ Different numbers of MPC 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[3].init(RUN_, Event_);
            stubs_comparison[3].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[3].nEvents = eventsAnalyzed;
            stubs_comparison[3].endcap = endc;
            stubs_comparison[3].station = stat;
            stubs_comparison[3].ring = ring;
            stubs_comparison[3].chamber = cham;
            stubs_comparison[3].chambertype = detid.iChamberType();
            stubs_comparison[3].totStubs_data = ndata;
            stubs_comparison[3].totStubs_emul = nemul;
            stubs_comparison[3].nStub_data = i+1;
            stubs_comparison[3].has_data = true;
            stubs_comparison[3].WGcrossHS_data = doesALCTCrossCLCT(detid,  (*pd).getKeyWG(),  (*pd).getStrip());
            stubs_comparison[3].quality_data = (*pd).getQuality();
            stubs_comparison[3].key_WG_data = (*pd).getKeyWG();
            stubs_comparison[3].key_hs_data = (*pd).getStrip();
            stubs_comparison[3].bend_data = (*pd).getBend();
            stubs_comparison[3].pattern_data = (*pd).getCLCTPattern();
            stubs_comparison[3].bx_data = (*pd).getBX();
            stubs_comparison[3].trknmb_data = data_trknmb;
            GlobalPoint gp_lct_data(getGlobalPosition(detid.rawId(), (*pd).getKeyWG(), (*pd).getStrip()));
            stubs_comparison[3].eta_data = gp_lct_data.eta();
            stubs_comparison[3].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;
              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 (data_trknmb == emul_trknmb) {
                // 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      ){
                  //data_bx        == emul_corr_bx) {
                  /*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;
                  stubs_comparison[3].nStub_emul = j+1;
                  stubs_comparison[3].has_emul = true;
                  stubs_comparison[3].WGcrossHS_emul = doesALCTCrossCLCT(detid,  (*pe).getKeyWG(),  (*pe).getStrip());
                  stubs_comparison[3].quality_emul = (*pe).getQuality();
                  stubs_comparison[3].key_WG_emul = (*pe).getKeyWG();
                  stubs_comparison[3].key_hs_emul = (*pe).getStrip();
                  stubs_comparison[3].bend_emul = (*pe).getBend();
                  stubs_comparison[3].pattern_emul = (*pe).getCLCTPattern();
                  stubs_comparison[3].bx_emul = (*pe).getBX();
                  stubs_comparison[3].bx_corr_emul = emul_corr_bx;
                  stubs_comparison[3].trknmb_emul = emul_trknmb;
                  GlobalPoint gp_lct_emul(getGlobalPosition(detid.rawId(), (*pe).getKeyWG(), (*pe).getStrip()));
                  stubs_comparison[3].eta_emul = gp_lct_emul.eta();
                  stubs_comparison[3].phi_emul = gp_lct_emul.phi();
                  bookedlctV_emul[j]  = true;
                  break;
                }
                else {
                  LogTrace("CSCTriggerPrimitivesReader")
                    //cerr
                    << "       Different LCTs #" << data_trknmb << " in ME"
                    << ((endc == 1) ? "+" : "-") << stat << "/"
                    << ring << "/" << cham <<" data_lct bx "<< data_bx<< " emul bx "<< emul_corr_bx;
                }
              }
            }//loop emul
            if (debug and stubs_comparison[3].key_hs_data != stubs_comparison[3].key_hs_emul)
              LogTrace("CSCTriggerPrimitivesReader")
                <<"stubs_comparison 2 key_hs_data "<<stubs_comparison[3].key_hs_data <<" key_hs_emul "<< stubs_comparison[3].key_hs_emul;
            stub_tree[3]->Fill();
          }//loop data

          for (int k=0; k<nemul; k++){
            if (bookedlctV_emul[k]) continue;
            stubs_comparison[3].init(RUN_, Event_);
            stubs_comparison[3].firstfill = firstfill;
            if (firstfill) firstfill = false;
            stubs_comparison[3].nEvents = eventsAnalyzed;
            stubs_comparison[3].endcap = endc;
            stubs_comparison[3].station = stat;
            stubs_comparison[3].ring = ring;
            stubs_comparison[3].chamber = cham;
            stubs_comparison[3].chambertype = detid.iChamberType();
            stubs_comparison[3].totStubs_data = ndata;
            stubs_comparison[3].totStubs_emul = nemul;
            stubs_comparison[3].trknmb_emul = lctV_emul[i].getTrknmb();
            stubs_comparison[3].nStub_data =-1;
            stubs_comparison[3].has_data = false;
            stubs_comparison[3].nStub_emul = k+1;
            stubs_comparison[3].has_emul = true;
            stubs_comparison[3].WGcrossHS_emul = doesALCTCrossCLCT(detid, lctV_emul[k].getKeyWG(),  lctV_emul[k].getStrip());
            stubs_comparison[3].quality_emul = lctV_emul[k].getQuality();
            stubs_comparison[3].key_WG_emul = lctV_emul[k].getKeyWG();
            stubs_comparison[3].key_hs_emul = lctV_emul[k].getStrip();
            stubs_comparison[3].bend_emul = lctV_emul[k].getBend();
            stubs_comparison[3].pattern_emul = lctV_emul[k].getCLCTPattern();
            stubs_comparison[3].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[3].eta_emul = gp_lct_emul.eta();
            stubs_comparison[3].phi_emul = gp_lct_emul.phi();
            bookedlctV_emul[k] = true;
            stub_tree[3]->Fill();

          }
        }//end loop of chambers
      }
    }
  }
}

int CSCTriggerPrimitivesReader::convertBXofLCT ( const int  emul_bx, const CSCDetId &  detid, const CSCALCTDigiCollection *  alcts_data, const CSCCLCTDigiCollection *  clcts_data  )

private

Definition at line 2617 of file CSCTriggerPrimitivesReader.cc.

Referenced by compareLCTs(), and compareMPCLCTs().

                                                                                        {
  int full_anode_bx = -999;
  //int full_cathode_bx = -999;
  int lct_bx = -999;
  int tbin_anode_offset = 5; // 2007, run 14419.

  // Extract full 12-bit anode BX word from ALCT collections.
  const auto& arange = alcts_data->get(detid);
  for (auto digiIt = arange.first; digiIt != arange.second; digiIt++) {
    if ((*digiIt).isValid()) {
      full_anode_bx = (*digiIt).getFullBX();
      break;
    }
  }

  // Extract full 12-bit cathode BX word from CLCT collections.
  const auto& crange = clcts_data->get(detid);
  for (auto digiIt = crange.first; digiIt != crange.second; digiIt++) {
    if ((*digiIt).isValid()) {
      //full_cathode_bx = (*digiIt).getFullBX();
      break;
    }
  }

  // Use these 12-bit BX's to convert emulator BX into hardware BX.
  if (full_anode_bx == -999) {
    // What to do???
    edm::LogWarning("L1CSCTPEmulatorWrongInput")
      << "+++ Warning in convertBXofLCT(): full anode BX is not available!"
      << " +++\n";
  }
  else {
    // LCT BX has two bits: the least-significant bit is the LSB of ALCT BX;
    // the MSB is 1/0 depending on whether the 12-bit full cathode BX is 0
    // or not.
    lct_bx = (full_anode_bx + emul_bx - tbin_anode_offset) & 0x01;
    // SV, 12/Jun/08: it looks like this bit is never set - docu must be
    // wrong.
    //lct_bx = lct_bx | ((full_cathode_bx == 0) << 1);
  }
  //std::cout <<"convertBXofLCT old emul_bx "<< emul_bx <<" new lct bx "<< lct_bx <<" ful_anode_bx "<< full_anode_bx << std::endl;
  return lct_bx;
}

bool CSCTriggerPrimitivesReader::doesALCTCrossCLCT ( CSCDetId  id, int  key_wg, int  key_hs  ) const

private

Definition at line 4472 of file CSCTriggerPrimitivesReader.cc.

References gangedME1a, lut_wg_vs_hs_me1a, lut_wg_vs_hs_me1ag, lut_wg_vs_hs_me1b, CSCConstants::MAX_HALF_STRIP_ME1A_GANGED, CSCConstants::MAX_HALF_STRIP_ME1A_UNGANGED, CSCConstants::MAX_HALF_STRIP_ME1B, or, and relativeConstraints::ring.

Referenced by compareLCTs(), and compareMPCLCTs().

{

  bool isME11 = (id.station() ==1 and (id.ring()==1 or id.ring()==4));
  if (not isME11) return true;

  int theEndcap = (id.endcap() == 1)?1 : 2;

  if (key_hs > CSCConstants::MAX_HALF_STRIP_ME1B)
    {
      key_hs = key_hs - CSCConstants::MAX_HALF_STRIP_ME1B -1;//convert it from 128-223 -> 0-95
      if ( !gangedME1a )
        {
          // wrap around ME11 HS number for -z endcap
          if (theEndcap==2) key_hs = CSCConstants::MAX_HALF_STRIP_ME1A_UNGANGED - key_hs;
          if ( key_hs >= lut_wg_vs_hs_me1a[key_wg][0] &&
               key_hs <= lut_wg_vs_hs_me1a[key_wg][1]    ) return true;
          return false;
        }
      else
        {
          if (theEndcap==2) key_hs = CSCConstants::MAX_HALF_STRIP_ME1A_GANGED - key_hs;
          if ( key_hs >= lut_wg_vs_hs_me1ag[key_wg][0] &&
               key_hs <= lut_wg_vs_hs_me1ag[key_wg][1]    ) return true;
          return false;
        }
    }
  if ( key_hs <= CSCConstants::MAX_HALF_STRIP_ME1B)
    {
      if (theEndcap==2) key_hs = CSCConstants::MAX_HALF_STRIP_ME1B - key_hs;
      if ( key_hs >= lut_wg_vs_hs_me1b[key_wg][0] &&
           key_hs <= lut_wg_vs_hs_me1b[key_wg][1]      ) return true;
    }
  return false;
}

void CSCTriggerPrimitivesReader::drawALCTHistos ( )

private

Definition at line 3129 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, csc_type, CSC_TYPES, alignmentValidation::fname, hAlctAccel, hAlctBXN, hAlctCollis, hAlctCsc, hAlctKeyGroup, hAlctPerChamber, hAlctPerCSC, hAlctPerEvent, hAlctQuality, hAlctValid, mps_fire::i, MAX_ENDCAPS, MAXPAGES, postprocess-scan-build::page, plotME1A, plotME42, resultsFileNamesPrefix_, lumiQTWidget::t, and runGCPTkAlMap::title.

Referenced by endJob().

                                                {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  string fname = resultsFileNamesPrefix_+"alcts.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[7], titl[50];
  TPaveLabel *title;

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "Number of ALCTs");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(1,3);
  pad[page]->cd(1);  hAlctPerEvent->Draw();
  pad[page]->cd(2);  hAlctPerChamber->Draw();
  for (int i = 0; i < CSC_TYPES; i++) {
    hAlctPerCSC->GetXaxis()->SetBinLabel(i+1, csc_type[i].c_str());
  }
  // Should be multiplied by 40/nevents to convert to MHz
  pad[page]->cd(3);  hAlctPerCSC->Draw();
  page++;  c1->Update();

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "ALCTs per chamber, endcap %d", endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    gStyle->SetOptStat(10);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hAlctCsc[endc][idh]->SetMinimum(0.0);
      pad[page]->cd(idh+1);  hAlctCsc[endc][idh]->Draw();
    }
    page++;  c1->Update();
  }

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "ALCT quantities");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(2,3);
  pad[page]->cd(1);  hAlctValid->Draw();
  pad[page]->cd(2);  hAlctQuality->Draw();
  pad[page]->cd(3);  hAlctAccel->Draw();
  pad[page]->cd(4);  hAlctCollis->Draw();
  pad[page]->cd(5);  hAlctKeyGroup->Draw();
  pad[page]->cd(6);  hAlctBXN->Draw();
  page++;  c1->Update();

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::drawCLCTHistos ( )

private

Definition at line 3203 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, csc_type, CSC_TYPES, alignmentValidation::fname, hClctBendCsc, hClctBXN, hClctCFEB, hClctCsc, hClctKeyStrip, hClctPattern, hClctPerChamber, hClctPerCSC, hClctPerEvent, hClctQuality, hClctSign, hClctValid, mps_fire::i, MAX_ENDCAPS, MAXPAGES, pileupCalc::nbins, postprocess-scan-build::page, plotME1A, plotME42, resultsFileNamesPrefix_, lumiQTWidget::t, and runGCPTkAlMap::title.

Referenced by endJob().

                                                {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  string fname = resultsFileNamesPrefix_+"clcts.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[7], titl[50];
  TPaveLabel *title;

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "Number of CLCTs");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(1,3);
  pad[page]->cd(1);  hClctPerEvent->Draw();

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  edm::LogInfo("CSCTriggerPrimitivesReader") << "\n";
  int nbins = hClctPerChamber->GetNbinsX();
  for (int ibin = 1; ibin <= nbins; ibin++) {
    double f_bin = hClctPerChamber->GetBinContent(ibin);
    edm::LogInfo("CSCTriggerPrimitivesReader")
      << "  # CLCTs/chamber: " << ibin-1 << "; events: " << f_bin << endl;
  }

  pad[page]->cd(2);  hClctPerChamber->Draw();
  for (int i = 0; i < CSC_TYPES; i++) {
    hClctPerCSC->GetXaxis()->SetBinLabel(i+1, csc_type[i].c_str());
  }
  // Should be multiplied by 40/nevents to convert to MHz
  pad[page]->cd(3);  hClctPerCSC->Draw();
  page++;  c1->Update();

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "CLCTs per chamber, endcap %d", endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    gStyle->SetOptStat(10);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hClctCsc[endc][idh]->SetMinimum(0.0);
      pad[page]->cd(idh+1);  hClctCsc[endc][idh]->Draw();
    }
    page++;  c1->Update();
  }

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "CLCT quantities");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(2,4);
  pad[page]->cd(1);  hClctValid->Draw();
  pad[page]->cd(2);  hClctQuality->Draw();
  pad[page]->cd(3);  hClctSign->Draw();
  hClctPattern[1]->SetTitle("CLCT pattern #");
  pad[page]->cd(4);  hClctPattern[1]->Draw();
  pad[page]->cd(5);  hClctCFEB->Draw();
  pad[page]->cd(7);  hClctKeyStrip[1]->Draw();
  pad[page]->cd(8);  hClctBXN->Draw();
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "CLCT bend for various chamber types, halfstrips");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(110);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    pad[page]->cd(idh+1);
    hClctBendCsc[idh][1]->GetXaxis()->SetTitle("Pattern bend");
    hClctBendCsc[idh][1]->GetYaxis()->SetTitle("Number of LCTs");
    hClctBendCsc[idh][1]->Draw();
  }
  page++;  c1->Update();

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::drawCompHistos ( )

private

Definition at line 3476 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, CSC_TYPES, relativeConstraints::error, alignmentValidation::fname, hAlctCompFoundCsc, hAlctCompMatchCsc, hAlctCompSameNCsc, hAlctCompTotalCsc, hClctCompFoundCsc, hClctCompMatchCsc, hClctCompSameNCsc, hClctCompTotalCsc, hLctCompFoundCsc, hLctCompMatchCsc, hLctCompSameNCsc, hLctCompTotalCsc, MAX_ENDCAPS, MAXPAGES, pileupCalc::nbins, postprocess-scan-build::page, plotME1A, plotME42, particleFlowDisplacedVertex_cfi::ratio, resultsFileNamesPrefix_, mathSSE::sqrt(), lumiQTWidget::t, and runGCPTkAlMap::title.

Referenced by endJob().

                                                {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  string fname = resultsFileNamesPrefix_+"lcts_comp.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[15];
  TPaveLabel *title;
  Int_t nbins;

  TText teff;
  teff.SetTextFont(32);
  teff.SetTextSize(0.08);
  char eff[25], titl[60];

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) { // endcaps
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "ALCT firmware-emulator: match in number found, endcap %d",
            endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    //gStyle->SetOptStat(110010);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hAlctFoundEffVsCsc[MAX_ENDCAPS][CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hAlctFoundEffVsCsc[endc][idh] =
        (TH1F*)hAlctCompFoundCsc[endc][idh]->Clone();
      hAlctFoundEffVsCsc[endc][idh]->Divide(hAlctCompSameNCsc[endc][idh],
                                            hAlctCompFoundCsc[endc][idh],
                                            1., 1., "B");
      nbins = hAlctCompFoundCsc[endc][idh]->GetNbinsX();
      for (Int_t ibin = 1; ibin <= nbins; ibin++) {
        if (hAlctCompFoundCsc[endc][idh]->GetBinContent(ibin) == 0) {
          hAlctFoundEffVsCsc[endc][idh]->SetBinContent(ibin, -1.);
          hAlctFoundEffVsCsc[endc][idh]->SetBinError(ibin, 0.);
        }
      }
      gPad->Update();  gStyle->SetStatX(0.65);
      hAlctFoundEffVsCsc[endc][idh]->SetMinimum(-0.05);
      hAlctFoundEffVsCsc[endc][idh]->SetMaximum(1.05);
      hAlctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitleOffset(0.7);
      hAlctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitleOffset(0.8);
      hAlctFoundEffVsCsc[endc][idh]->GetXaxis()->SetLabelSize(0.06); // default=0.04
      hAlctFoundEffVsCsc[endc][idh]->GetYaxis()->SetLabelSize(0.06); // default=0.04
      hAlctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitleSize(0.07); // default=0.05
      hAlctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitleSize(0.07); // default=0.05
      hAlctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitle("CSC id");
      hAlctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitle("% of same number found");
      pad[page]->cd(idh+1);  hAlctFoundEffVsCsc[endc][idh]->Draw("e");
      double numer = hAlctCompSameNCsc[endc][idh]->Integral();
      double denom = hAlctCompFoundCsc[endc][idh]->Integral();
      double ratio = 0.0, error = 0.0;
      if (denom > 0.) {
        ratio = numer/denom;
        error = sqrt(ratio*(1.-ratio)/denom);
      }
      sprintf(eff, "eff = (%4.1f +/- %4.1f)%%", ratio*100., error*100.);
      teff.DrawTextNDC(0.3, 0.5, eff);
    }
    page++;  c1->Update();
  }

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) { // endcaps
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "ALCT firmware-emulator: exact match, endcap %d", endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    //gStyle->SetOptStat(110010);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hAlctMatchEffVsCsc[MAX_ENDCAPS][CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hAlctMatchEffVsCsc[endc][idh] =
        (TH1F*)hAlctCompTotalCsc[endc][idh]->Clone();
      hAlctMatchEffVsCsc[endc][idh]->Divide(hAlctCompMatchCsc[endc][idh],
                                            hAlctCompTotalCsc[endc][idh],
                                            1., 1., "B");
      nbins = hAlctCompTotalCsc[endc][idh]->GetNbinsX();
      for (Int_t ibin = 1; ibin <= nbins; ibin++) {
        if (hAlctCompTotalCsc[endc][idh]->GetBinContent(ibin) == 0) {
          hAlctMatchEffVsCsc[endc][idh]->SetBinContent(ibin, -1.);
          hAlctMatchEffVsCsc[endc][idh]->SetBinError(ibin, 0.);
        }
      }
      gPad->Update();  gStyle->SetStatX(0.65);
      hAlctMatchEffVsCsc[endc][idh]->SetMinimum(-0.05);
      hAlctMatchEffVsCsc[endc][idh]->SetMaximum(1.05);
      hAlctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitleOffset(0.7);
      hAlctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitleOffset(0.8);
      hAlctMatchEffVsCsc[endc][idh]->GetXaxis()->SetLabelSize(0.06);
      hAlctMatchEffVsCsc[endc][idh]->GetYaxis()->SetLabelSize(0.06);
      hAlctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitleSize(0.07);
      hAlctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitleSize(0.07);
      hAlctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitle("CSC id");
      hAlctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitle("% of exact match");
      pad[page]->cd(idh+1);  hAlctMatchEffVsCsc[endc][idh]->Draw("e");
      double numer = hAlctCompMatchCsc[endc][idh]->Integral();
      double denom = hAlctCompTotalCsc[endc][idh]->Integral();
      double ratio = 0.0, error = 0.0;
      if (denom > 0.) {
        ratio = numer/denom;
        error = sqrt(ratio*(1.-ratio)/denom);
      }
      sprintf(eff, "eff = (%4.1f +/- %4.1f)%%", ratio*100., error*100.);
      teff.DrawTextNDC(0.3, 0.5, eff);
    }
    page++;  c1->Update();
  }

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "CLCT firmware-emulator: match in number found, endcap %d",
            endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    //gStyle->SetOptStat(110010);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hClctFoundEffVsCsc[MAX_ENDCAPS][CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hClctFoundEffVsCsc[endc][idh] =
        (TH1F*)hClctCompFoundCsc[endc][idh]->Clone();
      hClctFoundEffVsCsc[endc][idh]->Divide(hClctCompSameNCsc[endc][idh],
                                            hClctCompFoundCsc[endc][idh],
                                            1., 1., "B");
      nbins = hClctCompFoundCsc[endc][idh]->GetNbinsX();
      for (Int_t ibin = 1; ibin <= nbins; ibin++) {
        if (hClctCompFoundCsc[endc][idh]->GetBinContent(ibin) == 0) {
          hClctFoundEffVsCsc[endc][idh]->SetBinContent(ibin, -1.);
          hClctFoundEffVsCsc[endc][idh]->SetBinError(ibin, 0.);
        }
      }
      gPad->Update();  gStyle->SetStatX(0.65);
      hClctFoundEffVsCsc[endc][idh]->SetMinimum(-0.05);
      hClctFoundEffVsCsc[endc][idh]->SetMaximum(1.05);
      hClctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitleOffset(0.7);
      hClctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitleOffset(0.8);
      hClctFoundEffVsCsc[endc][idh]->GetXaxis()->SetLabelSize(0.06);
      hClctFoundEffVsCsc[endc][idh]->GetYaxis()->SetLabelSize(0.06);
      hClctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitleSize(0.07);
      hClctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitleSize(0.07);
      hClctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitle("CSC id");
      hClctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitle("% of same number found");
      pad[page]->cd(idh+1);  hClctFoundEffVsCsc[endc][idh]->Draw("e");
      double numer = hClctCompSameNCsc[endc][idh]->Integral();
      double denom = hClctCompFoundCsc[endc][idh]->Integral();
      double ratio = 0.0, error = 0.0;
      if (denom > 0.) {
        ratio = numer/denom;
        error = sqrt(ratio*(1.-ratio)/denom);
      }
      sprintf(eff, "eff = (%4.1f +/- %4.1f)%%", ratio*100., error*100.);
      teff.DrawTextNDC(0.3, 0.5, eff);
    }
    page++;  c1->Update();
  }

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "CLCT firmware-emulator: exact match, endcap %d", endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    //gStyle->SetOptStat(110010);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hClctMatchEffVsCsc[MAX_ENDCAPS][CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hClctMatchEffVsCsc[endc][idh] =
        (TH1F*)hClctCompTotalCsc[endc][idh]->Clone();
      hClctMatchEffVsCsc[endc][idh]->Divide(hClctCompMatchCsc[endc][idh],
                                            hClctCompTotalCsc[endc][idh],
                                            1., 1., "B");
      nbins = hClctCompTotalCsc[endc][idh]->GetNbinsX();
      for (Int_t ibin = 1; ibin <= nbins; ibin++) {
        if (hClctCompTotalCsc[endc][idh]->GetBinContent(ibin) == 0) {
          hClctMatchEffVsCsc[endc][idh]->SetBinContent(ibin, -1.);
          hClctMatchEffVsCsc[endc][idh]->SetBinError(ibin, 0.);
        }
      }
      gPad->Update();  gStyle->SetStatX(0.65);
      hClctMatchEffVsCsc[endc][idh]->SetMinimum(-0.05);
      hClctMatchEffVsCsc[endc][idh]->SetMaximum(1.05);
      hClctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitleOffset(0.7);
      hClctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitleOffset(0.8);
      hClctMatchEffVsCsc[endc][idh]->GetXaxis()->SetLabelSize(0.06);
      hClctMatchEffVsCsc[endc][idh]->GetYaxis()->SetLabelSize(0.06);
      hClctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitleSize(0.07);
      hClctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitleSize(0.07);
      hClctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitle("CSC id");
      hClctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitle("% of exact match");
      pad[page]->cd(idh+1);  hClctMatchEffVsCsc[endc][idh]->Draw("e");
      double numer = hClctCompMatchCsc[endc][idh]->Integral();
      double denom = hClctCompTotalCsc[endc][idh]->Integral();
      double ratio = 0.0, error = 0.0;
      if (denom > 0.) {
        ratio = numer/denom;
        error = sqrt(ratio*(1.-ratio)/denom);
      }
      sprintf(eff, "eff = (%4.1f +/- %4.1f)%%", ratio*100., error*100.);
      teff.DrawTextNDC(0.3, 0.5, eff);
    }
    page++;  c1->Update();
  }

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "LCT firmware-emulator: match in number found, endcap %d",
            endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    //gStyle->SetOptStat(110010);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hLctFoundEffVsCsc[MAX_ENDCAPS][CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hLctFoundEffVsCsc[endc][idh] =
        (TH1F*)hLctCompFoundCsc[endc][idh]->Clone();
      hLctFoundEffVsCsc[endc][idh]->Divide(hLctCompSameNCsc[endc][idh],
                                           hLctCompFoundCsc[endc][idh],
                                           1., 1., "B");
      nbins = hLctCompFoundCsc[endc][idh]->GetNbinsX();
      for (Int_t ibin = 1; ibin <= nbins; ibin++) {
        if (hLctCompFoundCsc[endc][idh]->GetBinContent(ibin) == 0) {
          hLctFoundEffVsCsc[endc][idh]->SetBinContent(ibin, -1.);
          hLctFoundEffVsCsc[endc][idh]->SetBinError(ibin, 0.);
        }
      }
      gPad->Update();  gStyle->SetStatX(0.65);
      hLctFoundEffVsCsc[endc][idh]->SetMinimum(-0.05);
      hLctFoundEffVsCsc[endc][idh]->SetMaximum(1.05);
      hLctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitleOffset(0.7);
      hLctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitleOffset(0.8);
      hLctFoundEffVsCsc[endc][idh]->GetXaxis()->SetLabelSize(0.06);
      hLctFoundEffVsCsc[endc][idh]->GetYaxis()->SetLabelSize(0.06);
      hLctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitleSize(0.07);
      hLctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitleSize(0.07);
      hLctFoundEffVsCsc[endc][idh]->GetXaxis()->SetTitle("CSC id");
      hLctFoundEffVsCsc[endc][idh]->GetYaxis()->SetTitle("% of same number found");
      pad[page]->cd(idh+1);  hLctFoundEffVsCsc[endc][idh]->Draw("e");
      double numer = hLctCompSameNCsc[endc][idh]->Integral();
      double denom = hLctCompFoundCsc[endc][idh]->Integral();
      double ratio = 0.0, error = 0.0;
      if (denom > 0.) {
        ratio = numer/denom;
        error = sqrt(ratio*(1.-ratio)/denom);
      }
      sprintf(eff, "eff = (%4.1f +/- %4.1f)%%", ratio*100., error*100.);
      teff.DrawTextNDC(0.3, 0.5, eff);
    }
    page++;  c1->Update();
  }

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "LCT firmware-emulator: exact match, endcap %d", endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    //gStyle->SetOptStat(110010);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hLctMatchEffVsCsc[MAX_ENDCAPS][CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hLctMatchEffVsCsc[endc][idh] =
        (TH1F*)hLctCompTotalCsc[endc][idh]->Clone();
      hLctMatchEffVsCsc[endc][idh]->Divide(hLctCompMatchCsc[endc][idh],
                                           hLctCompTotalCsc[endc][idh],
                                           1., 1., "B");
      nbins = hLctCompTotalCsc[endc][idh]->GetNbinsX();
      for (Int_t ibin = 1; ibin <= nbins; ibin++) {
        if (hLctCompTotalCsc[endc][idh]->GetBinContent(ibin) == 0) {
          hLctMatchEffVsCsc[endc][idh]->SetBinContent(ibin, -1.);
          hLctMatchEffVsCsc[endc][idh]->SetBinError(ibin, 0.);
        }
      }
      gPad->Update();  gStyle->SetStatX(0.65);
      hLctMatchEffVsCsc[endc][idh]->SetMinimum(-0.05);
      hLctMatchEffVsCsc[endc][idh]->SetMaximum(1.05);
      hLctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitleOffset(0.7);
      hLctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitleOffset(0.8);
      hLctMatchEffVsCsc[endc][idh]->GetXaxis()->SetLabelSize(0.06);
      hLctMatchEffVsCsc[endc][idh]->GetYaxis()->SetLabelSize(0.06);
      hLctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitleSize(0.07);
      hLctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitleSize(0.07);
      hLctMatchEffVsCsc[endc][idh]->GetXaxis()->SetTitle("CSC id");
      hLctMatchEffVsCsc[endc][idh]->GetYaxis()->SetTitle("% of exact match");
      pad[page]->cd(idh+1);  hLctMatchEffVsCsc[endc][idh]->Draw("e");
      double numer = hLctCompMatchCsc[endc][idh]->Integral();
      double denom = hLctCompTotalCsc[endc][idh]->Integral();
      double ratio = 0.0, error = 0.0;
      if (denom > 0.) {
        ratio = numer/denom;
        error = sqrt(ratio*(1.-ratio)/denom);
      }
      sprintf(eff, "eff = (%4.1f +/- %4.1f)%%", ratio*100., error*100.);
      teff.DrawTextNDC(0.3, 0.5, eff);
    }
    page++;  c1->Update();
  }

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::drawEfficHistos ( )

private

Definition at line 4118 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, csc_type, CSC_TYPES, alignmentValidation::fname, hEfficALCTEta, hEfficALCTEtaCsc, hEfficCLCTEta, hEfficCLCTEtaCsc, hEfficHitsEta, hEfficHitsEtaCsc, MAX_STATIONS, MAXPAGES, postprocess-scan-build::page, plotME1A, plotME42, resultsFileNamesPrefix_, lumiQTWidget::t, and runGCPTkAlMap::title.

Referenced by endJob().

                                                 {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 700);
  string fname = resultsFileNamesPrefix_+"lcts_effic.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[7];
  TPaveLabel *title;
  char histtitle[60];

  gStyle->SetOptDate(0);
  gStyle->SetTitleSize(0.1, "");   // size for pad title; default is 0.02

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "ALCT efficiency vs #eta");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(0);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  TH1F *hALCTEffVsEta[MAX_STATIONS];
  for (int istation = 0; istation < MAX_STATIONS; istation++) {
    hALCTEffVsEta[istation] = (TH1F*)hEfficHitsEta[istation]->Clone();
    hALCTEffVsEta[istation]->Divide(hEfficALCTEta[istation],
                                    hEfficHitsEta[istation], 1., 1., "B");
    hALCTEffVsEta[istation]->GetXaxis()->SetTitleOffset(1.2);
    hALCTEffVsEta[istation]->GetXaxis()->SetTitle("#eta");
    hALCTEffVsEta[istation]->SetMaximum(1.05);
    sprintf(histtitle, "ALCT efficiency vs #eta, station %d", istation+1);
    hALCTEffVsEta[istation]->SetTitle(histtitle);
    pad[page]->cd(istation+1);  hALCTEffVsEta[istation]->Draw();
  }
  page++;  c1->Update();

  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "ALCT efficiency vs #eta");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(11111);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  TH1F *hALCTEffVsEtaCsc[CSC_TYPES];
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hALCTEffVsEtaCsc[idh] = (TH1F*)hEfficHitsEtaCsc[idh]->Clone();
    hALCTEffVsEtaCsc[idh]->Divide(hEfficALCTEtaCsc[idh],
                                  hEfficHitsEtaCsc[idh], 1., 1., "B");
    if (idh == 3 || idh == 4 || idh == 6 || idh == 8) {
      gPad->Update();  gStyle->SetStatX(0.43);
    }
    else {
      gPad->Update();  gStyle->SetStatX(1.00);
    }
    hALCTEffVsEtaCsc[idh]->GetXaxis()->SetTitle("#eta");
    hALCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleOffset(0.8);
    hALCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleSize(0.07); // default=0.05
    hALCTEffVsEtaCsc[idh]->GetXaxis()->SetLabelSize(0.10); // default=0.04
    hALCTEffVsEtaCsc[idh]->GetYaxis()->SetLabelSize(0.10);
    hALCTEffVsEtaCsc[idh]->SetLabelOffset(0.012, "XY");
    hALCTEffVsEtaCsc[idh]->SetMinimum(0.50);
    hALCTEffVsEtaCsc[idh]->SetMaximum(1.05);
    hALCTEffVsEtaCsc[idh]->SetTitle(csc_type[idh].c_str());
    hALCTEffVsEtaCsc[idh]->SetTitleSize(0.1, "");
    hALCTEffVsEtaCsc[idh]->SetLineWidth(2);
    hALCTEffVsEtaCsc[idh]->SetLineColor(4);
    pad[page]->cd(idh+1);  gPad->SetGrid(1);  hALCTEffVsEtaCsc[idh]->Draw();
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "CLCT efficiency vs #eta");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(0);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  TH1F *hCLCTEffVsEta[MAX_STATIONS];
  for (int istation = 0; istation < MAX_STATIONS; istation++) {
    hCLCTEffVsEta[istation] = (TH1F*)hEfficHitsEta[istation]->Clone();
    hCLCTEffVsEta[istation]->Divide(hEfficCLCTEta[istation],
                                    hEfficHitsEta[istation], 1., 1., "B");
    hCLCTEffVsEta[istation]->GetXaxis()->SetTitleOffset(1.2);
    hCLCTEffVsEta[istation]->GetXaxis()->SetTitle("#eta");
    hCLCTEffVsEta[istation]->SetMaximum(1.05);
    sprintf(histtitle, "CLCT efficiency vs #eta, station %d", istation+1);
    hCLCTEffVsEta[istation]->SetTitle(histtitle);
    pad[page]->cd(istation+1);  hCLCTEffVsEta[istation]->Draw();
  }
  page++;  c1->Update();

  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "CLCT efficiency vs #eta");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  TH1F *hCLCTEffVsEtaCsc[CSC_TYPES];
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hCLCTEffVsEtaCsc[idh] = (TH1F*)hEfficHitsEtaCsc[idh]->Clone();
    hCLCTEffVsEtaCsc[idh]->Divide(hEfficCLCTEtaCsc[idh],
                                  hEfficHitsEtaCsc[idh], 1., 1., "B");
    if (idh == 3 || idh == 4 || idh == 6 || idh == 8) {
      gPad->Update();  gStyle->SetStatX(0.43);
    }
    else {
      gPad->Update();  gStyle->SetStatX(1.00);
    }
    hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetTitle("#eta");
    hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleOffset(0.8);
    hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleSize(0.07); // default=0.05
    hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetLabelSize(0.10); // default=0.04
    hCLCTEffVsEtaCsc[idh]->GetYaxis()->SetLabelSize(0.10);
    hCLCTEffVsEtaCsc[idh]->SetLabelOffset(0.012, "XY");
    hCLCTEffVsEtaCsc[idh]->SetMinimum(0.50);
    hCLCTEffVsEtaCsc[idh]->SetMaximum(1.05);
    hCLCTEffVsEtaCsc[idh]->SetTitle(csc_type[idh].c_str());
    hCLCTEffVsEtaCsc[idh]->SetLineWidth(2);
    hCLCTEffVsEtaCsc[idh]->SetLineColor(4);
    pad[page]->cd(idh+1);  gPad->SetGrid(1);  hCLCTEffVsEtaCsc[idh]->Draw();
  }
  page++;  c1->Update();

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::drawHistosForTalks ( )

private

Definition at line 4258 of file CSCTriggerPrimitivesReader.cc.

References bookedEfficHistos, bookedResolHistos, alignmentValidation::c1, csc_type, CSC_TYPES, hClctCFEB, hClctKeyStrip, hClctPattern, hClctQuality, hClctSign, hClctStripType, hEfficALCTEtaCsc, hEfficCLCTEtaCsc, hEfficHitsEtaCsc, hPhiDiffCsc, hResolDeltaDS, hResolDeltaHS, hResolDeltaWG, MAXPAGES, postprocess-scan-build::page, plotME1A, plotME42, and runGCPTkAlMap::title.

                                                    {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  TCanvas *c2 = new TCanvas("c2", "", 0, 0, 540, 540);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .07, .07, .93, .93);
  }

  int page = 1;
  TPaveLabel *title;
  gStyle->SetOptDate(0);

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  TPostScript *eps1 = new TPostScript("clcts.eps", 113);
  eps1->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "CLCT quantities");
  title->SetFillColor(10);  title->Draw();
  pad[page]->Draw();
  pad[page]->Divide(2,3);
  pad[page]->cd(1);  hClctQuality->Draw();
  pad[page]->cd(2);  hClctSign->Draw();
  TH1F* hClctPatternTot = (TH1F*)hClctPattern[0]->Clone();
  hClctPatternTot->SetTitle("CLCT pattern #");
  hClctPatternTot->Add(hClctPattern[0], hClctPattern[1], 1., 1.);
  pad[page]->cd(3);  hClctPatternTot->Draw();
  hClctPattern[0]->SetLineStyle(2);  hClctPattern[0]->Draw("same");
  hClctPattern[1]->SetLineStyle(3);  hClctPattern[1]->Draw("same");
  pad[page]->cd(4);  hClctCFEB->Draw();
  pad[page]->cd(5);  hClctStripType->Draw();
  TH1F* hClctKeyStripTot = (TH1F*)hClctKeyStrip[0]->Clone();
  hClctKeyStripTot->SetTitle("CLCT key strip #");
  hClctKeyStripTot->Add(hClctKeyStrip[0], hClctKeyStrip[1], 1., 1.);
  pad[page]->cd(6);  hClctKeyStripTot->Draw();
  page++;  c1->Update();
  c1->Print("asdf.png");
  eps1->Close();

  // Resolution histograms.
  if (bookedResolHistos) {
    gStyle->SetTitleSize(0.055, "");   // size for pad title; default is 0.02

    TPostScript *eps2 = new TPostScript("alct_deltaWG.eps", 113);
    eps2->NewPage();
    c2->Clear();  c2->cd(0);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(1,1);
    hResolDeltaWG->GetXaxis()->SetTitle("WG_{rec} - WG_{sim}");
    hResolDeltaWG->GetXaxis()->SetTitleOffset(1.2);
    hResolDeltaWG->GetYaxis()->SetTitle("Entries");
    hResolDeltaWG->GetYaxis()->SetTitleOffset(1.9);
    hResolDeltaWG->GetXaxis()->SetLabelSize(0.04);
    hResolDeltaWG->GetYaxis()->SetLabelSize(0.04);
    pad[page]->cd(1);  hResolDeltaWG->Draw();
    page++;  c2->Update();
    eps2->Close();

    TPostScript *eps3 = new TPostScript("clct_deltaHS.eps", 113);
    eps3->NewPage();
    c2->Clear();  c2->cd(0);
    pad[page]->Draw();
    pad[page]->Divide(1,1);
    hResolDeltaHS->GetXaxis()->SetTitle("HS_{rec} - HS_{sim}");
    hResolDeltaHS->GetXaxis()->SetTitleOffset(1.2);
    hResolDeltaHS->GetYaxis()->SetTitle("Entries");
    hResolDeltaHS->GetYaxis()->SetTitleOffset(1.7);
    hResolDeltaHS->GetXaxis()->SetLabelSize(0.04); // default=0.04
    hResolDeltaHS->GetYaxis()->SetLabelSize(0.04);
    pad[page]->cd(1);  hResolDeltaHS->Draw();
    page++;  c2->Update();
    eps3->Close();

    TPostScript *eps4 = new TPostScript("clct_deltaDS.eps", 113);
    eps4->NewPage();
    c2->Clear();  c2->cd(0);
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(1,1);
    hResolDeltaDS->GetXaxis()->SetTitle("DS_{rec} - DS_{sim}");
    hResolDeltaDS->GetXaxis()->SetTitleOffset(1.2);
    hResolDeltaDS->GetYaxis()->SetTitle("Entries");
    hResolDeltaDS->GetYaxis()->SetTitleOffset(1.6);
    hResolDeltaDS->GetXaxis()->SetLabelSize(0.04); // default=0.04
    hResolDeltaDS->GetYaxis()->SetLabelSize(0.04);
    pad[page]->cd(1);  hResolDeltaDS->Draw();
    page++;  c2->Update();
    eps4->Close();

    TPostScript *eps5 = new TPostScript("clct_deltaPhi_hs.eps", 113);
    eps5->NewPage();
    c1->Clear();  c1->cd(0);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                           "#phi_rec-#phi_sim (mrad), halfstrips only");
    title->SetFillColor(10);  title->Draw();
    gStyle->SetTitleSize(0.1, "");   // size for pad title; default is 0.02
    gStyle->SetOptStat(111110);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      pad[page]->cd(idh+1);  hPhiDiffCsc[idh][4]->Draw();
      //if (hPhiDiffCsc[idh][4]->GetEntries() > 1)
      //hPhiDiffCsc[idh][4]->Fit("gaus","Q");
      //hPhiDiffCsc[idh][4]->GetXaxis()->SetTitle("#phi_{rec} - #phi_{sim} (mrad)");
      //hPhiDiffCsc[idh][4]->GetXaxis()->SetTitleSize(0.06);
      //hPhiDiffCsc[idh][4]->GetXaxis()->SetTitleOffset(0.9);
      hPhiDiffCsc[idh][4]->GetYaxis()->SetTitle("Entries        ");
      hPhiDiffCsc[idh][4]->GetYaxis()->SetTitleSize(0.07);
      hPhiDiffCsc[idh][4]->GetYaxis()->SetTitleOffset(1.0);
      hPhiDiffCsc[idh][4]->GetXaxis()->SetLabelSize(0.10); // default=0.04
      hPhiDiffCsc[idh][4]->GetYaxis()->SetLabelSize(0.10);
      hPhiDiffCsc[idh][4]->SetLabelOffset(0.012, "XY");
    }
    page++;  c1->Update();
    eps5->Close();
  }

  // Efficiency histograms.
  if (bookedEfficHistos) {
    TPostScript *eps6 = new TPostScript("alct_effic.eps", 113);
    eps6->NewPage();
    c1->Clear();  c1->cd(0);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "ALCT efficiency vs #eta");
    title->SetFillColor(10);  title->Draw();
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hALCTEffVsEtaCsc[CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hALCTEffVsEtaCsc[idh] = (TH1F*)hEfficHitsEtaCsc[idh]->Clone();
      hALCTEffVsEtaCsc[idh]->Divide(hEfficALCTEtaCsc[idh],
                                    hEfficHitsEtaCsc[idh], 1., 1., "B");
      hALCTEffVsEtaCsc[idh]->GetXaxis()->SetTitle("#eta");
      hALCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleOffset(0.8);
      hALCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleSize(0.07); // default=0.05
      hALCTEffVsEtaCsc[idh]->GetXaxis()->SetLabelSize(0.10); // default=0.04
      hALCTEffVsEtaCsc[idh]->GetYaxis()->SetLabelSize(0.10);
      hALCTEffVsEtaCsc[idh]->SetLabelOffset(0.012, "XY");
      hALCTEffVsEtaCsc[idh]->SetMinimum(0.50);
      hALCTEffVsEtaCsc[idh]->SetMaximum(1.05);
      hALCTEffVsEtaCsc[idh]->SetTitle(csc_type[idh].c_str());
      hALCTEffVsEtaCsc[idh]->SetTitleSize(0.1, "");
      hALCTEffVsEtaCsc[idh]->SetLineWidth(2);
      hALCTEffVsEtaCsc[idh]->SetLineColor(4);
      hALCTEffVsEtaCsc[idh]->SetLineColor(4);
      pad[page]->cd(idh+1);  gPad->SetGrid(1);  hALCTEffVsEtaCsc[idh]->Draw();
    }
    page++;  c1->Update();
    eps6->Close();

    TPostScript *eps7 = new TPostScript("clct_effic.eps", 113);
    eps7->NewPage();
    c1->Clear();  c1->cd(0);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "CLCT efficiency vs #eta");
    title->SetFillColor(10);  title->Draw();
    gStyle->SetOptStat(0);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    TH1F *hCLCTEffVsEtaCsc[CSC_TYPES];
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hCLCTEffVsEtaCsc[idh] = (TH1F*)hEfficHitsEtaCsc[idh]->Clone();
      hCLCTEffVsEtaCsc[idh]->Divide(hEfficCLCTEtaCsc[idh],
                                    hEfficHitsEtaCsc[idh], 1., 1., "B");
      hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetTitle("#eta");
      hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleOffset(0.8);
      hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetTitleSize(0.07); // default=0.05
      hCLCTEffVsEtaCsc[idh]->GetXaxis()->SetLabelSize(0.10); // default=0.04
      hCLCTEffVsEtaCsc[idh]->GetYaxis()->SetLabelSize(0.10);
      hCLCTEffVsEtaCsc[idh]->SetLabelOffset(0.012, "XY");
      hCLCTEffVsEtaCsc[idh]->SetMinimum(0.50);
      hCLCTEffVsEtaCsc[idh]->SetMaximum(1.05);
      hCLCTEffVsEtaCsc[idh]->SetTitle(csc_type[idh].c_str());
      hCLCTEffVsEtaCsc[idh]->SetLineWidth(2);
      hCLCTEffVsEtaCsc[idh]->SetLineColor(4);
      pad[page]->cd(idh+1);  gPad->SetGrid(1);  hCLCTEffVsEtaCsc[idh]->Draw();
    }
    page++;  c1->Update();
    eps7->Close();
  }
  delete c1;
  delete c2;
}

void CSCTriggerPrimitivesReader::drawLCTMPCHistos ( )

private

Definition at line 3403 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, csc_type, CSC_TYPES, alignmentValidation::fname, hCorrLctMPCPerCSC, hLctMPCBend, hLctMPCBXN, hLctMPCChamber, hLctMPCEndcap, hLctMPCKeyGroup, hLctMPCKeyStrip, hLctMPCPattern, hLctMPCPerCSC, hLctMPCPerEvent, hLctMPCQuality, hLctMPCRing, hLctMPCSector, hLctMPCStation, hLctMPCStripType, hLctMPCValid, mps_fire::i, MAX_STATIONS, MAXPAGES, postprocess-scan-build::page, resultsFileNamesPrefix_, lumiQTWidget::t, and runGCPTkAlMap::title.

                                                  {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  string fname = resultsFileNamesPrefix_+"lcts_mpc.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[7];
  TPaveLabel *title;

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "Number of LCTs");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(1,3);
  pad[page]->cd(1);  hLctMPCPerEvent->Draw();
  for (int i = 0; i < CSC_TYPES; i++) {
    hLctMPCPerCSC->GetXaxis()->SetBinLabel(i+1, csc_type[i].c_str());
    hCorrLctMPCPerCSC->GetXaxis()->SetBinLabel(i+1, csc_type[i].c_str());
  }
  // Should be multiplied by 40/nevents to convert to MHz
  pad[page]->cd(2);  hLctMPCPerCSC->Draw();
  pad[page]->cd(3);  hCorrLctMPCPerCSC->Draw();
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "LCT geometry");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(110110);
  pad[page]->Draw();
  pad[page]->Divide(2,4);
  pad[page]->cd(1);  hLctMPCEndcap->Draw();
  pad[page]->cd(2);  hLctMPCStation->Draw();
  pad[page]->cd(3);  hLctMPCSector->Draw();
  pad[page]->cd(4);  hLctMPCRing->Draw();
  for (int istat = 0; istat < MAX_STATIONS; istat++) {
    pad[page]->cd(istat+5);  hLctMPCChamber[istat]->Draw();
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "LCT quantities");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,4);
  pad[page]->cd(1);  hLctMPCValid->Draw();
  pad[page]->cd(2);  hLctMPCQuality->Draw();
  pad[page]->cd(3);  hLctMPCKeyGroup->Draw();
  pad[page]->cd(4);  hLctMPCKeyStrip->Draw();
  pad[page]->cd(5);  hLctMPCStripType->Draw();
  pad[page]->cd(6);  hLctMPCPattern->Draw();
  pad[page]->cd(7);  hLctMPCBend->Draw();
  pad[page]->cd(8);  hLctMPCBXN->Draw();
  page++;  c1->Update();

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::drawLCTTMBHistos ( )

private

Definition at line 3306 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, csc_type, CSC_TYPES, alignmentValidation::fname, hCorrLctTMBPerCSC, hLctTMBBend, hLctTMBBXN, hLctTMBChamber, hLctTMBCsc, hLctTMBEndcap, hLctTMBKeyGroup, hLctTMBKeyStrip, hLctTMBPattern, hLctTMBPerChamber, hLctTMBPerCSC, hLctTMBPerEvent, hLctTMBQuality, hLctTMBRing, hLctTMBSector, hLctTMBStation, hLctTMBStripType, hLctTMBValid, mps_fire::i, MAX_ENDCAPS, MAX_STATIONS, MAXPAGES, postprocess-scan-build::page, plotME1A, plotME42, resultsFileNamesPrefix_, lumiQTWidget::t, and runGCPTkAlMap::title.

Referenced by endJob().

                                                  {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  string fname = resultsFileNamesPrefix_+"lcts_tmb.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[7], titl[50];
  TPaveLabel *title;

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "Number of LCTs");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  pad[page]->cd(1);  hLctTMBPerEvent->Draw();
  pad[page]->cd(2);  hLctTMBPerChamber->Draw();
  c1->Update();
  for (int i = 0; i < CSC_TYPES; i++) {
    hLctTMBPerCSC->GetXaxis()->SetBinLabel(i+1, csc_type[i].c_str());
    hCorrLctTMBPerCSC->GetXaxis()->SetBinLabel(i+1, csc_type[i].c_str());
  }
  // Should be multiplied by 40/nevents to convert to MHz
  pad[page]->cd(3);  hLctTMBPerCSC->Draw();
  pad[page]->cd(4);  hCorrLctTMBPerCSC->Draw();
  gStyle->SetOptStat(1110);
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "LCT geometry");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(110110);
  pad[page]->Draw();
  pad[page]->Divide(2,4);
  pad[page]->cd(1);  hLctTMBEndcap->Draw();
  pad[page]->cd(2);  hLctTMBStation->Draw();
  pad[page]->cd(3);  hLctTMBSector->Draw();
  pad[page]->cd(4);  hLctTMBRing->Draw();
  for (int istat = 0; istat < MAX_STATIONS; istat++) {
    pad[page]->cd(istat+5);  hLctTMBChamber[istat]->Draw();
  }
  page++;  c1->Update();

  for (int endc = 0; endc < MAX_ENDCAPS; endc++) {
    ps->NewPage();
    c1->Clear();  c1->cd(0);
    sprintf(titl, "LCTs per chamber, endcap %d", endc+1);
    title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, titl);
    title->SetFillColor(10);  title->Draw();
    sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
    gStyle->SetOptStat(10);
    pad[page]->Draw();
    pad[page]->Divide(2,5);
    for (int idh = 0; idh < max_idh; idh++) {
      if (!plotME1A && idh == 3) continue;
      hLctTMBCsc[endc][idh]->SetMinimum(0.0);
      pad[page]->cd(idh+1);  hLctTMBCsc[endc][idh]->Draw();
    }
    page++;  c1->Update();
  }

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "LCT quantities");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(110110);
  pad[page]->Draw();
  pad[page]->Divide(2,4);
  pad[page]->cd(1);  hLctTMBValid->Draw();
  pad[page]->cd(2);  hLctTMBQuality->Draw();
  pad[page]->cd(3);  hLctTMBKeyGroup->Draw();
  pad[page]->cd(4);  hLctTMBKeyStrip->Draw();
  pad[page]->cd(5);  hLctTMBStripType->Draw();
  pad[page]->cd(6);  hLctTMBPattern->Draw();
  pad[page]->cd(7);  hLctTMBBend->Draw();
  pad[page]->cd(8);  hLctTMBBXN->Draw();
  page++;  c1->Update();

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::drawResolHistos ( )

private

Definition at line 3814 of file CSCTriggerPrimitivesReader.cc.

References alignmentValidation::c1, CSC_TYPES, alignmentValidation::fname, hAlctVsEta, hClctVsPhi, hEtaDiffCsc, hEtaDiffVsEta, hEtaDiffVsWireCsc, hEtaRecVsSim, hPhiDiffCsc, hPhiDiffPattern, hPhiDiffVsPhi, hPhiDiffVsStripCsc, hPhiRecVsSim, hResolDeltaDS, hResolDeltaEta, hResolDeltaHS, hResolDeltaPhi, hResolDeltaWG, hTrueBendCsc, MAX_STATIONS, MAXPAGES, CSCConstants::NUM_CLCT_PATTERNS, postprocess-scan-build::page, plotME1A, plotME42, resultsFileNamesPrefix_, lumiQTWidget::t, and runGCPTkAlMap::title.

Referenced by endJob().

                                                 {
  TCanvas *c1 = new TCanvas("c1", "", 0, 0, 500, 640);
  string fname = resultsFileNamesPrefix_+"lcts_resol.ps";
  TPostScript *ps = new TPostScript(fname.c_str(), 111);

  TPad *pad[MAXPAGES];
  for (int i_page = 0; i_page < MAXPAGES; i_page++) {
    pad[i_page] = new TPad("", "", .05, .05, .93, .93);
  }

  int page = 1;
  TText t;
  t.SetTextFont(32);
  t.SetTextSize(0.025);
  char pagenum[7];
  TPaveLabel *title;

  int max_idh = plotME42 ? CSC_TYPES : CSC_TYPES-1;

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "ALCT resolution");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  gStyle->SetStatX(1.00);  gStyle->SetStatY(0.65);
  pad[page]->cd(1);  hEtaRecVsSim->SetMarkerSize(0.2);  hEtaRecVsSim->Draw();
  gPad->Update();  gStyle->SetStatX(1.00);  gStyle->SetStatY(0.995);
  hResolDeltaWG->GetXaxis()->SetTitle("WG_{rec} - WG_{sim}");
  hResolDeltaWG->GetXaxis()->SetTitleOffset(1.2);
  hResolDeltaWG->GetYaxis()->SetTitle("Entries");
  hResolDeltaWG->GetYaxis()->SetTitleOffset(1.9);
  hResolDeltaWG->GetXaxis()->SetLabelSize(0.03);
  hResolDeltaWG->GetYaxis()->SetLabelSize(0.03);
  pad[page]->cd(3);  hResolDeltaWG->Draw();
  hResolDeltaEta->GetXaxis()->SetNdivisions(505); // twice fewer divisions
  hResolDeltaEta->GetXaxis()->SetLabelSize(0.04);
  hResolDeltaEta->GetYaxis()->SetLabelSize(0.04);
  pad[page]->cd(4);  hResolDeltaEta->Draw();  hResolDeltaEta->Fit("gaus","Q");
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "#eta_rec-#eta_sim");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hEtaDiffCsc[idh][0]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hEtaDiffCsc[idh][0]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hEtaDiffCsc[idh][0]->Draw();
    if (hEtaDiffCsc[idh][0]->GetEntries() > 1)
      hEtaDiffCsc[idh][0]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "#eta_rec-#eta_sim, endcap1");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hEtaDiffCsc[idh][1]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hEtaDiffCsc[idh][1]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hEtaDiffCsc[idh][1]->Draw();
    if (hEtaDiffCsc[idh][1]->GetEntries() > 1)
      hEtaDiffCsc[idh][1]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "#eta_rec-#eta_sim, endcap2");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hEtaDiffCsc[idh][2]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hEtaDiffCsc[idh][2]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hEtaDiffCsc[idh][2]->Draw();
    if (hEtaDiffCsc[idh][2]->GetEntries() > 1)
      hEtaDiffCsc[idh][2]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#LT#eta_rec-#eta_sim#GT vs #eta_rec");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  //gStyle->SetOptStat(0);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  TH1F *hMeanEtaDiffVsEta[MAX_STATIONS];
  for (int istation = 0; istation < MAX_STATIONS; istation++) {
    hMeanEtaDiffVsEta[istation] = (TH1F*)hEtaDiffVsEta[istation]->Clone();
    hMeanEtaDiffVsEta[istation]->Divide(hEtaDiffVsEta[istation],
                                        hAlctVsEta[istation], 1., 1.);
    hMeanEtaDiffVsEta[istation]->GetXaxis()->SetTitleOffset(1.2);
    hMeanEtaDiffVsEta[istation]->GetXaxis()->SetTitle("#eta");
    hMeanEtaDiffVsEta[istation]->SetMaximum(0.05);
    pad[page]->cd(istation+1);  hMeanEtaDiffVsEta[istation]->Draw();
  }
  page++;  c1->Update();

  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#eta_rec-#eta_sim vs wiregroup");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    pad[page]->cd(idh+1);  hEtaDiffVsWireCsc[idh]->SetMarkerSize(0.2);
    hEtaDiffVsWireCsc[idh]->GetXaxis()->SetTitle("Wiregroup");
    hEtaDiffVsWireCsc[idh]->GetXaxis()->SetTitleSize(0.07);
    hEtaDiffVsWireCsc[idh]->GetXaxis()->SetTitleOffset(1.2);
    hEtaDiffVsWireCsc[idh]->GetYaxis()->SetTitle("#eta_rec-#eta_sim");
    hEtaDiffVsWireCsc[idh]->GetYaxis()->SetTitleSize(0.07);
    hEtaDiffVsWireCsc[idh]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hEtaDiffVsWireCsc[idh]->GetYaxis()->SetLabelSize(0.07);
    hEtaDiffVsWireCsc[idh]->Draw();
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "#phi resolution");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  gStyle->SetStatX(1.00);  gStyle->SetStatY(0.65);
  pad[page]->cd(1);  hPhiRecVsSim->SetMarkerSize(0.2);  hPhiRecVsSim->Draw();
  gPad->Update();  gStyle->SetStatX(1.00);  gStyle->SetStatY(0.995);
  hResolDeltaPhi->GetXaxis()->SetLabelSize(0.04);
  hResolDeltaPhi->GetYaxis()->SetLabelSize(0.04);
  pad[page]->cd(2);  hResolDeltaPhi->Draw();  hResolDeltaPhi->Fit("gaus","Q");
  hResolDeltaHS->GetXaxis()->SetTitle("HS_{rec} - HS_{sim}");
  hResolDeltaHS->GetXaxis()->SetTitleOffset(1.2);
  hResolDeltaHS->GetYaxis()->SetTitle("Entries");
  hResolDeltaHS->GetYaxis()->SetTitleOffset(1.7);
  hResolDeltaHS->GetXaxis()->SetLabelSize(0.03);
  hResolDeltaHS->GetYaxis()->SetLabelSize(0.03);
  pad[page]->cd(3);  hResolDeltaHS->Draw();
  hResolDeltaDS->GetXaxis()->SetTitle("DS_{rec} - DS_{sim}");
  hResolDeltaDS->GetXaxis()->SetTitleOffset(1.2);
  hResolDeltaDS->GetYaxis()->SetTitle("Entries");
  hResolDeltaDS->GetYaxis()->SetTitleOffset(1.6);
  hResolDeltaDS->GetXaxis()->SetLabelSize(0.04);
  hResolDeltaDS->GetYaxis()->SetLabelSize(0.04);
  pad[page]->cd(4);  hResolDeltaDS->Draw();
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98, "#phi_rec-#phi_sim (mrad)");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hPhiDiffCsc[idh][0]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hPhiDiffCsc[idh][0]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hPhiDiffCsc[idh][0]->Draw();
    if (hPhiDiffCsc[idh][0]->GetEntries() > 1)
      hPhiDiffCsc[idh][0]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#phi_rec-#phi_sim (mrad), endcap1");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hPhiDiffCsc[idh][1]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hPhiDiffCsc[idh][1]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hPhiDiffCsc[idh][1]->Draw();
    if (hPhiDiffCsc[idh][1]->GetEntries() > 1)
      hPhiDiffCsc[idh][1]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#phi_rec-#phi_sim (mrad), endcap2");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hPhiDiffCsc[idh][2]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hPhiDiffCsc[idh][2]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hPhiDiffCsc[idh][2]->Draw();
    if (hPhiDiffCsc[idh][2]->GetEntries() > 1)
      hPhiDiffCsc[idh][2]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#LT#phi_rec-#phi_sim#GT (mrad) vs #phi_rec");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(0);
  pad[page]->Draw();
  pad[page]->Divide(2,2);
  TH1F *hMeanPhiDiffVsPhi[MAX_STATIONS];
  for (int istation = 0; istation < MAX_STATIONS; istation++) {
    hMeanPhiDiffVsPhi[istation] = (TH1F*)hPhiDiffVsPhi[istation]->Clone();
    hMeanPhiDiffVsPhi[istation]->Divide(hPhiDiffVsPhi[istation],
                                        hClctVsPhi[istation], 1., 1.);
    hMeanPhiDiffVsPhi[istation]->GetXaxis()->SetTitleOffset(1.2);
    hMeanPhiDiffVsPhi[istation]->GetYaxis()->SetTitleOffset(1.7);
    hMeanPhiDiffVsPhi[istation]->GetXaxis()->SetTitle("#phi");
    hMeanPhiDiffVsPhi[istation]->GetYaxis()->SetTitle("#LT#phi_rec-#phi_sim#GT (mrad)");
    hMeanPhiDiffVsPhi[istation]->SetMaximum(5.);
    pad[page]->cd(istation+1);  hMeanPhiDiffVsPhi[istation]->Draw();
  }
  page++;  c1->Update();

  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#phi_rec-#phi_sim (mrad) vs halfstrip #");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(0);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    pad[page]->cd(idh+1);  hPhiDiffVsStripCsc[idh][1]->SetMarkerSize(0.2);
    hPhiDiffVsStripCsc[idh][1]->GetXaxis()->SetTitle("Halfstrip");
    hPhiDiffVsStripCsc[idh][1]->GetXaxis()->SetTitleOffset(1.4);
    hPhiDiffVsStripCsc[idh][1]->GetYaxis()->SetTitle("#phi_rec-#phi_sim (mrad)");
    hPhiDiffVsStripCsc[idh][1]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hPhiDiffVsStripCsc[idh][1]->GetYaxis()->SetLabelSize(0.07);
    hPhiDiffVsStripCsc[idh][1]->Draw();
  }
  page++;  c1->Update();

  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#phi_rec-#phi_sim, halfstrips only, different patterns");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  gStyle->SetOptStat(111110);
  pad[page]->Draw();
  pad[page]->Divide(3,3);
  int min_pattern, max_pattern;
  min_pattern = 2;
  max_pattern = CSCConstants::NUM_CLCT_PATTERNS;
  for (int idh = min_pattern; idh < max_pattern; idh++) {
    hPhiDiffPattern[idh]->GetXaxis()->SetTitle("Halfstrip");
    hPhiDiffPattern[idh]->GetXaxis()->SetTitleOffset(1.2);
    pad[page]->cd(idh-min_pattern+1);  hPhiDiffPattern[idh]->Draw();
    // if (hPhiDiffPattern[idh]->GetEntries() > 1)
    //   hPhiDiffPattern[idh]->Fit("gaus","Q");
  }
  page++;  c1->Update();

  ps->NewPage();
  c1->Clear();  c1->cd(0);
  title = new TPaveLabel(0.1, 0.94, 0.9, 0.98,
                         "#phi_1-#phi_6 (mrad), muon SimHits");
  title->SetFillColor(10);  title->Draw();
  sprintf(pagenum, "- %d -", page);  t.DrawText(0.9, 0.02, pagenum);
  pad[page]->Draw();
  pad[page]->Divide(2,5);
  for (int idh = 0; idh < max_idh; idh++) {
    if (!plotME1A && idh == 3) continue;
    hTrueBendCsc[idh]->GetYaxis()->SetTitle("Entries");
    hTrueBendCsc[idh]->GetYaxis()->SetTitleSize(0.07);
    hTrueBendCsc[idh]->GetXaxis()->SetLabelSize(0.07); // default=0.04
    hTrueBendCsc[idh]->GetYaxis()->SetLabelSize(0.07);
    pad[page]->cd(idh+1);  hTrueBendCsc[idh]->Draw();
  }
  page++;  c1->Update();

  ps->Close();
  delete c1;
}

void CSCTriggerPrimitivesReader::endJob ( void  )

virtual

Write to ROOT file, make plots, etc.

Reimplemented from edm::EDAnalyzer.

Definition at line 538 of file CSCTriggerPrimitivesReader.cc.

References bookedALCTHistos, bookedCLCTHistos, bookedCompHistos, bookedEfficHistos, bookedLCTTMBHistos, bookedResolHistos, csc_type, CSC_TYPES, drawALCTHistos(), drawCLCTHistos(), drawCompHistos(), drawEfficHistos(), drawLCTTMBHistos(), drawResolHistos(), eventsAnalyzed, hEfficALCTEtaCsc, hEfficCLCTEtaCsc, hEfficHitsEtaCsc, hResolDeltaHS, hResolDeltaWG, numALCT, numCLCT, numLCTMPC, numLCTTMB, and printps.

                                        {
  // Note: all operations involving ROOT should be placed here and not in the
  // destructor.
  // Plot histos if they were booked/filled.
  if(printps) {
    if (bookedALCTHistos)   drawALCTHistos();
    if (bookedCLCTHistos)   drawCLCTHistos();
    if (bookedLCTTMBHistos) drawLCTTMBHistos();
    //if (bookedLCTMPCHistos) drawLCTMPCHistos();

    if (bookedCompHistos)   drawCompHistos();

    if (bookedResolHistos)  drawResolHistos();
    if (bookedEfficHistos)  drawEfficHistos();
  }
  //drawHistosForTalks();

  //theFile->cd();
  //theFile->Write();
  //theFile->Close();

  // Job summary.
  edm::LogInfo("CSCTriggerPrimitivesReader")
    << "\n  Average number of ALCTs/event = "
    << static_cast<float>(numALCT)/eventsAnalyzed << endl;
  edm::LogInfo("CSCTriggerPrimitivesReader")
    << "  Average number of CLCTs/event = "
    << static_cast<float>(numCLCT)/eventsAnalyzed << endl;
  edm::LogInfo("CSCTriggerPrimitivesReader")
    << "  Average number of TMB LCTs/event = "
    << static_cast<float>(numLCTTMB)/eventsAnalyzed << endl;
  edm::LogInfo("CSCTriggerPrimitivesReader")
    << "  Average number of MPC LCTs/event = "
    << static_cast<float>(numLCTMPC)/eventsAnalyzed << endl;

  if (bookedEfficHistos) {
    {
      edm::LogInfo("CSCTriggerPrimitivesReader") << "\n  ALCT efficiencies:";
      double tot_simh = 0.0, tot_alct = 0.0;
      for (int idh = 0; idh < CSC_TYPES; idh++) {
        double simh = hEfficHitsEtaCsc[idh]->Integral();
        double alct = hEfficALCTEtaCsc[idh]->Integral();
        double eff  = 0.;
        if (simh > 0) eff = alct/simh;
        edm::LogInfo("CSCTriggerPrimitivesReader")
          << "    " << csc_type[idh]
          << ": alct = " << alct << ", simh = " << simh << " eff = " << eff;
        tot_simh += simh;
        tot_alct += alct;
      }
      edm::LogInfo("CSCTriggerPrimitivesReader")
        << "    overall: alct = " << tot_alct << ", simh = " << tot_simh
        << " eff = " << tot_alct/tot_simh;
    }

    {
      edm::LogInfo("CSCTriggerPrimitivesReader") << "\n  CLCT efficiencies:";
      double tot_simh = 0.0, tot_clct = 0.0;
      for (int idh = 0; idh < CSC_TYPES; idh++) {
        double simh = hEfficHitsEtaCsc[idh]->Integral();
        double clct = hEfficCLCTEtaCsc[idh]->Integral();
        double eff  = 0.;
        if (simh > 0.) eff = clct/simh;
        edm::LogInfo("CSCTriggerPrimitivesReader")
          << "    " << csc_type[idh]
          << ": clct = " << clct << ", simh = " << simh << " eff = " << eff;
        tot_simh += simh;
        tot_clct += clct;
      }
      edm::LogInfo("CSCTriggerPrimitivesReader")
        << "    overall: clct = " << tot_clct << ", simh = " << tot_simh
        << " eff = " << tot_clct/tot_simh;
    }
  }

  if (bookedResolHistos) {
    double cor = 0.0, tot = 0.0;
    cor = hResolDeltaHS->GetBinContent(hResolDeltaHS->FindBin(0.));
    tot = hResolDeltaHS->GetEntries();
    edm::LogInfo("CSCTriggerPrimitivesReader")
      << "\n  Correct half-strip assigned in " << cor << "/" << tot
      << " = " << cor/tot << " of half-strip CLCTs";
    //cor = hResolDeltaDS->GetBinContent(hResolDeltaDS->FindBin(0.));
    //tot = hResolDeltaDS->GetEntries();
    //edm::LogInfo("CSCTriggerPrimitivesReader")
    //  << "  Correct di-strip assigned in " << cor << "/" << tot
    //  << " = " << cor/tot << " of di-strip CLCTs";
    cor = hResolDeltaWG->GetBinContent(hResolDeltaWG->FindBin(0.));
    tot = hResolDeltaWG->GetEntries();
    edm::LogInfo("CSCTriggerPrimitivesReader")
      << "  Correct wire group assigned in " << cor << "/" << tot
      << " = " << cor/tot << " of ALCTs";
  }
}

void CSCTriggerPrimitivesReader::fillALCTHistos ( const CSCALCTDigiCollection *  alcts )

private

Definition at line 1162 of file CSCTriggerPrimitivesReader.cc.

References badChambers_, bookALCTHistos(), bookedALCTHistos, relativeConstraints::chamber, checkBadChambers_, debug, getCSCType(), hAlctAccel, hAlctBXN, hAlctCollis, hAlctCsc, hAlctKeyGroup, hAlctKeyGroupME11, hAlctPerChamber, hAlctPerCSC, hAlctPerEvent, hAlctQuality, hAlctValid, CSCBadChambers::isInBadChamber(), LogTrace, and numALCT.

Referenced by analyze().

                                                                                  {
  // Book histos when called for the first time.
  if (!bookedALCTHistos) bookALCTHistos();

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

      bool alct_valid = (*digiIt).isValid();
      hAlctValid->Fill(alct_valid);
      if (alct_valid) {
        hAlctQuality->Fill((*digiIt).getQuality());
        hAlctAccel->Fill((*digiIt).getAccelerator());
        hAlctCollis->Fill((*digiIt).getCollisionB());
        hAlctKeyGroup->Fill((*digiIt).getKeyWG());
        hAlctBXN->Fill((*digiIt).getBX());

        int csctype = getCSCType(id);
        hAlctPerCSC->Fill(csctype);
        hAlctCsc[id.endcap()-1][csctype]->Fill(id.chamber());

        if (csctype==0) hAlctKeyGroupME11->Fill((*digiIt).getKeyWG());

        nValidALCTs++;
        nValidALCTsPerCSC++;

        if (debug) LogTrace("CSCTriggerPrimitivesReader")
                     << (*digiIt) << " found in ME" << ((id.endcap() == 1) ? "+" : "-")
                     << id.station() << "/" << id.ring() << "/" << id.chamber()
                     << " (sector " << id.triggerSector()
                     << " trig id. " << id.triggerCscId() << ")";
        //cout << "raw id = " << id.rawId() << endl;
      }
    }
    hAlctPerChamber->Fill(nValidALCTsPerCSC);
  }
  hAlctPerEvent->Fill(nValidALCTs);
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               << nValidALCTs << " valid ALCTs found in this event";
  numALCT += nValidALCTs;
}

void CSCTriggerPrimitivesReader::fillCLCTHistos ( const CSCCLCTDigiCollection *  clcts )

private

Definition at line 1209 of file CSCTriggerPrimitivesReader.cc.

References funct::abs(), badChambers_, bookCLCTHistos(), bookedCLCTHistos, relativeConstraints::chamber, checkBadChambers_, debug, getCSCType(), hClctBendCsc, hClctBXN, hClctCFEB, hClctCsc, hClctKeyStrip, hClctKeyStripCsc, hClctKeyStripME11, hClctPattern, hClctPerChamber, hClctPerCSC, hClctPerEvent, hClctQuality, hClctSign, hClctStripType, hClctValid, CSCBadChambers::isInBadChamber(), LogTrace, numCLCT, listBenchmarks::pattern, and ptype_TMB07.

Referenced by analyze().

                                                                                  {
  // Book histos when called for the first time.
  if (!bookedCLCTHistos) bookCLCTHistos();

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

      bool clct_valid = (*digiIt).isValid();
      hClctValid->Fill(clct_valid);
      if (clct_valid) {
        int striptype = (*digiIt).getStripType();
        int keystrip  = (*digiIt).getKeyStrip(); // halfstrip #
        if (striptype == 0) keystrip /= 4;       // distrip # for distrip ptns
        hClctQuality->Fill((*digiIt).getQuality());
        hClctStripType->Fill(striptype);
        hClctSign->Fill((*digiIt).getBend());
        hClctCFEB->Fill((*digiIt).getCFEB());
        hClctBXN->Fill((*digiIt).getBX());
        hClctKeyStrip[striptype]->Fill(keystrip);
        hClctPattern[striptype]->Fill((*digiIt).getPattern());

        int csctype = getCSCType(id);
        hClctPerCSC->Fill(csctype);
        hClctCsc[id.endcap()-1][csctype]->Fill(id.chamber());

        if (striptype==1 && csctype==0) hClctKeyStripME11->Fill(keystrip);

        int phibend;
        int pattern = (*digiIt).getPattern();
        phibend = ptype_TMB07[pattern];
        hClctBendCsc[csctype][striptype]->Fill(abs(phibend));

        if (striptype == 0) // distrips
          hClctKeyStripCsc[csctype]->Fill(keystrip);

        nValidCLCTs++;
        nValidCLCTsPerCSC++;

        if (debug) LogTrace("CSCTriggerPrimitivesReader")
                     << (*digiIt) << " found in ME" << ((id.endcap() == 1) ? "+" : "-")
                     << id.station() << "/" << id.ring() << "/" << id.chamber()
                     << " (sector " << id.triggerSector()
                     << " trig id. " << id.triggerCscId() << ")";
      }
    }
    hClctPerChamber->Fill(nValidCLCTsPerCSC);
  }
  hClctPerEvent->Fill(nValidCLCTs);
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               << nValidCLCTs << " valid CLCTs found in this event";
  numCLCT += nValidCLCTs;
}

void CSCTriggerPrimitivesReader::fillLCTMPCHistos ( const CSCCorrelatedLCTDigiCollection *  lcts )

private

Definition at line 1340 of file CSCTriggerPrimitivesReader.cc.

References badChambers_, bookedLCTMPCHistos, bookLCTMPCHistos(), checkBadChambers_, debug, makeMuonMisalignmentScenario::endcap, getCSCType(), hCorrLctMPCPerCSC, hLctMPCBend, hLctMPCBXN, hLctMPCChamber, hLctMPCEndcap, hLctMPCKeyGroup, hLctMPCKeyGroupME11, hLctMPCKeyStrip, hLctMPCKeyStripME11, hLctMPCPattern, hLctMPCPerCSC, hLctMPCPerEvent, hLctMPCQuality, hLctMPCRing, hLctMPCSector, hLctMPCStation, hLctMPCStripType, hLctMPCValid, CSCBadChambers::isInBadChamber(), LogTrace, numLCTMPC, jets_cff::quality, relativeConstraints::ring, relativeConstraints::station, triggerCscId(), and triggerSector().

                                                                                            {
  // Book histos when called for the first time.
  if (!bookedLCTMPCHistos) bookLCTMPCHistos();

  int nValidLCTs = 0;
  bool alct_valid, clct_valid;

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

      bool lct_valid = (*digiIt).isValid();
      hLctMPCValid->Fill(lct_valid);
      if (lct_valid) {
        hLctMPCEndcap->Fill(id.endcap());
        hLctMPCStation->Fill(id.station());
        hLctMPCSector->Fill(id.triggerSector());
        hLctMPCRing->Fill(id.ring());
        hLctMPCChamber[id.station()-1]->Fill(id.triggerCscId());

        int quality = (*digiIt).getQuality();
        hLctMPCQuality->Fill(quality);
        hLctMPCBXN->Fill((*digiIt).getBX());

        alct_valid = (quality != 0 && quality != 2);
        if (alct_valid) {
          hLctMPCKeyGroup->Fill((*digiIt).getKeyWG());
        }

        clct_valid = (quality != 0 && quality != 1);
        if (clct_valid) {
          hLctMPCKeyStrip->Fill((*digiIt).getStrip());
          hLctMPCStripType->Fill(1.);
          hLctMPCPattern->Fill((*digiIt).getPattern());
          hLctMPCBend->Fill((*digiIt).getBend());
        }

        int csctype = getCSCType(id);
        hLctMPCPerCSC->Fill(csctype);
        // Truly correlated LCTs; for DAQ
        if (alct_valid && clct_valid) hCorrLctMPCPerCSC->Fill(csctype);


        if (alct_valid && csctype==0) {
          hLctMPCKeyGroupME11->Fill((*digiIt).getKeyWG());
        }
        if (clct_valid && csctype==0) {
          hLctMPCKeyStripME11->Fill((*digiIt).getStrip());
        }

        nValidLCTs++;

        if (debug) LogTrace("CSCTriggerPrimitivesReader")
                     << "MPC "
                     << (*digiIt) << " found in ME" << ((id.endcap() == 1) ? "+" : "-")
                     << id.station() << "/" << id.ring() << "/" << id.chamber()
                     << " (sector " << id.triggerSector()
                     << " trig id. " << id.triggerCscId() << ")";
      }
    }
  }
  hLctMPCPerEvent->Fill(nValidLCTs);
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               << nValidLCTs << " MPC LCTs found in this event";
  numLCTMPC += nValidLCTs;
}

void CSCTriggerPrimitivesReader::fillLCTTMBHistos ( const CSCCorrelatedLCTDigiCollection *  lcts )

private

Definition at line 1268 of file CSCTriggerPrimitivesReader.cc.

References badChambers_, bookedLCTTMBHistos, bookLCTTMBHistos(), relativeConstraints::chamber, checkBadChambers_, debug, makeMuonMisalignmentScenario::endcap, getCSCType(), hCorrLctTMBPerCSC, hLctTMBBend, hLctTMBBXN, hLctTMBChamber, hLctTMBCsc, hLctTMBEndcap, hLctTMBKeyGroup, hLctTMBKeyGroupME11, hLctTMBKeyStrip, hLctTMBKeyStripME11, hLctTMBPattern, hLctTMBPerChamber, hLctTMBPerCSC, hLctTMBPerEvent, hLctTMBQuality, hLctTMBRing, hLctTMBSector, hLctTMBStation, hLctTMBStripType, hLctTMBValid, CSCBadChambers::isInBadChamber(), LogTrace, numLCTTMB, jets_cff::quality, relativeConstraints::ring, relativeConstraints::station, triggerCscId(), and triggerSector().

Referenced by analyze().

                                                                                            {
  // Book histos when called for the first time.
  if (!bookedLCTTMBHistos) bookLCTTMBHistos();

  int nValidLCTs = 0;
  bool alct_valid, clct_valid;

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

      bool lct_valid = (*digiIt).isValid();
      hLctTMBValid->Fill(lct_valid);
      if (lct_valid) {
        hLctTMBEndcap->Fill(id.endcap());
        hLctTMBStation->Fill(id.station());
        hLctTMBSector->Fill(id.triggerSector());
        hLctTMBRing->Fill(id.ring());
        hLctTMBChamber[id.station()-1]->Fill(id.triggerCscId());

        int quality = (*digiIt).getQuality();
        hLctTMBQuality->Fill(quality);
        hLctTMBBXN->Fill((*digiIt).getBX());

        alct_valid = (quality != 0 && quality != 2);
        if (alct_valid) {
          hLctTMBKeyGroup->Fill((*digiIt).getKeyWG());
        }

        clct_valid = (quality != 0 && quality != 1);
        if (clct_valid) {
          hLctTMBKeyStrip->Fill((*digiIt).getStrip());
          hLctTMBStripType->Fill(1.);
          hLctTMBPattern->Fill((*digiIt).getPattern());
          hLctTMBBend->Fill((*digiIt).getBend());
        }

        int csctype = getCSCType(id);
        hLctTMBPerCSC->Fill(csctype);
        hLctTMBCsc[id.endcap()-1][csctype]->Fill(id.chamber());
        // Truly correlated LCTs; for DAQ
        if (alct_valid && clct_valid) hCorrLctTMBPerCSC->Fill(csctype);

        if (alct_valid && csctype==0) {
          hLctTMBKeyGroupME11->Fill((*digiIt).getKeyWG());
        }
        if (clct_valid && csctype==0) {
          hLctTMBKeyStripME11->Fill((*digiIt).getStrip());
        }

        nValidLCTs++;
        nValidLCTsPerCSC++;

        if (debug) LogTrace("CSCTriggerPrimitivesReader")
                     << (*digiIt) << " found in ME" << ((id.endcap() == 1) ? "+" : "-")
                     << id.station() << "/" << id.ring() << "/" << id.chamber()
                     << " (sector " << id.triggerSector()
                     << " trig id. " << id.triggerCscId() << ")";
      }
    }
    hLctTMBPerChamber->Fill(nValidLCTsPerCSC);
  }
  hLctTMBPerEvent->Fill(nValidLCTs);
  if (debug) LogTrace("CSCTriggerPrimitivesReader")
               << nValidLCTs << " valid LCTs found in this event";
  numLCTTMB += nValidLCTs;
}

int CSCTriggerPrimitivesReader::getCSCType ( const CSCDetId &  id )

private

Definition at line 4512 of file CSCTriggerPrimitivesReader.cc.

References CSC_TYPES, relativeConstraints::ring, and relativeConstraints::station.

Referenced by calcEfficiency(), calcResolution(), compareALCTs(), compareCLCTs(), compareLCTs(), fillALCTHistos(), fillCLCTHistos(), fillLCTMPCHistos(), and fillLCTTMBHistos().

                                                             {
  int type = -999;

  if (id.station() == 1) {
    type = (id.triggerCscId()-1)/3;
    if (id.ring() == 4) {
      type = 3;
    }
  }
  else { // stations 2-4
    type = 3 + id.ring() + 2*(id.station()-2);
  }

  assert(type >= 0 && type < CSC_TYPES);
  return type;
}

GlobalPoint CSCTriggerPrimitivesReader::getGlobalPosition ( unsigned int  rawId, int  keWg, int  keyHS  ) const

private

Definition at line 4447 of file CSCTriggerPrimitivesReader.cc.

References CSCDetId::chamber(), CSCGeometry::chamber(), CSCDetId::endcap(), geom_, CSCLayer::geometry(), CSCGeometry::idToDet(), CSCConstants::KEY_CLCT_LAYER, CSCChamber::layer(), lut_wg_vs_hs_me1b, CSCLayerGeometry::middleWireOfGroup(), relativeConstraints::ring, CSCDetId::ring(), CSCDetId::station(), GeomDet::surface(), and Surface::toGlobal().

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

{
    // taken from https://github.com/cms-sw/cmssw/blob/dc9f78b6af4ad56c9342cf14041b6485a60b0691/L1Trigger/CSCTriggerPrimitives/src/CSCTriggerPrimitivesReaderGEM.cc
    CSCDetId cscId = CSCDetId(rawId);
    int ring = cscId.ring();
    if (cscId.station() == 1 and cscId.ring() == 1 and (lut_wg_vs_hs_me1b[keyWg][0] <0 || keyHS>=128)){
      ring =4;
      if (keyHS >= 128)
        keyHS = keyHS-128;
    }

    CSCDetId key_id(cscId.endcap(), cscId.station(), ring,
                  cscId.chamber(), CSCConstants::KEY_CLCT_LAYER);
    auto cscChamber = geom_->chamber(cscId);
    float fractional_strip = 0.5 * (keyHS + 1) - 0.25;
    auto layer_geo = cscChamber->layer(CSCConstants::KEY_CLCT_LAYER)->geometry();
    // LCT::getKeyWG() also starts from 0
    float wire = layer_geo->middleWireOfGroup(keyWg + 1);
    LocalPoint csc_intersect = layer_geo->intersectionOfStripAndWire(fractional_strip, wire);
    GlobalPoint csc_gp = geom_->idToDet(key_id)->surface().toGlobal(csc_intersect);
    return csc_gp;

}

double CSCTriggerPrimitivesReader::getHsPerRad ( const int  idh )

private

Definition at line 4530 of file CSCTriggerPrimitivesReader.cc.

References DEFINE_FWK_MODULE, MAX_HS, NCHAMBERS, and TWOPI.

Referenced by calcResolution().

                                                            {
  return (NCHAMBERS[idh]*MAX_HS[idh]/TWOPI);
}

void CSCTriggerPrimitivesReader::HotWires

(

const edm::Event &

iEvent

)

Definition at line 2665 of file CSCTriggerPrimitivesReader.cc.

References bookedHotWireHistos, bookHotWireHistos(), chamberSerial(), edm::Event::getByToken(), hHotCham1, hHotWire1, pileupCalc::nbins, wireDigi_token_, and muonCSCDigis_cfi::wires.

Referenced by analyze().

                                                                {
  if (!bookedHotWireHistos) bookHotWireHistos();
  edm::Handle<CSCWireDigiCollection> wires;
  //  iEvent.getByLabel(wireDigiProducer_.label(), wireDigiProducer_.instance(), wires);
  iEvent.getByToken(wireDigi_token_, wires);

  int serial_old=-1;
  for (auto dWDiter=wires->begin(); dWDiter!=wires->end(); dWDiter++) {
    CSCDetId id = (CSCDetId)(*dWDiter).first;
    int serial = chamberSerial(id)-1;
    //     printf("serial %i\n",serial);
    std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
    std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
    bool has_layer=false;
    for( ; wireIter != lWire; ++wireIter) {
      has_layer=true;
      int i_layer= id.layer()-1;
      int i_wire = wireIter->getWireGroup()-1;
      int nbins = wireIter->getTimeBinsOn().size();
      int serial2=serial*(6*112)+i_layer*112+i_wire;
      /*
        printf("endcap %i, station %i, ring %i, chamber %i, serial %i, serial2 %i, layer %i, wg %i\n",
        id.endcap(), id.station(), id.ring(), id.chamber(), serial, serial2, i_layer, i_wire);
      */
      hHotWire1->Fill(serial2,nbins);
      /*
        if(id.station()==1) {
        printf("ring %i, chamber type %i, wg %i\n",id.ring(),id.iChamberType(),i_wire);
        }
      */
    }
    if(serial_old!=serial && has_layer) {
      //       nHotCham[serial]++;
      hHotCham1->Fill(serial);
      //    printf("serial %i filled\n",serial);
      serial_old=serial;
    }
  }
}

int CSCTriggerPrimitivesReader::maxRing ( int  station )

private

Definition at line 386 of file CSCTriggerPrimitivesReader.cc.

References plotME1A.

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

{
  if (station == 1) {
    if (plotME1A) return 4;
    else  return 3;
  }
  return 2;
}

void CSCTriggerPrimitivesReader::MCStudies ( const edm::Event &  ev, const CSCALCTDigiCollection *  alcts, const CSCCLCTDigiCollection *  clcts  )

private

Definition at line 2705 of file CSCTriggerPrimitivesReader.cc.

References calcEfficiency(), calcResolution(), compDigi_token_, compDigiProducer_, debug, edm::Event::getByToken(), edm::Event::getManyByType(), mps_fire::i, edm::HandleBase::isValid(), edm::InputTag::label(), LogDebug, LogTrace, M_PI, CaloTowersParam_cfi::mc, AlCaHLTBitMon_ParallelJobs::p, edm::Handle< T >::product(), simHit_token_, simHitProducer_, trackerHits::simHits, wireDigi_token_, and wireDigiProducer_.

Referenced by analyze().

                                                                               {
  // MC particles, if any.
  //edm::Handle<edm::HepMCProduct> mcp;
  //ev.getByLabel("source", mcp);
  //ev.getByType(mcp);
  vector<edm::Handle<edm::HepMCProduct> > allhepmcp;
  // Use "getManyByType" to be able to check the existence of MC info.
  ev.getManyByType(allhepmcp);

  //cout << "HepMC info: " << allhepmcp.size() << endl;
  if (allhepmcp.size() > 0) {
    const HepMC::GenEvent& mc = allhepmcp[0]->getHepMCData();
    int i = 0;
    for (HepMC::GenEvent::particle_const_iterator p = mc.particles_begin();
         p != mc.particles_end(); ++p) {
      int id = (*p)->pdg_id();
      double phitmp = (*p)->momentum().phi();
      if (phitmp < 0) phitmp += 2.*M_PI;
      if (debug) LogDebug("CSCTriggerPrimitivesReader")
                   << "MC part #" << ++i << ": id = "  << id
                   << ", status = " << (*p)->status()
                   << "\n   pX = " << (*p)->momentum().x()
                   << ", pY = " << (*p)->momentum().y()
                   << ", pT = " << (*p)->momentum().perp() << " GeV"
                   << ", p =  " << (*p)->momentum().rho()  << " GeV"
                   << "\n   eta = " << (*p)->momentum().pseudoRapidity()
                   << ", phi = " << phitmp << " (" << phitmp*180./M_PI << " deg)";
    }

    // If hepMC info is there, try to get wire and comparator digis,
    // and SimHits.
    edm::Handle<CSCWireDigiCollection>       wireDigis;
    edm::Handle<CSCComparatorDigiCollection> compDigis;
    edm::Handle<edm::PSimHitContainer>       simHitsH;
    //    ev.getByLabel(wireDigiProducer_.label(), wireDigiProducer_.instance(),
    //        wireDigis);
    //    ev.getByLabel(compDigiProducer_.label(), compDigiProducer_.instance(),
    //        compDigis);
    //    ev.getByLabel(simHitProducer_.label(), simHitProducer_.instance(),
    //        simHits);
    ev.getByToken(wireDigi_token_, wireDigis);
    ev.getByToken(compDigi_token_, compDigis);
    ev.getByToken(simHit_token_, simHitsH);
    const edm::PSimHitContainer& simHits = *simHitsH.product();

    if (!wireDigis.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of wire digis with label"
        << wireDigiProducer_.label()
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    if (!compDigis.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of comparator digis with label"
        << compDigiProducer_.label()
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }
    if (!simHitsH.isValid()) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: Collection of SimHits with label"
        << simHitProducer_.label()
        << " requested, but not found in the event... Skipping the rest +++\n";
      return;
    }


    if (debug) LogTrace("CSCTriggerPrimitivesReader")
                 << "   #CSC SimHits: " << simHits.size();

    // MC-based resolution studies.
    calcResolution(alcts, clcts, wireDigis.product(), compDigis.product(),
                   simHits);

    // MC-based efficiency studies.
    calcEfficiency(alcts, clcts, simHits);
  }
}

void CSCTriggerPrimitivesReader::setRootStyle ( )

private

Definition at line 636 of file CSCTriggerPrimitivesReader.cc.

Referenced by CSCTriggerPrimitivesReader().

                                              {
  TH1::AddDirectory(false);

  gROOT->SetStyle("Plain");
  gStyle->SetFillColor(0);
  gStyle->SetOptDate();
  gStyle->SetOptStat(111110);
  gStyle->SetOptFit(1111);
  gStyle->SetPadTickX(1);
  gStyle->SetPadTickY(1);
  gStyle->SetMarkerSize(0.5);
  gStyle->SetMarkerStyle(8);
  gStyle->SetGridStyle(3);
  gStyle->SetPaperSize(TStyle::kA4);
  gStyle->SetStatW(0.25); // width of statistics box; default is 0.19
  gStyle->SetStatH(0.10); // height of statistics box; default is 0.1
  gStyle->SetStatFormat("6.4g");  // leave default format for now
  gStyle->SetTitleSize(0.055, "");   // size for pad title; default is 0.02
  // Really big; useful for talks.
  //gStyle->SetTitleSize(0.1, "");   // size for pad title; default is 0.02
  gStyle->SetLabelSize(0.05, "XYZ"); // size for axis labels; default is 0.04
  gStyle->SetStatFontSize(0.06);     // size for stat. box
  gStyle->SetTitleFont(32, "XYZ"); // times-bold-italic font (p. 153) for axes
  gStyle->SetTitleFont(32, "");    // same for pad title
  gStyle->SetLabelFont(32, "XYZ"); // same for axis labels
  gStyle->SetStatFont(32);         // same for stat. box
  gStyle->SetLabelOffset(0.006, "Y"); // default is 0.005
}

Member Data Documentation

edm::EDGetTokenT<CSCALCTDigiCollection> CSCTriggerPrimitivesReader::alcts_d_token_

private

Definition at line 182 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCALCTDigiCollection> CSCTriggerPrimitivesReader::alcts_e_token_

private

Definition at line 186 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

const CSCBadChambers* CSCTriggerPrimitivesReader::badChambers_

private

Definition at line 155 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), calcEfficiency(), calcResolution(), compareALCTs(), compareCLCTs(), compareLCTs(), compareMPCLCTs(), fillALCTHistos(), fillCLCTHistos(), fillLCTMPCHistos(), and fillLCTTMBHistos().

bool CSCTriggerPrimitivesReader::bookedALCTHistos = false

staticprivate

Definition at line 228 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), endJob(), and fillALCTHistos().

bool CSCTriggerPrimitivesReader::bookedCLCTHistos = false

staticprivate

Definition at line 229 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), endJob(), and fillCLCTHistos().

bool CSCTriggerPrimitivesReader::bookedCompHistos = false

staticprivate

Definition at line 233 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compare(), and endJob().

bool CSCTriggerPrimitivesReader::bookedEfficHistos = false

staticprivate

Definition at line 236 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), drawHistosForTalks(), and endJob().

bool CSCTriggerPrimitivesReader::bookedHotWireHistos = false

staticprivate

Definition at line 227 of file CSCTriggerPrimitivesReader.h.

Referenced by bookHotWireHistos(), and HotWires().

bool CSCTriggerPrimitivesReader::bookedLCTMPCHistos = false

staticprivate

Definition at line 231 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), and fillLCTMPCHistos().

bool CSCTriggerPrimitivesReader::bookedLCTTMBHistos = false

staticprivate

Definition at line 230 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), endJob(), and fillLCTTMBHistos().

bool CSCTriggerPrimitivesReader::bookedResolHistos = false

staticprivate

Definition at line 235 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), drawHistosForTalks(), and endJob().

bool CSCTriggerPrimitivesReader::checkBadChambers_

private

Definition at line 196 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), calcEfficiency(), calcResolution(), compareALCTs(), compareCLCTs(), compareLCTs(), compareMPCLCTs(), CSCTriggerPrimitivesReader(), fillALCTHistos(), fillCLCTHistos(), fillLCTMPCHistos(), and fillLCTTMBHistos().

edm::EDGetTokenT<CSCCLCTDigiCollection> CSCTriggerPrimitivesReader::clcts_d_token_

private

Definition at line 183 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCCLCTDigiCollection> CSCTriggerPrimitivesReader::clcts_e_token_

private

Definition at line 187 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCComparatorDigiCollection> CSCTriggerPrimitivesReader::compDigi_token_

private

Definition at line 180 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and MCStudies().

edm::InputTag CSCTriggerPrimitivesReader::compDigiProducer_

private

Definition at line 176 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and MCStudies().

const string CSCTriggerPrimitivesReader::csc_type

staticprivate

Initial value:

= {
  "ME1/1",  "ME1/2",  "ME1/3",  "ME1/A",  "ME2/1",  "ME2/2",
  "ME3/1",  "ME3/2",  "ME4/1",  "ME4/2"}

Definition at line 210 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), bookEfficHistos(), bookResolHistos(), drawALCTHistos(), drawCLCTHistos(), drawEfficHistos(), drawHistosForTalks(), drawLCTMPCHistos(), drawLCTTMBHistos(), and endJob().

const string CSCTriggerPrimitivesReader::csc_type_minus

staticprivate

Initial value:

= {
  "ME-1/1", "ME-1/2", "ME-1/3", "ME-1/A", "ME-2/1", "ME-2/2",
  "ME-3/1", "ME-3/2", "ME-4/1", "ME-4/2"}

Definition at line 212 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), bookCLCTHistos(), bookCompHistos(), and bookLCTTMBHistos().

const string CSCTriggerPrimitivesReader::csc_type_plus

staticprivate

Initial value:

= {
  "ME+1/1", "ME+1/2", "ME+1/3", "ME+1/A", "ME+2/1", "ME+2/2",
  "ME+3/1", "ME+3/2", "ME+4/1", "ME+4/2"}

Definition at line 211 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), bookCLCTHistos(), bookCompHistos(), and bookLCTTMBHistos().

bool CSCTriggerPrimitivesReader::dataIsAnotherMC_

private

Definition at line 199 of file CSCTriggerPrimitivesReader.h.

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

bool CSCTriggerPrimitivesReader::dataLctsIn_

private

Definition at line 159 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

bool CSCTriggerPrimitivesReader::debug

private

Definition at line 144 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), bookEfficHistos(), bookLCTMPCHistos(), bookResolHistos(), calcResolution(), compareALCTs(), compareCLCTs(), compareLCTs(), compareMPCLCTs(), CSCTriggerPrimitivesReader(), fillALCTHistos(), fillCLCTHistos(), fillLCTMPCHistos(), fillLCTTMBHistos(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), MCStudies(), and runTauIdMVA.TauIDEmbedder::runTauID().

bool CSCTriggerPrimitivesReader::emulLctsIn_

private

Definition at line 160 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

int CSCTriggerPrimitivesReader::Event_

private

Definition at line 149 of file CSCTriggerPrimitivesReader.h.

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

TTree* CSCTriggerPrimitivesReader::event_tree[6]

private

Definition at line 318 of file CSCTriggerPrimitivesReader.h.

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

int CSCTriggerPrimitivesReader::eventsAnalyzed

private

Definition at line 143 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), compareALCTs(), compareCLCTs(), compareLCTs(), compareMPCLCTs(), and endJob().

bool CSCTriggerPrimitivesReader::gangedME1a

private

Definition at line 162 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and doesALCTCrossCLCT().

const CSCGeometry* CSCTriggerPrimitivesReader::geom_

private

Definition at line 152 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), calcEfficiency(), calcResolution(), and getGlobalPosition().

TH1F * CSCTriggerPrimitivesReader::hAlctAccel

private

Definition at line 327 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctBXN

private

Definition at line 328 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F * CSCTriggerPrimitivesReader::hAlctCollis

private

Definition at line 327 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctCompFound

private

Definition at line 354 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompFound2

private

Definition at line 355 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompFound2i

private

Definition at line 357 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompFound2x

private

Definition at line 356 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH1F* CSCTriggerPrimitivesReader::hAlctCompFoundCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 415 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareALCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctCompMatch

private

Definition at line 364 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompMatch2

private

Definition at line 365 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompMatch2i

private

Definition at line 367 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompMatch2x

private

Definition at line 366 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH1F* CSCTriggerPrimitivesReader::hAlctCompMatchCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 418 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareALCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctCompSameN

private

Definition at line 359 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hAlctCompSameN2

private

Definition at line 360 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompSameN2i

private

Definition at line 362 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompSameN2x

private

Definition at line 361 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH1F* CSCTriggerPrimitivesReader::hAlctCompSameNCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 416 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareALCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctCompTotal

private

Definition at line 369 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompTotal2

private

Definition at line 370 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompTotal2i

private

Definition at line 372 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH2F* CSCTriggerPrimitivesReader::hAlctCompTotal2x

private

Definition at line 371 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareALCTs().

TH1F* CSCTriggerPrimitivesReader::hAlctCompTotalCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 417 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareALCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 326 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F * CSCTriggerPrimitivesReader::hAlctKeyGroup

private

Definition at line 327 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctKeyGroupME11

private

Definition at line 454 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), and fillALCTHistos().

TH1F * CSCTriggerPrimitivesReader::hAlctPerChamber

private

Definition at line 325 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F * CSCTriggerPrimitivesReader::hAlctPerCSC

private

Definition at line 325 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctPerEvent

private

Definition at line 325 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F * CSCTriggerPrimitivesReader::hAlctQuality

private

Definition at line 327 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctValid

private

Definition at line 327 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), drawALCTHistos(), and fillALCTHistos().

TH1F* CSCTriggerPrimitivesReader::hAlctVsEta[MAX_STATIONS]

private

Definition at line 434 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F* CSCTriggerPrimitivesReader::hClctBendCsc[CSC_TYPES][2]

private

Definition at line 335 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctBXN

private

Definition at line 333 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctCFEB

private

Definition at line 332 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), drawHistosForTalks(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctCompFound

private

Definition at line 374 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hClctCompFound2

private

Definition at line 375 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompFound2i

private

Definition at line 377 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompFound2x

private

Definition at line 376 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH1F* CSCTriggerPrimitivesReader::hClctCompFoundCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 420 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareCLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hClctCompMatch

private

Definition at line 383 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hClctCompMatch2

private

Definition at line 384 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompMatch2i

private

Definition at line 386 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompMatch2x

private

Definition at line 385 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH1F* CSCTriggerPrimitivesReader::hClctCompMatchCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 423 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareCLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hClctCompSameN

private

Definition at line 378 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hClctCompSameN2

private

Definition at line 379 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompSameN2i

private

Definition at line 381 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompSameN2x

private

Definition at line 380 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH1F* CSCTriggerPrimitivesReader::hClctCompSameNCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 421 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareCLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hClctCompTotal

private

Definition at line 388 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hClctCompTotal2

private

Definition at line 389 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompTotal2i

private

Definition at line 391 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH2F* CSCTriggerPrimitivesReader::hClctCompTotal2x

private

Definition at line 390 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareCLCTs().

TH1F* CSCTriggerPrimitivesReader::hClctCompTotalCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 422 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareCLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hClctCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 331 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctKeyStrip[2]

private

Definition at line 334 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), drawHistosForTalks(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctKeyStripCsc[CSC_TYPES]

private

Definition at line 335 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctKeyStripME11

private

Definition at line 455 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctPattern[2]

private

Definition at line 334 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), drawHistosForTalks(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctPerChamber

private

Definition at line 330 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctPerCSC

private

Definition at line 330 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctPerEvent

private

Definition at line 330 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctQuality

private

Definition at line 332 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), drawHistosForTalks(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctSign

private

Definition at line 332 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), drawHistosForTalks(), and fillCLCTHistos().

TH1F * CSCTriggerPrimitivesReader::hClctStripType

private

Definition at line 332 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawHistosForTalks(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctValid

private

Definition at line 332 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), drawCLCTHistos(), and fillCLCTHistos().

TH1F* CSCTriggerPrimitivesReader::hClctVsPhi[MAX_STATIONS]

private

Definition at line 442 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F * CSCTriggerPrimitivesReader::hCorrLctMPCPerCSC

private

Definition at line 345 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hCorrLctTMBPerCSC

private

Definition at line 338 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hEfficALCTEta[MAX_STATIONS]

private

Definition at line 450 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), and drawEfficHistos().

TH1F* CSCTriggerPrimitivesReader::hEfficALCTEtaCsc[CSC_TYPES]

private

Definition at line 452 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), drawEfficHistos(), drawHistosForTalks(), and endJob().

TH1F * CSCTriggerPrimitivesReader::hEfficCLCTEta[MAX_STATIONS]

private

Definition at line 450 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), and drawEfficHistos().

TH1F * CSCTriggerPrimitivesReader::hEfficCLCTEtaCsc[CSC_TYPES]

private

Definition at line 452 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), drawEfficHistos(), drawHistosForTalks(), and endJob().

TH1F* CSCTriggerPrimitivesReader::hEfficHitsEta[MAX_STATIONS]

private

Definition at line 449 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), and drawEfficHistos().

TH1F* CSCTriggerPrimitivesReader::hEfficHitsEtaCsc[CSC_TYPES]

private

Definition at line 451 of file CSCTriggerPrimitivesReader.h.

Referenced by bookEfficHistos(), calcEfficiency(), drawEfficHistos(), drawHistosForTalks(), and endJob().

TH1F* CSCTriggerPrimitivesReader::hEtaDiffCsc[CSC_TYPES][3]

private

Definition at line 436 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F* CSCTriggerPrimitivesReader::hEtaDiffVsEta[MAX_STATIONS]

private

Definition at line 435 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH2F* CSCTriggerPrimitivesReader::hEtaDiffVsWireCsc[CSC_TYPES]

private

Definition at line 437 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH2F* CSCTriggerPrimitivesReader::hEtaRecVsSim

private

Definition at line 432 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F * CSCTriggerPrimitivesReader::hHotCham1

private

Definition at line 322 of file CSCTriggerPrimitivesReader.h.

Referenced by bookHotWireHistos(), and HotWires().

TH1F* CSCTriggerPrimitivesReader::hHotWire1

private

Definition at line 322 of file CSCTriggerPrimitivesReader.h.

Referenced by bookHotWireHistos(), and HotWires().

TH1F* CSCTriggerPrimitivesReader::hLCTCompFound

private

Definition at line 393 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hLCTCompFound2

private

Definition at line 394 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompFound2i

private

Definition at line 396 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompFound2x

private

Definition at line 395 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH1F* CSCTriggerPrimitivesReader::hLctCompFoundCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 425 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hLCTCompMatch

private

Definition at line 403 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hLCTCompMatch2

private

Definition at line 404 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompMatch2i

private

Definition at line 406 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompMatch2x

private

Definition at line 405 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH1F* CSCTriggerPrimitivesReader::hLctCompMatchCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 428 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hLCTCompSameN

private

Definition at line 398 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hLCTCompSameN2

private

Definition at line 399 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompSameN2i

private

Definition at line 401 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompSameN2x

private

Definition at line 400 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH1F* CSCTriggerPrimitivesReader::hLctCompSameNCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 426 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareLCTs(), and drawCompHistos().

TH1F* CSCTriggerPrimitivesReader::hLCTCompTotal

private

Definition at line 408 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos().

TH2F* CSCTriggerPrimitivesReader::hLCTCompTotal2

private

Definition at line 409 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompTotal2i

private

Definition at line 411 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH2F* CSCTriggerPrimitivesReader::hLCTCompTotal2x

private

Definition at line 410 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), and compareLCTs().

TH1F* CSCTriggerPrimitivesReader::hLctCompTotalCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 427 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCompHistos(), compareLCTs(), and drawCompHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCBend

private

Definition at line 350 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCBXN

private

Definition at line 350 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCChamber[MAX_STATIONS]

private

Definition at line 347 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCEndcap

private

Definition at line 346 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCKeyGroup

private

Definition at line 348 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCKeyGroupME11

private

Definition at line 458 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCKeyStrip

private

Definition at line 349 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCKeyStripME11

private

Definition at line 459 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCPattern

private

Definition at line 350 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCPerCSC

private

Definition at line 345 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCPerEvent

private

Definition at line 345 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCQuality

private

Definition at line 348 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCRing

private

Definition at line 346 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCSector

private

Definition at line 346 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCStation

private

Definition at line 346 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctMPCStripType

private

Definition at line 349 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F* CSCTriggerPrimitivesReader::hLctMPCValid

private

Definition at line 348 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTMPCHistos(), drawLCTMPCHistos(), and fillLCTMPCHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBBend

private

Definition at line 343 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBBXN

private

Definition at line 343 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBChamber[MAX_STATIONS]

private

Definition at line 340 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBCsc[MAX_ENDCAPS][CSC_TYPES]

private

Definition at line 340 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBEndcap

private

Definition at line 339 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBKeyGroup

private

Definition at line 341 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBKeyGroupME11

private

Definition at line 456 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBKeyStrip

private

Definition at line 342 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBKeyStripME11

private

Definition at line 457 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBPattern

private

Definition at line 343 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBPerChamber

private

Definition at line 337 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBPerCSC

private

Definition at line 338 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBPerEvent

private

Definition at line 337 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBQuality

private

Definition at line 341 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBRing

private

Definition at line 339 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBSector

private

Definition at line 339 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBStation

private

Definition at line 339 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F * CSCTriggerPrimitivesReader::hLctTMBStripType

private

Definition at line 342 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hLctTMBValid

private

Definition at line 341 of file CSCTriggerPrimitivesReader.h.

Referenced by bookLCTTMBHistos(), drawLCTTMBHistos(), and fillLCTTMBHistos().

TH1F* CSCTriggerPrimitivesReader::hPhiDiffCsc[CSC_TYPES][5]

private

Definition at line 444 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), drawHistosForTalks(), and drawResolHistos().

TH1F* CSCTriggerPrimitivesReader::hPhiDiffPattern[CSCConstants::NUM_CLCT_PATTERNS]

private

Definition at line 447 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F* CSCTriggerPrimitivesReader::hPhiDiffVsPhi[MAX_STATIONS]

private

Definition at line 443 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH2F* CSCTriggerPrimitivesReader::hPhiDiffVsStripCsc[CSC_TYPES][2]

private

Definition at line 445 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH2F* CSCTriggerPrimitivesReader::hPhiRecVsSim

private

Definition at line 439 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F * CSCTriggerPrimitivesReader::hResolDeltaDS

private

Definition at line 440 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), drawHistosForTalks(), and drawResolHistos().

TH1F * CSCTriggerPrimitivesReader::hResolDeltaEta

private

Definition at line 433 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F* CSCTriggerPrimitivesReader::hResolDeltaHS

private

Definition at line 440 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), drawHistosForTalks(), drawResolHistos(), and endJob().

TH1F* CSCTriggerPrimitivesReader::hResolDeltaPhi

private

Definition at line 441 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

TH1F * CSCTriggerPrimitivesReader::hResolDeltaPhiDS

private

Definition at line 441 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), and calcResolution().

TH1F * CSCTriggerPrimitivesReader::hResolDeltaPhiHS

private

Definition at line 441 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), and calcResolution().

TH1F* CSCTriggerPrimitivesReader::hResolDeltaWG

private

Definition at line 433 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), drawHistosForTalks(), drawResolHistos(), and endJob().

TH1F* CSCTriggerPrimitivesReader::hTrueBendCsc[CSC_TYPES]

private

Definition at line 446 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), calcResolution(), and drawResolHistos().

std::string CSCTriggerPrimitivesReader::lctProducerData_

private

Definition at line 171 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader().

std::string CSCTriggerPrimitivesReader::lctProducerEmul_

private

Definition at line 173 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> CSCTriggerPrimitivesReader::lcts_mpc_d_token_

private

Definition at line 185 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> CSCTriggerPrimitivesReader::lcts_mpc_e_token_

private

Definition at line 190 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> CSCTriggerPrimitivesReader::lcts_tmb_d_token_

private

Definition at line 184 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> CSCTriggerPrimitivesReader::lcts_tmb_e_token_

private

Definition at line 189 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

const int CSCTriggerPrimitivesReader::lut_wg_vs_hs_me1a

staticprivate

Initial value:

= {
  {0, 95},{0, 95},{0, 95},{0, 95},{0, 95},
  {0, 95},{0, 95},{0, 95},{0, 95},{0, 95},
  {0, 95},{0, 95},{0, 77},{0, 61},{0, 39},
  {0, 22},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1} }

Definition at line 219 of file CSCTriggerPrimitivesReader.h.

Referenced by doesALCTCrossCLCT().

const int CSCTriggerPrimitivesReader::lut_wg_vs_hs_me1ag

staticprivate

Initial value:

= {
  {0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
  {0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
  {0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
  {0, 22},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1} }

Definition at line 220 of file CSCTriggerPrimitivesReader.h.

Referenced by doesALCTCrossCLCT().

const int CSCTriggerPrimitivesReader::lut_wg_vs_hs_me1b

staticprivate

Initial value:

= {
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
  {100, 127},{73, 127},{47, 127},{22, 127},{0, 127},
  {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
  {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
  {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
  {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
  {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
  {0, 127},{0, 127},{0, 127},{0, 127},{0, 105},
  {0, 93},{0, 78},{0, 63} }

Definition at line 218 of file CSCTriggerPrimitivesReader.h.

Referenced by doesALCTCrossCLCT(), and getGlobalPosition().

const int CSCTriggerPrimitivesReader::MAX_HS

staticprivate

Initial value:

= {
  128, 160, 128,  96, 160, 160, 160, 160, 160, 160}

Definition at line 215 of file CSCTriggerPrimitivesReader.h.

Referenced by bookCLCTHistos(), bookResolHistos(), and getHsPerRad().

const int CSCTriggerPrimitivesReader::MAX_WG

staticprivate

Initial value:

= {
  48,  64,  32,  48, 112,  64,  96,  64,  96,  64}

Definition at line 214 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos().

std::string CSCTriggerPrimitivesReader::mpclctProducerData_

private

Definition at line 172 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader().

const int CSCTriggerPrimitivesReader::NCHAMBERS

staticprivate

Initial value:

= {
  36, 36, 36, 36, 18, 36, 18, 36, 18, 36}

Definition at line 213 of file CSCTriggerPrimitivesReader.h.

Referenced by bookALCTHistos(), bookCLCTHistos(), bookCompHistos(), bookLCTTMBHistos(), and getHsPerRad().

int CSCTriggerPrimitivesReader::numALCT = 0

staticprivate

Definition at line 222 of file CSCTriggerPrimitivesReader.h.

Referenced by endJob(), and fillALCTHistos().

int CSCTriggerPrimitivesReader::numCLCT = 0

staticprivate

Definition at line 223 of file CSCTriggerPrimitivesReader.h.

Referenced by endJob(), and fillCLCTHistos().

int CSCTriggerPrimitivesReader::numLCTMPC = 0

staticprivate

Definition at line 225 of file CSCTriggerPrimitivesReader.h.

Referenced by endJob(), and fillLCTMPCHistos().

int CSCTriggerPrimitivesReader::numLCTTMB = 0

staticprivate

Definition at line 224 of file CSCTriggerPrimitivesReader.h.

Referenced by endJob(), and fillLCTTMBHistos().

TreePerStub CSCTriggerPrimitivesReader::perStub[6]

private

Definition at line 317 of file CSCTriggerPrimitivesReader.h.

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

bool CSCTriggerPrimitivesReader::plotME1A

private

Definition at line 165 of file CSCTriggerPrimitivesReader.h.

Referenced by calcEfficiency(), CSCTriggerPrimitivesReader(), drawALCTHistos(), drawCLCTHistos(), drawCompHistos(), drawEfficHistos(), drawHistosForTalks(), drawLCTTMBHistos(), drawResolHistos(), and maxRing().

bool CSCTriggerPrimitivesReader::plotME42

private

Definition at line 168 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), drawALCTHistos(), drawCLCTHistos(), drawCompHistos(), drawEfficHistos(), drawHistosForTalks(), drawLCTTMBHistos(), and drawResolHistos().

edm::EDGetTokenT<CSCCLCTPreTriggerDigiCollection> CSCTriggerPrimitivesReader::pretrigs_e_token_

private

Definition at line 188 of file CSCTriggerPrimitivesReader.h.

Referenced by analyze(), and CSCTriggerPrimitivesReader().

bool CSCTriggerPrimitivesReader::printps = false

staticprivate

Definition at line 238 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and endJob().

const int CSCTriggerPrimitivesReader::ptype_TMB07

staticprivate

Initial value:

= {
  -999,  -5,  4, -4,  3, -3,  2, -2,  1, -1,  0}

Definition at line 216 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), and fillCLCTHistos().

std::string CSCTriggerPrimitivesReader::resultsFileNamesPrefix_

private

Definition at line 193 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), drawALCTHistos(), drawCLCTHistos(), drawCompHistos(), drawEfficHistos(), drawLCTMPCHistos(), drawLCTTMBHistos(), and drawResolHistos().

std::string CSCTriggerPrimitivesReader::rootFileName

private

Definition at line 145 of file CSCTriggerPrimitivesReader.h.

int CSCTriggerPrimitivesReader::RUN_

private

Definition at line 148 of file CSCTriggerPrimitivesReader.h.

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

edm::EDGetTokenT<edm::PSimHitContainer> CSCTriggerPrimitivesReader::simHit_token_

private

Definition at line 178 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and MCStudies().

edm::InputTag CSCTriggerPrimitivesReader::simHitProducer_

private

Definition at line 174 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and MCStudies().

TTree* CSCTriggerPrimitivesReader::stub_tree[4]

private

Definition at line 315 of file CSCTriggerPrimitivesReader.h.

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

MyStubComparison CSCTriggerPrimitivesReader::stubs_comparison[4]

private

Definition at line 314 of file CSCTriggerPrimitivesReader.h.

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

const double CSCTriggerPrimitivesReader::TWOPI = 2.*M_PI

staticprivate

Definition at line 207 of file CSCTriggerPrimitivesReader.h.

Referenced by bookResolHistos(), and getHsPerRad().

edm::EDGetTokenT<CSCWireDigiCollection> CSCTriggerPrimitivesReader::wireDigi_token_

private

Definition at line 179 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), HotWires(), and MCStudies().

edm::InputTag CSCTriggerPrimitivesReader::wireDigiProducer_

private

Definition at line 175 of file CSCTriggerPrimitivesReader.h.

Referenced by CSCTriggerPrimitivesReader(), and MCStudies().