#include <TtFullLepKinSolver.h>

Classes
struct	NeutrinoSolution
Public Member Functions
TtDilepEvtSolution	addKinSolInfo (TtDilepEvtSolution *asol)
NeutrinoSolution	getNuSolution (TLorentzVector LV_l, TLorentzVector LV_l_, TLorentzVector LV_b, TLorentzVector LV_b_)
void	SetConstraints (double xx=0, double yy=0)
	TtFullLepKinSolver (double, double, double, std::vector< double >)
	TtFullLepKinSolver ()
void	useWeightFromMC (bool useMC)
	~TtFullLepKinSolver ()
Private Member Functions
int	cubic (double c_coeff, double c_sol)
void	FindCoeff (const TLorentzVector al, const TLorentzVector l, const TLorentzVector b_al, const TLorentzVector b_l, double mt, double mat, double pxboost, double pyboost, double *q_coeff)
int	quartic (double q_coeff, double q_sol)
double	sqr (double x)
void	SWAP (double &realone, double &realtwo)
void	TopRec (const TLorentzVector al, const TLorentzVector l, const TLorentzVector b_al, const TLorentzVector b_l, double sol)
double	WeightSolfromMC ()
double	WeightSolfromShape ()
Private Attributes
double	C
double	D
TF2 *	EventShape_
double	F
TLorentzVector	genLV_n
TLorentzVector	genLV_n_
double	k16
double	k26
double	k36
double	k46
double	k51
double	k56
double	k61
TLorentzVector	LV_n
TLorentzVector	LV_n_
TLorentzVector	LV_t
TLorentzVector	LV_t_
TLorentzVector	LV_tt_t
TLorentzVector	LV_tt_t_
double	m1
double	m2
double	m3
double	mab
double	maw
double	mb
double	mw
double	n1
double	n2
double	n3
double	pom
double	pxmiss_
double	pymiss_
double	topmass_begin
double	topmass_end
double	topmass_step
bool	useMCforBest_

Detailed Description

Definition at line 13 of file TtFullLepKinSolver.h.

Constructor & Destructor Documentation

TtFullLepKinSolver::TtFullLepKinSolver ( )

Definition at line 5 of file TtFullLepKinSolver.cc.

References EventShape_.

{
  // That crude parametrisation has been obtained from a fit of O(1000) pythia events.
  // It is normalized to 1.
  EventShape_ = new TF2("landau2D","[0]*TMath::Landau(x,[1],[2],0)*TMath::Landau(y,[3],[4],0)",0,500,0,500);
  EventShape_->SetParameters(30.7137,56.2880,23.0744,59.1015,24.9145);
}

TtFullLepKinSolver::TtFullLepKinSolver	(	double	b,
		double	e,
		double	s,
		std::vector< double >	nupars
	)

Definition at line 13 of file TtFullLepKinSolver.cc.

References b, EventShape_, mab, maw, mb, mw, pxmiss_, pymiss_, asciidump::s, topmass_begin, topmass_end, and topmass_step.

{
  topmass_begin = b;
  topmass_end = e;
  topmass_step = s;
  pxmiss_ = 0;
  pymiss_ = 0;
  mw = 80.22;
  maw = 80.22;
  mab = 4.800;
  mb = 4.800;
  // That crude parametrisation has been obtained from a fit of O(1000) pythia events.
  // It is normalized to 1.
  EventShape_ = new TF2("landau2D","[0]*TMath::Landau(x,[1],[2],0)*TMath::Landau(y,[3],[4],0)",0,500,0,500);
  EventShape_->SetParameters(nupars[0],nupars[1],nupars[2],nupars[3],nupars[4]);
}

TtFullLepKinSolver::~TtFullLepKinSolver ( )

Definition at line 33 of file TtFullLepKinSolver.cc.

References EventShape_.

{
  delete EventShape_;
}

Member Function Documentation

TtDilepEvtSolution TtFullLepKinSolver::addKinSolInfo ( TtDilepEvtSolution * asol )

Definition at line 40 of file TtFullLepKinSolver.cc.

Referenced by TtDilepEvtSolutionMaker::produce().

