tauImpactParameter::TauA1NuConstrainedFitter Class Reference

#include <TauA1NuConstrainedFitter.h>

Inheritance diagram for tauImpactParameter::TauA1NuConstrainedFitter:

Public Types
enum	ExpandedPars { a1_vx =9, a1_vy, a1_vz, nexpandedpar }
enum	OrignialPars { norigpar =13 }
enum	Pars {   tau_phi =0, tau_theta, a1_px, a1_py,   a1_pz, a1_m, nu_px, nu_py,   nu_pz, npar }
Public Types inherited from tauImpactParameter::MultiProngTauSolver
enum	Ambiguity { zero, minus, plus, NAmbiguity }

Public Member Functions
bool	fit ()
LorentzVectorParticle	getMother ()
std::vector< LorentzVectorParticle >	getRefitDaughters ()
double	getTauRotationSignificance ()
	TauA1NuConstrainedFitter (unsigned int ambiguity, const LorentzVectorParticle &A1, const TVector3 &PVertex, const TMatrixTSym< double > &VertexCov)
	~TauA1NuConstrainedFitter () override
Public Member Functions inherited from tauImpactParameter::MultiProngTauSolver
	MultiProngTauSolver ()
virtual	~MultiProngTauSolver ()

Private Member Functions
void	UpdateExpandedPar ()

Static Private Member Functions
static TVectorT< double >	ComputeA1LorentzVectorPar (const TVectorT< double > &inpar)
static TVectorT< double >	ComputeExpParToPar (const TVectorT< double > &inpar)
static TVectorT< double >	ComputeInitalExpPar (const TVectorT< double > &inpar)
static TVectorT< double >	ComputeMotherLorentzVectorPar (const TVectorT< double > &inpar)
static TVectorT< double >	ComputeNuLorentzVectorPar (const TVectorT< double > &inpar)
static void	CovertParToObjects (const TVectorD &v, TLorentzVector &a1, TLorentzVector &nu, double &phi, double &theta, TVector3 &TauDir)
static TVectorT< double >	SolveAmbiguityAnalytically (const TVectorT< double > &inpar, unsigned int ambiguity)
static TVectorT< double >	SolveAmbiguityAnalyticallywithRot (const TVectorT< double > &inpar, unsigned int ambiguity)
static TVectorT< double >	TauRot (const TVectorT< double > &inpar)

Private Attributes
unsigned int	ambiguity_
TMatrixTSym< double >	cov
TMatrixTSym< double >	cov_0
TMatrixTSym< double >	expcov
TVectorT< double >	exppar
TVectorT< double >	par
TVectorT< double >	par_0
std::vector< LorentzVectorParticle >	particles_

Additional Inherited Members
Static Public Member Functions inherited from tauImpactParameter::MultiProngTauSolver
static void	analyticESolver (TLorentzVector &nu_plus, TLorentzVector &nu_minus, const TLorentzVector &A1, bool &isReal)
static LorentzVectorParticle	estimateNu (const LorentzVectorParticle &a1, const TVector3 &pv, int ambiguity, TLorentzVector &tau)
static void	numericalESolver (TLorentzVector &nu_plus, TLorentzVector &nu_minus, const TLorentzVector &A1, bool &isReal)
static void	quadratic (double &x_plus, double &x_minus, double a, double b, double c, bool &isReal)
static TVectorT< double >	rotateToTauFrame (const TVectorT< double > &inpar)
static bool	setTauDirectionatThetaGJMax (const TLorentzVector &a1, double &theta, double &phi, double scale=1.0)
static void	solveByRotation (const TVector3 &TauDir, const TLorentzVector &A1, TLorentzVector &Tau_plus, TLorentzVector &Tau_minus, TLorentzVector &nu_plus, TLorentzVector &nu_minus, bool &isReal, bool rotateback=true)
static double	thetaGJMax (const TLorentzVector &a1)

Detailed Description

Definition at line 21 of file TauA1NuConstrainedFitter.h.

Member Enumeration Documentation

