CMS 3D CMS Logo
LHERunInfo.cc
Go to the documentation of this file.
1 #include <algorithm>
2 #include <iostream>
3 #include <iomanip>
4 #include <string>
5 #include <cctype>
6 #include <vector>
7 #include <memory>
8 #include <cmath>
9 #include <cstring>
10 
11 #include <xercesc/dom/DOM.hpp>
12 #include <xercesc/parsers/XercesDOMParser.hpp>
13 #include <xercesc/sax/HandlerBase.hpp>
14 
15 #include "FWCore/Utilities/interface/Exception.h"
16 #include "FWCore/MessageLogger/interface/MessageLogger.h"
17 
18 #include "SimDataFormats/GeneratorProducts/interface/LesHouches.h"
19 
20 #include "GeneratorInterface/LHEInterface/interface/LHERunInfo.h"
21 
22 #include "XMLUtils.h"
23 
24 XERCES_CPP_NAMESPACE_USE
25 
26 static int skipWhitespace(std::istream &in) {
27  int ch;
28  do {
29  ch = in.get();
30  } while (std::isspace(ch));
31  if (ch != std::istream::traits_type::eof())
32  in.putback(ch);
33  return ch;
34 }
35 
36 namespace lhef {
37 
38  LHERunInfo::LHERunInfo(std::istream &in) {
39  in >> heprup.IDBMUP.first >> heprup.IDBMUP.second >> heprup.EBMUP.first >> heprup.EBMUP.second >>
40  heprup.PDFGUP.first >> heprup.PDFGUP.second >> heprup.PDFSUP.first >> heprup.PDFSUP.second >> heprup.IDWTUP >>
41  heprup.NPRUP;
42  if (!in.good())
43  throw cms::Exception("InvalidFormat") << "Les Houches file contained invalid"
44  " header in init section."
45  << std::endl;
46 
47  heprup.resize();
48 
49  for (int i = 0; i < heprup.NPRUP; i++) {
50  in >> heprup.XSECUP[i] >> heprup.XERRUP[i] >> heprup.XMAXUP[i] >> heprup.LPRUP[i];
51  if (!in.good())
52  throw cms::Exception("InvalidFormat") << "Les Houches file contained invalid data"
53  " in header payload line "
54  << (i + 1) << "." << std::endl;
55  }
56 
57  while (skipWhitespace(in) == '#') {
58  std::string line;
59  std::getline(in, line);
60  comments.push_back(line + "\n");
61  }
62 
63  if (!in.eof())
64  edm::LogInfo("Generator|LHEInterface")
65  << "Les Houches file contained spurious"
66  " content after the regular data (this is normal for LHEv3 files for now)."
67  << std::endl;
68 
69  init();
70  }
71 
72  LHERunInfo::LHERunInfo(const HEPRUP &heprup) : heprup(heprup) { init(); }
73 
74  LHERunInfo::LHERunInfo(const HEPRUP &heprup,
75  const std::vector<LHERunInfoProduct::Header> &headers,
76  const std::vector<std::string> &comments)
77  : heprup(heprup) {
78  std::copy(headers.begin(), headers.end(), std::back_inserter(this->headers));
79  std::copy(comments.begin(), comments.end(), std::back_inserter(this->comments));
80 
81  init();
82  }
83 
84  LHERunInfo::LHERunInfo(const LHERunInfoProduct &product) : heprup(product.heprup()) {
85  std::copy(product.headers_begin(), product.headers_end(), std::back_inserter(headers));
86  std::copy(product.comments_begin(), product.comments_end(), std::back_inserter(comments));
87 
88  init();
89  }
90 
91  LHERunInfo::~LHERunInfo() {}
92 
93  void LHERunInfo::init() {
94  for (int i = 0; i < heprup.NPRUP; i++) {
95  Process proc;
96  proc.setProcess(heprup.LPRUP[i]);
97  proc.setHepRupIndex((unsigned int)i);
98  processes.push_back(proc);
99  }
100 
101  std::sort(processes.begin(), processes.end());
102  }
103 
104  void LHERunInfo::initLumi() {
105  processesLumi.clear();
106  for (int i = 0; i < heprup.NPRUP; i++) {
107  Process proc;
108  proc.setProcess(heprup.LPRUP[i]);
109  proc.setHepRupIndex((unsigned int)i);
110  proc.setLHEXSec(heprup.XSECUP[i], heprup.XERRUP[i]);
111  processesLumi.push_back(proc);
112  }
113 
114  std::sort(processesLumi.begin(), processesLumi.end());
115  }
116 
117  bool LHERunInfo::operator==(const LHERunInfo &other) const { return heprup == other.heprup; }
118 
119  void LHERunInfo::count(int process, CountMode mode, double eventWeight, double brWeight, double matchWeight) {
120  std::vector<Process>::iterator proc = std::lower_bound(processes.begin(), processes.end(), process);
121  if (proc == processes.end() || proc->process() != process)
122  return;
123 
124  std::vector<Process>::iterator procLumi = std::lower_bound(processesLumi.begin(), processesLumi.end(), process);
125  if (procLumi == processesLumi.end() || procLumi->process() != process)
126  return;
127 
128  switch (mode) {
129  case kAccepted:
130  proc->addAcceptedBr(eventWeight * brWeight * matchWeight);
131  proc->addAccepted(eventWeight * matchWeight);
132  procLumi->addAcceptedBr(eventWeight * brWeight * matchWeight);
133  procLumi->addAccepted(eventWeight * matchWeight);
134  [[fallthrough]];
135  case kKilled:
136  proc->addKilled(eventWeight * matchWeight);
137  procLumi->addKilled(eventWeight * matchWeight);
138  if (eventWeight > 0) {
139  proc->addNPassPos();
140  procLumi->addNPassPos();
141  } else {
142  proc->addNPassNeg();
143  procLumi->addNPassNeg();
144  }
145  [[fallthrough]];
146  case kSelected:
147  proc->addSelected(eventWeight);
148  procLumi->addSelected(eventWeight);
149  if (eventWeight > 0) {
150  proc->addNTotalPos();
151  procLumi->addNTotalPos();
152  } else {
153  proc->addNTotalNeg();
154  procLumi->addNTotalNeg();
155  }
156  [[fallthrough]];
157  case kTried:
158  proc->addTried(eventWeight);
159  procLumi->addTried(eventWeight);
160  }
161  }
162 
163  LHERunInfo::XSec LHERunInfo::xsec() const {
164  double sigSelSum = 0.0;
165  double sigSum = 0.0;
166  double sigBrSum = 0.0;
167  double err2Sum = 0.0;
168  double errBr2Sum = 0.0;
169  int idwtup = heprup.IDWTUP;
170  for (std::vector<Process>::const_iterator proc = processes.begin(); proc != processes.end(); ++proc) {
171  unsigned int idx = proc->heprupIndex();
172 
173  if (!proc->killed().n())
174  continue;
175 
176  double sigma2Sum, sigma2Err;
177  sigma2Sum = heprup.XSECUP[idx] * heprup.XSECUP[idx];
178  sigma2Err = heprup.XERRUP[idx] * heprup.XERRUP[idx];
179 
180  double sigmaAvg = heprup.XSECUP[idx];
181 
182  double fracAcc = 0;
183  double ntotal = proc->nTotalPos() - proc->nTotalNeg();
184  double npass = proc->nPassPos() - proc->nPassNeg();
185  switch (idwtup) {
186  case 3:
187  case -3:
188  fracAcc = ntotal > 0 ? npass / ntotal : -1;
189  break;
190  default:
191  fracAcc = proc->selected().sum() > 0 ? proc->killed().sum() / proc->selected().sum() : -1;
192  break;
193  }
194 
195  if (fracAcc <= 0)
196  continue;
197 
198  double fracBr = proc->accepted().sum() > 0.0 ? proc->acceptedBr().sum() / proc->accepted().sum() : 1;
199  double sigmaFin = sigmaAvg * fracAcc;
200  double sigmaFinBr = sigmaFin * fracBr;
201 
202  double relErr = 1.0;
203 
204  double efferr2 = 0;
205  switch (idwtup) {
206  case 3:
207  case -3: {
208  double ntotal_pos = proc->nTotalPos();
209  double effp = ntotal_pos > 0 ? (double)proc->nPassPos() / ntotal_pos : 0;
210  double effp_err2 = ntotal_pos > 0 ? (1 - effp) * effp / ntotal_pos : 0;
211 
212  double ntotal_neg = proc->nTotalNeg();
213  double effn = ntotal_neg > 0 ? (double)proc->nPassNeg() / ntotal_neg : 0;
214  double effn_err2 = ntotal_neg > 0 ? (1 - effn) * effn / ntotal_neg : 0;
215 
216  efferr2 = ntotal > 0
217  ? (ntotal_pos * ntotal_pos * effp_err2 + ntotal_neg * ntotal_neg * effn_err2) / ntotal / ntotal
218  : 0;
219  break;
220  }
221  default: {
222  double denominator = pow(proc->selected().sum(), 4);
223  double passw = proc->killed().sum();
224  double passw2 = proc->killed().sum2();
225  double failw = proc->selected().sum() - passw;
226  double failw2 = proc->selected().sum2() - passw2;
227  double numerator = (passw2 * failw * failw + failw2 * passw * passw);
228 
229  efferr2 = denominator > 0 ? numerator / denominator : 0;
230  break;
231  }
232  }
233  double delta2Veto = efferr2 / fracAcc / fracAcc;
234  double delta2Sum = delta2Veto + sigma2Err / sigma2Sum;
235  relErr = (delta2Sum > 0.0 ? std::sqrt(delta2Sum) : 0.0);
236 
237  double deltaFin = sigmaFin * relErr;
238  double deltaFinBr = sigmaFinBr * relErr;
239 
240  sigSelSum += sigmaAvg;
241  sigSum += sigmaFin;
242  sigBrSum += sigmaFinBr;
243  err2Sum += deltaFin * deltaFin;
244  errBr2Sum += deltaFinBr * deltaFinBr;
245  }
246 
247  XSec result(sigBrSum, std::sqrt(errBr2Sum));
248 
249  return result;
250  }
251 
252  void LHERunInfo::statistics() const {
253  double sigSelSum = 0.0;
254  double sigSum = 0.0;
255  double sigBrSum = 0.0;
256  double errSel2Sum = 0.0;
257  double err2Sum = 0.0;
258  double errBr2Sum = 0.0;
259  double errMatch2Sum = 0.0;
260  unsigned long nAccepted = 0;
261  unsigned long nTried = 0;
262  unsigned long nAccepted_pos = 0;
263  unsigned long nTried_pos = 0;
264  unsigned long nAccepted_neg = 0;
265  unsigned long nTried_neg = 0;
266  int idwtup = heprup.IDWTUP;
267 
268  LogDebug("LHERunInfo") << " statistics";
269  LogDebug("LHERunInfo") << "Process and cross-section statistics";
270  LogDebug("LHERunInfo") << "------------------------------------";
271  LogDebug("LHERunInfo") << "Process\t\txsec_before [pb]\t\tpassed\tnposw\tnnegw\ttried\tnposw\tnnegw \txsec_match "
272  "[pb]\t\t\taccepted [%]\t event_eff [%]";
273 
274  for (std::vector<Process>::const_iterator proc = processes.begin(); proc != processes.end(); ++proc) {
275  unsigned int idx = proc->heprupIndex();
276 
277  if (!proc->selected().n()) {
278  LogDebug("LHERunInfo") << proc->process() << "\t0\t0\tn/a\t\t\tn/a";
279  continue;
280  }
281 
282  double sigma2Sum, sigma2Err;
283  sigma2Sum = heprup.XSECUP[idx] * heprup.XSECUP[idx];
284  sigma2Err = heprup.XERRUP[idx] * heprup.XERRUP[idx];
285 
286  double sigmaAvg = heprup.XSECUP[idx];
287 
288  double fracAcc = 0;
289  double ntotal = proc->nTotalPos() - proc->nTotalNeg();
290  double npass = proc->nPassPos() - proc->nPassNeg();
291  switch (idwtup) {
292  case 3:
293  case -3:
294  fracAcc = ntotal > 0 ? npass / ntotal : -1;
295  break;
296  default:
297  fracAcc = proc->selected().sum() > 0 ? proc->killed().sum() / proc->selected().sum() : -1;
298  break;
299  }
300 
301  double fracBr = proc->accepted().sum() > 0.0 ? proc->acceptedBr().sum() / proc->accepted().sum() : 1;
302  double sigmaFin = fracAcc > 0 ? sigmaAvg * fracAcc : 0;
303  double sigmaFinBr = sigmaFin * fracBr;
304 
305  double relErr = 1.0;
306  double relAccErr = 1.0;
307  double efferr2 = 0;
308 
309  if (proc->killed().n() > 0 && fracAcc > 0) {
310  switch (idwtup) {
311  case 3:
312  case -3: {
313  double ntotal_pos = proc->nTotalPos();
314  double effp = ntotal_pos > 0 ? (double)proc->nPassPos() / ntotal_pos : 0;
315  double effp_err2 = ntotal_pos > 0 ? (1 - effp) * effp / ntotal_pos : 0;
316 
317  double ntotal_neg = proc->nTotalNeg();
318  double effn = ntotal_neg > 0 ? (double)proc->nPassNeg() / ntotal_neg : 0;
319  double effn_err2 = ntotal_neg > 0 ? (1 - effn) * effn / ntotal_neg : 0;
320 
321  efferr2 = ntotal > 0 ? (ntotal_pos * ntotal_pos * effp_err2 + ntotal_neg * ntotal_neg * effn_err2) /
322  ntotal / ntotal
323  : 0;
324  break;
325  }
326  default: {
327  double denominator = pow(proc->selected().sum(), 4);
328  double passw = proc->killed().sum();
329  double passw2 = proc->killed().sum2();
330  double failw = proc->selected().sum() - passw;
331  double failw2 = proc->selected().sum2() - passw2;
332  double numerator = (passw2 * failw * failw + failw2 * passw * passw);
333 
334  efferr2 = denominator > 0 ? numerator / denominator : 0;
335  break;
336  }
337  }
338  double delta2Veto = efferr2 / fracAcc / fracAcc;
339  double delta2Sum = delta2Veto + sigma2Err / sigma2Sum;
340  relErr = (delta2Sum > 0.0 ? std::sqrt(delta2Sum) : 0.0);
341  relAccErr = (delta2Veto > 0.0 ? std::sqrt(delta2Veto) : 0.0);
342  }
343  double deltaFin = sigmaFin * relErr;
344  double deltaFinBr = sigmaFinBr * relErr;
345 
346  double ntotal_proc = proc->nTotalPos() + proc->nTotalNeg();
347  double event_eff_proc = ntotal_proc > 0 ? (double)(proc->nPassPos() + proc->nPassNeg()) / ntotal_proc : -1;
348  double event_eff_err_proc = ntotal_proc > 0 ? std::sqrt((1 - event_eff_proc) * event_eff_proc / ntotal_proc) : -1;
349 
350  LogDebug("LHERunInfo") << proc->process() << "\t\t" << std::scientific << std::setprecision(3)
351  << heprup.XSECUP[proc->heprupIndex()] << " +/- " << heprup.XERRUP[proc->heprupIndex()]
352  << "\t\t" << proc->accepted().n() << "\t" << proc->nPassPos() << "\t" << proc->nPassNeg()
353  << "\t" << proc->tried().n() << "\t" << proc->nTotalPos() << "\t" << proc->nTotalNeg()
354  << "\t" << std::scientific << std::setprecision(3) << sigmaFinBr << " +/- " << deltaFinBr
355  << "\t\t" << std::fixed << std::setprecision(1) << (fracAcc * 100) << " +/- "
356  << (std::sqrt(efferr2) * 100) << "\t" << std::fixed << std::setprecision(1)
357  << (event_eff_proc * 100) << " +/- " << (event_eff_err_proc * 100);
358 
359  nAccepted += proc->accepted().n();
360  nTried += proc->tried().n();
361  nAccepted_pos += proc->nPassPos();
362  nTried_pos += proc->nTotalPos();
363  nAccepted_neg += proc->nPassNeg();
364  nTried_neg += proc->nTotalNeg();
365  sigSelSum += sigmaAvg;
366  sigSum += sigmaFin;
367  sigBrSum += sigmaFinBr;
368  errSel2Sum += sigma2Err;
369  err2Sum += deltaFin * deltaFin;
370  errBr2Sum += deltaFinBr * deltaFinBr;
371  errMatch2Sum += sigmaFin * relAccErr * sigmaFin * relAccErr;
372  }
373 
374  double ntotal_all = (nTried_pos + nTried_neg);
375  double event_eff_all = ntotal_all > 0 ? (double)(nAccepted_pos + nAccepted_neg) / ntotal_all : -1;
376  double event_eff_err_all = ntotal_all > 0 ? std::sqrt((1 - event_eff_all) * event_eff_all / ntotal_all) : -1;
377 
378  LogDebug("LHERunInfo") << "Total\t\t" << std::scientific << std::setprecision(3) << sigSelSum << " +/- "
379  << std::sqrt(errSel2Sum) << "\t\t" << nAccepted << "\t" << nAccepted_pos << "\t"
380  << nAccepted_neg << "\t" << nTried << "\t" << nTried_pos << "\t" << nTried_neg << "\t"
381  << std::scientific << std::setprecision(3) << sigBrSum << " +/- " << std::sqrt(errBr2Sum)
382  << "\t\t" << std::fixed << std::setprecision(1) << (sigSum / sigSelSum * 100) << " +/- "
383  << (std::sqrt(errMatch2Sum) / sigSelSum * 100) << "\t" << std::fixed << std::setprecision(1)
384  << (event_eff_all * 100) << " +/- " << (event_eff_err_all * 100);
385  }
386 
387  LHERunInfo::Header::Header() : xmlDoc(nullptr) {}
388 
389  LHERunInfo::Header::Header(const std::string &tag) : LHERunInfoProduct::Header(tag), xmlDoc(nullptr) {}
390 
391  LHERunInfo::Header::Header(const Header &orig) : LHERunInfoProduct::Header(orig), xmlDoc(nullptr) {}
392 
393  LHERunInfo::Header::Header(const LHERunInfoProduct::Header &orig)
394  : LHERunInfoProduct::Header(orig), xmlDoc(nullptr) {}
395 
396  LHERunInfo::Header::~Header() {
397  if (xmlDoc)
398  xmlDoc->release();
399  }
400 
401  static void fillLines(std::vector<std::string> &lines, const char *data, int len = -1) {
402  const char *end = len >= 0 ? (data + len) : nullptr;
403  while (*data && (!end || data < end)) {
404  std::size_t len = std::strcspn(data, "\r\n");
405  if (end && data + len > end)
406  len = end - data;
407  if (data[len] == '\r' && data[len + 1] == '\n')
408  len += 2;
409  else if (data[len])
410  len++;
411  lines.push_back(std::string(data, len));
412  data += len;
413  }
414  }
415 
416  static std::vector<std::string> domToLines(const DOMNode *node) {
417  std::vector<std::string> result;
418  DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(XMLUniStr("Core"));
419  std::unique_ptr<DOMLSSerializer> writer(((DOMImplementationLS *)(impl))->createLSSerializer());
420 
421  std::unique_ptr<DOMLSOutput> outputDesc(((DOMImplementationLS *)impl)->createLSOutput());
422  assert(outputDesc.get());
423  outputDesc->setEncoding(XMLUniStr("UTF-8"));
424 
425  XMLSimpleStr buffer(writer->writeToString(node));
426 
427  const char *p = std::strchr((const char *)buffer, '>') + 1;
428  const char *q = std::strrchr(p, '<');
429  fillLines(result, p, q - p);
430 
431  return result;
432  }
433 
434  std::vector<std::string> LHERunInfo::findHeader(const std::string &tag) const {
435  const LHERunInfo::Header *header = nullptr;
436  for (std::vector<Header>::const_iterator iter = headers.begin(); iter != headers.end(); ++iter) {
437  if (iter->tag() == tag)
438  return std::vector<std::string>(iter->begin(), iter->end());
439  if (iter->tag() == "header")
440  header = &*iter;
441  }
442 
443  if (!header)
444  return std::vector<std::string>();
445 
446  const DOMNode *root = header->getXMLNode();
447  if (!root)
448  return std::vector<std::string>();
449 
450  for (const DOMNode *iter = root->getFirstChild(); iter; iter = iter->getNextSibling()) {
451  if (iter->getNodeType() != DOMNode::ELEMENT_NODE)
452  continue;
453  if (tag == (const char *)XMLSimpleStr(iter->getNodeName()))
454  return domToLines(iter);
455  }
456 
457  return std::vector<std::string>();
458  }
459 
460  namespace {
461  class HeaderReader : public CBInputStream::Reader {
462  public:
463  HeaderReader(const LHERunInfo::Header *header) : header(header), mode(kHeader), iter(header->begin()) {}
464 
465  const std::string &data() override {
466  switch (mode) {
467  case kHeader:
468  tmp = "<" + header->tag() + ">";
469  mode = kBody;
470  break;
471  case kBody:
472  if (iter != header->end())
473  return *iter++;
474  tmp = "</" + header->tag() + ">";
475  mode = kFooter;
476  break;
477  case kFooter:
478  tmp.clear();
479  }
480 
481  return tmp;
482  }
483 
484  private:
485  enum Mode { kHeader, kBody, kFooter };
486 
487  const LHERunInfo::Header *header;
488  Mode mode;
489  LHERunInfo::Header::const_iterator iter;
490  std::string tmp;
491  };
492  } // anonymous namespace
493 
494  const DOMNode *LHERunInfo::Header::getXMLNode() const {
495  if (tag().empty())
496  return nullptr;
497 
498  if (!xmlDoc) {
499  XercesDOMParser parser;
500  parser.setValidationScheme(XercesDOMParser::Val_Auto);
501  parser.setDoNamespaces(false);
502  parser.setDoSchema(false);
503  parser.setValidationSchemaFullChecking(false);
504 
505  HandlerBase errHandler;
506  parser.setErrorHandler(&errHandler);
507  parser.setCreateEntityReferenceNodes(false);
508 
509  try {
510  std::unique_ptr<CBInputStream::Reader> reader(new HeaderReader(this));
511  CBInputSource source(reader);
512  parser.parse(source);
513  xmlDoc = parser.adoptDocument();
514  } catch (const XMLException &e) {
515  throw cms::Exception("Generator|LHEInterface")
516  << "XML parser reported DOM error no. " << (unsigned long)e.getCode() << ": "
517  << XMLSimpleStr(e.getMessage()) << "." << std::endl;
518  } catch (const SAXException &e) {
519  throw cms::Exception("Generator|LHEInterface")
520  << "XML parser reported: " << XMLSimpleStr(e.getMessage()) << "." << std::endl;
521  }
522  }
523 
524  return xmlDoc->getDocumentElement();
525  }
526 
527  std::pair<int, int> LHERunInfo::pdfSetTranslation() const {
528  int pdfA = -1, pdfB = -1;
529 
530  if (heprup.PDFGUP.first >= 0) {
531  pdfA = heprup.PDFSUP.first;
532  }
533 
534  if (heprup.PDFGUP.second >= 0) {
535  pdfB = heprup.PDFSUP.second;
536  }
537 
538  return std::make_pair(pdfA, pdfB);
539  }
540 
541  const bool operator==(const LHERunInfo::Process &lhs, const LHERunInfo::Process &rhs) {
542  return (lhs.process() == rhs.process());
543  }
544 
545  const bool operator<(const LHERunInfo::Process &lhs, const LHERunInfo::Process &rhs) {
546  return (lhs.process() < rhs.process());
547  }
548 
549 } // namespace lhef
lhef::LHERunInfo::kAccepted
Definition: LHERunInfo.h:64
lhef::HEPRUP::XSECUP
std::vector< double > XSECUP
Definition: LesHouches.h:112
lhef::CBInputSource
XMLInputSourceWrapper< CBInputStream > CBInputSource
Definition: XMLUtils.h:185
alignBH_cfg.fixed
fixed
Definition: alignBH_cfg.py:54
mps_fire.i
i
Definition: mps_fire.py:428
MessageLogger.h
HcalTopologyMode::Mode
Mode
Definition: HcalTopologyMode.h:26
LHERunInfoProduct::Header::const_iterator
std::vector< std::string >::const_iterator const_iterator
Definition: LHERunInfoProduct.h:18
LHERunInfoProduct::Header
Definition: LHERunInfoProduct.h:16
filterCSVwithJSON.copy
copy
Definition: filterCSVwithJSON.py:36
lhef::domToLines
static std::vector< std::string > domToLines(const DOMNode *node)
Definition: LHERunInfo.cc:416
lhef::LHERunInfo::XSec
Definition: LHERunInfo.h:66
lhef::CBInputStream::Reader
Definition: XMLUtils.h:119
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
lhef::LHERunInfo::processesLumi
std::vector< Process > processesLumi
Definition: LHERunInfo.h:168
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
lhef::LHERunInfo::headers
std::vector< Header > headers
Definition: LHERunInfo.h:159
lhef::XMLUniStr
Definition: XMLUtils.h:91
lhef::LHERunInfo::processes
std::vector< Process > processes
Definition: LHERunInfo.h:158
cms::cuda::assert
assert(be >=bs)
writedatasetfile.parser
parser
Definition: writedatasetfile.py:7
cscNeutronWriter_cfi.writer
writer
Definition: cscNeutronWriter_cfi.py:6
XERCES_CPP_NAMESPACE_USE
Definition: XMLConfigWriter.cc:40
LHERunInfoProduct::headers_end
headers_const_iterator headers_end() const
Definition: LHERunInfoProduct.h:59
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
lhef::LHERunInfo::operator==
bool operator==(const LHERunInfo &other) const
Definition: LHERunInfo.cc:117
getRunAppsInfo.headers
headers
Definition: getRunAppsInfo.py:65
lhef::fillLines
static void fillLines(std::vector< std::string > &lines, const char *data, int len=-1)
Definition: LHERunInfo.cc:401
groupFilesInBlocks.ntotal
int ntotal
Definition: groupFilesInBlocks.py:100
lhef::operator<
const bool operator<(const LHERunInfo::Process &lhs, const LHERunInfo::Process &rhs)
Definition: LHERunInfo.cc:545
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
edmScanValgrind.buffer
buffer
Definition: edmScanValgrind.py:171
lhef::LHERunInfo::kSelected
Definition: LHERunInfo.h:64
lhef::HEPRUP::EBMUP
std::pair< double, double > EBMUP
Definition: LesHouches.h:82
LHERunInfoProduct::headers_begin
headers_const_iterator headers_begin() const
Definition: LHERunInfoProduct.h:58
skipWhitespace
static XERCES_CPP_NAMESPACE_USE int skipWhitespace(std::istream &in)
Definition: LHERunInfo.cc:26
LHERunInfoProduct
Definition: LHERunInfoProduct.h:13
XMLUtils.h
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
DQM.reader
reader
Definition: DQM.py:105
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
mps_fire.end
end
Definition: mps_fire.py:242
lhef::LHERunInfo::LHERunInfo
LHERunInfo(std::istream &in)
Definition: LHERunInfo.cc:38
source
static const std::string source
Definition: EdmProvDump.cc:47
lhef::HEPRUP::LPRUP
std::vector< int > LPRUP
Definition: LesHouches.h:128
trackingPlots.other
other
Definition: trackingPlots.py:1467
lhef::LHERunInfo::comments
std::vector< std::string > comments
Definition: LHERunInfo.h:160
lhef::LHERunInfo::Process
Definition: LHERunInfo.h:103
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
pfDeepBoostedJetPreprocessParams_cfi.lower_bound
lower_bound
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:15
indexGen.comments
comments
Definition: indexGen.py:75
lhef::HEPRUP::PDFGUP
std::pair< int, int > PDFGUP
Definition: LesHouches.h:88
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
lhef::LHERunInfo
Definition: LHERunInfo.h:25
ValidateTausOnZEEFastSim_cff.proc
proc
Definition: ValidateTausOnZEEFastSim_cff.py:6
groupFilesInBlocks.lines
lines
Definition: groupFilesInBlocks.py:95
lhef::LHERunInfo::~LHERunInfo
~LHERunInfo()
Definition: LHERunInfo.cc:91
lhef::LHERunInfo::init
void init()
Definition: LHERunInfo.cc:93
LHERunInfo.h
LaserDQM_cfg.process
process
Definition: LaserDQM_cfg.py:3
lhef
Definition: ExhumeHadronizer.h:12
LHERunInfoProduct::comments_begin
comments_const_iterator comments_begin() const
Definition: LHERunInfoProduct.h:62
recoMuon::in
Definition: RecoMuonEnumerators.h:6
lhef::HEPRUP::resize
void resize(int nrup)
Definition: LesHouches.h:44
lhef::LHERunInfo::count
void count(int process, CountMode count, double eventWeight=1.0, double brWeight=1.0, double matchWeight=1.0)
Definition: LHERunInfo.cc:119
lhef::LHERunInfo::CountMode
CountMode
Definition: LHERunInfo.h:64
lhef::HEPRUP::NPRUP
int NPRUP
Definition: LesHouches.h:107
lhef::XMLSimpleStr
Definition: XMLUtils.h:73
LHERunInfoProduct::comments_end
comments_const_iterator comments_end() const
Definition: LHERunInfoProduct.h:63
root
Definition: RooFitFunction.h:10
lhef::HEPRUP
Definition: LesHouches.h:22
lhef::HEPRUP::IDWTUP
int IDWTUP
Definition: LesHouches.h:101
HLTTauDQMOffline_cfi.numerator
numerator
Definition: HLTTauDQMOffline_cfi.py:179
submitPVResolutionJobs.q
q
Definition: submitPVResolutionJobs.py:84
lhef::LHERunInfo::Header::Header
Header()
Definition: LHERunInfo.cc:387
lhef::LHERunInfo::kKilled
Definition: LHERunInfo.h:64
LesHouches.h
lhef::LHERunInfo::xsec
XSec xsec() const
Definition: LHERunInfo.cc:163
lhef::HEPRUP::XERRUP
std::vector< double > XERRUP
Definition: LesHouches.h:118
HLTTauDQMOffline_cfi.denominator
denominator
Definition: HLTTauDQMOffline_cfi.py:180
lhef::HEPRUP::PDFSUP
std::pair< int, int > PDFSUP
Definition: LesHouches.h:94
impl
Definition: trackAlgoPriorityOrder.h:18
lhef::LHERunInfo::Header
Definition: LHERunInfo.h:35
lhef::LHERunInfo::Header::~Header
~Header()
Definition: LHERunInfo.cc:396
lhef::LHERunInfo::initLumi
void initLumi()
Definition: LHERunInfo.cc:104
relativeConstraints.empty
bool empty
Definition: relativeConstraints.py:46
Exception
Definition: hltDiff.cc:246
lhef::LHERunInfo::Process::process
int process() const
Definition: LHERunInfo.h:108
Exception.h
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
RecoTauValidation_cfi.header
header
Definition: RecoTauValidation_cfi.py:292
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
mps_fire.result
result
Definition: mps_fire.py:311
cms::Exception
Definition: Exception.h:70
lhef::HEPRUP::XMAXUP
std::vector< double > XMAXUP
Definition: LesHouches.h:123
lhef::LHERunInfo::kTried
Definition: LHERunInfo.h:64
mps_splice.line
line
Definition: mps_splice.py:76
lhef::LHERunInfo::findHeader
std::vector< std::string > findHeader(const std::string &tag) const
Definition: LHERunInfo.cc:434
edm::Log
Definition: MessageLogger.h:70
lhef::LHERunInfo::statistics
void statistics() const
Definition: LHERunInfo.cc:252
lhef::LHERunInfo::heprup
HEPRUP heprup
Definition: LHERunInfo.h:157
lhef::LHERunInfo::pdfSetTranslation
std::pair< int, int > pdfSetTranslation() const
Definition: LHERunInfo.cc:527
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
lhef::HEPRUP::IDBMUP
std::pair< int, int > IDBMUP
Definition: LesHouches.h:77
Generated for CMSSW Reference Manual by doxygen 1.8.16