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 edm::EDConsumerBase

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
 
void esPrefetchAsync (WaitingTaskHolder iTask, EventSetupImpl const &iImpl, Transition iTrans, ServiceToken const &iToken) const
 
virtual std::set< eventsetup::EventSetupRecordKey > modifyingRecords () const
 
EDLooperBase & operator= (EDLooperBase const &)=delete
 
void prefetchAsync (WaitingTaskHolder iTask, ServiceToken const &token, Transition iTrans, Principal const &iPrincipal, EventSetupImpl const &iImpl) const
 
void prepareForNextLoop (eventsetup::EventSetupProvider *esp)
 
void setActionTable (ExceptionToActionTable const *actionTable)
 
void setModuleChanger (ModuleChanger *)
 
 ~EDLooperBase () noexcept(false) override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase &&)=default
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
std::vector< ESProxyIndex > const & esGetTokenIndicesVector (edm::Transition iTrans) const
 
std::vector< ESRecordIndex > const & esGetTokenRecordIndicesVector (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () 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 Member Functions inherited from edm::EDConsumerBase
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B > consumes (edm::InputTag tag) noexcept
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<Transition Tr = Transition::Event>
constexpr auto esConsumes () noexcept
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<Transition Tr = Transition::Event>
auto esConsumes (ESInputTag tag) noexcept
 
template<Transition Tr = Transition::Event>
ESGetTokenGeneric esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
 Used with EventSetupRecord::doGet. More...
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 

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 }
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- 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_
 
int theCompressionSettings_
 
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 185 of file MuScleFit.cc.

Constructor & Destructor Documentation

◆ MuScleFit()

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

Definition at line 373 of file MuScleFit.cc.

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

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, cmssw_cycle_finder::G, genParticlesName_, MuScleFitUtils::goodmuon, mps_fire::i, inputRootTreeFileName_, HLT_FULL_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, MuScleFitBase::theMuonLabel_, MuScleFitBase::theMuonType_, triggerPath_, triggerResultsLabel_, triggerResultsProcess_, MuScleFitUtils::useProbsFile_, vertexSrc_, and MuScleFitUtils::x.

◆ ~MuScleFit()

MuScleFit::~MuScleFit ( )
override

Definition at line 603 of file MuScleFit.cc.

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

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 1403 of file MuScleFit.cc.

1403  {
1404  if (MuScleFitUtils::BiasType > 0) {
1405  mu = MuScleFitUtils::applyBias(mu, charge);
1406  if (debug_ > 0)
1407  std::cout << "Muon #" << MuScleFitUtils::goodmuon << ": after bias Pt = " << mu.Pt() << std::endl;
1408  }
1409 }

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 1395 of file MuScleFit.cc.

1395  {
1396  if (MuScleFitUtils::SmearType > 0) {
1397  mu = MuScleFitUtils::applySmearing(mu);
1398  if (debug_ > 0)
1399  std::cout << "Muon #" << MuScleFitUtils::goodmuon << ": after smearing Pt = " << mu.Pt() << std::endl;
1400  }
1401 }

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 639 of file MuScleFit.cc.

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

References gather_cfg::cout, MuScleFitPlotter::debug, MuScleFitBase::debug_, mps_fire::i, maxLoopNumber, plotter, MuScleFitBase::readProbabilityDistributionsFromFile(), CSCSkim_cfi::rootFileName, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, MuScleFitBase::theCompressionSettings_, 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 1362 of file MuScleFit.cc.

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

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 1413 of file MuScleFit.cc.

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

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 1086 of file MuScleFit.cc.

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

References CrossSectionHandler::addParameters(), MuScleFitUtils::applyScale(), checkDeltaR(), compareToSimTracks_, MuScleFitUtils::computeWeight(), gather_cfg::cout, MuScleFitUtils::crossSectionHandler, MuScleFitBase::debug_, MuScleFitUtils::debugMassResol_, MuScleFitUtils::doScaleFit, HLT_FULL_cff::eta1, HLT_FULL_cff::eta2, fillComparisonHistograms(), 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_FULL_cff::pt1, HLT_FULL_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 788 of file MuScleFit.cc.

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

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 753 of file MuScleFit.cc.

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

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 675 of file MuScleFit.cc.

675  {
676  if (debug_ > 0)
677  std::cout << "[MuScleFit]: endOfJob" << std::endl;
678 }

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 709 of file MuScleFit.cc.

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

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 1377 of file MuScleFit.cc.

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

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 316 of file MuScleFit.cc.

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

References applyBias(), applySmearing(), gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::goodmuon, MuScleFitUtils::mMu2, amptDefaultParameters_cff::mu, HLT_FULL_cff::muon, PDWG_BPHSkim_cff::muons, mathSSE::sqrt(), HLT_FULL_cff::track, and 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 863 of file MuScleFit.cc.

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

