TtFullLepKinSolver Class Reference

#include <TtFullLepKinSolver.h>

Classes
struct	NeutrinoSolution

Public Member Functions
TtDilepEvtSolution	addKinSolInfo (TtDilepEvtSolution *asol)
NeutrinoSolution	getNuSolution (const TLorentzVector &LV_l, const TLorentzVector &LV_l_, const TLorentzVector &LV_b, const TLorentzVector &LV_b_)
void	SetConstraints (const double xx=0, const double yy=0)
	TtFullLepKinSolver ()
	default constructor More...
	TtFullLepKinSolver (const double, const double, const double, const std::vector< double > &, const double=80.4, const double=4.8)
	constructor with parameters to configure the top-mass scan and the neutrino spectrum More...
void	useWeightFromMC (bool useMC)
	~TtFullLepKinSolver ()
	destructor More...

Private Member Functions
int	cubic (const double *c_coeff, double *c_sol) const
void	FindCoeff (const TLorentzVector &al, const TLorentzVector &l, const TLorentzVector &b_al, const TLorentzVector &b_l, const double mt, const double mat, const double pxboost, const double pyboost, double *q_coeff)
int	quartic (double *q_coeff, double *q_sol) const
double	sqr (const double x) const
void	SWAP (double &realone, double &realtwo) const
void	TopRec (const TLorentzVector &al, const TLorentzVector &l, const TLorentzVector &b_al, const TLorentzVector &b_l, const double sol)
double	WeightSolfromMC () const
double	WeightSolfromShape () const
	use the parametrized event shape to obtain the solution weight. More...

Private Attributes
double	C
double	D
TF2 *	EventShape_
	Event shape. More...
double	F
TLorentzVector	genLV_n
	provisional More...
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
const double	mb
const double	mw
double	n1
double	n2
double	n3
double	pom
double	pxmiss_
double	pymiss_
const double	topmass_begin
const double	topmass_end
const double	topmass_step
bool	useMCforBest_
	flag to swith from WeightSolfromMC() to WeightSolfromShape() More...

Detailed Description

Definition at line 25 of file TtFullLepKinSolver.h.

Constructor & Destructor Documentation

TtFullLepKinSolver::TtFullLepKinSolver

(

)

default constructor

Definition at line 4 of file TtFullLepKinSolver.cc.

References EventShape_.

    : topmass_begin(0), topmass_end(0), topmass_step(0), mw(80.4), mb(4.8), pxmiss_(0), pymiss_(0) {
  // 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	(	const double	b,
		const double	e,
		const double	s,
		const std::vector< double > &	nupars,
		const double	mW = 80.4,
		const double	mB = 4.8
	)

constructor with parameters to configure the top-mass scan and the neutrino spectrum

Definition at line 12 of file TtFullLepKinSolver.cc.