{
  TtDilepEvtSolution fitsol(*asol);
  
  //antilepton and lepton
  TLorentzVector LV_e, LV_e_;
  //b and bbar quark
  TLorentzVector LV_b, LV_b_;
  
  bool hasMCinfo = true;
  if(fitsol.getGenN()) { // protect against non-dilept genevents
    genLV_n = TLorentzVector(fitsol.getGenN()->px(), fitsol.getGenN()->py(),
                             fitsol.getGenN()->pz(), fitsol.getGenN()->energy());
  } else hasMCinfo = false;

  if(fitsol.getGenNbar()) { // protect against non-dilept genevents
    genLV_n_ = TLorentzVector(fitsol.getGenNbar()->px(), fitsol.getGenNbar()->py(),
                              fitsol.getGenNbar()->pz(), fitsol.getGenNbar()->energy());
  } else hasMCinfo = false;
  // if MC is to be used to select the best top mass and is not available,
  // then nothing can be done. Stop here.
  if(useMCforBest_&&!hasMCinfo) return fitsol;

  // first lepton
  if (fitsol.getWpDecay() == "muon") {
    LV_e = TLorentzVector(fitsol.getMuonp().px(), fitsol.getMuonp().py(),
                          fitsol.getMuonp().pz(), fitsol.getMuonp().energy());
  } else if (fitsol.getWpDecay() == "electron") {
    LV_e = TLorentzVector(fitsol.getElectronp().px(), fitsol.getElectronp().py(),
                          fitsol.getElectronp().pz(), fitsol.getElectronp().energy());
  } else if (fitsol.getWpDecay() == "tau") {
    LV_e = TLorentzVector(fitsol.getTaup().px(), fitsol.getTaup().py(),
                          fitsol.getTaup().pz(), fitsol.getTaup().energy());
  }
    
  // second lepton
  if (fitsol.getWmDecay() == "muon") {
    LV_e_ = TLorentzVector(fitsol.getMuonm().px(), fitsol.getMuonm().py(),
                          fitsol.getMuonm().pz(), fitsol.getMuonm().energy());
  } else if (fitsol.getWmDecay() == "electron") {
    LV_e_ = TLorentzVector(fitsol.getElectronm().px(), fitsol.getElectronm().py(),
                           fitsol.getElectronm().pz(), fitsol.getElectronm().energy());
  } else if (fitsol.getWmDecay() == "tau") {
    LV_e_ = TLorentzVector(fitsol.getTaum().px(), fitsol.getTaum().py(),
                           fitsol.getTaum().pz(), fitsol.getTaum().energy());
  }

  // first jet
  LV_b = TLorentzVector(fitsol.getCalJetB().px(), fitsol.getCalJetB().py(),
                        fitsol.getCalJetB().pz(), fitsol.getCalJetB().energy());

  // second jet
  LV_b_ = TLorentzVector(fitsol.getCalJetBbar().px(), fitsol.getCalJetBbar().py(),
                         fitsol.getCalJetBbar().pz(), fitsol.getCalJetBbar().energy());
  
  //loop on top mass parameter
  double weightmax = -1e30;
  double mtmax = 0;
  for (double mt = topmass_begin; 
              mt < topmass_end + 0.5*topmass_step; 
              mt += topmass_step) {
    //cout << "mt = " << mt << endl;
    double q_coeff[5], q_sol[4];
    FindCoeff(LV_e, LV_e_, LV_b, LV_b_, mt, mt, pxmiss_, pymiss_, q_coeff);
    int NSol = quartic(q_coeff, q_sol);
    
    //loop on all solutions
    for (int isol = 0; isol < NSol; isol++) {
      TopRec(LV_e, LV_e_, LV_b, LV_b_, q_sol[isol]);
      double weight = useMCforBest_ ? WeightSolfromMC() : WeightSolfromShape();
      if (weight > weightmax) {
        weightmax =weight;
        mtmax = mt;
      }
    }
    
    //for (int i=0;i<5;i++) cout << " q_coeff["<<i<< "]= " << q_coeff[i];
    //cout << endl;
    
    //for (int i=0;i<4;i++) cout << " q_sol["<<i<< "]= " << q_sol[i];
    //cout << endl;
    //cout << "NSol_" << NSol << endl;
  }
  
  fitsol.setRecTopMass(mtmax);
  fitsol.setRecWeightMax(weightmax);
  
  return fitsol;
}

