CMS 3D CMS Logo
List of all members | Public Member Functions | Protected Member Functions | Protected Attributes
MuScleFit Class Reference
Inheritance diagram for MuScleFit:
edm::EDLooper MuScleFitBase edm::EDLooperBase

Public Member Functions

void beginOfJobInConstructor ()
 
virtual void duringFastLoop ()
 
edm::EDLooper::Status duringLoop (const edm::Event &event, const edm::EventSetup &eventSetup) override
 
virtual void endOfFastLoop (const unsigned int iLoop)
 
void endOfJob () override
 
edm::EDLooper::Status endOfLoop (const edm::EventSetup &eventSetup, unsigned int iLoop) override
 
template<typename T >
std::vector< MuScleFitMuon > fillMuonCollection (const std::vector< T > &tracks)
 
 MuScleFit (const edm::ParameterSet &pset)
 
void startingNewLoop (unsigned int iLoop) override
 
 ~MuScleFit () override
 
- Public Member Functions inherited from edm::EDLooper
 EDLooper ()
 
 EDLooper (EDLooper const &)=delete
 
EDLooper & operator= (EDLooper const &)=delete
 
 ~EDLooper () override
 
- Public Member Functions inherited from edm::EDLooperBase
virtual void attachTo (ActivityRegistry &)
 Override this method if you need to monitor the state of the processing. More...
 
virtual void beginOfJob ()
 
virtual void beginOfJob (EventSetup const &)
 
void beginOfJob (EventSetupImpl const &)
 
void copyInfo (ScheduleInfo const &)
 
void doBeginLuminosityBlock (LuminosityBlockPrincipal &, EventSetupImpl const &, ProcessContext *)
 
void doBeginRun (RunPrincipal &, EventSetupImpl const &, ProcessContext *)
 
Status doDuringLoop (EventPrincipal &eventPrincipal, EventSetupImpl const &es, ProcessingController &, StreamContext *)
 
void doEndLuminosityBlock (LuminosityBlockPrincipal &, EventSetupImpl const &, ProcessContext *)
 
Status doEndOfLoop (EventSetupImpl const &es)
 
void doEndRun (RunPrincipal &, EventSetupImpl const &, ProcessContext *)
 
void doStartingNewLoop ()
 
 EDLooperBase ()
 
 EDLooperBase (EDLooperBase const &)=delete
 
virtual std::set< eventsetup::EventSetupRecordKey > modifyingRecords () const
 
EDLooperBase & operator= (EDLooperBase const &)=delete
 
void prepareForNextLoop (eventsetup::EventSetupProvider *esp)
 
void setActionTable (ExceptionToActionTable const *actionTable)
 
void setModuleChanger (ModuleChanger *)
 
virtual ~EDLooperBase () noexcept(false)
 

Protected Member Functions

void applyBias (reco::Particle::LorentzVector &mu, const int charge)
 Apply the bias if needed using the function in MuScleFitUtils. More...
 
void applySmearing (reco::Particle::LorentzVector &mu)
 Apply the smearing if needed using the function in MuScleFitUtils. More...
 
bool checkDeltaR (reco::Particle::LorentzVector &genMu, reco::Particle::LorentzVector &recMu)
 Check if two lorentzVector are near in deltaR. More...
 
void checkParameters ()
 
void fillComparisonHistograms (const reco::Particle::LorentzVector &genMu, const reco::Particle::LorentzVector &recoMu, const std::string &inputName, const int charge)
 Fill the reco vs gen and reco vs sim comparison histograms. More...
 
void selectMuons (const edm::Event &event)
 
void selectMuons (const int maxEvents, const TString &treeFileName)
 
bool selGlobalMuon (const pat::Muon *aMuon)
 Function for onia selections. More...
 
bool selTrackerMuon (const pat::Muon *aMuon)
 
template<typename T >
void takeSelectedMuonType (const T &muon, std::vector< reco::Track > &tracks)
 Template method used to fill the track collection starting from reco::muons or pat::muons. More...
 
- Protected Member Functions inherited from edm::EDLooperBase
ModuleChanger * moduleChanger ()
 This only returns a non-zero value during the call to endOfLoop. More...
 
ScheduleInfo const * scheduleInfo () const
 This returns a non-zero value after the constructor has been called. More...
 

Protected Attributes

bool compareToSimTracks_
 
bool fastLoop
 
std::string genParticlesName_
 
int iev
 
bool ifGenPart
 
bool ifHepMC
 
std::string inputRootTreeFileName_
 
unsigned int loopCounter
 
int maxEventsFromRootTree_
 
unsigned int maxLoopNumber
 
double maxResMass_hwindow [6]
 
double minResMass_hwindow [6]
 
std::unique_ptr< MuScleFitMuonSelector > muonSelector_
 
bool negateTrigger_
 
int numberOfEwkZ
 
int numberOfSimMuons
 
int numberOfSimTracks
 
int numberOfSimVertices
 
std::string outputRootTreeFileName_
 
bool PATmuons_
 
MuScleFitPlotter * plotter
 
edm::InputTag puInfoSrc_
 
reco::Particle::LorentzVector recMu1
 
reco::Particle::LorentzVector recMu2
 
MuScleFitMuon recMuScleMu1
 
MuScleFitMuon recMuScleMu2
 
bool saveAllToTree_
 
edm::InputTag simTracksCollection_
 
MuonServiceProxy * theService
 
int totalEvents_
 
std::vector< std::string > triggerPath_
 
std::string triggerResultsLabel_
 
std::string triggerResultsProcess_
 
edm::InputTag vertexSrc_
 

Additional Inherited Members

- Public Types inherited from edm::EDLooperBase
enum  Status { kContinue, kStop }
 
- Private Member Functions inherited from MuScleFitBase
 MuScleFitBase (const edm::ParameterSet &iConfig)
 
virtual ~MuScleFitBase () noexcept(false)
 
void clearHistoMap ()
 Clean the histograms map. More...
 
void fillHistoMap (TFile *outputFile, unsigned int iLoop)
 Create the histograms map. More...
 
void readProbabilityDistributionsFromFile ()
 Read probability distributions from a local root file. More...
 
void writeHistoMap (const unsigned int iLoop)
 Save the histograms map to file. More...
 
- Private Attributes inherited from MuScleFitBase
int debug_
 
std::vector< GenMuonPair > genMuonPairs_
 Stores the genMuon pairs and the motherId prior to the creation of the internal tree. More...
 
std::map< std::string, Histograms * > mapHisto_
 The map of histograms. More...
 
std::vector< MuonPair > muonPairs_
 Used to store the muon pairs plus run and event number prior to the creation of the internal tree. More...
 
std::string probabilitiesFile_
 
std::string probabilitiesFileInPath_
 
std::vector< TFile * > theFiles_
 The files were the histograms are saved. More...
 
std::string theGenInfoRootFileName_
 
edm::InputTag theMuonLabel_
 
int theMuonType_
 
std::string theRootFileName_
 

Detailed Description

Analyzer of the Global muon tracks

Definition at line 183 of file MuScleFit.cc.

Constructor & Destructor Documentation

◆ MuScleFit()

MuScleFit::MuScleFit ( const edm::ParameterSet &  pset)

Definition at line 371 of file MuScleFit.cc.

371  : MuScleFitBase(pset), totalEvents_(0) {
372  MuScleFitUtils::debug = debug_;
373  if (debug_ > 0)
374  std::cout << "[MuScleFit]: Constructor" << std::endl;
375 
376  if ((theMuonType_ < -4 || theMuonType_ > 5) && theMuonType_ < 10) {
377  std::cout << "[MuScleFit]: Unknown muon type! Aborting." << std::endl;
378  abort();
379  }
380 
381  loopCounter = 0;
382 
383  // Boundaries for h-function computation (to be improved!)
384  // -------------------------------------------------------
385  minResMass_hwindow[0] = 71.1876; // 76.;
386  maxResMass_hwindow[0] = 111.188; // 106.;
387  minResMass_hwindow[1] = 10.15;
388  maxResMass_hwindow[1] = 10.55;
389  minResMass_hwindow[2] = 9.8;
390  maxResMass_hwindow[2] = 10.2;
391  minResMass_hwindow[3] = 9.25;
392  maxResMass_hwindow[3] = 9.65;
393  minResMass_hwindow[4] = 3.58;
394  maxResMass_hwindow[4] = 3.78;
395  minResMass_hwindow[5] = 3.0;
396  maxResMass_hwindow[5] = 3.2;
397 
398  // Max number of loops (if > 2 then try to minimize likelihood more than once)
399  // ---------------------------------------------------------------------------
400  maxLoopNumber = pset.getUntrackedParameter<int>("maxLoopNumber", 2);
401  fastLoop = pset.getUntrackedParameter<bool>("FastLoop", true);
402 
403  // Selection of fits according to loop
404  MuScleFitUtils::doResolFit = pset.getParameter<std::vector<int> >("doResolFit");
405  MuScleFitUtils::doScaleFit = pset.getParameter<std::vector<int> >("doScaleFit");
406  MuScleFitUtils::doCrossSectionFit = pset.getParameter<std::vector<int> >("doCrossSectionFit");
407  MuScleFitUtils::doBackgroundFit = pset.getParameter<std::vector<int> >("doBackgroundFit");
408 
409  // Bias and smear types
410  // --------------------
411  int biasType = pset.getParameter<int>("BiasType");
412  MuScleFitUtils::BiasType = biasType;
413  // No error, the scale functions are used also for the bias
414  MuScleFitUtils::biasFunction = scaleFunctionVecService(biasType);
415  int smearType = pset.getParameter<int>("SmearType");
416  MuScleFitUtils::SmearType = smearType;
417  MuScleFitUtils::smearFunction = smearFunctionService(smearType);
418 
419  // Fit types
420  // ---------
421  int resolFitType = pset.getParameter<int>("ResolFitType");
422  MuScleFitUtils::ResolFitType = resolFitType;
423  MuScleFitUtils::resolutionFunction = resolutionFunctionService(resolFitType);
424  MuScleFitUtils::resolutionFunctionForVec = resolutionFunctionVecService(resolFitType);
425  int scaleType = pset.getParameter<int>("ScaleFitType");
426  MuScleFitUtils::ScaleFitType = scaleType;
427  MuScleFitUtils::scaleFunction = scaleFunctionService(scaleType);
428  MuScleFitUtils::scaleFunctionForVec = scaleFunctionVecService(scaleType);
429 
430  // Initial parameters values
431  // -------------------------
432  MuScleFitUtils::parBias = pset.getParameter<std::vector<double> >("parBias");
433  MuScleFitUtils::parSmear = pset.getParameter<std::vector<double> >("parSmear");
434  MuScleFitUtils::parResol = pset.getParameter<std::vector<double> >("parResol");
435  MuScleFitUtils::parResolStep =
436  pset.getUntrackedParameter<std::vector<double> >("parResolStep", std::vector<double>());
437  MuScleFitUtils::parResolMin = pset.getUntrackedParameter<std::vector<double> >("parResolMin", std::vector<double>());
438  MuScleFitUtils::parResolMax = pset.getUntrackedParameter<std::vector<double> >("parResolMax", std::vector<double>());
439  MuScleFitUtils::parScale = pset.getParameter<std::vector<double> >("parScale");
440  MuScleFitUtils::parScaleStep =
441  pset.getUntrackedParameter<std::vector<double> >("parScaleStep", std::vector<double>());
442  MuScleFitUtils::parScaleMin = pset.getUntrackedParameter<std::vector<double> >("parScaleMin", std::vector<double>());
443  MuScleFitUtils::parScaleMax = pset.getUntrackedParameter<std::vector<double> >("parScaleMax", std::vector<double>());
444  MuScleFitUtils::parCrossSection = pset.getParameter<std::vector<double> >("parCrossSection");
445  MuScleFitUtils::parBgr = pset.getParameter<std::vector<double> >("parBgr");
446  MuScleFitUtils::parResolFix = pset.getParameter<std::vector<int> >("parResolFix");
447  MuScleFitUtils::parScaleFix = pset.getParameter<std::vector<int> >("parScaleFix");
448  MuScleFitUtils::parCrossSectionFix = pset.getParameter<std::vector<int> >("parCrossSectionFix");
449  MuScleFitUtils::parBgrFix = pset.getParameter<std::vector<int> >("parBgrFix");
450  MuScleFitUtils::parResolOrder = pset.getParameter<std::vector<int> >("parResolOrder");
451  MuScleFitUtils::parScaleOrder = pset.getParameter<std::vector<int> >("parScaleOrder");
452  MuScleFitUtils::parCrossSectionOrder = pset.getParameter<std::vector<int> >("parCrossSectionOrder");
453  MuScleFitUtils::parBgrOrder = pset.getParameter<std::vector<int> >("parBgrOrder");
454 
455  MuScleFitUtils::resfind = pset.getParameter<std::vector<int> >("resfind");
456  MuScleFitUtils::FitStrategy = pset.getParameter<int>("FitStrategy");
457 
458  // Option to skip unnecessary stuff
459  // --------------------------------
460  MuScleFitUtils::speedup = pset.getParameter<bool>("speedup");
461 
462  // Option to skip simTracks comparison
463  compareToSimTracks_ = pset.getParameter<bool>("compareToSimTracks");
464  simTracksCollection_ = pset.getUntrackedParameter<edm::InputTag>("SimTracksCollection", edm::InputTag("g4SimHits"));
465 
466  triggerResultsLabel_ = pset.getUntrackedParameter<std::string>("TriggerResultsLabel");
467  triggerResultsProcess_ = pset.getUntrackedParameter<std::string>("TriggerResultsProcess");
468  triggerPath_ = pset.getUntrackedParameter<std::vector<std::string> >("TriggerPath");
469  negateTrigger_ = pset.getUntrackedParameter<bool>("NegateTrigger", false);
470  saveAllToTree_ = pset.getUntrackedParameter<bool>("SaveAllToTree", false);
471 
472  // input collections for PU related infos
473  puInfoSrc_ = pset.getUntrackedParameter<edm::InputTag>("PileUpSummaryInfo");
474  vertexSrc_ = pset.getUntrackedParameter<edm::InputTag>("PrimaryVertexCollection");
475 
476  PATmuons_ = pset.getUntrackedParameter<bool>("PATmuons", false);
477  genParticlesName_ = pset.getUntrackedParameter<std::string>("GenParticlesName", "genParticles");
478 
479  // Use the probability file or not. If not it will perform a simpler selection taking the muon pair with
480  // invariant mass closer to the pdf value and will crash if some fit is attempted.
481  MuScleFitUtils::useProbsFile_ = pset.getUntrackedParameter<bool>("UseProbsFile", true);
482 
483  // This must be set to true if using events generated with Sherpa
484  MuScleFitUtils::sherpa_ = pset.getUntrackedParameter<bool>("Sherpa", false);
485 
486  MuScleFitUtils::rapidityBinsForZ_ = pset.getUntrackedParameter<bool>("RapidityBinsForZ", true);
487 
488  // Set the cuts on muons to be used in the fit
489  MuScleFitUtils::separateRanges_ = pset.getUntrackedParameter<bool>("SeparateRanges", true);
490  MuScleFitUtils::maxMuonPt_ = pset.getUntrackedParameter<double>("MaxMuonPt", 100000000.);
491  MuScleFitUtils::minMuonPt_ = pset.getUntrackedParameter<double>("MinMuonPt", 0.);
492  MuScleFitUtils::minMuonEtaFirstRange_ = pset.getUntrackedParameter<double>("MinMuonEtaFirstRange", -6.);
493  MuScleFitUtils::maxMuonEtaFirstRange_ = pset.getUntrackedParameter<double>("MaxMuonEtaFirstRange", 6.);
494  MuScleFitUtils::minMuonEtaSecondRange_ = pset.getUntrackedParameter<double>("MinMuonEtaSecondRange", -100.);
495  MuScleFitUtils::maxMuonEtaSecondRange_ = pset.getUntrackedParameter<double>("MaxMuonEtaSecondRange", 100.);
496  MuScleFitUtils::deltaPhiMinCut_ = pset.getUntrackedParameter<double>("DeltaPhiMinCut", -100.);
497  MuScleFitUtils::deltaPhiMaxCut_ = pset.getUntrackedParameter<double>("DeltaPhiMaxCut", 100.);
498 
499  MuScleFitUtils::debugMassResol_ = pset.getUntrackedParameter<bool>("DebugMassResol", false);
500  // MuScleFitUtils::massResolComponentsStruct MuScleFitUtils::massResolComponents;
501 
502  // Check for parameters consistency
503  // it will abort in case of errors.
504  checkParameters();
505 
506  // Generate array of gaussian-distributed numbers for smearing
507  // -----------------------------------------------------------
508  if (MuScleFitUtils::SmearType > 0) {
509  std::cout << "[MuScleFit-Constructor]: Generating random values for smearing" << std::endl;
510  TF1 G("G", "[0]*exp(-0.5*pow(x,2))", -5., 5.);
511  double norm = 1 / sqrt(2 * TMath::Pi());
512  G.SetParameter(0, norm);
513  for (int i = 0; i < 10000; i++) {
514  for (int j = 0; j < 7; j++) {
515  MuScleFitUtils::x[j][i] = G.GetRandom();
516  }
517  }
518  }
519  MuScleFitUtils::goodmuon = 0;
520 
521  if (theMuonType_ > 0 && theMuonType_ < 4) {
522  MuScleFitUtils::MuonTypeForCheckMassWindow = theMuonType_ - 1;
523  MuScleFitUtils::MuonType = theMuonType_ - 1;
524  } else if (theMuonType_ == 0 || theMuonType_ == 4 || theMuonType_ == 5 || theMuonType_ >= 10 || theMuonType_ == -1 ||
525  theMuonType_ == -2 || theMuonType_ == -3 || theMuonType_ == -4) {
526  MuScleFitUtils::MuonTypeForCheckMassWindow = 2;
527  MuScleFitUtils::MuonType = 2;
528  } else {
529  std::cout << "Wrong muon type " << theMuonType_ << std::endl;
530  exit(1);
531  }
532 
533  // When using standalone muons switch to the single Z pdf
534  if (theMuonType_ == 2) {
535  MuScleFitUtils::rapidityBinsForZ_ = false;
536  }
537 
538  // Initialize ResMaxSigma And ResHalfWidth - 0 = global, 1 = SM, 2 = tracker
539  // -------------------------------------------------------------------------
540  MuScleFitUtils::massWindowHalfWidth[0][0] = 20.;
541  MuScleFitUtils::massWindowHalfWidth[0][1] = 0.35;
542  MuScleFitUtils::massWindowHalfWidth[0][2] = 0.35;
543  MuScleFitUtils::massWindowHalfWidth[0][3] = 0.35;
544  MuScleFitUtils::massWindowHalfWidth[0][4] = 0.2;
545  MuScleFitUtils::massWindowHalfWidth[0][5] = 0.2;
546  MuScleFitUtils::massWindowHalfWidth[1][0] = 20.;
547  MuScleFitUtils::massWindowHalfWidth[1][1] = 0.35;
548  MuScleFitUtils::massWindowHalfWidth[1][2] = 0.35;
549  MuScleFitUtils::massWindowHalfWidth[1][3] = 0.35;
550  MuScleFitUtils::massWindowHalfWidth[1][4] = 0.2;
551  MuScleFitUtils::massWindowHalfWidth[1][5] = 0.2;
552  MuScleFitUtils::massWindowHalfWidth[2][0] = 20.;
553  MuScleFitUtils::massWindowHalfWidth[2][1] = 0.35;
554  MuScleFitUtils::massWindowHalfWidth[2][2] = 0.35;
555  MuScleFitUtils::massWindowHalfWidth[2][3] = 0.35;
556  MuScleFitUtils::massWindowHalfWidth[2][4] = 0.2;
557  MuScleFitUtils::massWindowHalfWidth[2][5] = 0.2;
558 
559  muonSelector_.reset(new MuScleFitMuonSelector(theMuonLabel_,
560  theMuonType_,
561  PATmuons_,
562  MuScleFitUtils::resfind,
563  MuScleFitUtils::speedup,
564  genParticlesName_,
565  compareToSimTracks_,
566  simTracksCollection_,
567  MuScleFitUtils::sherpa_,
568  debug_));
569 
570  MuScleFitUtils::backgroundHandler =
571  new BackgroundHandler(pset.getParameter<std::vector<int> >("BgrFitType"),
572  pset.getParameter<std::vector<double> >("LeftWindowBorder"),
573  pset.getParameter<std::vector<double> >("RightWindowBorder"),
574  MuScleFitUtils::ResMass,
575  MuScleFitUtils::massWindowHalfWidth[MuScleFitUtils::MuonTypeForCheckMassWindow]);
576 
577  MuScleFitUtils::crossSectionHandler =
578  new CrossSectionHandler(MuScleFitUtils::parCrossSection, MuScleFitUtils::resfind);
579 
580  // Build cross section scale factors
581  // MuScleFitUtils::resfind
582 
583  MuScleFitUtils::normalizeLikelihoodByEventNumber_ =
584  pset.getUntrackedParameter<bool>("NormalizeLikelihoodByEventNumber", true);
585  if (debug_ > 0)
586  std::cout << "End of MuScleFit constructor" << std::endl;
587 
588  inputRootTreeFileName_ = pset.getParameter<std::string>("InputRootTreeFileName");
589  outputRootTreeFileName_ = pset.getParameter<std::string>("OutputRootTreeFileName");
590  maxEventsFromRootTree_ = pset.getParameter<int>("MaxEventsFromRootTree");
591 
592  MuScleFitUtils::startWithSimplex_ = pset.getParameter<bool>("StartWithSimplex");
593  MuScleFitUtils::computeMinosErrors_ = pset.getParameter<bool>("ComputeMinosErrors");
594  MuScleFitUtils::minimumShapePlots_ = pset.getParameter<bool>("MinimumShapePlots");
595 
596  beginOfJobInConstructor();
597 }

