CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Attributes | Friends
EcalEndcapMonitorClient Class Reference

#include <EcalEndcapMonitorClient.h>

Inheritance diagram for EcalEndcapMonitorClient:
edm::EDAnalyzer EcalEndcapMonitorDbClient EcalEndcapMonitorXdaqClient

Public Member Functions

void analyze (void)
 Analyze. More...
 
void analyze (const edm::Event &e, const edm::EventSetup &c)
 
void beginJob (void)
 BeginJob. More...
 
void beginLuminosityBlock (const edm::LuminosityBlock &l, const edm::EventSetup &c)
 BeginLumiBlock. More...
 
void beginRun (void)
 BeginRun. More...
 
void beginRun (const edm::Run &r, const edm::EventSetup &c)
 
void beginRunDb (void)
 BeginRunDB. More...
 
void cleanup (void)
 Cleanup. More...
 
 EcalEndcapMonitorClient (const edm::ParameterSet &ps)
 Constructor. More...
 
void endJob (void)
 EndJob. More...
 
void endLuminosityBlock (const edm::LuminosityBlock &l, const edm::EventSetup &c)
 EndLumiBlock. More...
 
void endRun (void)
 EndRun. More...
 
void endRun (const edm::Run &r, const edm::EventSetup &c)
 
void endRunDb (void)
 EndRunDB. More...
 
const char * getRunType (void)
 
void reset (void)
 Reset. More...
 
void setup (void)
 Setup. More...
 
void softReset (bool flag)
 SoftReset. More...
 
void writeDb (void)
 WriteDB. More...
 
virtual ~EcalEndcapMonitorClient ()
 Destructor. More...
 
- Public Member Functions inherited from edm::EDAnalyzer
 EDAnalyzer ()
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 

Private Attributes

bool begin_run_
 
std::vector< EEClient * > clients_
 
std::vector< std::string > clientsNames_
 
std::multimap< EEClient *, int > clientsRuns_
 
std::map< std::string, int > clientsStatus_
 
bool cloneME_
 
time_t current_time_
 
std::string dbHostName_
 
int dbHostPort_
 
std::string dbName_
 
std::string dbPassword_
 
std::string dbTagName_
 
time_t dbUpdateTime_
 
std::string dbUserName_
 
bool debug_
 
DQMStore * dqmStore_
 
bool enableCleanup_
 
std::vector< std::string > enabledClients_
 
bool end_run_
 
int evt_
 
int evtType_
 
bool forced_status_
 
bool forced_update_
 
TH1F * h_
 
int ievt_
 
std::string inputFile_
 
int jevt_
 
int last_run_
 
time_t last_time_reset_
 
time_t last_time_update_
 
std::string location_
 
bool mergeRuns_
 
std::string prefixME_
 
int prescaleFactor_
 
std::string referenceFile_
 
std::string resetFile_
 
int run_
 
int runType_
 
std::vector< std::string > runTypes_
 
std::string status_
 
int subrun_
 
EESummaryClient * summaryClient_
 
std::vector< int > superModules_
 
time_t updateTime_
 
bool verbose_
 

Friends

class EcalEndcapMonitorXdaqClient
 

Additional Inherited Members

- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
typedef WorkerT< EDAnalyzer > WorkerType
 
- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const * currentContext () const
 

Detailed Description

Definition at line 36 of file EcalEndcapMonitorClient.h.

Constructor & Destructor Documentation

EcalEndcapMonitorClient::EcalEndcapMonitorClient ( const edm::ParameterSet &  ps)

Constructor.

Definition at line 63 of file EcalEndcapMonitorClient.cc.

References EcalDCCHeaderBlock::BEAMH2, EcalDCCHeaderBlock::BEAMH4, EcalDCCHeaderBlock::CALIB_LOCAL, clients_, clientsNames_, clientsRuns_, clientsStatus_, cloneME_, EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, gather_cfg::cout, dbHostName_, dbHostPort_, dbName_, dbPassword_, dbTagName_, dbUpdateTime_, dbUserName_, debug_, enableCleanup_, enabledClients_, spr::find(), edm::ParameterSet::getUntrackedParameter(), EcalDCCHeaderBlock::HALO_GLOBAL, EcalDCCHeaderBlock::HALO_LOCAL, i, inputFile_, EcalDCCHeaderBlock::LASER_GAP, EcalDCCHeaderBlock::LASER_STD, EcalDCCHeaderBlock::LED_GAP, EcalDCCHeaderBlock::LED_STD, location_, mergeRuns_, EcalDCCHeaderBlock::MTCC, EcalDCCHeaderBlock::PEDESTAL_GAP, EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN, EcalDCCHeaderBlock::PEDESTAL_STD, EcalDCCHeaderBlock::PHYSICS_GLOBAL, EcalDCCHeaderBlock::PHYSICS_LOCAL, prefixME_, prescaleFactor_, resetFile_, runTypes_, EESummaryClient::setFriends(), summaryClient_, superModules_, EcalDCCHeaderBlock::TESTPULSE_GAP, EcalDCCHeaderBlock::TESTPULSE_MGPA, updateTime_, and verbose_.

