HbbAnalysis/src/Objects.cc

#include "UserCode/HbbAnalysis/interface/Objects.hh"

namespace HbbAnalysis {
 
  double DeltaPhi(const double phi1, const double phi2)
  {
    
    double dPhi = phi1 - phi2;
    if (dPhi<0) dPhi += 2*TMath::Pi();

    return dPhi;
  }

  double DeltaR(const BaseVars & v1, const BaseVars & v2)
  {
    
    double dEta = v1.eta - v2.eta;
    double dPhi = v1.phi - v2.phi;
    if (dPhi<0) dPhi += 2*TMath::Pi();

    return sqrt(dEta*dEta+dPhi*dPhi);
  }

  double DeltaR(const BaseVars & v1, const GenVars & v2)
  {
    
    double dEta = v1.eta - v2.eta;
    double dPhi = v1.phi - v2.phi;
    if (dPhi<0) dPhi += 2*TMath::Pi();

    return sqrt(dEta*dEta+dPhi*dPhi);
  }

  double SameSign(const BaseVars & v1, const BaseVars & v2)
  {
    
    return v1.charge == v2.charge;
  }

  double OppSign(const BaseVars & v1, const BaseVars & v2)
  {
    
    return (v1.charge != v2.charge && 
            v1.charge != 0 && 
            v2.charge != 0);
  }

  TLorentzVector FourMomentum(const BaseVars & v, const double scale) 
  {
    double lpx = v.pT*cos(v.phi);
    double lpy = v.pT*sin(v.phi);
    //double lp = v.pT/sin(2*atan(exp(-v.eta)));
    //double lpz = sqrt(lp*lp - v.pT*v.pT);
    double lpz = v.pT*sinh(v.eta);
    double lE = v.pT*cosh(v.eta);//v.E

    return TLorentzVector(lpx/scale,lpy/scale,lpz/scale,lE/scale);

  }

  double TransverseMass(const BaseVars & leg1, 
                        const BaseVars & leg2, 
                        const double mEx, 
                        const double mEy)
  {
    double px = leg1.pT*cos(leg1.phi) + leg2.pT*cos(leg2.phi) + mEx;
    double py = leg1.pT*sin(leg1.phi) + leg2.pT*sin(leg2.phi) + mEy;
    double et = leg1.pT + leg2.pT + TMath::Sqrt(mEx*mEx + mEy*mEy);
    double mt2 = et*et - (px*px + py*py);
    if ( mt2 < 0 ) {
      std::cout << " --- WARNING : mt2 = " << mt2 << " is negative... Set to 0.";
      return 0.;
    }
    return sqrt(mt2);
  }

  double TransverseMass(const BaseVars & leg1, 
                        const double mEx, 
                        const double mEy)
  {
    double px = leg1.pT*cos(leg1.phi) + mEx;
    double py = leg1.pT*sin(leg1.phi) + mEy;
    double et = leg1.pT + TMath::Sqrt(mEx*mEx + mEy*mEy);
    double mt = et*et - (px*px + py*py);
    if ( mt < 0 ) {
      std::cout << " --- WARNING : mt = " << mt << " is negative... Set to 0.";
      return 0.;
    }
    return sqrt(mt);
  }

  TLorentzVector FourMomentumCDFmethod(const BaseVars & leg1, 
                                       const BaseVars & leg2, 
                                       double mEx, 
                                       double mEy)
  {
    double lpx = leg1.pT*cos(leg1.phi) + leg2.pT*cos(leg2.phi) + mEx;
    double lpy = leg1.pT*sin(leg1.phi) + leg2.pT*sin(leg2.phi) + mEy;
    double lpz = leg1.pT*sinh(leg1.eta) + leg2.pT*sinh(leg2.eta);
    double le =  leg1.pT*cosh(leg1.eta) + leg2.pT*cosh(leg2.eta) + TMath::Sqrt(mEx*mEx + mEy*mEy);
    return TLorentzVector(lpx, lpy, lpz, le);
  }

  TLorentzVector FourMomentumCollinearApprox(const BaseVars & leg1,
                                             const BaseVars & leg2,
                                             double mEx, 
                                             double mEy)
  {
    double px1 = leg1.pT*cos(leg1.phi);
    double px2 = leg2.pT*cos(leg2.phi);
    double py1 = leg1.pT*sin(leg1.phi);
    double py2 = leg2.pT*sin(leg2.phi);

    double x1_numerator = px1*py2 - px2*py1;
    double x1_denominator = py2*(px1 + mEx) - px2*(py1 + mEy);
    double x1 = ( x1_denominator != 0. ) ? x1_numerator/x1_denominator : -1.;

    double x2_numerator = x1_numerator;
    double x2_denominator = px1*(py2 + mEy) - py1*(px2 + mEx);
    double x2 = ( x2_denominator != 0. ) ? x2_numerator/x2_denominator : -1.;

    if ( (x1 > 0. && x1 < 1.) &&
         (x2 > 0. && x2 < 1.) ) {
      TLorentzVector p4 = FourMomentum(leg1,1/x1) + FourMomentum(leg2,1/x2);
      return p4;
    } else {
      return TLorentzVector(0,0,0,0);
    }
  }

}//namespace