enum tauImpactParameter::TauA1NuConstrainedFitter::ExpandedPars

Enumerator
a1_vx
a1_vy
a1_vz
nexpandedpar

Definition at line 27 of file TauA1NuConstrainedFitter.h.

{a1_vx=9,a1_vy,a1_vz,nexpandedpar};

enum tauImpactParameter::TauA1NuConstrainedFitter::OrignialPars

Enumerator
norigpar

Definition at line 28 of file TauA1NuConstrainedFitter.h.

{norigpar=13};

enum tauImpactParameter::TauA1NuConstrainedFitter::Pars

Enumerator
tau_phi
tau_theta
a1_px
a1_py
a1_pz
a1_m
nu_px
nu_py
nu_pz
npar

Definition at line 26 of file TauA1NuConstrainedFitter.h.

{tau_phi=0,tau_theta,a1_px,a1_py,a1_pz,a1_m,nu_px,nu_py,nu_pz,npar};

Constructor & Destructor Documentation

TauA1NuConstrainedFitter::TauA1NuConstrainedFitter	(	unsigned int	ambiguity,
		const LorentzVectorParticle &	A1,
		const TVector3 &	PVertex,
		const TMatrixTSym< double > &	VertexCov
	)

Definition at line 15 of file TauA1NuConstrainedFitter.cc.

References tauImpactParameter::Particle::bField(), ComputeExpParToPar(), ComputeInitalExpPar(), cov, cov_0, tauImpactParameter::Particle::covariance(), expcov, exppar, mps_fire::i, nexpandedpar, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, npar, TtFullLepDaughter::Nu, tauImpactParameter::PDGInfo::nu_tau, tauImpactParameter::LorentzVectorParticle::NVertex, par, par_0, tauImpactParameter::LorentzVectorParticle::parameter(), particles_, tauImpactParameter::ErrorMatrixPropagator::propagateError(), findQualityFiles::size, tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, and tauImpactParameter::LorentzVectorParticle::vz.

                                                                                                                                                                      :
  MultiProngTauSolver(),
  ambiguity_(ambiguity)
{
  TLorentzVector Tau(0,0,0,0);
  //dummy substitution not used later
  TVectorT<double> nu_par(LorentzVectorParticle::NLorentzandVertexPar,1);
  TMatrixTSym<double> nu_cov(LorentzVectorParticle::NLorentzandVertexPar); 
  LorentzVectorParticle Nu(nu_par,nu_cov,PDGInfo::nu_tau,0.0,A1.bField()); 
  particles_.push_back(A1);
  particles_.push_back(Nu);
  
  // setup 13 by 13 matrix
  int size=LorentzVectorParticle::NVertex+particles_.size()*LorentzVectorParticle::NLorentzandVertexPar;
  TVectorT<double>    inpar(size);
  TMatrixTSym<double> incov(size);

  // Get primary vertex information
  if(VertexCov.GetNrows()!=LorentzVectorParticle::NVertex)return;
  inpar(LorentzVectorParticle::vx)=PVertex.X();
  inpar(LorentzVectorParticle::vy)=PVertex.Y();
  inpar(LorentzVectorParticle::vz)=PVertex.Z();  
  for(int i=0; i<LorentzVectorParticle::NVertex;i++){
    for(int j=0; j<LorentzVectorParticle::NVertex;j++)incov(i,j)=VertexCov(i,j);
  }
  int A1offset=LorentzVectorParticle::NVertex;
  int Nuoffset=LorentzVectorParticle::NLorentzandVertexPar+LorentzVectorParticle::NVertex;
  for(int i=0; i<LorentzVectorParticle::NLorentzandVertexPar;i++){
    inpar(i+A1offset)=A1.parameter(i);
    inpar(i+Nuoffset)=Nu.parameter(i)+1.0;// offset by 1 GeV to prevent convergence on first iteration
    for(int j=0; j<LorentzVectorParticle::NLorentzandVertexPar;j++){
      incov(i+A1offset,j+A1offset)=A1.covariance(i,j);
      incov(i+Nuoffset,j+Nuoffset)=Nu.covariance(i,j);
    }
  }

  exppar.ResizeTo(nexpandedpar,1);
  exppar=ComputeInitalExpPar(inpar);
  expcov.ResizeTo(nexpandedpar,nexpandedpar);
  expcov=ErrorMatrixPropagator::propagateError(&TauA1NuConstrainedFitter::ComputeInitalExpPar,inpar,incov);

  TVectorT<double> PAR_0(npar);
  par_0.ResizeTo(npar);
  cov_0.ResizeTo(npar,npar);
  PAR_0=ComputeExpParToPar(exppar);
  for(int i=0; i<npar;i++)par_0(i)=PAR_0(i);
  cov_0=ErrorMatrixPropagator::propagateError(&TauA1NuConstrainedFitter::ComputeExpParToPar,exppar,expcov);

  for(int i=0; i<npar;i++){
    for(int j=0;j<npar;j++){cov_0(i,j)=expcov(i,j);}
  }

  par.ResizeTo(npar);
  par=par_0;
  cov.ResizeTo(npar,npar);
  cov=cov_0;
}