References MuScleFitUtils::backgroundHandler, beginOfJobInConstructor(), MuScleFitUtils::biasFunction, MuScleFitUtils::BiasType, checkParameters(), compareToSimTracks_, MuScleFitUtils::computeMinosErrors_, gather_cfg::cout, MuScleFitUtils::crossSectionHandler, MuScleFitUtils::debug, MuScleFitBase::debug_, MuScleFitUtils::debugMassResol_, MuScleFitUtils::deltaPhiMaxCut_, MuScleFitUtils::deltaPhiMinCut_, MuScleFitUtils::doBackgroundFit, MuScleFitUtils::doCrossSectionFit, MuScleFitUtils::doResolFit, MuScleFitUtils::doScaleFit, beamvalidation::exit(), fastLoop, MuScleFitUtils::FitStrategy, callgraph::G, genParticlesName_, MuScleFitUtils::goodmuon, mps_fire::i, inputRootTreeFileName_, HLT_2018_cff::InputTag, dqmiolumiharvest::j, loopCounter, MuScleFitUtils::massWindowHalfWidth, maxEventsFromRootTree_, maxLoopNumber, MuScleFitUtils::maxMuonEtaFirstRange_, MuScleFitUtils::maxMuonEtaSecondRange_, MuScleFitUtils::maxMuonPt_, maxResMass_hwindow, MuScleFitUtils::minimumShapePlots_, MuScleFitUtils::minMuonEtaFirstRange_, MuScleFitUtils::minMuonEtaSecondRange_, MuScleFitUtils::minMuonPt_, minResMass_hwindow, muonSelector_, MuScleFitUtils::MuonType, MuScleFitUtils::MuonTypeForCheckMassWindow, negateTrigger_, MuScleFitUtils::normalizeLikelihoodByEventNumber_, outputRootTreeFileName_, MuScleFitUtils::parBgr, MuScleFitUtils::parBgrFix, MuScleFitUtils::parBgrOrder, MuScleFitUtils::parBias, MuScleFitUtils::parCrossSection, MuScleFitUtils::parCrossSectionFix, MuScleFitUtils::parCrossSectionOrder, MuScleFitUtils::parResol, MuScleFitUtils::parResolFix, MuScleFitUtils::parResolMax, MuScleFitUtils::parResolMin, MuScleFitUtils::parResolOrder, MuScleFitUtils::parResolStep, MuScleFitUtils::parScale, MuScleFitUtils::parScaleFix, MuScleFitUtils::parScaleMax, MuScleFitUtils::parScaleMin, MuScleFitUtils::parScaleOrder, MuScleFitUtils::parScaleStep, MuScleFitUtils::parSmear, PATmuons_, Pi, muonDTDigis_cfi::pset, puInfoSrc_, MuScleFitUtils::rapidityBinsForZ_, MuScleFitUtils::resfind, MuScleFitUtils::ResMass, MuScleFitUtils::ResolFitType, MuScleFitUtils::resolutionFunction, MuScleFitUtils::resolutionFunctionForVec, resolutionFunctionService(), resolutionFunctionVecService(), saveAllToTree_, MuScleFitUtils::ScaleFitType, MuScleFitUtils::scaleFunction, MuScleFitUtils::scaleFunctionForVec, scaleFunctionService(), scaleFunctionVecService(), MuScleFitUtils::separateRanges_, MuScleFitUtils::sherpa_, simTracksCollection_, MuScleFitUtils::smearFunction, smearFunctionService(), MuScleFitUtils::SmearType, MuScleFitUtils::speedup, mathSSE::sqrt(), MuScleFitUtils::startWithSimplex_, AlCaHLTBitMon_QueryRunRegistry::string, tools::TF1, MuScleFitBase::theMuonLabel_, MuScleFitBase::theMuonType_, triggerPath_, triggerResultsLabel_, triggerResultsProcess_, MuScleFitUtils::useProbsFile_, vertexSrc_, and MuScleFitUtils::x.

◆ ~MuScleFit()

MuScleFit::~MuScleFit ( )
override

Definition at line 601 of file MuScleFit.cc.

601  {
602  if (debug_ > 0)
603  std::cout << "[MuScleFit]: Destructor" << std::endl;
604  std::cout << "Total number of analyzed events = " << totalEvents_ << std::endl;
605 
606  if (!(outputRootTreeFileName_.empty())) {
607  // Save the events to a root tree unless we are reading from the edm root file and the SavedPair size is different from the totalEvents_
608  if (!(inputRootTreeFileName_.empty() && (int(MuScleFitUtils::SavedPair.size()) != totalEvents_))) {
609  std::cout << "Saving muon pairs to root tree" << std::endl;
610  RootTreeHandler rootTreeHandler;
611  if (MuScleFitUtils::speedup) {
612  // rootTreeHandler.writeTree(outputRootTreeFileName_, &(MuScleFitUtils::SavedPair), theMuonType_, 0, saveAllToTree_);
613  if (debug_ > 0) {
614  std::vector<MuonPair>::const_iterator it = muonPairs_.begin();
615  std::cout << "[MuScleFit::~MuScleFit] (Destructor)" << std::endl;
616  for (; it < muonPairs_.end(); ++it) {
617  std::cout << " Debugging pairs that are going to be written to file" << std::endl;
618  std::cout << " muon1 = " << it->mu1 << std::endl;
619  std::cout << " muon2 = " << it->mu2 << std::endl;
620  }
621  }
622  rootTreeHandler.writeTree(outputRootTreeFileName_, &(muonPairs_), theMuonType_, nullptr, saveAllToTree_);
623  } else {
624  // rootTreeHandler.writeTree(outputRootTreeFileName_, &(MuScleFitUtils::SavedPair), theMuonType_, &(MuScleFitUtils::genPair), saveAllToTree_ );
625  rootTreeHandler.writeTree(
626  outputRootTreeFileName_, &(muonPairs_), theMuonType_, &(genMuonPairs_), saveAllToTree_);
627  }
628  } else {
629  std::cout << "ERROR: events in the vector = " << MuScleFitUtils::SavedPair.size()
630  << " != totalEvents = " << totalEvents_ << std::endl;
631  }
632  }
633 }

References gather_cfg::cout, MuScleFitBase::debug_, MuScleFitBase::genMuonPairs_, inputRootTreeFileName_, createfilelist::int, MuScleFitBase::muonPairs_, outputRootTreeFileName_, saveAllToTree_, MuScleFitUtils::SavedPair, findQualityFiles::size, MuScleFitUtils::speedup, MuScleFitBase::theMuonType_, totalEvents_, and RootTreeHandler::writeTree().

Member Function Documentation

◆ applyBias()

void MuScleFit::applyBias ( reco::Particle::LorentzVector &  mu,
const int  charge 
)
protected

Apply the bias if needed using the function in MuScleFitUtils.

Definition at line 1396 of file MuScleFit.cc.

1396  {
1397  if (MuScleFitUtils::BiasType > 0) {
1398  mu = MuScleFitUtils::applyBias(mu, charge);
1399  if (debug_ > 0)
1400  std::cout << "Muon #" << MuScleFitUtils::goodmuon << ": after bias Pt = " << mu.Pt() << std::endl;
1401  }
1402 }

References MuScleFitUtils::applyBias(), MuScleFitUtils::BiasType, ALCARECOTkAlJpsiMuMu_cff::charge, gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::goodmuon, and amptDefaultParameters_cff::mu.

Referenced by fillMuonCollection(), and selectMuons().

◆ applySmearing()

void MuScleFit::applySmearing ( reco::Particle::LorentzVector &  mu)
protected

Apply the smearing if needed using the function in MuScleFitUtils.

Definition at line 1388 of file MuScleFit.cc.

1388  {
1389  if (MuScleFitUtils::SmearType > 0) {
1390  mu = MuScleFitUtils::applySmearing(mu);
1391  if (debug_ > 0)
1392  std::cout << "Muon #" << MuScleFitUtils::goodmuon << ": after smearing Pt = " << mu.Pt() << std::endl;
1393  }
1394 }

References MuScleFitUtils::applySmearing(), gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::goodmuon, amptDefaultParameters_cff::mu, and MuScleFitUtils::SmearType.

Referenced by fillMuonCollection(), and selectMuons().

◆ beginOfJobInConstructor()

void MuScleFit::beginOfJobInConstructor ( )

Definition at line 637 of file MuScleFit.cc.

640 {
641  if (debug_ > 0)
642  std::cout << "[MuScleFit]: beginOfJob" << std::endl;
643  //if(maxLoopNumber>1)
644  if (MuScleFitUtils::useProbsFile_) {
645  readProbabilityDistributionsFromFile();
646  }
647 
648  if (debug_ > 0)
649  std::cout << "[MuScleFit]: beginOfJob" << std::endl;
650 
651  // Create the root file
652  // --------------------
653  for (unsigned int i = 0; i < (maxLoopNumber); i++) {
654  std::stringstream ss;
655  ss << i;
656  std::string rootFileName = ss.str() + "_" + theRootFileName_;
657  theFiles_.push_back(new TFile(rootFileName.c_str(), "RECREATE"));
658  }
659  if (debug_ > 0)
660  std::cout << "[MuScleFit]: Root file created" << std::endl;
661 
662  std::cout << "creating plotter" << std::endl;
663  plotter = new MuScleFitPlotter(theGenInfoRootFileName_);
664  plotter->debug = debug_;
665 }

