|
|
|
#include <CSCOfflineMonitor.h>
Simple package for offline CSC DQM based on RecoLocalMuon/CSCValidation: DIGIS recHits segments
Andrew Kubik, Northwestern University, Oct 2008
Definition at line 74 of file CSCOfflineMonitor.h.
| CSCOfflineMonitor::CSCOfflineMonitor | ( | const edm::ParameterSet & | pset | ) |
Constructor.
Definition at line 17 of file CSCOfflineMonitor.cc.
References edm::ParameterSet::getParameter().
{
param = pset;
stripDigiTag_ = pset.getParameter<edm::InputTag>("stripDigiTag");
wireDigiTag_ = pset.getParameter<edm::InputTag>("wireDigiTag");
alctDigiTag_ = pset.getParameter<edm::InputTag>("alctDigiTag");
clctDigiTag_ = pset.getParameter<edm::InputTag>("clctDigiTag");
cscRecHitTag_ = pset.getParameter<edm::InputTag>("cscRecHitTag");
cscSegTag_ = pset.getParameter<edm::InputTag>("cscSegTag");
FEDRawDataCollectionTag_ = pset.getParameter<edm::InputTag>("FEDRawDataCollectionTag");
finalizedHistograms_=false;
}
| CSCOfflineMonitor::~CSCOfflineMonitor | ( | ) | [virtual] |
| void CSCOfflineMonitor::analyze | ( | const edm::Event & | event, |
| const edm::EventSetup & | eventSetup | ||
| ) | [virtual] |
Perform the real analysis.
Implements edm::EDAnalyzer.
Definition at line 599 of file CSCOfflineMonitor.cc.
References cscSegments_cfi::cscSegments, edm::EventSetup::get(), and RecoTauPiZeroBuilderPlugins_cfi::strips.
{
edm::Handle<CSCWireDigiCollection> wires;
edm::Handle<CSCStripDigiCollection> strips;
edm::Handle<CSCALCTDigiCollection> alcts;
edm::Handle<CSCCLCTDigiCollection> clcts;
event.getByLabel(stripDigiTag_, strips);
event.getByLabel(wireDigiTag_, wires);
event.getByLabel(alctDigiTag_, alcts);
event.getByLabel(clctDigiTag_, clcts);
// Get the CSC Geometry :
ESHandle<CSCGeometry> cscGeom;
eventSetup.get<MuonGeometryRecord>().get(cscGeom);
// Get the RecHits collection :
Handle<CSCRecHit2DCollection> recHits;
event.getByLabel(cscRecHitTag_,recHits);
// get CSC segment collection
Handle<CSCSegmentCollection> cscSegments;
event.getByLabel(cscSegTag_, cscSegments);
doOccupancies(strips,wires,recHits,cscSegments,clcts);
doStripDigis(strips);
doWireDigis(wires);
doRecHits(recHits,strips,cscGeom);
doSegments(cscSegments,cscGeom);
doResolution(cscSegments,cscGeom);
doPedestalNoise(strips);
doEfficiencies(wires,strips, recHits, cscSegments,cscGeom);
doBXMonitor(alcts, clcts, event, eventSetup);
}
| void CSCOfflineMonitor::applyCSClabels | ( | MonitorElement * | meHisto, |
| LabelType | t, | ||
| AxisType | a | ||
| ) | [private] |
Definition at line 1918 of file CSCOfflineMonitor.cc.
References NULL, MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), and SMALL.
{
if (me != NULL)
{
me->setAxisTitle("Chamber #");
if (t == EXTENDED)
{
me->setBinLabel(1,"ME -4/2",a);
me->setBinLabel(2,"ME -4/1",a);
me->setBinLabel(3,"ME -3/2",a);
me->setBinLabel(4,"ME -3/1",a);
me->setBinLabel(5,"ME -2/2",a);
me->setBinLabel(6,"ME -2/1",a);
me->setBinLabel(7,"ME -1/3",a);
me->setBinLabel(8,"ME -1/2",a);
me->setBinLabel(9,"ME -1/1b",a);
me->setBinLabel(10,"ME -1/1a",a);
me->setBinLabel(11,"ME +1/1a",a);
me->setBinLabel(12,"ME +1/1b",a);
me->setBinLabel(13,"ME +1/2",a);
me->setBinLabel(14,"ME +1/3",a);
me->setBinLabel(15,"ME +2/1",a);
me->setBinLabel(16,"ME +2/2",a);
me->setBinLabel(17,"ME +3/1",a);
me->setBinLabel(18,"ME +3/2",a);
me->setBinLabel(19,"ME +4/1",a);
me->setBinLabel(20,"ME +4/2",a);
}
else if (t == SMALL)
{
me->setBinLabel(1,"ME -4/1",a);
me->setBinLabel(2,"ME -3/2",a);
me->setBinLabel(3,"ME -3/1",a);
me->setBinLabel(4,"ME -2/2",a);
me->setBinLabel(5,"ME -2/1",a);
me->setBinLabel(6,"ME -1/3",a);
me->setBinLabel(7,"ME -1/2",a);
me->setBinLabel(8,"ME -1/1b",a);
me->setBinLabel(9,"ME -1/1a",a);
me->setBinLabel(10,"ME +1/1a",a);
me->setBinLabel(11,"ME +1/1b",a);
me->setBinLabel(12,"ME +1/2",a);
me->setBinLabel(13,"ME +1/3",a);
me->setBinLabel(14,"ME +2/1",a);
me->setBinLabel(15,"ME +2/2",a);
me->setBinLabel(16,"ME +3/1",a);
me->setBinLabel(17,"ME +3/2",a);
me->setBinLabel(18,"ME +4/1",a);
}
}
}
| void CSCOfflineMonitor::beginJob | ( | void | ) | [virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 33 of file CSCOfflineMonitor.cc.
References cppFunctionSkipper::operator, SMALL, and X.
{
dbe = Service<DQMStore>().operator->();
// Occupancies
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/Occupancy");
hCSCOccupancy = dbe->book1D("hCSCOccupancy","overall CSC occupancy",13,-0.5,12.5);
hCSCOccupancy->setBinLabel(2,"Total Events");
hCSCOccupancy->setBinLabel(4,"# Events with Wires");
hCSCOccupancy->setBinLabel(6,"# Events with Strips");
hCSCOccupancy->setBinLabel(8,"# Events with Wires&Strips");
hCSCOccupancy->setBinLabel(10,"# Events with Rechits");
hCSCOccupancy->setBinLabel(12,"# Events with Segments");
hOWiresAndCLCT = dbe->book2D("hOWiresAndCLCT","Wire and CLCT Digi Occupancy ",36,0.5,36.5,20,0.5,20.5);
hOWires = dbe->book2D("hOWires","Wire Digi Occupancy",36,0.5,36.5,20,0.5,20.5);
hOWireSerial = dbe->book1D("hOWireSerial","Wire Occupancy by Chamber Serial",601,-0.5,600.5);
hOWireSerial->setAxisTitle("Chamber Serial Number");
hOStrips = dbe->book2D("hOStrips","Strip Digi Occupancy",36,0.5,36.5,20,0.5,20.5);
hOStripSerial = dbe->book1D("hOStripSerial","Strip Occupancy by Chamber Serial",601,-0.5,600.5);
hOStripSerial->setAxisTitle("Chamber Serial Number");
hOStripsAndWiresAndCLCT = dbe->book2D("hOStripsAndWiresAndCLCT","Strip And Wire And CLCT Digi Occupancy",36,0.5,36.5,20,0.5,20.5);
hOStripsAndWiresAndCLCT->setAxisTitle("Chamber #");
hORecHits = dbe->book2D("hORecHits","RecHit Occupancy",36,0.5,36.5,20,0.5,20.5);
hORecHitsSerial = dbe->book1D("hORecHitSerial","RecHit Occupancy by Chamber Serial",601,-0.5,600.5);
hORecHitsSerial->setAxisTitle("Chamber Serial Number");
hOSegments = dbe->book2D("hOSegments","Segment Occupancy",36,0.5,36.5,20,0.5,20.5);
hOSegmentsSerial = dbe->book1D("hOSegmentSerial","Segment Occupancy by Chamber Serial",601,-0.5,600.5);
hOSegmentsSerial->setAxisTitle("Chamber Serial Number");
// wire digis
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/Digis");
hWirenGroupsTotal = dbe->book1D("hWirenGroupsTotal","Fired Wires per Event; # Wiregroups Fired",61,-0.5,60.5);
hWireTBin.push_back(dbe->book1D("hWireTBin_m42","Wire TBin Fired (ME -4/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m41","Wire TBin Fired (ME -4/1); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m32","Wire TBin Fired (ME -3/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m31","Wire TBin Fired (ME -3/1); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m22","Wire TBin Fired (ME -2/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m21","Wire TBin Fired (ME -2/1); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m11a","Wire TBin Fired (ME -1/1a); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m13","Wire TBin Fired (ME -1/3); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m12","Wire TBin Fired (ME -1/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_m11b","Wire TBin Fired (ME -1/1b); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p11b","Wire TBin Fired (ME +1/1b); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p12","Wire TBin Fired (ME +1/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p13","Wire TBin Fired (ME +1/3); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p11a","Wire TBin Fired (ME +1/1a); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p21","Wire TBin Fired (ME +2/1); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p22","Wire TBin Fired (ME +2/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p31","Wire TBin Fired (ME +3/1); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p32","Wire TBin Fired (ME +3/2); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p41","Wire TBin Fired (ME +4/1); Time Bin (25ns)",17,-0.5,16.5));
hWireTBin.push_back(dbe->book1D("hWireTBin_p42","Wire TBin Fired (ME +4/2); Time Bin (25ns)",17,-0.5,16.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m42","Wiregroup Number Fired (ME -4/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m41","Wiregroup Number Fired (ME -4/1); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m32","Wiregroup Number Fired (ME -3/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m31","Wiregroup Number Fired (ME -3/1); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m22","Wiregroup Number Fired (ME -2/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m21","Wiregroup Number Fired (ME -2/1); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m11a","Wiregroup Number Fired (ME -1/1a); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m13","Wiregroup Number Fired (ME -1/3); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m12","Wiregroup Number Fired (ME -1/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_m11b","Wiregroup Number Fired (ME -1/1b); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p11b","Wiregroup Number Fired (ME +1/1b); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p12","Wiregroup Number Fired (ME +1/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p13","Wiregroup Number Fired (ME +1/3); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p11a","Wiregroup Number Fired (ME +1/1a); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p21","Wiregroup Number Fired (ME +2/1); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p22","Wiregroup Number Fired (ME +2/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p31","Wiregroup Number Fired (ME +3/1); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p32","Wiregroup Number Fired (ME +3/2); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p41","Wiregroup Number Fired (ME +4/1); Wiregroup #",113,-0.5,112.5));
hWireNumber.push_back(dbe->book1D("hWireNumber_p42","Wiregroup Number Fired (ME +4/2); Wiregroup #",113,-0.5,112.5));
// strip digis
hStripNFired = dbe->book1D("hStripNFired","Fired Strips per Event; # Strips Fired (above 13 ADC)",101,-0.5,100.5);
hStripNumber.push_back(dbe->book1D("hStripNumber_m42","Strip Number Fired (ME -4/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m41","Strip Number Fired (ME -4/1); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m32","Strip Number Fired (ME -3/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m31","Strip Number Fired (ME -3/1); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m22","Strip Number Fired (ME -2/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m21","Strip Number Fired (ME -2/1); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m11a","Strip Number Fired (ME -1/1a); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m13","Strip Number Fired (ME -1/3); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m12","Strip Number Fired (ME -1/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_m11b","Strip Number Fired (ME -1/1b); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p11b","Strip Number Fired (ME +1/1b); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p12","Strip Number Fired (ME +1/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p13","Strip Number Fired (ME +1/3); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p11a","Strip Number Fired (ME +1/1a); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p21","Strip Number Fired (ME +2/1); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p22","Strip Number Fired (ME +2/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p31","Strip Number Fired (ME +3/1); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p32","Strip Number Fired (ME +3/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p41","Strip Number Fired (ME +4/1); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
hStripNumber.push_back(dbe->book1D("hStripNumber_p42","Stripgroup Number Fired (ME +4/2); Strip # Fired (above 13 ADC)",81,-0.5,80.5));
//Pedestal Noise Plots
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/PedestalNoise");
hStripPed.push_back(dbe->book1D("hStripPedMEm42","Pedestal Noise Distribution Chamber ME -4/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm41","Pedestal Noise Distribution Chamber ME -4/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm32","Pedestal Noise Distribution Chamber ME -3/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm31","Pedestal Noise Distribution Chamber ME -3/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm22","Pedestal Noise Distribution Chamber ME -2/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm21","Pedestal Noise Distribution Chamber ME -2/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm11a","Pedestal Noise Distribution Chamber ME -1/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm13","Pedestal Noise Distribution Chamber ME -1/3; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm12","Pedestal Noise Distribution Chamber ME -1/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEm11b","Pedestal Noise Distribution Chamber ME -1/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp11b","Pedestal Noise Distribution Chamber ME +1/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp12","Pedestal Noise Distribution Chamber ME +1/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp13","Pedestal Noise Distribution Chamber ME +1/3; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp11a","Pedestal Noise Distribution Chamber ME +1/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp21","Pedestal Noise Distribution Chamber ME +2/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp22","Pedestal Noise Distribution Chamber ME +2/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp31","Pedestal Noise Distribution Chamber ME +3/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp32","Pedestal Noise Distribution Chamber ME +3/2; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp41","Pedestal Noise Distribution Chamber ME +4/1; ADC Counts",50,-25.,25.));
hStripPed.push_back(dbe->book1D("hStripPedMEp42","Pedestal Noise Distribution Chamber ME +4/2; ADC Counts",50,-25.,25.));
// recHits
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/recHits");
hRHnrechits = dbe->book1D("hRHnrechits","recHits per Event (all chambers); # of RecHits",50,0,50);
hRHGlobal.push_back(dbe->book2D("hRHGlobalp1","recHit global X,Y station +1; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalp2","recHit global X,Y station +2; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalp3","recHit global X,Y station +3; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalp4","recHit global X,Y station +4; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalm1","recHit global X,Y station -1; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalm2","recHit global X,Y station -2; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalm3","recHit global X,Y station -3; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHGlobal.push_back(dbe->book2D("hRHGlobalm4","recHit global X,Y station -4; Global X (cm); Global Y (cm)",100,-800.,800.,100,-800.,800.));
hRHSumQ.push_back(dbe->book1D("hRHSumQm42","Sum 3x3 recHit Charge (ME -4/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm41","Sum 3x3 recHit Charge (ME -4/1); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm32","Sum 3x3 recHit Charge (ME -3/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm31","Sum 3x3 recHit Charge (ME -3/1); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm22","Sum 3x3 recHit Charge (ME -2/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm21","Sum 3x3 recHit Charge (ME -2/1); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm11a","Sum 3x3 recHit Charge (ME -1/1a); ADC counts",100,0,4000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm13","Sum 3x3 recHit Charge (ME -1/3); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm12","Sum 3x3 recHit Charge (ME -1/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQm11b","Sum 3x3 recHit Charge (ME -1/1b); ADC counts",100,0,4000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp11b","Sum 3x3 recHit Charge (ME +1/1b); ADC counts",100,0,4000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp12","Sum 3x3 recHit Charge (ME +1/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp13","Sum 3x3 recHit Charge (ME +1/3); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp11a","Sum 3x3 recHit Charge (ME +1/1a); ADC counts",100,0,4000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp21","Sum 3x3 recHit Charge (ME +2/1); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp22","Sum 3x3 recHit Charge (ME +2/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp31","Sum 3x3 recHit Charge (ME +3/1); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp32","Sum 3x3 recHit Charge (ME +3/2); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp41","Sum 3x3 recHit Charge (ME +4/1); ADC counts",100,0,2000));
hRHSumQ.push_back(dbe->book1D("hRHSumQp42","Sum 3x3 recHit Charge (ME +4/2); ADC counts",100,0,2000));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm42","Charge Ratio (Ql+Qr)/Qt (ME -4/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm41","Charge Ratio (Ql+Qr)/Qt (ME -4/1); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm32","Charge Ratio (Ql+Qr)/Qt (ME -3/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm31","Charge Ratio (Ql+Qr)/Qt (ME -3/1); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm22","Charge Ratio (Ql+Qr)/Qt (ME -2/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm21","Charge Ratio (Ql+Qr)/Qt (ME -2/1); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm11a","Charge Ratio (Ql+Qr)/Qt (ME -1/1a); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm13","Charge Ratio (Ql+Qr)/Qt (ME -1/3); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm12","Charge Ratio (Ql+Qr)/Qt (ME -1/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQm11b","Charge Ratio (Ql+Qr)/Qt (ME -1/1b); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp11b","Charge Ratio (Ql+Qr)/Qt (ME +1/1b); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp12","Charge Ratio (Ql+Qr)/Qt (ME +1/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp13","Charge Ratio (Ql+Qr)/Qt (ME +1/3); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp11a","Charge Ratio (Ql+Qr)/Qt (ME +1/1a); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp21","Charge Ratio (Ql+Qr)/Qt (ME +2/1); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp22","Charge Ratio (Ql+Qr)/Qt (ME +2/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp31","Charge Ratio (Ql+Qr)/Qt (ME +3/1); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp32","Charge Ratio (Ql+Qr)/Qt (ME +3/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp41","Charge Ratio (Ql+Qr)/Qt (ME +4/1); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHRatioQ.push_back(dbe->book1D("hRHRatioQp42","Charge Ratio (Ql+Qr)/Qt (ME +4/2); (Ql+Qr)/Qt",100,-0.1,1.1));
hRHTiming.push_back(dbe->book1D("hRHTimingm42","recHit Time (ME -4/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm41","recHit Time (ME -4/1); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm32","recHit Time (ME -3/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm31","recHit Time (ME -3/1); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm22","recHit Time (ME -2/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm21","recHit Time (ME -2/1); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm11a","recHit Time (ME -1/1a); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm13","recHit Time (ME -1/3); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm12","recHit Time (ME -1/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingm11b","recHit Time (ME -1/1b); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp11b","recHit Time (ME +1/1b); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp12","recHit Time (ME +1/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp13","recHit Time (ME +1/3); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp11a","recHit Time (ME +1/1a); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp21","recHit Time (ME +2/1); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp22","recHit Time (ME +2/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp31","recHit Time (ME +3/1); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp32","recHit Time (ME +3/2); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp41","recHit Time (ME +4/1); ns",200,-500.,500.));
hRHTiming.push_back(dbe->book1D("hRHTimingp42","recHit Time (ME +4/2); ns",200,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem42","Anode recHit Time (ME -4/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem41","Anode recHit Time (ME -4/1); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem32","Anode recHit Time (ME -3/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem31","Anode recHit Time (ME -3/1); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem22","Anode recHit Time (ME -2/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem21","Anode recHit Time (ME -2/1); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem11a","Anode recHit Time (ME -1/1a); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem13","Anode recHit Time (ME -1/3); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem12","Anode recHit Time (ME -1/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodem11b","Anode recHit Time (ME -1/1b); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep11b","Anode recHit Time (ME +1/1b); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep12","Anode recHit Time (ME +1/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep13","Anode recHit Time (ME +1/3); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep11a","Anode recHit Time (ME +1/1a); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep21","Anode recHit Time (ME +2/1); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep22","Anode recHit Time (ME +2/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep31","Anode recHit Time (ME +3/1); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep32","Anode recHit Time (ME +3/2); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep41","Anode recHit Time (ME +4/1); ns",80,-500.,500.));
hRHTimingAnode.push_back(dbe->book1D("hRHTimingAnodep42","Anode recHit Time (ME +4/2); ns",80,-500.,500.));
hRHstpos.push_back(dbe->book1D("hRHstposm42","Reconstructed Position on Strip (ME -4/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm41","Reconstructed Position on Strip (ME -4/1); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm32","Reconstructed Position on Strip (ME -3/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm31","Reconstructed Position on Strip (ME -3/1); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm22","Reconstructed Position on Strip (ME -2/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm21","Reconstructed Position on Strip (ME -2/1); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm11a","Reconstructed Position on Strip (ME -1/1a); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm13","Reconstructed Position on Strip (ME -1/3); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm12","Reconstructed Position on Strip (ME -1/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposm11b","Reconstructed Position on Strip (ME -1/1b); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp11b","Reconstructed Position on Strip (ME +1/1b); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp12","Reconstructed Position on Strip (ME +1/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp13","Reconstructed Position on Strip (ME +1/3); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp11a","Reconstructed Position on Strip (ME +1/1a); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp21","Reconstructed Position on Strip (ME +2/1); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp22","Reconstructed Position on Strip (ME +2/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp31","Reconstructed Position on Strip (ME +3/1); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp32","Reconstructed Position on Strip (ME +3/2); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp41","Reconstructed Position on Strip (ME +4/1); Strip Widths",120,-0.6,0.6));
hRHstpos.push_back(dbe->book1D("hRHstposp42","Reconstructed Position on Strip (ME +4/2); Strip Widths",120,-0.6,0.6));
hRHsterr.push_back(dbe->book1D("hRHsterrm42","Estimated Error on Strip Measurement (ME -4/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm41","Estimated Error on Strip Measurement (ME -4/1); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm32","Estimated Error on Strip Measurement (ME -3/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm31","Estimated Error on Strip Measurement (ME -3/1); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm22","Estimated Error on Strip Measurement (ME -2/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm21","Estimated Error on Strip Measurement (ME -2/1); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm11a","Estimated Error on Strip Measurement (ME -1/1a); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm13","Estimated Error on Strip Measurement (ME -1/3); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm12","Estimated Error on Strip Measurement (ME -1/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrm11b","Estimated Error on Strip Measurement (ME -1/1b); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp11b","Estimated Error on Strip Measurement (ME +1/1b); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp12","Estimated Error on Strip Measurement (ME +1/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp13","Estimated Error on Strip Measurement (ME +1/3); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp11a","Estimated Error on Strip Measurement (ME +1/1a); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp21","Estimated Error on Strip Measurement (ME +2/1); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp22","Estimated Error on Strip Measurement (ME +2/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp31","Estimated Error on Strip Measurement (ME +3/1); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp32","Estimated Error on Strip Measurement (ME +3/2); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp41","Estimated Error on Strip Measurement (ME +4/1); Strip Widths",75,-0.01,0.24));
hRHsterr.push_back(dbe->book1D("hRHsterrp42","Estimated Error on Strip Measurement (ME +4/2); Strip Widths",75,-0.01,0.24));
// segments
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/Segments");
hSnSegments = dbe->book1D("hSnSegments","Number of Segments per Event; # of Segments",11,-0.5,10.5);
hSnhitsAll = dbe->book1D("hSnhits","N hits on Segments; # of hits",8,-0.5,7.5);
hSnhits.push_back(dbe->book1D("hSnhitsm42","# of hits on Segments (ME -4/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm41","# of hits on Segments (ME -4/1); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm32","# of hits on Segments (ME -3/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm31","# of hits on Segments (ME -3/1); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm22","# of hits on Segments (ME -2/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm21","# of hits on Segments (ME -2/1); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm11a","# of hits on Segments (ME -1/1a); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm13","# of hits on Segments (ME -1/3); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm12","# of hits on Segments (ME -1/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsm11b","# of hits on Segments (ME -1/1b); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp11b","# of hits on Segments (ME +1/1b); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp12","# of hits on Segments (ME +1/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp13","# of hits on Segments (ME +1/3); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp11a","# of hits on Segments (ME +1/1a); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp21","# of hits on Segments (ME +2/1); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp22","# of hits on Segments (ME +2/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp31","# of hits on Segments (ME +3/1); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp32","# of hits on Segments (ME +3/2); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp41","# of hits on Segments (ME +4/1); # of hits",8,-0.5,7.5));
hSnhits.push_back(dbe->book1D("hSnhitsp42","# of hits on Segments (ME +4/2); # of hits",8,-0.5,7.5));
hSChiSqAll = dbe->book1D("hSChiSq","Segment Normalized Chi2; Chi2/ndof",110,-0.05,10.5);
hSChiSq.push_back(dbe->book1D("hSChiSqm42","Segment Normalized Chi2 (ME -4/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm41","Segment Normalized Chi2 (ME -4/1); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm32","Segment Normalized Chi2 (ME -3/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm31","Segment Normalized Chi2 (ME -3/1); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm22","Segment Normalized Chi2 (ME -2/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm21","Segment Normalized Chi2 (ME -2/1); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm11a","Segment Normalized Chi2 (ME -1/1a); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm13","Segment Normalized Chi2 (ME -1/3); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm12","Segment Normalized Chi2 (ME -1/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqm11b","Segment Normalized Chi2 (ME -1/1b); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp11b","Segment Normalized Chi2 (ME +1/1b); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp12","Segment Normalized Chi2 (ME +1/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp13","Segment Normalized Chi2 (ME +1/3); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp11a","Segment Normalized Chi2 (ME +1/1a); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp21","Segment Normalized Chi2 (ME +2/1); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp22","Segment Normalized Chi2 (ME +2/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp31","Segment Normalized Chi2 (ME +3/1); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp32","Segment Normalized Chi2 (ME +3/2); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp41","Segment Normalized Chi2 (ME +4/1); Chi2/ndof",110,-0.05,10.5));
hSChiSq.push_back(dbe->book1D("hSChiSqp42","Segment Normalized Chi2 (ME +4/2); Chi2/ndof",110,-0.05,10.5));
hSChiSqProbAll = dbe->book1D("hSChiSqProb","Segment chi2 Probability; Probability",110,-0.05,1.05);
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm42","Segment chi2 Probability (ME -4/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm41","Segment chi2 Probability (ME -4/1); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm32","Segment chi2 Probability (ME -3/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm31","Segment chi2 Probability (ME -3/1); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm22","Segment chi2 Probability (ME -2/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm21","Segment chi2 Probability (ME -2/1); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm11a","Segment chi2 Probability (ME -1/1a); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm13","Segment chi2 Probability (ME -1/3); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm12","Segment chi2 Probability (ME -1/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbm11b","Segment chi2 Probability (ME -1/1b); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp11b","Segment chi2 Probability (ME +1/1b); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp12","Segment chi2 Probability (ME +1/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp13","Segment chi2 Probability (ME +1/3); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp11a","Segment chi2 Probability (ME +1/1a); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp21","Segment chi2 Probability (ME +2/1); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp22","Segment chi2 Probability (ME +2/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp31","Segment chi2 Probability (ME +3/1); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp32","Segment chi2 Probability (ME +3/2); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp41","Segment chi2 Probability (ME +4/1); Probability",110,-0.05,1.05));
hSChiSqProb.push_back(dbe->book1D("hSChiSqProbp42","Segment chi2 Probability (ME +4/2); Probability",110,-0.05,1.05));
hSGlobalTheta = dbe->book1D("hSGlobalTheta","Segment Direction (Global Theta); Global Theta (radians)",136,-0.1,3.3);
hSGlobalPhi = dbe->book1D("hSGlobalPhi","Segment Direction (Global Phi); Global Phi (radians)", 128,-3.2,3.2);
hSTimeCathode = dbe->book1D("hSTimeCathode", "Cathode Only Segment Time [ns]",200,-200,200);
hSTimeCombined = dbe->book1D("hSTimeCombined", "Segment Time (anode+cathode times) [ns]",200,-200,200);
hSTimeVsZ = dbe->book2D("hSTimeVsZ","Segment Time vs. Z; [ns] vs. [cm]",200,-1200,1200,200,-200,200);
hSTimeVsTOF = dbe->book2D("hSTimeVsTOF","Segment Time vs. Distance from IP; [ns] vs. [cm]",180,500,1400, 200,-200,200);
// Resolution
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/Resolution");
hSResid.push_back(dbe->book1D("hSResidm42","Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm41","Fitted Position on Strip - Reconstructed for Layer 3 (ME -4/1); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm32","Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm31","Fitted Position on Strip - Reconstructed for Layer 3 (ME -3/1); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm22","Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm21","Fitted Position on Strip - Reconstructed for Layer 3 (ME -2/1); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm11a","Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1a); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm13","Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/3); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm12","Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidm11b","Fitted Position on Strip - Reconstructed for Layer 3 (ME -1/1b); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp11b","Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1b); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp12","Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp13","Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/3); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp11a","Fitted Position on Strip - Reconstructed for Layer 3 (ME +1/1a); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp21","Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/1); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp22","Fitted Position on Strip - Reconstructed for Layer 3 (ME +2/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp31","Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/1); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp32","Fitted Position on Strip - Reconstructed for Layer 3 (ME +3/2); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp41","Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/1); Strip Widths",100,-0.5,0.5));
hSResid.push_back(dbe->book1D("hSResidp42","Fitted Position on Strip - Reconstructed for Layer 3 (ME +4/2); Strip Widths",100,-0.5,0.5));
// Efficiency
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/Efficiency");
hSSTE = dbe->book1D("hSSTE","hSSTE",40,0.5,40.5);
hRHSTE = dbe->book1D("hRHSTE","hRHSTE",40,0.5,40.5);
hSEff = dbe->book1D("hSEff","Segment Efficiency",20,0.5,20.5);
hRHEff = dbe->book1D("hRHEff","recHit Efficiency",20,0.5,20.5);
hSSTE2 = dbe->book2D("hSSTE2","hSSTE2",36,0.5,36.5, 18, 0.5, 18.5);
hRHSTE2 = dbe->book2D("hRHSTE2","hRHSTE2",36,0.5,36.5, 18, 0.5, 18.5);
hStripSTE2 = dbe->book2D("hStripSTE2","hStripSTE2",36,0.5,36.5, 18, 0.5, 18.5);
hWireSTE2 = dbe->book2D("hWireSTE2","hWireSTE2",36,0.5,36.5, 18, 0.5, 18.5);
hEffDenominator = dbe->book2D("hEffDenominator","hEffDenominator",36,0.5,36.5, 18, 0.5, 18.5);
hSEff2 = dbe->book2D("hSEff2","Segment Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
hRHEff2 = dbe->book2D("hRHEff2","recHit Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
hStripReadoutEff2 = dbe->book2D("hStripReadoutEff2","strip readout ratio [(strip+clct+wires)/(clct+wires)] 2D",36,0.5,36.5, 20, 0.5, 20.5);
hStripReadoutEff2->setAxisTitle("Chamber #");
hStripEff2 = dbe->book2D("hStripEff2","strip Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
hWireEff2 = dbe->book2D("hWireEff2","wire Efficiency 2D",36,0.5,36.5, 18, 0.5, 18.5);
hSensitiveAreaEvt = dbe->book2D("hSensitiveAreaEvt","Events Passing Selection for Efficiency",36,0.5,36.5, 18, 0.5, 18.5);
// BX Monitor for trigger synchronization
dbe->setCurrentFolder("CSC/CSCOfflineMonitor/BXMonitor");
hALCTgetBX = dbe->book1D("hALCTgetBX","ALCT position in ALCT-L1A match window [BX]",7,-0.5,6.5);
hALCTgetBXChamberMeans = dbe->book1D("hALCTgetBXChamberMeans","Chamber Mean ALCT position in ALCT-L1A match window [BX]",60,0,6);
hALCTgetBXSerial = dbe->book2D("hALCTgetBXSerial","ALCT position in ALCT-L1A match window [BX]",601,-0.5,600.5,7,-0.5,6.5);
hALCTgetBXSerial->setAxisTitle("Chamber Serial Number");
hALCTgetBX2DNumerator = dbe->book2D("hALCTgetBX2DNumerator","ALCT position in ALCT-L1A match window [BX] (sum)",36,0.5,36.5,20,0.5,20.5);
hALCTgetBX2DMeans = dbe->book2D("hALCTgetBX2DMeans","ALCT position in ALCT-L1A match window [BX]",36,0.5,36.5,20,0.5,20.5);
hALCTgetBX2Denominator = dbe->book2D("hALCTgetBX2Denominator","Number of ALCT Digis checked",36,0.5,36.5,20,0.5,20.5);
hALCTgetBX2DMeans->setAxisTitle("Chamber #");
hALCTgetBX2Denominator->setAxisTitle("Chamber #");
hALCTMatch = dbe->book1D("hALCTMatch","ALCT position in ALCT-CLCT match window [BX]",7,-0.5,6.5);
hALCTMatchChamberMeans = dbe->book1D("hALCTMatchChamberMeans","Chamber Mean ALCT position in ALCT-CLCT match window [BX]",60,0,6);
hALCTMatchSerial = dbe->book2D("hALCTMatchSerial","ALCT position in ALCT-CLCT match window [BX]",601,-0.5,600.5,7,-0.5,6.5);
hALCTMatchSerial->setAxisTitle("Chamber Serial Number");
hALCTMatch2DNumerator = dbe->book2D("hALCTMatch2DNumerator","ALCT position in ALCT-CLCT match window [BX] (sum)",36,0.5,36.5,20,0.5,20.5);
hALCTMatch2DMeans = dbe->book2D("hALCTMatch2DMeans","ALCT position in ALCT-CLCT match window [BX]",36,0.5,36.5,20,0.5,20.5);
hALCTMatch2Denominator = dbe->book2D("hALCTMatch2Denominator","Number of ALCT-CLCT matches checked",36,0.5,36.5,20,0.5,20.5);
hALCTMatch2DMeans->setAxisTitle("Chamber #");
hALCTMatch2Denominator->setAxisTitle("Chamber #");
hCLCTL1A = dbe->book1D("hCLCTL1A","L1A - CLCTpreTrigger at TMB [BX]",10,149.5,159.5);
hCLCTL1AChamberMeans = dbe->book1D("hCLCTL1AChamberMeans","Chamber Mean L1A - CLCTpreTrigger at TMB [BX]",90,150,159);
hCLCTL1ASerial = dbe->book2D("hCLCTL1ASerial","L1A - CLCTpreTrigger at TMB [BX]",601,-0.5,600.5,10,149.5,159.5);
hCLCTL1ASerial->setAxisTitle("Chamber Serial Number");
hCLCTL1A2DNumerator = dbe->book2D("hCLCTL1A2DNumerator","L1A - CLCTpreTrigger at TMB [BX] (sum)",36,0.5,36.5,20,0.5,20.5);
hCLCTL1A2DMeans = dbe->book2D("hCLCTL1A2DMeans","L1A - CLCTpreTrigger at TMB [BX]",36,0.5,36.5,20,0.5,20.5);
hCLCTL1A2Denominator = dbe->book2D("hCLCTL1A2Denominator","Number of TMB CLCTs checked",36,0.5,36.5,20,0.5,20.5);
// Set all Labels
applyCSClabels(hOWiresAndCLCT, EXTENDED, Y);
applyCSClabels(hOWires, EXTENDED, Y);
applyCSClabels(hOStrips, EXTENDED, Y);
applyCSClabels(hOStripsAndWiresAndCLCT, EXTENDED, Y);
applyCSClabels(hORecHits, EXTENDED, Y);
applyCSClabels(hOSegments, EXTENDED, Y);
applyCSClabels(hSEff, EXTENDED, X);
applyCSClabels(hRHEff, EXTENDED, X);
applyCSClabels(hSEff2, SMALL, Y);
applyCSClabels(hSSTE2, SMALL, Y);
applyCSClabels(hEffDenominator, SMALL, Y);
applyCSClabels(hRHEff2, SMALL, Y);
applyCSClabels(hRHSTE2, SMALL, Y);
applyCSClabels(hStripReadoutEff2, EXTENDED, Y);
applyCSClabels(hStripEff2, SMALL, Y);
applyCSClabels(hStripSTE2, SMALL, Y);
applyCSClabels(hWireEff2, SMALL, Y);
applyCSClabels(hWireSTE2, SMALL, Y);
applyCSClabels(hSensitiveAreaEvt, SMALL, Y);
applyCSClabels(hALCTgetBX2DMeans, EXTENDED, Y);
applyCSClabels(hALCTgetBX2Denominator, EXTENDED, Y);
applyCSClabels(hALCTMatch2DMeans, EXTENDED, Y);
applyCSClabels(hALCTMatch2Denominator, EXTENDED, Y);
applyCSClabels(hCLCTL1A2DMeans, EXTENDED, Y);
applyCSClabels(hCLCTL1A2Denominator,EXTENDED, Y);
}
| virtual void CSCOfflineMonitor::beginRun | ( | edm::Run const & | , |
| edm::EventSetup const & | |||
| ) | [inline, virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 85 of file CSCOfflineMonitor.h.
References finalizedHistograms_.
{finalizedHistograms_ = false;};
| int CSCOfflineMonitor::chamberSerial | ( | CSCDetId | id | ) | [private] |
Definition at line 1898 of file CSCOfflineMonitor.cc.
{
int st = id.station();
int ri = id.ring();
int ch = id.chamber();
int ec = id.endcap();
int kSerial = ch;
if (st == 1 && ri == 1) kSerial = ch;
if (st == 1 && ri == 2) kSerial = ch + 36;
if (st == 1 && ri == 3) kSerial = ch + 72;
if (st == 1 && ri == 4) kSerial = ch;
if (st == 2 && ri == 1) kSerial = ch + 108;
if (st == 2 && ri == 2) kSerial = ch + 126;
if (st == 3 && ri == 1) kSerial = ch + 162;
if (st == 3 && ri == 2) kSerial = ch + 180;
if (st == 4 && ri == 1) kSerial = ch + 216;
if (st == 4 && ri == 2) kSerial = ch + 234; // one day...
if (ec == 2) kSerial = kSerial + 300;
return kSerial;
}
| void 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 1560 of file CSCOfflineMonitor.cc.
References CSCTMBHeader::ALCTMatchTime(), CSCTMBHeader::BXNCount(), CSCDetId::chamber(), CastorDataFrameFilter_impl::check(), CSCDCCExaminer::check(), CSCDCCExaminer::crcALCT(), CSCDCCExaminer::crcCFEB(), CSCDCCExaminer::crcTMB(), CSCDetId, data, FEDRawData::data(), CSCDCCEventData::dduData(), CSCCrateMap::detId(), CSCDetId::endcap(), CSCDCCExaminer::errors(), edm::EventSetup::get(), edm::Event::getByLabel(), j, LogTrace, FEDNumbering::MAXCSCFEDID, FEDNumbering::MINCSCFEDID, NULL, CSCDCCExaminer::output1(), CSCDCCExaminer::output2(), edm::ESHandle< T >::product(), lumiPlot::rawdata, DetId::rawId(), CSCDetId::ring(), CSCDCCExaminer::setMask(), FEDRawData::size(), and CSCDetId::station().
{
// Loop over ALCTDigis
for (CSCALCTDigiCollection::DigiRangeIterator j=alcts->begin(); j!=alcts->end(); j++) {
const CSCDetId& idALCT = (*j).first;
const CSCALCTDigiCollection::Range& range =(*j).second;
for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt!=range.second; ++digiIt){
// Valid digi in the chamber (or in neighbouring chamber)
if((*digiIt).isValid()){
hALCTgetBX->Fill((*digiIt).getBX());
hALCTgetBXSerial->Fill(chamberSerial(idALCT),(*digiIt).getBX());
hALCTgetBX2DNumerator->Fill(idALCT.chamber(),typeIndex(idALCT,2),(*digiIt).getBX());
hALCTgetBX2Denominator->Fill(idALCT.chamber(),typeIndex(idALCT,2));
}
}
}// end ALCT Digi loop
// Loop over raw data to get TMBHeader information
// Taking code from EventFilter/CSCRawToDigis/CSCDCCUnpacker.cc
edm::ESHandle<CSCCrateMap> hcrate;
eventSetup.get<CSCCrateMapRcd>().get(hcrate);
const CSCCrateMap* pcrate = hcrate.product();
// Try to get raw data
edm::Handle<FEDRawDataCollection> rawdata;
if (!(event.getByLabel(FEDRawDataCollectionTag_,rawdata)) ){
edm::LogWarning("CSCOfflineMonitor")<<" raw data with label "<<FEDRawDataCollectionTag_ <<" not available";
return;
}
bool goodEvent = false;
unsigned long dccBinCheckMask = 0x06080016;
unsigned int examinerMask = 0x1FEBF3F6;
unsigned int errorMask = 0x0;
for (int id=FEDNumbering::MINCSCFEDID;
id<=FEDNumbering::MAXCSCFEDID; ++id) { // loop over DCCs
const FEDRawData& fedData = rawdata->FEDData(id);
unsigned long length = fedData.size();
if (length>=32){
CSCDCCExaminer* examiner = NULL;
std::stringstream examiner_out, examiner_err;
goodEvent = true;
examiner = new CSCDCCExaminer();
examiner->output1().redirect(examiner_out);
examiner->output2().redirect(examiner_err);
if( examinerMask&0x40000 ) examiner->crcCFEB(1);
if( examinerMask&0x8000 ) examiner->crcTMB (1);
if( examinerMask&0x0400 ) examiner->crcALCT(1);
examiner->output1().show();
examiner->output2().show();
examiner->setMask(examinerMask);
const short unsigned int *data = (short unsigned int *)fedData.data();
int res = examiner->check(data,long(fedData.size()/2));
if( res < 0 ) {
goodEvent=false;
}
else {
goodEvent=!(examiner->errors()&dccBinCheckMask);
}
if (goodEvent) {
CSCDCCExaminer * ptrExaminer = examiner;
CSCDCCEventData dccData((short unsigned int *) fedData.data(), ptrExaminer);
const std::vector<CSCDDUEventData> & dduData = dccData.dduData();
CSCDetId layer(1, 1, 1, 1, 1);
for (unsigned int iDDU=0; iDDU<dduData.size(); ++iDDU) { // loop over DDUs
if (dduData[iDDU].trailer().errorstat()&errorMask) {
LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! " <<
std::hex << dduData[iDDU].trailer().errorstat();
continue; // to next iteration of DDU loop
}
const std::vector<CSCEventData> & cscData = dduData[iDDU].cscData();
for (unsigned int iCSC=0; iCSC<cscData.size(); ++iCSC) { // loop over CSCs
int vmecrate = cscData[iCSC].dmbHeader()->crateID();
int dmb = cscData[iCSC].dmbHeader()->dmbID();
int icfeb = 0;
int ilayer = 0;
if ((vmecrate>=1)&&(vmecrate<=60) && (dmb>=1)&&(dmb<=10)&&(dmb!=6)) {
layer = pcrate->detId(vmecrate, dmb,icfeb,ilayer );
}
else{
LogTrace ("CSCOfflineMonitor") << " detID input out of range!!! ";
LogTrace ("CSCOfflineMonitor")
<< " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
continue; // to next iteration of iCSC loop
}
int nalct = cscData[iCSC].dmbHeader()->nalct();
bool goodALCT=false;
//if (nalct&&(cscData[iCSC].dataPresent>>6&0x1)==1) {
if (nalct&&cscData[iCSC].alctHeader()) {
if (cscData[iCSC].alctHeader()->check()){
goodALCT=true;
}
}
int nclct = cscData[iCSC].dmbHeader()->nclct();
bool goodTMB=false;
if (nclct&&cscData[iCSC].tmbData()) {
if (cscData[iCSC].tmbHeader()->check()){
if (cscData[iCSC].clctData()->check()) goodTMB=true;
}
}
if (goodTMB && goodALCT) {
const CSCTMBHeader *tmbHead = cscData[iCSC].tmbHeader();
std::vector<CSCCLCTDigi> clcts = cscData[iCSC].tmbHeader()->CLCTDigis(layer.rawId());
if (clcts.size()==0 || !(clcts[0].isValid()))
continue;
// Check if the CLCT was in ME11a (ring 4)
if(layer.station()==1 && layer.ring() ==1 && clcts[0].getKeyStrip()>128){
layer = CSCDetId(layer.endcap(),layer.station(),4, layer.chamber());
}
hALCTMatch->Fill(tmbHead->ALCTMatchTime());
hALCTMatchSerial->Fill(chamberSerial(layer),tmbHead->ALCTMatchTime());
// Only fill big 2D display if ALCTMatchTime !=6, since this bin is polluted by the CLCT only triggers
// One will have to look at the serial plots to see if the are a lot of entries here
if(tmbHead->ALCTMatchTime()!=6){
hALCTMatch2DNumerator->Fill(layer.chamber(),typeIndex(layer,2),tmbHead->ALCTMatchTime());
hALCTMatch2Denominator->Fill(layer.chamber(),typeIndex(layer,2));
}
int TMB_CLCTpre_rel_L1A = tmbHead->BXNCount()-clcts[0].getFullBX();
if (TMB_CLCTpre_rel_L1A > 3563)
TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A - 3564;
if (TMB_CLCTpre_rel_L1A < 0)
TMB_CLCTpre_rel_L1A = TMB_CLCTpre_rel_L1A + 3564;
hCLCTL1A->Fill(TMB_CLCTpre_rel_L1A);
hCLCTL1ASerial->Fill(chamberSerial(layer),TMB_CLCTpre_rel_L1A);
hCLCTL1A2DNumerator->Fill(layer.chamber(),typeIndex(layer,2),TMB_CLCTpre_rel_L1A);
hCLCTL1A2Denominator->Fill(layer.chamber(),typeIndex(layer,2));
}// end if goodTMB and goodALCT
}// end loop CSCData
}// end loop DDU
}// end if good event
if (examiner!=NULL) delete examiner;
}// end if non-zero fed data
}// end DCC loop for NON-REFERENCE
return;
}
| 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 1260 of file CSCOfflineMonitor.cc.
References newFWLiteAna::bin, CSCDetId::chamber(), CSCChamberSpecs::chamberTypeName(), CSCDetId, diffTreeTool::diff, CSCDetId::endcap(), first, CSCLayer::geometry(), CSCChamber::id(), CSCDetId::layer(), CSCChamber::layer(), TrapezoidalPlaneBounds::parameters(), CSCDetId::ring(), CSCChamber::specs(), CSCDetId::station(), dtDQMClient_cfg::threshold, GeomDet::toGlobal(), GeomDet::toLocal(), CommonMethods::weight(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().
{
bool allWires[2][4][4][36][6];
bool allStrips[2][4][4][36][6];
bool AllRecHits[2][4][4][36][6];
bool AllSegments[2][4][4][36];
//bool MultiSegments[2][4][4][36];
for(int iE = 0;iE<2;iE++){
for(int iS = 0;iS<4;iS++){
for(int iR = 0; iR<4;iR++){
for(int iC =0;iC<36;iC++){
AllSegments[iE][iS][iR][iC] = false;
//MultiSegments[iE][iS][iR][iC] = false;
for(int iL=0;iL<6;iL++){
allWires[iE][iS][iR][iC][iL] = false;
allStrips[iE][iS][iR][iC][iL] = false;
AllRecHits[iE][iS][iR][iC][iL] = false;
}
}
}
}
}
// Wires
for (CSCWireDigiCollection::DigiRangeIterator dWDiter=wires->begin(); dWDiter!=wires->end(); dWDiter++) {
CSCDetId idrec = (CSCDetId)(*dWDiter).first;
std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
for( ; wireIter != lWire; ++wireIter) {
allWires[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber() -1][idrec.layer() -1] = true;
break;
}
}
//---- STRIPS
for (CSCStripDigiCollection::DigiRangeIterator dSDiter=strips->begin(); dSDiter!=strips->end(); dSDiter++) {
CSCDetId idrec = (CSCDetId)(*dSDiter).first;
std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
for( ; stripIter != lStrip; ++stripIter) {
std::vector<int> myADCVals = stripIter->getADCCounts();
bool thisStripFired = false;
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float threshold = 13.3 ;
float diff = 0.;
for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
diff = (float)myADCVals[iCount]-thisPedestal;
if (diff > threshold) {
thisStripFired = true;
break;
}
}
if(thisStripFired){
allStrips[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber() -1][idrec.layer() -1] = true;
break;
}
}
}
// Rechits
for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
//CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
CSCDetId idrec = (CSCDetId)(*recEffIt).cscDetId();
AllRecHits[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber() -1][idrec.layer() -1] = true;
}
std::vector <uint> seg_ME2(2,0) ;
std::vector <uint> seg_ME3(2,0) ;
std::vector < pair <CSCDetId, CSCSegment> > theSegments(4);
// Segments
for(CSCSegmentCollection::const_iterator segEffIt=cscSegments->begin(); segEffIt != cscSegments->end(); segEffIt++) {
CSCDetId idseg = (CSCDetId)(*segEffIt).cscDetId();
//if(AllSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()]){
//MultiSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()] = true;
//}
AllSegments[idseg.endcap() -1][idseg.station() -1][idseg.ring() -1][idseg.chamber() -1] = true;
// "Intrinsic" efficiency measurement relies on "good" segment extrapolation - we need the pre-selection below
// station 2 "good" segment will be used for testing efficiencies in ME1 and ME3
// station 3 "good" segment will be used for testing efficiencies in ME2 and ME4
if(2==idseg.station() || 3==idseg.station()){
uint seg_tmp ;
if(2==idseg.station()){
++seg_ME2[idseg.endcap() -1];
seg_tmp = seg_ME2[idseg.endcap() -1];
}
else{
++seg_ME3[idseg.endcap() -1];
seg_tmp = seg_ME3[idseg.endcap() -1];
}
// is the segment good
if(1== seg_tmp&& 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
}
}
/*
if(2==idseg.station()){
++seg_ME2[idseg.endcap() -1];
if(1==seg_ME2[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
}
}
else if(3==idseg.station()){
++seg_ME3[idseg.endcap() -1];
if(1==seg_ME3[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
}
}
*/
}
// Simple efficiency calculations
for(int iE = 0;iE<2;iE++){
for(int iS = 0;iS<4;iS++){
for(int iR = 0; iR<4;iR++){
for(int iC =0;iC<36;iC++){
int NumberOfLayers = 0;
for(int iL=0;iL<6;iL++){
if(AllRecHits[iE][iS][iR][iC][iL]){
NumberOfLayers++;
}
}
int bin = 0;
if (iS==0) bin = iR+1+(iE*10);
else bin = (iS+1)*2 + (iR+1) + (iE*10);
if(NumberOfLayers>1){
//if(!(MultiSegments[iE][iS][iR][iC])){
if(AllSegments[iE][iS][iR][iC]){
//---- Efficient segment evenents
hSSTE->Fill(bin);
}
//---- All segment events (normalization)
hSSTE->Fill(20+bin);
//}
}
if(AllSegments[iE][iS][iR][iC]){
if(NumberOfLayers==6){
//---- Efficient rechit events
hRHSTE->Fill(bin);;
}
//---- All rechit events (normalization)
hRHSTE->Fill(20+bin);;
}
}
}
}
}
// pick a segment only if there are no others in the station
std::vector < pair <CSCDetId, CSCSegment> * > theSeg;
if(1==seg_ME2[0]) theSeg.push_back(&theSegments[0]);
if(1==seg_ME3[0]) theSeg.push_back(&theSegments[1]);
if(1==seg_ME2[1]) theSeg.push_back(&theSegments[2]);
if(1==seg_ME3[1]) theSeg.push_back(&theSegments[3]);
// Needed for plots
// at the end the chamber types will be numbered as 1 to 18
// (ME-4/1, -ME3/2, -ME3/1, ..., +ME3/1, +ME3/2, ME+4/1 )
std::map <std::string, float> chamberTypes;
chamberTypes["ME1/a"] = 0.5;
chamberTypes["ME1/b"] = 1.5;
chamberTypes["ME1/2"] = 2.5;
chamberTypes["ME1/3"] = 3.5;
chamberTypes["ME2/1"] = 4.5;
chamberTypes["ME2/2"] = 5.5;
chamberTypes["ME3/1"] = 6.5;
chamberTypes["ME3/2"] = 7.5;
chamberTypes["ME4/1"] = 8.5;
if(theSeg.size()){
std::map <int , GlobalPoint> extrapolatedPoint;
std::map <int , GlobalPoint>::iterator it;
const std::vector<CSCChamber*> ChamberContainer = cscGeom->chambers();
// Pick which chamber with which segment to test
for(unsigned int nCh=0;nCh<ChamberContainer.size();nCh++){
const CSCChamber *cscchamber = ChamberContainer[nCh];
pair <CSCDetId, CSCSegment> * thisSegment = 0;
for(uint iSeg =0;iSeg<theSeg.size();++iSeg ){
if(cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()){
if(1==cscchamber->id().station() || 3==cscchamber->id().station() ){
if(2==theSeg[iSeg]->first.station()){
thisSegment = theSeg[iSeg];
}
}
else if (2==cscchamber->id().station() || 4==cscchamber->id().station()){
if(3==theSeg[iSeg]->first.station()){
thisSegment = theSeg[iSeg];
}
}
}
}
// this chamber is to be tested with thisSegment
if(thisSegment){
CSCSegment * seg = &(thisSegment->second);
const CSCChamber *segChamber = cscGeom->chamber(thisSegment->first);
LocalPoint localCenter(0.,0.,0);
GlobalPoint cscchamberCenter = cscchamber->toGlobal(localCenter);
// try to save some time (extrapolate a segment to a certain position only once)
it = extrapolatedPoint.find(int(cscchamberCenter.z()));
if(it==extrapolatedPoint.end()){
GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
double paramaterLine = lineParametrization(segPos.z(),cscchamberCenter.z() , segDir.z());
double xExtrapolated = extrapolate1D(segPos.x(),segDir.x(), paramaterLine);
double yExtrapolated = extrapolate1D(segPos.y(),segDir.y(), paramaterLine);
GlobalPoint globP (xExtrapolated, yExtrapolated, cscchamberCenter.z());
extrapolatedPoint[int(cscchamberCenter.z())] = globP;
}
// Where does the extrapolated point lie in the (tested) chamber local frame? Here:
LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
const CSCLayer *layer_p = cscchamber->layer(1);//layer 1
const CSCLayerGeometry *layerGeom = layer_p->geometry ();
const std::array<const float, 4> & layerBounds = layerGeom->parameters ();
float shiftFromEdge = 15.;//cm
float shiftFromDeadZone = 10.;
// is the extrapolated point within a sensitive region
bool pass = withinSensitiveRegion(extrapolatedPointLocal, layerBounds,
cscchamber->id().station(), cscchamber->id().ring(),
shiftFromEdge, shiftFromDeadZone);
if(pass){// the extrapolation point of the segment lies within sensitive region of that chamber
// how many rechit layers are there in the chamber?
// 0 - maybe the muon died or is deflected at large angle? do not use that case
// 1 - could be noise...
// 2 or more - this is promissing; this is our definition of a reliable signal; use it below
// is other definition better?
int nRHLayers = 0;
for(int iL =0;iL<6;++iL){
if(AllRecHits[cscchamber->id().endcap()-1]
[cscchamber->id().station()-1]
[cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
++nRHLayers;
}
}
//std::cout<<" nRHLayers = "<<nRHLayers<<std::endl;
float verticalScale = chamberTypes[cscchamber->specs()->chamberTypeName()];
if(cscchamberCenter.z()<0){
verticalScale = - verticalScale;
}
verticalScale +=9.5;
hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()),verticalScale);
if(nRHLayers>1){// this chamber contains a reliable signal
//chamberTypes[cscchamber->specs()->chamberTypeName()];
// "intrinsic" efficiencies
//std::cout<<" verticalScale = "<<verticalScale<<" chType = "<<cscchamber->specs()->chamberTypeName()<<std::endl;
// this is the denominator forr all efficiencies
hEffDenominator->Fill(float(cscchamber->id().chamber()),verticalScale);
// Segment efficiency
if(AllSegments[cscchamber->id().endcap()-1]
[cscchamber->id().station()-1]
[cscchamber->id().ring()-1][cscchamber->id().chamber()-1]){
hSSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale));
}
for(int iL =0;iL<6;++iL){
float weight = 1./6.;
// one shold account for the weight in the efficiency...
// Rechit efficiency
if(AllRecHits[cscchamber->id().endcap()-1]
[cscchamber->id().station()-1]
[cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
hRHSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale),weight);
}
// Wire efficiency
if(allWires[cscchamber->id().endcap()-1]
[cscchamber->id().station()-1]
[cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
// one shold account for the weight in the efficiency...
hWireSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale),weight);
}
// Strip efficiency
if(allStrips[cscchamber->id().endcap()-1]
[cscchamber->id().station()-1]
[cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
// one shold account for the weight in the efficiency...
hStripSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale),weight);
}
}
}
}
}
}
}
//
}
| 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 640 of file CSCOfflineMonitor.cc.
References trackerHits::c, CSCDetId::chamber(), CSCDetId, diffTreeTool::diff, alignCSCRings::e, CSCDetId::endcap(), j, alignCSCRings::r, CSCDetId::ring(), alignCSCRings::s, CSCDetId::station(), and dtDQMClient_cfg::threshold.
{
bool clcto[2][4][4][36];
bool wireo[2][4][4][36];
bool stripo[2][4][4][36];
bool rechito[2][4][4][36];
bool segmento[2][4][4][36];
bool hasWires = false;
bool hasStrips = false;
bool hasRecHits = false;
bool hasSegments = false;
for (int e = 0; e < 2; e++){
for (int s = 0; s < 4; s++){
for (int r = 0; r < 4; r++){
for (int c = 0; c < 36; c++){
clcto[e][s][r][c] = false;
wireo[e][s][r][c] = false;
stripo[e][s][r][c] = false;
rechito[e][s][r][c] = false;
segmento[e][s][r][c] = false;
}
}
}
}
//clcts
for (CSCCLCTDigiCollection::DigiRangeIterator j=clcts->begin(); j!=clcts->end(); j++) {
CSCDetId id = (CSCDetId)(*j).first;
int kEndcap = id.endcap();
int kRing = id.ring();
int kStation = id.station();
int kChamber = id.chamber();
const CSCCLCTDigiCollection::Range& range =(*j).second;
for (CSCCLCTDigiCollection::const_iterator digiIt = range.first; digiIt!=range.second; ++digiIt){
// Valid digi in the chamber (or in neighbouring chamber)
if((*digiIt).isValid()){
//Check whether this CLCT came from ME11a
if( kStation ==1 && kRing==1 && (*digiIt).getKeyStrip()>128)
kRing = 4;
clcto[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
}
}
}
//wires
for (CSCWireDigiCollection::DigiRangeIterator wi=wires->begin(); wi!=wires->end(); wi++) {
CSCDetId id = (CSCDetId)(*wi).first;
int kEndcap = id.endcap();
int kRing = id.ring();
int kStation = id.station();
int kChamber = id.chamber();
std::vector<CSCWireDigi>::const_iterator wireIt = (*wi).second.first;
std::vector<CSCWireDigi>::const_iterator lastWire = (*wi).second.second;
for( ; wireIt != lastWire; ++wireIt){
if (!wireo[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
wireo[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
hOWires->Fill(kChamber,typeIndex(id,2));
hOWireSerial->Fill(chamberSerial(id));
hasWires = true;
if( clcto[kEndcap-1][kStation-1][kRing-1][kChamber-1])
hOWiresAndCLCT->Fill(kChamber,typeIndex(id,2));
//Also check for a CLCT in ME11a if you're in ME11 already
if (kStation==1 && kRing==1 && clcto[kEndcap-1][kStation-1][3][kChamber-1]){
CSCDetId idME11a = CSCDetId(kEndcap, kStation, 4, kChamber);
hOWiresAndCLCT->Fill(kChamber,typeIndex(idME11a,2));
}
}
}//end for loop
}
//strips
for (CSCStripDigiCollection::DigiRangeIterator si=strips->begin(); si!=strips->end(); si++) {
CSCDetId id = (CSCDetId)(*si).first;
int kEndcap = id.endcap();
int kRing = id.ring();
int kStation = id.station();
int kChamber = id.chamber();
std::vector<CSCStripDigi>::const_iterator stripIt = (*si).second.first;
std::vector<CSCStripDigi>::const_iterator lastStrip = (*si).second.second;
for( ; stripIt != lastStrip; ++stripIt) {
std::vector<int> myADCVals = stripIt->getADCCounts();
bool thisStripFired = false;
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float threshold = 13.3 ;
float diff = 0.;
for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
diff = (float)myADCVals[iCount]-thisPedestal;
if (diff > threshold) { thisStripFired = true; }
}
if (thisStripFired) {
if (!stripo[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
stripo[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
hOStrips->Fill(kChamber,typeIndex(id,2));
hOStripSerial->Fill(chamberSerial(id));
hasStrips = true;
if (clcto[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
// check if there is a wire digi in this chamber too
// for ME 1/4 check for a wire in ME 1/1
if(wireo[kEndcap-1][kStation-1][kRing-1][kChamber-1] || (kRing==4 && wireo[kEndcap-1][kStation-1][0][kChamber-1]) ){
hOStripsAndWiresAndCLCT->Fill(kChamber,typeIndex(id,2));
}
}//end clct and wire digi check
}
}//end if (thisStripFired)
}
}
//rechits
CSCRecHit2DCollection::const_iterator recIt;
for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
int kEndcap = idrec.endcap();
int kRing = idrec.ring();
int kStation = idrec.station();
int kChamber = idrec.chamber();
if (!rechito[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
rechito[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
hORecHitsSerial->Fill(chamberSerial(idrec));
hORecHits->Fill(kChamber,typeIndex(idrec,2));
hasRecHits = true;
}
}
//segments
for(CSCSegmentCollection::const_iterator segIt=cscSegments->begin(); segIt != cscSegments->end(); segIt++) {
CSCDetId id = (CSCDetId)(*segIt).cscDetId();
int kEndcap = id.endcap();
int kRing = id.ring();
int kStation = id.station();
int kChamber = id.chamber();
if (!segmento[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
segmento[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
hOSegmentsSerial->Fill(chamberSerial(id));
hOSegments->Fill(kChamber,typeIndex(id,2));
hasSegments = true;
}
}
//Overall CSC Occupancy
hCSCOccupancy->Fill(1);
if (hasWires) hCSCOccupancy->Fill(3);
if (hasStrips) hCSCOccupancy->Fill(5);
if (hasWires && hasStrips) hCSCOccupancy->Fill(7);
if (hasRecHits) hCSCOccupancy->Fill(9);
if (hasSegments) hCSCOccupancy->Fill(11);
}
| void CSCOfflineMonitor::doPedestalNoise | ( | edm::Handle< CSCStripDigiCollection > | strips | ) | [private] |
Definition at line 868 of file CSCOfflineMonitor.cc.
References CSCDetId, CSCDetId::station(), and dtDQMClient_cfg::threshold.
{
for (CSCStripDigiCollection::DigiRangeIterator dPNiter=strips->begin(); dPNiter!=strips->end(); dPNiter++) {
CSCDetId id = (CSCDetId)(*dPNiter).first;
int kStation = id.station();
int kRing = id.ring();
std::vector<CSCStripDigi>::const_iterator pedIt = (*dPNiter).second.first;
std::vector<CSCStripDigi>::const_iterator lStrip = (*dPNiter).second.second;
for( ; pedIt != lStrip; ++pedIt) {
int myStrip = pedIt->getStrip();
std::vector<int> myADCVals = pedIt->getADCCounts();
float TotalADC = getSignal(*strips, id, myStrip);
bool thisStripFired = false;
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float thisSignal = (1./6)*(myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
float threshold = 13.3;
if(kStation == 1 && kRing == 4)
{
kRing = 1;
if(myStrip <= 16) myStrip += 64; // no trapping for any bizarreness
}
if (TotalADC > threshold) { thisStripFired = true;}
if (!thisStripFired){
float ADC = thisSignal - thisPedestal;
hStripPed[typeIndex(id)-1]->Fill(ADC);
}
}
}
}
| 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 906 of file CSCOfflineMonitor.cc.
References CSCDetId, CSCDetId::endcap(), i, j, CSCDetId::station(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().
{
// Get the RecHits collection :
int nRecHits = recHits->size();
// ---------------------
// Loop over rechits
// ---------------------
// Build iterator for rechits and loop :
CSCRecHit2DCollection::const_iterator dRHIter;
for (dRHIter = recHits->begin(); dRHIter != recHits->end(); dRHIter++) {
// Find chamber with rechits in CSC
CSCDetId idrec = (CSCDetId)(*dRHIter).cscDetId();
// Store rechit as a Local Point:
LocalPoint rhitlocal = (*dRHIter).localPosition();
//float xreco = rhitlocal.x();
//float yreco = rhitlocal.y();
// Get the reconstucted strip position and error
float stpos = (*dRHIter).positionWithinStrip();
float sterr = (*dRHIter).errorWithinStrip();
int adcsize = dRHIter->nStrips()*dRHIter->nTimeBins();
float rHSumQ = 0;
float sumsides = 0;
for (unsigned int i = 0; i < dRHIter->nStrips(); i++){
for (unsigned int j=0; j<dRHIter->nTimeBins()-1; j++) {
rHSumQ+=dRHIter->adcs(i,j);
if ( i != 1 ) sumsides += dRHIter->adcs(i,j); // skip central strip
}
}
float rHratioQ = sumsides/rHSumQ;
if (adcsize != 12) rHratioQ = -99;
// Get the signal timing of this hit
float rHtime = (*dRHIter).tpeak(); //calculated from cathode SCA bins
float rHtimeAnode = (*dRHIter).wireTime(); // calculated from anode wire bx
// Get pointer to the layer:
const CSCLayer* csclayer = cscGeom->layer( idrec );
// Transform hit position from local chamber geometry to global CMS geom
GlobalPoint rhitglobal= csclayer->toGlobal(rhitlocal);
float grecx = rhitglobal.x();
float grecy = rhitglobal.y();
// Fill some histograms
int sIndex = idrec.station() + ((idrec.endcap()-1) * 4);
int tIndex = typeIndex(idrec);
hRHSumQ[tIndex-1]->Fill(rHSumQ);
hRHRatioQ[tIndex-1]->Fill(rHratioQ);
hRHstpos[tIndex-1]->Fill(stpos);
hRHsterr[tIndex-1]->Fill(sterr);
hRHTiming[tIndex-1]->Fill(rHtime);
hRHTimingAnode[tIndex-1]->Fill(rHtimeAnode);
hRHGlobal[sIndex-1]->Fill(grecx,grecy);
} //end rechit loop
if (nRecHits == 0) nRecHits = -1;
hRHnrechits->Fill(nRecHits);
}
| void CSCOfflineMonitor::doResolution | ( | edm::Handle< CSCSegmentCollection > | cscSegments, |
| edm::ESHandle< CSCGeometry > | cscGeom | ||
| ) | [private] |
Find the strip containing this hit
Definition at line 1096 of file CSCOfflineMonitor.cc.
References CSCDetId, kLayer(), CSCDetId::layer(), CSCDetId::ring(), and CSCDetId::station().
{
for(CSCSegmentCollection::const_iterator dSiter=cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
//
// try to get the CSC recHits that contribute to this segment.
std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
int nRH = (*dSiter).nRecHits();
int jRH = 0;
CLHEP::HepMatrix sp(6,1);
CLHEP::HepMatrix se(6,1);
for ( vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
jRH++;
CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
//int kEndcap = idRH.endcap();
int kRing = idRH.ring();
int kStation = idRH.station();
//int kChamber = idRH.chamber();
int kLayer = idRH.layer();
int centerid = iRH->nStrips()/2 + 1;
int centerStrip = iRH->channels(centerid - 1);
// If this segment has 6 hits, find the position of each hit on the strip in units of stripwidth and store values
if (nRH == 6){
float stpos = (*iRH).positionWithinStrip();
se(kLayer,1) = (*iRH).errorWithinStrip();
// Take into account half-strip staggering of layers (ME1/1 has no staggering)
if (kStation == 1 && (kRing == 1 || kRing == 4)) sp(kLayer,1) = stpos + centerStrip;
else{
if (kLayer == 1 || kLayer == 3 || kLayer == 5) sp(kLayer,1) = stpos + centerStrip;
if (kLayer == 2 || kLayer == 4 || kLayer == 6) sp(kLayer,1) = stpos - 0.5 + centerStrip;
}
}
}
float residual = -99;
// Fit all points except layer 3, then compare expected value for layer 3 to reconstructed value
if (nRH == 6){
float expected = fitX(sp,se);
residual = expected - sp(3,1);
}
hSResid[typeIndex(id)-1]->Fill(residual);
} // end segment loop
}
| void CSCOfflineMonitor::doSegments | ( | edm::Handle< CSCSegmentCollection > | cscSegments, |
| edm::ESHandle< CSCGeometry > | cscGeom | ||
| ) | [private] |
Definition at line 984 of file CSCOfflineMonitor.cc.
References ChiSquaredProbability(), CSCDetId, i, j, PV3DBase< T, PVType, FrameType >::phi(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::theta(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().
{
// get CSC segment collection
int nSegments = cscSegments->size();
for(CSCSegmentCollection::const_iterator dSiter=cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
CSCDetId id = (CSCDetId)(*dSiter).cscDetId();
float chisq = (*dSiter).chi2();
int nhits = (*dSiter).nRecHits();
int nDOF = 2*nhits-4;
float nChi2 = chisq/nDOF;
double chisqProb = ChiSquaredProbability( (double)chisq, nDOF );
LocalPoint localPos = (*dSiter).localPosition();
LocalVector segDir = (*dSiter).localDirection();
// prepare to calculate segment times
float timeCathode = 0; //average from cathode information alone
float timeAnode = 0; //average from pruned anode information alone
float timeCombined = 0; //average from cathode hits and pruned anode list
std::vector<float> cathodeTimes;
std::vector<float> anodeTimes;
// Get the CSC recHits that contribute to this segment.
std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
for ( vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
if ( !((*iRH).isValid()) ) continue; // only interested in valid hits
cathodeTimes.push_back((*iRH).tpeak());
anodeTimes.push_back((*iRH).wireTime());
}//end rechit loop
// Calculate cathode average
for (unsigned int i=0; i<cathodeTimes.size(); i++)
timeCathode+=cathodeTimes[i]/cathodeTimes.size();
// Prune the anode list to deal with the late tail
float anodeMaxDiff;
bool modified = false;
std::vector<float>::iterator anodeMaxHit;
do {
if (anodeTimes.size()==0) continue;
timeAnode=0;
anodeMaxDiff=0;
modified=false;
// Find the average
for (unsigned int j=0; j<anodeTimes.size(); j++) timeAnode+=anodeTimes[j]/anodeTimes.size();
// Find the maximum outlier hit
for (unsigned int j=0; j<anodeTimes.size(); j++) {
if (fabs(anodeTimes[j]-timeAnode)>anodeMaxDiff) {
anodeMaxHit=anodeTimes.begin()+j;
anodeMaxDiff=fabs(anodeTimes[j]-timeAnode);
}
}
// Cut hit if its greater than some time away
if (anodeMaxDiff>26) {
modified=true;
anodeTimes.erase(anodeMaxHit);
}
} while (modified);
// Calculate combined anode and cathode time average
if(cathodeTimes.size()+anodeTimes.size() >0 )
timeCombined = (timeCathode*cathodeTimes.size() + timeAnode*anodeTimes.size())/(cathodeTimes.size()+anodeTimes.size());
// global transformation
float globX = 0.;
float globY = 0.;
float globZ = 0.;
float globTOF = 0.;
float globTheta = 0.;
float globPhi = 0.;
const CSCChamber* cscchamber = cscGeom->chamber(id);
if (cscchamber) {
GlobalPoint globalPosition = cscchamber->toGlobal(localPos);
globX = globalPosition.x();
globY = globalPosition.y();
globZ = globalPosition.z();
globTOF = sqrt(globX*globX+globY*globY+globZ*globZ);
GlobalVector globalDirection = cscchamber->toGlobal(segDir);
globTheta = globalDirection.theta();
globPhi = globalDirection.phi();
}
// Fill histos
int tIndex = typeIndex(id);
hSnhitsAll->Fill(nhits);
hSnhits[tIndex-1]->Fill(nhits);
hSChiSqAll->Fill(nChi2);
hSChiSq[tIndex-1]->Fill(nChi2);
hSChiSqProbAll->Fill(chisqProb);
hSChiSqProb[tIndex-1]->Fill(chisqProb);
hSGlobalTheta->Fill(globTheta);
hSGlobalPhi->Fill(globPhi);
hSTimeCathode->Fill(timeCathode);
hSTimeCombined->Fill(timeCombined);
hSTimeVsZ->Fill(globZ, timeCombined);
hSTimeVsTOF->Fill(globTOF, timeCombined);
} // end segment loop
if (nSegments == 0) nSegments = -1;
hSnSegments->Fill(nSegments);
}
| void CSCOfflineMonitor::doStripDigis | ( | edm::Handle< CSCStripDigiCollection > | strips | ) | [private] |
Definition at line 829 of file CSCOfflineMonitor.cc.
References CSCDetId, diffTreeTool::diff, and dtDQMClient_cfg::threshold.
{
int nStripsFired = 0;
for (CSCStripDigiCollection::DigiRangeIterator dSDiter=strips->begin(); dSDiter!=strips->end(); dSDiter++) {
CSCDetId id = (CSCDetId)(*dSDiter).first;
std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
for( ; stripIter != lStrip; ++stripIter) {
int myStrip = stripIter->getStrip();
std::vector<int> myADCVals = stripIter->getADCCounts();
bool thisStripFired = false;
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float threshold = 13.3 ;
float diff = 0.;
for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
diff = (float)myADCVals[iCount]-thisPedestal;
if (diff > threshold) { thisStripFired = true; }
}
if (thisStripFired) {
nStripsFired++;
hStripNumber[typeIndex(id)-1]->Fill(myStrip);
}
}
} // end strip loop
// this way you can zero suppress but still store info on # events with no digis
if (nStripsFired == 0) nStripsFired = -1;
hStripNFired->Fill(nStripsFired);
// fill n per event
}
| void CSCOfflineMonitor::doWireDigis | ( | edm::Handle< CSCWireDigiCollection > | wires | ) | [private] |
Definition at line 800 of file CSCOfflineMonitor.cc.
References CSCDetId.
{
int nWireGroupsTotal = 0;
for (CSCWireDigiCollection::DigiRangeIterator dWDiter=wires->begin(); dWDiter!=wires->end(); dWDiter++) {
CSCDetId id = (CSCDetId)(*dWDiter).first;
std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
for( ; wireIter != lWire; ++wireIter) {
int myWire = wireIter->getWireGroup();
int myTBin = wireIter->getTimeBin();
nWireGroupsTotal++;
hWireTBin[typeIndex(id)-1]->Fill(myTBin);
hWireNumber[typeIndex(id)-1]->Fill(myWire);
}
} // end wire loop
// this way you can zero suppress but still store info on # events with no digis
if (nWireGroupsTotal == 0) nWireGroupsTotal = -1;
hWirenGroupsTotal->Fill(nWireGroupsTotal);
}
| void CSCOfflineMonitor::endJob | ( | void | ) | [virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 472 of file CSCOfflineMonitor.cc.
References dumpDBToFile_GT_ttrig_cfg::outputFileName, and funct::true.
{
finalize() ;
finalizedHistograms_ = true ;
bool saveHistos = param.getParameter<bool>("saveHistos");
string outputFileName = param.getParameter<string>("outputFileName");
if(saveHistos){
dbe->save(outputFileName);
}
}
| void CSCOfflineMonitor::endRun | ( | edm::Run const & | , |
| edm::EventSetup const & | |||
| ) | [virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 463 of file CSCOfflineMonitor.cc.
References funct::true.
{
if (!finalizedHistograms_){
finalize() ;
finalizedHistograms_ = true ;
}
}
| double CSCOfflineMonitor::extrapolate1D | ( | double | initPosition, |
| double | initDirection, | ||
| double | parameterOfTheLine | ||
| ) | [inline, private] |
Definition at line 147 of file CSCOfflineMonitor.h.
{
double extrapolatedPosition = initPosition + initDirection*parameterOfTheLine;
return extrapolatedPosition;
}
| void CSCOfflineMonitor::fillEfficiencyHistos | ( | int | bin, |
| int | flag | ||
| ) | [private] |
| void CSCOfflineMonitor::finalize | ( | void | ) |
Definition at line 486 of file CSCOfflineMonitor.cc.
{
hRHEff = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hRHEff");
hSEff = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hSEff");
hSEff2 = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hSEff2");
hRHEff2 = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hRHEff2");
hStripEff2 = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hStripEff2");
hWireEff2 = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hWireEff2");
hOStripsAndWiresAndCLCT= dbe->get("CSC/CSCOfflineMonitor/Occupancy/hOStripsAndWiresAndCLCT");
hOWiresAndCLCT= dbe->get("CSC/CSCOfflineMonitor/Occupancy/hOWiresAndCLCT");
hStripReadoutEff2 = dbe->get("CSC/CSCOfflineMonitor/Efficiency/hStripReadoutEff2");
hALCTgetBX2DMeans = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hALCTgetBX2DMeans");
hALCTMatch2DMeans = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hALCTMatch2DMeans");
hCLCTL1A2DMeans = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hCLCTL1A2DMeans");
hALCTgetBXSerial = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hALCTgetBXSerial");
hALCTMatchSerial = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hALCTMatchSerial");
hCLCTL1ASerial = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hCLCTL1ASerial");
hALCTgetBXChamberMeans = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hALCTgetBXChamberMeans");
hALCTMatchChamberMeans = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hALCTMatchChamberMeans");
hCLCTL1AChamberMeans = dbe->get("CSC/CSCOfflineMonitor/BXMonitor/hCLCTL1AChamberMeans");
if (hRHEff) histoEfficiency(hRHSTE->getTH1F(),hRHEff);
if (hSEff) histoEfficiency(hSSTE->getTH1F(),hSEff);
if (hSEff2) hSEff2->getTH2F()->Divide(hSSTE2->getTH2F(),\
hEffDenominator->getTH2F(), 1., 1.,"B");
if (hRHEff2) hRHEff2->getTH2F()->Divide(hRHSTE2->getTH2F(),\
hEffDenominator->getTH2F(), 1., 1., "B");
if (hStripEff2) hStripEff2->getTH2F()->Divide(hStripSTE2->getTH2F(),\
hEffDenominator->getTH2F(), 1., 1., "B");
if (hWireEff2) hWireEff2->getTH2F()->Divide(hWireSTE2->getTH2F(),\
hEffDenominator->getTH2F(), 1., 1., "B");
if (hStripReadoutEff2) hStripReadoutEff2->getTH2F()->Divide(hOStripsAndWiresAndCLCT->getTH2F(),\
hOWiresAndCLCT->getTH2F(), 1., 1., "B");
if (hALCTMatch2DMeans){
harvestChamberMeans(hALCTMatchChamberMeans,\
hALCTMatch2DMeans,\
hALCTMatch2DNumerator,\
hALCTMatch2Denominator );
}
if (hALCTgetBX2DMeans) {
harvestChamberMeans(hALCTgetBXChamberMeans,\
hALCTgetBX2DMeans,\
hALCTgetBX2DNumerator,\
hALCTgetBX2Denominator );
}
if (hCLCTL1A2DMeans) {
harvestChamberMeans(hCLCTL1AChamberMeans,\
hCLCTL1A2DMeans,\
hCLCTL1A2DNumerator,\
hCLCTL1A2Denominator );
}
if(hALCTgetBXSerial) normalize(hALCTgetBXSerial);
if(hALCTMatchSerial) normalize(hALCTMatchSerial);
if(hCLCTL1ASerial) normalize(hCLCTL1ASerial);
}
| float CSCOfflineMonitor::fitX | ( | CLHEP::HepMatrix | sp, |
| CLHEP::HepMatrix | ep | ||
| ) | [private] |
Definition at line 1156 of file CSCOfflineMonitor.cc.
References delta, benchmark_cfg::errors, i, and slope.
{
float S = 0;
float Sx = 0;
float Sy = 0;
float Sxx = 0;
float Sxy = 0;
float sigma2 = 0;
for (int i=1;i<7;i++){
if (i != 3){
sigma2 = errors(i,1)*errors(i,1);
S = S + (1/sigma2);
Sy = Sy + (points(i,1)/sigma2);
Sx = Sx + ((i)/sigma2);
Sxx = Sxx + (i*i)/sigma2;
Sxy = Sxy + (((i)*points(i,1))/sigma2);
}
}
float delta = S*Sxx - Sx*Sx;
float intercept = (Sxx*Sy - Sx*Sxy)/delta;
float slope = (S*Sxy - Sx*Sy)/delta;
return (intercept + slope*3);
}
| void CSCOfflineMonitor::getEfficiency | ( | float | bin, |
| float | Norm, | ||
| std::vector< float > & | eff | ||
| ) | [private] |
Definition at line 1738 of file CSCOfflineMonitor.cc.
References mathSSE::sqrt().
| float CSCOfflineMonitor::getSignal | ( | const CSCStripDigiCollection & | stripdigis, |
| CSCDetId | idRH, | ||
| int | centerStrip | ||
| ) | [private] |
Definition at line 1191 of file CSCOfflineMonitor.cc.
References CSCDetId, if(), and prof2calltree::last.
{
float SigADC[5];
float TotalADC = 0;
SigADC[0] = 0;
SigADC[1] = 0;
SigADC[2] = 0;
SigADC[3] = 0;
SigADC[4] = 0;
// Loop over strip digis
CSCStripDigiCollection::DigiRangeIterator sIt;
for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++){
CSCDetId id = (CSCDetId)(*sIt).first;
if (id == idCS){
// First, find the Signal-Pedestal for center strip
vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
for ( ; digiItr != last; ++digiItr ) {
int thisStrip = digiItr->getStrip();
if (thisStrip == (centerStrip)){
std::vector<int> myADCVals = digiItr->getADCCounts();
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
SigADC[0] = thisSignal - 6*thisPedestal;
}
// Now,find the Signal-Pedestal for neighbouring 4 strips
if (thisStrip == (centerStrip+1)){
std::vector<int> myADCVals = digiItr->getADCCounts();
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
SigADC[1] = thisSignal - 6*thisPedestal;
}
if (thisStrip == (centerStrip+2)){
std::vector<int> myADCVals = digiItr->getADCCounts();
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
SigADC[2] = thisSignal - 6*thisPedestal;
}
if (thisStrip == (centerStrip-1)){
std::vector<int> myADCVals = digiItr->getADCCounts();
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
SigADC[3] = thisSignal - 6*thisPedestal;
}
if (thisStrip == (centerStrip-2)){
std::vector<int> myADCVals = digiItr->getADCCounts();
float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
SigADC[4] = thisSignal - 6*thisPedestal;
}
}
TotalADC = 0.2*(SigADC[0]+SigADC[1]+SigADC[2]+SigADC[3]+SigADC[4]);
}
}
return TotalADC;
}
| void CSCOfflineMonitor::harvestChamberMeans | ( | MonitorElement * | meMean1D, |
| MonitorElement * | meMean2D, | ||
| MonitorElement * | hNum, | ||
| MonitorElement * | meDenom | ||
| ) | [private] |
Definition at line 549 of file CSCOfflineMonitor.cc.
References MonitorElement::Fill(), MonitorElement::getBinContent(), MonitorElement::getNbinsX(), MonitorElement::getNbinsY(), timingPdfMaker::mean, and MonitorElement::setBinContent().
{
if (hNum->getNbinsY()!= meDenom->getNbinsY() || hNum->getNbinsX()!= meDenom->getNbinsX())
return;
if (meMean2D->getNbinsY()!= meDenom->getNbinsY() || meMean2D->getNbinsX()!= meDenom->getNbinsX())
return;
float mean;
for (int biny = 0; biny < hNum->getNbinsY()+1 ; biny++){
for (int binx = 0; binx < hNum->getNbinsX()+1 ; binx++){
if ( meDenom->getBinContent(binx,biny) > 0){
mean = hNum->getBinContent(binx,biny)/meDenom->getBinContent(binx,biny);
meMean1D->Fill(mean);
meMean2D->setBinContent(binx,biny,mean);
}
}
}
return;
}
| void CSCOfflineMonitor::histoEfficiency | ( | TH1F * | readHisto, |
| MonitorElement * | writeHisto | ||
| ) | [private] |
Definition at line 1752 of file CSCOfflineMonitor.cc.
References i, SiStripMonitorClusterAlca_cfi::Nbins, MonitorElement::setBinContent(), and MonitorElement::setBinError().
{
std::vector<float> eff(2);
int Nbins = readHisto->GetSize()-2;//without underflows and overflows
std::vector<float> bins(Nbins);
std::vector<float> Efficiency(Nbins);
std::vector<float> EffError(Nbins);
float Num = 1;
float Den = 1;
for (int i=0;i<20;i++){
Num = readHisto->GetBinContent(i+1);
Den = readHisto->GetBinContent(i+21);
getEfficiency(Num, Den, eff);
Efficiency[i] = eff[0];
EffError[i] = eff[1];
writeHisto->setBinContent(i+1, Efficiency[i]);
writeHisto->setBinError(i+1, EffError[i]);
}
}
| double CSCOfflineMonitor::lineParametrization | ( | double | z1Position, |
| double | z2Position, | ||
| double | z1Direction | ||
| ) | [inline, private] |
Definition at line 143 of file CSCOfflineMonitor.h.
{
double parameterLine = (z2Position-z1Position)/z1Direction;
return parameterLine;
}
| void CSCOfflineMonitor::normalize | ( | MonitorElement * | me | ) | [private] |
Definition at line 574 of file CSCOfflineMonitor.cc.
References python::tagInventory::entries, MonitorElement::getTH2F(), and h.
{
TH2F* h = me->getTH2F();
if (! h)
return;
TH1D* hproj = h->ProjectionX("hproj");
for (int binx = 0; binx < h->GetNbinsX()+1 ; binx++){
Double_t entries = hproj->GetBinContent(binx);
for (Int_t biny=1;biny <= h->GetNbinsY();biny++) {
Double_t cxy = h->GetBinContent(binx,biny);
if (cxy > 0 && entries>0) h->SetBinContent(binx,biny,cxy/entries);
}
}
return;
}
| int CSCOfflineMonitor::typeIndex | ( | CSCDetId | id, |
| int | flag = 1 |
||
| ) | [private] |
Definition at line 1872 of file CSCOfflineMonitor.cc.
References Reference_intrackfit_cff::endcap, getHLTprescales::index, relativeConstraints::ring, and relativeConstraints::station.
{
if (flag == 1){
// linearlized index bases on endcap, station, and ring
int index = 0;
if (id.station() == 1) index = id.ring();
else index = id.station()*2 + id.ring();
if (id.endcap() == 1) index = index + 10;
if (id.endcap() == 2) index = 11 - index;
return index;
}
else if (flag == 2){
int index = 0;
if (id.station() == 1 && id.ring() != 4) index = id.ring()+1;
if (id.station() == 1 && id.ring() == 4) index = 1;
if (id.station() != 1) index = id.station()*2 + id.ring();
if (id.endcap() == 1) index = index + 10;
if (id.endcap() == 2) index = 11 - index;
return index;
}
else return 0;
}
| bool CSCOfflineMonitor::withinSensitiveRegion | ( | LocalPoint | localPos, |
| const std::array< const float, 4 > & | layerBounds, | ||
| int | station, | ||
| int | ring, | ||
| float | shiftFromEdge, | ||
| float | shiftFromDeadZone | ||
| ) | [private] |
Definition at line 1771 of file CSCOfflineMonitor.cc.
References abs, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().
{
//---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded)
bool pass = false;
float y_center = 0.;
double yUp = layerBounds[3] + y_center;
double yDown = - layerBounds[3] + y_center;
double xBound1Shifted = layerBounds[0] - shiftFromEdge;//
double xBound2Shifted = layerBounds[1] - shiftFromEdge;//
double lineSlope = (yUp - yDown)/(xBound2Shifted-xBound1Shifted);
double lineConst = yUp - lineSlope*xBound2Shifted;
double yBorder = lineSlope*abs(localPos.x()) + lineConst;
//bool withinChamberOnly = false;// false = "good region"; true - boundaries only
std::vector <float> deadZoneCenter(6);
float cutZone = shiftFromDeadZone;//cm
//---- hardcoded... not good
if(station>1 && station<5){
if(2==ring){
deadZoneCenter[0]= -162.48 ;
deadZoneCenter[1] = -81.8744;
deadZoneCenter[2] = -21.18165;
deadZoneCenter[3] = 39.51105;
deadZoneCenter[4] = 100.2939;
deadZoneCenter[5] = 160.58;
if(localPos.y() >yBorder &&
((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
(localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
(localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone) ||
(localPos.y()> deadZoneCenter[3] + cutZone && localPos.y()< deadZoneCenter[4] - cutZone) ||
(localPos.y()> deadZoneCenter[4] + cutZone && localPos.y()< deadZoneCenter[5] - cutZone))){
pass = true;
}
}
else if(1==ring){
if(2==station){
deadZoneCenter[0]= -95.80 ;
deadZoneCenter[1] = -27.47;
deadZoneCenter[2] = 33.67;
deadZoneCenter[3] = 90.85;
}
else if(3==station){
deadZoneCenter[0]= -89.305 ;
deadZoneCenter[1] = -39.705;
deadZoneCenter[2] = 20.195;
deadZoneCenter[3] = 77.395;
}
else if(4==station){
deadZoneCenter[0]= -75.645;
deadZoneCenter[1] = -26.055;
deadZoneCenter[2] = 23.855;
deadZoneCenter[3] = 70.575;
}
if(localPos.y() >yBorder &&
((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
(localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
(localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone))){
pass = true;
}
}
}
else if(1==station){
if(3==ring){
deadZoneCenter[0]= -83.155 ;
deadZoneCenter[1] = -22.7401;
deadZoneCenter[2] = 27.86665;
deadZoneCenter[3] = 81.005;
if(localPos.y() > yBorder &&
((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
(localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
(localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone))){
pass = true;
}
}
else if(2==ring){
deadZoneCenter[0]= -86.285 ;
deadZoneCenter[1] = -32.88305;
deadZoneCenter[2] = 32.867423;
deadZoneCenter[3] = 88.205;
if(localPos.y() > (yBorder) &&
((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
(localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
(localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone))){
pass = true;
}
}
else{
deadZoneCenter[0]= -81.0;
deadZoneCenter[1] = 81.0;
if(localPos.y() > (yBorder) &&
(localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone )){
pass = true;
}
}
}
return pass;
}
edm::InputTag CSCOfflineMonitor::alctDigiTag_ [private] |
Definition at line 107 of file CSCOfflineMonitor.h.
edm::InputTag CSCOfflineMonitor::clctDigiTag_ [private] |
Definition at line 108 of file CSCOfflineMonitor.h.
Definition at line 109 of file CSCOfflineMonitor.h.
edm::InputTag CSCOfflineMonitor::cscSegTag_ [private] |
Definition at line 110 of file CSCOfflineMonitor.h.
DQMStore* CSCOfflineMonitor::dbe [private] |
Definition at line 159 of file CSCOfflineMonitor.h.
Definition at line 111 of file CSCOfflineMonitor.h.
bool CSCOfflineMonitor::finalizedHistograms_ [private] |
Definition at line 102 of file CSCOfflineMonitor.h.
Referenced by beginRun().
MonitorElement* CSCOfflineMonitor::hALCTgetBX [private] |
Definition at line 230 of file CSCOfflineMonitor.h.
Definition at line 234 of file CSCOfflineMonitor.h.
Definition at line 233 of file CSCOfflineMonitor.h.
Definition at line 235 of file CSCOfflineMonitor.h.
Definition at line 232 of file CSCOfflineMonitor.h.
Definition at line 231 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hALCTMatch [private] |
Definition at line 237 of file CSCOfflineMonitor.h.
Definition at line 241 of file CSCOfflineMonitor.h.
Definition at line 240 of file CSCOfflineMonitor.h.
Definition at line 242 of file CSCOfflineMonitor.h.
Definition at line 239 of file CSCOfflineMonitor.h.
Definition at line 238 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hCLCTL1A [private] |
Definition at line 244 of file CSCOfflineMonitor.h.
Definition at line 248 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hCLCTL1A2DMeans [private] |
Definition at line 247 of file CSCOfflineMonitor.h.
Definition at line 249 of file CSCOfflineMonitor.h.
Definition at line 246 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hCLCTL1ASerial [private] |
Definition at line 245 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hCSCOccupancy [private] |
Definition at line 210 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hEffDenominator [private] |
Definition at line 226 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hORecHits [private] |
Definition at line 204 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hORecHitsSerial [private] |
Definition at line 208 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hOSegments [private] |
Definition at line 205 of file CSCOfflineMonitor.h.
Definition at line 209 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hOStrips [private] |
Definition at line 202 of file CSCOfflineMonitor.h.
Definition at line 203 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hOStripSerial [private] |
Definition at line 207 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hOWires [private] |
Definition at line 200 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hOWiresAndCLCT [private] |
Definition at line 201 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hOWireSerial [private] |
Definition at line 206 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hRHEff [private] |
Definition at line 216 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hRHEff2 [private] |
Definition at line 222 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHGlobal [private] |
Definition at line 173 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hRHnrechits [private] |
Definition at line 172 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHRatioQ [private] |
Definition at line 177 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hRHSTE [private] |
Definition at line 214 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hRHSTE2 [private] |
Definition at line 218 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHsterr [private] |
Definition at line 179 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHstpos [private] |
Definition at line 178 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHSumQ [private] |
Definition at line 174 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHTiming [private] |
Definition at line 175 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hRHTimingAnode [private] |
Definition at line 176 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hSChiSq [private] |
Definition at line 186 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSChiSqAll [private] |
Definition at line 185 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hSChiSqProb [private] |
Definition at line 188 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSChiSqProbAll [private] |
Definition at line 187 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSEff [private] |
Definition at line 215 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSEff2 [private] |
Definition at line 221 of file CSCOfflineMonitor.h.
Definition at line 227 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSGlobalPhi [private] |
Definition at line 190 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSGlobalTheta [private] |
Definition at line 189 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hSnhits [private] |
Definition at line 184 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSnhitsAll [private] |
Definition at line 183 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSnSegments [private] |
Definition at line 182 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hSResid [private] |
Definition at line 197 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSSTE [private] |
Definition at line 213 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSSTE2 [private] |
Definition at line 217 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSTimeCathode [private] |
Definition at line 191 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSTimeCombined [private] |
Definition at line 192 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSTimeVsTOF [private] |
Definition at line 194 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hSTimeVsZ [private] |
Definition at line 193 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hStripEff2 [private] |
Definition at line 223 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hStripNFired [private] |
Definition at line 167 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hStripNumber [private] |
Definition at line 168 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hStripPed [private] |
Definition at line 169 of file CSCOfflineMonitor.h.
Definition at line 225 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hStripSTE2 [private] |
Definition at line 219 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hWireEff2 [private] |
Definition at line 224 of file CSCOfflineMonitor.h.
Definition at line 162 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hWireNumber [private] |
Definition at line 164 of file CSCOfflineMonitor.h.
MonitorElement* CSCOfflineMonitor::hWireSTE2 [private] |
Definition at line 220 of file CSCOfflineMonitor.h.
std::vector<MonitorElement*> CSCOfflineMonitor::hWireTBin [private] |
Definition at line 163 of file CSCOfflineMonitor.h.
edm::ParameterSet CSCOfflineMonitor::param [private] |
Definition at line 104 of file CSCOfflineMonitor.h.
Definition at line 105 of file CSCOfflineMonitor.h.
edm::InputTag CSCOfflineMonitor::wireDigiTag_ [private] |
Definition at line 106 of file CSCOfflineMonitor.h.
1.7.3