tauImpactParameter::TauA1NuConstrainedFitter::~TauA1NuConstrainedFitter ( )

inlineoverride

Definition at line 24 of file TauA1NuConstrainedFitter.h.

{};

Member Function Documentation

TVectorT< double > TauA1NuConstrainedFitter::ComputeA1LorentzVectorPar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 113 of file TauA1NuConstrainedFitter.cc.

References a1_m, a1_px, a1_py, a1_pz, a1_vx, a1_vy, a1_vz, tauImpactParameter::LorentzVectorParticle::m, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, and tauImpactParameter::LorentzVectorParticle::vz.

Referenced by ComputeMotherLorentzVectorPar(), and getRefitDaughters().

                                                                                                 {
  TVectorT<double> outpar(LorentzVectorParticle::NLorentzandVertexPar);
  outpar(LorentzVectorParticle::vx)=inpar(a1_vx);
  outpar(LorentzVectorParticle::vy)=inpar(a1_vy);
  outpar(LorentzVectorParticle::vz)=inpar(a1_vz);
  outpar(LorentzVectorParticle::px)=inpar(a1_px);
  outpar(LorentzVectorParticle::py)=inpar(a1_py);
  outpar(LorentzVectorParticle::pz)=inpar(a1_pz);
  outpar(LorentzVectorParticle::m)=inpar(a1_m);
  return outpar;
}

TVectorT< double > TauA1NuConstrainedFitter::ComputeExpParToPar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 95 of file TauA1NuConstrainedFitter.cc.

References mps_fire::i, and npar.

Referenced by TauA1NuConstrainedFitter().

                                                                                          {
  TVectorT<double> outpar(npar);
  for(int i=0;i<npar;i++){outpar(i)=inpar(i);}
  return outpar;
}

TVectorT< double > TauA1NuConstrainedFitter::ComputeInitalExpPar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 73 of file TauA1NuConstrainedFitter.cc.

References a1_m, a1_px, a1_py, a1_pz, a1_vx, a1_vy, a1_vz, tauImpactParameter::LorentzVectorParticle::m, nexpandedpar, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, nu_px, nu_py, nu_pz, tauImpactParameter::LorentzVectorParticle::NVertex, PFRecoTauDiscriminationByIsolation_cfi::offset, MetAnalyzer::pv(), tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, pfDeepBoostedJetPreprocessParams_cfi::sv, tau_phi, tau_theta, tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, and tauImpactParameter::LorentzVectorParticle::vz.