References gather_cfg::cout, MuScleFitPlotter::debug, MuScleFitBase::debug_, mps_fire::i, maxLoopNumber, plotter, MuScleFitBase::readProbabilityDistributionsFromFile(), CSCSkim_cfi::rootFileName, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, MuScleFitBase::theFiles_, MuScleFitBase::theGenInfoRootFileName_, MuScleFitBase::theRootFileName_, and MuScleFitUtils::useProbsFile_.

Referenced by MuScleFit().

◆ checkDeltaR()

bool MuScleFit::checkDeltaR ( reco::Particle::LorentzVector &  genMu,
reco::Particle::LorentzVector &  recMu 
)
protected

Check if two lorentzVector are near in deltaR.

Definition at line 1355 of file MuScleFit.cc.

1355  {
1356  //first is always mu-, second is always mu+
1357  double deltaR =
1358  sqrt(MuScleFitUtils::deltaPhi(recMu.Phi(), genMu.Phi()) * MuScleFitUtils::deltaPhi(recMu.Phi(), genMu.Phi()) +
1359  ((recMu.Eta() - genMu.Eta()) * (recMu.Eta() - genMu.Eta())));
1360  if (deltaR < 0.01)
1361  return true;
1362  else if (debug_ > 0) {
1363  std::cout << "Reco muon " << recMu << " with eta " << recMu.Eta() << " and phi " << recMu.Phi() << std::endl
1364  << " DOES NOT MATCH with generated muon from resonance: " << std::endl
1365  << genMu << " with eta " << genMu.Eta() << " and phi " << genMu.Phi() << std::endl;
1366  }
1367  return false;
1368 }

References gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::deltaPhi(), PbPb_ZMuSkimMuonDPG_cff::deltaR, and mathSSE::sqrt().

Referenced by duringFastLoop().

◆ checkParameters()

void MuScleFit::checkParameters ( )
protected

Simple method to check parameters consistency. It aborts the job if the parameters are not consistent.

Definition at line 1406 of file MuScleFit.cc.

1406  {
1407  // Fits selection dimension check
1408  if (MuScleFitUtils::doResolFit.size() != maxLoopNumber) {
1409  std::cout << "[MuScleFit-Constructor]: wrong size of resolution fits selector = "
1410  << MuScleFitUtils::doResolFit.size() << std::endl;
1411  std::cout << "it must have as many values as the number of loops, which is = " << maxLoopNumber << std::endl;
1412  abort();
1413  }
1414  if (MuScleFitUtils::doScaleFit.size() != maxLoopNumber) {
1415  std::cout << "[MuScleFit-Constructor]: wrong size of scale fits selector = " << MuScleFitUtils::doScaleFit.size()
1416  << std::endl;
1417  std::cout << "it must have as many values as the number of loops, which is = " << maxLoopNumber << std::endl;
1418  abort();
1419  }
1420  if (MuScleFitUtils::doCrossSectionFit.size() != maxLoopNumber) {
1421  std::cout << "[MuScleFit-Constructor]: wrong size of cross section fits selector = "
1422  << MuScleFitUtils::doCrossSectionFit.size() << std::endl;
1423  std::cout << "it must have as many values as the number of loops, which is = " << maxLoopNumber << std::endl;
1424  abort();
1425  }
1426  if (MuScleFitUtils::doBackgroundFit.size() != maxLoopNumber) {
1427  std::cout << "[MuScleFit-Constructor]: wrong size of background fits selector = "
1428  << MuScleFitUtils::doBackgroundFit.size() << std::endl;
1429  std::cout << "it must have as many values as the number of loops, which is = " << maxLoopNumber << std::endl;
1430  abort();
1431  }
1432 
1433  // Bias parameters: dimension check
1434  // --------------------------------
1435  if ((MuScleFitUtils::BiasType == 1 && MuScleFitUtils::parBias.size() != 2) || // linear in pt
1436  (MuScleFitUtils::BiasType == 2 && MuScleFitUtils::parBias.size() != 2) || // linear in |eta|
1437  (MuScleFitUtils::BiasType == 3 && MuScleFitUtils::parBias.size() != 4) || // sinusoidal in phi
1438  (MuScleFitUtils::BiasType == 4 && MuScleFitUtils::parBias.size() != 3) || // linear in pt and |eta|
1439  (MuScleFitUtils::BiasType == 5 && MuScleFitUtils::parBias.size() != 3) || // linear in pt and sinusoidal in phi
1440  (MuScleFitUtils::BiasType == 6 &&
1441  MuScleFitUtils::parBias.size() != 3) || // linear in |eta| and sinusoidal in phi
1442  (MuScleFitUtils::BiasType == 7 &&
1443  MuScleFitUtils::parBias.size() != 4) || // linear in pt and |eta| and sinusoidal in phi
1444  (MuScleFitUtils::BiasType == 8 && MuScleFitUtils::parBias.size() != 4) || // linear in pt and parabolic in |eta|
1445  (MuScleFitUtils::BiasType == 9 && MuScleFitUtils::parBias.size() != 2) || // exponential in pt
1446  (MuScleFitUtils::BiasType == 10 && MuScleFitUtils::parBias.size() != 3) || // parabolic in pt
1447  (MuScleFitUtils::BiasType == 11 &&
1448  MuScleFitUtils::parBias.size() != 4) || // linear in pt and sin in phi with chg
1449  (MuScleFitUtils::BiasType == 12 &&
1450  MuScleFitUtils::parBias.size() != 6) || // linear in pt and para in plus sin in phi with chg
1451  (MuScleFitUtils::BiasType == 13 &&
1452  MuScleFitUtils::parBias.size() != 8) || // linear in pt and para in plus sin in phi with chg
1453  MuScleFitUtils::BiasType < 0 ||
1454  MuScleFitUtils::BiasType > 13) {
1455  std::cout << "[MuScleFit-Constructor]: Wrong bias type or number of parameters: aborting!" << std::endl;
1456  abort();
1457  }
1458  // Smear parameters: dimension check
1459  // ---------------------------------
1460  if ((MuScleFitUtils::SmearType == 1 && MuScleFitUtils::parSmear.size() != 3) ||
1461  (MuScleFitUtils::SmearType == 2 && MuScleFitUtils::parSmear.size() != 4) ||
1462  (MuScleFitUtils::SmearType == 3 && MuScleFitUtils::parSmear.size() != 5) ||
1463  (MuScleFitUtils::SmearType == 4 && MuScleFitUtils::parSmear.size() != 6) ||
1464  (MuScleFitUtils::SmearType == 5 && MuScleFitUtils::parSmear.size() != 7) ||
1465  (MuScleFitUtils::SmearType == 6 && MuScleFitUtils::parSmear.size() != 16) ||
1466  (MuScleFitUtils::SmearType == 7 && !MuScleFitUtils::parSmear.empty()) || MuScleFitUtils::SmearType < 0 ||
1467  MuScleFitUtils::SmearType > 7) {
1468  std::cout << "[MuScleFit-Constructor]: Wrong smear type or number of parameters: aborting!" << std::endl;
1469  abort();
1470  }
1471  // Protect against bad size of parameters
1472  // --------------------------------------
1473  if (MuScleFitUtils::parResol.size() != MuScleFitUtils::parResolFix.size() ||
1474  MuScleFitUtils::parResol.size() != MuScleFitUtils::parResolOrder.size()) {
1475  std::cout << "[MuScleFit-Constructor]: Mismatch in number of parameters for Resol: aborting!" << std::endl;
1476  abort();
1477  }
1478  if (MuScleFitUtils::parScale.size() != MuScleFitUtils::parScaleFix.size() ||
1479  MuScleFitUtils::parScale.size() != MuScleFitUtils::parScaleOrder.size()) {
1480  std::cout << "[MuScleFit-Constructor]: Mismatch in number of parameters for Scale: aborting!" << std::endl;
1481  abort();
1482  }
1483  if (MuScleFitUtils::parCrossSection.size() != MuScleFitUtils::parCrossSectionFix.size() ||
1484  MuScleFitUtils::parCrossSection.size() != MuScleFitUtils::parCrossSectionOrder.size()) {
1485  std::cout << "[MuScleFit-Constructor]: Mismatch in number of parameters for Bgr: aborting!" << std::endl;
1486  abort();
1487  }
1488  if (MuScleFitUtils::parBgr.size() != MuScleFitUtils::parBgrFix.size() ||
1489  MuScleFitUtils::parBgr.size() != MuScleFitUtils::parBgrOrder.size()) {
1490  std::cout << "[MuScleFit-Constructor]: Mismatch in number of parameters for Bgr: aborting!" << std::endl;
1491  abort();
1492  }
1493 
1494  // Protect against an incorrect number of resonances
1495  // -------------------------------------------------
1496  if (MuScleFitUtils::resfind.size() != 6) {
1497  std::cout << "[MuScleFit-Constructor]: resfind must have 6 elements (1 Z, 3 Y, 2 Psi): aborting!" << std::endl;
1498  abort();
1499  }
1500 }

References MuScleFitUtils::BiasType, gather_cfg::cout, MuScleFitUtils::doBackgroundFit, MuScleFitUtils::doCrossSectionFit, MuScleFitUtils::doResolFit, MuScleFitUtils::doScaleFit, relativeConstraints::empty, maxLoopNumber, MuScleFitUtils::parBgr, MuScleFitUtils::parBgrFix, MuScleFitUtils::parBgrOrder, MuScleFitUtils::parBias, MuScleFitUtils::parCrossSection, MuScleFitUtils::parCrossSectionFix, MuScleFitUtils::parCrossSectionOrder, MuScleFitUtils::parResol, MuScleFitUtils::parResolFix, MuScleFitUtils::parResolOrder, MuScleFitUtils::parScale, MuScleFitUtils::parScaleFix, MuScleFitUtils::parScaleOrder, MuScleFitUtils::parSmear, MuScleFitUtils::resfind, findQualityFiles::size, and MuScleFitUtils::SmearType.

Referenced by MuScleFit().

◆ duringFastLoop()

void MuScleFit::duringFastLoop ( )
virtual

This method performs all needed operations on the muon pair. It reads the muons from SavedPair and uses the iev counter to keep track of the event number. The iev is incremented internally and reset to 0 in startingNewLoop.

Definition at line 1080 of file MuScleFit.cc.

