/*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;
}
//___________________[ 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;
}
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;
}
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);
}
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.;
}
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());
}
///------------------------------------------------------------------------
/// 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 );
}
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;
}
void AnalyseParticles(LHEF::Reader *reader, ExRootTreeBranch *branch)
{
const LHEF::HEPEUP &hepeup = reader->hepeup;
Int_t particle;
Double_t signPz, cosTheta;
TLorentzVector momentum;
TRootLHEFParticle *element;
for(particle = 0; particle < hepeup.NUP; ++particle)
{
element = (TRootLHEFParticle*) branch->NewEntry();
element->PID = hepeup.IDUP[particle];
element->Status = hepeup.ISTUP[particle];
element->Mother1 = hepeup.MOTHUP[particle].first;
element->Mother2 = hepeup.MOTHUP[particle].second;
element->ColorLine1 = hepeup.ICOLUP[particle].first;
element->ColorLine2 = hepeup.ICOLUP[particle].second;
element->Px = hepeup.PUP[particle][0];
element->Py = hepeup.PUP[particle][1];
element->Pz = hepeup.PUP[particle][2];
element->E = hepeup.PUP[particle][3];
element->M = hepeup.PUP[particle][4];
momentum.SetPxPyPzE(element->Px, element->Py, element->Pz, element->E);
cosTheta = TMath::Abs(momentum.CosTheta());
signPz = (momentum.Pz() >= 0.0) ? 1.0 : -1.0;
element->PT = momentum.Perp();
element->Eta = (cosTheta == 1.0 ? signPz*999.9 : momentum.Eta());
element->Phi = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
element->Rapidity = (cosTheta == 1.0 ? signPz*999.9 : momentum.Rapidity());
element->LifeTime = hepeup.VTIMUP[particle];
element->Spin = hepeup.SPINUP[particle];
}
}
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 xAna::HggTreeWriteLoop(const char* filename, int ijob,
bool correctVertex, bool correctEnergy,
bool setRho0
) {
//bool invDRtoTrk = false;
if( _config == 0 ) {
cout << " config file was not set properly... bail out" << endl;
return -1;
}
if (fChain == 0) return -1;
Long64_t nentries = fChain->GetEntriesFast();
// nentries = 10000;
cout << "nentries: " << nentries << endl;
Long64_t entry_start = ijob *_config->nEvtsPerJob();
Long64_t entry_stop = (ijob+1)*_config->nEvtsPerJob();
if( _config->nEvtsPerJob() < 0 ) {
entry_stop = nentries;
}
if( entry_stop > nentries ) entry_stop = nentries;
cout << " *** doing entries from: " << entry_start << " -> " << entry_stop << endl;
if( entry_start > entry_stop ) return -1;
EnergyScaleReader enScaleSkimEOS; /// skim EOS bugged so need to undo the energy scale in the skim
EnergyScaleReader enScale;
// enScaleSkimEOS.setup( "ecalCalibFiles/EnergyScale2012_Lisbon_9fb.txt" );
enScale.setup( _config->energyScaleFile() );
Float_t HiggsMCMass = _weight_manager->getCrossSection()->getHiggsMass();
Float_t HiggsMCPt = -1;
bool isHiggsSignal = false;
if( HiggsMCMass > 0 ) isHiggsSignal = true;
mode_ = _weight_manager->getCrossSection()->mode();
isData = false;
if(mode_==-1) isData = true;
// mode_ = ijob; //
DoCorrectVertex_ = correctVertex;
DoCorrectEnergy_ = correctEnergy;
DoSetRho0_ = setRho0;
doJetRegression = _config->getDoJetRegression();
doControlSample = _config->getDoControlSample();
phoID_2011[0] = new TMVA::Reader("!Color:Silent");
phoID_2011[1] = new TMVA::Reader("!Color:Silent");
phoID_2012[0] = new TMVA::Reader("!Color:Silent");
phoID_2012[1] = new TMVA::Reader("!Color:Silent");
DiscriDiPho_2011 = new TMVA::Reader("!Color:Silent");
DiscriDiPho_2012 = new TMVA::Reader("!Color:Silent");
if(doJetRegression!=0) jetRegres = new TMVA::Reader("!Color:Silent");
Setup_MVA();
if( _config->setup() == "ReReco2011" ) for( int i = 0 ; i < 2; i++ ) phoID_mva[i] = phoID_2011[i];
else for( int i = 0 ; i < 2; i++ ) phoID_mva[i] = phoID_2012[i];
MassResolution massResoCalc;
massResoCalc.addSmearingTerm();
if( _config->setup() == "ReReco2011" ) Ddipho_mva = DiscriDiPho_2011;
else Ddipho_mva = DiscriDiPho_2012;
float Ddipho_cat[5]; Ddipho_cat[4] = -1;
if( _config->setup() == "ReReco2011" ) { Ddipho_cat[0] = 0.89; Ddipho_cat[1] = 0.72; Ddipho_cat[2] = 0.55; Ddipho_cat[3] = +0.05; }
else { Ddipho_cat[0] = 0.91; Ddipho_cat[1] = 0.79; Ddipho_cat[2] = 0.49; Ddipho_cat[3] = -0.05; }
// else { Ddipho_cat[0] = 0.88; Ddipho_cat[1] = 0.71; Ddipho_cat[2] = 0.50; Ddipho_cat[3] = -0.05; }
DiscriVBF_UseDiPhoPt = true;
DiscriVBF_UsePhoPt = true;
DiscriVBF_cat.resize(2); DiscriVBF_cat[0] = 0.985; DiscriVBF_cat[1] = 0.93;
DiscriVBF_useMvaSel = _config->doVBFmvaCat();
/// depending on the selection veto or not on electrons (can do muele, elemu,eleele)
bool vetoElec[2] = {true,true};
if( _config->invertElectronVeto() ) { vetoElec[0] = false; vetoElec[1] = false; }
if( _config->isEleGamma() ) { vetoElec[0] = false; vetoElec[1] = true ; }
if( _config->isGammaEle() ) { vetoElec[0] = true ; vetoElec[1] = false; }
cout << " --------- veto electron config -----------" << endl;
cout << " Leading Pho VetoElec: " << vetoElec[0] << endl;
cout << " Trailing Pho VetoElec: " << vetoElec[1] << endl;
DoDebugEvent = true;
bool DoPreselection = true;
// bool DoPrint = true;
TString VertexFileNamePrefix;
TRandom3 *rnd = new TRandom3();
rnd->SetSeed(0);
/// output tree and cross check file
_xcheckTextFile.open(TString(filename)+".xcheck.txt");
// _xcheckTextFile = cout;
_minitree = new MiniTree( filename );
TTree * tSkim = 0;
if( _config->doSkimming() ) tSkim = (TTree*) fChain->CloneTree(0);
InitHists();
_minitree->mc_wXsec = _weight_manager->xSecW();
_minitree->mc_wNgen = 100000./_weight_manager->getNevts();
if( isData ) {
_minitree->mc_wXsec = 1;
_minitree->mc_wNgen = 1;
}
Int_t isprompt0 = -1;
Int_t isprompt1 = -1;
set<Long64_t> syncEvt;
cout <<" ================ mode " << mode_ <<" =============================== "<<endl;
/// setupType has to be passed via config file
// photonOverSmearing overSmearICHEP("Test52_ichep");
photonOverSmearing overSmearHCP( "oversmear_hcp2012" );
photonOverSmearing overSmear( _config->setup() );
int overSmearSyst = _config->getEnergyOverSmearingSyst();
Long64_t nbytes = 0, nb = 0;
////////////////////////////////////////////////////////////////////////////
//////////////////////////// Start the loop ////////////////////////////////
////////////////////////////////////////////////////////////////////////////
vector<int> nEvts;
vector<string> nCutName;
nCutName.push_back("TOTAL :"); nEvts.push_back(0);
nCutName.push_back("2 gammas :"); nEvts.push_back(0);
nCutName.push_back("triggers :"); nEvts.push_back(0);
nCutName.push_back("nan weight :"); nEvts.push_back(0);
nCutName.push_back("presel kin cuts:"); nEvts.push_back(0);
nCutName.push_back("pass 2 gam incl:"); nEvts.push_back(0);
nCutName.push_back("pass all :"); nEvts.push_back(0);
nCutName.push_back(" --> pass 2 gam lep: "); nEvts.push_back(0);
nCutName.push_back(" --> pass 2 gam vbf: "); nEvts.push_back(0);
vector<int> selVtxSumPt2(3); selVtxSumPt2[0] = 0; selVtxSumPt2[1] = -1; selVtxSumPt2[2] = -1;
for (Long64_t jentry=entry_start; jentry< entry_stop ; ++jentry) {
Long64_t ientry = LoadTree(jentry);
if (ientry < -9999) break;
if( jentry % 10000 == 0) cout<<"processing event "<<jentry<<endl;
nb = fChain->GetEntry(jentry); nbytes += nb;
/// reset minitree variables
_minitree->initEvent();
// study mc truth block
if( !isData ) {
fillMCtruthInfo_HiggsSignal();
_minitree->fillMCtrueOnly();
}
/// reco analysis
unsigned icutlevel = 0;
nEvts[icutlevel++]++;
if( nPho < 2 ) continue;
nEvts[icutlevel++]++;
/// set synchronisation flag
if( syncEvt.find(event) != syncEvt.end() ) DoDebugEvent = true;
else DoDebugEvent = false;
if( DoDebugEvent ) _xcheckTextFile << "==========================================================" << endl;
if( DoDebugEvent ) _xcheckTextFile << "================= debugging event: " << event << endl;
/// PU & BSz reweightings
if( !isData ) {
int itpu = 1; /// 0 without OOT PU - 1 with OOT PU
_minitree->mc_wPU = _weight_manager->puW( nPU[itpu] );
// PUwei = _weight_manager->puWTrue( puTrue[itpu] );
}
hTotEvents->Fill(1,_minitree->mc_wPU);
bool sigWH = false ;
bool sigZH = false ;
int mc_whzh_type = 0;
_minitree->mc_wHQT = 1;
if( isHiggsSignal ) {
if ( _weight_manager->getCrossSection()->getMCType() == "vh" )
for( Int_t i=0; i < nMC && i <= 1; ++i ) {
if( abs(mcPID[i]) == 24 ) sigWH=true;
if( abs(mcPID[i]) == 23 ) sigZH=true;
}
if( sigWH ) mc_whzh_type = 1;
if( sigZH ) mc_whzh_type = 2;
for( Int_t i=0; i<nMC; ++i)
if ( abs(mcPID[i]) == 25 ) HiggsMCPt = mcPt[i];
if( _weight_manager->getCrossSection()->getMCType() == "ggh" &&
_config->setup().find( "ReReco2011" ) != string::npos )
_minitree->mc_wHQT = getHqTWeight(HiggsMCMass, HiggsMCPt);
}
if ((mode_ == 2 || mode_ ==1 || mode_ == 18 || mode_ == 19) && processID==18) continue;
// Remove double counting in gamma+jets and QCDjets
Int_t mcIFSR_pho = 0;
Int_t mcPartonic_pho = 0;
if (mode_ == 1 || mode_ == 2 || mode_ == 3 || mode_ == 18 || mode_ == 19 ) {
for (Int_t i=0; i<nMC; ++i) {
if (mcPID[i] == 22 && (fabs(mcMomPID[i]) < 6 || mcMomPID[i] == 21)) mcIFSR_pho++;
if (mcPID[i] == 22 && mcMomPID[i] == 22) mcPartonic_pho++;
}
}
// if pythia is used for diphoton.. no IFSR removing from QCD and Gjets!!!!!!
if ((mode_==1 || mode_ == 2 || mode_ == 18 ) && mcIFSR_pho >= 1 && mcPartonic_pho >=1) continue;
if ((mode_ == 3 || mode_ == 19 )&& mcIFSR_pho == 2) continue;
bool prompt2= false;
bool prompt1= false;
bool prompt0= false;
vertProb = -1;
if (mode_ == 2 || mode_ == 1 || mode_ == 18 ){
if ( mcPartonic_pho >= 1 && mcIFSR_pho >= 1 ) prompt2 = true;
else if ( mcPartonic_pho >= 1 && mcIFSR_pho == 0 ) prompt1 = true;
else if ( mcPartonic_pho == 0 && mcIFSR_pho == 0 ) prompt0 = true;
} else if(mode_ == 3 || mode_ == 19 ){
if ( mcIFSR_pho >= 2 ) prompt2 = true;
else if ( mcIFSR_pho == 1 ) prompt1 = true;
else if ( mcIFSR_pho == 0 ) prompt0 = true;
if( prompt1 ) _minitree->mc_wXsec = 1.3*_weight_manager->xSecW();
}
if(mode_==1 || mode_==2 || mode_==3 || mode_==18 || mode_==19){
if(prompt0)isprompt0=1;
else isprompt0=0;
if(prompt1)isprompt1=1;
else isprompt1=0;
}
if( mode_ == 20 && isZgamma() ) continue;
/// wei weight is just temporary and may not contain all info.
float wei = _minitree->mc_wXsec * _minitree->mc_wPU
* _minitree->mc_wNgen * _minitree->mc_wHQT;
if( isData && !PassTriggerSelection() ) continue; nEvts[icutlevel++]++;
if( std::isinf( wei ) || std::isnan( wei ) )continue; nEvts[icutlevel++]++;
//// ********************* define S4 variable **********************////
for( int i=0; i<nPho; ++i){
if( _config->setup() == "ReReco2011" ) phoS4ratio[i] = 1;
else phoS4ratio[i] = phoE2x2[i] / phoE5x5[i];
}
//// ************************************************************* ////
if( !isData ) {
//// ************** MC corrections (mostly MC) ******************* ////
// 1. energy shifting / smearing
for( int i=0; i<nPho; ++i)
if( fabs(phoSCEta[i]) <= 2.5 ) {
float smearing = overSmear.randOverSmearing(phoSCEta[i],phoR9[i],isInGAP_EB(i),overSmearSyst);
phoRegrE[i] *= (1 + smearing);
phoE[i] *= (1 + smearing);
/// from MassFactorized in gglobe: energyCorrectedError[ipho] *=(l.pho_isEB[ipho]) ? 1.07 : 1.045 ;
float smearFactor = 1;
if( _config->setup() == "ReReco2011" ) smearFactor = fabs(phoSCEta[i]) < 1.45 ? 1.07: 1.045;
phoRegrErr[i] *= smearFactor;
}
// 2. reweighting of photon id variables (R9...)
for (int i=0; i<nPho; ++i) ReweightMC_phoIdVar(i);
//// ************************************************************* ////
}
//// ********** Apply regression energy ************* ////
float phoStdE[500];
for( int i=0; i<nPho; ++i)
if( fabs(phoSCEta[i]) <= 2.5 ) {
if( isData ){
float enCorrSkim = 1;//enScaleSkimEOS.energyScale( phoR9[i], phoSCEta[i], run);
float phoEnScale = enScale.energyScale( phoR9[i], phoSCEta[i], run)/enCorrSkim;
phoRegrE[i] *= phoEnScale;
phoE[i] *= phoEnScale;
}
phoStdE[i] = phoE[i];
phoE[i] = phoRegrE[i];
/// transform calo position abd etaVtx, phiVtx with SC position
for( int x = 0 ; x < 3; x++ ) phoCaloPos[i][x] = phoSCPos[i][x];
for( int ivtx = 0 ; ivtx < nVtxBS; ivtx++ ) {
TVector3 xxi = getCorPhotonTVector3(i,ivtx);
phoEtaVtx[i][ivtx] = xxi.Eta();
phoPhiVtx[i][ivtx] = xxi.Phi();
}
/// additionnal smearing to go to data energy resolution
phoRegrSmear[i] = phoE[i]*overSmearHCP.meanOverSmearing(phoSCEta[i],phoR9[i],isInGAP_EB(i),0);
phoEt[i] = phoE[i] / cosh(phoEta[i]);
}
//// ************************************************* ////
/// lepton selection
int iElecVtx(-1), iMuonVtx(-1);
vector<int> elecIndex = selectElectronsHCP2012( wei, iElecVtx );
vector<int> muonIndex = selectMuonsHCP2012( wei, iMuonVtx );
vector<int> event_vtx;
vector<int> event_ilead ;
vector<int> event_itrail;
vector<TLorentzVector> event_plead ;
vector<TLorentzVector> event_ptrail;
TLorentzVector leptag;
int lepCat = -1;
bool exitLoop = false;
for( int ii = 0 ; ii < nPho ; ++ii ) {
for( int jj = (ii+1); jj < nPho ; ++jj ) {
// Preselection 2nd leg
if (DoPreselection && !preselectPhoton(ii,phoEt[ii])) continue;
if (DoPreselection && !preselectPhoton(jj,phoEt[jj])) continue;
/// define i, j locally, so when they are inverted this does not mess up the loop
int i = ii;
int j = jj;
if(phoEt[j] > phoEt[i]){ i = jj; j = ii; }
// Select vertex
int selVtx = 0;
TLorentzVector gi,gj;
double mij(-1);
vector<int> selVtxIncl;
if(_config->vtxSelType()==0)
selVtxIncl = getSelectedVertex(i,j,true,true );
else //use sumpt2 ranking
selVtxIncl = selVtxSumPt2;
selVtx = selVtxIncl[0];
if( selVtx < 0 ) continue;
/// check lepton tag
if( muonIndex.size() > 0 ) {
//selVtx = iMuonVtx;
leptag.SetPtEtaPhiM( muPt[muonIndex[0]], muEta[muonIndex[0]], muPhi[muonIndex[0]],0);
if( selectTwoPhotons(i,j,selVtx,gi,gj,vetoElec) ) {
lepCat = 0;
}
}
/// check electron tag only if muon tag failed
if( elecIndex.size() > 0 && lepCat == -1 ) {
//selVtx = iElecVtx;
leptag.SetPtEtaPhiM( elePt[elecIndex[0]], eleEta[elecIndex[0]], elePhi[elecIndex[0]],0);
if( selectTwoPhotons(i,j,selVtx,gi,gj,vetoElec) ) {
lepCat = 1;
if( fabs( (leptag+gi).M() - 91.19 ) < 10 || fabs( (leptag+gj).M() - 91.19 ) < 10 ) lepCat = -1;
/// this is not actually the cut, but it should be but ok (dR(pho,eleTrk) > 1 no dR(pho,anyTrk) > 1 )
if(phoCiCdRtoTrk[i] < 1 || phoCiCdRtoTrk[j] <1 ) lepCat = -1;
}
}
if( lepCat >= 0 ) {
mij = (gi+gj).M();
if( _config->analysisType() == "MVA" )
if( gi.Pt() / mij < 45./120. || gj.Pt() / mij < 30./120. ) lepCat = -1;
if( _config->analysisType() == "baselineCiC4PF" )
if( gi.Pt() / mij < 45./120. || gj.Pt() < 25. ) lepCat = -1;
if( leptag.DeltaR(gi) < 1.0 || leptag.DeltaR(gj) < 1.0 ) lepCat = -1;
}
if( lepCat >= 0 ) {
cout << " ****** keep leptag event pts[photons] i: " << i << " j: " << j << " -> event: " << ientry << endl;
cout << " leptonCat: " << lepCat << endl;
/// if one pair passes lepton tag then no need to go further
/// fill in variables
event_vtx.resize( 1); event_vtx[0] = selVtx;
event_ilead.resize( 1); event_ilead[0] = i;
event_itrail.resize(1); event_itrail[0] = j;
event_plead.resize( 1); event_plead[0] = gi;
event_ptrail.resize(1); event_ptrail[0] = gj;
exitLoop = true;
break;
} else {
/// inclusive + VBF + MetTag preselection
/// apply kinematic cuts
if( !selectTwoPhotons(i,j,selVtx,gi,gj,vetoElec) ) continue;
/// drop photon pt cuts from inclusive cuts (add them in categorisation only)
mij = (gi+gj).M();
if( ! _config->doSkimming() &&
( gi.Pt() < _config->pt1Cut() || gi.Pt() < _config->pt2Cut() ||
gi.Pt()/mij < _config->loosePt1MCut() ||
gj.Pt()/mij < _config->loosePt2MCut() ) ) continue;
}
/// here i = lead; j = trail (selectTwoPhotons does that)
/// fill in variables
event_vtx.push_back( selVtx );
event_ilead.push_back( i );
event_itrail.push_back( j );
event_plead.push_back( gi );
event_ptrail.push_back( gj );
}
if( exitLoop ) break;
}
if(event_ilead.size()==0 || event_itrail.size()==0)continue;
if(event_vtx.size() == 0 ) continue; // no pairs selected
nEvts[icutlevel++]++;
// Now decide which photon-photon pair in the event to select
// for lepton tag (size of arrays is 1, so dummy selection)
unsigned int selectedPair = 0;
float sumEt = -1;
for (unsigned int p=0; p < event_vtx.size(); p++) {
float tempSumEt = event_plead[p].Pt() + event_ptrail[p].Pt();
if( tempSumEt > sumEt) {
sumEt = tempSumEt;
selectedPair = p;
}
}
int ilead = event_ilead[ selectedPair ];
int itrail = event_itrail[ selectedPair ];
int selVtx = event_vtx[ selectedPair ];
TLorentzVector glead = event_plead[selectedPair];
TLorentzVector gtrail = event_ptrail[selectedPair];
TLorentzVector hcand = glead + gtrail;
int CAT4 = cat4(phoR9[ilead], phoR9[itrail], phoSCEta[ilead], phoSCEta[itrail]);
if( glead.Pt() < _config->pt1Cut() ) continue;
if( gtrail.Pt() < _config->pt2Cut() ) continue;
if( hcand.M() < _config->mggCut() ) continue;
nEvts[icutlevel++]++;
_minitree->mtree_runNum = run;
_minitree->mtree_evtNum = event;
_minitree->mtree_lumiSec = lumis;
// TLorentzVector g1,g2;
// g1.SetPtEtaPhiM(phoE[ilead ]/cosh(phoEta[ilead]),phoEta[ilead ], phoPhi[ilead ], 0);
// g2.SetPtEtaPhiM(phoE[itrail]/cosh(phoEta[ilead]),phoEta[itrail], phoPhi[itrail], 0);
// TLorentzVector lgg = g1 + g2;
//_minitree->mtree_massDefVtx = lgg.M();
_minitree->mtree_massDefVtx = hcand.M()/sqrt(phoE[ilead]*phoE[itrail])*sqrt(phoStdE[ilead]*phoStdE[itrail]);
// calc again vertex to get correct vertex probability (can be different from last one in loop)
vector<int> sortedVertex;
if(_config->vtxSelType()==0)
sortedVertex = getSelectedVertex( ilead, itrail, true, true );
else //use sumpt2 ranking
sortedVertex = selVtxSumPt2;
if( sortedVertex.size() < 2 ) sortedVertex.push_back(-1);
if( sortedVertex.size() < 3 ) sortedVertex.push_back(-1);
if( lepCat >= 0 ) {
/// lepton tag
sortedVertex[0] = selVtx;
sortedVertex[1] = -1;
sortedVertex[2] = -1;
// vertProb = 1;
}
_minitree->mtree_rho = rho2012;
_minitree->mtree_rho25 = rho25;
_minitree->mtree_zVtx = vtxbs[selVtx][2];
_minitree->mtree_nVtx = nVtxBS;
_minitree->mtree_ivtx1 = selVtx;
_minitree->mtree_ivtx2 = sortedVertex[1];
_minitree->mtree_ivtx3 = sortedVertex[2];
_minitree->mtree_vtxProb = vertProb;
_minitree->mtree_vtxMva = vertMVA;
_minitree->mtree_mass = hcand.M();
_minitree->mtree_pt = hcand.Pt();
_minitree->mtree_piT = hcand.Pt()/hcand.M();
_minitree->mtree_y = hcand.Rapidity();
/// spin variables
TLorentzVector gtmp1 = glead; gtmp1.Boost( -hcand.BoostVector() );
TLorentzVector gtmp2 = gtrail; gtmp2.Boost( -hcand.BoostVector() );
_minitree->mtree_cThetaLead_heli = cos( gtmp1.Angle(hcand.BoostVector()) );
_minitree->mtree_cThetaTrail_heli = cos( gtmp2.Angle(hcand.BoostVector()) );
_minitree->mtree_cThetaStar_CS = 2*(glead.E()*gtrail.Pz() - gtrail.E()*glead.Pz())/(hcand.M()*sqrt(hcand.M2()+hcand.Pt()*hcand.Pt()));
/// fill photon id variables in main tree
_minitree->mtree_minR9 = +999;
_minitree->mtree_minPhoIdEB = +999;
_minitree->mtree_minPhoIdEE = +999;
_minitree->mtree_maxSCEta = -1;
_minitree->mtree_minSCEta = +999;
for( int i = 0 ; i < 2; i++ ) {
int ipho = -1;
if( i == 0 ) ipho = ilead;
if( i == 1 ) ipho = itrail;
fillPhotonVariablesToMiniTree( ipho, selVtx, i );
if( _minitree->mtree_r9[i] < _minitree->mtree_minR9 ) _minitree->mtree_minR9 = _minitree->mtree_r9[i];
if( fabs( _minitree->mtree_sceta[i] ) < 1.5 && _minitree->mtree_mvaid[i] < _minitree->mtree_minPhoIdEB ) _minitree->mtree_minPhoIdEB = _minitree->mtree_mvaid[i];
if( fabs( _minitree->mtree_sceta[i] ) >= 1.5 && _minitree->mtree_mvaid[i] < _minitree->mtree_minPhoIdEE ) _minitree->mtree_minPhoIdEE = _minitree->mtree_mvaid[i];
if( fabs( _minitree->mtree_sceta[i] ) > _minitree->mtree_maxSCEta ) _minitree->mtree_maxSCEta = fabs(_minitree->mtree_sceta[i]);
if( fabs( _minitree->mtree_sceta[i] ) < _minitree->mtree_minSCEta ) _minitree->mtree_minSCEta = fabs(_minitree->mtree_sceta[i]);
}
//------------ compute diphoton mva (add var to minitree inside function) ----------------//
massResoCalc.setP4CalPosVtxResoSmear( glead,gtrail,
TVector3(phoCaloPos[ilead ][0], phoCaloPos[ilead ][1],phoCaloPos[ilead ][2]),
TVector3(phoCaloPos[itrail][0], phoCaloPos[itrail][1],phoCaloPos[itrail][2]),
TVector3(vtxbs[selVtx][0], vtxbs[selVtx][1], vtxbs[selVtx][2]),
_minitree->mtree_relResOverE, _minitree->mtree_relSmearing );
_minitree->mtree_massResoTot = massResoCalc.relativeMassResolutionFab_total( vertProb );
_minitree->mtree_massResoEng = massResoCalc.relativeMassResolutionFab_energy( );
_minitree->mtree_massResoAng = massResoCalc.relativeMassResolutionFab_angular();
float diphotonmva = DiPhoID_MVA( glead, gtrail, hcand, massResoCalc, vertProb,
_minitree->mtree_mvaid[0],_minitree->mtree_mvaid[1] );
// ---- Start categorisation ---- //
_minitree->mtree_lepTag = 0;
_minitree->mtree_metTag = 0;
_minitree->mtree_vbfTag = 0;
_minitree->mtree_hvjjTag = 0;
// 1. lepton tag
if( lepCat >= 0 ) {
_minitree->mtree_lepTag = 1;
_minitree->mtree_lepCat = lepCat;
_minitree->mtree_fillLepTree = true;
// if( lepCat == 0 ) fillMuonTagVariables(lepTag,glead,gtrail,elecIndex[0],selVtx);
// if( lepCat == 1 ) fillElecTagVariables(lepTag,glead,gtrail,muonIndex[0],selVtx);
}
// 3. met tag (For the jet energy regression, MET needs to be corrected first.)
_minitree->mtree_rawMet = recoPfMET;
_minitree->mtree_rawMetPhi = recoPfMETPhi;
// if( !isData ) {
/// bug in data skim, met correction already applied
//3.1 Soft Jet correction (FC?)
applyJEC4SoftJets();
//3.2 smearing
if( !isData ) METSmearCorrection(ilead, itrail);
//3.3 shifting (even in data? but different in data and MC)
METPhiShiftCorrection();
//3.4 scaling
if( isData) METScaleCorrection(ilead, itrail);
// }
_minitree->mtree_corMet = recoPfMET;
_minitree->mtree_corMetPhi = recoPfMETPhi;
// 2. dijet tag
Int_t nVtxJetID = -1;
if( _config->doPUJetID() ) nVtxJetID = nVtxBS;
//vector<int> goodJetsIndex = selectJets( ilead, itrail, nVtxJetID, wei, selVtx );
vector<int> goodJetsIndex = selectJetsJEC( ilead, itrail, nVtxJetID, wei, selVtx );
int vbftag(-1),hstratag(-1),catjet(-1);
dijetSelection( glead, gtrail, goodJetsIndex, wei, selVtx, vbftag, hstratag, catjet);
_minitree->mtree_vbfTag = vbftag;
_minitree->mtree_hvjjTag = hstratag;
_minitree->mtree_vbfCat = catjet;
// 2x. radion analysis
// take the very same photon candidates as in the H->GG analysis above
_minitree->radion_evtNum = event;
*(_minitree->radion_gamma1) = glead;
*(_minitree->radion_gamma2) = gtrail;
vector<int> goodJetsIndexRadion = selectJetsRadion(nVtxJetID, selVtx);
_minitree->radion_bJetTags->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_genJetPt ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_eta ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_cef ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_nef ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_mef ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_nconstituents ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_chf ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_JECUnc ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_ptLeadTrack ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_vtxPt ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_vtx3dL ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_SoftLeptPtCut ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_dPhiMETJet ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_nch ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_vtx3deL ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_vtxMass ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_ptRaw ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_EnRaw ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_SoftLeptptRelCut->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_SoftLeptdRCut ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_partonID ->Set(goodJetsIndexRadion.size());
_minitree->radion_jet_dRJetGenJet ->Set(goodJetsIndexRadion.size());
_minitree->radion_MET = recoPfMET;
_minitree->radion_rho25 = rho25;
for (unsigned i = 0; i < goodJetsIndexRadion.size(); i++) {
int iJet = goodJetsIndexRadion[i];
//_minitree->radion_bJetTags->AddAt(jetCombinedSecondaryVtxMVABJetTags[iJet], i);
_minitree->radion_bJetTags->AddAt(jetCombinedSecondaryVtxBJetTags[iJet], i);
_minitree->radion_jet_genJetPt ->AddAt(jetGenJetPt[iJet], i);
_minitree->radion_jet_eta ->AddAt(jetEta[iJet], i);
_minitree->radion_jet_cef ->AddAt(jetCEF[iJet], i);
_minitree->radion_jet_nef ->AddAt(jetNEF[iJet], i);
_minitree->radion_jet_mef ->AddAt(jetMEF[iJet], i);
_minitree->radion_jet_nconstituents ->AddAt(jetNConstituents[iJet], i);
_minitree->radion_jet_chf ->AddAt(jetCHF[iJet], i);
_minitree->radion_jet_JECUnc ->AddAt(jetJECUnc[iJet], i);
_minitree->radion_jet_ptLeadTrack ->AddAt(jetLeadTrackPt[iJet], i);
_minitree->radion_jet_vtxPt ->AddAt(jetVtxPt[iJet], i);
_minitree->radion_jet_vtx3dL ->AddAt(jetVtx3dL[iJet], i);
_minitree->radion_jet_SoftLeptPtCut ->AddAt(jetSoftLeptPt[iJet], i);
_minitree->radion_jet_nch ->AddAt(jetNCH[iJet], i);
_minitree->radion_jet_vtx3deL ->AddAt(jetVtx3deL[iJet], i);
_minitree->radion_jet_vtxMass ->AddAt(jetVtxMass[iJet], i);
_minitree->radion_jet_ptRaw ->AddAt(jetRawPt[iJet], i);
_minitree->radion_jet_EnRaw ->AddAt(jetRawEn[iJet], i);
_minitree->radion_jet_SoftLeptptRelCut ->AddAt(jetSoftLeptPtRel[iJet], i);
_minitree->radion_jet_SoftLeptdRCut ->AddAt(jetSoftLeptdR[iJet], i);
_minitree->radion_jet_partonID ->AddAt(jetPartonID[iJet], i);
_minitree->radion_jet_dRJetGenJet ->AddAt(sqrt(pow(jetEta[iJet]-jetGenEta[iJet],2)+pow(jetPhi[iJet]-jetGenPhi[iJet],2)), i);
float tmpPi = 3.1415927, tmpDPhi=fabs(jetPhi[iJet]-recoPfMETPhi);
if(tmpDPhi>tmpPi) tmpDPhi=2*tmpPi-tmpDPhi;
_minitree->radion_jet_dPhiMETJet ->AddAt(tmpDPhi, i);
TLorentzVector* jet = new((*(_minitree->radion_jets))[_minitree->radion_jets->GetEntriesFast()]) TLorentzVector();
jet->SetPtEtaPhiE(jetPt[iJet], jetEta[iJet], jetPhi[iJet], jetEn[iJet]);
}
// Continue step 3.
if ( MetTagSelection(glead,gtrail,goodJetsIndex) && _minitree->mtree_vbfTag == 0 && _minitree->mtree_lepTag == 0 &&
_minitree->mtree_corMet > 70. &&
fabs( phoSCEta[ilead] ) < 1.45 && fabs( phoSCEta[itrail]) < 1.45 ) _minitree->mtree_metTag = 1;
//----------- categorisation (for now incl + vbf + lep + met) -----------//
_minitree->mtree_catBase = CAT4;
_minitree->mtree_catMva = -1;
for( int icat_mva = 0 ; icat_mva < 4; icat_mva++ )
if( diphotonmva >= Ddipho_cat[icat_mva] ) { _minitree->mtree_catMva = icat_mva; break; }
if ( _minitree->mtree_lepTag == 1 ) {
_minitree->mtree_catBase = _minitree->mtree_lepCat + 6;
_minitree->mtree_catMva = _minitree->mtree_lepCat + 6;
} else if( _minitree->mtree_vbfTag == 1 ) {
_minitree->mtree_catBase = _minitree->mtree_vbfCat + 4;
_minitree->mtree_catMva = _minitree->mtree_vbfCat + 4;
} else if( _minitree->mtree_metTag == 1 ) {
_minitree->mtree_catBase = 8;
_minitree->mtree_catMva = 8;
}
if( diphotonmva < Ddipho_cat[3] ) _minitree->mtree_catMva = -1;
/// photon pt cut was dropped from the inclusive cuts
if( _minitree->mtree_catMva < 4 && (glead.Pt()/hcand.M() < 1./3. || gtrail.Pt()/hcand.M() < 1./4.) )
_minitree->mtree_catMva = -1;
if( _minitree->mtree_catBase < 4 && (glead.Pt()/hcand.M() < 1./3. || gtrail.Pt()/hcand.M() < 1./4.) )
_minitree->mtree_catBase = -1;
//------------ MC weighting factors and corrections
if( !isData ) {
/// needs to be recomputed for each event (because reinit var for each event)
_minitree->mc_wNgen = 100000./_weight_manager->getNevts();
_minitree->mc_wXsec = _weight_manager->xSecW(mc_whzh_type);
if( ( mode_ == 3 || mode_ == 19 ) && isprompt1 == 1 ) _minitree->mc_wXsec *= 1.3;
_minitree->mc_wBSz = _weight_manager->bszW(vtxbs[selVtx][2]-mcVtx[0][2]);
_minitree->mc_wVtxId = _weight_manager->vtxPtCorrW( hcand.Pt() );
/// photon identification
float wPhoId[] = { 1., 1.};
for( int i = 0 ; i < 2; i++ ) {
wPhoId[i] = 1;
int index = -1;
if( i == 0 ) index = ilead;
if( i == 1 ) index = itrail;
wPhoId[i] *= _weight_manager->phoIdPresel(phoR9[index],phoSCEta[index]);
if( _config->analysisType() == "baselineCiC4PF" ) wPhoId[i] *= _weight_manager->phoIdCiC(phoR9[index],phoSCEta[index]);
if( _config->analysisType() == "MVA" ) wPhoId[i] *= _weight_manager->phoIdMVA(phoR9[index],phoSCEta[index]);
if( vetoElec[i] ) wPhoId[i] *= _weight_manager->phoIdEleVeto(phoR9[index],phoSCEta[index]);
}
_minitree->mc_wPhoEffi = wPhoId[0]*wPhoId[1];
/// trigger efficiency
_minitree->mc_wTrigEffi = 0.9968; /// FIX ME
/// cross section volontary not included in total weight
_minitree->mc_wei =
_minitree->mc_wPU *
_minitree->mc_wBSz *
_minitree->mc_wHQT * /// = 1 but in 2011
_minitree->mc_wVtxId *
_minitree->mc_wPhoEffi *
_minitree->mc_wTrigEffi *
_minitree->mc_wNgen;
wei = _minitree->mc_wei;
}
nEvts[icutlevel++]++;
if( _minitree->mtree_lepTag ) nEvts[icutlevel+0]++;
if( _minitree->mtree_vbfTag ) nEvts[icutlevel+1]++;
//// following crap can be removed when the synchornization will be successfull.
if( DoDebugEvent ) {
_minitree->setSynchVariables();
_xcheckTextFile << " pho1 pos: " << phoPos[ilead] << endl;
_xcheckTextFile << " ieta1 : " << phoSeedDetId1[ilead] << " iphi1: " << phoSeedDetId2[ilead] << endl;
_xcheckTextFile << " pho2 pos: " << phoPos[itrail] << endl;
_xcheckTextFile << " ieta1 : " << phoSeedDetId1[itrail] << " iphi1: " << phoSeedDetId2[itrail] << endl;
_xcheckTextFile << " oversmear 1: " << overSmear.meanOverSmearing(phoSCEta[ilead],phoR9[ilead] ,isInGAP_EB(ilead),0) << endl;
_xcheckTextFile << " oversmear 2: " << overSmear.meanOverSmearing(phoSCEta[itrail],phoR9[itrail],isInGAP_EB(itrail),0) << endl;
_xcheckTextFile << " mass reso (eng only): " << _minitree->mtree_massResoEng << endl;
_xcheckTextFile << " mass reso (ang only): " << _minitree->mtree_massResoAng << endl;
for( unsigned i = 0 ; i < _minitree->sync_iName.size(); i++ )
cout << _minitree->sync_iName[i] << ":" << *_minitree->sync_iVal[i] << " ";
for( unsigned i = 0 ; i < _minitree->sync_lName.size(); i++ )
cout << _minitree->sync_lName[i] << ":" << *_minitree->sync_lVal[i] << " ";
for( unsigned i = 0 ; i < _minitree->sync_fName.size(); i++ )
cout << _minitree->sync_fName[i] << ":" << *_minitree->sync_fVal[i] << " ";
cout << endl;
cout << " myVtx = " << selVtx << "; 1=" << sortedVertex[1] << " 2= " << sortedVertex[2] << endl;
for( int ivtx = 0; ivtx < nVtxBS; ivtx++ ) {
cout << " etas[ ivtx = " << ivtx << "] = " << phoEtaVtx[ilead][ivtx] << " - " << phoEtaVtx[itrail][ivtx] << " - zVtx = " << vtxbs[ivtx][2] << endl;
}
}
_minitree->fill();
if( _config->doSkimming() && tSkim ) {
/// undo all modifs before filling the skim
fChain->GetEntry(jentry);
tSkim->Fill();
}
//---------------
// }
}// end for entry
if( _config->doSkimming() ) {
_minitree->mtree_file->cd();
TH1F *hEvents = new TH1F("hEvents","hEvents",2,0,2);
hEvents->SetBinContent(1,_weight_manager->getNevts());
hEvents->SetBinContent(2,nEvts[nEvts.size()-1]);
hEvents->Write();
tSkim->Write();
_minitree->mtree_file->Close();
} else _minitree->end();
for( unsigned icut = 0 ; icut < nEvts.size(); icut++ )
cout << nCutName[icut] << nEvts[icut] << endl;
delete rnd;
return nEvts[nEvts.size()-1];
}
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;
}
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;
}
// 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();
}
int main(int argc, char * argv[])
{
// load silly ROOT thing
gROOT->ProcessLine("#include <vector>");
gROOT->ProcessLine(".L loader.C+");
// output
TFile * output_file = new TFile("output_file.root", "RECREATE");
TTree * jet_tree = new TTree("jet_tree", "jet_tree");
float jet_pt = 0;
float jet_eta = 0;
float jet_phi = 0;
float jet_m = 0;
jet_tree->Branch("jet_pt", &jet_pt);
jet_tree->Branch("jet_eta", &jet_eta);
jet_tree->Branch("jet_phi", &jet_phi);
jet_tree->Branch("jet_m", &jet_m);
TTree * event_tree = new TTree("event_tree", "event_tree");
int n = 0;
int us = 0;
event_tree->Branch("n", &n);
event_tree->Branch("us", &us);
// input tracks
TChain * tree = new TChain("tree");
tree->Add("mc15_13TeV.301523.RS_G_hh_bbbb_c20_M2000.track_ntuple.root");
int number_of_events = tree->GetEntries();
int track_number = 0;
vector<float> * track_pt = 0;
vector<float> * track_eta = 0;
vector<float> * track_phi = 0;
tree->SetBranchAddress("track_number", &track_number);
tree->SetBranchAddress("track_pt", &track_pt);
tree->SetBranchAddress("track_eta", &track_eta);
tree->SetBranchAddress("track_phi", &track_phi);
vector<PseudoJet> particles;
// variables for timing
struct timeval start;
struct timeval end;
struct timeval duration;
// TH2F * h_timing = new TH2F("timing", "timing; # Tracks; #mus", 1000, 0, 1000, 100, 1, 10000);
// TH2F * h_log_timing = new TH2F("log_timing", "log_timing; # Tracks; log_{10}(#mus)", 1000, 0, 1000, 100, log10(1), log10(10000));
// TH2F * h_timing = new TH2F("timing", "timing; # Tracks; #mus", 1000, 0, 1000, 100, 1, 10000);
// TH2F * h_log_timing = new TH2F("log_timing", "log_timing; # Tracks; log_{10}(#mus)", 1000, 0, 1000, 100, log10(1), log10(10000));
// TH2F * h_timing = new TH2F("timing", "timing; # Tracks; #mus", 1000, 0, 1000, 100, 1, 10000);
// TH2F * h_log_timing = new TH2F("log_timing", "log_timing; # Tracks; log_{10}(#mus)", 1000, 0, 1000, 100, log10(1), log10(10000));
TH2F * h_timing = new TH2F("timing", "timing; # Tracks; #mus", 1000, 0, 1000, 100, 1, 5000); // N2Tiled
TH2F * h_log_timing = new TH2F("log_timing", "log_timing; # Tracks; log_{10}(#mus)", 1000, 0, 1000, 100, log10(1), log10(5000)); // N2Tiled
for (int event = 0; event < number_of_events; event++)
{
// print a sexy load bar
loadBar(event, number_of_events, 100, 50);
tree->GetEntry(event);
for (int track = 0; track < track_number; track++)
{
TLorentzVector trackLorentzVector;
trackLorentzVector.SetPtEtaPhiM(track_pt->at(track) / 1000.0, track_eta->at(track), track_phi->at(track), 0);
particles.push_back(PseudoJet(trackLorentzVector.Px(), trackLorentzVector.Py(), trackLorentzVector.Pz(), trackLorentzVector.E()));
}
// get the start time
gettimeofday(&start, NULL);
// not vrplugin
double R = 0.4;
// JetDefinition jet_def(antikt_vr, R, N3Dumb, E_scheme, 1, 60);
// JetDefinition jet_def(antikt_vr, R, N2Plain, E_scheme, 1, 60);
JetDefinition jet_def(antikt_vr, R, N2Tiled, E_scheme, 1, 60);
ClusterSequence cs(particles, jet_def);
vector<PseudoJet> jets = sorted_by_pt(cs.inclusive_jets());
// vrplugin
// double rho = 60;
// double min_r = 0;
// double max_r = 0.4;
// VariableRPlugin vrplugin(rho, min_r, max_r, VariableRPlugin::AKTLIKE);
// JetDefinition jet_def_vrplugin(&vrplugin);
// ClusterSequence cs_vrplugin(particles, jet_def_vrplugin);
// vector<fastjet::PseudoJet> jets = sorted_by_pt(cs_vrplugin.inclusive_jets());
// get the final time
gettimeofday(&end, NULL);
// get the duration
timersub(&end, &start, &duration);
h_timing->Fill(track_number, (long int) duration.tv_sec * 1000000 + (long int) duration.tv_usec);
h_log_timing->Fill(track_number, log10((long int) duration.tv_sec * 1000000 + (long int) duration.tv_usec));
n = track_number;
us = (long int) duration.tv_sec * 1000000 + (long int) duration.tv_usec;
event_tree->Fill();
for (int jet = 0; jet < jets.size(); jet++)
{
// printf("jets[jet].pt() = %f\n", jets[jet].pt());
// printf("jets[jet].eta() = %f\n", jets[jet].eta());
// printf("jets[jet].phi() = %f\n", jets[jet].phi());
// printf("jets[jet].m() = %f\n", jets[jet].m());
jet_pt = jets[jet].pt();
jet_eta = jets[jet].eta();
jet_phi = jets[jet].phi();
jet_m = jets[jet].m();
jet_tree->Fill();
}
particles.clear();
}
TProfile * pr_timing = h_timing->ProfileX();
TF1 * f_timing_n2 = new TF1("f_timing_n2", "pol2", 0, 1000);
TF1 * f_timing_n3 = new TF1("f_timing_n3", "pol3", 0, 1000);
pr_timing->Fit(f_timing_n2);
pr_timing->Fit(f_timing_n3);
TProfile * pr_log_timing = h_log_timing->ProfileX();
TF1 * f_log_timing = new TF1("f_log_timing", "pol1", 0, 1000);
pr_log_timing->Fit(f_log_timing);
output_file->Write();
h_timing->Write();
pr_timing->Write();
f_timing_n2->Write();
f_timing_n3->Write();
h_log_timing->Write();
pr_log_timing->Write();
f_log_timing->Write();
delete(jet_tree);
delete(event_tree);
return 0;
}
PseudoJet::PseudoJet(TLorentzVector const& vector) :
fastjet::PseudoJet(vector.Px(), vector.Py(), vector.Pz(), vector.E())
{
INFO(vector.Px(), px(), vector.Py(), py());
}
void print_vec(TLorentzVector v){
cout <<"("<< v.Px() << " , " << v.Py() << " , " << v.Pz() << " , " << v.E() << ")" <<endl;
}
