CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
GenXSecAnalyzer Class Reference
Inheritance diagram for GenXSecAnalyzer:
edm::global::EDAnalyzer< edm::RunCache< gxsec::RunCache >, edm::LuminosityBlockCache< gxsec::LumiCache > > edm::global::EDAnalyzerBase edm::EDConsumerBase

Public Member Functions

 GenXSecAnalyzer (const edm::ParameterSet &)
 
 ~GenXSecAnalyzer () override
 
- Public Member Functions inherited from edm::global::EDAnalyzer< edm::RunCache< gxsec::RunCache >, edm::LuminosityBlockCache< gxsec::LumiCache > >
 EDAnalyzer ()=default
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
bool wantsStreamLuminosityBlocks () const final
 
bool wantsStreamRuns () const final
 
- Public Member Functions inherited from edm::global::EDAnalyzerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzerBase ()
 
ModuleDescription const & moduleDescription () const
 
 ~EDAnalyzerBase () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase &&)=default
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Private Member Functions

void analyze (edm::StreamID, const edm::Event &, const edm::EventSetup &) const final
 
void beginJob () final
 
void combine (double &, double &, double &, const double &, const double &, const double &) const
 
void combine (GenLumiInfoProduct::XSec &, double &, const GenLumiInfoProduct::XSec &, const double &) const
 
GenLumiInfoProduct::XSec compute (const GenLumiInfoProduct &) const
 
void endJob () final
 
std::shared_ptr< gxsec::LumiCache > globalBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) const final
 
std::shared_ptr< gxsec::RunCache > globalBeginRun (edm::Run const &, edm::EventSetup const &) const final
 
void globalEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) const final
 
void globalEndRun (edm::Run const &, edm::EventSetup const &) const final
 

Private Attributes

GenFilterInfo filterOnlyEffStat_
 
edm::EDGetTokenT< GenFilterInfo > genFilterInfoToken_
 
edm::EDGetTokenT< GenLumiInfoProduct > genLumiInfoToken_
 
std::atomic< int > hepidwtup_
 
GenFilterInfo hepMCFilterEffStat_
 
edm::EDGetTokenT< GenFilterInfo > hepMCFilterInfoToken_
 
std::map< int, GenFilterInfo > jetMatchEffStat_
 
edm::EDGetTokenT< LHERunInfoProduct > lheRunInfoToken_
 
std::mutex mutex_
 
std::atomic< int > nMCs_
 
double totalWeight_
 
double totalWeightPre_
 
GenLumiInfoProduct::XSec xsec_
 
std::vector< GenLumiInfoProduct::XSec > xsecAfterMatching_
 
std::vector< GenLumiInfoProduct::XSec > xsecBeforeMatching_
 
GenLumiInfoProduct::XSec xsecPreFilter_
 

Additional Inherited Members

- Public Types inherited from edm::global::EDAnalyzerBase
typedef EDAnalyzerBase ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::global::EDAnalyzerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 

Detailed Description

Definition at line 70 of file GenXSecAnalyzer.cc.

Constructor & Destructor Documentation

◆ GenXSecAnalyzer()

GenXSecAnalyzer::GenXSecAnalyzer ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 133 of file GenXSecAnalyzer.cc.

134  : nMCs_(0),
135  hepidwtup_(-9999),
136  totalWeightPre_(0),
137  totalWeight_(0),
138  xsecPreFilter_(-1, -1),
139  xsec_(-1, -1),
140  filterOnlyEffStat_(0, 0, 0, 0, 0., 0., 0., 0.),
141  hepMCFilterEffStat_(0, 0, 0, 0, 0., 0., 0., 0.) {
142  genFilterInfoToken_ = consumes<GenFilterInfo, edm::InLumi>(edm::InputTag("genFilterEfficiencyProducer", ""));
143  hepMCFilterInfoToken_ = consumes<GenFilterInfo, edm::InLumi>(edm::InputTag("generator", ""));
144  genLumiInfoToken_ = consumes<GenLumiInfoProduct, edm::InLumi>(edm::InputTag("generator", ""));
145  lheRunInfoToken_ = consumes<LHERunInfoProduct, edm::InRun>(edm::InputTag("externalLHEProducer", ""));
146 }

References genFilterInfoToken_, genLumiInfoToken_, hepMCFilterInfoToken_, and lheRunInfoToken_.

◆ ~GenXSecAnalyzer()

GenXSecAnalyzer::~GenXSecAnalyzer ( )
override

Definition at line 148 of file GenXSecAnalyzer.cc.

148 {}

Member Function Documentation

◆ analyze()

void GenXSecAnalyzer::analyze ( edm::StreamID  ,
const edm::Event &  ,
const edm::EventSetup &   
) const
finalprivatevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 171 of file GenXSecAnalyzer.cc.

171 {}

◆ beginJob()

void GenXSecAnalyzer::beginJob ( void  )
finalprivatevirtual

Reimplemented from edm::global::EDAnalyzerBase.

Definition at line 150 of file GenXSecAnalyzer.cc.

150 {}

◆ combine() [1/2]

void GenXSecAnalyzer::combine ( double &  finalValue,
double &  finalError,
double &  finalWeight,
const double &  currentValue,
const double &  currentError,
const double &  currentWeight 
) const
private

Definition at line 349 of file GenXSecAnalyzer.cc.

354  {
355  if (finalValue <= 0) {
356  finalValue = currentValue;
357  finalError = currentError;
358  finalWeight += currentWeight;
359  } else {
360  double wgt1 = (finalError <= 0 || currentError <= 0) ? finalWeight : 1 / (finalError * finalError);
361  double wgt2 = (finalError <= 0 || currentError <= 0) ? currentWeight : 1 / (currentError * currentError);
362  double xsec = (wgt1 * finalValue + wgt2 * currentValue) / (wgt1 + wgt2);
363  double err = (finalError <= 0 || currentError <= 0) ? 0 : 1.0 / std::sqrt(wgt1 + wgt2);
364  finalValue = xsec;
365  finalError = err;
366  finalWeight += currentWeight;
367  }
368  return;
369 }

References runTheMatrix::err, and mathSSE::sqrt().

◆ combine() [2/2]

void GenXSecAnalyzer::combine ( GenLumiInfoProduct::XSec &  finalXSec,
double &  totalw,
const GenLumiInfoProduct::XSec &  thisRunXSec,
const double &  thisw 
) const
private