int TtFullLepKinSolver::cubic	(	double *	c_coeff,
		double *	c_sol
	)		`[private]`

Definition at line 378 of file TtFullLepKinSolver.cc.

References funct::cos(), h, i, AlCaHLTBitMon_ParallelJobs::p, phi, Pi, lumiQueryAPI::q, sqr(), mathSSE::sqrt(), and SWAP().

Referenced by quartic().

                                                            {
  int i, nreal;
  double w, p, q, dis, h, phi;
  
  if (coeffs[3]!=0.0) {
    /* cubic problem? */
    w = coeffs[2]/(3*coeffs[3]);
    p = sqr(coeffs[1]/(3*coeffs[3])-sqr(w))*(coeffs[1]/(3*coeffs[3])-sqr(w));
    q = -0.5*(2*sqr(w)*w-(coeffs[1]*w-coeffs[0])/coeffs[3]);
    dis = sqr(q)+p;
    /* discriminant */
    if (dis<0.0) {
      /* 3 real solutions */
      h = q/sqrt(-p);
      if (h>1.0) h = 1.0;
      /* confine the argument of */
      if (h<-1.0) h = -1.0;
      /* acos to [-1;+1] */
      phi = acos(h);
      p = 2*TMath::Power(-p, 1.0/6.0);
      for (i=0; i<3; i++) 
        koreny[i] = p*cos((phi+2*i*TMath::Pi())/3.0) - w;
      if (koreny[1]<koreny[0]) SWAP(koreny[0], koreny[1]);
      /* sort results */
      if (koreny[2]<koreny[1]) SWAP(koreny[1], koreny[2]);
      if (koreny[1]<koreny[0]) SWAP(koreny[0], koreny[1]);
      nreal = 3;
    }
    else {
      /* only one real solution */
      dis = sqrt(dis);
      h = TMath::Power(fabs(q+dis), 1.0/3.0);
      p = TMath::Power(fabs(q-dis), 1.0/3.0);
      koreny[0] = ((q+dis>0.0)? h : -h) + ((q-dis>0.0)? p : -p) -  w;
      nreal = 1;
    }

    /* Perform one step of a Newton iteration in order to minimize
       round-off errors */
    for (i=0; i<nreal; i++) {
      h = coeffs[1] + koreny[i] * (2 * coeffs[2] + 3 * koreny[i] * coeffs[3]);
      if (h != 0.0)
        koreny[i] -= (coeffs[0] + koreny[i] * (coeffs[1] + koreny[i] * (coeffs[2] + koreny[i] * coeffs[3])))/h;
    }
  }

  else if (coeffs[2]!=0.0) {
    /* quadratic problem? */
    p = 0.5*coeffs[1]/coeffs[2];
    dis = sqr(p) - coeffs[0]/coeffs[2];
    if (dis>=0.0) {
      /* two real solutions */
      dis = sqrt(dis);
      koreny[0] = -p - dis;
      koreny[1] = -p + dis;
      nreal = 2;
    }
    else
      /* no real solution */
      nreal = 0;
  }

  else if (coeffs[1]!=0.0) {
    /* linear problem? */
    koreny[0] = -coeffs[0]/coeffs[1];
    nreal = 1;
  }

  else
    /* no equation */
    nreal = 0;
  
  return nreal;
}

void TtFullLepKinSolver::FindCoeff	(	const TLorentzVector	al,
		const TLorentzVector	l,
		const TLorentzVector	b_al,
		const TLorentzVector	b_l,
		double	mt,
		double	mat,
		double	pxboost,
		double	pyboost,
		double *	q_coeff
	)		`[private]`

Definition at line 171 of file TtFullLepKinSolver.cc.

References C, D, F, k16, k26, k36, k46, k51, k56, k61, m1, m2, m3, mab, maw, mb, mw, n1, n2, n3, pom, funct::pow(), and sqr().

