ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
TtresNeutrinoBuilder Class Reference

#include <TtresNeutrinoBuilder.h>

Collaboration diagram for TtresNeutrinoBuilder:

Public Member Functions

 TtresNeutrinoBuilder (std::string units)
 
virtual ~TtresNeutrinoBuilder ()
 
 TtresNeutrinoBuilder (const TtresNeutrinoBuilder &)
 
TtresNeutrinoBuilder & operator= (const TtresNeutrinoBuilder &)
 
void setdebuglevel (int level)
 
Double_t getDiscriminant (const TLorentzVector *, const Double_t, const Double_t)
 
bool candidatesFromWMass_Scaling (const TLorentzVector *, double, Double_t, std::vector< TLorentzVector * > &)
 
std::vector< TLorentzVector * > candidatesFromWMass_Scaling (const TLorentzVector *, const Double_t, const Double_t)
 
std::vector< TLorentzVector * > candidatesFromWMass_Scaling (const TLorentzVector *, const TLorentzVector *)
 
std::vector< TLorentzVector * > candidatesFromWMass_Rotation (const TLorentzVector *, const Double_t, const Double_t, const bool)
 
std::vector< TLorentzVector * > candidatesFromWMass_Rotation (const TLorentzVector *, const TLorentzVector *, const bool)
 
std::vector< TLorentzVector * > candidatesFromWMass_RealPart (const TLorentzVector *, const Double_t, const Double_t, const bool)
 
std::vector< TLorentzVector * > candidatesFromWMass_RealPart (const TLorentzVector *, const TLorentzVector *, const bool)
 

Protected Member Functions

double fitAlpha (const TLorentzVector *, const Double_t, const Double_t)
 

Protected Attributes

int m_debug
 
double m_Units
 

Detailed Description

Definition at line 16 of file TtresNeutrinoBuilder.h.

Constructor & Destructor Documentation

◆ TtresNeutrinoBuilder() [1/2]

TtresNeutrinoBuilder::TtresNeutrinoBuilder ( std::string  units)

Definition at line 12 of file TtresNeutrinoBuilder.cxx.

12  {
13  m_debug = 0;
14  if (units == "MeV") m_Units = 1000.;
15  else if (units == "GeV") m_Units = 1.;
16  else std::cerr << "WARNING in NeutrinoBuilder: units different from GeV or MeV" << std::endl;
17 }

◆ ~TtresNeutrinoBuilder()

TtresNeutrinoBuilder::~TtresNeutrinoBuilder ( )
virtual

Definition at line 20 of file TtresNeutrinoBuilder.cxx.

20  {
21  if (m_debug > 0) std::cout << "in destructor " << std::endl;
22 }

◆ TtresNeutrinoBuilder() [2/2]

TtresNeutrinoBuilder::TtresNeutrinoBuilder ( const TtresNeutrinoBuilder &  other)

Definition at line 25 of file TtresNeutrinoBuilder.cxx.

25  {
26  m_debug = other.m_debug;
27 }

Member Function Documentation

◆ candidatesFromWMass_RealPart() [1/2]

std::vector< TLorentzVector * > TtresNeutrinoBuilder::candidatesFromWMass_RealPart ( const TLorentzVector *  L,
const  Double_t,
const  Double_t,
const bool  useSmallestPz 
)

Definition at line 288 of file TtresNeutrinoBuilder.cxx.