References L1TStage2uGTEmulatorClient_cff::BX, gather_cfg::cout, MuScleFitBase::debug_, MuScleFitUtils::findBestRecoRes(), 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_, AlignmentTracksFromVertexSelector_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 969 of file MuScleFit.cc.

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

References applyBias(), applySmearing(), MuScleFitUtils::BiasType, gather_cfg::cout, SiPixelRawToDigiRegional_cfi::deltaPhi, MuScleFitUtils::deltaPhi(), MuScleFitUtils::deltaPhiMaxCut_, MuScleFitUtils::deltaPhiMinCut_, HLT_FULL_cff::eta1, HLT_FULL_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_FULL_cff::pt1, HLT_FULL_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 1509 of file MuScleFit.cc.

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

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

◆ selTrackerMuon()

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

Definition at line 1524 of file MuScleFit.cc.

1524  {
1525  reco::TrackRef iTrack = aMuon->innerTrack();
1526  const reco::HitPattern& p = iTrack->hitPattern();
1527 
1528  return ( //isMuonInAccept(aMuon) // no acceptance cuts!
1529  iTrack->found() > 11 && iTrack->chi2() / iTrack->ndof() < 4.0 && aMuon->muonID("TrackerMuonArbitrated") &&
1530  aMuon->muonID("TMLastStationAngTight") && p.pixelLayersWithMeasurement() > 1 &&
1531  fabs(iTrack->dxy()) < 3.0 && //should be done w.r.t. PV!
1532  fabs(iTrack->dz()) < 15.0); //should be done w.r.t. PV!
1533 }

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 682 of file MuScleFit.cc.

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

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 352 of file MuScleFit.cc.

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

References MuScleFitBase::theMuonType_, and tracks.

Member Data Documentation

◆ compareToSimTracks_

bool MuScleFit::compareToSimTracks_
protected

Definition at line 290 of file MuScleFit.cc.

Referenced by duringFastLoop(), and MuScleFit().

◆ fastLoop

bool MuScleFit::fastLoop
protected

Definition at line 279 of file MuScleFit.cc.

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

◆ genParticlesName_

std::string MuScleFit::genParticlesName_
protected

Definition at line 293 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ iev

int MuScleFit::iev
protected

Definition at line 287 of file MuScleFit.cc.

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

◆ ifGenPart

bool MuScleFit::ifGenPart
protected

Definition at line 267 of file MuScleFit.cc.

◆ ifHepMC

bool MuScleFit::ifHepMC
protected

Definition at line 266 of file MuScleFit.cc.

◆ inputRootTreeFileName_

std::string MuScleFit::inputRootTreeFileName_
protected

Definition at line 296 of file MuScleFit.cc.

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

◆ loopCounter

unsigned int MuScleFit::loopCounter
protected

Definition at line 277 of file MuScleFit.cc.

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

◆ maxEventsFromRootTree_

int MuScleFit::maxEventsFromRootTree_
protected

Definition at line 300 of file MuScleFit.cc.

Referenced by endOfLoop(), and MuScleFit().

◆ maxLoopNumber

unsigned int MuScleFit::maxLoopNumber
protected

Definition at line 276 of file MuScleFit.cc.

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

◆ maxResMass_hwindow

double MuScleFit::maxResMass_hwindow[6]
protected

Definition at line 272 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ minResMass_hwindow

double MuScleFit::minResMass_hwindow[6]
protected

Definition at line 271 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ muonSelector_

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

Definition at line 312 of file MuScleFit.cc.

Referenced by MuScleFit(), and selectMuons().

◆ negateTrigger_

bool MuScleFit::negateTrigger_
protected

Definition at line 305 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ numberOfEwkZ

int MuScleFit::numberOfEwkZ
protected

Definition at line 264 of file MuScleFit.cc.

◆ numberOfSimMuons

int MuScleFit::numberOfSimMuons
protected

Definition at line 262 of file MuScleFit.cc.

◆ numberOfSimTracks

int MuScleFit::numberOfSimTracks
protected

Definition at line 261 of file MuScleFit.cc.

◆ numberOfSimVertices

int MuScleFit::numberOfSimVertices
protected

Definition at line 263 of file MuScleFit.cc.

◆ outputRootTreeFileName_

std::string MuScleFit::outputRootTreeFileName_
protected

Definition at line 298 of file MuScleFit.cc.

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

◆ PATmuons_

bool MuScleFit::PATmuons_
protected

Definition at line 292 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ plotter

MuScleFitPlotter* MuScleFit::plotter
protected