Referenced by addKinSolInfo(), and getNuSolution().

                                                        {

double E, apom1, apom2, apom3;
double k11, k21, k31, k41,  cpom1, cpom2, cpom3, l11, l21, l31, l41, l51, l61, k1, k2, k3, k4, k5,k6;
double l1, l2, l3, l4, l5, l6, k15, k25, k35, k45;

  C = -al.Px()-b_al.Px()-l.Px()-b_l.Px() + px_miss;
  D = -al.Py()-b_al.Py()-l.Py()-b_l.Py() + py_miss;

  // right side offirst two linear equations - missing pT

  
  E = (sqr(mt)-sqr(mw)-sqr(mb))/(2*b_al.E())-sqr(mw)/(2*al.E())-al.E()+al.Px()*b_al.Px()/b_al.E()+al.Py()*b_al.Py()/b_al.E()+al.Pz()*b_al.Pz()/b_al.E();
  F = (sqr(mat)-sqr(maw)-sqr(mab))/(2*b_l.E())-sqr(maw)/(2*l.E())-l.E()+l.Px()*b_l.Px()/b_l.E()+l.Py()*b_l.Py()/b_l.E()+l.Pz()*b_l.Pz()/b_l.E();
  
  m1 = al.Px()/al.E()-b_al.Px()/b_al.E();
  m2 = al.Py()/al.E()-b_al.Py()/b_al.E();
  m3 = al.Pz()/al.E()-b_al.Pz()/b_al.E();
  
  n1 = l.Px()/l.E()-b_l.Px()/b_l.E();
  n2 = l.Py()/l.E()-b_l.Py()/b_l.E();
  n3 = l.Pz()/l.E()-b_l.Pz()/b_l.E();
  
  pom = E-m1*C-m2*D;
  apom1 = sqr(al.Px())-sqr(al.E());
  apom2 = sqr(al.Py())-sqr(al.E());
  apom3 = sqr(al.Pz())-sqr(al.E());
  
  k11 = 1/sqr(al.E())*(pow(mw,4)/4+sqr(C)*apom1+sqr(D)*apom2+apom3*sqr(pom)/sqr(m3)+sqr(mw)*(al.Px()*C+al.Py()*D+al.Pz()*pom/m3)+2*al.Px()*al.Py()*C*D+2*al.Px()*al.Pz()*C*pom/m3+2*al.Py()*al.Pz()*D*pom/m3);
  k21 = 1/sqr(al.E())*(-2*C*m3*n3*apom1+2*apom3*n3*m1*pom/m3-sqr(mw)*m3*n3*al.Px()+sqr(mw)*m1*n3*al.Pz()-2*al.Px()*al.Py()*D*m3*n3+2*al.Px()*al.Pz()*C*m1*n3-2*al.Px()*al.Pz()*n3*pom+2*al.Py()*al.Pz()*D*m1*n3);
  k31 = 1/sqr(al.E())*(-2*D*m3*n3*apom2+2*apom3*n3*m2*pom/m3-sqr(mw)*m3*n3*al.Py()+sqr(mw)*m2*n3*al.Pz()-2*al.Px()*al.Py()*C*m3*n3+2*al.Px()*al.Pz()*C*m2*n3-2*al.Py()*al.Pz()*n3*pom+2*al.Py()*al.Pz()*D*m2*n3);
  k41 = 1/sqr(al.E())*(2*apom3*m1*m2*sqr(n3)+2*al.Px()*al.Py()*sqr(m3)*sqr(n3)-2*al.Px()*al.Pz()*m2*m3*sqr(n3)-2*al.Py()*al.Pz()*m1*m3*sqr(n3));
  k51 = 1/sqr(al.E())*(apom1*sqr(m3)*sqr(n3)+apom3*sqr(m1)*sqr(n3)-2*al.Px()*al.Pz()*m1*m3*sqr(n3));
  k61 = 1/sqr(al.E())*(apom2*sqr(m3)*sqr(n3)+apom3*sqr(m2)*sqr(n3)-2*al.Py()*al.Pz()*m2*m3*sqr(n3));
  
  cpom1 = sqr(l.Px())-sqr(l.E());
  cpom2 = sqr(l.Py())-sqr(l.E());
  cpom3 = sqr(l.Pz())-sqr(l.E());
  
  l11 = 1/sqr(l.E())*(pow(maw,4)/4+cpom3*sqr(F)/sqr(n3)+sqr(maw)*l.Pz()*F/n3);
  l21 = 1/sqr(l.E())*(-2*cpom3*F*m3*n1/n3+sqr(maw)*(l.Px()*m3*n3-l.Pz()*n1*m3)+2*l.Px()*l.Pz()*F*m3);
  l31 = 1/sqr(l.E())*(-2*cpom3*F*m3*n2/n3+sqr(maw)*(l.Py()*m3*n3-l.Pz()*n2*m3)+2*l.Py()*l.Pz()*F*m3);
  l41 = 1/sqr(l.E())*(2*cpom3*n1*n2*sqr(m3)+2*l.Px()*l.Py()*sqr(m3)*sqr(n3)-2*l.Px()*l.Pz()*n2*n3*sqr(m3)-2*l.Py()*l.Pz()*n1*n3*sqr(m3));
  l51 = 1/sqr(l.E())*(cpom1*sqr(m3)*sqr(n3)+cpom3*sqr(n1)*sqr(m3)-2*l.Px()*l.Pz()*n1*n3*sqr(m3));
  l61 = 1/sqr(l.E())*(cpom2*sqr(m3)*sqr(n3)+cpom3*sqr(n2)*sqr(m3)-2*l.Py()*l.Pz()*n2*n3*sqr(m3));
  
  k1 = k11*k61;
  k2 = k61*k21/k51;
  k3 = k31;
  k4 = k41/k51;
  k5 = k61/k51;
  k6 = 1;
  
  l1 = l11*k61;
  l2 = l21*k61/k51;
  l3 = l31;
  l4 = l41/k51;
  l5 = l51*k61/(sqr(k51));
  l6 = l61/k61;
  
  k15 = k1*l5-l1*k5;
  k25 = k2*l5-l2*k5;
  k35 = k3*l5-l3*k5;
  k45 = k4*l5-l4*k5;
  
  k16 = k1*l6-l1*k6;
  k26 = k2*l6-l2*k6;
  k36 = k3*l6-l3*k6;
  k46 = k4*l6-l4*k6;
  k56 = k5*l6-l5*k6;
  

  koeficienty[0] = k15*sqr(k36)-k35*k36*k16-k56*sqr(k16);
  koeficienty[1] = 2*k15*k36*k46+k25*sqr(k36)+k35*(-k46*k16-k36*k26)-k45*k36*k16-2*k56*k26*k16;
  koeficienty[2] = k15*sqr(k46)+2*k25*k36*k46+k35*(-k46*k26-k36*k56)-k56*(sqr(k26)+2*k56*k16)-k45*(k46*k16+k36*k26);
  koeficienty[3] = k25*sqr(k46)-k35*k46*k56-k45*(k46*k26+k36*k56)-2*sqr(k56)*k26;
  koeficienty[4] = -k45*k46*k56-pow(k56,3);
  
  // normalization of coefficients
  int moc=(int(log10(fabs(koeficienty[0])))+int(log10(fabs(koeficienty[4]))))/2;
  
  koeficienty[0]=koeficienty[0]/TMath::Power(10,moc);
  koeficienty[1]=koeficienty[1]/TMath::Power(10,moc);
  koeficienty[2]=koeficienty[2]/TMath::Power(10,moc);
  koeficienty[3]=koeficienty[3]/TMath::Power(10,moc);
  koeficienty[4]=koeficienty[4]/TMath::Power(10,moc);
}