Revision:	1.3
Committed:	Fri Mar 26 15:26:10 2010 UTC (15 years, 1 month ago) by amagnan
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HbbAnaFor35X, v00-04-02, v00-04-01, v00-04-00
Changes since 1.2:	+10 -0 lines
Log Message:	bug fix and analysis updates
#	User	Rev	Content
1	amagnan	1.1	#include "UserCode/HbbAnalysis/interface/Objects.hh"
2
3			namespace HbbAnalysis {
4
5			double DeltaPhi(const double phi1, const double phi2)
6			{
7
8			double dPhi = phi1 - phi2;
9			if (dPhi<0) dPhi += 2*TMath::Pi();
10
11			return dPhi;
12			}
13
14			double DeltaR(const BaseVars & v1, const BaseVars & v2)
15			{
16
17			double dEta = v1.eta - v2.eta;
18			double dPhi = v1.phi - v2.phi;
19			if (dPhi<0) dPhi += 2*TMath::Pi();
20
21			return sqrt(dEtadEta+dPhidPhi);
22			}
23
24	amagnan	1.3	double DeltaR(const BaseVars & v1, const GenVars & v2)
25			{
26
27			double dEta = v1.eta - v2.eta;
28			double dPhi = v1.phi - v2.phi;
29			if (dPhi<0) dPhi += 2*TMath::Pi();
30
31			return sqrt(dEtadEta+dPhidPhi);
32			}
33
34	amagnan	1.1	double SameSign(const BaseVars & v1, const BaseVars & v2)
35			{
36
37			return v1.charge == v2.charge;
38			}
39
40			double OppSign(const BaseVars & v1, const BaseVars & v2)
41			{
42
43			return (v1.charge != v2.charge &&
44			v1.charge != 0 &&
45			v2.charge != 0);
46			}
47
48			TLorentzVector FourMomentum(const BaseVars & v, const double scale)
49			{
50			double lpx = v.pT*cos(v.phi);
51			double lpy = v.pT*sin(v.phi);
52			//double lp = v.pT/sin(2*atan(exp(-v.eta)));
53			//double lpz = sqrt(lplp - v.pTv.pT);
54			double lpz = v.pT*sinh(v.eta);
55			double lE = v.pT*cosh(v.eta);//v.E
56
57			return TLorentzVector(lpx/scale,lpy/scale,lpz/scale,lE/scale);
58
59			}
60
61			double TransverseMass(const BaseVars & leg1,
62			const BaseVars & leg2,
63			const double mEx,
64			const double mEy)
65			{
66			double px = leg1.pTcos(leg1.phi) + leg2.pTcos(leg2.phi) + mEx;
67			double py = leg1.pTsin(leg1.phi) + leg2.pTsin(leg2.phi) + mEy;
68			double et = leg1.pT + leg2.pT + TMath::Sqrt(mExmEx + mEymEy);
69			double mt2 = etet - (pxpx + py*py);
70			if ( mt2 < 0 ) {
71			std::cout << " --- WARNING : mt2 = " << mt2 << " is negative... Set to 0.";
72			return 0.;
73			}
74			return sqrt(mt2);
75			}
76
77			double TransverseMass(const BaseVars & leg1,
78			const double mEx,
79			const double mEy)
80			{
81			double px = leg1.pT*cos(leg1.phi) + mEx;
82			double py = leg1.pT*sin(leg1.phi) + mEy;
83			double et = leg1.pT + TMath::Sqrt(mExmEx + mEymEy);
84			double mt = etet - (pxpx + py*py);
85			if ( mt < 0 ) {
86			std::cout << " --- WARNING : mt = " << mt << " is negative... Set to 0.";
87			return 0.;
88			}
89			return sqrt(mt);
90			}
91
92			TLorentzVector FourMomentumCDFmethod(const BaseVars & leg1,
93			const BaseVars & leg2,
94			double mEx,
95			double mEy)
96			{
97			double lpx = leg1.pTcos(leg1.phi) + leg2.pTcos(leg2.phi) + mEx;
98			double lpy = leg1.pTsin(leg1.phi) + leg2.pTsin(leg2.phi) + mEy;
99			double lpz = leg1.pTsinh(leg1.eta) + leg2.pTsinh(leg2.eta);
100			double le = leg1.pTcosh(leg1.eta) + leg2.pTcosh(leg2.eta) + TMath::Sqrt(mExmEx + mEymEy);
101			return TLorentzVector(lpx, lpy, lpz, le);
102			}
103
104			TLorentzVector FourMomentumCollinearApprox(const BaseVars & leg1,
105			const BaseVars & leg2,
106			double mEx,
107			double mEy)
108			{
109			double px1 = leg1.pT*cos(leg1.phi);
110			double px2 = leg2.pT*cos(leg2.phi);
111			double py1 = leg1.pT*sin(leg1.phi);
112			double py2 = leg2.pT*sin(leg2.phi);
113
114			double x1_numerator = px1py2 - px2py1;
115			double x1_denominator = py2(px1 + mEx) - px2(py1 + mEy);
116			double x1 = ( x1_denominator != 0. ) ? x1_numerator/x1_denominator : -1.;
117
118			double x2_numerator = x1_numerator;
119			double x2_denominator = px1(py2 + mEy) - py1(px2 + mEx);
120			double x2 = ( x2_denominator != 0. ) ? x2_numerator/x2_denominator : -1.;
121
122			if ( (x1 > 0. && x1 < 1.) &&
123			(x2 > 0. && x2 < 1.) ) {
124			TLorentzVector p4 = FourMomentum(leg1,1/x1) + FourMomentum(leg2,1/x2);
125			return p4;
126			} else {
127			return TLorentzVector(0,0,0,0);
128			}
129			}
130
131			}//namespace
132