290  {
291  if (m_debug > 0) std::cout << "entering candidatesFromWMass_RealPart()" << std::endl;
292 
293  // initialize
294  Double_t m_mWpdg = 80.4 * m_Units;
295  Double_t pxNu = met * cos(metphi);
296  Double_t pyNu = met * sin(metphi);
297  Double_t pzNu = -1000000;
298  Double_t ptNu = met;
299  Double_t eNu;
300 
301  std::vector<TLorentzVector*> NC;
302 
303  Double_t c1 = m_mWpdg * m_mWpdg - L->M() * L->M() + 2 * (L->Px() * pxNu + L->Py() * pyNu);
304  Double_t b1 = 2 * L->Pz();
305 
306  Double_t A = 4 * pow(L->E(), 2) - b1 * b1;
307  Double_t B = -2 * c1 * b1;
308  Double_t C = 4 * pow(L->E(), 2) * ptNu * ptNu - c1 * c1;
309  Double_t discr = B * B - 4 * A * C;
310 
311  Double_t sol1, sol2;
312  if (discr > 0) {
313  sol1 = (-B + sqrt(discr)) / (2 * A);
314  sol2 = (-B - sqrt(discr)) / (2 * A);
315  }
316  //if discr<0
317  else {
318  pzNu = -B / (2 * A);
319 
320  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
321  TLorentzVector* nu1 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
322  NC.push_back(nu1);
323  return NC;
324  }
325 
326  if (useSmallestPz) {
327  pzNu = (fabs(sol1) > fabs(sol2)) ? sol2 : sol1;
328 
329  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
330  TLorentzVector* nu1 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
331  NC.push_back(nu1);
332  } else {
333  pzNu = sol1;
334  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
335  TLorentzVector* nu1 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
336  pzNu = sol2;
337  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
338  TLorentzVector* nu2 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
339  NC.push_back(nu1);
340  NC.push_back(nu2);
341  }
342 
343  if (m_debug > 0) std::cout << "quitting NeutrinoBuilder::candidatesFromWMass_RealPart() : " << NC.size() << std::endl;
344 
345  return NC;
346 }

◆ candidatesFromWMass_RealPart() [2/2]

std::vector< TLorentzVector * > TtresNeutrinoBuilder::candidatesFromWMass_RealPart ( const TLorentzVector *  L,
const TLorentzVector *  MET,
const bool  useSmallestPz 
)

Definition at line 280 of file TtresNeutrinoBuilder.cxx.

282  {
283  return this->candidatesFromWMass_RealPart(L, MET->Pt(), MET->Phi(), useSmallestPz);
284 }

◆ candidatesFromWMass_Rotation() [1/2]

std::vector< TLorentzVector * > TtresNeutrinoBuilder::candidatesFromWMass_Rotation ( const TLorentzVector *  L,
const Double_t  met,
const Double_t  metphi,
const bool  useSmallestPz 
)

Definition at line 206 of file TtresNeutrinoBuilder.cxx.

209  {
210  if (m_debug > 0) std::cout << "entering candidatesFromWMassRotation()" << std::endl;
211 
212  // initialize
213  Double_t m_mWpdg = 80.4 * m_Units;
214  Double_t pxNu = met * cos(metphi);
215  Double_t pyNu = met * sin(metphi);
216  Double_t pzNu = -1000000;
217  Double_t ptNu = met;
218  Double_t eNu;
219 
220  std::vector<TLorentzVector*> NC;
221 
222  Double_t c1 = m_mWpdg * m_mWpdg - L->M() * L->M() + 2 * (L->Px() * pxNu + L->Py() * pyNu);
223  Double_t b1 = 2 * L->Pz();
224 
225  Double_t A = 4 * pow(L->E(), 2) - b1 * b1;
226  Double_t B = -2 * c1 * b1;
227  Double_t C = 4 * pow(L->E(), 2) * ptNu * ptNu - c1 * c1;
228  Double_t discr = B * B - 4 * A * C;
229  Double_t r = 1;
230 
231  Double_t sol1, sol2;
232  if (discr > 0) {
233  sol1 = (-B + sqrt(discr)) / (2 * A);
234  sol2 = (-B - sqrt(discr)) / (2 * A);
235  } else {
236  Double_t alpha = fitAlpha(L, met, metphi);
237  Double_t dphi = metphi - L->Phi();
238  r =
239  (pow(m_mWpdg,
240  2) - pow(L->M(), 2)) / (2 * ptNu * (sqrt(pow(L->Pt(), 2) + pow(L->M(), 2)) - L->Pt() * cos(dphi + alpha)));
241 
242  Double_t old_p = ptNu;
243  Double_t old_phi = metphi;
244  pxNu = r * old_p * cos(old_phi + alpha);
245  pyNu = r * old_p * sin(old_phi + alpha);
246  ptNu = sqrt(pxNu * pxNu + pyNu * pyNu);
247 
248  c1 = m_mWpdg * m_mWpdg - pow(L->M(), 2) + 2 * (L->Px() * pxNu + L->Py() * pyNu);
249  B = -2 * c1 * b1;
250  C = 4 * pow(L->E(), 2) * ptNu * ptNu - c1 * c1;
251  discr = B * B - 4 * A * C;
252 
253  sol1 = -B / (2 * A);
254  sol2 = -B / (2 * A);
255  }
256 
257  if (useSmallestPz) {
258  pzNu = (fabs(sol1) > fabs(sol2)) ? sol2 : sol1;
259 
260  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
261  TLorentzVector* nu1 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
262  NC.push_back(nu1);
263  } else {
264  pzNu = sol1;
265  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
266  TLorentzVector* nu1 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
267  pzNu = sol2;
268  eNu = sqrt(pxNu * pxNu + pyNu * pyNu + pzNu * pzNu);
269  TLorentzVector* nu2 = new TLorentzVector(pxNu, pyNu, pzNu, eNu);
270  NC.push_back(nu1);
271  NC.push_back(nu2);
272  }
273 
274  if (m_debug > 0) std::cout << "quitting NeutrinoBuilder::candidatesFromWMassRotation() : " << NC.size() << std::endl;
275  return NC;
276 }