63  {
64 
65  // verbose switch
66 
67  verbose_ = ps.getUntrackedParameter<bool>("verbose", true);
68 
69  if ( verbose_ ) {
70  std::cout << std::endl;
71  std::cout << " *** Ecal Endcap Generic Monitor Client ***" << std::endl;
72  std::cout << std::endl;
73  }
74 
75  // DQM ROOT input file
76 
77  inputFile_ = ps.getUntrackedParameter<std::string>("inputFile", "");
78 
79  if ( verbose_ ) {
80  if ( inputFile_.size() != 0 ) {
81  std::cout << " Reading DQM data from inputFile '" << inputFile_ << "'" << std::endl;
82  }
83  }
84 
85  // Ecal Cond DB
86 
87  dbName_ = ps.getUntrackedParameter<std::string>("dbName", "");
88  dbHostName_ = ps.getUntrackedParameter<std::string>("dbHostName", "");
89  dbHostPort_ = ps.getUntrackedParameter<int>("dbHostPort", 1521);
90  dbUserName_ = ps.getUntrackedParameter<std::string>("dbUserName", "");
91  dbPassword_ = ps.getUntrackedParameter<std::string>("dbPassword", "");
92 
93  dbTagName_ = ps.getUntrackedParameter<std::string>("dbTagName", "CMSSW");
94 
95  if ( verbose_ ) {
96  if ( dbName_.size() != 0 ) {
97  std::cout << " Ecal Cond DB: " << std::endl;
98  std::cout << " dbName = '" << dbName_ << "'" << std::endl;
99  std::cout << " dbUserName = '" << dbUserName_ << "'" << std::endl;
100  if ( dbHostName_.size() != 0 ) {
101  std::cout << " dbHostName = '" << dbHostName_ << "'" << std::endl;
102  std::cout << " dbHostPort = '" << dbHostPort_ << "'" << std::endl;
103  }
104  std::cout << " dbTagName = '" << dbTagName_ << "'" << std::endl;
105 #ifndef WITH_ECAL_COND_DB
106  std::cout << std::endl;
107  std::cout << "WARNING: DB access is NOT available" << std::endl;
108  std::cout << std::endl;
109 #endif
110  } else {
111  std::cout << " Ecal Cond DB is OFF" << std::endl;
112  }
113  }
114 
115  // mergeRuns switch
116 
117  mergeRuns_ = ps.getUntrackedParameter<bool>("mergeRuns", false);
118 
119  if ( verbose_ ) {
120  if ( mergeRuns_ ) {
121  std::cout << " mergeRuns switch is ON" << std::endl;
122  } else {
123  std::cout << " mergeRuns switch is OFF" << std::endl;
124  }
125  }
126 
127  // resetFile
128 
129  resetFile_ = ps.getUntrackedParameter<std::string>("resetFile", "");
130 
131  if ( verbose_ ) {
132  if ( resetFile_.size() != 0 ) {
133  std::cout << " resetFile is '" << resetFile_ << "'" << std::endl;
134  }
135  }
136 
137  // updateTime
138 
139  updateTime_ = ps.getUntrackedParameter<int>("updateTime", 0);
140 
141  if ( verbose_ ) {
142  std::cout << " updateTime is " << updateTime_ << " minute(s)" << std::endl;
143  }
144 
145  // dbUpdateTime
146 
147  dbUpdateTime_ = ps.getUntrackedParameter<int>("dbUpdateTime", 0);
148 
149  if ( verbose_ ) {
150  std::cout << " dbUpdateTime is " << dbUpdateTime_ << " minute(s)" << std::endl;
151  }
152 
153  // location
154 
155  location_ = ps.getUntrackedParameter<std::string>("location", "H4");
156 
157  if ( verbose_ ) {
158  std::cout << " location is '" << location_ << "'" << std::endl;
159  }
160 
161  // cloneME switch
162 
163  cloneME_ = ps.getUntrackedParameter<bool>("cloneME", true);
164 
165  if ( verbose_ ) {
166  if ( cloneME_ ) {
167  std::cout << " cloneME switch is ON" << std::endl;
168  } else {
169  std::cout << " cloneME switch is OFF" << std::endl;
170  }
171  }
172 
173  // debug switch
174 
175  debug_ = ps.getUntrackedParameter<bool>("debug", false);
176 
177  if ( verbose_ ) {
178  if ( debug_ ) {
179  std::cout << " debug switch is ON" << std::endl;
180  } else {
181  std::cout << " debug switch is OFF" << std::endl;
182  }
183  }
184 
185  // prescaleFactor
186 
187  prescaleFactor_ = ps.getUntrackedParameter<int>("prescaleFactor", 1);
188 
189  if ( verbose_ ) {
190  std::cout << " prescaleFactor is " << prescaleFactor_ << std::endl;
191  }
192 
193  // prefixME path
194 
195  prefixME_ = ps.getUntrackedParameter<std::string>("prefixME", "");
196 
197  if ( verbose_ ) {
198  std::cout << " prefixME path is '" << prefixME_ << "'" << std::endl;
199  }
200 
201  // enableCleanup switch
202 
203  enableCleanup_ = ps.getUntrackedParameter<bool>("enableCleanup", false);
204 
205  if ( verbose_ ) {
206  if ( enableCleanup_ ) {
207  std::cout << " enableCleanup switch is ON" << std::endl;
208  } else {
209  std::cout << " enableCleanup switch is OFF" << std::endl;
210  }
211  }
212 
213  // vector of selected Super Modules (Defaults to all 18).
214 
215  superModules_.reserve(18);
216  for ( unsigned int i = 1; i <= 18; i++ ) superModules_.push_back(i);
217 
218  superModules_ = ps.getUntrackedParameter<std::vector<int> >("superModules", superModules_);
219 
220  if ( verbose_ ) {
221  std::cout << " Selected SMs:" << std::endl;
222  for ( unsigned int i = 0; i < superModules_.size(); i++ ) {
223  std::cout << " " << std::setw(2) << std::setfill('0') << superModules_[i];
224  }
225  std::cout << std::endl;
226  }
227 
228  // vector of enabled Clients (defaults)
229 
230  enabledClients_.push_back("Integrity");
231  enabledClients_.push_back("StatusFlags");
232  enabledClients_.push_back("PedestalOnline");
233  enabledClients_.push_back("Summary");
234 
235  enabledClients_ = ps.getUntrackedParameter<std::vector<std::string> >("enabledClients", enabledClients_);
236 
237  if ( verbose_ ) {
238  std::cout << " Enabled Clients:" << std::endl;
239  for ( unsigned int i = 0; i < enabledClients_.size(); i++ ) {
240  std::cout << " " << enabledClients_[i];
241  }
242  std::cout << std::endl;
243  }
244 
245  // set runTypes (use resize() on purpose!)
246 
247  runTypes_.resize(30);
248  for ( unsigned int i = 0; i < runTypes_.size(); i++ ) runTypes_[i] = "UNKNOWN";
249 
250  runTypes_[EcalDCCHeaderBlock::COSMIC] = "COSMIC";
251  runTypes_[EcalDCCHeaderBlock::BEAMH4] = "BEAM";
252  runTypes_[EcalDCCHeaderBlock::BEAMH2] = "BEAM";
253  runTypes_[EcalDCCHeaderBlock::MTCC] = "MTCC";
254  runTypes_[EcalDCCHeaderBlock::LASER_STD] = "LASER";
255  runTypes_[EcalDCCHeaderBlock::LED_STD] = "LED";
256  runTypes_[EcalDCCHeaderBlock::TESTPULSE_MGPA] = "TEST_PULSE";
257  runTypes_[EcalDCCHeaderBlock::PEDESTAL_STD] = "PEDESTAL";
258  runTypes_[EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN] = "PEDESTAL-OFFSET";
259 
260  runTypes_[EcalDCCHeaderBlock::COSMICS_GLOBAL] = "COSMIC";
261  runTypes_[EcalDCCHeaderBlock::PHYSICS_GLOBAL] = "PHYSICS";
262  runTypes_[EcalDCCHeaderBlock::HALO_GLOBAL] = "HALO";
263  runTypes_[EcalDCCHeaderBlock::COSMICS_LOCAL] = "COSMIC";
264  runTypes_[EcalDCCHeaderBlock::PHYSICS_LOCAL] = "PHYSICS";
265  runTypes_[EcalDCCHeaderBlock::HALO_LOCAL] = "HALO";
266 
267  runTypes_[EcalDCCHeaderBlock::LASER_GAP] = "LASER";
268  runTypes_[EcalDCCHeaderBlock::LED_GAP] = "LED";
269  runTypes_[EcalDCCHeaderBlock::TESTPULSE_GAP] = "TEST_PULSE";
270  runTypes_[EcalDCCHeaderBlock::PEDESTAL_GAP] = "PEDESTAL";
271 
272  runTypes_[EcalDCCHeaderBlock::CALIB_LOCAL] = "CALIB";
273 
274  // clients' constructors
275 
276  clients_.reserve(12);
277  clientsNames_.reserve(12);
278 
279  if ( find(enabledClients_.begin(), enabledClients_.end(), "Integrity" ) != enabledClients_.end() ) {
280 
281  clients_.push_back( new EEIntegrityClient(ps) );
282  clientsNames_.push_back( "Integrity" );
283 
284  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
285  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
286  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
287  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
288  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN ));
289  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
290  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
291  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
292  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
293 
294  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
295  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
296  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
297  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
298  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
299  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
300  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
301  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
302 
303  }
304 
305  if ( find(enabledClients_.begin(), enabledClients_.end(), "StatusFlags" ) != enabledClients_.end() ) {
306 
307  clients_.push_back( new EEStatusFlagsClient(ps) );
308  clientsNames_.push_back( "StatusFlags" );
309 
310  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
311  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
312  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
313  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
314  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN ));
315  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
316  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
317  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
318  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
319 
320  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
321  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
322  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
323  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
324  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
325  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
326  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
327  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
328 
329  }
330 
331  if ( find(enabledClients_.begin(), enabledClients_.end(), "Occupancy" ) != enabledClients_.end() ) {
332 
333  clients_.push_back( new EEOccupancyClient(ps) );
334  clientsNames_.push_back( "Occupancy" );
335 
336  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
337  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
338  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
339  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
340  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_OFFSET_SCAN ));
341  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
342  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
343  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
344  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
345 
346  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
347  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
348  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
349  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
350  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
351  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
352  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
353  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
354 
355  }
356 
357  if ( find(enabledClients_.begin(), enabledClients_.end(), "Cosmic" ) != enabledClients_.end() ) {
358 
359  clients_.push_back( new EECosmicClient(ps) );
360  clientsNames_.push_back( "Cosmic" );
361 
362  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
363  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
364  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
365  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
366  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
367  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
368 
369  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
370  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
371  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
372  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
373  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
374  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
375  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
376  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
377 
378  }
379 
380  if ( find(enabledClients_.begin(), enabledClients_.end(), "Laser" ) != enabledClients_.end() ) {
381 
382  clients_.push_back( new EELaserClient(ps) );
383  clientsNames_.push_back( "Laser" );
384 
385  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
386  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
387  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
388  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
389  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
390  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
391  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
392  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
393 
394  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
395  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
396  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
397  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
398  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
399  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
400  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
401  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
402 
403  }
404 
405  if ( find(enabledClients_.begin(), enabledClients_.end(), "Pedestal" ) != enabledClients_.end() ) {
406 
407  clients_.push_back( new EEPedestalClient(ps) );
408  clientsNames_.push_back( "Pedestal" );
409 
410  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
411  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
412  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
413  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
414  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
415  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
416  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
417  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
418 
419  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
420  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
421  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
422  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
423  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
424  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
425  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
426  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
427 
428  }
429 
430  if ( find(enabledClients_.begin(), enabledClients_.end(), "PedestalOnline" ) != enabledClients_.end() ) {
431 
432  clients_.push_back( new EEPedestalOnlineClient(ps) );
433  clientsNames_.push_back( "PedestalOnline" );
434 
435  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
436  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
437  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
438  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
439  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
440  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
441  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
442  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
443 
444  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
445  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
446  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
447  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
448  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
449  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
450  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
451  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
452 
453  }
454 
455  if ( find(enabledClients_.begin(), enabledClients_.end(), "TestPulse" ) != enabledClients_.end() ) {
456 
457  clients_.push_back( new EETestPulseClient(ps) );
458  clientsNames_.push_back( "TestPulse" );
459 
460  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
461  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
462  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
463  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
464  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
465  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
466  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
467  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
468 
469  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
470  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
471  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
472  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
473  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
474  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
475  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
476  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
477 
478  }
479 
480  if ( find(enabledClients_.begin(), enabledClients_.end(), "BeamCalo" ) != enabledClients_.end() ) {
481 
482  clients_.push_back( new EEBeamCaloClient(ps) );
483  clientsNames_.push_back( "BeamCalo" );
484 
485  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
486  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
487 
488  }
489 
490  if ( find(enabledClients_.begin(), enabledClients_.end(), "BeamHodo" ) != enabledClients_.end() ) {
491 
492  clients_.push_back( new EEBeamHodoClient(ps) );
493  clientsNames_.push_back( "BeamHodo" );
494 
495  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
496  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
497 
498  }
499 
500  if ( find(enabledClients_.begin(), enabledClients_.end(), "TriggerTower" ) != enabledClients_.end() ) {
501 
502  clients_.push_back( new EETriggerTowerClient(ps) );
503  clientsNames_.push_back( "TriggerTower" );
504 
505  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
506  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
507  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
508  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
509  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
510  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
511  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
512  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
513 
514  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
515  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
516  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
517  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
518  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
519  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
520  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
521  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
522 
523  }
524 
525  if ( find(enabledClients_.begin(), enabledClients_.end(), "Cluster" ) != enabledClients_.end() ) {
526 
527  clients_.push_back( new EEClusterClient(ps) );
528  clientsNames_.push_back( "Cluster" );
529 
530  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
531  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
532  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
533  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
534  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
535  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
536  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
537  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
538 
539  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
540  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
541  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
542  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
543  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
544  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
545  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
546  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
547 
548  }
549 
550  if ( find(enabledClients_.begin(), enabledClients_.end(), "Timing" ) != enabledClients_.end() ) {
551 
552  clients_.push_back( new EETimingClient(ps) );
553  clientsNames_.push_back( "Timing" );
554 
555  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
556  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
557  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
558  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
559  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
560  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
561  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
562  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
563 
564  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_GLOBAL ));
565  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
566  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMICS_LOCAL ));
567  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
568  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
569  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
570  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
571  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
572 
573  }
574 
575  if ( find(enabledClients_.begin(), enabledClients_.end(), "Led" ) != enabledClients_.end() ) {
576 
577  clients_.push_back( new EELedClient(ps) );
578  clientsNames_.push_back( "Led" );
579 
580  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::COSMIC ));
581  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_STD ));
582  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_STD ));
583  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_STD ));
584  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_MGPA ));
585  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH4 ));
586  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::BEAMH2 ));
587  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::MTCC ));
588 
589  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_GLOBAL ));
590  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PHYSICS_LOCAL ));
591  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LASER_GAP ));
592  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::LED_GAP ));
593  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::TESTPULSE_GAP ));
594  clientsRuns_.insert(std::pair<EEClient*,int>( clients_.back(), EcalDCCHeaderBlock::PEDESTAL_GAP ));
595 
596  }
597 
598  // define status bits
599 
600  clientsStatus_.insert(std::pair<std::string,int>( "Integrity", 0 ));
601  clientsStatus_.insert(std::pair<std::string,int>( "Cosmic", 1 ));
602  clientsStatus_.insert(std::pair<std::string,int>( "Laser", 2 ));
603  clientsStatus_.insert(std::pair<std::string,int>( "Pedestal", 3 ));
604  clientsStatus_.insert(std::pair<std::string,int>( "PedestalOnline", 4 ));
605  clientsStatus_.insert(std::pair<std::string,int>( "TestPulse", 5 ));
606  clientsStatus_.insert(std::pair<std::string,int>( "BeamCalo", 6 ));
607  clientsStatus_.insert(std::pair<std::string,int>( "BeamHodo", 7 ));
608  clientsStatus_.insert(std::pair<std::string,int>( "TriggerTower", 8 ));
609  clientsStatus_.insert(std::pair<std::string,int>( "Cluster", 9 ));
610  clientsStatus_.insert(std::pair<std::string,int>( "Timing", 10 ));
611  clientsStatus_.insert(std::pair<std::string,int>( "Led", 11 ));
612  clientsStatus_.insert(std::pair<std::string,int>( "StatusFlags", 12 ));
613  clientsStatus_.insert(std::pair<std::string,int>( "Occupancy", 13 ));
614 
615  if ( find(enabledClients_.begin(), enabledClients_.end(), "Summary" ) != enabledClients_.end() ) {
616 
617  summaryClient_ = new EESummaryClient(ps);
618 
619  }
620 
621  if ( summaryClient_ ) summaryClient_->setFriends(clients_);
622 
623  if ( verbose_ ) std::cout << std::endl;
624 
625 }
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
EcalEndcapMonitorClient::runTypes_
std::vector< std::string > runTypes_
Definition: EcalEndcapMonitorClient.h:146
EESummaryClient::setFriends
void setFriends(std::vector< EEClient * > clients)
Set Clients.
Definition: EESummaryClient.h:72
EcalEndcapMonitorClient::clientsStatus_
std::map< std::string, int > clientsStatus_
Definition: EcalEndcapMonitorClient.h:149
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:7
EcalEndcapMonitorClient::clientsNames_
std::vector< std::string > clientsNames_
Definition: EcalEndcapMonitorClient.h:148
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
EcalEndcapMonitorClient::enabledClients_
std::vector< std::string > enabledClients_
Definition: EcalEndcapMonitorClient.h:143
EcalEndcapMonitorClient::clientsRuns_
std::multimap< EEClient *, int > clientsRuns_
Definition: EcalEndcapMonitorClient.h:145
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
EcalEndcapMonitorClient::~EcalEndcapMonitorClient ( )
virtual

Destructor.

Definition at line 627 of file EcalEndcapMonitorClient.cc.

References clients_, gather_cfg::cout, i, summaryClient_, and verbose_.

627  {
628 
629  if ( verbose_ ) std::cout << "Exit ..." << std::endl;
630 
631  for ( unsigned int i=0; i<clients_.size(); i++ ) {
632  delete clients_[i];
633  }
634 
635  if ( summaryClient_ ) delete summaryClient_;
636 
637 }
i
int i
Definition: DBlmapReader.cc:9
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41

