ATLAS Offline Software
Classes | Public Member Functions | Public Attributes | Protected Member Functions | Private Member Functions | Private Attributes | List of all members
DiTauMassTools::MissingMassCalculatorV2 Class Reference

#include <MissingMassCalculatorV2.h>

Collaboration diagram for DiTauMassTools::MissingMassCalculatorV2:

Classes

struct  DitauStuff
 

Public Member Functions

 ~MissingMassCalculatorV2 ()
 
 MissingMassCalculatorV2 (MMCCalibrationSetV2::e aset, std::string m_paramFilePath)
 
int RunMissingMassCalculator (const xAOD::IParticle *part1, const xAOD::IParticle *part2, const xAOD::MissingET *met, const int &njets)
 
void FinalizeSettings (const xAOD::IParticle *part1, const xAOD::IParticle *part2, const xAOD::MissingET *met, const int &njets)
 
void SetNiterFit1 (const int val)
 
void SetNiterFit2 (const int val)
 
void SetNiterFit3 (const int val)
 
void SetNiterRandom (const int val)
 
void SetNsucStop (const int val)
 
void SetRMSStop (const int val)
 
void SetMeanbinStop (const double val)
 
void SetRndmSeedAltering (const int val)
 
void SetdTheta3d_binMax (const double val)
 
void SetdTheta3d_binMin (const double val)
 
void SetEventNumber (const int eventNumber)
 
void SetJERsyst (const int val)
 
void SetApplyMassScale (const int val)
 
void SetMnuScanRange (const double val)
 
void SetProposalTryMEt (const double val)
 
void SetProposalTryPhi (const double val)
 
void SetProposalTryMnu (const double val)
 
void SetProposalTryEtau (const double val)
 
void SetUseEfficiencyRecovery (const bool val)
 
bool GetUseEfficiencyRecovery () const
 
int GetNiterFit1 () const
 
int GetNiterFit2 () const
 
int GetNiterFit3 () const
 
int GetNiterRandom () const
 
int GetNsucStop () const
 
int GetRMSStop () const
 
double GetMeanbinStop () const
 
int GetRndmSeedAltering () const
 
int GetMarkovCountDuplicate () const
 
int GetMarkovNRejectNoSol () const
 
int GetMarkovNRejectMetropolis () const
 
int GetMarkovNAccept () const
 
int GetMarkovNFullscan () const
 
double GetProposalTryMEt () const
 
double GetProposalTryPhi () const
 
double GetProposalTryMnu () const
 
double GetProposalTryEtau () const
 
void SetNsigmaMETscan_ll (const double val)
 
void SetNsigmaMETscan_lh (const double val)
 
void SetNsigmaMETscan_hh (const double val)
 
void SetNsigmaMETscan (const double val)
 
void SetUseFloatStopping (const bool val)
 
void SetBeamEnergy (const double val)
 
void SetLFVLeplepRefit (const bool val)
 
double GetmMaxError () const
 
double GetmMeanError () const
 
double GetmInvWidth2Error () const
 
int GetNNoSol () const
 
int GetNMetroReject () const
 
int GetNSol () const
 
int StandardCollApprox (const TLorentzVector &tau_vec1, const TLorentzVector &tau_vec2, const TVector2 &met_vec, double &Mrec)
 
Double_t maxFitting (Double_t *x, Double_t *par)
 
double maxFromHist (TH1F *theHist, std::vector< double > &histInfo, const MaxHistStrategyV2::e maxHistStrategy=MaxHistStrategyV2::FIT, const int winHalfWidth=2, bool debug=false)
 
double maxFromHist (const std::shared_ptr< TH1F > &theHist, std::vector< double > &histInfo, const MaxHistStrategyV2::e maxHistStrategy=MaxHistStrategyV2::FIT, const int winHalfWidth=2, bool debug=false)
 
double dTheta3DLimit (const int &tau_type, const int &limit_code, const double &P_tau)
 

Public Attributes

MissingMassInput preparedInput
 
MissingMassOutput OutputInfo
 
MissingMassProb * Prob
 
TVector2 metvec_tmp
 

Protected Member Functions

int CheckSolutions (TLorentzVector nu_vec, TLorentzVector vis_vec, int decayType)
 
int TailCleanUp (const TLorentzVector &vis1, const TLorentzVector &nu1, const TLorentzVector &vis2, const TLorentzVector &nu2, const double &mmc_mass, const double &vis_mass, const double &eff_mass, const double &dphiTT)
 
int refineSolutions (const double &M_nu1, const double &M_nu2, const int nsol1, const int nsol2, const double &Mvis, const double &Meff)
 
void handleSolutions ()
 
double MassScale (int method, double mass, const int &tau_type1, const int &tau_type2)
 
int DitauMassCalculatorV9walk ()
 
int DitauMassCalculatorV9lfv (bool refit)
 
int probCalculatorV9fast (const double &phi1, const double &phi2, const double &M_nu1, const double &M_nu2)
 
void SpaceWalkerInit ()
 
bool SpaceWalkerWalk ()
 
bool precomputeCache ()
 
bool checkMEtInRange ()
 
bool checkAllParamInRange ()
 

Private Member Functions

void ClearDitauStuff (DitauStuff &fStuff)
 
void DoOutputInfo ()
 
void PrintOtherInput ()
 
void PrintResults ()
 
int NuPsolution (TVector2 met_vec, double theta1, double phi1, double theta2, double phi2, double &P1, double &P2)
 
int NuPsolutionV3 (const double &mNu1, const double &mNu2, const double &phi1, const double &phi2, int &nsol1, int &nsol2)
 
int NuPsolutionLFV (const TVector2 &met_vec, const TLorentzVector &tau, const double &m_nu, std::vector< TLorentzVector > &nu_vec)
 

Private Attributes

TRandom2 m_randomGen
 
MMCCalibrationSetV2::e m_mmcCalibrationSet
 
bool m_fUseEfficiencyRecovery
 
bool m_fUseFloatStopping
 
int m_nsolmax
 
int m_nsolfinalmax
 
int m_niterRandomLocal
 
int m_nsucStop
 
int m_rmsStop
 
double m_meanbinStop
 
std::vector< TLorentzVector > m_nuvecsol1
 
std::vector< TLorentzVector > m_nuvecsol2
 
std::vector< TLorentzVector > m_tauvecsol1
 
std::vector< TLorentzVector > m_tauvecsol2
 
std::vector< double > m_tauvecprob1
 
std::vector< double > m_tauvecprob2
 
std::vector< TLorentzVector > m_nuvec1_tmp
 
std::vector< TLorentzVector > m_nuvec2_tmp
 
TLorentzVector m_tautau_tmp
 
bool m_debugThisIteration
 
bool m_lfvLeplepRefit
 
int m_nCallprobCalculatorV9fast
 
double m_nsigma_METscan
 
double m_nsigma_METscan2
 
double m_nsigma_METscan_ll
 
double m_nsigma_METscan_lh
 
double m_nsigma_METscan_hh
 
double m_nsigma_METscan_lfv_ll
 
double m_nsigma_METscan_lfv_lh
 
double m_beamEnergy
 
int m_iter1
 
int m_iter2
 
int m_iter3
 
int m_iter4
 
int m_iter5
 
int m_iang1low
 
int m_iang1high
 
int m_iang2low
 
int m_iang2high
 
int m_iterTheta3d
 
double m_prob_tmp
 
double m_totalProbSum
 
double m_mtautauSum
 
int m_eventNumber
 
int m_seed
 
int m_iter0
 
int m_iterNuPV3
 
int m_testptn1
 
int m_testptn2
 
int m_testdiscri1
 
int m_testdiscri2
 
int m_nosol1
 
int m_nosol2
 
int m_iterNsuc
 
bool m_switch1
 
bool m_switch2
 
bool m_meanbinToBeEvaluated
 
int m_markovCountDuplicate
 
int m_markovNFullScan
 
int m_markovNRejectNoSol
 
int m_markovNRejectMetropolis
 
int m_markovNAccept
 
double m_PrintmMaxError
 
double m_PrintmMeanError
 
double m_PrintmInvWidth2Error
 
double m_proposalTryMEt
 
double m_ProposalTryPhi
 
double m_ProposalTryMnu
 
double m_ProposalTryEtau
 
double m_mTau
 
double m_mTau2
 
double m_MEtL
 
double m_MEtP
 
double m_Phi1
 
double m_Phi2
 
double m_Mnu1
 
double m_Mnu2
 
double m_eTau1
 
double m_eTau2
 
double m_eTau10
 
double m_eTau20
 
double m_MEtL0
 
double m_MEtP0
 
double m_Phi10
 
double m_Phi20
 
double m_Mnu10
 
double m_Mnu20
 
double m_MEtLMin
 
double m_MEtPMin
 
double m_Phi1Min
 
double m_Phi2Min
 
double m_Mnu1Min
 
double m_Mnu2Min
 
double m_MEtLMax
 
double m_MEtPMax
 
double m_Phi1Max
 
double m_Phi2Max
 
double m_Mnu1Max
 
double m_Mnu2Max
 
double m_MEtLStep
 
double m_MEtPStep
 
double m_Phi1Step
 
double m_Phi2Step
 
double m_Mnu1Step
 
double m_Mnu2Step
 
double m_MEtLRange
 
double m_MEtPRange
 
double m_Phi1Range
 
double m_Phi2Range
 
double m_Mnu1Range
 
double m_Mnu2Range
 
double m_MEtProposal
 
double m_PhiProposal
 
double m_MnuProposal
 
double m_metCovPhiCos
 
double m_metCovPhiSin
 
double m_eTau1Proposal
 
double m_eTau2Proposal
 
double m_eTau1Min
 
double m_eTau1Max
 
double m_eTau1Range
 
double m_eTau2Min
 
double m_eTau2Max
 
double m_eTau2Range
 
bool m_fullParamSpaceScan
 
bool m_Mnu1Exclude
 
int m_nsolOld
 
std::vector< double > m_probFinalSolOldVec
 
std::vector< double > m_mtautauFinalSolOldVec
 
std::vector< TLorentzVector > m_nu1FinalSolOldVec
 
std::vector< TLorentzVector > m_nu2FinalSolOldVec
 
int m_nsol
 
std::vector< double > m_probFinalSolVec
 
std::vector< double > m_mtautauFinalSolVec
 
std::vector< TLorentzVector > m_nu1FinalSolVec
 
std::vector< TLorentzVector > m_nu2FinalSolVec
 
double m_Mnu1ExcludeMin
 
double m_Mnu1ExcludeMax
 
double m_Mnu1ExcludeRange
 
double m_Mnu1XMin
 
double m_Mnu1XMax
 
double m_Mnu1XRange
 
double m_walkWeight
 
double m_cosPhi1
 
double m_cosPhi2
 
double m_sinPhi1
 
double m_sinPhi2
 
bool m_scanMnu1
 
bool m_scanMnu2
 
TLorentzVector m_tauVec1
 
TLorentzVector m_tauVec2
 
double m_tauVec1Phi
 
double m_tauVec2Phi
 
double m_tauVec1M
 
double m_tauVec2M
 
double m_tauVec1Px
 
double m_tauVec1Py
 
double m_tauVec1Pz
 
double m_tauVec2Px
 
double m_tauVec2Py
 
double m_tauVec2Pz
 
double m_tauVec1P
 
double m_tauVec2P
 
double m_tauVec1E
 
double m_tauVec2E
 
double m_m2Nu1
 
double m_m2Nu2
 
double m_ET2v1
 
double m_ET2v2
 
double m_E2v1
 
double m_E2v2
 
double m_Ev2
 
double m_Ev1
 
double m_Mvis
 
double m_Meff
 
bool m_reRunWithBestMET
 
std::shared_ptr< TH1F > m_fMfit_all
 
std::shared_ptr< TH1F > m_fMEtP_all
 
std::shared_ptr< TH1F > m_fMEtL_all
 
std::shared_ptr< TH1F > m_fMnu1_all
 
std::shared_ptr< TH1F > m_fMnu2_all
 
std::shared_ptr< TH1F > m_fPhi1_all
 
std::shared_ptr< TH1F > m_fPhi2_all
 
std::shared_ptr< TGraph > m_fMfit_allGraph
 
std::shared_ptr< TH1F > m_fMfit_allNoWeight
 
std::shared_ptr< TH1F > m_fPXfit1
 
std::shared_ptr< TH1F > m_fPYfit1
 
std::shared_ptr< TH1F > m_fPZfit1
 
std::shared_ptr< TH1F > m_fPXfit2
 
std::shared_ptr< TH1F > m_fPYfit2
 
std::shared_ptr< TH1F > m_fPZfit2
 
std::shared_ptr< TH1F > m_fMmass_split1
 
std::shared_ptr< TH1F > m_fMEtP_split1
 
std::shared_ptr< TH1F > m_fMEtL_split1
 
std::shared_ptr< TH1F > m_fMnu1_split1
 
std::shared_ptr< TH1F > m_fMnu2_split1
 
std::shared_ptr< TH1F > m_fPhi1_split1
 
std::shared_ptr< TH1F > m_fPhi2_split1
 
std::shared_ptr< TH1F > m_fMmass_split2
 
std::shared_ptr< TH1F > m_fMEtP_split2
 
std::shared_ptr< TH1F > m_fMEtL_split2
 
std::shared_ptr< TH1F > m_fMnu1_split2
 
std::shared_ptr< TH1F > m_fMnu2_split2
 
std::shared_ptr< TH1F > m_fPhi1_split2
 
std::shared_ptr< TH1F > m_fPhi2_split2
 
TF1 * m_fFitting
 
TH1F * m_fPhi1
 
TH1F * m_fPhi2
 
TH1F * m_fMnu1
 
TH1F * m_fMnu2
 
TH1F * m_fMetx
 
TH1F * m_fMety
 
TH1F * m_fTheta3D
 
TH1F * m_fTauProb
 
TLorentzVector m_TLVdummy
 
DitauStuff m_fDitauStuffFit
 
DitauStuff m_fDitauStuffHisto
 
int m_fApplyMassScale
 
int m_niter_fit1
 
int m_niter_fit2
 
int m_niter_fit3
 
int m_NiterRandom
 
int m_NsucStop
 
int m_RMSStop
 
int m_RndmSeedAltering
 
int m_fJERsyst
 
double m_dTheta3d_binMin
 
double m_dTheta3d_binMax
 
double m_dRmax_tau
 
double m_MnuScanRange
 

Detailed Description

Definition at line 45 of file MissingMassCalculatorV2.h.

Constructor & Destructor Documentation

◆ ~MissingMassCalculatorV2()

MissingMassCalculatorV2::~MissingMassCalculatorV2 ( )

Definition at line 262 of file MissingMassCalculatorV2.cxx.

262 { delete Prob; }

◆ MissingMassCalculatorV2()

MissingMassCalculatorV2::MissingMassCalculatorV2 ( MMCCalibrationSetV2::e  aset,
std::string  m_paramFilePath 
)

Definition at line 37 of file MissingMassCalculatorV2.cxx.

39  : m_randomGen(), Prob(new MissingMassProb(aset, m_paramFilePath)) {
40  m_mmcCalibrationSet = aset;
41  preparedInput.m_fUseVerbose = 0;
42  preparedInput.m_beamEnergy = 6500.0; // for now LHC default is sqrt(S)=7 TeV
43  m_niter_fit1 = 20;
44  m_niter_fit2 = 30;
45  m_niter_fit3 = 10;
46  m_NsucStop = -1;
47  m_NiterRandom = -1; // if the user does not set it to positive value,will be set
48  // in SpaceWalkerInit
49  m_niterRandomLocal = -1; // niterandom which is really used
50  // to be used with RMSSTOP NiterRandom=10000000; // number of random
51  // iterations for lh. Multiplied by 10 for ll, divided by 10 for hh (to be
52  // optimised)
53  // RMSStop=200;// Stop criteria depending of rms of histogram
54  m_reRunWithBestMET = false;
55  m_RMSStop = -1; // disable
56 
57  m_RndmSeedAltering = 0; // can be changed to re-compute with different random seed
58  m_dRmax_tau = 0.4; // changed from 0.2
59  m_nsigma_METscan = -1; // number of sigmas for MET scan
60  m_nsigma_METscan_ll = 3.0; // number of sigmas for MET scan
61  m_nsigma_METscan_lh = 3.0; // number of sigmas for MET scan
62  m_nsigma_METscan_hh = 4.0; // number of sigmas for MET scan (4 for hh 2013)
63  m_nsigma_METscan_lfv_ll = 5.0; // number of sigmas for MET scan (LFV leplep)
64  m_nsigma_METscan_lfv_lh = 5.0; // number of sigmas for MET scan (LFV lephad)
65 
66  m_meanbinStop = -1; // meanbin stopping criterion (-1 if not used)
67  m_proposalTryMEt = -1; // loop on METproposal disable // FIXME should be cleaner
68  m_ProposalTryPhi = -1; // loop on Phiproposal disable
69  m_ProposalTryMnu = -1; // loop on MNuProposal disable
70  m_ProposalTryEtau = -1; // loop on ETauProposal disable
71 
72  Prob->SetUseTauProbability(true); // TauProbability is ON by default DRMERGE comment out for now
73  Prob->SetUseMnuProbability(false); // MnuProbability is OFF by default
74  Prob->SetUseDphiLL(false); // added by Tomas Davidek for lep-lep
75  m_dTheta3d_binMin = 0.0025;
76  m_dTheta3d_binMax = 0.02;
77  m_fJERsyst = 0; // no JER systematics by default (+/-1: up/down 1 sigma)
78  preparedInput.m_METresSyst = 0; // no MET resolution systematics by default (+/-1: up/down 1 sigma)
79  m_fApplyMassScale = 0; // don't apply mass scale correction by default
80  preparedInput.m_dataType = 1; // set to "data" by default
81  preparedInput.m_fUseTailCleanup = 1; // cleanup by default for lep-had Moriond 2012 analysis
82  preparedInput.m_fUseDefaults = 0; // use pre-set defaults for various configurations; if set it to 0
83  // if need to study various options
84  m_fUseEfficiencyRecovery = 0; // no re-fit by default
85  m_fUseFloatStopping = 1; // use floating stopping criterion by default
86 
87  preparedInput.m_METScanScheme = 1; // MET-scan scheme: 0- use JER; 1- use simple sumEt & missingHt
88  // for Njet=0 events in (lep-had winter 2012)
89  // MnuScanRange=1.777; // range of M(nunu) scan
90  m_MnuScanRange = 1.5; // better value (sacha)
91  preparedInput.m_LFVmode = -1; // by default consider case of H->mu+tau(->ele)
92  preparedInput.ClearInput();
93 
94  m_nCallprobCalculatorV9fast = 0;
95  m_iterTheta3d = 0;
96  m_debugThisIteration = false;
97  m_lfvLeplepRefit = true;
98 
99  m_nsolmax = 4;
100  m_nsolfinalmax = m_nsolmax * m_nsolmax;
101 
102  m_nuvecsol1.resize(m_nsolmax);
103  m_nuvecsol2.resize(m_nsolmax);
104  m_tauvecsol1.resize(m_nsolmax);
105  m_tauvecsol2.resize(m_nsolmax);
106  m_tauvecprob1.resize(m_nsolmax);
107  m_tauvecprob2.resize(m_nsolmax);
108 
109  m_nsol = 0;
110  m_probFinalSolVec.resize(m_nsolfinalmax);
111  m_mtautauFinalSolVec.resize(m_nsolfinalmax);
112  m_nu1FinalSolVec.resize(m_nsolfinalmax);
113  m_nu2FinalSolVec.resize(m_nsolfinalmax);
114 
115  m_nsolOld = 0;
116  m_probFinalSolOldVec.resize(m_nsolfinalmax);
117  m_mtautauFinalSolOldVec.resize(m_nsolfinalmax);
118  m_nu1FinalSolOldVec.resize(m_nsolfinalmax);
119  m_nu2FinalSolOldVec.resize(m_nsolfinalmax);
120 
121  float hEmax = 3000.0; // maximum energy (GeV)
122  // number of bins
123  int hNbins = 1500; // original 2500 for mass, 10000 for P
124  // choice of hNbins also related to size of window for fitting (see
125  // maxFromHist)
126 
127  //--- define histograms for histogram method
128  //--- upper limits need to be revisied in the future!!! It may be not enough
129  // for some analyses
130 
131  m_fMfit_all = std::make_shared<TH1F>("MMC_h1", "M", hNbins, 0.0,
132  hEmax); // all solutions
133 #ifdef SAVELIKELIHOODHISTO
134  m_fMEtP_all = std::make_shared<TH1F>("MEtP_h1", "M", hNbins, -100.0,
135  100.); // all solutions
136  m_fMEtL_all = std::make_shared<TH1F>("MEtL_h1", "M", hNbins, -100.0,
137  100.); // all solutions
138  m_fMnu1_all = std::make_shared<TH1F>("Mnu1_h1", "M", hNbins, 0.0,
139  hEmax); // all solutions
140  m_fMnu2_all = std::make_shared<TH1F>("Mnu2_h1", "M", hNbins, 0.0,
141  hEmax); // all solutions
142  m_fPhi1_all = std::make_shared<TH1F>("Phi1_h1", "M", hNbins, -10.0,
143  10.); // all solutions
144  m_fPhi2_all = std::make_shared<TH1F>("Phi2_h1", "M", hNbins, -10.0,
145  10.); // all solutions
146  m_fMfit_allGraph = std::make_shared<TGraph>(); // all solutions
147 #endif
148  m_fMfit_all->Sumw2(); // allow proper error bin calculation. Slightly slower but
149  // completely negligible
150  // these histograms are used for the floating stopping criterion
151  if (m_fUseFloatStopping) {
152  m_fMmass_split1 = std::make_shared<TH1F>("mass_h1_1", "M", hNbins, 0.0, hEmax);
153  m_fMEtP_split1 = std::make_shared<TH1F>("MEtP_h1_1", "M", hNbins, -100.0, 100.0);
154  m_fMEtL_split1 = std::make_shared<TH1F>("MEtL_h1_1", "M", hNbins, -100.0, 100.0);
155  m_fMnu1_split1 = std::make_shared<TH1F>("Mnu1_h1_1", "M", hNbins, 0.0, hEmax);
156  m_fMnu2_split1 = std::make_shared<TH1F>("Mnu2_h1_1", "M", hNbins, 0.0, hEmax);
157  m_fPhi1_split1 = std::make_shared<TH1F>("Phi1_h1_1", "M", hNbins, -10.0, 10.0);
158  m_fPhi2_split1 = std::make_shared<TH1F>("Phi2_h1_1", "M", hNbins, -10.0, 10.0);
159  m_fMmass_split2 = std::make_shared<TH1F>("mass_h1_2", "M", hNbins, 0.0, hEmax);
160  m_fMEtP_split2 = std::make_shared<TH1F>("MEtP_h1_2", "M", hNbins, -100.0, 100.0);
161  m_fMEtL_split2 = std::make_shared<TH1F>("MEtL_h1_2", "M", hNbins, -100.0, 100.0);
162  m_fMnu1_split2 = std::make_shared<TH1F>("Mnu1_h1_2", "M", hNbins, 0.0, hEmax);
163  m_fMnu2_split2 = std::make_shared<TH1F>("Mnu2_h1_2", "M", hNbins, 0.0, hEmax);
164  m_fPhi1_split2 = std::make_shared<TH1F>("Phi1_h1_2", "M", hNbins, -10.0, 10.0);
165  m_fPhi2_split2 = std::make_shared<TH1F>("Phi2_h1_2", "M", hNbins, -10.0, 10.0);
166  }
167 #ifdef SAVELIKELIHOODHISTO
168  m_fMEtP_all->Sumw2();
169  m_fMEtL_all->Sumw2();
170  m_fMnu1_all->Sumw2();
171  m_fMnu2_all->Sumw2();
172  m_fPhi1_all->Sumw2();
173  m_fPhi2_all->Sumw2();
174 #endif
175  // these histograms are used for the floating stopping criterion
176  if (m_fUseFloatStopping) {
177  m_fMmass_split1->Sumw2();
178  m_fMEtP_split1->Sumw2();
179  m_fMEtL_split1->Sumw2();
180  m_fMnu1_split1->Sumw2();
181  m_fMnu2_split1->Sumw2();
182  m_fPhi1_split1->Sumw2();
183  m_fPhi2_split1->Sumw2();
184  m_fMmass_split2->Sumw2();
185  m_fMEtP_split2->Sumw2();
186  m_fMEtL_split2->Sumw2();
187  m_fMnu1_split2->Sumw2();
188  m_fMnu2_split2->Sumw2();
189  m_fPhi1_split2->Sumw2();
190  m_fPhi2_split2->Sumw2();
191  }
192 
193  // histogram without weight. useful for debugging. negligibly slow until now
194  m_fMfit_allNoWeight =
195  std::make_shared<TH1F>("MMC_h1NoW", "M no weight", hNbins, 0.0, hEmax); // all solutions
196 
197  m_fPXfit1 = std::make_shared<TH1F>("MMC_h2", "Px1", 4 * hNbins, -hEmax,
198  hEmax); // Px for tau1
199  m_fPYfit1 = std::make_shared<TH1F>("MMC_h3", "Py1", 4 * hNbins, -hEmax,
200  hEmax); // Py for tau1
201  m_fPZfit1 = std::make_shared<TH1F>("MMC_h4", "Pz1", 4 * hNbins, -hEmax,
202  hEmax); // Pz for tau1
203  m_fPXfit2 = std::make_shared<TH1F>("MMC_h5", "Px2", 4 * hNbins, -hEmax,
204  hEmax); // Px for tau2
205  m_fPYfit2 = std::make_shared<TH1F>("MMC_h6", "Py2", 4 * hNbins, -hEmax,
206  hEmax); // Py for tau2
207  m_fPZfit2 = std::make_shared<TH1F>("MMC_h7", "Pz2", 4 * hNbins, -hEmax,
208  hEmax); // Pz for tau2
209 
210  m_fMfit_all->SetDirectory(0);
211 #ifdef SAVELIKELIHOODHISTO
212  m_fMEtP_all->SetDirectory(0);
213  m_fMEtL_all->SetDirectory(0);
214  m_fMnu1_all->SetDirectory(0);
215  m_fMnu2_all->SetDirectory(0);
216  m_fPhi1_all->SetDirectory(0);
217  m_fPhi2_all->SetDirectory(0);
218 #endif
219  m_fMfit_allNoWeight->SetDirectory(0);
220  m_fPXfit1->SetDirectory(0);
221  m_fPYfit1->SetDirectory(0);
222  m_fPZfit1->SetDirectory(0);
223  m_fPXfit2->SetDirectory(0);
224  m_fPYfit2->SetDirectory(0);
225  m_fPZfit2->SetDirectory(0);
226 
227  // these histograms are used for the floating stopping criterion
228  if (m_fUseFloatStopping) {
229  m_fMmass_split1->SetDirectory(0);
230  m_fMEtP_split1->SetDirectory(0);
231  m_fMEtL_split1->SetDirectory(0);
232  m_fMnu1_split1->SetDirectory(0);
233  m_fMnu2_split1->SetDirectory(0);
234  m_fPhi1_split1->SetDirectory(0);
235  m_fPhi2_split1->SetDirectory(0);
236  m_fMmass_split2->SetDirectory(0);
237  m_fMEtP_split2->SetDirectory(0);
238  m_fMEtL_split2->SetDirectory(0);
239  m_fMnu1_split2->SetDirectory(0);
240  m_fMnu2_split2->SetDirectory(0);
241  m_fPhi1_split2->SetDirectory(0);
242  m_fPhi2_split2->SetDirectory(0);
243  }
244 
245  // max hist fitting function
246  m_fFitting =
247  new TF1("MMC_maxFitting", this, &MissingMassCalculatorV2::maxFitting, 0., hEmax, 3);
248  // Sets initial parameter names
249  m_fFitting->SetParNames("Max", "Mean", "InvWidth2");
250 
251  if (preparedInput.m_fUseVerbose == 1) {
252  gDirectory->pwd();
253  gDirectory->ls();
254  }
255 
256  if (preparedInput.m_fUseVerbose == 1) {
257  gDirectory->pwd();
258  gDirectory->ls();
259  }
260 }

Member Function Documentation

◆ checkAllParamInRange()

bool MissingMassCalculatorV2::checkAllParamInRange ( )
inlineprotected

Definition at line 2780 of file MissingMassCalculatorV2.cxx.

2780  {
2781 
2782  if (m_scanMnu1) {
2783  if (m_Mnu1 < m_Mnu1Min)
2784  return false;
2785  if (m_Mnu1 > m_Mnu1Max)
2786  return false;
2787  if (m_Mnu1 > m_mTau - m_tauVec1M)
2788  return false;
2789  }
2790 
2791  if (m_scanMnu2) {
2792  if (m_Mnu2 < m_Mnu2Min)
2793  return false;
2794  if (m_Mnu2 > m_Mnu2Max)
2795  return false;
2796  if (m_Mnu2 > m_mTau - m_tauVec2M)
2797  return false;
2798  }
2799 
2800  // FIXME note that since there is a coupling between Met and tau, should
2801  // rigorously test both together however since the 3 sigma range is just a
2802  // hack, it is probably OK
2803 
2804  if (m_Phi1 < m_Phi1Min)
2805  return false;
2806  if (m_Phi1 > m_Phi1Max)
2807  return false;
2808 
2809  if (m_Phi2 < m_Phi2Min)
2810  return false;
2811  if (m_Phi2 > m_Phi2Max)
2812  return false;
2813 
2814  if (!checkMEtInRange())
2815  return false;
2816 
2817  return true;
2818 }

◆ checkMEtInRange()

bool MissingMassCalculatorV2::checkMEtInRange ( )
inlineprotected

Definition at line 2821 of file MissingMassCalculatorV2.cxx.

2821  {
2822  // check MEt is in allowed range
2823  // range is 3sigma disk ("cutting the corners")
2824  if (std::pow(m_MEtL / preparedInput.m_METsigmaL, 2) +
2825  std::pow(m_MEtP / preparedInput.m_METsigmaP, 2) >
2826  m_nsigma_METscan2) {
2827  return false;
2828  } else {
2829  return true;
2830  }
2831 }

◆ CheckSolutions()

int DiTauMassTools::MissingMassCalculatorV2::CheckSolutions ( TLorentzVector  nu_vec,
TLorentzVector  vis_vec,
int  decayType 
)
inlineprotected

◆ ClearDitauStuff()

void MissingMassCalculatorV2::ClearDitauStuff ( DitauStuff &  fStuff)
private

Definition at line 358 of file MissingMassCalculatorV2.cxx.

358  {
359  fStuff.Mditau_best = 0.0;
360  fStuff.Sign_best = 1.0E6;
361  fStuff.nutau1 = TLorentzVector(0., 0., 0., 0.);
362  fStuff.nutau2 = TLorentzVector(0., 0., 0., 0.);
363  fStuff.vistau1 = TLorentzVector(0., 0., 0., 0.);
364  fStuff.vistau2 = TLorentzVector(0., 0., 0., 0.);
365  fStuff.RMSoverMPV = 0.0;
366 
367  return;
368 }

◆ DitauMassCalculatorV9lfv()

int MissingMassCalculatorV2::DitauMassCalculatorV9lfv ( bool  refit)
inlineprotected

Definition at line 1081 of file MissingMassCalculatorV2.cxx.