TtFullLepKinSolver::NeutrinoSolution TtFullLepKinSolver::getNuSolution	(	TLorentzVector	LV_l,
		TLorentzVector	LV_l_,
		TLorentzVector	LV_b,
		TLorentzVector	LV_b_
	)

Definition at line 136 of file TtFullLepKinSolver.cc.

References FindCoeff(), LV_n, LV_n_, TtFullLepKinSolver::NeutrinoSolution::neutrino, TtFullLepKinSolver::NeutrinoSolution::neutrinoBar, pxmiss_, pymiss_, quartic(), topmass_begin, topmass_end, topmass_step, TopRec(), CommonMethods::weight(), TtFullLepKinSolver::NeutrinoSolution::weight, and WeightSolfromShape().

Referenced by TtFullLepKinSolutionProducer::produce().

                                                                                             {                                                                                                                      
    
  math::XYZTLorentzVector maxLV_n  = math::XYZTLorentzVector(0,0,0,0); 
  math::XYZTLorentzVector maxLV_n_ = math::XYZTLorentzVector(0,0,0,0);   

  //loop on top mass parameter
  double weightmax = -1;
  for(double mt = topmass_begin; 
             mt < topmass_end + 0.5*topmass_step; 
             mt += topmass_step) {
    double q_coeff[5], q_sol[4];
    FindCoeff(LV_l, LV_l_, LV_b, LV_b_, mt, mt, pxmiss_, pymiss_, q_coeff);
    int NSol = quartic(q_coeff, q_sol);
    
    //loop on all solutions
    for (int isol = 0; isol < NSol; isol++) {
      TopRec(LV_l, LV_l_, LV_b, LV_b_, q_sol[isol]);
      double weight = WeightSolfromShape();
      if (weight > weightmax) {
        weightmax =weight;
        maxLV_n.SetPxPyPzE(LV_n.Px(), LV_n.Py(), LV_n.Pz(), LV_n.E());
        maxLV_n_.SetPxPyPzE(LV_n_.Px(), LV_n_.Py(), LV_n_.Pz(), LV_n_.E());
      }
    }
  }
  TtFullLepKinSolver::NeutrinoSolution nuSol;
  nuSol.neutrino    = reco::LeafCandidate(0, maxLV_n  );
  nuSol.neutrinoBar = reco::LeafCandidate(0, maxLV_n_ ); 
  nuSol.weight = weightmax; 
  return nuSol;
}

