NcPosition.cxx

Go to the documentation of this file.

// Positions (r), errors (e), reference frames (f) and angular units (u)
// are specified via
//
//    SetPosition(Float_t* r,TString f,TString u)
//    SetPositionErrors(Float_t* e,TString f,TString u)
//
// under the following conventions :
//
// f="car" ==> r in Cartesian coordinates   (x,y,z)
// f="sph" ==> r in Spherical coordinates   (r,theta,phi)
// f="cyl" ==> r in Cylindrical coordinates (rho,phi,z)
//
// u="rad" ==> angles in radians
// u="deg" ==> angles in degrees
//
// The "f" and "u" facilities only serve as a convenient user interface.
// Internally the actual storage of the various components is performed
// in a unique way. This allows setting/retrieval of vector components in a
// user selected frame/unit convention at any time. 
//
// The metric unit scale for the coordinates can be defined by the user
// via the SetUnitScale() memberfunction.
// This enables standardised expressions using numerical values of
// physical constants by means of the GetUnitScale() memberfunction.
// By default the unit scale is set to meter, corresponding to invokation
// of SetUnitScale(1).
// The user can specify a certain required metric unit scale in retreiving
// position components and/or distances.
// Please refer to the corresponding member functions for further details.
//   
//
// Example :
// ---------
//
// NcPosition q;
// Float_t pos[3]={-1,25,7};
// Float_t err[3]={0.08,1.85,0.5};
// q.SetPosition(pos,"car");
// q.SetPositionErrors(pos,"car");
// Float_t loc[3],dloc[3];
// q.GetPosition(loc,"sph","deg");
// q.GetPositionErrors(dloc,"sph","deg");
//
//--- Author: Nick van Eijndhoven 06-feb-1999 Utrecht University
//- Modified: Nick van Eijndhoven, IIHE-VUB, Brussel, May 4, 2021  10:49Z
~~~
**/
 
#include "NcPosition.h"
#include "Riostream.h"
 
ClassImp(NcPosition); // Class implementation to enable ROOT I/O
 
NcPosition::NcPosition()
{
 
 fScale=1;
 fTstamp=0;
}

NcPosition::~NcPosition()
{
 
 if (fTstamp)
 {
  delete fTstamp;
  fTstamp=0;
 }
}

NcPosition::NcPosition(const NcPosition& p) : Nc3Vector(p)
{
 
 fScale=p.fScale;
 fTstamp=0;
 if (p.fTstamp) fTstamp=new NcTimestamp(*(p.fTstamp));
}

void NcPosition::SetPosition(Double_t* r,TString f,TString u)
{
 
 SetVector(r,f,u);
}

void NcPosition::SetPosition(Double_t r1,Double_t r2,Double_t r3,TString f,TString u)
{
 
 SetVector(r1,r2,r3,f,u);
}

void NcPosition::GetPosition(Double_t* r,TString f,TString u,Float_t scale) const
{
 
 Nc3Vector v=(Nc3Vector)(*this);
 if (scale>0) v*=fScale/scale;
 v.GetVector(r,f,u);
}

void NcPosition::SetPosition(Float_t* r,TString f,TString u)
{
 
 SetVector(r,f,u);
}

void NcPosition::GetPosition(Float_t* r,TString f,TString u,Float_t scale) const
{
 
 Nc3Vector v=(Nc3Vector)(*this);
 if (scale>0) v*=fScale/scale;
 v.GetVector(r,f,u);
}

NcPosition& NcPosition::GetPosition()
{
 
 return (*this);
}

void NcPosition::SetPosition(Nc3Vector& r)
{
 
 Double_t a[3];
 r.GetVector(a,"sph");
 SetVector(a,"sph");
 r.GetErrors(a,"car");
 SetErrors(a,"car");
}

void NcPosition::SetPositionErrors(Double_t* e,TString f,TString u)
{
 
 SetErrors(e,f,u);
}

void NcPosition::SetPositionErrors(Double_t e1,Double_t e2,Double_t e3,TString f,TString u)
{
 
 SetErrors(e1,e2,e3,f,u);
}

void NcPosition::GetPositionErrors(Double_t* e,TString f,TString u,Float_t scale) const
{
 
 Nc3Vector v=(Nc3Vector)(*this);
 if (scale>0) v*=fScale/scale;
 v.GetErrors(e,f,u);
}

void NcPosition::SetPositionErrors(Float_t* e,TString f,TString u)
{
 
 SetErrors(e,f,u);
}

void NcPosition::GetPositionErrors(Float_t* e,TString f,TString u,Float_t scale) const
{
 
 Nc3Vector v=(Nc3Vector)(*this);
 if (scale>0) v*=fScale/scale;
 v.GetErrors(e,f,u);
}

void NcPosition::ResetPosition()
{
 
 SetZero();
}

Double_t NcPosition::GetDistance(NcPosition& p,Float_t scale)
{
 
 Nc3Vector d=(Nc3Vector)p;
 Float_t pscale=p.GetUnitScale();
 if ((pscale/fScale > 1.1) || (fScale/pscale > 1.1)) d=d*(pscale/fScale);
 Nc3Vector q=(Nc3Vector)(*this);
 d=d-q;
 Double_t dist=d.GetNorm();
 fDresult=d.GetResultError();
 
 if (scale>0)
 {
  dist*=fScale/scale;
  fDresult*=fScale/scale;
 }
 return dist;
}

void NcPosition::SetUnitScale(Float_t s)
{
 
 if (s>0.)
 {
  fScale=s;
 }
 else
 {
  cout << " *NcPosition::SetUnitScale* Invalid argument s = " << s << endl;
 }
}

Float_t NcPosition::GetUnitScale() const
{
 
 return fScale;
}

void NcPosition::SetTimestamp(NcTimestamp& t)
{
 
 if (fTstamp) delete fTstamp;
 fTstamp=new NcTimestamp(t);
}

NcTimestamp* NcPosition::GetTimestamp()
{
 
 return fTstamp;
}

void NcPosition::RemoveTimestamp()
{
 
 if (fTstamp)
 {
  delete fTstamp;
  fTstamp=0;
 }
}

void NcPosition::Data(TString f,TString u) const
{
 
 Nc3Vector::Data(f,u);
 if (fNv) cout << "   Metric unit : " << fScale << " meter" << endl;
 if (fTstamp) fTstamp->Date(1);
}