NcBoost.cxx

Go to the documentation of this file.

 
#include "NcBoost.h"
#include "Riostream.h"
 
ClassImp(NcBoost); // Class implementation to enable ROOT I/O
 
NcBoost::NcBoost() : TObject()
{
 
 Double_t a[3]={0,0,0};
 fBeta.SetVector(a,"sph");
 fGamma=1;
 fDgamma=0;
 fDresult=0;
}

NcBoost::~NcBoost()
{
}

NcBoost::NcBoost(const NcBoost& b) : TObject(b)
{
 
 fBeta=b.fBeta;
 fGamma=b.fGamma;
 fDgamma=b.fDgamma;
 fDresult=b.fDresult;
}

void NcBoost::SetBeta(Nc3Vector& b)
{
 
 fBeta=b;
 Double_t beta2=fBeta.Dot(fBeta);
 Double_t dbeta2=fBeta.GetResultError();
 
 if (beta2 > 1.)
 {
  cout << " *NcBoost::SetBeta* beta > 1." << endl;
 }
 fGamma=0;
 fDgamma=0;
 Double_t temp=1.-beta2;
 if (temp > 0.)
 {
  fGamma=sqrt(1./temp);
  fDgamma=fabs(dbeta2/(2.*pow(temp,1.5)));
 }
}

void NcBoost::Set4Momentum(Nc4Vector& p)
{
 
 Double_t E=p.GetScalar();
 Double_t dE=p.GetResultError();
 if (E <= 0.)
 {
  cout << " *NcBoost::Set4Momentum* Unphysical situation." << endl;
  p.Data();
 }
 else
 {
  Nc3Vector b=p.Get3Vector();
  Double_t vb[3],eb[3];
  b.GetVector(vb,"car");
  b.GetErrors(eb,"car");
  b=b/E;
  for (Int_t i=0; i<3; i++)
  {
   eb[i]=sqrt(pow(eb[i]/E,2)+pow(vb[i]*dE/(E*E),2));
  }
  b.SetErrors(eb,"car");
  SetBeta(b);
 }
}

Nc3Vector NcBoost::GetBetaVector() const
{
 
 return fBeta;
}

Double_t NcBoost::GetBeta()
{
 
 Double_t norm=fBeta.GetNorm();
 fDresult=fBeta.GetResultError();
 return norm;
}

Double_t NcBoost::GetGamma()
{
 
 fDresult=fDgamma;
 return fGamma;
}

Double_t NcBoost::GetResultError() const
{
 
 return fDresult;
}

void NcBoost::Data(TString f)
{
 
 Double_t beta=fBeta.GetNorm();
 Double_t dbeta=fBeta.GetResultError();
 cout << " *NcBoost::Data* beta : " << beta << " error : " << dbeta
      << " gamma : " << fGamma << " error : " << fDgamma << endl;
 cout << "  Beta"; 
 fBeta.Data(f);
}

Nc4Vector NcBoost::Boost(Nc4Vector& v)
{
 
 Double_t beta=fBeta.GetNorm();
 Double_t dbeta=fBeta.GetResultError();
 
 Double_t beta2=pow(beta,2);
 
 if (beta > 1.e-10)
 {
  Double_t E=v.GetScalar();
  Double_t dE=v.GetResultError();
 
  Nc3Vector p=v.Get3Vector();
 
  Double_t pdotbeta=p.Dot(fBeta);
  Double_t dpdotbeta=p.GetResultError();
 
  // Determine the new vector components
  Double_t Eprim=fGamma*(E-pdotbeta);
 
  Double_t z=((fGamma-1.)*pdotbeta/beta2)-fGamma*E;
  Nc3Vector add=fBeta*z;
 
  // Determine errors on the new vector components
  Double_t dEprim=sqrt(pow((E-pdotbeta)*fDgamma,2)+pow(fGamma*dE,2)
                      +pow(fGamma*dpdotbeta,2));
  Double_t dz=sqrt( pow(((fGamma-1.)/beta2)*dpdotbeta,2) + pow(fGamma*dE,2)
                   +pow((
    ((2./beta)-(4.*pow(beta,3)-6.*pow(beta,5))/(2.*pow((pow(beta,4)-pow(beta,6)),1.5)))*pdotbeta
    +beta*E/pow(fGamma,3))*dbeta,2) );
 
  Double_t vb[3],eb[3];
  fBeta.GetVector(vb,"car");
  fBeta.GetErrors(eb,"car");
  for (Int_t i=0; i<3; i++)
  {
   eb[i]=sqrt(pow(z*eb[i],2)+pow(vb[i]*dz,2));
  }
  add.SetErrors(eb,"car");
 
  // Calculate the new 3-vector
  Nc3Vector pprim=p+add;
 
  // Set the components and errors of the new 4-vector 
  Nc4Vector w;
  w.Load(v);
  if (v.GetScalarFlag())
  {
   w.SetVector(Eprim,pprim);
   w.SetScalarError(dEprim);
  }
  else
  {
   w.Set3Vector(pprim);
  }
  return w;
 }
 else
 {
  return v;
 }
}

Nc4Vector NcBoost::Inverse(Nc4Vector& vprim)
{
 
 Double_t beta=fBeta.GetNorm();
 Double_t dbeta=fBeta.GetResultError();
 
 Double_t beta2=pow(beta,2);
 
 if (beta > 1.e-10)
 {
  Double_t Eprim=vprim.GetScalar();
  Double_t dEprim=vprim.GetResultError();
 
  Nc3Vector pprim=vprim.Get3Vector();
 
  Double_t pprimdotbeta=pprim.Dot(fBeta);
  Double_t dpprimdotbeta=pprim.GetResultError();
 
  // Determine the new vector components
  Double_t E=fGamma*(Eprim+pprimdotbeta);
 
  Double_t z=((fGamma-1.)*pprimdotbeta/beta2)+fGamma*Eprim;
  Nc3Vector add=fBeta*z;
 
  // Determine errors on the prime-vector components
  Double_t dE=sqrt(pow((Eprim+pprimdotbeta)*fDgamma,2)+pow(fGamma*dEprim,2)
                      +pow(fGamma*dpprimdotbeta,2));
  Double_t dz=sqrt( pow(((fGamma-1.)/beta2)*dpprimdotbeta,2) + pow(fGamma*dEprim,2)
                   +pow((
    ((2./beta)-(4.*pow(beta,3)-6.*pow(beta,5))/(2.*pow((pow(beta,4)-pow(beta,6)),1.5)))*pprimdotbeta
    -beta*Eprim/pow(fGamma,3))*dbeta,2) );
 
  Double_t vb[3],eb[3];
  fBeta.GetVector(vb,"car");
  fBeta.GetErrors(eb,"car");
  for (Int_t i=0; i<3; i++)
  {
   eb[i]=sqrt(pow(z*eb[i],2)+pow(vb[i]*dz,2));
  }
  add.SetErrors(eb,"car");
 
  // Calculate the new 3-vector
  Nc3Vector p=pprim+add;
 
  // Set the components and errors of the new 4-vector 
  Nc4Vector w;
  w.Load(vprim);
  if (vprim.GetScalarFlag())
  {
   w.SetVector(E,p);
   w.SetScalarError(dE);
  }
  else
  {
   w.Set3Vector(p);
  }
  return w;
 }
 else
 {
  return vprim;
 }
}