1080  {
1081  // On loops>0 the two muons are directly obtained from the SavedMuon array
1082  // -----------------------------------------------------------------------
1083  MuScleFitUtils::ResFound = false;
1084  recMu1 = (MuScleFitUtils::SavedPair[iev].first);
1085  recMu2 = (MuScleFitUtils::SavedPair[iev].second);
1086 
1087  //std::cout << "iev = " << iev << ", recMu1 pt = " << recMu1.Pt() << ", recMu2 pt = " << recMu2.Pt() << std::endl;
1088 
1089  if (recMu1.Pt() > 0 && recMu2.Pt() > 0) {
1090  MuScleFitUtils::ResFound = true;
1091  if (debug_ > 0)
1092  std::cout << "Ev = " << iev << ": found muons in tree with Pt = " << recMu1.Pt() << " " << recMu2.Pt()
1093  << std::endl;
1094  }
1095 
1096  if (debug_ > 0)
1097  std::cout << "About to start lik par correction and histo filling; ResFound is " << MuScleFitUtils::ResFound
1098  << std::endl;
1099  // If resonance found, do the hard work
1100  // ------------------------------------
1101  if (MuScleFitUtils::ResFound) {
1102  // Find weight and reference mass for this muon pair
1103  // -------------------------------------------------
1104  // The last parameter = true means that we want to use always the background window to compute the weight,
1105  // otherwise the probability will be filled only for the resonance region.
1106  double weight = MuScleFitUtils::computeWeight((recMu1 + recMu2).mass(), iev, true);
1107  if (debug_ > 0) {
1108  std::cout << "Loop #" << loopCounter << "Event #" << iev << ": before correction Pt1 = " << recMu1.Pt()
1109  << " Pt2 = " << recMu2.Pt() << std::endl;
1110  }
1111  // For successive iterations, correct the muons only if the previous iteration was a scale fit.
1112  // --------------------------------------------------------------------------------------------
1113  if (loopCounter > 0) {
1114  if (MuScleFitUtils::doScaleFit[loopCounter - 1]) {
1115  recMu1 = (MuScleFitUtils::applyScale(recMu1, MuScleFitUtils::parvalue[loopCounter - 1], -1));
1116  recMu2 = (MuScleFitUtils::applyScale(recMu2, MuScleFitUtils::parvalue[loopCounter - 1], 1));
1117  }
1118  }
1119  if (debug_ > 0) {
1120  std::cout << "Loop #" << loopCounter << "Event #" << iev << ": after correction Pt1 = " << recMu1.Pt()
1121  << " Pt2 = " << recMu2.Pt() << std::endl;
1122  }
1123 
1124  reco::Particle::LorentzVector bestRecRes(recMu1 + recMu2);
1125 
1126  //Fill histograms
1127  //------------------
1128 
1129  mapHisto_["hRecBestMu"]->Fill(recMu1, -1, weight);
1130  mapHisto_["hRecBestMuVSEta"]->Fill(recMu1);
1131  mapHisto_["hRecBestMu"]->Fill(recMu2, +1, weight);
1132  mapHisto_["hRecBestMuVSEta"]->Fill(recMu2);
1133  mapHisto_["hDeltaRecBestMu"]->Fill(recMu1, recMu2);
1134  // Reconstructed resonance
1135  mapHisto_["hRecBestRes"]->Fill(bestRecRes, +1, weight);
1136  mapHisto_["hRecBestResAllEvents"]->Fill(bestRecRes, +1, 1.);
1137  // // Fill histogram of Res mass vs muon variables
1138  // mapHisto_["hRecBestResVSMu"]->Fill (recMu1, bestRecRes, -1);
1139  // mapHisto_["hRecBestResVSMu"]->Fill (recMu2, bestRecRes, +1);
1140  // // Fill also the mass mu+/mu- comparisons
1141  // mapHisto_["hRecBestResVSMu"]->Fill(recMu1, recMu2, bestRecRes);
1142 
1143  mapHisto_["hRecBestResVSMu"]->Fill(recMu1, bestRecRes, -1, weight);
1144  mapHisto_["hRecBestResVSMu"]->Fill(recMu2, bestRecRes, +1, weight);
1145  // Fill also the mass mu+/mu- comparisons
1146  mapHisto_["hRecBestResVSMu"]->Fill(recMu1, recMu2, bestRecRes, weight);
1147 
1148  //-- rc 2010 filling histograms for mu+ /mu- ------
1149  // mapHisto_["hRecBestResVSMuMinus"]->Fill (recMu1, bestRecRes, -1);
1150  // mapHisto_["hRecBestResVSMuPlus"]->Fill (recMu2, bestRecRes, +1);
1151 
1152  //-- rc 2010 filling histograms MassVsMuEtaPhi------
1153  // mapHisto_["hRecBestResVSMuEtaPhi"]->Fill (recMu1, bestRecRes,-1);
1154  // mapHisto_["hRecBestResVSMuEtaPhi"]->Fill (recMu2, bestRecRes,+1);
1155 
1156  // Fill histogram of Res mass vs Res variables
1157  // mapHisto_["hRecBestResVSRes"]->Fill (bestRecRes, bestRecRes, +1);
1158  mapHisto_["hRecBestResVSRes"]->Fill(bestRecRes, bestRecRes, +1, weight);
1159 
1160  std::vector<double>* parval;
1161  std::vector<double> initpar;
1162  // Store a pointer to the vector of parameters of the last iteration, or the initial
1163  // parameters if this is the first iteration
1164  if (loopCounter == 0) {
1165  initpar = MuScleFitUtils::parResol;
1166  initpar.insert(initpar.end(), MuScleFitUtils::parScale.begin(), MuScleFitUtils::parScale.end());
1167  initpar.insert(initpar.end(), MuScleFitUtils::parCrossSection.begin(), MuScleFitUtils::parCrossSection.end());
1168  initpar.insert(initpar.end(), MuScleFitUtils::parBgr.begin(), MuScleFitUtils::parBgr.end());
1169  parval = &initpar;
1170  } else {
1171  parval = &(MuScleFitUtils::parvalue[loopCounter - 1]);
1172  }
1173 
1174  //Compute pt resolution w.r.t generated and simulated muons
1175  //--------------------------------------------------------
1176  if (!MuScleFitUtils::speedup) {
1177  //first is always mu-, second is always mu+
1178  if (checkDeltaR(MuScleFitUtils::genPair[iev].first, recMu1)) {
1179  fillComparisonHistograms(MuScleFitUtils::genPair[iev].first, recMu1, "Gen", -1);
1180  }
1181  if (checkDeltaR(MuScleFitUtils::genPair[iev].second, recMu2)) {
1182  fillComparisonHistograms(MuScleFitUtils::genPair[iev].second, recMu2, "Gen", +1);
1183  }
1184  if (compareToSimTracks_) {
1185  //first is always mu-, second is always mu+
1186  if (checkDeltaR(MuScleFitUtils::simPair[iev].first, recMu1)) {
1187  fillComparisonHistograms(MuScleFitUtils::simPair[iev].first, recMu1, "Sim", -1);
1188  }
1189  if (checkDeltaR(MuScleFitUtils::simPair[iev].second, recMu2)) {
1190  fillComparisonHistograms(MuScleFitUtils::simPair[iev].second, recMu2, "Sim", +1);
1191  }
1192  }
1193  }
1194 
1195  // ATTENTION: this was done only when a matching was found. Moved it outside because, genInfo or not, we still want to see the resolution function
1196  // Fill also the resolution histogramsm using the resolution functions:
1197  // the parameters are those from the last iteration, as the muons up to this point have also the corrections from the same iteration.
1198  // Need to use a different array (ForVec), containing functors able to operate on std::vector<double>
1199  mapHisto_["hFunctionResolPt"]->Fill(
1200  recMu1, MuScleFitUtils::resolutionFunctionForVec->sigmaPt(recMu1.Pt(), recMu1.Eta(), *parval), -1);
1201  mapHisto_["hFunctionResolCotgTheta"]->Fill(
1202  recMu1, MuScleFitUtils::resolutionFunctionForVec->sigmaCotgTh(recMu1.Pt(), recMu1.Eta(), *parval), -1);
1203  mapHisto_["hFunctionResolPhi"]->Fill(
1204  recMu1, MuScleFitUtils::resolutionFunctionForVec->sigmaPhi(recMu1.Pt(), recMu1.Eta(), *parval), -1);
1205  mapHisto_["hFunctionResolPt"]->Fill(
1206  recMu2, MuScleFitUtils::resolutionFunctionForVec->sigmaPt(recMu2.Pt(), recMu2.Eta(), *parval), +1);
1207  mapHisto_["hFunctionResolCotgTheta"]->Fill(
1208  recMu2, MuScleFitUtils::resolutionFunctionForVec->sigmaCotgTh(recMu2.Pt(), recMu2.Eta(), *parval), +1);
1209  mapHisto_["hFunctionResolPhi"]->Fill(
1210  recMu2, MuScleFitUtils::resolutionFunctionForVec->sigmaPhi(recMu2.Pt(), recMu2.Eta(), *parval), +1);
1211 
1212  // Compute likelihood histograms
1213  // -----------------------------
1214  if (debug_ > 0)
1215  std::cout << "mass = " << bestRecRes.mass() << std::endl;
1216  if (weight != 0.) {
1217  double massResol;
1218  double prob;
1219  double deltalike;
1220  if (loopCounter == 0) {
1221  std::vector<double> initpar;
1222  for (int i = 0; i < (int)(MuScleFitUtils::parResol.size()); i++) {
1223  initpar.push_back(MuScleFitUtils::parResol[i]);
1224  }
1225  for (int i = 0; i < (int)(MuScleFitUtils::parScale.size()); i++) {
1226  initpar.push_back(MuScleFitUtils::parScale[i]);
1227  }
1228  // for (int i=0; i<(int)(MuScleFitUtils::parCrossSection.size()); i++) {
1229  // initpar.push_back(MuScleFitUtils::parCrossSection[i]);
1230  // }
1231  MuScleFitUtils::crossSectionHandler->addParameters(initpar);
1232 
1233  for (int i = 0; i < (int)(MuScleFitUtils::parBgr.size()); i++) {
1234  initpar.push_back(MuScleFitUtils::parBgr[i]);
1235  }
1236  massResol = MuScleFitUtils::massResolution(recMu1, recMu2, initpar);
1237  // prob = MuScleFitUtils::massProb( bestRecRes.mass(), bestRecRes.Eta(), bestRecRes.Rapidity(), massResol, initpar, true );
1238  prob = MuScleFitUtils::massProb(bestRecRes.mass(),
1239  bestRecRes.Eta(),
1240  bestRecRes.Rapidity(),
1241  massResol,
1242  initpar,
1243  true,
1244  recMu1.eta(),
1245  recMu2.eta());
1246  } else {
1247  massResol = MuScleFitUtils::massResolution(recMu1, recMu2, MuScleFitUtils::parvalue[loopCounter - 1]);
1248  // prob = MuScleFitUtils::massProb( bestRecRes.mass(), bestRecRes.Eta(), bestRecRes.Rapidity(),
1249  // massResol, MuScleFitUtils::parvalue[loopCounter-1], true );
1250  prob = MuScleFitUtils::massProb(bestRecRes.mass(),
1251  bestRecRes.Eta(),
1252  bestRecRes.Rapidity(),
1253  massResol,
1254  MuScleFitUtils::parvalue[loopCounter - 1],
1255  true,
1256  recMu1.eta(),
1257  recMu2.eta());
1258  }
1259  if (debug_ > 0)
1260  std::cout << "inside weight: mass = " << bestRecRes.mass() << ", prob = " << prob << std::endl;
1261  if (prob > 0) {
1262  if (debug_ > 0)
1263  std::cout << "inside prob: mass = " << bestRecRes.mass() << ", prob = " << prob << std::endl;
1264 
1265  deltalike = log(prob) * weight; // NB maximum likelihood --> deltalike is maximized
1266  mapHisto_["hLikeVSMu"]->Fill(recMu1, deltalike);
1267  mapHisto_["hLikeVSMu"]->Fill(recMu2, deltalike);
1268  mapHisto_["hLikeVSMuMinus"]->Fill(recMu1, deltalike);
1269  mapHisto_["hLikeVSMuPlus"]->Fill(recMu2, deltalike);
1270 
1271  double recoMass = (recMu1 + recMu2).mass();
1272  if (recoMass != 0) {
1273  // IMPORTANT: massResol is not a relative resolution
1274  mapHisto_["hResolMassVSMu"]->Fill(recMu1, massResol, -1);
1275  mapHisto_["hResolMassVSMu"]->Fill(recMu2, massResol, +1);
1276  mapHisto_["hFunctionResolMassVSMu"]->Fill(recMu1, massResol / recoMass, -1);
1277  mapHisto_["hFunctionResolMassVSMu"]->Fill(recMu2, massResol / recoMass, +1);
1278  }
1279 
1280  if (MuScleFitUtils::debugMassResol_) {
1281  mapHisto_["hdMdPt1"]->Fill(recMu1, MuScleFitUtils::massResolComponents.dmdpt1, -1);
1282  mapHisto_["hdMdPt2"]->Fill(recMu2, MuScleFitUtils::massResolComponents.dmdpt2, +1);
1283  mapHisto_["hdMdPhi1"]->Fill(recMu1, MuScleFitUtils::massResolComponents.dmdphi1, -1);
1284  mapHisto_["hdMdPhi2"]->Fill(recMu2, MuScleFitUtils::massResolComponents.dmdphi2, +1);
1285  mapHisto_["hdMdCotgTh1"]->Fill(recMu1, MuScleFitUtils::massResolComponents.dmdcotgth1, -1);
1286  mapHisto_["hdMdCotgTh2"]->Fill(recMu2, MuScleFitUtils::massResolComponents.dmdcotgth2, +1);
1287  }
1288 
1289  if (!MuScleFitUtils::speedup) {
1290  double genMass = (MuScleFitUtils::genPair[iev].first + MuScleFitUtils::genPair[iev].second).mass();
1291  // Fill the mass resolution (computed from MC), we use the covariance class to compute the variance
1292  if (genMass != 0) {
1293  mapHisto_["hGenResVSMu"]->Fill((MuScleFitUtils::genPair[iev].first),
1294  (MuScleFitUtils::genPair[iev].first + MuScleFitUtils::genPair[iev].second),
1295  -1);
1296  mapHisto_["hGenResVSMu"]->Fill((MuScleFitUtils::genPair[iev].second),
1297  (MuScleFitUtils::genPair[iev].first + MuScleFitUtils::genPair[iev].second),
1298  +1);
1299  double diffMass = (recoMass - genMass) / genMass;
1300  // double diffMass = recoMass - genMass;
1301  // Fill if for both muons
1302  double pt1 = recMu1.pt();
1303  double eta1 = recMu1.eta();
1304  double pt2 = recMu2.pt();
1305  double eta2 = recMu2.eta();
1306  // This is to avoid nan
1307  if (diffMass == diffMass) {
1308  // Mass relative difference vs Pt and Eta. To be used to extract the true mass resolution
1309  mapHisto_["hDeltaMassOverGenMassVsPt"]->Fill(pt1, diffMass);
1310  mapHisto_["hDeltaMassOverGenMassVsPt"]->Fill(pt2, diffMass);
1311  mapHisto_["hDeltaMassOverGenMassVsEta"]->Fill(eta1, diffMass);
1312  mapHisto_["hDeltaMassOverGenMassVsEta"]->Fill(eta2, diffMass);
1313  // This is used for the covariance comparison
1314  mapHisto_["hMassResolutionVsPtEta"]->Fill(pt1, eta1, diffMass, diffMass);
1315  mapHisto_["hMassResolutionVsPtEta"]->Fill(pt2, eta2, diffMass, diffMass);
1316  } else {
1317  std::cout << "Error, there is a nan: recoMass = " << recoMass << ", genMass = " << genMass << std::endl;
1318  }
1319  }
1320  // Fill with mass resolution from resolution function
1321  double massRes = MuScleFitUtils::massResolution(recMu1, recMu2, MuScleFitUtils::parResol);
1322  mapHisto_["hFunctionResolMass"]->Fill(recMu1, std::pow(massRes, 2), -1);
1323  mapHisto_["hFunctionResolMass"]->Fill(recMu2, std::pow(massRes, 2), +1);
1324  }
1325 
1326  mapHisto_["hMass_P"]->Fill(bestRecRes.mass(), prob);
1327  if (debug_ > 0)
1328  std::cout << "mass = " << bestRecRes.mass() << ", prob = " << prob << std::endl;
1329  mapHisto_["hMass_fine_P"]->Fill(bestRecRes.mass(), prob);
1330 
1331  mapHisto_["hMassProbVsRes"]->Fill(bestRecRes, bestRecRes, +1, prob);
1332  mapHisto_["hMassProbVsMu"]->Fill(recMu1, bestRecRes, -1, prob);
1333  mapHisto_["hMassProbVsMu"]->Fill(recMu2, bestRecRes, +1, prob);
1334  mapHisto_["hMassProbVsRes_fine"]->Fill(bestRecRes, bestRecRes, +1, prob);
1335  mapHisto_["hMassProbVsMu_fine"]->Fill(recMu1, bestRecRes, -1, prob);
1336  mapHisto_["hMassProbVsMu_fine"]->Fill(recMu2, bestRecRes, +1, prob);
1337  }
1338  }
1339  } // end if ResFound
1340 
1341  // Fill the pair
1342  // -------------
1343  if (loopCounter > 0) {
1344  if (debug_ > 0)
1345  std::cout << "[MuScleFit]: filling the pair" << std::endl;
1346  MuScleFitUtils::SavedPair[iev] = std::make_pair(recMu1, recMu2);
1347  }
1348 
1349  iev++;
1350  MuScleFitUtils::iev_++;
1351 
1352  // return kContinue;
1353 }

References CrossSectionHandler::addParameters(), MuScleFitUtils::applyScale(), checkDeltaR(), compareToSimTracks_, MuScleFitUtils::computeWeight(), gather_cfg::cout, MuScleFitUtils::crossSectionHandler, MuScleFitBase::debug_, MuScleFitUtils::debugMassResol_, MuScleFitUtils::doScaleFit, HLT_2018_cff::eta1, HLT_2018_cff::eta2, fillComparisonHistograms(), dqmdumpme::first, MuScleFitUtils::genPair, mps_fire::i, iev, MuScleFitUtils::iev_, createfilelist::int, dqm-mbProfile::log, loopCounter, MuScleFitBase::mapHisto_, EgHLTOffHistBins_cfi::mass, MuScleFitUtils::massProb(), MuScleFitUtils::massResolComponents, MuScleFitUtils::massResolution(), MuScleFitUtils::parBgr, MuScleFitUtils::parCrossSection, MuScleFitUtils::parResol, MuScleFitUtils::parScale, MuScleFitUtils::parvalue, funct::pow(), TtFullHadEvtBuilder_cfi::prob, HLT_2018_cff::pt1, HLT_2018_cff::pt2, recMu1, recMu2, MuScleFitUtils::ResFound, MuScleFitUtils::resolutionFunctionForVec, MuScleFitUtils::SavedPair, edm::second(), MuScleFitUtils::simPair, findQualityFiles::size, MuScleFitUtils::speedup, and mps_merge::weight.

Referenced by duringLoop(), and endOfLoop().

◆ duringLoop()

edm::EDLooper::Status MuScleFit::duringLoop ( const edm::Event &  ,
const edm::EventSetup &   
)
overridevirtual

Called after all event modules have had a chance to process the edm::Event.

Implements edm::EDLooper.

Definition at line 782 of file MuScleFit.cc.