Definition at line 371 of file GenXSecAnalyzer.cc.

374  {
375  double value = finalXSec.value();
376  double error = finalXSec.error();
377  double thisValue = thisRunXSec.value();
378  double thisError = thisRunXSec.error();
379  combine(value, error, totalw, thisValue, thisError, thisw);
380  finalXSec = GenLumiInfoProduct::XSec(value, error);
381  return;
382 }

References GenLumiInfoProduct::XSec::error(), relativeConstraints::error, and GenLumiInfoProduct::XSec::value().

Referenced by globalEndLuminosityBlock(), and globalEndRun().

◆ compute()

GenLumiInfoProduct::XSec GenXSecAnalyzer::compute ( const GenLumiInfoProduct &  iLumiInfo) const
private

Definition at line 384 of file GenXSecAnalyzer.cc.

384  {
385  // sum of cross sections and errors over different processes
386  double sigSelSum = 0.0;
387  double err2SelSum = 0.0;
388  double sigSum = 0.0;
389  double err2Sum = 0.0;
390 
391  std::vector<GenLumiInfoProduct::XSec> tempVector_before;
392  std::vector<GenLumiInfoProduct::XSec> tempVector_after;
393 
394  // loop over different processes for each sample
395  unsigned int vectorSize = iLumiInfo.getProcessInfos().size();
396  for (unsigned int ip = 0; ip < vectorSize; ip++) {
397  GenLumiInfoProduct::ProcessInfo proc = iLumiInfo.getProcessInfos()[ip];
398  double hepxsec_value = proc.lheXSec().value();
399  double hepxsec_error = proc.lheXSec().error() <= 0 ? 0 : proc.lheXSec().error();
400  tempVector_before.push_back(GenLumiInfoProduct::XSec(hepxsec_value, hepxsec_error));
401 
402  sigSelSum += hepxsec_value;
403  err2SelSum += hepxsec_error * hepxsec_error;
404 
405  // skips computation if jet matching efficiency=0
406  if (proc.killed().n() < 1) {
407  tempVector_after.push_back(GenLumiInfoProduct::XSec(0.0, 0.0));
408  continue;
409  }
410 
411  // computing jet matching efficiency for this process
412  double fracAcc = 0;
413  double ntotal = proc.nTotalPos() - proc.nTotalNeg();
414  double npass = proc.nPassPos() - proc.nPassNeg();
415  switch (hepidwtup_) {
416  case 3:
417  case -3:
418  fracAcc = ntotal > 0 ? npass / ntotal : -1;
419  break;
420  default:
421  fracAcc = proc.selected().sum() > 0 ? proc.killed().sum() / proc.selected().sum() : -1;
422  break;
423  }
424 
425  if (fracAcc <= 0) {
426  tempVector_after.push_back(GenLumiInfoProduct::XSec(0.0, 0.0));
427  continue;
428  }
429 
430  // cross section after matching for this particular process
431  double sigmaFin = hepxsec_value * fracAcc;
432 
433  // computing error on jet matching efficiency
434  double relErr = 1.0;
435  double efferr2 = 0;
436  switch (hepidwtup_) {
437  case 3:
438  case -3: {
439  double ntotal_pos = proc.nTotalPos();
440  double effp = ntotal_pos > 0 ? (double)proc.nPassPos() / ntotal_pos : 0;
441  double effp_err2 = ntotal_pos > 0 ? (1 - effp) * effp / ntotal_pos : 0;
442 
443  double ntotal_neg = proc.nTotalNeg();
444  double effn = ntotal_neg > 0 ? (double)proc.nPassNeg() / ntotal_neg : 0;
445  double effn_err2 = ntotal_neg > 0 ? (1 - effn) * effn / ntotal_neg : 0;
446 
447  efferr2 = ntotal > 0
448  ? (ntotal_pos * ntotal_pos * effp_err2 + ntotal_neg * ntotal_neg * effn_err2) / ntotal / ntotal
449  : 0;
450  break;
451  }
452  default: {
453  double denominator = pow(proc.selected().sum(), 4);
454  double passw = proc.killed().sum();
455  double passw2 = proc.killed().sum2();
456  double failw = proc.selected().sum() - passw;
457  double failw2 = proc.selected().sum2() - passw2;
458  double numerator = (passw2 * failw * failw + failw2 * passw * passw);
459 
460  efferr2 = denominator > 0 ? numerator / denominator : 0;
461  break;
462  }
463  }
464  double delta2Veto = efferr2 / fracAcc / fracAcc;
465 
466  // computing total error on cross section after matching efficiency
467 
468  double sigma2Sum, sigma2Err;
469  sigma2Sum = hepxsec_value * hepxsec_value;
470  sigma2Err = hepxsec_error * hepxsec_error;
471 
472  double delta2Sum = delta2Veto + sigma2Err / sigma2Sum;
473  relErr = (delta2Sum > 0.0 ? std::sqrt(delta2Sum) : 0.0);
474  double deltaFin = sigmaFin * relErr;
475 
476  tempVector_after.push_back(GenLumiInfoProduct::XSec(sigmaFin, deltaFin));
477 
478  // sum of cross sections and errors over different processes
479  sigSum += sigmaFin;
480  err2Sum += deltaFin * deltaFin;
481 
482  } // end of loop over different processes
483  tempVector_before.push_back(GenLumiInfoProduct::XSec(sigSelSum, sqrt(err2SelSum)));
484 
485  double total_matcheff = jetMatchEffStat_[10000].filterEfficiency(hepidwtup_);
486  double total_matcherr = jetMatchEffStat_[10000].filterEfficiencyError(hepidwtup_);
487 
488  double xsec_after = sigSelSum * total_matcheff;
489  double xsecerr_after = (total_matcheff > 0 && sigSelSum > 0)
490  ? xsec_after * sqrt(err2SelSum / sigSelSum / sigSelSum +
491  total_matcherr * total_matcherr / total_matcheff / total_matcheff)
492  : 0;
493 
494  GenLumiInfoProduct::XSec result(xsec_after, xsecerr_after);
495  tempVector_after.push_back(result);
496 
497  xsecBeforeMatching_ = tempVector_before;
498  xsecAfterMatching_ = tempVector_after;
499 
500  return result;
501 }