1081  {
1082 
1083  // debugThisIteration=false;
1084  m_debugThisIteration = true;
1085 
1086  int fit_code = 0; // 0==bad, 1==good
1087  ClearDitauStuff(m_fDitauStuffFit);
1088  ClearDitauStuff(m_fDitauStuffHisto);
1089  OutputInfo.m_NTrials = 0;
1090  OutputInfo.m_NSuccesses = 0;
1091  OutputInfo.m_AveSolRMS = 0.;
1092 
1093  //------- Settings -------------------------------
1094  int NiterMET = m_niter_fit2; // number of iterations for each MET scan loop
1095  int NiterMnu = m_niter_fit3; // number of iterations for Mnu loop
1096  const double Mtau = 1.777;
1097  double Mnu_binSize = m_MnuScanRange / NiterMnu;
1098 
1099  double METresX = preparedInput.m_METsigmaL; // MET resolution in direction parallel to
1100  // leading jet, for MET scan
1101  double METresY = preparedInput.m_METsigmaP; // MET resolution in direction perpendicular to
1102  // leading jet, for MET scan
1103 
1104  //-------- end of Settings
1105  if (preparedInput.m_tauTypes == TauTypes::ll) { // both tau's are leptonic
1106  m_nsigma_METscan = m_nsigma_METscan_lfv_ll;
1107  } else if (preparedInput.m_tauTypes == TauTypes::lh) { // lep had
1108  m_nsigma_METscan = m_nsigma_METscan_lfv_lh;
1109  }
1110 
1111  double N_METsigma = m_nsigma_METscan; // number of sigmas for MET scan
1112  double METresX_binSize = 2 * N_METsigma * METresX / NiterMET;
1113  double METresY_binSize = 2 * N_METsigma * METresY / NiterMET;
1114 
1115  int solution = 0;
1116 
1117  std::vector<TLorentzVector> nu_vec;
1118 
1119  m_totalProbSum = 0;
1120  m_mtautauSum = 0;
1121 
1122  double metprob = 1.0;
1123  double sign_tmp = 0.0;
1124  double tauprob = 1.0;
1125  double totalProb = 0.0;
1126 
1127  m_prob_tmp = 0.0;
1128 
1129  double met_smear_x = 0.0;
1130  double met_smear_y = 0.0;
1131  double met_smearL = 0.0;
1132  double met_smearP = 0.0;
1133 
1134  double angle1 = 0.0;
1135 
1136  if (m_fMfit_all) {
1137  m_fMfit_all->Reset();
1138  }
1139  if (m_fMfit_allNoWeight) {
1140  m_fMfit_allNoWeight->Reset();
1141  }
1142  if (m_fPXfit1) {
1143  m_fPXfit1->Reset();
1144  }
1145  if (m_fPYfit1) {
1146  m_fPYfit1->Reset();
1147  }
1148  if (m_fPZfit1) {
1149  m_fPZfit1->Reset();
1150  }
1151 
1152  int iter0 = 0;
1153  m_iter1 = 0;
1154  m_iter2 = 0;
1155  m_iter3 = 0;
1156  m_iter4 = 0;
1157 
1158  const double met_coscovphi = cos(preparedInput.m_METcovphi);
1159  const double met_sincovphi = sin(preparedInput.m_METcovphi);
1160 
1161  m_iang1low = 0;
1162  m_iang1high = 0;
1163 
1164  // double Mvis=(tau_vec1+tau_vec2).M();
1165  // TLorentzVector met4vec(0.0,0.0,0.0,0.0);
1166  // met4vec.SetPxPyPzE(met_vec.X(),met_vec.Y(),0.0,met_vec.Mod());
1167  // double Meff=(tau_vec1+tau_vec2+met4vec).M();
1168  // double met_det=met_vec.Mod();
1169 
1170  //---------------------------------------------
1171  if (preparedInput.m_tauTypes == TauTypes::ll) // dilepton case
1172  {
1173  if (preparedInput.m_fUseVerbose == 1) {
1174  Info("DiTauMassTools", "Running in dilepton mode");
1175  }
1176  double input_metX = preparedInput.m_MetVec.X();
1177  double input_metY = preparedInput.m_MetVec.Y();
1178 
1179  TLorentzVector tau_tmp(0.0, 0.0, 0.0, 0.0);
1180  TLorentzVector lep_tmp(0.0, 0.0, 0.0, 0.0);
1181  int tau_type_tmp;
1182  int tau_ind = 0;
1183 
1184  if (preparedInput.m_LFVmode == 1) // muon case: H->mu+tau(->ele) decays
1185  {
1186  if ((preparedInput.m_vistau1.M() > 0.05 &&
1187  preparedInput.m_vistau2.M() < 0.05) != refit) // choosing lepton from Higgs decay
1188  //When the mass calculator is rerun with refit==true the alternative lepton ordering is used
1189  {
1190  tau_tmp = preparedInput.m_vistau2;
1191  lep_tmp = preparedInput.m_vistau1;
1192  tau_type_tmp = preparedInput.m_type_visTau2;
1193  tau_ind = 2;
1194  } else {
1195  tau_tmp = preparedInput.m_vistau1;
1196  lep_tmp = preparedInput.m_vistau2;
1197  tau_type_tmp = preparedInput.m_type_visTau1;
1198  tau_ind = 1;
1199  }
1200  }
1201  if (preparedInput.m_LFVmode == 0) // electron case: H->ele+tau(->mu) decays
1202  {
1203  if ((preparedInput.m_vistau1.M() < 0.05 &&
1204  preparedInput.m_vistau2.M() > 0.05) != refit) // choosing lepton from Higgs decay
1205  //When the mass calculator is rerun with refit=true the alternative lepton ordering is used
1206  {
1207  tau_tmp = preparedInput.m_vistau2;
1208  lep_tmp = preparedInput.m_vistau1;
1209  tau_type_tmp = preparedInput.m_type_visTau2;
1210  tau_ind = 2;
1211  } else {
1212  tau_tmp = preparedInput.m_vistau1;
1213  lep_tmp = preparedInput.m_vistau2;
1214  tau_type_tmp = preparedInput.m_type_visTau1;
1215  tau_ind = 1;
1216  }
1217  }
1218 
1219  //------- Settings -------------------------------
1220  double Mlep = tau_tmp.M();
1221  // double dMnu_max=m_MnuScanRange-Mlep;
1222  // double Mnu_binSize=dMnu_max/NiterMnu;
1223  //-------- end of Settings
1224 
1225  // double M=Mtau;
1226  double M_nu = 0.0;
1227  double MnuProb = 1.0;
1228  //---------------------------------------------
1229  for (int i3 = 0; i3 < NiterMnu; i3++) //---- loop-3: virtual neutrino mass
1230  {
1231  M_nu = Mnu_binSize * i3;
1232  if (M_nu >= (Mtau - Mlep))
1233  continue;
1234  // M=sqrt(Mtau*Mtau-M_nu*M_nu);
1235  MnuProb = Prob->MnuProbability(preparedInput, M_nu,
1236  Mnu_binSize); // Mnu probability
1237  //---------------------------------------------
1238  for (int i4 = 0; i4 < NiterMET + 1; i4++) // MET_X scan
1239  {
1240  met_smearL = METresX_binSize * i4 - N_METsigma * METresX;
1241  for (int i5 = 0; i5 < NiterMET + 1; i5++) // MET_Y scan
1242  {
1243  met_smearP = METresY_binSize * i5 - N_METsigma * METresY;
1244  if (pow(met_smearL / METresX, 2) + pow(met_smearP / METresY, 2) > pow(N_METsigma, 2))
1245  continue; // use ellipse instead of square
1246  met_smear_x = met_smearL * met_coscovphi - met_smearP * met_sincovphi;
1247  met_smear_y = met_smearL * met_sincovphi + met_smearP * met_coscovphi;
1248  metvec_tmp.Set(input_metX + met_smear_x, input_metY + met_smear_y);
1249 
1250  solution = NuPsolutionLFV(metvec_tmp, tau_tmp, M_nu, nu_vec);
1251 
1252  ++iter0;
1253 
1254  if (solution < 1)
1255  continue;
1256  ++m_iter1;
1257 
1258  // if fast sin cos, result to not match exactly nupsolutionv2, so skip
1259  // test
1260  // SpeedUp no nested loop to compute individual probability
1261  int ngoodsol1 = 0;
1262 
1263  metprob = Prob->MetProbability(preparedInput, met_smearL, met_smearP, METresX, METresY);
1264  if (metprob <= 0)
1265  continue;
1266  for (unsigned int j1 = 0; j1 < nu_vec.size(); j1++) {
1267  if (tau_tmp.E() + nu_vec[j1].E() >= preparedInput.m_beamEnergy)
1268  continue;
1269  const double tau1_tmpp = (tau_tmp + nu_vec[j1]).P();
1270  angle1 = Angle(nu_vec[j1], tau_tmp);
1271 
1272  if (angle1 < dTheta3DLimit(tau_type_tmp, 0, tau1_tmpp)) {
1273  ++m_iang1low;
1274  continue;
1275  } // lower 99% bound
1276  if (angle1 > dTheta3DLimit(tau_type_tmp, 1, tau1_tmpp)) {
1277  ++m_iang1high;
1278  continue;
1279  } // upper 99% bound
1280  double tauvecprob1j =
1281  Prob->dTheta3d_probabilityFast(preparedInput, tau_type_tmp, angle1, tau1_tmpp);
1282  if (tauvecprob1j == 0.)
1283  continue;
1284  tauprob = Prob->TauProbabilityLFV(preparedInput, tau_type_tmp, tau_tmp, nu_vec[j1]);
1285  totalProb = tauvecprob1j * metprob * MnuProb * tauprob;
1286 
1287  m_tautau_tmp.SetPxPyPzE(0.0, 0.0, 0.0, 0.0);
1288  m_tautau_tmp += tau_tmp;
1289  m_tautau_tmp += lep_tmp;
1290  m_tautau_tmp += nu_vec[j1];
1291 
1292  const double mtautau = m_tautau_tmp.M();
1293 
1294  m_totalProbSum += totalProb;
1295  m_mtautauSum += mtautau;
1296 
1297  fit_code = 1; // at least one solution is found
1298 
1299  m_fMfit_all->Fill(mtautau, totalProb);
1300  m_fMfit_allNoWeight->Fill(mtautau, 1.);
1301  //----------------- using P*fit to fill Px,y,z_tau
1302  m_fPXfit1->Fill((tau_tmp + nu_vec[j1]).Px(), totalProb);
1303  m_fPYfit1->Fill((tau_tmp + nu_vec[j1]).Py(), totalProb);
1304  m_fPZfit1->Fill((tau_tmp + nu_vec[j1]).Pz(), totalProb);
1305 
1306  if (totalProb > m_prob_tmp) // fill solution with highest probability
1307  {
1308  sign_tmp = -log10(totalProb);
1309  m_prob_tmp = totalProb;
1310  m_fDitauStuffFit.Mditau_best = mtautau;
1311  m_fDitauStuffFit.Sign_best = sign_tmp;
1312  if (tau_ind == 1)
1313  m_fDitauStuffFit.nutau1 = nu_vec[j1];
1314  if (tau_ind == 2)
1315  m_fDitauStuffFit.nutau2 = nu_vec[j1];
1316  }
1317 
1318  ++ngoodsol1;
1319  }
1320 
1321  if (ngoodsol1 == 0)
1322  continue;
1323  m_iter2 += 1;
1324 
1325  m_iter3 += 1;
1326  }
1327  }
1328  }
1329  } else if (preparedInput.m_tauTypes == TauTypes::lh) // lepton+tau case
1330  {
1331  if (preparedInput.m_fUseVerbose == 1) {
1332  Info("DiTauMassTools", "Running in lepton+tau mode");
1333  }
1334  //------- Settings -------------------------------
1335 
1336  //----- Stuff below are for Winter 2012 lep-had analysis only; it has to be
1337  // replaced by a more common scheme once other channels are optimized
1338  // TVector2
1339  // mht_vec((tau_vec1+tau_vec2).Px(),(tau_vec1+tau_vec2).Py()); //
1340  // missing Ht vector for Njet25=0 events const double
1341  // mht=mht_vec.Mod();
1342  double input_metX = preparedInput.m_MetVec.X();
1343  double input_metY = preparedInput.m_MetVec.Y();
1344 
1345  // double mht_offset=0.0;
1346  // if(InputInfo.UseHT) // use missing Ht (for 0-jet events only for
1347  // now)
1348  // {
1349  // input_metX=-mht_vec.X();
1350  // input_metY=-mht_vec.Y();
1351  // }
1352  // else // use MET (for 0-jet and 1-jet events)
1353  // {
1354  // input_metX=met_vec.X();
1355  // input_metY=met_vec.Y();
1356  // }
1357 
1358  TLorentzVector tau_tmp(0.0, 0.0, 0.0, 0.0);
1359  TLorentzVector lep_tmp(0.0, 0.0, 0.0, 0.0);
1360  int tau_type_tmp;
1361  if (preparedInput.m_type_visTau1 == 8) {
1362  tau_tmp = preparedInput.m_vistau2;
1363  lep_tmp = preparedInput.m_vistau1;
1364  tau_type_tmp = preparedInput.m_type_visTau2;
1365  }
1366  if (preparedInput.m_type_visTau2 == 8) {
1367  tau_tmp = preparedInput.m_vistau1;
1368  lep_tmp = preparedInput.m_vistau2;
1369  tau_type_tmp = preparedInput.m_type_visTau1;
1370  }
1371 
1372  //---------------------------------------------
1373  for (int i4 = 0; i4 < NiterMET + 1; i4++) // MET_X scan
1374  {
1375  met_smearL = METresX_binSize * i4 - N_METsigma * METresX;
1376  for (int i5 = 0; i5 < NiterMET + 1; i5++) // MET_Y scan
1377  {
1378  met_smearP = METresY_binSize * i5 - N_METsigma * METresY;
1379  if (pow(met_smearL / METresX, 2) + pow(met_smearP / METresY, 2) > pow(N_METsigma, 2))
1380  continue; // use ellipse instead of square
1381  met_smear_x = met_smearL * m_metCovPhiCos - met_smearP * m_metCovPhiSin;
1382  met_smear_y = met_smearL * m_metCovPhiSin + met_smearP * m_metCovPhiCos;
1383  metvec_tmp.Set(input_metX + met_smear_x, input_metY + met_smear_y);
1384 
1385  solution = NuPsolutionLFV(metvec_tmp, tau_tmp, 0.0, nu_vec);
1386 
1387  ++iter0;
1388 
1389  if (solution < 1)
1390  continue;
1391  ++m_iter1;
1392 
1393  // if fast sin cos, result to not match exactly nupsolutionv2, so skip
1394  // test
1395  // SpeedUp no nested loop to compute individual probability
1396  int ngoodsol1 = 0;
1397 
1398  metprob = Prob->MetProbability(preparedInput, met_smearL, met_smearP, METresX, METresY);
1399  if (metprob <= 0)
1400  continue;
1401  for (unsigned int j1 = 0; j1 < nu_vec.size(); j1++) {
1402  if (tau_tmp.E() + nu_vec[j1].E() >= preparedInput.m_beamEnergy)
1403  continue;
1404  const double tau1_tmpp = (tau_tmp + nu_vec[j1]).P();
1405  angle1 = Angle(nu_vec[j1], tau_tmp);
1406 
1407  if (angle1 < dTheta3DLimit(tau_type_tmp, 0, tau1_tmpp)) {
1408  ++m_iang1low;
1409  continue;
1410  } // lower 99% bound
1411  if (angle1 > dTheta3DLimit(tau_type_tmp, 1, tau1_tmpp)) {
1412  ++m_iang1high;
1413  continue;
1414  } // upper 99% bound
1415  double tauvecprob1j =
1416  Prob->dTheta3d_probabilityFast(preparedInput, tau_type_tmp, angle1, tau1_tmpp);
1417  if (tauvecprob1j == 0.)
1418  continue;
1419  tauprob = Prob->TauProbabilityLFV(preparedInput, tau_type_tmp, tau_tmp, nu_vec[j1]);
1420  totalProb = tauvecprob1j * metprob * tauprob;
1421 
1422  m_tautau_tmp.SetPxPyPzE(0.0, 0.0, 0.0, 0.0);
1423  m_tautau_tmp += tau_tmp;
1424  m_tautau_tmp += lep_tmp;
1425  m_tautau_tmp += nu_vec[j1];
1426 
1427  const double mtautau = m_tautau_tmp.M();
1428 
1429  m_totalProbSum += totalProb;
1430  m_mtautauSum += mtautau;
1431 
1432  fit_code = 1; // at least one solution is found
1433 
1434  m_fMfit_all->Fill(mtautau, totalProb);
1435  m_fMfit_allNoWeight->Fill(mtautau, 1.);
1437  // m_fPXfit1->Fill((tau_tmp+nu_vec[j1]).Px(),totalProb);
1438  // m_fPYfit1->Fill((tau_tmp+nu_vec[j1]).Py(),totalProb);
1439  // m_fPZfit1->Fill((tau_tmp+nu_vec[j1]).Pz(),totalProb);
1440 
1441  if (totalProb > m_prob_tmp) // fill solution with highest probability
1442  {
1443  sign_tmp = -log10(totalProb);
1444  m_prob_tmp = totalProb;
1445  m_fDitauStuffFit.Mditau_best = mtautau;
1446  m_fDitauStuffFit.Sign_best = sign_tmp;
1447  if (preparedInput.m_type_visTau1 == 8) {
1448  m_fDitauStuffFit.vistau1 = lep_tmp;
1449  m_fDitauStuffFit.vistau2 = tau_tmp;
1450  m_fDitauStuffFit.nutau2 = nu_vec[j1];
1451  } else if (preparedInput.m_type_visTau2 == 8) {
1452  m_fDitauStuffFit.vistau2 = lep_tmp;
1453  m_fDitauStuffFit.vistau1 = tau_tmp;
1454  m_fDitauStuffFit.nutau1 = nu_vec[j1];
1455  }
1456  }
1457 
1458  ++ngoodsol1;
1459  }
1460 
1461  if (ngoodsol1 == 0)
1462  continue;
1463  m_iter2 += 1;
1464 
1465  m_iter3 += 1;
1466  }
1467  }
1468  } else {
1469  Info("DiTauMassTools", "Running in an unknown mode?!?!");
1470  }
1471 
1472  OutputInfo.m_NTrials = iter0;
1473  OutputInfo.m_NSuccesses = m_iter3;
1474 
1475  if (preparedInput.m_fUseVerbose == 1) {
1476  Info("DiTauMassTools", "%s",
1477  ("SpeedUp niters=" + std::to_string(iter0) + " " + std::to_string(m_iter1) + " " +
1478  std::to_string(m_iter2) + " " + std::to_string(m_iter3) + "skip:" + std::to_string(m_iang1low) +
1479  " " + std::to_string(m_iang1high))
1480  .c_str());
1481  }
1482 
1483  if (m_fMfit_all->GetEntries() > 0 && m_iter3 > 0) {
1484 #ifdef SMOOTH
1485  m_fMfit_all->Smooth();
1486  m_fMfit_allNoWeight->Smooth();
1487  m_fPXfit1->Smooth();
1488  m_fPYfit1->Smooth();
1489  m_fPZfit1->Smooth();
1490 #endif
1491 
1492  // default max finding method defined in MissingMassCalculator.h
1493  // note that window defined in terms of number of bin, so depend on binning
1494  std::vector<double> histInfo(HistInfoV2::MAXHISTINFO);
1495  m_fDitauStuffHisto.Mditau_best = maxFromHist(m_fMfit_all, histInfo);
1496  double prob_hist = histInfo.at(HistInfoV2::PROB);
1497 
1498  if (prob_hist != 0.0)
1499  m_fDitauStuffHisto.Sign_best = -log10(std::abs(prob_hist));
1500  else {
1501  // this mean the histogram is empty.
1502  // possible but very rare if all entries outside histogram range
1503  // fall back to maximum
1504  m_fDitauStuffHisto.Sign_best = -999.;
1505  m_fDitauStuffHisto.Mditau_best = m_fDitauStuffFit.Mditau_best;
1506  }
1507 
1508  if (m_fDitauStuffHisto.Mditau_best > 0.0)
1509  m_fDitauStuffHisto.RMSoverMPV = m_fMfit_all->GetRMS() / m_fDitauStuffHisto.Mditau_best;
1510  std::vector<double> histInfoOther(HistInfoV2::MAXHISTINFO);
1511  //---- getting Nu1
1512  double Px1 = maxFromHist(m_fPXfit1, histInfoOther);
1513  double Py1 = maxFromHist(m_fPYfit1, histInfoOther);
1514  double Pz1 = maxFromHist(m_fPZfit1, histInfoOther);
1515  //---- setting 4-vecs
1516  TLorentzVector nu1_tmp(0.0, 0.0, 0.0, 0.0);
1517  TLorentzVector nu2_tmp(0.0, 0.0, 0.0, 0.0);
1518  if (preparedInput.m_type_visTau1 == 8) {
1519  nu1_tmp = preparedInput.m_vistau1;
1520  nu2_tmp.SetXYZM(Px1, Py1, Pz1, 1.777);
1521  }
1522  if (preparedInput.m_type_visTau2 == 8) {
1523  nu2_tmp = preparedInput.m_vistau2;
1524  nu1_tmp.SetXYZM(Px1, Py1, Pz1, 1.777);
1525  }
1526  m_fDitauStuffHisto.nutau1 = nu1_tmp - preparedInput.m_vistau1;
1527  m_fDitauStuffHisto.nutau2 = nu2_tmp - preparedInput.m_vistau2;
1528  }
1529  if (m_lfvLeplepRefit && fit_code==0 && !refit) {
1530  fit_code = DitauMassCalculatorV9lfv(true);
1531  return fit_code;
1532  }
1533 
1534 
1535 
1536  if (preparedInput.m_fUseVerbose == 1) {
1537  if (fit_code == 0) {
1538  Info(
1539  "DiTauMassTools", "%s",
1540  ("!!!----> Warning-3 in MissingMassCalculator::DitauMassCalculatorV9lfv() : fit status=" +
1541  std::to_string(fit_code))
1542  .c_str());
1543  Info("DiTauMassTools", "....... No solution is found. Printing input info .......");
1544 
1545  Info("DiTauMassTools", "%s", (" vis Tau-1: Pt="+std::to_string(preparedInput.m_vistau1.Pt())
1546  +" M="+std::to_string(preparedInput.m_vistau1.M())+" eta="+std::to_string(preparedInput.m_vistau1.Eta())
1547  +" phi="+std::to_string(preparedInput.m_vistau1.Phi())
1548  +" type="+std::to_string(preparedInput.m_type_visTau1)).c_str());
1549  Info("DiTauMassTools", "%s", (" vis Tau-2: Pt="+std::to_string(preparedInput.m_vistau2.Pt())
1550  +" M="+std::to_string(preparedInput.m_vistau2.M())+" eta="+std::to_string(preparedInput.m_vistau2.Eta())
1551  +" phi="+std::to_string(preparedInput.m_vistau2.Phi())
1552  +" type="+std::to_string(preparedInput.m_type_visTau2)).c_str());
1553  Info("DiTauMassTools", "%s", (" MET="+std::to_string(preparedInput.m_MetVec.Mod())+" Met_X="+std::to_string(preparedInput.m_MetVec.Px())
1554  +" Met_Y="+std::to_string(preparedInput.m_MetVec.Py())).c_str());
1555  Info("DiTauMassTools", " ---------------------------------------------------------- ");
1556  }
1557  }
1558  return fit_code;
1559 }

◆ DitauMassCalculatorV9walk()

int MissingMassCalculatorV2::DitauMassCalculatorV9walk ( )
inlineprotected

Definition at line 863 of file MissingMassCalculatorV2.cxx.

863  {
864 
865  int nsuccesses = 0;
866 
867  int fit_code = 0; // 0==bad, 1==good
868  ClearDitauStuff(m_fDitauStuffFit);
869  ClearDitauStuff(m_fDitauStuffHisto);
870  OutputInfo.m_AveSolRMS = 0.;
871 
872  m_fMfit_all->Reset();
873 #ifdef SAVELIKELIHOODHISTO
874  m_fMEtP_all->Reset();
875  m_fMEtL_all->Reset();
876  m_fMnu1_all->Reset();
877  m_fMnu2_all->Reset();
878  m_fPhi1_all->Reset();
879  m_fPhi2_all->Reset();
880 #endif
881  m_fMfit_allNoWeight->Reset();
882  m_fPXfit1->Reset();
883  m_fPYfit1->Reset();
884  m_fPZfit1->Reset();
885  m_fPXfit2->Reset();
886  m_fPYfit2->Reset();
887  m_fPZfit2->Reset();
888 
889  // these histograms are used for the floating stopping criterion
890  if (m_fUseFloatStopping) {
891  m_fMmass_split1->Reset();
892  m_fMEtP_split1->Reset();
893  m_fMEtL_split1->Reset();
894  m_fMnu1_split1->Reset();
895  m_fMnu2_split1->Reset();
896  m_fPhi1_split1->Reset();
897  m_fPhi2_split1->Reset();
898  m_fMmass_split2->Reset();
899  m_fMEtP_split2->Reset();
900  m_fMEtL_split2->Reset();
901  m_fMnu1_split2->Reset();
902  m_fMnu2_split2->Reset();
903  m_fPhi1_split2->Reset();
904  m_fPhi2_split2->Reset();
905  }
906 
907  m_prob_tmp = 0.0;
908 
909  m_iter1 = 0;
910 
911  m_totalProbSum = 0;
912  m_mtautauSum = 0;
913 
914  TVector2 deltamet_vec;
915 
916  // initialize a spacewalker, which walks the parameter space according to some
917  // algorithm
918  SpaceWalkerInit();
919 
920  while (SpaceWalkerWalk()) {
921  bool paramInsideRange = false;
922  m_nsol = 0;
923 
924  paramInsideRange = checkAllParamInRange();
925 
926  // FIXME if no tau scanning, or symmetric matrices, rotatin is made twice
927  // which is inefficient
928  const double deltaMetx = m_MEtL * m_metCovPhiCos - m_MEtP * m_metCovPhiSin;
929  const double deltaMety = m_MEtL * m_metCovPhiSin + m_MEtP * m_metCovPhiCos;
930 
931  // deltaMetVec.Set(met_smear_x,met_smear_y);
932  preparedInput.m_metVec.Set(preparedInput.m_inputMEtX + deltaMetx,
933  preparedInput.m_inputMEtY + deltaMety);
934 
935  // save in global variable for speed sake
936  preparedInput.m_MEtX = preparedInput.m_metVec.Px();
937  preparedInput.m_MEtY = preparedInput.m_metVec.Py();
938  preparedInput.m_MEtT = preparedInput.m_metVec.Mod();
939 
940  if (paramInsideRange)
941  probCalculatorV9fast(m_Phi1, m_Phi2, m_Mnu1, m_Mnu2);
942 
943  // DR for markov chain need to enter handleSolution also when zero solutions
944  handleSolutions();
945  // be careful that with markov, current solution is from now on stored in
946  // XYZOldSolVec
947 
948  if (m_nsol <= 0)
949  continue;
950 
951  // for markov, nsuccess more difficult to define. Decide this is the number
952  // of independent point accepted (hence without weight)
953  nsuccesses = m_markovNAccept;
954  m_iterNsuc = m_markovNAccept;
955 
956  m_iter1 += m_nsol;
957  fit_code = 1;
958 
959  } // while loop
960 
961  OutputInfo.m_NTrials = m_iter0;
962  OutputInfo.m_NSuccesses = nsuccesses;
963 
964  if (nsuccesses > 0) {
965  OutputInfo.m_AveSolRMS /= nsuccesses;
966  } else {
967  OutputInfo.m_AveSolRMS = -1.;
968  }
969 
970  double Px1, Py1, Pz1;
971  double Px2, Py2, Pz2;
972  if (nsuccesses > 0) {
973 
974  // note that smoothing can slightly change the integral of the histogram
975 
976 #ifdef SMOOTH
977  m_fMfit_all->Smooth();
978  m_fMfit_allNoWeight->Smooth();
979  m_fPXfit1->Smooth();
980  m_fPYfit1->Smooth();
981  m_fPZfit1->Smooth();
982  m_fPXfit2->Smooth();
983  m_fPYfit2->Smooth();
984  m_fPZfit2->Smooth();
985 #endif
986 
987  // default max finding method defined in MissingMassCalculator.h
988  // note that window defined in terms of number of bin, so depend on binning
989  std::vector<double> histInfo(HistInfoV2::MAXHISTINFO);
990  m_fDitauStuffHisto.Mditau_best = maxFromHist(m_fMfit_all, histInfo);
991  double prob_hist = histInfo.at(HistInfoV2::PROB);
992 
993  if (prob_hist != 0.0)
994  m_fDitauStuffHisto.Sign_best = -log10(std::abs(prob_hist));
995  else {
996  // this mean the histogram is empty.
997  // possible but very rare if all entries outside histogram range
998  // fall back to maximum
999  m_fDitauStuffHisto.Sign_best = -999.;
1000  m_fDitauStuffHisto.Mditau_best = m_fDitauStuffFit.Mditau_best;
1001  }
1002 
1003  if (m_fDitauStuffHisto.Mditau_best > 0.0)
1004  m_fDitauStuffHisto.RMSoverMPV = m_fMfit_all->GetRMS() / m_fDitauStuffHisto.Mditau_best;
1005  std::vector<double> histInfoOther(HistInfoV2::MAXHISTINFO);
1006  //---- getting full tau1 momentum
1007  Px1 = maxFromHist(m_fPXfit1, histInfoOther);
1008  Py1 = maxFromHist(m_fPYfit1, histInfoOther);
1009  Pz1 = maxFromHist(m_fPZfit1, histInfoOther);
1010 
1011  //---- getting full tau2 momentum
1012  Px2 = maxFromHist(m_fPXfit2, histInfoOther);
1013  Py2 = maxFromHist(m_fPYfit2, histInfoOther);
1014  Pz2 = maxFromHist(m_fPZfit2, histInfoOther);
1015 
1016  //---- setting 4-vecs
1017  TLorentzVector fulltau1, fulltau2;
1018 
1019  fulltau1.SetXYZM(Px1, Py1, Pz1, 1.777);
1020  fulltau2.SetXYZM(Px2, Py2, Pz2, 1.777);
1021  if (fulltau1.P() < preparedInput.m_vistau1.P())
1022  fulltau1 = 1.01 * preparedInput.m_vistau1; // protection against cases when fitted tau
1023  // momentum is smaller than visible tau momentum
1024  if (fulltau2.P() < preparedInput.m_vistau2.P())
1025  fulltau2 = 1.01 * preparedInput.m_vistau2; // protection against cases when fitted tau
1026  // momentum is smaller than visible tau momentum
1027  m_fDitauStuffHisto.vistau1 = preparedInput.m_vistau1; // FIXME should also be fitted if tau scan
1028  m_fDitauStuffHisto.vistau2 = preparedInput.m_vistau2;
1029  m_fDitauStuffHisto.nutau1 = fulltau1 - preparedInput.m_vistau1; // these are the original tau vis
1030  m_fDitauStuffHisto.nutau2 =
1031  fulltau2 - preparedInput.m_vistau2; // FIXME neutrino mass not necessarily zero
1032  }
1033 
1034  // Note that for v9walk, points outside the METx MEty disk are counted, while
1035  // this was not the case for v9
1036  if (preparedInput.m_fUseVerbose == 1) {
1037  Info("DiTauMassTools", "Scanning ");
1038  Info("DiTauMassTools", " Markov ");
1039  Info("DiTauMassTools", "%s",
1040  (" V9W niters=" + std::to_string(m_iter0) + " " + std::to_string(m_iter1)).c_str());
1041  Info("DiTauMassTools", "%s", (" nFullScan " + std::to_string(m_markovNFullScan)).c_str());
1042  Info("DiTauMassTools", "%s", (" nRejectNoSol " + std::to_string(m_markovNRejectNoSol)).c_str());
1043  Info("DiTauMassTools", "%s", (" nRejectMetro " + std::to_string(m_markovNRejectMetropolis)).c_str());
1044  Info("DiTauMassTools", "%s", (" nAccept " + std::to_string(m_markovNAccept)).c_str());
1045  Info("DiTauMassTools", "%s",
1046  (" probsum " + std::to_string(m_totalProbSum) + " msum " + std::to_string(m_mtautauSum))
1047  .c_str());
1048  }
1049 
1050  if (preparedInput.m_fUseVerbose == 1) {
1051  if (fit_code == 0) {
1052  Info("DiTauMassTools", "%s", ("!!!----> Warning-3 in "
1053  "MissingMassCalculator::DitauMassCalculatorV9Walk() : fit status=" +
1054  std::to_string(fit_code))
1055  .c_str());
1056  Info("DiTauMassTools", "%s", "....... No solution is found. Printing input info .......");
1057 
1058  Info("DiTauMassTools", "%s", (" vis Tau-1: Pt=" + std::to_string(preparedInput.m_vistau1.Pt()) +
1059  " M=" + std::to_string(preparedInput.m_vistau1.M()) +
1060  " eta=" + std::to_string(preparedInput.m_vistau1.Eta()) +
1061  " phi=" + std::to_string(preparedInput.m_vistau1.Phi()) +
1062  " type=" + std::to_string(preparedInput.m_type_visTau1))
1063  .c_str());
1064  Info("DiTauMassTools", "%s", (" vis Tau-2: Pt=" + std::to_string(preparedInput.m_vistau2.Pt()) +
1065  " M=" + std::to_string(preparedInput.m_vistau2.M()) +
1066  " eta=" + std::to_string(preparedInput.m_vistau2.Eta()) +
1067  " phi=" + std::to_string(preparedInput.m_vistau2.Phi()) +
1068  " type=" + std::to_string(preparedInput.m_type_visTau2))
1069  .c_str());
1070  Info("DiTauMassTools", "%s", (" MET=" + std::to_string(preparedInput.m_MetVec.Mod()) +
1071  " Met_X=" + std::to_string(preparedInput.m_MetVec.Px()) +
1072  " Met_Y=" + std::to_string(preparedInput.m_MetVec.Py()))
1073  .c_str());
1074  Info("DiTauMassTools", " ---------------------------------------------------------- ");
1075  }
1076  }
1077 
1078  return fit_code;
1079 }

◆ DoOutputInfo()

void MissingMassCalculatorV2::DoOutputInfo ( )
private

Definition at line 373 of file MissingMassCalculatorV2.cxx.

373  {
374  if (OutputInfo.m_FitStatus > 0) {
375  if (preparedInput.m_fUseVerbose == 1) {
376  Info("DiTauMassTools", "Retrieving output from fDitauStuffFit");
377  }
378  // MAXW method : get from fDittauStuffFit
379  OutputInfo.m_FitSignificance[MMCFitMethodV2::MAXW] = m_fDitauStuffFit.Sign_best;
380  OutputInfo.m_FittedMass[MMCFitMethodV2::MAXW] = m_fDitauStuffFit.Mditau_best;
381  double q1 = (1. - 0.68) / 2.;
382  double q2 = 1. - q1;
383  double xq[2], yq[2];
384  xq[0] = q1;
385  xq[1] = q2;
386  m_fMfit_all->GetQuantiles(2, yq, xq);
387  OutputInfo.m_FittedMassLowerError[MMCFitMethodV2::MAXW] = yq[0];
388  OutputInfo.m_FittedMassUpperError[MMCFitMethodV2::MAXW] = yq[1];
389  OutputInfo.m_nuvec1[MMCFitMethodV2::MAXW] = m_fDitauStuffFit.nutau1;
390  OutputInfo.m_objvec1[MMCFitMethodV2::MAXW] =
391  m_fDitauStuffFit.vistau1 + m_fDitauStuffFit.nutau1;
392  OutputInfo.m_nuvec2[MMCFitMethodV2::MAXW] = m_fDitauStuffFit.nutau2;
393  OutputInfo.m_objvec2[MMCFitMethodV2::MAXW] =
394  m_fDitauStuffFit.vistau2 + m_fDitauStuffFit.nutau2;
395  OutputInfo.m_totalvec[MMCFitMethodV2::MAXW] =
396  OutputInfo.m_objvec1[MMCFitMethodV2::MAXW] +
397  OutputInfo.m_objvec2[MMCFitMethodV2::MAXW];
398  TVector2 metmaxw(OutputInfo.m_nuvec1[MMCFitMethodV2::MAXW].Px() +
399  OutputInfo.m_nuvec2[MMCFitMethodV2::MAXW].Px(),
400  OutputInfo.m_nuvec1[MMCFitMethodV2::MAXW].Py() +
401  OutputInfo.m_nuvec2[MMCFitMethodV2::MAXW].Py());
402  OutputInfo.m_FittedMetVec[MMCFitMethodV2::MAXW] = metmaxw;
403 
404  // MLM method : can only get MMC, rest is dummy
405  double scale = MassScale(MMCFitMethodV2::MAXW, m_fDitauStuffHisto.Mditau_best,
406  preparedInput.m_type_visTau1,
407  preparedInput.m_type_visTau2); // only for histo method for now. In
408  // practice disabled by default
409 
410  OutputInfo.m_FittedMass[MMCFitMethodV2::MLM] = scale * m_fDitauStuffHisto.Mditau_best;
411  OutputInfo.m_FittedMassLowerError[MMCFitMethodV2::MLM] = yq[0];
412  OutputInfo.m_FittedMassUpperError[MMCFitMethodV2::MLM] = yq[1];
413 
414  TLorentzVector tlvdummy(0., 0., 0., 0.);
415  TVector2 metdummy(0., 0.);
416  OutputInfo.m_FitSignificance[MMCFitMethodV2::MLM] = -1.;
417  OutputInfo.m_nuvec1[MMCFitMethodV2::MLM] = tlvdummy;
418  OutputInfo.m_objvec1[MMCFitMethodV2::MLM] = tlvdummy;
419  OutputInfo.m_nuvec2[MMCFitMethodV2::MLM] = tlvdummy;
420  OutputInfo.m_objvec2[MMCFitMethodV2::MLM] = tlvdummy;
421  OutputInfo.m_totalvec[MMCFitMethodV2::MLM] = tlvdummy;
422  OutputInfo.m_FittedMetVec[MMCFitMethodV2::MLM] = metdummy;
423 
424  // MLNU3P method : get from fDittauStuffHisto 4 momentum
425  OutputInfo.m_nuvec1[MMCFitMethodV2::MLNU3P] = m_fDitauStuffHisto.nutau1;
426  OutputInfo.m_objvec1[MMCFitMethodV2::MLNU3P] =
427  m_fDitauStuffHisto.vistau1 + m_fDitauStuffHisto.nutau1;
428  OutputInfo.m_nuvec2[MMCFitMethodV2::MLNU3P] = m_fDitauStuffHisto.nutau2;
429  OutputInfo.m_objvec2[MMCFitMethodV2::MLNU3P] =
430  m_fDitauStuffHisto.vistau2 + m_fDitauStuffHisto.nutau2;
431  OutputInfo.m_totalvec[MMCFitMethodV2::MLNU3P] =
432  OutputInfo.m_objvec1[MMCFitMethodV2::MLNU3P] +
433  OutputInfo.m_objvec2[MMCFitMethodV2::MLNU3P];
434  OutputInfo.m_FittedMass[MMCFitMethodV2::MLNU3P] =
435  OutputInfo.m_totalvec[MMCFitMethodV2::MLNU3P].M();
436  OutputInfo.m_FittedMassUpperError[MMCFitMethodV2::MLNU3P] = 0.;
437  OutputInfo.m_FittedMassLowerError[MMCFitMethodV2::MLNU3P] = 0.;
438 
439  TVector2 metmlnu3p(OutputInfo.m_nuvec1[MMCFitMethodV2::MLNU3P].Px() +
440  OutputInfo.m_nuvec2[MMCFitMethodV2::MLNU3P].Px(),
441  OutputInfo.m_nuvec1[MMCFitMethodV2::MLNU3P].Py() +
442  OutputInfo.m_nuvec2[MMCFitMethodV2::MLNU3P].Py());
443  OutputInfo.m_FittedMetVec[MMCFitMethodV2::MLNU3P] = metmlnu3p;
444 
445  OutputInfo.m_RMS2MPV = m_fDitauStuffHisto.RMSoverMPV;
446  }
447 
448  OutputInfo.m_hMfit_all = m_fMfit_all;
449  OutputInfo.m_hMfit_allNoWeight = m_fMfit_allNoWeight;
450  OutputInfo.m_NSolutions = m_fMfit_all->GetEntries();
451  OutputInfo.m_SumW = m_fMfit_all->GetSumOfWeights();
452 
453  //----------------- Check if input was re-ordered in FinalizeInputStuff() and
454  // restore the original order if needed
455  if (preparedInput.m_InputReorder == 1) {
456  TLorentzVector dummy_vec1(0.0, 0.0, 0.0, 0.0);
457  TLorentzVector dummy_vec2(0.0, 0.0, 0.0, 0.0);
458  for (int i = 0; i < 3; i++) {
459  // re-ordering neutrinos
460  dummy_vec1 = OutputInfo.m_nuvec1[i];
461  dummy_vec2 = OutputInfo.m_nuvec2[i];
462  OutputInfo.m_nuvec1[i] = dummy_vec2;
463  OutputInfo.m_nuvec2[i] = dummy_vec1;
464  // re-ordering tau's
465  dummy_vec1 = OutputInfo.m_objvec1[i];
466  dummy_vec2 = OutputInfo.m_objvec2[i];
467  OutputInfo.m_objvec1[i] = dummy_vec2;
468  OutputInfo.m_objvec2[i] = dummy_vec1;
469  }
470  }
471 
472  return;
473 }