782  {
783  edm::Handle<edm::TriggerResults> triggerResults;
784  event.getByLabel(edm::InputTag(triggerResultsLabel_.c_str(), "", triggerResultsProcess_.c_str()), triggerResults);
785  //event.getByLabel(InputTag(triggerResultsLabel_),triggerResults);
786  bool isFired = false;
787 
788  if (triggerPath_[0].empty())
789  isFired = true;
790  else if (triggerPath_[0] == "All") {
791  isFired = triggerResults->accept();
792  if (debug_ > 0)
793  std::cout << "Trigger " << isFired << std::endl;
794  } else {
795  bool changed;
796  HLTConfigProvider hltConfig;
797  hltConfig.init(event.getRun(), eventSetup, triggerResultsProcess_, changed);
798 
799  const edm::TriggerNames& triggerNames = event.triggerNames(*triggerResults);
800 
801  for (unsigned i = 0; i < triggerNames.size(); i++) {
802  const std::string& hltName = triggerNames.triggerName(i);
803 
804  // match the path in the pset with the true name of the trigger
805  for (unsigned int ipath = 0; ipath < triggerPath_.size(); ipath++) {
806  if (hltName.find(triggerPath_[ipath]) != std::string::npos) {
807  unsigned int triggerIndex(hltConfig.triggerIndex(hltName));
808 
809  // triggerIndex must be less than the size of HLTR or you get a CMSException: _M_range_check
810  if (triggerIndex < triggerResults->size()) {
811  isFired = triggerResults->accept(triggerIndex);
812  if (debug_ > 0)
813  std::cout << triggerPath_[ipath] << " " << hltName << " " << isFired << std::endl;
814  }
815  } // end if (matching the path in the pset with the true trigger name
816  }
817  }
818  }
819 
820  if (negateTrigger_ && isFired)
821  return kContinue;
822  else if (!(negateTrigger_) && !isFired)
823  return kContinue;
824 
825 #ifdef USE_CALLGRIND
826  CALLGRIND_START_INSTRUMENTATION;
827 #endif
828 
829  if (debug_ > 0) {
830  std::cout << "[MuScleFit-duringLoop]: loopCounter = " << loopCounter << " Run: " << event.id().run()
831  << " Event: " << event.id().event() << std::endl;
832  }
833 
834  // On the first iteration we read the bank, otherwise we fetch the information from the muon tree
835  // ------------------------------------ Important Note --------------------------------------- //
836  // The fillMuonCollection method applies any smearing or bias to the muons, so we NEVER use
837  // unbiased muons.
838  // ----------------------------------------------------------------------------------------------
839  if (loopCounter == 0) {
840  if (!fastLoop || inputRootTreeFileName_.empty()) {
841  if (debug_ > 0)
842  std::cout << "Reading from edm event" << std::endl;
843  selectMuons(event);
844  duringFastLoop();
845  ++totalEvents_;
846  }
847  }
848 
849  return kContinue;
850 
851 #ifdef USE_CALLGRIND
852  CALLGRIND_STOP_INSTRUMENTATION;
853  CALLGRIND_DUMP_STATS;
854 #endif
855 }

References gather_cfg::cout, MuScleFitBase::debug_, duringFastLoop(), relativeConstraints::empty, fastLoop, HltComparatorCreateWorkflow::hltConfig, mps_fire::i, inputRootTreeFileName_, edm::EDLooperBase::kContinue, loopCounter, negateTrigger_, selectMuons(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, totalEvents_, L1TEGammaOffline_cfi::triggerNames, triggerPath_, triggerResults, triggerResultsLabel_, and triggerResultsProcess_.

◆ endOfFastLoop()

void MuScleFit::endOfFastLoop ( const unsigned int  iLoop)
virtual

Definition at line 747 of file MuScleFit.cc.

747  {
748  // std::cout<< "Inside endOfFastLoop, iLoop = " << iLoop << " and loopCounter = " << loopCounter << std::endl;
749 
750  if (loopCounter == 0) {
751  // plotter->writeHistoMap();
752  // The destructor will call the writeHistoMap after the cd to the output file
753  delete plotter;
754  }
755 
756  std::cout << "Ending loop # " << iLoop << std::endl;
757 
758  // Write the histos to file
759  // ------------------------
760  // theFiles_[iLoop]->cd();
761  writeHistoMap(iLoop);
762 
763  // Likelihood minimization to compute corrections
764  // ----------------------------------------------
765  // theFiles_[iLoop]->cd();
766  TDirectory* likelihoodDir = theFiles_[iLoop]->mkdir("likelihood");
767  likelihoodDir->cd();
768  MuScleFitUtils::minimizeLikelihood();
769 
770  // ATTENTION, this was put BEFORE the minimizeLikelihood. Check for problems.
771  theFiles_[iLoop]->Close();
772  // ATTENTION: Check that this delete does not give any problem
773  delete theFiles_[iLoop];
774 
775  // Clear the histos
776  // ----------------
777  clearHistoMap();
778 }

References MuScleFitBase::clearHistoMap(), gather_cfg::cout, loopCounter, MuScleFitUtils::minimizeLikelihood(), plotter, MuScleFitBase::theFiles_, and MuScleFitBase::writeHistoMap().

Referenced by endOfLoop().

◆ endOfJob()

void MuScleFit::endOfJob ( )
overridevirtual

Reimplemented from edm::EDLooperBase.

Definition at line 669 of file MuScleFit.cc.

669  {
670  if (debug_ > 0)
671  std::cout << "[MuScleFit]: endOfJob" << std::endl;
672 }

References gather_cfg::cout, and MuScleFitBase::debug_.

◆ endOfLoop()

edm::EDLooper::Status MuScleFit::endOfLoop ( const edm::EventSetup &  ,
unsigned int  iCounter 
)
overridevirtual

Called after the system has finished one loop over the events. Thar argument is a count of how many loops have been processed before this loo. For the first time through the events the argument will be 0.

Implements edm::EDLooperBase.

Definition at line 703 of file MuScleFit.cc.

703  {
704  unsigned int iFastLoop = 1;
705 
706  // Read the events from the root tree if requested
707  if (!(inputRootTreeFileName_.empty())) {
708  selectMuons(maxEventsFromRootTree_, inputRootTreeFileName_);
709  // When reading from local file all the loops are done here
710  totalEvents_ = MuScleFitUtils::SavedPair.size();
711  iFastLoop = 0;
712  } else {
713  endOfFastLoop(iLoop);
714  }
715 
716  // If a fastLoop is required we do all the remaining iterations here
717  if (fastLoop == true) {
718  for (; iFastLoop < maxLoopNumber; ++iFastLoop) {
719  std::cout << "Starting fast loop number " << iFastLoop << std::endl;
720 
721  // In the first loop is called by the framework
722  // if( iFastLoop > 0 ) {
723  startingNewLoop(iFastLoop);
724  // }
725 
726  // std::vector<std::pair<lorentzVector,lorentzVector> >::const_iterator it = MuScleFitUtils::SavedPair.begin();
727  // for( ; it != SavedPair.end(); ++it ) {
728  while (iev < totalEvents_) {
729  if (iev % 50000 == 0) {
730  std::cout << "Fast looping on event number " << iev << std::endl;
731  }
732  // This reads muons from SavedPair using iev to keep track of the event
733  duringFastLoop();
734  }
735  std::cout << "End of fast loop number " << iFastLoop << ". Ran on " << iev << " events" << std::endl;
736  endOfFastLoop(iFastLoop);
737  }
738  }
739 
740  if (iFastLoop >= maxLoopNumber - 1) {
741  return kStop;
742  } else {
743  return kContinue;
744  }
745 }

References gather_cfg::cout, duringFastLoop(), endOfFastLoop(), fastLoop, iev, inputRootTreeFileName_, edm::EDLooperBase::kContinue, edm::EDLooperBase::kStop, maxEventsFromRootTree_, maxLoopNumber, MuScleFitUtils::SavedPair, selectMuons(), startingNewLoop(), and totalEvents_.

◆ fillComparisonHistograms()

void MuScleFit::fillComparisonHistograms ( const reco::Particle::LorentzVector &  genMu,
const reco::Particle::LorentzVector &  recoMu,
const std::string &  inputName,
const int  charge 
)
protected

Fill the reco vs gen and reco vs sim comparison histograms.

Definition at line 1370 of file MuScleFit.cc.

1373  {
1374  std::string name(inputName + "VSMu");
1375  mapHisto_["hResolPt" + name]->Fill(recMu, (-genMu.Pt() + recMu.Pt()) / genMu.Pt(), charge);
1376  mapHisto_["hResolTheta" + name]->Fill(recMu, (-genMu.Theta() + recMu.Theta()), charge);
1377  mapHisto_["hResolCotgTheta" + name]->Fill(
1378  recMu, (-cos(genMu.Theta()) / sin(genMu.Theta()) + cos(recMu.Theta()) / sin(recMu.Theta())), charge);
1379  mapHisto_["hResolEta" + name]->Fill(recMu, (-genMu.Eta() + recMu.Eta()), charge);
1380  mapHisto_["hResolPhi" + name]->Fill(recMu, MuScleFitUtils::deltaPhiNoFabs(recMu.Phi(), genMu.Phi()), charge);
1381 
1382  // Fill only if it was matched to a genMu and this muon is valid
1383  if ((genMu.Pt() != 0) && (recMu.Pt() != 0)) {
1384  mapHisto_["hPtRecoVsPt" + inputName]->Fill(genMu.Pt(), recMu.Pt());
1385  }
1386 }

References ALCARECOTkAlJpsiMuMu_cff::charge, funct::cos(), MuScleFitUtils::deltaPhiNoFabs(), MuScleFitBase::mapHisto_, Skims_PA_cff::name, funct::sin(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by duringFastLoop().

◆ fillMuonCollection()

template<typename T >
std::vector< MuScleFitMuon > MuScleFit::fillMuonCollection ( const std::vector< T > &  tracks)

Definition at line 314 of file MuScleFit.cc.

314  {
315  std::vector<MuScleFitMuon> muons;
316  typename std::vector<T>::const_iterator track;
317  for (track = tracks.begin(); track != tracks.end(); ++track) {
318  reco::Particle::LorentzVector mu;
319  mu = reco::Particle::LorentzVector(
320  track->px(), track->py(), track->pz(), sqrt(track->p() * track->p() + MuScleFitUtils::mMu2));
321  // Apply smearing if needed, and then bias
322  // ---------------------------------------
323  MuScleFitUtils::goodmuon++;
324  if (debug_ > 0)
325  std::cout << std::setprecision(9) << "Muon #" << MuScleFitUtils::goodmuon << ": initial value Pt = " << mu.Pt()
326  << std::endl;
327 
328  applySmearing(mu);
329  applyBias(mu, track->charge());
330  if (debug_ > 0)
331  std::cout << "track charge: " << track->charge() << std::endl;
332 
333  Double_t hitsTk = track->innerTrack()->hitPattern().numberOfValidTrackerHits();
334  Double_t hitsMuon = track->innerTrack()->hitPattern().numberOfValidMuonHits();
335  Double_t ptError = track->innerTrack()->ptError();
336  MuScleFitMuon muon(mu, track->charge(), ptError, hitsTk, hitsMuon, false);
337  if (debug_ > 0) {
338  std::cout << "[MuScleFit::fillMuonCollection]" << std::endl;
339  std::cout << " muon = " << muon << std::endl;
340  }
341 
342  // Store modified muon
343  // -------------------
344  muons.push_back(muon);
345  }
346  return muons;
347 }

References applyBias(), applySmearing(), gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::goodmuon, MuScleFitUtils::mMu2, amptDefaultParameters_cff::mu, HLT_2018_cff::muon, PDWG_BPHSkim_cff::muons, mathSSE::sqrt(), HLT_2018_cff::track, and PDWG_EXOHSCP_cff::tracks.

◆ selectMuons() [1/2]

void MuScleFit::selectMuons ( const edm::Event &  event)
protected

Selects the muon pairs and fills the SavedPair and (if needed) the genPair vector. This version reads the events from the edm root file and performs a selection of the muons according to the parameters in the cfg.

Definition at line 857 of file MuScleFit.cc.

857  {
858  recMu1 = reco::Particle::LorentzVector(0, 0, 0, 0);
859  recMu2 = reco::Particle::LorentzVector(0, 0, 0, 0);
860 
861  std::vector<MuScleFitMuon> muons;
862  muonSelector_->selectMuons(event, muons, genMuonPairs_, MuScleFitUtils::simPair, plotter);
863  // plotter->fillRec(muons); // @EM method already invoked inside MuScleFitMuonSelector::selectMuons()
864 
865  if (debug_ > 0) {
866  std::cout << "[MuScleFit::selectMuons] Debugging muons collections after call to muonSelector_->selectMuons"
867  << std::endl;
868  int iMu = 0;
869  for (std::vector<MuScleFitMuon>::const_iterator it = muons.begin(); it < muons.end(); ++it) {
870  std::cout << " - muon n. " << iMu << " = " << (*it) << std::endl;
871  ++iMu;
872  }
873  }
874 
875  // Find the two muons from the resonance, and set ResFound bool
876  // ------------------------------------------------------------
877  std::pair<MuScleFitMuon, MuScleFitMuon> recMuFromBestRes = MuScleFitUtils::findBestRecoRes(muons);
878 
879  if (MuScleFitUtils::ResFound) {
880  if (debug_ > 0) {
881  std::cout << std::setprecision(9) << "Pt after findbestrecores: " << (recMuFromBestRes.first).Pt() << " "
882  << (recMuFromBestRes.second).Pt() << std::endl;
883  std::cout << "recMu1 = " << recMu1 << std::endl;
884  std::cout << "recMu2 = " << recMu2 << std::endl;
885  }
886  recMu1 = recMuFromBestRes.first.p4();
887  recMu2 = recMuFromBestRes.second.p4();
888  recMuScleMu1 = recMuFromBestRes.first;
889  recMuScleMu2 = recMuFromBestRes.second;
890 
891  if (debug_ > 0) {
892  std::cout << "after recMu1 = " << recMu1 << std::endl;
893  std::cout << "after recMu2 = " << recMu2 << std::endl;
894  std::cout << "mu1.pt = " << recMu1.Pt() << std::endl;
895  std::cout << "mu2.pt = " << recMu2.Pt() << std::endl;
896  std::cout << "after recMuScleMu1 = " << recMuScleMu1 << std::endl;
897  std::cout << "after recMuScleMu2 = " << recMuScleMu2 << std::endl;
898  }
899  MuScleFitUtils::SavedPair.push_back(std::make_pair(recMu1, recMu2));
900  MuScleFitUtils::SavedPairMuScleFitMuons.push_back(std::make_pair(recMuScleMu1, recMuScleMu2));
901  } else {
902  MuScleFitUtils::SavedPair.push_back(std::make_pair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.)));
903  MuScleFitUtils::SavedPairMuScleFitMuons.push_back(std::make_pair(MuScleFitMuon(), MuScleFitMuon()));
904  }
905  // Save the events also in the external tree so that it can be saved late
906 
907  // Fetch extra information (per event)
908  UInt_t the_NVtx(0);
909  Int_t the_numPUvtx(0);
910  Float_t the_TrueNumInteractions(0);
911 
912  // Fill pile-up related informations
913  // --------------------------------
914  edm::Handle<std::vector<PileupSummaryInfo> > puInfo;
915  event.getByLabel(puInfoSrc_, puInfo);
916  if (puInfo.isValid()) {
917  std::vector<PileupSummaryInfo>::const_iterator PVI;
918  for (PVI = puInfo->begin(); PVI != puInfo->end(); ++PVI) {
919  int BX = PVI->getBunchCrossing();
920  if (BX == 0) { // "0" is the in-time crossing, negative values are the early crossings, positive are late
921  the_TrueNumInteractions = PVI->getTrueNumInteractions();
922  the_numPUvtx = PVI->getPU_NumInteractions();
923  }
924  }
925  }
926 
927  edm::Handle<std::vector<reco::Vertex> > vertices;
928  event.getByLabel(vertexSrc_, vertices);
929  if (vertices.isValid()) {
930  std::vector<reco::Vertex>::const_iterator itv;
931  // now, count vertices
932  for (itv = vertices->begin(); itv != vertices->end(); ++itv) {
933  // require that the vertex meets certain criteria
934  if (itv->ndof() < 5)
935  continue;
936  if (fabs(itv->z()) > 50.0)
937  continue;
938  if (fabs(itv->position().rho()) > 2.0)
939  continue;
940  ++the_NVtx;
941  }
942  }
943 
944  // get the MC event weight
945  edm::Handle<GenEventInfoProduct> genEvtInfo;
946  event.getByLabel("generator", genEvtInfo);
947  double the_genEvtweight = 1.;
948  if (genEvtInfo.isValid()) {
949  the_genEvtweight = genEvtInfo->weight();
950  }
951 
952  muonPairs_.push_back(MuonPair(
953  MuScleFitUtils::SavedPairMuScleFitMuons.back().first,
954  MuScleFitUtils::SavedPairMuScleFitMuons.back().second,
955  MuScleFitEvent(
956  event.run(), event.id().event(), the_genEvtweight, the_numPUvtx, the_TrueNumInteractions, the_NVtx)));
957  // Fill the internal genPair tree from the external one
958  if (MuScleFitUtils::speedup == false) {
959  MuScleFitUtils::genPair.push_back(std::make_pair(genMuonPairs_.back().mu1.p4(), genMuonPairs_.back().mu2.p4()));
960  }
961 }