References HLTTauDQMOffline_cfi::denominator, GenLumiInfoProduct::getProcessInfos(), hepidwtup_, jetMatchEffStat_, groupFilesInBlocks::ntotal, HLTTauDQMOffline_cfi::numerator, funct::pow(), ValidateTausOnZEEFastSim_cff::proc, mps_fire::result, mathSSE::sqrt(), xsecAfterMatching_, and xsecBeforeMatching_.

Referenced by globalEndRun().

◆ endJob()

void GenXSecAnalyzer::endJob ( void  )
finalprivatevirtual

Reimplemented from edm::global::EDAnalyzerBase.

Definition at line 503 of file GenXSecAnalyzer.cc.

503  {
504  edm::LogPrint("GenXSecAnalyzer") << "\n"
505  << "------------------------------------"
506  << "\n"
507  << "GenXsecAnalyzer:"
508  << "\n"
509  << "------------------------------------";
510 
511  if (jetMatchEffStat_.empty()) {
512  edm::LogPrint("GenXSecAnalyzer") << "------------------------------------"
513  << "\n"
514  << "Cross-section summary not available"
515  << "\n"
516  << "------------------------------------";
517  return;
518  }
519 
520  // fraction of negative weights
521  double final_fract_neg_w = 0;
522  double final_fract_neg_w_unc = 0;
523 
524  // below print out is only for combination of same physics MC samples and ME+Pythia MCs
525 
526  if (nMCs_ == 1 && hepidwtup_ != -1) {
527  edm::LogPrint("GenXSecAnalyzer")
528  << "-----------------------------------------------------------------------------------------------------------"
529  "--------------------------------------------------------------- \n"
530  << "Overall cross-section summary \n"
531  << "-----------------------------------------------------------------------------------------------------------"
532  "---------------------------------------------------------------";
533  edm::LogPrint("GenXSecAnalyzer") << "Process\t\txsec_before [pb]\t\tpassed\tnposw\tnnegw\ttried\tnposw\tnnegw "
534  "\txsec_match [pb]\t\t\taccepted [%]\t event_eff [%]";
535 
536  const unsigned sizeOfInfos = jetMatchEffStat_.size();
537  const unsigned last = sizeOfInfos - 1;
538  std::string *title = new std::string[sizeOfInfos];
539  unsigned int i = 0;
540  double jetmatch_eff = 0;
541  double jetmatch_err = 0;
542  double matching_eff = 1;
543  double matching_efferr = 1;
544 
545  for (std::map<int, GenFilterInfo>::const_iterator iter = jetMatchEffStat_.begin(); iter != jetMatchEffStat_.end();
546  ++iter, i++) {
547  GenFilterInfo thisJetMatchStat = iter->second;
548  GenFilterInfo thisEventEffStat =
549  GenFilterInfo(thisJetMatchStat.numPassPositiveEvents() + thisJetMatchStat.numPassNegativeEvents(),
550  0,
551  thisJetMatchStat.numTotalPositiveEvents() + thisJetMatchStat.numTotalNegativeEvents(),
552  0,
553  thisJetMatchStat.numPassPositiveEvents() + thisJetMatchStat.numPassNegativeEvents(),
554  thisJetMatchStat.numPassPositiveEvents() + thisJetMatchStat.numPassNegativeEvents(),
555  thisJetMatchStat.numTotalPositiveEvents() + thisJetMatchStat.numTotalNegativeEvents(),
556  thisJetMatchStat.numTotalPositiveEvents() + thisJetMatchStat.numTotalNegativeEvents());
557 
558  jetmatch_eff = thisJetMatchStat.filterEfficiency(hepidwtup_);
559  jetmatch_err = thisJetMatchStat.filterEfficiencyError(hepidwtup_);
560 
561  if (i == last) {
562  title[i] = "Total";
563 
564  edm::LogPrint("GenXSecAnalyzer")
565  << "-------------------------------------------------------------------------------------------------------"
566  "------------------------------------------------------------------- ";
567 
568  // fill negative fraction of negative weights and uncertainty after matching
569  final_fract_neg_w = thisEventEffStat.numEventsPassed() > 0
570  ? thisJetMatchStat.numPassNegativeEvents() / thisEventEffStat.numEventsPassed()
571  : 0;
572  final_fract_neg_w_unc =
573  thisJetMatchStat.numPassNegativeEvents() > 0
574  ? final_fract_neg_w * final_fract_neg_w / thisEventEffStat.numEventsPassed() *
575  sqrt(thisJetMatchStat.numPassPositiveEvents() * thisJetMatchStat.numPassPositiveEvents() /
576  thisJetMatchStat.numPassNegativeEvents() +
577  thisJetMatchStat.numPassPositiveEvents())
578  : 0;
579  } else {
580  title[i] = Form("%d", i);
581  }
582 
583  edm::LogPrint("GenXSecAnalyzer") << title[i] << "\t\t" << std::scientific << std::setprecision(3)
584  << xsecBeforeMatching_[i].value() << " +/- " << xsecBeforeMatching_[i].error()
585  << "\t\t" << thisEventEffStat.numEventsPassed() << "\t"
586  << thisJetMatchStat.numPassPositiveEvents() << "\t"
587  << thisJetMatchStat.numPassNegativeEvents() << "\t"
588  << thisEventEffStat.numEventsTotal() << "\t"
589  << thisJetMatchStat.numTotalPositiveEvents() << "\t"
590  << thisJetMatchStat.numTotalNegativeEvents() << "\t" << std::scientific
591  << std::setprecision(3) << xsecAfterMatching_[i].value() << " +/- "
592  << xsecAfterMatching_[i].error() << "\t\t" << std::fixed << std::setprecision(1)
593  << (jetmatch_eff * 100) << " +/- " << (jetmatch_err * 100) << "\t" << std::fixed
594  << std::setprecision(1) << (thisEventEffStat.filterEfficiency(+3) * 100)
595  << " +/- " << (thisEventEffStat.filterEfficiencyError(+3) * 100);
596 
597  matching_eff = thisEventEffStat.filterEfficiency(+3);
598  matching_efferr = thisEventEffStat.filterEfficiencyError(+3);
599  }
600  delete[] title;
601 
602  edm::LogPrint("GenXSecAnalyzer")
603  << "-----------------------------------------------------------------------------------------------------------"
604  "---------------------------------------------------------------";
605 
606  edm::LogPrint("GenXSecAnalyzer") << "Before matching: total cross section = " << std::scientific
607  << std::setprecision(3) << xsecBeforeMatching_[last].value() << " +- "
608  << xsecBeforeMatching_[last].error() << " pb";
609 
610  edm::LogPrint("GenXSecAnalyzer") << "After matching: total cross section = " << std::scientific
611  << std::setprecision(3) << xsecAfterMatching_[last].value() << " +- "
612  << xsecAfterMatching_[last].error() << " pb";
613 
614  edm::LogPrint("GenXSecAnalyzer") << "Matching efficiency = " << std::fixed << std::setprecision(1) << matching_eff
615  << " +/- " << matching_efferr << " [TO BE USED IN MCM]";
616 
617  } else if (hepidwtup_ == -1)
618  edm::LogPrint("GenXSecAnalyzer") << "Before Filter: total cross section = " << std::scientific
619  << std::setprecision(3) << xsecPreFilter_.value() << " +- "
620  << xsecPreFilter_.error() << " pb";
621 
622  // hepMC filter efficiency
623  double hepMCFilter_eff = 1.0;
624  double hepMCFilter_err = 0.0;
625  if (hepMCFilterEffStat_.sumWeights2() > 0) {
626  hepMCFilter_eff = hepMCFilterEffStat_.filterEfficiency(-1);
627  hepMCFilter_err = hepMCFilterEffStat_.filterEfficiencyError(-1);
628  edm::LogPrint("GenXSecAnalyzer") << "HepMC filter efficiency (taking into account weights)= "
629  << "(" << hepMCFilterEffStat_.sumPassWeights() << ")"
630  << " / "
631  << "(" << hepMCFilterEffStat_.sumWeights() << ")"
632  << " = " << std::scientific << std::setprecision(3) << hepMCFilter_eff << " +- "
633  << hepMCFilter_err;
634 
635  double hepMCFilter_event_total =
636  hepMCFilterEffStat_.numTotalPositiveEvents() + hepMCFilterEffStat_.numTotalNegativeEvents();
637  double hepMCFilter_event_pass =
638  hepMCFilterEffStat_.numPassPositiveEvents() + hepMCFilterEffStat_.numPassNegativeEvents();
639  double hepMCFilter_event_eff = hepMCFilter_event_total > 0 ? hepMCFilter_event_pass / hepMCFilter_event_total : 0;
640  double hepMCFilter_event_err =
641  hepMCFilter_event_total > 0
642  ? sqrt((1 - hepMCFilter_event_eff) * hepMCFilter_event_eff / hepMCFilter_event_total)
643  : -1;
644  edm::LogPrint("GenXSecAnalyzer") << "HepMC filter efficiency (event-level)= "
645  << "(" << hepMCFilter_event_pass << ")"
646  << " / "
647  << "(" << hepMCFilter_event_total << ")"
648  << " = " << std::scientific << std::setprecision(3) << hepMCFilter_event_eff
649  << " +- " << hepMCFilter_event_err;
650  }
651 
652  // gen-particle filter efficiency
653  if (filterOnlyEffStat_.sumWeights2() > 0) {
654  double filterOnly_eff = filterOnlyEffStat_.filterEfficiency(-1);
655  double filterOnly_err = filterOnlyEffStat_.filterEfficiencyError(-1);
656 
657  edm::LogPrint("GenXSecAnalyzer") << "Filter efficiency (taking into account weights)= "
658  << "(" << filterOnlyEffStat_.sumPassWeights() << ")"
659  << " / "
660  << "(" << filterOnlyEffStat_.sumWeights() << ")"
661  << " = " << std::scientific << std::setprecision(3) << filterOnly_eff << " +- "
662  << filterOnly_err;
663 
664  double filterOnly_event_total =
665  filterOnlyEffStat_.numTotalPositiveEvents() + filterOnlyEffStat_.numTotalNegativeEvents();
666  double filterOnly_event_pass =
667  filterOnlyEffStat_.numPassPositiveEvents() + filterOnlyEffStat_.numPassNegativeEvents();
668  double filterOnly_event_eff = filterOnly_event_total > 0 ? filterOnly_event_pass / filterOnly_event_total : 0;
669  double filterOnly_event_err = filterOnly_event_total > 0
670  ? sqrt((1 - filterOnly_event_eff) * filterOnly_event_eff / filterOnly_event_total)
671  : -1;
672  edm::LogPrint("GenXSecAnalyzer") << "Filter efficiency (event-level)= "
673  << "(" << filterOnly_event_pass << ")"
674  << " / "
675  << "(" << filterOnly_event_total << ")"
676  << " = " << std::scientific << std::setprecision(3) << filterOnly_event_eff
677  << " +- " << filterOnly_event_err << " [TO BE USED IN MCM]";
678 
679  // fill negative fraction of negative weights and uncertainty after filter
680  final_fract_neg_w =
681  filterOnly_event_pass > 0 ? filterOnlyEffStat_.numPassNegativeEvents() / (filterOnly_event_pass) : 0;
682  final_fract_neg_w_unc =
683  filterOnlyEffStat_.numPassNegativeEvents() > 0
684  ? final_fract_neg_w * final_fract_neg_w / filterOnly_event_pass *
685  sqrt(filterOnlyEffStat_.numPassPositiveEvents() * filterOnlyEffStat_.numPassPositiveEvents() /
686  filterOnlyEffStat_.numPassNegativeEvents() +
687  filterOnlyEffStat_.numPassPositiveEvents())
688  : 0;
689  }
690 
691  edm::LogPrint("GenXSecAnalyzer") << "\nAfter filter: final cross section = " << std::scientific
692  << std::setprecision(3) << xsec_.value() << " +- " << xsec_.error() << " pb";
693 
694  edm::LogPrint("GenXSecAnalyzer") << "After filter: final fraction of events with negative weights = "
695  << std::scientific << std::setprecision(3) << final_fract_neg_w << " +- "
696  << final_fract_neg_w_unc;
697 
698  // L=[N*(1-2f)^2]/s
699  double lumi_1M_evts =
700  xsec_.value() > 0 ? 1e6 * (1 - 2 * final_fract_neg_w) * (1 - 2 * final_fract_neg_w) / xsec_.value() / 1e3 : 0;
701  double lumi_1M_evts_unc =
702  xsec_.value() > 0 ? (1 - 2 * final_fract_neg_w) * lumi_1M_evts *
703  sqrt(1e-6 + 16 * pow(final_fract_neg_w_unc, 2) / pow(1 - 2 * final_fract_neg_w, 2) +
704  pow(xsec_.error() / xsec_.value(), 2))
705  : 0;
706  edm::LogPrint("GenXSecAnalyzer") << "After filter: final equivalent lumi for 1M events (1/fb) = " << std::scientific
707  << std::setprecision(3) << lumi_1M_evts << " +- " << lumi_1M_evts_unc;
708 }