◆ dTheta3DLimit()

double MissingMassCalculatorV2::dTheta3DLimit ( const int &  tau_type,
const int &  limit_code,
const double &  P_tau 
)
inline

Definition at line 2837 of file MissingMassCalculatorV2.cxx.

2838  {
2839 
2840 #ifndef WITHDTHETA3DLIM
2841  // make the test ineffective if desired
2842  if (limit_code == 0)
2843  return 0.;
2844  if (limit_code == 1)
2845  return 10.;
2846  if (limit_code == 2)
2847  return 10.;
2848 #endif
2849 
2850  double limit = 1.0;
2851  if (limit_code == 0)
2852  limit = 0.0;
2853  double par[3] = {0.0, 0.0, 0.0};
2854  // ---- leptonic tau's
2855  if (tau_type == 8) {
2856  if (limit_code == 0) // lower 99% limit
2857  {
2858  par[0] = 0.3342;
2859  par[1] = -0.3376;
2860  par[2] = -0.001377;
2861  }
2862  if (limit_code == 1) // upper 99% limit
2863  {
2864  par[0] = 3.243;
2865  par[1] = -12.87;
2866  par[2] = 0.009656;
2867  }
2868  if (limit_code == 2) // upper 95% limit
2869  {
2870  par[0] = 2.927;
2871  par[1] = -7.911;
2872  par[2] = 0.007783;
2873  }
2874  }
2875  // ---- 1-prong tau's
2876  if (tau_type >= 0 && tau_type <= 2) {
2877  if (limit_code == 0) // lower 99% limit
2878  {
2879  par[0] = 0.2673;
2880  par[1] = -14.8;
2881  par[2] = -0.0004859;
2882  }
2883  if (limit_code == 1) // upper 99% limit
2884  {
2885  par[0] = 9.341;
2886  par[1] = -15.88;
2887  par[2] = 0.0333;
2888  }
2889  if (limit_code == 2) // upper 95% limit
2890  {
2891  par[0] = 6.535;
2892  par[1] = -8.649;
2893  par[2] = 0.00277;
2894  }
2895  }
2896  // ---- 3-prong tau's
2897  if (tau_type >= 3 && tau_type <= 5) {
2898  if (limit_code == 0) // lower 99% limit
2899  {
2900  par[0] = 0.2308;
2901  par[1] = -15.24;
2902  par[2] = -0.0009458;
2903  }
2904  if (limit_code == 1) // upper 99% limit
2905  {
2906  par[0] = 14.58;
2907  par[1] = -6.043;
2908  par[2] = -0.00928;
2909  }
2910  if (limit_code == 2) // upper 95% limit
2911  {
2912  par[0] = 8.233;
2913  par[1] = -0.3018;
2914  par[2] = -0.009399;
2915  }
2916  }
2917 
2918  if (std::abs(P_tau + par[1]) > 0.0)
2919  limit = par[0] / (P_tau + par[1]) + par[2];
2920  if (limit_code == 0) {
2921  if (limit < 0.0) {
2922  limit = 0.0;
2923  } else if (limit > 0.03) {
2924  limit = 0.03;
2925  }
2926  } else {
2927  if (limit < 0.0 || limit > 0.5 * TMath::Pi()) {
2928  limit = 0.5 * TMath::Pi();
2929  } else if (limit < 0.05 && limit > 0.0) {
2930  limit = 0.05; // parameterization only runs up to P~220 GeV in this regime
2931  // will set an upper bound of 0.05
2932  }
2933  }
2934 
2935  return limit;
2936 }

◆ FinalizeSettings()

void MissingMassCalculatorV2::FinalizeSettings ( const xAOD::IParticle *  part1,
const xAOD::IParticle *  part2,
const xAOD::MissingET *  met,
const int &  njets 
)

Definition at line 2984 of file MissingMassCalculatorV2.cxx.

2987  {
2988  const double GEV = 1000.;
2989  int mmcType1 = mmcType(part1);
2990  if (mmcType1 < 0)
2991  return; // return CP::CorrectionCode::Error;
2992 
2993  int mmcType2 = mmcType(part2);
2994  if (mmcType2 < 0)
2995  return; // return CP::CorrectionCode::Error;
2996 
2997  preparedInput.SetLFVmode(-2); // initialise LFV mode value for this event with being *not* LFV
2998  // if(getLFVMode(part1, part2, mmcType1, mmcType2) ==
2999  // CP::CorrectionCode::Error) {
3000  if (m_mmcCalibrationSet == MMCCalibrationSetV2::LFVMMC2012) {
3001  int LFVMode = getLFVMode(part1, part2, mmcType1, mmcType2);
3002  if (LFVMode == -1) {
3003  return; // return CP::CorrectionCode::Error;
3004  } else if (LFVMode != -2) {
3005  preparedInput.SetLFVmode(LFVMode);
3006  }
3007  }
3008 
3009  // this will be in MeV but MMC allows MeV
3010  // assume the mass is correct as well
3011  TLorentzVector tlvTau1 = part1->p4();
3012  TLorentzVector tlvTau2 = part2->p4();
3013 
3014  // Convert to GeV. In principle, MMC should cope with MeV but should check
3015  // thoroughly
3016  TLorentzVector fixedtau1;
3017  fixedtau1.SetPtEtaPhiM(tlvTau1.Pt() / GEV, tlvTau1.Eta(), tlvTau1.Phi(), tlvTau1.M() / GEV);
3018  TLorentzVector fixedtau2;
3019  fixedtau2.SetPtEtaPhiM(tlvTau2.Pt() / GEV, tlvTau2.Eta(), tlvTau2.Phi(), tlvTau2.M() / GEV);
3020 
3021  preparedInput.SetVisTauType(0, mmcType1);
3022  preparedInput.SetVisTauType(1, mmcType2);
3023  preparedInput.SetVisTauVec(0, fixedtau1);
3024  preparedInput.SetVisTauVec(1, fixedtau2);
3025 
3026  if (mmcType1 == 8 && mmcType2 == 8) {
3027  preparedInput.m_tauTypes = TauTypes::ll;
3028  } else if (mmcType1 >= 0 && mmcType1 <= 5 && mmcType2 >= 0 && mmcType2 <= 5) {
3029  preparedInput.m_tauTypes = TauTypes::hh;
3030  } else {
3031  preparedInput.m_tauTypes = TauTypes::lh;
3032  }
3033  if (preparedInput.m_fUseVerbose)
3034  Info("DiTauMassTools", "%s", ("running for tau types "+std::to_string(preparedInput.m_type_visTau1)+" "+std::to_string(preparedInput.m_type_visTau2)).c_str());
3035  TVector2 met_vec(met->mpx() / GEV, met->mpy() / GEV);
3036  preparedInput.SetMetVec(met_vec);
3037  if (preparedInput.m_fUseVerbose)
3038  Info("DiTauMassTools", "%s", ("passing SumEt="+std::to_string(met->sumet() / GEV)).c_str());
3039  preparedInput.SetSumEt(met->sumet() / GEV);
3040  preparedInput.SetNjet25(njets);
3041 
3042  // check that the calibration set has been chosen explicitly, otherwise abort
3043  if (m_mmcCalibrationSet == MMCCalibrationSetV2::MAXMMCCALIBRATIONSET) {
3044  Error("DiTauMassTools", "MMCCalibrationSet has not been set !. Please use "
3045  "fMMC.SetCalibrationSet(MMCCalibrationSetV2::MMC2019)"
3046  ". Abort now. ");
3047  throw; // stop job
3048  }
3049  //----------- Re-ordering input info, to make sure there is no dependence of
3050  // results on input order
3051  // this might be needed because a random scan is used
3052  // highest pT tau is always first
3053  preparedInput.m_InputReorder = 0; // set flag to 0 by default, i.e. no re-ordering
3054  if ((preparedInput.m_type_visTau1 >= 0 && preparedInput.m_type_visTau1 <= 5) &&
3055  preparedInput.m_type_visTau2 == 8) // if hadron-lepton, reorder to have lepton first
3056  {
3057  preparedInput.m_InputReorder =
3058  1; // re-order to be done, this flag is to be checked in DoOutputInfo()
3059  } else if (!((preparedInput.m_type_visTau2 >= 0 && preparedInput.m_type_visTau2 <= 5) &&
3060  preparedInput.m_type_visTau1 == 8)) // if not lep-had nor had lep, reorder if tau1 is
3061  // after tau2 clockwise
3062  {
3063  if (fixPhiRange(preparedInput.m_vistau1.Phi() - preparedInput.m_vistau2.Phi()) > 0) {
3064  preparedInput.m_InputReorder = 1; // re-order to be done, this flag is to be
3065  // checked in DoOutputInfo()
3066  }
3067  }
3068 
3069  if (preparedInput.m_InputReorder == 1) // copy and re-order
3070  {
3071  std::swap(preparedInput.m_vistau1, preparedInput.m_vistau2);
3072  std::swap(preparedInput.m_type_visTau1, preparedInput.m_type_visTau2);
3073  std::swap(preparedInput.m_Nprong_tau1, preparedInput.m_Nprong_tau2);
3074  }
3075  //--------- re-ordering is done ---------------------------------------
3076 
3077  preparedInput.m_DelPhiTT =
3078  std::abs(TVector2::Phi_mpi_pi(preparedInput.m_vistau1.Phi() - preparedInput.m_vistau2.Phi()));
3079 
3080  for (unsigned int i = 0; i < preparedInput.m_jet4vecs.size(); i++) {
3081  // correcting sumEt, give priority to SetMetScanParamsUE()
3082  if (preparedInput.m_METScanScheme == 0) {
3083  if ((preparedInput.m_METsigmaP < 0.1 || preparedInput.m_METsigmaL < 0.1) &&
3084  preparedInput.m_SumEt > preparedInput.m_jet4vecs[i].Pt() &&
3085  preparedInput.m_jet4vecs[i].Pt() > 20.0) {
3086  if (preparedInput.m_fUseVerbose == 1) {
3087  Info("DiTauMassTools", "correcting sumET");
3088  }
3089  preparedInput.m_SumEt -= preparedInput.m_jet4vecs[i].Pt();
3090  }
3091  }
3092  }
3093 
3094  // give priority to SetVisTauType, only do this if type_visTau1 and
3095  // type_visTau2 are not set
3096  /*if(type_visTau1<0 && type_visTau2<0 && Nprong_tau1>-1 && Nprong_tau2>-1)
3097  {
3098  if(Nprong_tau1==0) type_visTau1 = 8; // leptonic tau
3099  else if( Nprong_tau1==1) type_visTau1 = 0; // set to 1p0n for now, may use
3100 different solution later like explicit integer for this case that pantau info is
3101 not available? else if( Nprong_tau1==3) type_visTau1 = 3; // set to 3p0n for
3102 now, see above if(Nprong_tau2==0) type_visTau2 = 8; // leptonic tau else if(
3103 Nprong_tau2==1) type_visTau2 = 0; // set to 1p0n for now, see above else if(
3104 Nprong_tau2==3) type_visTau2=3; // set to 3p0n for now, see above
3105  }
3106  */
3107  // checking input mass of hadronic tau-1
3108  // one prong
3109  // // checking input mass of hadronic tau-1
3110  // DRMERGE LFV addition
3111  if (m_mmcCalibrationSet == MMCCalibrationSetV2::LFVMMC2012 ) {
3112  if ((preparedInput.m_type_visTau1 >= 0 && preparedInput.m_type_visTau1 <= 2) &&
3113  preparedInput.m_vistau1.M() != 1.1) {
3114  preparedInput.m_vistau1.SetPtEtaPhiM(preparedInput.m_vistau1.Pt(), preparedInput.m_vistau1.Eta(),
3115  preparedInput.m_vistau1.Phi(), 1.1);
3116  }
3117  if ((preparedInput.m_type_visTau1 >= 3 && preparedInput.m_type_visTau1 <= 5) &&
3118  preparedInput.m_vistau1.M() != 1.35) {
3119  preparedInput.m_vistau1.SetPtEtaPhiM(preparedInput.m_vistau1.Pt(), preparedInput.m_vistau1.Eta(),
3120  preparedInput.m_vistau1.Phi(), 1.35);
3121  }
3122  // checking input mass of hadronic tau-2
3123  if ((preparedInput.m_type_visTau2 >= 0 && preparedInput.m_type_visTau2 <= 2) &&
3124  preparedInput.m_vistau2.M() != 1.1) {
3125  preparedInput.m_vistau2.SetPtEtaPhiM(preparedInput.m_vistau2.Pt(), preparedInput.m_vistau2.Eta(),
3126  preparedInput.m_vistau2.Phi(), 1.1);
3127  }
3128  if ((preparedInput.m_type_visTau2 >= 3 && preparedInput.m_type_visTau2 <= 5) &&
3129  preparedInput.m_vistau2.M() != 1.35) {
3130  preparedInput.m_vistau2.SetPtEtaPhiM(preparedInput.m_vistau2.Pt(), preparedInput.m_vistau2.Eta(),
3131  preparedInput.m_vistau2.Phi(), 1.35);
3132  }
3133  } else {
3134  // DRMERGE end LFV addition
3135  if ((preparedInput.m_type_visTau1 >= 0 && preparedInput.m_type_visTau1 <= 2) &&
3136  preparedInput.m_vistau1.M() != 0.8) {
3137  preparedInput.m_vistau1.SetPtEtaPhiM(preparedInput.m_vistau1.Pt(), preparedInput.m_vistau1.Eta(),
3138  preparedInput.m_vistau1.Phi(), 0.8);
3139  }
3140  // 3 prong
3141  if ((preparedInput.m_type_visTau1 >= 3 && preparedInput.m_type_visTau1 <= 5) &&
3142  preparedInput.m_vistau1.M() != 1.2) {
3143  preparedInput.m_vistau1.SetPtEtaPhiM(preparedInput.m_vistau1.Pt(), preparedInput.m_vistau1.Eta(),
3144  preparedInput.m_vistau1.Phi(), 1.2);
3145  }
3146  // checking input mass of hadronic tau-2
3147  // one prong
3148  if ((preparedInput.m_type_visTau2 >= 0 && preparedInput.m_type_visTau2 <= 2) &&
3149  preparedInput.m_vistau2.M() != 0.8) {
3150  preparedInput.m_vistau2.SetPtEtaPhiM(preparedInput.m_vistau2.Pt(), preparedInput.m_vistau2.Eta(),
3151  preparedInput.m_vistau2.Phi(), 0.8);
3152  }
3153  // 3 prong
3154  if ((preparedInput.m_type_visTau2 >= 3 && preparedInput.m_type_visTau2 <= 5) &&
3155  preparedInput.m_vistau2.M() != 1.2) {
3156  preparedInput.m_vistau2.SetPtEtaPhiM(preparedInput.m_vistau2.Pt(), preparedInput.m_vistau2.Eta(),
3157  preparedInput.m_vistau2.Phi(), 1.2);
3158  }
3159  } // DRDRMERGE LFV else closing
3160 
3161  // correcting sumEt for electron pt, give priority to SetMetScanParamsUE()
3162  // DR20150615 in tag 00-00-11 and before. The following was done before the
3163  // mass of the hadronic tau was set which mean that sumEt was wrongly
3164  // corrected for the hadronic tau pt if the hadronic tau mass was set to zero
3165  // Sasha 08/12/15: don't do electron Pt subtraction for high mass studies; in
3166  // the future, need to check if lepton Pt needs to be subtracted for both ele
3167  // and muon
3168  if (preparedInput.m_METsigmaP < 0.1 || preparedInput.m_METsigmaL < 0.1) {
3169 
3170  // T. Davidek: hack for lep-lep -- subtract lepton pT both for muon and
3171  // electron
3172  if ((m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2016MC15C ||
3173  m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2019) &&
3174  preparedInput.m_vistau1.M() < 0.12 && preparedInput.m_vistau2.M() < 0.12) { // lep-lep channel
3175  if (preparedInput.m_SumEt > preparedInput.m_vistau1.Pt())
3176  preparedInput.m_SumEt -= preparedInput.m_vistau1.Pt();
3177  if (preparedInput.m_SumEt > preparedInput.m_vistau2.Pt())
3178  preparedInput.m_SumEt -= preparedInput.m_vistau2.Pt();
3179  } else {
3180  // continue with the original code
3181  if (preparedInput.m_SumEt > preparedInput.m_vistau1.Pt() && preparedInput.m_vistau1.M() < 0.05 &&
3182  m_mmcCalibrationSet != MMCCalibrationSetV2::MMC2015HIGHMASS) {
3183  if (preparedInput.m_fUseVerbose == 1) {
3184  Info("DiTauMassTools", "Substracting pt1 from sumEt");
3185  }
3186  preparedInput.m_SumEt -= preparedInput.m_vistau1.Pt();
3187  }
3188  if (preparedInput.m_SumEt > preparedInput.m_vistau2.Pt() && preparedInput.m_vistau2.M() < 0.05 &&
3189  m_mmcCalibrationSet != MMCCalibrationSetV2::MMC2015HIGHMASS) {
3190  if (preparedInput.m_fUseVerbose == 1) {
3191  Info("DiTauMassTools", "Substracting pt2 from sumEt");
3192  }
3193  preparedInput.m_SumEt -= preparedInput.m_vistau2.Pt();
3194  }
3195  }
3196  }
3197 
3198  // controling TauProbability settings for UPGRADE studies
3199  if (m_mmcCalibrationSet == MMCCalibrationSetV2::UPGRADE &&
3200  preparedInput.m_fUseDefaults == 1) {
3201  if ((preparedInput.m_vistau1.M() < 0.12 && preparedInput.m_vistau2.M() > 0.12) ||
3202  (preparedInput.m_vistau2.M() < 0.12 && preparedInput.m_vistau1.M() > 0.12)) {
3203  Prob->SetUseTauProbability(true); // lep-had case
3204  }
3205  if (preparedInput.m_vistau1.M() > 0.12 && preparedInput.m_vistau2.M() > 0.12) {
3206  Prob->SetUseTauProbability(false); // had-had case
3207  }
3208  }
3209 
3210  // change Beam Energy for different running conditions
3211  preparedInput.m_beamEnergy = m_beamEnergy;
3212 
3213  //--------------------- pre-set defaults for Run-2. To disable pre-set
3214  // defaults set fUseDefaults=0
3215  if (preparedInput.m_fUseDefaults == 1) {
3216  if (m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2015HIGHMASS) {
3217  SetNsigmaMETscan_ll(4.0);
3218  SetNsigmaMETscan_lh(4.0);
3219  SetNsigmaMETscan_hh(4.0);
3220  preparedInput.m_fUseTailCleanup = 0;
3221  if ((preparedInput.m_vistau1.M() < 0.12 && preparedInput.m_vistau2.M() > 0.12) ||
3222  (preparedInput.m_vistau2.M() < 0.12 && preparedInput.m_vistau1.M() > 0.12))
3223  Prob->SetUseTauProbability(false); // lep-had
3224  if (preparedInput.m_tauTypes == TauTypes::hh)
3225  Prob->SetUseTauProbability(true); // had-had
3226  Prob->SetUseMnuProbability(false);
3227  }
3228  }
3229 
3230  // compute HTOffset if relevant
3231  if (Prob->GetUseHT()) // use missing Ht for Njet25=0 events
3232  {
3233  // dPhi(l-t) dependence of misHt-trueMET
3234  double HtOffset = 0.;
3235  // proper for hh
3236  if (preparedInput.m_tauTypes == TauTypes::hh) {
3237  // hh
3238  double x = preparedInput.m_DelPhiTT;
3239  HtOffset = 87.5 - 27.0 * x;
3240  }
3241 
3242  preparedInput.m_HtOffset = HtOffset;
3243 
3244  // if use HT, replace MET with HT
3245  preparedInput.m_METsigmaP =
3246  preparedInput.m_MHtSigma2; // sigma of 2nd Gaussian for missing Ht resolution
3247  preparedInput.m_METsigmaL = preparedInput.m_MHtSigma2;
3248 
3249  TLorentzVector tauSum = preparedInput.m_vistau1 + preparedInput.m_vistau2;
3250  preparedInput.m_MetVec.Set(-tauSum.Px(), -tauSum.Py()); // WARNING this replace metvec by -mht
3251  }
3252 }

◆ GetMarkovCountDuplicate()

int DiTauMassTools::MissingMassCalculatorV2::GetMarkovCountDuplicate ( ) const
inline

Definition at line 381 of file MissingMassCalculatorV2.h.

381 { return m_markovCountDuplicate; }

◆ GetMarkovNAccept()

int DiTauMassTools::MissingMassCalculatorV2::GetMarkovNAccept ( ) const
inline

Definition at line 384 of file MissingMassCalculatorV2.h.

384 { return m_markovNAccept; }

◆ GetMarkovNFullscan()

int DiTauMassTools::MissingMassCalculatorV2::GetMarkovNFullscan ( ) const
inline

Definition at line 385 of file MissingMassCalculatorV2.h.

385 { return m_markovNFullScan;}

◆ GetMarkovNRejectMetropolis()

int DiTauMassTools::MissingMassCalculatorV2::GetMarkovNRejectMetropolis ( ) const
inline

Definition at line 383 of file MissingMassCalculatorV2.h.

383 {return m_markovNRejectMetropolis;}

◆ GetMarkovNRejectNoSol()

int DiTauMassTools::MissingMassCalculatorV2::GetMarkovNRejectNoSol ( ) const
inline

Definition at line 382 of file MissingMassCalculatorV2.h.

382 { return m_markovNRejectNoSol;}

◆ GetMeanbinStop()

double DiTauMassTools::MissingMassCalculatorV2::GetMeanbinStop ( ) const
inline

Definition at line 378 of file MissingMassCalculatorV2.h.

378 { return m_meanbinStop;}

◆ GetmInvWidth2Error()

double DiTauMassTools::MissingMassCalculatorV2::GetmInvWidth2Error ( ) const
inline

Definition at line 402 of file MissingMassCalculatorV2.h.

402 {return m_PrintmInvWidth2Error;}

◆ GetmMaxError()

double DiTauMassTools::MissingMassCalculatorV2::GetmMaxError ( ) const
inline

Definition at line 400 of file MissingMassCalculatorV2.h.

400 {return m_PrintmMaxError;}

◆ GetmMeanError()

double DiTauMassTools::MissingMassCalculatorV2::GetmMeanError ( ) const
inline

Definition at line 401 of file MissingMassCalculatorV2.h.

401 { return m_PrintmMeanError;}

◆ GetNiterFit1()

int DiTauMassTools::MissingMassCalculatorV2::GetNiterFit1 ( ) const
inline

Definition at line 371 of file MissingMassCalculatorV2.h.

371 { return m_niter_fit1; } // number of iterations per loop in dPhi loop

◆ GetNiterFit2()

int DiTauMassTools::MissingMassCalculatorV2::GetNiterFit2 ( ) const
inline

Definition at line 372 of file MissingMassCalculatorV2.h.

372 { return m_niter_fit2; } // number of iterations per loop in MET loop

◆ GetNiterFit3()

int DiTauMassTools::MissingMassCalculatorV2::GetNiterFit3 ( ) const
inline

Definition at line 373 of file MissingMassCalculatorV2.h.

373 { return m_niter_fit3; } // number of iterations per loop in Mnu loop

◆ GetNiterRandom()

int DiTauMassTools::MissingMassCalculatorV2::GetNiterRandom ( ) const
inline

Definition at line 374 of file MissingMassCalculatorV2.h.

374 { return m_niterRandomLocal; } // number of random iterations

◆ GetNMetroReject()

int DiTauMassTools::MissingMassCalculatorV2::GetNMetroReject ( ) const
inline

Definition at line 405 of file MissingMassCalculatorV2.h.

405 {return m_markovNRejectMetropolis;}

◆ GetNNoSol()

int DiTauMassTools::MissingMassCalculatorV2::GetNNoSol ( ) const
inline

Definition at line 404 of file MissingMassCalculatorV2.h.

404 {return m_markovNRejectNoSol;}

◆ GetNSol()

int DiTauMassTools::MissingMassCalculatorV2::GetNSol ( ) const
inline

Definition at line 406 of file MissingMassCalculatorV2.h.

406 {return m_markovNAccept;}

◆ GetNsucStop()

int DiTauMassTools::MissingMassCalculatorV2::GetNsucStop ( ) const
inline

Definition at line 376 of file MissingMassCalculatorV2.h.

376 { return m_NsucStop; } // Arrest criteria for NSuc

◆ GetProposalTryEtau()

double DiTauMassTools::MissingMassCalculatorV2::GetProposalTryEtau ( ) const
inline

Definition at line 389 of file MissingMassCalculatorV2.h.

389 {return m_ProposalTryEtau;}

◆ GetProposalTryMEt()

double DiTauMassTools::MissingMassCalculatorV2::GetProposalTryMEt ( ) const
inline

Definition at line 386 of file MissingMassCalculatorV2.h.

386 {return m_proposalTryMEt;}

◆ GetProposalTryMnu()

double DiTauMassTools::MissingMassCalculatorV2::GetProposalTryMnu ( ) const
inline

Definition at line 388 of file MissingMassCalculatorV2.h.

388 {return m_ProposalTryMnu;}

◆ GetProposalTryPhi()

double DiTauMassTools::MissingMassCalculatorV2::GetProposalTryPhi ( ) const
inline

Definition at line 387 of file MissingMassCalculatorV2.h.

387 {return m_ProposalTryPhi;}

◆ GetRMSStop()

int DiTauMassTools::MissingMassCalculatorV2::GetRMSStop ( ) const
inline

Definition at line 377 of file MissingMassCalculatorV2.h.

377 { return m_RMSStop; }

◆ GetRndmSeedAltering()

int DiTauMassTools::MissingMassCalculatorV2::GetRndmSeedAltering ( ) const
inline

Definition at line 379 of file MissingMassCalculatorV2.h.

379 { return m_RndmSeedAltering; } // number of iterations per loop in Mnu loop

◆ GetUseEfficiencyRecovery()

bool DiTauMassTools::MissingMassCalculatorV2::GetUseEfficiencyRecovery ( ) const
inline

Definition at line 369 of file MissingMassCalculatorV2.h.

369 { return m_fUseEfficiencyRecovery; }

◆ handleSolutions()

void MissingMassCalculatorV2::handleSolutions ( )
inlineprotected

Definition at line 2167 of file MissingMassCalculatorV2.cxx.

2169 {
2170 
2171  bool reject = true;
2172  double totalProbSumSol = 0.;
2173  double totalProbSumSolOld = 0.;
2174  bool firstPointWithSol = false;
2175 
2176  for (int isol = 0; isol < m_nsol; ++isol) {
2177  totalProbSumSol += m_probFinalSolVec[isol];
2178  }
2179 
2180  double uMC = -1.;
2181  bool notSureToKeep = true;
2182  // note : if no solution, the point is treated as having a zero probability
2183  if (m_fullParamSpaceScan) {
2184  reject = false; // accept anyway in this mode
2185  notSureToKeep = false; // do not need to test on prob
2186  if (m_nsol <= 0) {
2187  // if initial full scaning and no sol : continue
2188  m_markovNFullScan += 1;
2189  } else {
2190  // if we were in in full scan mode and we have a solution, switch it off
2191  m_fullParamSpaceScan = false;
2192  firstPointWithSol = true; // as this is the first point without a solution
2193  // there is no old sol
2194  m_iter0 = 0; // reset the counter so that separately the full scan pphase
2195  // and the markov phase use m_niterRandomLocal points
2196  // hack for hh : allow 10 times less iteration for markov than for the
2197  // fullscan phase
2198  if (preparedInput.m_tauTypes == TauTypes::hh) {
2199  m_niterRandomLocal /= 10;
2200  }
2201  }
2202  }
2203 
2204  if (notSureToKeep) {
2205  // apply Metropolis algorithm to decide to keep this point.
2206  // compute the probability of the previous point and the current one
2207  for (int isol = 0; isol < m_nsolOld; ++isol) {
2208  totalProbSumSolOld += m_probFinalSolOldVec[isol];
2209  }
2210 
2211  // accept anyway if null old probability (should only happen for the very
2212  // first point with a solution)
2213  if (!firstPointWithSol && totalProbSumSolOld <= 0.) {
2214  Error("DiTauMassTools", "%s",
2215  (" ERROR null old probability !!! " + std::to_string(totalProbSumSolOld) + " nsolOld " +
2216  std::to_string(m_nsolOld))
2217  .c_str());
2218  reject = false;
2219  } else if (totalProbSumSol > totalProbSumSolOld) {
2220  // if going up, accept anyway
2221  reject = false;
2222  // else if (totalProbSumSol < 1E-16) { // if null target probability,
2223  // reject anyway
2224  } else if (totalProbSumSol < totalProbSumSolOld * 1E-6) { // if ratio of probability <1e6, point
2225  // will be accepted only every 1E6
2226  // iteration, so can reject anyway
2227  reject = true;
2228  } else if (m_nsol <= 0) { // new parametrisation give prob too small to
2229  // trigger above condition if no solution is found
2230  reject = true;
2231  } else {
2232  // if going down, reject with a probability
2233  // 1-totalProbSum/totalProbSumOld)
2234  uMC = m_randomGen.Rndm();
2235  reject = (uMC > totalProbSumSol / totalProbSumSolOld);
2236  }
2237  } // if reject
2238 
2239  // proceed with the handling of the solutions wether the old or the new ones
2240 
2241  // optionally fill the vectors with the complete list of points (for all
2242  // walkstrategy)
2243 
2244  if (reject) {
2245  // current point reset to the previous one
2246  // Note : only place where m_MEtP etc... are modified outside spacewalkerXYZ
2247  m_MEtP = m_MEtP0;
2248  m_MEtL = m_MEtL0;
2249  m_Phi1 = m_Phi10;
2250  m_Phi2 = m_Phi20;
2251  m_eTau1 = m_eTau10;
2252  m_eTau2 = m_eTau20;
2253  if (m_scanMnu1)
2254  m_Mnu1 = m_Mnu10;
2255  if (m_scanMnu2)
2256  m_Mnu2 = m_Mnu20;
2257  }
2258 
2259  // default case : fill the histogram with solution, using current point
2260  bool fillSolution = true;
2261  bool oldToBeUsed = false;
2262 
2263  // now handle the reject or accept cases
2264  // the tricky thing is that for markov, we accept the old point as soon as a
2265  // new accepted point is found with a weight equal to one plus the number of
2266  // rejected point inbetween
2267 
2268  if (reject) {
2269  fillSolution = false; // do not fill solution, just count number of replication
2270  m_markovCountDuplicate += 1;
2271  if (m_nsol <= 0) {
2272  m_markovNRejectNoSol += 1;
2273  } else {
2274  m_markovNRejectMetropolis += 1;
2275  }
2276 
2277  } else {
2278  // if accept, will fill solution (except for very first point) but taking
2279  // the values from the previous point
2280  if (!m_fullParamSpaceScan) {
2281  m_markovNAccept += 1;
2282  }
2283  if (!firstPointWithSol) {
2284  fillSolution = true;
2285  oldToBeUsed = true;
2286  } else {
2287  fillSolution = false;
2288  }
2289  } // else reject
2290 
2291  // if do not fill solution exit now
2292  // for the first point with solution we need to copy the new sol into the old
2293  // one before leaving
2294  if (!fillSolution) {
2295  if (firstPointWithSol) {
2296  // current point is the future previous one
2297  m_nsolOld = m_nsol;
2298  for (int isol = 0; isol < m_nsol; ++isol) {
2299  m_probFinalSolOldVec[isol] = m_probFinalSolVec[isol];
2300  m_mtautauFinalSolOldVec[isol] = m_mtautauFinalSolVec[isol];
2301  m_nu1FinalSolOldVec[isol] = m_nu1FinalSolVec[isol];
2302  m_nu2FinalSolOldVec[isol] = m_nu2FinalSolVec[isol];
2303  }
2304  }
2305  return;
2306  }
2307 
2308  // compute RMS of the different solutions
2309  double solSum = 0.;
2310  double solSum2 = 0.;
2311 
2312  for (int isol = 0; isol < m_nsol; ++isol) {
2313  ++m_iter5;
2314  double totalProb;
2315  double mtautau;
2316  const TLorentzVector *pnuvec1_tmpj;
2317  const TLorentzVector *pnuvec2_tmpj;
2318 
2319  if (oldToBeUsed) {
2320  totalProb = m_probFinalSolOldVec[isol];
2321  mtautau = m_mtautauFinalSolOldVec[isol];
2322  pnuvec1_tmpj = &m_nu1FinalSolOldVec[isol];
2323  pnuvec2_tmpj = &m_nu2FinalSolOldVec[isol];
2324  } else {
2325  totalProb = m_probFinalSolVec[isol];
2326  mtautau = m_mtautauFinalSolVec[isol];
2327  pnuvec1_tmpj = &m_nu1FinalSolVec[isol];
2328  pnuvec2_tmpj = &m_nu2FinalSolVec[isol];
2329  }
2330  const TLorentzVector &nuvec1_tmpj = *pnuvec1_tmpj;
2331  const TLorentzVector &nuvec2_tmpj = *pnuvec2_tmpj;
2332 
2333  solSum += mtautau;
2334  solSum2 += mtautau * mtautau;
2335 
2336  double weight;
2337  // MarkovChain : accepted events already distributed according to
2338  // probability distribution, so weight is 1. acutally to have a proper
2339  // estimate of per bin error, instead of putting several time the same point
2340  // when metropolis alg reject one (or no solution), rather put it with the
2341  // multiplicity weight. Should only change the error bars might change if
2342  // weighted markov chain are used there is also an issue with the 4 very
2343  // close nearly identical solution
2344  weight = m_markovCountDuplicate +
2345  1; // incremented only when a point is rejected, hence need to add 1
2346 
2347  m_fMfit_all->Fill(mtautau, weight);
2348 #ifdef SAVELIKELIHOODHISTO
2349  m_fMEtP_all->Fill(m_MEtP, weight);
2350  m_fMEtL_all->Fill(m_MEtL, weight);
2351  m_fMnu1_all->Fill(m_Mnu1, weight);
2352  m_fMnu2_all->Fill(m_Mnu2, weight);
2353  m_fPhi1_all->Fill(m_Phi1, weight);
2354  m_fPhi2_all->Fill(m_Phi2, weight);
2355  if (mtautau != 0. && weight != 0.)
2356  m_fMfit_allGraph->SetPoint(m_iter0, mtautau, -TMath::Log(weight));
2357 #endif
2358  m_fMfit_allNoWeight->Fill(mtautau, 1.);
2359 
2360  // m_fPXfit1->Fill(nuvec1_tmpj.Px(),weight);
2361  // m_fPYfit1->Fill(nuvec1_tmpj.Py(),weight);
2362  // m_fPZfit1->Fill(nuvec1_tmpj.Pz(),weight);
2363  // m_fPXfit2->Fill(nuvec2_tmpj.Px(),weight);
2364  // m_fPYfit2->Fill(nuvec2_tmpj.Py(),weight);
2365  // m_fPZfit2->Fill(nuvec2_tmpj.Pz(),weight);
2366 
2367  //----------------- using P*fit to fill Px,y,z_tau
2368  // Note that the original vistau are used there deliberately,
2369  // since they will be subtracted after histogram fitting
2370  // DR, kudos Antony Lesage : do not create temporary TLV within each Fill,
2371  // saves 10% CPU
2372  m_fPXfit1->Fill(preparedInput.m_vistau1.Px() + nuvec1_tmpj.Px(), totalProb);
2373  m_fPYfit1->Fill(preparedInput.m_vistau1.Py() + nuvec1_tmpj.Py(), totalProb);
2374  m_fPZfit1->Fill(preparedInput.m_vistau1.Pz() + nuvec1_tmpj.Pz(), totalProb);
2375  m_fPXfit2->Fill(preparedInput.m_vistau2.Px() + nuvec2_tmpj.Px(), totalProb);
2376  m_fPYfit2->Fill(preparedInput.m_vistau2.Py() + nuvec2_tmpj.Py(), totalProb);
2377  m_fPZfit2->Fill(preparedInput.m_vistau2.Pz() + nuvec2_tmpj.Pz(), totalProb);
2378 
2379  // fill histograms for floating stopping criterion, split randomly
2380  if (m_fUseFloatStopping) {
2381  if (m_randomGen.Rndm() <= 0.5) {
2382  m_fMmass_split1->Fill(mtautau, weight);
2383  m_fMEtP_split1->Fill(m_MEtP, weight);
2384  m_fMEtL_split1->Fill(m_MEtL, weight);
2385  m_fMnu1_split1->Fill(m_Mnu1, weight);
2386  m_fMnu2_split1->Fill(m_Mnu2, weight);
2387  m_fPhi1_split1->Fill(m_Phi1, weight);
2388  m_fPhi2_split1->Fill(m_Phi2, weight);
2389  } else {
2390  m_fMmass_split2->Fill(mtautau, weight);
2391  m_fMEtP_split2->Fill(m_MEtP, weight);
2392  m_fMEtL_split2->Fill(m_MEtL, weight);
2393  m_fMnu1_split2->Fill(m_Mnu1, weight);
2394  m_fMnu2_split2->Fill(m_Mnu2, weight);
2395  m_fPhi1_split2->Fill(m_Phi1, weight);
2396  m_fPhi2_split2->Fill(m_Phi2, weight);
2397  }
2398  }
2399 
2400  if (totalProb > m_prob_tmp) // fill solution with highest probability
2401  {
2402  m_prob_tmp = totalProb;
2403  m_fDitauStuffFit.Mditau_best = mtautau;
2404  m_fDitauStuffFit.Sign_best = -log10(totalProb);
2405  ;
2406  m_fDitauStuffFit.nutau1 = nuvec1_tmpj;
2407  m_fDitauStuffFit.nutau2 = nuvec2_tmpj;
2408  m_fDitauStuffFit.vistau1 = m_tauVec1;
2409  m_fDitauStuffFit.vistau2 = m_tauVec2;
2410  }
2411  } // loop on solutions
2412 
2413  m_markovCountDuplicate = 0; // now can reset the duplicate count
2414 
2415  if (oldToBeUsed) {
2416  // current point is the future previous one
2417  // TLV copy not super efficient but not dramatic
2418  m_nsolOld = m_nsol;
2419  for (int isol = 0; isol < m_nsol; ++isol) {
2420  m_probFinalSolOldVec[isol] = m_probFinalSolVec[isol];
2421  m_mtautauFinalSolOldVec[isol] = m_mtautauFinalSolVec[isol];
2422  m_nu1FinalSolOldVec[isol] = m_nu1FinalSolVec[isol];
2423  m_nu2FinalSolOldVec[isol] = m_nu2FinalSolVec[isol];
2424  }
2425  }
2426 
2427  // compute rms of solutions
2428  const double solRMS = sqrt(solSum2 / m_nsol - std::pow(solSum / m_nsol, 2));
2429  OutputInfo.m_AveSolRMS += solRMS;
2430 
2431  return;
2432 }