Member Function Documentation

void EcalEndcapMonitorClient::analyze ( void  )

Analyze.

Definition at line 1458 of file EcalEndcapMonitorClient.cc.

References EESummaryClient::analyze(), EcalDCCHeaderBlock::BEAMH2, EcalDCCHeaderBlock::BEAMH4, begin_run_, beginRun(), clients_, clientsRuns_, cloneME_, EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, gather_cfg::cout, current_time_, dbUpdateTime_, debug_, generateEDF::done, dqmStore_, end_run_, endRun(), evt_, evtType_, forced_status_, forced_update_, DQMStore::get(), getRunType(), h_, i, ievt_, inputFile_, j, jevt_, last_run_, last_time_reset_, location_, mergeRuns_, NULL, EcalDCCHeaderBlock::PHYSICS_GLOBAL, EcalDCCHeaderBlock::PHYSICS_LOCAL, prefixME_, prescaleFactor_, reset(), resetFile_, run_, runType_, runTypes_, asciidump::s, softReset(), status_, summaryClient_, cond::rpcobgas::time, update, MonitorElement::valueString(), verbose_, and writeDb().

Referenced by analyze(), endJob(), endLuminosityBlock(), and endRun().

1458  {
1459 
1460  current_time_ = time(NULL);
1461 
1462  ievt_++;
1463  jevt_++;
1464 
1465  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: ievt/jevt = " << ievt_ << "/" << jevt_ << std::endl;
1466 
1467  MonitorElement* me;
1468  std::string s;
1469 
1470  me = dqmStore_->get(prefixME_ + "/EcalInfo/STATUS");
1471  if ( me ) {
1472  status_ = "unknown";
1473  s = me->valueString();
1474  if ( strcmp(s.c_str(), "i=0") == 0 ) status_ = "begin-of-run";
1475  if ( strcmp(s.c_str(), "i=1") == 0 ) status_ = "running";
1476  if ( strcmp(s.c_str(), "i=2") == 0 ) status_ = "end-of-run";
1477  if ( debug_ ) std::cout << "Found '" << prefixME_ << "/EcalInfo/STATUS'" << std::endl;
1478  }
1479 
1480  if ( inputFile_.size() != 0 ) {
1481  if ( ievt_ == 1 ) {
1482  if ( verbose_ ) {
1483  std::cout << std::endl;
1484  std::cout << " Reading DQM from file, forcing 'begin-of-run'" << std::endl;
1485  std::cout << std::endl;
1486  }
1487  status_ = "begin-of-run";
1488  }
1489  }
1490 
1491  int ecal_run = -1;
1492  me = dqmStore_->get(prefixME_ + "/EcalInfo/RUN");
1493  if ( me ) {
1494  s = me->valueString();
1495  sscanf(s.c_str(), "i=%d", &ecal_run);
1496  if ( debug_ ) std::cout << "Found '" << prefixME_ << "/EcalInfo/RUN'" << std::endl;
1497  }
1498 
1499  int ecal_evt = -1;
1500  me = dqmStore_->get(prefixME_ + "/EcalInfo/EVT");
1501  if ( me ) {
1502  s = me->valueString();
1503  sscanf(s.c_str(), "i=%d", &ecal_evt);
1504  if ( debug_ ) std::cout << "Found '" << prefixME_ << "/EcalInfo/EVT'" << std::endl;
1505  }
1506 
1507  me = dqmStore_->get(prefixME_ + "/EcalInfo/EVTTYPE");
1508  h_ = UtilsClient::getHisto<TH1F*>( me, cloneME_, h_ );
1509 
1510  me = dqmStore_->get(prefixME_ + "/EcalInfo/RUNTYPE");
1511  if ( me ) {
1512  s = me->valueString();
1513  sscanf(s.c_str(), "i=%d", &evtType_);
1514  if ( runType_ == -1 ) runType_ = evtType_;
1515  if ( debug_ ) std::cout << "Found '" << prefixME_ << "/EcalInfo/RUNTYPE'" << std::endl;
1516  }
1517 
1518  // if the run number from the Event is less than zero,
1519  // use the run number from the ECAL DCC header
1520  if ( run_ <= 0 ) run_ = ecal_run;
1521 
1522  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
1523  if ( ! mergeRuns_ && run_ != last_run_ ) forced_update_ = true;
1524  }
1525 
1526  bool update = ( forced_update_ ) ||
1527  ( prescaleFactor_ != 1 ) ||
1528  ( jevt_ < 10 ) ||
1529  ( jevt_ < 100 && jevt_ % 10 == 0 ) ||
1530  ( jevt_ < 1000 && jevt_ % 100 == 0 ) ||
1531  ( jevt_ % 1000 == 0 );
1532 
1533  if ( update || strcmp(status_.c_str(), "begin-of-run") == 0 || strcmp(status_.c_str(), "end-of-run") == 0 ) {
1534 
1535  if ( verbose_ ) {
1536  std::cout << " RUN status = \"" << status_ << "\"" << std::endl;
1537  std::cout << " CMS run/event number = " << run_ << "/" << evt_ << std::endl;
1538  std::cout << " EE run/event number = " << ecal_run << "/" << ecal_evt << std::endl;
1539  std::cout << " EE location = " << location_ << std::endl;
1540  std::cout << " EE run/event type = " << this->getRunType() << "/" << ( evtType_ == -1 ? "UNKNOWN" : runTypes_[evtType_] ) << std::flush;
1541 
1542  if ( h_ ) {
1543  if ( h_->GetSumOfWeights() != 0 ) {
1544  std::cout << " ( " << std::flush;
1545  for ( unsigned int i = 0; i < runTypes_.size(); i++ ) {
1546  if ( strcmp(runTypes_[i].c_str(), "UNKNOWN") != 0 && h_->GetBinContent(2+i) != 0 ) {
1547  std::string s = runTypes_[i];
1548  transform( s.begin(), s.end(), s.begin(), (int(*)(int))tolower );
1549  std::cout << s << " ";
1550  }
1551  }
1552  std::cout << ")" << std::flush;
1553  }
1554  }
1555  std::cout << std::endl;
1556  }
1557 
1558  }
1559 
1560  if ( strcmp(status_.c_str(), "begin-of-run") == 0 ) {
1561 
1562  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
1563 
1564  if ( ! begin_run_ ) {
1565 
1566  forced_status_ = false;
1567  this->beginRun();
1568 
1569  }
1570 
1571  }
1572 
1573  }
1574 
1575  if ( strcmp(status_.c_str(), "begin-of-run") == 0 || strcmp(status_.c_str(), "running") == 0 || strcmp(status_.c_str(), "end-of-run") == 0 ) {
1576 
1577  if ( begin_run_ && ! end_run_ ) {
1578 
1579  bool update = ( forced_update_ ) ||
1580  ( prescaleFactor_ != 1 ) ||
1581  ( jevt_ < 3 ) ||
1582  ( jevt_ < 1000 && jevt_ % 100 == 0 ) ||
1583  ( jevt_ < 10000 && jevt_ % 1000 == 0 ) ||
1584  ( jevt_ % 10000 == 0 );
1585 
1586  if ( update || strcmp(status_.c_str(), "begin-of-run") == 0 || strcmp(status_.c_str(), "end-of-run") == 0 ) {
1587 
1588  for ( int i=0; i<int(clients_.size()); i++ ) {
1589  bool done = false;
1590  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
1591  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
1592  done = true;
1593  clients_[i]->analyze();
1594  }
1595  }
1596  }
1597 
1598  if ( summaryClient_ ) summaryClient_->analyze();
1599 
1600  }
1601 
1602  forced_update_ = false;
1603 
1604  bool reset = false;
1605 
1606  if ( resetFile_.size() != 0 ) {
1607  if ( access(resetFile_.c_str(), W_OK) == 0 ) {
1608  if ( unlink(resetFile_.c_str()) == 0 ) {
1609  reset |= true;
1610  }
1611  }
1612  }
1613 
1614  if ( dbUpdateTime_ > 0 ) {
1615  reset |= (current_time_ - last_time_reset_) > 60 * dbUpdateTime_;
1616  }
1617 
1618  if ( reset ) {
1619  if ( runType_ == EcalDCCHeaderBlock::COSMIC ||
1620  runType_ == EcalDCCHeaderBlock::COSMICS_GLOBAL ||
1621  runType_ == EcalDCCHeaderBlock::PHYSICS_GLOBAL ||
1622  runType_ == EcalDCCHeaderBlock::COSMICS_LOCAL ||
1623  runType_ == EcalDCCHeaderBlock::PHYSICS_LOCAL ||
1624  runType_ == EcalDCCHeaderBlock::BEAMH2 ||
1625  runType_ == EcalDCCHeaderBlock::BEAMH4 ) this->writeDb();
1626  this->softReset(true);
1627  last_time_reset_ = current_time_;
1628  }
1629 
1630  }
1631 
1632  }
1633 
1634  if ( strcmp(status_.c_str(), "end-of-run") == 0 ) {
1635 
1636  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
1637 
1638  if ( begin_run_ && ! end_run_ ) {
1639 
1640  forced_status_ = false;
1641  this->endRun();
1642 
1643  }
1644 
1645  }
1646 
1647  }
1648 
1649  // BEGIN: run-time fixes for missing state transitions
1650 
1651  // run number transition
1652 
1653  if ( strcmp(status_.c_str(), "running") == 0 ) {
1654 
1655  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
1656 
1657  if ( ! mergeRuns_ ) {
1658 
1659  int new_run_ = run_;
1660  int old_run_ = last_run_;
1661 
1662  if ( new_run_ != old_run_ ) {
1663 
1664  if ( begin_run_ && ! end_run_ ) {
1665 
1666  if ( verbose_ ) {
1667  std::cout << std::endl;
1668  std::cout << " Old run has finished, issuing endRun() ... " << std::endl;
1669  std::cout << std::endl;
1670  }
1671 
1672  // end old_run_
1673  run_ = old_run_;
1674 
1675  forced_status_ = false;
1676  this->endRun();
1677 
1678  }
1679 
1680  if ( ! begin_run_ ) {
1681 
1682  if ( verbose_ ) {
1683  std::cout << std::endl;
1684  std::cout << " New run has started, issuing beginRun() ... " << std::endl;
1685  std::cout << std::endl;
1686  }
1687 
1688  // start new_run_
1689  run_ = new_run_;
1690 
1691  forced_status_ = false;
1692  this->beginRun();
1693 
1694  }
1695 
1696  }
1697 
1698  }
1699 
1700  }
1701 
1702  }
1703 
1704  // 'running' state without a previous 'begin-of-run' state
1705 
1706  if ( strcmp(status_.c_str(), "running") == 0 ) {
1707 
1708  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
1709 
1710  if ( ! forced_status_ ) {
1711 
1712  if ( ! begin_run_ ) {
1713 
1714  if ( verbose_ ) {
1715  std::cout << std::endl;
1716  std::cout << "Forcing beginRun() ... NOW !" << std::endl;
1717  std::cout << std::endl;
1718  }
1719 
1720  forced_status_ = true;
1721  this->beginRun();
1722 
1723  }
1724 
1725  }
1726 
1727  }
1728 
1729  }
1730 
1731  // 'end-of-run' state without a previous 'begin-of-run' or 'running' state
1732 
1733  if ( strcmp(status_.c_str(), "end-of-run") == 0 ) {
1734 
1735  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
1736 
1737  if ( ! forced_status_ ) {
1738 
1739  if ( ! begin_run_ ) {
1740 
1741  if ( verbose_ ) {
1742  std::cout << std::endl;
1743  std::cout << "Forcing beginRun() ... NOW !" << std::endl;
1744  std::cout << std::endl;
1745  }
1746 
1747  forced_status_ = true;
1748  this->beginRun();
1749 
1750  }
1751 
1752  }
1753 
1754  }
1755 
1756  }
1757 
1758  // END: run-time fixes for missing state transitions
1759 
1760 }
i
int i
Definition: DBlmapReader.cc:9
EcalEndcapMonitorClient::runTypes_
std::vector< std::string > runTypes_
Definition: EcalEndcapMonitorClient.h:146
EESummaryClient::analyze
void analyze(void)
Analyze.
Definition: EESummaryClient.cc:1380
NULL
#define NULL
Definition: scimark2.h:8
j
int j
Definition: DBlmapReader.cc:9
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1270
MonitorElement::valueString
std::string valueString(void) const
Definition: MonitorElement.cc:471
EcalEndcapMonitorClient::softReset
void softReset(bool flag)
SoftReset.
Definition: EcalEndcapMonitorClient.cc:1773
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
EcalEndcapMonitorClient::clientsRuns_
std::multimap< EEClient *, int > clientsRuns_
Definition: EcalEndcapMonitorClient.h:145
update
#define update(a, b)
Definition: TrackClassifier.cc:10
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
asciidump.s
string s
Definition: asciidump.py:422
void EcalEndcapMonitorClient::analyze ( const edm::Event &  e,
const edm::EventSetup &  c 
)
virtual