References MillePedeFileConverter_cfg::e, SiPixelPhase1Clusters_cfi::e3, GenLumiInfoProduct::XSec::error(), GenFilterInfo::filterEfficiency(), GenFilterInfo::filterEfficiencyError(), filterOnlyEffStat_, alignBH_cfg::fixed, hepidwtup_, hepMCFilterEffStat_, mps_fire::i, jetMatchEffStat_, dqmdumpme::last, nMCs_, GenFilterInfo::numEventsPassed(), GenFilterInfo::numEventsTotal(), GenFilterInfo::numPassNegativeEvents(), GenFilterInfo::numPassPositiveEvents(), GenFilterInfo::numTotalNegativeEvents(), GenFilterInfo::numTotalPositiveEvents(), funct::pow(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, GenFilterInfo::sumPassWeights(), GenFilterInfo::sumWeights(), GenFilterInfo::sumWeights2(), overlapproblemtsosanalyzer_cfi::title, GenLumiInfoProduct::XSec::value(), xsec_, xsecAfterMatching_, xsecBeforeMatching_, and xsecPreFilter_.

◆ globalBeginLuminosityBlock()

std::shared_ptr< gxsec::LumiCache > GenXSecAnalyzer::globalBeginLuminosityBlock ( edm::LuminosityBlock const &  iLumi,
edm::EventSetup const &   
) const
finalprivate

Definition at line 166 of file GenXSecAnalyzer.cc.

167  {
168  return std::shared_ptr<gxsec::LumiCache>();
169 }

◆ globalBeginRun()

std::shared_ptr< gxsec::RunCache > GenXSecAnalyzer::globalBeginRun ( edm::Run const &  iRun,
edm::EventSetup const &   
) const
finalprivate

Definition at line 152 of file GenXSecAnalyzer.cc.

152  {
153  // initialization for every different physics MC
154 
155  nMCs_++;
156 
157  {
158  std::lock_guard l{mutex_};
159  xsecBeforeMatching_.clear();
160  xsecAfterMatching_.clear();
161  jetMatchEffStat_.clear();
162  }
163  return std::make_shared<gxsec::RunCache>();
164 }

References jetMatchEffStat_, cmsLHEtoEOSManager::l, mutex_, nMCs_, xsecAfterMatching_, and xsecBeforeMatching_.

◆ globalEndLuminosityBlock()

void GenXSecAnalyzer::globalEndLuminosityBlock ( edm::LuminosityBlock const &  iLumi,
edm::EventSetup const &   
) const
finalprivate

Definition at line 173 of file GenXSecAnalyzer.cc.

173  {
174  edm::Handle<GenLumiInfoProduct> genLumiInfo;
175  iLumi.getByToken(genLumiInfoToken_, genLumiInfo);
176  if (!genLumiInfo.isValid())
177  return;
178  hepidwtup_ = genLumiInfo->getHEPIDWTUP();
179 
180  std::vector<GenLumiInfoProduct::ProcessInfo> const &theProcesses = genLumiInfo->getProcessInfos();
181 
182  unsigned int theProcesses_size = theProcesses.size();
183 
184  // if it's a pure parton-shower generator, check there should be only one element in thisProcessInfos
185  // the error of lheXSec is -1
186  if (hepidwtup_ == -1) {
187  if (theProcesses_size != 1) {
188  edm::LogError("GenXSecAnalyzer::endLuminosityBlock") << "Pure parton shower has thisProcessInfos size!=1";
189  return;
190  }
191  }
192 
193  for (unsigned int ip = 0; ip < theProcesses_size; ip++) {
194  if (theProcesses[ip].lheXSec().value() < 0) {
195  edm::LogError("GenXSecAnalyzer::endLuminosityBlock")
196  << "cross section of process " << ip << " value = " << theProcesses[ip].lheXSec().value();
197  return;
198  }
199  }
200 
201  auto runC = runCache(iLumi.getRun().index());
202  {
203  std::lock_guard g{mutex_};
204  runC->product_.mergeProduct(*genLumiInfo);
205  }
206  edm::Handle<GenFilterInfo> genFilter;
207  iLumi.getByToken(genFilterInfoToken_, genFilter);
208 
209  if (genFilter.isValid()) {
210  std::lock_guard g{mutex_};
211  filterOnlyEffStat_.mergeProduct(*genFilter);
212  runC->filterOnlyEffRun_.mergeProduct(*genFilter);
213  runC->thisRunWeight_ += genFilter->sumPassWeights();
214  }
215 
216  edm::Handle<GenFilterInfo> hepMCFilter;
217  iLumi.getByToken(hepMCFilterInfoToken_, hepMCFilter);
218 
219  if (hepMCFilter.isValid()) {
220  std::lock_guard g{mutex_};
221  hepMCFilterEffStat_.mergeProduct(*hepMCFilter);
222  runC->hepMCFilterEffRun_.mergeProduct(*hepMCFilter);
223  }
224 
225  std::lock_guard g{mutex_};
226  // doing generic summing for jet matching statistics
227  // and computation of combined LHE information
228  for (unsigned int ip = 0; ip < theProcesses_size; ip++) {
229  int id = theProcesses[ip].process();
230  GenFilterInfo &x = jetMatchEffStat_[id];
231  GenLumiInfoProduct::XSec &y = runC->currentLumiBlockLHEXSec_[id];
232  GenLumiInfoProduct::FinalStat temp_killed = theProcesses[ip].killed();
233  GenLumiInfoProduct::FinalStat temp_selected = theProcesses[ip].selected();
234  double passw = temp_killed.sum();
235  double passw2 = temp_killed.sum2();
236  double totalw = temp_selected.sum();
237  double totalw2 = temp_selected.sum2();
238  GenFilterInfo tempInfo(theProcesses[ip].nPassPos(),
239  theProcesses[ip].nPassNeg(),
240  theProcesses[ip].nTotalPos(),
241  theProcesses[ip].nTotalNeg(),
242  passw,
243  passw2,
244  totalw,
245  totalw2);
246 
247  // matching statistics for all processes
248  jetMatchEffStat_[10000].mergeProduct(tempInfo);
249  double currentValue = theProcesses[ip].lheXSec().value();
250  double currentError = theProcesses[ip].lheXSec().error();
251 
252  // this process ID has occurred before
253  auto &thisRunWeightPre = runC->thisRunWeightPre_;
254  if (y.value() > 0) {
255  x.mergeProduct(tempInfo);
256  double previousValue = runC->previousLumiBlockLHEXSec_[id].value();
257 
258  if (currentValue != previousValue) // transition of cross section
259  {
260  double xsec = y.value();
261  double err = y.error();
262  combine(xsec, err, thisRunWeightPre, currentValue, currentError, totalw);
263  y = GenLumiInfoProduct::XSec(xsec, err);
264  } else // LHE cross section is the same as previous lumiblock
265  thisRunWeightPre += totalw;
266 
267  }
268  // this process ID has never occurred before
269  else {
270  x = tempInfo;
271  y = theProcesses[ip].lheXSec();
272  thisRunWeightPre += totalw;
273  }
274 
275  runC->previousLumiBlockLHEXSec_[id] = theProcesses[ip].lheXSec();
276  } // end
277 
278  return;
279 }

References combine(), runTheMatrix::err, filterOnlyEffStat_, g, genFilterInfoToken_, rivetAnalyzer_cfi::genLumiInfo, genLumiInfoToken_, edm::LuminosityBlock::getByToken(), edm::LuminosityBlock::getRun(), hepidwtup_, hepMCFilterEffStat_, hepMCFilterInfoToken_, triggerObjects_cff::id, edm::Run::index(), edm::HandleBase::isValid(), jetMatchEffStat_, GenFilterInfo::mergeProduct(), mutex_, GenLumiInfoProduct::FinalStat::sum(), GenLumiInfoProduct::FinalStat::sum2(), GenFilterInfo::sumPassWeights(), relativeConstraints::value, x, and y.

◆ globalEndRun()

void GenXSecAnalyzer::globalEndRun ( edm::Run const &  iRun,
edm::EventSetup const &   
) const
finalprivate

Definition at line 281 of file GenXSecAnalyzer.cc.

281  {
282  //xsection before matching
283  edm::Handle<LHERunInfoProduct> run;
284 
285  if (iRun.getByToken(lheRunInfoToken_, run)) {
286  const lhef::HEPRUP thisHeprup = run->heprup();
287 
288  for (unsigned int iSize = 0; iSize < thisHeprup.XSECUP.size(); iSize++) {
289  std::cout << std::setw(14) << std::fixed << thisHeprup.XSECUP[iSize] << std::setw(14) << std::fixed
290  << thisHeprup.XERRUP[iSize] << std::setw(14) << std::fixed << thisHeprup.XMAXUP[iSize] << std::setw(14)
291  << std::fixed << thisHeprup.LPRUP[iSize] << std::endl;
292  }
293  std::cout << " " << std::endl;
294  }
295 
296  auto runC = runCache(iRun.index());
297  std::lock_guard l{mutex_};
298 
299  // compute cross section for this run first
300  // set the correct combined LHE+filter cross sections
301  unsigned int i = 0;
302  std::vector<GenLumiInfoProduct::ProcessInfo> newInfos;
303  for (std::map<int, GenLumiInfoProduct::XSec>::const_iterator iter = runC->currentLumiBlockLHEXSec_.begin();
304  iter != runC->currentLumiBlockLHEXSec_.end();
305  ++iter, i++) {
306  GenLumiInfoProduct::ProcessInfo temp = runC->product_.getProcessInfos()[i];
307  temp.setLheXSec(iter->second.value(), iter->second.error());
308  newInfos.push_back(temp);
309  }
310  runC->product_.setProcessInfo(newInfos);
311 
312  const GenLumiInfoProduct::XSec thisRunXSecPre = compute(runC->product_);
313  // xsection after matching before filters
314  combine(xsecPreFilter_, totalWeightPre_, thisRunXSecPre, runC->thisRunWeightPre_);
315 
316  double thisHepFilterEff = 1;
317  double thisHepFilterErr = 0;
318 
319  if (runC->hepMCFilterEffRun_.sumWeights2() > 0) {
320  thisHepFilterEff = runC->hepMCFilterEffRun_.filterEfficiency(hepidwtup_);
321  thisHepFilterErr = runC->hepMCFilterEffRun_.filterEfficiencyError(hepidwtup_);
322  if (thisHepFilterEff < 0) {
323  thisHepFilterEff = 1;
324  thisHepFilterErr = 0;
325  }
326  }
327 
328  double thisGenFilterEff = 1;
329  double thisGenFilterErr = 0;
330 
331  if (runC->filterOnlyEffRun_.sumWeights2() > 0) {
332  thisGenFilterEff = runC->filterOnlyEffRun_.filterEfficiency(hepidwtup_);
333  thisGenFilterErr = runC->filterOnlyEffRun_.filterEfficiencyError(hepidwtup_);
334  if (thisGenFilterEff < 0) {
335  thisGenFilterEff = 1;
336  thisGenFilterErr = 0;
337  }
338  }
339  double thisXsec = thisRunXSecPre.value() > 0 ? thisHepFilterEff * thisGenFilterEff * thisRunXSecPre.value() : 0;
340  double thisErr =
341  thisRunXSecPre.value() > 0
342  ? thisXsec * sqrt(pow(TMath::Max(thisRunXSecPre.error(), (double)0) / thisRunXSecPre.value(), 2) +
343  pow(thisHepFilterErr / thisHepFilterEff, 2) + pow(thisGenFilterErr / thisGenFilterEff, 2))
344  : 0;
345  const GenLumiInfoProduct::XSec thisRunXSec = GenLumiInfoProduct::XSec(thisXsec, thisErr);
346  combine(xsec_, totalWeight_, thisRunXSec, runC->thisRunWeight_);
347 }

References combine(), compute(), gather_cfg::cout, GenLumiInfoProduct::XSec::error(), alignBH_cfg::fixed, edm::Run::getByToken(), hepidwtup_, mps_fire::i, edm::Run::index(), cmsLHEtoEOSManager::l, lheRunInfoToken_, lhef::HEPRUP::LPRUP, Max(), mutex_, funct::pow(), writedatasetfile::run, mathSSE::sqrt(), groupFilesInBlocks::temp, totalWeight_, totalWeightPre_, GenLumiInfoProduct::XSec::value(), lhef::HEPRUP::XERRUP, lhef::HEPRUP::XMAXUP, xsec_, xsecPreFilter_, and lhef::HEPRUP::XSECUP.

Member Data Documentation

◆ filterOnlyEffStat_

GenFilterInfo GenXSecAnalyzer::filterOnlyEffStat_
mutableprivate

Definition at line 117 of file GenXSecAnalyzer.cc.

Referenced by endJob(), and globalEndLuminosityBlock().

◆ genFilterInfoToken_

edm::EDGetTokenT<GenFilterInfo> GenXSecAnalyzer::genFilterInfoToken_
private

Definition at line 91 of file GenXSecAnalyzer.cc.

Referenced by GenXSecAnalyzer(), and globalEndLuminosityBlock().

◆ genLumiInfoToken_

edm::EDGetTokenT<GenLumiInfoProduct> GenXSecAnalyzer::genLumiInfoToken_
private

Definition at line 93 of file GenXSecAnalyzer.cc.

Referenced by GenXSecAnalyzer(), and globalEndLuminosityBlock().

◆ hepidwtup_

std::atomic<int> GenXSecAnalyzer::hepidwtup_
mutableprivate

Definition at line 100 of file GenXSecAnalyzer.cc.

Referenced by compute(), endJob(), globalEndLuminosityBlock(), and globalEndRun().

◆ hepMCFilterEffStat_

GenFilterInfo GenXSecAnalyzer::hepMCFilterEffStat_
mutableprivate

Definition at line 120 of file GenXSecAnalyzer.cc.

Referenced by endJob(), and globalEndLuminosityBlock().

◆ hepMCFilterInfoToken_

edm::EDGetTokenT<GenFilterInfo> GenXSecAnalyzer::hepMCFilterInfoToken_
private

Definition at line 92 of file GenXSecAnalyzer.cc.

Referenced by GenXSecAnalyzer(), and globalEndLuminosityBlock().

◆ jetMatchEffStat_

std::map<int, GenFilterInfo> GenXSecAnalyzer::jetMatchEffStat_
mutableprivate

Definition at line 130 of file GenXSecAnalyzer.cc.

Referenced by compute(), endJob(), globalBeginRun(), and globalEndLuminosityBlock().

◆ lheRunInfoToken_

edm::EDGetTokenT<LHERunInfoProduct> GenXSecAnalyzer::lheRunInfoToken_
private

Definition at line 94 of file GenXSecAnalyzer.cc.

Referenced by GenXSecAnalyzer(), and globalEndRun().

◆ mutex_

std::mutex GenXSecAnalyzer::mutex_
mutableprivate

Definition at line 102 of file GenXSecAnalyzer.cc.

Referenced by globalBeginRun(), globalEndLuminosityBlock(), and globalEndRun().

◆ nMCs_

std::atomic<int> GenXSecAnalyzer::nMCs_
mutableprivate

Definition at line 98 of file GenXSecAnalyzer.cc.

Referenced by endJob(), and globalBeginRun().

◆ totalWeight_

double GenXSecAnalyzer::totalWeight_
mutableprivate

Definition at line 108 of file GenXSecAnalyzer.cc.

Referenced by globalEndRun().

◆ totalWeightPre_

double GenXSecAnalyzer::totalWeightPre_
mutableprivate

Definition at line 105 of file GenXSecAnalyzer.cc.

Referenced by globalEndRun().

◆ xsec_

GenLumiInfoProduct::XSec GenXSecAnalyzer::xsec_
mutableprivate

Definition at line 114 of file GenXSecAnalyzer.cc.

Referenced by endJob(), and globalEndRun().

◆ xsecAfterMatching_

std::vector<GenLumiInfoProduct::XSec> GenXSecAnalyzer::xsecAfterMatching_
mutableprivate

Definition at line 128 of file GenXSecAnalyzer.cc.

Referenced by compute(), endJob(), and globalBeginRun().

◆ xsecBeforeMatching_

std::vector<GenLumiInfoProduct::XSec> GenXSecAnalyzer::xsecBeforeMatching_
mutableprivate

Definition at line 126 of file GenXSecAnalyzer.cc.

Referenced by compute(), endJob(), and globalBeginRun().

◆ xsecPreFilter_

GenLumiInfoProduct::XSec GenXSecAnalyzer::xsecPreFilter_
mutableprivate

Definition at line 111 of file GenXSecAnalyzer.cc.

Referenced by endJob(), and globalEndRun().

GenXSecAnalyzer::totalWeight_
double totalWeight_
Definition: GenXSecAnalyzer.cc:108
lhef::HEPRUP::XSECUP
std::vector< double > XSECUP
Definition: LesHouches.h:112
GenFilterInfo::numPassNegativeEvents
unsigned int numPassNegativeEvents() const
Definition: GenFilterInfo.h:28
DDAxes::y
alignBH_cfg.fixed
fixed
Definition: alignBH_cfg.py:54
GenFilterInfo::filterEfficiencyError
double filterEfficiencyError(int idwtup=+3) const
Definition: GenFilterInfo.cc:103
GenFilterInfo
Definition: GenFilterInfo.h:11
mps_fire.i
i
Definition: mps_fire.py:355
GenFilterInfo::mergeProduct
bool mergeProduct(GenFilterInfo const &other)
Definition: GenFilterInfo.cc:61
GenXSecAnalyzer::hepidwtup_
std::atomic< int > hepidwtup_
Definition: GenXSecAnalyzer.cc:100
GenXSecAnalyzer::genLumiInfoToken_
edm::EDGetTokenT< GenLumiInfoProduct > genLumiInfoToken_
Definition: GenXSecAnalyzer.cc:93
GenFilterInfo::filterEfficiency
double filterEfficiency(int idwtup=+3) const
Definition: GenFilterInfo.cc:89
GenLumiInfoProduct::XSec::error
double error() const
Definition: GenLumiInfoProduct.h:41
GenXSecAnalyzer::xsec_
GenLumiInfoProduct::XSec xsec_
Definition: GenXSecAnalyzer.cc:114
GenXSecAnalyzer::compute
GenLumiInfoProduct::XSec compute(const GenLumiInfoProduct &) const
Definition: GenXSecAnalyzer.cc:384
gather_cfg.cout
cout
Definition: gather_cfg.py:144
GenXSecAnalyzer::hepMCFilterEffStat_
GenFilterInfo hepMCFilterEffStat_
Definition: GenXSecAnalyzer.cc:120
DDAxes::x
GenFilterInfo::numPassPositiveEvents
unsigned int numPassPositiveEvents() const
Definition: GenFilterInfo.h:25
GenXSecAnalyzer::hepMCFilterInfoToken_
edm::EDGetTokenT< GenFilterInfo > hepMCFilterInfoToken_
Definition: GenXSecAnalyzer.cc:92
edm::Handle
Definition: AssociativeIterator.h:50
groupFilesInBlocks.temp
list temp
Definition: groupFilesInBlocks.py:142
relativeConstraints.error
error
Definition: relativeConstraints.py:53
groupFilesInBlocks.ntotal
int ntotal
Definition: groupFilesInBlocks.py:100
GenFilterInfo::numTotalPositiveEvents
unsigned int numTotalPositiveEvents() const
Definition: GenFilterInfo.h:26
GenLumiInfoProduct::XSec
Definition: GenLumiInfoProduct.h:34
GenLumiInfoProduct::XSec::value
double value() const
Definition: GenLumiInfoProduct.h:40
GenXSecAnalyzer::jetMatchEffStat_
std::map< int, GenFilterInfo > jetMatchEffStat_
Definition: GenXSecAnalyzer.cc:130
dqmdumpme.last
last
Definition: dqmdumpme.py:56
GenXSecAnalyzer::lheRunInfoToken_
edm::EDGetTokenT< LHERunInfoProduct > lheRunInfoToken_
Definition: GenXSecAnalyzer.cc:94
GenFilterInfo::sumWeights
double sumWeights() const
Definition: GenFilterInfo.h:37
GenLumiInfoProduct::ProcessInfo
Definition: GenLumiInfoProduct.h:86
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
GenXSecAnalyzer::filterOnlyEffStat_
GenFilterInfo filterOnlyEffStat_
Definition: GenXSecAnalyzer.cc:117
GenXSecAnalyzer::combine
void combine(GenLumiInfoProduct::XSec &, double &, const GenLumiInfoProduct::XSec &, const double &) const
Definition: GenXSecAnalyzer.cc:371
GenFilterInfo::sumPassWeights
double sumPassWeights() const
Definition: GenFilterInfo.h:31
GenLumiInfoProduct::getProcessInfos
const std::vector< ProcessInfo > & getProcessInfos() const
Definition: GenLumiInfoProduct.h:26
lhef::HEPRUP::LPRUP
std::vector< int > LPRUP
Definition: LesHouches.h:128
GenXSecAnalyzer::totalWeightPre_
double totalWeightPre_
Definition: GenXSecAnalyzer.cc:105
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::LogError
Definition: MessageLogger.h:183
rivetAnalyzer_cfi.genLumiInfo
genLumiInfo
Definition: rivetAnalyzer_cfi.py:7
ValidateTausOnZEEFastSim_cff.proc
proc
Definition: ValidateTausOnZEEFastSim_cff.py:6
GenXSecAnalyzer::xsecAfterMatching_
std::vector< GenLumiInfoProduct::XSec > xsecAfterMatching_
Definition: GenXSecAnalyzer.cc:128
GenFilterInfo::numEventsTotal
unsigned int numEventsTotal() const
Definition: GenFilterInfo.h:23
runTheMatrix.err
err
Definition: runTheMatrix.py:288
GenFilterInfo::numTotalNegativeEvents
unsigned int numTotalNegativeEvents() const
Definition: GenFilterInfo.h:29
GenFilterInfo::sumWeights2
double sumWeights2() const
Definition: GenFilterInfo.h:38
value
Definition: value.py:1
edm::LogPrint
Definition: MessageLogger.h:342
lhef::HEPRUP
Definition: LesHouches.h:22
GenXSecAnalyzer::nMCs_
std::atomic< int > nMCs_
Definition: GenXSecAnalyzer.cc:98
HLTTauDQMOffline_cfi.numerator
numerator
Definition: HLTTauDQMOffline_cfi.py:194
Max
T Max(T a, T b)
Definition: MathUtil.h:44
GenFilterInfo::numEventsPassed
unsigned int numEventsPassed() const
Definition: GenFilterInfo.h:22
GenXSecAnalyzer::genFilterInfoToken_
edm::EDGetTokenT< GenFilterInfo > genFilterInfoToken_
Definition: GenXSecAnalyzer.cc:91
GenXSecAnalyzer::xsecPreFilter_
GenLumiInfoProduct::XSec xsecPreFilter_
Definition: GenXSecAnalyzer.cc:111
cmsLHEtoEOSManager.l
l
Definition: cmsLHEtoEOSManager.py:193
overlapproblemtsosanalyzer_cfi.title
title
Definition: overlapproblemtsosanalyzer_cfi.py:7
GenLumiInfoProduct::FinalStat::sum
double sum() const
Definition: GenLumiInfoProduct.h:63
SiPixelPhase1Clusters_cfi.e3
e3
Definition: SiPixelPhase1Clusters_cfi.py:9
lhef::HEPRUP::XERRUP
std::vector< double > XERRUP
Definition: LesHouches.h:118
HLTTauDQMOffline_cfi.denominator
denominator
Definition: HLTTauDQMOffline_cfi.py:195
writedatasetfile.run
run
Definition: writedatasetfile.py:27
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
relativeConstraints.value
value
Definition: relativeConstraints.py:53
GenLumiInfoProduct::FinalStat
Definition: GenLumiInfoProduct.h:56
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
lhef::HEPRUP::XMAXUP
std::vector< double > XMAXUP
Definition: LesHouches.h:123
GenXSecAnalyzer::xsecBeforeMatching_
std::vector< GenLumiInfoProduct::XSec > xsecBeforeMatching_
Definition: GenXSecAnalyzer.cc:126
GenXSecAnalyzer::mutex_
std::mutex mutex_
Definition: GenXSecAnalyzer.cc:102
GenLumiInfoProduct::FinalStat::sum2
double sum2() const
Definition: GenLumiInfoProduct.h:64
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
edm::InputTag
Definition: InputTag.h:15
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Generated for CMSSW Reference Manual by doxygen 1.8.16