Referenced by TauA1NuConstrainedFitter().

                                                                                           {
  TVectorT<double> outpar(nexpandedpar);
  int offset=LorentzVectorParticle::NVertex;// for A1
  TVector3 pv(inpar(LorentzVectorParticle::vx),inpar(LorentzVectorParticle::vy),inpar(LorentzVectorParticle::vz));
  TVector3 sv(inpar(LorentzVectorParticle::vx+offset),inpar(LorentzVectorParticle::vy+offset),inpar(LorentzVectorParticle::vz+offset));
  TVector3 TauDir=sv-pv;
  outpar(tau_phi)=TauDir.Phi();
  outpar(tau_theta)=TauDir.Theta();
  outpar(a1_px)=inpar(LorentzVectorParticle::px+offset);
  outpar(a1_py)=inpar(LorentzVectorParticle::py+offset);
  outpar(a1_pz)=inpar(LorentzVectorParticle::pz+offset);
  outpar(a1_m)=inpar(LorentzVectorParticle::m+offset);
  outpar(a1_vx)=inpar(LorentzVectorParticle::vx+offset);
  outpar(a1_vy)=inpar(LorentzVectorParticle::vy+offset);
  outpar(a1_vz)=inpar(LorentzVectorParticle::vz+offset);
  offset+=LorentzVectorParticle::NLorentzandVertexPar; // for Nu
  outpar(nu_px)=inpar(LorentzVectorParticle::px+offset);
  outpar(nu_py)=inpar(LorentzVectorParticle::py+offset);
  outpar(nu_pz)=inpar(LorentzVectorParticle::pz+offset);
  return outpar;
}

TVectorT< double > TauA1NuConstrainedFitter::ComputeMotherLorentzVectorPar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 125 of file TauA1NuConstrainedFitter.cc.

References a1_m, a1_px, a1_py, a1_pz, ComputeA1LorentzVectorPar(), ComputeNuLorentzVectorPar(), mps_fire::i, tauImpactParameter::LorentzVectorParticle::m, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, nu_px, nu_py, nu_pz, tauImpactParameter::LorentzVectorParticle::NVertex, tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, and mathSSE::sqrt().

Referenced by getMother().

                                                                                                     {
  TVectorT<double> outpar(LorentzVectorParticle::NLorentzandVertexPar);
  TVectorT<double> nupar=ComputeNuLorentzVectorPar(inpar);
  TVectorT<double> a1par=ComputeA1LorentzVectorPar(inpar);
  for(int i=0;i<LorentzVectorParticle::NLorentzandVertexPar;i++){
    if(i<LorentzVectorParticle::NVertex){outpar(i)=a1par(i);}
    else{outpar(i)=nupar(i)+a1par(i);}
    //if(i==LorentzVectorParticle::m) outpar(i,0)=PDGInfo::tau_mass();
  }
  double nu_px = nupar(LorentzVectorParticle::px);
  double nu_py = nupar(LorentzVectorParticle::py);
  double nu_pz = nupar(LorentzVectorParticle::pz); 
  double Enu2  = nu_px*nu_px + nu_py*nu_py + nu_pz*nu_pz;
  double a1_px = a1par(LorentzVectorParticle::px);
  double a1_py = a1par(LorentzVectorParticle::py);
  double a1_pz = a1par(LorentzVectorParticle::pz);
  double a1_m =  a1par(LorentzVectorParticle::m);
  double Ea12  = a1_px*a1_px + a1_py*a1_py + a1_pz*a1_pz + a1_m*a1_m;
  double outpar_px = outpar(LorentzVectorParticle::px);
  double outpar_py = outpar(LorentzVectorParticle::py);
  double outpar_pz = outpar(LorentzVectorParticle::pz);
  double P2=outpar_px*outpar_px + outpar_py*outpar_py + outpar_pz*outpar_pz;
   outpar(LorentzVectorParticle::m)=sqrt(std::fabs(Enu2 + Ea12 + 2*sqrt(Enu2*Ea12)-P2));
  return outpar;
}

TVectorT< double > TauA1NuConstrainedFitter::ComputeNuLorentzVectorPar ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 101 of file TauA1NuConstrainedFitter.cc.

References a1_vx, a1_vy, a1_vz, tauImpactParameter::LorentzVectorParticle::m, tauImpactParameter::LorentzVectorParticle::NLorentzandVertexPar, nu_px, nu_py, nu_pz, tauImpactParameter::LorentzVectorParticle::px, tauImpactParameter::LorentzVectorParticle::py, tauImpactParameter::LorentzVectorParticle::pz, tauImpactParameter::LorentzVectorParticle::vx, tauImpactParameter::LorentzVectorParticle::vy, and tauImpactParameter::LorentzVectorParticle::vz.