Implements edm::EDAnalyzer.

Definition at line 1762 of file EcalEndcapMonitorClient.cc.

References analyze(), edm::EventID::event(), evt_, edm::EventBase::id(), jevt_, prescaleFactor_, edm::EventID::run(), and run_.

1762  {
1763 
1764  run_ = e.id().run();
1765  evt_ = e.id().event();
1766 
1767  if ( prescaleFactor_ > 0 ) {
1768  if ( jevt_ % prescaleFactor_ == 0 ) this->analyze();
1769  }
1770 
1771 }
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:42
edm::EventID::event
EventNumber_t event() const
Definition: EventID.h:44
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:56
void EcalEndcapMonitorClient::beginJob ( void  )
virtual

BeginJob.

Reimplemented from edm::EDAnalyzer.

Definition at line 639 of file EcalEndcapMonitorClient.cc.

References begin_run_, EESummaryClient::beginJob(), DQMStore::book2D(), DQMStore::bookFloat(), clients_, gather_cfg::cout, current_time_, debug_, dqmStore_, end_run_, evt_, evtType_, MonitorElement::Fill(), forced_status_, forced_update_, DQMStore::get(), MonitorElement::getName(), h_, trackerHits::histo, i, ievt_, inputFile_, jevt_, last_run_, last_time_reset_, last_time_update_, NULL, DQMStore::open(), cmsCodeRules.cppFunctionSkipper::operator, prefixME_, DQMStore::removeElement(), run_, runType_, Numbers::sEE(), MonitorElement::setAxisTitle(), MonitorElement::setBinContent(), DQMStore::setCurrentFolder(), status_, subrun_, summaryClient_, and cond::rpcobgas::time.

639  {
640 
641  begin_run_ = false;
642  end_run_ = false;
643 
644  forced_status_ = false;
645  forced_update_ = false;
646 
647  h_ = 0;
648 
649  status_ = "unknown";
650 
651  run_ = -1;
652  evt_ = -1;
653 
654  runType_ = -1;
655  evtType_ = -1;
656 
657  last_run_ = -1;
658 
659  subrun_ = -1;
660 
661  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: beginJob" << std::endl;
662 
663  ievt_ = 0;
664  jevt_ = 0;
665 
666  current_time_ = time(NULL);
667  last_time_update_ = current_time_;
668  last_time_reset_ = current_time_;
669 
670  // get hold of back-end interface
671  dqmStore_ = edm::Service<DQMStore>().operator->();
672 
673  if ( inputFile_.size() != 0 ) {
674  if ( dqmStore_ ) {
675  dqmStore_->open(inputFile_);
676  }
677  }
678 
679  for ( unsigned int i=0; i<clients_.size(); i++ ) {
680  clients_[i]->beginJob();
681  }
682 
683  if ( summaryClient_ ) summaryClient_->beginJob();
684 
685  // summary for DQM GUI
686 
687  char histo[200];
688 
689  MonitorElement* me;
690 
691  dqmStore_->setCurrentFolder( prefixME_ + "/EventInfo" );
692 
693  sprintf(histo, "reportSummary");
694  me = dqmStore_->get(prefixME_ + "/EventInfo/" + histo);
695  if ( me ) {
696  dqmStore_->removeElement(me->getName());
697  }
698  me = dqmStore_->bookFloat(histo);
699  me->Fill(-1.0);
700 
701  dqmStore_->setCurrentFolder( prefixME_ + "/EventInfo/reportSummaryContents" );
702 
703  for (int i = 0; i < 18; i++) {
704  sprintf(histo, "EcalEndcap_%s", Numbers::sEE(i+1).c_str());
705  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummaryContents/" + histo);
706  if ( me ) {
707  dqmStore_->removeElement(me->getName());
708  }
709  me = dqmStore_->bookFloat(histo);
710  me->Fill(-1.0);
711  }
712 
713  dqmStore_->setCurrentFolder( prefixME_ + "/EventInfo" );
714 
715  sprintf(histo, "reportSummaryMap");
716  me = dqmStore_->get(prefixME_ + "/EventInfo/" + histo);
717  if ( me ) {
718  dqmStore_->removeElement(me->getName());
719  }
720  me = dqmStore_->book2D(histo, histo, 200, 0., 200., 100, 0., 100);
721  for ( int jx = 1; jx <= 200; jx++ ) {
722  for ( int jy = 1; jy <= 100; jy++ ) {
723  me->setBinContent( jx, jy, -1.0 );
724  }
725  }
726  me->setAxisTitle("ix / ix+100", 1);
727  me->setAxisTitle("iy", 2);
728 
729 }
EESummaryClient::beginJob
void beginJob(void)
BeginJob.
Definition: EESummaryClient.cc:218
MonitorElement::getName
const std::string & getName(void) const
get name of ME
Definition: MonitorElement.h:99
i
int i
Definition: DBlmapReader.cc:9
MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:800
Numbers::sEE
static std::string sEE(const int ism)
Definition: Numbers.cc:199
NULL
#define NULL
Definition: scimark2.h:8
trackerHits.histo
tuple histo
Definition: trackerHits.py:12
DQMStore::bookFloat
MonitorElement * bookFloat(const char *name)
Book float.
Definition: DQMStore.cc:456
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:147
DQMStore::removeElement
void removeElement(const std::string &name)
Definition: DQMStore.cc:2338
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1270
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
DQMStore::open
bool open(const std::string &filename, bool overwrite=false, const std::string &path="", const std::string &prepend="", OpenRunDirs stripdirs=KeepRunDirs, bool fileMustExist=true)
Definition: DQMStore.cc:2198
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:647
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:903
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:237
void EcalEndcapMonitorClient::beginLuminosityBlock ( const edm::LuminosityBlock &  l,
const edm::EventSetup &  c 
)
virtual

BeginLumiBlock.

Reimplemented from edm::EDAnalyzer.

Definition at line 944 of file EcalEndcapMonitorClient.cc.

References gather_cfg::cout, edm::LuminosityBlockBase::id(), edm::LuminosityBlockID::luminosityBlock(), edm::LuminosityBlockID::run(), and verbose_.

944  {
945 
946  if ( verbose_ ) {
947  std::cout << std::endl;
948  std::cout << "Standard beginLuminosityBlock() for luminosity block " << l.id().luminosityBlock() << " of run " << l.id().run() << std::endl;
949  std::cout << std::endl;
950  }
951 
952 }
edm::LuminosityBlockBase::id
LuminosityBlockID id() const
Definition: LuminosityBlockBase.h:52
edm::LuminosityBlockID::run
RunNumber_t run() const
Definition: LuminosityBlockID.h:42
edm::LuminosityBlockID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockID.h:43
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::beginRun ( void  )

BeginRun.

Definition at line 731 of file EcalEndcapMonitorClient.cc.

References begin_run_, EESummaryClient::beginRun(), beginRunDb(), clients_, clientsRuns_, gather_cfg::cout, current_time_, debug_, generateEDF::done, end_run_, i, j, jevt_, last_run_, last_time_reset_, last_time_update_, NULL, run_, runType_, setup(), summaryClient_, and cond::rpcobgas::time.

Referenced by analyze().

731  {
732 
733  begin_run_ = true;
734  end_run_ = false;
735 
736  last_run_ = run_;
737 
738  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: beginRun" << std::endl;
739 
740  jevt_ = 0;
741 
742  current_time_ = time(NULL);
743  last_time_update_ = current_time_;
744  last_time_reset_ = current_time_;
745 
746  this->setup();
747 
748  this->beginRunDb();
749 
750  for ( int i=0; i<int(clients_.size()); i++ ) {
751  clients_[i]->cleanup();
752  bool done = false;
753  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
754  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
755  done = true;
756  clients_[i]->beginRun();
757  }
758  }
759  }
760 
761  if ( summaryClient_ ) summaryClient_->beginRun();
762 
763 }
i
int i
Definition: DBlmapReader.cc:9
NULL
#define NULL
Definition: scimark2.h:8
EcalEndcapMonitorClient::beginRunDb
void beginRunDb(void)
BeginRunDB.
Definition: EcalEndcapMonitorClient.cc:1000
EESummaryClient::beginRun
void beginRun(void)
BeginRun.
Definition: EESummaryClient.cc:229
j
int j
Definition: DBlmapReader.cc:9
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
EcalEndcapMonitorClient::clientsRuns_
std::multimap< EEClient *, int > clientsRuns_
Definition: EcalEndcapMonitorClient.h:145
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::beginRun ( const edm::Run &  r,
const edm::EventSetup &  c 
)
virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 765 of file EcalEndcapMonitorClient.cc.

References gather_cfg::cout, evt_, edm::RunBase::id(), Numbers::initGeometry(), Masks::initMasking(), jevt_, edm::RunID::run(), run_, and verbose_.

765  {
766 
767  Numbers::initGeometry(c, verbose_);
768 
769  if ( verbose_ ) std::cout << std::endl;
770 
771  Masks::initMasking(c, verbose_);
772 
773  if ( verbose_ ) {
774  std::cout << std::endl;
775  std::cout << "Standard beginRun() for run " << r.id().run() << std::endl;
776  std::cout << std::endl;
777  }
778 
779  run_ = r.id().run();
780  evt_ = 0;
781 
782  jevt_ = 0;
783 
784 }
edm::RunBase::id
RunID const & id() const
Definition: RunBase.h:43
edm::RunID::run
RunNumber_t run() const
Definition: RunID.h:44
Masks::initMasking
static void initMasking(const edm::EventSetup &setup, bool verbose=false)
Definition: Masks.cc:34
Numbers::initGeometry
static void initGeometry(const edm::EventSetup &setup, bool verbose=false)
Definition: Numbers.cc:43
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::beginRunDb ( void  )

BeginRunDB.

Definition at line 1000 of file EcalEndcapMonitorClient.cc.

References ExpressReco_HICollisions_FallBack::cerr, gather_cfg::cout, dbHostName_, dbHostPort_, dbName_, dbPassword_, dbUserName_, ExpressReco_HICollisions_FallBack::e, EcalCondDBInterface::fetchRunIOV(), getRunType(), i, EcalCondDBInterface::insertRunIOV(), location_, run_, runType_, runTypes_, RunTag::setGeneralTag(), LocationDef::setLocation(), RunTag::setLocationDef(), RunTypeDef::setRunType(), RunTag::setRunTypeDef(), Tm::setToCurrentGMTime(), subrun_, and verbose_.

Referenced by beginRun().