int TtFullLepKinSolver::quartic	(	double *	q_coeff,
		double *	q_sol
	)		`[private]`

Definition at line 317 of file TtFullLepKinSolver.cc.

References trackerHits::c, cubic(), debug_cff::d0, debug_cff::d1, h, i, sqr(), mathSSE::sqrt(), matplotRender::t, and z.

Referenced by addKinSolInfo(), and getNuSolution().

                                                                   {
  int i, nreal;
  double w, b0, b1, b2;
  double c[4];
  double d0, d1, h, t, z;
  double *px;

  
  if (koeficienty[4]==0.0) 
    return cubic(koeficienty, koreny);
  /* quartic problem? */
  w = koeficienty[3]/(4*koeficienty[4]);
  /* offset */
  b2 = -6*sqr(w) + koeficienty[2]/koeficienty[4];
  /* koeficienty. of shifted polynomial */
  b1 = (8*sqr(w) - 2*koeficienty[2]/koeficienty[4])*w + koeficienty[1]/koeficienty[4];
  b0 = ((-3*sqr(w) + koeficienty[2]/koeficienty[4])*w - koeficienty[1]/koeficienty[4])*w + koeficienty[0]/koeficienty[4];

  c[3] = 1.0;
  /* cubic resolvent */
  c[2] = b2;
  c[1] = -4*b0;
  c[0] = sqr(b1) - 4*b0*b2;
  
  
  i = cubic(c, koreny);
  z = koreny[0];
  //double z1=1.0,z2=2.0,z3=3.0;
  //TMath::RootsCubic(c,z1,z2,z3);
  //if (z2 !=0) z = z2;
  //if (z1 !=0) z = z1;
  /* only lowermost root needed */

  nreal = 0;
  px = koreny;
  t = sqrt(0.25*sqr(z) - b0);
  for (i=-1; i<=1; i+=2) {
    d0 = -0.5*z + i*t;
    /* coeffs. of quadratic factor */
    d1 = (t!=0.0)? -i*0.5*b1/t : i*sqrt(-z - b2);
    h = 0.25*sqr(d1) - d0;
    if (h>=0.0) {
      h = sqrt(h);
      nreal += 2;
      *px++ = -0.5*d1 - h - w;
      *px++ = -0.5*d1 + h - w;
    }
  }

  if (nreal==4) {
    /* sort results */
//    if (koreny[2]<koreny[0]) SWAP(koreny[0], koreny[2]);
//    if (koreny[3]<koreny[1]) SWAP(koreny[1], koreny[3]);
//    if (koreny[1]<koreny[0]) SWAP(koreny[0], koreny[1]);
//    if (koreny[3]<koreny[2]) SWAP(koreny[2], koreny[3]);
//    if (koreny[2]<koreny[1]) SWAP(koreny[1], koreny[2]);
  }
  return nreal;

}

