12-may-2004 NvE Track reference-point introduced in AliTrack.
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Jun 2004 15:24:00 +0000 (15:24 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Jun 2004 15:24:00 +0000 (15:24 +0000)
02-jun-2004 NvE Memberfunction GetUnprimed introduced for Ali3Vector.
17-jun-2004 NvE New class AliHelix introduced and "macgcclib" added to create ralice libs on MAC.

RALICE/Ali3Vector.cxx
RALICE/Ali3Vector.h
RALICE/AliHelix.cxx [new file with mode: 0644]
RALICE/AliHelix.h [new file with mode: 0644]
RALICE/AliTrack.cxx
RALICE/AliTrack.h
RALICE/RALICEHeaders.h
RALICE/RALICELinkDef.h
RALICE/history.txt
RALICE/libRALICE.pkg
RALICE/scripts/macgcclib [new file with mode: 0644]

index b123d8d..853b439 100644 (file)
@@ -849,3 +849,33 @@ Ali3Vector Ali3Vector::GetPrimed(TRotMatrix* m) const
  return v;
 }
 ///////////////////////////////////////////////////////////////////////////
+Ali3Vector Ali3Vector::GetUnprimed(TRotMatrix* m) const
+{
+// Provide original vector components (and errors) from the rotated ones.
+// The orientation of the rotated frame is described by the TRotMatrix
+// input argument.
+// So, this is the inverse of the GetPrimed() memberfunction.
+// This memberfunction makes use of the fact that the inverse of a certain
+// TRotMatrix is given by its transposed matrix.
+ Ali3Vector v=*this;
+ if (!m) return v;
+
+ Double_t* mat=m->GetMatrix();
+
+ Double_t a[3],aprim[3];
+
+ GetVector(aprim,"car");
+ a[0]=aprim[0]*mat[0]+aprim[1]*mat[3]+aprim[2]*mat[6];
+ a[1]=aprim[0]*mat[1]+aprim[1]*mat[4]+aprim[2]*mat[7];
+ a[2]=aprim[0]*mat[2]+aprim[1]*mat[5]+aprim[2]*mat[8];
+ v.SetVector(a,"car");
+
+ GetErrors(aprim,"car");
+ a[0]=sqrt(pow(aprim[0]*mat[0],2)+pow(aprim[1]*mat[3],2)+pow(aprim[2]*mat[6],2));
+ a[1]=sqrt(pow(aprim[0]*mat[1],2)+pow(aprim[1]*mat[4],2)+pow(aprim[2]*mat[7],2));
+ a[2]=sqrt(pow(aprim[0]*mat[2],2)+pow(aprim[1]*mat[5],2)+pow(aprim[2]*mat[8],2));
+ v.SetErrors(a,"car");
+
+ return v;
+}
+///////////////////////////////////////////////////////////////////////////
index 6edf3d7..c00fc5a 100644 (file)
@@ -44,12 +44,13 @@ class Ali3Vector
   Ali3Vector GetVecTrans() const;                // Provide transverse vector w.r.t. z-axis
   Ali3Vector GetVecLong() const;                 // Provide longitudinal vector w.r.t. z-axis
   Ali3Vector GetPrimed(TRotMatrix* m) const;     // Provide vector components in a rotated frame
+  Ali3Vector GetUnprimed(TRotMatrix* m) const;   // Provide original vector components from a rotated one
 
  protected:
   Double_t fV,fTheta,fPhi;    // Vector in spherical coordinates
   Double_t fDx,fDy,fDz;       // Errors on Cartesian coordinates
   Double_t fDresult;          // Error on scalar result (e.g. norm or dotproduct)
 
- ClassDef(Ali3Vector,7) // Handling of 3-vectors in various reference frames.
+ ClassDef(Ali3Vector,8) // Handling of 3-vectors in various reference frames.
 };
 #endif