◆ MassScale()

double MissingMassCalculatorV2::MassScale ( int  method,
double  mass,
const int &  tau_type1,
const int &  tau_type2 
)
inlineprotected

Definition at line 2110 of file MissingMassCalculatorV2.cxx.

2111  {
2112  double Fscale = 1.0;
2113  // calibration for rel16 lep-had analysis only
2114  if (m_fApplyMassScale == 1) {
2115  if (preparedInput.m_tauTypes == TauTypes::lh) {
2116  if (method != 1)
2117  return 1.0;
2118  // float p0, p1, p2, p3;
2119  // if(tau_type1==1 || tau_type2==1) // 1-prong tau's
2120  // {
2121  // p0=3.014; p1=-71.86; p2=1.018; p3=0.8912;
2122  // if(mass>91.2) Fscale=p0/(p1+p2*mass)+p3;
2123  // else Fscale=p0/(p1+p2*91.2)+p3;
2124  // }
2125  // if(tau_type1==3 || tau_type2==3) // 3-prong tau's
2126  // {
2127  // p0=0.4576; p1=-84.22; p2=0.9783; p3=0.9136;
2128  // if(mass>91.2) Fscale=p0/(p1+p2*mass)+p3;
2129  // else Fscale=p0/(p1+p2*91.2)+p3;
2130  // }
2131  // if(Fscale>1.0) Fscale=1.0;
2132  // if(Fscale<0.89) Fscale=0.89;
2133 
2134  float p0, p1, p2, p3, p4, p5, p6, p7;
2135  if ((tau_type1 >= 0 && tau_type1 <= 2) || (tau_type2 >= 0 && tau_type2 <= 2))
2136  return 1.0; // 1-prong tau's
2137  if ((tau_type1 >= 3 && tau_type1 <= 5) || (tau_type2 >= 3 && tau_type2 <= 5)) // 3-prong tau's
2138  {
2139  p0 = 3.014;
2140  p1 = -71.86;
2141  p2 = 1.018;
2142  p3 = 0.8912;
2143  p4 = 0.4576;
2144  p5 = -84.22;
2145  p6 = 0.9783;
2146  p7 = 0.9136;
2147  double scale1 = p0 / (p1 + p2 * mass) + p3;
2148  double scale3 = p4 / (p5 + p6 * mass) + p7;
2149  if (mass > 91.2)
2150  Fscale = scale3 / scale1;
2151  else {
2152  scale1 = p0 / (p1 + p2 * 91.2) + p3;
2153  scale3 = p4 / (p5 + p6 * 91.2) + p7;
2154  Fscale = scale3 / scale1;
2155  }
2156  }
2157  if (Fscale > 1.0)
2158  Fscale = 1.0;
2159  if (Fscale < 0.95)
2160  Fscale = 0.95;
2161  }
2162  }
2163  return 1.0 / Fscale;
2164 }

◆ maxFitting()

Double_t MissingMassCalculatorV2::maxFitting ( Double_t *  x,
Double_t *  par 
)

Definition at line 1562 of file MissingMassCalculatorV2.cxx.

1564 {
1565  // parabola with parameters max, mean and invwidth
1566  const double mM = x[0];
1567  const double mMax = par[0];
1568  const double mMean = par[1];
1569  const double mInvWidth2 = par[2]; // if param positif distance between intersection of the
1570  // parabola with x axis: 1/Sqrt(mInvWidth2)
1571  const double fitval = mMax * (1 - 4 * mInvWidth2 * std::pow(mM - mMean, 2));
1572  return fitval;
1573 }

◆ maxFromHist() [1/2]

double DiTauMassTools::MissingMassCalculatorV2::maxFromHist ( const std::shared_ptr< TH1F > &  theHist,
std::vector< double > &  histInfo,
const MaxHistStrategyV2::e  maxHistStrategy = MaxHistStrategyV2::FIT,
const int  winHalfWidth = 2,
bool  debug = false 
)
inline

Definition at line 415 of file MissingMassCalculatorV2.h.

415  {
416  return maxFromHist(theHist.get(), histInfo, maxHistStrategy, winHalfWidth, debug);
417  }

◆ maxFromHist() [2/2]

double MissingMassCalculatorV2::maxFromHist ( TH1F *  theHist,
std::vector< double > &  histInfo,
const MaxHistStrategyV2::e  maxHistStrategy = MaxHistStrategyV2::FIT,
const int  winHalfWidth = 2,
bool  debug = false 
)

Definition at line 1582 of file MissingMassCalculatorV2.cxx.

1584  {
1585  // namespace HistInfo
1586  // enum e {
1587  // PROB=0,INTEGRAL,CHI2,DISCRI,TANTHETA,TANTHETAW,FITLENGTH,RMS,RMSVSDISCRI,MAXHISTINFO
1588  // };
1589  double maxPos = 0.;
1590  double prob = 0.;
1591 
1592  for (std::vector<double>::iterator itr = histInfo.begin(); itr != histInfo.end(); ++itr) {
1593  *itr = -1;
1594  }
1595 
1596  histInfo[HistInfoV2::INTEGRAL] = theHist->Integral();
1597 
1598  if (maxHistStrategy == MaxHistStrategyV2::MAXBIN ||
1599  ((maxHistStrategy == MaxHistStrategyV2::MAXBINWINDOW ||
1600  maxHistStrategy == MaxHistStrategyV2::SLIDINGWINDOW) &&
1601  winHalfWidth == 0)) {
1602 
1603  // simple max search
1604  // original version, simple bin maximum
1605  int max_bin = theHist->GetMaximumBin();
1606  maxPos = theHist->GetBinCenter(max_bin);
1607 
1608  // FIXME GetEntries is unweighted
1609  prob = theHist->GetBinContent(max_bin) / double(theHist->GetEntries());
1610  if (prob > 1.)
1611  prob = 1.;
1612  histInfo[HistInfoV2::PROB] = prob;
1613  return maxPos;
1614  }
1615 
1616  int hNbins = theHist->GetNbinsX();
1617 
1618  if (maxHistStrategy == MaxHistStrategyV2::MAXBINWINDOW) {
1619  // average around maximum bin (nearly useless in fact)
1620  // could be faster
1621  int max_bin = theHist->GetMaximumBin();
1622  int iBinMin = max_bin - winHalfWidth;
1623  if (iBinMin < 0)
1624  iBinMin = 0;
1625  int iBinMax = max_bin + winHalfWidth;
1626  if (iBinMax > hNbins)
1627  iBinMax = hNbins - 1;
1628  double sumw = 0;
1629  double sumx = 0;
1630  for (int iBin = iBinMin; iBin <= iBinMax; ++iBin) {
1631  const double weight = theHist->GetBinContent(iBin);
1632  sumw += weight;
1633  sumx += weight * theHist->GetBinCenter(iBin);
1634  }
1635  maxPos = sumx / sumw;
1636 
1637  // FIXME GetEntries is unweighted
1638  prob = sumw / theHist->GetEntries();
1639  if (prob > 1.)
1640  prob = 1.;
1641 
1642  return maxPos;
1643  }
1644 
1645  // now compute sliding window anyway
1646  if (maxHistStrategy != MaxHistStrategyV2::SLIDINGWINDOW &&
1647  maxHistStrategy != MaxHistStrategyV2::FIT) {
1648  Error("DiTauMassTools", "%s",
1649  ("ERROR undefined maxHistStrategy:" + std::to_string(maxHistStrategy)).c_str());
1650  return -10.;
1651  }
1652 
1653  // first iteration to find the first and last non zero bin, and the histogram
1654  // integral (not same as Entries because of weights)
1655  int lastNonZeroBin = -1;
1656  int firstNonZeroBin = -1;
1657  double totalSumw = 0.;
1658  bool firstNullPart = true;
1659  for (int iBin = 0; iBin < hNbins; ++iBin) {
1660  const double weight = theHist->GetBinContent(iBin);
1661  if (weight > 0) {
1662  totalSumw += weight;
1663  lastNonZeroBin = iBin;
1664  if (firstNullPart) {
1665  firstNullPart = false;
1666  firstNonZeroBin = iBin;
1667  }
1668  }
1669  }
1670 
1671  // enlarge first and last non zero bin with window width to avoid side effect
1672  // (maximum close to the edge)
1673  firstNonZeroBin = std::max(0, firstNonZeroBin - winHalfWidth - 1);
1674  lastNonZeroBin = std::min(hNbins - 1, lastNonZeroBin + winHalfWidth + 1);
1675 
1676  // if null histogram quit
1677  if (firstNullPart)
1678  return maxPos;
1679 
1680  // determine the size of the sliding window in the fit case
1681 
1682  // sliding window
1683  const int nwidth = 2 * winHalfWidth + 1;
1684  double winsum = 0.;
1685 
1686  for (int ibin = 0; ibin < nwidth; ++ibin) {
1687  winsum += theHist->GetBinContent(ibin);
1688  }
1689  double winmax = winsum;
1690 
1691  int max_bin = 0.;
1692  int iBinL = firstNonZeroBin;
1693  int iBinR = iBinL + 2 * winHalfWidth;
1694  bool goingUp = true;
1695 
1696  do {
1697  ++iBinL;
1698  ++iBinR;
1699  const double deltawin = theHist->GetBinContent(iBinR) - theHist->GetBinContent(iBinL - 1);
1700 
1701  if (deltawin < 0) {
1702  if (goingUp) {
1703  // if were climbing and now loose more on the left
1704  // than win on the right. This was a local maxima
1705  if (winsum > winmax) {
1706  // global maximum one so far
1707  winmax = winsum;
1708  max_bin = (iBinR + iBinL) / 2 - 1;
1709  }
1710  goingUp = false; // now going down
1711  }
1712  } else {
1713  // do not care about minima, simply indicate we are going down
1714  goingUp = true;
1715  }
1716 
1717  winsum += deltawin;
1718 
1719  } while (iBinR < lastNonZeroBin);
1720 
1721  // now compute average
1722  int iBinMin = max_bin - winHalfWidth;
1723  if (iBinMin < 0)
1724  iBinMin = 0;
1725  int iBinMax = max_bin + winHalfWidth;
1726  if (iBinMax >= hNbins)
1727  iBinMax = hNbins - 1;
1728  double sumw = 0;
1729  double sumx = 0;
1730  for (int iBin = iBinMin; iBin <= iBinMax; ++iBin) {
1731  const double weight = theHist->GetBinContent(iBin);
1732  sumw += weight;
1733  sumx += weight * theHist->GetBinCenter(iBin);
1734  }
1735 
1736  double maxPosWin = -1.;
1737 
1738  if (sumw > 0.) {
1739  maxPosWin = sumx / sumw;
1740  }
1741  // prob if the fraction of events in the window
1742  prob = sumw / totalSumw;
1743 
1744  // Definitions of some useful parameters
1745 
1746  const double h_rms = theHist->GetRMS(1);
1747  histInfo[HistInfoV2::RMS] = h_rms;
1748 
1749  double num = 0;
1750  double numerator = 0;
1751  double denominator = 0;
1752  bool nullBin = false;
1753 
1754  for (int i = iBinMin; i < iBinMax; ++i) {
1755  double binError = theHist->GetBinError(i);
1756  if (binError < 1e-10) {
1757  nullBin = true;
1758  }
1759  double binErrorSquare = std::pow(binError, 2);
1760  num = theHist->GetBinContent(i) / (binErrorSquare);
1761  numerator = numerator + num;
1762  denominator = denominator + (1 / (binErrorSquare));
1763  }
1764  if (numerator < 1e-10 || denominator < 1e-10 || nullBin == true) {
1765  histInfo[HistInfoV2::MEANBIN] = -1;
1766  } else {
1767  histInfo[HistInfoV2::MEANBIN] = sqrt(1 / denominator) / (numerator / denominator);
1768  }
1769 
1770  // stop here if only looking for sliding window
1771  if (maxHistStrategy == MaxHistStrategyV2::SLIDINGWINDOW) {
1772  return maxPosWin;
1773  }
1774 
1775  maxPos = maxPosWin;
1776  // now FIT maxHistStrategy==MaxHistStrategyV2::FIT
1777 
1778  // now mass fit in range defined by sliding window
1779  // window will be around maxPos
1780  const double binWidth = theHist->GetBinCenter(2) - theHist->GetBinCenter(1);
1781  double fitWidth = (winHalfWidth + 0.5) * binWidth;
1782  // fit range 2 larger than original window range, 3 if less than 20% of the
1783  // histogram in slinding window
1784 
1785  if (prob > 0.2) {
1786  fitWidth *= 2.;
1787  } else {
1788  fitWidth *= 3.;
1789  }
1790  // fit option : Q == Quiet, no printout S result of the fit returned in
1791  // TFitResultPtr N do not draw the resulting function
1792 
1793  // if debug plot the fitted function
1794  TString fitOption = debug ? "QS" : "QNS";
1795  // root fit
1796  // Sets initial values
1797  m_fFitting->SetParameters(sumw / winHalfWidth, maxPos, 0.0025);
1798  // TFitResultPtr
1799  // fitRes=theHist->Fit("pol2",fitOption,"",maxPos-fitWidth,maxPos+fitWidth);
1800  TFitResultPtr fitRes =
1801  theHist->Fit(m_fFitting, fitOption, "", maxPos - fitWidth, maxPos + fitWidth);
1802 
1803  double maxPosFit = -1.;
1804 
1805  if (int(fitRes) == 0) {
1806  // root fit
1807  histInfo[HistInfoV2::CHI2] = fitRes->Chi2();
1808  const double mMax = fitRes->Parameter(0);
1809  const double mMean = fitRes->Parameter(1);
1810  const double mInvWidth2 = fitRes->Parameter(2);
1811  double mMaxError = fitRes->ParError(0);
1812  m_PrintmMaxError = mMaxError;
1813  double mMeanError = fitRes->ParError(1);
1814  m_PrintmMeanError = mMeanError;
1815  double mInvWidth2Error = fitRes->ParError(2);
1816  m_PrintmInvWidth2Error = mInvWidth2Error;
1817  mMeanError = 0.; // avoid warning
1818  mInvWidth2Error = 0.; // avoid warning
1819  const double c = mMax * (1 - 4 * mMean * mMean * mInvWidth2);
1820  const double b = 8 * mMax * mMean * mInvWidth2;
1821  const double a = -4 * mMax * mInvWidth2;
1822  // when built in polynomial fit
1823  // const double c=fitRes->Parameter(0);
1824  // const double b=fitRes->Parameter(1);
1825  // const double a=fitRes->Parameter(2);
1826 
1827  const double h_discri = b * b - 4 * a * c;
1828  histInfo[HistInfoV2::DISCRI] = h_discri;
1829  const double sqrth_discri = sqrt(h_discri);
1830  const double h_fitLength = sqrth_discri / a;
1831  histInfo[HistInfoV2::FITLENGTH] = h_fitLength;
1832  histInfo[HistInfoV2::TANTHETA] = 2 * a / sqrth_discri;
1833  histInfo[HistInfoV2::TANTHETAW] = 2 * a * sumw / sqrth_discri;
1834  histInfo[HistInfoV2::RMSVSDISCRI] = h_rms / h_fitLength;
1835  // compute maximum position (only if inverted parabola)
1836  if (a < 0)
1837  maxPosFit = -b / (2 * a);
1838  }
1839 
1840  // keep fit result only if within 80% of fit window, and fit succeeded
1841  if (maxPosFit >= 0. and std::abs(maxPosFit - maxPosWin) < 0.8 * fitWidth) {
1842  histInfo[HistInfoV2::PROB] = prob;
1843  return maxPosFit;
1844  } else {
1845  // otherwise keep the weighted average
1846  // negate prob just to flag such event
1847  prob = -prob;
1848  histInfo[HistInfoV2::PROB] = prob;
1849  return maxPosWin;
1850  }
1851 }

◆ NuPsolution()

int MissingMassCalculatorV2::NuPsolution ( TVector2  met_vec,
double  theta1,
double  phi1,
double  theta2,
double  phi2,
double &  P1,
double &  P2 
)
private

Definition at line 2939 of file MissingMassCalculatorV2.cxx.

2941  {
2942  int solution_code = 0; // 0== no solution, 1==with solution
2943  P1 = 0.0;
2944  P2 = 0.0;
2945  double D = sin(theta1) * sin(theta2) * sin(phi2 - phi1);
2946  if (std::abs(D) > 0.0) // matrix deteriminant is non-zero
2947  {
2948  P1 = (met_vec.Px() * sin(phi2) - met_vec.Py() * cos(phi2)) * sin(theta2) / D;
2949  P2 = (met_vec.Py() * cos(phi1) - met_vec.Px() * sin(phi1)) * sin(theta1) / D;
2950  if (P1 > 0.0 && P2 > 0.0)
2951  solution_code = 1;
2952  }
2953  return solution_code;
2954 }

◆ NuPsolutionLFV()

int MissingMassCalculatorV2::NuPsolutionLFV ( const TVector2 &  met_vec,
const TLorentzVector &  tau,
const double &  m_nu,
std::vector< TLorentzVector > &  nu_vec 
)
inlineprivate

Definition at line 828 of file MissingMassCalculatorV2.cxx.

830  {
831  int solution_code = 0; // 0 with no solution, 1 with solution
832 
833  nu_vec.clear();
834  TLorentzVector nu(0.0, 0.0, 0.0, 0.0);
835  TLorentzVector nu2(0.0, 0.0, 0.0, 0.0);
836  nu.SetXYZM(met_vec.Px(), met_vec.Py(), 0.0, l_nu);
837  nu2.SetXYZM(met_vec.Px(), met_vec.Py(), 0.0, l_nu);
838 
839  const double Mtau = 1.777;
840  // double msq = (Mtau*Mtau-tau.M()*tau.M())/2;
841  double msq = (Mtau * Mtau - tau.M() * tau.M() - l_nu * l_nu) /
842  2; // to take into account the fact that 2-nu systema has mass
843  double gamma = nu.Px() * nu.Px() + nu.Py() * nu.Py();
844  double beta = tau.Px() * nu.Px() + tau.Py() * nu.Py() + msq;
845  double a = tau.E() * tau.E() - tau.Pz() * tau.Pz();
846  double b = -2 * tau.Pz() * beta;
847  double c = tau.E() * tau.E() * gamma - beta * beta;
848  if ((b * b - 4 * a * c) < 0)
849  return solution_code; // no solution found
850  else
851  solution_code = 2;
852  double pvz1 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a);
853  double pvz2 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a);
854  nu.SetXYZM(met_vec.Px(), met_vec.Py(), pvz1, l_nu);
855  nu2.SetXYZM(met_vec.Px(), met_vec.Py(), pvz2, l_nu);
856  nu_vec.push_back(nu);
857  nu_vec.push_back(nu2);
858  return solution_code;
859 }

◆ NuPsolutionV3()

int MissingMassCalculatorV2::NuPsolutionV3 ( const double &  mNu1,
const double &  mNu2,
const double &  phi1,
const double &  phi2,
int &  nsol1,
int &  nsol2 
)
inlineprivate

Definition at line 623 of file MissingMassCalculatorV2.cxx.

625  {
626 
627  // Pv1, Pv2 : visible tau decay product momentum
628  // Pn1 Pn2 : neutrino momentum
629  // phi1, phi2 : neutrino azymutal angles
630  // PTmiss2=PTmissy Cos[phi2] - PTmissx Sin[phi2]
631  // PTmiss2cscdphi=PTmiss2/Sin[phi1-phi2]
632  // Pv1proj=Pv1x Cos[phi1] + Pv1y Sin[phi1]
633  // M2noma1=Mtau^2-Mv1^2-Mn1^2
634  // ETv1^2=Ev1^2-Pv1z^2
635 
636  // discriminant : 16 Ev1^2 (M2noma1^2 + 4 M2noma1 PTmiss2cscdphi Pv1proj - 4
637  // (ETv1^2 (Mn1^2 + PTmiss2cscdphi^2) - PTmiss2cscdphi^2 Pv1proj^2))
638  // two solutions for epsilon = +/-1
639  // Pn1z=(1/(2 ETv1^2))(epsilon Ev1 Sqrt[ M2noma1^2 + 4 M2noma1 PTmiss2cscdphi
640  // Pv1proj - 4 (ETv1^2 (Mn1^2 + qPTmiss2cscdphi^2) - PTmiss2cscdphi^2
641  // Pv1proj^2)] + M2noma1 Pv1z + 2 PTmiss2cscdphi Pv1proj Pv1z)
642  // with conditions: M2noma1 + 2 PTmiss2cscdphi Pv1proj + 2 Pn1z Pv1z > 0
643  // PTn1 -> PTmiss2 Csc[phi1 - phi2]
644 
645  // if initialisation precompute some quantities
646  int solution_code = 0; // 0 with no solution, 1 with solution
647  nsol1 = 0;
648  nsol2 = 0;
649 
650  // Variables used to test PTn1 and PTn2 > 0
651 
652  const double &pTmissx = preparedInput.m_MEtX;
653  const double &pTmissy = preparedInput.m_MEtY;
654 
655  fastSinCos(phi2, m_sinPhi2, m_cosPhi2);
656  double pTmiss2 = pTmissy * m_cosPhi2 - pTmissx * m_sinPhi2;
657 
658  int dPhiSign = 0;
659  dPhiSign = fixPhiRange(phi1 - phi2) > 0 ? +1 : -1;
660 
661  // Test if PTn1 and PTn2 > 0. Then MET vector is between the two neutrino
662  // vector
663 
664  if (pTmiss2 * dPhiSign < 0) {
665  ++m_testptn1;
666  return solution_code;
667  }
668 
669  fastSinCos(phi1, m_sinPhi1, m_cosPhi1);
670  double pTmiss1 = pTmissy * m_cosPhi1 - pTmissx * m_sinPhi1;
671 
672  if (pTmiss1 * (-dPhiSign) < 0) {
673  ++m_testptn2;
674  return solution_code;
675  }
676 
677  // Variables used to calculate discri1
678 
679  double m2Vis1 = m_tauVec1M * m_tauVec1M;
680  m_ET2v1 = std::pow(m_tauVec1E, 2) - std::pow(m_tauVec1Pz, 2);
681  m_m2Nu1 = mNu1 * mNu1;
682  double m2noma1 = m_mTau2 - m_m2Nu1 - m2Vis1;
683  double m4noma1 = m2noma1 * m2noma1;
684  double pv1proj = m_tauVec1Px * m_cosPhi1 + m_tauVec1Py * m_sinPhi1;
685  double p2v1proj = std::pow(pv1proj, 2);
686  double sinDPhi2 = m_cosPhi2 * m_sinPhi1 - m_sinPhi2 * m_cosPhi1; // sin(Phi1-Phi2)
687  double pTmiss2CscDPhi = pTmiss2 / sinDPhi2;
688  double &pTn1 = pTmiss2CscDPhi;
689  double pT2miss2CscDPhi = pTmiss2CscDPhi * pTmiss2CscDPhi;
690 
691  // Test on discri1
692  const double discri1 = m4noma1 + 4 * m2noma1 * pTmiss2CscDPhi * pv1proj -
693  4 * (m_ET2v1 * (m_m2Nu1 + pT2miss2CscDPhi) - (pT2miss2CscDPhi * p2v1proj));
694 
695  if (discri1 < 0) // discriminant negative -> no solution
696  {
697  ++m_testdiscri1;
698  return solution_code;
699  }
700 
701  // Variables used to calculate discri2
702  double m2Vis2 = m_tauVec2M * m_tauVec2M;
703  m_ET2v2 = std::pow(m_tauVec2E, 2) - std::pow(m_tauVec2Pz, 2);
704  m_m2Nu2 = mNu2 * mNu2;
705  double m2noma2 = m_mTau2 - m_m2Nu2 - m2Vis2;
706  double m4noma2 = m2noma2 * m2noma2;
707  double pv2proj = m_tauVec2Px * m_cosPhi2 + m_tauVec2Py * m_sinPhi2;
708  double p2v2proj = std::pow(pv2proj, 2);
709  double sinDPhi1 = -sinDPhi2;
710  double pTmiss1CscDPhi = pTmiss1 / sinDPhi1;
711  double &pTn2 = pTmiss1CscDPhi;
712  double pT2miss1CscDPhi = pTmiss1CscDPhi * pTmiss1CscDPhi;
713 
714  const double discri2 = m4noma2 + 4 * m2noma2 * pTmiss1CscDPhi * pv2proj -
715  4 * (m_ET2v2 * (m_m2Nu2 + pT2miss1CscDPhi) - (pT2miss1CscDPhi * p2v2proj));
716 
717  if (discri2 < 0) // discriminant negative -> no solution
718  {
719  ++m_testdiscri2;
720  return solution_code;
721  }
722 
723  // this should be done only once we know there are solutions for nu2
724  m_E2v1 = m_tauVec1Pz * m_tauVec1Pz + m_ET2v1;
725  m_Ev1 = sqrt(m_E2v1);
726  double sqdiscri1 = sqrt(discri1);
727  double first1 =
728  (m2noma1 * m_tauVec1Pz + 2 * pTmiss2CscDPhi * pv1proj * m_tauVec1Pz) / (2 * m_ET2v1);
729  double second1 = sqdiscri1 * m_Ev1 / (2 * m_ET2v1);
730 
731  // first solution
732  double pn1Z = first1 + second1;
733 
734  if (m2noma1 + 2 * pTmiss2CscDPhi * pv1proj + 2 * pn1Z * m_tauVec1Pz >
735  0) // Condition for solution to exist
736  {
737  m_nuvecsol1[nsol1].SetPxPyPzE(pTn1 * m_cosPhi1, pTn1 * m_sinPhi1, pn1Z,
738  sqrt(std::pow(pTn1, 2) + std::pow(pn1Z, 2) + m_m2Nu1));
739 
740  ++nsol1;
741  }
742 
743  pn1Z = first1 - second1;
744 
745  if (m2noma1 + 2 * pTmiss2CscDPhi * pv1proj + 2 * pn1Z * m_tauVec1Pz >
746  0) // Condition for solution to exist
747  {
748 
749  m_nuvecsol1[nsol1].SetPxPyPzE(pTn1 * m_cosPhi1, pTn1 * m_sinPhi1, pn1Z,
750  sqrt(std::pow(pTn1, 2) + std::pow(pn1Z, 2) + m_m2Nu1));
751 
752  ++nsol1;
753  }
754 
755  if (nsol1 == 0) {
756  ++m_nosol1;
757  return solution_code;
758  }
759 
760  m_E2v2 = m_tauVec2Pz * m_tauVec2Pz + m_ET2v2;
761  m_Ev2 = sqrt(m_E2v2);
762  double sqdiscri2 = sqrt(discri2);
763  double first2 =
764  (m2noma2 * m_tauVec2Pz + 2 * pTmiss1CscDPhi * pv2proj * m_tauVec2Pz) / (2 * m_ET2v2);
765  double second2 = sqdiscri2 * m_Ev2 / (2 * m_ET2v2);
766 
767  // second solution
768  double pn2Z = first2 + second2;
769 
770  if (m2noma2 + 2 * pTmiss1CscDPhi * pv2proj + 2 * pn2Z * m_tauVec2Pz >
771  0) // Condition for solution to exist
772  {
773  m_nuvecsol2[nsol2].SetPxPyPzE(pTn2 * m_cosPhi2, pTn2 * m_sinPhi2, pn2Z,
774  sqrt(std::pow(pTn2, 2) + std::pow(pn2Z, 2) + m_m2Nu2));
775 
776  ++nsol2;
777  }
778 
779  pn2Z = first2 - second2;
780  ;
781 
782  if (m2noma2 + 2 * pTmiss1CscDPhi * pv2proj + 2 * pn2Z * m_tauVec2Pz >
783  0) // Condition for solution to exist
784  {
785  m_nuvecsol2[nsol2].SetPxPyPzE(pTn2 * m_cosPhi2, pTn2 * m_sinPhi2, pn2Z,
786  sqrt(std::pow(pTn2, 2) + std::pow(pn2Z, 2) + m_m2Nu2));
787 
788  ++nsol2;
789  }
790 
791  if (nsol2 == 0) {
792  ++m_nosol2;
793  return solution_code;
794  }
795 
796  // Verification if solution exist
797 
798  solution_code = 1;
799  ++m_iterNuPV3;
800 
801  // double check solutions from time to time
802  if (m_iterNuPV3 % 1000 == 1) {
803  double pnux = m_nuvecsol1[0].Px() + m_nuvecsol2[0].Px();
804  double pnuy = m_nuvecsol1[0].Py() + m_nuvecsol2[0].Py();
805  double mtau1plus = (m_nuvecsol1[0] + m_tauVec1).M();
806  double mtau1moins = (m_nuvecsol1[1] + m_tauVec1).M();
807  double mtau2plus = (m_nuvecsol2[0] + m_tauVec2).M();
808  double mtau2moins = (m_nuvecsol2[1] + m_tauVec2).M();
809  if (std::abs(pnux - pTmissx) > 0.001 || std::abs(pnuy - pTmissy) > 0.001) {
810  Info("DiTauMassTools", "%s", ("NuPsolutionV3 ERROR Pnux-Met.X or Pnuy-Met.Y > 0.001 : " +
811  std::to_string(pnux - pTmissx) + " and " +
812  std::to_string(pnuy - pTmissx) + " " + "Invalid solutions")
813  .c_str());
814  }
815  if (std::abs(mtau1plus - m_mTau) > 0.001 || std::abs(mtau1moins - m_mTau) > 0.001 ||
816  std::abs(mtau2plus - m_mTau) > 0.001 || std::abs(mtau2moins - m_mTau) > 0.001) {
817  Info("DiTauMassTools", "%s", ("NuPsolutionV3 ERROR tau mass not recovered : " +
818  std::to_string(mtau1plus) + " " + std::to_string(mtau1moins) + " " +
819  std::to_string(mtau2plus) + " " + std::to_string(mtau2moins))
820  .c_str());
821  }
822  }
823 
824  return solution_code;
825 }

◆ precomputeCache()

bool MissingMassCalculatorV2::precomputeCache ( )
inlineprotected

