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 1448 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().

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

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

1752  {
1753 
1754  run_ = e.id().run();
1755  evt_ = e.id().event();
1756 
1757  if ( prescaleFactor_ > 0 ) {
1758  if ( jevt_ % prescaleFactor_ == 0 ) this->analyze();
1759  }
1760 
1761 }
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_, 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  MonitorElement* me;
688 
689  dqmStore_->setCurrentFolder( prefixME_ + "/EventInfo" );
690 
691  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummary");
692  if ( me ) {
693  dqmStore_->removeElement(me->getName());
694  }
695  me = dqmStore_->bookFloat("reportSummary");
696  me->Fill(-1.0);
697 
698  dqmStore_->setCurrentFolder( prefixME_ + "/EventInfo/reportSummaryContents" );
699 
700  for (int i = 0; i < 18; i++) {
701  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummaryContents/EcalEndcap_" + Numbers::sEE(i+1) );
702  if ( me ) {
703  dqmStore_->removeElement(me->getName());
704  }
705  me = dqmStore_->bookFloat("EcalEndcap_" + Numbers::sEE(i+1));
706  me->Fill(-1.0);
707  }
708 
709  dqmStore_->setCurrentFolder( prefixME_ + "/EventInfo" );
710 
711  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummaryMap");
712  if ( me ) {
713  dqmStore_->removeElement(me->getName());
714  }
715  me = dqmStore_->book2D("reportSummaryMap", "reportSummaryMap", 40, 0., 200., 20, 0., 100);
716  for ( int jx = 1; jx <= 40; jx++ ) {
717  for ( int jy = 1; jy <= 20; jy++ ) {
718  me->setBinContent( jx, jy, -1.0 );
719  }
720  }
721  me->setAxisTitle("ix / ix+100", 1);
722  me->setAxisTitle("iy", 2);
723 
724 }
EESummaryClient::beginJob
void beginJob(void)
BeginJob.
Definition: EESummaryClient.cc:225
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:205
NULL
#define NULL
Definition: scimark2.h:8
DQMStore::bookFloat
MonitorElement * bookFloat(const char *name)
Book float.
Definition: DQMStore.cc:451
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:147
DQMStore::removeElement
void removeElement(const std::string &name)
Definition: DQMStore.cc:2353
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:1265
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:2213
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:642
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:232
void EcalEndcapMonitorClient::beginLuminosityBlock ( const edm::LuminosityBlock &  l,
const edm::EventSetup &  c 
)
virtual

BeginLumiBlock.

Reimplemented from edm::EDAnalyzer.

Definition at line 934 of file EcalEndcapMonitorClient.cc.

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

934  {
935 
936  if ( verbose_ ) {
937  std::cout << std::endl;
938  std::cout << "Standard beginLuminosityBlock() for luminosity block " << l.id().luminosityBlock() << " of run " << l.id().run() << std::endl;
939  std::cout << std::endl;
940  }
941 
942 }
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 726 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().

726  {
727 
728  begin_run_ = true;
729  end_run_ = false;
730 
731  last_run_ = run_;
732 
733  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: beginRun" << std::endl;
734 
735  jevt_ = 0;
736 
737  current_time_ = time(NULL);
738  last_time_update_ = current_time_;
739  last_time_reset_ = current_time_;
740 
741  this->setup();
742 
743  this->beginRunDb();
744 
745  for ( int i=0; i<int(clients_.size()); i++ ) {
746  clients_[i]->cleanup();
747  bool done = false;
748  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
749  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
750  done = true;
751  clients_[i]->beginRun();
752  }
753  }
754  }
755 
756  if ( summaryClient_ ) summaryClient_->beginRun();
757 
758 }
i
int i
Definition: DBlmapReader.cc:9
NULL
#define NULL
Definition: scimark2.h:8
EcalEndcapMonitorClient::beginRunDb
void beginRunDb(void)
BeginRunDB.
Definition: EcalEndcapMonitorClient.cc:990
EESummaryClient::beginRun
void beginRun(void)
BeginRun.
Definition: EESummaryClient.cc:236
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 760 of file EcalEndcapMonitorClient.cc.

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