1000  {
1001 
1002  subrun_ = 0;
1003 
1004 #ifdef WITH_ECAL_COND_DB
1005  EcalCondDBInterface* econn;
1006 
1007  econn = 0;
1008 
1009  if ( dbName_.size() != 0 ) {
1010  try {
1011  if ( verbose_ ) std::cout << "Opening DB connection with TNS_ADMIN ..." << std::endl;
1012  econn = new EcalCondDBInterface(dbName_, dbUserName_, dbPassword_);
1013  if ( verbose_ ) std::cout << "done." << std::endl;
1014  } catch (std::runtime_error &e) {
1015  std::cerr << e.what() << std::endl;
1016  if ( dbHostName_.size() != 0 ) {
1017  try {
1018  if ( verbose_ ) std::cout << "Opening DB connection without TNS_ADMIN ..." << std::endl;
1019  econn = new EcalCondDBInterface(dbHostName_, dbName_, dbUserName_, dbPassword_, dbHostPort_);
1020  if ( verbose_ ) std::cout << "done." << std::endl;
1021  } catch (std::runtime_error &e) {
1022  std::cerr << e.what() << std::endl;
1023  }
1024  }
1025  }
1026  }
1027 
1028  // create the objects necessary to identify a dataset
1029 
1030  LocationDef locdef;
1031 
1032  locdef.setLocation(location_);
1033 
1034  RunTypeDef rundef;
1035 
1036  rundef.setRunType( this->getRunType() );
1037 
1038  RunTag runtag;
1039 
1040  runtag.setLocationDef(locdef);
1041  runtag.setRunTypeDef(rundef);
1042 
1043  runtag.setGeneralTag( this->getRunType() );
1044 
1045  // fetch the RunIOV from the DB
1046 
1047  bool foundRunIOV = false;
1048 
1049  if ( econn ) {
1050  try {
1051  if ( verbose_ ) std::cout << "Fetching RunIOV ..." << std::endl;
1052 // runiov_ = econn->fetchRunIOV(&runtag, run_);
1053  runiov_ = econn->fetchRunIOV(location_, run_);
1054  if ( verbose_ ) std::cout << "done." << std::endl;
1055  foundRunIOV = true;
1056  } catch (std::runtime_error &e) {
1057  std::cerr << e.what() << std::endl;
1058  foundRunIOV = false;
1059  }
1060  }
1061 
1062  // begin - setup the RunIOV (on behalf of the DAQ)
1063 
1064  if ( ! foundRunIOV ) {
1065 
1066  Tm startRun;
1067 
1068  startRun.setToCurrentGMTime();
1069 
1070  runiov_.setRunNumber(run_);
1071  runiov_.setRunStart(startRun);
1072  runiov_.setRunTag(runtag);
1073 
1074  if ( econn ) {
1075  try {
1076  if ( verbose_ ) std::cout << "Inserting RunIOV ..." << std::endl;
1077  econn->insertRunIOV(&runiov_);
1078 // runiov_ = econn->fetchRunIOV(&runtag, run_);
1079  runiov_ = econn->fetchRunIOV(location_, run_);
1080  if ( verbose_ ) std::cout << "done." << std::endl;
1081  } catch (std::runtime_error &e) {
1082  std::cerr << e.what() << std::endl;
1083  try {
1084  if ( verbose_ ) std::cout << "Fetching RunIOV (again) ..." << std::endl;
1085 // runiov_ = econn->fetchRunIOV(&runtag, run_);
1086  runiov_ = econn->fetchRunIOV(location_, run_);
1087  if ( verbose_ ) std::cout << "done." << std::endl;
1088  foundRunIOV = true;
1089  } catch (std::runtime_error &e) {
1090  std::cerr << e.what() << std::endl;
1091  foundRunIOV = false;
1092  }
1093  }
1094  }
1095 
1096  }
1097 
1098  // end - setup the RunIOV (on behalf of the DAQ)
1099 
1100  if ( verbose_ ) {
1101  std::cout << std::endl;
1102  std::cout << "=============RunIOV:" << std::endl;
1103  std::cout << "Run Number: " << runiov_.getRunNumber() << std::endl;
1104  std::cout << "Run Start: " << runiov_.getRunStart().str() << std::endl;
1105  std::cout << "Run End: " << runiov_.getRunEnd().str() << std::endl;
1106  std::cout << "====================" << std::endl;
1107  std::cout << std::endl;
1108  std::cout << "=============RunTag:" << std::endl;
1109  std::cout << "GeneralTag: " << runiov_.getRunTag().getGeneralTag() << std::endl;
1110  std::cout << "Location: " << runiov_.getRunTag().getLocationDef().getLocation() << std::endl;
1111  std::cout << "Run Type: " << runiov_.getRunTag().getRunTypeDef().getRunType() << std::endl;
1112  std::cout << "====================" << std::endl;
1113  std::cout << std::endl;
1114  }
1115 
1116  std::string rt = runiov_.getRunTag().getRunTypeDef().getRunType();
1117  if ( strcmp(rt.c_str(), "UNKNOWN") == 0 ) {
1118  runType_ = -1;
1119  } else {
1120  for ( unsigned int i = 0; i < runTypes_.size(); i++ ) {
1121  if ( strcmp(rt.c_str(), runTypes_[i].c_str()) == 0 ) {
1122  if ( runType_ != int(i) ) {
1123  if ( verbose_ ) {
1124  std::cout << std::endl;
1125  std::cout << "Fixing Run Type to: " << runTypes_[i] << std::endl;
1126  std::cout << std::endl;
1127  }
1128  runType_ = i;
1129  }
1130  break;
1131  }
1132  }
1133  }
1134 
1135  if ( verbose_ ) std::cout << std::endl;
1136 
1137  if ( econn ) {
1138  try {
1139  if ( verbose_ ) std::cout << "Closing DB connection ..." << std::endl;
1140  delete econn;
1141  econn = 0;
1142  if ( verbose_ ) std::cout << "done." << std::endl;
1143  } catch (std::runtime_error &e) {
1144  std::cerr << e.what() << std::endl;
1145  }
1146  }
1147 #endif
1148 
1149  if ( verbose_ ) std::cout << std::endl;
1150 
1151 }
ExpressReco_HICollisions_FallBack.e
tuple e
Definition: ExpressReco_HICollisions_FallBack.py:1068
i
int i
Definition: DBlmapReader.cc:9
RunTag::setLocationDef
void setLocationDef(const LocationDef locDef)
Definition: RunTag.cc:53
EcalCondDBInterface::insertRunIOV
void insertRunIOV(RunIOV *iov)
Definition: EcalCondDBInterface.cc:380
EcalEndcapMonitorClient::runTypes_
std::vector< std::string > runTypes_
Definition: EcalEndcapMonitorClient.h:146
RunTag
Definition: RunTag.h:13
EcalCondDBInterface::fetchRunIOV
RunIOV fetchRunIOV(RunTag *tag, run_t run)
Definition: EcalCondDBInterface.cc:528
Tm::setToCurrentGMTime
void setToCurrentGMTime()
Definition: Tm.cc:156
RunTag::setRunTypeDef
void setRunTypeDef(const RunTypeDef runTypeDef)
Definition: RunTag.cc:70
ExpressReco_HICollisions_FallBack.cerr
tuple cerr
Definition: ExpressReco_HICollisions_FallBack.py:21068
RunTypeDef::setRunType
void setRunType(std::string runtype)
Definition: RunTypeDef.cc:33
LocationDef::setLocation
void setLocation(std::string loc)
Definition: LocationDef.cc:33
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
RunTag::setGeneralTag
void setGeneralTag(std::string tag)
Definition: RunTag.cc:36
Tm
Definition: Tm.h:14
void EcalEndcapMonitorClient::cleanup ( void  )

Cleanup.

Definition at line 988 of file EcalEndcapMonitorClient.cc.

References cloneME_, enableCleanup_, and h_.

Referenced by endJob(), and endRun().

988  {
989 
990  if ( ! enableCleanup_ ) return;
991 
992  if ( cloneME_ ) {
993  if ( h_ ) delete h_;
994  }
995 
996  h_ = 0;
997 
998 }
void EcalEndcapMonitorClient::endJob ( void  )
virtual

EndJob.

Reimplemented from edm::EDAnalyzer.

Definition at line 786 of file EcalEndcapMonitorClient.cc.

References analyze(), begin_run_, cleanup(), clients_, gather_cfg::cout, debug_, end_run_, EESummaryClient::endJob(), endRun(), forced_status_, forced_update_, i, ievt_, summaryClient_, and verbose_.

786  {
787 
788  if ( ! end_run_ ) {
789 
790  if ( verbose_ ) {
791  std::cout << std::endl;
792  std::cout << "Checking last event at endJob() ... " << std::endl;
793  std::cout << std::endl;
794  }
795 
796  forced_update_ = true;
797  this->analyze();
798 
799  if ( begin_run_ && ! end_run_ ) {
800 
801  if ( verbose_ ) {
802  std::cout << std::endl;
803  std::cout << "Forcing endRun() ... " << std::endl;
804  std::cout << std::endl;
805  }
806 
807  forced_status_ = true;
808  this->analyze();
809  this->endRun();
810 
811  }
812 
813  }
814 
815  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: endJob, ievt = " << ievt_ << std::endl;
816 
817  this->cleanup();
818 
819  for ( unsigned int i=0; i<clients_.size(); i++ ) {
820  clients_[i]->endJob();
821  }
822 
823  if ( summaryClient_ ) summaryClient_->endJob();
824 
825 }
i
int i
Definition: DBlmapReader.cc:9
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
EESummaryClient::endJob
void endJob(void)
EndJob.
Definition: EESummaryClient.cc:239
void EcalEndcapMonitorClient::endLuminosityBlock ( const edm::LuminosityBlock &  l,
const edm::EventSetup &  c 
)
virtual

EndLumiBlock.

Reimplemented from edm::EDAnalyzer.

Definition at line 954 of file EcalEndcapMonitorClient.cc.

References analyze(), gather_cfg::cout, current_time_, evt_, forced_update_, edm::LuminosityBlockBase::id(), last_time_update_, edm::LuminosityBlockID::luminosityBlock(), NULL, edm::LuminosityBlockID::run(), run_, runType_, cond::rpcobgas::time, updateTime_, and verbose_.

954  {
955 
956  current_time_ = time(NULL);
957 
958  if ( verbose_ ) {
959  std::cout << std::endl;
960  std::cout << "Standard endLuminosityBlock() for luminosity block " << l.id().luminosityBlock() << " of run " << l.id().run() << std::endl;
961  std::cout << std::endl;
962  }
963 
964  if ( updateTime_ > 0 ) {
965  if ( (current_time_ - last_time_update_) < 60 * updateTime_ ) {
966  return;
967  }
968  last_time_update_ = current_time_;
969  }
970 
971  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
972 
973  forced_update_ = true;
974  this->analyze();
975 
976  }
977 
978 }
edm::LuminosityBlockBase::id
LuminosityBlockID id() const
Definition: LuminosityBlockBase.h:52
NULL
#define NULL
Definition: scimark2.h:8
edm::LuminosityBlockID::run
RunNumber_t run() const
Definition: LuminosityBlockID.h:42
edm::LuminosityBlockID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockID.h:43
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::endRun ( void  )

EndRun.

Definition at line 827 of file EcalEndcapMonitorClient.cc.

References EESummaryClient::analyze(), begin_run_, cleanup(), clients_, clientsRuns_, gather_cfg::cout, dbUpdateTime_, debug_, generateEDF::done, end_run_, EESummaryClient::endRun(), endRunDb(), evt_, evtType_, i, j, jevt_, resetFile_, run_, runType_, softReset(), status_, subrun_, summaryClient_, and writeDb().

Referenced by analyze(), endJob(), and endRun().

