CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
List of all members | Public Types | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
CSCOfflineMonitor Class Reference

#include <CSCOfflineMonitor.h>

Inheritance diagram for CSCOfflineMonitor:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

Public Types

enum  AxisType { X = 1, Y = 2, Z = 3 }
 
enum  LabelType { SMALL, EXTENDED }
 
- Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::RunSummaryCache
 

Public Member Functions

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

Protected Member Functions

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

Private Member Functions

void applyCSClabels (MonitorElement *meHisto, LabelType t, AxisType a)
 
int chamberSerial (CSCDetId id)
 
void doBXMonitor (edm::Handle< CSCALCTDigiCollection > alcts, edm::Handle< CSCCLCTDigiCollection > clcts, const edm::Event &event, const edm::EventSetup &eventSetup)
 
void doEfficiencies (edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
 
void doOccupancies (edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::Handle< CSCCLCTDigiCollection > clcts)
 
void doPedestalNoise (edm::Handle< CSCStripDigiCollection > strips, edm::ESHandle< CSCGeometry > cscGeom)
 
void doRecHits (edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCStripDigiCollection > strips, edm::ESHandle< CSCGeometry > cscGeom)
 
void doResolution (edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
 
void doSegments (edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
 
void doStripDigis (edm::Handle< CSCStripDigiCollection > strips)
 
void doWireDigis (edm::Handle< CSCWireDigiCollection > wires)
 
double extrapolate1D (double initPosition, double initDirection, double parameterOfTheLine)
 
void fillEfficiencyHistos (int bin, int flag)
 
float fitX (const CLHEP::HepMatrix &sp, const CLHEP::HepMatrix &ep)
 
float getSignal (const CSCStripDigiCollection &stripdigis, CSCDetId idRH, int centerStrip)
 
double lineParametrization (double z1Position, double z2Position, double z1Direction)
 
int typeIndex (CSCDetId id, int flag=1)
 
bool withinSensitiveRegion (LocalPoint localPos, const std::array< const float, 4 > &layerBounds, int station, int ring, float shiftFromEdge, float shiftFromDeadZone)
 

Private Attributes

edm::EDGetTokenT< CSCALCTDigiCollectional_token
 
edm::EDGetTokenT< CSCCLCTDigiCollectioncl_token
 
const edm::ESGetToken< CSCGeometry, MuonGeometryRecordcscGeomToken_
 
MonitorElementhALCTgetBX
 
MonitorElementhALCTgetBX2Denominator
 
MonitorElementhALCTgetBX2DNumerator
 
MonitorElementhALCTgetBXSerial
 
MonitorElementhALCTMatch
 
MonitorElementhALCTMatch2Denominator
 
MonitorElementhALCTMatch2DNumerator
 
MonitorElementhALCTMatchSerial
 
MonitorElementhCLCTL1A
 
MonitorElementhCLCTL1A2Denominator
 
MonitorElementhCLCTL1A2DNumerator
 
MonitorElementhCLCTL1ASerial
 
const edm::ESGetToken< CSCCrateMap, CSCCrateMapRcdhcrateToken_
 
MonitorElementhCSCOccupancy
 
MonitorElementhEffDenominator
 
MonitorElementhORecHits
 
MonitorElementhORecHitsSerial
 
MonitorElementhOSegments
 
MonitorElementhOSegmentsSerial
 
MonitorElementhOStrips
 
MonitorElementhOStripsAndWiresAndCLCT
 
MonitorElementhOStripSerial
 
MonitorElementhOWires
 
MonitorElementhOWiresAndCLCT
 
MonitorElementhOWireSerial
 
MonitorElementhRHden
 
std::vector< MonitorElement * > hRHGlobal
 
MonitorElementhRHnrechits
 
MonitorElementhRHnrechitsHi
 
MonitorElementhRHnum
 
std::vector< MonitorElement * > hRHRatioQ
 
MonitorElementhRHSTE2
 
std::vector< MonitorElement * > hRHsterr
 
std::vector< MonitorElement * > hRHstpos
 
std::vector< MonitorElement * > hRHSumQ
 
std::vector< MonitorElement * > hRHTiming
 
std::vector< MonitorElement * > hRHTimingAnode
 
std::vector< MonitorElement * > hSChiSq
 
MonitorElementhSChiSqAll
 
std::vector< MonitorElement * > hSChiSqProb
 
MonitorElementhSChiSqProbAll
 
MonitorElementhSden
 
MonitorElementhSensitiveAreaEvt
 
MonitorElementhSGlobalPhi
 
MonitorElementhSGlobalTheta
 
std::vector< MonitorElement * > hSnhits
 
MonitorElementhSnhitsAll
 
MonitorElementhSnSegments
 
MonitorElementhSnum
 
std::vector< MonitorElement * > hSResid
 
MonitorElementhSSTE2
 
MonitorElementhSTimeAnode
 
std::vector< MonitorElement * > hSTimeAnodeByChamberType
 
MonitorElementhSTimeAnodeSerial
 
MonitorElementhSTimeCathode
 
std::vector< MonitorElement * > hSTimeCathodeByChamberType
 
MonitorElementhSTimeCathodeSerial
 
MonitorElementhSTimeCombined
 
std::vector< MonitorElement * > hSTimeCombinedByChamberType
 
MonitorElementhSTimeCombinedSerial
 
MonitorElementhSTimeDiff
 
std::vector< MonitorElement * > hSTimeDiffByChamberType
 
MonitorElementhSTimeDiffSerial
 
MonitorElementhSTimeVsTOF
 
MonitorElementhSTimeVsZ
 
MonitorElementhStripNFired
 
MonitorElementhStripNFiredHi
 
std::vector< MonitorElement * > hStripNumber
 
std::vector< MonitorElement * > hStripPed
 
MonitorElementhStripSTE2
 
MonitorElementhWirenGroupsTotal
 
MonitorElementhWirenGroupsTotalHi
 
std::vector< MonitorElement * > hWireNumber
 
MonitorElementhWireSTE2
 
std::vector< MonitorElement * > hWireTBin
 
edm::ParameterSet param
 
edm::EDGetTokenT< FEDRawDataCollectionrd_token
 
edm::EDGetTokenT< CSCRecHit2DCollectionrh_token
 
edm::EDGetTokenT< CSCStripDigiCollectionsd_token
 
edm::EDGetTokenT< CSCSegmentCollectionse_token
 
edm::EDGetTokenT< CSCWireDigiCollectionwd_token
 

Additional Inherited Members

- Static Public Member Functions inherited from DQMEDAnalyzer
static void globalEndJob (DQMEDAnalyzerGlobalCache const *)
 
static void globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
 
static void globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
 
static std::unique_ptr< DQMEDAnalyzerGlobalCacheinitializeGlobalCache (edm::ParameterSet const &)
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMTokenlumiToken_
 
edm::EDPutTokenT< DQMTokenrunToken_
 
unsigned int streamId_
 

Detailed Description

Simple package for offline CSC DQM based on RecoLocalMuon/CSCValidation: digis, rechits, segments

Andrew Kubik, Northwestern University, Oct 2008

Definition at line 69 of file CSCOfflineMonitor.h.

Member Enumeration Documentation

◆ AxisType

Enumerator

Definition at line 75 of file CSCOfflineMonitor.h.

◆ LabelType

Enumerator
SMALL 
EXTENDED 

Definition at line 74 of file CSCOfflineMonitor.h.

Constructor & Destructor Documentation

◆ CSCOfflineMonitor()

CSCOfflineMonitor::CSCOfflineMonitor ( const edm::ParameterSet pset)

Definition at line 13 of file CSCOfflineMonitor.cc.

References al_token, cl_token, muonDTDigis_cfi::pset, rd_token, rh_token, sd_token, se_token, and wd_token.

14  : cscGeomToken_(esConsumes<CSCGeometry, MuonGeometryRecord>()),
15  hcrateToken_(esConsumes<CSCCrateMap, CSCCrateMapRcd>()) {
16  rd_token = consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("FEDRawDataCollectionTag"));
17  sd_token = consumes<CSCStripDigiCollection>(pset.getParameter<edm::InputTag>("stripDigiTag"));
18  wd_token = consumes<CSCWireDigiCollection>(pset.getParameter<edm::InputTag>("wireDigiTag"));
19  al_token = consumes<CSCALCTDigiCollection>(pset.getParameter<edm::InputTag>("alctDigiTag"));
20  cl_token = consumes<CSCCLCTDigiCollection>(pset.getParameter<edm::InputTag>("clctDigiTag"));
21  rh_token = consumes<CSCRecHit2DCollection>(pset.getParameter<edm::InputTag>("cscRecHitTag"));
22  se_token = consumes<CSCSegmentCollection>(pset.getParameter<edm::InputTag>("cscSegTag"));
23 }
edm::EDGetTokenT< CSCALCTDigiCollection > al_token
const edm::ESGetToken< CSCCrateMap, CSCCrateMapRcd > hcrateToken_
edm::EDGetTokenT< CSCWireDigiCollection > wd_token
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord > cscGeomToken_
edm::EDGetTokenT< FEDRawDataCollection > rd_token
edm::EDGetTokenT< CSCCLCTDigiCollection > cl_token
edm::EDGetTokenT< CSCSegmentCollection > se_token
edm::EDGetTokenT< CSCStripDigiCollection > sd_token
edm::EDGetTokenT< CSCRecHit2DCollection > rh_token

◆ ~CSCOfflineMonitor()

CSCOfflineMonitor::~CSCOfflineMonitor ( )
inlineoverride

Definition at line 72 of file CSCOfflineMonitor.h.

72 {};

Member Function Documentation

◆ analyze()

void CSCOfflineMonitor::analyze ( const edm::Event event,
const edm::EventSetup eventSetup 
)
overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 826 of file CSCOfflineMonitor.cc.

References al_token, cl_token, cscGeomToken_, dtChamberEfficiency_cfi::cscSegments, doBXMonitor(), doEfficiencies(), doOccupancies(), doPedestalNoise(), doRecHits(), doResolution(), doSegments(), doStripDigis(), doWireDigis(), options_cfi::eventSetup, FastTrackerRecHitMaskProducer_cfi::recHits, rh_token, sd_token, se_token, DigiDM_cff::strips, wd_token, and DigiDM_cff::wires.

826  {
831  event.getByToken(sd_token, strips);
832  event.getByToken(wd_token, wires);
833  event.getByToken(al_token, alcts);
834  event.getByToken(cl_token, clcts);
835 
836  // Get the CSC Geometry :
838 
839  cscGeom = eventSetup.getHandle(cscGeomToken_);
840 
841  // Get the RecHits collection :
843  event.getByToken(rh_token, recHits);
844 
845  // get CSC segment collection
847  event.getByToken(se_token, cscSegments);
848 
852  doRecHits(recHits, strips, cscGeom);
853  doSegments(cscSegments, cscGeom);
854  doResolution(cscSegments, cscGeom);
855  doPedestalNoise(strips, cscGeom);
857  doBXMonitor(alcts, clcts, event, eventSetup);
858 }
edm::EDGetTokenT< CSCALCTDigiCollection > al_token
void doResolution(edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
edm::EDGetTokenT< CSCWireDigiCollection > wd_token
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord > cscGeomToken_
edm::EDGetTokenT< CSCCLCTDigiCollection > cl_token
edm::EDGetTokenT< CSCSegmentCollection > se_token
edm::EDGetTokenT< CSCStripDigiCollection > sd_token
void doSegments(edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
void doWireDigis(edm::Handle< CSCWireDigiCollection > wires)
void doBXMonitor(edm::Handle< CSCALCTDigiCollection > alcts, edm::Handle< CSCCLCTDigiCollection > clcts, const edm::Event &event, const edm::EventSetup &eventSetup)
void doStripDigis(edm::Handle< CSCStripDigiCollection > strips)
void doPedestalNoise(edm::Handle< CSCStripDigiCollection > strips, edm::ESHandle< CSCGeometry > cscGeom)
strips
#turn off noise in all subdetectors simHcalUnsuppressedDigis.doNoise = False mix.digitizers.hcal.doNoise = False simEcalUnsuppressedDigis.doNoise = False mix.digitizers.ecal.doNoise = False simEcalUnsuppressedDigis.doESNoise = False simSiPixelDigis.AddNoise = False mix.digitizers.pixel.AddNoise = False simSiStripDigis.Noise = False mix.digitizers.strip.AddNoise = False
Definition: DigiDM_cff.py:32
edm::EDGetTokenT< CSCRecHit2DCollection > rh_token
void doEfficiencies(edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)
void doOccupancies(edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::Handle< CSCCLCTDigiCollection > clcts)
Definition: event.py:1
void doRecHits(edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCStripDigiCollection > strips, edm::ESHandle< CSCGeometry > cscGeom)

◆ applyCSClabels()

void CSCOfflineMonitor::applyCSClabels ( MonitorElement meHisto,
LabelType  t,
AxisType  a 
)
private

Definition at line 2147 of file CSCOfflineMonitor.cc.

References a, EXTENDED, hlt_dqm_clientPB-live_cfg::me, SMALL, and submitPVValidationJobs::t.

Referenced by bookHistograms().

2147  {
2148  if (me != nullptr) {
2149  me->setAxisTitle("Chamber #");
2150  if (t == EXTENDED) {
2151  me->setBinLabel(1, "ME -4/2", a);
2152  me->setBinLabel(2, "ME -4/1", a);
2153  me->setBinLabel(3, "ME -3/2", a);
2154  me->setBinLabel(4, "ME -3/1", a);
2155  me->setBinLabel(5, "ME -2/2", a);
2156  me->setBinLabel(6, "ME -2/1", a);
2157  me->setBinLabel(7, "ME -1/3", a);
2158  me->setBinLabel(8, "ME -1/2", a);
2159  me->setBinLabel(9, "ME -1/1b", a);
2160  me->setBinLabel(10, "ME -1/1a", a);
2161  me->setBinLabel(11, "ME +1/1a", a);
2162  me->setBinLabel(12, "ME +1/1b", a);
2163  me->setBinLabel(13, "ME +1/2", a);
2164  me->setBinLabel(14, "ME +1/3", a);
2165  me->setBinLabel(15, "ME +2/1", a);
2166  me->setBinLabel(16, "ME +2/2", a);
2167  me->setBinLabel(17, "ME +3/1", a);
2168  me->setBinLabel(18, "ME +3/2", a);
2169  me->setBinLabel(19, "ME +4/1", a);
2170  me->setBinLabel(20, "ME +4/2", a);
2171  } else if (t == SMALL) {
2172  me->setBinLabel(1, "ME -4/1", a);
2173  me->setBinLabel(2, "ME -3/2", a);
2174  me->setBinLabel(3, "ME -3/1", a);
2175  me->setBinLabel(4, "ME -2/2", a);
2176  me->setBinLabel(5, "ME -2/1", a);
2177  me->setBinLabel(6, "ME -1/3", a);
2178  me->setBinLabel(7, "ME -1/2", a);
2179  me->setBinLabel(8, "ME -1/1b", a);
2180  me->setBinLabel(9, "ME -1/1a", a);
2181  me->setBinLabel(10, "ME +1/1a", a);
2182  me->setBinLabel(11, "ME +1/1b", a);
2183  me->setBinLabel(12, "ME +1/2", a);
2184  me->setBinLabel(13, "ME +1/3", a);
2185  me->setBinLabel(14, "ME +2/1", a);
2186  me->setBinLabel(15, "ME +2/2", a);
2187  me->setBinLabel(16, "ME +3/1", a);
2188  me->setBinLabel(17, "ME +3/2", a);
2189  me->setBinLabel(18, "ME +4/1", a);
2190  }
2191  }
2192 }
double a
Definition: hdecay.h:121

◆ bookHistograms()

void CSCOfflineMonitor::bookHistograms ( DQMStore::IBooker ibooker,
edm::Run const &  iRun,
edm::EventSetup const &   
)
overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 25 of file CSCOfflineMonitor.cc.

References applyCSClabels(), dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::NavigatorBase::cd(), EXTENDED, hALCTgetBX, hALCTgetBX2Denominator, hALCTgetBX2DNumerator, hALCTgetBXSerial, hALCTMatch, hALCTMatch2Denominator, hALCTMatch2DNumerator, hALCTMatchSerial, hCLCTL1A, hCLCTL1A2Denominator, hCLCTL1A2DNumerator, hCLCTL1ASerial, hCSCOccupancy, hEffDenominator, hORecHits, hORecHitsSerial, hOSegments, hOSegmentsSerial, hOStrips, hOStripsAndWiresAndCLCT, hOStripSerial, hOWires, hOWiresAndCLCT, hOWireSerial, hRHden, hRHGlobal, hRHnrechits, hRHnrechitsHi, hRHnum, hRHRatioQ, hRHSTE2, hRHsterr, hRHstpos, hRHSumQ, hRHTiming, hRHTimingAnode, hSChiSq, hSChiSqAll, hSChiSqProb, hSChiSqProbAll, hSden, hSensitiveAreaEvt, hSGlobalPhi, hSGlobalTheta, hSnhits, hSnhitsAll, hSnSegments, hSnum, hSResid, hSSTE2, hSTimeAnode, hSTimeAnodeByChamberType, hSTimeAnodeSerial, hSTimeCathode, hSTimeCathodeByChamberType, hSTimeCathodeSerial, hSTimeCombined, hSTimeCombinedByChamberType, hSTimeCombinedSerial, hSTimeDiff, hSTimeDiffByChamberType, hSTimeDiffSerial, hSTimeVsTOF, hSTimeVsZ, hStripNFired, hStripNFiredHi, hStripNumber, hStripPed, hStripSTE2, hWirenGroupsTotal, hWirenGroupsTotalHi, hWireNumber, hWireSTE2, hWireTBin, dqm::impl::MonitorElement::setAxisTitle(), dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), X, and Y.

27  {
28  // occupancies
29  ibooker.cd();
30  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Occupancy");
31 
32  hCSCOccupancy = ibooker.book1D("hCSCOccupancy", "overall CSC occupancy", 13, -0.5, 12.5);
33  hCSCOccupancy->setBinLabel(2, "Total Events");
34  hCSCOccupancy->setBinLabel(4, "# Events with Wires");
35  hCSCOccupancy->setBinLabel(6, "# Events with Strips");
36  hCSCOccupancy->setBinLabel(8, "# Events with Wires&Strips");
37  hCSCOccupancy->setBinLabel(10, "# Events with Rechits");
38  hCSCOccupancy->setBinLabel(12, "# Events with Segments");
39  hOWiresAndCLCT = ibooker.book2D("hOWiresAndCLCT", "Wire and CLCT Digi Occupancy ", 36, 0.5, 36.5, 20, 0.5, 20.5);
40  hOWires = ibooker.book2D("hOWires", "Wire Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
41  hOWireSerial = ibooker.book1D("hOWireSerial", "Wire Occupancy by Chamber Serial", 601, -0.5, 600.5);
42  hOWireSerial->setAxisTitle("Chamber Serial Number");
43  hOStrips = ibooker.book2D("hOStrips", "Strip Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
44  hOStripSerial = ibooker.book1D("hOStripSerial", "Strip Occupancy by Chamber Serial", 601, -0.5, 600.5);
45  hOStripSerial->setAxisTitle("Chamber Serial Number");
47  ibooker.book2D("hOStripsAndWiresAndCLCT", "Strip And Wire And CLCT Digi Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
49  hORecHits = ibooker.book2D("hORecHits", "RecHit Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
50  hORecHitsSerial = ibooker.book1D("hORecHitSerial", "RecHit Occupancy by Chamber Serial", 601, -0.5, 600.5);
51  hORecHitsSerial->setAxisTitle("Chamber Serial Number");
52  hOSegments = ibooker.book2D("hOSegments", "Segment Occupancy", 36, 0.5, 36.5, 20, 0.5, 20.5);
53  hOSegmentsSerial = ibooker.book1D("hOSegmentSerial", "Segment Occupancy by Chamber Serial", 601, -0.5, 600.5);
54  hOSegmentsSerial->setAxisTitle("Chamber Serial Number");
55 
56  // wire digis
57  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Digis");
58 
59  // For low multiplicities (e.g. low or no pileup)
61  ibooker.book1D("hWirenGroupsTotal", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 250.); // 1 bin is 1
62  // For high multiplcities (e.g. with pileup)
64  ibooker.book1D("hWirenGroupsTotalHi", "Fired Wires per Event; # Wiregroups Fired", 250, 0., 1000.); // i bin is 4
65 
66  hWireTBin.push_back(ibooker.book1D("hWireTBin_m42", "Wire TBin Fired (ME -4/2); Time Bin (25ns)", 17, -0.5, 16.5));
67  hWireTBin.push_back(ibooker.book1D("hWireTBin_m41", "Wire TBin Fired (ME -4/1); Time Bin (25ns)", 17, -0.5, 16.5));
68  hWireTBin.push_back(ibooker.book1D("hWireTBin_m32", "Wire TBin Fired (ME -3/2); Time Bin (25ns)", 17, -0.5, 16.5));
69  hWireTBin.push_back(ibooker.book1D("hWireTBin_m31", "Wire TBin Fired (ME -3/1); Time Bin (25ns)", 17, -0.5, 16.5));
70  hWireTBin.push_back(ibooker.book1D("hWireTBin_m22", "Wire TBin Fired (ME -2/2); Time Bin (25ns)", 17, -0.5, 16.5));
71  hWireTBin.push_back(ibooker.book1D("hWireTBin_m21", "Wire TBin Fired (ME -2/1); Time Bin (25ns)", 17, -0.5, 16.5));
72  hWireTBin.push_back(ibooker.book1D("hWireTBin_m11a", "Wire TBin Fired (ME -1/1a); Time Bin (25ns)", 17, -0.5, 16.5));
73  hWireTBin.push_back(ibooker.book1D("hWireTBin_m13", "Wire TBin Fired (ME -1/3); Time Bin (25ns)", 17, -0.5, 16.5));
74  hWireTBin.push_back(ibooker.book1D("hWireTBin_m12", "Wire TBin Fired (ME -1/2); Time Bin (25ns)", 17, -0.5, 16.5));
75  hWireTBin.push_back(ibooker.book1D("hWireTBin_m11b", "Wire TBin Fired (ME -1/1b); Time Bin (25ns)", 17, -0.5, 16.5));
76  hWireTBin.push_back(ibooker.book1D("hWireTBin_p11b", "Wire TBin Fired (ME +1/1b); Time Bin (25ns)", 17, -0.5, 16.5));
77  hWireTBin.push_back(ibooker.book1D("hWireTBin_p12", "Wire TBin Fired (ME +1/2); Time Bin (25ns)", 17, -0.5, 16.5));
78  hWireTBin.push_back(ibooker.book1D("hWireTBin_p13", "Wire TBin Fired (ME +1/3); Time Bin (25ns)", 17, -0.5, 16.5));
79  hWireTBin.push_back(ibooker.book1D("hWireTBin_p11a", "Wire TBin Fired (ME +1/1a); Time Bin (25ns)", 17, -0.5, 16.5));
80  hWireTBin.push_back(ibooker.book1D("hWireTBin_p21", "Wire TBin Fired (ME +2/1); Time Bin (25ns)", 17, -0.5, 16.5));
81  hWireTBin.push_back(ibooker.book1D("hWireTBin_p22", "Wire TBin Fired (ME +2/2); Time Bin (25ns)", 17, -0.5, 16.5));
82  hWireTBin.push_back(ibooker.book1D("hWireTBin_p31", "Wire TBin Fired (ME +3/1); Time Bin (25ns)", 17, -0.5, 16.5));
83  hWireTBin.push_back(ibooker.book1D("hWireTBin_p32", "Wire TBin Fired (ME +3/2); Time Bin (25ns)", 17, -0.5, 16.5));
84  hWireTBin.push_back(ibooker.book1D("hWireTBin_p41", "Wire TBin Fired (ME +4/1); Time Bin (25ns)", 17, -0.5, 16.5));
85  hWireTBin.push_back(ibooker.book1D("hWireTBin_p42", "Wire TBin Fired (ME +4/2); Time Bin (25ns)", 17, -0.5, 16.5));
86  hWireNumber.push_back(
87  ibooker.book1D("hWireNumber_m42", "Wiregroup Number Fired (ME -4/2); Wiregroup #", 113, -0.5, 112.5));
88  hWireNumber.push_back(
89  ibooker.book1D("hWireNumber_m41", "Wiregroup Number Fired (ME -4/1); Wiregroup #", 113, -0.5, 112.5));
90  hWireNumber.push_back(
91  ibooker.book1D("hWireNumber_m32", "Wiregroup Number Fired (ME -3/2); Wiregroup #", 113, -0.5, 112.5));
92  hWireNumber.push_back(
93  ibooker.book1D("hWireNumber_m31", "Wiregroup Number Fired (ME -3/1); Wiregroup #", 113, -0.5, 112.5));
94  hWireNumber.push_back(
95  ibooker.book1D("hWireNumber_m22", "Wiregroup Number Fired (ME -2/2); Wiregroup #", 113, -0.5, 112.5));
96  hWireNumber.push_back(
97  ibooker.book1D("hWireNumber_m21", "Wiregroup Number Fired (ME -2/1); Wiregroup #", 113, -0.5, 112.5));
98  hWireNumber.push_back(
99  ibooker.book1D("hWireNumber_m11a", "Wiregroup Number Fired (ME -1/1a); Wiregroup #", 113, -0.5, 112.5));
100  hWireNumber.push_back(
101  ibooker.book1D("hWireNumber_m13", "Wiregroup Number Fired (ME -1/3); Wiregroup #", 113, -0.5, 112.5));
102  hWireNumber.push_back(
103  ibooker.book1D("hWireNumber_m12", "Wiregroup Number Fired (ME -1/2); Wiregroup #", 113, -0.5, 112.5));
104  hWireNumber.push_back(
105  ibooker.book1D("hWireNumber_m11b", "Wiregroup Number Fired (ME -1/1b); Wiregroup #", 113, -0.5, 112.5));
106  hWireNumber.push_back(
107  ibooker.book1D("hWireNumber_p11b", "Wiregroup Number Fired (ME +1/1b); Wiregroup #", 113, -0.5, 112.5));
108  hWireNumber.push_back(
109  ibooker.book1D("hWireNumber_p12", "Wiregroup Number Fired (ME +1/2); Wiregroup #", 113, -0.5, 112.5));
110  hWireNumber.push_back(
111  ibooker.book1D("hWireNumber_p13", "Wiregroup Number Fired (ME +1/3); Wiregroup #", 113, -0.5, 112.5));
112  hWireNumber.push_back(
113  ibooker.book1D("hWireNumber_p11a", "Wiregroup Number Fired (ME +1/1a); Wiregroup #", 113, -0.5, 112.5));
114  hWireNumber.push_back(
115  ibooker.book1D("hWireNumber_p21", "Wiregroup Number Fired (ME +2/1); Wiregroup #", 113, -0.5, 112.5));
116  hWireNumber.push_back(
117  ibooker.book1D("hWireNumber_p22", "Wiregroup Number Fired (ME +2/2); Wiregroup #", 113, -0.5, 112.5));
118  hWireNumber.push_back(
119  ibooker.book1D("hWireNumber_p31", "Wiregroup Number Fired (ME +3/1); Wiregroup #", 113, -0.5, 112.5));
120  hWireNumber.push_back(
121  ibooker.book1D("hWireNumber_p32", "Wiregroup Number Fired (ME +3/2); Wiregroup #", 113, -0.5, 112.5));
122  hWireNumber.push_back(
123  ibooker.book1D("hWireNumber_p41", "Wiregroup Number Fired (ME +4/1); Wiregroup #", 113, -0.5, 112.5));
124  hWireNumber.push_back(
125  ibooker.book1D("hWireNumber_p42", "Wiregroup Number Fired (ME +4/2); Wiregroup #", 113, -0.5, 112.5));
126 
127  // strip digis
128 
129  // For low multiplicities (e.g. low or no pileup)
130  hStripNFired = ibooker.book1D(
131  "hStripNFired", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 400, 0., 400.); // 1 bin is 1
132  // For high multiplcities (e.g. with pileup)
133  hStripNFiredHi = ibooker.book1D(
134  "hStripNFiredHi", "Fired Strips per Event; # Strips Fired (above 13 ADC)", 500, 0., 2000.); // 1 bin is 4
135 
136  hStripNumber.push_back(
137  ibooker.book1D("hStripNumber_m42", "Strip Number Fired (ME -4/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
138  hStripNumber.push_back(
139  ibooker.book1D("hStripNumber_m41", "Strip Number Fired (ME -4/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
140  hStripNumber.push_back(
141  ibooker.book1D("hStripNumber_m32", "Strip Number Fired (ME -3/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
142  hStripNumber.push_back(
143  ibooker.book1D("hStripNumber_m31", "Strip Number Fired (ME -3/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
144  hStripNumber.push_back(
145  ibooker.book1D("hStripNumber_m22", "Strip Number Fired (ME -2/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
146  hStripNumber.push_back(
147  ibooker.book1D("hStripNumber_m21", "Strip Number Fired (ME -2/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
148  hStripNumber.push_back(ibooker.book1D(
149  "hStripNumber_m11a", "Strip Number Fired (ME -1/1a); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
150  hStripNumber.push_back(
151  ibooker.book1D("hStripNumber_m13", "Strip Number Fired (ME -1/3); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
152  hStripNumber.push_back(
153  ibooker.book1D("hStripNumber_m12", "Strip Number Fired (ME -1/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
154  hStripNumber.push_back(ibooker.book1D(
155  "hStripNumber_m11b", "Strip Number Fired (ME -1/1b); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
156  hStripNumber.push_back(ibooker.book1D(
157  "hStripNumber_p11b", "Strip Number Fired (ME +1/1b); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
158  hStripNumber.push_back(
159  ibooker.book1D("hStripNumber_p12", "Strip Number Fired (ME +1/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
160  hStripNumber.push_back(
161  ibooker.book1D("hStripNumber_p13", "Strip Number Fired (ME +1/3); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
162  hStripNumber.push_back(ibooker.book1D(
163  "hStripNumber_p11a", "Strip Number Fired (ME +1/1a); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
164  hStripNumber.push_back(
165  ibooker.book1D("hStripNumber_p21", "Strip Number Fired (ME +2/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
166  hStripNumber.push_back(
167  ibooker.book1D("hStripNumber_p22", "Strip Number Fired (ME +2/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
168  hStripNumber.push_back(
169  ibooker.book1D("hStripNumber_p31", "Strip Number Fired (ME +3/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
170  hStripNumber.push_back(
171  ibooker.book1D("hStripNumber_p32", "Strip Number Fired (ME +3/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
172  hStripNumber.push_back(
173  ibooker.book1D("hStripNumber_p41", "Strip Number Fired (ME +4/1); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
174  hStripNumber.push_back(ibooker.book1D(
175  "hStripNumber_p42", "Stripgroup Number Fired (ME +4/2); Strip # Fired (above 13 ADC)", 81, -0.5, 80.5));
176 
177  // pedestal noise
178  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/PedestalNoise");
179 
180  hStripPed.push_back(
181  ibooker.book1D("hStripPedMEm42", "Pedestal Noise Distribution Chamber ME -4/2; ADC Counts", 50, -25., 25.));
182  hStripPed.push_back(
183  ibooker.book1D("hStripPedMEm41", "Pedestal Noise Distribution Chamber ME -4/1; ADC Counts", 50, -25., 25.));
184  hStripPed.push_back(
185  ibooker.book1D("hStripPedMEm32", "Pedestal Noise Distribution Chamber ME -3/2; ADC Counts", 50, -25., 25.));
186  hStripPed.push_back(
187  ibooker.book1D("hStripPedMEm31", "Pedestal Noise Distribution Chamber ME -3/1; ADC Counts", 50, -25., 25.));
188  hStripPed.push_back(
189  ibooker.book1D("hStripPedMEm22", "Pedestal Noise Distribution Chamber ME -2/2; ADC Counts", 50, -25., 25.));
190  hStripPed.push_back(
191  ibooker.book1D("hStripPedMEm21", "Pedestal Noise Distribution Chamber ME -2/1; ADC Counts", 50, -25., 25.));
192  hStripPed.push_back(
193  ibooker.book1D("hStripPedMEm11a", "Pedestal Noise Distribution Chamber ME -1/1; ADC Counts", 50, -25., 25.));
194  hStripPed.push_back(
195  ibooker.book1D("hStripPedMEm13", "Pedestal Noise Distribution Chamber ME -1/3; ADC Counts", 50, -25., 25.));
196  hStripPed.push_back(
197  ibooker.book1D("hStripPedMEm12", "Pedestal Noise Distribution Chamber ME -1/2; ADC Counts", 50, -25., 25.));
198  hStripPed.push_back(
199  ibooker.book1D("hStripPedMEm11b", "Pedestal Noise Distribution Chamber ME -1/1; ADC Counts", 50, -25., 25.));
200  hStripPed.push_back(
201  ibooker.book1D("hStripPedMEp11b", "Pedestal Noise Distribution Chamber ME +1/1; ADC Counts", 50, -25., 25.));
202  hStripPed.push_back(
203  ibooker.book1D("hStripPedMEp12", "Pedestal Noise Distribution Chamber ME +1/2; ADC Counts", 50, -25., 25.));
204  hStripPed.push_back(
205  ibooker.book1D("hStripPedMEp13", "Pedestal Noise Distribution Chamber ME +1/3; ADC Counts", 50, -25., 25.));
206  hStripPed.push_back(
207  ibooker.book1D("hStripPedMEp11a", "Pedestal Noise Distribution Chamber ME +1/1; ADC Counts", 50, -25., 25.));
208  hStripPed.push_back(
209  ibooker.book1D("hStripPedMEp21", "Pedestal Noise Distribution Chamber ME +2/1; ADC Counts", 50, -25., 25.));
210  hStripPed.push_back(
211  ibooker.book1D("hStripPedMEp22", "Pedestal Noise Distribution Chamber ME +2/2; ADC Counts", 50, -25., 25.));
212  hStripPed.push_back(
213  ibooker.book1D("hStripPedMEp31", "Pedestal Noise Distribution Chamber ME +3/1; ADC Counts", 50, -25., 25.));
214  hStripPed.push_back(
215  ibooker.book1D("hStripPedMEp32", "Pedestal Noise Distribution Chamber ME +3/2; ADC Counts", 50, -25., 25.));
216  hStripPed.push_back(
217  ibooker.book1D("hStripPedMEp41", "Pedestal Noise Distribution Chamber ME +4/1; ADC Counts", 50, -25., 25.));
218  hStripPed.push_back(
219  ibooker.book1D("hStripPedMEp42", "Pedestal Noise Distribution Chamber ME +4/2; ADC Counts", 50, -25., 25.));
220 
221  // rechits
222  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/recHits");
223 
224  // For low multiplicities (e.g. low or no pileup)
225  hRHnrechits = ibooker.book1D("hRHnrechits", "RecHits per Event; # of RecHits", 100, 0., 100.); // 1 bin is 1
226  // For high multiplcities (e.g. with pileup)
227  hRHnrechitsHi = ibooker.book1D("hRHnrechitsHi", "RecHits per Event; # of RecHits", 250, 0., 1000.); // 1 bin is 4
228 
229  hRHGlobal.push_back(ibooker.book2D(
230  "hRHGlobalp1", "recHit global X,Y station +1; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
231  hRHGlobal.push_back(ibooker.book2D(
232  "hRHGlobalp2", "recHit global X,Y station +2; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
233  hRHGlobal.push_back(ibooker.book2D(
234  "hRHGlobalp3", "recHit global X,Y station +3; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
235  hRHGlobal.push_back(ibooker.book2D(
236  "hRHGlobalp4", "recHit global X,Y station +4; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
237  hRHGlobal.push_back(ibooker.book2D(
238  "hRHGlobalm1", "recHit global X,Y station -1; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
239  hRHGlobal.push_back(ibooker.book2D(
240  "hRHGlobalm2", "recHit global X,Y station -2; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
241  hRHGlobal.push_back(ibooker.book2D(
242  "hRHGlobalm3", "recHit global X,Y station -3; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
243  hRHGlobal.push_back(ibooker.book2D(
244  "hRHGlobalm4", "recHit global X,Y station -4; Global X (cm); Global Y (cm)", 100, -800., 800., 100, -800., 800.));
245  hRHSumQ.push_back(ibooker.book1D("hRHSumQm42", "Sum 3x3 recHit Charge (ME -4/2); ADC counts", 100, 0, 2000));
246  hRHSumQ.push_back(ibooker.book1D("hRHSumQm41", "Sum 3x3 recHit Charge (ME -4/1); ADC counts", 100, 0, 2000));
247  hRHSumQ.push_back(ibooker.book1D("hRHSumQm32", "Sum 3x3 recHit Charge (ME -3/2); ADC counts", 100, 0, 2000));
248  hRHSumQ.push_back(ibooker.book1D("hRHSumQm31", "Sum 3x3 recHit Charge (ME -3/1); ADC counts", 100, 0, 2000));
249  hRHSumQ.push_back(ibooker.book1D("hRHSumQm22", "Sum 3x3 recHit Charge (ME -2/2); ADC counts", 100, 0, 2000));
250  hRHSumQ.push_back(ibooker.book1D("hRHSumQm21", "Sum 3x3 recHit Charge (ME -2/1); ADC counts", 100, 0, 2000));
251  hRHSumQ.push_back(ibooker.book1D("hRHSumQm11a", "Sum 3x3 recHit Charge (ME -1/1a); ADC counts", 100, 0, 4000));
252  hRHSumQ.push_back(ibooker.book1D("hRHSumQm13", "Sum 3x3 recHit Charge (ME -1/3); ADC counts", 100, 0, 2000));
253  hRHSumQ.push_back(ibooker.book1D("hRHSumQm12", "Sum 3x3 recHit Charge (ME -1/2); ADC counts", 100, 0, 2000));
254  hRHSumQ.push_back(ibooker.book1D("hRHSumQm11b", "Sum 3x3 recHit Charge (ME -1/1b); ADC counts", 100, 0, 4000));
255  hRHSumQ.push_back(ibooker.book1D("hRHSumQp11b", "Sum 3x3 recHit Charge (ME +1/1b); ADC counts", 100, 0, 4000));
256  hRHSumQ.push_back(ibooker.book1D("hRHSumQp12", "Sum 3x3 recHit Charge (ME +1/2); ADC counts", 100, 0, 2000));
257  hRHSumQ.push_back(ibooker.book1D("hRHSumQp13", "Sum 3x3 recHit Charge (ME +1/3); ADC counts", 100, 0, 2000));
258  hRHSumQ.push_back(ibooker.book1D("hRHSumQp11a", "Sum 3x3 recHit Charge (ME +1/1a); ADC counts", 100, 0, 4000));
259  hRHSumQ.push_back(ibooker.book1D("hRHSumQp21", "Sum 3x3 recHit Charge (ME +2/1); ADC counts", 100, 0, 2000));
260  hRHSumQ.push_back(ibooker.book1D("hRHSumQp22", "Sum 3x3 recHit Charge (ME +2/2); ADC counts", 100, 0, 2000));
261  hRHSumQ.push_back(ibooker.book1D("hRHSumQp31", "Sum 3x3 recHit Charge (ME +3/1); ADC counts", 100, 0, 2000));
262  hRHSumQ.push_back(ibooker.book1D("hRHSumQp32", "Sum 3x3 recHit Charge (ME +3/2); ADC counts", 100, 0, 2000));
263  hRHSumQ.push_back(ibooker.book1D("hRHSumQp41", "Sum 3x3 recHit Charge (ME +4/1); ADC counts", 100, 0, 2000));
264  hRHSumQ.push_back(ibooker.book1D("hRHSumQp42", "Sum 3x3 recHit Charge (ME +4/2); ADC counts", 100, 0, 2000));
265  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm42", "Charge Ratio (Ql+Qr)/Qt (ME -4/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
266  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm41", "Charge Ratio (Ql+Qr)/Qt (ME -4/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
267  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm32", "Charge Ratio (Ql+Qr)/Qt (ME -3/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
268  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm31", "Charge Ratio (Ql+Qr)/Qt (ME -3/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
269  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm22", "Charge Ratio (Ql+Qr)/Qt (ME -2/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
270  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm21", "Charge Ratio (Ql+Qr)/Qt (ME -2/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
271  hRHRatioQ.push_back(
272  ibooker.book1D("hRHRatioQm11a", "Charge Ratio (Ql+Qr)/Qt (ME -1/1a); (Ql+Qr)/Qt", 100, -0.1, 1.1));
273  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm13", "Charge Ratio (Ql+Qr)/Qt (ME -1/3); (Ql+Qr)/Qt", 100, -0.1, 1.1));
274  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQm12", "Charge Ratio (Ql+Qr)/Qt (ME -1/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
275  hRHRatioQ.push_back(
276  ibooker.book1D("hRHRatioQm11b", "Charge Ratio (Ql+Qr)/Qt (ME -1/1b); (Ql+Qr)/Qt", 100, -0.1, 1.1));
277  hRHRatioQ.push_back(
278  ibooker.book1D("hRHRatioQp11b", "Charge Ratio (Ql+Qr)/Qt (ME +1/1b); (Ql+Qr)/Qt", 100, -0.1, 1.1));
279  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp12", "Charge Ratio (Ql+Qr)/Qt (ME +1/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
280  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp13", "Charge Ratio (Ql+Qr)/Qt (ME +1/3); (Ql+Qr)/Qt", 100, -0.1, 1.1));
281  hRHRatioQ.push_back(
282  ibooker.book1D("hRHRatioQp11a", "Charge Ratio (Ql+Qr)/Qt (ME +1/1a); (Ql+Qr)/Qt", 100, -0.1, 1.1));
283  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp21", "Charge Ratio (Ql+Qr)/Qt (ME +2/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
284  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp22", "Charge Ratio (Ql+Qr)/Qt (ME +2/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
285  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp31", "Charge Ratio (Ql+Qr)/Qt (ME +3/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
286  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp32", "Charge Ratio (Ql+Qr)/Qt (ME +3/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
287  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp41", "Charge Ratio (Ql+Qr)/Qt (ME +4/1); (Ql+Qr)/Qt", 100, -0.1, 1.1));
288  hRHRatioQ.push_back(ibooker.book1D("hRHRatioQp42", "Charge Ratio (Ql+Qr)/Qt (ME +4/2); (Ql+Qr)/Qt", 100, -0.1, 1.1));
289  hRHTiming.push_back(ibooker.book1D("hRHTimingm42", "recHit Time (ME -4/2); ns", 200, -500., 500.));
290  hRHTiming.push_back(ibooker.book1D("hRHTimingm41", "recHit Time (ME -4/1); ns", 200, -500., 500.));
291  hRHTiming.push_back(ibooker.book1D("hRHTimingm32", "recHit Time (ME -3/2); ns", 200, -500., 500.));
292  hRHTiming.push_back(ibooker.book1D("hRHTimingm31", "recHit Time (ME -3/1); ns", 200, -500., 500.));
293  hRHTiming.push_back(ibooker.book1D("hRHTimingm22", "recHit Time (ME -2/2); ns", 200, -500., 500.));
294  hRHTiming.push_back(ibooker.book1D("hRHTimingm21", "recHit Time (ME -2/1); ns", 200, -500., 500.));
295  hRHTiming.push_back(ibooker.book1D("hRHTimingm11a", "recHit Time (ME -1/1a); ns", 200, -500., 500.));
296  hRHTiming.push_back(ibooker.book1D("hRHTimingm13", "recHit Time (ME -1/3); ns", 200, -500., 500.));
297  hRHTiming.push_back(ibooker.book1D("hRHTimingm12", "recHit Time (ME -1/2); ns", 200, -500., 500.));
298  hRHTiming.push_back(ibooker.book1D("hRHTimingm11b", "recHit Time (ME -1/1b); ns", 200, -500., 500.));
299  hRHTiming.push_back(ibooker.book1D("hRHTimingp11b", "recHit Time (ME +1/1b); ns", 200, -500., 500.));
300  hRHTiming.push_back(ibooker.book1D("hRHTimingp12", "recHit Time (ME +1/2); ns", 200, -500., 500.));
301  hRHTiming.push_back(ibooker.book1D("hRHTimingp13", "recHit Time (ME +1/3); ns", 200, -500., 500.));
302  hRHTiming.push_back(ibooker.book1D("hRHTimingp11a", "recHit Time (ME +1/1a); ns", 200, -500., 500.));
303  hRHTiming.push_back(ibooker.book1D("hRHTimingp21", "recHit Time (ME +2/1); ns", 200, -500., 500.));
304  hRHTiming.push_back(ibooker.book1D("hRHTimingp22", "recHit Time (ME +2/2); ns", 200, -500., 500.));
305  hRHTiming.push_back(ibooker.book1D("hRHTimingp31", "recHit Time (ME +3/1); ns", 200, -500., 500.));
306  hRHTiming.push_back(ibooker.book1D("hRHTimingp32", "recHit Time (ME +3/2); ns", 200, -500., 500.));
307  hRHTiming.push_back(ibooker.book1D("hRHTimingp41", "recHit Time (ME +4/1); ns", 200, -500., 500.));
308  hRHTiming.push_back(ibooker.book1D("hRHTimingp42", "recHit Time (ME +4/2); ns", 200, -500., 500.));
309  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem42", "Anode recHit Time (ME -4/2); ns", 80, -500., 500.));
310  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem41", "Anode recHit Time (ME -4/1); ns", 80, -500., 500.));
311  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem32", "Anode recHit Time (ME -3/2); ns", 80, -500., 500.));
312  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem31", "Anode recHit Time (ME -3/1); ns", 80, -500., 500.));
313  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem22", "Anode recHit Time (ME -2/2); ns", 80, -500., 500.));
314  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem21", "Anode recHit Time (ME -2/1); ns", 80, -500., 500.));
315  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem11a", "Anode recHit Time (ME -1/1a); ns", 80, -500., 500.));
316  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem13", "Anode recHit Time (ME -1/3); ns", 80, -500., 500.));
317  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem12", "Anode recHit Time (ME -1/2); ns", 80, -500., 500.));
318  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodem11b", "Anode recHit Time (ME -1/1b); ns", 80, -500., 500.));
319  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep11b", "Anode recHit Time (ME +1/1b); ns", 80, -500., 500.));
320  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep12", "Anode recHit Time (ME +1/2); ns", 80, -500., 500.));
321  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep13", "Anode recHit Time (ME +1/3); ns", 80, -500., 500.));
322  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep11a", "Anode recHit Time (ME +1/1a); ns", 80, -500., 500.));
323  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep21", "Anode recHit Time (ME +2/1); ns", 80, -500., 500.));
324  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep22", "Anode recHit Time (ME +2/2); ns", 80, -500., 500.));
325  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep31", "Anode recHit Time (ME +3/1); ns", 80, -500., 500.));
326  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep32", "Anode recHit Time (ME +3/2); ns", 80, -500., 500.));
327  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep41", "Anode recHit Time (ME +4/1); ns", 80, -500., 500.));
328  hRHTimingAnode.push_back(ibooker.book1D("hRHTimingAnodep42", "Anode recHit Time (ME +4/2); ns", 80, -500., 500.));
329  hRHstpos.push_back(
330  ibooker.book1D("hRHstposm42", "Reconstructed Position on Strip (ME -4/2); Strip Widths", 120, -0.6, 0.6));
331  hRHstpos.push_back(
332  ibooker.book1D("hRHstposm41", "Reconstructed Position on Strip (ME -4/1); Strip Widths", 120, -0.6, 0.6));
333  hRHstpos.push_back(
334  ibooker.book1D("hRHstposm32", "Reconstructed Position on Strip (ME -3/2); Strip Widths", 120, -0.6, 0.6));
335  hRHstpos.push_back(
336  ibooker.book1D("hRHstposm31", "Reconstructed Position on Strip (ME -3/1); Strip Widths", 120, -0.6, 0.6));
337  hRHstpos.push_back(
338  ibooker.book1D("hRHstposm22", "Reconstructed Position on Strip (ME -2/2); Strip Widths", 120, -0.6, 0.6));
339  hRHstpos.push_back(
340  ibooker.book1D("hRHstposm21", "Reconstructed Position on Strip (ME -2/1); Strip Widths", 120, -0.6, 0.6));
341  hRHstpos.push_back(
342  ibooker.book1D("hRHstposm11a", "Reconstructed Position on Strip (ME -1/1a); Strip Widths", 120, -0.6, 0.6));
343  hRHstpos.push_back(
344  ibooker.book1D("hRHstposm13", "Reconstructed Position on Strip (ME -1/3); Strip Widths", 120, -0.6, 0.6));
345  hRHstpos.push_back(
346  ibooker.book1D("hRHstposm12", "Reconstructed Position on Strip (ME -1/2); Strip Widths", 120, -0.6, 0.6));
347  hRHstpos.push_back(
348  ibooker.book1D("hRHstposm11b", "Reconstructed Position on Strip (ME -1/1b); Strip Widths", 120, -0.6, 0.6));
349  hRHstpos.push_back(
350  ibooker.book1D("hRHstposp11b", "Reconstructed Position on Strip (ME +1/1b); Strip Widths", 120, -0.6, 0.6));
351  hRHstpos.push_back(
352  ibooker.book1D("hRHstposp12", "Reconstructed Position on Strip (ME +1/2); Strip Widths", 120, -0.6, 0.6));
353  hRHstpos.push_back(
354  ibooker.book1D("hRHstposp13", "Reconstructed Position on Strip (ME +1/3); Strip Widths", 120, -0.6, 0.6));
355  hRHstpos.push_back(
356  ibooker.book1D("hRHstposp11a", "Reconstructed Position on Strip (ME +1/1a); Strip Widths", 120, -0.6, 0.6));
357  hRHstpos.push_back(
358  ibooker.book1D("hRHstposp21", "Reconstructed Position on Strip (ME +2/1); Strip Widths", 120, -0.6, 0.6));
359  hRHstpos.push_back(
360  ibooker.book1D("hRHstposp22", "Reconstructed Position on Strip (ME +2/2); Strip Widths", 120, -0.6, 0.6));
361  hRHstpos.push_back(
362  ibooker.book1D("hRHstposp31", "Reconstructed Position on Strip (ME +3/1); Strip Widths", 120, -0.6, 0.6));
363  hRHstpos.push_back(
364  ibooker.book1D("hRHstposp32", "Reconstructed Position on Strip (ME +3/2); Strip Widths", 120, -0.6, 0.6));
365  hRHstpos.push_back(
366  ibooker.book1D("hRHstposp41", "Reconstructed Position on Strip (ME +4/1); Strip Widths", 120, -0.6, 0.6));
367  hRHstpos.push_back(
368  ibooker.book1D("hRHstposp42", "Reconstructed Position on Strip (ME +4/2); Strip Widths", 120, -0.6, 0.6));
369  hRHsterr.push_back(
370  ibooker.book1D("hRHsterrm42", "Estimated Error on Strip Measurement (ME -4/2); Strip Widths", 75, -0.01, 0.24));
371  hRHsterr.push_back(
372  ibooker.book1D("hRHsterrm41", "Estimated Error on Strip Measurement (ME -4/1); Strip Widths", 75, -0.01, 0.24));
373  hRHsterr.push_back(
374  ibooker.book1D("hRHsterrm32", "Estimated Error on Strip Measurement (ME -3/2); Strip Widths", 75, -0.01, 0.24));
375  hRHsterr.push_back(
376  ibooker.book1D("hRHsterrm31", "Estimated Error on Strip Measurement (ME -3/1); Strip Widths", 75, -0.01, 0.24));
377  hRHsterr.push_back(
378  ibooker.book1D("hRHsterrm22", "Estimated Error on Strip Measurement (ME -2/2); Strip Widths", 75, -0.01, 0.24));
379  hRHsterr.push_back(
380  ibooker.book1D("hRHsterrm21", "Estimated Error on Strip Measurement (ME -2/1); Strip Widths", 75, -0.01, 0.24));
381  hRHsterr.push_back(
382  ibooker.book1D("hRHsterrm11a", "Estimated Error on Strip Measurement (ME -1/1a); Strip Widths", 75, -0.01, 0.24));
383  hRHsterr.push_back(
384  ibooker.book1D("hRHsterrm13", "Estimated Error on Strip Measurement (ME -1/3); Strip Widths", 75, -0.01, 0.24));
385  hRHsterr.push_back(
386  ibooker.book1D("hRHsterrm12", "Estimated Error on Strip Measurement (ME -1/2); Strip Widths", 75, -0.01, 0.24));
387  hRHsterr.push_back(
388  ibooker.book1D("hRHsterrm11b", "Estimated Error on Strip Measurement (ME -1/1b); Strip Widths", 75, -0.01, 0.24));
389  hRHsterr.push_back(
390  ibooker.book1D("hRHsterrp11b", "Estimated Error on Strip Measurement (ME +1/1b); Strip Widths", 75, -0.01, 0.24));
391  hRHsterr.push_back(
392  ibooker.book1D("hRHsterrp12", "Estimated Error on Strip Measurement (ME +1/2); Strip Widths", 75, -0.01, 0.24));
393  hRHsterr.push_back(
394  ibooker.book1D("hRHsterrp13", "Estimated Error on Strip Measurement (ME +1/3); Strip Widths", 75, -0.01, 0.24));
395  hRHsterr.push_back(
396  ibooker.book1D("hRHsterrp11a", "Estimated Error on Strip Measurement (ME +1/1a); Strip Widths", 75, -0.01, 0.24));
397  hRHsterr.push_back(
398  ibooker.book1D("hRHsterrp21", "Estimated Error on Strip Measurement (ME +2/1); Strip Widths", 75, -0.01, 0.24));
399  hRHsterr.push_back(
400  ibooker.book1D("hRHsterrp22", "Estimated Error on Strip Measurement (ME +2/2); Strip Widths", 75, -0.01, 0.24));
401  hRHsterr.push_back(
402  ibooker.book1D("hRHsterrp31", "Estimated Error on Strip Measurement (ME +3/1); Strip Widths", 75, -0.01, 0.24));
403  hRHsterr.push_back(
404  ibooker.book1D("hRHsterrp32", "Estimated Error on Strip Measurement (ME +3/2); Strip Widths", 75, -0.01, 0.24));
405  hRHsterr.push_back(
406  ibooker.book1D("hRHsterrp41", "Estimated Error on Strip Measurement (ME +4/1); Strip Widths", 75, -0.01, 0.24));
407  hRHsterr.push_back(
408  ibooker.book1D("hRHsterrp42", "Estimated Error on Strip Measurement (ME +4/2); Strip Widths", 75, -0.01, 0.24));
409 
410  // segments
411  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Segments");
412 
413  hSnSegments = ibooker.book1D("hSnSegments", "Segments per Event; # of Segments", 100, 0., 100.); // 1 bin is 1
414 
415  hSnhitsAll = ibooker.book1D("hSnhits", "N hits on Segments; # of hits", 8, -0.5, 7.5);
416  hSnhits.push_back(ibooker.book1D("hSnhitsm42", "# of hits on Segments (ME -4/2); # of hits", 8, -0.5, 7.5));
417  hSnhits.push_back(ibooker.book1D("hSnhitsm41", "# of hits on Segments (ME -4/1); # of hits", 8, -0.5, 7.5));
418  hSnhits.push_back(ibooker.book1D("hSnhitsm32", "# of hits on Segments (ME -3/2); # of hits", 8, -0.5, 7.5));
419  hSnhits.push_back(ibooker.book1D("hSnhitsm31", "# of hits on Segments (ME -3/1); # of hits", 8, -0.5, 7.5));
420  hSnhits.push_back(ibooker.book1D("hSnhitsm22", "# of hits on Segments (ME -2/2); # of hits", 8, -0.5, 7.5));
421  hSnhits.push_back(ibooker.book1D("hSnhitsm21", "# of hits on Segments (ME -2/1); # of hits", 8, -0.5, 7.5));
422  hSnhits.push_back(ibooker.book1D("hSnhitsm11a", "# of hits on Segments (ME -1/1a); # of hits", 8, -0.5, 7.5));
423  hSnhits.push_back(ibooker.book1D("hSnhitsm13", "# of hits on Segments (ME -1/3); # of hits", 8, -0.5, 7.5));
424  hSnhits.push_back(ibooker.book1D("hSnhitsm12", "# of hits on Segments (ME -1/2); # of hits", 8, -0.5, 7.5));
425  hSnhits.push_back(ibooker.book1D("hSnhitsm11b", "# of hits on Segments (ME -1/1b); # of hits", 8, -0.5, 7.5));
426  hSnhits.push_back(ibooker.book1D("hSnhitsp11b", "# of hits on Segments (ME +1/1b); # of hits", 8, -0.5, 7.5));
427  hSnhits.push_back(ibooker.book1D("hSnhitsp12", "# of hits on Segments (ME +1/2); # of hits", 8, -0.5, 7.5));
428  hSnhits.push_back(ibooker.book1D("hSnhitsp13", "# of hits on Segments (ME +1/3); # of hits", 8, -0.5, 7.5));
429  hSnhits.push_back(ibooker.book1D("hSnhitsp11a", "# of hits on Segments (ME +1/1a); # of hits", 8, -0.5, 7.5));
430  hSnhits.push_back(ibooker.book1D("hSnhitsp21", "# of hits on Segments (ME +2/1); # of hits", 8, -0.5, 7.5));
431  hSnhits.push_back(ibooker.book1D("hSnhitsp22", "# of hits on Segments (ME +2/2); # of hits", 8, -0.5, 7.5));
432  hSnhits.push_back(ibooker.book1D("hSnhitsp31", "# of hits on Segments (ME +3/1); # of hits", 8, -0.5, 7.5));
433  hSnhits.push_back(ibooker.book1D("hSnhitsp32", "# of hits on Segments (ME +3/2); # of hits", 8, -0.5, 7.5));
434  hSnhits.push_back(ibooker.book1D("hSnhitsp41", "# of hits on Segments (ME +4/1); # of hits", 8, -0.5, 7.5));
435  hSnhits.push_back(ibooker.book1D("hSnhitsp42", "# of hits on Segments (ME +4/2); # of hits", 8, -0.5, 7.5));
436  hSChiSqAll = ibooker.book1D("hSChiSq", "Segment Normalized Chi2; Chi2/ndof", 110, -0.05, 10.5);
437  hSChiSq.push_back(ibooker.book1D("hSChiSqm42", "Segment Normalized Chi2 (ME -4/2); Chi2/ndof", 110, -0.05, 10.5));
438  hSChiSq.push_back(ibooker.book1D("hSChiSqm41", "Segment Normalized Chi2 (ME -4/1); Chi2/ndof", 110, -0.05, 10.5));
439  hSChiSq.push_back(ibooker.book1D("hSChiSqm32", "Segment Normalized Chi2 (ME -3/2); Chi2/ndof", 110, -0.05, 10.5));
440  hSChiSq.push_back(ibooker.book1D("hSChiSqm31", "Segment Normalized Chi2 (ME -3/1); Chi2/ndof", 110, -0.05, 10.5));
441  hSChiSq.push_back(ibooker.book1D("hSChiSqm22", "Segment Normalized Chi2 (ME -2/2); Chi2/ndof", 110, -0.05, 10.5));
442  hSChiSq.push_back(ibooker.book1D("hSChiSqm21", "Segment Normalized Chi2 (ME -2/1); Chi2/ndof", 110, -0.05, 10.5));
443  hSChiSq.push_back(ibooker.book1D("hSChiSqm11a", "Segment Normalized Chi2 (ME -1/1a); Chi2/ndof", 110, -0.05, 10.5));
444  hSChiSq.push_back(ibooker.book1D("hSChiSqm13", "Segment Normalized Chi2 (ME -1/3); Chi2/ndof", 110, -0.05, 10.5));
445  hSChiSq.push_back(ibooker.book1D("hSChiSqm12", "Segment Normalized Chi2 (ME -1/2); Chi2/ndof", 110, -0.05, 10.5));
446  hSChiSq.push_back(ibooker.book1D("hSChiSqm11b", "Segment Normalized Chi2 (ME -1/1b); Chi2/ndof", 110, -0.05, 10.5));
447  hSChiSq.push_back(ibooker.book1D("hSChiSqp11b", "Segment Normalized Chi2 (ME +1/1b); Chi2/ndof", 110, -0.05, 10.5));
448  hSChiSq.push_back(ibooker.book1D("hSChiSqp12", "Segment Normalized Chi2 (ME +1/2); Chi2/ndof", 110, -0.05, 10.5));
449  hSChiSq.push_back(ibooker.book1D("hSChiSqp13", "Segment Normalized Chi2 (ME +1/3); Chi2/ndof", 110, -0.05, 10.5));
450  hSChiSq.push_back(ibooker.book1D("hSChiSqp11a", "Segment Normalized Chi2 (ME +1/1a); Chi2/ndof", 110, -0.05, 10.5));
451  hSChiSq.push_back(ibooker.book1D("hSChiSqp21", "Segment Normalized Chi2 (ME +2/1); Chi2/ndof", 110, -0.05, 10.5));
452  hSChiSq.push_back(ibooker.book1D("hSChiSqp22", "Segment Normalized Chi2 (ME +2/2); Chi2/ndof", 110, -0.05, 10.5));
453  hSChiSq.push_back(ibooker.book1D("hSChiSqp31", "Segment Normalized Chi2 (ME +3/1); Chi2/ndof", 110, -0.05, 10.5));
454  hSChiSq.push_back(ibooker.book1D("hSChiSqp32", "Segment Normalized Chi2 (ME +3/2); Chi2/ndof", 110, -0.05, 10.5));
455  hSChiSq.push_back(ibooker.book1D("hSChiSqp41", "Segment Normalized Chi2 (ME +4/1); Chi2/ndof", 110, -0.05, 10.5));
456  hSChiSq.push_back(ibooker.book1D("hSChiSqp42", "Segment Normalized Chi2 (ME +4/2); Chi2/ndof", 110, -0.05, 10.5));
457  hSChiSqProbAll = ibooker.book1D("hSChiSqProb", "Segment chi2 Probability; Probability", 110, -0.05, 1.05);
458  hSChiSqProb.push_back(
459  ibooker.book1D("hSChiSqProbm42", "Segment chi2 Probability (ME -4/2); Probability", 110, -0.05, 1.05));
460  hSChiSqProb.push_back(
461  ibooker.book1D("hSChiSqProbm41", "Segment chi2 Probability (ME -4/1); Probability", 110, -0.05, 1.05));
462  hSChiSqProb.push_back(
463  ibooker.book1D("hSChiSqProbm32", "Segment chi2 Probability (ME -3/2); Probability", 110, -0.05, 1.05));
464  hSChiSqProb.push_back(
465  ibooker.book1D("hSChiSqProbm31", "Segment chi2 Probability (ME -3/1); Probability", 110, -0.05, 1.05));
466  hSChiSqProb.push_back(
467  ibooker.book1D("hSChiSqProbm22", "Segment chi2 Probability (ME -2/2); Probability", 110, -0.05, 1.05));
468  hSChiSqProb.push_back(
469  ibooker.book1D("hSChiSqProbm21", "Segment chi2 Probability (ME -2/1); Probability", 110, -0.05, 1.05));
470  hSChiSqProb.push_back(
471  ibooker.book1D("hSChiSqProbm11a", "Segment chi2 Probability (ME -1/1a); Probability", 110, -0.05, 1.05));
472  hSChiSqProb.push_back(
473  ibooker.book1D("hSChiSqProbm13", "Segment chi2 Probability (ME -1/3); Probability", 110, -0.05, 1.05));
474  hSChiSqProb.push_back(
475  ibooker.book1D("hSChiSqProbm12", "Segment chi2 Probability (ME -1/2); Probability", 110, -0.05, 1.05));
476  hSChiSqProb.push_back(
477  ibooker.book1D("hSChiSqProbm11b", "Segment chi2 Probability (ME -1/1b); Probability", 110, -0.05, 1.05));
478  hSChiSqProb.push_back(
479  ibooker.book1D("hSChiSqProbp11b", "Segment chi2 Probability (ME +1/1b); Probability", 110, -0.05, 1.05));
480  hSChiSqProb.push_back(
481  ibooker.book1D("hSChiSqProbp12", "Segment chi2 Probability (ME +1/2); Probability", 110, -0.05, 1.05));
482  hSChiSqProb.push_back(
483  ibooker.book1D("hSChiSqProbp13", "Segment chi2 Probability (ME +1/3); Probability", 110, -0.05, 1.05));
484  hSChiSqProb.push_back(
485  ibooker.book1D("hSChiSqProbp11a", "Segment chi2 Probability (ME +1/1a); Probability", 110, -0.05, 1.05));
486  hSChiSqProb.push_back(
487  ibooker.book1D("hSChiSqProbp21", "Segment chi2 Probability (ME +2/1); Probability", 110, -0.05, 1.05));
488  hSChiSqProb.push_back(
489  ibooker.book1D("hSChiSqProbp22", "Segment chi2 Probability (ME +2/2); Probability", 110, -0.05, 1.05));
490  hSChiSqProb.push_back(
491  ibooker.book1D("hSChiSqProbp31", "Segment chi2 Probability (ME +3/1); Probability", 110, -0.05, 1.05));
492  hSChiSqProb.push_back(
493  ibooker.book1D("hSChiSqProbp32", "Segment chi2 Probability (ME +3/2); Probability", 110, -0.05, 1.05));
494  hSChiSqProb.push_back(
495  ibooker.book1D("hSChiSqProbp41", "Segment chi2 Probability (ME +4/1); Probability", 110, -0.05, 1.05));
496  hSChiSqProb.push_back(
497  ibooker.book1D("hSChiSqProbp42", "Segment chi2 Probability (ME +4/2); Probability", 110, -0.05, 1.05));
498  hSGlobalTheta =
499  ibooker.book1D("hSGlobalTheta", "Segment Direction (Global Theta); Global Theta (radians)", 136, -0.1, 3.3);
500  hSGlobalPhi = ibooker.book1D("hSGlobalPhi", "Segment Direction (Global Phi); Global Phi (radians)", 128, -3.2, 3.2);
501 
502  hSTimeDiff = ibooker.book1D("hSTimeDiff", "Anode Minus Cathode Segment Time [ns]", 50, -50, 50);
503  hSTimeDiffByChamberType.push_back(
504  ibooker.book1D("hSTimeDiff_m42", "Anode Minus Cathode Segment Time (ME -4/2) [ns]", 50, -50, 50));
505  hSTimeDiffByChamberType.push_back(
506  ibooker.book1D("hSTimeDiff_m41", "Anode Minus Cathode Segment Time (ME -4/1) [ns]", 50, -50, 50));
507  hSTimeDiffByChamberType.push_back(
508  ibooker.book1D("hSTimeDiff_m32", "Anode Minus Cathode Segment Time (ME -3/2) [ns]", 50, -50, 50));
509  hSTimeDiffByChamberType.push_back(
510  ibooker.book1D("hSTimeDiff_m31", "Anode Minus Cathode Segment Time (ME -3/2) [ns]", 50, -50, 50));
511  hSTimeDiffByChamberType.push_back(
512  ibooker.book1D("hSTimeDiff_m22", "Anode Minus Cathode Segment Time (ME -2/2) [ns]", 50, -50, 50));
513  hSTimeDiffByChamberType.push_back(
514  ibooker.book1D("hSTimeDiff_m21", "Anode Minus Cathode Segment Time (ME -2/1) [ns]", 50, -50, 50));
515  hSTimeDiffByChamberType.push_back(
516  ibooker.book1D("hSTimeDiff_m11a", "Anode Minus Cathode Segment Time (ME -1/1a) [ns]", 50, -50, 50));
517  hSTimeDiffByChamberType.push_back(
518  ibooker.book1D("hSTimeDiff_m13", "Anode Minus Cathode Segment Time (ME -1/3) [ns]", 50, -50, 50));
519  hSTimeDiffByChamberType.push_back(
520  ibooker.book1D("hSTimeDiff_m12", "Anode Minus Cathode Segment Time (ME -1/2) [ns]", 50, -50, 50));
521  hSTimeDiffByChamberType.push_back(
522  ibooker.book1D("hSTimeDiff_m11b", "Anode Minus Cathode Segment Time (ME -1/1b) [ns]", 50, -50, 50));
523  hSTimeDiffByChamberType.push_back(
524  ibooker.book1D("hSTimeDiff_p11b", "Anode Minus Cathode Segment Time (ME +1/1b) [ns]", 50, -50, 50));
525  hSTimeDiffByChamberType.push_back(
526  ibooker.book1D("hSTimeDiff_p12", "Anode Minus Cathode Segment Time (ME +1/2) [ns]", 50, -50, 50));
527  hSTimeDiffByChamberType.push_back(
528  ibooker.book1D("hSTimeDiff_p13", "Anode Minus Cathode Segment Time (ME +1/3) [ns]", 50, -50, 50));
529  hSTimeDiffByChamberType.push_back(
530  ibooker.book1D("hSTimeDiff_p11a", "Anode Minus Cathode Segment Time (ME +1/1a) [ns]", 50, -50, 50));
531  hSTimeDiffByChamberType.push_back(
532  ibooker.book1D("hSTimeDiff_p21", "Anode Minus Cathode Segment Time (ME +2/1) [ns]", 50, -50, 50));
533  hSTimeDiffByChamberType.push_back(
534  ibooker.book1D("hSTimeDiff_p22", "Anode Minus Cathode Segment Time (ME +2/2) [ns]", 50, -50, 50));
535  hSTimeDiffByChamberType.push_back(
536  ibooker.book1D("hSTimeDiff_p31", "Anode Minus Cathode Segment Time (ME +3/1) [ns]", 50, -50, 50));
537  hSTimeDiffByChamberType.push_back(
538  ibooker.book1D("hSTimeDiff_p32", "Anode Minus Cathode Segment Time (ME +3/2) [ns]", 50, -50, 50));
539  hSTimeDiffByChamberType.push_back(
540  ibooker.book1D("hSTimeDiff_p41", "Anode Minus Cathode Segment Time (ME +4/1) [ns]", 50, -50, 50));
541  hSTimeDiffByChamberType.push_back(
542  ibooker.book1D("hSTimeDiff_p42", "Anode Minus Cathode Segment Time (ME +4/2) [ns]", 50, -50, 50));
543 
544  hSTimeAnode = ibooker.book1D("hSTimeAnode", "Anode Only Segment Time [ns]", 200, -200, 200);
545  hSTimeAnodeByChamberType.push_back(
546  ibooker.book1D("hSTimeAnode_m42", "Anode Only Segment Time (ME -4/2) [ns]", 200, -200, 200));
547  hSTimeAnodeByChamberType.push_back(
548  ibooker.book1D("hSTimeAnode_m41", "Anode Only Segment Time (ME -4/1) [ns]", 200, -200, 200));
549  hSTimeAnodeByChamberType.push_back(
550  ibooker.book1D("hSTimeAnode_m32", "Anode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
551  hSTimeAnodeByChamberType.push_back(
552  ibooker.book1D("hSTimeAnode_m31", "Anode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
553  hSTimeAnodeByChamberType.push_back(
554  ibooker.book1D("hSTimeAnode_m22", "Anode Only Segment Time (ME -2/2) [ns]", 200, -200, 200));
555  hSTimeAnodeByChamberType.push_back(
556  ibooker.book1D("hSTimeAnode_m21", "Anode Only Segment Time (ME -2/1) [ns]", 200, -200, 200));
557  hSTimeAnodeByChamberType.push_back(
558  ibooker.book1D("hSTimeAnode_m11a", "Anode Only Segment Time (ME -1/1a) [ns]", 200, -200, 200));
559  hSTimeAnodeByChamberType.push_back(
560  ibooker.book1D("hSTimeAnode_m13", "Anode Only Segment Time (ME -1/3) [ns]", 200, -200, 200));
561  hSTimeAnodeByChamberType.push_back(
562  ibooker.book1D("hSTimeAnode_m12", "Anode Only Segment Time (ME -1/2) [ns]", 200, -200, 200));
563  hSTimeAnodeByChamberType.push_back(
564  ibooker.book1D("hSTimeAnode_m11b", "Anode Only Segment Time (ME -1/1b) [ns]", 200, -200, 200));
565  hSTimeAnodeByChamberType.push_back(
566  ibooker.book1D("hSTimeAnode_p11b", "Anode Only Segment Time (ME +1/1b) [ns]", 200, -200, 200));
567  hSTimeAnodeByChamberType.push_back(
568  ibooker.book1D("hSTimeAnode_p12", "Anode Only Segment Time (ME +1/2) [ns]", 200, -200, 200));
569  hSTimeAnodeByChamberType.push_back(
570  ibooker.book1D("hSTimeAnode_p13", "Anode Only Segment Time (ME +1/3) [ns]", 200, -200, 200));
571  hSTimeAnodeByChamberType.push_back(
572  ibooker.book1D("hSTimeAnode_p11a", "Anode Only Segment Time (ME +1/1a) [ns]", 200, -200, 200));
573  hSTimeAnodeByChamberType.push_back(
574  ibooker.book1D("hSTimeAnode_p21", "Anode Only Segment Time (ME +2/1) [ns]", 200, -200, 200));
575  hSTimeAnodeByChamberType.push_back(
576  ibooker.book1D("hSTimeAnode_p22", "Anode Only Segment Time (ME +2/2) [ns]", 200, -200, 200));
577  hSTimeAnodeByChamberType.push_back(
578  ibooker.book1D("hSTimeAnode_p31", "Anode Only Segment Time (ME +3/1) [ns]", 200, -200, 200));
579  hSTimeAnodeByChamberType.push_back(
580  ibooker.book1D("hSTimeAnode_p32", "Anode Only Segment Time (ME +3/2) [ns]", 200, -200, 200));
581  hSTimeAnodeByChamberType.push_back(
582  ibooker.book1D("hSTimeAnode_p41", "Anode Only Segment Time (ME +4/1) [ns]", 200, -200, 200));
583  hSTimeAnodeByChamberType.push_back(
584  ibooker.book1D("hSTimeAnode_p42", "Anode Only Segment Time (ME +4/2) [ns]", 200, -200, 200));
585 
586  hSTimeCathode = ibooker.book1D("hSTimeCathode", "Cathode Only Segment Time [ns]", 200, -200, 200);
587  hSTimeCathodeByChamberType.push_back(
588  ibooker.book1D("hSTimeCathode_m42", "Cathode Only Segment Time (ME -4/2) [ns]", 200, -200, 200));
589  hSTimeCathodeByChamberType.push_back(
590  ibooker.book1D("hSTimeCathode_m41", "Cathode Only Segment Time (ME -4/1) [ns]", 200, -200, 200));
591  hSTimeCathodeByChamberType.push_back(
592  ibooker.book1D("hSTimeCathode_m32", "Cathode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
593  hSTimeCathodeByChamberType.push_back(
594  ibooker.book1D("hSTimeCathode_m31", "Cathode Only Segment Time (ME -3/2) [ns]", 200, -200, 200));
595  hSTimeCathodeByChamberType.push_back(
596  ibooker.book1D("hSTimeCathode_m22", "Cathode Only Segment Time (ME -2/2) [ns]", 200, -200, 200));
597  hSTimeCathodeByChamberType.push_back(
598  ibooker.book1D("hSTimeCathode_m21", "Cathode Only Segment Time (ME -2/1) [ns]", 200, -200, 200));
599  hSTimeCathodeByChamberType.push_back(
600  ibooker.book1D("hSTimeCathode_m11a", "Cathode Only Segment Time (ME -1/1a) [ns]", 200, -200, 200));
601  hSTimeCathodeByChamberType.push_back(
602  ibooker.book1D("hSTimeCathode_m13", "Cathode Only Segment Time (ME -1/3) [ns]", 200, -200, 200));
603  hSTimeCathodeByChamberType.push_back(
604  ibooker.book1D("hSTimeCathode_m12", "Cathode Only Segment Time (ME -1/2) [ns]", 200, -200, 200));
605  hSTimeCathodeByChamberType.push_back(
606  ibooker.book1D("hSTimeCathode_m11b", "Cathode Only Segment Time (ME -1/1b) [ns]", 200, -200, 200));
607  hSTimeCathodeByChamberType.push_back(
608  ibooker.book1D("hSTimeCathode_p11b", "Cathode Only Segment Time (ME +1/1b) [ns]", 200, -200, 200));
609  hSTimeCathodeByChamberType.push_back(
610  ibooker.book1D("hSTimeCathode_p12", "Cathode Only Segment Time (ME +1/2) [ns]", 200, -200, 200));
611  hSTimeCathodeByChamberType.push_back(
612  ibooker.book1D("hSTimeCathode_p13", "Cathode Only Segment Time (ME +1/3) [ns]", 200, -200, 200));
613  hSTimeCathodeByChamberType.push_back(
614  ibooker.book1D("hSTimeCathode_p11a", "Cathode Only Segment Time (ME +1/1a) [ns]", 200, -200, 200));
615  hSTimeCathodeByChamberType.push_back(
616  ibooker.book1D("hSTimeCathode_p21", "Cathode Only Segment Time (ME +2/1) [ns]", 200, -200, 200));
617  hSTimeCathodeByChamberType.push_back(
618  ibooker.book1D("hSTimeCathode_p22", "Cathode Only Segment Time (ME +2/2) [ns]", 200, -200, 200));
619  hSTimeCathodeByChamberType.push_back(
620  ibooker.book1D("hSTimeCathode_p31", "Cathode Only Segment Time (ME +3/1) [ns]", 200, -200, 200));
621  hSTimeCathodeByChamberType.push_back(
622  ibooker.book1D("hSTimeCathode_p32", "Cathode Only Segment Time (ME +3/2) [ns]", 200, -200, 200));
623  hSTimeCathodeByChamberType.push_back(
624  ibooker.book1D("hSTimeCathode_p41", "Cathode Only Segment Time (ME +4/1) [ns]", 200, -200, 200));
625  hSTimeCathodeByChamberType.push_back(
626  ibooker.book1D("hSTimeCathode_p42", "Cathode Only Segment Time (ME +4/2) [ns]", 200, -200, 200));
627 
628  hSTimeCombined = ibooker.book1D("hSTimeCombined", "Segment Time (anode+cathode times) [ns]", 200, -200, 200);
629  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
630  "hSTimeCombined_m42", "Segment Time (anode+cathode times) Segment Time (ME -4/2) [ns]", 200, -200, 200));
631  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
632  "hSTimeCombined_m41", "Segment Time (anode+cathode times) Segment Time (ME -4/1) [ns]", 200, -200, 200));
633  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
634  "hSTimeCombined_m32", "Segment Time (anode+cathode times) Segment Time (ME -3/2) [ns]", 200, -200, 200));
635  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
636  "hSTimeCombined_m31", "Segment Time (anode+cathode times) Segment Time (ME -3/2) [ns]", 200, -200, 200));
637  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
638  "hSTimeCombined_m22", "Segment Time (anode+cathode times) Segment Time (ME -2/2) [ns]", 200, -200, 200));
639  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
640  "hSTimeCombined_m21", "Segment Time (anode+cathode times) Segment Time (ME -2/1) [ns]", 200, -200, 200));
641  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
642  "hSTimeCombined_m11a", "Segment Time (anode+cathode times) Segment Time (ME -1/1a) [ns]", 200, -200, 200));
643  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
644  "hSTimeCombined_m13", "Segment Time (anode+cathode times) Segment Time (ME -1/3) [ns]", 200, -200, 200));
645  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
646  "hSTimeCombined_m12", "Segment Time (anode+cathode times) Segment Time (ME -1/2) [ns]", 200, -200, 200));
647  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
648  "hSTimeCombined_m11b", "Segment Time (anode+cathode times) Segment Time (ME -1/1b) [ns]", 200, -200, 200));
649  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
650  "hSTimeCombined_p11b", "Segment Time (anode+cathode times) Segment Time (ME +1/1b) [ns]", 200, -200, 200));
651  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
652  "hSTimeCombined_p12", "Segment Time (anode+cathode times) Segment Time (ME +1/2) [ns]", 200, -200, 200));
653  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
654  "hSTimeCombined_p13", "Segment Time (anode+cathode times) Segment Time (ME +1/3) [ns]", 200, -200, 200));
655  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
656  "hSTimeCombined_p11a", "Segment Time (anode+cathode times) Segment Time (ME +1/1a) [ns]", 200, -200, 200));
657  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
658  "hSTimeCombined_p21", "Segment Time (anode+cathode times) Segment Time (ME +2/1) [ns]", 200, -200, 200));
659  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
660  "hSTimeCombined_p22", "Segment Time (anode+cathode times) Segment Time (ME +2/2) [ns]", 200, -200, 200));
661  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
662  "hSTimeCombined_p31", "Segment Time (anode+cathode times) Segment Time (ME +3/1) [ns]", 200, -200, 200));
663  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
664  "hSTimeCombined_p32", "Segment Time (anode+cathode times) Segment Time (ME +3/2) [ns]", 200, -200, 200));
665  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
666  "hSTimeCombined_p41", "Segment Time (anode+cathode times) Segment Time (ME +4/1) [ns]", 200, -200, 200));
667  hSTimeCombinedByChamberType.push_back(ibooker.book1D(
668  "hSTimeCombined_p42", "Segment Time (anode+cathode times) Segment Time (ME +4/2) [ns]", 200, -200, 200));
669 
671  ibooker.book2D("hSTimeDiffSerial", "Anode Minus Cathode Segment Time [ns]", 601, -0.5, 600.5, 200, -50, 50);
673  ibooker.book2D("hSTimeAnodeSerial", "Anode Only Segment Time [ns]", 601, -0.5, 600.5, 200, -200, 200);
675  ibooker.book2D("hSTimeCathodeSerial", "Cathode Only Segment Time [ns]", 601, -0.5, 600.5, 200, -200, 200);
676  hSTimeCombinedSerial = ibooker.book2D(
677  "hSTimeCombinedSerial", "Segment Time (anode+cathode times) [ns]", 601, -0.5, 600.5, 200, -200, 200);
678 
679  hSTimeVsZ = ibooker.book2D("hSTimeVsZ", "Segment Time vs. Z; [ns] vs. [cm]", 200, -1200, 1200, 200, -200, 200);
680  hSTimeVsTOF =
681  ibooker.book2D("hSTimeVsTOF", "Segment Time vs. Distance from IP; [ns] vs. [cm]", 180, 500, 1400, 200, -200, 200);
682 
683  // resolution
684  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Resolution");
685 
686  hSResid.push_back(ibooker.book1D(
687  "hSResidm42", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/2); Strip Widths", 100, -0.5, 0.5));
688  hSResid.push_back(ibooker.book1D(
689  "hSResidm41", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/1); Strip Widths", 100, -0.5, 0.5));
690  hSResid.push_back(ibooker.book1D(
691  "hSResidm32", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/2); Strip Widths", 100, -0.5, 0.5));
692  hSResid.push_back(ibooker.book1D(
693  "hSResidm31", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/1); Strip Widths", 100, -0.5, 0.5));
694  hSResid.push_back(ibooker.book1D(
695  "hSResidm22", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/2); Strip Widths", 100, -0.5, 0.5));
696  hSResid.push_back(ibooker.book1D(
697  "hSResidm21", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/1); Strip Widths", 100, -0.5, 0.5));
698  hSResid.push_back(ibooker.book1D(
699  "hSResidm11a", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1a); Strip Widths", 100, -0.5, 0.5));
700  hSResid.push_back(ibooker.book1D(
701  "hSResidm13", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/3); Strip Widths", 100, -0.5, 0.5));
702  hSResid.push_back(ibooker.book1D(
703  "hSResidm12", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/2); Strip Widths", 100, -0.5, 0.5));
704  hSResid.push_back(ibooker.book1D(
705  "hSResidm11b", "Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1b); Strip Widths", 100, -0.5, 0.5));
706  hSResid.push_back(ibooker.book1D(
707  "hSResidp11b", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1b); Strip Widths", 100, -0.5, 0.5));
708  hSResid.push_back(ibooker.book1D(
709  "hSResidp12", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/2); Strip Widths", 100, -0.5, 0.5));
710  hSResid.push_back(ibooker.book1D(
711  "hSResidp13", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/3); Strip Widths", 100, -0.5, 0.5));
712  hSResid.push_back(ibooker.book1D(
713  "hSResidp11a", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1a); Strip Widths", 100, -0.5, 0.5));
714  hSResid.push_back(ibooker.book1D(
715  "hSResidp21", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/1); Strip Widths", 100, -0.5, 0.5));
716  hSResid.push_back(ibooker.book1D(
717  "hSResidp22", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/2); Strip Widths", 100, -0.5, 0.5));
718  hSResid.push_back(ibooker.book1D(
719  "hSResidp31", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/1); Strip Widths", 100, -0.5, 0.5));
720  hSResid.push_back(ibooker.book1D(
721  "hSResidp32", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/2); Strip Widths", 100, -0.5, 0.5));
722  hSResid.push_back(ibooker.book1D(
723  "hSResidp41", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/1); Strip Widths", 100, -0.5, 0.5));
724  hSResid.push_back(ibooker.book1D(
725  "hSResidp42", "Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/2); Strip Widths", 100, -0.5, 0.5));
726 
727  // efficiency
728  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/Efficiency");
729 
730  // hSSTE = ibooker.book1D("hSSTE","hSSTE",40,0.5,40.5);
731  // hRHSTE = ibooker.book1D("hRHSTE","hRHSTE",40,0.5,40.5);
732  hSnum = ibooker.book1D("hSnum", "CSC w rechits in 2+ layers && segment(s)", 20, 0.5, 20.5);
733  hSden = ibooker.book1D("hSden", "CSC w rechits in 2+ layers", 20, 0.5, 20.5);
734  hRHnum = ibooker.book1D("hRHnum", "CSC w segment(s) && rechits in 6 layers", 20, 0.5, 20.5);
735  hRHden = ibooker.book1D("hRHden", "CSC w segment(s)", 20, 0.5, 20.5);
740 
741  // hSEff = ibooker.book1D("hSEff","Segment Efficiency",20,0.5,20.5);
742  // hRHEff = ibooker.book1D("hRHEff","recHit Efficiency",20,0.5,20.5);
743  hSSTE2 = ibooker.book2D("hSSTE2", "hSSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
744  hRHSTE2 = ibooker.book2D("hRHSTE2", "hRHSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
745  hStripSTE2 = ibooker.book2D("hStripSTE2", "hStripSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
746  hWireSTE2 = ibooker.book2D("hWireSTE2", "hWireSTE2", 36, 0.5, 36.5, 20, 0.5, 20.5);
747  hEffDenominator = ibooker.book2D("hEffDenominator", "hEffDenominator", 36, 0.5, 36.5, 20, 0.5, 20.5);
748  // hSEff2 = ibooker.book2D("hSEff2","Segment Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
749  // hRHEff2 = ibooker.book2D("hRHEff2","recHit Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
750  // hStripReadoutEff2 = ibooker.book2D("hStripReadoutEff2","strip readout ratio [(strip+clct+wires)/(clct+wires)] 2D",36,0.5,36.5, 20, 0.5, 20.5);
751  // hStripReadoutEff2->setAxisTitle("Chamber #");
752  // hStripEff2 = ibooker.book2D("hStripEff2","strip Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
753  // hWireEff2 = ibooker.book2D("hWireEff2","wire Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
755  ibooker.book2D("hSensitiveAreaEvt", "Events Passing Selection for Efficiency", 36, 0.5, 36.5, 20, 0.5, 20.5);
756 
757  // bx monitor for trigger synchronization
758  ibooker.setCurrentFolder("CSC/CSCOfflineMonitor/BXMonitor");
759 
760  hALCTgetBX = ibooker.book1D("hALCTgetBX", "ALCT position in ALCT-L1A match window [BX]", 7, -0.5, 6.5);
761  // hALCTgetBXChamberMeans = ibooker.book1D("hALCTgetBXChamberMeans","Chamber Mean ALCT position in ALCT-L1A match window [BX]",60,0,6);
763  ibooker.book2D("hALCTgetBXSerial", "ALCT position in ALCT-L1A match window [BX]", 601, -0.5, 600.5, 7, -0.5, 6.5);
764  hALCTgetBXSerial->setAxisTitle("Chamber Serial Number");
765  hALCTgetBX2DNumerator = ibooker.book2D(
766  "hALCTgetBX2DNumerator", "ALCT position in ALCT-L1A match window [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
767  // hALCTgetBX2DMeans = ibooker.book2D("hALCTgetBX2DMeans","ALCT position in ALCT-L1A match window [BX]",36,0.5,36.5,20,0.5,20.5);
769  ibooker.book2D("hALCTgetBX2Denominator", "Number of ALCT Digis checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
770  // hALCTgetBX2DMeans->setAxisTitle("Chamber #");
771  hALCTgetBX2Denominator->setAxisTitle("Chamber #");
772  hALCTMatch = ibooker.book1D("hALCTMatch", "ALCT position in ALCT-CLCT match window [BX]", 7, -0.5, 6.5);
773  // hALCTMatchChamberMeans = ibooker.book1D("hALCTMatchChamberMeans","Chamber Mean ALCT position in ALCT-CLCT match window [BX]",60,0,6);
774  hALCTMatchSerial = ibooker.book2D(
775  "hALCTMatchSerial", "ALCT position in ALCT-CLCT match window [BX]", 601, -0.5, 600.5, 7, -0.5, 6.5);
776  hALCTMatchSerial->setAxisTitle("Chamber Serial Number");
777  hALCTMatch2DNumerator = ibooker.book2D(
778  "hALCTMatch2DNumerator", "ALCT position in ALCT-CLCT match window [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
779  // hALCTMatch2DMeans = ibooker.book2D("hALCTMatch2DMeans","ALCT position in ALCT-CLCT match window [BX]",36,0.5,36.5,20,0.5,20.5);
781  ibooker.book2D("hALCTMatch2Denominator", "Number of ALCT-CLCT matches checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
782  // hALCTMatch2DMeans->setAxisTitle("Chamber #");
783  hALCTMatch2Denominator->setAxisTitle("Chamber #");
784  hCLCTL1A = ibooker.book1D("hCLCTL1A", "L1A - CLCTpreTrigger at TMB [BX]", 40, 149.5, 189.5);
785  // hCLCTL1AChamberMeans = ibooker.book1D("hCLCTL1AChamberMeans","Chamber Mean L1A - CLCTpreTrigger at TMB [BX]",90,150,159);
787  ibooker.book2D("hCLCTL1ASerial", "L1A - CLCTpreTrigger at TMB [BX]", 601, -0.5, 600.5, 40, 149.5, 189.5);
788  hCLCTL1ASerial->setAxisTitle("Chamber Serial Number");
790  ibooker.book2D("hCLCTL1A2DNumerator", "L1A - CLCTpreTrigger at TMB [BX] (sum)", 36, 0.5, 36.5, 20, 0.5, 20.5);
791  // hCLCTL1A2DMeans = ibooker.book2D("hCLCTL1A2DMeans","L1A - CLCTpreTrigger at TMB [BX]",36,0.5,36.5,20,0.5,20.5);
793  ibooker.book2D("hCLCTL1A2Denominator", "Number of TMB CLCTs checked", 36, 0.5, 36.5, 20, 0.5, 20.5);
794 
795  // labels
802  // applyCSClabels(hSEff, EXTENDED, X);
803  // applyCSClabels(hRHEff, EXTENDED, X);
804  // applyCSClabels(hSEff2, SMALL, Y);
807  // applyCSClabels(hRHEff2, SMALL, Y);
809  // applyCSClabels(hStripReadoutEff2, EXTENDED, Y);
810  // applyCSClabels(hStripEff2, SMALL, Y);
812  // applyCSClabels(hWireEff2, SMALL, Y);
815  // applyCSClabels(hALCTgetBX2DMeans, EXTENDED, Y);
817  // applyCSClabels(hALCTMatch2DMeans, EXTENDED, Y);
819  // applyCSClabels(hCLCTL1A2DMeans, EXTENDED, Y);
821 }
MonitorElement * hEffDenominator
MonitorElement * hOSegmentsSerial
MonitorElement * hRHden
std::vector< MonitorElement * > hSTimeCathodeByChamberType
MonitorElement * hOWireSerial
MonitorElement * hSensitiveAreaEvt
MonitorElement * hOStrips
std::vector< MonitorElement * > hSTimeAnodeByChamberType
std::vector< MonitorElement * > hSTimeDiffByChamberType
std::vector< MonitorElement * > hSResid
MonitorElement * hORecHits
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:36
std::vector< MonitorElement * > hRHSumQ
MonitorElement * hStripSTE2
std::vector< MonitorElement * > hWireNumber
std::vector< MonitorElement * > hRHGlobal
MonitorElement * hALCTMatch2DNumerator
MonitorElement * hORecHitsSerial
MonitorElement * hSTimeAnodeSerial
MonitorElement * hWirenGroupsTotal
MonitorElement * hCLCTL1ASerial
MonitorElement * hOStripSerial
std::vector< MonitorElement * > hStripNumber
MonitorElement * hSSTE2
MonitorElement * hWireSTE2
MonitorElement * hSTimeAnode
MonitorElement * hSGlobalPhi
std::vector< MonitorElement * > hSnhits
MonitorElement * hOWires
MonitorElement * hSnSegments
MonitorElement * hOStripsAndWiresAndCLCT
MonitorElement * hOSegments
std::vector< MonitorElement * > hRHstpos
MonitorElement * hALCTMatchSerial
MonitorElement * hSnhitsAll
MonitorElement * hRHnrechitsHi
MonitorElement * hALCTgetBX
MonitorElement * hALCTMatch
std::vector< MonitorElement * > hSChiSq
MonitorElement * hSGlobalTheta
MonitorElement * hSTimeDiffSerial
MonitorElement * hSTimeCombined
MonitorElement * hOWiresAndCLCT
MonitorElement * hSden
MonitorElement * hCLCTL1A2Denominator
std::vector< MonitorElement * > hSTimeCombinedByChamberType
MonitorElement * hALCTgetBX2Denominator
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
MonitorElement * hSTimeVsZ
MonitorElement * hRHSTE2
MonitorElement * hSChiSqAll
MonitorElement * hCSCOccupancy
std::vector< MonitorElement * > hWireTBin
MonitorElement * hCLCTL1A2DNumerator
std::vector< MonitorElement * > hRHTiming
MonitorElement * hALCTgetBX2DNumerator
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:212
MonitorElement * hALCTMatch2Denominator
MonitorElement * hCLCTL1A
std::vector< MonitorElement * > hRHTimingAnode
std::vector< MonitorElement * > hRHRatioQ
std::vector< MonitorElement * > hRHsterr
MonitorElement * hSTimeDiff
MonitorElement * hSTimeCathode
std::vector< MonitorElement * > hSChiSqProb
MonitorElement * hSTimeCathodeSerial
MonitorElement * hWirenGroupsTotalHi
MonitorElement * hStripNFired
MonitorElement * hSTimeCombinedSerial
std::vector< MonitorElement * > hStripPed
MonitorElement * hALCTgetBXSerial
MonitorElement * hSTimeVsTOF
MonitorElement * hRHnrechits
MonitorElement * hSnum
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
MonitorElement * hStripNFiredHi
MonitorElement * hRHnum
MonitorElement * hSChiSqProbAll
void applyCSClabels(MonitorElement *meHisto, LabelType t, AxisType a)
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)

◆ chamberSerial()

int CSCOfflineMonitor::chamberSerial ( CSCDetId  id)
private

Definition at line 2116 of file CSCOfflineMonitor.cc.

Referenced by doBXMonitor(), doOccupancies(), and doSegments().

2116  {
2117  int st = id.station();
2118  int ri = id.ring();
2119  int ch = id.chamber();
2120  int ec = id.endcap();
2121  int kSerial = ch;
2122  if (st == 1 && ri == 1)
2123  kSerial = ch;
2124  if (st == 1 && ri == 2)
2125  kSerial = ch + 36;
2126  if (st == 1 && ri == 3)
2127  kSerial = ch + 72;
2128  if (st == 1 && ri == 4)
2129  kSerial = ch;
2130  if (st == 2 && ri == 1)
2131  kSerial = ch + 108;
2132  if (st == 2 && ri == 2)
2133  kSerial = ch + 126;
2134  if (st == 3 && ri == 1)
2135  kSerial = ch + 162;
2136  if (st == 3 && ri == 2)
2137  kSerial = ch + 180;
2138  if (st == 4 && ri == 1)
2139  kSerial = ch + 216;
2140  if (st == 4 && ri == 2)
2141  kSerial = ch + 234; // from 2014
2142  if (ec == 2)
2143  kSerial = kSerial + 300;
2144  return kSerial;
2145 }

◆ doBXMonitor()

void CSCOfflineMonitor::doBXMonitor ( edm::Handle< CSCALCTDigiCollection alcts,
edm::Handle< CSCCLCTDigiCollection clcts,
const edm::Event event,
const edm::EventSetup eventSetup 
)
private

uncomment this for regional unpacking if (id!=SOME_ID) continue;











Take a reference to this FED's data

if fed has data then unpack it

get a pointer to data and pass it to constructor for unpacking

get a reference to dduData

set default detid to that for E=+z, S=1, R=1, C=1, L=1

skip the DDU if its data has serious errors define a mask for serious errors





get a reference to chamber data

first process chamber-wide digis such as LCT

default value for all digis not related to cfebs

layer=0 flags entire chamber

check alct data integrity

check tmb data integrity

Definition at line 1782 of file CSCOfflineMonitor.cc.

References CSCTMBHeader::ALCTMatchTime(), CSCTMBHeader::BXNCount(), CSCDetId::chamber(), chamberSerial(), RPCNoise_example::check, CSCDCCExaminer::check(), CSCDCCExaminer::crcALCT(), CSCDCCExaminer::crcCFEB(), CSCDCCExaminer::crcTMB(), FEDRawData::data(), data, CSCDCCEventData::dduData(), CSCCrateMap::detId(), CSCDCCExaminer::errors(), options_cfi::eventSetup, FEDRawDataCollection::FEDData(), dqm::impl::MonitorElement::Fill(), hALCTgetBX, hALCTgetBX2Denominator, hALCTgetBX2DNumerator, hALCTgetBXSerial, hALCTMatch, hALCTMatch2Denominator, hALCTMatch2DNumerator, hALCTMatchSerial, hCLCTL1A, hCLCTL1A2Denominator, hCLCTL1A2DNumerator, hCLCTL1ASerial, hcrateToken_, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, nano_mu_digi_cff::layer, LogTrace, FEDNumbering::MAXCSCDDUFEDID, FEDNumbering::MAXCSCFEDID, FEDNumbering::MINCSCDDUFEDID, FEDNumbering::MINCSCFEDID, edm::ESHandle< T >::product(), FastTimerService_cff::range, rd_token, CSCDCCExaminer::setMask(), FEDRawData::size(), and typeIndex().

Referenced by analyze().

1785  {
1786  // Loop over ALCTDigis
1787 
1788  for (CSCALCTDigiCollection::DigiRangeIterator j = alcts->begin(); j != alcts->end(); j++) {
1789  const CSCDetId& idALCT = (*j).first;
1790  const CSCALCTDigiCollection::Range& range = (*j).second;
1791  for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
1792  // Valid digi in the chamber (or in neighbouring chamber)
1793  if ((*digiIt).isValid()) {
1794  hALCTgetBX->Fill((*digiIt).getBX());
1795  hALCTgetBXSerial->Fill(chamberSerial(idALCT), (*digiIt).getBX());
1796  hALCTgetBX2DNumerator->Fill(idALCT.chamber(), typeIndex(idALCT, 2), (*digiIt).getBX());
1797  hALCTgetBX2Denominator->Fill(idALCT.chamber(), typeIndex(idALCT, 2));
1798  }
1799  }
1800  } // end ALCT Digi loop
1801 
1802  // Loop over raw data to get TMBHeader information
1803  // Taking code from EventFilter/CSCRawToDigis/CSCDCCUnpacker.cc
1805 
1806  hcrate = eventSetup.getHandle(hcrateToken_);
1807 
1808  const CSCCrateMap* pcrate = hcrate.product();
1809 
1810  // Try to get raw data
1812  if (!(event.getByToken(rd_token, rawdata))) {
1813  edm::LogWarning("CSCOfflineMonitor") << " FEDRawDataCollection not available";
1814  return;
1815  }
1816 
1817  bool goodEvent = false;
1818  unsigned long dccBinCheckMask = 0x06080016;
1819  unsigned int examinerMask = 0x1FEBF3F6;
1820  unsigned int errorMask = 0x0;
1821 
1822  // For new CSC readout layout, which doesn't include DCCs need to loop over DDU FED IDs.
1823  // DCC IDs are included for backward compatibility with old data
1824  std::vector<unsigned int> cscFEDids;
1825 
1826  for (unsigned int id = FEDNumbering::MINCSCFEDID; id <= FEDNumbering::MAXCSCFEDID; ++id) // loop over DCCs
1827  {
1828  cscFEDids.push_back(id);
1829  }
1830 
1831  for (unsigned int id = FEDNumbering::MINCSCDDUFEDID; id <= FEDNumbering::MAXCSCDDUFEDID; ++id) // loop over DDUs
1832  {
1833  cscFEDids.push_back(id);
1834  }
1835 
1836  for (unsigned int i = 0; i < cscFEDids.size(); i++) // loop over all CSC FEDs (DCCs and DDUs)
1837  {
1838  unsigned int id = cscFEDids[i];
1839  bool isDDU_FED = ((id >= FEDNumbering::MINCSCDDUFEDID) && (id <= FEDNumbering::MAXCSCDDUFEDID)) ? true : false;
1840 
1843 
1845  const FEDRawData& fedData = rawdata->FEDData(id);
1846  unsigned long length = fedData.size();
1847 
1848  if (length >= 32) {
1849  CSCDCCExaminer* examiner = nullptr;
1850  std::stringstream examiner_out, examiner_err;
1851  goodEvent = true;
1852  examiner = new CSCDCCExaminer();
1853  if (examinerMask & 0x40000)
1854  examiner->crcCFEB(true);
1855  if (examinerMask & 0x8000)
1856  examiner->crcTMB(true);
1857  if (examinerMask & 0x0400)
1858  examiner->crcALCT(true);
1859  examiner->setMask(examinerMask);
1860  const short unsigned int* data = (short unsigned int*)fedData.data();
1861 
1862  int res = examiner->check(data, long(fedData.size() / 2));
1863  if (res < 0) {
1864  goodEvent = false;
1865  } else {
1866  goodEvent = !(examiner->errors() & dccBinCheckMask);
1867  }
1868 
1869  if (goodEvent) {
1871 
1872  CSCDCCExaminer* ptrExaminer = examiner;
1873 
1874  std::vector<CSCDDUEventData> fed_Data;
1875  std::vector<CSCDDUEventData>* ptr_fedData = &fed_Data;
1876 
1877  if (isDDU_FED) // Use new DDU FED readout mode
1878  {
1879  CSCDDUEventData single_dduData((short unsigned int*)fedData.data(), ptrExaminer);
1880  fed_Data.push_back(single_dduData);
1881 
1882  } else // Use old DCC FED readout mode
1883  {
1884  CSCDCCEventData dccData((short unsigned int*)fedData.data(), ptrExaminer);
1885  fed_Data = dccData.dduData();
1886  }
1887 
1889  const std::vector<CSCDDUEventData>& dduData = *ptr_fedData;
1890 
1892  CSCDetId layer(1, 1, 1, 1, 1);
1893  for (unsigned int iDDU = 0; iDDU < dduData.size(); ++iDDU) { // loop over DDUs
1896  if (dduData[iDDU].trailer().errorstat() & errorMask) {
1897  LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! "
1898  << std::hex << dduData[iDDU].trailer().errorstat();
1899  continue; // to next iteration of DDU loop
1900  }
1901 
1903  const std::vector<CSCEventData>& cscData = dduData[iDDU].cscData();
1904 
1905  for (unsigned int iCSC = 0; iCSC < cscData.size(); ++iCSC) { // loop over CSCs
1906 
1908  int vmecrate = cscData[iCSC].dmbHeader()->crateID();
1909  int dmb = cscData[iCSC].dmbHeader()->dmbID();
1910 
1911  int icfeb = 0;
1912  int ilayer = 0;
1913 
1914  if ((vmecrate >= 1) && (vmecrate <= 60) && (dmb >= 1) && (dmb <= 10) && (dmb != 6)) {
1915  layer = pcrate->detId(vmecrate, dmb, icfeb, ilayer);
1916  } else {
1917  LogTrace("CSCOfflineMonitor") << " detID input out of range!!! ";
1918  LogTrace("CSCOfflineMonitor") << " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
1919  continue; // to next iteration of iCSC loop
1920  }
1921 
1923  int nalct = cscData[iCSC].dmbHeader()->nalct();
1924  bool goodALCT = false;
1925  //if (nalct&&(cscData[iCSC].dataPresent>>6&0x1)==1) {
1926  if (nalct && cscData[iCSC].alctHeader()) {
1927  if (cscData[iCSC].alctHeader()->check()) {
1928  goodALCT = true;
1929  }
1930  }
1931 
1933  int nclct = cscData[iCSC].dmbHeader()->nclct();
1934  bool goodTMB = false;
1935  if (nclct && cscData[iCSC].tmbData()) {
1936  if (cscData[iCSC].tmbHeader()->check()) {
1937  if (cscData[iCSC].comparatorData()->check())
1938  goodTMB = true;
1939  }
1940  }
1941 
1942  if (goodTMB && goodALCT) {
1943  const CSCTMBHeader* tmbHead = cscData[iCSC].tmbHeader();
1944  std::vector<CSCCLCTDigi> clcts = cscData[iCSC].tmbHeader()->CLCTDigis(layer.rawId());
1945  if (clcts.empty() || !(clcts[0].isValid()))
1946  continue;
1947  // Check if the CLCT was in ME11a (ring 4)
1948  if (layer.station() == 1 && layer.ring() == 1 && clcts[0].getKeyStrip() > 128) {
1949  layer = CSCDetId(layer.endcap(), layer.station(), 4, layer.chamber());
1950  }
1951  hALCTMatch->Fill(tmbHead->ALCTMatchTime());
1953  // Only fill big 2D display if ALCTMatchTime !=6, since this bin is polluted by the CLCT only triggers
1954  // One will have to look at the serial plots to see if the are a lot of entries here
1955  if (tmbHead->ALCTMatchTime() != 6) {
1956  hALCTMatch2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), tmbHead->ALCTMatchTime());
1957  hALCTMatch2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1958  }
1959 
1960  int TMB_CLCTpre_rel_L1A = tmbHead->BXNCount() - clcts[0].getFullBX();
1961  if (TMB_CLCTpre_rel_L1A > 3563)
1962  TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A - 3564;
1963  if (TMB_CLCTpre_rel_L1A < 0)
1964  TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A + 3564;
1965 
1966  hCLCTL1A->Fill(TMB_CLCTpre_rel_L1A);
1967  hCLCTL1ASerial->Fill(chamberSerial(layer), TMB_CLCTpre_rel_L1A);
1968  hCLCTL1A2DNumerator->Fill(layer.chamber(), typeIndex(layer, 2), TMB_CLCTpre_rel_L1A);
1969  hCLCTL1A2Denominator->Fill(layer.chamber(), typeIndex(layer, 2));
1970 
1971  } // end if goodTMB and goodALCT
1972  } // end loop CSCData
1973  } // end loop DDU
1974  } // end if good event
1975  if (examiner != nullptr)
1976  delete examiner;
1977  } // end if non-zero fed data
1978  } // end DCC loop for NON-REFERENCE
1979 
1980  return;
1981 }
01/20/05 A.Tumanov
void crcCFEB(bool enable)
const edm::ESGetToken< CSCCrateMap, CSCCrateMapRcd > hcrateToken_
int chamberSerial(CSCDetId id)
MonitorElement * hALCTMatch2DNumerator
size_t size() const
Lenght of the data buffer in bytes.
Definition: FEDRawData.h:45
MonitorElement * hCLCTL1ASerial
void crcALCT(bool enable)
Definition: Electron.h:6
#define LogTrace(id)
void Fill(long long x)
uint16_t ALCTMatchTime() const
Definition: CSCTMBHeader.h:44
const std::vector< CSCDDUEventData > & dduData() const
accessor to dduData
T const * product() const
Definition: ESHandle.h:86
uint16_t BXNCount() const
Definition: CSCTMBHeader.h:43
edm::EDGetTokenT< FEDRawDataCollection > rd_token
MonitorElement * hALCTMatchSerial
int typeIndex(CSCDetId id, int flag=1)
MonitorElement * hALCTgetBX
MonitorElement * hALCTMatch
void crcTMB(bool enable)
int chamber() const
Definition: CSCDetId.h:62
MonitorElement * hCLCTL1A2Denominator
MonitorElement * hALCTgetBX2Denominator
const FEDRawData & FEDData(int fedid) const
retrieve data for fed
CSCDetId detId(int vme, int dmb, int cfeb, int layer=0) const
Definition: CSCCrateMap.cc:9
MonitorElement * hCLCTL1A2DNumerator
MonitorElement * hALCTgetBX2DNumerator
std::pair< const_iterator, const_iterator > Range
MonitorElement * hALCTMatch2Denominator
std::vector< DigiType >::const_iterator const_iterator
MonitorElement * hCLCTL1A
int32_t check(const uint16_t *&buffer, int32_t length)
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:80
ExaminerStatusType errors(void) const
const unsigned char * data() const
Return a const pointer to the beginning of the data buffer.
Definition: FEDRawData.cc:24
MonitorElement * hALCTgetBXSerial
Log< level::Warning, false > LogWarning
void setMask(ExaminerMaskType mask)
Definition: event.py:1

◆ doEfficiencies()

void CSCOfflineMonitor::doEfficiencies ( edm::Handle< CSCWireDigiCollection wires,
edm::Handle< CSCStripDigiCollection strips,
edm::Handle< CSCRecHit2DCollection recHits,
edm::Handle< CSCSegmentCollection cscSegments,
edm::ESHandle< CSCGeometry cscGeom 
)
private

Definition at line 1490 of file CSCOfflineMonitor.cc.

References newFWLiteAna::bin, CSCDetId::chamber(), CSCGeometry::chamber(), CSCGeometry::chambers(), CSCChamberSpecs::chamberType(), dtChamberEfficiency_cfi::cscSegments, change_name::diff, CSCDetId::endcap(), extrapolate1D(), dqm::impl::MonitorElement::Fill(), dqmdumpme::first, nano_mu_digi_cff::float, cms::cuda::for(), CSCLayer::geometry(), hEffDenominator, hRHden, hRHnum, hRHSTE2, hSden, hSensitiveAreaEvt, hSnum, hSSTE2, hStripSTE2, hWireSTE2, CSCDetId::iChamberType(), CSCChamber::id(), createfilelist::int, CSCChamber::layer(), CSCDetId::layer(), lineParametrization(), CSCSegment::localDirection(), CSCSegment::localPosition(), TrapezoidalPlaneBounds::parameters(), FastTrackerRecHitMaskProducer_cfi::recHits, CSCDetId::ring(), CSCChamber::specs(), CSCDetId::station(), DigiDM_cff::strips, remoteMonitoring_LASER_era2018_cfg::threshold, GeomDet::toGlobal(), GeomDet::toLocal(), parallelization::uint, mps_merge::weight, DigiDM_cff::wires, withinSensitiveRegion(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and CSCDetId::zendcap().

Referenced by analyze().

1494  {
1495  bool allWires[2][4][4][36][6];
1496  bool allStrips[2][4][4][36][6];
1497  bool AllRecHits[2][4][4][36][6];
1498  bool AllSegments[2][4][4][36];
1499 
1500  //bool MultiSegments[2][4][4][36];
1501  for (int iE = 0; iE < 2; iE++) {
1502  for (int iS = 0; iS < 4; iS++) {
1503  for (int iR = 0; iR < 4; iR++) {
1504  for (int iC = 0; iC < 36; iC++) {
1505  AllSegments[iE][iS][iR][iC] = false;
1506  //MultiSegments[iE][iS][iR][iC] = false;
1507  for (int iL = 0; iL < 6; iL++) {
1508  allWires[iE][iS][iR][iC][iL] = false;
1509  allStrips[iE][iS][iR][iC][iL] = false;
1510  AllRecHits[iE][iS][iR][iC][iL] = false;
1511  }
1512  }
1513  }
1514  }
1515  }
1516 
1517  // Wires
1518  for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1519  CSCDetId idrec = (CSCDetId)(*dWDiter).first;
1520  std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1521  std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1522  for (; wireIter != lWire; ++wireIter) {
1523  allWires[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1524  true;
1525  break;
1526  }
1527  }
1528 
1529  //---- STRIPS
1530  for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1531  CSCDetId idrec = (CSCDetId)(*dSDiter).first;
1532  std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1533  std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1534  for (; stripIter != lStrip; ++stripIter) {
1535  std::vector<int> myADCVals = stripIter->getADCCounts();
1536  bool thisStripFired = false;
1537  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1538  float threshold = 13.3;
1539  float diff = 0.;
1540  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1541  diff = (float)myADCVals[iCount] - thisPedestal;
1542  if (diff > threshold) {
1543  thisStripFired = true;
1544  break;
1545  }
1546  }
1547  if (thisStripFired) {
1548  allStrips[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1549  true;
1550  break;
1551  }
1552  }
1553  }
1554 
1555  // Rechits
1556  for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
1557  //CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
1558  CSCDetId idrec = (CSCDetId)(*recEffIt).cscDetId();
1559  AllRecHits[idrec.endcap() - 1][idrec.station() - 1][idrec.ring() - 1][idrec.chamber() - 1][idrec.layer() - 1] =
1560  true;
1561  }
1562 
1563  std::vector<uint> seg_ME2(2, 0);
1564  std::vector<uint> seg_ME3(2, 0);
1565  std::vector<pair<CSCDetId, CSCSegment> > theSegments(4);
1566  // Segments
1567  for (CSCSegmentCollection::const_iterator segEffIt = cscSegments->begin(); segEffIt != cscSegments->end();
1568  segEffIt++) {
1569  CSCDetId idseg = (CSCDetId)(*segEffIt).cscDetId();
1570  //if(AllSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()]){
1571  //MultiSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()] = true;
1572  //}
1573  AllSegments[idseg.endcap() - 1][idseg.station() - 1][idseg.ring() - 1][idseg.chamber() - 1] = true;
1574  // "Intrinsic" efficiency measurement relies on "good" segment extrapolation - we need the pre-selection below
1575  // station 2 "good" segment will be used for testing efficiencies in ME1 and ME3
1576  // station 3 "good" segment will be used for testing efficiencies in ME2 and ME4
1577  if (2 == idseg.station() || 3 == idseg.station()) {
1578  uint seg_tmp;
1579  if (2 == idseg.station()) {
1580  ++seg_ME2[idseg.endcap() - 1];
1581  seg_tmp = seg_ME2[idseg.endcap() - 1];
1582  } else {
1583  ++seg_ME3[idseg.endcap() - 1];
1584  seg_tmp = seg_ME3[idseg.endcap() - 1];
1585  }
1586  // is the segment good
1587  if (1 == seg_tmp && 6 == (*segEffIt).nRecHits() && (*segEffIt).chi2() / (*segEffIt).degreesOfFreedom() < 3.) {
1588  pair<CSCDetId, CSCSegment> specSeg = make_pair((CSCDetId)(*segEffIt).cscDetId(), *segEffIt);
1589  theSegments[2 * (idseg.endcap() - 1) + (idseg.station() - 2)] = specSeg;
1590  }
1591  }
1592  /*
1593  if(2==idseg.station()){
1594  ++seg_ME2[idseg.endcap() -1];
1595  if(1==seg_ME2[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1596  pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1597  theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1598  }
1599  }
1600  else if(3==idseg.station()){
1601  ++seg_ME3[idseg.endcap() -1];
1602  if(1==seg_ME3[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
1603  pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
1604  theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
1605  }
1606  }
1607  */
1608  }
1609  // Simple efficiency calculations
1610  for (int iE = 0; iE < 2; iE++) {
1611  for (int iS = 0; iS < 4; iS++) {
1612  for (int iR = 0; iR < 4; iR++) {
1613  for (int iC = 0; iC < 36; iC++) {
1614  int NumberOfLayers = 0;
1615  for (int iL = 0; iL < 6; iL++) {
1616  if (AllRecHits[iE][iS][iR][iC][iL]) {
1617  NumberOfLayers++;
1618  }
1619  }
1620 
1621  // set bin = 1-10 for ME-42, ME-41,...ME-11B, ME-11A,
1622  // 11-20 for ME+11A, ME+11B, ... ME+41, ME+42
1623  int bin = CSCDetId::iChamberType(iS + 1, iR + 1); // 1-10 for ME11A...ME42
1624  if (iE > 0) { // in this loop iE=1 is -z endcap
1625  bin = 11 - bin;
1626  } else { // in this loop iE=0 is +z endcap
1627  bin += 10;
1628  }
1629 
1630  if (NumberOfLayers > 1) {
1631  //if(!(MultiSegments[iE][iS][iR][iC])){
1632  if (AllSegments[iE][iS][iR][iC]) {
1633  //---- Efficient segment evenents
1634  hSnum->Fill(bin);
1635  }
1636  //---- All segment events (normalization)
1637  hSden->Fill(bin);
1638  //}
1639  }
1640  if (AllSegments[iE][iS][iR][iC]) {
1641  if (NumberOfLayers == 6) {
1642  //---- Efficient rechit events
1643  hRHnum->Fill(bin);
1644  ;
1645  }
1646  //---- All rechit events (normalization)
1647  hRHden->Fill(bin);
1648  ;
1649  }
1650  }
1651  }
1652  }
1653  }
1654 
1655  // pick a segment only if there are no others in the station
1656  std::vector<pair<CSCDetId, CSCSegment>*> theSeg;
1657  if (1 == seg_ME2[0])
1658  theSeg.push_back(&theSegments[0]);
1659  if (1 == seg_ME3[0])
1660  theSeg.push_back(&theSegments[1]);
1661  if (1 == seg_ME2[1])
1662  theSeg.push_back(&theSegments[2]);
1663  if (1 == seg_ME3[1])
1664  theSeg.push_back(&theSegments[3]);
1665 
1666  if (!theSeg.empty()) {
1667  std::map<int, GlobalPoint> extrapolatedPoint;
1668  std::map<int, GlobalPoint>::iterator it;
1669  const CSCGeometry::ChamberContainer& ChamberContainer = cscGeom->chambers();
1670  // Pick which chamber with which segment to test
1671  for (unsigned int nCh = 0; nCh < ChamberContainer.size(); nCh++) {
1672  const CSCChamber* cscchamber = ChamberContainer[nCh];
1673  pair<CSCDetId, CSCSegment>* thisSegment = nullptr;
1674  for (uint iSeg = 0; iSeg < theSeg.size(); ++iSeg) {
1675  if (cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()) {
1676  if (1 == cscchamber->id().station() || 3 == cscchamber->id().station()) {
1677  if (2 == theSeg[iSeg]->first.station()) {
1678  thisSegment = theSeg[iSeg];
1679  }
1680  } else if (2 == cscchamber->id().station() || 4 == cscchamber->id().station()) {
1681  if (3 == theSeg[iSeg]->first.station()) {
1682  thisSegment = theSeg[iSeg];
1683  }
1684  }
1685  }
1686  }
1687  // this chamber is to be tested with thisSegment
1688  if (thisSegment) {
1689  CSCSegment* seg = &(thisSegment->second);
1690  const CSCChamber* segChamber = cscGeom->chamber(thisSegment->first);
1691  LocalPoint localCenter(0., 0., 0);
1692  GlobalPoint cscchamberCenter = cscchamber->toGlobal(localCenter);
1693  // try to save some time (extrapolate a segment to a certain position only once)
1694  it = extrapolatedPoint.find(int(cscchamberCenter.z()));
1695  if (it == extrapolatedPoint.end()) {
1696  GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
1697  GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
1698  double paramaterLine = lineParametrization(segPos.z(), cscchamberCenter.z(), segDir.z());
1699  double xExtrapolated = extrapolate1D(segPos.x(), segDir.x(), paramaterLine);
1700  double yExtrapolated = extrapolate1D(segPos.y(), segDir.y(), paramaterLine);
1701  GlobalPoint globP(xExtrapolated, yExtrapolated, cscchamberCenter.z());
1702  extrapolatedPoint[int(cscchamberCenter.z())] = globP;
1703  }
1704  // Where does the extrapolated point lie in the (tested) chamber local frame? Here:
1705  LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
1706  const CSCLayer* layer_p = cscchamber->layer(1); //layer 1
1707  const CSCLayerGeometry* layerGeom = layer_p->geometry();
1708  const std::array<const float, 4>& layerBounds = layerGeom->parameters();
1709  float shiftFromEdge = 15.; //cm
1710  float shiftFromDeadZone = 10.;
1711  // is the extrapolated point within a sensitive region
1712  bool pass = withinSensitiveRegion(extrapolatedPointLocal,
1713  layerBounds,
1714  cscchamber->id().station(),
1715  cscchamber->id().ring(),
1716  shiftFromEdge,
1717  shiftFromDeadZone);
1718  if (pass) { // the extrapolation point of the segment lies within sensitive region of that chamber
1719  // how many rechit layers are there in the chamber?
1720  // 0 - maybe the muon died or is deflected at large angle? do not use that case
1721  // 1 - could be noise...
1722  // 2 or more - this is promissing; this is our definition of a reliable signal; use it below
1723  // is other definition better?
1724  int nRHLayers = 0;
1725  for (int iL = 0; iL < 6; ++iL) {
1726  if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1727  [cscchamber->id().chamber() - 1][iL]) {
1728  ++nRHLayers;
1729  }
1730  }
1731 
1732  // set verticalScale to 1-10 for ME-42...ME-11A,
1733  // 11-20 for ME+11A...ME+42
1734  float verticalScale =
1735  9. + cscchamber->id().endcap() + (cscchamber->specs()->chamberType()) * (cscchamber->id().zendcap());
1736 
1737  hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()), verticalScale);
1738  if (nRHLayers > 1) { // this chamber contains a reliable signal
1739  // this is the denominator for all efficiencies
1740  hEffDenominator->Fill(float(cscchamber->id().chamber()), verticalScale);
1741  // Segment efficiency
1742  if (AllSegments[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1743  [cscchamber->id().chamber() - 1]) {
1744  hSSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale));
1745  }
1746 
1747  for (int iL = 0; iL < 6; ++iL) {
1748  float weight = 1. / 6.;
1749  // should account for the weight in the efficiency...
1750  // Rechit efficiency
1751  if (AllRecHits[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1752  [cscchamber->id().chamber() - 1][iL]) {
1753  hRHSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1754  }
1755  // Wire efficiency
1756  if (allWires[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1757  [cscchamber->id().chamber() - 1][iL]) {
1758  // one shold account for the weight in the efficiency...
1759  hWireSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1760  }
1761  // Strip efficiency
1762  if (allStrips[cscchamber->id().endcap() - 1][cscchamber->id().station() - 1][cscchamber->id().ring() - 1]
1763  [cscchamber->id().chamber() - 1][iL]) {
1764  // one shold account for the weight in the efficiency...
1765  hStripSTE2->Fill(float(cscchamber->id().chamber()), float(verticalScale), weight);
1766  }
1767  }
1768  }
1769  }
1770  }
1771  }
1772  }
1773  //
1774 }
MonitorElement * hEffDenominator
MonitorElement * hRHden
int chamberType() const
const CSCLayer * layer(CSCDetId id) const
Return the layer corresponding to the given id.
Definition: CSCChamber.cc:30
MonitorElement * hSensitiveAreaEvt
LocalPoint localPosition() const override
Definition: CSCSegment.h:39
short int zendcap() const
Definition: CSCDetId.h:91
const CSCChamber * chamber(CSCDetId id) const
Return the chamber corresponding to given DetId.
Definition: CSCGeometry.cc:100
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
T z() const
Definition: PV3DBase.h:61
MonitorElement * hStripSTE2
for(int i=first, nt=offsets[nh];i< nt;i+=gridDim.x *blockDim.x)
Definition: weight.py:1
int layer() const
Definition: CSCDetId.h:56
MonitorElement * hSSTE2
unsigned short iChamberType() const
Definition: CSCDetId.h:96
MonitorElement * hWireSTE2
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
void Fill(long long x)
LocalVector localDirection() const override
Local direction.
Definition: CSCSegment.h:42
C::const_iterator const_iterator
constant access iterator type
Definition: RangeMap.h:43
T x() const
Definition: PV3DBase.h:59
T y() const
Definition: PV3DBase.h:60
int chamber() const
Definition: CSCDetId.h:62
MonitorElement * hSden
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
MonitorElement * hRHSTE2
int station() const
Definition: CSCDetId.h:79
virtual const std::array< const float, 4 > parameters() const
int endcap() const
Definition: CSCDetId.h:85
bool withinSensitiveRegion(LocalPoint localPos, const std::array< const float, 4 > &layerBounds, int station, int ring, float shiftFromEdge, float shiftFromDeadZone)
std::vector< const CSCChamber * > ChamberContainer
Definition: CSCGeometry.h:30
strips
#turn off noise in all subdetectors simHcalUnsuppressedDigis.doNoise = False mix.digitizers.hcal.doNoise = False simEcalUnsuppressedDigis.doNoise = False mix.digitizers.ecal.doNoise = False simEcalUnsuppressedDigis.doESNoise = False simSiPixelDigis.AddNoise = False mix.digitizers.pixel.AddNoise = False simSiStripDigis.Noise = False mix.digitizers.strip.AddNoise = False
Definition: DigiDM_cff.py:32
int ring() const
Definition: CSCDetId.h:68
MonitorElement * hSnum
const ChamberContainer & chambers() const
Return a vector of all chambers.
Definition: CSCGeometry.cc:96
double extrapolate1D(double initPosition, double initDirection, double parameterOfTheLine)
double lineParametrization(double z1Position, double z2Position, double z1Direction)
MonitorElement * hRHnum
const CSCChamberSpecs * specs() const
Definition: CSCChamber.h:39
CSCDetId id() const
Get the (concrete) DetId.
Definition: CSCChamber.h:34

◆ doOccupancies()

void CSCOfflineMonitor::doOccupancies ( edm::Handle< CSCStripDigiCollection strips,
edm::Handle< CSCWireDigiCollection wires,
edm::Handle< CSCRecHit2DCollection recHits,
edm::Handle< CSCSegmentCollection cscSegments,
edm::Handle< CSCCLCTDigiCollection clcts 
)
private

Definition at line 866 of file CSCOfflineMonitor.cc.

References HltBtagPostValidation_cff::c, CSCDetId::chamber(), chamberSerial(), dtChamberEfficiency_cfi::cscSegments, change_name::diff, MillePedeFileConverter_cfg::e, CSCDetId::endcap(), dqm::impl::MonitorElement::Fill(), nano_mu_digi_cff::float, hCSCOccupancy, hORecHits, hORecHitsSerial, hOSegments, hOSegmentsSerial, hOStrips, hOStripsAndWiresAndCLCT, hOStripSerial, hOWires, hOWiresAndCLCT, hOWireSerial, dqmiolumiharvest::j, alignCSCRings::r, FastTimerService_cff::range, FastTrackerRecHitMaskProducer_cfi::recHits, CSCDetId::ring(), alignCSCRings::s, CSCDetId::station(), DigiDM_cff::strips, remoteMonitoring_LASER_era2018_cfg::threshold, typeIndex(), and DigiDM_cff::wires.

Referenced by analyze().

870  {
871  bool clcto[2][4][4][36];
872  bool wireo[2][4][4][36];
873  bool stripo[2][4][4][36];
874  bool rechito[2][4][4][36];
875  bool segmento[2][4][4][36];
876 
877  bool hasWires = false;
878  bool hasStrips = false;
879  bool hasRecHits = false;
880  bool hasSegments = false;
881 
882  for (int e = 0; e < 2; e++) {
883  for (int s = 0; s < 4; s++) {
884  for (int r = 0; r < 4; r++) {
885  for (int c = 0; c < 36; c++) {
886  clcto[e][s][r][c] = false;
887  wireo[e][s][r][c] = false;
888  stripo[e][s][r][c] = false;
889  rechito[e][s][r][c] = false;
890  segmento[e][s][r][c] = false;
891  }
892  }
893  }
894  }
895 
896  //clcts
897  for (CSCCLCTDigiCollection::DigiRangeIterator j = clcts->begin(); j != clcts->end(); j++) {
898  CSCDetId id = (CSCDetId)(*j).first;
899  int kEndcap = id.endcap();
900  int kRing = id.ring();
901  int kStation = id.station();
902  int kChamber = id.chamber();
903  const CSCCLCTDigiCollection::Range& range = (*j).second;
904  for (CSCCLCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
905  // Valid digi in the chamber (or in neighbouring chamber)
906  if ((*digiIt).isValid()) {
907  //Check whether this CLCT came from ME11a
908  if (kStation == 1 && kRing == 1 && (*digiIt).getKeyStrip() > 128)
909  kRing = 4;
910  clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
911  }
912  }
913  }
914 
915  //wires
916  for (CSCWireDigiCollection::DigiRangeIterator wi = wires->begin(); wi != wires->end(); wi++) {
917  CSCDetId id = (CSCDetId)(*wi).first;
918  int kEndcap = id.endcap();
919  int kRing = id.ring();
920  int kStation = id.station();
921  int kChamber = id.chamber();
922  std::vector<CSCWireDigi>::const_iterator wireIt = (*wi).second.first;
923  std::vector<CSCWireDigi>::const_iterator lastWire = (*wi).second.second;
924  for (; wireIt != lastWire; ++wireIt) {
925  if (!wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
926  wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
927  hOWires->Fill(kChamber, typeIndex(id, 2));
929  hasWires = true;
930  if (clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1])
931  hOWiresAndCLCT->Fill(kChamber, typeIndex(id, 2));
932  //Also check for a CLCT in ME11a if you're in ME11 already
933  if (kStation == 1 && kRing == 1 && clcto[kEndcap - 1][kStation - 1][3][kChamber - 1]) {
934  CSCDetId idME11a = CSCDetId(kEndcap, kStation, 4, kChamber);
935  hOWiresAndCLCT->Fill(kChamber, typeIndex(idME11a, 2));
936  }
937  }
938  } //end for loop
939  }
940 
941  //strips
942  for (CSCStripDigiCollection::DigiRangeIterator si = strips->begin(); si != strips->end(); si++) {
943  CSCDetId id = (CSCDetId)(*si).first;
944  int kEndcap = id.endcap();
945  int kRing = id.ring();
946  int kStation = id.station();
947  int kChamber = id.chamber();
948  std::vector<CSCStripDigi>::const_iterator stripIt = (*si).second.first;
949  std::vector<CSCStripDigi>::const_iterator lastStrip = (*si).second.second;
950  for (; stripIt != lastStrip; ++stripIt) {
951  std::vector<int> myADCVals = stripIt->getADCCounts();
952  bool thisStripFired = false;
953  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
954  float threshold = 13.3;
955  float diff = 0.;
956  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
957  diff = (float)myADCVals[iCount] - thisPedestal;
958  if (diff > threshold) {
959  thisStripFired = true;
960  }
961  }
962  if (thisStripFired) {
963  if (!stripo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
964  stripo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
965  hOStrips->Fill(kChamber, typeIndex(id, 2));
967  hasStrips = true;
968  if (clcto[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
969  // check if there is a wire digi in this chamber too
970  // for ME 1/4 check for a wire in ME 1/1
971  if (wireo[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] ||
972  (kRing == 4 && wireo[kEndcap - 1][kStation - 1][0][kChamber - 1])) {
973  hOStripsAndWiresAndCLCT->Fill(kChamber, typeIndex(id, 2));
974  }
975  } //end clct and wire digi check
976  }
977  } //end if (thisStripFired)
978  }
979  }
980 
981  //rechits
983  for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
984  CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
985  int kEndcap = idrec.endcap();
986  int kRing = idrec.ring();
987  int kStation = idrec.station();
988  int kChamber = idrec.chamber();
989  if (!rechito[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
990  rechito[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
992  hORecHits->Fill(kChamber, typeIndex(idrec, 2));
993  hasRecHits = true;
994  }
995  }
996 
997  //segments
998  for (CSCSegmentCollection::const_iterator segIt = cscSegments->begin(); segIt != cscSegments->end(); segIt++) {
999  CSCDetId id = (CSCDetId)(*segIt).cscDetId();
1000  int kEndcap = id.endcap();
1001  int kRing = id.ring();
1002  int kStation = id.station();
1003  int kChamber = id.chamber();
1004  if (!segmento[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1]) {
1005  segmento[kEndcap - 1][kStation - 1][kRing - 1][kChamber - 1] = true;
1007  hOSegments->Fill(kChamber, typeIndex(id, 2));
1008  hasSegments = true;
1009  }
1010  }
1011 
1012  //Overall CSC Occupancy
1013  hCSCOccupancy->Fill(1);
1014  if (hasWires)
1015  hCSCOccupancy->Fill(3);
1016  if (hasStrips)
1017  hCSCOccupancy->Fill(5);
1018  if (hasWires && hasStrips)
1019  hCSCOccupancy->Fill(7);
1020  if (hasRecHits)
1021  hCSCOccupancy->Fill(9);
1022  if (hasSegments)
1023  hCSCOccupancy->Fill(11);
1024 }
MonitorElement * hOSegmentsSerial
MonitorElement * hOWireSerial
MonitorElement * hOStrips
int chamberSerial(CSCDetId id)
MonitorElement * hORecHits
MonitorElement * hORecHitsSerial
MonitorElement * hOStripSerial
MonitorElement * hOWires
void Fill(long long x)
C::const_iterator const_iterator
constant access iterator type
Definition: RangeMap.h:43
MonitorElement * hOStripsAndWiresAndCLCT
MonitorElement * hOSegments
int typeIndex(CSCDetId id, int flag=1)
int chamber() const
Definition: CSCDetId.h:62
MonitorElement * hOWiresAndCLCT
MonitorElement * hCSCOccupancy
int station() const
Definition: CSCDetId.h:79
std::pair< const_iterator, const_iterator > Range
int endcap() const
Definition: CSCDetId.h:85
std::vector< DigiType >::const_iterator const_iterator
strips
#turn off noise in all subdetectors simHcalUnsuppressedDigis.doNoise = False mix.digitizers.hcal.doNoise = False simEcalUnsuppressedDigis.doNoise = False mix.digitizers.ecal.doNoise = False simEcalUnsuppressedDigis.doESNoise = False simSiPixelDigis.AddNoise = False mix.digitizers.pixel.AddNoise = False simSiStripDigis.Noise = False mix.digitizers.strip.AddNoise = False
Definition: DigiDM_cff.py:32
int ring() const
Definition: CSCDetId.h:68

◆ doPedestalNoise()

void CSCOfflineMonitor::doPedestalNoise ( edm::Handle< CSCStripDigiCollection strips,
edm::ESHandle< CSCGeometry cscGeom 
)
private

Definition at line 1095 of file CSCOfflineMonitor.cc.

References nano_mu_digi_cff::float, CSCGeometry::gangedStrips(), getSignal(), hStripPed, CSCDetId::station(), DigiDM_cff::strips, remoteMonitoring_LASER_era2018_cfg::threshold, and typeIndex().

Referenced by analyze().

1096  {
1097  for (CSCStripDigiCollection::DigiRangeIterator dPNiter = strips->begin(); dPNiter != strips->end(); dPNiter++) {
1098  CSCDetId id = (CSCDetId)(*dPNiter).first;
1099  int kStation = id.station();
1100  int kRing = id.ring();
1101  std::vector<CSCStripDigi>::const_iterator pedIt = (*dPNiter).second.first;
1102  std::vector<CSCStripDigi>::const_iterator lStrip = (*dPNiter).second.second;
1103  for (; pedIt != lStrip; ++pedIt) {
1104  int myStrip = pedIt->getStrip();
1105  std::vector<int> myADCVals = pedIt->getADCCounts();
1106  float TotalADC = getSignal(*strips, id, myStrip);
1107  bool thisStripFired = false;
1108  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1109  float thisSignal =
1110  (1. / 6) * (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1111  float threshold = 13.3;
1112 
1113  // Why is this code block even here? Doesn't use myStrip after setting it (converts channel to strip
1114  // for ganged ME11A
1115  if ((kStation == 1 && kRing == 4) && cscGeom->gangedStrips()) {
1116  kRing = 1;
1117  if (myStrip <= 16)
1118  myStrip += 64; // no trapping for any bizarreness
1119  }
1120 
1121  if (TotalADC > threshold) {
1122  thisStripFired = true;
1123  }
1124  if (!thisStripFired) {
1125  float ADC = thisSignal - thisPedestal;
1126  hStripPed[typeIndex(id) - 1]->Fill(ADC);
1127  }
1128  }
1129  }
1130 }
float getSignal(const CSCStripDigiCollection &stripdigis, CSCDetId idRH, int centerStrip)
bool gangedStrips() const
Definition: CSCGeometry.h:110
int typeIndex(CSCDetId id, int flag=1)
int station() const
Definition: CSCDetId.h:79
std::vector< MonitorElement * > hStripPed
strips
#turn off noise in all subdetectors simHcalUnsuppressedDigis.doNoise = False mix.digitizers.hcal.doNoise = False simEcalUnsuppressedDigis.doNoise = False mix.digitizers.ecal.doNoise = False simEcalUnsuppressedDigis.doESNoise = False simSiPixelDigis.AddNoise = False mix.digitizers.pixel.AddNoise = False simSiStripDigis.Noise = False mix.digitizers.strip.AddNoise = False
Definition: DigiDM_cff.py:32

◆ doRecHits()

void CSCOfflineMonitor::doRecHits ( edm::Handle< CSCRecHit2DCollection recHits,
edm::Handle< CSCStripDigiCollection strips,
edm::ESHandle< CSCGeometry cscGeom 
)
private

Find the charge associated with this hit

Definition at line 1138 of file CSCOfflineMonitor.cc.

References CSCDetId::endcap(), dqm::impl::MonitorElement::Fill(), hRHGlobal, hRHnrechits, hRHnrechitsHi, hRHRatioQ, hRHsterr, hRHstpos, hRHSumQ, hRHTiming, hRHTimingAnode, mps_fire::i, dqmiolumiharvest::j, CSCGeometry::layer(), FastTrackerRecHitMaskProducer_cfi::recHits, CSCDetId::station(), GeomDet::toGlobal(), typeIndex(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by analyze().

1140  {
1141  // Get the RecHits collection :
1142  int nRecHits = recHits->size();
1143 
1144  // ---------------------
1145  // Loop over rechits
1146  // ---------------------
1147  // Build iterator for rechits and loop :
1149  for (dRHIter = recHits->begin(); dRHIter != recHits->end(); dRHIter++) {
1150  // Find chamber with rechits in CSC
1151  CSCDetId idrec = (CSCDetId)(*dRHIter).cscDetId();
1152 
1153  // Store rechit as a Local Point:
1154  LocalPoint rhitlocal = (*dRHIter).localPosition();
1155  //float xreco = rhitlocal.x();
1156  //float yreco = rhitlocal.y();
1157 
1158  // Get the reconstucted strip position and error
1159  float stpos = (*dRHIter).positionWithinStrip();
1160  float sterr = (*dRHIter).errorWithinStrip();
1161 
1163 
1164  int adcsize = dRHIter->nStrips() * dRHIter->nTimeBins();
1165  float rHSumQ = 0;
1166  float sumsides = 0;
1167  for (unsigned int i = 0; i < dRHIter->nStrips(); i++) {
1168  for (unsigned int j = 0; j < dRHIter->nTimeBins() - 1; j++) {
1169  rHSumQ += dRHIter->adcs(i, j);
1170  if (i != 1)
1171  sumsides += dRHIter->adcs(i, j); // skip central strip
1172  }
1173  }
1174 
1175  float rHratioQ = sumsides / rHSumQ;
1176  if (adcsize != 12)
1177  rHratioQ = -99;
1178 
1179  // Get the signal timing of this hit
1180  float rHtime = (*dRHIter).tpeak(); //calculated from cathode SCA bins
1181  float rHtimeAnode = (*dRHIter).wireTime(); // calculated from anode wire bx
1182 
1183  // Get pointer to the layer:
1184  const CSCLayer* csclayer = cscGeom->layer(idrec);
1185 
1186  // Transform hit position from local chamber geometry to global CMS geom
1187  GlobalPoint rhitglobal = csclayer->toGlobal(rhitlocal);
1188  float grecx = rhitglobal.x();
1189  float grecy = rhitglobal.y();
1190 
1191  // Fill some histograms
1192  int sIndex = idrec.station() + ((idrec.endcap() - 1) * 4);
1193  int tIndex = typeIndex(idrec);
1194  hRHSumQ[tIndex - 1]->Fill(rHSumQ);
1195  hRHRatioQ[tIndex - 1]->Fill(rHratioQ);
1196  hRHstpos[tIndex - 1]->Fill(stpos);
1197  hRHsterr[tIndex - 1]->Fill(sterr);
1198  hRHTiming[tIndex - 1]->Fill(rHtime);
1199  hRHTimingAnode[tIndex - 1]->Fill(rHtimeAnode);
1200  hRHGlobal[sIndex - 1]->Fill(grecx, grecy);
1201 
1202  } //end rechit loop
1203 
1204  // if (nRecHits == 0) nRecHits = -1; // I see no point in doing this
1205  hRHnrechits->Fill(nRecHits);
1206  hRHnrechitsHi->Fill(nRecHits);
1207 }
std::vector< MonitorElement * > hRHSumQ
std::vector< MonitorElement * > hRHGlobal
void Fill(long long x)
C::const_iterator const_iterator
constant access iterator type
Definition: RangeMap.h:43
T x() const
Definition: PV3DBase.h:59
T y() const
Definition: PV3DBase.h:60
std::vector< MonitorElement * > hRHstpos
int typeIndex(CSCDetId id, int flag=1)
MonitorElement * hRHnrechitsHi
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
int station() const
Definition: CSCDetId.h:79
std::vector< MonitorElement * > hRHTiming
int endcap() const
Definition: CSCDetId.h:85
std::vector< MonitorElement * > hRHTimingAnode
std::vector< MonitorElement * > hRHRatioQ
std::vector< MonitorElement * > hRHsterr
MonitorElement * hRHnrechits
const CSCLayer * layer(CSCDetId id) const
Return the layer corresponding to given DetId.
Definition: CSCGeometry.cc:105

◆ doResolution()

void CSCOfflineMonitor::doResolution ( edm::Handle< CSCSegmentCollection cscSegments,
edm::ESHandle< CSCGeometry cscGeom 
)
private

Find the strip containing this hit

Definition at line 1337 of file CSCOfflineMonitor.cc.

References dtChamberEfficiency_cfi::cscSegments, fitX(), hSResid, kLayer(), CSCDetId::layer(), CSCDetId::ring(), CSCDetId::station(), and typeIndex().

Referenced by analyze().

1338  {
1339  for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1340  CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1341  //
1342  // try to get the CSC recHits that contribute to this segment.
1343  std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1344  int nRH = (*dSiter).nRecHits();
1345  CLHEP::HepMatrix sp(6, 1);
1346  CLHEP::HepMatrix se(6, 1);
1347  for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1348  CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
1349  //int kEndcap = idRH.endcap();
1350  int kRing = idRH.ring();
1351  int kStation = idRH.station();
1352  //int kChamber = idRH.chamber();
1353  int kLayer = idRH.layer();
1354 
1356  int centerid = iRH->nStrips() / 2 + 1;
1357  int centerStrip = iRH->channels(centerid - 1);
1358 
1359  // If this segment has 6 hits, find the position of each hit on the strip in units of stripwidth and store values
1360  if (nRH == 6) {
1361  float stpos = (*iRH).positionWithinStrip();
1362  se(kLayer, 1) = (*iRH).errorWithinStrip();
1363  // Take into account half-strip staggering of layers (ME1/1 has no staggering)
1364  if (kStation == 1 && (kRing == 1 || kRing == 4))
1365  sp(kLayer, 1) = stpos + centerStrip;
1366  else {
1367  if (kLayer == 1 || kLayer == 3 || kLayer == 5)
1368  sp(kLayer, 1) = stpos + centerStrip;
1369  if (kLayer == 2 || kLayer == 4 || kLayer == 6)
1370  sp(kLayer, 1) = stpos - 0.5 + centerStrip;
1371  }
1372  }
1373  }
1374 
1375  // Fit all points except layer 3, then compare expected value for layer 3 to reconstructed value
1376  // float residual = -99.; // used to fill always
1377  if (nRH == 6) {
1378  float expected = fitX(sp, se);
1379  float residual = expected - sp(3, 1);
1380 
1381  hSResid[typeIndex(id) - 1]->Fill(residual); // fill here so stats make sense
1382  }
1383 
1384  // hSResid[typeIndex(id)-1]->Fill(residual); // used to fill here but then stats distorted by underflows
1385 
1386  } // end segment loop
1387 }
std::vector< MonitorElement * > hSResid
int layer() const
Definition: CSCDetId.h:56
C::const_iterator const_iterator
constant access iterator type
Definition: RangeMap.h:43
int typeIndex(CSCDetId id, int flag=1)
float fitX(const CLHEP::HepMatrix &sp, const CLHEP::HepMatrix &ep)
static const std::string kLayer("layer")
int station() const
Definition: CSCDetId.h:79
int ring() const
Definition: CSCDetId.h:68

◆ doSegments()

void CSCOfflineMonitor::doSegments ( edm::Handle< CSCSegmentCollection cscSegments,
edm::ESHandle< CSCGeometry cscGeom 
)
private

Definition at line 1215 of file CSCOfflineMonitor.cc.

References CSCGeometry::chamber(), chamberSerial(), ChiSquaredProbability(), dtChamberEfficiency_cfi::cscSegments, dqm::impl::MonitorElement::Fill(), hSChiSq, hSChiSqAll, hSChiSqProb, hSChiSqProbAll, hSGlobalPhi, hSGlobalTheta, hSnhits, hSnhitsAll, hSnSegments, hSTimeAnode, hSTimeAnodeByChamberType, hSTimeAnodeSerial, hSTimeCathode, hSTimeCathodeByChamberType, hSTimeCathodeSerial, hSTimeCombined, hSTimeCombinedByChamberType, hSTimeCombinedSerial, hSTimeDiff, hSTimeDiffByChamberType, hSTimeDiffSerial, hSTimeVsTOF, hSTimeVsZ, mps_fire::i, dqmiolumiharvest::j, nhits, PV3DBase< T, PVType, FrameType >::phi(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::theta(), GeomDet::toGlobal(), typeIndex(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

1215  {
1216  // get CSC segment collection
1217  int nSegments = cscSegments->size();
1218 
1219  for (CSCSegmentCollection::const_iterator dSiter = cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
1220  CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
1221  float chisq = (*dSiter).chi2();
1222  int nhits = (*dSiter).nRecHits();
1223  int nDOF = 2 * nhits - 4;
1224  float nChi2 = chisq / nDOF;
1225  double chisqProb = ChiSquaredProbability((double)chisq, nDOF);
1226  LocalPoint localPos = (*dSiter).localPosition();
1227  LocalVector segDir = (*dSiter).localDirection();
1228 
1229  // prepare to calculate segment times
1230  float timeCathode = 0; //average from cathode information alone
1231  float timeAnode = 0; //average from pruned anode information alone
1232  float timeCombined = 0; //average from cathode hits and pruned anode list
1233  std::vector<float> cathodeTimes;
1234  std::vector<float> anodeTimes;
1235  // Get the CSC recHits that contribute to this segment.
1236  std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
1237  for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
1238  if (!((*iRH).isValid()))
1239  continue; // only interested in valid hits
1240  cathodeTimes.push_back((*iRH).tpeak());
1241  anodeTimes.push_back((*iRH).wireTime());
1242  } //end rechit loop
1243 
1244  // Calculate cathode average
1245  for (unsigned int i = 0; i < cathodeTimes.size(); i++)
1246  timeCathode += cathodeTimes[i] / cathodeTimes.size();
1247 
1248  // Prune the anode list to deal with the late tail
1249  float anodeMaxDiff;
1250  bool modified = false;
1251  std::vector<float>::iterator anodeMaxHit;
1252  do {
1253  if (anodeTimes.empty())
1254  continue;
1255  timeAnode = 0;
1256  anodeMaxDiff = 0;
1257  modified = false;
1258 
1259  // Find the average
1260  for (unsigned int j = 0; j < anodeTimes.size(); j++)
1261  timeAnode += anodeTimes[j] / anodeTimes.size();
1262 
1263  // Find the maximum outlier hit
1264  for (unsigned int j = 0; j < anodeTimes.size(); j++) {
1265  if (fabs(anodeTimes[j] - timeAnode) > anodeMaxDiff) {
1266  anodeMaxHit = anodeTimes.begin() + j;
1267  anodeMaxDiff = fabs(anodeTimes[j] - timeAnode);
1268  }
1269  }
1270 
1271  // Cut hit if its greater than some time away
1272  if (anodeMaxDiff > 26) {
1273  modified = true;
1274  anodeTimes.erase(anodeMaxHit);
1275  }
1276  } while (modified);
1277 
1278  // Calculate combined anode and cathode time average
1279  if (cathodeTimes.size() + anodeTimes.size() > 0)
1280  timeCombined = (timeCathode * cathodeTimes.size() + timeAnode * anodeTimes.size()) /
1281  (cathodeTimes.size() + anodeTimes.size());
1282 
1283  // global transformation
1284  float globX = 0.;
1285  float globY = 0.;
1286  float globZ = 0.;
1287  float globTOF = 0.;
1288  float globTheta = 0.;
1289  float globPhi = 0.;
1290  const CSCChamber* cscchamber = cscGeom->chamber(id);
1291  if (cscchamber) {
1292  GlobalPoint globalPosition = cscchamber->toGlobal(localPos);
1293  globX = globalPosition.x();
1294  globY = globalPosition.y();
1295  globZ = globalPosition.z();
1296  globTOF = sqrt(globX * globX + globY * globY + globZ * globZ);
1297  GlobalVector globalDirection = cscchamber->toGlobal(segDir);
1298  globTheta = globalDirection.theta();
1299  globPhi = globalDirection.phi();
1300  }
1301 
1302  // Fill histos
1303  int tIndex = typeIndex(id);
1304  hSnhitsAll->Fill(nhits);
1305  hSnhits[tIndex - 1]->Fill(nhits);
1306  hSChiSqAll->Fill(nChi2);
1307  hSChiSq[tIndex - 1]->Fill(nChi2);
1308  hSChiSqProbAll->Fill(chisqProb);
1309  hSChiSqProb[tIndex - 1]->Fill(chisqProb);
1310  hSGlobalTheta->Fill(globTheta);
1311  hSGlobalPhi->Fill(globPhi);
1312  hSTimeDiff->Fill(timeAnode - timeCathode);
1313  hSTimeDiffByChamberType[tIndex - 1]->Fill(timeAnode - timeCathode);
1314  hSTimeAnode->Fill(timeAnode);
1315  hSTimeAnodeByChamberType[tIndex - 1]->Fill(timeAnode);
1316  hSTimeCathode->Fill(timeCathode);
1317  hSTimeCathodeByChamberType[tIndex - 1]->Fill(timeCathode);
1318  hSTimeCombined->Fill(timeCombined);
1319  hSTimeCombinedByChamberType[tIndex - 1]->Fill(timeCombined);
1320  hSTimeDiffSerial->Fill(chamberSerial(id), timeAnode - timeCathode);
1321  hSTimeAnodeSerial->Fill(chamberSerial(id), timeAnode);
1322  hSTimeCathodeSerial->Fill(chamberSerial(id), timeCathode);
1323  hSTimeCombinedSerial->Fill(chamberSerial(id), timeCombined);
1324  hSTimeVsZ->Fill(globZ, timeCombined);
1325  hSTimeVsTOF->Fill(globTOF, timeCombined);
1326 
1327  } // end segment loop
1328 
1329  hSnSegments->Fill(nSegments);
1330 }
std::vector< MonitorElement * > hSTimeCathodeByChamberType
int chamberSerial(CSCDetId id)
std::vector< MonitorElement * > hSTimeAnodeByChamberType
std::vector< MonitorElement * > hSTimeDiffByChamberType
const CSCChamber * chamber(CSCDetId id) const
Return the chamber corresponding to given DetId.
Definition: CSCGeometry.cc:100
T z() const
Definition: PV3DBase.h:61
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
MonitorElement * hSTimeAnodeSerial
MonitorElement * hSTimeAnode
MonitorElement * hSGlobalPhi
std::vector< MonitorElement * > hSnhits
void Fill(long long x)
MonitorElement * hSnSegments
C::const_iterator const_iterator
constant access iterator type
Definition: RangeMap.h:43
T x() const
Definition: PV3DBase.h:59
T y() const
Definition: PV3DBase.h:60
int typeIndex(CSCDetId id, int flag=1)
MonitorElement * hSnhitsAll
T sqrt(T t)
Definition: SSEVec.h:19
std::vector< MonitorElement * > hSChiSq
MonitorElement * hSGlobalTheta
MonitorElement * hSTimeDiffSerial
float ChiSquaredProbability(double chiSquared, double nrDOF)
MonitorElement * hSTimeCombined
std::vector< MonitorElement * > hSTimeCombinedByChamberType
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
MonitorElement * hSTimeVsZ
MonitorElement * hSChiSqAll
MonitorElement * hSTimeDiff
MonitorElement * hSTimeCathode
std::vector< MonitorElement * > hSChiSqProb
MonitorElement * hSTimeCathodeSerial
MonitorElement * hSTimeCombinedSerial
MonitorElement * hSTimeVsTOF
MonitorElement * hSChiSqProbAll
Geom::Theta< T > theta() const
Definition: PV3DBase.h:72

◆ doStripDigis()

void CSCOfflineMonitor::doStripDigis ( edm::Handle< CSCStripDigiCollection strips)
private

Definition at line 1057 of file CSCOfflineMonitor.cc.

References change_name::diff, dqm::impl::MonitorElement::Fill(), nano_mu_digi_cff::float, cms::cuda::for(), hStripNFired, hStripNFiredHi, hStripNumber, DigiDM_cff::strips, remoteMonitoring_LASER_era2018_cfg::threshold, and typeIndex().

Referenced by analyze().

1057  {
1058  int nStripsFired = 0;
1059  for (CSCStripDigiCollection::DigiRangeIterator dSDiter = strips->begin(); dSDiter != strips->end(); dSDiter++) {
1060  CSCDetId id = (CSCDetId)(*dSDiter).first;
1061  std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
1062  std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
1063  for (; stripIter != lStrip; ++stripIter) {
1064  int myStrip = stripIter->getStrip();
1065  std::vector<int> myADCVals = stripIter->getADCCounts();
1066  bool thisStripFired = false;
1067  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1068  float threshold = 13.3;
1069  float diff = 0.;
1070  for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
1071  diff = (float)myADCVals[iCount] - thisPedestal;
1072  if (diff > threshold) {
1073  thisStripFired = true;
1074  }
1075  }
1076  if (thisStripFired) {
1077  nStripsFired++;
1078  hStripNumber[typeIndex(id) - 1]->Fill(myStrip);
1079  }
1080  }
1081  } // end strip loop
1082 
1083  hStripNFired->Fill(nStripsFired);
1084  hStripNFiredHi->Fill(nStripsFired);
1085 
1086  // fill n per event
1087 }
for(int i=first, nt=offsets[nh];i< nt;i+=gridDim.x *blockDim.x)
std::vector< MonitorElement * > hStripNumber
void Fill(long long x)
int typeIndex(CSCDetId id, int flag=1)
MonitorElement * hStripNFired
strips
#turn off noise in all subdetectors simHcalUnsuppressedDigis.doNoise = False mix.digitizers.hcal.doNoise = False simEcalUnsuppressedDigis.doNoise = False mix.digitizers.ecal.doNoise = False simEcalUnsuppressedDigis.doESNoise = False simSiPixelDigis.AddNoise = False mix.digitizers.pixel.AddNoise = False simSiStripDigis.Noise = False mix.digitizers.strip.AddNoise = False
Definition: DigiDM_cff.py:32
MonitorElement * hStripNFiredHi

◆ doWireDigis()

void CSCOfflineMonitor::doWireDigis ( edm::Handle< CSCWireDigiCollection wires)
private

Definition at line 1032 of file CSCOfflineMonitor.cc.

References dqm::impl::MonitorElement::Fill(), cms::cuda::for(), hWirenGroupsTotal, hWirenGroupsTotalHi, hWireNumber, hWireTBin, typeIndex(), and DigiDM_cff::wires.

Referenced by analyze().

1032  {
1033  int nWireGroupsTotal = 0;
1034  for (CSCWireDigiCollection::DigiRangeIterator dWDiter = wires->begin(); dWDiter != wires->end(); dWDiter++) {
1035  CSCDetId id = (CSCDetId)(*dWDiter).first;
1036  std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
1037  std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
1038  for (; wireIter != lWire; ++wireIter) {
1039  int myWire = wireIter->getWireGroup();
1040  int myTBin = wireIter->getTimeBin();
1041  nWireGroupsTotal++;
1042  hWireTBin[typeIndex(id) - 1]->Fill(myTBin);
1043  hWireNumber[typeIndex(id) - 1]->Fill(myWire);
1044  }
1045  } // end wire loop
1046 
1047  hWirenGroupsTotal->Fill(nWireGroupsTotal);
1048  hWirenGroupsTotalHi->Fill(nWireGroupsTotal);
1049 }
std::vector< MonitorElement * > hWireNumber
for(int i=first, nt=offsets[nh];i< nt;i+=gridDim.x *blockDim.x)
MonitorElement * hWirenGroupsTotal
void Fill(long long x)
int typeIndex(CSCDetId id, int flag=1)
std::vector< MonitorElement * > hWireTBin
MonitorElement * hWirenGroupsTotalHi

◆ extrapolate1D()

double CSCOfflineMonitor::extrapolate1D ( double  initPosition,
double  initDirection,
double  parameterOfTheLine 
)
inlineprivate

Definition at line 139 of file CSCOfflineMonitor.h.

Referenced by doEfficiencies().

139  {
140  double extrapolatedPosition = initPosition + initDirection * parameterOfTheLine;
141  return extrapolatedPosition;
142  }

◆ fillEfficiencyHistos()

void CSCOfflineMonitor::fillEfficiencyHistos ( int  bin,
int  flag 
)
private

◆ fitX()

float CSCOfflineMonitor::fitX ( const CLHEP::HepMatrix &  sp,
const CLHEP::HepMatrix &  ep 
)
private

Definition at line 1394 of file CSCOfflineMonitor.cc.

References dumpMFGeometry_cfg::delta, nano_mu_digi_cff::errors, mps_fire::i, hiPixelPairStep_cff::points, and slope.

Referenced by doResolution().

1394  {
1395  float S = 0;
1396  float Sx = 0;
1397  float Sy = 0;
1398  float Sxx = 0;
1399  float Sxy = 0;
1400  float sigma2 = 0;
1401 
1402  for (int i = 1; i < 7; i++) {
1403  if (i != 3) {
1404  sigma2 = errors(i, 1) * errors(i, 1);
1405  S = S + (1 / sigma2);
1406  Sy = Sy + (points(i, 1) / sigma2);
1407  Sx = Sx + ((i) / sigma2);
1408  Sxx = Sxx + (i * i) / sigma2;
1409  Sxy = Sxy + (((i)*points(i, 1)) / sigma2);
1410  }
1411  }
1412 
1413  float delta = S * Sxx - Sx * Sx;
1414  float intercept = (Sxx * Sy - Sx * Sxy) / delta;
1415  float slope = (S * Sxy - Sx * Sy) / delta;
1416 
1417  return (intercept + slope * 3);
1418 }
static const double slope[3]

◆ getSignal()

float CSCOfflineMonitor::getSignal ( const CSCStripDigiCollection stripdigis,
CSCDetId  idRH,
int  centerStrip 
)
private

Definition at line 1427 of file CSCOfflineMonitor.cc.

References nano_mu_digi_cff::float, caHitNtupletGeneratorKernels::if(), and dqmdumpme::last.

Referenced by doPedestalNoise().

1427  {
1428  float SigADC[5];
1429  float TotalADC = 0;
1430  SigADC[0] = 0;
1431  SigADC[1] = 0;
1432  SigADC[2] = 0;
1433  SigADC[3] = 0;
1434  SigADC[4] = 0;
1435 
1436  // Loop over strip digis
1438 
1439  for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++) {
1440  CSCDetId id = (CSCDetId)(*sIt).first;
1441  if (id == idCS) {
1442  // First, find the Signal-Pedestal for center strip
1443  vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
1444  vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
1445  for (; digiItr != last; ++digiItr) {
1446  int thisStrip = digiItr->getStrip();
1447  if (thisStrip == (centerStrip)) {
1448  std::vector<int> myADCVals = digiItr->getADCCounts();
1449  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1450  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1451  SigADC[0] = thisSignal - 6 * thisPedestal;
1452  }
1453  // Now,find the Signal-Pedestal for neighbouring 4 strips
1454  if (thisStrip == (centerStrip + 1)) {
1455  std::vector<int> myADCVals = digiItr->getADCCounts();
1456  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1457  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1458  SigADC[1] = thisSignal - 6 * thisPedestal;
1459  }
1460  if (thisStrip == (centerStrip + 2)) {
1461  std::vector<int> myADCVals = digiItr->getADCCounts();
1462  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1463  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1464  SigADC[2] = thisSignal - 6 * thisPedestal;
1465  }
1466  if (thisStrip == (centerStrip - 1)) {
1467  std::vector<int> myADCVals = digiItr->getADCCounts();
1468  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1469  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1470  SigADC[3] = thisSignal - 6 * thisPedestal;
1471  }
1472  if (thisStrip == (centerStrip - 2)) {
1473  std::vector<int> myADCVals = digiItr->getADCCounts();
1474  float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
1475  float thisSignal = (myADCVals[2] + myADCVals[3] + myADCVals[4] + myADCVals[5] + myADCVals[6] + myADCVals[7]);
1476  SigADC[4] = thisSignal - 6 * thisPedestal;
1477  }
1478  }
1479  TotalADC = 0.2 * (SigADC[0] + SigADC[1] + SigADC[2] + SigADC[3] + SigADC[4]);
1480  }
1481  }
1482  return TotalADC;
1483 }

◆ lineParametrization()

double CSCOfflineMonitor::lineParametrization ( double  z1Position,
double  z2Position,
double  z1Direction 
)
inlineprivate

Definition at line 134 of file CSCOfflineMonitor.h.

Referenced by doEfficiencies().

134  {
135  double parameterLine = (z2Position - z1Position) / z1Direction;
136  return parameterLine;
137  }

◆ typeIndex()

int CSCOfflineMonitor::typeIndex ( CSCDetId  id,
int  flag = 1 
)
private

Definition at line 2081 of file CSCOfflineMonitor.cc.

References makeMuonMisalignmentScenario::endcap, RemoveAddSevLevel::flag, relativeConstraints::ring, and relativeConstraints::station.

Referenced by doBXMonitor(), doOccupancies(), doPedestalNoise(), doRecHits(), doResolution(), doSegments(), doStripDigis(), and doWireDigis().

2081  {
2082  // linearized index based on endcap, station, and ring
2083 
2084  if (flag == 1) {
2085  int index = 0;
2086  if (id.station() == 1)
2087  index = id.ring();
2088  else
2089  index = id.station() * 2 + id.ring();
2090  if (id.endcap() == 1)
2091  index = index + 10;
2092  if (id.endcap() == 2)
2093  index = 11 - index;
2094  return index;
2095  }
2096 
2097  else if (flag == 2) {
2098  int index = 0;
2099  if (id.station() == 1 && id.ring() != 4)
2100  index = id.ring() + 1;
2101  if (id.station() == 1 && id.ring() == 4)
2102  index = 1;
2103  if (id.station() != 1)
2104  index = id.station() * 2 + id.ring();
2105  if (id.endcap() == 1)
2106  index = index + 10;
2107  if (id.endcap() == 2)
2108  index = 11 - index;
2109  return index;
2110  }
2111 
2112  else
2113  return 0;
2114 }

◆ withinSensitiveRegion()

bool CSCOfflineMonitor::withinSensitiveRegion ( LocalPoint  localPos,
const std::array< const float, 4 > &  layerBounds,
int  station,
int  ring,
float  shiftFromEdge,
float  shiftFromDeadZone 
)
private

Definition at line 1983 of file CSCOfflineMonitor.cc.

References funct::abs(), relativeConstraints::ring, relativeConstraints::station, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by doEfficiencies().

1988  {
1989  //---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded)
1990  bool pass = false;
1991 
1992  float y_center = 0.;
1993  double yUp = layerBounds[3] + y_center;
1994  double yDown = -layerBounds[3] + y_center;
1995  double xBound1Shifted = layerBounds[0] - shiftFromEdge; //
1996  double xBound2Shifted = layerBounds[1] - shiftFromEdge; //
1997  double lineSlope = (yUp - yDown) / (xBound2Shifted - xBound1Shifted);
1998  double lineConst = yUp - lineSlope * xBound2Shifted;
1999  double yBorder = lineSlope * abs(localPos.x()) + lineConst;
2000 
2001  //bool withinChamberOnly = false;// false = "good region"; true - boundaries only
2002  std::vector<float> deadZoneCenter(6);
2003  float cutZone = shiftFromDeadZone; //cm
2004  //---- hardcoded... not good
2005  if (station > 1 && station < 5) {
2006  if (2 == ring) {
2007  deadZoneCenter[0] = -162.48;
2008  deadZoneCenter[1] = -81.8744;
2009  deadZoneCenter[2] = -21.18165;
2010  deadZoneCenter[3] = 39.51105;
2011  deadZoneCenter[4] = 100.2939;
2012  deadZoneCenter[5] = 160.58;
2013 
2014  if (localPos.y() > yBorder &&
2015  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2016  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2017  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone) ||
2018  (localPos.y() > deadZoneCenter[3] + cutZone && localPos.y() < deadZoneCenter[4] - cutZone) ||
2019  (localPos.y() > deadZoneCenter[4] + cutZone && localPos.y() < deadZoneCenter[5] - cutZone))) {
2020  pass = true;
2021  }
2022  } else if (1 == ring) {
2023  if (2 == station) {
2024  deadZoneCenter[0] = -95.80;
2025  deadZoneCenter[1] = -27.47;
2026  deadZoneCenter[2] = 33.67;
2027  deadZoneCenter[3] = 90.85;
2028  } else if (3 == station) {
2029  deadZoneCenter[0] = -89.305;
2030  deadZoneCenter[1] = -39.705;
2031  deadZoneCenter[2] = 20.195;
2032  deadZoneCenter[3] = 77.395;
2033  } else if (4 == station) {
2034  deadZoneCenter[0] = -75.645;
2035  deadZoneCenter[1] = -26.055;
2036  deadZoneCenter[2] = 23.855;
2037  deadZoneCenter[3] = 70.575;
2038  }
2039  if (localPos.y() > yBorder &&
2040  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2041  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2042  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2043  pass = true;
2044  }
2045  }
2046  } else if (1 == station) {
2047  if (3 == ring) {
2048  deadZoneCenter[0] = -83.155;
2049  deadZoneCenter[1] = -22.7401;
2050  deadZoneCenter[2] = 27.86665;
2051  deadZoneCenter[3] = 81.005;
2052  if (localPos.y() > yBorder &&
2053  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2054  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2055  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2056  pass = true;
2057  }
2058  } else if (2 == ring) {
2059  deadZoneCenter[0] = -86.285;
2060  deadZoneCenter[1] = -32.88305;
2061  deadZoneCenter[2] = 32.867423;
2062  deadZoneCenter[3] = 88.205;
2063  if (localPos.y() > (yBorder) &&
2064  ((localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone) ||
2065  (localPos.y() > deadZoneCenter[1] + cutZone && localPos.y() < deadZoneCenter[2] - cutZone) ||
2066  (localPos.y() > deadZoneCenter[2] + cutZone && localPos.y() < deadZoneCenter[3] - cutZone))) {
2067  pass = true;
2068  }
2069  } else {
2070  deadZoneCenter[0] = -81.0;
2071  deadZoneCenter[1] = 81.0;
2072  if (localPos.y() > (yBorder) &&
2073  (localPos.y() > deadZoneCenter[0] + cutZone && localPos.y() < deadZoneCenter[1] - cutZone)) {
2074  pass = true;
2075  }
2076  }
2077  }
2078  return pass;
2079 }
T x() const
Definition: PV3DBase.h:59
T y() const
Definition: PV3DBase.h:60
Abs< T >::type abs(const T &t)
Definition: Abs.h:22

Member Data Documentation

◆ al_token

edm::EDGetTokenT<CSCALCTDigiCollection> CSCOfflineMonitor::al_token
private

Definition at line 87 of file CSCOfflineMonitor.h.

Referenced by analyze(), and CSCOfflineMonitor().

◆ cl_token

edm::EDGetTokenT<CSCCLCTDigiCollection> CSCOfflineMonitor::cl_token
private

Definition at line 88 of file CSCOfflineMonitor.h.

Referenced by analyze(), and CSCOfflineMonitor().

◆ cscGeomToken_

const edm::ESGetToken<CSCGeometry, MuonGeometryRecord> CSCOfflineMonitor::cscGeomToken_
private

Definition at line 92 of file CSCOfflineMonitor.h.

Referenced by analyze().

◆ hALCTgetBX

MonitorElement* CSCOfflineMonitor::hALCTgetBX
private

Definition at line 239 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTgetBX2Denominator

MonitorElement* CSCOfflineMonitor::hALCTgetBX2Denominator
private

Definition at line 243 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTgetBX2DNumerator

MonitorElement* CSCOfflineMonitor::hALCTgetBX2DNumerator
private

Definition at line 244 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTgetBXSerial

MonitorElement* CSCOfflineMonitor::hALCTgetBXSerial
private

Definition at line 240 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTMatch

MonitorElement* CSCOfflineMonitor::hALCTMatch
private

Definition at line 246 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTMatch2Denominator

MonitorElement* CSCOfflineMonitor::hALCTMatch2Denominator
private

Definition at line 250 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTMatch2DNumerator

MonitorElement* CSCOfflineMonitor::hALCTMatch2DNumerator
private

Definition at line 251 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hALCTMatchSerial

MonitorElement* CSCOfflineMonitor::hALCTMatchSerial
private

Definition at line 247 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hCLCTL1A

MonitorElement* CSCOfflineMonitor::hCLCTL1A
private

Definition at line 253 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hCLCTL1A2Denominator

MonitorElement* CSCOfflineMonitor::hCLCTL1A2Denominator
private

Definition at line 257 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hCLCTL1A2DNumerator

MonitorElement* CSCOfflineMonitor::hCLCTL1A2DNumerator
private

Definition at line 258 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hCLCTL1ASerial

MonitorElement* CSCOfflineMonitor::hCLCTL1ASerial
private

Definition at line 254 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doBXMonitor().

◆ hcrateToken_

const edm::ESGetToken<CSCCrateMap, CSCCrateMapRcd> CSCOfflineMonitor::hcrateToken_
private

Definition at line 94 of file CSCOfflineMonitor.h.

Referenced by doBXMonitor().

◆ hCSCOccupancy

MonitorElement* CSCOfflineMonitor::hCSCOccupancy
private

Definition at line 217 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hEffDenominator

MonitorElement* CSCOfflineMonitor::hEffDenominator
private

Definition at line 235 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hORecHits

MonitorElement* CSCOfflineMonitor::hORecHits
private

Definition at line 211 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hORecHitsSerial

MonitorElement* CSCOfflineMonitor::hORecHitsSerial
private

Definition at line 215 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOSegments

MonitorElement* CSCOfflineMonitor::hOSegments
private

Definition at line 212 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOSegmentsSerial

MonitorElement* CSCOfflineMonitor::hOSegmentsSerial
private

Definition at line 216 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOStrips

MonitorElement* CSCOfflineMonitor::hOStrips
private

Definition at line 209 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOStripsAndWiresAndCLCT

MonitorElement* CSCOfflineMonitor::hOStripsAndWiresAndCLCT
private

Definition at line 210 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOStripSerial

MonitorElement* CSCOfflineMonitor::hOStripSerial
private

Definition at line 214 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOWires

MonitorElement* CSCOfflineMonitor::hOWires
private

Definition at line 207 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOWiresAndCLCT

MonitorElement* CSCOfflineMonitor::hOWiresAndCLCT
private

Definition at line 208 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hOWireSerial

MonitorElement* CSCOfflineMonitor::hOWireSerial
private

Definition at line 213 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doOccupancies().

◆ hRHden

MonitorElement* CSCOfflineMonitor::hRHden
private

Definition at line 223 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hRHGlobal

std::vector<MonitorElement *> CSCOfflineMonitor::hRHGlobal
private

Definition at line 170 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHnrechits

MonitorElement* CSCOfflineMonitor::hRHnrechits
private

Definition at line 168 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHnrechitsHi

MonitorElement* CSCOfflineMonitor::hRHnrechitsHi
private

Definition at line 169 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHnum

MonitorElement* CSCOfflineMonitor::hRHnum
private

Definition at line 222 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hRHRatioQ

std::vector<MonitorElement *> CSCOfflineMonitor::hRHRatioQ
private

Definition at line 174 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHSTE2

MonitorElement* CSCOfflineMonitor::hRHSTE2
private

Definition at line 227 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hRHsterr

std::vector<MonitorElement *> CSCOfflineMonitor::hRHsterr
private

Definition at line 176 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHstpos

std::vector<MonitorElement *> CSCOfflineMonitor::hRHstpos
private

Definition at line 175 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHSumQ

std::vector<MonitorElement *> CSCOfflineMonitor::hRHSumQ
private

Definition at line 171 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHTiming

std::vector<MonitorElement *> CSCOfflineMonitor::hRHTiming
private

Definition at line 172 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hRHTimingAnode

std::vector<MonitorElement *> CSCOfflineMonitor::hRHTimingAnode
private

Definition at line 173 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doRecHits().

◆ hSChiSq

std::vector<MonitorElement *> CSCOfflineMonitor::hSChiSq
private

Definition at line 183 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSChiSqAll

MonitorElement* CSCOfflineMonitor::hSChiSqAll
private

Definition at line 182 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSChiSqProb

std::vector<MonitorElement *> CSCOfflineMonitor::hSChiSqProb
private

Definition at line 185 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSChiSqProbAll

MonitorElement* CSCOfflineMonitor::hSChiSqProbAll
private

Definition at line 184 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSden

MonitorElement* CSCOfflineMonitor::hSden
private

Definition at line 221 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hSensitiveAreaEvt

MonitorElement* CSCOfflineMonitor::hSensitiveAreaEvt
private

Definition at line 236 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hSGlobalPhi

MonitorElement* CSCOfflineMonitor::hSGlobalPhi
private

Definition at line 187 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSGlobalTheta

MonitorElement* CSCOfflineMonitor::hSGlobalTheta
private

Definition at line 186 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSnhits

std::vector<MonitorElement *> CSCOfflineMonitor::hSnhits
private

Definition at line 181 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSnhitsAll

MonitorElement* CSCOfflineMonitor::hSnhitsAll
private

Definition at line 180 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSnSegments

MonitorElement* CSCOfflineMonitor::hSnSegments
private

Definition at line 179 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSnum

MonitorElement* CSCOfflineMonitor::hSnum
private

Definition at line 220 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hSResid

std::vector<MonitorElement *> CSCOfflineMonitor::hSResid
private

Definition at line 204 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doResolution().

◆ hSSTE2

MonitorElement* CSCOfflineMonitor::hSSTE2
private

Definition at line 226 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hSTimeAnode

MonitorElement* CSCOfflineMonitor::hSTimeAnode
private

Definition at line 190 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeAnodeByChamberType

std::vector<MonitorElement *> CSCOfflineMonitor::hSTimeAnodeByChamberType
private

Definition at line 191 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeAnodeSerial

MonitorElement* CSCOfflineMonitor::hSTimeAnodeSerial
private

Definition at line 197 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeCathode

MonitorElement* CSCOfflineMonitor::hSTimeCathode
private

Definition at line 192 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeCathodeByChamberType

std::vector<MonitorElement *> CSCOfflineMonitor::hSTimeCathodeByChamberType
private

Definition at line 193 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeCathodeSerial

MonitorElement* CSCOfflineMonitor::hSTimeCathodeSerial
private

Definition at line 198 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeCombined

MonitorElement* CSCOfflineMonitor::hSTimeCombined
private

Definition at line 194 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeCombinedByChamberType

std::vector<MonitorElement *> CSCOfflineMonitor::hSTimeCombinedByChamberType
private

Definition at line 195 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeCombinedSerial

MonitorElement* CSCOfflineMonitor::hSTimeCombinedSerial
private

Definition at line 199 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeDiff

MonitorElement* CSCOfflineMonitor::hSTimeDiff
private

Definition at line 188 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeDiffByChamberType

std::vector<MonitorElement *> CSCOfflineMonitor::hSTimeDiffByChamberType
private

Definition at line 189 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeDiffSerial

MonitorElement* CSCOfflineMonitor::hSTimeDiffSerial
private

Definition at line 196 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeVsTOF

MonitorElement* CSCOfflineMonitor::hSTimeVsTOF
private

Definition at line 201 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hSTimeVsZ

MonitorElement* CSCOfflineMonitor::hSTimeVsZ
private

Definition at line 200 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doSegments().

◆ hStripNFired

MonitorElement* CSCOfflineMonitor::hStripNFired
private

Definition at line 162 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doStripDigis().

◆ hStripNFiredHi

MonitorElement* CSCOfflineMonitor::hStripNFiredHi
private

Definition at line 163 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doStripDigis().

◆ hStripNumber

std::vector<MonitorElement *> CSCOfflineMonitor::hStripNumber
private

Definition at line 164 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doStripDigis().

◆ hStripPed

std::vector<MonitorElement *> CSCOfflineMonitor::hStripPed
private

Definition at line 165 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doPedestalNoise().

◆ hStripSTE2

MonitorElement* CSCOfflineMonitor::hStripSTE2
private

Definition at line 228 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hWirenGroupsTotal

MonitorElement* CSCOfflineMonitor::hWirenGroupsTotal
private

Definition at line 156 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doWireDigis().

◆ hWirenGroupsTotalHi

MonitorElement* CSCOfflineMonitor::hWirenGroupsTotalHi
private

Definition at line 157 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doWireDigis().

◆ hWireNumber

std::vector<MonitorElement *> CSCOfflineMonitor::hWireNumber
private

Definition at line 159 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doWireDigis().

◆ hWireSTE2

MonitorElement* CSCOfflineMonitor::hWireSTE2
private

Definition at line 229 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doEfficiencies().

◆ hWireTBin

std::vector<MonitorElement *> CSCOfflineMonitor::hWireTBin
private

Definition at line 158 of file CSCOfflineMonitor.h.

Referenced by bookHistograms(), and doWireDigis().

◆ param

edm::ParameterSet CSCOfflineMonitor::param
private

Definition at line 82 of file CSCOfflineMonitor.h.

◆ rd_token

edm::EDGetTokenT<FEDRawDataCollection> CSCOfflineMonitor::rd_token
private

Definition at line 84 of file CSCOfflineMonitor.h.

Referenced by CSCOfflineMonitor(), and doBXMonitor().

◆ rh_token

edm::EDGetTokenT<CSCRecHit2DCollection> CSCOfflineMonitor::rh_token
private

Definition at line 89 of file CSCOfflineMonitor.h.

Referenced by analyze(), and CSCOfflineMonitor().

◆ sd_token

edm::EDGetTokenT<CSCStripDigiCollection> CSCOfflineMonitor::sd_token
private

Definition at line 86 of file CSCOfflineMonitor.h.

Referenced by analyze(), and CSCOfflineMonitor().

◆ se_token

edm::EDGetTokenT<CSCSegmentCollection> CSCOfflineMonitor::se_token
private

Definition at line 90 of file CSCOfflineMonitor.h.

Referenced by analyze(), and CSCOfflineMonitor().

◆ wd_token

edm::EDGetTokenT<CSCWireDigiCollection> CSCOfflineMonitor::wd_token
private

Definition at line 85 of file CSCOfflineMonitor.h.

Referenced by analyze(), and CSCOfflineMonitor().