Referenced by ComputeMotherLorentzVectorPar(), and getRefitDaughters().

                                                                                                 {
  TVectorT<double> outpar(LorentzVectorParticle::NLorentzandVertexPar);
  outpar(LorentzVectorParticle::vx)=inpar(a1_vx);
  outpar(LorentzVectorParticle::vy)=inpar(a1_vy);
  outpar(LorentzVectorParticle::vz)=inpar(a1_vz);
  outpar(LorentzVectorParticle::px)=inpar(nu_px);
  outpar(LorentzVectorParticle::py)=inpar(nu_py);
  outpar(LorentzVectorParticle::pz)=inpar(nu_pz);
  outpar(LorentzVectorParticle::m)=0;
  return outpar;
}

void TauA1NuConstrainedFitter::CovertParToObjects ( const TVectorD &  v, TLorentzVector &  a1, TLorentzVector &  nu, double &  phi, double &  theta, TVector3 &  TauDir  )

staticprivate

Definition at line 184 of file TauA1NuConstrainedFitter.cc.

References a1_m, a1_px, a1_py, a1_pz, nu_px, nu_py, nu_pz, mathSSE::sqrt(), tau_phi, tau_theta, and findQualityFiles::v.

Referenced by SolveAmbiguityAnalytically(), SolveAmbiguityAnalyticallywithRot(), and TauRot().

                                                                                                                                                   {
  a1=TLorentzVector(v(a1_px),v(a1_py),v(a1_pz),sqrt(v(a1_m)*v(a1_m)+v(a1_px)*v(a1_px)+v(a1_py)*v(a1_py)+v(a1_pz)*v(a1_pz)));
  nu=TLorentzVector(v(nu_px),v(nu_py),v(nu_pz),sqrt(v(nu_px)*v(nu_px)+v(nu_py)*v(nu_py)+v(nu_pz)*v(nu_pz)));
  phi=v(tau_phi);
  theta=v(tau_theta);
  TauDir.SetMagThetaPhi(1.0,theta,phi);
}

bool TauA1NuConstrainedFitter::fit

(

void

)

Definition at line 192 of file TauA1NuConstrainedFitter.cc.

References a1_m, a1_px, a1_py, a1_pz, ambiguity_, funct::cos(), cov, cov_0, mps_fire::i, tauImpactParameter::MultiProngTauSolver::minus, npar, par, tauImpactParameter::MultiProngTauSolver::plus, tauImpactParameter::ErrorMatrixPropagator::propagateError(), funct::sin(), SolveAmbiguityAnalytically(), SolveAmbiguityAnalyticallywithRot(), tauImpactParameter::MultiProngTauSolver::solveByRotation(), mathSSE::sqrt(), tau_phi, tau_theta, theta(), and tauImpactParameter::MultiProngTauSolver::zero.