Definition at line 281 of file MuScleFit.cc.

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

◆ puInfoSrc_

edm::InputTag MuScleFit::puInfoSrc_
protected

Definition at line 309 of file MuScleFit.cc.

Referenced by MuScleFit(), and selectMuons().

◆ recMu1

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

Definition at line 285 of file MuScleFit.cc.

Referenced by duringFastLoop(), and selectMuons().

◆ recMu2

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

Definition at line 285 of file MuScleFit.cc.

Referenced by duringFastLoop(), and selectMuons().

◆ recMuScleMu1

MuScleFitMuon MuScleFit::recMuScleMu1
protected

Definition at line 286 of file MuScleFit.cc.

Referenced by selectMuons().

◆ recMuScleMu2

MuScleFitMuon MuScleFit::recMuScleMu2
protected

Definition at line 286 of file MuScleFit.cc.

Referenced by selectMuons().

◆ saveAllToTree_

bool MuScleFit::saveAllToTree_
protected

Definition at line 306 of file MuScleFit.cc.

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

◆ simTracksCollection_

edm::InputTag MuScleFit::simTracksCollection_
protected

Definition at line 291 of file MuScleFit.cc.

Referenced by MuScleFit().

◆ theService

MuonServiceProxy* MuScleFit::theService
protected

Definition at line 257 of file MuScleFit.cc.

◆ totalEvents_

int MuScleFit::totalEvents_
protected

Definition at line 288 of file MuScleFit.cc.

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

◆ triggerPath_

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

Definition at line 304 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ triggerResultsLabel_

std::string MuScleFit::triggerResultsLabel_
protected

Definition at line 302 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ triggerResultsProcess_

std::string MuScleFit::triggerResultsProcess_
protected

Definition at line 303 of file MuScleFit.cc.

Referenced by duringLoop(), and MuScleFit().

◆ vertexSrc_

edm::InputTag MuScleFit::vertexSrc_
protected