760  {
761 
762  Numbers::initGeometry(c, verbose_);
763 
764  if ( verbose_ ) std::cout << std::endl;
765 
766  Masks::initMasking(c, verbose_);
767 
768  if ( verbose_ ) {
769  std::cout << std::endl;
770  std::cout << "Standard beginRun() for run " << r.id().run() << std::endl;
771  std::cout << std::endl;
772  }
773 
774  run_ = r.id().run();
775  evt_ = 0;
776 
777  jevt_ = 0;
778 
779 }
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:45
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::beginRunDb ( void  )

BeginRunDB.

Definition at line 990 of file EcalEndcapMonitorClient.cc.

References benchmark_cfg::cerr, gather_cfg::cout, dbHostName_, dbHostPort_, dbName_, dbPassword_, dbUserName_, 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().

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

References cloneME_, enableCleanup_, and h_.

Referenced by endJob(), and endRun().

978  {
979 
980  if ( ! enableCleanup_ ) return;
981 
982  if ( cloneME_ ) {
983  if ( h_ ) delete h_;
984  }
985 
986  h_ = 0;
987 
988 }
void EcalEndcapMonitorClient::endJob ( void  )
virtual

EndJob.

Reimplemented from edm::EDAnalyzer.

Definition at line 781 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_.

781  {
782 
783  if ( ! end_run_ ) {
784 
785  if ( verbose_ ) {
786  std::cout << std::endl;
787  std::cout << "Checking last event at endJob() ... " << std::endl;
788  std::cout << std::endl;
789  }
790 
791  forced_update_ = true;
792  this->analyze();
793 
794  if ( begin_run_ && ! end_run_ ) {
795 
796  if ( verbose_ ) {
797  std::cout << std::endl;
798  std::cout << "Forcing endRun() ... " << std::endl;
799  std::cout << std::endl;
800  }
801 
802  forced_status_ = true;
803  this->analyze();
804  this->endRun();
805 
806  }
807 
808  }
809 
810  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: endJob, ievt = " << ievt_ << std::endl;
811 
812  this->cleanup();
813 
814  for ( unsigned int i=0; i<clients_.size(); i++ ) {
815  clients_[i]->endJob();
816  }
817 
818  if ( summaryClient_ ) summaryClient_->endJob();
819 
820 }
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:246
void EcalEndcapMonitorClient::endLuminosityBlock ( const edm::LuminosityBlock &  l,
const edm::EventSetup &  c 
)
virtual

EndLumiBlock.

Reimplemented from edm::EDAnalyzer.

Definition at line 944 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_.

944  {
945 
946  current_time_ = time(NULL);
947 
948  if ( verbose_ ) {
949  std::cout << std::endl;
950  std::cout << "Standard endLuminosityBlock() for luminosity block " << l.id().luminosityBlock() << " of run " << l.id().run() << std::endl;
951  std::cout << std::endl;
952  }
953 
954  if ( updateTime_ > 0 ) {
955  if ( (current_time_ - last_time_update_) < 60 * updateTime_ ) {
956  return;
957  }
958  last_time_update_ = current_time_;
959  }
960 
961  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
962 
963  forced_update_ = true;
964  this->analyze();
965 
966  }
967 
968 }
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 822 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().

822  {
823 
824  begin_run_ = false;
825  end_run_ = true;
826 
827  if ( debug_ ) std::cout << "EcalEndcapMonitorClient: endRun, jevt = " << jevt_ << std::endl;
828 
829  if ( subrun_ != -1 ) {
830 
831  this->writeDb();
832 
833  this->endRunDb();
834 
835  }
836 
837  if ( resetFile_.size() != 0 || dbUpdateTime_ > 0 ) {
838 
839  this->softReset(false);
840 
841  for ( int i=0; i<int(clients_.size()); i++ ) {
842  bool done = false;
843  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
844  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
845  done = true;
846  clients_[i]->analyze();
847  }
848  }
849  }
850 
851  if ( summaryClient_ ) summaryClient_->analyze();
852 
853  }
854 
855  for ( int i=0; i<int(clients_.size()); i++ ) {
856  bool done = false;
857  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
858  if ( runType_ != -1 && runType_ == (*j).second && !done ) {
859  done = true;
860  clients_[i]->endRun();
861  }
862  }
863  }
864 
865  if ( summaryClient_ ) summaryClient_->endRun();
866 
867  this->cleanup();
868 
869  status_ = "unknown";
870 
871  run_ = -1;
872  evt_ = -1;
873 
874  runType_ = -1;
875  evtType_ = -1;
876 
877  subrun_ = -1;
878 
879 }
i
int i
Definition: DBlmapReader.cc:9
EESummaryClient::analyze
void analyze(void)
Analyze.
Definition: EESummaryClient.cc:1387
j
int j
Definition: DBlmapReader.cc:9
EESummaryClient::endRun
void endRun(void)
EndRun.
Definition: EESummaryClient.cc:254
EcalEndcapMonitorClient::softReset
void softReset(bool flag)
SoftReset.
Definition: EcalEndcapMonitorClient.cc:1763
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 881 of file EcalEndcapMonitorClient.cc.

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