References L1TStage2uGTEmulatorClient_cff::BX, gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::findBestRecoRes(), dqmdumpme::first, MuScleFitBase::genMuonPairs_, MuScleFitUtils::genPair, edm::HandleBase::isValid(), MuScleFitBase::muonPairs_, PDWG_BPHSkim_cff::muons, muonSelector_, plotter, puInfoSrc_, recMu1, recMu2, recMuScleMu1, recMuScleMu2, MuScleFitUtils::ResFound, MuScleFitUtils::SavedPair, MuScleFitUtils::SavedPairMuScleFitMuons, edm::second(), MuScleFitUtils::simPair, MuScleFitUtils::speedup, vertexSrc_, pwdgSkimBPark_cfi::vertices, and GenEventInfoProduct::weight().

Referenced by duringLoop(), and endOfLoop().

◆ selectMuons() [2/2]

void MuScleFit::selectMuons ( const int  maxEvents,
const TString &  treeFileName 
)
protected

Selects the muon pairs and fills the SavedPair and (if needed) the genPair vector. This version reads the events from a tree in the file specified in the cfg. The tree only contains one muon pair per event. This means that no selection is performed and we use preselected muons.

Definition at line 963 of file MuScleFit.cc.

963  {
964  std::cout << "Reading muon pairs from Root Tree in " << treeFileName << std::endl;
965  RootTreeHandler rootTreeHandler;
966  std::vector<std::pair<unsigned int, unsigned long long> > evtRun;
967  if (MuScleFitUtils::speedup) {
968  rootTreeHandler.readTree(
969  maxEvents, inputRootTreeFileName_, &(MuScleFitUtils::SavedPairMuScleFitMuons), theMuonType_, &evtRun);
970  } else {
971  rootTreeHandler.readTree(maxEvents,
972  inputRootTreeFileName_,
973  &(MuScleFitUtils::SavedPairMuScleFitMuons),
974  theMuonType_,
975  &evtRun,
976  &(MuScleFitUtils::genMuscleFitPair));
977  }
978  // Now loop on all the pairs and apply any smearing and bias if needed
979  std::vector<std::pair<unsigned int, unsigned long long> >::iterator evtRunIt = evtRun.begin();
980  std::vector<std::pair<MuScleFitMuon, MuScleFitMuon> >::iterator it = MuScleFitUtils::SavedPairMuScleFitMuons.begin();
981  std::vector<std::pair<MuScleFitMuon, MuScleFitMuon> >::iterator genIt;
982  if (MuScleFitUtils::speedup == false)
983  genIt = MuScleFitUtils::genMuscleFitPair.begin();
984  for (; it != MuScleFitUtils::SavedPairMuScleFitMuons.end(); ++it, ++evtRunIt) {
985  // Apply any cut if requested
986  // Note that cuts here are only applied to already selected muons. They should not be used unless
987  // you are sure that the difference is negligible (e.g. the number of events with > 2 muons is negligible).
988  double pt1 = it->first.pt();
989  //std::cout << "pt1 = " << pt1 << std::endl;
990  double pt2 = it->second.pt();
991  //std::cout << "pt2 = " << pt2 << std::endl;
992  double eta1 = it->first.eta();
993  //std::cout << "eta1 = " << eta1 << std::endl;
994  double eta2 = it->second.eta();
995  //std::cout << "eta2 = " << eta2 << std::endl;
996  // If they don't pass the cuts set to null vectors
997  bool dontPass = false;
998  bool eta1InFirstRange;
999  bool eta2InFirstRange;
1000  bool eta1InSecondRange;
1001  bool eta2InSecondRange;
1002 
1003  int ch1 = it->first.charge();
1004  int ch2 = it->second.charge();
1005 
1006  if (MuScleFitUtils::separateRanges_) {
1007  eta1InFirstRange = eta1 >= MuScleFitUtils::minMuonEtaFirstRange_ && eta1 < MuScleFitUtils::maxMuonEtaFirstRange_;
1008  eta2InFirstRange = eta2 >= MuScleFitUtils::minMuonEtaFirstRange_ && eta2 < MuScleFitUtils::maxMuonEtaFirstRange_;
1009  eta1InSecondRange =
1010  eta1 >= MuScleFitUtils::minMuonEtaSecondRange_ && eta1 < MuScleFitUtils::maxMuonEtaSecondRange_;
1011  eta2InSecondRange =
1012  eta2 >= MuScleFitUtils::minMuonEtaSecondRange_ && eta2 < MuScleFitUtils::maxMuonEtaSecondRange_;
1013 
1014  // This is my logic, which should be erroneous, but certainly simpler...
1015  if (!(pt1 >= MuScleFitUtils::minMuonPt_ && pt1 < MuScleFitUtils::maxMuonPt_ &&
1016  pt2 >= MuScleFitUtils::minMuonPt_ && pt2 < MuScleFitUtils::maxMuonPt_ &&
1017  ((eta1InFirstRange && eta2InSecondRange && ch1 >= ch2) ||
1018  (eta1InSecondRange && eta2InFirstRange && ch1 < ch2))))
1019  dontPass = true;
1020  } else {
1021  eta1InFirstRange = eta1 >= MuScleFitUtils::minMuonEtaFirstRange_ && eta1 < MuScleFitUtils::maxMuonEtaFirstRange_;
1022  eta2InFirstRange = eta2 >= MuScleFitUtils::minMuonEtaFirstRange_ && eta2 < MuScleFitUtils::maxMuonEtaFirstRange_;
1023  eta1InSecondRange =
1024  eta1 >= MuScleFitUtils::minMuonEtaSecondRange_ && eta1 < MuScleFitUtils::maxMuonEtaSecondRange_;
1025  eta2InSecondRange =
1026  eta2 >= MuScleFitUtils::minMuonEtaSecondRange_ && eta2 < MuScleFitUtils::maxMuonEtaSecondRange_;
1027  if (!(pt1 >= MuScleFitUtils::minMuonPt_ && pt1 < MuScleFitUtils::maxMuonPt_ &&
1028  pt2 >= MuScleFitUtils::minMuonPt_ && pt2 < MuScleFitUtils::maxMuonPt_ &&
1029  (((eta1InFirstRange && !eta2InFirstRange) && (eta2InSecondRange && !eta1InSecondRange) && ch1 >= ch2) ||
1030  ((eta2InFirstRange && !eta1InFirstRange) && (eta1InSecondRange && !eta2InSecondRange) && ch1 < ch2))))
1031  dontPass = true;
1032  }
1033 
1034  // Additional check on deltaPhi
1035  double deltaPhi = MuScleFitUtils::deltaPhi(it->first.phi(), it->second.phi());
1036  if ((deltaPhi <= MuScleFitUtils::deltaPhiMinCut_) || (deltaPhi >= MuScleFitUtils::deltaPhiMaxCut_))
1037  dontPass = true;
1038 
1039  lorentzVector vec1 = it->first.p4();
1040  lorentzVector vec2 = it->second.p4();
1041  if (ch1 >= ch2) {
1042  lorentzVector vectemp = vec1;
1043  vec1 = vec2;
1044  vec2 = vectemp;
1045  }
1046 
1047  if (!dontPass) {
1048  // First is always mu-, second mu+
1049  if ((MuScleFitUtils::SmearType != 0) || (MuScleFitUtils::BiasType != 0)) {
1050  applySmearing(vec1);
1051  applyBias(vec1, -1);
1052  applySmearing(vec2);
1053  applyBias(vec2, 1);
1054  }
1055 
1056  MuScleFitUtils::SavedPair.push_back(std::make_pair(vec1, vec2));
1057  }
1058 
1059  //FIXME: we loose the additional information besides the 4-momenta
1060  muonPairs_.push_back(MuonPair(
1061  MuScleFitMuon(vec1, -1),
1062  MuScleFitMuon(vec2, +1),
1063  MuScleFitEvent(
1064  (*evtRunIt).first, (*evtRunIt).second, 0, 0, 0, 0)) // FIXME: order of event and run number mixed up!
1065  );
1066 
1067  // Fill the internal genPair tree from the external one
1068  if (!MuScleFitUtils::speedup) {
1069  MuScleFitUtils::genPair.push_back(std::make_pair(genIt->first.p4(), genIt->second.p4()));
1070  genMuonPairs_.push_back(GenMuonPair(genIt->first.p4(), genIt->second.p4(), 0));
1071  ++genIt;
1072  }
1073  }
1074  plotter->fillTreeRec(MuScleFitUtils::SavedPair);
1075  if (!(MuScleFitUtils::speedup)) {
1076  plotter->fillTreeGen(MuScleFitUtils::genPair);
1077  }
1078 }

References applyBias(), applySmearing(), MuScleFitUtils::BiasType, gather_cfg::cout, SiPixelRawToDigiRegional_cfi::deltaPhi, MuScleFitUtils::deltaPhi(), MuScleFitUtils::deltaPhiMaxCut_, MuScleFitUtils::deltaPhiMinCut_, HLT_2018_cff::eta1, HLT_2018_cff::eta2, MuScleFitPlotter::fillTreeGen(), MuScleFitPlotter::fillTreeRec(), MuScleFitBase::genMuonPairs_, MuScleFitUtils::genMuscleFitPair, MuScleFitUtils::genPair, inputRootTreeFileName_, Data_TkAlMinBias_Run2018C_PromptReco_v3_cff::maxEvents, MuScleFitUtils::maxMuonEtaFirstRange_, MuScleFitUtils::maxMuonEtaSecondRange_, MuScleFitUtils::maxMuonPt_, MuScleFitUtils::minMuonEtaFirstRange_, MuScleFitUtils::minMuonEtaSecondRange_, MuScleFitUtils::minMuonPt_, MuScleFitBase::muonPairs_, plotter, HLT_2018_cff::pt1, HLT_2018_cff::pt2, RootTreeHandler::readTree(), MuScleFitUtils::SavedPair, MuScleFitUtils::SavedPairMuScleFitMuons, MuScleFitUtils::separateRanges_, MuScleFitUtils::SmearType, MuScleFitUtils::speedup, and MuScleFitBase::theMuonType_.

◆ selGlobalMuon()

bool MuScleFit::selGlobalMuon ( const pat::Muon *  aMuon)
protected

Function for onia selections.

Definition at line 1502 of file MuScleFit.cc.

1502  {
1503  reco::TrackRef iTrack = aMuon->innerTrack();
1504  const reco::HitPattern& p = iTrack->hitPattern();
1505 
1506  reco::TrackRef gTrack = aMuon->globalTrack();
1507  const reco::HitPattern& q = gTrack->hitPattern();
1508 
1509  return ( //isMuonInAccept(aMuon) &&// no acceptance cuts!
1510  iTrack->found() > 11 && gTrack->chi2() / gTrack->ndof() < 20.0 && q.numberOfValidMuonHits() > 0 &&
1511  iTrack->chi2() / iTrack->ndof() < 4.0 && aMuon->muonID("TrackerMuonArbitrated") &&
1512  aMuon->muonID("TMLastStationAngTight") && p.pixelLayersWithMeasurement() > 1 &&
1513  fabs(iTrack->dxy()) < 3.0 && //should be done w.r.t. PV!
1514  fabs(iTrack->dz()) < 15.0); //should be done w.r.t. PV!
1515 }

References pat::Muon::globalTrack(), pat::Muon::innerTrack(), pat::Muon::muonID(), AlCaHLTBitMon_ParallelJobs::p, and data-class-funcs::q.

◆ selTrackerMuon()

bool MuScleFit::selTrackerMuon ( const pat::Muon *  aMuon)
protected

Definition at line 1517 of file MuScleFit.cc.

1517  {
1518  reco::TrackRef iTrack = aMuon->innerTrack();
1519  const reco::HitPattern& p = iTrack->hitPattern();
1520 
1521  return ( //isMuonInAccept(aMuon) // no acceptance cuts!
1522  iTrack->found() > 11 && iTrack->chi2() / iTrack->ndof() < 4.0 && aMuon->muonID("TrackerMuonArbitrated") &&
1523  aMuon->muonID("TMLastStationAngTight") && p.pixelLayersWithMeasurement() > 1 &&
1524  fabs(iTrack->dxy()) < 3.0 && //should be done w.r.t. PV!
1525  fabs(iTrack->dz()) < 15.0); //should be done w.r.t. PV!
1526 }

References pat::Muon::innerTrack(), pat::Muon::muonID(), and AlCaHLTBitMon_ParallelJobs::p.

◆ startingNewLoop()

void MuScleFit::startingNewLoop ( unsigned int  )
overridevirtual

Called before system starts to loop over the events. The argument is a count of how many loops have been processed. For the first time through the events the argument will be 0.

Implements edm::EDLooperBase.

Definition at line 676 of file MuScleFit.cc.

676  {
677  if (debug_ > 0)
678  std::cout << "[MuScleFit]: Starting loop # " << iLoop << std::endl;
679 
680  // Number of muons used
681  // --------------------
682  MuScleFitUtils::goodmuon = 0;
683 
684  // Counters for problem std::cout-ing
685  // -----------------------------
686  MuScleFitUtils::counter_resprob = 0;
687 
688  // Create the root file
689  // --------------------
690  fillHistoMap(theFiles_[iLoop], iLoop);
691 
692  loopCounter = iLoop;
693  MuScleFitUtils::loopCounter = loopCounter;
694 
695  iev = 0;
696  MuScleFitUtils::iev_ = 0;
697 
698  MuScleFitUtils::oldNormalization_ = 0;
699 }

References MuScleFitUtils::counter_resprob, gather_cfg::cout, MuScleFitBase::debug_, MuScleFitBase::fillHistoMap(), MuScleFitUtils::goodmuon, iev, MuScleFitUtils::iev_, MuScleFitUtils::loopCounter, loopCounter, MuScleFitUtils::oldNormalization_, and MuScleFitBase::theFiles_.

Referenced by endOfLoop().

◆ takeSelectedMuonType()

template<typename T >
void MuScleFit::takeSelectedMuonType ( const T &  muon,
std::vector< reco::Track > &  tracks 
)
protected

Template method used to fill the track collection starting from reco::muons or pat::muons.

Definition at line 350 of file MuScleFit.cc.