References EventShape_.

    : topmass_begin(b), topmass_end(e), topmass_step(s), mw(mW), mb(mB), pxmiss_(0), pymiss_(0) {
  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

(

)

destructor

Definition at line 22 of file TtFullLepKinSolver.cc.

References EventShape_.

{ delete EventShape_; }

Member Function Documentation

TtDilepEvtSolution TtFullLepKinSolver::addKinSolInfo

(

TtDilepEvtSolution *

asol

)

Definition at line 24 of file TtFullLepKinSolver.cc.

References reco::LeafCandidate::energy(), FindCoeff(), genLV_n, genLV_n_, TtDilepEvtSolution::getCalJetB(), TtDilepEvtSolution::getCalJetBbar(), TtDilepEvtSolution::getElectronm(), TtDilepEvtSolution::getElectronp(), TtDilepEvtSolution::getGenN(), TtDilepEvtSolution::getGenNbar(), TtDilepEvtSolution::getMuonm(), TtDilepEvtSolution::getMuonp(), TtDilepEvtSolution::getTaum(), TtDilepEvtSolution::getTaup(), TtDilepEvtSolution::getWmDecay(), TtDilepEvtSolution::getWpDecay(), reco::LeafCandidate::px(), pxmiss_, reco::LeafCandidate::py(), pymiss_, reco::LeafCandidate::pz(), quartic(), TtDilepEvtSolution::setRecTopMass(), TtDilepEvtSolution::setRecWeightMax(), topmass_begin, topmass_end, topmass_step, TopRec(), useMCforBest_, histoStyle::weight, WeightSolfromMC(), and WeightSolfromShape().

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 ( const double *  c_coeff, double *  c_sol  ) const

private

Definition at line 372 of file TtFullLepKinSolver.cc.

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

Referenced by quartic().

                                                                        {
  unsigned 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 (unsigned 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 (unsigned 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, const double  mt, const double  mat, const double  pxboost, const double  pyboost, double *  q_coeff  )

private

Definition at line 157 of file TtFullLepKinSolver.cc.

References C, D, F, k16, relval_steps::k2, k26, k36, k46, k51, k56, k61, m1, m2, m3, 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 of first 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(mw) - sqr(mb)) / (2 * b_l.E()) - sqr(mw) / (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(mw, 4) / 4 + cpom3 * sqr(F) / sqr(n3) + sqr(mw) * l.Pz() * F / n3);
  l21 =
      1 / sqr(l.E()) *
      (-2 * cpom3 * F * m3 * n1 / n3 + sqr(mw) * (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(mw) * (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	(	const TLorentzVector &	LV_l,
		const TLorentzVector &	LV_l_,
		const TLorentzVector &	LV_b,
		const TLorentzVector &	LV_b_
	)

Definition at line 125 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(), TtFullLepKinSolver::NeutrinoSolution::weight, histoStyle::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  ) const

private

Definition at line 314 of file TtFullLepKinSolver.cc.

References b0, b1, b2, c, cubic(), d0, d1, h, mps_fire::i, sqr(), mathSSE::sqrt(), submitPVValidationJobs::t, w(), and z.

Referenced by addKinSolInfo(), and getNuSolution().

                                                                         {
  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;

  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 */

  int nreal = 0;
  px = koreny;
  t = sqrt(0.25 * sqr(z) - b0);
  for (int 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	(	const double	xx = 0,
		const double	yy = 0
	)

Definition at line 120 of file TtFullLepKinSolver.cc.

References pxmiss_, and pymiss_.

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

                                                                        {
  pxmiss_ = xx;
  pymiss_ = yy;
}

double TtFullLepKinSolver::sqr ( const double  x ) const

inlineprivate

Definition at line 80 of file TtFullLepKinSolver.h.

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

{ return (x * x); }

void TtFullLepKinSolver::SWAP ( double &  realone, double &  realtwo  ) const

private

Definition at line 450 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, const double  sol  )

private

Definition at line 275 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 43 of file TtFullLepKinSolver.h.

References PatBasicFWLiteJetAnalyzer_Selector_cfg::useMC, and useMCforBest_.

Referenced by TtDilepEvtSolutionMaker::produce().

{ useMCforBest_ = useMC; }

double TtFullLepKinSolver::WeightSolfromMC ( ) const

private

Definition at line 305 of file TtFullLepKinSolver.cc.

References genLV_n, genLV_n_, LV_n, LV_n_, and histoStyle::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 ( ) const

private

use the parametrized event shape to obtain the solution weight.

Definition at line 312 of file TtFullLepKinSolver.cc.

References EventShape_, LV_n, and LV_n_.

Referenced by addKinSolInfo(), and getNuSolution().

{ return EventShape_->Eval(LV_n.E(), LV_n_.E()); }

Member Data Documentation

double TtFullLepKinSolver::C

private

Definition at line 98 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::D

private

Definition at line 99 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

TF2* TtFullLepKinSolver::EventShape_

private

Event shape.

Definition at line 124 of file TtFullLepKinSolver.h.

Referenced by TtFullLepKinSolver(), WeightSolfromShape(), and ~TtFullLepKinSolver().

double TtFullLepKinSolver::F

private

Definition at line 100 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

TLorentzVector TtFullLepKinSolver::genLV_n

private

provisional

Definition at line 119 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), and WeightSolfromMC().

TLorentzVector TtFullLepKinSolver::genLV_n_

private

Definition at line 119 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), and WeightSolfromMC().

double TtFullLepKinSolver::k16

private

Definition at line 102 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::k26

private

Definition at line 103 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::k36

private

Definition at line 104 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::k46

private

Definition at line 105 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::k51

private

Definition at line 107 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::k56

private

Definition at line 106 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::k61

private

Definition at line 108 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

TLorentzVector TtFullLepKinSolver::LV_n

private

Definition at line 117 of file TtFullLepKinSolver.h.

Referenced by getNuSolution(), TopRec(), WeightSolfromMC(), and WeightSolfromShape().

TLorentzVector TtFullLepKinSolver::LV_n_

private

Definition at line 117 of file TtFullLepKinSolver.h.

Referenced by getNuSolution(), TopRec(), WeightSolfromMC(), and WeightSolfromShape().

TLorentzVector TtFullLepKinSolver::LV_t

private

Definition at line 117 of file TtFullLepKinSolver.h.

Referenced by TopRec().

TLorentzVector TtFullLepKinSolver::LV_t_

private

Definition at line 117 of file TtFullLepKinSolver.h.

Referenced by TopRec().

TLorentzVector TtFullLepKinSolver::LV_tt_t

private

Definition at line 117 of file TtFullLepKinSolver.h.

Referenced by TopRec().

TLorentzVector TtFullLepKinSolver::LV_tt_t_

private

Definition at line 117 of file TtFullLepKinSolver.h.

Referenced by TopRec().

double TtFullLepKinSolver::m1

private

Definition at line 109 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::m2

private

Definition at line 110 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::m3

private

Definition at line 111 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

const double TtFullLepKinSolver::mb

private

Definition at line 94 of file TtFullLepKinSolver.h.

Referenced by FindCoeff().

const double TtFullLepKinSolver::mw

private

Definition at line 92 of file TtFullLepKinSolver.h.

Referenced by FindCoeff().

double TtFullLepKinSolver::n1

private

Definition at line 112 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::n2

private

Definition at line 113 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::n3

private

Definition at line 114 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::pom

private

Definition at line 101 of file TtFullLepKinSolver.h.

Referenced by FindCoeff(), and TopRec().

double TtFullLepKinSolver::pxmiss_

private

Definition at line 96 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), getNuSolution(), and SetConstraints().

double TtFullLepKinSolver::pymiss_

private

Definition at line 96 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), getNuSolution(), and SetConstraints().

const double TtFullLepKinSolver::topmass_begin

private

Definition at line 86 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), and getNuSolution().

const double TtFullLepKinSolver::topmass_end

private

Definition at line 88 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), and getNuSolution().

const double TtFullLepKinSolver::topmass_step

private

Definition at line 90 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), and getNuSolution().

bool TtFullLepKinSolver::useMCforBest_

private

flag to swith from WeightSolfromMC() to WeightSolfromShape()

Definition at line 122 of file TtFullLepKinSolver.h.

Referenced by addKinSolInfo(), and useWeightFromMC().