Definition at line 310 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:82
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:306
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:428
MuScleFitUtils::smearFunction
static smearFunctionBase * smearFunction
Definition: MuScleFitUtils.h:148
MuScleFitUtils::parResolMin
static std::vector< double > parResolMin
Definition: MuScleFitUtils.h:194
RootTreeHandler
Definition: RootTreeHandler.h:24
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11724
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:1377
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:84
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:288
mps_merge.weight
weight
Definition: mps_merge.py:88
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
MuScleFitUtils::mMu2
static const double mMu2
Definition: MuScleFitUtils.h:139
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
MuScleFitUtils::crossSectionHandler
static CrossSectionHandler * crossSectionHandler
Definition: MuScleFitUtils.h:171
triggerResults
static const std::string triggerResults
Definition: EdmProvDump.cc:45
MuScleFitUtils::MuonTypeForCheckMassWindow
static int MuonTypeForCheckMassWindow
Definition: MuScleFitUtils.h:224
MuScleFit::negateTrigger_
bool negateTrigger_
Definition: MuScleFit.cc:305
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
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
vec2
std::vector< vec1 > vec2
Definition: HCALResponse.h:16
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:863
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:300
AlignmentTracksFromVertexSelector_cfi.vertices
vertices
Definition: AlignmentTracksFromVertexSelector_cfi.py:5
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:285
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:286
reco::HitPattern
Definition: HitPattern.h:147
MuScleFitBase::theFiles_
std::vector< TFile * > theFiles_
The files were the histograms are saved.
Definition: MuScleFitBase.h:76
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
MuScleFit::simTracksCollection_
edm::InputTag simTracksCollection_
Definition: MuScleFit.cc:291
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:82
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
HLT_FULL_cff.muon
muon
Definition: HLT_FULL_cff.py:11725
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
HLT_FULL_cff.eta2
eta2
Definition: HLT_FULL_cff.py:9551
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:285
MuScleFitUtils::deltaPhiMinCut_
static double deltaPhiMinCut_
Definition: MuScleFitUtils.h:265
HLT_FULL_cff.pt1
pt1
Definition: HLT_FULL_cff.py:9893
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:682
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:1395
MuScleFitUtils::ResolFitType
static int ResolFitType
Definition: MuScleFitUtils.h:152
MuScleFitBase::theMuonLabel_
edm::InputTag theMuonLabel_
Definition: MuScleFitBase.h:48
MuScleFit::maxLoopNumber
unsigned int maxLoopNumber
Definition: MuScleFit.cc:276
first
auto first
Definition: CAHitNtupletGeneratorKernelsImpl.h:125
MuScleFit::maxResMass_hwindow
double maxResMass_hwindow[6]
Definition: MuScleFit.cc:272
MuScleFitUtils::parScale
static std::vector< double > parScale
Definition: MuScleFitUtils.h:196
MuScleFitUtils::resolutionFunctionForVec
static resolutionFunctionBase< std::vector< double > > * resolutionFunctionForVec
Definition: MuScleFitUtils.h:154
MuScleFitBase::theRootFileName_
std::string theRootFileName_
Definition: MuScleFitBase.h:50
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
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:639
MuScleFit::triggerResultsLabel_
std::string triggerResultsLabel_
Definition: MuScleFit.cc:302
HLT_FULL_cff.eta1
eta1
Definition: HLT_FULL_cff.py:9550
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:292
MuScleFitBase::theMuonType_
int theMuonType_
Definition: MuScleFitBase.h:47
MuScleFitUtils::debug
static int debug
Definition: MuScleFitUtils.h:130
MuScleFitUtils::parScaleMax
static std::vector< double > parScaleMax
Definition: MuScleFitUtils.h:199
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
MuScleFit::minResMass_hwindow
double minResMass_hwindow[6]
Definition: MuScleFit.cc:271
lorentzVector
reco::Particle::LorentzVector lorentzVector
Definition: GenMuonPair.h:9
MuScleFitUtils::iev_
static int iev_
Definition: MuScleFitUtils.h:253
tracks
const uint32_t *__restrict__ const HitContainer *__restrict__ TkSoA *__restrict__ tracks
Definition: CAHitNtupletGeneratorKernelsImpl.h:176
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:312
MuScleFit::outputRootTreeFileName_
std::string outputRootTreeFileName_
Definition: MuScleFit.cc:298
MuScleFitUtils::biasFunction
static scaleFunctionBase< std::vector< double > > * biasFunction
Definition: MuScleFitUtils.h:151
submitPVResolutionJobs.q
q
Definition: submitPVResolutionJobs.py:84
MuScleFitBase::debug_
int debug_
Definition: MuScleFitBase.h:53
MuScleFit::recMuScleMu2
MuScleFitMuon recMuScleMu2
Definition: MuScleFit.cc:286
edm::EDLooperBase::kContinue
Definition: EDLooperBase.h:82
HLT_FULL_cff.pt2
pt2
Definition: HLT_FULL_cff.py:9895
MuScleFitUtils::parResolFix
static std::vector< int > parResolFix
Definition: MuScleFitUtils.h:202
MuScleFitBase::theGenInfoRootFileName_
std::string theGenInfoRootFileName_
Definition: MuScleFitBase.h:51
MuScleFitUtils::parBgr
static std::vector< double > parBgr
Definition: MuScleFitUtils.h:201
MuScleFit::triggerResultsProcess_
std::string triggerResultsProcess_
Definition: MuScleFit.cc:303
MuScleFitEvent
Definition: Event.h:6
MuScleFitUtils::maxMuonPt_
static double maxMuonPt_
Definition: MuScleFitUtils.h:260
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
MuScleFitBase::clearHistoMap
void clearHistoMap()
Clean the histograms map.
Definition: MuScleFitBase.cc:143
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:309
MuScleFitBase::theCompressionSettings_
int theCompressionSettings_
Definition: MuScleFitBase.h:49
MuScleFit::genParticlesName_
std::string genParticlesName_
Definition: MuScleFit.cc:293
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:29
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:1403
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:1413
MuScleFit::endOfFastLoop
virtual void endOfFastLoop(const unsigned int iLoop)
Definition: MuScleFit.cc:753
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
MuScleFit::plotter
MuScleFitPlotter * plotter
Definition: MuScleFit.cc:281
MuScleFit::fastLoop
bool fastLoop
Definition: MuScleFit.cc:279
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:79
beamvalidation.exit
def exit(msg="")
Definition: beamvalidation.py:52
MuScleFit::compareToSimTracks_
bool compareToSimTracks_
Definition: MuScleFit.cc:290
MuScleFit::vertexSrc_
edm::InputTag vertexSrc_
Definition: MuScleFit.cc:310
MuScleFit::inputRootTreeFileName_
std::string inputRootTreeFileName_
Definition: MuScleFit.cc:296
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:1362
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
cmssw_cycle_finder.G
G
Definition: cmssw_cycle_finder.py:154
TtFullHadEvtBuilder_cfi.prob
prob
Definition: TtFullHadEvtBuilder_cfi.py:33
edm::InputTag
Definition: InputTag.h:15
MuScleFit::duringFastLoop
virtual void duringFastLoop()
Definition: MuScleFit.cc:1086
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:287
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
MuScleFit::triggerPath_
std::vector< std::string > triggerPath_
Definition: MuScleFit.cc:304
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:277
Generated for CMSSW Reference Manual by doxygen 1.8.16