881  {
882 
883  if ( verbose_ ) {
884  std::cout << std::endl;
885  std::cout << "Standard endRun() for run " << r.id().run() << std::endl;
886  std::cout << std::endl;
887  }
888 
889  this->analyze();
890 
891  if ( run_ != -1 && evt_ != -1 && runType_ != -1 ) {
892 
893  forced_update_ = true;
894  this->analyze();
895 
896  if ( ! mergeRuns_ ) {
897 
898  if ( begin_run_ && ! end_run_ ) {
899 
900  forced_status_ = false;
901  this->endRun();
902 
903  }
904 
905  }
906 
907  }
908 
909  // summary for DQM GUI
910 
911  if ( run_ != -1 && evt_ != -1 && runType_ == -1 ) {
912 
913  MonitorElement* me;
914 
915  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummary");
916  if ( me ) me->Fill(-1.0);
917 
918  for (int i = 0; i < 18; i++) {
919  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummaryContents/EcalEndcap_" + Numbers::sEE(i+1));
920  if ( me ) me->Fill(-1.0);
921  }
922 
923  me = dqmStore_->get(prefixME_ + "/EventInfo/reportSummaryMap");
924  for ( int jx = 1; jx <= 40; jx++ ) {
925  for ( int jy = 1; jy <= 20; jy++ ) {
926  if ( me ) me->setBinContent( jx, jy, -1.0 );
927  }
928  }
929 
930  }
931 
932 }
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:205
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:1265
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
void EcalEndcapMonitorClient::endRunDb ( void  )

EndRunDB.

Definition at line 1355 of file EcalEndcapMonitorClient.cc.

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

Referenced by endRun().

1355  {
1356 
1357 #ifdef WITH_ECAL_COND_DB
1358  EcalCondDBInterface* econn;
1359 
1360  econn = 0;
1361 
1362  if ( dbName_.size() != 0 ) {
1363  try {
1364  if ( verbose_ ) std::cout << "Opening DB connection with TNS_ADMIN ..." << std::endl;
1365  econn = new EcalCondDBInterface(dbName_, dbUserName_, dbPassword_);
1366  if ( verbose_ ) std::cout << "done." << std::endl;
1367  } catch (std::runtime_error &e) {
1368  std::cerr << e.what() << std::endl;
1369  if ( dbHostName_.size() != 0 ) {
1370  try {
1371  if ( verbose_ ) std::cout << "Opening DB connection without TNS_ADMIN ..." << std::endl;
1372  econn = new EcalCondDBInterface(dbHostName_, dbName_, dbUserName_, dbPassword_, dbHostPort_);
1373  if ( verbose_ ) std::cout << "done." << std::endl;
1374  } catch (std::runtime_error &e) {
1375  std::cerr << e.what() << std::endl;
1376  }
1377  }
1378  }
1379  }
1380 
1381  EcalLogicID ecid;
1382  RunDat rd;
1383  std::map<EcalLogicID, RunDat> dataset;
1384 
1385  float nevt = -1.;
1386 
1387  if ( h_ ) nevt = h_->GetSumOfWeights();
1388 
1389  rd.setNumEvents(int(nevt));
1390 
1391  // fetch the RunDat from the DB
1392 
1393  bool foundRunDat = false;
1394 
1395  if ( econn ) {
1396  try {
1397  if ( verbose_ ) std::cout << "Fetching RunDat ..." << std::endl;
1398  econn->fetchDataSet(&dataset, &runiov_);
1399  if ( verbose_ ) std::cout << "done." << std::endl;
1400  foundRunDat = true;
1401  } catch (std::runtime_error &e) {
1402  std::cerr << e.what() << std::endl;
1403  foundRunDat = false;
1404  }
1405  }
1406 
1407  // begin - setup the RunDat (on behalf of the DAQ)
1408 
1409  if ( ! foundRunDat ) {
1410 
1411  if ( econn ) {
1412  try {
1413  ecid = LogicID::getEcalLogicID("EE");
1414  dataset[ecid] = rd;
1415  } catch (std::runtime_error &e) {
1416  std::cerr << e.what() << std::endl;
1417  }
1418  }
1419 
1420  if ( econn ) {
1421  try {
1422  if ( verbose_ ) std::cout << "Inserting RunDat ..." << std::endl;
1423  econn->insertDataSet(&dataset, &runiov_);
1424  if ( verbose_ ) std::cout << "done." << std::endl;
1425  } catch (std::runtime_error &e) {
1426  std::cerr << e.what() << std::endl;
1427  }
1428  }
1429 
1430  }
1431 
1432  // end - setup the RunDat (on behalf of the DAQ)
1433 
1434  if ( econn ) {
1435  try {
1436  if ( verbose_ ) std::cout << "Closing DB connection ..." << std::endl;
1437  delete econn;
1438  econn = 0;
1439  if ( verbose_ ) std::cout << "done." << std::endl;
1440  } catch (std::runtime_error &e) {
1441  std::cerr << e.what() << std::endl;
1442  }
1443  }
1444 #endif
1445 
1446 }
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
benchmark_cfg.cerr
tuple cerr
Definition: benchmark_cfg.py:96
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
BeamSplash_cfg.dataset
tuple dataset
Definition: BeamSplash_cfg.py:56
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 970 of file EcalEndcapMonitorClient.cc.

