* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.2 1999/09/29 09:24:28 fca
-Introduction of the Copyright and cvs Log
-
-*/
+// $Id$
///////////////////////////////////////////////////////////////////////////
// Class AliPosition
//
// Note :
// ------
-// Positions (r), errors (e) and reference frames (f) are specified via
+// Positions (r), errors (e), reference frames (f) and angular units (u)
+// are specified via
//
-// SetPosition(Float_t* r,TString f)
-// SetPositionErrors(Float_t* e,TString f)
+// SetPosition(Float_t* r,TString f,TString u)
+// SetPositionErrors(Float_t* e,TString f,TString u)
//
// under the following conventions :
//
// f="sph" ==> r in Spherical coordinates (r,theta,phi)
// f="cyl" ==> r in Cylindrical coordinates (rho,phi,z)
//
-// All angles are in radians.
+// 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 :
// ---------
// q.SetPosition(pos,"car");
// q.SetPositionErrors(pos,"car");
// Float_t loc[3],dloc[3];
-// q.GetPosition(loc,"sph");
-// q.GetPositionErrors(dloc,"sph");
+// q.GetPosition(loc,"sph","deg");
+// q.GetPositionErrors(dloc,"sph","deg");
//
//--- Author: Nick van Eijndhoven 06-feb-1999 UU-SAP Utrecht
+//- Modified: NvE $Date$ UU-SAP Utrecht
///////////////////////////////////////////////////////////////////////////
#include "AliPosition.h"
+#include "Riostream.h"
ClassImp(AliPosition) // Class implementation to enable ROOT I/O
AliPosition::AliPosition()
{
-// Creation of an AliPosition object and initialisation of parameters
+// Creation of an AliPosition object and initialisation of parameters.
+// The unit scale for position coordinates is initialised to cm.
+ fScale=1;
+ fTstamp=0;
}
///////////////////////////////////////////////////////////////////////////
AliPosition::~AliPosition()
{
// Destructor to delete dynamically allocated memory
+ if (fTstamp)
+ {
+ delete fTstamp;
+ fTstamp=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliPosition::AliPosition(const AliPosition& p) : Ali3Vector(p)
+{
+// Copy constructor
+ fScale=p.fScale;
+ fTstamp=0;
+ if (p.fTstamp) fTstamp=new AliTimestamp(*(p.fTstamp));
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::SetPosition(Double_t* r,TString f)
+void AliPosition::SetPosition(Double_t* r,TString f,TString u)
{
// Store position according to reference frame f
- SetVector(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+
+ SetVector(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::GetPosition(Double_t* r,TString f)
+void AliPosition::GetPosition(Double_t* r,TString f,TString u,Float_t scale) const
{
// Provide position according to reference frame f
- GetVector(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+//
+// By default the coordinates will be provided in the metric unit scale as
+// stored in the AliPosition object.
+// However, the user can select a different metric unit scale by
+// specification of the scale parameter.
+// The convention is that scale=1 corresponds to meter, so specification
+// of scale=0.01 will provide the position coordinates in cm.
+
+ Ali3Vector v=(Ali3Vector)(*this);
+ if (scale>0) v*=fScale/scale;
+ v.GetVector(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::SetPosition(Float_t* r,TString f)
+void AliPosition::SetPosition(Float_t* r,TString f,TString u)
{
// Store position according to reference frame f
- SetVector(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+
+ SetVector(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::GetPosition(Float_t* r,TString f)
+void AliPosition::GetPosition(Float_t* r,TString f,TString u,Float_t scale) const
{
// Provide position according to reference frame f
- GetVector(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+//
+// By default the coordinates will be provided in the metric unit scale as
+// stored in the AliPosition object.
+// However, the user can select a different metric unit scale by
+// specification of the scale parameter.
+// The convention is that scale=1 corresponds to meter, so specification
+// of scale=0.01 will provide the position coordinates in cm.
+
+ Ali3Vector v=(Ali3Vector)(*this);
+ if (scale>0) v*=fScale/scale;
+ v.GetVector(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
AliPosition& AliPosition::GetPosition()
SetErrors(a,"car");
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::SetPositionErrors(Double_t* r,TString f)
+void AliPosition::SetPositionErrors(Double_t* r,TString f,TString u)
{
// Store position errors according to reference frame f
- SetErrors(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+
+ SetErrors(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::GetPositionErrors(Double_t* r,TString f)
+void AliPosition::GetPositionErrors(Double_t* r,TString f,TString u,Float_t scale) const
{
// Provide position errors according to reference frame f
- GetErrors(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+//
+// By default the coordinate errors will be provided in the metric unit scale as
+// stored in the AliPosition object.
+// However, the user can select a different metric unit scale by
+// specification of the scale parameter.
+// The convention is that scale=1 corresponds to meter, so specification
+// of scale=0.01 will provide the position coordinate errors in cm.
+
+ Ali3Vector v=(Ali3Vector)(*this);
+ if (scale>0) v*=fScale/scale;
+ v.GetErrors(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::SetPositionErrors(Float_t* r,TString f)
+void AliPosition::SetPositionErrors(Float_t* r,TString f,TString u)
{
// Store position errors according to reference frame f
- SetErrors(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+
+ SetErrors(r,f,u);
}
///////////////////////////////////////////////////////////////////////////
-void AliPosition::GetPositionErrors(Float_t* r,TString f)
+void AliPosition::GetPositionErrors(Float_t* r,TString f,TString u,Float_t scale) const
{
// Provide position errors according to reference frame f
- GetErrors(r,f);
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The default is u="rad".
+//
+// By default the coordinate errors will be provided in the metric unit scale as
+// stored in the AliPosition object.
+// However, the user can select a different metric unit scale by
+// specification of the scale parameter.
+// The convention is that scale=1 corresponds to meter, so specification
+// of scale=0.01 will provide the position coordinate errors in cm.
+
+ Ali3Vector v=(Ali3Vector)(*this);
+ if (scale>0) v*=fScale/scale;
+ v.GetErrors(r,f,u);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliPosition::ResetPosition()
+{
+// Reset the position and corresponding errors to 0.
+ Double_t r[3]={0,0,0};
+ SetVector(r,"sph");
+ SetErrors(r,"car");
+}
+///////////////////////////////////////////////////////////////////////////
+Double_t AliPosition::GetDistance(AliPosition& p,Float_t scale)
+{
+// Provide distance of the current AliPosition to position p.
+// The error on the result can be obtained as usual by invoking
+// GetResultError() afterwards.
+//
+// By default the distance will be provided in the metric unit scale of
+// the current AliPosition.
+// This implies that the results of r1.GetDistance(r2) and r2.GetDistance(r1)
+// may be numerically different in case r1 and r2 have different metric units.
+// However, the user can specify a required metric unit scale by specification
+// of the scale parameter.
+// The convention is that scale=1 corresponds to meter, so specification
+// of scale=0.01 will provide the distance in cm.
+// As such it is possible to obtain a correctly computed distance even in case
+// the position coordinates have a different unit scale.
+// However, it is recommended to work always with one single unit scale.
+//
+ Ali3Vector d=(Ali3Vector)p;
+ Float_t pscale=p.GetUnitScale();
+ if ((pscale/fScale > 1.1) || (fScale/pscale > 1.1)) d=d*(pscale/fScale);
+ Ali3Vector q=(Ali3Vector)(*this);
+ d=d-q;
+ Double_t dist=d.GetNorm();
+ fDresult=d.GetResultError();
+
+ if (scale>0)
+ {
+ dist*=fScale/scale;
+ fDresult*=fScale/scale;
+ }
+ return dist;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliPosition::SetUnitScale(Float_t s)
+{
+// Set the unit scale for the position coordinates.
+// The scale is normalised w.r.t. the meter, so setting the unit scale
+// to 0.01 means that all position coordinates are in cm.
+// By default the unit scale is set to meter in the AliPosition constructor.
+// It is recommended to use one single unit scale throughout a complete
+// analysis and/or simulation project.
+//
+// Note : This memberfunction does not modify the numerical values of
+// the position coordinates.
+// It only specifies their numerical meaning.
+//
+ if (s>0.)
+ {
+ fScale=s;
+ }
+ else
+ {
+ cout << " *AliPosition::SetUnitScale* Invalid argument s = " << s << endl;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+Float_t AliPosition::GetUnitScale() const
+{
+// Provide the unit scale for the position coordinates.
+// The scale is normalised w.r.t. the meter, so a unit scale of 0.01
+// means that all position coordinates are in cm.
+ return fScale;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliPosition::SetTimestamp(AliTimestamp& t)
+{
+// Store the timestamp for this position.
+ if (fTstamp) delete fTstamp;
+ fTstamp=new AliTimestamp(t);
+}
+///////////////////////////////////////////////////////////////////////////
+AliTimestamp* AliPosition::GetTimestamp()
+{
+// Provide the timestamp of this position.
+ return fTstamp;
}
///////////////////////////////////////////////////////////////////////////
+void AliPosition::RemoveTimestamp()
+{
+// Remove the timestamp from this postion.
+ if (fTstamp)
+ {
+ delete fTstamp;
+ fTstamp=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliPosition::Data(TString f,TString u) const
+{
+// Provide all position/time information within the coordinate frame f.
+//
+// The string argument "u" allows to choose between different angular units
+// in case e.g. a spherical frame is selected.
+// u = "rad" : angles provided in radians
+// "deg" : angles provided in degrees
+//
+// The defaults are f="car" and u="rad".
+
+ Ali3Vector::Data(f,u);
+ cout << " Metric unit : " << fScale << " meter" << endl;
+ if (fTstamp) fTstamp->Date(1);
+}
+///////////////////////////////////////////////////////////////////////////
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff