CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
SiStripMonitorCluster.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 // Package: SiStripMonitorCluster
3 // Class: SiStripMonitorCluster
6 // Original Author: Dorian Kcira
7 // Created: Wed Feb 1 16:42:34 CET 2006
8 #include <vector>
9 #include <numeric>
10 #include <fstream>
11 #include <math.h>
12 #include "TNamed.h"
13 #include "FWCore/MessageLogger/interface/MessageLogger.h"
14 #include "FWCore/ServiceRegistry/interface/Service.h"
15 
16 #include "CalibTracker/Records/interface/SiStripDetCablingRcd.h"
17 #include "CalibFormats/SiStripObjects/interface/SiStripDetCabling.h"
18 #include "CondFormats/DataRecord/interface/SiStripCondDataRecords.h"
19 #include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
20 #include "CalibFormats/SiStripObjects/interface/SiStripGain.h"
21 #include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
22 #include "DataFormats/SiStripCluster/interface/SiStripClusterCollection.h"
23 #include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
24 #include "DQM/SiStripCommon/interface/SiStripFolderOrganizer.h"
25 #include "DQM/SiStripCommon/interface/SiStripHistoId.h"
26 #include "DQM/SiStripMonitorCluster/interface/SiStripMonitorCluster.h"
27 #include "DQMServices/Core/interface/DQMStore.h"
28 #include "DQMServices/Core/interface/MonitorElement.h"
29 #include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
30 #include "DataFormats/SiStripDetId/interface/SiStripSubStructure.h"
31 #include "CalibTracker/SiStripCommon/interface/SiStripDCSStatus.h"
32 #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
33 
34 #include "DPGAnalysis/SiStripTools/interface/APVCyclePhaseCollection.h"
35 #include "DPGAnalysis/SiStripTools/interface/EventWithHistory.h"
36 
37 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
38 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
39 
40 #include "TMath.h"
41 #include <iostream>
42 
43 //--------------------------------------------------------------------------------------------
44 SiStripMonitorCluster::SiStripMonitorCluster(const edm::ParameterSet& iConfig)
45  : conf_(iConfig), show_mechanical_structure_view(true), show_readout_view(false), show_control_view(false), select_all_detectors(false), reset_each_run(false), m_cacheID_(0)
46  // , genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig, consumesCollector()))
47 {
48 
49  // initialize
50  passBPTXfilter_ = true;
51 
52  // initialize GenericTriggerEventFlag by specific configuration
53  // in this way, one can set specific selections for different MEs
54  genTriggerEventFlagBPTXfilter_ = new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("BPTXfilter") , consumesCollector(), *this );
55  genTriggerEventFlagPixelDCSfilter_ = new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("PixelDCSfilter"), consumesCollector(), *this );
56  genTriggerEventFlagStripDCSfilter_ = new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("StripDCSfilter"), consumesCollector(), *this );
57 
58  firstEvent = -1;
59  eventNb = 0;
60 
61  // Detector Partitions
62  SubDetPhasePartMap["TIB"] = "TI";
63  SubDetPhasePartMap["TID__MINUS"] = "TI";
64  SubDetPhasePartMap["TID__PLUS"] = "TI";
65  SubDetPhasePartMap["TOB"] = "TO";
66  SubDetPhasePartMap["TEC__MINUS"] = "TM";
67  SubDetPhasePartMap["TEC__PLUS"] = "TP";
68 
69  //get on/off option for every cluster from cfi
70  edm::ParameterSet ParametersnClusters = conf_.getParameter<edm::ParameterSet>("TH1nClusters");
71  layerswitchncluson = ParametersnClusters.getParameter<bool>("layerswitchon");
72  moduleswitchncluson = ParametersnClusters.getParameter<bool>("moduleswitchon");
73 
74  edm::ParameterSet ParametersClusterCharge = conf_.getParameter<edm::ParameterSet>("TH1ClusterCharge");
75  layerswitchcluschargeon = ParametersClusterCharge.getParameter<bool>("layerswitchon");
76  moduleswitchcluschargeon = ParametersClusterCharge.getParameter<bool>("moduleswitchon");
77  subdetswitchcluschargeon = ParametersClusterCharge.getParameter<bool>("subdetswitchon");
78 
79  edm::ParameterSet ParametersClusterStoN = conf_.getParameter<edm::ParameterSet>("TH1ClusterStoN");
80  layerswitchclusstonon = ParametersClusterStoN.getParameter<bool>("layerswitchon");
81  moduleswitchclusstonon = ParametersClusterStoN.getParameter<bool>("moduleswitchon");
82 
83  edm::ParameterSet ParametersClusterStoNVsPos = conf_.getParameter<edm::ParameterSet>("TH1ClusterStoNVsPos");
84  layerswitchclusstonVsposon = ParametersClusterStoNVsPos.getParameter<bool>("layerswitchon");
85  moduleswitchclusstonVsposon = ParametersClusterStoNVsPos.getParameter<bool>("moduleswitchon");
86 
87  edm::ParameterSet ParametersClusterPos = conf_.getParameter<edm::ParameterSet>("TH1ClusterPos");
88  layerswitchclusposon = ParametersClusterPos.getParameter<bool>("layerswitchon");
89  moduleswitchclusposon = ParametersClusterPos.getParameter<bool>("moduleswitchon");
90 
91  edm::ParameterSet ParametersClusterDigiPos = conf_.getParameter<edm::ParameterSet>("TH1ClusterDigiPos");
92  layerswitchclusdigiposon = ParametersClusterDigiPos.getParameter<bool>("layerswitchon");
93  moduleswitchclusdigiposon = ParametersClusterDigiPos.getParameter<bool>("moduleswitchon");
94 
95  edm::ParameterSet ParametersClusterNoise = conf_.getParameter<edm::ParameterSet>("TH1ClusterNoise");
96  layerswitchclusnoiseon = ParametersClusterNoise.getParameter<bool>("layerswitchon");
97  moduleswitchclusnoiseon = ParametersClusterNoise.getParameter<bool>("moduleswitchon");
98 
99  edm::ParameterSet ParametersClusterWidth = conf_.getParameter<edm::ParameterSet>("TH1ClusterWidth");
100  layerswitchcluswidthon = ParametersClusterWidth.getParameter<bool>("layerswitchon");
101  moduleswitchcluswidthon = ParametersClusterWidth.getParameter<bool>("moduleswitchon");
102  subdetswitchcluswidthon = ParametersClusterWidth.getParameter<bool>("subdetswitchon");
103 
104  edm::ParameterSet ParametersModuleLocalOccupancy = conf_.getParameter<edm::ParameterSet>("TH1ModuleLocalOccupancy");
105  layerswitchlocaloccupancy = ParametersModuleLocalOccupancy.getParameter<bool>("layerswitchon");
106  moduleswitchlocaloccupancy = ParametersModuleLocalOccupancy.getParameter<bool>("moduleswitchon");
107 
108  edm::ParameterSet ParametersNrOfClusterizedStrips = conf_.getParameter<edm::ParameterSet>("TH1NrOfClusterizedStrips");
109  layerswitchnrclusterizedstrip = ParametersNrOfClusterizedStrips.getParameter<bool>("layerswitchon");
110  moduleswitchnrclusterizedstrip = ParametersNrOfClusterizedStrips.getParameter<bool>("moduleswitchon");
111 
112  edm::ParameterSet ParametersClusterProf = conf_.getParameter<edm::ParameterSet>("TProfNumberOfCluster");
113  layerswitchnumclusterprofon = ParametersClusterProf.getParameter<bool>("layerswitchon");
114 
115  edm::ParameterSet ParametersClusterWidthProf = conf_.getParameter<edm::ParameterSet>("TProfClusterWidth");
116  layerswitchclusterwidthprofon = ParametersClusterWidthProf.getParameter<bool>("layerswitchon");
117 
118  edm::ParameterSet ParametersTotClusterProf = conf_.getParameter<edm::ParameterSet>("TProfTotalNumberOfClusters");
119  subdetswitchtotclusprofon = ParametersTotClusterProf.getParameter<bool>("subdetswitchon");
120 
121  edm::ParameterSet ParametersTotClusterTH1 = conf_.getParameter<edm::ParameterSet>("TH1TotalNumberOfClusters");
122  subdetswitchtotclusth1on = ParametersTotClusterTH1.getParameter<bool>("subdetswitchon");
123 
124  edm::ParameterSet ParametersClusterApvProf = conf_.getParameter<edm::ParameterSet>("TProfClustersApvCycle");
125  subdetswitchapvcycleprofon = ParametersClusterApvProf.getParameter<bool>("subdetswitchon");
126 
127  edm::ParameterSet ParametersClustersApvTH2 = conf_.getParameter<edm::ParameterSet>("TH2ClustersApvCycle");
128  subdetswitchapvcycleth2on = ParametersClustersApvTH2.getParameter<bool>("subdetswitchon");
129 
130  edm::ParameterSet ParametersApvCycleDBxProf2 = conf_.getParameter<edm::ParameterSet>("TProf2ApvCycleVsDBx");
131  subdetswitchapvcycledbxprof2on = ParametersApvCycleDBxProf2.getParameter<bool>("subdetswitchon");
132 
133  edm::ParameterSet ParametersDBxCycleProf = conf_.getParameter<edm::ParameterSet>("TProfClustersVsDBxCycle");
134  subdetswitchdbxcycleprofon = ParametersDBxCycleProf.getParameter<bool>("subdetswitchon");
135 
136  edm::ParameterSet ParametersCStripVsCPix = conf_.getParameter<edm::ParameterSet>("TH2CStripVsCpixel");
137  globalswitchcstripvscpix = ParametersCStripVsCPix.getParameter<bool>("globalswitchon");
138 
139  edm::ParameterSet ParametersMultiplicityRegionsTH1 = conf_.getParameter<edm::ParameterSet>("TH1MultiplicityRegions");
140  globalswitchMultiRegions = ParametersMultiplicityRegionsTH1.getParameter<bool>("globalswitchon");
141 
142  edm::ParameterSet ParametersApvCycleVsDBxGlobalTH2 = conf_.getParameter<edm::ParameterSet>("TH2ApvCycleVsDBxGlobal");
143  globalswitchapvcycledbxth2on = ParametersApvCycleVsDBxGlobalTH2.getParameter<bool>("globalswitchon");
144 
145  edm::ParameterSet ParametersNoiseStrip2ApvCycle = conf_.getParameter<edm::ParameterSet>("TH1StripNoise2ApvCycle");
146  globalswitchstripnoise2apvcycle = ParametersNoiseStrip2ApvCycle.getParameter<bool>("globalswitchon");
147 
148  edm::ParameterSet ParametersNoiseStrip3ApvCycle = conf_.getParameter<edm::ParameterSet>("TH1StripNoise3ApvCycle");
149  globalswitchstripnoise3apvcycle = ParametersNoiseStrip3ApvCycle.getParameter<bool>("globalswitchon");
150 
151  edm::ParameterSet ParametersMainDiagonalPosition = conf_.getParameter<edm::ParameterSet>("TH1MainDiagonalPosition");
152  globalswitchmaindiagonalposition= ParametersMainDiagonalPosition.getParameter<bool>("globalswitchon");
153 
154  edm::ParameterSet ClusterMultiplicityRegions = conf_.getParameter<edm::ParameterSet>("MultiplicityRegions");
155  k0 = ClusterMultiplicityRegions.getParameter<double>("k0");
156  q0 = ClusterMultiplicityRegions.getParameter<double>("q0");
157  dk0 = ClusterMultiplicityRegions.getParameter<double>("dk0");
158  maxClus = ClusterMultiplicityRegions.getParameter<double>("MaxClus");
159  minPix = ClusterMultiplicityRegions.getParameter<double>("MinPix");
160 
161  edm::ParameterSet ParametersNclusVsCycleTimeProf2D = conf_.getParameter<edm::ParameterSet>("NclusVsCycleTimeProf2D");
162  globalswitchnclusvscycletimeprof2don = ParametersNclusVsCycleTimeProf2D.getParameter<bool>("globalswitchon");
163 
164  clustertkhistomapon = conf_.getParameter<bool>("TkHistoMap_On");
165  createTrendMEs = conf_.getParameter<bool>("CreateTrendMEs");
166  trendVsLs_ = conf_.getParameter<bool>("TrendVsLS");
167  Mod_On_ = conf_.getParameter<bool>("Mod_On");
168  ClusterHisto_ = conf_.getParameter<bool>("ClusterHisto");
169 
170  topFolderName_ = conf_.getParameter<std::string>("TopFolderName");
171 
172 
173  // Poducer name of input StripClusterCollection
174  clusterProducerStripToken_ = consumes<edmNew::DetSetVector<SiStripCluster> >(conf_.getParameter<edm::InputTag>("ClusterProducerStrip") );
175  clusterProducerPixToken_ = consumes<edmNew::DetSetVector<SiPixelCluster> >(conf_.getParameter<edm::InputTag>("ClusterProducerPix") );
176  /*
177  clusterProducerStrip_ = conf_.getParameter<edm::InputTag>("ClusterProducerStrip");
178  clusterProducerPix_ = conf_.getParameter<edm::InputTag>("ClusterProducerPix");
179  */
180  // SiStrip Quality Label
181  qualityLabel_ = conf_.getParameter<std::string>("StripQualityLabel");
182  // cluster quality conditions
183  edm::ParameterSet cluster_condition = conf_.getParameter<edm::ParameterSet>("ClusterConditions");
184  applyClusterQuality_ = cluster_condition.getParameter<bool>("On");
185  sToNLowerLimit_ = cluster_condition.getParameter<double>("minStoN");
186  sToNUpperLimit_ = cluster_condition.getParameter<double>("maxStoN");
187  widthLowerLimit_ = cluster_condition.getParameter<double>("minWidth");
188  widthUpperLimit_ = cluster_condition.getParameter<double>("maxWidth");
189 
190  // Event History Producer
191  // historyProducer_ = conf_.getParameter<edm::InputTag>("HistoryProducer");
192  historyProducerToken_ = consumes<EventWithHistory>(conf_.getParameter<edm::InputTag>("HistoryProducer") );
193  // Apv Phase Producer
194  // apvPhaseProducer_ = conf_.getParameter<edm::InputTag>("ApvPhaseProducer");
195  apvPhaseProducerToken_ = consumes<APVCyclePhaseCollection>(conf_.getParameter<edm::InputTag>("ApvPhaseProducer") );
196  // Create DCS Status
197  bool checkDCS = conf_.getParameter<bool>("UseDCSFiltering");
198  if (checkDCS) dcsStatus_ = new SiStripDCSStatus(consumesCollector());
199  else dcsStatus_ = 0;
200 
201 }
202 
203 SiStripMonitorCluster::~SiStripMonitorCluster() {
204  if (dcsStatus_) delete dcsStatus_;
205  if (genTriggerEventFlagBPTXfilter_ ) delete genTriggerEventFlagBPTXfilter_;
206  if (genTriggerEventFlagPixelDCSfilter_) delete genTriggerEventFlagPixelDCSfilter_;
207  if (genTriggerEventFlagStripDCSfilter_) delete genTriggerEventFlagStripDCSfilter_;
208 }
209 
210 
211 //--------------------------------------------------------------------------------------------
212 void SiStripMonitorCluster::dqmBeginRun(const edm::Run& run, const edm::EventSetup &es ) {
213 
214  // Initialize the GenericTriggerEventFlag
215  if ( genTriggerEventFlagBPTXfilter_->on() )
216  genTriggerEventFlagBPTXfilter_->initRun( run, es );
217  if ( genTriggerEventFlagPixelDCSfilter_->on() )
218  genTriggerEventFlagPixelDCSfilter_->initRun( run, es );
219  if ( genTriggerEventFlagStripDCSfilter_->on() )
220  genTriggerEventFlagStripDCSfilter_->initRun( run, es );
221 }
222 
223 //--------------------------------------------------------------------------------------------
224 void SiStripMonitorCluster::createMEs(const edm::EventSetup& es , DQMStore::IBooker & ibooker){
225 
226  if ( show_mechanical_structure_view ){
227 
228  //Retrieve tracker topology from geometry
229  edm::ESHandle<TrackerTopology> tTopoHandle;
230  es.get<TrackerTopologyRcd>().get(tTopoHandle);
231  const TrackerTopology* const tTopo = tTopoHandle.product();
232 
233  // take from eventSetup the SiStripDetCabling object - here will use SiStripDetControl later on
234  es.get<SiStripDetCablingRcd>().get(SiStripDetCabling_);
235 
236  // get list of active detectors from SiStripDetCabling
237  std::vector<uint32_t> activeDets;
238  SiStripDetCabling_->addActiveDetectorsRawIds(activeDets);
239 
240  SiStripSubStructure substructure;
241 
242  SiStripFolderOrganizer folder_organizer;
243  folder_organizer.setSiStripFolderName(topFolderName_);
244  folder_organizer.setSiStripFolder();
245 
246 
247  // Create TkHistoMap for Cluster
248  if (clustertkhistomapon) {
249  // std::cout << "[SiStripMonitorCluster::createMEs] topFolderName_: " << topFolderName_ << " ";
250  if ( (topFolderName_ == "SiStrip") or (std::string::npos != topFolderName_.find("HLT")) )
251  tkmapcluster = new TkHistoMap(ibooker , topFolderName_,"TkHMap_NumberOfCluster",0.,true);
252  else tkmapcluster = new TkHistoMap(ibooker , topFolderName_+"/TkHistoMap","TkHMap_NumberOfCluster",0.,false);
253  }
254 
255  // loop over detectors and book MEs
256  edm::LogInfo("SiStripTkDQM|SiStripMonitorCluster")<<"nr. of activeDets: "<<activeDets.size();
257  for(std::vector<uint32_t>::iterator detid_iterator = activeDets.begin(); detid_iterator!=activeDets.end(); detid_iterator++){
258  uint32_t detid = (*detid_iterator);
259  // remove any eventual zero elements - there should be none, but just in case
260  if(detid == 0) {
261  activeDets.erase(detid_iterator);
262  continue;
263  }
264 
265  if (Mod_On_) {
266  ModMEs mod_single;
267  // set appropriate folder using SiStripFolderOrganizer
268  folder_organizer.setDetectorFolder(detid, tTopo); // pass the detid to this method
269  if (reset_each_run) ResetModuleMEs(detid);
270  createModuleMEs(mod_single, detid , ibooker);
271  // append to ModuleMEsMap
272  ModuleMEsMap.insert( std::make_pair(detid, mod_single));
273  }
274 
275  // Create Layer Level MEs if they are not created already
276  std::pair<std::string,int32_t> det_layer_pair = folder_organizer.GetSubDetAndLayer(detid, tTopo);
277  SiStripHistoId hidmanager;
278  std::string label = hidmanager.getSubdetid(detid,tTopo,false);
279 
280  std::map<std::string, LayerMEs>::iterator iLayerME = LayerMEsMap.find(label);
281  if(iLayerME==LayerMEsMap.end()) {
282 
283  // get detids for the layer
284  int32_t lnumber = det_layer_pair.second;
285  std::vector<uint32_t> layerDetIds;
286  if (det_layer_pair.first == "TIB") {
287  substructure.getTIBDetectors(activeDets,layerDetIds,lnumber,0,0,0);
288  } else if (det_layer_pair.first == "TOB") {
289  substructure.getTOBDetectors(activeDets,layerDetIds,lnumber,0,0);
290  } else if (det_layer_pair.first == "TID" && lnumber > 0) {
291  substructure.getTIDDetectors(activeDets,layerDetIds,2,abs(lnumber),0,0);
292  } else if (det_layer_pair.first == "TID" && lnumber < 0) {
293  substructure.getTIDDetectors(activeDets,layerDetIds,1,abs(lnumber),0,0);
294  } else if (det_layer_pair.first == "TEC" && lnumber > 0) {
295  substructure.getTECDetectors(activeDets,layerDetIds,2,abs(lnumber),0,0,0,0);
296  } else if (det_layer_pair.first == "TEC" && lnumber < 0) {
297  substructure.getTECDetectors(activeDets,layerDetIds,1,abs(lnumber),0,0,0,0);
298  }
299  LayerDetMap[label] = layerDetIds;
300 
301  // book Layer MEs
302  folder_organizer.setLayerFolder(detid,tTopo,det_layer_pair.second);
303  createLayerMEs(label, layerDetIds.size() , ibooker );
304  }
305  // book sub-detector plots
306  auto sdet_pair = folder_organizer.getSubDetFolderAndTag(detid, tTopo);
307  if (SubDetMEsMap.find(sdet_pair.second) == SubDetMEsMap.end()){
308  ibooker.setCurrentFolder(sdet_pair.first);
309 
310  createSubDetMEs(sdet_pair.second , ibooker );
311  }
312  }//end of loop over detectors
313 
314  // Create Global Histogram
315  if (globalswitchapvcycledbxth2on) {
316  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
317  edm::ParameterSet GlobalTH2Parameters = conf_.getParameter<edm::ParameterSet>("TH2ApvCycleVsDBxGlobal");
318  std::string HistoName = "DeltaBx_vs_ApvCycle";
319  GlobalApvCycleDBxTH2 = ibooker.book2D(HistoName,HistoName,
320  GlobalTH2Parameters.getParameter<int32_t>("Nbinsx"),
321  GlobalTH2Parameters.getParameter<double>("xmin"),
322  GlobalTH2Parameters.getParameter<double>("xmax"),
323  GlobalTH2Parameters.getParameter<int32_t>("Nbinsy"),
324  GlobalTH2Parameters.getParameter<double>("ymin"),
325  GlobalTH2Parameters.getParameter<double>("ymax"));
326  GlobalApvCycleDBxTH2->setAxisTitle("APV Cycle (Corrected Absolute Bx % 70)",1);
327  GlobalApvCycleDBxTH2->setAxisTitle("Delta Bunch Crossing Cycle",2);
328  }
329 
330  if (globalswitchcstripvscpix) {
331  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
332  edm::ParameterSet GlobalTH2Parameters = conf_.getParameter<edm::ParameterSet>("TH2CStripVsCpixel");
333  std::string HistoName = "StripClusVsPixClus";
334  GlobalCStripVsCpix = ibooker.book2D(HistoName,HistoName,
335  GlobalTH2Parameters.getParameter<int32_t>("Nbinsx"),
336  GlobalTH2Parameters.getParameter<double>("xmin"),
337  GlobalTH2Parameters.getParameter<double>("xmax"),
338  GlobalTH2Parameters.getParameter<int32_t>("Nbinsy"),
339  GlobalTH2Parameters.getParameter<double>("ymin"),
340  GlobalTH2Parameters.getParameter<double>("ymax"));
341  GlobalCStripVsCpix->setAxisTitle("Strip Clusters",1);
342  GlobalCStripVsCpix->setAxisTitle("Pix Clusters",2);
343  }
344 
345  if (globalswitchMultiRegions){
346  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
347  edm::ParameterSet GlobalTH2Parameters = conf_.getParameter<edm::ParameterSet>("TH1MultiplicityRegions");
348  std::string HistoName = "ClusterMultiplicityRegions";
349  PixVsStripMultiplicityRegions = ibooker.book1D(HistoName,HistoName,
350  GlobalTH2Parameters.getParameter<int32_t>("Nbinx"),
351  GlobalTH2Parameters.getParameter<double>("xmin"),
352  GlobalTH2Parameters.getParameter<double>("xmax"));
353  PixVsStripMultiplicityRegions->setAxisTitle("");
354  PixVsStripMultiplicityRegions->setBinLabel(1,"Main Diagonal");
355  PixVsStripMultiplicityRegions->setBinLabel(2,"Strip Noise");
356  PixVsStripMultiplicityRegions->setBinLabel(3,"High Strip Noise");
357  PixVsStripMultiplicityRegions->setBinLabel(4,"Beam Background");
358  PixVsStripMultiplicityRegions->setBinLabel(5,"No Strip Clusters");
359  }
360 
361  if (globalswitchmaindiagonalposition){
362  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
363  edm::ParameterSet GlobalTH1Parameters = conf_.getParameter<edm::ParameterSet>("TH1MainDiagonalPosition");
364  std::string HistoName = "MainDiagonal Position";
365  GlobalMainDiagonalPosition = ibooker.book1D(HistoName,HistoName,
366  GlobalTH1Parameters.getParameter<int32_t>("Nbinsx"),
367  GlobalTH1Parameters.getParameter<double>("xmin"),
368  GlobalTH1Parameters.getParameter<double>("xmax"));
369  GlobalMainDiagonalPosition->setAxisTitle("atan(NPix/(k*NStrip))");
370  }
371 
372  // TO BE ADDED !!!
373  /*
374  if ( globalswitchapvcycledbxth2on or globalswitchcstripvscpix or globalswitchMultiRegions or ClusterHisto_ ) {
375  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
376  std::string HistoName = "BPTX rate";
377  BPTXrateTrend = ibooker.bookProfile(HistoName,HistoName, LSBin, LSMin, LSMax, 0, 10000.,"");
378  BPTXrateTrend->getTH1()->SetCanExtend(TH1::kAllAxes);
379  BPTXrateTrend->setAxisTitle("#Lumi section",1);
380  BPTXrateTrend->setAxisTitle("Number of BPTX events per LS",2);
381  }
382  */
383 
384  if (globalswitchstripnoise2apvcycle){
385  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
386  edm::ParameterSet GlobalTH1Parameters = conf_.getParameter<edm::ParameterSet>("TH1StripNoise2ApvCycle");
387  std::string HistoName = "StripNoise_ApvCycle";
388  StripNoise2Cycle = ibooker.book1D(HistoName,HistoName,
389  GlobalTH1Parameters.getParameter<int32_t>("Nbinsx"),
390  GlobalTH1Parameters.getParameter<double>("xmin"),
391  GlobalTH1Parameters.getParameter<double>("xmax"));
392  StripNoise2Cycle->setAxisTitle("APV Cycle");
393  }
394 
395  if (globalswitchstripnoise3apvcycle){
396  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
397  edm::ParameterSet GlobalTH1Parameters = conf_.getParameter<edm::ParameterSet>("TH1StripNoise3ApvCycle");
398  std::string HistoName = "HighStripNoise_ApvCycle";
399  StripNoise3Cycle = ibooker.book1D(HistoName,HistoName,
400  GlobalTH1Parameters.getParameter<int32_t>("Nbinsx"),
401  GlobalTH1Parameters.getParameter<double>("xmin"),
402  GlobalTH1Parameters.getParameter<double>("xmax"));
403  StripNoise3Cycle->setAxisTitle("APV Cycle");
404  }
405 
406  if ( globalswitchnclusvscycletimeprof2don ) {
407  const char* HistoName = "StripClusVsBXandOrbit";
408  const char* HistoTitle = "Strip cluster multiplicity vs BX mod(70) and Orbit;Event 1 BX mod(70);time [Orb#]";
409  edm::ParameterSet ParametersNclusVsCycleTimeProf2D = conf_.getParameter<edm::ParameterSet>("NclusVsCycleTimeProf2D");
410  NclusVsCycleTimeProf2D = ibooker.bookProfile2D ( HistoName , HistoTitle ,
411  ParametersNclusVsCycleTimeProf2D.getParameter<int32_t>("Nbins"),
412  ParametersNclusVsCycleTimeProf2D.getParameter<double>("xmin"),
413  ParametersNclusVsCycleTimeProf2D.getParameter<double>("xmax"),
414  ParametersNclusVsCycleTimeProf2D.getParameter<int32_t>("Nbinsy"),
415  ParametersNclusVsCycleTimeProf2D.getParameter<double>("ymin"),
416  ParametersNclusVsCycleTimeProf2D.getParameter<double>("ymax"),
417  0 , 0 );
418  if (NclusVsCycleTimeProf2D->kind() == MonitorElement::DQM_KIND_TPROFILE2D) NclusVsCycleTimeProf2D->getTH1()->SetCanExtend(TH1::kAllAxes);
419  }
420 
421  if (ClusterHisto_){
422  ibooker.setCurrentFolder(topFolderName_+"/MechanicalView/");
423  edm::ParameterSet PixelCluster = conf_.getParameter<edm::ParameterSet>("TH1NClusPx");
424  std::string HistoName = "NumberOfClustersInPixel";
425  NumberOfPixelClus = ibooker.book1D(HistoName, HistoName,
426  PixelCluster.getParameter<int32_t>("Nbinsx"),
427  PixelCluster.getParameter<double>("xmin"),
428  PixelCluster.getParameter<double>("xmax"));
429  NumberOfPixelClus->setAxisTitle("# of Clusters in Pixel", 1);
430  NumberOfPixelClus->setAxisTitle("Number of Events", 2);
431  //
432  edm::ParameterSet StripCluster = conf_.getParameter<edm::ParameterSet>("TH1NClusStrip");
433  HistoName = "NumberOfClustersInStrip";
434  NumberOfStripClus = ibooker.book1D(HistoName, HistoName,
435  StripCluster.getParameter<int32_t>("Nbinsx"),
436  StripCluster.getParameter<double>("xmin"),
437  StripCluster.getParameter<double>("xmax"));
438  NumberOfStripClus->setAxisTitle("# of Clusters in Strip", 1);
439  NumberOfStripClus->setAxisTitle("Number of Events", 2);
440  }
441 
442 
443  }//end of if
444 }//end of method
445 
446 //--------------------------------------------------------------------------------------------
447 
448 void SiStripMonitorCluster::bookHistograms(DQMStore::IBooker & ibooker, const edm::Run& run, const edm::EventSetup& es)
449 {
450  if (show_mechanical_structure_view) {
451  unsigned long long cacheID = es.get<SiStripDetCablingRcd>().cacheIdentifier();
452  if (m_cacheID_ != cacheID) {
453  m_cacheID_ = cacheID;
454  edm::LogInfo("SiStripMonitorCluster") <<"SiStripMonitorCluster::bookHistograms: "
455  << " Creating MEs for new Cabling ";
456 
457  createMEs(es , ibooker);
458  }
459  } else if (reset_each_run) {
460  edm::LogInfo("SiStripMonitorCluster") <<"SiStripMonitorCluster::bookHistograms: "
461  << " Resetting MEs ";
462  for (std::map<uint32_t, ModMEs >::const_iterator idet = ModuleMEsMap.begin() ; idet!=ModuleMEsMap.end() ; idet++) {
463  ResetModuleMEs(idet->first);
464  }
465  }
466 
467 }
468 
469 //--------------------------------------------------------------------------------------------
470 void SiStripMonitorCluster::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
471 {
472  //Retrieve tracker topology from geometry
473  edm::ESHandle<TrackerTopology> tTopoHandle;
474  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
475  const TrackerTopology* const tTopo = tTopoHandle.product();
476 
477  // Filter out events if Trigger Filtering is requested
478  passBPTXfilter_ = ( iEvent.isRealData() and genTriggerEventFlagBPTXfilter_->on() ) ? genTriggerEventFlagBPTXfilter_->accept( iEvent, iSetup) : true;
479  passPixelDCSfilter_ = ( iEvent.isRealData() and genTriggerEventFlagPixelDCSfilter_->on() ) ? genTriggerEventFlagPixelDCSfilter_->accept( iEvent, iSetup) : true;
480  passStripDCSfilter_ = ( iEvent.isRealData() and genTriggerEventFlagStripDCSfilter_->on() ) ? genTriggerEventFlagStripDCSfilter_->accept( iEvent, iSetup) : true;
481  // std::cout << "passBPTXfilter_ ? " << passBPTXfilter_ << std::endl;
482 
483  // Filter out events if DCS Event if requested
484  if (dcsStatus_ && !dcsStatus_->getStatus(iEvent,iSetup)) return;
485 
486  runNb = iEvent.id().run();
487  eventNb++;
488  trendVar = trendVsLs_ ? iEvent.orbitNumber()/262144.0 : iEvent.orbitNumber()/11223.0; // lumisection : seconds
489 
490  int NPixClusters=0, NStripClusters=0, MultiplicityRegion=0;
491  bool isPixValid=false;
492 
493  edm::ESHandle<SiStripNoises> noiseHandle;
494  iSetup.get<SiStripNoisesRcd>().get(noiseHandle);
495 
496  edm::ESHandle<SiStripGain> gainHandle;
497  iSetup.get<SiStripGainRcd>().get(gainHandle);
498 
499  edm::ESHandle<SiStripQuality> qualityHandle;
500  iSetup.get<SiStripQualityRcd>().get(qualityLabel_,qualityHandle);
501 
502  iSetup.get<SiStripDetCablingRcd>().get(SiStripDetCabling_);
503 
504  // get collection of DetSetVector of clusters from Event
505  edm::Handle< edmNew::DetSetVector<SiStripCluster> > cluster_detsetvektor;
506  iEvent.getByToken(clusterProducerStripToken_, cluster_detsetvektor);
507 
508  //get pixel clusters
509  edm::Handle< edmNew::DetSetVector<SiPixelCluster> > cluster_detsetvektor_pix;
510  iEvent.getByToken(clusterProducerPixToken_, cluster_detsetvektor_pix);
511 
512  if (!cluster_detsetvektor.isValid()) return;
513 
514  const edmNew::DetSetVector<SiStripCluster> * StrC= cluster_detsetvektor.product();
515  NStripClusters= StrC->data().size();
516 
517  if (cluster_detsetvektor_pix.isValid()){
518  const edmNew::DetSetVector<SiPixelCluster> * PixC= cluster_detsetvektor_pix.product();
519  NPixClusters= PixC->data().size();
520  isPixValid=true;
521  MultiplicityRegion=FindRegion(NStripClusters,NPixClusters);
522 
523  if ( passBPTXfilter_ and passPixelDCSfilter_ and passStripDCSfilter_ ) {
524  if (globalswitchcstripvscpix) GlobalCStripVsCpix->Fill(NStripClusters,NPixClusters);
525  if (globalswitchmaindiagonalposition && NStripClusters > 0) GlobalMainDiagonalPosition->Fill(atan(NPixClusters/(k0*NStripClusters)));
526  if (globalswitchMultiRegions) PixVsStripMultiplicityRegions->Fill(MultiplicityRegion);
527  }
528 
529  if (ClusterHisto_){
530  if ( passBPTXfilter_ and passPixelDCSfilter_ )
531  NumberOfPixelClus->Fill(NPixClusters);
532  if ( passBPTXfilter_ and passStripDCSfilter_ )
533  NumberOfStripClus->Fill(NStripClusters);
534  }
535  }
536  // initialise # of clusters to zero
537  for (std::map<std::string, SubDetMEs>::iterator iSubdet = SubDetMEsMap.begin();
538  iSubdet != SubDetMEsMap.end(); iSubdet++) {
539  iSubdet->second.totNClusters = 0;
540  }
541 
542  SiStripFolderOrganizer folder_organizer;
543  bool found_layer_me = false;
544  for (std::map<std::string, std::vector< uint32_t > >::const_iterator iterLayer = LayerDetMap.begin();
545  iterLayer != LayerDetMap.end(); iterLayer++) {
546 
547  std::string layer_label = iterLayer->first;
548 
549  int ncluster_layer = 0;
550  std::map<std::string, LayerMEs>::iterator iLayerME = LayerMEsMap.find(layer_label);
551 
552  //get Layer MEs
553  LayerMEs layer_single;
554  if(iLayerME != LayerMEsMap.end()) {
555  layer_single = iLayerME->second;
556  found_layer_me = true;
557  }
558 
559  bool found_module_me = false;
560  uint16_t iDet = 0;
561  std::string subdet_label = "";
562  // loop over all modules in the layer
563  for (std::vector< uint32_t >::const_iterator iterDets = iterLayer->second.begin() ;
564  iterDets != iterLayer->second.end() ; iterDets++) {
565  iDet++;
566  // detid and type of ME
567  uint32_t detid = (*iterDets);
568 
569  // Get SubDet label once
570  if (subdet_label.size() == 0) subdet_label = folder_organizer.getSubDetFolderAndTag(detid, tTopo).second;
571 
572  // DetId and corresponding set of MEs
573  ModMEs mod_single;
574  if (Mod_On_) {
575  std::map<uint32_t, ModMEs >::iterator imodME = ModuleMEsMap.find(detid);
576  if (imodME != ModuleMEsMap.end()) {
577  mod_single = imodME->second;
578  found_module_me = true;
579  }
580  } else found_module_me = false;
581 
582  edmNew::DetSetVector<SiStripCluster>::const_iterator isearch = cluster_detsetvektor->find(detid); // search clusters of detid
583 
584  if(isearch==cluster_detsetvektor->end()){
585  if(found_module_me && moduleswitchncluson && (mod_single.NumberOfClusters)){
586  (mod_single.NumberOfClusters)->Fill(0.); // no clusters for this detector module,fill histogram with 0
587  }
588  if(clustertkhistomapon) tkmapcluster->fill(detid,0.);
589  if (found_layer_me && layerswitchnumclusterprofon) layer_single.LayerNumberOfClusterProfile->Fill(iDet, 0.0);
590  continue; // no clusters for this detid => jump to next step of loop
591  }
592 
593  //cluster_detset is a structure, cluster_detset.data is a std::vector<SiStripCluster>, cluster_detset.id is uint32_t
594  // edmNew::DetSet<SiStripCluster> cluster_detset = (*cluster_detsetvektor)[detid]; // the statement above makes sure there exists an element with 'detid'
595  edmNew::DetSet<SiStripCluster> cluster_detset = (*isearch);
596 
597  // Filling TkHistoMap with number of clusters for each module
598  if(clustertkhistomapon) {
599  tkmapcluster->fill(detid,static_cast<float>(cluster_detset.size()));
600  }
601 
602  if(moduleswitchncluson && found_module_me && (mod_single.NumberOfClusters != NULL)){ // nr. of clusters per module
603  (mod_single.NumberOfClusters)->Fill(static_cast<float>(cluster_detset.size()));
604  }
605 
606  if (found_layer_me && layerswitchnumclusterprofon)
607  layer_single.LayerNumberOfClusterProfile->Fill(iDet, static_cast<float>(cluster_detset.size()));
608  ncluster_layer += cluster_detset.size();
609 
610  short total_clusterized_strips = 0;
611 
612  SiStripNoises::Range detNoiseRange = noiseHandle->getRange(detid);
613  SiStripApvGain::Range detGainRange = gainHandle->getRange(detid);
614  SiStripQuality::Range qualityRange = qualityHandle->getRange(detid);
615 
616  for(edmNew::DetSet<SiStripCluster>::const_iterator clusterIter = cluster_detset.begin(); clusterIter!= cluster_detset.end(); clusterIter++){
617 
618  const auto & ampls = clusterIter->amplitudes();
619  // cluster position
620  float cluster_position = clusterIter->barycenter();
621  // start defined as nr. of first strip beloning to the cluster
622  short cluster_start = clusterIter->firstStrip();
623  // width defined as nr. of strips that belong to cluster
624  short cluster_width = ampls.size();
625  // add nr of strips of this cluster to total nr. of clusterized strips
626  total_clusterized_strips = total_clusterized_strips + cluster_width;
627 
628  // cluster signal and noise from the amplitudes
629  float cluster_signal = 0.0;
630  float cluster_noise = 0.0;
631  int nrnonzeroamplitudes = 0;
632  float noise2 = 0.0;
633  float noise = 0.0;
634  for(uint iamp=0; iamp<ampls.size(); iamp++){
635  if(ampls[iamp]>0){ // nonzero amplitude
636  cluster_signal += ampls[iamp];
637  if(!qualityHandle->IsStripBad(qualityRange, clusterIter->firstStrip()+iamp)){
638  noise = noiseHandle->getNoise(clusterIter->firstStrip()+iamp,detNoiseRange)/gainHandle->getStripGain(clusterIter->firstStrip()+iamp, detGainRange);
639  }
640  noise2 += noise*noise;
641  nrnonzeroamplitudes++;
642  }
643  } // End loop over cluster amplitude
644 
645  if (nrnonzeroamplitudes > 0) cluster_noise = sqrt(noise2/nrnonzeroamplitudes);
646 
647  if( applyClusterQuality_ &&
648  (cluster_signal/cluster_noise < sToNLowerLimit_ ||
649  cluster_signal/cluster_noise > sToNUpperLimit_ ||
650  cluster_width < widthLowerLimit_ ||
651  cluster_width > widthUpperLimit_) ) continue;
652 
653  ClusterProperties cluster_properties;
654  cluster_properties.charge = cluster_signal;
655  cluster_properties.position = cluster_position;
656  cluster_properties.start = cluster_start;
657  cluster_properties.width = cluster_width;
658  cluster_properties.noise = cluster_noise;
659 
660  // Fill Module Level MEs
661  if (found_module_me) fillModuleMEs(mod_single, cluster_properties);
662 
663  // Fill Layer Level MEs
664  if (found_layer_me) {
665  fillLayerMEs(layer_single, cluster_properties);
666  if (layerswitchclusterwidthprofon)
667  layer_single.LayerClusterWidthProfile->Fill(iDet, cluster_width);
668  }
669 
670  if (subdetswitchcluschargeon || subdetswitchcluswidthon)
671  {
672  std::map<std::string, SubDetMEs>::iterator iSubdet = SubDetMEsMap.find(subdet_label);
673  if(iSubdet != SubDetMEsMap.end())
674  {
675  if (subdetswitchcluschargeon) iSubdet->second.SubDetClusterChargeTH1->Fill(cluster_signal);
676  if (subdetswitchcluswidthon) iSubdet->second.SubDetClusterWidthTH1->Fill(cluster_width);
677  }
678  }
679  } // end loop over clusters
680 
681  short total_nr_strips = SiStripDetCabling_->nApvPairs(detid) * 2 * 128; // get correct # of avp pairs
682  float local_occupancy = static_cast<float>(total_clusterized_strips)/static_cast<float>(total_nr_strips);
683  if (found_module_me) {
684  if(moduleswitchnrclusterizedstrip && mod_single.NrOfClusterizedStrips ){ // nr of clusterized strips
685  mod_single.NrOfClusterizedStrips->Fill(static_cast<float>(total_clusterized_strips));
686  }
687 
688  if(moduleswitchlocaloccupancy && mod_single.ModuleLocalOccupancy ){ // Occupancy
689  mod_single.ModuleLocalOccupancy->Fill(local_occupancy);
690  }
691  }
692  if (layerswitchlocaloccupancy && found_layer_me && layer_single.LayerLocalOccupancy) {
693  fillME(layer_single.LayerLocalOccupancy,local_occupancy);
694  if (createTrendMEs)
695  fillME(layer_single.LayerLocalOccupancyTrend,trendVar,local_occupancy);
696  }
697  }
698  std::map<std::string, SubDetMEs>::iterator iSubdet = SubDetMEsMap.find(subdet_label);
699  if(iSubdet != SubDetMEsMap.end()) iSubdet->second.totNClusters += ncluster_layer;
700  }
701 
702  // EventHistory
703  edm::Handle<EventWithHistory> event_history;
704  iEvent.getByToken(historyProducerToken_,event_history);
705 
706  // Phase of APV
707  edm::Handle<APVCyclePhaseCollection> apv_phase_collection;
708  iEvent.getByToken(apvPhaseProducerToken_,apv_phase_collection);
709 
710  if (event_history.isValid()
711  && !event_history.failedToGet()
712  && apv_phase_collection.isValid()
713  && !apv_phase_collection.failedToGet()) {
714 
715 
716  long long dbx = event_history->deltaBX();
717  long long tbx = event_history->absoluteBX();
718 
719  bool global_histo_filled = false;
720  bool MultiplicityRegion_Vs_APVcycle_filled=false;
721 
722  for (std::map<std::string, SubDetMEs>::iterator it = SubDetMEsMap.begin();
723  it != SubDetMEsMap.end(); it++) {
724  std::string sdet = it->first;
725  //std::string sdet = sdet_tag.substr(0,sdet_tag.find_first_of("_"));
726  SubDetMEs sdetmes = it->second;
727 
728  int the_phase = APVCyclePhaseCollection::invalid;
729  long long tbx_corr = tbx;
730 
731  if (SubDetPhasePartMap.find(sdet) != SubDetPhasePartMap.end()) the_phase = apv_phase_collection->getPhase(SubDetPhasePartMap[sdet]);
732  if(the_phase==APVCyclePhaseCollection::nopartition ||
733  the_phase==APVCyclePhaseCollection::multiphase ||
734  the_phase==APVCyclePhaseCollection::invalid) {
735  the_phase=30;
736  //std::cout << " subdet " << it->first << " not valid" << " MR " << MultiplicityRegion <<std::endl;
737  }
738  tbx_corr -= the_phase;
739  long long dbxincycle = event_history->deltaBXinCycle(the_phase);
740  if (globalswitchapvcycledbxth2on && !global_histo_filled) {
741  GlobalApvCycleDBxTH2->Fill(tbx_corr%70,dbx);
742  global_histo_filled = true;
743  }
744 
745  if (isPixValid && !MultiplicityRegion_Vs_APVcycle_filled){
746  if (globalswitchstripnoise2apvcycle && MultiplicityRegion==2) {StripNoise2Cycle->Fill(tbx_corr%70);}
747  if (globalswitchstripnoise3apvcycle && MultiplicityRegion==3) {StripNoise3Cycle->Fill(tbx_corr%70);}
748  MultiplicityRegion_Vs_APVcycle_filled=true;
749  }
750 
751  if (subdetswitchtotclusth1on)
752  sdetmes.SubDetTotClusterTH1->Fill(sdetmes.totNClusters);
753  if (subdetswitchtotclusprofon)
754  sdetmes.SubDetTotClusterProf->Fill(trendVar,sdetmes.totNClusters);
755  if (subdetswitchapvcycleprofon)
756  sdetmes.SubDetClusterApvProf->Fill(tbx_corr%70,sdetmes.totNClusters);
757  if (subdetswitchapvcycleth2on)
758  sdetmes.SubDetClusterApvTH2->Fill(tbx_corr%70,sdetmes.totNClusters);
759  if (subdetswitchdbxcycleprofon)
760  sdetmes.SubDetClusterDBxCycleProf->Fill(dbxincycle,sdetmes.totNClusters);
761  if (subdetswitchapvcycledbxprof2on)
762  sdetmes.SubDetApvDBxProf2->Fill(tbx_corr%70,dbx,sdetmes.totNClusters);
763  }
764 
765  if ( globalswitchnclusvscycletimeprof2don )
766  {
767  long long tbx_corr = tbx;
768  int the_phase = apv_phase_collection->getPhase("All");
769 
770  if( the_phase == APVCyclePhaseCollection::nopartition ||
771  the_phase == APVCyclePhaseCollection::multiphase ||
772  the_phase == APVCyclePhaseCollection::invalid )
773  the_phase=30;
774 
775  tbx_corr -= the_phase;
776 
777  NclusVsCycleTimeProf2D->Fill( tbx_corr%70 , (int)event_history->_orbit , NStripClusters );
778  }
779  }
780 }
781 //
782 // -- Reset MEs
783 //------------------------------------------------------------------------------
784 void SiStripMonitorCluster::ResetModuleMEs(uint32_t idet){
785  std::map<uint32_t, ModMEs >::iterator pos = ModuleMEsMap.find(idet);
786  ModMEs mod_me = pos->second;
787 
788  if (moduleswitchncluson) mod_me.NumberOfClusters->Reset();
789  if (moduleswitchclusposon) mod_me.ClusterPosition->Reset();
790  if (moduleswitchclusdigiposon) mod_me.ClusterDigiPosition->Reset();
791  if (moduleswitchclusstonVsposon) mod_me.ClusterSignalOverNoiseVsPos->Reset();
792  if (moduleswitchcluswidthon) mod_me.ClusterWidth->Reset();
793  if (moduleswitchcluschargeon) mod_me.ClusterCharge->Reset();
794  if (moduleswitchclusnoiseon) mod_me.ClusterNoise->Reset();
795  if (moduleswitchclusstonon) mod_me.ClusterSignalOverNoise->Reset();
796  if (moduleswitchlocaloccupancy) mod_me.ModuleLocalOccupancy->Reset();
797  if (moduleswitchnrclusterizedstrip) mod_me.NrOfClusterizedStrips->Reset();
798 }
799 //
800 // -- Create Module Level MEs
801 //
802 void SiStripMonitorCluster::createModuleMEs(ModMEs& mod_single, uint32_t detid , DQMStore::IBooker & ibooker) {
803 
804  // use SistripHistoId for producing histogram id (and title)
805  SiStripHistoId hidmanager;
806  std::string hid;
807 
808  //nr. of clusters per module
809  if(moduleswitchncluson) {
810  hid = hidmanager.createHistoId("NumberOfClusters","det",detid);
811  mod_single.NumberOfClusters = bookME1D("TH1nClusters", hid.c_str() , ibooker);
812  ibooker.tag(mod_single.NumberOfClusters, detid);
813  mod_single.NumberOfClusters->setAxisTitle("number of clusters in one detector module");
814  mod_single.NumberOfClusters->getTH1()->StatOverflows(kTRUE); // over/underflows in Mean calculation
815  }
816 
817  //ClusterPosition
818  if(moduleswitchclusposon) {
819  short total_nr_strips = SiStripDetCabling_->nApvPairs(detid) * 2 * 128; // get correct # of avp pairs
820  hid = hidmanager.createHistoId("ClusterPosition","det",detid);
821  mod_single.ClusterPosition = ibooker.book1D(hid, hid, total_nr_strips, 0.5, total_nr_strips+0.5);
822  ibooker.tag(mod_single.ClusterPosition, detid);
823  mod_single.ClusterPosition->setAxisTitle("cluster position [strip number +0.5]");
824  }
825 
826  //ClusterDigiPosition
827  if(moduleswitchclusdigiposon) {
828  short total_nr_strips = SiStripDetCabling_->nApvPairs(detid) * 2 * 128; // get correct # of avp pairs
829  hid = hidmanager.createHistoId("ClusterDigiPosition","det",detid);
830  mod_single.ClusterDigiPosition = ibooker.book1D(hid, hid, total_nr_strips, 0.5, total_nr_strips+0.5);
831  ibooker.tag(mod_single.ClusterDigiPosition, detid);
832  mod_single.ClusterDigiPosition->setAxisTitle("digi in cluster position [strip number +0.5]");
833  }
834 
835  //ClusterWidth
836  if(moduleswitchcluswidthon) {
837  hid = hidmanager.createHistoId("ClusterWidth","det",detid);
838  mod_single.ClusterWidth = bookME1D("TH1ClusterWidth", hid.c_str() , ibooker);
839  ibooker.tag(mod_single.ClusterWidth, detid);
840  mod_single.ClusterWidth->setAxisTitle("cluster width [nr strips]");
841  }
842 
843  //ClusterCharge
844  if(moduleswitchcluschargeon) {
845  hid = hidmanager.createHistoId("ClusterCharge","det",detid);
846  mod_single.ClusterCharge = bookME1D("TH1ClusterCharge", hid.c_str() , ibooker );
847  ibooker.tag(mod_single.ClusterCharge, detid);
848  mod_single.ClusterCharge->setAxisTitle("cluster charge [ADC]");
849  }
850 
851  //ClusterNoise
852  if(moduleswitchclusnoiseon) {
853  hid = hidmanager.createHistoId("ClusterNoise","det",detid);
854  mod_single.ClusterNoise = bookME1D("TH1ClusterNoise", hid.c_str() , ibooker );
855  ibooker.tag(mod_single.ClusterNoise, detid);
856  mod_single.ClusterNoise->setAxisTitle("cluster noise");
857  }
858 
859  //ClusterSignalOverNoise
860  if(moduleswitchclusstonon) {
861  hid = hidmanager.createHistoId("ClusterSignalOverNoise","det",detid);
862  mod_single.ClusterSignalOverNoise = bookME1D("TH1ClusterStoN", hid.c_str() , ibooker);
863  ibooker.tag(mod_single.ClusterSignalOverNoise, detid);
864  mod_single.ClusterSignalOverNoise->setAxisTitle("ratio of signal to noise for each cluster");
865  }
866 
867  //ClusterSignalOverNoiseVsPos
868  if(moduleswitchclusstonVsposon) {
869  hid = hidmanager.createHistoId("ClusterSignalOverNoiseVsPos","det",detid);
870  Parameters = conf_.getParameter<edm::ParameterSet>("TH1ClusterStoNVsPos");
871  mod_single.ClusterSignalOverNoiseVsPos= ibooker.bookProfile(hid.c_str(),hid.c_str(),
872  Parameters.getParameter<int32_t>("Nbinx"),
873  Parameters.getParameter<double>("xmin"),
874  Parameters.getParameter<double>("xmax"),
875  Parameters.getParameter<int32_t>("Nbiny"),
876  Parameters.getParameter<double>("ymin"),
877  Parameters.getParameter<double>("ymax")
878  );
879  ibooker.tag(mod_single.ClusterSignalOverNoiseVsPos, detid);
880  mod_single.ClusterSignalOverNoiseVsPos->setAxisTitle("pos");
881  }
882 
883  //ModuleLocalOccupancy
884  if (moduleswitchlocaloccupancy) {
885  hid = hidmanager.createHistoId("ClusterLocalOccupancy","det",detid);
886  mod_single.ModuleLocalOccupancy = bookME1D("TH1ModuleLocalOccupancy", hid.c_str() , ibooker);
887  ibooker.tag(mod_single.ModuleLocalOccupancy, detid);
888  mod_single.ModuleLocalOccupancy->setAxisTitle("module local occupancy [% of clusterized strips]");
889  }
890 
891  //NrOfClusterizedStrips
892  if (moduleswitchnrclusterizedstrip) {
893  hid = hidmanager.createHistoId("NrOfClusterizedStrips","det",detid);
894  mod_single.NrOfClusterizedStrips = bookME1D("TH1NrOfClusterizedStrips", hid.c_str() , ibooker );
895  ibooker.tag(mod_single.NrOfClusterizedStrips, detid);
896  mod_single.NrOfClusterizedStrips->setAxisTitle("number of clusterized strips");
897  }
898 }
899 //
900 // -- Create Module Level MEs
901 //
902 void SiStripMonitorCluster::createLayerMEs(std::string label, int ndets , DQMStore::IBooker & ibooker) {
903 
904  SiStripHistoId hidmanager;
905 
906  LayerMEs layerMEs;
907  layerMEs.LayerClusterStoN = 0;
908  layerMEs.LayerClusterStoNTrend = 0;
909  layerMEs.LayerClusterCharge = 0;
910  layerMEs.LayerClusterChargeTrend = 0;
911  layerMEs.LayerClusterNoise = 0;
912  layerMEs.LayerClusterNoiseTrend = 0;
913  layerMEs.LayerClusterWidth = 0;
914  layerMEs.LayerClusterWidthTrend = 0;
915  layerMEs.LayerLocalOccupancy = 0;
916  layerMEs.LayerLocalOccupancyTrend = 0;
917  layerMEs.LayerNumberOfClusterProfile = 0;
918  layerMEs.LayerClusterWidthProfile = 0;
919 
920  //Cluster Width
921  if(layerswitchcluswidthon) {
922  layerMEs.LayerClusterWidth=bookME1D("TH1ClusterWidth", hidmanager.createHistoLayer("Summary_ClusterWidth","layer",label,"").c_str() , ibooker );
923  if (createTrendMEs)
924  layerMEs.LayerClusterWidthTrend=bookMETrend(hidmanager.createHistoLayer("Trend_ClusterWidth","layer",label,"").c_str() , ibooker );
925  }
926 
927  //Cluster Noise
928  if(layerswitchclusnoiseon) {
929  layerMEs.LayerClusterNoise=bookME1D("TH1ClusterNoise", hidmanager.createHistoLayer("Summary_ClusterNoise","layer",label,"").c_str() , ibooker );
930  if (createTrendMEs)
931  layerMEs.LayerClusterNoiseTrend=bookMETrend(hidmanager.createHistoLayer("Trend_ClusterNoise","layer",label,"").c_str() , ibooker);
932  }
933 
934  //Cluster Charge
935  if(layerswitchcluschargeon) {
936  layerMEs.LayerClusterCharge=bookME1D("TH1ClusterCharge", hidmanager.createHistoLayer("Summary_ClusterCharge","layer",label,"").c_str() , ibooker );
937  if (createTrendMEs)
938  layerMEs.LayerClusterChargeTrend=bookMETrend(hidmanager.createHistoLayer("Trend_ClusterCharge","layer",label,"").c_str(),ibooker);
939  }
940 
941  //Cluster StoN
942  if(layerswitchclusstonon) {
943  layerMEs.LayerClusterStoN=bookME1D("TH1ClusterStoN", hidmanager.createHistoLayer("Summary_ClusterSignalOverNoise","layer",label,"").c_str() , ibooker );
944  if (createTrendMEs)
945  layerMEs.LayerClusterStoNTrend=bookMETrend(hidmanager.createHistoLayer("Trend_ClusterSignalOverNoise","layer",label,"").c_str(),ibooker);
946  }
947 
948  //Cluster Occupancy
949  if(layerswitchlocaloccupancy) {
950  layerMEs.LayerLocalOccupancy=bookME1D("TH1ModuleLocalOccupancy", hidmanager.createHistoLayer("Summary_ClusterLocalOccupancy","layer",label,"").c_str() , ibooker );
951  if (createTrendMEs)
952  layerMEs.LayerLocalOccupancyTrend=bookMETrend(hidmanager.createHistoLayer("Trend_ClusterLocalOccupancy","layer",label,"").c_str(),ibooker);
953  }
954 
955  // # of Cluster Profile
956  if(layerswitchnumclusterprofon) {
957  std::string hid = hidmanager.createHistoLayer("NumberOfClusterProfile","layer",label,"");
958  layerMEs.LayerNumberOfClusterProfile = ibooker.bookProfile(hid, hid, ndets, 0.5, ndets+0.5,21, -0.5, 20.5);
959  }
960 
961  // Cluster Width Profile
962  if(layerswitchclusterwidthprofon) {
963  std::string hid = hidmanager.createHistoLayer("ClusterWidthProfile","layer",label,"");
964  layerMEs.LayerClusterWidthProfile = ibooker.bookProfile(hid, hid, ndets, 0.5, ndets+0.5, 20, -0.5, 19.5);
965  }
966 
967  LayerMEsMap[label]=layerMEs;
968 }
969 //
970 // -- Create SubDetector MEs
971 //
972 void SiStripMonitorCluster::createSubDetMEs(std::string label , DQMStore::IBooker & ibooker ) {
973 
974  SubDetMEs subdetMEs;
975  subdetMEs.totNClusters = 0;
976  subdetMEs.SubDetTotClusterTH1 = 0;
977  subdetMEs.SubDetTotClusterProf = 0;
978  subdetMEs.SubDetClusterApvProf = 0;
979  subdetMEs.SubDetClusterApvTH2 = 0;
980  subdetMEs.SubDetClusterDBxCycleProf = 0;
981  subdetMEs.SubDetApvDBxProf2 = 0;
982  subdetMEs.SubDetClusterChargeTH1 = 0;
983  subdetMEs.SubDetClusterWidthTH1 = 0;
984 
985  std::string HistoName;
986  // cluster charge
987  if (subdetswitchcluschargeon){
988  HistoName = "ClusterCharge__" + label;
989  subdetMEs.SubDetClusterChargeTH1 = bookME1D("TH1ClusterCharge",HistoName.c_str() , ibooker);
990  subdetMEs.SubDetClusterChargeTH1->setAxisTitle("Cluster charge [ADC counts]");
991  subdetMEs.SubDetClusterChargeTH1->getTH1()->StatOverflows(kTRUE); // over/underflows in Mean calculation
992  }
993  // cluster width
994  if (subdetswitchcluswidthon){
995  HistoName = "ClusterWidth__" + label;
996  subdetMEs.SubDetClusterWidthTH1 = bookME1D("TH1ClusterWidth",HistoName.c_str() , ibooker);
997  subdetMEs.SubDetClusterWidthTH1->setAxisTitle("Cluster width [strips]");
998  subdetMEs.SubDetClusterWidthTH1->getTH1()->StatOverflows(kTRUE); // over/underflows in Mean calculation
999  }
1000  // Total Number of Cluster - 1D
1001  if (subdetswitchtotclusth1on){
1002  HistoName = "TotalNumberOfCluster__" + label;
1003  subdetMEs.SubDetTotClusterTH1 = bookME1D("TH1TotalNumberOfClusters",HistoName.c_str() , ibooker);
1004  subdetMEs.SubDetTotClusterTH1->setAxisTitle("Total number of clusters in subdetector");
1005  subdetMEs.SubDetTotClusterTH1->getTH1()->StatOverflows(kTRUE); // over/underflows in Mean calculation
1006  }
1007  // Total Number of Cluster vs Time - Profile
1008  if (subdetswitchtotclusprofon){
1009  edm::ParameterSet Parameters = trendVsLs_ ? conf_.getParameter<edm::ParameterSet>("TrendingLS") : conf_.getParameter<edm::ParameterSet>("Trending");
1010  HistoName = "TotalNumberOfClusterProfile__" + label;
1011  subdetMEs.SubDetTotClusterProf = ibooker.bookProfile(HistoName,HistoName,
1012  Parameters.getParameter<int32_t>("Nbins"),
1013  Parameters.getParameter<double>("xmin"),
1014  Parameters.getParameter<double>("xmax"),
1015  0 , 0 , "" );
1016  subdetMEs.SubDetTotClusterProf->setAxisTitle(Parameters.getParameter<std::string>("xaxis"),1);
1017  if (subdetMEs.SubDetTotClusterProf->kind() == MonitorElement::DQM_KIND_TPROFILE) subdetMEs.SubDetTotClusterProf->getTH1()->SetCanExtend(TH1::kAllAxes);
1018  }
1019 
1020  // Total Number of Cluster vs APV cycle - Profile
1021  if(subdetswitchapvcycleprofon){
1022  edm::ParameterSet Parameters = conf_.getParameter<edm::ParameterSet>("TProfClustersApvCycle");
1023  HistoName = "Cluster_vs_ApvCycle__" + label;
1024  subdetMEs.SubDetClusterApvProf=ibooker.bookProfile(HistoName,HistoName,
1025  Parameters.getParameter<int32_t>("Nbins"),
1026  Parameters.getParameter<double>("xmin"),
1027  Parameters.getParameter<double>("xmax"),
1028  200, //that parameter should not be there !?
1029  Parameters.getParameter<double>("ymin"),
1030  Parameters.getParameter<double>("ymax"),
1031  "" );
1032  subdetMEs.SubDetClusterApvProf->setAxisTitle("Apv Cycle (Corrected Absolute Bx % 70)",1);
1033  }
1034 
1035  // Total Number of Clusters vs ApvCycle - 2D
1036  if(subdetswitchapvcycleth2on){
1037  edm::ParameterSet Parameters = conf_.getParameter<edm::ParameterSet>("TH2ClustersApvCycle");
1038  HistoName = "Cluster_vs_ApvCycle_2D__" + label;
1039  // Adjusting the scale for 2D histogram
1040  double h2ymax = 9999.0;
1041  double yfact = Parameters.getParameter<double>("yfactor");
1042  if(label.find("TIB") != std::string::npos) h2ymax = (6984.*256.)*yfact;
1043  else if (label.find("TID") != std::string::npos) h2ymax = (2208.*256.)*yfact;
1044  else if (label.find("TOB") != std::string::npos) h2ymax = (12906.*256.)*yfact;
1045  else if (label.find("TEC") != std::string::npos) h2ymax = (7552.*2.*256.)*yfact;
1046 
1047  subdetMEs.SubDetClusterApvTH2=ibooker.book2D(HistoName,HistoName,
1048  Parameters.getParameter<int32_t>("Nbinsx"),
1049  Parameters.getParameter<double>("xmin"),
1050  Parameters.getParameter<double>("xmax"),
1051  Parameters.getParameter<int32_t>("Nbinsy"),
1052  Parameters.getParameter<double>("ymin"),
1053  h2ymax);
1054  subdetMEs.SubDetClusterApvTH2->setAxisTitle("Apv Cycle (Corrected Absolute Bx % 70))",1);
1055  subdetMEs.SubDetClusterApvTH2->setAxisTitle("Total # of Clusters",2);
1056 
1057  }
1058  // Total Number of Cluster vs DeltaBxCycle - Profile
1059  if(subdetswitchdbxcycleprofon){
1060  edm::ParameterSet Parameters = conf_.getParameter<edm::ParameterSet>("TProfClustersVsDBxCycle");
1061  HistoName = "Cluster_vs_DeltaBxCycle__" + label;
1062  subdetMEs.SubDetClusterDBxCycleProf = ibooker.bookProfile(HistoName,HistoName,
1063  Parameters.getParameter<int32_t>("Nbins"),
1064  Parameters.getParameter<double>("xmin"),
1065  Parameters.getParameter<double>("xmax"),
1066  200, //that parameter should not be there !?
1067  Parameters.getParameter<double>("ymin"),
1068  Parameters.getParameter<double>("ymax"),
1069  "" );
1070  subdetMEs.SubDetClusterDBxCycleProf->setAxisTitle("Delta Bunch Crossing Cycle",1);
1071  }
1072  // DeltaBx vs ApvCycle - 2DProfile
1073  if(subdetswitchapvcycledbxprof2on){
1074  edm::ParameterSet Parameters = conf_.getParameter<edm::ParameterSet>("TProf2ApvCycleVsDBx");
1075  HistoName = "DeltaBx_vs_ApvCycle__" + label;
1076  subdetMEs.SubDetApvDBxProf2 = ibooker.bookProfile2D(HistoName,HistoName,
1077  Parameters.getParameter<int32_t>("Nbinsx"),
1078  Parameters.getParameter<double>("xmin"),
1079  Parameters.getParameter<double>("xmax"),
1080  Parameters.getParameter<int32_t>("Nbinsy"),
1081  Parameters.getParameter<double>("ymin"),
1082  Parameters.getParameter<double>("ymax"),
1083  Parameters.getParameter<double>("zmin"),
1084  Parameters.getParameter<double>("zmax"),
1085  "" );
1086  subdetMEs.SubDetApvDBxProf2->setAxisTitle("APV Cycle (Corrected Absolute Bx % 70)",1);
1087  subdetMEs.SubDetApvDBxProf2->setAxisTitle("Delta Bunch Crossing Cycle",2);
1088  }
1089  SubDetMEsMap[label]=subdetMEs;
1090 }
1091 
1092 //
1093 // -- Fill Module Level Histograms
1094 //
1095 void SiStripMonitorCluster::fillModuleMEs(ModMEs& mod_mes, ClusterProperties& cluster) {
1096 
1097  if(moduleswitchclusposon && (mod_mes.ClusterPosition)) // position of cluster
1098  (mod_mes.ClusterPosition)->Fill(cluster.position);
1099 
1100  // position of digis in cluster
1101  if(moduleswitchclusdigiposon && (mod_mes.ClusterDigiPosition)) {
1102  for(int ipos=cluster.start+1; ipos<=cluster.start+cluster.width; ipos++){
1103  (mod_mes.ClusterDigiPosition)->Fill(ipos);
1104  }
1105  }
1106 
1107  if(moduleswitchcluswidthon && (mod_mes.ClusterWidth)) // width of cluster
1108  (mod_mes.ClusterWidth)->Fill(static_cast<float>(cluster.width));
1109 
1110  if(moduleswitchclusstonon && (mod_mes.ClusterSignalOverNoise)) {// SignalToNoise
1111  if (cluster.noise > 0)
1112  (mod_mes.ClusterSignalOverNoise)->Fill(cluster.charge/cluster.noise);
1113  }
1114 
1115  if(moduleswitchclusstonVsposon && (mod_mes.ClusterSignalOverNoiseVsPos)) {// SignalToNoise
1116  if (cluster.noise > 0)
1117  (mod_mes.ClusterSignalOverNoiseVsPos)->Fill(cluster.position,cluster.charge/cluster.noise);
1118  }
1119 
1120  if(moduleswitchclusnoiseon && (mod_mes.ClusterNoise)) // Noise
1121  (mod_mes.ClusterNoise)->Fill(cluster.noise);
1122 
1123  if(moduleswitchcluschargeon && (mod_mes.ClusterCharge)) // charge of cluster
1124  (mod_mes.ClusterCharge)->Fill(cluster.charge);
1125 
1126 }
1127 //
1128 // -- Fill Layer Level MEs
1129 //
1130 void SiStripMonitorCluster::fillLayerMEs(LayerMEs& layerMEs, ClusterProperties& cluster) {
1131 
1132  if(layerswitchclusstonon) {
1133  fillME(layerMEs.LayerClusterStoN ,cluster.charge/cluster.noise);
1134  if (createTrendMEs) {
1135  fillME(layerMEs.LayerClusterStoNTrend,trendVar,cluster.charge/cluster.noise);
1136  }
1137  }
1138 
1139  if(layerswitchcluschargeon) {
1140  fillME(layerMEs.LayerClusterCharge,cluster.charge);
1141  if (createTrendMEs) {
1142  fillME(layerMEs.LayerClusterChargeTrend,trendVar,cluster.charge);
1143  }
1144  }
1145 
1146  if(layerswitchclusnoiseon) {
1147  fillME(layerMEs.LayerClusterNoise ,cluster.noise);
1148  if (createTrendMEs) {
1149  fillME(layerMEs.LayerClusterNoiseTrend,trendVar,cluster.noise);
1150  }
1151  }
1152 
1153  if(layerswitchcluswidthon) {
1154  fillME(layerMEs.LayerClusterWidth ,cluster.width);
1155  if (createTrendMEs) {
1156  fillME(layerMEs.LayerClusterWidthTrend,trendVar,cluster.width);
1157  }
1158  }
1159 
1160 }
1161 //------------------------------------------------------------------------------------------
1162 MonitorElement* SiStripMonitorCluster::bookMETrend(const char* HistoName , DQMStore::IBooker & ibooker)
1163 {
1164  edm::ParameterSet ParametersTrend = trendVsLs_ ? conf_.getParameter<edm::ParameterSet>("TrendingLS") : conf_.getParameter<edm::ParameterSet>("Trending");
1165  MonitorElement* me = ibooker.bookProfile(HistoName,HistoName,
1166  ParametersTrend.getParameter<int32_t>("Nbins"),
1167  ParametersTrend.getParameter<double>("xmin"),
1168  ParametersTrend.getParameter<double>("xmax"),
1169  0 , 0 , "" );
1170  if(!me) return me;
1171  me->setAxisTitle(ParametersTrend.getParameter<std::string>("xaxis"),1);
1172  if (me->kind() == MonitorElement::DQM_KIND_TPROFILE) me->getTH1()->SetCanExtend(TH1::kAllAxes);
1173  return me;
1174 }
1175 
1176 //------------------------------------------------------------------------------------------
1177 MonitorElement* SiStripMonitorCluster::bookME1D(const char* ParameterSetLabel, const char* HistoName , DQMStore::IBooker & ibooker)
1178 {
1179  Parameters = conf_.getParameter<edm::ParameterSet>(ParameterSetLabel);
1180  return ibooker.book1D(HistoName,HistoName,
1181  Parameters.getParameter<int32_t>("Nbinx"),
1182  Parameters.getParameter<double>("xmin"),
1183  Parameters.getParameter<double>("xmax")
1184  );
1185 }
1186 
1187 int SiStripMonitorCluster::FindRegion(int nstrip,int npix){
1188 
1189  double kplus= k0*(1+dk0/100);
1190  double kminus=k0*(1-dk0/100);
1191  int region=0;
1192 
1193  if (nstrip!=0 && npix >= (nstrip*kminus-q0) && npix <=(nstrip*kplus+q0)) region=1;
1194  else if (nstrip!=0 && npix < (nstrip*kminus-q0) && nstrip <= maxClus) region=2;
1195  else if (nstrip!=0 && npix < (nstrip*kminus-q0) && nstrip > maxClus) region=3;
1196  else if (nstrip!=0 && npix > (nstrip*kplus+q0)) region=4;
1197  else if (npix > minPix && nstrip==0) region=5;
1198  return region;
1199 
1200 }
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:39
SiStripMonitorCluster::ResetModuleMEs
void ResetModuleMEs(uint32_t idet)
Definition: SiStripMonitorCluster.cc:784
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
SiStripMonitorCluster::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: SiStripMonitorCluster.cc:470
HLT_50ns_5e33_v3_cff.region
tuple region
Definition: HLT_50ns_5e33_v3_cff.py:51638
SiStripMonitorCluster::bookME1D
MonitorElement * bookME1D(const char *ParameterSetLabel, const char *HistoName, DQMStore::IBooker &ibooker)
Definition: SiStripMonitorCluster.cc:1177
SiStripMonitorCluster::FindRegion
int FindRegion(int nstrip, int npixel)
Definition: SiStripMonitorCluster.cc:1187
HLT_25ns14e33_v1_cff.noise
tuple noise
Definition: HLT_25ns14e33_v1_cff.py:2166
edmNew::DetSetVector::const_iterator
boost::transform_iterator< IterHelp, const_IdIter > const_iterator
Definition: DetSetVectorNew.h:124
SiStripFolderOrganizer::setSiStripFolderName
void setSiStripFolderName(std::string name)
Definition: SiStripFolderOrganizer.cc:45
SiStripMonitorCluster::PixVsStripMultiplicityRegions
MonitorElement * PixVsStripMultiplicityRegions
Definition: SiStripMonitorCluster.h:99
SiStripFolderOrganizer::getSubDetFolderAndTag
std::pair< const std::string, const char * > getSubDetFolderAndTag(const uint32_t &detid, const TrackerTopology *tTopo)
Definition: SiStripFolderOrganizer.cc:456
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventIDconst &, edm::Timestampconst & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:457
SiStripMonitorCluster::GlobalCStripVsCpix
MonitorElement * GlobalCStripVsCpix
Definition: SiStripMonitorCluster.h:98
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:920
SiStripMonitorCluster::SiStripDetCabling_
edm::ESHandle< SiStripDetCabling > SiStripDetCabling_
Definition: SiStripMonitorCluster.h:138
SiStripFolderOrganizer::GetSubDetAndLayer
std::pair< std::string, int32_t > GetSubDetAndLayer(const uint32_t &detid, const TrackerTopology *tTopo, bool ring_flag=0)
Definition: SiStripFolderOrganizer.cc:119
NULL
#define NULL
Definition: scimark2.h:8
SiStripMonitorCluster::ModMEs::ClusterSignalOverNoiseVsPos
MonitorElement * ClusterSignalOverNoiseVsPos
Definition: SiStripMonitorCluster.h:56
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:40
SiStripMonitorCluster::StripNoise2Cycle
MonitorElement * StripNoise2Cycle
Definition: SiStripMonitorCluster.h:101
edmNew::DetSet::const_iterator
data_type const * const_iterator
Definition: DetSetNew.h:30
SiStripMonitorCluster::createLayerMEs
void createLayerMEs(std::string label, int ndets, DQMStore::IBooker &ibooker)
Definition: SiStripMonitorCluster.cc:902
SiStripMonitorCluster::LayerMEsMap
std::map< std::string, LayerMEs > LayerMEsMap
Definition: SiStripMonitorCluster.h:129
edm::EventBase::isRealData
bool isRealData() const
Definition: EventBase.h:64
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
SiStripMonitorCluster::LayerDetMap
std::map< std::string, std::vector< uint32_t > > LayerDetMap
Definition: SiStripMonitorCluster.h:130
SiStripMonitorCluster::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: SiStripMonitorCluster.cc:448
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
SiStripMonitorCluster::NumberOfPixelClus
MonitorElement * NumberOfPixelClus
Definition: SiStripMonitorCluster.h:103
SiStripFolderOrganizer::setDetectorFolder
void setDetectorFolder(uint32_t rawdetid, const TrackerTopology *tTopo)
Definition: SiStripFolderOrganizer.cc:211
SiStripMonitorCluster::m_cacheID_
unsigned long long m_cacheID_
Definition: SiStripMonitorCluster.h:136
SiStripMonitorCluster::createSubDetMEs
void createSubDetMEs(std::string label, DQMStore::IBooker &ibooker)
Definition: SiStripMonitorCluster.cc:972
SiStripMonitorCluster::ModuleMEsMap
std::map< uint32_t, ModMEs > ModuleMEsMap
Definition: SiStripMonitorCluster.h:128
SiStripDCSStatus::getStatus
bool getStatus(edm::Event const &e, edm::EventSetup const &eSetup)
Definition: SiStripDCSStatus.cc:45
iEvent
int iEvent
Definition: GenABIO.cc:230
SiStripMonitorCluster::createMEs
void createMEs(const edm::EventSetup &es, DQMStore::IBooker &ibooker)
Definition: SiStripMonitorCluster.cc:224
SiStripMonitorCluster::SubDetPhasePartMap
std::map< std::string, std::string > SubDetPhasePartMap
Definition: SiStripMonitorCluster.h:132
SiStripMonitorCluster::GlobalApvCycleDBxTH2
MonitorElement * GlobalApvCycleDBxTH2
Definition: SiStripMonitorCluster.h:97
Parameters
vector< ParameterSet > Parameters
Definition: HLTMuonPlotter.cc:32
SiStripSubStructure::getTOBDetectors
void getTOBDetectors(const std::vector< uint32_t > &inputDetRawIds, std::vector< uint32_t > &tobDetRawIds, uint32_t layer=0, uint32_t bkw_frw=0, uint32_t rod=0) const
Definition: SiStripSubStructure.cc:77
DQMStore::IBooker::bookProfile2D
MonitorElement * bookProfile2D(Args &&...args)
Definition: DQMStore.h:163
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
SiStripMonitorCluster::genTriggerEventFlagPixelDCSfilter_
GenericTriggerEventFlag * genTriggerEventFlagPixelDCSfilter_
Definition: SiStripMonitorCluster.h:227
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:71
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
TkHistoMap::fill
void fill(uint32_t &detid, float value)
Definition: TkHistoMap.cc:180
GenericTriggerEventFlag::accept
bool accept(const edm::Event &event, const edm::EventSetup &setup)
To be called from analyze/filter() methods.
Definition: GenericTriggerEventFlag.cc:217
edmNew::DetSetVector::data
data_type const * data(size_t cell) const
Definition: DetSetVectorNew.h:391
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
DQMStore::IBooker::tag
void tag(MonitorElement *, unsigned int)
Definition: DQMStore.cc:286
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
SiStripApvGain::Range
std::pair< ContainerIterator, ContainerIterator > Range
Definition: SiStripApvGain.h:27
SiStripMonitorCluster::bookMETrend
MonitorElement * bookMETrend(const char *, DQMStore::IBooker &ibooker)
Definition: SiStripMonitorCluster.cc:1162
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1450
edm::EventBase::orbitNumber
int orbitNumber() const
Definition: EventBase.h:67
SiStripMonitorCluster::NumberOfStripClus
MonitorElement * NumberOfStripClus
Definition: SiStripMonitorCluster.h:104
MonitorElement::kind
Kind kind(void) const
Get the type of the monitor element.
Definition: MonitorElement.h:109
SiStripHistoId::getSubdetid
std::string getSubdetid(uint32_t id, const TrackerTopology *tTopo, bool flag_ring)
Definition: SiStripHistoId.cc:84
SiStripMonitorCluster::dqmBeginRun
void dqmBeginRun(const edm::Run &, const edm::EventSetup &)
Definition: SiStripMonitorCluster.cc:212
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:75
SiStripMonitorCluster::historyProducerToken_
edm::EDGetTokenT< EventWithHistory > historyProducerToken_
Definition: SiStripMonitorCluster.h:208
SiStripMonitorCluster::GlobalMainDiagonalPosition
MonitorElement * GlobalMainDiagonalPosition
Definition: SiStripMonitorCluster.h:100
SiStripMonitorCluster::dcsStatus_
SiStripDCSStatus * dcsStatus_
Definition: SiStripMonitorCluster.h:223
edm::HandleBase::failedToGet
bool failedToGet() const
Definition: HandleBase.h:79
SiStripMonitorCluster::genTriggerEventFlagBPTXfilter_
GenericTriggerEventFlag * genTriggerEventFlagBPTXfilter_
Definition: SiStripMonitorCluster.h:226
SiStripFolderOrganizer::setLayerFolder
void setLayerFolder(uint32_t rawdetid, const TrackerTopology *tTopo, int32_t layer=0, bool ring_flag=0)
Definition: SiStripFolderOrganizer.cc:300
SiStripMonitorCluster::fillME
void fillME(MonitorElement *ME, float value1)
Definition: SiStripMonitorCluster.h:120
SiStripMonitorCluster::SiStripMonitorCluster
SiStripMonitorCluster(const edm::ParameterSet &)
Definition: SiStripMonitorCluster.cc:44
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
edm::Handle::product
T const * product() const
Definition: Handle.h:81
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
SiStripHistoId::createHistoId
std::string createHistoId(std::string description, std::string id_type, uint32_t component_id)
Definition: SiStripHistoId.cc:32
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
cscdqm::HistoName
std::string HistoName
Definition: CSCDQM_HistoDef.h:32
SiStripMonitorCluster::StripNoise3Cycle
MonitorElement * StripNoise3Cycle
Definition: SiStripMonitorCluster.h:102
SiStripMonitorCluster::createModuleMEs
void createModuleMEs(ModMEs &mod_single, uint32_t detid, DQMStore::IBooker &ibooker)
Definition: SiStripMonitorCluster.cc:802
SiStripSubStructure::getTECDetectors
void getTECDetectors(const std::vector< uint32_t > &inputDetRawIds, std::vector< uint32_t > &tecDetRawIds, uint32_t side=0, uint32_t wheel=0, uint32_t petal_bkw_frw=0, uint32_t petal=0, uint32_t ring=0, uint32_t ster=0) const
Definition: SiStripSubStructure.cc:99
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:60
edmNew::DetSet::end
iterator end()
Definition: DetSetNew.h:70
SiStripMonitorCluster::clusterProducerPixToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > clusterProducerPixToken_
Definition: SiStripMonitorCluster.h:207
SiStripMonitorCluster::SubDetMEsMap
std::map< std::string, SubDetMEs > SubDetMEsMap
Definition: SiStripMonitorCluster.h:131
SiStripMonitorCluster::fillLayerMEs
void fillLayerMEs(LayerMEs &, ClusterProperties &cluster)
Definition: SiStripMonitorCluster.cc:1130
SiStripBadStrip::Range
std::pair< ContainerIterator, ContainerIterator > Range
Definition: SiStripBadStrip.h:54
SiStripSubStructure::getTIBDetectors
void getTIBDetectors(const std::vector< uint32_t > &inputDetRawIds, std::vector< uint32_t > &tibDetRawIds, uint32_t layer=0, uint32_t bkw_frw=0, uint32_t int_ext=0, uint32_t string=0) const
Definition: SiStripSubStructure.cc:29
SiStripMonitorCluster::clusterProducerStripToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > clusterProducerStripToken_
Definition: SiStripMonitorCluster.h:206
SiStripSubStructure::getTIDDetectors
void getTIDDetectors(const std::vector< uint32_t > &inputDetRawIds, std::vector< uint32_t > &tidDetRawIds, uint32_t side=0, uint32_t wheel=0, uint32_t ring=0, uint32_t ster=0) const
Definition: SiStripSubStructure.cc:53
edm::false
volatile std::atomic< bool > shutdown_flag false
Definition: UnixSignalHandlers.cc:22
GenericTriggerEventFlag::initRun
void initRun(const edm::Run &run, const edm::EventSetup &setup)
To be called from beginRun() methods.
Definition: GenericTriggerEventFlag.cc:129
SiStripHistoId::createHistoLayer
std::string createHistoLayer(std::string description, std::string id_type, std::string path, std::string flag)
Definition: SiStripHistoId.cc:57
SiStripNoises::Range
std::pair< ContainerIterator, ContainerIterator > Range
Definition: SiStripNoises.h:48
edmNew::DetSet::size
size_type size() const
Definition: DetSetNew.h:86
SiStripMonitorCluster::apvPhaseProducerToken_
edm::EDGetTokenT< APVCyclePhaseCollection > apvPhaseProducerToken_
Definition: SiStripMonitorCluster.h:209
SiStripMonitorCluster::genTriggerEventFlagStripDCSfilter_
GenericTriggerEventFlag * genTriggerEventFlagStripDCSfilter_
Definition: SiStripMonitorCluster.h:228
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:453
SiStripMonitorCluster::NclusVsCycleTimeProf2D
MonitorElement * NclusVsCycleTimeProf2D
Definition: SiStripMonitorCluster.h:106
SiStripMonitorCluster::fillModuleMEs
void fillModuleMEs(ModMEs &mod_mes, ClusterProperties &cluster)
Definition: SiStripMonitorCluster.cc:1095
edm::Run
Definition: Run.h:41
SiPixelCluster::size
int size() const
Definition: SiPixelCluster.h:136
edmNew::DetSet::begin
iterator begin()
Definition: DetSetNew.h:67
Generated for CMSSW Reference Manual by doxygen 1.8.5