Referenced by trackingPlots.Iteration::modules(), and PFTau3ProngReco::produce().

                                  {
  // Check if Tau Direction is unphysical and if nessicary set the starting point to Theta_{GJ-Max}
  TLorentzVector a1(par(a1_px),par(a1_py),par(a1_pz),sqrt(par(a1_m)*par(a1_m)+par(a1_px)*par(a1_px)+par(a1_py)*par(a1_py)+par(a1_pz)*par(a1_pz)));
  double phi(par(tau_phi)),theta(par(tau_theta));
  TLorentzVector Tau_plus,Tau_minus,nu_plus,nu_minus;
  TVector3 TauDir(cos(phi)*sin(theta),sin(phi)*sin(theta),cos(theta));
  bool isReal;
  solveByRotation(TauDir,a1,Tau_plus,Tau_minus,nu_plus,nu_minus,isReal);

  //check that the do product of the a1 and tau is positive, otherwise there is no information for tau direction -> use zero solution
  if(TauDir.Dot(a1.Vect())<0){
    isReal=false;
  }

  //case 1: is real then solve analytically
  if(isReal && (ambiguity_==plus || ambiguity_==minus)){
    // popogate errors
    TVectorT<double> par_tmp=TauA1NuConstrainedFitter::SolveAmbiguityAnalytically(par,ambiguity_);
    cov=ErrorMatrixPropagator::propagateError(std::bind(TauA1NuConstrainedFitter::SolveAmbiguityAnalytically,std::placeholders::_1,ambiguity_),par,cov_0);
    for(int i=0; i<npar;i++) par(i)=par_tmp(i);
    return true;
  }
  // case 2 is in unphsyical region - rotate and substitue \theta_{GJ} with \theta_{GJ}^{Max} and then solve analytically
  else if(!isReal && ambiguity_==zero){
    TVectorT<double> par_tmp=TauA1NuConstrainedFitter::SolveAmbiguityAnalyticallywithRot(par,ambiguity_);
    cov=ErrorMatrixPropagator::propagateError(std::bind(TauA1NuConstrainedFitter::SolveAmbiguityAnalyticallywithRot,std::placeholders::_1,ambiguity_),par,cov_0);
    for(int i=0; i<npar;i++) par(i)=par_tmp(i);
    return true;
  }
  return false;
}

LorentzVectorParticle TauA1NuConstrainedFitter::getMother

(

)

Definition at line 174 of file TauA1NuConstrainedFitter.cc.

References funct::abs(), b, EnergyCorrector::c, ComputeMotherLorentzVectorPar(), expcov, exppar, mps_fire::i, funct::m, particles_, tauImpactParameter::ErrorMatrixPropagator::propagateError(), tauImpactParameter::PDGInfo::tau_minus, and UpdateExpandedPar().

Referenced by PFTau3ProngReco::produce().

                                                         {
  UpdateExpandedPar();
  double c(0),b(0);
  for(unsigned int i=0;i<particles_.size();i++){c+=particles_[i].charge();b=particles_[i].bField();}
  TVectorT<double> m=ComputeMotherLorentzVectorPar(exppar);
  TMatrixTSym<double> mcov=ErrorMatrixPropagator::propagateError(&TauA1NuConstrainedFitter::ComputeMotherLorentzVectorPar,exppar,expcov);
  LorentzVectorParticle mymother= LorentzVectorParticle(m,mcov,(int)(-1.0*std::abs(PDGInfo::tau_minus)*c),c,b);
  return mymother;
}

std::vector< LorentzVectorParticle > TauA1NuConstrainedFitter::getRefitDaughters

(

)

Definition at line 160 of file TauA1NuConstrainedFitter.cc.

References b, EnergyCorrector::c, ComputeA1LorentzVectorPar(), ComputeNuLorentzVectorPar(), expcov, exppar, mps_fire::i, tauImpactParameter::PDGInfo::nu_tau, particles_, common_cff::pdgId, tauImpactParameter::ErrorMatrixPropagator::propagateError(), and UpdateExpandedPar().

Referenced by PFTau3ProngReco::produce().

                                                                            {
  std::vector<LorentzVectorParticle> refitParticles;
  UpdateExpandedPar();
  double c(0),b(0);
  for(unsigned int i=0;i<particles_.size();i++){c+=particles_[i].charge();b=particles_[i].bField();}
  TVectorT<double> a1=ComputeA1LorentzVectorPar(exppar);
  TMatrixTSym<double> a1cov=ErrorMatrixPropagator::propagateError(&TauA1NuConstrainedFitter::ComputeA1LorentzVectorPar,exppar,expcov);
  refitParticles.push_back(LorentzVectorParticle(a1,a1cov,particles_[0].pdgId(),c,b));
  TVectorT<double> nu=ComputeNuLorentzVectorPar(exppar);
  TMatrixTSym<double> nucov=ErrorMatrixPropagator::propagateError(&TauA1NuConstrainedFitter::ComputeNuLorentzVectorPar,exppar,expcov);
  refitParticles.push_back(LorentzVectorParticle(nu,nucov,PDGInfo::nu_tau,0.0,b));
  return refitParticles;
}

