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