827  {
828 
829  begin_run_ = false;
830  end_run_ = true;
831 
832  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: endRun, jevt = " << jevt_ << std::endl;
833 
834  if ( subrun_ != -1 ) {
835 
836  this->writeDb();
837 
838  this->endRunDb();
839 
840  }
841 
842  if ( resetFile_.size() != 0 || dbUpdateTime_ > 0 ) {
843 
844  this->softReset(false);
845 
846  for ( int i=0; i<int(clients_.size()); i++ ) {
847  bool done = false;
848  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
849  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
850  done = true;
851  clients_[i]->analyze();
852  }
853  }
854  }
855 
856  if ( summaryClient_ ) summaryClient_->analyze();
857 
858  }
859 
860  for ( int i=0; i<int(clients_.size()); i++ ) {
861  bool done = false;
862  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
863  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
864  done = true;
865  clients_[i]->endRun();
866  }
867  }
868  }
869 
870  if ( summaryClient_ ) summaryClient_->endRun();
871 
872  this->cleanup();
873 
874  status_ = "unknown";
875 
876  run_ = -1;
877  evt_ = -1;
878 
879  runType_ = -1;
880  evtType_ = -1;
881 
882  subrun_ = -1;
883 
884 }
i
int i
Definition: DBlmapReader.cc:9
EESummaryClient::analyze
void analyze(void)
Analyze.
Definition: EESummaryClient.cc:1380
j
int j
Definition: DBlmapReader.cc:9
EESummaryClient::endRun
void endRun(void)
EndRun.
Definition: EESummaryClient.cc:247
EcalEndcapMonitorClient::softReset
void softReset(bool flag)
SoftReset.
Definition: EcalEndcapMonitorClient.cc:1773
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
EcalEndcapMonitorClient::clientsRuns_
std::multimap< EEClient *, int > clientsRuns_
Definition: EcalEndcapMonitorClient.h:145
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::endRun ( const edm::Run &  r,
const edm::EventSetup &  c 
)
virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 886 of file EcalEndcapMonitorClient.cc.

References analyze(), begin_run_, gather_cfg::cout, dqmStore_, end_run_, endRun(), evt_, MonitorElement::Fill(), forced_status_, forced_update_, DQMStore::get(), trackerHits::histo, i, edm::RunBase::id(), mergeRuns_, prefixME_, edm::RunID::run(), run_, runType_, Numbers::sEE(), MonitorElement::setBinContent(), and verbose_.

886  {
887 
888  if ( verbose_ ) {
889  std::cout << std::endl;
890  std::cout << "Standard endRun() for run " << r.id().run() << std::endl;
891  std::cout << std::endl;
892  }
893 
894  this->analyze();
895 
896  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
897 
898  forced_update_ = true;
899  this->analyze();
900 
901  if ( ! mergeRuns_ ) {
902 
903  if ( begin_run_ && ! end_run_ ) {
904 
905  forced_status_ = false;
906  this->endRun();
907 
908  }
909 
910  }
911 
912  }
913 
914  // summary for DQM GUI
915 
916  if ( run_ != -1 && evt_ != -1 && runType_ == -1 ) {
917 
918  char histo[200];
919 
920  MonitorElement* me;
921 
922  sprintf(histo, "reportSummary");
923  me = dqmStore_->get(prefixME_ + "/EventInfo/" + histo);
924  if ( me ) me->Fill(-1.0);
925 
926  for (int i = 0; i < 18; i++) {
927  sprintf(histo, "EcalEndcap_%s", Numbers::sEE(i+1).c_str());
928  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummaryContents/" + histo);
929  if ( me ) me->Fill(-1.0);
930  }
931 
932  sprintf(histo, "reportSummaryMap");
933  me = dqmStore_->get(prefixME_ + "/EventInfo/" + histo);
934  for ( int jx = 1; jx <= 200; jx++ ) {
935  for ( int jy = 1; jy <= 100; jy++ ) {
936  if ( me ) me->setBinContent( jx, jy, -1.0 );
937  }
938  }
939 
940  }
941 
942 }
i
int i
Definition: DBlmapReader.cc:9
MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:800
edm::RunBase::id
RunID const & id() const
Definition: RunBase.h:43
edm::RunID::run
RunNumber_t run() const
Definition: RunID.h:44
Numbers::sEE
static std::string sEE(const int ism)
Definition: Numbers.cc:199
trackerHits.histo
tuple histo
Definition: trackerHits.py:12
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:147
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1270
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::endRunDb ( void  )

EndRunDB.

Definition at line 1365 of file EcalEndcapMonitorClient.cc.

References ExpressReco_HICollisions_FallBack::cerr, gather_cfg::cout, AlCaRecoCosmics_cfg::dataset, dbHostName_, dbHostPort_, dbName_, dbPassword_, dbUserName_, ExpressReco_HICollisions_FallBack::e, EcalCondDBInterface::fetchDataSet(), LogicID::getEcalLogicID(), h_, EcalCondDBInterface::insertDataSet(), RunDat::setNumEvents(), and verbose_.

Referenced by endRun().

1365  {
1366 
1367 #ifdef WITH_ECAL_COND_DB
1368  EcalCondDBInterface* econn;
1369 
1370  econn = 0;
1371 
1372  if ( dbName_.size() != 0 ) {
1373  try {
1374  if ( verbose_ ) std::cout << "Opening DB connection with TNS_ADMIN ..." << std::endl;
1375  econn = new EcalCondDBInterface(dbName_, dbUserName_, dbPassword_);
1376  if ( verbose_ ) std::cout << "done." << std::endl;
1377  } catch (std::runtime_error &e) {
1378  std::cerr << e.what() << std::endl;
1379  if ( dbHostName_.size() != 0 ) {
1380  try {
1381  if ( verbose_ ) std::cout << "Opening DB connection without TNS_ADMIN ..." << std::endl;
1382  econn = new EcalCondDBInterface(dbHostName_, dbName_, dbUserName_, dbPassword_, dbHostPort_);
1383  if ( verbose_ ) std::cout << "done." << std::endl;
1384  } catch (std::runtime_error &e) {
1385  std::cerr << e.what() << std::endl;
1386  }
1387  }
1388  }
1389  }
1390 
1391  EcalLogicID ecid;
1392  RunDat rd;
1393  std::map<EcalLogicID, RunDat> dataset;
1394 
1395  float nevt = -1.;
1396 
1397  if ( h_ ) nevt = h_->GetSumOfWeights();
1398 
1399  rd.setNumEvents(int(nevt));
1400 
1401  // fetch the RunDat from the DB
1402 
1403  bool foundRunDat = false;
1404 
1405  if ( econn ) {
1406  try {
1407  if ( verbose_ ) std::cout << "Fetching RunDat ..." << std::endl;
1408  econn->fetchDataSet(&dataset, &runiov_);
1409  if ( verbose_ ) std::cout << "done." << std::endl;
1410  foundRunDat = true;
1411  } catch (std::runtime_error &e) {
1412  std::cerr << e.what() << std::endl;
1413  foundRunDat = false;
1414  }
1415  }
1416 
1417  // begin - setup the RunDat (on behalf of the DAQ)
1418 
1419  if ( ! foundRunDat ) {
1420 
1421  if ( econn ) {
1422  try {
1423  ecid = LogicID::getEcalLogicID("EE");
1424  dataset[ecid] = rd;
1425  } catch (std::runtime_error &e) {
1426  std::cerr << e.what() << std::endl;
1427  }
1428  }
1429 
1430  if ( econn ) {
1431  try {
1432  if ( verbose_ ) std::cout << "Inserting RunDat ..." << std::endl;
1433  econn->insertDataSet(&dataset, &runiov_);
1434  if ( verbose_ ) std::cout << "done." << std::endl;
1435  } catch (std::runtime_error &e) {
1436  std::cerr << e.what() << std::endl;
1437  }
1438  }
1439 
1440  }
1441 
1442  // end - setup the RunDat (on behalf of the DAQ)
1443 
1444  if ( econn ) {
1445  try {
1446  if ( verbose_ ) std::cout << "Closing DB connection ..." << std::endl;
1447  delete econn;
1448  econn = 0;
1449  if ( verbose_ ) std::cout << "done." << std::endl;
1450  } catch (std::runtime_error &e) {
1451  std::cerr << e.what() << std::endl;
1452  }
1453  }
1454 #endif
1455 
1456 }
ExpressReco_HICollisions_FallBack.e
tuple e
Definition: ExpressReco_HICollisions_FallBack.py:1068
AlCaRecoCosmics_cfg.dataset
tuple dataset
Definition: AlCaRecoCosmics_cfg.py:54
EcalCondDBInterface::fetchDataSet
void fetchDataSet(std::map< EcalLogicID, DATT > *fillMap, IOVT *iov)
Definition: EcalCondDBInterface.h:554
RunDat::setNumEvents
void setNumEvents(int num)
Definition: RunDat.h:20
ExpressReco_HICollisions_FallBack.cerr
tuple cerr
Definition: ExpressReco_HICollisions_FallBack.py:21068
RunDat
Definition: RunDat.h:11
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
EcalCondDBInterface::insertDataSet
void insertDataSet(const std::map< EcalLogicID, DATT > *data, IOVT *iov)
Definition: EcalCondDBInterface.h:281
LogicID::getEcalLogicID
static EcalLogicID getEcalLogicID(const char *name, const int id1=EcalLogicID::NULLID, const int id2=EcalLogicID::NULLID, const int id3=EcalLogicID::NULLID)
Definition: LogicID.h:31
const char* EcalEndcapMonitorClient::getRunType ( void  )
inline

Definition at line 93 of file EcalEndcapMonitorClient.h.

References runType_, and runTypes_.

Referenced by analyze(), beginRunDb(), and EcalEndcapMonitorXdaqClient::defaultWebPage().

93 { return( runType_ == -1 ? "UNKNOWN" : runTypes_[runType_].c_str() ); }
EcalEndcapMonitorClient::runTypes_
std::vector< std::string > runTypes_
Definition: EcalEndcapMonitorClient.h:146
void EcalEndcapMonitorClient::reset ( void  )

Reset.

Definition at line 980 of file EcalEndcapMonitorClient.cc.

Referenced by analyze().

980  {
981 
982 }
void EcalEndcapMonitorClient::setup ( void  )

Setup.

Definition at line 984 of file EcalEndcapMonitorClient.cc.

Referenced by beginRun().

984  {
985 
986 }
void EcalEndcapMonitorClient::softReset ( bool  flag)

SoftReset.

Definition at line 1773 of file EcalEndcapMonitorClient.cc.

References DQMStore::disableSoftReset(), dqmStore_, DQMStore::get(), DQMStore::getAllContents(), prefixME_, and DQMStore::softReset().

Referenced by analyze(), and endRun().

1773  {
1774 
1775  std::vector<MonitorElement*> mes = dqmStore_->getAllContents(prefixME_);
1776  std::vector<MonitorElement*>::const_iterator meitr;
1777  for ( meitr=mes.begin(); meitr!=mes.end(); meitr++ ) {
1778  if ( !strncmp((*meitr)->getName().c_str(), "EE", 2)
1779  && strncmp((*meitr)->getName().c_str(), "EETrend", 7)
1780  && strncmp((*meitr)->getName().c_str(), "by lumi", 7) ) {
1781  if ( flag ) {
1782  dqmStore_->softReset(*meitr);
1783  } else {
1784  dqmStore_->disableSoftReset(*meitr);
1785  }
1786  }
1787  }
1788 
1789  MonitorElement* me = dqmStore_->get(prefixME_ + "/EcalInfo/EVTTYPE");
1790  if ( me ) {
1791  if ( flag ) {
1792  dqmStore_->softReset(me);
1793  } else {
1794  dqmStore_->disableSoftReset(me);
1795  }
1796  }
1797 
1798 }
flag
long int flag
Definition: mlp_lapack.h:47
DQMStore::getAllContents
std::vector< MonitorElement * > getAllContents(const std::string &path) const
Definition: DQMStore.cc:1474
DQMStore::disableSoftReset
void disableSoftReset(MonitorElement *me)
Definition: DQMStore.cc:2520
DQMStore::softReset
void softReset(MonitorElement *me)
Definition: DQMStore.cc:2512
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1270
void EcalEndcapMonitorClient::writeDb ( void  )