double TauA1NuConstrainedFitter::getTauRotationSignificance

(

)

Definition at line 267 of file TauA1NuConstrainedFitter.cc.

References cov_0, par, tauImpactParameter::ErrorMatrixPropagator::propagateError(), mathSSE::sqrt(), and TauRot().

                                                           {
  TVectorT<double> par_tmp=TauA1NuConstrainedFitter::TauRot(par);
  TMatrixTSym<double> cov_tmp=ErrorMatrixPropagator::propagateError(&TauA1NuConstrainedFitter::TauRot,par,cov_0);
  if(!(cov_tmp(0,0)>0)) return -999; // return invalid value if the covariance is unphysical (safety flag)
  if(par_tmp(0)>0)    return par_tmp(0)/sqrt(cov_tmp(0,0)); // return the significance if the value is in the unphysical region
  return 0; // reutrn 0 for the rotation significance if the tau is in the physical region
}

TVectorT< double > TauA1NuConstrainedFitter::SolveAmbiguityAnalytically ( const TVectorT< double > &  inpar, unsigned int  ambiguity  )

staticprivate

Definition at line 225 of file TauA1NuConstrainedFitter.cc.

References CovertParToObjects(), mps_fire::i, nu_px, nu_py, nu_pz, tauImpactParameter::MultiProngTauSolver::plus, tauImpactParameter::MultiProngTauSolver::solveByRotation(), and theta().

Referenced by fit(), and SolveAmbiguityAnalyticallywithRot().

                                                                                                                    {
  // Solve equation quadratic equation
  TVectorT<double> outpar(inpar.GetNrows());
  TLorentzVector a1,nu;
  double phi(0),theta(0);
  TVector3 TauDir;
  CovertParToObjects(inpar,a1,nu,phi,theta,TauDir);
  TLorentzVector a1_d=a1;
  TLorentzVector nu_d=nu;
  TLorentzVector Tau_plus,Tau_minus,nu_plus,nu_minus;
  bool isReal;
  solveByRotation(TauDir,a1_d,Tau_plus,Tau_minus,nu_plus,nu_minus,isReal,true);
  if(amb==plus)nu=nu_plus;
  else nu=nu_minus;
  for(int i=0; i<outpar.GetNrows();i++){ outpar(i)=inpar(i);}
  outpar(nu_px)=nu.Px(); 
  outpar(nu_py)=nu.Py(); 
  outpar(nu_pz)=nu.Pz(); 
  return outpar;
}

TVectorT< double > TauA1NuConstrainedFitter::SolveAmbiguityAnalyticallywithRot ( const TVectorT< double > &  inpar, unsigned int  ambiguity  )

staticprivate

Definition at line 246 of file TauA1NuConstrainedFitter.cc.

References funct::cos(), CovertParToObjects(), mps_fire::i, funct::sin(), SolveAmbiguityAnalytically(), tau_phi, tau_theta, theta(), and tauImpactParameter::MultiProngTauSolver::thetaGJMax().

Referenced by fit().

                                                                                                                                 {
  // Rotate and subsitute \theta_{GJ} with \theta_{GJ}^{Max} - assumes uncertianty on thata and phi of the a1 or small compared to the tau direction. 
  TVectorT<double> outpar(inpar.GetNrows());
  TLorentzVector a1,nu;
  double phi(0),theta(0);
  TVector3 TauDir;
  CovertParToObjects(inpar,a1,nu,phi,theta,TauDir);
  double theta_a1(a1.Theta()),phi_a1(a1.Phi()),theta_GJMax(thetaGJMax(a1));
  TauDir.RotateZ(-phi_a1);
  TauDir.RotateY(-theta_a1);
  double phiprime(TauDir.Phi());
  TauDir=TVector3(sin(theta_GJMax)*cos(phiprime),sin(theta_GJMax)*sin(phiprime),cos(theta_GJMax));
  TauDir.RotateY(theta_a1);
  TauDir.RotateZ(phi_a1);
  for(int i=0; i<outpar.GetNrows();i++) outpar(i)=inpar(i);
  outpar(tau_phi)=TauDir.Phi();
  outpar(tau_theta)=TauDir.Theta();
  return SolveAmbiguityAnalytically(outpar,ambiguity);
}