void TtFullLepKinSolver::SetConstraints	(	double	xx = `0`,
		double	yy = `0`
	)

Definition at line 130 of file TtFullLepKinSolver.cc.

References pxmiss_, and pymiss_.

Referenced by TtDilepEvtSolutionMaker::produce(), and TtFullLepKinSolutionProducer::produce().

{
  pxmiss_ = xx;
  pymiss_ = yy;
}

double TtFullLepKinSolver::sqr ( double x ) [inline, private]

Definition at line 55 of file TtFullLepKinSolver.h.

Referenced by cubic(), FindCoeff(), and quartic().

{return (x*x);}

void TtFullLepKinSolver::SWAP	(	double &	realone,
		double &	realtwo
	)		`[private]`

Definition at line 454 of file TtFullLepKinSolver.cc.

References printConversionInfo::aux.

Referenced by cubic().

                                                               {
  if (realtwo < realone) {
    double aux = realtwo;
    realtwo = realone;
    realone = aux;
  }
}

void TtFullLepKinSolver::TopRec	(	const TLorentzVector	al,
		const TLorentzVector	l,
		const TLorentzVector	b_al,
		const TLorentzVector	b_l,
		double	sol
	)		`[private]`

Definition at line 267 of file TtFullLepKinSolver.cc.

References printConversionInfo::aux, C, D, F, k16, k26, k36, k46, k51, k56, k61, LV_n, LV_n_, LV_t, LV_t_, LV_tt_t, LV_tt_t_, m1, m2, m3, n1, n2, n3, pom, and funct::pow().

Referenced by addKinSolInfo(), and getNuSolution().

                                            {

  TVector3 t_ttboost;
  TLorentzVector aux;
  double pxp, pyp, pzp, pup, pvp, pwp;
  
    
  pxp = sol*(m3*n3/k51);   
  pyp = -(m3*n3/k61)*(k56*pow(sol,2) + k26*sol + k16)/(k36 + k46*sol);
  pzp = -1/n3*(n1*pxp + n2*pyp - F);
  pwp = 1/m3*(m1*pxp + m2*pyp + pom);
  pup = C - pxp;
  pvp = D - pyp;
     
  LV_n_.SetXYZM(pxp, pyp, pzp, 0.0);
  LV_n.SetXYZM(pup, pvp, pwp, 0.0);
      
  
  LV_t_ = b_l + l + LV_n_;
  LV_t = b_al + al + LV_n;  
  
  
  aux = (LV_t_ + LV_t);
  t_ttboost = -aux.BoostVector();
  LV_tt_t_ = LV_t_;
  LV_tt_t = LV_t;
  LV_tt_t_.Boost(t_ttboost);
  LV_tt_t.Boost(t_ttboost); 
}

void TtFullLepKinSolver::useWeightFromMC ( bool useMC ) [inline]

Definition at line 21 of file TtFullLepKinSolver.h.

References PatBasicFWLiteJetAnalyzer_Selector_cfg::useMC, and useMCforBest_.

Referenced by TtDilepEvtSolutionMaker::produce().

{ useMCforBest_ = useMC; }

double TtFullLepKinSolver::WeightSolfromMC ( ) [private]

Definition at line 301 of file TtFullLepKinSolver.cc.

References genLV_n, genLV_n_, LV_n, LV_n_, and CommonMethods::weight().

Referenced by addKinSolInfo().

                                           {

  double weight = 1;
  weight = ((LV_n.E() > genLV_n.E())? genLV_n.E()/LV_n.E(): LV_n.E()/genLV_n.E())
           *((LV_n_.E() > genLV_n_.E())? genLV_n_.E()/LV_n_.E(): LV_n_.E()/genLV_n_.E());
  return weight;

}

double TtFullLepKinSolver::WeightSolfromShape ( ) [private]

Definition at line 310 of file TtFullLepKinSolver.cc.

References EventShape_, LV_n, and LV_n_.

Referenced by addKinSolInfo(), and getNuSolution().

                                              {
  
  // Use the parametrized event shape to obtain the solution weight.
  return EventShape_->Eval(LV_n.E(),LV_n_.E());

}