WriteDB.

Definition at line 1153 of file EcalEndcapMonitorClient.cc.

References ExpressReco_HICollisions_FallBack::cerr, clients_, clientsNames_, clientsRuns_, clientsStatus_, EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, gather_cfg::cout, AlCaRecoCosmics_cfg::dataset, dbHostName_, dbHostPort_, dbName_, dbPassword_, dbTagName_, dbUserName_, generateEDF::done, ExpressReco_HICollisions_FallBack::e, EcalCondDBInterface::fetchMonRunIOV(), LogicID::getEcalLogicID(), h_, i, EcalCondDBInterface::insertDataSet(), EcalCondDBInterface::insertMonRunIOV(), j, EcalDCCHeaderBlock::LASER_GAP, EcalDCCHeaderBlock::LASER_STD, EcalDCCHeaderBlock::LED_GAP, EcalDCCHeaderBlock::LED_STD, EcalDCCHeaderBlock::PEDESTAL_GAP, EcalDCCHeaderBlock::PEDESTAL_STD, EcalDCCHeaderBlock::PHYSICS_GLOBAL, EcalDCCHeaderBlock::PHYSICS_LOCAL, run_, runType_, MonRunTag::setGeneralTag(), MonVersionDef::setMonitoringVersion(), MonRunDat::setMonRunOutcomeDef(), MonRunTag::setMonVersionDef(), MonRunDat::setNumEvents(), MonRunOutcomeDef::setShortDesc(), MonRunDat::setTaskList(), MonRunDat::setTaskOutcome(), Tm::setToCurrentGMTime(), ntuplemaker::status, subrun_, summaryClient_, EcalDCCHeaderBlock::TESTPULSE_GAP, EcalDCCHeaderBlock::TESTPULSE_MGPA, and verbose_.

Referenced by analyze(), and endRun().

1153  {
1154 
1155  subrun_++;
1156 
1157 #ifdef WITH_ECAL_COND_DB
1158  EcalCondDBInterface* econn;
1159 
1160  econn = 0;
1161 
1162  if ( dbName_.size() != 0 ) {
1163  try {
1164  if ( verbose_ ) std::cout << "Opening DB connection with TNS_ADMIN ..." << std::endl;
1165  econn = new EcalCondDBInterface(dbName_, dbUserName_, dbPassword_);
1166  if ( verbose_ ) std::cout << "done." << std::endl;
1167  } catch (std::runtime_error &e) {
1168  std::cerr << e.what() << std::endl;
1169  if ( dbHostName_.size() != 0 ) {
1170  try {
1171  if ( verbose_ ) std::cout << "Opening DB connection without TNS_ADMIN ..." << std::endl;
1172  econn = new EcalCondDBInterface(dbHostName_, dbName_, dbUserName_, dbPassword_, dbHostPort_);
1173  if ( verbose_ ) std::cout << "done." << std::endl;
1174  } catch (std::runtime_error &e) {
1175  std::cerr << e.what() << std::endl;
1176  }
1177  }
1178  }
1179  }
1180 
1181  MonVersionDef monverdef;
1182 
1183  monverdef.setMonitoringVersion("test01");
1184 
1185  MonRunTag montag;
1186 
1187  montag.setMonVersionDef(monverdef);
1188  montag.setGeneralTag(dbTagName_);
1189 
1190  Tm startSubRun;
1191 
1192  startSubRun.setToCurrentGMTime();
1193 
1194  // fetch the MonIOV from the DB
1195 
1196  bool foundMonIOV = false;
1197 
1198  if ( econn ) {
1199  try {
1200  if ( verbose_ ) std::cout << "Fetching MonIOV ..." << std::endl;
1201  RunTag runtag = runiov_.getRunTag();
1202  moniov_ = econn->fetchMonRunIOV(&runtag, &montag, run_, subrun_);
1203  if ( verbose_ ) std::cout << "done." << std::endl;
1204  foundMonIOV = true;
1205  } catch (std::runtime_error &e) {
1206  std::cerr << e.what() << std::endl;
1207  foundMonIOV = false;
1208  }
1209  }
1210 
1211  // begin - setup the MonIOV
1212 
1213  if ( !foundMonIOV ) {
1214 
1215  moniov_.setRunIOV(runiov_);
1216  moniov_.setSubRunNumber(subrun_);
1217 
1218  if ( subrun_ > 1 ) {
1219  moniov_.setSubRunStart(startSubRun);
1220  } else {
1221  moniov_.setSubRunStart(runiov_.getRunStart());
1222  }
1223 
1224  moniov_.setMonRunTag(montag);
1225 
1226  if ( econn ) {
1227  try {
1228  if ( verbose_ ) std::cout << "Inserting MonIOV ..." << std::endl;
1229  econn->insertMonRunIOV(&moniov_);
1230  RunTag runtag = runiov_.getRunTag();
1231  moniov_ = econn->fetchMonRunIOV(&runtag, &montag, run_, subrun_);
1232  if ( verbose_ ) std::cout << "done." << std::endl;
1233  } catch (std::runtime_error &e) {
1234  std::cerr << e.what() << std::endl;
1235  try {
1236  if ( verbose_ ) std::cout << "Fetching MonIOV (again) ..." << std::endl;
1237  RunTag runtag = runiov_.getRunTag();
1238  moniov_ = econn->fetchMonRunIOV(&runtag, &montag, run_, subrun_);
1239  if ( verbose_ ) std::cout << "done." << std::endl;
1240  foundMonIOV = true;
1241  } catch (std::runtime_error &e) {
1242  std::cerr << e.what() << std::endl;
1243  foundMonIOV = false;
1244  }
1245  }
1246  }
1247 
1248  }
1249 
1250  // end - setup the MonIOV
1251 
1252  if ( verbose_ ) {
1253  std::cout << std::endl;
1254  std::cout << "==========MonRunIOV:" << std::endl;
1255  std::cout << "SubRun Number: " << moniov_.getSubRunNumber() << std::endl;
1256  std::cout << "SubRun Start: " << moniov_.getSubRunStart().str() << std::endl;
1257  std::cout << "SubRun End: " << moniov_.getSubRunEnd().str() << std::endl;
1258  std::cout << "====================" << std::endl;
1259  std::cout << std::endl;
1260  std::cout << "==========MonRunTag:" << std::endl;
1261  std::cout << "GeneralTag: " << moniov_.getMonRunTag().getGeneralTag() << std::endl;
1262  std::cout << "Monitoring Ver: " << moniov_.getMonRunTag().getMonVersionDef().getMonitoringVersion() << std::endl;
1263  std::cout << "====================" << std::endl;
1264  std::cout << std::endl;
1265  }
1266 
1267  int taskl = 0x0;
1268  int tasko = 0x0;
1269 
1270  for ( int i=0; i<int(clients_.size()); i++ ) {
1271  bool done = false;
1272  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
1273  if ( h_ && runType_ != -1 && runType_ == (*j).second && !done ) {
1274  if ( strcmp(clientsNames_[i].c_str(), "Cosmic") == 0 && runType_ != EcalDCCHeaderBlock::COSMIC && runType_ != EcalDCCHeaderBlock::COSMICS_LOCAL && runType_ != EcalDCCHeaderBlock::COSMICS_GLOBAL && runType_ != EcalDCCHeaderBlock::PHYSICS_GLOBAL && runType_ != EcalDCCHeaderBlock::PHYSICS_LOCAL && h_->GetBinContent(2+EcalDCCHeaderBlock::COSMIC) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::COSMICS_LOCAL) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::COSMICS_GLOBAL) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::PHYSICS_GLOBAL) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::PHYSICS_LOCAL) == 0 ) continue;
1275  if ( strcmp(clientsNames_[i].c_str(), "Laser") == 0 && runType_ != EcalDCCHeaderBlock::LASER_STD && runType_ != EcalDCCHeaderBlock::LASER_GAP && h_->GetBinContent(2+EcalDCCHeaderBlock::LASER_STD) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::LASER_GAP) == 0 ) continue;
1276  if ( strcmp(clientsNames_[i].c_str(), "Led") == 0 && runType_ != EcalDCCHeaderBlock::LED_STD && runType_ != EcalDCCHeaderBlock::LED_GAP && h_->GetBinContent(2+EcalDCCHeaderBlock::LED_STD) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::LED_GAP) == 0 ) continue;
1277  if ( strcmp(clientsNames_[i].c_str(), "Pedestal") == 0 && runType_ != EcalDCCHeaderBlock::PEDESTAL_STD && runType_ != EcalDCCHeaderBlock::PEDESTAL_GAP && h_->GetBinContent(2+EcalDCCHeaderBlock::PEDESTAL_STD) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::PEDESTAL_GAP) == 0 ) continue;
1278  if ( strcmp(clientsNames_[i].c_str(), "TestPulse") == 0 && runType_ != EcalDCCHeaderBlock::TESTPULSE_MGPA && runType_ != EcalDCCHeaderBlock::TESTPULSE_GAP && h_->GetBinContent(2+EcalDCCHeaderBlock::TESTPULSE_MGPA) == 0 && h_->GetBinContent(2+EcalDCCHeaderBlock::TESTPULSE_GAP) == 0 ) continue;
1279  done = true;
1280  if ( verbose_ ) {
1281  if ( econn ) {
1282  std::cout << " Writing " << clientsNames_[i] << " results to DB " << std::endl;
1283  std::cout << std::endl;
1284  }
1285  }
1286  bool status;
1287  if ( clients_[i]->writeDb(econn, &runiov_, &moniov_, status) ) {
1288  taskl |= 0x1 << clientsStatus_[clientsNames_[i]];
1289  if ( status ) {
1290  tasko |= 0x1 << clientsStatus_[clientsNames_[i]];
1291  }
1292  } else {
1293  tasko |= 0x1 << clientsStatus_[clientsNames_[i]];
1294  }
1295  }
1296  }
1297  if ( ((taskl >> clientsStatus_[clientsNames_[i]]) & 0x1) ) {
1298  if ( verbose_ ) {
1299  std::cout << " Task output for " << clientsNames_[i] << " = "
1300  << ((tasko >> clientsStatus_[clientsNames_[i]]) & 0x1) << std::endl;
1301  std::cout << std::endl;
1302  }
1303  }
1304  }
1305 
1306  bool status;
1307  if ( summaryClient_ ) summaryClient_->writeDb(econn, &runiov_, &moniov_, status);
1308 
1309  EcalLogicID ecid;
1310  MonRunDat md;
1311  std::map<EcalLogicID, MonRunDat> dataset;
1312 
1313  MonRunOutcomeDef monRunOutcomeDef;
1314 
1315  monRunOutcomeDef.setShortDesc("success");
1316 
1317  float nevt = -1.;
1318 
1319  if ( h_ ) nevt = h_->GetSumOfWeights();
1320 
1321  md.setNumEvents(int(nevt));
1322  md.setMonRunOutcomeDef(monRunOutcomeDef);
1323 
1324 // string fileName = "";
1325 // md.setRootfileName(fileName);
1326 
1327  md.setTaskList(taskl);
1328  md.setTaskOutcome(tasko);
1329 
1330  if ( econn ) {
1331  try {
1332  ecid = LogicID::getEcalLogicID("EE");
1333  dataset[ecid] = md;
1334  } catch (std::runtime_error &e) {
1335  std::cerr << e.what() << std::endl;
1336  }
1337  }
1338 
1339  if ( econn ) {
1340  try {
1341  if ( verbose_ ) std::cout << "Inserting MonRunDat ..." << std::endl;
1342  econn->insertDataSet(&dataset, &moniov_);
1343  if ( verbose_ ) std::cout << "done." << std::endl;
1344  } catch (std::runtime_error &e) {
1345  std::cerr << e.what() << std::endl;
1346  }
1347  }
1348 
1349  if ( econn ) {
1350  try {
1351  if ( verbose_ ) std::cout << "Closing DB connection ..." << std::endl;
1352  delete econn;
1353  econn = 0;
1354  if ( verbose_ ) std::cout << "done." << std::endl;
1355  } catch (std::runtime_error &e) {
1356  std::cerr << e.what() << std::endl;
1357  }
1358  }
1359 #endif
1360 
1361  if ( verbose_ ) std::cout << std::endl;
1362 
1363 }
ExpressReco_HICollisions_FallBack.e
tuple e
Definition: ExpressReco_HICollisions_FallBack.py:1068
i
int i
Definition: DBlmapReader.cc:9
MonRunDat::setTaskList
void setTaskList(int list)
Definition: MonRunDat.h:30
AlCaRecoCosmics_cfg.dataset
tuple dataset
Definition: AlCaRecoCosmics_cfg.py:54
MonRunDat::setNumEvents
void setNumEvents(int num)
Definition: MonRunDat.h:21
RunTag
Definition: RunTag.h:13
EcalEndcapMonitorClient::clientsStatus_
std::map< std::string, int > clientsStatus_
Definition: EcalEndcapMonitorClient.h:149
Tm::setToCurrentGMTime
void setToCurrentGMTime()
Definition: Tm.cc:156
MonRunTag::setGeneralTag
void setGeneralTag(std::string tag)
Definition: MonRunTag.cc:33
MonRunOutcomeDef::setShortDesc
void setShortDesc(std::string desc)
Definition: MonRunOutcomeDef.cc:35
EcalEndcapMonitorClient::clientsNames_
std::vector< std::string > clientsNames_
Definition: EcalEndcapMonitorClient.h:148
ExpressReco_HICollisions_FallBack.cerr
tuple cerr
Definition: ExpressReco_HICollisions_FallBack.py:21068
j
int j
Definition: DBlmapReader.cc:9
MonRunTag::setMonVersionDef
void setMonVersionDef(MonVersionDef ver)
Definition: MonRunTag.cc:49
MonRunDat::setTaskOutcome
void setTaskOutcome(int outcome)
Definition: MonRunDat.h:33
MonRunDat::setMonRunOutcomeDef
void setMonRunOutcomeDef(MonRunOutcomeDef outcomeDef)
Definition: MonRunDat.h:24
EcalEndcapMonitorClient::clients_
std::vector< EEClient * > clients_
Definition: EcalEndcapMonitorClient.h:147
EcalEndcapMonitorClient::clientsRuns_
std::multimap< EEClient *, int > clientsRuns_
Definition: EcalEndcapMonitorClient.h:145
EcalCondDBInterface::fetchMonRunIOV
MonRunIOV fetchMonRunIOV(RunTag *runtag, MonRunTag *montag, run_t run, subrun_t monrun)
Definition: EcalCondDBInterface.cc:580
MonVersionDef::setMonitoringVersion
void setMonitoringVersion(std::string ver)
Definition: MonVersionDef.cc:33
EcalCondDBInterface::insertMonRunIOV
void insertMonRunIOV(MonRunIOV *iov)
Definition: EcalCondDBInterface.cc:551
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
EcalCondDBInterface::insertDataSet
void insertDataSet(const std::map< EcalLogicID, DATT > *data, IOVT *iov)
Definition: EcalCondDBInterface.h:281
ntuplemaker.status
tuple status
Definition: ntuplemaker.py:245
LogicID::getEcalLogicID
static EcalLogicID getEcalLogicID(const char *name, const int id1=EcalLogicID::NULLID, const int id2=EcalLogicID::NULLID, const int id3=EcalLogicID::NULLID)
Definition: LogicID.h:31
Tm
Definition: Tm.h:14