TVectorT< double > TauA1NuConstrainedFitter::TauRot ( const TVectorT< double > &  inpar )

staticprivate

Definition at line 276 of file TauA1NuConstrainedFitter.cc.

References CovertParToObjects(), theta(), and tauImpactParameter::MultiProngTauSolver::thetaGJMax().

Referenced by getTauRotationSignificance().

                                                                              {
  TVectorT<double> outpar(1);
  TLorentzVector a1,nu;
  double phi(0),theta(0);
  TVector3 TauDir;
  CovertParToObjects(inpar,a1,nu,phi,theta,TauDir);
  double theta_a1(a1.Theta()),phi_a1(a1.Phi()),theta_GJMax(thetaGJMax(a1));
  TauDir.RotateZ(-phi_a1);
  TauDir.RotateY(-theta_a1);
  outpar(0)=(TauDir.Theta()-theta_GJMax);
  return outpar;
}

void TauA1NuConstrainedFitter::UpdateExpandedPar ( )

private

Definition at line 151 of file TauA1NuConstrainedFitter.cc.

References cov, expcov, exppar, mps_fire::i, npar, and par.

Referenced by getMother(), and getRefitDaughters().

                                                {
  // assumes changes to a1 correlation to vertex is small
  if(par.GetNrows()==npar && cov.GetNrows()==npar && exppar.GetNrows()==npar && expcov.GetNrows()==npar) return;
  for(int i=0; i<npar;i++){
    exppar(i)=par(i);
    for(int j=0; j<npar;j++){expcov(i,j)=cov(i,j);}
  }
}

Member Data Documentation

unsigned int tauImpactParameter::TauA1NuConstrainedFitter::ambiguity_

private

Definition at line 57 of file TauA1NuConstrainedFitter.h.

Referenced by fit().

TMatrixTSym<double> tauImpactParameter::TauA1NuConstrainedFitter::cov

private

Definition at line 52 of file TauA1NuConstrainedFitter.h.

Referenced by fit(), TauA1NuConstrainedFitter(), and UpdateExpandedPar().

TMatrixTSym<double> tauImpactParameter::TauA1NuConstrainedFitter::cov_0

private

Definition at line 51 of file TauA1NuConstrainedFitter.h.

Referenced by fit(), getTauRotationSignificance(), and TauA1NuConstrainedFitter().

TMatrixTSym<double> tauImpactParameter::TauA1NuConstrainedFitter::expcov

private

Definition at line 55 of file TauA1NuConstrainedFitter.h.

Referenced by getMother(), getRefitDaughters(), TauA1NuConstrainedFitter(), and UpdateExpandedPar().

TVectorT<double> tauImpactParameter::TauA1NuConstrainedFitter::exppar

private

Definition at line 54 of file TauA1NuConstrainedFitter.h.

Referenced by getMother(), getRefitDaughters(), TauA1NuConstrainedFitter(), and UpdateExpandedPar().

TVectorT<double> tauImpactParameter::TauA1NuConstrainedFitter::par

private

Definition at line 50 of file TauA1NuConstrainedFitter.h.

Referenced by fit(), getTauRotationSignificance(), TauA1NuConstrainedFitter(), and UpdateExpandedPar().

TVectorT<double> tauImpactParameter::TauA1NuConstrainedFitter::par_0

private

Definition at line 49 of file TauA1NuConstrainedFitter.h.

Referenced by TauA1NuConstrainedFitter().

std::vector<LorentzVectorParticle> tauImpactParameter::TauA1NuConstrainedFitter::particles_

private

Definition at line 56 of file TauA1NuConstrainedFitter.h.

Referenced by getMother(), getRefitDaughters(), and TauA1NuConstrainedFitter().