Referenced by analyze().

970  {
971 
972 }
void EcalEndcapMonitorClient::setup ( void  )

Setup.

Definition at line 974 of file EcalEndcapMonitorClient.cc.

Referenced by beginRun().

974  {
975 
976 }
void EcalEndcapMonitorClient::softReset ( bool  flag)

SoftReset.

Definition at line 1763 of file EcalEndcapMonitorClient.cc.

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

Referenced by analyze(), and endRun().

1763  {
1764 
1765  std::vector<MonitorElement*> mes = dqmStore_->getAllContents(prefixME_);
1766  std::vector<MonitorElement*>::const_iterator meitr;
1767  for ( meitr=mes.begin(); meitr!=mes.end(); meitr++ ) {
1768  if ( !strncmp((*meitr)->getName().c_str(), "EE", 2)
1769  && strncmp((*meitr)->getName().c_str(), "EETrend", 7)
1770  && strncmp((*meitr)->getName().c_str(), "by lumi", 7) ) {
1771  if ( flag ) {
1772  dqmStore_->softReset(*meitr);
1773  } else {
1774  dqmStore_->disableSoftReset(*meitr);
1775  }
1776  }
1777  }
1778 
1779  MonitorElement* me = dqmStore_->get(prefixME_ + "/EcalInfo/EVTTYPE");
1780  if ( me ) {
1781  if ( flag ) {
1782  dqmStore_->softReset(me);
1783  } else {
1784  dqmStore_->disableSoftReset(me);
1785  }
1786  }
1787 
1788 }
flag
long int flag
Definition: mlp_lapack.h:47
DQMStore::getAllContents
std::vector< MonitorElement * > getAllContents(const std::string &path) const
Definition: DQMStore.cc:1469
DQMStore::disableSoftReset
void disableSoftReset(MonitorElement *me)
Definition: DQMStore.cc:2535
DQMStore::softReset
void softReset(MonitorElement *me)
Definition: DQMStore.cc:2527
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:1265
void EcalEndcapMonitorClient::writeDb ( void  )

WriteDB.

Definition at line 1143 of file EcalEndcapMonitorClient.cc.

References benchmark_cfg::cerr, clients_, clientsNames_, clientsRuns_, clientsStatus_, EcalDCCHeaderBlock::COSMIC, EcalDCCHeaderBlock::COSMICS_GLOBAL, EcalDCCHeaderBlock::COSMICS_LOCAL, gather_cfg::cout, BeamSplash_cfg::dataset, dbHostName_, dbHostPort_, dbName_, dbPassword_, dbTagName_, dbUserName_, generateEDF::done, 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().