Definition at line 2735 of file MissingMassCalculatorV2.cxx.

2735  {
2736 
2737  // copy tau 4 vect. If tau E scanning, these vectors will be modified
2738  m_tauVec1 = preparedInput.m_vistau1;
2739  m_tauVec2 = preparedInput.m_vistau2;
2740 
2741  const TVector2 &metVec = preparedInput.m_MetVec;
2742 
2743  bool same = true;
2744  same = updateDouble(m_tauVec1.Phi(), m_tauVec1Phi) && same;
2745  same = updateDouble(m_tauVec2.Phi(), m_tauVec2Phi) && same;
2746  same = updateDouble(m_tauVec1.M(), m_tauVec1M) && same;
2747  same = updateDouble(m_tauVec2.M(), m_tauVec2M) && same;
2748  same = updateDouble(m_tauVec1.E(), m_tauVec1E) && same;
2749  same = updateDouble(m_tauVec2.E(), m_tauVec2E) && same;
2750  same = updateDouble(m_tauVec1.Px(), m_tauVec1Px) && same;
2751  same = updateDouble(m_tauVec1.Py(), m_tauVec1Py) && same;
2752  same = updateDouble(m_tauVec1.Pz(), m_tauVec1Pz) && same;
2753  same = updateDouble(m_tauVec2.Px(), m_tauVec2Px) && same;
2754  same = updateDouble(m_tauVec2.Py(), m_tauVec2Py) && same;
2755  same = updateDouble(m_tauVec2.Pz(), m_tauVec2Pz) && same;
2756  same = updateDouble(m_tauVec1.P(), m_tauVec1P) && same;
2757  same = updateDouble(m_tauVec2.P(), m_tauVec2P) && same;
2758 
2759  same = updateDouble(1.777, m_mTau) && same;
2760  same = updateDouble(std::pow(m_mTau, 2), m_mTau2) && same;
2761  same = updateDouble(cos(preparedInput.m_METcovphi), m_metCovPhiCos) && same;
2762  same = updateDouble(sin(preparedInput.m_METcovphi), m_metCovPhiSin) && same;
2763  same = updateDouble((m_tauVec1 + m_tauVec2).M(), m_Mvis) && same;
2764 
2765  TLorentzVector Met4vec;
2766  Met4vec.SetPxPyPzE(preparedInput.m_MetVec.X(), preparedInput.m_MetVec.Y(), 0.0,
2767  preparedInput.m_MetVec.Mod());
2768  same = updateDouble((m_tauVec1 + m_tauVec2 + Met4vec).M(), m_Meff) && same;
2769 
2770  same = updateDouble(preparedInput.m_HtOffset, preparedInput.m_htOffset) && same;
2771  // note that if useHT met_vec is actually -HT
2772  same = updateDouble(metVec.X(), preparedInput.m_inputMEtX) && same;
2773  same = updateDouble(metVec.Y(), preparedInput.m_inputMEtY) && same;
2774  same = updateDouble(metVec.Mod(), preparedInput.m_inputMEtT) && same;
2775 
2776  return same;
2777 }

◆ PrintOtherInput()

void MissingMassCalculatorV2::PrintOtherInput ( )
private

Definition at line 476 of file MissingMassCalculatorV2.cxx.

476  {
477  if (preparedInput.m_fUseVerbose != 1)
478  return;
479 
480  Info("DiTauMassTools",
481  ".........................Other input.....................................");
482  Info("DiTauMassTools", "%s",
483  ("Beam energy =" + std::to_string(preparedInput.m_beamEnergy) +
484  " sqrt(S) for collisions =" + std::to_string(2.0 * preparedInput.m_beamEnergy))
485  .c_str());
486  Info("DiTauMassTools", "%s",
487  ("CalibrationSet " + MMCCalibrationSetV2::name[m_mmcCalibrationSet])
488  .c_str());
489  Info("DiTauMassTools", "%s",
490  ("LFV mode " + std::to_string(preparedInput.m_LFVmode) + " seed=" + std::to_string(m_seed))
491  .c_str());
492  Info("DiTauMassTools", "%s", ("usetauProbability=" + std::to_string(Prob->GetUseTauProbability()) +
493  " useTailCleanup=" + std::to_string(preparedInput.m_fUseTailCleanup))
494  .c_str());
495 
496  if (preparedInput.m_InputReorder != 0) {
497  Info("DiTauMassTools",
498  "tau1 and tau2 were internally swapped (visible on prepared input printout)");
499  } else {
500  Info("DiTauMassTools", "tau1 and tau2 were NOT internally swapped");
501  }
502 
503  Info("DiTauMassTools", "%s",
504  (" MEtLMin=" + std::to_string(m_MEtLMin) + " MEtLMax=" + std::to_string(m_MEtLMax)).c_str());
505  Info("DiTauMassTools", "%s",
506  (" MEtPMin=" + std::to_string(m_MEtPMin) + " MEtPMax=" + std::to_string(m_MEtPMax)).c_str());
507  Info("DiTauMassTools", "%s",
508  (" Phi1Min=" + std::to_string(m_Phi1Min) + " Phi1Max=" + std::to_string(m_Phi1Max)).c_str());
509  Info("DiTauMassTools", "%s",
510  (" Phi2Min=" + std::to_string(m_Phi2Min) + " Phi2Max=" + std::to_string(m_Phi2Max)).c_str());
511  Info("DiTauMassTools", "%s",
512  (" Mnu1Min=" + std::to_string(m_Mnu1Min) + " Mnu1Max=" + std::to_string(m_Mnu1Max)).c_str());
513  Info("DiTauMassTools", "%s",
514  (" Mnu2Min=" + std::to_string(m_Mnu2Min) + " Mnu2Max=" + std::to_string(m_Mnu2Max)).c_str());
515 }

◆ PrintResults()

void MissingMassCalculatorV2::PrintResults ( )
private

Definition at line 518 of file MissingMassCalculatorV2.cxx.

518  {
519 
520  if (preparedInput.m_fUseVerbose != 1)
521  return;
522 
523  const TLorentzVector *origVisTau1 = 0;
524  const TLorentzVector *origVisTau2 = 0;
525 
526  if (preparedInput.m_InputReorder == 0) {
527  origVisTau1 = &preparedInput.m_vistau1;
528  origVisTau2 = &preparedInput.m_vistau2;
529  } else // input order was flipped
530  {
531  origVisTau1 = &preparedInput.m_vistau2;
532  origVisTau2 = &preparedInput.m_vistau1;
533  }
534 
535  PrintOtherInput();
536 
537  Info("DiTauMassTools",
538  "------------- Printing Final Results for MissingMassCalculator --------------");
539  Info("DiTauMassTools",
540  ".............................................................................");
541  Info("DiTauMassTools", "%s", ("Fit status=" + std::to_string(OutputInfo.m_FitStatus)).c_str());
542 
543  for (int imeth = 0; imeth < MMCFitMethodV2::MAX; ++imeth) {
544  Info("DiTauMassTools", "%s",
545  ("___ Results for " + MMCFitMethodV2::name[imeth] + "Method ___")
546  .c_str());
547  Info("DiTauMassTools", "%s",
548  (" signif=" + std::to_string(OutputInfo.m_FitSignificance[imeth])).c_str());
549  Info("DiTauMassTools", "%s", (" mass=" + std::to_string(OutputInfo.m_FittedMass[imeth])).c_str());
550  Info("DiTauMassTools", "%s", (" rms/mpv=" + std::to_string(OutputInfo.m_RMS2MPV)).c_str());
551 
552  if (imeth == MMCFitMethodV2::MLM) {
553  Info("DiTauMassTools", " no 4-momentum or MET from this method ");
554  continue;
555  }
556 
557  if (OutputInfo.m_FitStatus <= 0) {
558  Info("DiTauMassTools", " fit failed ");
559  }
560 
561  const TLorentzVector &tlvnu1 = OutputInfo.m_nuvec1[imeth];
562  const TLorentzVector &tlvnu2 = OutputInfo.m_nuvec2[imeth];
563  const TLorentzVector &tlvo1 = OutputInfo.m_objvec1[imeth];
564  const TLorentzVector &tlvo2 = OutputInfo.m_objvec2[imeth];
565  const TVector2 &tvmet = OutputInfo.m_FittedMetVec[imeth];
566 
567  Info("DiTauMassTools", "%s",
568  (" Neutrino-1: P=" + std::to_string(tlvnu1.P()) + " Pt=" + std::to_string(tlvnu1.Pt()) +
569  " Eta=" + std::to_string(tlvnu1.Eta()) + " Phi=" + std::to_string(tlvnu1.Phi()) +
570  " M=" + std::to_string(tlvnu1.M()) + " Px=" + std::to_string(tlvnu1.Px()) +
571  " Py=" + std::to_string(tlvnu1.Py()) + " Pz=" + std::to_string(tlvnu1.Pz()))
572  .c_str());
573  Info("DiTauMassTools", "%s",
574  (" Neutrino-2: P=" + std::to_string(tlvnu2.P()) + " Pt=" + std::to_string(tlvnu2.Pt()) +
575  " Eta=" + std::to_string(tlvnu2.Eta()) + " Phi=" + std::to_string(tlvnu2.Phi()) +
576  " M=" + std::to_string(tlvnu2.M()) + " Px=" + std::to_string(tlvnu2.Px()) +
577  " Py=" + std::to_string(tlvnu2.Py()) + " Pz=" + std::to_string(tlvnu2.Pz()))
578  .c_str());
579  Info("DiTauMassTools", "%s",
580  (" Tau-1: P=" + std::to_string(tlvo1.P()) + " Pt=" + std::to_string(tlvo1.Pt()) +
581  " Eta=" + std::to_string(tlvo1.Eta()) + " Phi=" + std::to_string(tlvo1.Phi()) +
582  " M=" + std::to_string(tlvo1.M()) + " Px=" + std::to_string(tlvo1.Px()) +
583  " Py=" + std::to_string(tlvo1.Py()) + " Pz=" + std::to_string(tlvo1.Pz()))
584  .c_str());
585  Info("DiTauMassTools", "%s",
586  (" Tau-2: P=" + std::to_string(tlvo2.P()) + " Pt=" + std::to_string(tlvo2.Pt()) +
587  " Eta=" + std::to_string(tlvo2.Eta()) + " Phi=" + std::to_string(tlvo2.Phi()) +
588  " M=" + std::to_string(tlvo2.M()) + " Px=" + std::to_string(tlvo2.Px()) +
589  " Py=" + std::to_string(tlvo2.Py()) + " Pz=" + std::to_string(tlvo2.Pz()))
590  .c_str());
591 
592  Info("DiTauMassTools", "%s",
593  (" dR(nu1-visTau1)=" + std::to_string(tlvnu1.DeltaR(*origVisTau1))).c_str());
594  Info("DiTauMassTools", "%s",
595  (" dR(nu2-visTau2)=" + std::to_string(tlvnu2.DeltaR(*origVisTau2))).c_str());
596 
597  Info("DiTauMassTools", "%s",
598  (" Fitted MET =" + std::to_string(tvmet.Mod()) + " Phi=" + std::to_string(tlvnu1.Phi()) +
599  " Px=" + std::to_string(tvmet.Px()) + " Py=" + std::to_string(tvmet.Py()))
600  .c_str());
601 
602  Info("DiTauMassTools", "%s", (" Resonance: P=" + std::to_string(OutputInfo.m_totalvec[imeth].P()) +
603  " Pt=" + std::to_string(OutputInfo.m_totalvec[imeth].Pt()) +
604  " Eta=" + std::to_string(OutputInfo.m_totalvec[imeth].Eta()) +
605  " Phi=" + std::to_string(OutputInfo.m_totalvec[imeth].Phi()) +
606  " M=" + std::to_string(OutputInfo.m_totalvec[imeth].M()) +
607  " Px=" + std::to_string(OutputInfo.m_totalvec[imeth].Px()) +
608  " Py=" + std::to_string(OutputInfo.m_totalvec[imeth].Py()) +
609  " Pz=" + std::to_string(OutputInfo.m_totalvec[imeth].Pz()))
610  .c_str());
611  }
612 
613  return;
614 }

◆ probCalculatorV9fast()

int MissingMassCalculatorV2::probCalculatorV9fast ( const double &  phi1,
const double &  phi2,
const double &  M_nu1,
const double &  M_nu2 
)
inlineprotected

Definition at line 1858 of file MissingMassCalculatorV2.cxx.

1860  {
1861  // bool debug=true;
1862 
1863  int nsol1;
1864  int nsol2;
1865 
1866  const int solution = NuPsolutionV3(M_nu1, M_nu2, phi1, phi2, nsol1, nsol2);
1867 
1868  if (solution != 1)
1869  return -4;
1870  // refineSolutions ( M_nu1,M_nu2,
1871  // met_smearL,met_smearP,metvec_tmp.Mod(),
1872  // nsol1, nsol2,m_Mvis,m_Meff);
1873  refineSolutions(M_nu1, M_nu2, nsol1, nsol2, m_Mvis, m_Meff);
1874 
1875  if (m_nsol <= 0)
1876  return 0;
1877 
1878  // success
1879 
1880  return m_nsol; // for backward compatibility
1881 }

◆ refineSolutions()

int MissingMassCalculatorV2::refineSolutions ( const double &  M_nu1,
const double &  M_nu2,
const int  nsol1,
const int  nsol2,
const double &  Mvis,
const double &  Meff 
)
inlineprotected

Definition at line 1884 of file MissingMassCalculatorV2.cxx.

1888 {
1889  m_nsol = 0;
1890 
1891  if (int(m_probFinalSolVec.size()) < m_nsolfinalmax)
1892  Error("DiTauMassTools", "%s",
1893  ("refineSolutions ERROR probFinalSolVec.size() should be " + std::to_string(m_nsolfinalmax))
1894  .c_str());
1895  if (int(m_mtautauFinalSolVec.size()) < m_nsolfinalmax)
1896  Error("DiTauMassTools", "%s",
1897  ("refineSolutions ERROR mtautauSolVec.size() should be " + std::to_string(m_nsolfinalmax))
1898  .c_str());
1899  if (int(m_nu1FinalSolVec.size()) < m_nsolfinalmax)
1900  Error("DiTauMassTools", "%s",
1901  ("refineSolutions ERROR nu1FinalSolVec.size() should be " + std::to_string(m_nsolfinalmax))
1902  .c_str());
1903  if (int(m_nu2FinalSolVec.size()) < m_nsolfinalmax)
1904  Error("DiTauMassTools", "%s",
1905  ("refineSolutions ERROR nu2FinalSolVec.size() should be " + std::to_string(m_nsolfinalmax))
1906  .c_str());
1907  if (nsol1 > int(m_nsolmax))
1908  Error("DiTauMassTools", "%s", ("refineSolutions ERROR nsol1 " + std::to_string(nsol1) +
1909  " > nsolmax !" + std::to_string(m_nsolmax))
1910  .c_str());
1911  if (nsol2 > int(m_nsolmax))
1912  Error("DiTauMassTools", "%s", ("refineSolutions ERROR nsol1 " + std::to_string(nsol2) +
1913  " > nsolmax !" + std::to_string(m_nsolmax))
1914  .c_str());
1915 
1916  int ngoodsol1 = 0;
1917  int ngoodsol2 = 0;
1918  double constProb =
1919  Prob->apply(preparedInput, -99, -99, TLorentzVector(0, 0, 0, 0), TLorentzVector(0, 0, 0, 0),
1920  TLorentzVector(0, 0, 0, 0), TLorentzVector(0, 0, 0, 0), true, false, false);
1921 
1922  for (int j1 = 0; j1 < nsol1; ++j1) {
1923  TLorentzVector &nuvec1_tmpj = m_nuvecsol1[j1];
1924  TLorentzVector &tauvecsol1j = m_tauvecsol1[j1];
1925  double &tauvecprob1j = m_tauvecprob1[j1];
1926  tauvecprob1j = 0.;
1927  // take first or second solution
1928  // no time to call rndm, switch more or less randomely, according to an
1929  // oscillating switch perturbed by m_phi1
1930  if (nsol1 > 1) {
1931  if (j1 == 0) { // decide at the first solution which one we will take
1932  const int pickInt = std::abs(10000 * m_Phi1);
1933  const int pickDigit = pickInt - 10 * (pickInt / 10);
1934  if (pickDigit < 5)
1935  m_switch1 = !m_switch1;
1936  }
1937  m_switch1 = !m_switch1;
1938  }
1939 
1940  if (!m_switch1) {
1941  nuvec1_tmpj.SetXYZM(nuvec1_tmpj.Px(), nuvec1_tmpj.Py(), nuvec1_tmpj.Pz(), M_nu1);
1942  tauvecsol1j.SetPxPyPzE(0., 0., 0., 0.);
1943  tauvecsol1j += nuvec1_tmpj;
1944  tauvecsol1j += m_tauVec1;
1945  if (tauvecsol1j.E() >= preparedInput.m_beamEnergy)
1946  continue;
1947  tauvecprob1j = Prob->apply(preparedInput, preparedInput.m_type_visTau1, -99, m_tauVec1,
1948  TLorentzVector(0, 0, 0, 0), nuvec1_tmpj,
1949  TLorentzVector(0, 0, 0, 0), false, true, false);
1950  ++ngoodsol1;
1951  }
1952 
1953  for (int j2 = 0; j2 < nsol2; ++j2) {
1954  TLorentzVector &nuvec2_tmpj = m_nuvecsol2[j2];
1955  TLorentzVector &tauvecsol2j = m_tauvecsol2[j2];
1956  double &tauvecprob2j = m_tauvecprob2[j2];
1957  if (j1 == 0) {
1958  tauvecprob2j = 0.;
1959  // take first or second solution
1960  // no time to call rndm, switch more or less randomely, according to an
1961  // oscillating switch perturbed by m_phi2
1962  if (nsol2 > 1) {
1963  if (j2 == 0) { // decide at the first solution which one we will take
1964  const int pickInt = std::abs(10000 * m_Phi2);
1965  const int pickDigit = pickInt - 10 * int(pickInt / 10);
1966  if (pickDigit < 5)
1967  m_switch2 = !m_switch2;
1968  }
1969  m_switch2 = !m_switch2;
1970  }
1971 
1972  if (!m_switch2) {
1973  nuvec2_tmpj.SetXYZM(nuvec2_tmpj.Px(), nuvec2_tmpj.Py(), nuvec2_tmpj.Pz(), M_nu2);
1974  tauvecsol2j.SetPxPyPzE(0., 0., 0., 0.);
1975  tauvecsol2j += nuvec2_tmpj;
1976  tauvecsol2j += m_tauVec2;
1977  if (tauvecsol2j.E() >= preparedInput.m_beamEnergy)
1978  continue;
1979  tauvecprob2j = Prob->apply(preparedInput, -99, preparedInput.m_type_visTau2,
1980  TLorentzVector(0, 0, 0, 0), m_tauVec2,
1981  TLorentzVector(0, 0, 0, 0), nuvec2_tmpj, false, true, false);
1982  ++ngoodsol2;
1983  }
1984  }
1985  if (tauvecprob1j == 0.)
1986  continue;
1987  if (tauvecprob2j == 0.)
1988  continue;
1989 
1990  double totalProb = 1.;
1991 
1992  m_tautau_tmp.SetPxPyPzE(0., 0., 0., 0.);
1993  m_tautau_tmp += tauvecsol1j;
1994  m_tautau_tmp += tauvecsol2j;
1995  const double mtautau = m_tautau_tmp.M();
1996 
1997  if (TailCleanUp(m_tauVec1, nuvec1_tmpj, m_tauVec2, nuvec2_tmpj, mtautau, Mvis, Meff,
1998  preparedInput.m_DelPhiTT) == 0) {
1999  continue;
2000  }
2001 
2002  totalProb *=
2003  (constProb * tauvecprob1j * tauvecprob2j *
2004  Prob->apply(preparedInput, preparedInput.m_type_visTau1, preparedInput.m_type_visTau2,
2005  m_tauVec1, m_tauVec2, nuvec1_tmpj, nuvec2_tmpj, false, false, true));
2006 
2007  if (totalProb <= 0) {
2008  if (preparedInput.m_fUseVerbose)
2009  Warning("DiTauMassTools", "%s",
2010  ("null proba solution, rejected "+std::to_string(totalProb)).c_str());
2011  } else {
2012  // only count solution with non zero probability
2013  m_totalProbSum += totalProb;
2014  m_mtautauSum += mtautau;
2015 
2016  if (m_nsol >= int(m_nsolfinalmax)) {
2017  Error("DiTauMassTools", "%s",
2018  ("refineSolutions ERROR nsol getting larger than nsolfinalmax!!! " +
2019  std::to_string(m_nsol))
2020  .c_str());
2021  Error("DiTauMassTools", "%s",
2022  (" j1 " + std::to_string(j1) + " j2 " + std::to_string(j2) + " nsol1 " +
2023  std::to_string(nsol1) + " nsol2 " + std::to_string(nsol2))
2024  .c_str());
2025  --m_nsol; // overwrite last solution. However this should really never
2026  // happen
2027  }
2028 
2029  // good solution found, copy in vector
2030  m_mtautauFinalSolVec[m_nsol] = mtautau;
2031  m_probFinalSolVec[m_nsol] = totalProb;
2032 
2033  TLorentzVector &nu1Final = m_nu1FinalSolVec[m_nsol];
2034  TLorentzVector &nu2Final = m_nu2FinalSolVec[m_nsol];
2035  // for (int iv=0;iv<4;++iv){
2036 
2037  nu1Final.SetPxPyPzE(nuvec1_tmpj.Px(), nuvec1_tmpj.Py(), nuvec1_tmpj.Pz(), nuvec1_tmpj.E());
2038  nu2Final.SetPxPyPzE(nuvec2_tmpj.Px(), nuvec2_tmpj.Py(), nuvec2_tmpj.Pz(), nuvec2_tmpj.E());
2039  // }
2040 
2041  ++m_nsol;
2042  } // else totalProb<=0
2043 
2044  } // loop j2
2045  } // loop j1
2046  if (ngoodsol1 == 0) {
2047  return -1;
2048  }
2049  if (ngoodsol2 == 0) {
2050  return -2;
2051  }
2052  return m_nsol;
2053 }

◆ RunMissingMassCalculator()

int MissingMassCalculatorV2::RunMissingMassCalculator ( const xAOD::IParticle *  part1,
const xAOD::IParticle *  part2,
const xAOD::MissingET *  met,
const int &  njets 
)

Definition at line 266 of file MissingMassCalculatorV2.cxx.

269  {
270  m_reRunWithBestMET = false;
271 
272  OutputInfo.ClearOutput(preparedInput.m_fUseVerbose);
273  if (preparedInput.m_fUseVerbose == 1) {
274  Info("DiTauMassTools", "------------- Raw Input for MissingMassCalculator --------------");
275  }
276  FinalizeSettings(part1, part2, met, njets); // rawInput, preparedInput );
277  Prob->MET(preparedInput);
278  if (preparedInput.m_fUseVerbose == 1) {
279  Info("DiTauMassTools", "------------- Prepared Input for MissingMassCalculator--------------");
280  preparedInput.PrintInputInfo();
281  }
282 
283  if (preparedInput.m_LFVmode < 0) {
284  // remove argument DiTauMassCalculatorV9Walk work directly on preparedInput
285  OutputInfo.m_FitStatus = DitauMassCalculatorV9walk();
286 
287  // re-running MMC for on failed events
288  if (m_fUseEfficiencyRecovery == 1 && OutputInfo.m_FitStatus != 1) {
289  // most events where MMC failed happened to have dPhi>2.9. Run re-fit only
290  // on these events
291  if (preparedInput.m_DelPhiTT > 2.9) {
292  // preparedInput.MetVec.Set(-(preparedInput.vistau1+preparedInput.vistau2).Px(),-(preparedInput.vistau1+preparedInput.vistau2).Py());
293  // // replace MET by MPT
294 
295  TVector2 dummy_met(-(preparedInput.m_vistau1 + preparedInput.m_vistau2).Px(),
296  -(preparedInput.m_vistau1 + preparedInput.m_vistau2).Py());
297  preparedInput.m_METcovphi = dummy_met.Phi();
298  double dummy_METres =
299  sqrt(pow(preparedInput.m_METsigmaL, 2) + pow(preparedInput.m_METsigmaP, 2));
300  preparedInput.m_METsigmaL =
301  dummy_METres * std::abs(cos(dummy_met.Phi() - preparedInput.m_MetVec.Phi()));
302  preparedInput.m_METsigmaP =
303  dummy_METres * std::abs(sin(dummy_met.Phi() - preparedInput.m_MetVec.Phi()));
304  if (preparedInput.m_METsigmaP < 5.0)
305  preparedInput.m_METsigmaP = 5.0;
306  m_nsigma_METscan_lh = 6.0; // increase range of MET scan
307  m_nsigma_METscan_hh = 6.0; // increase range of MET scan
308 
309  OutputInfo.ClearOutput(preparedInput.m_fUseVerbose); // clear output stuff before re-running
310  OutputInfo.m_FitStatus = DitauMassCalculatorV9walk(); // run MMC again
311  }
312  }
313 
314  }
315 
316  // running MMC in LFV mode for reconstructing mass of X->lep+tau
317  else {
318  if (preparedInput.m_fUseVerbose == 1) {
319  Info("DiTauMassTools", "Calling DitauMassCalculatorV9lfv");
320  }
321  OutputInfo.m_FitStatus = DitauMassCalculatorV9lfv(false);
322  }
323 #ifdef SAVELIKELIHOODHISTO
324  TFile *outFile = TFile::Open("MMC_likelihoods.root", "UPDATE");
325  outFile->cd();
326  auto path = std::to_string(m_eventNumber);
327  if (!outFile->GetDirectory(path.c_str()))
328  outFile->mkdir(path.c_str());
329  outFile->cd(path.c_str());
330  m_fMfit_all->Write(m_fMfit_all->GetName(), TObject::kOverwrite);
331  m_fMEtP_all->Write(m_fMEtP_all->GetName(), TObject::kOverwrite);
332  m_fMEtL_all->Write(m_fMEtL_all->GetName(), TObject::kOverwrite);
333  m_fMnu1_all->Write(m_fMnu1_all->GetName(), TObject::kOverwrite);
334  m_fMnu2_all->Write(m_fMnu2_all->GetName(), TObject::kOverwrite);
335  m_fPhi1_all->Write(m_fPhi1_all->GetName(), TObject::kOverwrite);
336  m_fPhi2_all->Write(m_fPhi2_all->GetName(), TObject::kOverwrite);
337  m_fMfit_allNoWeight->Write(m_fMfit_allNoWeight->GetName(), TObject::kOverwrite);
338  m_fMfit_allGraph->Write("Graph", TObject::kOverwrite);
339  TH1D *nosol = new TH1D("nosol", "nosol", 7, 0, 7);
340  nosol->SetBinContent(1, m_testptn1);
341  nosol->SetBinContent(2, m_testptn2);
342  nosol->SetBinContent(3, m_testdiscri1);
343  nosol->SetBinContent(4, m_testdiscri2);
344  nosol->SetBinContent(5, m_nosol1);
345  nosol->SetBinContent(6, m_nosol1);
346  nosol->SetBinContent(7, m_iterNuPV3);
347  nosol->Write(nosol->GetName(), TObject::kOverwrite);
348  outFile->Write();
349  outFile->Close();
350 #endif
351  DoOutputInfo();
352  PrintResults();
353  preparedInput.ClearInput();
354  return 1;
355 }

◆ SetApplyMassScale()

void DiTauMassTools::MissingMassCalculatorV2::SetApplyMassScale ( const int  val)
inline

Definition at line 359 of file MissingMassCalculatorV2.h.

359 { m_fApplyMassScale=val; }

◆ SetBeamEnergy()

void DiTauMassTools::MissingMassCalculatorV2::SetBeamEnergy ( const double  val)
inline

Definition at line 397 of file MissingMassCalculatorV2.h.

397 { m_beamEnergy=val; }

◆ SetdTheta3d_binMax()

void DiTauMassTools::MissingMassCalculatorV2::SetdTheta3d_binMax ( const double  val)
inline

Definition at line 354 of file MissingMassCalculatorV2.h.

354 { m_dTheta3d_binMax=val; } // maximum step size for dTheta3D

◆ SetdTheta3d_binMin()

void DiTauMassTools::MissingMassCalculatorV2::SetdTheta3d_binMin ( const double  val)
inline

Definition at line 355 of file MissingMassCalculatorV2.h.

355 { m_dTheta3d_binMin=val; } // minimal step size for dTheta3D

◆ SetEventNumber()

void DiTauMassTools::MissingMassCalculatorV2::SetEventNumber ( const int  eventNumber)
inline

Definition at line 356 of file MissingMassCalculatorV2.h.

356 { m_eventNumber = eventNumber; }

◆ SetJERsyst()

void DiTauMassTools::MissingMassCalculatorV2::SetJERsyst ( const int  val)
inline

Definition at line 358 of file MissingMassCalculatorV2.h.

358 { m_fJERsyst=val; }

◆ SetLFVLeplepRefit()

void DiTauMassTools::MissingMassCalculatorV2::SetLFVLeplepRefit ( const bool  val)
inline

Definition at line 398 of file MissingMassCalculatorV2.h.

398 { m_lfvLeplepRefit=val; }

◆ SetMeanbinStop()

void DiTauMassTools::MissingMassCalculatorV2::SetMeanbinStop ( const double  val)
inline

Definition at line 352 of file MissingMassCalculatorV2.h.

352 {m_meanbinStop=val;}

◆ SetMnuScanRange()

void DiTauMassTools::MissingMassCalculatorV2::SetMnuScanRange ( const double  val)
inline

Definition at line 361 of file MissingMassCalculatorV2.h.

361 { m_MnuScanRange=val; }

◆ SetNiterFit1()

void DiTauMassTools::MissingMassCalculatorV2::SetNiterFit1 ( const int  val)
inline

Definition at line 346 of file MissingMassCalculatorV2.h.

346 { m_niter_fit1=val; } // number of iterations per loop in dPhi loop

◆ SetNiterFit2()

void DiTauMassTools::MissingMassCalculatorV2::SetNiterFit2 ( const int  val)
inline

Definition at line 347 of file MissingMassCalculatorV2.h.

347 { m_niter_fit2=val; } // number of iterations per loop in MET loop

◆ SetNiterFit3()

void DiTauMassTools::MissingMassCalculatorV2::SetNiterFit3 ( const int  val)
inline

Definition at line 348 of file MissingMassCalculatorV2.h.

348 { m_niter_fit3=val; } // number of iterations per loop in Mnu loop

◆ SetNiterRandom()

void DiTauMassTools::MissingMassCalculatorV2::SetNiterRandom ( const int  val)
inline

Definition at line 349 of file MissingMassCalculatorV2.h.

349 { m_NiterRandom=val; } // number of random iterations

◆ SetNsigmaMETscan()

void DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan ( const double  val)
inline

Definition at line 394 of file MissingMassCalculatorV2.h.

394 { m_nsigma_METscan=val; } // number of sigma's for MET-scan

◆ SetNsigmaMETscan_hh()

void DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan_hh ( const double  val)
inline

Definition at line 393 of file MissingMassCalculatorV2.h.

393 { m_nsigma_METscan_hh=val; } // number of sigma's for MET-scan in hh events

◆ SetNsigmaMETscan_lh()

void DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan_lh ( const double  val)
inline

Definition at line 392 of file MissingMassCalculatorV2.h.

392 { m_nsigma_METscan_lh=val; } // number of sigma's for MET-scan in lh events

◆ SetNsigmaMETscan_ll()

void DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan_ll ( const double  val)
inline

Definition at line 391 of file MissingMassCalculatorV2.h.

391 { m_nsigma_METscan_ll=val; } // number of sigma's for MET-scan in ll events

◆ SetNsucStop()

void DiTauMassTools::MissingMassCalculatorV2::SetNsucStop ( const int  val)
inline

Definition at line 350 of file MissingMassCalculatorV2.h.

350 { m_NsucStop=val; } // Arrest criteria for Nsuccesses

◆ SetProposalTryEtau()

void DiTauMassTools::MissingMassCalculatorV2::SetProposalTryEtau ( const double  val)
inline

Definition at line 366 of file MissingMassCalculatorV2.h.

366 {m_ProposalTryEtau=val;}

◆ SetProposalTryMEt()

void DiTauMassTools::MissingMassCalculatorV2::SetProposalTryMEt ( const double  val)
inline

Definition at line 363 of file MissingMassCalculatorV2.h.

363 {m_proposalTryMEt=val; }

◆ SetProposalTryMnu()

void DiTauMassTools::MissingMassCalculatorV2::SetProposalTryMnu ( const double  val)
inline

Definition at line 365 of file MissingMassCalculatorV2.h.

365 {m_ProposalTryMnu=val;}

◆ SetProposalTryPhi()

void DiTauMassTools::MissingMassCalculatorV2::SetProposalTryPhi ( const double  val)
inline

Definition at line 364 of file MissingMassCalculatorV2.h.

364 {m_ProposalTryPhi=val;}

◆ SetRMSStop()

void DiTauMassTools::MissingMassCalculatorV2::SetRMSStop ( const int  val)
inline

Definition at line 351 of file MissingMassCalculatorV2.h.

351 { m_RMSStop=val;}

◆ SetRndmSeedAltering()

void DiTauMassTools::MissingMassCalculatorV2::SetRndmSeedAltering ( const int  val)
inline

Definition at line 353 of file MissingMassCalculatorV2.h.

353 { m_RndmSeedAltering=val; } // number of iterations per loop in Mnu loop

◆ SetUseEfficiencyRecovery()

void DiTauMassTools::MissingMassCalculatorV2::SetUseEfficiencyRecovery ( const bool  val)
inline

Definition at line 368 of file MissingMassCalculatorV2.h.

368 { m_fUseEfficiencyRecovery=val; }

◆ SetUseFloatStopping()

void DiTauMassTools::MissingMassCalculatorV2::SetUseFloatStopping ( const bool  val)
inline

Definition at line 396 of file MissingMassCalculatorV2.h.

396 { m_fUseFloatStopping=val; } // switch for floating stopping criterion

◆ SpaceWalkerInit()

void MissingMassCalculatorV2::SpaceWalkerInit ( )
inlineprotected

Definition at line 2434 of file MissingMassCalculatorV2.cxx.