350  {
351  // std::cout<<"muon "<<muon->isGlobalMuon()<<muon->isStandAloneMuon()<<muon->isTrackerMuon()<<std::endl;
352  //NNBB: one muon can be of many kinds at once but with the theMuonType_ we are sure
353  // to avoid double counting of the same muon
354  if (muon->isGlobalMuon() && theMuonType_ == 1)
355  tracks.push_back(*(muon->globalTrack()));
356  else if (muon->isStandAloneMuon() && theMuonType_ == 2)
357  tracks.push_back(*(muon->outerTrack()));
358  else if (muon->isTrackerMuon() && theMuonType_ == 3)
359  tracks.push_back(*(muon->innerTrack()));
360 
361  else if (theMuonType_ == 10 && !(muon->isStandAloneMuon())) //particular case!!
362  tracks.push_back(*(muon->innerTrack()));
363  else if (theMuonType_ == 11 && muon->isGlobalMuon())
364  tracks.push_back(*(muon->innerTrack()));
365  else if (theMuonType_ == 13 && muon->isTrackerMuon())
366  tracks.push_back(*(muon->innerTrack()));
367 }

References MuScleFitBase::theMuonType_, and PDWG_EXOHSCP_cff::tracks.

Member Data Documentation

◆ compareToSimTracks_

bool MuScleFit::compareToSimTracks_
protected

Definition at line 288 of file MuScleFit.cc.

Referenced by duringFastLoop(), and MuScleFit().

◆ fastLoop

bool MuScleFit::fastLoop
protected

Definition at line 277 of file MuScleFit.cc.

Referenced by duringLoop(), endOfLoop(), and MuScleFit().

◆ genParticlesName_

std::string MuScleFit::genParticlesName_
protected

Definition at line 291 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ iev

int MuScleFit::iev
protected

Definition at line 285 of file MuScleFit.cc.

Referenced by duringFastLoop(), endOfLoop(), and startingNewLoop().

◆ ifGenPart

bool MuScleFit::ifGenPart
protected

Definition at line 265 of file MuScleFit.cc.

◆ ifHepMC

bool MuScleFit::ifHepMC
protected

Definition at line 264 of file MuScleFit.cc.

◆ inputRootTreeFileName_

std::string MuScleFit::inputRootTreeFileName_
protected

Definition at line 294 of file MuScleFit.cc.

Referenced by duringLoop(), endOfLoop(), MuScleFit(), selectMuons(), and ~MuScleFit().

◆ loopCounter

unsigned int MuScleFit::loopCounter
protected

Definition at line 275 of file MuScleFit.cc.

Referenced by duringFastLoop(), duringLoop(), endOfFastLoop(), MuScleFit(), and startingNewLoop().

◆ maxEventsFromRootTree_

int MuScleFit::maxEventsFromRootTree_
protected

Definition at line 298 of file MuScleFit.cc.

Referenced by endOfLoop(), and MuScleFit().

◆ maxLoopNumber

unsigned int MuScleFit::maxLoopNumber
protected

Definition at line 274 of file MuScleFit.cc.

Referenced by beginOfJobInConstructor(), checkParameters(), endOfLoop(), and MuScleFit().

◆ maxResMass_hwindow

double MuScleFit::maxResMass_hwindow[6]
protected

Definition at line 270 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ minResMass_hwindow

double MuScleFit::minResMass_hwindow[6]
protected

Definition at line 269 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ muonSelector_

std::unique_ptr<MuScleFitMuonSelector> MuScleFit::muonSelector_
protected

Definition at line 310 of file MuScleFit.cc.

Referenced by MuScleFit(), and selectMuons().

◆ negateTrigger_

bool MuScleFit::negateTrigger_
protected

Definition at line 303 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ numberOfEwkZ

int MuScleFit::numberOfEwkZ
protected

Definition at line 262 of file MuScleFit.cc.

◆ numberOfSimMuons

int MuScleFit::numberOfSimMuons
protected

Definition at line 260 of file MuScleFit.cc.

◆ numberOfSimTracks

int MuScleFit::numberOfSimTracks
protected

Definition at line 259 of file MuScleFit.cc.

◆ numberOfSimVertices

int MuScleFit::numberOfSimVertices
protected

Definition at line 261 of file MuScleFit.cc.

◆ outputRootTreeFileName_

std::string MuScleFit::outputRootTreeFileName_
protected

Definition at line 296 of file MuScleFit.cc.

Referenced by MuScleFit(), and ~MuScleFit().

◆ PATmuons_

bool MuScleFit::PATmuons_
protected

Definition at line 290 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ plotter

MuScleFitPlotter* MuScleFit::plotter
protected

Definition at line 279 of file MuScleFit.cc.

Referenced by beginOfJobInConstructor(), endOfFastLoop(), and selectMuons().

◆ puInfoSrc_

edm::InputTag MuScleFit::puInfoSrc_
protected

Definition at line 307 of file MuScleFit.cc.

Referenced by MuScleFit(), and selectMuons().

◆ recMu1

reco::Particle::LorentzVector MuScleFit::recMu1
protected

Definition at line 283 of file MuScleFit.cc.

Referenced by duringFastLoop(), and selectMuons().

◆ recMu2

reco::Particle::LorentzVector MuScleFit::recMu2
protected

Definition at line 283 of file MuScleFit.cc.

Referenced by duringFastLoop(), and selectMuons().

◆ recMuScleMu1

MuScleFitMuon MuScleFit::recMuScleMu1
protected

Definition at line 284 of file MuScleFit.cc.

Referenced by selectMuons().

◆ recMuScleMu2

MuScleFitMuon MuScleFit::recMuScleMu2
protected

Definition at line 284 of file MuScleFit.cc.

Referenced by selectMuons().

◆ saveAllToTree_

bool MuScleFit::saveAllToTree_
protected

Definition at line 304 of file MuScleFit.cc.

Referenced by MuScleFit(), and ~MuScleFit().

◆ simTracksCollection_

edm::InputTag MuScleFit::simTracksCollection_
protected

Definition at line 289 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ theService

MuonServiceProxy* MuScleFit::theService
protected

Definition at line 255 of file MuScleFit.cc.

◆ totalEvents_

int MuScleFit::totalEvents_
protected

Definition at line 286 of file MuScleFit.cc.

Referenced by duringLoop(), endOfLoop(), and ~MuScleFit().

◆ triggerPath_

std::vector<std::string> MuScleFit::triggerPath_
protected

Definition at line 302 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ triggerResultsLabel_

std::string MuScleFit::triggerResultsLabel_
protected

Definition at line 300 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ triggerResultsProcess_

std::string MuScleFit::triggerResultsProcess_
protected

Definition at line 301 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ vertexSrc_

edm::InputTag MuScleFit::vertexSrc_
protected

Definition at line 308 of file MuScleFit.cc.

Referenced by MuScleFit(), and selectMuons().

