float computeR2(TLorentzVector hem1, TLorentzVector hem2, TLorentzVector pfMet) {
double mR = computeMR(hem1, hem2);
double term1 = pfMet.Pt()/2*(hem1.Pt() + hem2.Pt());
double term2 = pfMet.Px()/2*(hem1.Px() + hem2.Px()) + pfMet.Py()/2*(hem1.Py() + hem2.Py()); //dot product of MET with (p1T + p2T)
double mTR = sqrt(term1 - term2);
return (mTR / mR) * (mTR / mR);
}
//___________________[ TAUS RECONSTRUCTION AND INVMASS CALCULATION ]_________________________________________
double SUSYLooperHistsSoftBase::DiTau_InvMass( TLorentzVector Met, TLorentzVector L1, TLorentzVector L2, float Al ) {
TLorentzVector T1,T2; double DiTauMass; TMatrixF A(2,2); TVectorF C(2),X(2);
A(0,0)=L1.Px();
A(0,1)=L2.Px();
A(1,0)=L1.Py();
A(1,1)=L2.Py();
A=A.Invert();
C(0)=(Met+L1+L2).Px();
C(1)=(Met+L1+L2).Py();
X=A*C;
//double X0i=X(0), X1i=X(1);
if ( (X(0)<0.||X(1)<0.) && Al>0. ) {//---[MET Alignement subsection]--------------------------------------------------------------------------------------------
if ( fabs(L1.DeltaPhi(Met))>Al && fabs(L2.DeltaPhi(Met))>Al ) {}//{DO NOTHING just normaly a non-Z event!}
else if ( fabs(L1.DeltaPhi(Met))<Al && fabs(L2.DeltaPhi(Met))>Al ) Met.SetPtEtaPhiM(Met.Pt(),0,L1.Phi(),0);
else if ( fabs(L2.DeltaPhi(Met))<Al && fabs(L1.DeltaPhi(Met))>Al ) Met.SetPtEtaPhiM(Met.Pt(),0,L2.Phi(),0);
else if ( fabs(L1.DeltaPhi(Met))<Al && fabs(L2.DeltaPhi(Met))<Al && fabs(L1.DeltaPhi(Met))<fabs(L2.DeltaPhi(Met)) ) Met.SetPtEtaPhiM(Met.Pt(),0,L1.Phi(),0);
else if ( fabs(L1.DeltaPhi(Met))<Al && fabs(L2.DeltaPhi(Met))<Al && fabs(L1.DeltaPhi(Met))>fabs(L2.DeltaPhi(Met)) ) Met.SetPtEtaPhiM(Met.Pt(),0,L2.Phi(),0);
}//-------------------------------------------------------------------------------------------------------------------------------------------------------------
C(0)=(Met+L1+L2).Px();
C(1)=(Met+L1+L2).Py();
X=A*C;
T1.SetPxPyPzE( L1.Px()*X(0), L1.Py()*X(0), L1.Pz()*X(0), sqrt( 3.1571 +L1.P()*L1.P()*X(0)*X(0) ) );
T2.SetPxPyPzE( L2.Px()*X(1), L2.Py()*X(1), L2.Pz()*X(1), sqrt( 3.1571 +L2.P()*L2.P()*X(1)*X(1) ) );
if ( X(0)>0. && X(1)>0. ) DiTauMass=(T1+T2).M();
//if ( (X(0)>0. && 0.<X(1)&&X(1)<1.) || (X(1)>0. && 0.<X(0)&&X(0)<1.) ) DiTauMass=(T1+T2).M(); // B
//if ( (X(0)>1.&& X(1)<0.) || (X(1)>1.&& X(0)<0.) ) DiTauMass=(T1+T2).M(); // C
//if ( X(0)<0. && X(1)<0. ) DiTauMass=(T1+T2).M(); // D
else DiTauMass=-(T1+T2).M();
return DiTauMass;
}//-----------------------------------------------------------------------------------------------------------
double SUSYLooperHists::DiTau_InvMass( TLorentzVector Met, TLorentzVector L1, TLorentzVector L2, float Al ){
TLorentzVector T1,T2;
double DiTauMass;
TMatrixF A(2,2);
TVectorF C(2),X(2);
A(0,0)=L1.Px();
A(0,1)=L2.Px();
A(1,0)=L1.Py();
A(1,1)=L2.Py();
A=A.Invert();
C(0)=(Met+L1+L2).Px();
C(1)=(Met+L1+L2).Py();
X=A*C;// double X0i=X(0), X1i=X(1);
//---------------[ MET ReAlignement subsection ]------------------------------
if(X(0)<0||X(1)<0){
if ( fabs(L1.DeltaPhi(Met))>Al && fabs(L2.DeltaPhi(Met))>Al ) {/*DO NOTHING just normaly a non-Z event!*/}
else if( fabs(L1.DeltaPhi(Met))<Al && fabs(L2.DeltaPhi(Met))>Al ) Met.SetPtEtaPhiM(Met.Pt(),0,L1.Phi(),0);
else if( fabs(L2.DeltaPhi(Met))<Al && fabs(L1.DeltaPhi(Met))>Al ) Met.SetPtEtaPhiM(Met.Pt(),0,L2.Phi(),0);
else if( fabs(L1.DeltaPhi(Met))<Al && fabs(L2.DeltaPhi(Met))<Al && fabs(L1.DeltaPhi(Met))<fabs(L2.DeltaPhi(Met)) ) Met.SetPtEtaPhiM(Met.Pt(),0,L1.Phi(),0);
else if( fabs(L1.DeltaPhi(Met))<Al && fabs(L2.DeltaPhi(Met))<Al && fabs(L1.DeltaPhi(Met))>fabs(L2.DeltaPhi(Met)) ) Met.SetPtEtaPhiM(Met.Pt(),0,L2.Phi(),0);
}//---------------------------------------------------------------------------
C(0)=(Met+L1+L2).Px(); C(1)=(Met+L1+L2).Py(); X=A*C;
T1.SetPxPyPzE( L1.Px()*X(0), L1.Py()*X(0), L1.Pz()*X(0), sqrt( 3.1571 +L1.P()*L1.P()*X(0)*X(0) ) );
T2.SetPxPyPzE( L2.Px()*X(1), L2.Py()*X(1), L2.Pz()*X(1), sqrt( 3.1571 +L2.P()*L2.P()*X(1)*X(1) ) );
if( X(0)>0 && X(1)>0 ) DiTauMass=(T1+T2).M(); else DiTauMass=-(T1+T2).M(); return DiTauMass;
//if((X(0)!=X0i||X(1)!=X1i))std::cout<<X(0)<<" "<<X(1)<<" <--"<<X0i<<" "<<X1i<<" RMETal.phi="<<(T1+T2-L1-L2).Phi()<<" RMETal.eta"<<(T1+T2-L1-L2).Eta()<<" MZ="<<DiTauMass<<endl;
}
/*Given the impact point on the front face (vin) and the incoming particle LorentzVector (chi for invisible decay, A' for visible),
* determine the interaction point within the fiducial volume and save it in vhit.
Use a random distribution along the chi flight path, with uniform probability
This function returns the length (in m) of the trajectory within the fiducial volume.
Displacement is the lateral displacement (in m) of the detector, along x
*/
double KinUtils::findInteractionPoint(const TLorentzVector &chi, const TVector3 &fiducialV, const TVector3 &vin, TVector3 &vout, TVector3 &vhit) {
double tz, tx, ty, tout, L;
int sigPx, sigPy;
sigPx = (chi.Px() > 0 ? 1 : -1);
sigPy = (chi.Py() > 0 ? 1 : -1);
tz = fiducialV.Z() / chi.Pz();
tx = (sigPx * fiducialV.X() / 2 - vin.X()) / chi.Px();
ty = (sigPy * fiducialV.Y() / 2 - vin.Y()) / chi.Py();
tout = 0;
if ((tz < tx) && (tz < ty)) {
tout = tz;
} else if ((tx < ty) && (tx < tz)) {
tout = tx;
} else if ((ty < tx) && (ty < tz)) {
tout = ty;
}
vout.SetXYZ(tout * chi.Px() + vin.X(), tout * chi.Py() + vin.Y(), tout * chi.Pz() + vin.Z());
vhit.SetXYZ(Rand.Uniform(vin.X(), vout.X()), Rand.Uniform(vin.Y(), vout.Y()), Rand.Uniform(vin.Z(), vout.Z()));
L = (vout - vin).Mag();
return L;
}
void rochcor2012::musclefit_data( TLorentzVector& mu, TLorentzVector& mubar){
float dpar1 = 0.0;
float dpar2 = 0.0;
float epar1 = 0.0;
float epar2 = 0.0;
if(fabs(mu.PseudoRapidity())<=0.9){
dpar1 = d0par;
epar1 = e0par;
}else if(mu.PseudoRapidity()>0.9){
dpar1 = d1par;
epar1 = e1par;
}else if(mu.PseudoRapidity()<-0.9){
dpar1 = d2par;
epar1 = e2par;
}
if(fabs(mubar.PseudoRapidity())<=0.9){
dpar2 = d0par;
epar2 = e0par;
}else if(mubar.PseudoRapidity()>0.9){
dpar2 = d1par;
epar2 = e1par;
}else if(mubar.PseudoRapidity()<-0.9){
dpar2 = d2par;
epar2 = e2par;
}
float corr1 = 1.0 + bpar*mu.Pt() + (-1.0)*cpar*mu.Pt()*TMath::Sign(float(1.0),float(mu.PseudoRapidity()))*TMath::Power(mu.PseudoRapidity(),2)
+ (-1.0)*dpar1*mu.Pt()*sin(mu.Phi() + epar1);
float corr2 = 1.0 + bpar*mubar.Pt() + (1.0)*cpar*mubar.Pt()*TMath::Sign(float(1.0),float(mubar.PseudoRapidity()))*TMath::Power(mubar.PseudoRapidity(),2)
+ (1.0)*dpar2*mubar.Pt()*sin(mubar.Phi() + epar2);
float px1 = mu.Px();
float py1 = mu.Py();
float pz1 = mu.Pz();
float e1 = mu.E();
float px2 = mubar.Px();
float py2 = mubar.Py();
float pz2 = mubar.Pz();
float e2 = mubar.E();
px1 *= corr1;
py1 *= corr1;
pz1 *= corr1;
e1 *= corr1;
px2 *= corr2;
py2 *= corr2;
pz2 *= corr2;
e2 *= corr2;
mu.SetPxPyPzE(px1,py1,pz1,e1);
mubar.SetPxPyPzE(px2,py2,pz2,e2);
}
//these can be done better, pass in a specific struct and populate that struct
//could reduce these 6 calls into 1 or 2
void DalitzChiSq2::setap2(TLorentzVector vec){
ap2.v.SetXYZM(vec.Px(),vec.Py(),vec.Pz(),vec.M());
double Pt = TMath::Sqrt(vec.Px()*vec.Px() + vec.Py()*vec.Py());
double p = TMath::Sqrt(Pt*Pt + vec.Pz()*vec.Pz());
double thet = TMath::ACos(vec.Pz()/p);
ap2.pt=Pt;
ap2.theta=thet;
ap2.x_m=1/Pt;
}
void DalitzChiSq2::setp2(TLorentzVector vec){
p2.v.SetXYZM(vec.Px(),vec.Py(),vec.Pz(),vec.M());
double Pt = TMath::Sqrt(vec.Px()*vec.Px() + vec.Py()*vec.Py());
double p = TMath::Sqrt(Pt*Pt + vec.Pz()*vec.Pz());
double thet = TMath::ACos(vec.Pz()/p);
p2.pt=Pt;
p2.theta=thet;
p2.x_m=1/Pt;
//cout<<"electron : pt theta x1m : "<<Pt<<" "<<thet<<" "<<1/Pt<<endl;
}
HHKinFit2::HHKinFitMasterSingleHiggs::HHKinFitMasterSingleHiggs(TLorentzVector const& tauvis1,
TLorentzVector const& tauvis2,
TVector2 const& met,
TMatrixD const& met_cov,
bool istruth,
TLorentzVector const& higgsgen)
:m_MET_COV(TMatrixD(4,4))
{
m_tauvis1 = HHLorentzVector(tauvis1.Px(), tauvis1.Py(), tauvis1.Pz(), tauvis1.E());
m_tauvis2 = HHLorentzVector(tauvis2.Px(), tauvis2.Py(), tauvis2.Pz(), tauvis2.E());
m_tauvis1.SetMkeepE(1.77682);
m_tauvis2.SetMkeepE(1.77682);
m_MET = met;
m_MET_COV = met_cov;
m_chi2_best = pow(10,10);
m_bestHypo = 0;
// if (istruth){
// TRandom3 r(0);
//
// HHLorentzVector recoil;
// if(heavyhiggsgen != NULL){
// Double_t pxRecoil = r.Gaus(-(heavyhiggsgen->Px() ), 10.0);
// Double_t pyRecoil = r.Gaus(-(heavyhiggsgen->Py() ), 10.0);
//
// recoil = HHLorentzVector(pxRecoil, pyRecoil, 0,
// sqrt(pxRecoil*pxRecoil+pyRecoil*pyRecoil));
// }
// else{
// recoil = HHLorentzVector(0,0,0,0);
// std::cout << "WARNING! Truthinput mode active but no Heavy Higgs gen-information given! Setting Recoil to Zero!" << std::endl;
// }
//
// TMatrixD recoilCov(2,2);
// recoilCov(0,0)=100; recoilCov(0,1)=0;
// recoilCov(1,0)=0; recoilCov(1,1)=100;
//
// HHLorentzVector recoHH = m_bjet1 + m_bjet2 + m_tauvis1 + m_tauvis2 + recoil;
// m_MET = TVector2(-recoHH.Px(), -recoHH.Py() );
//
// m_MET_COV = TMatrixD(2,2);
// m_MET_COV = recoilCov + bjet1Cov + bjet2Cov;
//
// }
}
double cosRestFrame(TLorentzVector boost, TLorentzVector vect) {
double bx = -boost.Px()/boost.E();
double by = -boost.Py()/boost.E();
double bz = -boost.Pz()/boost.E();
vect.Boost(bx,by,bz);
double prod = -vect.Px()*bx-vect.Py()*by-vect.Pz()*bz;
double modBeta = TMath::Sqrt(bx*bx+by*by+bz*bz);
double modVect = TMath::Sqrt(vect.Px()*vect.Px()+vect.Py()*vect.Py()+vect.Pz()*vect.Pz());
double cosinus = prod/(modBeta*modVect);
return cosinus;
}
double METMHTAsys(MissingET* met,vector<Jet> jetvec,vector<Muon> muonvec,vector<Electron> electronvec,vector<Photon> photonvec){
double Met=-99;
double METAsys=-99;
TVector2 PUCorMet, RawMet;
TLorentzVector allvecsum;
allvecsum.SetPxPyPzE(0, 0, 0, 0);
PUCorMet.Set(0., 0.);
RawMet.Set(0.0, 0.0);
for(int i=0; i<(int)jetvec.size(); i++) {allvecsum += jetvec.at(i).P4();}
for(int j=0; j<(int)muonvec.size(); j++) {allvecsum += muonvec.at(j).P4();}
for(int k=0; k<(int)electronvec.size(); k++) {allvecsum += electronvec.at(k).P4();}
for(int l=0; l<(int)photonvec.size(); l++) {allvecsum += photonvec.at(l).P4();}
PUCorMet.Set(-allvecsum.Px(),-allvecsum.Py());
Met= PUCorMet.Mod();
RawMet.SetMagPhi(met->MET, met->Phi);
METAsys=fabs(Met-(RawMet.Mod()))/(Met+(RawMet.Mod()));//this is funny. RawMet.Mod() must return met->MET. We didn't need to build RawMet to obtain its magnitude :):0
//cout << "......................RawMet.Mod(): " << RawMet.Mod() << endl;
//cout << "...................... Met: " << Met << endl;
//cout << "...................... METAsys: " << METAsys << endl;
return METAsys;
}
double computeMETPhi(const double met, const double metphi, const TLorentzVector &photon)
{
double metx = met*cos(metphi) + photon.Px();
double mety = met*sin(metphi) + photon.Py();
TLorentzVector mvec(metx, mety, 0, 0);
return mvec.Phi();
}
void rochcor::momcor_data( TLorentzVector& mu, float charge, float sysdev, int runopt, float& qter){
float ptmu = mu.Pt();
float muphi = mu.Phi();
float mueta = mu.Eta(); // same with mu.Eta() in Root
float px = mu.Px();
float py = mu.Py();
float pz = mu.Pz();
float e = mu.E();
int mu_phibin = phibin(muphi);
int mu_etabin = etabin(mueta);
//float mptsys1 = sran.Gaus(0.0,sysdev);
float dm = 0.0;
float da = 0.0;
if(runopt==0){
dm = (dcor_bfA[mu_phibin][mu_etabin] + mptsys_da_dm[mu_phibin][mu_etabin]*dcor_bfAer[mu_phibin][mu_etabin])/dmavgA[mu_phibin][mu_etabin];
da = dcor_maA[mu_phibin][mu_etabin] + mptsys_da_da[mu_phibin][mu_etabin]*dcor_maAer[mu_phibin][mu_etabin];
}else if(runopt==1){
dm = (dcor_bfB[mu_phibin][mu_etabin] + mptsys_da_dm[mu_phibin][mu_etabin]*dcor_bfBer[mu_phibin][mu_etabin])/dmavgB[mu_phibin][mu_etabin];
da = dcor_maB[mu_phibin][mu_etabin] + mptsys_da_da[mu_phibin][mu_etabin]*dcor_maBer[mu_phibin][mu_etabin];
}
float cor = 1.0/(1.0 + dm + charge*da*ptmu);
px *= cor;
py *= cor;
pz *= cor;
e *= cor;
//after Z pt correction
float recm = 0.0;
float gscler = 0.0;
if(runopt==0){
recm = drecmA;
gscler = TMath::Sqrt( TMath::Power(dgsclA_stat,2) + TMath::Power(dgsclA_syst,2) );
}else if(runopt==1){
recm = drecmB;
gscler = TMath::Sqrt( TMath::Power(dgsclB_stat,2) + TMath::Power(dgsclB_syst,2) );
}
float gscl = (genm_smr/recm);
px *= (gscl + gscler_da_dev*gscler);
py *= (gscl + gscler_da_dev*gscler);
pz *= (gscl + gscler_da_dev*gscler);
e *= (gscl + gscler_da_dev*gscler);
float momscl = sqrt(px*px + py*py)/ptmu;
qter *= momscl;
mu.SetPxPyPzE(px,py,pz,e);
}
float getMT(TLorentzVector pZ, TLorentzVector pH)
{
//take MET from pZ
float myMET = pZ.Pt();
float myMETx = pZ.Px();
float myMETy = pZ.Py();
float Et = pH.Et();
float px = pH.Px();
float py = pH.Py();
float m = pH.M();
float MT = -99;
float MT2 = m*m + 2*( Et * myMET - (px*myMETx + py*myMETy) );
if(MT2>0.) {MT=sqrt(MT2);}
return MT;
}
void rochcor2012::momcor_mc( TLorentzVector& mu, float charge, float sysdev, int runopt,bool sync=false){
//sysdev == num : deviation = num
float ptmu = mu.Pt();
float muphi = mu.Phi();
float mueta = mu.Eta(); // same with mu.Eta() in Root
float px = mu.Px();
float py = mu.Py();
float pz = mu.Pz();
float e = mu.E();
int mu_phibin = phibin(muphi);
int mu_etabin = etabin(mueta);
//float mptsys = sran.Gaus(0.0,sysdev);
float dm = (mcor_bf[mu_phibin][mu_etabin] + mptsys_mc_dm[mu_phibin][mu_etabin]*mcor_bfer[mu_phibin][mu_etabin])/mmavg[mu_phibin][mu_etabin];
float da = mcor_ma[mu_phibin][mu_etabin] + mptsys_mc_da[mu_phibin][mu_etabin]*mcor_maer[mu_phibin][mu_etabin];
float cor = 1.0/(1.0 + dm + charge*da*ptmu);
//for the momentum tuning - eta,phi,Q correction
px *= cor;
py *= cor;
pz *= cor;
e *= cor;
float gscler = 0.0;
float deltaer = 0.0;
float sfer = 0.0;
gscler = TMath::Sqrt( TMath::Power(mgscl_stat,2) + TMath::Power(mgscl_syst,2) );
deltaer = TMath::Sqrt( TMath::Power(delta_stat,2) + TMath::Power(delta_syst,2) );
sfer = TMath::Sqrt( TMath::Power(sf_stat,2) + TMath::Power(sf_syst,2) );
float tune;
if (sync) tune = 1.0/(1.0 + (delta + sysdev*deltaer)*sqrt(px*px + py*py)*(1.0 + (sf + sysdev*sfer)));
else tune = 1.0/(1.0 + (delta + sysdev*deltaer)*sqrt(px*px + py*py)*eran.Gaus(1.0,(sf + sysdev*sfer)));
px *= (tune);
py *= (tune);
pz *= (tune);
e *= (tune);
float gscl = (genm_smr/mrecm);
px *= (gscl + gscler_mc_dev*gscler);
py *= (gscl + gscler_mc_dev*gscler);
pz *= (gscl + gscler_mc_dev*gscler);
e *= (gscl + gscler_mc_dev*gscler);
mu.SetPxPyPzE(px,py,pz,e);
}
void rochcor2012::momcor_mc( TLorentzVector& mu, float charge, float sysdev, int runopt, float& qter){
//sysdev == num : deviation = num
float ptmu = mu.Pt();
float muphi = mu.Phi();
float mueta = mu.Eta(); // same with mu.Eta() in Root
float px = mu.Px();
float py = mu.Py();
float pz = mu.Pz();
float e = mu.E();
int mu_phibin = phibin(muphi);
int mu_etabin = etabin(mueta);
//float mptsys = sran.Gaus(0.0,sysdev);
float Mf = (mcor_bf[mu_phibin][mu_etabin] + mptsys_mc_dm[mu_phibin][mu_etabin]*mcor_bfer[mu_phibin][mu_etabin])/(mpavg[mu_phibin][mu_etabin]+mmavg[mu_phibin][mu_etabin]);
float Af = ((mcor_ma[mu_phibin][mu_etabin]+mptsys_mc_da[mu_phibin][mu_etabin]*mcor_maer[mu_phibin][mu_etabin]) - Mf*(mpavg[mu_phibin][mu_etabin]-mmavg[mu_phibin][mu_etabin]));
float cor = 1.0/(1.0 + 2.0*Mf + charge*Af*ptmu);
//for the momentum tuning - eta,phi,Q correction
px *= cor;
py *= cor;
pz *= cor;
e *= cor;
float gscler = mgscl_stat;
float deltaer = delta_stat;
float sfer = sf_stat;
float gscl = (genm_smr/mrecm);
px *= (gscl + gscler_mc_dev*gscler);
py *= (gscl + gscler_mc_dev*gscler);
pz *= (gscl + gscler_mc_dev*gscler);
e *= (gscl + gscler_mc_dev*gscler);
float momscl = sqrt(px*px + py*py)/ptmu;
float tune = 1.0/(1.0 + (delta + sysdev*deltaer)*sqrt(px*px + py*py)*eran.Gaus(1.0,(sf + sysdev*sfer)));
px *= (tune);
py *= (tune);
pz *= (tune);
e *= (tune);
qter *= (momscl*momscl + (1.0-tune)*(1.0-tune));
mu.SetPxPyPzE(px,py,pz,e);
}
inline float kinematics::betaiSystem( TLorentzVector* pa, TLorentzVector* pb, int i)
{
TLorentzVector pTmp = (*pa)+(*pb);
float E = pTmp.E();
if(E<=0.) return -99999999.;
if (i==1) return pTmp.Px()/E;
else if(i==2) return pTmp.Py()/E;
else if(i==3) return pTmp.Pz()/E;
else _WARNING("i needs to be 1,2,3 (x,y,z), returning -99999999.");
return -99999999.;
}
///------------------------------------------------------------------------
/// MEKD::computeKD - compute KD and MEs for the input processes A and B
///------------------------------------------------------------------------
int MEKD::computeKD( TString processA, TString processB,
TLorentzVector lept1P, int lept1Id, TLorentzVector lept2P, int lept2Id,
TLorentzVector lept3P, int lept3Id, TLorentzVector lept4P, int lept4Id,
double& kd, double& me2processA, double& me2processB )
{
/// Prepare 4-momenta in the required format
lept1P_i[0] = lept1P.E();
lept1P_i[1] = lept1P.Px();
lept1P_i[2] = lept1P.Py();
lept1P_i[3] = lept1P.Pz();
lept2P_i[0] = lept2P.E();
lept2P_i[1] = lept2P.Px();
lept2P_i[2] = lept2P.Py();
lept2P_i[3] = lept2P.Pz();
lept3P_i[0] = lept3P.E();
lept3P_i[1] = lept3P.Px();
lept3P_i[2] = lept3P.Py();
lept3P_i[3] = lept3P.Pz();
lept4P_i[0] = lept4P.E();
lept4P_i[1] = lept4P.Px();
lept4P_i[2] = lept4P.Py();
lept4P_i[3] = lept4P.Pz();
/// Load internal containers
four_particle_Ps_i[0] = lept1P_i;
four_particle_Ps_i[1] = lept2P_i;
four_particle_Ps_i[2] = lept3P_i;
four_particle_Ps_i[3] = lept4P_i;
four_particle_IDs_i[0] = lept1Id;
four_particle_IDs_i[1] = lept2Id;
four_particle_IDs_i[2] = lept3Id;
four_particle_IDs_i[3] = lept4Id;
return computeKD( (string) processA.Data(), (string) processB.Data(), four_particle_Ps_i, four_particle_IDs_i, kd, me2processA, me2processB );
}
void Boost_To_Stop_Rest_Frame(TLorentzVector& stop4, TLorentzVector& chargino4, TLorentzVector& b4, TLorentzVector& neutralino4, TLorentzVector& W4, TLorentzVector& up4, TLorentzVector& down4, TLorentzVector& s4)
{
TVector3 betaV(-stop4.Px()/stop4.Energy(),-stop4.Py()/stop4.Energy(),-stop4.Pz()/stop4.Energy());
stop4.Boost(betaV);
chargino4.Boost(betaV);
b4.Boost(betaV);
neutralino4.Boost(betaV);
W4.Boost(betaV);
up4.Boost(betaV);
down4.Boost(betaV);
s4.SetE(chargino4.P()/chargino4.M());
s4.SetVect(chargino4.Vect().Unit()*chargino4.Gamma());
}
float GetWeightWjetsPolarizationF0(TLorentzVector _p4W, TLorentzVector _p4lepton,float PercentVariation, bool isWplus){
LorentzVector p4W, p4lepton;
p4W.SetPx(_p4W.Px());
p4W.SetPy(_p4W.Py());
p4W.SetPz(_p4W.Pz());
p4W.SetE(_p4W.E());
p4lepton.SetPx(_p4lepton.Px());
p4lepton.SetPy(_p4lepton.Py());
p4lepton.SetPz(_p4lepton.Pz());
p4lepton.SetE(_p4lepton.E());
float final_weight=1;
float cos_theta = WjetPolarizationAngle(p4W,p4lepton);
// final_weight = GetWeight( cos_theta,PercentVariation );
//final_weight = GetWeightFLminusFR( cos_theta,PercentVariation,p4W, isWplus );
final_weight = GetWeightF0( cos_theta,PercentVariation,p4W,isWplus );
return final_weight;
}//end of function
///------------------------------------------------------------------------
/// MEKD::computeMEs - compute MEs for a multiple reuse
///------------------------------------------------------------------------
int MEKD::computeMEs( TLorentzVector lept1P, int lept1Id, TLorentzVector lept2P, int lept2Id,
TLorentzVector lept3P, int lept3Id, TLorentzVector lept4P, int lept4Id )
{
/// Prepare 4-momenta in the required format
lept1P_i[0] = lept1P.E();
lept1P_i[1] = lept1P.Px();
lept1P_i[2] = lept1P.Py();
lept1P_i[3] = lept1P.Pz();
lept2P_i[0] = lept2P.E();
lept2P_i[1] = lept2P.Px();
lept2P_i[2] = lept2P.Py();
lept2P_i[3] = lept2P.Pz();
lept3P_i[0] = lept3P.E();
lept3P_i[1] = lept3P.Px();
lept3P_i[2] = lept3P.Py();
lept3P_i[3] = lept3P.Pz();
lept4P_i[0] = lept4P.E();
lept4P_i[1] = lept4P.Px();
lept4P_i[2] = lept4P.Py();
lept4P_i[3] = lept4P.Pz();
/// Load internal containers
four_particle_Ps_i[0] = lept1P_i;
four_particle_Ps_i[1] = lept2P_i;
four_particle_Ps_i[2] = lept3P_i;
four_particle_Ps_i[3] = lept4P_i;
four_particle_IDs_i[0] = lept1Id;
four_particle_IDs_i[1] = lept2Id;
four_particle_IDs_i[2] = lept3Id;
four_particle_IDs_i[3] = lept4Id;
return computeMEs( four_particle_Ps_i, four_particle_IDs_i );
}
void rochcor2012::momcor_data( TLorentzVector& mu, float charge, int runopt, float& qter){
float ptmu = mu.Pt();
float muphi = mu.Phi();
float mueta = mu.Eta(); // same with mu.Eta() in Root
float px = mu.Px();
float py = mu.Py();
float pz = mu.Pz();
float e = mu.E();
int mu_phibin = phibin(muphi);
int mu_etabin = etabin(mueta);
float Mf = 0.0;
float Af = 0.0;
if(runopt==0){
Mf = (dcor_bf[mu_phibin][mu_etabin]+mptsys_da_dm[mu_phibin][mu_etabin]*dcor_bfer[mu_phibin][mu_etabin])/(dpavg[mu_phibin][mu_etabin]+dmavg[mu_phibin][mu_etabin]);
Af = ((dcor_ma[mu_phibin][mu_etabin]+mptsys_da_da[mu_phibin][mu_etabin]*dcor_maer[mu_phibin][mu_etabin]) - Mf*(dpavg[mu_phibin][mu_etabin]-dmavg[mu_phibin][mu_etabin]));
}else if(runopt==1){
Mf = (dcor_bfD[mu_phibin][mu_etabin]+mptsys_da_dm[mu_phibin][mu_etabin]*dcor_bfDer[mu_phibin][mu_etabin])/(dpavgD[mu_phibin][mu_etabin]+dmavgD[mu_phibin][mu_etabin]);
Af = ((dcor_maD[mu_phibin][mu_etabin]+mptsys_da_da[mu_phibin][mu_etabin]*dcor_maDer[mu_phibin][mu_etabin]) - Mf*(dpavgD[mu_phibin][mu_etabin]-dmavgD[mu_phibin][mu_etabin]));
}
float cor = 1.0/(1.0 + 2.0*Mf + charge*Af*ptmu);
px *= cor;
py *= cor;
pz *= cor;
e *= cor;
//after Z pt correction
float gscler = dgscl_stat;
float gscl = (genm_smr/drecm);
px *= (gscl + gscler_da_dev*gscler);
py *= (gscl + gscler_da_dev*gscler);
pz *= (gscl + gscler_da_dev*gscler);
e *= (gscl + gscler_da_dev*gscler);
float momscl = sqrt(px*px + py*py)/ptmu;
qter *= momscl;
mu.SetPxPyPzE(px,py,pz,e);
}
TLorentzVector doCalEnergy(double BeamEnergy,
TLorentzVector Particle1,
TLorentzVector Particle2,
double nucleusMass,
double Particle2Mass,
double Particle3Mass)
{
double E_Particle1 = Particle1.E();
double p_Particle1_x = Particle1.Px();
double p_Particle1_y = Particle1.Py();
double p_Particle1_z = Particle1.Pz();
double p_Particle1 = sqrt(TMath::Power(p_Particle1_x,2.0) +
TMath::Power(p_Particle1_y,2.0) +
TMath::Power(p_Particle1_z,2.0));
double phi = Particle2.Phi();
double theta = Particle2.Theta();
double b = 2.0 * ( p_Particle1_x * cos(phi) * sin(theta) +
p_Particle1_y * sin(phi) * sin(theta) +
p_Particle1_z * cos(theta) -
BeamEnergy * cos(theta)
);
double c = p_Particle1 * p_Particle1 + BeamEnergy * BeamEnergy - 2.0 * BeamEnergy * p_Particle1_z;
double d = BeamEnergy + nucleusMass - E_Particle1;
double e = TMath::Power(Particle3Mass,2.0) - TMath::Power(Particle2Mass,2.0) - d * d + c;
double Delta = 16.0 * TMath::Power(d,2.0) * (TMath::Power(e,2.0) +
TMath::Power(b * Particle2Mass,2.0) -
TMath::Power(d * Particle2Mass * 2.0,2.0));
TLorentzVector NewParticle(0.0,0.0,0.0,0.0);
if(Delta>0.)
{
double sol2 = (2.0 * e * b + sqrt(Delta)) / (2.0 * (4.0 * TMath::Power(d,2.0) - TMath::Power(b,2.0)));
double newpxcal = sol2 * cos(phi) * sin(theta);
double newpycal = sol2 * sin(phi) * sin(theta);
double newpzcal = sol2 * cos(theta);
double energy = sqrt(TMath::Power(sol2,2.0) + TMath::Power(Particle2Mass,2.0));
TLorentzVector NewParticle2(newpxcal,newpycal,newpzcal,energy);
NewParticle = NewParticle2;
}
return NewParticle;
}
void rochcor::momcor_data( TLorentzVector& mu, float charge, float sysdev, int runopt){
float ptmu = mu.Pt();
float muphi = mu.Phi();
float mueta = mu.Eta(); // same with mu.Eta() in Root
float px = mu.Px();
float py = mu.Py();
float pz = mu.Pz();
float e = mu.E();
int mu_phibin = phibin(muphi);
int mu_etabin = etabin(mueta);
//float mptsys1 = sran.Gaus(0.0,sysdev);
float dm = (dcor_bf[mu_phibin][mu_etabin] + mptsys_da_dm[mu_phibin][mu_etabin]*dcor_bfer[mu_phibin][mu_etabin])/dmavg[mu_phibin][mu_etabin];
float da = dcor_ma[mu_phibin][mu_etabin] + mptsys_da_da[mu_phibin][mu_etabin]*dcor_maer[mu_phibin][mu_etabin];
float cor = 1.0/(1.0 + dm + charge*da*ptmu);
px *= cor;
py *= cor;
pz *= cor;
e *= cor;
//after Z pt correction
float gscler = 0.0;
gscler = TMath::Sqrt( TMath::Power(dgscl_stat,2) + TMath::Power(dgscl_syst,2) );
float gscl = (genm_smr/drecm);
px *= (gscl + gscler_da_dev*gscler);
py *= (gscl + gscler_da_dev*gscler);
pz *= (gscl + gscler_da_dev*gscler);
e *= (gscl + gscler_da_dev*gscler);
mu.SetPxPyPzE(px,py,pz,e);
}
//This is the function to determine the interaction point in case of a cylinder (case1), for BDXmini.
//The cylinder is with the axis along y(vertical), center at x=0,y=0,z=ldet, radius is R,height is h
double KinUtils::findInteractionPointCylinder1(const TLorentzVector &chi,double ldet,double h,double R,TVector3 &vin,TVector3 &vout,TVector3 &vhit){
double tIN,tOUT,t2,t3,t,L;
double px=chi.Px();
double py=chi.Py();
double pz=chi.Pz();
double delta=pz*pz*ldet*ldet-(pz*pz+px*px)*(ldet*ldet-R*R);
if (delta<0){
cout<<"KinUtils::findInteractionPointCylinder1 error, the delta is: "<<delta<<endl;
return 0;
}
//entry point
tIN = (pz*ldet - sqrt(delta))/(px*px+pz*pz);
t2 = (pz*ldet + sqrt(delta))/(px*px+pz*pz);
t3 = (h/2)/py;
if ((t3>0)&&(t3<t2)&&(t3>tIN)){
tOUT=t3;
}else{
tOUT=t2;
}
t=Rand.Uniform(tIN,tOUT);
vin.SetXYZ(tIN*px,tIN*py,tIN*pz);
vout.SetXYZ(tOUT*px,tOUT*py,tOUT*pz);
vhit.SetXYZ(t*px,t*py,t*pz);
L = (vout - vin).Mag();
return L;
}
bool KinUtils::intersectsCylinder1(const TLorentzVector &chi,double ldet,double h,double R){
double t1,y;
double px=chi.Px();
double py=chi.Py();
double pz=chi.Pz();
double delta=pz*pz*ldet*ldet-(pz*pz+px*px)*(ldet*ldet-R*R);
if (delta<0) return false;
t1 = (pz*ldet - sqrt(delta))/(px*px+pz*pz); //this is where it enters
y = t1*py;
if ((y>h/2)||(y<-h/2)) return false;
return true;
}
void DalitzChiSq2::setap3(TLorentzVector vec){
ap3.v.SetXYZM(vec.Px(),vec.Py(),vec.Pz(),vec.M());
//em & ep
double cos12 = (ap1.v.Px()*ap2.v.Px() + ap1.v.Py()*ap2.v.Py() + ap1.v.Pz()*ap2.v.Pz())/(ap1.v.P()*ap2.v.P());
//em & gm
double cos23 = (ap2.v.Px()*ap3.v.Px() + ap2.v.Py()*ap3.v.Py() + ap2.v.Pz()*ap3.v.Pz())/(ap3.v.P()*ap2.v.P());
//ep & gm
double cos13 = (ap1.v.Px()*ap3.v.Px() + ap1.v.Py()*ap3.v.Py() + ap1.v.Pz()*ap3.v.Pz())/(ap1.v.P()*ap3.v.P());
double beta1 = ap1.v.P()/ap1.v.E();
double beta2 = ap2.v.P()/ap2.v.E();
double z12 = 2*((1/(beta1*beta2)) -cos12);
double z23 = 2*((1/beta2)-cos23);
double z13 = 2*((1/beta1)-cos13);
double topterm = M*M - 2*m_e*m_e - ( z12/(TMath::Sin(ap1.theta) * TMath::Sin(ap2.theta) *ap1.x_m*ap2.x_m));
double bottomterm = ( (z13/(TMath::Sin(ap1.theta) * ap1.x_m)) + (z23/(TMath::Sin(ap2.theta) * ap2.x_m)) );
ap3.x_m=topterm/bottomterm;
}
int main(int argc, char* argv[])
{
TApplication theApp(srcName.Data(), &argc, argv);
//=============================================================================
if (argc<5) return -1;
TString sPath = argv[1]; if (sPath.IsNull()) return -1;
TString sFile = argv[2]; if (sFile.IsNull()) return -1;
TString sJetR = argv[3]; if (sJetR.IsNull()) return -1;
TString sSjeR = argv[4]; if (sSjeR.IsNull()) return -1;
//=============================================================================
sPath.ReplaceAll("#", "/");
//=============================================================================
double dJetR = -1.;
if (sJetR=="JetR02") dJetR = 0.2;
if (sJetR=="JetR03") dJetR = 0.3;
if (sJetR=="JetR04") dJetR = 0.4;
if (sJetR=="JetR05") dJetR = 0.5;
if (dJetR<0.) return -1;
cout << "Jet R = " << dJetR << endl;
//=============================================================================
double dSjeR = -1.;
if (sSjeR=="SjeR01") dSjeR = 0.1;
if (sSjeR=="SjeR02") dSjeR = 0.2;
if (sSjeR=="SjeR03") dSjeR = 0.3;
if (sSjeR=="SjeR04") dSjeR = 0.4;
if (dSjeR<0.) return -1;
cout << "Sub-jet R = " << dSjeR << endl;
//=============================================================================
const int multiLHC = 3000;
const double dJetsPtMin = 0.001;
const double dCutEtaMax = 1.6;
const double dJetEtaMax = 1.;
const double dJetAreaRef = TMath::Pi() * dJetR * dJetR;
fastjet::GhostedAreaSpec areaSpc(dCutEtaMax);
fastjet::JetDefinition jetsDef(fastjet::antikt_algorithm, dJetR, fastjet::BIpt_scheme, fastjet::Best);
//fastjet::AreaDefinition areaDef(fastjet::active_area,areaSpc);
fastjet::AreaDefinition areaDef(fastjet::active_area_explicit_ghosts,areaSpc);
fastjet::JetDefinition bkgsDef(fastjet::kt_algorithm, 0.2, fastjet::BIpt_scheme, fastjet::Best);
fastjet::AreaDefinition aBkgDef(fastjet::active_area_explicit_ghosts, areaSpc);
fastjet::Selector selectJet = fastjet::SelectorAbsEtaMax(dJetEtaMax);
fastjet::Selector selectRho = fastjet::SelectorAbsEtaMax(dCutEtaMax-0.2);
fastjet::Selector selecHard = fastjet::SelectorNHardest(2);
fastjet::Selector selectBkg = selectRho * (!(selecHard));
fastjet::JetMedianBackgroundEstimator bkgsEstimator(selectBkg, bkgsDef, aBkgDef);
//fastjet::Subtractor bkgSubtractor(&bkgsEstimator);
fastjet::JetDefinition subjDef(fastjet::kt_algorithm, dSjeR, fastjet::BIpt_scheme, fastjet::Best);
//=============================================================================
TRandom3 *r3 = new TRandom3(0);
TF1 *fBkg = BackgroundSpec();
//=============================================================================
std::vector<fastjet::PseudoJet> fjInputVac;
std::vector<fastjet::PseudoJet> fjInputHyd;
//=============================================================================
TList *list = new TList();
TH1D *hWeightSum = new TH1D("hWeightSum", "", 1, 0., 1.); list->Add(hWeightSum);
//=============================================================================
HepMC::IO_GenEvent ascii_in(Form("%s/%s.hepmc",sPath.Data(),sFile.Data()), std::ios::in);
HepMC::GenEvent *evt = ascii_in.read_next_event();
while (evt) {
fjInputVac.resize(0);
fjInputHyd.resize(0);
double dXsect = evt->cross_section()->cross_section() / 1e9;
double dWeight = evt->weights().back();
double dNorm = dWeight * dXsect;
hWeightSum->Fill(0.5, dWeight);
int iCount = 0;
TLorentzVector vPseudo;
for (HepMC::GenEvent::particle_const_iterator p=evt->particles_begin(); p!=evt->particles_end(); ++p) if ((*p)->status()==1) {
vPseudo.SetPtEtaPhiM((*p)->momentum().perp(), (*p)->momentum().eta(), (*p)->momentum().phi(), 0.);
if ((TMath::Abs(vPar.Eta())<dCutEtaMax)) {
fjInputVac.push_back(fastjet::PseudoJet(vPseudo.Px(), vPseudo.Py(), vPseudo.Pz(), vPseudo.E()));
fjInputVac.back().set_user_info(new UserInfoTrk(false));
fjInputVac.back().set_user_index(iCount); iCount+=1;
}
}
//=============================================================================
for (int i=0; i<=multiLHC; i++) {
double dPt = fBkg->GetRandom(fgkPtBkgMin, fgkPtBkgMax); if (dPt<0.001) continue;
vPseudo.SetPtEtaPhiM(dPt, r3->Uniform(-1.*dCutEtaMax,dCutEtaMax), r3->Uniform(0.,TMath::TwoPi()), 0.);
fjInputHyd.push_back(fastjet::PseudoJet(vPseudo.Px(), vPseudo.Py(), vPseudo.Pz(), vPseudo.E()));
fjInputHyd.back().set_user_info(new UserInfoTrk(true));
fjInputHyd.back().set_user_index(-10);
}
fjInputHyd.insert(fjInputHyd.end(), fjInputVac.begin(),fjInputVac.end());
//=============================================================================
fastjet::ClusterSequenceArea clustSeq(fjInputVac, jetsDef, areaDef);
std::vector<fastjet::PseudoJet> includJetsPy = clustSeq.inclusive_jets(dJetsPtMin);
// std::vector<fastjet::PseudoJet> subtedJetsPy = bkgSubtractor(includJetsPy);
std::vector<fastjet::PseudoJet> selectJetsPy = selectJet(includJetsPy);
// std::vector<fastjet::PseudoJet> sortedJetsPy = fastjet::sorted_by_pt(selectJetsPy);
for (int j=0; j<selectJetsPy.size(); j++) {
SetJetUserInfo(selectJetsPy[j]);
selectJetsPy[j].set_user_index(j);
}
//=============================================================================
bkgsEstimator.set_particles(fjInputHyd);
double dBkgRhoHd = bkgsEstimator.rho();
double dBkgRmsHd = bkgsEstimator.sigma();
fastjet::ClusterSequenceArea clustSeqHd(fjInputHyd, jetsDef, areaDef);
std::vector<fastjet::PseudoJet> includJetsHd = clustSeqHd.inclusive_jets(dJetsPtMin);
std::vector<fastjet::PseudoJet> selectJetsHd = selectJet(includJetsHd);
for (int j=0; j<selectJetsHd.size(); j++) {
SetJetUserInfo(selectJetsHd[j]);
selectJetsHd[j].set_user_index(j);
if (selectJetsHd[j].user_info<UserInfoJet>().IsBkg()) continue;
for (int i=0; i<selectJetsPy.size(); i++) {
if (CalcDeltaR(selectJetsHd[j],selectJetsPy[i])>0.8) continue;
DoTrkMatch(selectJetsHd[j], selectJetsPy[i]);
}
}
//=============================================================================
for (int j=0; j<sortedJets.size(); j++) {
double dJet = sortedJets[j].pt();
hJet->Fill(dJet, dNorm);
//=============================================================================
fastjet::Filter trimmer(subjDef, fastjet::SelectorPtFractionMin(0.));
fastjet::PseudoJet trimmdJet = trimmer(sortedJets[j]);
std::vector<fastjet::PseudoJet> trimmdSj = trimmdJet.pieces();
double nIsj = 0.;
double d1sj = -1.; int k1sj = -1;
double d2sj = -1.; int k2sj = -1;
for (int i=0; i<trimmdSj.size(); i++) {
double dIsj = trimmdSj[i].pt(); if (dIsj<0.001) continue;
hJetIsj->Fill(dJet, dIsj, dNorm);
hJetIsz->Fill(dJet, dIsj/dJet, dNorm);
if (dIsj>d1sj) {
d2sj = d1sj; k2sj = k1sj;
d1sj = dIsj; k1sj = i;
} else if (dIsj>d2sj) {
d2sj = dIsj; k2sj = i;
} nIsj += 1.;
}
hJetNsj->Fill(dJet, nIsj, dNorm);
if (d1sj>0.) { hJet1sj->Fill(dJet, d1sj, dNorm); hJet1sz->Fill(dJet, d1sj/dJet, dNorm); }
if (d2sj>0.) { hJet2sj->Fill(dJet, d2sj, dNorm); hJet2sz->Fill(dJet, d2sj/dJet, dNorm); }
if ((d1sj>0.) && (d2sj>0.)) {
TVector3 v1sj; v1sj.SetPtEtaPhi(d1sj, trimmdSj[k1sj].eta(), trimmdSj[k1sj].phi());
TVector3 v2sj; v2sj.SetPtEtaPhi(d2sj, trimmdSj[k2sj].eta(), trimmdSj[k2sj].phi());
double dsj = d1sj - d2sj;
double dsz = dsj / dJet;
double dsr = v1sj.DeltaR(v2sj) / 2. / dJetR;
hJetDsj->Fill(dJet, dsj, dNorm);
hJetDsz->Fill(dJet, dsz, dNorm);
hJetDsr->Fill(dJet, dsz, dsr, dNorm);
}
}
//=============================================================================
delete evt;
ascii_in >> evt;
}
//=============================================================================
TFile *file = TFile::Open(Form("%s.root",sFile.Data()), "NEW");
list->Write();
file->Close();
//=============================================================================
cout << "DONE" << endl;
return 0;
}
//!PG main function
int
selector (TChain * tree, histos & plots, int if_signal)
{
plots.v_hardTAGPt = -99;
plots.v_softTAGPt = -99;
plots.v_TAGDProdEta = -99;
plots.v_TAGDeta = -99;
plots.v_TAGMinv = -99;
plots.v_LepLep = -99;
plots.v_hardLEPPt = -99;
plots.v_softLEPPt = -99;
plots.v_LEPDPhi = -99;
plots.v_LEPDEta = -99;
plots.v_LEPDR = -99;
plots.v_LEPMinv = -99;
plots.v_LEPProdCharge = -99;
plots.v_hardLEPCharge = -99;
plots.v_softLEPCharge = -99;
plots.v_MET = -99;
plots.v_ojets = -99 ;
plots.v_ojetsCJV = -99 ;
plots.v_ojetsRegionalCJV = -99 ;
plots.v_ojetsZepp_01 = -99 ;
plots.v_ojetsZepp_02 = -99 ;
plots.v_ojetsZepp_03 = -99 ;
plots.v_ojetsZepp_04 = -99 ;
plots.v_ojetsZepp_05 = -99 ;
plots.v_ojetsZepp_06 = -99 ;
plots.v_ojetsZepp_07 = -99 ;
plots.v_ojetsZepp_08 = -99 ;
plots.v_ojetsZepp_09 = -99 ;
plots.v_ojetsZepp_10 = -99 ;
plots.v_ojetsZepp_11 = -99 ;
plots.v_ojetsZepp_12 = -99 ;
plots.v_ojetsZepp_13 = -99 ;
plots.v_ojetsZepp_14 = -99 ;
plots.v_decay_Channel_e = -99 ;
plots.v_decay_Channel_mu = -99 ;
plots.v_decay_Channel_tau = -99 ;
TClonesArray * genParticles = new TClonesArray ("TParticle") ;
tree->SetBranchAddress ("genParticles", &genParticles) ;
// TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ;
// tree->SetBranchAddress ("tagJets", &tagJets) ;
TClonesArray * otherJets_temp = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress (g_KindOfJet.c_str(), &otherJets_temp) ;
// tree->SetBranchAddress ("otherJets", &otherJets_temp) ;
TClonesArray * electrons = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("electrons", &electrons) ;
TClonesArray * muons = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("muons", &muons) ;
TClonesArray * MET = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("MET", &MET) ;
TClonesArray * tracks = new TClonesArray ("TLorentzVector") ;
tree->SetBranchAddress ("tracks", &tracks) ;
TClonesArray * tagJets = new TClonesArray ("TLorentzVector") ;
TClonesArray * otherJets = new TClonesArray ("TLorentzVector") ;
int EleId[100];
float IsolEleSumPt_VBF[100];
int nEle;
int EleCharge[30];
tree->SetBranchAddress ("nEle", &nEle) ;
tree->SetBranchAddress ("EleId",EleId ) ;
tree->SetBranchAddress ("IsolEleSumPt_VBF",IsolEleSumPt_VBF ) ;
tree->SetBranchAddress ("EleCharge",EleCharge ) ;
float IsolMuTr[100];
int nMu ;
int MuCharge[30];
tree->SetBranchAddress ("nMu", &nMu) ;
tree->SetBranchAddress ("IsolMuTr",IsolMuTr ) ;
tree->SetBranchAddress ("MuCharge", MuCharge) ;
int IdEvent;
tree->SetBranchAddress ("IdEvent", &IdEvent) ;
int nentries = (int) tree->GetEntries () ;
plots.passedJetAndLepNumberSelections = 0;
plots.analyzed = 0;
plots.analyzed_ee = 0;
plots.analyzed_mumu = 0;
plots.analyzed_tautau = 0;
plots.analyzed_emu = 0;
plots.analyzed_etau = 0;
plots.analyzed_mutau = 0;
plots.passedJetAndLepNumberSelections_ee = 0;
plots.passedJetAndLepNumberSelections_mumu = 0;
plots.passedJetAndLepNumberSelections_tautau = 0;
plots.passedJetAndLepNumberSelections_emu = 0;
plots.passedJetAndLepNumberSelections_etau = 0;
plots.passedJetAndLepNumberSelections_mutau = 0;
//PG loop over the events
for (int evt = 0 ; evt < nentries ; ++evt)
{
tree->GetEntry (evt) ;
tagJets -> Clear () ;
otherJets -> Clear () ;
//---- check if signal ----
if (if_signal && (IdEvent!=123 && IdEvent!=124)) continue;
plots.analyzed++;
//!---- MC ----
if (IdEvent==123 || IdEvent==124) { //---- VBF event ----
plots.v_decay_Channel_e = 0;
plots.v_decay_Channel_mu = 0;
plots.v_decay_Channel_tau = 0;
for (int iGen = 0; iGen < genParticles->GetEntries() ; ++iGen){
TParticle* myparticle = (TParticle*) genParticles->At(iGen);
if (abs(myparticle->GetPdgCode()) == 24) { //---- W
Int_t mother1 = 0;
mother1 = myparticle->GetMother(0);
if (mother1 == 25) { //---- mother is higgs ----
for (int iDaughter = 0; iDaughter<2; iDaughter++){
if (abs(myparticle->GetDaughter(iDaughter)) == 11) {//---- W -> e
plots.v_decay_Channel_e++;
}
if (abs(myparticle->GetDaughter(iDaughter)) == 13) {//---- W -> mu
plots.v_decay_Channel_mu++;
}
if (abs(myparticle->GetDaughter(iDaughter)) == 15) {//---- W -> tau
plots.v_decay_Channel_tau++;
}
}
}
}
}
}
if (plots.v_decay_Channel_e == 2) plots.analyzed_ee++;
if (plots.v_decay_Channel_mu == 2) plots.analyzed_mumu++;
if (plots.v_decay_Channel_tau == 2) plots.analyzed_tautau++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_mu == 1) plots.analyzed_emu++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_tau == 1) plots.analyzed_etau++;
if (plots.v_decay_Channel_mu == 1 && plots.v_decay_Channel_tau == 1) plots.analyzed_mutau++;
int cutId = 0 ;
plots.increase (cutId++) ; //AM 0 -> total number of events
// std::cerr << "--- preambolo leptoni " << std::endl;
std::vector<lepton> leptons ;
//PG pour electrons into leptons collection
//PG ---------------------------------------
//PG loop over electrons
for (int iele = 0; iele < electrons->GetEntries () ; ++iele)
{
TLorentzVector * theEle = (TLorentzVector*) (electrons->At (iele)) ;
lepton dummy (theEle, 0, iele) ;
leptons.push_back (dummy) ;
} //PG loop over electrons
//PG loop over muons
for (int imu = 0 ; imu < nMu ; ++imu)
{
TLorentzVector * theMu = (TLorentzVector*) (muons->At (imu)) ;
lepton dummy (theMu, 1, imu) ;
leptons.push_back (dummy) ;
} //PG loop over muons
//PG this check is not necessary
//PG if (leptons.size () < 2) continue ;
// std::cerr << "--- inizia leptoni " << std::endl;
//PG 2 LEPTONS
//PG ---------
/*
applied after the leptons choice:
in this case it is possible to differentiate the selections depending on the
position of each lepton in the pt-sorting.
the algorithm searches the first two most energetic candidates which satisfy
the ID selections required for the first and second lepton respectively.
Then check for channel analysis according to "g_LepLep"
0 == ee
1 == mumu
2 == emu
3 == mue
pt ordered
*/
sort (leptons.rbegin (), leptons.rend (), lessThan ()) ;
lepton primoLEP ;
lepton secondoLEP ;
double first_lepton_charge = 0;
double second_lepton_charge = 0;
int lepton_counter = 0;
int electron_counter = 0;
int muon_counter = 0;
//PG find the first lepton
int ilep = 0 ;
for ( ; ilep < leptons.size () ; ++ilep)
{
if (leptons.at (ilep).m_flav == 0) //PG electron
{
//PG iso check
bool eleIso = (IsolEleSumPt_VBF[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoElectron ; // 0.2 per il momento
if (g_ISO1[0] == 1 && eleIso != 1) continue;
//PG eleID check
int eleID = EleId[leptons.at (ilep).m_index] ;
if (g_ID1 == 100 && (eleID/100) != 1) continue;
else if (g_ID1 == 10 && ((eleID%100)/10) != 1) continue;
else if (g_ID1 == 1 && (eleID%10) != 1) continue;
first_lepton_charge = EleCharge[leptons.at (ilep).m_index];
}
else //PG muon
{
//PG iso check
bool muIso = (IsolMuTr[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoMuon ;
if (g_ISO1[1] == 1 && muIso != 1) continue;
first_lepton_charge = MuCharge[leptons.at (ilep).m_index];
}
primoLEP = leptons[ilep] ;
lepton_counter++;
if (leptons.at (ilep).m_flav == 0) electron_counter++;
else muon_counter++;
break ;
} //PG find the first lepton
//PG find the second lepton
bool flag_secondoLEP = false;
for (++ilep ; ilep < leptons.size () ; ++ilep)
{
if (leptons.at (ilep).m_flav == 0) //PG electron
{
//PG iso check
bool eleIso = (IsolEleSumPt_VBF[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoElectron ; // 0.2 per il momento
if (g_ISO2[0] == 1 && eleIso != 1) continue;
//PG eleID check
int eleID = EleId[leptons.at (ilep).m_index] ;
if (g_ID2 == 100 && (eleID/100) != 1) continue;
else if (g_ID2 == 10 && ((eleID%100)/10) != 1) continue;
else if (g_ID2 == 1 && (eleID%10) != 1) continue;
second_lepton_charge = EleCharge[leptons.at (ilep).m_index];
}
else //PG muon
{
//PG iso check
bool muIso = (IsolMuTr[leptons.at (ilep).m_index] /
leptons.at (ilep).m_kine->Pt () ) < g_IsoMuon ;
if (g_ISO2[1] == 1 && muIso != 1) continue;
second_lepton_charge = MuCharge[leptons.at (ilep).m_index];
}
if (!flag_secondoLEP) {
secondoLEP = leptons[ilep] ;
flag_secondoLEP = true;
}
if (leptons.at (ilep).m_kine->Pt () > 0) {
if (leptons.at (ilep).m_flav == 0) electron_counter++;
else muon_counter++;
lepton_counter++;
}
} //PG find the second lepton
//---- AM 3 --- 2 leptons after Id
if (primoLEP.m_flav == -1 || secondoLEP.m_flav == -1) continue ;
//---- AM 4 check for the two most transverse-energetic leptons have the right flavours
plots.v_numLep = lepton_counter;
plots.v_numEle = electron_counter;
plots.v_numMu = muon_counter;
if (primoLEP.m_flav == 0 && secondoLEP.m_flav == 0) plots.v_LepLep = 0 ;
if (primoLEP.m_flav == 1 && secondoLEP.m_flav == 1) plots.v_LepLep = 1 ;
if (primoLEP.m_flav == 0 && secondoLEP.m_flav == 1) plots.v_LepLep = 2 ;
if (primoLEP.m_flav == 1 && secondoLEP.m_flav == 0) plots.v_LepLep = 3 ;
plots.v_hardLEPPt = primoLEP.m_kine->Pt () ;
//---- AM 5 pt_min of the most energetic lepton
plots.v_softLEPPt = secondoLEP.m_kine->Pt () ;
//---- AM 6 pt_min of the least energetic lepton
plots.v_LEPDPhi = deltaPhi (primoLEP.m_kine->Phi (), secondoLEP.m_kine->Phi ()) ;
//---- AM 7 Delta_phi_min between leptons
plots.v_LEPDEta = deltaEta (primoLEP.m_kine->Eta (), secondoLEP.m_kine->Eta ()) ;
plots.v_LEPDR = deltaR (primoLEP.m_kine->Phi (),primoLEP.m_kine->Eta (), secondoLEP.m_kine->Phi (), secondoLEP.m_kine->Eta ()) ;
TLorentzVector sumLEP = *(primoLEP.m_kine) + *(secondoLEP.m_kine) ;
plots.v_LEPMinv = sumLEP.M () ;
//---- AM 9 MInv_min of leptons
plots.v_LEPProdCharge = first_lepton_charge * second_lepton_charge ;
plots.v_hardLEPCharge = first_lepton_charge ;
plots.v_softLEPCharge = second_lepton_charge ;
//PG MET
//PG ---
// std::cerr << "--- finito " << std::endl;
TLorentzVector* met = ((TLorentzVector*) (MET->At(0))) ;
//correct for muons
for (int i = 0 ; i < nMu ; i++)
{
TLorentzVector * mu_v = (TLorentzVector*) (muons->At (i)) ;
if (mu_v->Pt () > 3)
{
met->SetPx (met->Px () - mu_v->Px ()) ;
met->SetPy (met->Py () - mu_v->Py ()) ;
}
}
plots.v_MET = met->Pt () ;
//---- AM 11 Met_min ----------------> Met correction ?
// if (((TLorentzVector*) (MET->At (0)))->Pt () < g_METMin) continue ; plots.increase (cutId++) ; //PG 10
//PG Ztautau vetos
//PG -------------
//PG the two electrons should not be opposite to each other
//
// TVector2 primoLEPT (primoLEP.m_kine->X (), primoLEP.m_kine->Y ()) ;
// TVector2 secondoLEPT (secondoLEP.m_kine->X (), secondoLEP.m_kine->Y ()) ;
// TVector2 METT (met->X (), met->Y ()) ;
//
// double Sum = METT * primoLEPT + METT * secondoLEPT / (1 + primoLEPT * secondoLEPT) ;
// double Dif = METT * primoLEPT - METT * secondoLEPT / (1 - primoLEPT * secondoLEPT) ;
//
// TVector2 METT1 = 0.5 * (Sum + Dif) * primoLEPT ;
// TVector2 METT2 = 0.5 * (Sum - Dif) * secondoLEPT ;
//
// double ptNu1 = METT1.Mod () / cos (primoLEP.m_kine->Theta ()) ;
// double ptNu2 = METT2.Mod () / cos (secondoLEP.m_kine->Theta ()) ;
plots.m_tree_selections->Fill();
plots.passedJetAndLepNumberSelections++;
if (plots.v_decay_Channel_e == 2) plots.passedJetAndLepNumberSelections_ee++;
if (plots.v_decay_Channel_mu == 2) plots.passedJetAndLepNumberSelections_mumu++;
if (plots.v_decay_Channel_tau == 2) plots.passedJetAndLepNumberSelections_tautau++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_mu == 1) plots.passedJetAndLepNumberSelections_emu++;
if (plots.v_decay_Channel_e == 1 && plots.v_decay_Channel_tau == 1) plots.passedJetAndLepNumberSelections_etau++;
if (plots.v_decay_Channel_mu == 1 && plots.v_decay_Channel_tau == 1) plots.passedJetAndLepNumberSelections_mutau++;
} //PG loop over the events
plots.m_efficiency->Fill();
plots.m_efficiency->Write();
plots.m_tree_selections->Write();
delete otherJets_temp ;
delete tagJets ;
delete otherJets ;
delete electrons ;
delete muons ;
delete MET ;
delete tracks ;
return 0;
}
// Copied from http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/TopQuarkAnalysis/SingleTop/src/TopProducer.cc?revision=1.9&view=markup
TLorentzVector getNu4Momentum(const TLorentzVector& TLepton, const TLorentzVector& TMET)
{
const math::XYZTLorentzVector Lepton(TLepton.Px(), TLepton.Py(), TLepton.Pz(), TLepton.E());
const math::XYZTLorentzVector MET(TMET.Px(), TMET.Py(), 0., TMET.E());
double mW = 80.38;
//std::vector<math::XYZTLorentzVector> result;
std::vector<TLorentzVector> result;
// double Wmt = sqrt(pow(Lepton.et()+MET.pt(),2) - pow(Lepton.px()+MET.px(),2) - pow(Lepton.py()+MET.py(),2) );
double MisET2 = (MET.px()*MET.px() + MET.py()*MET.py());
double mu = (mW*mW)/2 + MET.px()*Lepton.px() + MET.py()*Lepton.py();
double a = (mu*Lepton.pz())/(Lepton.energy()*Lepton.energy() - Lepton.pz()*Lepton.pz());
double a2 = TMath::Power(a,2);
double b = (TMath::Power(Lepton.energy(),2.)*(MisET2) - TMath::Power(mu,2.))/(TMath::Power(Lepton.energy(),2) - TMath::Power(Lepton.pz(),2));
double pz1(0),pz2(0),pznu(0);
int nNuSol(0);
//math::XYZTLorentzVector p4nu_rec;
TLorentzVector p4nu_rec;
math::XYZTLorentzVector p4W_rec;
math::XYZTLorentzVector p4b_rec;
math::XYZTLorentzVector p4Top_rec;
math::XYZTLorentzVector p4lep_rec;
p4lep_rec.SetPxPyPzE(Lepton.px(),Lepton.py(),Lepton.pz(),Lepton.energy());
//math::XYZTLorentzVector p40_rec(0,0,0,0);
if(a2-b > 0 ){
//if(!usePositiveDeltaSolutions_)
// {
// result.push_back(p40_rec);
// return result;
// }
double root = sqrt(a2-b);
pz1 = a + root;
pz2 = a - root;
nNuSol = 2;
//if(usePzPlusSolutions_)pznu = pz1;
//if(usePzMinusSolutions_)pznu = pz2;
//if(usePzAbsValMinimumSolutions_){
pznu = pz1;
if(fabs(pz1)>fabs(pz2)) pznu = pz2;
//}
double Enu = sqrt(MisET2 + pznu*pznu);
p4nu_rec.SetPxPyPzE(MET.px(), MET.py(), pznu, Enu);
result.push_back(p4nu_rec);
}
else{
//if(!useNegativeDeltaSolutions_){
// result.push_back(p40_rec);
// return result;
//}
// double xprime = sqrt(mW;
double ptlep = Lepton.pt(),pxlep=Lepton.px(),pylep=Lepton.py(),metpx=MET.px(),metpy=MET.py();
double EquationA = 1;
double EquationB = -3*pylep*mW/(ptlep);
double EquationC = mW*mW*(2*pylep*pylep)/(ptlep*ptlep)+mW*mW-4*pxlep*pxlep*pxlep*metpx/(ptlep*ptlep)-4*pxlep*pxlep*pylep*metpy/(ptlep*ptlep);
double EquationD = 4*pxlep*pxlep*mW*metpy/(ptlep)-pylep*mW*mW*mW/ptlep;
std::vector<long double> solutions = EquationSolve<long double>((long double)EquationA,(long double)EquationB,(long double)EquationC,(long double)EquationD);
std::vector<long double> solutions2 = EquationSolve<long double>((long double)EquationA,-(long double)EquationB,(long double)EquationC,-(long double)EquationD);
double deltaMin = 14000*14000;
double zeroValue = -mW*mW/(4*pxlep);
double minPx=0;
double minPy=0;
// std::cout<<"a "<<EquationA << " b " << EquationB <<" c "<< EquationC <<" d "<< EquationD << std::endl;
//if(usePxMinusSolutions_){
for( int i =0; i< (int)solutions.size();++i){
if(solutions[i]<0 ) continue;
double p_x = (solutions[i]*solutions[i]-mW*mW)/(4*pxlep);
double p_y = ( mW*mW*pylep + 2*pxlep*pylep*p_x -mW*ptlep*solutions[i])/(2*pxlep*pxlep);
double Delta2 = (p_x-metpx)*(p_x-metpx)+(p_y-metpy)*(p_y-metpy);
// std::cout<<"intermediate solution1 met x "<<metpx << " min px " << p_x <<" met y "<<metpy <<" min py "<< p_y << std::endl;
if(Delta2< deltaMin && Delta2 > 0){deltaMin = Delta2;
minPx=p_x;
minPy=p_y;}
// std::cout<<"solution1 met x "<<metpx << " min px " << minPx <<" met y "<<metpy <<" min py "<< minPy << std::endl;
}
//}
//if(usePxPlusSolutions_){
for( int i =0; i< (int)solutions2.size();++i){
if(solutions2[i]<0 ) continue;
double p_x = (solutions2[i]*solutions2[i]-mW*mW)/(4*pxlep);
double p_y = ( mW*mW*pylep + 2*pxlep*pylep*p_x +mW*ptlep*solutions2[i])/(2*pxlep*pxlep);
double Delta2 = (p_x-metpx)*(p_x-metpx)+(p_y-metpy)*(p_y-metpy);
// std::cout<<"intermediate solution2 met x "<<metpx << " min px " << minPx <<" met y "<<metpy <<" min py "<< minPy << std::endl;
if(Delta2< deltaMin && Delta2 > 0){deltaMin = Delta2;
minPx=p_x;
minPy=p_y;
}
// std::cout<<"solution2 met x "<<metpx << " min px " << minPx <<" met y "<<metpy <<" min py "<< minPy << std::endl;
}
//}
double pyZeroValue= ( mW*mW*pxlep + 2*pxlep*pylep*zeroValue);
double delta2ZeroValue= (zeroValue-metpx)*(zeroValue-metpx) + (pyZeroValue-metpy)*(pyZeroValue-metpy);
if(deltaMin==14000*14000) return TLorentzVector(0,0,0,0);
//if(deltaMin==14000*14000) return result.front();
// else std::cout << " test " << std::endl;
if(delta2ZeroValue < deltaMin){
deltaMin = delta2ZeroValue;
minPx=zeroValue;
minPy=pyZeroValue;}
// std::cout<<" MtW2 from min py and min px "<< sqrt((minPy*minPy+minPx*minPx))*ptlep*2 -2*(pxlep*minPx + pylep*minPy) <<std::endl;
/// ////Y part
double mu_Minimum = (mW*mW)/2 + minPx*pxlep + minPy*pylep;
double a_Minimum = (mu_Minimum*Lepton.pz())/(Lepton.energy()*Lepton.energy() - Lepton.pz()*Lepton.pz());
pznu = a_Minimum;
//if(!useMetForNegativeSolutions_){
double Enu = sqrt(minPx*minPx+minPy*minPy + pznu*pznu);
p4nu_rec.SetPxPyPzE(minPx, minPy, pznu , Enu);
//}
//else{
// pznu = a;
// double Enu = sqrt(metpx*metpx+metpy*metpy + pznu*pznu);
// p4nu_rec.SetPxPyPzE(metpx, metpy, pznu , Enu);
//}
result.push_back(p4nu_rec);
}
return result.front();
}
Bool_t monojet::Process(Long64_t entry)
{
GetEntry(entry);
if( entry % 100000 == 0 ) cout << "Processing event number: " << entry << endl;
//cout << "Processing event number: " << entry << endl;
// To make the processing fast, apply a very looose selection
if (((TLorentzVector*)((*metP4)[0]))->Pt() < 40. or jetP4->GetEntries() < 1) return kTRUE;
//this is the type tree
tm->SetValue("run",runNum);
tm->SetValue("event",eventNum);
tm->SetValue("lumi",lumiNum);
float dR = 0.;
TClonesArray *tightLep;
TClonesArray *cleanJet;
TClonesArray *cleanTau;
tightLep = new TClonesArray("TLorentzVector",20);
cleanJet = new TClonesArray("TLorentzVector",20);
cleanTau = new TClonesArray("TLorentzVector",20);
std::vector<bool> jetMonojetId_clean;
jetMonojetId_clean.clear();
std::vector<bool> jetMonojetIdLoose_clean;
jetMonojetIdLoose_clean.clear();
//std::vector<float> jetPuId_clean;
//jetPuId_clean.clear();
std::vector<float> tauId_clean;
tauId_clean.clear();
std::vector<float> tauIso_clean;
tauIso_clean.clear();
int n_tightlep = 0;
// ********* Leptons ********** //
for(int lepton = 0; lepton < lepP4->GetEntries(); lepton++) {
TLorentzVector* Lepton = (TLorentzVector*) lepP4->At(lepton);
// check if this is a tight lep, and check the overlap
//iso_1 = divide(input_tree.lepIso[0],input_tree.lepP4[0].Pt())
//if (input_tree.lepTightId[0]==0 or iso_1 > 0.12): continue
if (Lepton->Pt() > 20. && (*lepTightId)[lepton] > 1) {
n_tightlep +=1;
new ( (*tightLep)[tightLep->GetEntriesFast()]) TLorentzVector(Lepton->Px(), Lepton->Py(), Lepton->Pz(), Lepton->Energy());
//check overlap with jets
for(int j = 0; j < jetP4->GetEntries(); j++) {
TLorentzVector* Jet = (TLorentzVector*) jetP4->At(j);
dR = deltaR(Lepton,Jet);
if (dR > dR_cut) {
new ( (*cleanJet)[cleanJet->GetEntriesFast()]) TLorentzVector(Jet->Px(), Jet->Py(), Jet->Pz(), Jet->Energy());
jetMonojetId_clean.push_back((*jetMonojetId)[j]);
jetMonojetIdLoose_clean.push_back((*jetMonojetIdLoose)[j]);
//jetPuId_clean.push_back((*jetPuId)[j]);
}
}
//check overlap with taus
for(int tau = 0; tau < tauP4->GetEntries(); tau++) {
TLorentzVector* Tau = (TLorentzVector*) tauP4->At(tau);
dR = deltaR(Lepton,Tau);
if (dR > dR_cut) new ( (*cleanTau)[cleanTau->GetEntriesFast()]) TLorentzVector(Tau->Px(), Tau->Py(), Tau->Pz(), Tau->Energy());
tauId_clean.push_back((*tauId)[tau]);
tauIso_clean.push_back((*tauIso)[tau]);
} // tau overlap
} // tight lepton selection
}//lepton loop
tm->SetValue("n_tightlep",n_tightlep);
TLorentzVector fakeMET;
// Z Selection
TLorentzVector Z;
if(lepP4->GetEntries() == 2 && n_tightlep > 0) {
if (((*lepPdgId)[0]+(*lepPdgId)[1])==0 ) {
Z = *((TLorentzVector*)((*lepP4)[0])) + *((TLorentzVector*)((*lepP4)[1]));
fakeMET = *((TLorentzVector*)((*metP4)[0])) + Z;
}
}
float MT = 0.0;
//// W Selection
if(lepP4->GetEntries() == 1 && n_tightlep == 1) {
fakeMET = *((TLorentzVector*)((*metP4)[0])) + *((TLorentzVector*)((*lepP4)[0])) ;
MT = transverseMass( ((TLorentzVector*)((*lepP4)[0]))->Pt(), ((TLorentzVector*)((*lepP4)[0]))->Phi(), ((TLorentzVector*)((*metP4)[0]))->Pt(), ((TLorentzVector*)((*metP4)[0]))->Phi());
}
tm->SetValue("mt",MT);
// ********* Jets ********** //
for(int jet = 0; jet < jetP4->GetEntries(); jet++) {
TLorentzVector* Jet = (TLorentzVector*) jetP4->At(jet);
//cout << (*jetMonojetId)[0] <<endl;
//cout << Jet->Pt()<<endl;
}
// ********* Met ********** //
// Here try to save all possible met variables
// and the recoil vectors (for Z and Photon)
TLorentzVector Recoil(-9999.,-9999.,-9999.,-9999);
float uPar = -9999. ;
float uPerp = -9999.;
if(Z.Pt() > 0) {
Recoil = *((TLorentzVector*)((*metP4)[0])) + Z;
Recoil.RotateZ(TMath::Pi());
Recoil.RotateZ(-Z.Phi());
if (Z.Phi() > TMath::Pi()) uPar = Recoil.Px() - Z.Pt() ;
else uPar = Recoil.Px() + Z.Pt();
uPerp = Recoil.Py();
}
tm->SetValue("uperp",uPerp);
tm->SetValue("upar",uPar);
// Decide on the type of the event and fill the
// type tree
int type_event = -1;
// forcing all regions to be orthogonal wrt to each other
if (((TLorentzVector*)((*metP4)[0]))->Pt() > 100. &&
jetP4->GetEntries() > 0 && lepP4->GetEntries() == 0) type_event=0;
if (lepP4->GetEntriesFast() == 1) type_event=1; //&& (*lepTightId)[0] == 1) type_event=1;
if (lepP4->GetEntriesFast() == 2) type_event=2; //&& ((*lepTightId)[0] == 1 || (*lepTightId)[1] == 1 )) type_event=2;
if ( lepP4->GetEntriesFast() == 2 && type_event!=2 ) std::cout << "WTF??" << std::endl;
tm->SetValue("event_type",type_event);
// Now replace all the needed collections based
// on the type
if (type_event ==1 || type_event==2)
{
jetP4 = cleanJet;
tauP4 = cleanTau;
*jetMonojetId = jetMonojetId_clean;
*jetMonojetIdLoose = jetMonojetIdLoose_clean;
//*jetPuId = jetPuId_clean;
*tauId = tauId_clean;
*tauIso = tauIso_clean;
*(TLorentzVector*)((*metP4)[0]) = fakeMET;
}
// final skim
if(((TLorentzVector*)((*metP4)[0]))->Pt() < 100.) return kTRUE;
//re-write the mc weight content to be +1 or -1
if(mcWeight < 0) mcWeight = -1.0;
if(mcWeight > 0) mcWeight = 1.0;
// and fill both trees;
tm ->TreeFill();
eventstree->Fill();
return kTRUE;
}