diff --git a/RALICE/AliHelix.cxx b/RALICE/AliHelix.cxx
new file mode 100644 (file)
index 0000000..d569c27
--- /dev/null
@@ -0,0 +1,817 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+// $Id$
+
+///////////////////////////////////////////////////////////////////////////
+// Class AliHelix
+// Representation and extrapolation of AliTracks in a magnetic field.
+//
+// This class is meant to provide a means to display and extrapolate
+// AliTrack objects in the presence of a constant homogeneous magnetic field. 
+//
+// Examples :
+// ==========
+//
+// Display and extrapolation of individual tracks 
+// ----------------------------------------------
+// Float_t vec[3];
+// AliPosition r1;
+// Ali3Vector p;
+// AliTrack t;
+//
+// vec[0]=0;
+// vec[1]=0;
+// vec[2]=0;
+// r1.SetVector(vec,"car");
+//
+// vec[0]=1;
+// vec[1]=0;
+// vec[2]=0.3;
+// p.SetVector(vec,"car");
+//
+// t.Set3Momentum(p);
+// t.SetBeginPoint(r1);
+// t.SetCharge(-1);
+// t.SetMass(0.139);
+//
+// // The magnetic field vector in Tesla
+// Ali3Vector b;
+// vec[0]=0;
+// vec[1]=0;
+// vec[2]=1;
+// b.SetVector(vec,"car");
+//
+// AliHelix* helix=new AliHelix();
+// helix->SetB(b);
+// helix->SetTofmax(1e-7);
+//
+// TCanvas* c1=new TCanvas("c1","c1");
+// TView* view=new TView(1);
+// view->SetRange(-1000,-1000,-1000,1000,1000,1000);
+// view->ShowAxis();
+//
+// // Track displays 
+// Double_t range[2]={0,600};
+// helix->Display(&t,range,3);
+// t.SetCharge(-t.GetCharge());
+// helix->Display(&t);
+//
+// // Track extrapolation
+// Double_t pars[3]={550,0.001,3};
+// AliPosition* rext=helix->Extrapolate(&t,pars);
+// if (rext) rext->Data();
+// ======================================================================
+//
+// Online display of events generated via AliCollider
+// -------------------------------------------------- 
+// Int_t nevents=5;   // Number of events to be generated
+// Int_t jrun=1;      // The run number of this batch of generated events
+//
+// cout << " ***" << endl;
+// cout << " *** AliCollider run for " << nevents << " events." << endl; 
+// cout << " ***" << endl;
+//
+// AliCollider* gen=new AliCollider();
+//
+// gen->OpenFortranFile(6,"dump.log");
+//
+// gen->SetVertexMode(2);
+// gen->SetResolution(1e-4);
+//
+// gen->SetRunNumber(jrun);
+// gen->SetPrintFreq(1);
+//
+// gen->SetSpectatorPmin(0.01);
+//
+// Int_t zp=1;
+// Int_t ap=1;
+// Int_t zt=2;
+// Int_t at=4;
+//
+// gen->Init("fixt",zp,ap,zt,at,158);
+//
+// AliHelix* helix=new AliHelix();
+// Float_t vec[3]={0,2,0};
+// Ali3Vector b;
+// b.SetVector(vec,"car");
+// helix->SetB(b);
+//
+// helix->Refresh(-1); // Refresh display after each event
+//
+// TCanvas* c1=new TCanvas("c1","c1");
+// TView* view=new TView(1);
+// view->SetRange(-200,-200,-200,200,200,200);
+// view->ShowAxis();
+//
+// // Prepare random number sequence for this run
+// // to obtain the number of participants for each event
+// AliRandom rndm(abs(jrun));
+// Float_t* rans=new Float_t[nevents];
+// rndm.Uniform(rans,nevents,2,ap+at);
+// Int_t npart=0;
+// Int_t ntk=0;
+// for (Int_t i=0; i<nevents; i++)
+// {
+//  npart=rans[i];
+//  gen->MakeEvent(npart);
+//  AliEvent* evt=gen->GetEvent();
+//  if (evt)
+//  {
+//   helix->Display(evt);
+//   c1->Update();
+//   gSystem->Sleep(5000); // Some delay to keep the display on screen
+//  }
+// }
+// ======================================================================
+//
+//--- Author: Nick van Eijndhoven 17-jun-2004 Utrecht University
+//- Modified: NvE $Date$ Utrecht University
+///////////////////////////////////////////////////////////////////////////
+
+#include "AliHelix.h"
+#include "Riostream.h"
+ClassImp(AliHelix) // Class implementation to enable ROOT I/O
+AliHelix::AliHelix() : THelix()
+{
+// Default constructor
+ fRefresh=0;
+ fCurves=0;
+ fExt=0;
+ fTofmax=1e-8;
+}
+///////////////////////////////////////////////////////////////////////////
+AliHelix::~AliHelix()
+{
+// Destructor to delete dynamically allocated memory.
+ if (fCurves)
+ {
+  delete fCurves;
+  fCurves=0;
+ }
+ if (fExt)
+ {
+  delete fExt;
+  fExt=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliHelix::AliHelix(const AliHelix& h) : THelix(h)
+{
+// Copy constructor
+ fB=h.fB;
+ fRefresh=h.fRefresh;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliHelix::SetB(Ali3Vector& b)
+{
+// Set the magnetic field vector in Tesla.
+ fB=b;
+
+ if (fB.GetNorm()>0)
+ {
+  Double_t axis[3];
+  fB.GetVector(axis,"car");
+  SetAxis(axis);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+Ali3Vector& AliHelix::GetB()
+{
+// Provide the magnetic field vector in Tesla.
+ return fB;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliHelix::SetTofmax(Float_t tof)
+{
+// Set the maximum time of flight for straight tracks in seconds.
+// This maximum tof will be used for drawing etc... in case no begin
+// and endpoints can be determined from the track info.
+// Notes :
+// -------
+// 1) In case the user specifies an explicit range, it will override
+//    the maximum tof limit.
+// 2) By default the tofmax is set to 10 ns in the AliHelix constructor.
+ fTofmax=tof;
+}
+///////////////////////////////////////////////////////////////////////////
+Float_t AliHelix::GetTofmax() const
+{
+// Provide the maximum time of flight for straight tracks in seconds.
+ return fTofmax;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliHelix::MakeCurve(AliTrack* t,Double_t* range,Int_t iaxis,Double_t scale)
+{
+// Make the helix curve for the specified AliTrack.
+// Detailed information of all the helix points can be obtained via the
+// GetN() and GetP() memberfunctions of TPolyLine3D.
+// In case one wants to display or extrapolate an AliTrack it is preferable
+// to use the Display() or Extrapolate() memberfunctions.
+// It is assumed that the track charge is stored in elementary units
+// (i.e. charge=1 for a proton) and that the track energy is stored in GeV.
+// The input argument "scale" specifies the unit scale for the various
+// locations where scale=0.01 indicates unit scales in cm etc...
+// In case scale<=0, the unit scale for locations is determined from the
+// begin, reference or endpoint of the track. If neither of these
+// positions is present, all locations are assumed to be given in cm.
+// The lower and upper bounds for the range are specified by range[0] and
+// range[1] and the argument "iaxis" indicates along which axis this range
+// is specified.
+// The range can be specified either in the LAB frame or in the Helix frame.
+// The latter is the frame in which the Z axis points in the B direction.
+//
+// The conventions for the "iaxis" argument are the following :
+// iaxis = 1 ==> X axis in the LAB frame
+//         2 ==> Y axis in the LAB frame
+//         3 ==> Z axis in the LAB frame
+//        -1 ==> X axis in the Helix frame
+//        -2 ==> Y axis in the Helix frame
+//        -3 ==> Z axis in the Helix frame
+//
+// In case range=0 the begin/end/reference points of the AliTrack and the
+// maximum time of flight (see the SetTofmax() memberfunction) will be used
+// and an appropriate choice for the iaxis parameter will be made automatically
+// based on the track kinematics.
+// In case the reference point is not present, the begin or endpoint will be used
+// as reference point for the 3-momentum specification. If neither of these positions
+// is present, (0,0,0) will be taken as the reference point.
+// 
+// The default values are range=0, iaxis=3 and scale=-1.
+
+ SetPolyLine(0); // Reset the polyline data points
+
+ if (!t || (range && !iaxis)) return;
+
+ Double_t energy=t->GetEnergy();
+ Double_t betanorm=t->GetBeta();
+
+ if (energy<=0 || betanorm<=0) return;
+
+ AliPosition* rbeg=t->GetBeginPoint();
+ AliPosition* rend=t->GetEndPoint();
+ AliPosition* rref=t->GetReferencePoint();
+
+ // Magnetic field vector or default Z-direction
+ Double_t bvec[3]={0,0,1};
+ if (fB.GetNorm()>0) fB.GetVector(bvec,"car");
+
+ // The unit scale for locations if not specified by the user
+ if (scale<=0)
+ {
+  scale=0.01; // Set default to cm
+  if (rbeg)
+  {
+   scale=rbeg->GetUnitScale();
+  }
+  else if (rend)
+  {
+   scale=rend->GetUnitScale();
+  }
+  else if (rref)
+  {
+   scale=rref->GetUnitScale();
+  }
+ }
+
+ Double_t c=2.99792458e8/scale; // Lightspeed in the selected unit scale
+
+ // The helix angular frequency
+ Double_t w=9e7*(t->GetCharge()*fB.GetNorm())/energy;
+
+ // The particle velocity in the LAB frame
+ Ali3Vector beta=t->GetBetaVector();
+ Ali3Vector v=beta*c;
+ Double_t vel[3];
+ v.GetVector(vel,"car");
+
+ // The particle velocity in the Helix frame
+ Ali3Vector betaprim=beta.GetPrimed(fRotMat);
+ v=v.GetPrimed(fRotMat);
+ Double_t velprim[3];
+ v.GetVector(velprim,"car");
+
+ // Check compatibility of velocity and range specification.
+ if (range)
+ {
+  Double_t betavec[3];
+  if (iaxis>0) beta.GetVector(betavec,"car");
+  if (iaxis<0) betaprim.GetVector(betavec,"car");
+  if (fabs(betavec[abs(iaxis)-1])/betanorm<1e-10) return;
+ }
+
+ // The LAB location in which the velocity of the particle is defined
+ Double_t loc[3]={0,0,0};
+ Ali3Vector* rx=0;
+ Double_t scalex=0;
+ if (rref)
+ {
+  rx=(Ali3Vector*)rref;
+  scalex=rref->GetUnitScale();
+ }
+ else if (rbeg)
+ {
+  rx=(Ali3Vector*)rbeg;
+  scalex=rbeg->GetUnitScale();
+ }
+ else if (rend)
+ {
+  rx=(Ali3Vector*)rend;
+  scalex=rend->GetUnitScale();
+ }
+
+ if (rx)
+ {
+  if (scalex/scale>1.1 || scale/scalex>1.1) (*rx)*=scalex/scale;
+  rx->GetVector(loc,"car");
+ }
+
+ // Initialisation of Helix kinematics
+ SetHelix(loc,vel,w,0,kUnchanged,bvec);
+
+ Int_t bend=0;
+ if (fabs(w)>0 && fabs(fVt)>0) bend=1;
+
+ // Flight time boundaries.
+ // The time origin t=0 is chosen to indicate the position in which
+ // the particle velocity was defined.
+ // The total flight time is initialised to the (user specified) tofmax.
+ Double_t tmin=0,tmax=0;
+ Double_t tof=fTofmax;
+ Double_t dum=0;
+
+ // The trajectory begin and end points
+ Double_t vec1[3]={0,0,0};
+ Double_t vec2[3]={0,0,0};
+ Ali3Vector r1;
+ Ali3Vector r2;
+ Double_t scale1=0.01;
+ Double_t scale2=0.01;
+
+ if (!bend)
+ {
+  ////////////////////////////////////////
+  // Treatment of straight trajectories //
+  ////////////////////////////////////////
+  Ali3Vector r;
+  if (range) // Specified range allows for exact flight time boundaries
+  {
+   if (iaxis>0)
+   {
+    tmin=(range[0]-loc[iaxis-1])/vel[iaxis-1];
+    tmax=(range[1]-loc[iaxis-1])/vel[iaxis-1];
+   }
+   else
+   {
+    loc[0]=fX0;
+    loc[1]=fY0;
+    loc[2]=fZ0;
+    tmin=(range[0]-loc[abs(iaxis)-1])/velprim[abs(iaxis)-1];
+    tmax=(range[1]-loc[abs(iaxis)-1])/velprim[abs(iaxis)-1];
+   }
+   if (tmax<tmin)
+   {
+    dum=tmin;
+    tmin=tmax;
+    tmax=dum;
+   }
+   // Make the 'curve' in the LAB frame and exit.
+   // Use the parametrisation : r(t)=r0+t*v
+   // using the range based flight time boundaries.
+   // An additional point in the middle of the trajectory is
+   // generated in view of accuracy in the case of extrapolations.
+   tof=tmax-tmin;
+   v=beta*c;
+   if (rx) r1=(*rx);
+   r=v*tmin;
+   r1=r1+r;
+   r1.GetVector(vec1,"car");
+   SetNextPoint(float(vec1[0]),float(vec1[1]),float(vec1[2]));
+   r=v*(tof/2.);
+   r2=r1+r;
+   r2.GetVector(vec2,"car");
+   SetNextPoint(float(vec2[0]),float(vec2[1]),float(vec2[2]));
+   r=v*tof;
+   r2=r1+r;
+   r2.GetVector(vec2,"car");
+   SetNextPoint(float(vec2[0]),float(vec2[1]),float(vec2[2]));
+  }
+  else // Automatic range determination
+  {
+   // Initially the point with Z=0 in the Helix frame is taken as a starting point.
+   // In case this point can't be reached, the point in which the particle velocity
+   // was defined is taken as the starting point.
+   // The endpoint is initially obtained by applying the tofmax from the start point.
+   tmin=0;
+   if (fabs(fVz)>0) tmin=-fZ0/fVz;
+   v=beta*c;
+   if (rx) r1=(*rx);
+   r=v*tmin;
+   r1=r1+r;
+
+   // Override the initial begin and endpoint settings by the track data
+   if (rbeg)
+   {
+    r1=(Ali3Vector)(*rbeg); 
+    scale1=rbeg->GetUnitScale();
+    // All coordinates in the selected unit scale
+    if (scale1/scale>1.1 || scale/scale1>1.1) r1*=scale1/scale;
+   }
+
+   r=v*fTofmax;
+   r2=r1+r;
+   if (rend)
+   {
+    r2=(Ali3Vector)(*rend); 
+    scale2=rend->GetUnitScale();
+    // All coordinates in the selected unit scale
+    if (scale2/scale>1.1 || scale/scale2>1.1) r2*=scale2/scale;
+   }
+   
+   r1.GetVector(vec1,"car");
+   r2.GetVector(vec2,"car");
+
+   // Make the 'curve' in the LAB frame and exit.
+   SetNextPoint(float(vec1[0]),float(vec1[1]),float(vec1[2]));
+   SetNextPoint(float(vec2[0]),float(vec2[1]),float(vec2[2]));
+  }
+ }
+ else
+ {
+  //////////////////////////////////////
+  // Treatment of curved trajectories //
+  //////////////////////////////////////
+
+  // Initialisation of the flight time boundaries.
+  // Based on the constant motion of the particle along the Helix Z-axis,
+  // the parametrisation z(t)=z0+fVz*t in the Helix frame is used. 
+  // If possible the point with Z=0 in the Helix frame is taken as a starting point.
+  // In case this point can't be reached, the point in which the particle velocity
+  // was defined is taken as the starting point.
+  tmin=0;
+  if (fabs(fVz)>0) tmin=-fZ0/fVz;
+  tmax=tmin+fTofmax;
+
+  if (tmax<tmin)
+  {
+   dum=tmin;
+   tmin=tmax;
+   tmax=dum;
+  }
+
+  // Determination of the range in the helix frame
+
+  if (!range) // Automatic range determination
+  {
+   scale1=0.01;
+   scale2=0.01;
+   if (rbeg)
+   {
+    r1=rbeg->GetPrimed(fRotMat);
+    scale1=rbeg->GetUnitScale();
+    // All coordinates in the selected unit scale
+    if (scale1/scale>1.1 || scale/scale1>1.1) r1*=scale1/scale;
+    // Re-calculate the tmin for this new starting point
+    r1.GetVector(vec1,"car");
+    if (abs(fVz)>0) tmin=(vec1[2]-fZ0)/fVz;
+    tmax=tmin+fTofmax;
+   }
+   if (rend)
+   {
+    r2=rend->GetPrimed(fRotMat);
+    scale2=rend->GetUnitScale();
+    // All coordinates in the selected unit scale
+    if (scale2/scale>1.1 || scale/scale2>1.1) r2*=scale2/scale;
+    r2.GetVector(vec2,"car");
+    if (abs(fVz)>0) tmax=(vec2[2]-fZ0)/fVz;
+   }
+   // Make the curve on basis of the flight time boundaries and exit
+   if (tmax<tmin)
+   {
+    dum=tmin;
+    tmin=tmax;
+    tmax=dum;
+   }
+   SetRange(tmin,tmax,kHelixT);
+  }
+  else // User explicitly specified range
+  {
+   vec1[abs(iaxis)-1]=range[0];
+   vec2[abs(iaxis)-1]=range[1];
+   r1.SetVector(vec1,"car");
+   r2.SetVector(vec2,"car");
+   if (iaxis>0) // Range specified in LAB frame
+   {
+    r1=r1.GetPrimed(fRotMat);
+    r1.GetVector(vec1,"car");
+    r2=r2.GetPrimed(fRotMat);
+    r2.GetVector(vec2,"car");
+   } 
+   // Determination of the axis component with the
+   // largest range difference
+   Double_t dmax=0;
+   Int_t imax=0;
+   Double_t test=0;
+   for (Int_t i=0; i<3; i++)
+   {
+    test=fabs(vec1[i]-vec2[i]);
+    if (test>dmax)
+    {
+     dmax=test;
+     imax=i;
+    }
+   }
+
+   Double_t rmin=vec1[imax];
+   Double_t rmax=vec2[imax];
+   if (rmax<rmin)
+   {
+    dum=rmin;
+    rmin=rmax;
+    rmax=dum;
+   }
+
+   // The kinematic range boundaries in the helix frame
+   Double_t xmin=fX0-fVt/fW;
+   Double_t xmax=fX0+fVt/fW;
+   Double_t ymin=fY0-fVt/fW;
+   Double_t ymax=fY0+fVt/fW;
+
+   if (xmax<xmin)
+   {
+    dum=xmin;
+    xmin=xmax;
+    xmax=dum;
+   }
+   if (ymax<ymin)
+   {
+    dum=ymin;
+    ymin=ymax;
+    ymax=dum;
+   }
+
+   // Set the range for the helix
+   if (imax==2 && dmax>0) SetRange(rmin,rmax,kHelixZ);
+   if (imax==1)
+   {
+    // Limit range to kinematic boundaries if needed
+    if (rmin<=ymin) rmin=ymin+1e-6*dmax;
+    if (rmax>=ymax) rmax=ymax-1e-6*dmax;
+    if (rmin<rmax) SetRange(rmin,rmax,kHelixY);
+   }
+   if (imax==0)
+   {
+    // Limit range to kinematic boundaries if needed
+    if (rmin<=xmin) rmin=xmin+1e-6*dmax;
+    if (rmax>=xmax) rmax=xmax-1e-6*dmax;
+    if (rmin<rmax) SetRange(rmin,rmax,kHelixX);
+   }
+  }
+ }
+ return;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliHelix::Display(AliTrack* t,Double_t* range,Int_t iaxis,Double_t scale)
+{
+// Display the helix curve of an AliTrack.
+// Various curves can be displayed together or individually; please refer to
+// the memberfunction Refresh() for further details.
+// It is assumed that the track charge is stored in elementary units
+// (i.e. charge=1 for a proton) and that the track energy is stored in GeV.
+// The input argument "scale" specifies the unit scale for the various
+// locations where scale=0.01 indicates unit scales in cm etc...
+// In case scale<=0, the unit scale for locations is determined from the
+// begin, reference or endpoint of the track. If neither of these
+// positions is present, all locations are assumed to be given in cm.
+// The lower and upper bounds for the range are specified by range[0] and
+// range[1] and the argument "iaxis" indicates along which axis this range
+// is specified.
+// The range can be specified either in the LAB frame or in the Helix frame.
+// The latter is the frame in which the Z axis points in the B direction.
+//
+// The conventions for the "iaxis" argument are the following :
+// iaxis = 1 ==> X axis in the LAB frame
+//         2 ==> Y axis in the LAB frame
+//         3 ==> Z axis in the LAB frame
+//        -1 ==> X axis in the Helix frame
+//        -2 ==> Y axis in the Helix frame
+//        -3 ==> Z axis in the Helix frame
+//
+// In case range=0 the begin/end/reference points of the AliTrack and the
+// maximum time of flight (see the SetTofmax() memberfunction) will be used
+// and an appropriate choice for the iaxis parameter will be made automatically
+// based on the track kinematics.
+// In case the reference point is not present, the begin or endpoint will be used
+// as reference point for the 3-momentum specification. If neither of these positions
+// is present, (0,0,0) will be taken as the reference point.
+// 
+// The default values are range=0, iaxis=3 and scale=-1.
+//
+// Note :
+// ------
+// Before any display activity, a TCanvas and a TView have to be initiated
+// first by the user like for instance
+// 
+// TCanvas* c1=new TCanvas("c1","c1");
+// TView* view=new TView(1);
+// view->SetRange(-1000,-1000,-1000,1000,1000,1000);
+// view->ShowAxis();
+
+ if (!t || (range && !iaxis)) return;
+
+ MakeCurve(t,range,iaxis,scale);
+
+ if (fRefresh>0) Refresh(fRefresh);
+
+ Int_t np=GetN();
+ if (!np) return;
+
+ Float_t* points=GetP();
+ TPolyLine3D* curve=new TPolyLine3D(np,points);
+
+ curve->SetLineWidth(2);
+ Float_t q=t->GetCharge();
+ curve->SetLineColor(kGreen);
+ if (q>0) curve->SetLineColor(kRed);
+ if (q<0) curve->SetLineColor(kBlue);
+ curve->Draw();
+
+ if (!fCurves)
+ {
+  fCurves=new TObjArray();
+  fCurves->SetOwner();
+ }
+ fCurves->Add(curve);
+}
+///////////////////////////////////////////////////////////////////////////
+void AliHelix::Refresh(Int_t mode)
+{
+// Refresh the display screen before showing the next curve.
+//
+// mode = 0 : refreshing fully under user control.
+//        1 : the display screen will be refreshed automatically
+//            at each individual track display.
+//       -1 : the display screen will be refreshed automatically
+//            at each event display.
+//
+// The default is mode=0.
+
+ if (abs(mode)<2) fRefresh=mode;
+ if (fCurves) fCurves->Delete();
+}
+///////////////////////////////////////////////////////////////////////////
+void AliHelix::Display(AliEvent* evt,Double_t* range,Int_t iaxis,Double_t scale)
+{
+// Display the helix curves of all tracks of the specified event.
+// Various events can be displayed together or individually; please refer to
+// the memberfunction Refresh() for further details.
+// Please refer to the track display memberfunction for further details
+// on the input arguments.
+// 
+// The default values are range=0, iaxis=3 and scale=-1.
+//
+// Note :
+// ------
+// Before any display activity, a TCanvas and a TView have to be initiated
+// first by the user like for instance
+// 
+// TCanvas* c1=new TCanvas("c1","c1");
+// TView* view=new TView(1);
+// view->SetRange(-1000,-1000,-1000,1000,1000,1000);
+// view->ShowAxis();
+
+ if (!evt) return;
+
+ if (fRefresh<0) Refresh(fRefresh);
+
+ Int_t ntk=evt->GetNtracks();
+ for (Int_t jtk=1; jtk<=ntk; jtk++)
+ {
+  AliTrack* tx=evt->GetTrack(jtk);
+  if (tx) Display(tx,range,iaxis,scale);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliPosition* AliHelix::Extrapolate(AliTrack* t,Double_t* pars,Double_t scale)
+{
+// Extrapolate an AliTrack according to the corresponding helix curve
+// and provide a pointer to the impact position w.r.t. a specified plane.
+// In case the track can never reach the specified plane, the returned
+// position pointer is zero.
+// Detailed information of all the helix points used in the extrapolation
+// can be obtained via the GetN() and GetP() memberfunctions of TPolyLine3D.
+// It is assumed that the track charge is stored in elementary units
+// (i.e. charge=1 for a proton) and that the track energy is stored in GeV.
+// The input argument "scale" specifies the unit scale for the various
+// locations where scale=0.01 indicates unit scales in cm etc...
+// In case scale<=0, the unit scale for locations is determined from the
+// begin, reference or endpoint of the track. If neither of these
+// positions is present, all locations are assumed to be given in cm.
+// The extrapolation parameters for the impact plane and required accuracy
+// are specified by pars[0], pars[1] and pars[2], respectively.
+// pars[0] = coordinate value of the plane for the impact point
+// pars[1] = required accuracy on the specified impact plane coordinate
+// pars[2] = the axis along which the value of par[0] is specified
+//
+// The parameters can be specified either w.r.t. the LAB frame or the Helix frame.
+// The latter is the frame in which the Z axis points in the B direction.
+//
+// The conventions for the par[2] argument are the following :
+// par[2] = 1 ==> X axis in the LAB frame
+//          2 ==> Y axis in the LAB frame
+//          3 ==> Z axis in the LAB frame
+//         -1 ==> X axis in the Helix frame
+//         -2 ==> Y axis in the Helix frame
+//         -3 ==> Z axis in the Helix frame
+//
+// Example :
+// ---------
+// To obtain an extrapolation to the plane Z=0 in the LAB frame
+// with an accuracy of 0.001 cm the input arguments would be
+// pars[0]=0  pars[1]=0.001  pars[2]=3  scale=0.01
+//
+// Note : The default value for the scale is -1.
+
+ if (fExt)
+ {
+  delete fExt;
+  fExt=0;
+ }
+
+ if (!t || !pars) return fExt;
+
+ AliPosition* rbeg=t->GetBeginPoint();
+ AliPosition* rend=t->GetEndPoint();
+ AliPosition* rref=t->GetReferencePoint();
+
+ // The unit scale for locations if not specified by the user
+ if (scale<=0)
+ {
+  scale=0.01; // Set default to cm
+  if (rbeg)
+  {
+   scale=rbeg->GetUnitScale();
+  }
+  else if (rend)
+  {
+   scale=rend->GetUnitScale();
+  }
+  else if (rref)
+  {
+   scale=rref->GetUnitScale();
+  }
+ }
+
+ Double_t range[2];
+ range[0]=pars[0]-fabs(pars[1])/2.;
+ range[1]=pars[0]+fabs(pars[1])/2.;
+
+ Int_t iaxis=int(pars[2]);
+
+ MakeCurve(t,range,iaxis,scale);
+
+ Int_t np=GetN();
+ if (!np) return fExt;
+
+ Float_t* points=GetP();
+
+ // First point of the curve around the impact
+ Int_t ip=0;
+ Float_t first[3]={points[3*ip],points[3*ip+1],points[3*ip+2]};
+
+ // Last point of the curve around the impact
+ ip=np-1;
+ Float_t last[3]={points[3*ip],points[3*ip+1],points[3*ip+2]};
+
+ // The accuracy on the impact point 
+ Float_t err[3];
+ err[0]=fabs(first[0]-last[0]);
+ err[1]=fabs(first[1]-last[1]);
+ err[2]=fabs(first[2]-last[2]);
+
+ // Take the middle point as impact location
+ ip=np/2;
+ Float_t imp[3]={points[3*ip],points[3*ip+1],points[3*ip+2]};
+
+ fExt=new AliPosition();
+ fExt->SetUnitScale(scale);
+ fExt->SetPosition(imp,"car");
+ fExt->SetPositionErrors(err,"car");
+
+ return fExt;
+}
+///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliHelix.h b/RALICE/AliHelix.h
new file mode 100644 (file)
index 0000000..4f2fd32
--- /dev/null
@@ -0,0 +1,40 @@
+#ifndef ALIHELIX_H
+#define ALIHELIX_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// $Id$
+
+#include "THelix.h"
+#include "TObjArray.h"
+
+#include "Ali3Vector.h"
+#include "AliTrack.h"
+#include "AliEvent.h"
+class AliHelix : public THelix
+{
+ public:
+  AliHelix();                  // Default constructor
+  virtual ~AliHelix();         // Destructor
+  AliHelix(const AliHelix& h); // Copy constructor
+  void SetB(Ali3Vector& b);    // Set the magnetic field vector in Tesla
+  Ali3Vector& GetB();          // Provide the magnetic field vector in Tesla
+  void SetTofmax(Float_t tof); // Set maximum time of flight
+  Float_t GetTofmax() const;   // Provide the maximum time of flight
+  void Display(AliTrack* t,Double_t* range=0,Int_t iaxis=3,Double_t scale=-1);// Show curve for this track
+  void Display(AliEvent* e,Double_t* range=0,Int_t iaxis=3,Double_t scale=-1);// Show curves for this event
+  void Refresh(Int_t mode=0);  // Refresh the view before drawing the next one
+  AliPosition* Extrapolate(AliTrack* t,Double_t* pars=0,Double_t scale=-1); // Extrapolate this track
+  void MakeCurve(AliTrack* t,Double_t* range=0,Int_t iaxis=3,Double_t scale=-1); // Helix curve for this track
+
+ protected:
+  Ali3Vector fB;                               // The magnetic field vector in Tesla
+  Float_t fTofmax;                             // The maximum time of flight
+  Int_t fRefresh;                              // Auto-refresh flag for drawings
+  TObjArray* fCurves;                          //! Temp. storage for the curves on the drawing
+  AliPosition* fExt;                           //! The extrapolation result
+ ClassDef(AliHelix,1) // Representation and extrapolation of AliTracks in a magnetic field.
+};
+#endif
index 2d5eaa2..2e4ebe1 100644 (file)
@@ -110,6 +110,7 @@ void AliTrack::Init()
  fHypotheses=0;
  fBegin=0;
  fEnd=0;
+ fRef=0;
  fImpactXY=0;
  fImpactXZ=0;
  fImpactYZ=0;
@@ -156,6 +157,11 @@ AliTrack::~AliTrack()
   delete fEnd;
   fEnd=0;
  }
+ if (fRef)
+ {
+  delete fRef;
+  fRef=0;
+ }
  if (fImpactXY)
  {
   delete fImpactXY;
@@ -187,6 +193,7 @@ AliTrack::AliTrack(const AliTrack& t) : TNamed(t),Ali4Vector(t)
  fProb=t.fProb;
  if (t.fBegin) fBegin=new AliPositionObj(*(t.fBegin));
  if (t.fEnd) fEnd=new AliPositionObj(*(t.fEnd));
+ if (t.fRef) fRef=new AliPositionObj(*(t.fRef));
  if (t.fImpactXY) fImpactXY=new AliPositionObj(*(t.fImpactXY));
  if (t.fImpactXZ) fImpactXZ=new AliPositionObj(*(t.fImpactXZ));
  if (t.fImpactYZ) fImpactYZ=new AliPositionObj(*(t.fImpactYZ));
@@ -271,6 +278,11 @@ void AliTrack::Reset()
   delete fEnd;
   fEnd=0;
  }
+ if (fRef)
+ {
+  delete fRef;
+  fRef=0;
+ }
  if (fImpactXY)
  {
   delete fImpactXY;
@@ -377,6 +389,7 @@ void AliTrack::ListAll(TString f)
  Data(f); // Information of the current track
  if (fBegin) { cout << " Begin-point :"; fBegin->Data(f); }
  if (fEnd)   { cout << " End-point   :"; fEnd->Data(f); }
+ if (fRef)   { cout << " Ref-point   :"; fRef->Data(f); }
 
  Int_t nhyp=GetNhypotheses();
  if (nhyp)
@@ -851,6 +864,33 @@ AliPosition* AliTrack::GetEndPoint()
  return fEnd;
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliTrack::SetReferencePoint(AliPosition& p)
+{
+// Store the position of the track reference-point.
+// The reference-point is the point on the track in which the 
+// 3-momentum vector components have been defined.
+// This reference point is the preferable point to start track extrapolations
+// etc... which are sensitive to the components of the 3-momentum vector.
+ if (!fRef)
+ {
+  fRef=new AliPositionObj(p);
+ }
+ else
+ {
+  fRef->Load(p);
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+AliPosition* AliTrack::GetReferencePoint()
+{
+// Provide the position of the track reference-point.
+// The reference-point is the point on the track in which the 
+// 3-momentum vector components have been defined.
+// This reference point is the preferable point to start track extrapolations
+// etc... which are sensitive to the components of the 3-momentum vector.
+ return fRef;
+}
+///////////////////////////////////////////////////////////////////////////
 void AliTrack::SetMass()
 {
 // Set the mass and error to the value of the hypothesis with highest prob.
index f10c248..0f9ed41 100644 (file)
@@ -50,6 +50,8 @@ class AliTrack : public TNamed,public Ali4Vector
   AliPosition* GetBeginPoint();           // Provide the track begin-point
   void SetEndPoint(AliPosition& p);       // Set the track end-point
   AliPosition* GetEndPoint();             // Provide the track end-point
+  void SetReferencePoint(AliPosition& p); // Set the track reference-point for the 3-momentum vector
+  AliPosition* GetReferencePoint();       // Provide the track reference-point for the 3-momentum vector
   void AddTrackHypothesis(AliTrack& t);   // Add track hypothesis
   void AddTrackHypothesis(Double_t prob,Double_t m,Double_t dm=0); // Add track hypothesis with mass data
   Int_t GetNhypotheses() const;           // Provide number of track hypotheses
@@ -88,6 +90,7 @@ class AliTrack : public TNamed,public Ali4Vector
   TObjArray* fHypotheses;    // The array of track hypotheses
   AliPositionObj* fBegin;    // The begin-point of the track 
   AliPositionObj* fEnd;      // The end-point of the track 
+  AliPositionObj* fRef;      // The reference-point of the track for the 3-momentum vector
   AliPositionObj* fImpactXY; // The (extrapolated) impact-point in the plane z=0
   AliPositionObj* fImpactXZ; // The (extrapolated) impact-point in the plane y=0
   AliPositionObj* fImpactYZ; // The (extrapolated) impact-point in the plane x=0
@@ -102,6 +105,6 @@ class AliTrack : public TNamed,public Ali4Vector
  private:
   void Dumps(AliTrack* t,Int_t n,TString f); // Recursively print all decay levels
  
- ClassDef(AliTrack,11) // Handling of the attributes of a reconstructed particle track.
+ ClassDef(AliTrack,12) // Handling of the attributes of a reconstructed particle track.
 };
 #endif
index 1d3554e..f6f08fc 100644 (file)
@@ -32,3 +32,4 @@
 #include "AliObjMatrix.h"
 #include "AliAttrib.h"
 #include "AliAttribObj.h"
+#include "AliHelix.h"
index b5d1235..5fabf8d 100644 (file)
@@ -37,5 +37,6 @@
  #pragma link C++ class AliObjMatrix+;
  #pragma link C++ class AliAttrib+;
  #pragma link C++ class AliAttribObj+;
+ #pragma link C++ class AliHelix+;
 #endif
  
index 8cfdaf8..2d527b4 100644 (file)
 19-apr-2004 NvE Memberfunction GetPrimed introduced for Ali3Vector.
 04-may-2004 NvE Various memberfunctions declared "const" to satisfy the strict Alice coding rules
                 and also to allow better compiler optimisation.
+12-may-2004 NvE Track reference-point introduced in AliTrack.
+02-jun-2004 NvE Memberfunction GetUnprimed introduced for Ali3Vector.
+17-jun-2004 NvE New class AliHelix introduced and "macgcclib" added to create ralice libs on MAC.
index 405a4ea..8ef60a0 100644 (file)
@@ -3,7 +3,7 @@ SRCS=  Ali3Vector.cxx Ali4Vector.cxx AliBoost.cxx AliCalcluster.cxx \
        AliMath.cxx AliPosition.cxx AliRandom.cxx AliSample.cxx AliSignal.cxx \
        AliTrack.cxx AliVertex.cxx Ali3VectorObj.cxx Ali4VectorObj.cxx \
        AliPositionObj.cxx AliEvent.cxx AliCollider.cxx AliObjMatrix.cxx \
-        AliAttrib.cxx AliAttribObj.cxx 
+        AliAttrib.cxx AliAttribObj.cxx AliHelix.cxx 
 
 HDRS= $(SRCS:.cxx=.h)
 
diff --git a/RALICE/scripts/macgcclib b/RALICE/scripts/macgcclib
new file mode 100644 (file)
index 0000000..36a2d88
--- /dev/null
@@ -0,0 +1,43 @@
+#!/bin/sh
+### Shell script to create a ROOT loadable GCC shared lib out of .cxx source code
+###
+### NvE 23-may-2000 UU-SAP Utrecht
+# 
+### Name of the produced shared libraries
+lib1=ralice.so
+lib2=ralice.dylib
+#
+### Some MAC specific settings
+export MACOSX_DEPLOYMENT_TARGET=10.3
+unset LD_PREBIND
+# 
+### The option string for GCC shared lib compilation and linking ***
+### For the GCC ROOT loadable shared lib the strict requirements are ***
+### dropped to avoid many warnings from the rootcint generated code ***
+gccroot="-c -g0 -ansi -pedantic -Wall -Wno-long-long -I$ROOTSYS/include"
+#
+echo "lib = " $lib
+echo "gccroot = " $gccroot 
+#
+### Create the dictionary files
+rootcint -f zzzralicedict.cxx -c RALICEHeaders.h RALICELinkDef.h
+# 
+### Compile and create the ROOT loadable shared library
+#
+# Compilation phase
+g++ $gccroot *.cxx   
+#
+# Creating ralice.so library 
+g++ -v -bundle -flat_namespace -undefined dynamic_lookup -o $lib1 *.o
+#
+# Creating ralice.dylib library 
+g++ -v -dynamiclib -flat_namespace -undefined dynamic_lookup -single_module -o $lib2 *.o
+### On some systems the following extra "-read_only_relocs" flag might be needed
+# g++ -v -dynamiclib -flat_namespace -undefined dynamic_lookup -single_module -read_only_relocs -o $lib2 *.o
+#
+rm zzzralicedict.*
+rm *.o
+#rm so_locations
+# 
+echo ' ' 
+echo '*** macgcclib done. Results in ralice.so and ralice.dylib'