MuScleFitUtils::x
static double x[7][10000]
Definition: MuScleFitUtils.h:213
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
MuScleFitUtils::parSmear
static std::vector< double > parSmear
Definition: MuScleFitUtils.h:190
MuScleFitUtils::parScaleFix
static std::vector< int > parScaleFix
Definition: MuScleFitUtils.h:203
MuScleFitBase::muonPairs_
std::vector< MuonPair > muonPairs_
Used to store the muon pairs plus run and event number prior to the creation of the internal tree.
Definition: MuScleFitBase.h:80
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
MuScleFitUtils::BiasType
static int BiasType
Definition: MuScleFitUtils.h:149
MuScleFitUtils::minMuonPt_
static double minMuonPt_
Definition: MuScleFitUtils.h:259
MuScleFitUtils::deltaPhiNoFabs
static double deltaPhiNoFabs(const double &phi1, const double &phi2)
Without fabs at the end, used to have a symmetric distribution for the resolution fits and variance c...
Definition: MuScleFitUtils.h:118
MuScleFit::saveAllToTree_
bool saveAllToTree_
Definition: MuScleFit.cc:304
MuScleFitUtils::findBestRecoRes
static std::pair< MuScleFitMuon, MuScleFitMuon > findBestRecoRes(const std::vector< MuScleFitMuon > &muons)
Definition: MuScleFitUtils.cc:315
mps_fire.i
i
Definition: mps_fire.py:355
MuScleFitUtils::smearFunction
static smearFunctionBase * smearFunction
Definition: MuScleFitUtils.h:148
HLT_2018_cff.pt2
pt2
Definition: HLT_2018_cff.py:8552
MuScleFitUtils::parResolMin
static std::vector< double > parResolMin
Definition: MuScleFitUtils.h:194
RootTreeHandler
Definition: RootTreeHandler.h:24
MuScleFit::fillComparisonHistograms
void fillComparisonHistograms(const reco::Particle::LorentzVector &genMu, const reco::Particle::LorentzVector &recoMu, const std::string &inputName, const int charge)
Fill the reco vs gen and reco vs sim comparison histograms.
Definition: MuScleFit.cc:1370
MuScleFitUtils::parvalue
static std::vector< std::vector< double > > parvalue
Definition: MuScleFitUtils.h:226
MuScleFitUtils::separateRanges_
static bool separateRanges_
Definition: MuScleFitUtils.h:258
MuScleFitBase::genMuonPairs_
std::vector< GenMuonPair > genMuonPairs_
Stores the genMuon pairs and the motherId prior to the creation of the internal tree.
Definition: MuScleFitBase.h:82
MuScleFitUtils::parScaleOrder
static std::vector< int > parScaleOrder
Definition: MuScleFitUtils.h:207
MuScleFitUtils::ResMass
static double ResMass[6]
Definition: MuScleFitUtils.h:136
vec1
std::vector< double > vec1
Definition: HCALResponse.h:15
BackgroundHandler
Definition: BackgroundHandler.h:32
muon
Definition: MuonCocktails.h:17
MuScleFitUtils::maxMuonEtaFirstRange_
static double maxMuonEtaFirstRange_
Definition: MuScleFitUtils.h:262
MuScleFitUtils::computeWeight
static double computeWeight(const double &mass, const int iev, const bool doUseBkgrWindow=false)
Definition: MuScleFitUtils.cc:1163
amptDefaultParameters_cff.mu
mu
Definition: amptDefaultParameters_cff.py:16
MuScleFitUtils::deltaPhi
static double deltaPhi(const double &phi1, const double &phi2)
Definition: MuScleFitUtils.h:109
GenMuonPair
Definition: GenMuonPair.h:19
MuScleFit::totalEvents_
int totalEvents_
Definition: MuScleFit.cc:286
mps_merge.weight
weight
Definition: mps_merge.py:88
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
MuScleFitPlotter::fillTreeRec
void fillTreeRec(const std::vector< std::pair< reco::Particle::LorentzVector, reco::Particle::LorentzVector > > &savedPairs)
Used when running on the root tree containing preselected muon pairs.
Definition: MuScleFitPlotter.cc:334
MuScleFitUtils::parBgrFix
static std::vector< int > parBgrFix
Definition: MuScleFitUtils.h:205
MuScleFitUtils::deltaPhiMaxCut_
static double deltaPhiMaxCut_
Definition: MuScleFitUtils.h:266
gather_cfg.cout
cout
Definition: gather_cfg.py:144
MuScleFitUtils::computeMinosErrors_
static bool computeMinosErrors_
Definition: MuScleFitUtils.h:280
HLT_2018_cff.eta1
eta1
Definition: HLT_2018_cff.py:8220
MuScleFitUtils::mMu2
static const double mMu2
Definition: MuScleFitUtils.h:139
MuScleFitUtils::crossSectionHandler
static CrossSectionHandler * crossSectionHandler
Definition: MuScleFitUtils.h:171
triggerResults
static const std::string triggerResults
Definition: EdmProvDump.cc:45
data-class-funcs.q
q
Definition: data-class-funcs.py:169
MuScleFitUtils::MuonTypeForCheckMassWindow
static int MuonTypeForCheckMassWindow
Definition: MuScleFitUtils.h:224
HLT_2018_cff.pt1
pt1
Definition: HLT_2018_cff.py:8550
MuScleFit::negateTrigger_
bool negateTrigger_
Definition: MuScleFit.cc:303
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:215
callgraph.G
G
Definition: callgraph.py:13
MuScleFitMuon
Definition: Muon.h:14
resolutionFunctionService
resolutionFunctionBase< double * > * resolutionFunctionService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier.
Definition: Functions.cc:70
MuScleFitUtils::parResolOrder
static std::vector< int > parResolOrder
Definition: MuScleFitUtils.h:206
MuScleFitUtils::parCrossSectionOrder
static std::vector< int > parCrossSectionOrder
Definition: MuScleFitUtils.h:208
MuScleFitUtils::speedup
static bool speedup
Definition: MuScleFitUtils.h:212
MuScleFitUtils::applyScale
static lorentzVector applyScale(const lorentzVector &muon, const std::vector< double > &parval, const int charge)
Definition: MuScleFitUtils.cc:465
HLT_2018_cff.muon
muon
Definition: HLT_2018_cff.py:10349
vec2
std::vector< vec1 > vec2
Definition: HCALResponse.h:16
tools.TF1
TF1
Definition: tools.py:23
MuScleFitUtils::FitStrategy
static int FitStrategy
Definition: MuScleFitUtils.h:211
MuScleFitUtils::massResolComponents
static struct MuScleFitUtils::massResolComponentsStruct massResolComponents
Definition: MuScleFitUtils.cc:262
edm::Handle< edm::TriggerResults >
MuScleFit::selectMuons
void selectMuons(const edm::Event &event)
Definition: MuScleFit.cc:857
dqmdumpme.first
first
Definition: dqmdumpme.py:55
MuScleFitUtils::useProbsFile_
static bool useProbsFile_
Definition: MuScleFitUtils.h:255
MuScleFitBase::readProbabilityDistributionsFromFile
void readProbabilityDistributionsFromFile()
Read probability distributions from a local root file.
Definition: MuScleFitBase.cc:159
MuScleFitUtils::resfind
static std::vector< int > resfind
Definition: MuScleFitUtils.h:210
MuScleFit::maxEventsFromRootTree_
int maxEventsFromRootTree_
Definition: MuScleFit.cc:298
MuScleFitUtils::genPair
static std::vector< std::pair< lorentzVector, lorentzVector > > genPair
Definition: MuScleFitUtils.h:233
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:21
MuScleFit::recMu2
reco::Particle::LorentzVector recMu2
Definition: MuScleFit.cc:283
edm::Ref< TrackCollection >
MuScleFitUtils::rapidityBinsForZ_
static bool rapidityBinsForZ_
Definition: MuScleFitUtils.h:251
MuonPair
Definition: MuonPair.h:13
MuScleFitUtils::applySmearing
static lorentzVector applySmearing(const lorentzVector &muon)
Definition: MuScleFitUtils.cc:416
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
resolutionFunctionVecService
resolutionFunctionBase< std::vector< double > > * resolutionFunctionVecService(const int identifier)
Service to build the resolution functor corresponding to the passed identifier when receiving a std::...
Definition: Functions.cc:92
CrossSectionHandler::addParameters
void addParameters(std::vector< double > &initpar)
Inputs the vars in a vector.
Definition: CrossSectionHandler.h:50
MuScleFitUtils::minimumShapePlots_
static bool minimumShapePlots_
Definition: MuScleFitUtils.h:281
contentValuesCheck.ss
ss
Definition: contentValuesCheck.py:33
MuScleFitUtils::doCrossSectionFit
static std::vector< int > doCrossSectionFit
Definition: MuScleFitUtils.h:180
MuScleFit::recMuScleMu1
MuScleFitMuon recMuScleMu1
Definition: MuScleFit.cc:284
reco::HitPattern
Definition: HitPattern.h:147
MuScleFitBase::theFiles_
std::vector< TFile * > theFiles_
The files were the histograms are saved.
Definition: MuScleFitBase.h:74
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
MuScleFit::simTracksCollection_
edm::InputTag simTracksCollection_
Definition: MuScleFit.cc:289
MuScleFitUtils::parResol
static std::vector< double > parResol
Definition: MuScleFitUtils.h:192
MuScleFitUtils::normalizeLikelihoodByEventNumber_
static bool normalizeLikelihoodByEventNumber_
Definition: MuScleFitUtils.h:240
MuScleFitUtils::parCrossSection
static std::vector< double > parCrossSection
Definition: MuScleFitUtils.h:200
MuScleFitUtils::debugMassResol_
static bool debugMassResol_
Definition: MuScleFitUtils.h:268
edm::EDLooperBase::kStop
Definition: EDLooperBase.h:79
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
L1TEGammaOffline_cfi.triggerNames
triggerNames
Definition: L1TEGammaOffline_cfi.py:40
MuScleFitUtils::parResolMax
static std::vector< double > parResolMax
Definition: MuScleFitUtils.h:195
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
MuScleFitUtils::ResFound
static bool ResFound
Definition: MuScleFitUtils.h:131
MuScleFitPlotter::fillTreeGen
void fillTreeGen(const std::vector< std::pair< reco::Particle::LorentzVector, reco::Particle::LorentzVector > > &genPairs)
Definition: MuScleFitPlotter.cc:354
MuScleFit::recMu1
reco::Particle::LorentzVector recMu1
Definition: MuScleFit.cc:283
MuScleFitUtils::deltaPhiMinCut_
static double deltaPhiMinCut_
Definition: MuScleFitUtils.h:265
MuScleFitUtils::scaleFunction
static scaleFunctionBase< double * > * scaleFunction
Definition: MuScleFitUtils.h:156
MuScleFitUtils::massResolution
static double massResolution(const lorentzVector &mu1, const lorentzVector &mu2)
MuScleFitUtils::startWithSimplex_
static bool startWithSimplex_
Definition: MuScleFitUtils.h:279
MuScleFit::startingNewLoop
void startingNewLoop(unsigned int iLoop) override
Definition: MuScleFit.cc:676
MuScleFitUtils::minMuonEtaSecondRange_
static double minMuonEtaSecondRange_
Definition: MuScleFitUtils.h:263
MuScleFit::applySmearing
void applySmearing(reco::Particle::LorentzVector &mu)
Apply the smearing if needed using the function in MuScleFitUtils.
Definition: MuScleFit.cc:1388
MuScleFitUtils::ResolFitType
static int ResolFitType
Definition: MuScleFitUtils.h:152
MuScleFitBase::theMuonLabel_
edm::InputTag theMuonLabel_
Definition: MuScleFitBase.h:47
MuScleFit::maxLoopNumber
unsigned int maxLoopNumber
Definition: MuScleFit.cc:274
MuScleFit::maxResMass_hwindow
double maxResMass_hwindow[6]
Definition: MuScleFit.cc:270
MuScleFitUtils::parScale
static std::vector< double > parScale
Definition: MuScleFitUtils.h:196
HLT_2018_cff.eta2
eta2
Definition: HLT_2018_cff.py:8221
MuScleFitUtils::resolutionFunctionForVec
static resolutionFunctionBase< std::vector< double > > * resolutionFunctionForVec
Definition: MuScleFitUtils.h:154
MuScleFitBase::theRootFileName_
std::string theRootFileName_
Definition: MuScleFitBase.h:48
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
RootTreeHandler::writeTree
void writeTree(const TString &fileName, const std::vector< MuonPair > *savedPair, const int muonType=0, const std::vector< GenMuonPair > *genPair=nullptr, const bool saveAll=false)
Definition: RootTreeHandler.h:28
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
scaleFunctionVecService
scaleFunctionBase< std::vector< double > > * scaleFunctionVecService(const int identifier)
Service to build the scale functor corresponding to the passed identifier when receiving a std::vecto...
Definition: Functions.cc:20
MuScleFitUtils::minMuonEtaFirstRange_
static double minMuonEtaFirstRange_
Definition: MuScleFitUtils.h:261
MuScleFit::beginOfJobInConstructor
void beginOfJobInConstructor()
Definition: MuScleFit.cc:637
MuScleFit::triggerResultsLabel_
std::string triggerResultsLabel_
Definition: MuScleFit.cc:300
MuScleFitUtils::SavedPairMuScleFitMuons
static std::vector< std::pair< MuScleFitMuon, MuScleFitMuon > > SavedPairMuScleFitMuons
Definition: MuScleFitUtils.h:234
MuScleFitUtils::massWindowHalfWidth
static double massWindowHalfWidth[3][6]
Definition: MuScleFitUtils.h:134
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
MuScleFit::PATmuons_
bool PATmuons_
Definition: MuScleFit.cc:290
MuScleFitBase::theMuonType_
int theMuonType_
Definition: MuScleFitBase.h:46
MuScleFitUtils::debug
static int debug
Definition: MuScleFitUtils.h:130
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
MuScleFitUtils::parScaleMax
static std::vector< double > parScaleMax
Definition: MuScleFitUtils.h:199
MuScleFit::minResMass_hwindow
double minResMass_hwindow[6]
Definition: MuScleFit.cc:269
lorentzVector
reco::Particle::LorentzVector lorentzVector
Definition: GenMuonPair.h:9
MuScleFitUtils::iev_
static int iev_
Definition: MuScleFitUtils.h:253
MuScleFitBase::fillHistoMap
void fillHistoMap(TFile *outputFile, unsigned int iLoop)
Create the histograms map.
Definition: MuScleFitBase.cc:9
MuScleFitBase::MuScleFitBase
MuScleFitBase(const edm::ParameterSet &iConfig)
Definition: MuScleFitBase.h:20
MuScleFitUtils::SavedPair
static std::vector< std::pair< lorentzVector, lorentzVector > > SavedPair
Definition: MuScleFitUtils.h:231
createfilelist.int
int
Definition: createfilelist.py:10
MuScleFit::muonSelector_
std::unique_ptr< MuScleFitMuonSelector > muonSelector_
Definition: MuScleFit.cc:310
MuScleFit::outputRootTreeFileName_
std::string outputRootTreeFileName_
Definition: MuScleFit.cc:296
MuScleFitUtils::biasFunction
static scaleFunctionBase< std::vector< double > > * biasFunction
Definition: MuScleFitUtils.h:151
MuScleFitBase::debug_
int debug_
Definition: MuScleFitBase.h:51
MuScleFit::recMuScleMu2
MuScleFitMuon recMuScleMu2
Definition: MuScleFit.cc:284
edm::EDLooperBase::kContinue
Definition: EDLooperBase.h:79
MuScleFitUtils::parResolFix
static std::vector< int > parResolFix
Definition: MuScleFitUtils.h:202
MuScleFitBase::theGenInfoRootFileName_
std::string theGenInfoRootFileName_
Definition: MuScleFitBase.h:49
MuScleFitUtils::parBgr
static std::vector< double > parBgr
Definition: MuScleFitUtils.h:201
MuScleFit::triggerResultsProcess_
std::string triggerResultsProcess_
Definition: MuScleFit.cc:301
MuScleFitEvent
Definition: Event.h:6
MuScleFitUtils::maxMuonPt_
static double maxMuonPt_
Definition: MuScleFitUtils.h:260
MuScleFitBase::clearHistoMap
void clearHistoMap()
Clean the histograms map.
Definition: MuScleFitBase.cc:143
MuScleFitMuonSelector
Definition: MuScleFitMuonSelector.h:29
MuScleFitUtils::parBgrOrder
static std::vector< int > parBgrOrder
Definition: MuScleFitUtils.h:209
MuScleFitUtils::genMuscleFitPair
static std::vector< std::pair< MuScleFitMuon, MuScleFitMuon > > genMuscleFitPair
Definition: MuScleFitUtils.h:235
pat::Muon::globalTrack
reco::TrackRef globalTrack() const override
reference to Track reconstructed in both tracked and muon detector (reimplemented from reco::Muon)
Definition: Muon.h:80
MuScleFit::puInfoSrc_
edm::InputTag puInfoSrc_
Definition: MuScleFit.cc:307
MuScleFit::genParticlesName_
std::string genParticlesName_
Definition: MuScleFit.cc:291
MuScleFitUtils::oldNormalization_
static double oldNormalization_
Definition: MuScleFitUtils.h:244
MuScleFitUtils::parBias
static std::vector< double > parBias
Definition: MuScleFitUtils.h:191
MuScleFitUtils::scaleFunctionForVec
static scaleFunctionBase< std::vector< double > > * scaleFunctionForVec
Definition: MuScleFitUtils.h:157
MuScleFitUtils::applyBias
static lorentzVector applyBias(const lorentzVector &muon, const int charge)
Definition: MuScleFitUtils.cc:444
HLTConfigProvider
Definition: HLTConfigProvider.h:28
smearFunctionService
smearFunctionBase * smearFunctionService(const int identifier)
Service to build the smearing functor corresponding to the passed identifier.
Definition: Functions.cc:37
MuScleFit::applyBias
void applyBias(reco::Particle::LorentzVector &mu, const int charge)
Apply the bias if needed using the function in MuScleFitUtils.
Definition: MuScleFit.cc:1396
MuScleFitUtils::parCrossSectionFix
static std::vector< int > parCrossSectionFix
Definition: MuScleFitUtils.h:204
MuScleFitUtils::doBackgroundFit
static std::vector< int > doBackgroundFit
Definition: MuScleFitUtils.h:181
MuScleFitPlotter::debug
bool debug
Definition: MuScleFitPlotter.h:55
MuScleFitUtils::ScaleFitType
static int ScaleFitType
Definition: MuScleFitUtils.h:155
relativeConstraints.empty
bool empty
Definition: relativeConstraints.py:46
CrossSectionHandler
Definition: CrossSectionHandler.h:27
edm::TriggerNames
Definition: TriggerNames.h:55
MuScleFitUtils::SmearType
static int SmearType
Definition: MuScleFitUtils.h:147
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
MuScleFitUtils::counter_resprob
static int counter_resprob
Definition: MuScleFitUtils.h:215
Data_TkAlMinBias_Run2018C_PromptReco_v3_cff.maxEvents
maxEvents
Definition: Data_TkAlMinBias_Run2018C_PromptReco_v3_cff.py:3
MuScleFitPlotter
Definition: MuScleFitPlotter.h:27
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
MuScleFitUtils::parScaleMin
static std::vector< double > parScaleMin
Definition: MuScleFitUtils.h:198
pat::Muon::muonID
bool muonID(const std::string &name) const
scaleFunctionService
scaleFunctionBase< double * > * scaleFunctionService(const int identifier)
Service to build the scale functor corresponding to the passed identifier.
Definition: Functions.cc:3
HltComparatorCreateWorkflow.hltConfig
hltConfig
Definition: HltComparatorCreateWorkflow.py:161
MuScleFitUtils::doScaleFit
static std::vector< int > doScaleFit
Definition: MuScleFitUtils.h:179
CSCSkim_cfi.rootFileName
rootFileName
Definition: CSCSkim_cfi.py:9
L1TStage2uGTEmulatorClient_cff.BX
BX
Definition: L1TStage2uGTEmulatorClient_cff.py:9
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
RootTreeHandler::readTree
void readTree(const int maxEvents, const TString &fileName, MuonPairVector *savedPair, const int muonType, std::vector< std::pair< unsigned int, unsigned long long > > *evtRun, MuonPairVector *genPair=nullptr)
Definition: RootTreeHandler.h:86
Pi
const double Pi
Definition: CosmicMuonParameters.h:18
MuScleFitUtils::parScaleStep
static std::vector< double > parScaleStep
Definition: MuScleFitUtils.h:197
MuScleFit::checkParameters
void checkParameters()
Definition: MuScleFit.cc:1406
MuScleFit::endOfFastLoop
virtual void endOfFastLoop(const unsigned int iLoop)
Definition: MuScleFit.cc:747
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
MuScleFit::plotter
MuScleFitPlotter * plotter
Definition: MuScleFit.cc:279
MuScleFit::fastLoop
bool fastLoop
Definition: MuScleFit.cc:277
MuScleFitUtils::loopCounter
static unsigned int loopCounter
Definition: MuScleFitUtils.h:145
MuScleFitBase::mapHisto_
std::map< std::string, Histograms * > mapHisto_
The map of histograms.
Definition: MuScleFitBase.h:77
beamvalidation.exit
def exit(msg="")
Definition: beamvalidation.py:53
MuScleFit::compareToSimTracks_
bool compareToSimTracks_
Definition: MuScleFit.cc:288
MuScleFit::vertexSrc_
edm::InputTag vertexSrc_
Definition: MuScleFit.cc:308
MuScleFit::inputRootTreeFileName_
std::string inputRootTreeFileName_
Definition: MuScleFit.cc:294
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
pat::Muon::innerTrack
reco::TrackRef innerTrack() const override
reference to Track reconstructed in the tracker only (reimplemented from reco::Muon)
Definition: Muon.h:72
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
event
Definition: event.py:1
MuScleFitUtils::sherpa_
static bool sherpa_
Definition: MuScleFitUtils.h:248
MuScleFit::checkDeltaR
bool checkDeltaR(reco::Particle::LorentzVector &genMu, reco::Particle::LorentzVector &recMu)
Check if two lorentzVector are near in deltaR.
Definition: MuScleFit.cc:1355
MuScleFitUtils::parResolStep
static std::vector< double > parResolStep
Definition: MuScleFitUtils.h:193
MuScleFitUtils::resolutionFunction
static resolutionFunctionBase< double * > * resolutionFunction
Definition: MuScleFitUtils.h:153
MuScleFitUtils::MuonType
static int MuonType
Definition: MuScleFitUtils.h:223
TtFullHadEvtBuilder_cfi.prob
prob
Definition: TtFullHadEvtBuilder_cfi.py:33
edm::InputTag
Definition: InputTag.h:15
MuScleFit::duringFastLoop
virtual void duringFastLoop()
Definition: MuScleFit.cc:1080
MuScleFitUtils::simPair
static std::vector< std::pair< lorentzVector, lorentzVector > > simPair
Definition: MuScleFitUtils.h:236
weight
Definition: weight.py:1
MuScleFitUtils::goodmuon
static int goodmuon
Definition: MuScleFitUtils.h:214
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
MuScleFitUtils::backgroundHandler
static BackgroundHandler * backgroundHandler
Definition: MuScleFitUtils.h:175
MuScleFitUtils::minimizeLikelihood
static void minimizeLikelihood()
Definition: MuScleFitUtils.cc:1197
MuScleFit::iev
int iev
Definition: MuScleFit.cc:285
MuScleFitUtils::maxMuonEtaSecondRange_
static double maxMuonEtaSecondRange_
Definition: MuScleFitUtils.h:264
MuScleFitUtils::doResolFit
static std::vector< int > doResolFit
Definition: MuScleFitUtils.h:178
MuScleFitBase::writeHistoMap
void writeHistoMap(const unsigned int iLoop)
Save the histograms map to file.
Definition: MuScleFitBase.cc:150
GenEventInfoProduct::weight
double weight() const
Definition: GenEventInfoProduct.h:35
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
MuScleFit::triggerPath_
std::vector< std::string > triggerPath_
Definition: MuScleFit.cc:302
MuScleFitUtils::massProb
static double massProb(const double &mass, const double &rapidity, const int ires, const double &massResol)
Definition: MuScleFitUtils.cc:2208
MuScleFit::loopCounter
unsigned int loopCounter
Definition: MuScleFit.cc:275
Generated for CMSSW Reference Manual by doxygen 1.8.16