◆ candidatesFromWMass_Rotation() [2/2]

std::vector< TLorentzVector * > TtresNeutrinoBuilder::candidatesFromWMass_Rotation ( const TLorentzVector *  L,
const TLorentzVector *  MET,
const bool  useSmallestPz 
)

Definition at line 198 of file TtresNeutrinoBuilder.cxx.

200  {
201  return this->candidatesFromWMass_Rotation(L, MET->Pt(), MET->Phi(), useSmallestPz);
202 }

◆ candidatesFromWMass_Scaling() [1/3]

std::vector<TLorentzVector*> TtresNeutrinoBuilder::candidatesFromWMass_Scaling ( const TLorentzVector *  ,
const  Double_t,
const  Double_t 
)

◆ candidatesFromWMass_Scaling() [2/3]

std::vector< TLorentzVector * > TtresNeutrinoBuilder::candidatesFromWMass_Scaling ( const TLorentzVector *  L,
const TLorentzVector *  MET 
)

Definition at line 118 of file TtresNeutrinoBuilder.cxx.

119  {
120  return this->candidatesFromWMass_Scaling(L, MET->Px(), MET->Py());
121 }

◆ candidatesFromWMass_Scaling() [3/3]

bool TtresNeutrinoBuilder::candidatesFromWMass_Scaling ( const TLorentzVector *  ,
double  ,
Double_t  ,
std::vector< TLorentzVector * > &   
)

◆ fitAlpha()

double TtresNeutrinoBuilder::fitAlpha ( const TLorentzVector *  L,
const Double_t  met,
const Double_t  metphi 
)
protected

Definition at line 65 of file TtresNeutrinoBuilder.cxx.

65  {
66  // initialize
67  double m_mWpdg = 80.4 * m_Units;
68  Double_t pxNu = met * cos(metphi);
69  Double_t pyNu = met * sin(metphi);
70  Double_t ptNu = met;
71 
72  TMinuit* fit = new TMinuit(7);
73 
74  fit->SetFCN(delta2_fcn);
75  int ierr = 0;
76  double arglist[1] = {
77  -1
78  };
79  fit->mnexcm("SET PRIN", arglist, 1, ierr);
80 
81  // Initialise the parameters
82  std::string par_name[7] = {
83  "alpha", "r", "dphi", "l_pt", "l_m", "n_px", "n_py"
84  };
85  Double_t par_ival[7] = {
86  0., (m_mWpdg * m_mWpdg - L->M() * L->M()) / (2 * ptNu), metphi - L->Phi(), L->Pt(), L->M(), pxNu, pyNu
87  };
88  Double_t par_step[7] = {
89  0.1, 0., 0., 0., 0., 0., 0.
90  };
91  Double_t par_min[7] = {
92  -3.15, 0., -3.15, 0., 0., -10000., -10000.
93  };
94  Double_t par_max[7] = {
95  3.15, 1., 3.15, 10000., 80., 10000., 10000.
96  };
97  for (Int_t i = 0; i < 7; i++) {
98  fit->DefineParameter(i, par_name[i].c_str(), par_ival[i], par_step[i], par_min[i], par_max[i]);
99  if (i != 0) {
100  fit->FixParameter(i);
101  }
102  }
103  fit->SetPrintLevel(-1);
104  fit->Migrad();
105  Double_t a, e_a;
106  Int_t ret = fit->GetParameter(0, a, e_a);
107  delete fit;
108  if (ret > 0) {
109  return a;
110  } else {
111  std::cout << "Error in fit of alpha for met correction" << std::endl;
112  return 0.;
113  }
114 }

◆ getDiscriminant()