Friends And Related Function Documentation

friend class EcalEndcapMonitorXdaqClient
friend

Definition at line 38 of file EcalEndcapMonitorClient.h.

Member Data Documentation

bool EcalEndcapMonitorClient::begin_run_
private

Definition at line 165 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), endJob(), and endRun().

std::vector<EEClient*> EcalEndcapMonitorClient::clients_
private

Definition at line 147 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), EcalEndcapMonitorXdaqClient::defaultWebPage(), EcalEndcapMonitorClient(), endJob(), endRun(), writeDb(), and ~EcalEndcapMonitorClient().

std::vector<std::string> EcalEndcapMonitorClient::clientsNames_
private

Definition at line 148 of file EcalEndcapMonitorClient.h.

Referenced by EcalEndcapMonitorXdaqClient::defaultWebPage(), EcalEndcapMonitorClient(), and writeDb().

std::multimap<EEClient*,int> EcalEndcapMonitorClient::clientsRuns_
private

Definition at line 145 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginRun(), EcalEndcapMonitorClient(), endRun(), and writeDb().

std::map<std::string,int> EcalEndcapMonitorClient::clientsStatus_
private

Definition at line 149 of file EcalEndcapMonitorClient.h.

Referenced by EcalEndcapMonitorClient(), and writeDb().

bool EcalEndcapMonitorClient::cloneME_
private

Definition at line 100 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), cleanup(), and EcalEndcapMonitorClient().

time_t EcalEndcapMonitorClient::current_time_
private

Definition at line 133 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), and endLuminosityBlock().

std::string EcalEndcapMonitorClient::dbHostName_
private

Definition at line 115 of file EcalEndcapMonitorClient.h.

Referenced by beginRunDb(), EcalEndcapMonitorClient(), endRunDb(), and writeDb().

int EcalEndcapMonitorClient::dbHostPort_
private

Definition at line 116 of file EcalEndcapMonitorClient.h.

Referenced by beginRunDb(), EcalEndcapMonitorClient(), endRunDb(), and writeDb().

std::string EcalEndcapMonitorClient::dbName_
private

Definition at line 114 of file EcalEndcapMonitorClient.h.

Referenced by beginRunDb(), EcalEndcapMonitorClient(), endRunDb(), and writeDb().

std::string EcalEndcapMonitorClient::dbPassword_
private

Definition at line 118 of file EcalEndcapMonitorClient.h.

Referenced by beginRunDb(), EcalEndcapMonitorClient(), endRunDb(), and writeDb().

std::string EcalEndcapMonitorClient::dbTagName_
private

Definition at line 120 of file EcalEndcapMonitorClient.h.

Referenced by EcalEndcapMonitorClient(), and writeDb().

time_t EcalEndcapMonitorClient::dbUpdateTime_
private

Definition at line 139 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), EcalEndcapMonitorClient(), and endRun().

std::string EcalEndcapMonitorClient::dbUserName_
private

Definition at line 117 of file EcalEndcapMonitorClient.h.

Referenced by beginRunDb(), EcalEndcapMonitorClient(), endRunDb(), and writeDb().

bool EcalEndcapMonitorClient::debug_
private

Definition at line 103 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), EcalEndcapMonitorClient(), endJob(), and endRun().

DQMStore* EcalEndcapMonitorClient::dqmStore_
private

Definition at line 153 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), endRun(), and softReset().

bool EcalEndcapMonitorClient::enableCleanup_
private

Definition at line 107 of file EcalEndcapMonitorClient.h.

Referenced by cleanup(), and EcalEndcapMonitorClient().

std::vector<std::string> EcalEndcapMonitorClient::enabledClients_
private

Definition at line 143 of file EcalEndcapMonitorClient.h.

Referenced by EcalEndcapMonitorClient().

bool EcalEndcapMonitorClient::end_run_
private

Definition at line 166 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), endJob(), and endRun().

int EcalEndcapMonitorClient::evt_
private

Definition at line 163 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), endLuminosityBlock(), and endRun().

int EcalEndcapMonitorClient::evtType_
private

Definition at line 158 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), and endRun().

bool EcalEndcapMonitorClient::forced_status_
private

Definition at line 168 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), endJob(), and endRun().

bool EcalEndcapMonitorClient::forced_update_
private

Definition at line 170 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), endJob(), endLuminosityBlock(), and endRun().

TH1F* EcalEndcapMonitorClient::h_
private

Definition at line 174 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), cleanup(), EcalEndcapMonitorXdaqClient::defaultWebPage(), endRunDb(), and writeDb().

int EcalEndcapMonitorClient::ievt_
private

Definition at line 97 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), EcalEndcapMonitorXdaqClient::defaultWebPage(), and endJob().

std::string EcalEndcapMonitorClient::inputFile_
private

Definition at line 111 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), and EcalEndcapMonitorClient().

int EcalEndcapMonitorClient::jevt_
private

Definition at line 98 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), and endRun().

int EcalEndcapMonitorClient::last_run_
private

Definition at line 172 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), and beginRun().

time_t EcalEndcapMonitorClient::last_time_reset_
private

Definition at line 136 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), and beginRun().

time_t EcalEndcapMonitorClient::last_time_update_
private

Definition at line 135 of file EcalEndcapMonitorClient.h.

Referenced by beginJob(), beginRun(), and endLuminosityBlock().

std::string EcalEndcapMonitorClient::location_
private

Definition at line 155 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginRunDb(), and EcalEndcapMonitorClient().

bool EcalEndcapMonitorClient::mergeRuns_
private

Definition at line 124 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), EcalEndcapMonitorClient(), and endRun().

std::string EcalEndcapMonitorClient::prefixME_
private

Definition at line 109 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), EcalEndcapMonitorClient(), endRun(), and softReset().

int EcalEndcapMonitorClient::prescaleFactor_
private

Definition at line 105 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), and EcalEndcapMonitorClient().

std::string EcalEndcapMonitorClient::referenceFile_
private

Definition at line 112 of file EcalEndcapMonitorClient.h.

std::string EcalEndcapMonitorClient::resetFile_
private

Definition at line 122 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), EcalEndcapMonitorClient(), and endRun().

int EcalEndcapMonitorClient::run_
private

Definition at line 162 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), beginRunDb(), EcalEndcapMonitorXdaqClient::defaultWebPage(), endLuminosityBlock(), endRun(), and writeDb().

int EcalEndcapMonitorClient::runType_
private

Definition at line 157 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), beginRunDb(), endLuminosityBlock(), endRun(), getRunType(), and writeDb().

std::vector<std::string> EcalEndcapMonitorClient::runTypes_
private

Definition at line 146 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginRunDb(), EcalEndcapMonitorXdaqClient::defaultWebPage(), EcalEndcapMonitorClient(), and getRunType().

std::string EcalEndcapMonitorClient::status_
private

Definition at line 160 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), and endRun().

int EcalEndcapMonitorClient::subrun_
private

Definition at line 131 of file EcalEndcapMonitorClient.h.

Referenced by beginJob(), beginRunDb(), endRun(), and writeDb().

EESummaryClient* EcalEndcapMonitorClient::summaryClient_
private

Definition at line 151 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginJob(), beginRun(), EcalEndcapMonitorClient(), endJob(), endRun(), writeDb(), and ~EcalEndcapMonitorClient().

std::vector<int> EcalEndcapMonitorClient::superModules_
private

Definition at line 141 of file EcalEndcapMonitorClient.h.

Referenced by EcalEndcapMonitorClient().

time_t EcalEndcapMonitorClient::updateTime_
private

Definition at line 138 of file EcalEndcapMonitorClient.h.

Referenced by EcalEndcapMonitorClient(), and endLuminosityBlock().

bool EcalEndcapMonitorClient::verbose_
private

Definition at line 102 of file EcalEndcapMonitorClient.h.

Referenced by analyze(), beginLuminosityBlock(), beginRun(), beginRunDb(), EcalEndcapMonitorClient(), endJob(), endLuminosityBlock(), endRun(), endRunDb(), writeDb(), and ~EcalEndcapMonitorClient().

Generated for CMSSW Reference Manual by doxygen 1.8.5