2434  {
2435  // FIXME could use function pointer to switch between functions
2436  m_nsolOld = 0;
2437 
2438  double METresX = preparedInput.m_METsigmaL; // MET resolution in direction parallel to MET
2439  // resolution major axis, for MET scan
2440  double METresY = preparedInput.m_METsigmaP; // MET resolution in direction perpendicular to
2441  // to MET resolution major axis, for MET scan
2442 
2443  // precompute some quantities and store in m_ data members
2444  precomputeCache();
2445  if (m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2019) {
2446  if (Prob->GetUseMnuProbability() == true && (preparedInput.m_tauTypes == TauTypes::ll || preparedInput.m_tauTypes == TauTypes::lh) ) Prob->setParamNuMass();
2447  Prob->setParamAngle(m_tauVec1, 1, preparedInput.m_type_visTau1);
2448  Prob->setParamAngle(m_tauVec2, 2, preparedInput.m_type_visTau2);
2449  Prob->setParamRatio(1, preparedInput.m_type_visTau1);
2450  Prob->setParamRatio(2, preparedInput.m_type_visTau2);
2451  }
2452 
2453  if (preparedInput.m_tauTypes == TauTypes::ll) // both tau's are leptonic
2454  {
2455  m_nsigma_METscan = m_nsigma_METscan_ll;
2456  } else if (preparedInput.m_tauTypes == TauTypes::lh) // lep had
2457  {
2458  m_nsigma_METscan = m_nsigma_METscan_lh;
2459  } else // hh
2460  {
2461  m_nsigma_METscan = m_nsigma_METscan_hh;
2462  }
2463 
2464  m_nsigma_METscan2 = std::pow(m_nsigma_METscan, 2);
2465 
2466  const double deltaPhi1 = MaxDelPhi(preparedInput.m_type_visTau1, m_tauVec1P, m_dRmax_tau);
2467  const double deltaPhi2 = MaxDelPhi(preparedInput.m_type_visTau2, m_tauVec2P, m_dRmax_tau);
2468 
2469  m_walkWeight = 1.;
2470 
2471  // dummy initial value to avoid printout with random values
2472  m_Phi10 = 0.;
2473  m_Phi20 = 0.;
2474  m_MEtL0 = 0.;
2475  m_MEtP0 = 0.;
2476  m_Mnu10 = 0.;
2477  m_Mnu20 = 0.;
2478 
2479  m_mTau = 1.777;
2480 
2481  // seeds the random generator in a reproducible way from the phi of both tau;
2482  double aux = std::abs(m_tauVec1Phi + double(m_tauVec2Phi) / 100. / TMath::Pi()) * 100;
2483  m_seed = (aux - floor(aux)) * 1E6 * (1 + m_RndmSeedAltering) + 13;
2484 
2485  m_randomGen.SetSeed(m_seed);
2486  // int Niter=Niter_fit1; // number of points for each dR loop
2487  // int NiterMET=Niter_fit2; // number of iterations for each MET scan loop
2488  // int NiterMnu=Niter_fit3; // number of iterations for Mnu loop
2489 
2490  // approximately compute the number of points from the grid scanning
2491  // divide by abritry number to recover timing with still better results
2492  // m_NiterRandom=(NiterMET+1)*(NiterMET+1)*4*Niter*Niter/10;
2493 
2494  m_Phi1Min = m_tauVec1Phi - deltaPhi1;
2495  m_Phi1Max = m_tauVec1Phi + deltaPhi1;
2496  m_Phi1Range = m_Phi1Max - m_Phi1Min;
2497 
2498  m_Phi2Min = m_tauVec2Phi - deltaPhi2;
2499  m_Phi2Max = m_tauVec2Phi + deltaPhi2;
2500  m_Phi2Range = m_Phi2Max - m_Phi2Min;
2501 
2502  m_Mnu1Min = 0.;
2503  m_scanMnu1 = false;
2504  m_Mnu1 = m_Mnu1Min;
2505 
2506  // for markov chain use factor 2
2507  m_niterRandomLocal = m_NiterRandom / 2;
2508 
2509  // NiterRandom set by user (default is -1). If negative, defines the default
2510  // here. no more automatic scaling for ll hl hh
2511  if (m_NiterRandom <= 0) {
2512  m_niterRandomLocal = 100000; // number of iterations for Markov for lh
2513  if (preparedInput.m_tauTypes == TauTypes::ll)
2514  m_niterRandomLocal *= 2; // multiplied for ll , unchecked
2515  if (preparedInput.m_tauTypes == TauTypes::hh)
2516  m_niterRandomLocal *= 5; // divided for hh ,checked
2517  } else {
2518  m_niterRandomLocal = m_NiterRandom;
2519  }
2520 
2521  if (preparedInput.m_type_visTau1 == 8) {
2522  // m_Mnu1Max=m_mTau-m_tauVec1M;
2523  m_Mnu1Max = m_MnuScanRange - m_tauVec1M;
2524  m_Mnu1Range = m_Mnu1Max - m_Mnu1Min;
2525  m_scanMnu1 = true;
2526  }
2527 
2528  m_Mnu2Min = 0.;
2529  m_scanMnu2 = false;
2530  m_Mnu2 = m_Mnu2Min;
2531  if (preparedInput.m_type_visTau2 == 8) {
2532  // m_Mnu2Max=m_mTau-m_tauVec2M;
2533  m_Mnu2Max = m_MnuScanRange - m_tauVec2M;
2534  m_Mnu2Range = m_Mnu2Max - m_Mnu2Min;
2535  m_scanMnu2 = true;
2536  }
2537 
2538  m_MEtLMin = -m_nsigma_METscan * METresX;
2539  m_MEtLMax = +m_nsigma_METscan * METresX;
2540  m_MEtLRange = m_MEtLMax - m_MEtLMin;
2541 
2542  m_MEtPMin = -m_nsigma_METscan * METresY;
2543  m_MEtPMax = +m_nsigma_METscan * METresY;
2544  m_MEtPRange = m_MEtPMax - m_MEtPMin;
2545 
2546  m_eTau1Min = -1;
2547  m_eTau1Max = -1;
2548  m_eTau2Min = -1;
2549  m_eTau2Max = -1;
2550 
2551  m_switch1 = true;
2552  m_switch2 = true;
2553 
2554  m_nsucStop = m_NsucStop;
2555  m_rmsStop = m_RMSStop;
2556 
2557  m_iter0 = -1;
2558  m_iterNuPV3 = 0;
2559  m_testptn1 = 0;
2560  m_testptn2 = 0;
2561  m_testdiscri1 = 0;
2562  m_testdiscri2 = 0;
2563  m_nosol1 = 0;
2564  m_nosol2 = 0;
2565  m_iterNsuc = 0;
2566  if (m_meanbinStop > 0) {
2567  m_meanbinToBeEvaluated = true;
2568  } else {
2569  m_meanbinToBeEvaluated = false;
2570  }
2571 
2572  m_markovCountDuplicate = 0;
2573  m_markovNRejectNoSol = 0;
2574  m_markovNRejectMetropolis = 0;
2575  m_markovNAccept = 0;
2576  m_markovNFullScan = 0;
2577  // set full parameter space scannning for the first steps, until a solution is
2578  // found
2579  m_fullParamSpaceScan = true;
2580  // size of step. Needs to be tune. Start with simple heuristic.
2581  if (m_proposalTryMEt < 0) {
2582  m_MEtProposal = m_MEtPRange / 30.;
2583  } else {
2584  m_MEtProposal = m_MEtPRange * m_proposalTryMEt;
2585  }
2586  if (m_ProposalTryPhi < 0) {
2587  m_PhiProposal = 0.04;
2588  } else {
2589  m_PhiProposal = m_ProposalTryPhi;
2590  }
2591  // FIXME if m_Mnu1Range !ne m_Mnu2Range same proposal will be done
2592  if (m_scanMnu1) {
2593  if (m_ProposalTryMnu < 0) {
2594  m_MnuProposal = m_Mnu1Range / 10.;
2595  } else {
2596  m_MnuProposal = m_Mnu1Range * m_ProposalTryMnu;
2597  }
2598  }
2599  if (m_scanMnu2) {
2600  if (m_ProposalTryMnu < 0) {
2601  m_MnuProposal = m_Mnu2Range / 10.;
2602  } else {
2603  m_MnuProposal = m_Mnu2Range * m_ProposalTryMnu;
2604  }
2605  }
2606 }

◆ SpaceWalkerWalk()

bool MissingMassCalculatorV2::SpaceWalkerWalk ( )
inlineprotected

Definition at line 2611 of file MissingMassCalculatorV2.cxx.

2611  {
2612  preparedInput.m_MEtX = -999.;
2613  preparedInput.m_MEtY = -999.;
2614 
2615  ++m_iter0;
2616 
2617  if (m_meanbinToBeEvaluated && m_iterNsuc == 500) {
2618  Info("DiTauMassTools", " in m_meanbinToBeEvaluated && m_iterNsuc==500 ");
2619  // for markov chain m_iterNsuc is the number of *accepted* points, so there
2620  // can be several iterations without any increment of m_iterNsuc. Hence need
2621  // to make sure meanbin is evaluated only once
2622  m_meanbinToBeEvaluated = false;
2623 
2624  // Meanbin stopping criterion
2625  std::vector<double> histInfo(HistInfoV2::MAXHISTINFO);
2626  // SLIDINGWINDOW strategy to avoid doing the parabola fit now given it will
2627  // not be use
2628  maxFromHist(m_fMfit_all, histInfo, MaxHistStrategyV2::SLIDINGWINDOW);
2629  double meanbin = histInfo.at(HistInfoV2::MEANBIN);
2630  if (meanbin < 0) {
2631  m_nsucStop = -1; // no meaningful meanbin switch back to niter criterion
2632  } else {
2633  double stopdouble = 500 * std::pow((meanbin / m_meanbinStop), 2);
2634  int stopint = stopdouble;
2635  m_nsucStop = stopint;
2636  }
2637  if (m_nsucStop < 500)
2638  return false;
2639  }
2640  // should be outside m_meanbinStop test
2641  if (m_iterNsuc == m_nsucStop)
2642  return false; // Critere d'arret pour nombre de succes
2643 
2644  if (m_iter0 == m_niterRandomLocal)
2645  return false; // for now simple stopping criterion on number of iteration
2646 
2647  // floating stopping criterion, reduces run-time for lh, hh by a factor ~2 and ll by roughly
2648  // factor ~3 check if every scanned variable and resulting mass thermalised after 10k iterations
2649  // and then every 1k iterations do this by checking that the means of the split distributions is
2650  // comparable within 5% of their sigma
2651  if (m_iter0 >= 10000 && (m_iter0 % 1000) == 0 && m_fUseFloatStopping) {
2652  if (std::abs(m_fMEtP_split1->GetMean() - m_fMEtP_split2->GetMean()) <= 0.05 * m_fMEtP_split1->GetRMS()) {
2653  if (std::abs(m_fMEtL_split1->GetMean() - m_fMEtL_split2->GetMean()) <=
2654  0.05 * m_fMEtL_split1->GetRMS()) {
2655  if (std::abs(m_fMnu1_split1->GetMean() - m_fMnu1_split2->GetMean()) <=
2656  0.05 * m_fMnu1_split1->GetRMS()) {
2657  if (std::abs(m_fMnu2_split1->GetMean() - m_fMnu2_split2->GetMean()) <=
2658  0.05 * m_fMnu2_split1->GetRMS()) {
2659  if (std::abs(m_fPhi1_split1->GetMean() - m_fPhi1_split2->GetMean()) <=
2660  0.05 * m_fPhi1_split1->GetRMS()) {
2661  if (std::abs(m_fPhi2_split1->GetMean() - m_fPhi2_split2->GetMean()) <=
2662  0.05 * m_fPhi2_split1->GetRMS()) {
2663  if (std::abs(m_fMmass_split1->GetMean() - m_fMmass_split2->GetMean()) <=
2664  0.05 * m_fMmass_split1->GetRMS()) {
2665  return false;
2666  }
2667  }
2668  }
2669  }
2670  }
2671  }
2672  }
2673  }
2674 
2675  if (m_fullParamSpaceScan) {
2676  // as long as no solution found need to randomise on the full parameter
2677  // space
2678 
2679  // cut the corners in MissingET (not optimised at all)
2680  // not needed if distribution is already gaussian
2681  do {
2682  m_MEtP = m_MEtPMin + m_MEtPRange * m_randomGen.Rndm();
2683  m_MEtL = m_MEtLMin + m_MEtLRange * m_randomGen.Rndm();
2684  } while (!checkMEtInRange());
2685 
2686  if (m_scanMnu1) {
2687  m_Mnu1 = m_Mnu1Min + m_Mnu1Range * m_randomGen.Rndm();
2688  }
2689 
2690  if (m_scanMnu2) {
2691  m_Mnu2 = m_Mnu2Min + m_Mnu2Range * m_randomGen.Rndm();
2692  }
2693 
2694  m_Phi1 = m_Phi1Min + m_Phi1Range * m_randomGen.Rndm();
2695  m_Phi2 = m_Phi2Min + m_Phi2Range * m_randomGen.Rndm();
2696 
2697  return true;
2698  }
2699 
2700  // here the real markov chain takes place : "propose" the new point
2701  // note that if one parameter goes outside range, this should not be fixed
2702  // here but later in handleSolution, otherwise would cause a bias
2703 
2704  // m_MEtP0 etc... also store the position of the previous Markov Chain step,
2705  // which is needed by the algorithm
2706  m_MEtP0 = m_MEtP;
2707  m_MEtL0 = m_MEtL;
2708 
2709  m_MEtP = m_randomGen.Gaus(m_MEtP0, m_MEtProposal);
2710 
2711  m_MEtL = m_randomGen.Gaus(m_MEtL0, m_MEtProposal);
2712 
2713  if (m_scanMnu1) {
2714  m_Mnu10 = m_Mnu1;
2715  m_Mnu1 = m_randomGen.Gaus(m_Mnu10, m_MnuProposal);
2716  }
2717 
2718  if (m_scanMnu2) {
2719  m_Mnu20 = m_Mnu2;
2720  m_Mnu2 = m_randomGen.Gaus(m_Mnu20, m_MnuProposal);
2721  }
2722 
2723  m_Phi10 = m_Phi1;
2724  m_Phi1 = m_randomGen.Gaus(m_Phi10, m_PhiProposal);
2725 
2726  m_Phi20 = m_Phi2;
2727 
2728  m_Phi2 = m_randomGen.Gaus(m_Phi20, m_PhiProposal);
2729 
2730  return true;
2731 }

◆ StandardCollApprox()

int MissingMassCalculatorV2::StandardCollApprox ( const TLorentzVector &  tau_vec1,
const TLorentzVector &  tau_vec2,
const TVector2 &  met_vec,
double &  Mrec 
)

Definition at line 2959 of file MissingMassCalculatorV2.cxx.

2961  {
2962  int code = 0;
2963  Mrec = 0.0;
2964  double P_nu1 = 0.0;
2965  double P_nu2 = 0.0;
2966  int coll_code = NuPsolution(met_vec, tau_vec1.Theta(), tau_vec1.Phi(), tau_vec2.Theta(),
2967  tau_vec2.Phi(), P_nu1, P_nu2);
2968  if (coll_code == 1) {
2969  code = 1;
2970  TLorentzVector nu1(P_nu1 * sin(tau_vec1.Theta()) * cos(tau_vec1.Phi()),
2971  P_nu1 * sin(tau_vec1.Theta()) * sin(tau_vec1.Phi()),
2972  P_nu1 * cos(tau_vec1.Theta()), P_nu1);
2973  TLorentzVector nu2(P_nu2 * sin(tau_vec2.Theta()) * cos(tau_vec2.Phi()),
2974  P_nu2 * sin(tau_vec2.Theta()) * sin(tau_vec2.Phi()),
2975  P_nu2 * cos(tau_vec2.Theta()), P_nu2);
2976  Mrec = (nu1 + nu2 + tau_vec1 + tau_vec2).M();
2977  }
2978  return code;
2979 }

◆ TailCleanUp()

int MissingMassCalculatorV2::TailCleanUp ( const TLorentzVector &  vis1,
const TLorentzVector &  nu1,
const TLorentzVector &  vis2,
const TLorentzVector &  nu2,
const double &  mmc_mass,
const double &  vis_mass,
const double &  eff_mass,
const double &  dphiTT 
)
inlineprotected

Definition at line 2055 of file MissingMassCalculatorV2.cxx.

2060  {
2061 
2062  int pass_code = 1;
2063  if (preparedInput.m_fUseTailCleanup == 0)
2064  return pass_code;
2065 
2066  // the Clean-up cuts are specifically for rel16 analyses.
2067  // the will change in rel17 analyses and after the MMC is updated
2068 
2069  if (preparedInput.m_tauTypes == TauTypes::ll) // lepton-lepton channel
2070  {
2071  const double MrecoMvis = mmc_mass / vis_mass;
2072  if (MrecoMvis > 2.6)
2073  return 0;
2074  const double MrecoMeff = mmc_mass / eff_mass;
2075  if (MrecoMeff > 1.9)
2076  return 0;
2077  const double e1p1 = nu1.E() / vis1.P();
2078  const double e2p2 = nu2.E() / vis2.P();
2079  if ((e1p1 + e2p2) > 4.5)
2080  return 0;
2081  if (e2p2 > 4.0)
2082  return 0;
2083  if (e1p1 > 3.0)
2084  return 0;
2085  }
2086 
2087  //-------- these are new cuts for lep-had analysis for Moriond
2088  if (preparedInput.m_tauTypes == TauTypes::lh) // lepton-hadron channel
2089  {
2090 
2091  if (m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2015HIGHMASS ||
2092  m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2016MC15C ||
2093  m_mmcCalibrationSet == MMCCalibrationSetV2::MMC2019 ||
2094  m_mmcCalibrationSet == MMCCalibrationSetV2::UPGRADE)
2095  return pass_code; // don't use TailCleanup for 8 & 13 TeV data
2096 
2097  //--------- leave code uncommented to avoid Compilation warnings
2098  if (Prob->GetUseHT()) {
2099  const double MrecoMvis = mmc_mass / vis_mass;
2100  const double MrecoMeff = mmc_mass / eff_mass;
2101  const double x = dphiTT > 1.5 ? dphiTT : 1.5;
2102  if ((MrecoMeff + MrecoMvis) > 5.908 - 1.881 * x + 0.2995 * x * x)
2103  return 0;
2104  }
2105  }
2106  return pass_code;
2107 }

Member Data Documentation

◆ m_beamEnergy

double DiTauMassTools::MissingMassCalculatorV2::m_beamEnergy
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_cosPhi1

double DiTauMassTools::MissingMassCalculatorV2::m_cosPhi1
private

Definition at line 170 of file MissingMassCalculatorV2.h.

◆ m_cosPhi2

double DiTauMassTools::MissingMassCalculatorV2::m_cosPhi2
private

Definition at line 170 of file MissingMassCalculatorV2.h.

◆ m_debugThisIteration

bool DiTauMassTools::MissingMassCalculatorV2::m_debugThisIteration
private

Definition at line 89 of file MissingMassCalculatorV2.h.

◆ m_dRmax_tau

double DiTauMassTools::MissingMassCalculatorV2::m_dRmax_tau
private

Definition at line 260 of file MissingMassCalculatorV2.h.

◆ m_dTheta3d_binMax

double DiTauMassTools::MissingMassCalculatorV2::m_dTheta3d_binMax
private

Definition at line 259 of file MissingMassCalculatorV2.h.

◆ m_dTheta3d_binMin

double DiTauMassTools::MissingMassCalculatorV2::m_dTheta3d_binMin
private

Definition at line 258 of file MissingMassCalculatorV2.h.

◆ m_E2v1

double DiTauMassTools::MissingMassCalculatorV2::m_E2v1
private

Definition at line 186 of file MissingMassCalculatorV2.h.

◆ m_E2v2

double DiTauMassTools::MissingMassCalculatorV2::m_E2v2
private

Definition at line 187 of file MissingMassCalculatorV2.h.

◆ m_ET2v1

double DiTauMassTools::MissingMassCalculatorV2::m_ET2v1
private

Definition at line 184 of file MissingMassCalculatorV2.h.

◆ m_ET2v2

double DiTauMassTools::MissingMassCalculatorV2::m_ET2v2
private

Definition at line 185 of file MissingMassCalculatorV2.h.

◆ m_eTau1

double DiTauMassTools::MissingMassCalculatorV2::m_eTau1
private

Definition at line 139 of file MissingMassCalculatorV2.h.

◆ m_eTau10

double DiTauMassTools::MissingMassCalculatorV2::m_eTau10
private

Definition at line 140 of file MissingMassCalculatorV2.h.

◆ m_eTau1Max

double DiTauMassTools::MissingMassCalculatorV2::m_eTau1Max
private

Definition at line 150 of file MissingMassCalculatorV2.h.

◆ m_eTau1Min

double DiTauMassTools::MissingMassCalculatorV2::m_eTau1Min
private

Definition at line 150 of file MissingMassCalculatorV2.h.

◆ m_eTau1Proposal

double DiTauMassTools::MissingMassCalculatorV2::m_eTau1Proposal
private

Definition at line 148 of file MissingMassCalculatorV2.h.

◆ m_eTau1Range

double DiTauMassTools::MissingMassCalculatorV2::m_eTau1Range
private

Definition at line 150 of file MissingMassCalculatorV2.h.

◆ m_eTau2

double DiTauMassTools::MissingMassCalculatorV2::m_eTau2
private

Definition at line 139 of file MissingMassCalculatorV2.h.

◆ m_eTau20

double DiTauMassTools::MissingMassCalculatorV2::m_eTau20
private

Definition at line 140 of file MissingMassCalculatorV2.h.

◆ m_eTau2Max

double DiTauMassTools::MissingMassCalculatorV2::m_eTau2Max
private

Definition at line 151 of file MissingMassCalculatorV2.h.

◆ m_eTau2Min

double DiTauMassTools::MissingMassCalculatorV2::m_eTau2Min
private

Definition at line 151 of file MissingMassCalculatorV2.h.

◆ m_eTau2Proposal

double DiTauMassTools::MissingMassCalculatorV2::m_eTau2Proposal
private

Definition at line 148 of file MissingMassCalculatorV2.h.

◆ m_eTau2Range

double DiTauMassTools::MissingMassCalculatorV2::m_eTau2Range
private

Definition at line 151 of file MissingMassCalculatorV2.h.

◆ m_Ev1

double DiTauMassTools::MissingMassCalculatorV2::m_Ev1
private

Definition at line 189 of file MissingMassCalculatorV2.h.

◆ m_Ev2

double DiTauMassTools::MissingMassCalculatorV2::m_Ev2
private

Definition at line 188 of file MissingMassCalculatorV2.h.

◆ m_eventNumber

int DiTauMassTools::MissingMassCalculatorV2::m_eventNumber
private

Definition at line 103 of file MissingMassCalculatorV2.h.

◆ m_fApplyMassScale

int DiTauMassTools::MissingMassCalculatorV2::m_fApplyMassScale
private

Definition at line 246 of file MissingMassCalculatorV2.h.

◆ m_fDitauStuffFit

DitauStuff DiTauMassTools::MissingMassCalculatorV2::m_fDitauStuffFit
private

Definition at line 243 of file MissingMassCalculatorV2.h.

◆ m_fDitauStuffHisto

DitauStuff DiTauMassTools::MissingMassCalculatorV2::m_fDitauStuffHisto
private

Definition at line 244 of file MissingMassCalculatorV2.h.

◆ m_fFitting

TF1* DiTauMassTools::MissingMassCalculatorV2::m_fFitting
private

Definition at line 228 of file MissingMassCalculatorV2.h.

◆ m_fJERsyst

int DiTauMassTools::MissingMassCalculatorV2::m_fJERsyst
private

Definition at line 257 of file MissingMassCalculatorV2.h.

◆ m_fMEtL_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMEtL_all
private

Definition at line 197 of file MissingMassCalculatorV2.h.

◆ m_fMEtL_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMEtL_split1
private

Definition at line 215 of file MissingMassCalculatorV2.h.

◆ m_fMEtL_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMEtL_split2
private

Definition at line 222 of file MissingMassCalculatorV2.h.

◆ m_fMEtP_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMEtP_all
private

Definition at line 196 of file MissingMassCalculatorV2.h.

◆ m_fMEtP_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMEtP_split1
private

Definition at line 214 of file MissingMassCalculatorV2.h.

◆ m_fMEtP_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMEtP_split2
private

Definition at line 221 of file MissingMassCalculatorV2.h.

◆ m_fMetx

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fMetx
private

Definition at line 234 of file MissingMassCalculatorV2.h.

◆ m_fMety

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fMety
private

Definition at line 235 of file MissingMassCalculatorV2.h.

◆ m_fMfit_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMfit_all
private

Definition at line 195 of file MissingMassCalculatorV2.h.

◆ m_fMfit_allGraph

std::shared_ptr<TGraph> DiTauMassTools::MissingMassCalculatorV2::m_fMfit_allGraph
private

Definition at line 202 of file MissingMassCalculatorV2.h.

◆ m_fMfit_allNoWeight

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMfit_allNoWeight
private

Definition at line 203 of file MissingMassCalculatorV2.h.

◆ m_fMmass_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMmass_split1
private

Definition at line 213 of file MissingMassCalculatorV2.h.

◆ m_fMmass_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMmass_split2
private

Definition at line 220 of file MissingMassCalculatorV2.h.

◆ m_fMnu1

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fMnu1
private

Definition at line 232 of file MissingMassCalculatorV2.h.

◆ m_fMnu1_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMnu1_all
private

Definition at line 198 of file MissingMassCalculatorV2.h.

◆ m_fMnu1_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMnu1_split1
private

Definition at line 216 of file MissingMassCalculatorV2.h.

◆ m_fMnu1_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMnu1_split2
private

Definition at line 223 of file MissingMassCalculatorV2.h.

◆ m_fMnu2

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fMnu2
private

Definition at line 233 of file MissingMassCalculatorV2.h.

◆ m_fMnu2_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMnu2_all
private

Definition at line 199 of file MissingMassCalculatorV2.h.

◆ m_fMnu2_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMnu2_split1
private

Definition at line 217 of file MissingMassCalculatorV2.h.

◆ m_fMnu2_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fMnu2_split2
private

Definition at line 224 of file MissingMassCalculatorV2.h.

◆ m_fPhi1

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fPhi1
private

Definition at line 230 of file MissingMassCalculatorV2.h.

◆ m_fPhi1_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPhi1_all
private

Definition at line 200 of file MissingMassCalculatorV2.h.

◆ m_fPhi1_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPhi1_split1
private

Definition at line 218 of file MissingMassCalculatorV2.h.

◆ m_fPhi1_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPhi1_split2
private

Definition at line 225 of file MissingMassCalculatorV2.h.

◆ m_fPhi2

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fPhi2
private

Definition at line 231 of file MissingMassCalculatorV2.h.

◆ m_fPhi2_all

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPhi2_all
private

Definition at line 201 of file MissingMassCalculatorV2.h.

◆ m_fPhi2_split1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPhi2_split1
private

Definition at line 219 of file MissingMassCalculatorV2.h.

◆ m_fPhi2_split2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPhi2_split2
private

Definition at line 226 of file MissingMassCalculatorV2.h.

◆ m_fPXfit1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPXfit1
private

Definition at line 205 of file MissingMassCalculatorV2.h.

◆ m_fPXfit2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPXfit2
private

Definition at line 208 of file MissingMassCalculatorV2.h.

◆ m_fPYfit1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPYfit1
private

Definition at line 206 of file MissingMassCalculatorV2.h.

◆ m_fPYfit2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPYfit2
private

Definition at line 209 of file MissingMassCalculatorV2.h.

◆ m_fPZfit1

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPZfit1
private

Definition at line 207 of file MissingMassCalculatorV2.h.

◆ m_fPZfit2

std::shared_ptr<TH1F> DiTauMassTools::MissingMassCalculatorV2::m_fPZfit2
private

Definition at line 210 of file MissingMassCalculatorV2.h.

◆ m_fTauProb

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fTauProb
private

Definition at line 237 of file MissingMassCalculatorV2.h.

◆ m_fTheta3D

TH1F* DiTauMassTools::MissingMassCalculatorV2::m_fTheta3D
private

Definition at line 236 of file MissingMassCalculatorV2.h.

◆ m_fullParamSpaceScan

bool DiTauMassTools::MissingMassCalculatorV2::m_fullParamSpaceScan
private

Definition at line 152 of file MissingMassCalculatorV2.h.

◆ m_fUseEfficiencyRecovery

bool DiTauMassTools::MissingMassCalculatorV2::m_fUseEfficiencyRecovery
private

Definition at line 66 of file MissingMassCalculatorV2.h.

◆ m_fUseFloatStopping

bool DiTauMassTools::MissingMassCalculatorV2::m_fUseFloatStopping
private

Definition at line 67 of file MissingMassCalculatorV2.h.

◆ m_iang1high

int DiTauMassTools::MissingMassCalculatorV2::m_iang1high
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iang1low

int DiTauMassTools::MissingMassCalculatorV2::m_iang1low
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iang2high

int DiTauMassTools::MissingMassCalculatorV2::m_iang2high
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iang2low

int DiTauMassTools::MissingMassCalculatorV2::m_iang2low
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iter0

int DiTauMassTools::MissingMassCalculatorV2::m_iter0
private

Definition at line 107 of file MissingMassCalculatorV2.h.

◆ m_iter1

int DiTauMassTools::MissingMassCalculatorV2::m_iter1
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iter2

int DiTauMassTools::MissingMassCalculatorV2::m_iter2
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iter3

int DiTauMassTools::MissingMassCalculatorV2::m_iter3
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iter4

int DiTauMassTools::MissingMassCalculatorV2::m_iter4
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iter5

int DiTauMassTools::MissingMassCalculatorV2::m_iter5
private

Definition at line 95 of file MissingMassCalculatorV2.h.

◆ m_iterNsuc

int DiTauMassTools::MissingMassCalculatorV2::m_iterNsuc
private

Definition at line 115 of file MissingMassCalculatorV2.h.

◆ m_iterNuPV3

int DiTauMassTools::MissingMassCalculatorV2::m_iterNuPV3
private

Definition at line 108 of file MissingMassCalculatorV2.h.

◆ m_iterTheta3d

int DiTauMassTools::MissingMassCalculatorV2::m_iterTheta3d
private

Definition at line 96 of file MissingMassCalculatorV2.h.

◆ m_lfvLeplepRefit

bool DiTauMassTools::MissingMassCalculatorV2::m_lfvLeplepRefit
private

Definition at line 89 of file MissingMassCalculatorV2.h.

◆ m_m2Nu1

double DiTauMassTools::MissingMassCalculatorV2::m_m2Nu1
private

Definition at line 182 of file MissingMassCalculatorV2.h.

◆ m_m2Nu2

double DiTauMassTools::MissingMassCalculatorV2::m_m2Nu2
private

Definition at line 183 of file MissingMassCalculatorV2.h.

◆ m_markovCountDuplicate

int DiTauMassTools::MissingMassCalculatorV2::m_markovCountDuplicate
private

Definition at line 121 of file MissingMassCalculatorV2.h.

◆ m_markovNAccept

int DiTauMassTools::MissingMassCalculatorV2::m_markovNAccept
private

Definition at line 125 of file MissingMassCalculatorV2.h.

◆ m_markovNFullScan

int DiTauMassTools::MissingMassCalculatorV2::m_markovNFullScan
private

Definition at line 122 of file MissingMassCalculatorV2.h.

◆ m_markovNRejectMetropolis

int DiTauMassTools::MissingMassCalculatorV2::m_markovNRejectMetropolis
private

Definition at line 124 of file MissingMassCalculatorV2.h.

◆ m_markovNRejectNoSol

int DiTauMassTools::MissingMassCalculatorV2::m_markovNRejectNoSol
private

Definition at line 123 of file MissingMassCalculatorV2.h.

◆ m_meanbinStop

double DiTauMassTools::MissingMassCalculatorV2::m_meanbinStop
private

Definition at line 73 of file MissingMassCalculatorV2.h.

◆ m_meanbinToBeEvaluated

bool DiTauMassTools::MissingMassCalculatorV2::m_meanbinToBeEvaluated
private

Definition at line 119 of file MissingMassCalculatorV2.h.

◆ m_Meff

double DiTauMassTools::MissingMassCalculatorV2::m_Meff
private

Definition at line 190 of file MissingMassCalculatorV2.h.

◆ m_metCovPhiCos

double DiTauMassTools::MissingMassCalculatorV2::m_metCovPhiCos
private

Definition at line 147 of file MissingMassCalculatorV2.h.

◆ m_metCovPhiSin

double DiTauMassTools::MissingMassCalculatorV2::m_metCovPhiSin
private

Definition at line 147 of file MissingMassCalculatorV2.h.

◆ m_MEtL

double DiTauMassTools::MissingMassCalculatorV2::m_MEtL
private

Definition at line 138 of file MissingMassCalculatorV2.h.

◆ m_MEtL0

double DiTauMassTools::MissingMassCalculatorV2::m_MEtL0
private

Definition at line 141 of file MissingMassCalculatorV2.h.

◆ m_MEtLMax

double DiTauMassTools::MissingMassCalculatorV2::m_MEtLMax
private

Definition at line 143 of file MissingMassCalculatorV2.h.

◆ m_MEtLMin

double DiTauMassTools::MissingMassCalculatorV2::m_MEtLMin
private

Definition at line 142 of file MissingMassCalculatorV2.h.

◆ m_MEtLRange

double DiTauMassTools::MissingMassCalculatorV2::m_MEtLRange
private

Definition at line 145 of file MissingMassCalculatorV2.h.

◆ m_MEtLStep

double DiTauMassTools::MissingMassCalculatorV2::m_MEtLStep
private

Definition at line 144 of file MissingMassCalculatorV2.h.

◆ m_MEtP

double DiTauMassTools::MissingMassCalculatorV2::m_MEtP
private

Definition at line 138 of file MissingMassCalculatorV2.h.

◆ m_MEtP0

double DiTauMassTools::MissingMassCalculatorV2::m_MEtP0
private

Definition at line 141 of file MissingMassCalculatorV2.h.

◆ m_MEtPMax

double DiTauMassTools::MissingMassCalculatorV2::m_MEtPMax
private

Definition at line 143 of file MissingMassCalculatorV2.h.

◆ m_MEtPMin

double DiTauMassTools::MissingMassCalculatorV2::m_MEtPMin
private

Definition at line 142 of file MissingMassCalculatorV2.h.

◆ m_MEtPRange

double DiTauMassTools::MissingMassCalculatorV2::m_MEtPRange
private

Definition at line 145 of file MissingMassCalculatorV2.h.

◆ m_MEtProposal

double DiTauMassTools::MissingMassCalculatorV2::m_MEtProposal
private

Definition at line 146 of file MissingMassCalculatorV2.h.

◆ m_MEtPStep

double DiTauMassTools::MissingMassCalculatorV2::m_MEtPStep
private

Definition at line 144 of file MissingMassCalculatorV2.h.

◆ m_mmcCalibrationSet

MMCCalibrationSetV2::e DiTauMassTools::MissingMassCalculatorV2::m_mmcCalibrationSet
private

Definition at line 64 of file MissingMassCalculatorV2.h.

◆ m_Mnu1

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1
private

Definition at line 138 of file MissingMassCalculatorV2.h.

◆ m_Mnu10

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu10
private

Definition at line 141 of file MissingMassCalculatorV2.h.

◆ m_Mnu1Exclude

bool DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Exclude
private

Definition at line 153 of file MissingMassCalculatorV2.h.

◆ m_Mnu1ExcludeMax

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1ExcludeMax
private

Definition at line 167 of file MissingMassCalculatorV2.h.

◆ m_Mnu1ExcludeMin

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1ExcludeMin
private

Definition at line 167 of file MissingMassCalculatorV2.h.

◆ m_Mnu1ExcludeRange

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1ExcludeRange
private

Definition at line 167 of file MissingMassCalculatorV2.h.

◆ m_Mnu1Max

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Max
private

Definition at line 143 of file MissingMassCalculatorV2.h.

◆ m_Mnu1Min

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Min
private

Definition at line 142 of file MissingMassCalculatorV2.h.

◆ m_Mnu1Range

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Range
private

Definition at line 145 of file MissingMassCalculatorV2.h.

◆ m_Mnu1Step

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Step
private

Definition at line 144 of file MissingMassCalculatorV2.h.

◆ m_Mnu1XMax

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1XMax
private

Definition at line 168 of file MissingMassCalculatorV2.h.