Double_t TtresNeutrinoBuilder::getDiscriminant ( const TLorentzVector *  L,
const  Double_t,
const  Double_t 
)

Definition at line 348 of file TtresNeutrinoBuilder.cxx.

348  {
349  // initialize
350  Double_t m_mWpdg = 80.4 * m_Units;
351  Double_t pxNu = met * cos(metphi);
352  Double_t pyNu = met * sin(metphi);
353  Double_t ptNu = met;
354 
355  Double_t c1 = m_mWpdg * m_mWpdg - L->M() * L->M() + 2 * (L->Px() * pxNu + L->Py() * pyNu);
356  Double_t b1 = 2 * L->Pz();
357 
358  Double_t A = 4 * pow(L->E(), 2) - b1 * b1;
359  Double_t B = -2 * c1 * b1;
360  Double_t C = 4 * pow(L->E(), 2) * ptNu * ptNu - c1 * c1;
361  Double_t discr = B * B - 4 * A * C;
362 
363  return discr;
364 }

◆ operator=()

TtresNeutrinoBuilder & TtresNeutrinoBuilder::operator= ( const TtresNeutrinoBuilder &  other)

Definition at line 30 of file TtresNeutrinoBuilder.cxx.

30  {
31  if (this != &other) {
32  m_debug = other.m_debug;
33  }
34  return *this;
35 }

◆ setdebuglevel()

void TtresNeutrinoBuilder::setdebuglevel ( int  level)
inline

Definition at line 23 of file TtresNeutrinoBuilder.h.

23 {m_debug = level;};

Member Data Documentation

◆ m_debug

int TtresNeutrinoBuilder::m_debug
protected

Definition at line 40 of file TtresNeutrinoBuilder.h.

◆ m_Units

double TtresNeutrinoBuilder::m_Units
protected

Definition at line 41 of file TtresNeutrinoBuilder.h.

The documentation for this class was generated from the following files:
beamspotman.r
def r
Definition: beamspotman.py:676
extractSporadic.c1
c1
Definition: extractSporadic.py:134
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
DMTest::C
C_v1 C
Definition: C.h:26
TtresNeutrinoBuilder::m_Units
double m_Units
Definition: TtresNeutrinoBuilder.h:41
TRT_PAI_gasdata::NC
const int NC
Number of levels for Carbon.
Definition: TRT_PAI_gasdata.h:237
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
dqt_zlumi_alleff_HIST.A
A
Definition: dqt_zlumi_alleff_HIST.py:110
met
Definition: IMETSignificance.h:24
lumiFormat.i
int i
Definition: lumiFormat.py:92
ret
T ret(T t)
Definition: rootspy.cxx:260
TCS::MET
@ MET
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/L1TopoCommon/Types.h:16
MuonValidation_CreateResolutionProfiles.fit
def fit(h, emin, emax)
Definition: MuonValidation_CreateResolutionProfiles.py:69
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
perfmonmt-refit.units
string units
Definition: perfmonmt-refit.py:77
delta2_fcn
void delta2_fcn(Int_t &, Double_t *, Double_t &, Double_t *, Int_t)
Definition: TtresNeutrinoBuilder.cxx:39
a
TList * a
Definition: liststreamerinfos.cxx:10
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
TtresNeutrinoBuilder::m_debug
int m_debug
Definition: TtresNeutrinoBuilder.h:40
TtresNeutrinoBuilder::candidatesFromWMass_Scaling
bool candidatesFromWMass_Scaling(const TLorentzVector *, double, Double_t, std::vector< TLorentzVector * > &)
TtresNeutrinoBuilder::candidatesFromWMass_Rotation
std::vector< TLorentzVector * > candidatesFromWMass_Rotation(const TLorentzVector *, const Double_t, const Double_t, const bool)
Definition: TtresNeutrinoBuilder.cxx:206
TtresNeutrinoBuilder::candidatesFromWMass_RealPart
std::vector< TLorentzVector * > candidatesFromWMass_RealPart(const TLorentzVector *, const Double_t, const Double_t, const bool)
Definition: TtresNeutrinoBuilder.cxx:288
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
TtresNeutrinoBuilder::fitAlpha
double fitAlpha(const TLorentzVector *, const Double_t, const Double_t)
Definition: TtresNeutrinoBuilder.cxx:65
Generated on Fri Jul 5 2024 22:09:15 for ATLAS Offline Software by   doxygen 1.8.18