1143  {
1144 
1145  subrun_++;
1146 
1147 #ifdef WITH_ECAL_COND_DB
1148  EcalCondDBInterface* econn;
1149 
1150  econn = 0;
1151 
1152  if ( dbName_.size() != 0 ) {
1153  try {
1154  if ( verbose_ ) std::cout << "Opening DB connection with TNS_ADMIN ..." << std::endl;
1155  econn = new EcalCondDBInterface(dbName_, dbUserName_, dbPassword_);
1156  if ( verbose_ ) std::cout << "done." << std::endl;
1157  } catch (std::runtime_error &e) {
1158  std::cerr << e.what() << std::endl;
1159  if ( dbHostName_.size() != 0 ) {
1160  try {
1161  if ( verbose_ ) std::cout << "Opening DB connection without TNS_ADMIN ..." << std::endl;
1162  econn = new EcalCondDBInterface(dbHostName_, dbName_, dbUserName_, dbPassword_, dbHostPort_);
1163  if ( verbose_ ) std::cout << "done." << std::endl;
1164  } catch (std::runtime_error &e) {
1165  std::cerr << e.what() << std::endl;
1166  }
1167  }
1168  }
1169  }
1170 
1171  MonVersionDef monverdef;
1172 
1173  monverdef.setMonitoringVersion("test01");
1174 
1175  MonRunTag montag;
1176 
1177  montag.setMonVersionDef(monverdef);
1178  montag.setGeneralTag(dbTagName_);
1179 
1180  Tm startSubRun;
1181 
1182  startSubRun.setToCurrentGMTime();
1183 
1184  // fetch the MonIOV from the DB
1185 
1186  bool foundMonIOV = false;
1187 
1188  if ( econn ) {
1189  try {
1190  if ( verbose_ ) std::cout << "Fetching MonIOV ..." << std::endl;
1191  RunTag runtag = runiov_.getRunTag();
1192  moniov_ = econn->fetchMonRunIOV(&runtag, &montag, run_, subrun_);
1193  if ( verbose_ ) std::cout << "done." << std::endl;
1194  foundMonIOV = true;
1195  } catch (std::runtime_error &e) {
1196  std::cerr << e.what() << std::endl;
1197  foundMonIOV = false;
1198  }
1199  }
1200 
1201  // begin - setup the MonIOV
1202 
1203  if ( !foundMonIOV ) {
1204 
1205  moniov_.setRunIOV(runiov_);
1206  moniov_.setSubRunNumber(subrun_);
1207 
1208  if ( subrun_ > 1 ) {
1209  moniov_.setSubRunStart(startSubRun);
1210  } else {
1211  moniov_.setSubRunStart(runiov_.getRunStart());
1212  }
1213 
1214  moniov_.setMonRunTag(montag);
1215 
1216  if ( econn ) {
1217  try {
1218  if ( verbose_ ) std::cout << "Inserting MonIOV ..." << std::endl;
1219  econn->insertMonRunIOV(&moniov_);
1220  RunTag runtag = runiov_.getRunTag();
1221  moniov_ = econn->fetchMonRunIOV(&runtag, &montag, run_, subrun_);
1222  if ( verbose_ ) std::cout << "done." << std::endl;
1223  } catch (std::runtime_error &e) {
1224  std::cerr << e.what() << std::endl;
1225  try {
1226  if ( verbose_ ) std::cout << "Fetching MonIOV (again) ..." << std::endl;
1227  RunTag runtag = runiov_.getRunTag();
1228  moniov_ = econn->fetchMonRunIOV(&runtag, &montag, run_, subrun_);
1229  if ( verbose_ ) std::cout << "done." << std::endl;
1230  foundMonIOV = true;
1231  } catch (std::runtime_error &e) {
1232  std::cerr << e.what() << std::endl;
1233  foundMonIOV = false;
1234  }
1235  }
1236  }
1237 
1238  }
1239 
1240  // end - setup the MonIOV
1241 
1242  if ( verbose_ ) {
1243  std::cout << std::endl;
1244  std::cout << "==========MonRunIOV:" << std::endl;
1245  std::cout << "SubRun Number: " << moniov_.getSubRunNumber() << std::endl;
1246  std::cout << "SubRun Start: " << moniov_.getSubRunStart().str() << std::endl;
1247  std::cout << "SubRun End: " << moniov_.getSubRunEnd().str() << std::endl;
1248  std::cout << "====================" << std::endl;
1249  std::cout << std::endl;
1250  std::cout << "==========MonRunTag:" << std::endl;
1251  std::cout << "GeneralTag: " << moniov_.getMonRunTag().getGeneralTag() << std::endl;
1252  std::cout << "Monitoring Ver: " << moniov_.getMonRunTag().getMonVersionDef().getMonitoringVersion() << std::endl;
1253  std::cout << "====================" << std::endl;
1254  std::cout << std::endl;
1255  }
1256 
1257  int taskl = 0x0;
1258  int tasko = 0x0;
1259 
1260  for ( int i=0; i<int(clients_.size()); i++ ) {
1261  bool done = false;
1262  for ( std::multimap<EEClient*,int>::iterator j = clientsRuns_.lower_bound(clients_[i]); j != clientsRuns_.upper_bound(clients_[i]); j++ ) {
1263  if ( h_ && runType_ != -1 && runType_ == (*j).second && !done ) {
1264  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;
1265  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;
1266  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;
1267  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;
1268  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;
1269  done = true;
1270  if ( verbose_ ) {
1271  if ( econn ) {
1272  std::cout << " Writing " << clientsNames_[i] << " results to DB " << std::endl;
1273  std::cout << std::endl;
1274  }
1275  }
1276  bool status;
1277  if ( clients_[i]->writeDb(econn, &runiov_, &moniov_, status) ) {
1278  taskl |= 0x1 << clientsStatus_[clientsNames_[i]];
1279  if ( status ) {
1280  tasko |= 0x1 << clientsStatus_[clientsNames_[i]];
1281  }
1282  } else {
1283  tasko |= 0x1 << clientsStatus_[clientsNames_[i]];
1284  }
1285  }
1286  }
1287  if ( ((taskl >> clientsStatus_[clientsNames_[i]]) & 0x1) ) {
1288  if ( verbose_ ) {
1289  std::cout << " Task output for " << clientsNames_[i] << " = "
1290  << ((tasko >> clientsStatus_[clientsNames_[i]]) & 0x1) << std::endl;
1291  std::cout << std::endl;
1292  }
1293  }
1294  }
1295 
1296  bool status;
1297  if ( summaryClient_ ) summaryClient_->writeDb(econn, &runiov_, &moniov_, status);
1298 
1299  EcalLogicID ecid;
1300  MonRunDat md;
1301  std::map<EcalLogicID, MonRunDat> dataset;
1302 
1303  MonRunOutcomeDef monRunOutcomeDef;
1304 
1305  monRunOutcomeDef.setShortDesc("success");
1306 
1307  float nevt = -1.;
1308 
1309  if ( h_ ) nevt = h_->GetSumOfWeights();
1310 
1311  md.setNumEvents(int(nevt));
1312  md.setMonRunOutcomeDef(monRunOutcomeDef);
1313 
1314 // string fileName = "";
1315 // md.setRootfileName(fileName);
1316 
1317  md.setTaskList(taskl);
1318  md.setTaskOutcome(tasko);
1319 
1320  if ( econn ) {
1321  try {
1322  ecid = LogicID::getEcalLogicID("EE");
1323  dataset[ecid] = md;
1324  } catch (std::runtime_error &e) {
1325  std::cerr << e.what() << std::endl;
1326  }
1327  }
1328 
1329  if ( econn ) {
1330  try {
1331  if ( verbose_ ) std::cout << "Inserting MonRunDat ..." << std::endl;
1332  econn->insertDataSet(&dataset, &moniov_);
1333  if ( verbose_ ) std::cout << "done." << std::endl;
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 << "Closing DB connection ..." << std::endl;
1342  delete econn;
1343  econn = 0;
1344  if ( verbose_ ) std::cout << "done." << std::endl;
1345  } catch (std::runtime_error &e) {
1346  std::cerr << e.what() << std::endl;
1347  }
1348  }
1349 #endif
1350 
1351  if ( verbose_ ) std::cout << std::endl;
1352 
1353 }
i
int i
Definition: DBlmapReader.cc:9
MonRunDat::setTaskList
void setTaskList(int list)
Definition: MonRunDat.h:30
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
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
benchmark_cfg.cerr
tuple cerr
Definition: benchmark_cfg.py:96
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
BeamSplash_cfg.dataset
tuple dataset
Definition: BeamSplash_cfg.py:56
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