◆ m_Mnu1XMin

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1XMin
private

Definition at line 168 of file MissingMassCalculatorV2.h.

◆ m_Mnu1XRange

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu1XRange
private

Definition at line 168 of file MissingMassCalculatorV2.h.

◆ m_Mnu2

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu2
private

Definition at line 138 of file MissingMassCalculatorV2.h.

◆ m_Mnu20

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu20
private

Definition at line 141 of file MissingMassCalculatorV2.h.

◆ m_Mnu2Max

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Max
private

Definition at line 143 of file MissingMassCalculatorV2.h.

◆ m_Mnu2Min

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Min
private

Definition at line 142 of file MissingMassCalculatorV2.h.

◆ m_Mnu2Range

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Range
private

Definition at line 145 of file MissingMassCalculatorV2.h.

◆ m_Mnu2Step

double DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Step
private

Definition at line 144 of file MissingMassCalculatorV2.h.

◆ m_MnuProposal

double DiTauMassTools::MissingMassCalculatorV2::m_MnuProposal
private

Definition at line 146 of file MissingMassCalculatorV2.h.

◆ m_MnuScanRange

double DiTauMassTools::MissingMassCalculatorV2::m_MnuScanRange
private

Definition at line 262 of file MissingMassCalculatorV2.h.

◆ m_mTau

double DiTauMassTools::MissingMassCalculatorV2::m_mTau
private

Definition at line 137 of file MissingMassCalculatorV2.h.

◆ m_mTau2

double DiTauMassTools::MissingMassCalculatorV2::m_mTau2
private

Definition at line 137 of file MissingMassCalculatorV2.h.

◆ m_mtautauFinalSolOldVec

std::vector<double> DiTauMassTools::MissingMassCalculatorV2::m_mtautauFinalSolOldVec
private

Definition at line 156 of file MissingMassCalculatorV2.h.

◆ m_mtautauFinalSolVec

std::vector<double> DiTauMassTools::MissingMassCalculatorV2::m_mtautauFinalSolVec
private

Definition at line 162 of file MissingMassCalculatorV2.h.

◆ m_mtautauSum

double DiTauMassTools::MissingMassCalculatorV2::m_mtautauSum
private

Definition at line 101 of file MissingMassCalculatorV2.h.

◆ m_Mvis

double DiTauMassTools::MissingMassCalculatorV2::m_Mvis
private

Definition at line 190 of file MissingMassCalculatorV2.h.

◆ m_nCallprobCalculatorV9fast

int DiTauMassTools::MissingMassCalculatorV2::m_nCallprobCalculatorV9fast
private

Definition at line 91 of file MissingMassCalculatorV2.h.

◆ m_niter_fit1

int DiTauMassTools::MissingMassCalculatorV2::m_niter_fit1
private

Definition at line 248 of file MissingMassCalculatorV2.h.

◆ m_niter_fit2

int DiTauMassTools::MissingMassCalculatorV2::m_niter_fit2
private

Definition at line 249 of file MissingMassCalculatorV2.h.

◆ m_niter_fit3

int DiTauMassTools::MissingMassCalculatorV2::m_niter_fit3
private

Definition at line 250 of file MissingMassCalculatorV2.h.

◆ m_NiterRandom

int DiTauMassTools::MissingMassCalculatorV2::m_NiterRandom
private

Definition at line 251 of file MissingMassCalculatorV2.h.

◆ m_niterRandomLocal

int DiTauMassTools::MissingMassCalculatorV2::m_niterRandomLocal
private

Definition at line 70 of file MissingMassCalculatorV2.h.

◆ m_nosol1

int DiTauMassTools::MissingMassCalculatorV2::m_nosol1
private

Definition at line 113 of file MissingMassCalculatorV2.h.

◆ m_nosol2

int DiTauMassTools::MissingMassCalculatorV2::m_nosol2
private

Definition at line 114 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan2

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan2
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan_hh

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_hh
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan_lfv_lh

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_lfv_lh
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan_lfv_ll

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_lfv_ll
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan_lh

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_lh
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsigma_METscan_ll

double DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_ll
private

Definition at line 93 of file MissingMassCalculatorV2.h.

◆ m_nsol

int DiTauMassTools::MissingMassCalculatorV2::m_nsol
private

Definition at line 160 of file MissingMassCalculatorV2.h.

◆ m_nsolfinalmax

int DiTauMassTools::MissingMassCalculatorV2::m_nsolfinalmax
private

Definition at line 69 of file MissingMassCalculatorV2.h.

◆ m_nsolmax

int DiTauMassTools::MissingMassCalculatorV2::m_nsolmax
private

Definition at line 69 of file MissingMassCalculatorV2.h.

◆ m_nsolOld

int DiTauMassTools::MissingMassCalculatorV2::m_nsolOld
private

Definition at line 154 of file MissingMassCalculatorV2.h.

◆ m_nsucStop

int DiTauMassTools::MissingMassCalculatorV2::m_nsucStop
private

Definition at line 71 of file MissingMassCalculatorV2.h.

◆ m_NsucStop

int DiTauMassTools::MissingMassCalculatorV2::m_NsucStop
private

Definition at line 252 of file MissingMassCalculatorV2.h.

◆ m_nu1FinalSolOldVec

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nu1FinalSolOldVec
private

Definition at line 157 of file MissingMassCalculatorV2.h.

◆ m_nu1FinalSolVec

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nu1FinalSolVec
private

Definition at line 163 of file MissingMassCalculatorV2.h.

◆ m_nu2FinalSolOldVec

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nu2FinalSolOldVec
private

Definition at line 158 of file MissingMassCalculatorV2.h.

◆ m_nu2FinalSolVec

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nu2FinalSolVec
private

Definition at line 164 of file MissingMassCalculatorV2.h.

◆ m_nuvec1_tmp

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nuvec1_tmp
private

Definition at line 84 of file MissingMassCalculatorV2.h.

◆ m_nuvec2_tmp

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nuvec2_tmp
private

Definition at line 85 of file MissingMassCalculatorV2.h.

◆ m_nuvecsol1

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nuvecsol1
private

Definition at line 76 of file MissingMassCalculatorV2.h.

◆ m_nuvecsol2

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_nuvecsol2
private

Definition at line 77 of file MissingMassCalculatorV2.h.

◆ m_Phi1

double DiTauMassTools::MissingMassCalculatorV2::m_Phi1
private

Definition at line 138 of file MissingMassCalculatorV2.h.

◆ m_Phi10

double DiTauMassTools::MissingMassCalculatorV2::m_Phi10
private

Definition at line 141 of file MissingMassCalculatorV2.h.

◆ m_Phi1Max

double DiTauMassTools::MissingMassCalculatorV2::m_Phi1Max
private

Definition at line 143 of file MissingMassCalculatorV2.h.

◆ m_Phi1Min

double DiTauMassTools::MissingMassCalculatorV2::m_Phi1Min
private

Definition at line 142 of file MissingMassCalculatorV2.h.

◆ m_Phi1Range

double DiTauMassTools::MissingMassCalculatorV2::m_Phi1Range
private

Definition at line 145 of file MissingMassCalculatorV2.h.

◆ m_Phi1Step

double DiTauMassTools::MissingMassCalculatorV2::m_Phi1Step
private

Definition at line 144 of file MissingMassCalculatorV2.h.

◆ m_Phi2

double DiTauMassTools::MissingMassCalculatorV2::m_Phi2
private

Definition at line 138 of file MissingMassCalculatorV2.h.

◆ m_Phi20

double DiTauMassTools::MissingMassCalculatorV2::m_Phi20
private

Definition at line 141 of file MissingMassCalculatorV2.h.

◆ m_Phi2Max

double DiTauMassTools::MissingMassCalculatorV2::m_Phi2Max
private

Definition at line 143 of file MissingMassCalculatorV2.h.

◆ m_Phi2Min

double DiTauMassTools::MissingMassCalculatorV2::m_Phi2Min
private

Definition at line 142 of file MissingMassCalculatorV2.h.

◆ m_Phi2Range

double DiTauMassTools::MissingMassCalculatorV2::m_Phi2Range
private

Definition at line 145 of file MissingMassCalculatorV2.h.

◆ m_Phi2Step

double DiTauMassTools::MissingMassCalculatorV2::m_Phi2Step
private

Definition at line 144 of file MissingMassCalculatorV2.h.

◆ m_PhiProposal

double DiTauMassTools::MissingMassCalculatorV2::m_PhiProposal
private

Definition at line 146 of file MissingMassCalculatorV2.h.

◆ m_PrintmInvWidth2Error

double DiTauMassTools::MissingMassCalculatorV2::m_PrintmInvWidth2Error
private

Definition at line 129 of file MissingMassCalculatorV2.h.

◆ m_PrintmMaxError

double DiTauMassTools::MissingMassCalculatorV2::m_PrintmMaxError
private

Definition at line 127 of file MissingMassCalculatorV2.h.

◆ m_PrintmMeanError

double DiTauMassTools::MissingMassCalculatorV2::m_PrintmMeanError
private

Definition at line 128 of file MissingMassCalculatorV2.h.

◆ m_prob_tmp

double DiTauMassTools::MissingMassCalculatorV2::m_prob_tmp
private

Definition at line 98 of file MissingMassCalculatorV2.h.

◆ m_probFinalSolOldVec

std::vector<double> DiTauMassTools::MissingMassCalculatorV2::m_probFinalSolOldVec
private

Definition at line 155 of file MissingMassCalculatorV2.h.

◆ m_probFinalSolVec

std::vector<double> DiTauMassTools::MissingMassCalculatorV2::m_probFinalSolVec
private

Definition at line 161 of file MissingMassCalculatorV2.h.

◆ m_ProposalTryEtau

double DiTauMassTools::MissingMassCalculatorV2::m_ProposalTryEtau
private

Definition at line 134 of file MissingMassCalculatorV2.h.

◆ m_proposalTryMEt

double DiTauMassTools::MissingMassCalculatorV2::m_proposalTryMEt
private

Definition at line 131 of file MissingMassCalculatorV2.h.

◆ m_ProposalTryMnu

double DiTauMassTools::MissingMassCalculatorV2::m_ProposalTryMnu
private

Definition at line 133 of file MissingMassCalculatorV2.h.

◆ m_ProposalTryPhi

double DiTauMassTools::MissingMassCalculatorV2::m_ProposalTryPhi
private

Definition at line 132 of file MissingMassCalculatorV2.h.

◆ m_randomGen

TRandom2 DiTauMassTools::MissingMassCalculatorV2::m_randomGen
private

Definition at line 62 of file MissingMassCalculatorV2.h.

◆ m_reRunWithBestMET

bool DiTauMassTools::MissingMassCalculatorV2::m_reRunWithBestMET
private

Definition at line 191 of file MissingMassCalculatorV2.h.

◆ m_rmsStop

int DiTauMassTools::MissingMassCalculatorV2::m_rmsStop
private

Definition at line 72 of file MissingMassCalculatorV2.h.

◆ m_RMSStop

int DiTauMassTools::MissingMassCalculatorV2::m_RMSStop
private

Definition at line 253 of file MissingMassCalculatorV2.h.

◆ m_RndmSeedAltering

int DiTauMassTools::MissingMassCalculatorV2::m_RndmSeedAltering
private

Definition at line 254 of file MissingMassCalculatorV2.h.

◆ m_scanMnu1

bool DiTauMassTools::MissingMassCalculatorV2::m_scanMnu1
private

Definition at line 172 of file MissingMassCalculatorV2.h.

◆ m_scanMnu2

bool DiTauMassTools::MissingMassCalculatorV2::m_scanMnu2
private

Definition at line 172 of file MissingMassCalculatorV2.h.

◆ m_seed

int DiTauMassTools::MissingMassCalculatorV2::m_seed
private

Definition at line 104 of file MissingMassCalculatorV2.h.

◆ m_sinPhi1

double DiTauMassTools::MissingMassCalculatorV2::m_sinPhi1
private

Definition at line 170 of file MissingMassCalculatorV2.h.

◆ m_sinPhi2

double DiTauMassTools::MissingMassCalculatorV2::m_sinPhi2
private

Definition at line 170 of file MissingMassCalculatorV2.h.

◆ m_switch1

bool DiTauMassTools::MissingMassCalculatorV2::m_switch1
private

Definition at line 116 of file MissingMassCalculatorV2.h.

◆ m_switch2

bool DiTauMassTools::MissingMassCalculatorV2::m_switch2
private

Definition at line 117 of file MissingMassCalculatorV2.h.

◆ m_tautau_tmp

TLorentzVector DiTauMassTools::MissingMassCalculatorV2::m_tautau_tmp
private

Definition at line 87 of file MissingMassCalculatorV2.h.

◆ m_tauVec1

TLorentzVector DiTauMassTools::MissingMassCalculatorV2::m_tauVec1
private

Definition at line 174 of file MissingMassCalculatorV2.h.

◆ m_tauVec1E

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1E
private

Definition at line 180 of file MissingMassCalculatorV2.h.

◆ m_tauVec1M

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1M
private

Definition at line 176 of file MissingMassCalculatorV2.h.

◆ m_tauVec1P

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1P
private

Definition at line 179 of file MissingMassCalculatorV2.h.

◆ m_tauVec1Phi

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Phi
private

Definition at line 175 of file MissingMassCalculatorV2.h.

◆ m_tauVec1Px

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Px
private

Definition at line 177 of file MissingMassCalculatorV2.h.

◆ m_tauVec1Py

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Py
private

Definition at line 177 of file MissingMassCalculatorV2.h.

◆ m_tauVec1Pz

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Pz
private

Definition at line 177 of file MissingMassCalculatorV2.h.

◆ m_tauVec2

TLorentzVector DiTauMassTools::MissingMassCalculatorV2::m_tauVec2
private

Definition at line 174 of file MissingMassCalculatorV2.h.

◆ m_tauVec2E

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2E
private

Definition at line 181 of file MissingMassCalculatorV2.h.

◆ m_tauVec2M

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2M
private

Definition at line 176 of file MissingMassCalculatorV2.h.

◆ m_tauVec2P

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2P
private

Definition at line 179 of file MissingMassCalculatorV2.h.

◆ m_tauVec2Phi

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Phi
private

Definition at line 175 of file MissingMassCalculatorV2.h.

◆ m_tauVec2Px

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Px
private

Definition at line 178 of file MissingMassCalculatorV2.h.

◆ m_tauVec2Py

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Py
private

Definition at line 178 of file MissingMassCalculatorV2.h.

◆ m_tauVec2Pz

double DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Pz
private

Definition at line 178 of file MissingMassCalculatorV2.h.

◆ m_tauvecprob1

std::vector<double> DiTauMassTools::MissingMassCalculatorV2::m_tauvecprob1
private

Definition at line 81 of file MissingMassCalculatorV2.h.

◆ m_tauvecprob2

std::vector<double> DiTauMassTools::MissingMassCalculatorV2::m_tauvecprob2
private

Definition at line 82 of file MissingMassCalculatorV2.h.

◆ m_tauvecsol1

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_tauvecsol1
private

Definition at line 79 of file MissingMassCalculatorV2.h.

◆ m_tauvecsol2

std::vector<TLorentzVector> DiTauMassTools::MissingMassCalculatorV2::m_tauvecsol2
private

Definition at line 80 of file MissingMassCalculatorV2.h.

◆ m_testdiscri1

int DiTauMassTools::MissingMassCalculatorV2::m_testdiscri1
private

Definition at line 111 of file MissingMassCalculatorV2.h.

◆ m_testdiscri2

int DiTauMassTools::MissingMassCalculatorV2::m_testdiscri2
private

Definition at line 112 of file MissingMassCalculatorV2.h.

◆ m_testptn1

int DiTauMassTools::MissingMassCalculatorV2::m_testptn1
private

Definition at line 109 of file MissingMassCalculatorV2.h.

◆ m_testptn2

int DiTauMassTools::MissingMassCalculatorV2::m_testptn2
private

Definition at line 110 of file MissingMassCalculatorV2.h.

◆ m_TLVdummy

TLorentzVector DiTauMassTools::MissingMassCalculatorV2::m_TLVdummy
private

Definition at line 240 of file MissingMassCalculatorV2.h.

◆ m_totalProbSum

double DiTauMassTools::MissingMassCalculatorV2::m_totalProbSum
private

Definition at line 100 of file MissingMassCalculatorV2.h.

◆ m_walkWeight

double DiTauMassTools::MissingMassCalculatorV2::m_walkWeight
private

Definition at line 169 of file MissingMassCalculatorV2.h.

◆ metvec_tmp

TVector2 DiTauMassTools::MissingMassCalculatorV2::metvec_tmp

Definition at line 419 of file MissingMassCalculatorV2.h.

◆ OutputInfo

MissingMassOutput DiTauMassTools::MissingMassCalculatorV2::OutputInfo

Definition at line 339 of file MissingMassCalculatorV2.h.

◆ preparedInput

MissingMassInput DiTauMassTools::MissingMassCalculatorV2::preparedInput

Definition at line 338 of file MissingMassCalculatorV2.h.

◆ Prob

MissingMassProb* DiTauMassTools::MissingMassCalculatorV2::Prob

Definition at line 340 of file MissingMassCalculatorV2.h.

The documentation for this class was generated from the following files:
DiTauMassTools::MissingMassCalculatorV2::m_Ev2
double m_Ev2
Definition: MissingMassCalculatorV2.h:188
RunTileTBRec.method
method
Definition: RunTileTBRec.py:73
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
DiTauMassTools::MissingMassCalculatorV2::m_fPhi2_split2
std::shared_ptr< TH1F > m_fPhi2_split2
Definition: MissingMassCalculatorV2.h:226
DiTauMassTools::MissingMassCalculatorV2::m_markovNFullScan
int m_markovNFullScan
Definition: MissingMassCalculatorV2.h:122
DiTauMassTools::MissingMassCalculatorV2::refineSolutions
int refineSolutions(const double &M_nu1, const double &M_nu2, const int nsol1, const int nsol2, const double &Mvis, const double &Meff)
Definition: MissingMassCalculatorV2.cxx:1884
DiTauMassTools::MissingMassCalculatorV2::m_fUseEfficiencyRecovery
bool m_fUseEfficiencyRecovery
Definition: MissingMassCalculatorV2.h:66
DiTauMassTools::MissingMassProb::SetUseDphiLL
void SetUseDphiLL(bool val)
Definition: MissingMassProb.h:56
DiTauMassTools::MissingMassCalculatorV2::m_iter5
int m_iter5
Definition: MissingMassCalculatorV2.h:95
DiTauMassTools::MissingMassCalculatorV2::m_iter2
int m_iter2
Definition: MissingMassCalculatorV2.h:95
DiTauMassTools::Angle
double Angle(const TLorentzVector &vec1, const TLorentzVector &vec2)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:46
DiTauMassTools::MissingMassCalculatorV2::m_probFinalSolOldVec
std::vector< double > m_probFinalSolOldVec
Definition: MissingMassCalculatorV2.h:155
DiTauMassTools::MissingMassCalculatorV2::m_ET2v2
double m_ET2v2
Definition: MissingMassCalculatorV2.h:185
DiTauMassTools::MissingMassCalculatorV2::m_markovNRejectNoSol
int m_markovNRejectNoSol
Definition: MissingMassCalculatorV2.h:123
DiTauMassTools::MissingMassCalculatorV2::maxFromHist
double maxFromHist(TH1F *theHist, std::vector< double > &histInfo, const MaxHistStrategyV2::e maxHistStrategy=MaxHistStrategyV2::FIT, const int winHalfWidth=2, bool debug=false)
Definition: MissingMassCalculatorV2.cxx:1582
DiTauMassTools::MissingMassOutput::m_FitSignificance
double m_FitSignificance[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:51
DiTauMassTools::MissingMassOutput::m_nuvec1
TLorentzVector m_nuvec1[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:55
DiTauMassTools::MissingMassCalculatorV2::m_fMEtL_split2
std::shared_ptr< TH1F > m_fMEtL_split2
Definition: MissingMassCalculatorV2.h:222
DiTauMassTools::MissingMassCalculatorV2::m_prob_tmp
double m_prob_tmp
Definition: MissingMassCalculatorV2.h:98
DiTauMassTools::TauTypes::lh
@ lh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:49
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::RMSoverMPV
double RMSoverMPV
Definition: MissingMassCalculatorV2.h:59
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_hh
double m_nsigma_METscan_hh
Definition: MissingMassCalculatorV2.h:93
DiTauMassTools::MissingMassInput::m_metVec
TVector2 m_metVec
Definition: MissingMassInput.h:77
DiTauMassTools::MissingMassCalculatorV2::m_markovNAccept
int m_markovNAccept
Definition: MissingMassCalculatorV2.h:125
DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan_ll
void SetNsigmaMETscan_ll(const double val)
Definition: MissingMassCalculatorV2.h:391
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:126
max
#define max(a, b)
Definition: cfImp.cxx:41
DiTauMassTools::MissingMassOutput::m_nuvec2
TLorentzVector m_nuvec2[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:57
DiTauMassTools::MissingMassCalculatorV2::m_testptn1
int m_testptn1
Definition: MissingMassCalculatorV2.h:109
DiTauMassTools::MissingMassCalculatorV2::m_fMfit_all
std::shared_ptr< TH1F > m_fMfit_all
Definition: MissingMassCalculatorV2.h:195
DiTauMassTools::HistInfoV2::TANTHETAW
@ TANTHETAW
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassProb::GetUseTauProbability
bool GetUseTauProbability()
Definition: MissingMassProb.h:51
DiTauMassTools::MissingMassCalculatorV2::m_iterNuPV3
int m_iterNuPV3
Definition: MissingMassCalculatorV2.h:108
DiTauMassTools::TauTypes::hh
@ hh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:49
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
DiTauMassTools::MissingMassCalculatorV2::m_niterRandomLocal
int m_niterRandomLocal
Definition: MissingMassCalculatorV2.h:70
DiTauMassTools::MissingMassCalculatorV2::maxFitting
Double_t maxFitting(Double_t *x, Double_t *par)
Definition: MissingMassCalculatorV2.cxx:1562
DiTauMassTools::MissingMassInput::m_METsigmaP
double m_METsigmaP
Definition: MissingMassInput.h:60
DiTauMassTools::MissingMassCalculatorV2::m_nosol2
int m_nosol2
Definition: MissingMassCalculatorV2.h:114
DiTauMassTools::MissingMassProb::TauProbabilityLFV
double TauProbabilityLFV(MissingMassInput &preparedInput, const int &type1, const TLorentzVector &vis1, const TLorentzVector &nu1)
Definition: MissingMassProb.cxx:612
DiTauMassTools::MissingMassCalculatorV2::m_MEtLRange
double m_MEtLRange
Definition: MissingMassCalculatorV2.h:145
DiTauMassTools::MissingMassInput::m_METScanScheme
int m_METScanScheme
Definition: MissingMassInput.h:72
DiTauMassTools::MissingMassCalculatorV2::m_nuvecsol1
std::vector< TLorentzVector > m_nuvecsol1
Definition: MissingMassCalculatorV2.h:76
DiTauMassTools::MissingMassCalculatorV2::m_tauvecprob2
std::vector< double > m_tauvecprob2
Definition: MissingMassCalculatorV2.h:82
DiTauMassTools::MissingMassCalculatorV2::ClearDitauStuff
void ClearDitauStuff(DitauStuff &fStuff)
Definition: MissingMassCalculatorV2.cxx:358
DiTauMassTools::HistInfoV2::FITLENGTH
@ FITLENGTH
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_fMfit_allNoWeight
std::shared_ptr< TH1F > m_fMfit_allNoWeight
Definition: MissingMassCalculatorV2.h:203
DiTauMassTools::MissingMassOutput::m_objvec1
TLorentzVector m_objvec1[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:56
DiTauMassTools::MissingMassCalculatorV2::DitauMassCalculatorV9lfv
int DitauMassCalculatorV9lfv(bool refit)
Definition: MissingMassCalculatorV2.cxx:1081
DiTauMassTools::MissingMassProb::MET
void MET(MissingMassInput &preparedInput)
Definition: MissingMassProb.cxx:1247
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
DiTauMassTools::MissingMassInput::m_inputMEtT
double m_inputMEtT
Definition: MissingMassInput.h:79
DiTauMassTools::MissingMassCalculatorV2::m_fUseFloatStopping
bool m_fUseFloatStopping
Definition: MissingMassCalculatorV2.h:67
DiTauMassTools::MissingMassProb::SetUseMnuProbability
void SetUseMnuProbability(bool val)
Definition: MissingMassProb.h:53
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1P
double m_tauVec1P
Definition: MissingMassCalculatorV2.h:179
DiTauMassTools::MissingMassCalculatorV2::m_fDitauStuffFit
DitauStuff m_fDitauStuffFit
Definition: MissingMassCalculatorV2.h:243
DiTauMassTools::MissingMassCalculatorV2::m_debugThisIteration
bool m_debugThisIteration
Definition: MissingMassCalculatorV2.h:89
DiTauMassTools::MissingMassCalculatorV2::m_fPXfit2
std::shared_ptr< TH1F > m_fPXfit2
Definition: MissingMassCalculatorV2.h:208
DiTauMassTools::MissingMassInput::m_METsigmaL
double m_METsigmaL
Definition: MissingMassInput.h:61
DiTauMassTools::MissingMassCalculatorV2::MassScale
double MassScale(int method, double mass, const int &tau_type1, const int &tau_type2)
Definition: MissingMassCalculatorV2.cxx:2110
DiTauMassTools::MissingMassCalculatorV2::m_Phi20
double m_Phi20
Definition: MissingMassCalculatorV2.h:141
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::Mditau_best
double Mditau_best
Definition: MissingMassCalculatorV2.h:53
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_lh
double m_nsigma_METscan_lh
Definition: MissingMassCalculatorV2.h:93
DiTauMassTools::MissingMassCalculatorV2::m_fPhi1_split1
std::shared_ptr< TH1F > m_fPhi1_split1
Definition: MissingMassCalculatorV2.h:218
DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Min
double m_Mnu1Min
Definition: MissingMassCalculatorV2.h:142
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1M
double m_tauVec1M
Definition: MissingMassCalculatorV2.h:176
DiTauMassTools::MissingMassOutput::m_FittedMetVec
TVector2 m_FittedMetVec[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:60
DiTauMassTools::MissingMassCalculatorV2::m_scanMnu2
bool m_scanMnu2
Definition: MissingMassCalculatorV2.h:172
DiTauMassTools::MissingMassCalculatorV2::m_fMmass_split1
std::shared_ptr< TH1F > m_fMmass_split1
Definition: MissingMassCalculatorV2.h:213
DiTauMassTools::MissingMassOutput::m_objvec2
TLorentzVector m_objvec2[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:58
DiTauMassTools::MissingMassCalculatorV2::m_nsol
int m_nsol
Definition: MissingMassCalculatorV2.h:160
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1E
double m_tauVec1E
Definition: MissingMassCalculatorV2.h:180
DiTauMassTools::MissingMassInput::SetLFVmode
void SetLFVmode(int val)
Definition: MissingMassInput.h:45
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
DiTauMassTools::MissingMassCalculatorV2::m_fMEtL_split1
std::shared_ptr< TH1F > m_fMEtL_split1
Definition: MissingMassCalculatorV2.h:215
plotBeamSpotVxVal.sumw
int sumw
Definition: plotBeamSpotVxVal.py:236
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::vistau1
TLorentzVector vistau1
Definition: MissingMassCalculatorV2.h:57
DiTauMassTools::MissingMassOutput::m_hMfit_all
std::shared_ptr< TH1F > m_hMfit_all
Definition: MissingMassOutput.h:62
DiTauMassTools::MissingMassCalculatorV2::m_iter4
int m_iter4
Definition: MissingMassCalculatorV2.h:95
DiTauMassTools::MissingMassCalculatorV2::m_fPhi2_split1
std::shared_ptr< TH1F > m_fPhi2_split1
Definition: MissingMassCalculatorV2.h:219
DiTauMassTools::MissingMassCalculatorV2::m_switch2
bool m_switch2
Definition: MissingMassCalculatorV2.h:117
DiTauMassTools::MissingMassCalculatorV2::m_Mnu10
double m_Mnu10
Definition: MissingMassCalculatorV2.h:141
DiTauMassTools::MissingMassCalculatorV2::metvec_tmp
TVector2 metvec_tmp
Definition: MissingMassCalculatorV2.h:419
DiTauMassTools::MissingMassCalculatorV2::m_ProposalTryEtau
double m_ProposalTryEtau
Definition: MissingMassCalculatorV2.h:134
yodamerge_tmp.scale
scale
Definition: yodamerge_tmp.py:138
covarianceTool.prob
prob
Definition: covarianceTool.py:678
ZDCMsg::Info
@ Info
Definition: ZDCMsg.h:20
Phi_mpi_pi
__HOSTDEV__ double Phi_mpi_pi(double)
Definition: GeoRegion.cxx:7
python.TrigEgammaFastCaloHypoTool.same
def same(val, tool)
Definition: TrigEgammaFastCaloHypoTool.py:12
x
#define x
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2M
double m_tauVec2M
Definition: MissingMassCalculatorV2.h:176
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2P
double m_tauVec2P
Definition: MissingMassCalculatorV2.h:179
DiTauMassTools::MissingMassCalculatorV2::m_Phi1Range
double m_Phi1Range
Definition: MissingMassCalculatorV2.h:145
DiTauMassTools::MissingMassCalculatorV2::NuPsolutionLFV
int NuPsolutionLFV(const TVector2 &met_vec, const TLorentzVector &tau, const double &m_nu, std::vector< TLorentzVector > &nu_vec)
Definition: MissingMassCalculatorV2.cxx:828
DiTauMassTools::MissingMassCalculatorV2::Prob
MissingMassProb * Prob
Definition: MissingMassCalculatorV2.h:340
DiTauMassTools::MissingMassCalculatorV2::m_MEtPMax
double m_MEtPMax
Definition: MissingMassCalculatorV2.h:143
DiTauMassTools::MissingMassProb::apply
double apply(MissingMassInput &preparedInput, const int &tau_type1, const int &tau_type2, const TLorentzVector &tauvec1, const TLorentzVector &tauvec2, const TLorentzVector nuvec1, const TLorentzVector &nuvec2, bool constant=false, bool oneTau=false, bool twoTau=false)
Definition: MissingMassProb.cxx:532
DiTauMassTools::MissingMassInput::m_jet4vecs
std::vector< TLorentzVector > m_jet4vecs
Definition: MissingMassInput.h:63
DiTauMassTools::MissingMassCalculatorV2::m_MnuProposal
double m_MnuProposal
Definition: MissingMassCalculatorV2.h:146
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
binWidth
void binWidth(TH1 *h)
Definition: listroot.cxx:80
DiTauMassTools::MissingMassCalculatorV2::m_eTau1Min
double m_eTau1Min
Definition: MissingMassCalculatorV2.h:150
DiTauMassTools::MissingMassOutput::m_FittedMassLowerError
double m_FittedMassLowerError[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:54
DiTauMassTools::MissingMassCalculatorV2::m_ProposalTryMnu
double m_ProposalTryMnu
Definition: MissingMassCalculatorV2.h:133
DiTauMassTools::MissingMassCalculatorV2::m_probFinalSolVec
std::vector< double > m_probFinalSolVec
Definition: MissingMassCalculatorV2.h:161
DiTauMassTools::MissingMassCalculatorV2::NuPsolution
int NuPsolution(TVector2 met_vec, double theta1, double phi1, double theta2, double phi2, double &P1, double &P2)
Definition: MissingMassCalculatorV2.cxx:2939
DiTauMassTools::MissingMassCalculatorV2::OutputInfo
MissingMassOutput OutputInfo
Definition: MissingMassCalculatorV2.h:339
DiTauMassTools::MissingMassCalculatorV2::m_nu2FinalSolOldVec
std::vector< TLorentzVector > m_nu2FinalSolOldVec
Definition: MissingMassCalculatorV2.h:158
DiTauMassTools::fastSinCos
void fastSinCos(const double &phi, double &sinPhi, double &cosPhi)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:74
DiTauMassTools::MissingMassOutput::m_hMfit_allNoWeight
std::shared_ptr< TH1F > m_hMfit_allNoWeight
Definition: MissingMassOutput.h:63
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::vistau2
TLorentzVector vistau2
Definition: MissingMassCalculatorV2.h:58
DiTauMassTools::MissingMassCalculatorV2::m_fMEtP_split1
std::shared_ptr< TH1F > m_fMEtP_split1
Definition: MissingMassCalculatorV2.h:214
DiTauMassTools::MissingMassCalculatorV2::m_Phi2Max
double m_Phi2Max
Definition: MissingMassCalculatorV2.h:143
DiTauMassTools::updateDouble
bool updateDouble(const double in, double &out)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:107
DiTauMassTools::MissingMassInput::m_METcovphi
double m_METcovphi
Definition: MissingMassInput.h:59
DiTauMassTools::MMCFitMethodV2::name
const std::string name[MAX]
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:43
ParticleJetTools::p3
Amg::Vector3D p3(const xAOD::TruthVertex *p)
Definition: ParticleJetLabelCommon.cxx:55
DiTauMassTools::MissingMassCalculatorV2::m_metCovPhiSin
double m_metCovPhiSin
Definition: MissingMassCalculatorV2.h:147
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
xAOD::EgammaParameters::deltaPhi1
@ deltaPhi1
difference between the cluster eta (1st sampling) and the eta of the track extrapolated to the 1st sa...
Definition: EgammaEnums.h:196
DiTauMassTools::MissingMassCalculatorV2::m_metCovPhiCos
double m_metCovPhiCos
Definition: MissingMassCalculatorV2.h:147
DiTauMassTools::MissingMassCalculatorV2::handleSolutions
void handleSolutions()
Definition: MissingMassCalculatorV2.cxx:2167
DiTauMassTools::MissingMassCalculatorV2::m_eTau20
double m_eTau20
Definition: MissingMassCalculatorV2.h:140
DiTauMassTools::MissingMassOutput::m_FittedMassUpperError
double m_FittedMassUpperError[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:53
DiTauMassTools::MissingMassInput::m_tauTypes
TauTypes::e m_tauTypes
Definition: MissingMassInput.h:83
DiTauMassTools::MissingMassCalculatorV2::m_Phi1Min
double m_Phi1Min
Definition: MissingMassCalculatorV2.h:142
DiTauMassTools::HistInfoV2::CHI2
@ CHI2
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Min
double m_Mnu2Min
Definition: MissingMassCalculatorV2.h:142
DiTauMassTools::MissingMassCalculatorV2::m_fullParamSpaceScan
bool m_fullParamSpaceScan
Definition: MissingMassCalculatorV2.h:152
DiTauMassTools::MMCFitMethodV2::MAXW
@ MAXW
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:42
DiTauMassTools::MissingMassCalculatorV2::m_fPZfit2
std::shared_ptr< TH1F > m_fPZfit2
Definition: MissingMassCalculatorV2.h:210
part1
Definition: part1.py:1
DiTauMassTools::MissingMassCalculatorV2::m_iterNsuc
int m_iterNsuc
Definition: MissingMassCalculatorV2.h:115
DiTauMassTools::MissingMassCalculatorV2::m_Mvis
double m_Mvis
Definition: MissingMassCalculatorV2.h:190
DiTauMassTools::MissingMassCalculatorV2::m_Mnu20
double m_Mnu20
Definition: MissingMassCalculatorV2.h:141
DiTauMassTools::MissingMassCalculatorV2::m_RMSStop
int m_RMSStop
Definition: MissingMassCalculatorV2.h:253
DiTauMassTools::MaxDelPhi
double MaxDelPhi(int tau_type, double Pvis, double dRmax_tau)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:41
DiTauMassTools::MaxHistStrategyV2::MAXBINWINDOW
@ MAXBINWINDOW
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
DiTauMassTools::MissingMassCalculatorV2::m_mtautauSum
double m_mtautauSum
Definition: MissingMassCalculatorV2.h:101
met
Definition: IMETSignificance.h:24
DiTauMassTools::MissingMassCalculatorV2::m_fPXfit1
std::shared_ptr< TH1F > m_fPXfit1
Definition: MissingMassCalculatorV2.h:205
DiTauMassTools::MissingMassCalculatorV2::m_fMEtL_all
std::shared_ptr< TH1F > m_fMEtL_all
Definition: MissingMassCalculatorV2.h:197
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Pz
double m_tauVec1Pz
Definition: MissingMassCalculatorV2.h:177
DiTauMassTools::MissingMassCalculatorV2::DoOutputInfo
void DoOutputInfo()
Definition: MissingMassCalculatorV2.cxx:373
DiTauMassTools::MissingMassCalculatorV2::m_sinPhi1
double m_sinPhi1
Definition: MissingMassCalculatorV2.h:170
DiTauMassTools::MissingMassCalculatorV2::DitauMassCalculatorV9walk
int DitauMassCalculatorV9walk()
Definition: MissingMassCalculatorV2.cxx:863
DiTauMassTools::MissingMassCalculatorV2::m_iang1low
int m_iang1low
Definition: MissingMassCalculatorV2.h:95
DiTauMassTools::MissingMassCalculatorV2::m_NsucStop
int m_NsucStop
Definition: MissingMassCalculatorV2.h:252
DiTauMassTools::MissingMassInput::m_htOffset
double m_htOffset
Definition: MissingMassInput.h:81
DiTauMassTools::MissingMassCalculatorV2::m_fPhi2_all
std::shared_ptr< TH1F > m_fPhi2_all
Definition: MissingMassCalculatorV2.h:201
DiTauMassTools::MissingMassInput::m_SumEt
double m_SumEt
Definition: MissingMassInput.h:62
doubleTestComp.j1
j1
Definition: doubleTestComp.py:21
DiTauMassTools::MissingMassProb::MnuProbability
double MnuProbability(MissingMassInput &preparedInput, double mnu, double binsize)
Definition: MissingMassProb.cxx:937
DiTauMassTools::MissingMassCalculatorV2::m_Ev1
double m_Ev1
Definition: MissingMassCalculatorV2.h:189
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Phi
double m_tauVec1Phi
Definition: MissingMassCalculatorV2.h:175
TrigVtx::gamma
@ gamma
Definition: TrigParticleTable.h:26
DiTauMassTools::MissingMassInput::m_Nprong_tau2
int m_Nprong_tau2
Definition: MissingMassInput.h:57
DiTauMassTools::MissingMassCalculatorV2::m_fPhi1_split2
std::shared_ptr< TH1F > m_fPhi1_split2
Definition: MissingMassCalculatorV2.h:225
ParseInputs.gDirectory
gDirectory
Definition: Final2012/ParseInputs.py:133
lumiFormat.i
int i
Definition: lumiFormat.py:92
DiTauMassTools::MissingMassCalculatorV2::m_testdiscri2
int m_testdiscri2
Definition: MissingMassCalculatorV2.h:112
DiTauMassTools::MissingMassInput::m_MHtSigma2
double m_MHtSigma2
Definition: MissingMassInput.h:67
DiTauMassTools::HistInfoV2::MAXHISTINFO
@ MAXHISTINFO
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_PrintmMeanError
double m_PrintmMeanError
Definition: MissingMassCalculatorV2.h:128
DiTauMassTools::MMCCalibrationSetV2::MMC2015HIGHMASS
@ MMC2015HIGHMASS
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:36
DiTauMassTools::MissingMassCalculatorV2::PrintOtherInput
void PrintOtherInput()
Definition: MissingMassCalculatorV2.cxx:476
DiTauMassTools::MissingMassCalculatorV2::m_proposalTryMEt
double m_proposalTryMEt
Definition: MissingMassCalculatorV2.h:131
DiTauMassTools::MissingMassCalculatorV2::m_switch1
bool m_switch1
Definition: MissingMassCalculatorV2.h:116
DiTauMassTools::MaxHistStrategyV2::FIT
@ FIT
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
DiTauMassTools::MissingMassCalculatorV2::m_m2Nu1
double m_m2Nu1
Definition: MissingMassCalculatorV2.h:182
DiTauMassTools::MissingMassCalculatorV2::m_fMEtP_split2
std::shared_ptr< TH1F > m_fMEtP_split2
Definition: MissingMassCalculatorV2.h:221
DiTauMassTools::MMCCalibrationSetV2::LFVMMC2012
@ LFVMMC2012
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:36
DiTauMassTools::MissingMassOutput::ClearOutput
void ClearOutput(bool fUseVerbose)
Definition: MissingMassOutput.cxx:22
DiTauMassTools::MissingMassCalculatorV2::m_Meff
double m_Meff
Definition: MissingMassCalculatorV2.h:190
DiTauMassTools::MissingMassCalculatorV2::m_totalProbSum
double m_totalProbSum
Definition: MissingMassCalculatorV2.h:100
DiTauMassTools::MissingMassCalculatorV2::checkMEtInRange
bool checkMEtInRange()
Definition: MissingMassCalculatorV2.cxx:2821
DiTauMassTools::MissingMassCalculatorV2::m_RndmSeedAltering
int m_RndmSeedAltering
Definition: MissingMassCalculatorV2.h:254
DiTauMassTools::MissingMassProb::setParamAngle
void setParamAngle(const TLorentzVector &tauvec, int tau, int tautype)
Definition: MissingMassProb.cxx:153
DiTauMassTools::MissingMassCalculatorV2::m_MnuScanRange
double m_MnuScanRange
Definition: MissingMassCalculatorV2.h:262
DiTauMassTools::MissingMassCalculatorV2::m_nu2FinalSolVec
std::vector< TLorentzVector > m_nu2FinalSolVec
Definition: MissingMassCalculatorV2.h:164
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::nutau1
TLorentzVector nutau1
Definition: MissingMassCalculatorV2.h:55
DiTauMassTools::MissingMassInput::m_MEtT
double m_MEtT
Definition: MissingMassInput.h:80
DiTauMassTools::getLFVMode
int getLFVMode(const xAOD::IParticle *p1, const xAOD::IParticle *p2, int mmcType1, int mmcType2)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:115
DiTauMassTools::MissingMassInput::m_Nprong_tau1
int m_Nprong_tau1
Definition: MissingMassInput.h:56
DiTauMassTools::MissingMassCalculatorV2::m_tauvecsol1
std::vector< TLorentzVector > m_tauvecsol1
Definition: MissingMassCalculatorV2.h:79
DiTauMassTools::MissingMassInput::m_vistau1
TLorentzVector m_vistau1
Definition: MissingMassInput.h:52
DiTauMassTools::MissingMassCalculatorV2::m_cosPhi2
double m_cosPhi2
Definition: MissingMassCalculatorV2.h:170
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1
TLorentzVector m_tauVec1
Definition: MissingMassCalculatorV2.h:174
DiTauMassTools::MissingMassProb::dTheta3d_probabilityFast
double dTheta3d_probabilityFast(MissingMassInput &preparedInput, const int &tau_type, const double &dTheta3d, const double &P_tau)
Definition: MissingMassProb.cxx:1034
DiTauMassTools::MissingMassProb::GetUseHT
bool GetUseHT()
Definition: MissingMassProb.h:48
DiTauMassTools::MissingMassCalculatorV2::m_nu1FinalSolVec
std::vector< TLorentzVector > m_nu1FinalSolVec
Definition: MissingMassCalculatorV2.h:163
DiTauMassTools::MissingMassCalculatorV2::m_reRunWithBestMET
bool m_reRunWithBestMET
Definition: MissingMassCalculatorV2.h:191
DiTauMassTools::MMCCalibrationSetV2::MMC2016MC15C
@ MMC2016MC15C
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:36
DiTauMassTools::MissingMassCalculatorV2::precomputeCache
bool precomputeCache()
Definition: MissingMassCalculatorV2.cxx:2735
DiTauMassTools::MissingMassCalculatorV2::m_niter_fit1
int m_niter_fit1
Definition: MissingMassCalculatorV2.h:248
DiTauMassTools::MissingMassCalculatorV2::m_MEtPRange
double m_MEtPRange
Definition: MissingMassCalculatorV2.h:145
GEV
#define GEV
Definition: PrintPhotonSF.cxx:24
DiTauMassTools::MissingMassInput::SetNjet25
void SetNjet25(int val)
Definition: MissingMassInput.cxx:105
DiTauMassTools::MissingMassInput::SetVisTauVec
void SetVisTauVec(int i, const TLorentzVector &vec)
Definition: MissingMassInput.cxx:121
DiTauMassTools::MMCFitMethodV2::MLNU3P
@ MLNU3P
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:42
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Px
double m_tauVec2Px
Definition: MissingMassCalculatorV2.h:178
DiTauMassTools::MissingMassCalculatorV2::m_Phi2
double m_Phi2
Definition: MissingMassCalculatorV2.h:138
DiTauMassTools::MissingMassCalculatorV2::m_ProposalTryPhi
double m_ProposalTryPhi
Definition: MissingMassCalculatorV2.h:132
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
DiTauMassTools::MissingMassProb::GetUseMnuProbability
bool GetUseMnuProbability()
Definition: MissingMassProb.h:54
DiTauMassTools::MissingMassOutput::m_NSolutions
int m_NSolutions
Definition: MissingMassOutput.h:66
DiTauMassTools::MissingMassCalculatorV2::m_eTau2Min
double m_eTau2Min
Definition: MissingMassCalculatorV2.h:151
DiTauMassTools::MissingMassInput::m_dataType
int m_dataType
Definition: MissingMassInput.h:58
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
DiTauMassTools::mmcType
int mmcType(const xAOD::IParticle *part)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:172
DiTauMassTools::MissingMassCalculatorV2::m_fPYfit2
std::shared_ptr< TH1F > m_fPYfit2
Definition: MissingMassCalculatorV2.h:209
DiTauMassTools::MMCCalibrationSetV2::UPGRADE
@ UPGRADE
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:36
DiTauMassTools::HistInfoV2::RMSVSDISCRI
@ RMSVSDISCRI
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassInput::m_fUseVerbose
bool m_fUseVerbose
Definition: MissingMassInput.h:76
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Py
double m_tauVec1Py
Definition: MissingMassCalculatorV2.h:177
ReadTripsProbsFromCool.denominator
denominator
Definition: ReadTripsProbsFromCool.py:96
DiTauMassTools::MissingMassOutput::m_totalvec
TLorentzVector m_totalvec[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:59
DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Max
double m_Mnu1Max
Definition: MissingMassCalculatorV2.h:143
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
DiTauMassTools::MissingMassCalculatorV2::m_niter_fit3
int m_niter_fit3
Definition: MissingMassCalculatorV2.h:250
DiTauMassTools::MissingMassOutput::m_RMS2MPV
double m_RMS2MPV
Definition: MissingMassOutput.h:61
DiTauMassTools::MissingMassCalculatorV2::m_PhiProposal
double m_PhiProposal
Definition: MissingMassCalculatorV2.h:146
DiTauMassTools::MMCCalibrationSetV2::MAXMMCCALIBRATIONSET
@ MAXMMCCALIBRATIONSET
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:36
DiTauMassTools::MissingMassCalculatorV2::TailCleanUp
int TailCleanUp(const TLorentzVector &vis1, const TLorentzVector &nu1, const TLorentzVector &vis2, const TLorentzVector &nu2, const double &mmc_mass, const double &vis_mass, const double &eff_mass, const double &dphiTT)
Definition: MissingMassCalculatorV2.cxx:2055
DiTauMassTools::MissingMassCalculatorV2::m_iter0
int m_iter0
Definition: MissingMassCalculatorV2.h:107
DiTauMassTools::MissingMassInput::m_HtOffset
double m_HtOffset
Definition: MissingMassInput.h:69
DiTauMassTools::MissingMassCalculatorV2::m_MEtLMax
double m_MEtLMax
Definition: MissingMassCalculatorV2.h:143
part2
Definition: part2.py:1
DiTauMassTools::MissingMassProb::setParamRatio
void setParamRatio(int tau, int tautype)
Definition: MissingMassProb.cxx:182
min
#define min(a, b)
Definition: cfImp.cxx:40
DiTauMassTools::MissingMassCalculatorV2::m_fApplyMassScale
int m_fApplyMassScale
Definition: MissingMassCalculatorV2.h:246
DiTauMassTools::MissingMassCalculatorV2::m_fJERsyst
int m_fJERsyst
Definition: MissingMassCalculatorV2.h:257
DQPostProcessTest.outFile
outFile
Comment Out Those You do not wish to run.
Definition: DQPostProcessTest.py:37
DiTauMassTools::MissingMassCalculatorV2::m_dTheta3d_binMin
double m_dTheta3d_binMin
Definition: MissingMassCalculatorV2.h:258
DiTauMassTools::MissingMassCalculatorV2::m_meanbinToBeEvaluated
bool m_meanbinToBeEvaluated
Definition: MissingMassCalculatorV2.h:119
DiTauMassTools::MissingMassCalculatorV2::m_markovCountDuplicate
int m_markovCountDuplicate
Definition: MissingMassCalculatorV2.h:121
DiTauMassTools::MissingMassCalculatorV2::m_tauvecsol2
std::vector< TLorentzVector > m_tauvecsol2
Definition: MissingMassCalculatorV2.h:80
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2
TLorentzVector m_tauVec2
Definition: MissingMassCalculatorV2.h:174
DiTauMassTools::MissingMassOutput::m_NSuccesses
int m_NSuccesses
Definition: MissingMassOutput.h:65
DiTauMassTools::MissingMassCalculatorV2::m_Phi2Range
double m_Phi2Range
Definition: MissingMassCalculatorV2.h:145
DiTauMassTools::MissingMassCalculatorV2::m_fMnu1_split2
std::shared_ptr< TH1F > m_fMnu1_split2
Definition: MissingMassCalculatorV2.h:223
DiTauMassTools::MissingMassCalculatorV2::m_eTau10
double m_eTau10
Definition: MissingMassCalculatorV2.h:140
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Py
double m_tauVec2Py
Definition: MissingMassCalculatorV2.h:178
DiTauMassTools::HistInfoV2::MEANBIN
@ MEANBIN
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassInput::m_type_visTau2
int m_type_visTau2
Definition: MissingMassInput.h:55
pmontree.code
code
Definition: pmontree.py:443
DiTauMassTools::MissingMassCalculatorV2::m_iterTheta3d
int m_iterTheta3d
Definition: MissingMassCalculatorV2.h:96
DiTauMassTools::MissingMassCalculatorV2::m_beamEnergy
double m_beamEnergy
Definition: MissingMassCalculatorV2.h:93
Py
Definition: PyDataStore.h:24
DiTauMassTools::MissingMassCalculatorV2::m_MEtP0
double m_MEtP0
Definition: MissingMassCalculatorV2.h:141
DiTauMassTools::MissingMassCalculatorV2::m_nosol1
int m_nosol1
Definition: MissingMassCalculatorV2.h:113
DiTauMassTools::MissingMassProb::MetProbability
double MetProbability(MissingMassInput &preparedInput, const double &met1, const double &met2, const double &MetSigma1, const double &MetSigma2)
Definition: MissingMassProb.cxx:551
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
DiTauMassTools::MissingMassInput::m_DelPhiTT
double m_DelPhiTT
Definition: MissingMassInput.h:65
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
DiTauMassTools::MissingMassCalculatorV2::m_lfvLeplepRefit
bool m_lfvLeplepRefit
Definition: MissingMassCalculatorV2.h:89
DiTauMassTools::MissingMassInput::PrintInputInfo
void PrintInputInfo()
Definition: MissingMassInput.cxx:56
DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Max
double m_Mnu2Max
Definition: MissingMassCalculatorV2.h:143
DiTauMassTools::MissingMassProb::SetUseTauProbability
void SetUseTauProbability(bool val)
Definition: MissingMassProb.h:50
DiTauMassTools::MissingMassOutput::m_AveSolRMS
double m_AveSolRMS
Definition: MissingMassOutput.h:68
DiTauMassTools::MissingMassInput::m_MetVec
TVector2 m_MetVec
Definition: MissingMassInput.h:51
DiTauMassTools::MissingMassCalculatorV2::m_fPhi1_all
std::shared_ptr< TH1F > m_fPhi1_all
Definition: MissingMassCalculatorV2.h:200
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
DiTauMassTools::MissingMassCalculatorV2::m_rmsStop
int m_rmsStop
Definition: MissingMassCalculatorV2.h:72
DiTauMassTools::MissingMassCalculatorV2::m_Phi10
double m_Phi10
Definition: MissingMassCalculatorV2.h:141
DiTauMassTools::MMCFitMethodV2::MLM
@ MLM
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:42
DiTauMassTools::MissingMassCalculatorV2::m_NiterRandom
int m_NiterRandom
Definition: MissingMassCalculatorV2.h:251
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan
double m_nsigma_METscan
Definition: MissingMassCalculatorV2.h:93
DiTauMassTools::MissingMassCalculatorV2::m_Phi2Min
double m_Phi2Min
Definition: MissingMassCalculatorV2.h:142
DiTauMassTools::MissingMassCalculatorV2::m_eTau1Max
double m_eTau1Max
Definition: MissingMassCalculatorV2.h:150
DiTauMassTools::fixPhiRange
double fixPhiRange(const double &phi)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/Root/HelperFunctions.cxx:53
DiTauMassTools::MissingMassCalculatorV2::m_mtautauFinalSolOldVec
std::vector< double > m_mtautauFinalSolOldVec
Definition: MissingMassCalculatorV2.h:156
DiTauMassTools::MissingMassInput::m_fUseTailCleanup
bool m_fUseTailCleanup
Definition: MissingMassInput.h:75
DiTauMassTools::MissingMassCalculatorV2::m_fMnu2_all
std::shared_ptr< TH1F > m_fMnu2_all
Definition: MissingMassCalculatorV2.h:199
DiTauMassTools::MissingMassCalculatorV2::m_nsolOld
int m_nsolOld
Definition: MissingMassCalculatorV2.h:154
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_ll
double m_nsigma_METscan_ll
Definition: MissingMassCalculatorV2.h:93
DiTauMassTools::MissingMassCalculatorV2::m_eTau1
double m_eTau1
Definition: MissingMassCalculatorV2.h:139
DiTauMassTools::MissingMassCalculatorV2::m_mmcCalibrationSet
MMCCalibrationSetV2::e m_mmcCalibrationSet
Definition: MissingMassCalculatorV2.h:64
DiTauMassTools::HistInfoV2::DISCRI
@ DISCRI
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_fDitauStuffHisto
DitauStuff m_fDitauStuffHisto
Definition: MissingMassCalculatorV2.h:244
DiTauMassTools::MissingMassCalculatorV2::PrintResults
void PrintResults()
Definition: MissingMassCalculatorV2.cxx:518
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Pz
double m_tauVec2Pz
Definition: MissingMassCalculatorV2.h:178
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2E
double m_tauVec2E
Definition: MissingMassCalculatorV2.h:181
DiTauMassTools::MissingMassInput::m_MEtX
double m_MEtX
Definition: MissingMassInput.h:80
DiTauMassTools::MissingMassCalculatorV2::m_MEtProposal
double m_MEtProposal
Definition: MissingMassCalculatorV2.h:146
DiTauMassTools::MissingMassCalculatorV2::m_mTau
double m_mTau
Definition: MissingMassCalculatorV2.h:137
DiTauMassTools::MissingMassInput::SetVisTauType
void SetVisTauType(int i, int tautype)
Definition: MissingMassInput.cxx:115
DiTauMassTools::MissingMassCalculatorV2::m_fFitting
TF1 * m_fFitting
Definition: MissingMassCalculatorV2.h:228
DiTauMassTools::MissingMassProb
Definition: MissingMassProb.h:27
DiTauMassTools::MissingMassCalculatorV2::m_eventNumber
int m_eventNumber
Definition: MissingMassCalculatorV2.h:103
DiTauMassTools::MissingMassCalculatorV2::m_MEtL
double m_MEtL
Definition: MissingMassCalculatorV2.h:138
DiTauMassTools::MissingMassOutput::m_NTrials
int m_NTrials
Definition: MissingMassOutput.h:64
DiTauMassTools::MissingMassInput::m_MEtY
double m_MEtY
Definition: MissingMassInput.h:80
DiTauMassTools::MissingMassCalculatorV2::m_mtautauFinalSolVec
std::vector< double > m_mtautauFinalSolVec
Definition: MissingMassCalculatorV2.h:162
DiTauMassTools::MissingMassCalculatorV2::m_seed
int m_seed
Definition: MissingMassCalculatorV2.h:104
DiTauMassTools::MissingMassCalculatorV2::dTheta3DLimit
double dTheta3DLimit(const int &tau_type, const int &limit_code, const double &P_tau)
Definition: MissingMassCalculatorV2.cxx:2837
DiTauMassTools::MissingMassCalculatorV2::m_MEtPMin
double m_MEtPMin
Definition: MissingMassCalculatorV2.h:142
DiTauMassTools::MissingMassCalculatorV2::m_PrintmMaxError
double m_PrintmMaxError
Definition: MissingMassCalculatorV2.h:127
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
DiTauMassTools::HistInfoV2::INTEGRAL
@ INTEGRAL
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_fMnu1_all
std::shared_ptr< TH1F > m_fMnu1_all
Definition: MissingMassCalculatorV2.h:198
DiTauMassTools::MissingMassCalculatorV2::m_E2v1
double m_E2v1
Definition: MissingMassCalculatorV2.h:186
DiTauMassTools::HistInfoV2::PROB
@ PROB
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_E2v2
double m_E2v2
Definition: MissingMassCalculatorV2.h:187
DiTauMassTools::MissingMassCalculatorV2::NuPsolutionV3
int NuPsolutionV3(const double &mNu1, const double &mNu2, const double &phi1, const double &phi2, int &nsol1, int &nsol2)
Definition: MissingMassCalculatorV2.cxx:623
DiTauMassTools::MissingMassCalculatorV2::m_Mnu1Range
double m_Mnu1Range
Definition: MissingMassCalculatorV2.h:145
DiTauMassTools::MissingMassCalculatorV2::m_Phi1
double m_Phi1
Definition: MissingMassCalculatorV2.h:138
DiTauMassTools::MissingMassInput::ClearInput
void ClearInput()
Definition: MissingMassInput.cxx:22
DiTauMassTools::MissingMassProb::setParamNuMass
void setParamNuMass()
Definition: MissingMassProb.cxx:145
DiTauMassTools::MissingMassCalculatorV2::SpaceWalkerInit
void SpaceWalkerInit()
Definition: MissingMassCalculatorV2.cxx:2434
DiTauMassTools::MissingMassCalculatorV2::m_scanMnu1
bool m_scanMnu1
Definition: MissingMassCalculatorV2.h:172
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::nutau2
TLorentzVector nutau2
Definition: MissingMassCalculatorV2.h:56
DiTauMassTools::MissingMassCalculatorV2::m_tautau_tmp
TLorentzVector m_tautau_tmp
Definition: MissingMassCalculatorV2.h:87
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
DiTauMassTools::MissingMassCalculatorV2::m_Mnu1
double m_Mnu1
Definition: MissingMassCalculatorV2.h:138
DiTauMassTools::MissingMassCalculatorV2::m_ET2v1
double m_ET2v1
Definition: MissingMassCalculatorV2.h:184
DiTauMassTools::MissingMassCalculatorV2::m_Mnu2Range
double m_Mnu2Range
Definition: MissingMassCalculatorV2.h:145
DiTauMassTools::MissingMassInput::m_inputMEtX
double m_inputMEtX
Definition: MissingMassInput.h:79
DiTauMassTools::MissingMassInput::m_vistau2
TLorentzVector m_vistau2
Definition: MissingMassInput.h:53
DiTauMassTools::MissingMassOutput::m_FitStatus
int m_FitStatus
Definition: MissingMassOutput.h:50
DiTauMassTools::MaxHistStrategyV2::SLIDINGWINDOW
@ SLIDINGWINDOW
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
DiTauMassTools::HistInfoV2::RMS
@ RMS
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::probCalculatorV9fast
int probCalculatorV9fast(const double &phi1, const double &phi2, const double &M_nu1, const double &M_nu2)
Definition: MissingMassCalculatorV2.cxx:1858
DiTauMassTools::MMCCalibrationSetV2::MMC2019
@ MMC2019
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:36
DiTauMassTools::MissingMassCalculatorV2::m_fMnu1_split1
std::shared_ptr< TH1F > m_fMnu1_split1
Definition: MissingMassCalculatorV2.h:216
DiTauMassTools::MissingMassCalculatorV2::m_meanbinStop
double m_meanbinStop
Definition: MissingMassCalculatorV2.h:73
DiTauMassTools::MissingMassInput::m_type_visTau1
int m_type_visTau1
Definition: MissingMassInput.h:54
DiTauMassTools::MissingMassCalculatorV2::m_PrintmInvWidth2Error
double m_PrintmInvWidth2Error
Definition: MissingMassCalculatorV2.h:129
DiTauMassTools::HistInfoV2::TANTHETA
@ TANTHETA
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
DiTauMassTools::MissingMassCalculatorV2::m_nsolmax
int m_nsolmax
Definition: MissingMassCalculatorV2.h:69
DiTauMassTools::MissingMassCalculatorV2::preparedInput
MissingMassInput preparedInput
Definition: MissingMassCalculatorV2.h:338
DiTauMassTools::MissingMassCalculatorV2::SpaceWalkerWalk
bool SpaceWalkerWalk()
Definition: MissingMassCalculatorV2.cxx:2611
DiTauMassTools::MissingMassCalculatorV2::m_fMnu2_split1
std::shared_ptr< TH1F > m_fMnu2_split1
Definition: MissingMassCalculatorV2.h:217
DiTauMassTools::MissingMassInput::m_METresSyst
int m_METresSyst
Definition: MissingMassInput.h:73
DiTauMassTools::MissingMassCalculatorV2::m_m2Nu2
double m_m2Nu2
Definition: MissingMassCalculatorV2.h:183
DiTauMassTools::MissingMassCalculatorV2::m_testdiscri1
int m_testdiscri1
Definition: MissingMassCalculatorV2.h:111
DiTauMassTools::MissingMassInput::m_InputReorder
int m_InputReorder
Definition: MissingMassInput.h:71
DiTauMassTools::MissingMassCalculatorV2::m_Mnu2
double m_Mnu2
Definition: MissingMassCalculatorV2.h:138
DiTauMassTools::MissingMassCalculatorV2::m_nsolfinalmax
int m_nsolfinalmax
Definition: MissingMassCalculatorV2.h:69
DiTauMassTools::MissingMassCalculatorV2::m_dRmax_tau
double m_dRmax_tau
Definition: MissingMassCalculatorV2.h:260
DiTauMassTools::MissingMassCalculatorV2::checkAllParamInRange
bool checkAllParamInRange()
Definition: MissingMassCalculatorV2.cxx:2780
DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan_lh
void SetNsigmaMETscan_lh(const double val)
Definition: MissingMassCalculatorV2.h:392
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_lfv_lh
double m_nsigma_METscan_lfv_lh
Definition: MissingMassCalculatorV2.h:93
L1Topo::Error
Error
The different types of error that can be flagged in the L1TopoRDO.
Definition: Error.h:16
DiTauMassTools::MissingMassOutput::m_SumW
double m_SumW
Definition: MissingMassOutput.h:67
DiTauMassTools::MissingMassCalculatorV2::m_Phi1Max
double m_Phi1Max
Definition: MissingMassCalculatorV2.h:143
DiTauMassTools::MissingMassCalculatorV2::m_tauVec2Phi
double m_tauVec2Phi
Definition: MissingMassCalculatorV2.h:175
DiTauMassTools::MissingMassInput::m_beamEnergy
double m_beamEnergy
Definition: MissingMassInput.h:70
DiTauMassTools::MissingMassCalculatorV2::m_MEtP
double m_MEtP
Definition: MissingMassCalculatorV2.h:138
scale1
#define scale1
Definition: JetAttributeHisto.cxx:41
DiTauMassTools::MissingMassCalculatorV2::m_fMEtP_all
std::shared_ptr< TH1F > m_fMEtP_all
Definition: MissingMassCalculatorV2.h:196
DiTauMassTools::MissingMassCalculatorV2::m_randomGen
TRandom2 m_randomGen
Definition: MissingMassCalculatorV2.h:62
DiTauMassTools::MissingMassCalculatorV2::m_dTheta3d_binMax
double m_dTheta3d_binMax
Definition: MissingMassCalculatorV2.h:259
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
DiTauMassTools::MissingMassCalculatorV2::FinalizeSettings
void FinalizeSettings(const xAOD::IParticle *part1, const xAOD::IParticle *part2, const xAOD::MissingET *met, const int &njets)
Definition: MissingMassCalculatorV2.cxx:2984
DiTauMassTools::MissingMassCalculatorV2::m_fMfit_allGraph
std::shared_ptr< TGraph > m_fMfit_allGraph
Definition: MissingMassCalculatorV2.h:202
DiTauMassTools::MissingMassCalculatorV2::m_nu1FinalSolOldVec
std::vector< TLorentzVector > m_nu1FinalSolOldVec
Definition: MissingMassCalculatorV2.h:157
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
DiTauMassTools::MissingMassInput::m_fUseDefaults
bool m_fUseDefaults
Definition: MissingMassInput.h:74
DiTauMassTools::MaxHistStrategyV2::MAXBIN
@ MAXBIN
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
DiTauMassTools::MissingMassCalculatorV2::m_testptn2
int m_testptn2
Definition: MissingMassCalculatorV2.h:110
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan_lfv_ll
double m_nsigma_METscan_lfv_ll
Definition: MissingMassCalculatorV2.h:93
DiTauMassTools::MissingMassInput::SetSumEt
void SetSumEt(double sumEt)
Definition: MissingMassInput.cxx:110
DiTauMassTools::MissingMassCalculatorV2::m_cosPhi1
double m_cosPhi1
Definition: MissingMassCalculatorV2.h:170
DiTauMassTools::MissingMassCalculatorV2::m_fMmass_split2
std::shared_ptr< TH1F > m_fMmass_split2
Definition: MissingMassCalculatorV2.h:220
DiTauMassTools::MissingMassCalculatorV2::m_nCallprobCalculatorV9fast
int m_nCallprobCalculatorV9fast
Definition: MissingMassCalculatorV2.h:91
DiTauMassTools::MissingMassOutput::m_FittedMass
double m_FittedMass[MMCFitMethodV2::MAX]
Definition: MissingMassOutput.h:52
DiTauMassTools::MissingMassInput::SetMetVec
void SetMetVec(const TVector2 &vec)
Definition: MissingMassInput.cxx:128
DiTauMassTools::MissingMassCalculatorV2::m_MEtLMin
double m_MEtLMin
Definition: MissingMassCalculatorV2.h:142
DiTauMassTools::MissingMassCalculatorV2::m_fPZfit1
std::shared_ptr< TH1F > m_fPZfit1
Definition: MissingMassCalculatorV2.h:207
DiTauMassTools::MissingMassCalculatorV2::m_sinPhi2
double m_sinPhi2
Definition: MissingMassCalculatorV2.h:170
DiTauMassTools::MissingMassCalculatorV2::m_fPYfit1
std::shared_ptr< TH1F > m_fPYfit1
Definition: MissingMassCalculatorV2.h:206
DiTauMassTools::MissingMassCalculatorV2::m_nuvecsol2
std::vector< TLorentzVector > m_nuvecsol2
Definition: MissingMassCalculatorV2.h:77
DiTauMassTools::MissingMassCalculatorV2::m_tauVec1Px
double m_tauVec1Px
Definition: MissingMassCalculatorV2.h:177
DiTauMassTools::MissingMassCalculatorV2::m_iter3
int m_iter3
Definition: MissingMassCalculatorV2.h:95
python.compressB64.c
def c
Definition: compressB64.py:93
updateCoolNtuple.limit
int limit
Definition: updateCoolNtuple.py:45
DiTauMassTools::MissingMassInput::m_inputMEtY
double m_inputMEtY
Definition: MissingMassInput.h:79
DiTauMassTools::MissingMassCalculatorV2::m_markovNRejectMetropolis
int m_markovNRejectMetropolis
Definition: MissingMassCalculatorV2.h:124
DiTauMassTools::MissingMassCalculatorV2::m_MEtL0
double m_MEtL0
Definition: MissingMassCalculatorV2.h:141
DiTauMassTools::MissingMassCalculatorV2::m_iter1
int m_iter1
Definition: MissingMassCalculatorV2.h:95
DiTauMassTools::MissingMassCalculatorV2::m_eTau2Max
double m_eTau2Max
Definition: MissingMassCalculatorV2.h:151
doubleTestComp.j2
j2
Definition: doubleTestComp.py:22
DiTauMassTools::MissingMassCalculatorV2::m_eTau2
double m_eTau2
Definition: MissingMassCalculatorV2.h:139
DiTauMassTools::MissingMassCalculatorV2::m_tauvecprob1
std::vector< double > m_tauvecprob1
Definition: MissingMassCalculatorV2.h:81
DiTauMassTools::MissingMassInput::m_LFVmode
int m_LFVmode
Definition: MissingMassInput.h:82
DiTauMassTools::MissingMassCalculatorV2::m_fMnu2_split2
std::shared_ptr< TH1F > m_fMnu2_split2
Definition: MissingMassCalculatorV2.h:224
DiTauMassTools::MMCCalibrationSetV2::name
const std::string name[MAXMMCCALIBRATIONSET]
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:37
DiTauMassTools::MissingMassCalculatorV2::SetNsigmaMETscan_hh
void SetNsigmaMETscan_hh(const double val)
Definition: MissingMassCalculatorV2.h:393
DiTauMassTools::MissingMassCalculatorV2::DitauStuff::Sign_best
double Sign_best
Definition: MissingMassCalculatorV2.h:54
DiTauMassTools::MissingMassCalculatorV2::m_iang1high
int m_iang1high
Definition: MissingMassCalculatorV2.h:95
DiTauMassTools::MissingMassCalculatorV2::m_niter_fit2
int m_niter_fit2
Definition: MissingMassCalculatorV2.h:249
DiTauMassTools::MissingMassCalculatorV2::m_mTau2
double m_mTau2
Definition: MissingMassCalculatorV2.h:137
DiTauMassTools::MissingMassCalculatorV2::m_walkWeight
double m_walkWeight
Definition: MissingMassCalculatorV2.h:169
DiTauMassTools::MissingMassCalculatorV2::m_nsigma_METscan2
double m_nsigma_METscan2
Definition: MissingMassCalculatorV2.h:93
DiTauMassTools::TauTypes::ll
@ ll
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:49
DiTauMassTools::MMCFitMethodV2::MAX
@ MAX
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:42
DiTauMassTools::MissingMassCalculatorV2::m_nsucStop
int m_nsucStop
Definition: MissingMassCalculatorV2.h:71
Generated on Sun Jun 30 2024 22:15:23 for ATLAS Offline Software by   doxygen 1.8.18