Removing obsolete package
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 1 Feb 2011 16:21:13 +0000 (16:21 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 1 Feb 2011 16:21:13 +0000 (16:21 +0000)
64 files changed:
CMakeLists.txt
RALICE/Ali3Vector.cxx [deleted file]
RALICE/Ali3Vector.h [deleted file]
RALICE/Ali3VectorObj.cxx [deleted file]
RALICE/Ali3VectorObj.h [deleted file]
RALICE/Ali4Vector.cxx [deleted file]
RALICE/Ali4Vector.h [deleted file]
RALICE/Ali4VectorObj.cxx [deleted file]
RALICE/Ali4VectorObj.h [deleted file]
RALICE/AliAstrolab.cxx [deleted file]
RALICE/AliAstrolab.h [deleted file]
RALICE/AliAttrib.cxx [deleted file]
RALICE/AliAttrib.h [deleted file]
RALICE/AliAttribObj.cxx [deleted file]
RALICE/AliAttribObj.h [deleted file]
RALICE/AliBoost.cxx [deleted file]
RALICE/AliBoost.h [deleted file]
RALICE/AliCalcluster.cxx [deleted file]
RALICE/AliCalcluster.h [deleted file]
RALICE/AliCalmodule.cxx [deleted file]
RALICE/AliCalmodule.h [deleted file]
RALICE/AliCalorimeter.cxx [deleted file]
RALICE/AliCalorimeter.h [deleted file]
RALICE/AliCollider.cxx [deleted file]
RALICE/AliCollider.h [deleted file]
RALICE/AliDevice.cxx [deleted file]
RALICE/AliDevice.h [deleted file]
RALICE/AliEvent.cxx [deleted file]
RALICE/AliEvent.h [deleted file]
RALICE/AliEventSelector.cxx [deleted file]
RALICE/AliEventSelector.h [deleted file]
RALICE/AliHelix.cxx [deleted file]
RALICE/AliHelix.h [deleted file]
RALICE/AliInvmass.cxx [deleted file]
RALICE/AliInvmass.h [deleted file]
RALICE/AliJet.cxx [deleted file]
RALICE/AliJet.h [deleted file]
RALICE/AliJob.cxx [deleted file]
RALICE/AliJob.h [deleted file]
RALICE/AliMath.cxx [deleted file]
RALICE/AliMath.h [deleted file]
RALICE/AliObjMatrix.cxx [deleted file]
RALICE/AliObjMatrix.h [deleted file]
RALICE/AliPosition.cxx [deleted file]
RALICE/AliPosition.h [deleted file]
RALICE/AliPositionObj.cxx [deleted file]
RALICE/AliPositionObj.h [deleted file]
RALICE/AliRandom.cxx [deleted file]
RALICE/AliRandom.h [deleted file]
RALICE/AliSample.cxx [deleted file]
RALICE/AliSample.h [deleted file]
RALICE/AliSignal.cxx [deleted file]
RALICE/AliSignal.h [deleted file]
RALICE/AliTimestamp.cxx [deleted file]
RALICE/AliTimestamp.h [deleted file]
RALICE/AliTrack.cxx [deleted file]
RALICE/AliTrack.h [deleted file]
RALICE/AliVertex.cxx [deleted file]
RALICE/AliVertex.h [deleted file]
RALICE/CMakelibRALICE.pkg [deleted file]
RALICE/RALICEHeaders.h [deleted file]
RALICE/RALICELinkDef.h [deleted file]
RALICE/doc.txt [deleted file]
RALICE/history.txt [deleted file]

index 107282c..e911c68 100644 (file)
@@ -149,7 +149,7 @@ set(CERNMODULES LHAPDF HIJING MICROCERN HERWIG)
 # Check for Pythia 6
 if(EXISTS ${ROOTINCDIR}/TPythia6.h)
   set(PYTHIA6 TRUE)
-  list(APPEND CERNMODULES PYTHIA6 RALICE EVGEN)
+  list(APPEND CERNMODULES PYTHIA6 EVGEN)
 elseif(NOT NOPYTHIA)
   message(FATAL_ERROR "ROOT must have Pythia6 enabled !")
 endif(EXISTS ${ROOTINCDIR}/TPythia6.h)
diff --git a/RALICE/Ali3Vector.cxx b/RALICE/Ali3Vector.cxx
deleted file mode 100644 (file)
index 8645655..0000000
+++ /dev/null
@@ -1,1063 +0,0 @@
-/**************************************************************************
- * 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 Ali3Vector
-// Handling of 3-vectors in various reference frames.
-//
-// This class is meant to serve as a base class for ALICE objects
-// that have 3-dimensional vector characteristics.
-// Error propagation is performed automatically. 
-//
-// Note :
-// ------
-// Vectors (v), Errors (e), reference frames (f) and angular units (u)
-// are specified via
-// SetVector(Float_t* v,TString f,TString u)
-// SetErrors(Float_t* e,TString f,TString u)
-// under the following conventions :
-//
-// f="car" ==> v in Cartesian coordinates   (x,y,z)
-// f="sph" ==> v in Spherical coordinates   (r,theta,phi)
-// f="cyl" ==> v 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. 
-//
-// Example :
-// ---------
-//
-// Ali3Vector a;
-// Float_t v[3]={-1,25,7};
-// Float_t e[3]={0.03,0.5,0.21};
-// a.SetVector(v,"car");
-// a.SetErrors(e,"car");
-// a.Data();
-//
-// Float_t vec[3];
-// Float_t err[3];
-// a.GetVector(vec,"sph","deg");
-// a.GetErrors(vec,"sph","deg");
-//
-// Ali3Vector b;
-// Float_t v2[3]={6,-18,33};
-// Float_t e2[3]={0.19,0.45,0.93};
-// b.SetVector(v2,"car");
-// b.SetErrors(e2,"car");
-//
-// Float_t dotpro=a.Dot(b);
-// Float_t doterror=a.GetResultError();
-//
-// Ali3Vector c=a.Cross(b);
-// c.Data("sph");
-// c.GetVector(vec,"cyl");
-// c.GetErrors(err,"cyl");
-//
-// Float_t norm=c.GetNorm();
-// Float_t normerror=c.GetResultError();
-//
-// c=a+b;
-// c=a-b;
-// c=a*5;
-//
-//--- Author: Nick van Eijndhoven 30-mar-1999 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "Ali3Vector.h"
-#include "Riostream.h"
-ClassImp(Ali3Vector) // Class implementation to enable ROOT I/O
-Ali3Vector::Ali3Vector()
-{
-// Creation of an Ali3Vector object and initialisation of parameters
-// All attributes initialised to 0
- SetZero();
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector::~Ali3Vector()
-{
-// Destructor to delete dynamically allocated memory
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector::Ali3Vector(const Ali3Vector& v)
-{
-// Copy constructor
- fV=v.fV;
- fTheta=v.fTheta;
- fPhi=v.fPhi;
- fDx=v.fDx;
- fDy=v.fDy;
- fDz=v.fDz;
- fDresult=v.fDresult;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::Load(Ali3Vector& q)
-{
-// Load all attributes of the input Ali3Vector into this Ali3Vector object.
- Double_t temp=q.GetResultError();
- Double_t a[3];
- q.GetVector(a,"sph");
- SetVector(a,"sph");
- q.GetErrors(a,"car");
- SetErrors(a,"car");
- fDresult=temp;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::SetZero()
-{
-// (Re)set all attributes to zero.
- fV=0;
- fTheta=0;
- fPhi=0;
- fDx=0;
- fDy=0;
- fDz=0;
- fDresult=0;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::SetVector(Double_t* v,TString f,TString u)
-{
-// Store vector according to reference 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 default is u="rad".
-//
-// All errors will be reset to 0
-
- fDx=0;
- fDy=0;
- fDz=0;
- fDresult=0;
-
- Double_t pi=acos(-1.);
-
- Double_t fu=1.;
- if (u == "deg") fu=pi/180.;
-
- Int_t frame=0;
- if (f == "car") frame=1;
- if (f == "sph") frame=2;
- if (f == "cyl") frame=3;
-
- Double_t x,y,z,rho,phi;
-
- switch (frame)
- {
-  case 1: // Cartesian coordinates
-   x=v[0];
-   y=v[1];
-   z=v[2];
-   fV=sqrt(x*x+y*y+z*z);
-   fTheta=0;
-   if (fV && fabs(z/fV)<=1.)
-   {
-    fTheta=acos(z/fV);
-   }
-   else
-   {
-    if (z<0.) fTheta=pi;
-   }
-   if (fTheta<0.) fTheta+=2.*pi;
-   fPhi=0;
-   if (x || y) fPhi=atan2(y,x);
-   if (fPhi<0.) fPhi+=2.*pi;
-   break;
-
-  case 2: // Spherical coordinates
-   fV=v[0];
-   fTheta=v[1]*fu;
-   fPhi=v[2]*fu;
-   break;
-
-  case 3: // Cylindrical coordinates
-   rho=v[0];
-   phi=v[1]*fu;
-   z=v[2];
-   fV=sqrt(rho*rho+z*z);
-   fPhi=phi;
-   if (fPhi<0.) fPhi+=2.*pi;
-   fTheta=0;
-   if (fV && fabs(z/fV)<=1.)
-   {
-    fTheta=acos(z/fV);
-   }
-   else
-   {
-    if (z<0.) fTheta=pi;
-   }
-   if (fTheta<0.) fTheta+=2.*pi;
-   break;
-
-  default: // Unsupported reference frame
-   cout << "*Ali3Vector::SetVector* Unsupported frame : " << f.Data() << endl
-        << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
-   fV=0;
-   fTheta=0;
-   fPhi=0;
-   break;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::GetVector(Double_t* v,TString f,TString u) const
-{
-// Provide vector according to reference 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 default is u="rad".
-
- Double_t pi=acos(-1.);
-
- Double_t fu=1.;
- if (u == "deg") fu=180./pi;
-
- Int_t frame=0;
- if (f == "car") frame=1;
- if (f == "sph") frame=2;
- if (f == "cyl") frame=3;
-
- switch (frame)
- {
-  case 1: // Cartesian coordinates
-   v[0]=fV*sin(fTheta)*cos(fPhi);
-   v[1]=fV*sin(fTheta)*sin(fPhi);
-   v[2]=fV*cos(fTheta);
-   break;
-
-  case 2: // Spherical coordinates
-   v[0]=fV;
-   v[1]=fTheta*fu;
-   v[2]=fPhi*fu;
-   break;
-
-  case 3: // Cylindrical coordinates
-   v[0]=fV*sin(fTheta);
-   v[1]=fPhi*fu;
-   v[2]=fV*cos(fTheta);
-   break;
-
-  default: // Unsupported reference frame
-   cout << "*Ali3Vector::GetVector* Unsupported frame : " << f.Data() << endl
-        << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
-   for (Int_t i=0; i<3; i++)
-   {
-    v[i]=0;
-   }
-   break;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::SetVector(Float_t* v,TString f,TString u)
-{
-// Store vector according to reference 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 default is u="rad".
-//
-// All errors will be reset to 0
-
- Double_t vec[3];
- for (Int_t i=0; i<3; i++)
- {
-  vec[i]=v[i];
- }
- SetVector(vec,f,u);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::GetVector(Float_t* v,TString f,TString u) const
-{
-// Provide vector according to reference 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 default is u="rad".
-
- Double_t vec[3];
- GetVector(vec,f,u);
- for (Int_t i=0; i<3; i++)
- {
-  v[i]=vec[i];
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::SetErrors(Double_t* e,TString f,TString u)
-{
-// Store errors according to reference 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 default is u="rad".
-//
-// The error on scalar results is reset to 0
-
- Double_t pi=acos(-1.);
-
- Double_t fu=1.;
- if (u == "deg") fu=pi/180.;
-
- fDresult=0;
-
- Int_t frame=0;
- if (f == "car") frame=1;
- if (f == "sph") frame=2;
- if (f == "cyl") frame=3;
-
- Double_t dx2,dy2,dz2,rho;
-
- switch (frame)
- {
-  case 1: // Cartesian coordinates
-   fDx=fabs(e[0]);
-   fDy=fabs(e[1]);
-   fDz=fabs(e[2]);
-   break;
-
-  case 2: // Spherical coordinates
-   dx2=pow((cos(fPhi)*sin(fTheta)*e[0]),2)+pow((fV*cos(fTheta)*cos(fPhi)*e[1]*fu),2)
-       +pow((fV*sin(fTheta)*sin(fPhi)*e[2]*fu),2);
-   dy2=pow((sin(fPhi)*sin(fTheta)*e[0]),2)+pow((fV*cos(fTheta)*sin(fPhi)*e[1]*fu),2)
-       +pow((fV*sin(fTheta)*cos(fPhi)*e[2]*fu),2);
-   dz2=pow((cos(fTheta)*e[0]),2)+pow((fV*sin(fTheta)*e[1]*fu),2);
-   fDx=sqrt(dx2);
-   fDy=sqrt(dy2);
-   fDz=sqrt(dz2);
-   break;
-
-  case 3: // Cylindrical coordinates
-   rho=fV*sin(fTheta);
-   dx2=pow((cos(fPhi)*e[0]),2)+pow((rho*sin(fPhi)*e[1]*fu),2);
-   dy2=pow((sin(fPhi)*e[0]),2)+pow((rho*cos(fPhi)*e[1]*fu),2);
-   fDx=sqrt(dx2);
-   fDy=sqrt(dy2);
-   fDz=fabs(e[2]);
-   break;
-
-  default: // Unsupported reference frame
-   cout << "*Ali3Vector::SetErrors* Unsupported frame : " << f.Data() << endl
-        << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
-   fDx=0;
-   fDy=0;
-   fDz=0;
-   break;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::GetErrors(Double_t* e,TString f,TString u) const
-{
-// Provide errors according to reference 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 default is u="rad".
-
- Double_t pi=acos(-1.);
-
- Double_t fu=1.;
- if (u == "deg") fu=180./pi;
-
- Int_t frame=0;
- if (f == "car") frame=1;
- if (f == "sph") frame=2;
- if (f == "cyl") frame=3;
-
- Double_t dr2,dtheta2,dphi2,rho,drho2;
- Double_t v[3]; 
- Double_t rxy2; // Shorthand for (x*x+y*y)
-
- switch (frame)
- {
-  case 1: // Cartesian coordinates
-   e[0]=fDx;
-   e[1]=fDy;
-   e[2]=fDz;
-   break;
-
-  case 2: // Spherical coordinates
-   GetVector(v,"car");
-   rxy2=pow(v[0],2)+pow(v[1],2);
-   if (sqrt(rxy2)<(fV*1e-10)) rxy2=0;
-   if (fV) 
-   {
-    dr2=(pow((v[0]*fDx),2)+pow((v[1]*fDy),2)+pow((v[2]*fDz),2))/(fV*fV);
-   }
-   else
-   {
-    dr2=0;
-   }
-   if (fV)
-   {
-    dtheta2=rxy2*pow(fDz,2)/pow(fV,4);
-    if (v[2] && rxy2)
-    {
-     dtheta2+=rxy2*pow(v[2],2)*(pow((v[0]*fDx),2)+pow((v[1]*fDy),2)) /
-              pow(((pow(v[2],2)*rxy2)+pow(rxy2,2)),2);
-    }
-   }
-   else
-   {
-    dtheta2=0;
-   }
-   if (rxy2)
-   {
-    dphi2=(pow((v[1]*fDx),2)+pow((v[0]*fDy),2))/(pow(rxy2,2));
-   }
-   else
-   {
-    dphi2=0;
-   }
-   e[0]=sqrt(dr2);
-   e[1]=sqrt(dtheta2);
-   if (e[1]>pi) e[1]=pi;
-   e[2]=sqrt(dphi2);
-   if (e[2]>(2.*pi)) e[2]=2.*pi;
-   e[1]*=fu;
-   e[2]*=fu;
-   break;
-
-  case 3: // Cylindrical coordinates
-   GetVector(v,"car");
-   rho=fabs(fV*sin(fTheta));
-   if (rho<(fV*1e-10)) rho=0;
-   if (rho) 
-   {
-    drho2=(pow((v[0]*fDx),2)+pow((v[1]*fDy),2))/(rho*rho);
-   }
-   else
-   {
-    drho2=0;
-   }
-   if (rho)
-   {
-    dphi2=(pow((v[1]*fDx),2)+pow((v[0]*fDy),2))/(pow(rho,4));
-   }
-   else
-   {
-    dphi2=0;
-   }
-   e[0]=sqrt(drho2);
-   e[1]=sqrt(dphi2);
-   if (e[1]>(2.*pi)) e[1]=2.*pi;
-   e[2]=fDz;
-   e[1]*=fu;
-   break;
-
-  default: // Unsupported reference frame
-   cout << "*Ali3Vector::GetErrors* Unsupported frame : " << f.Data() << endl
-        << " Possible frames are 'car', 'sph' and 'cyl'." << endl; 
-   for (Int_t i=0; i<3; i++)
-   {
-    e[i]=0;
-   }
-   break;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::SetErrors(Float_t* e,TString f,TString u)
-{
-// Store errors according to reference 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 default is u="rad".
-//
-// The error on scalar results is reset to 0
-
- Double_t vec[3];
- for (Int_t i=0; i<3; i++)
- {
-  vec[i]=e[i];
- }
- SetErrors(vec,f,u);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::GetErrors(Float_t* e,TString f,TString u) const
-{
-// Provide errors according to reference 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 default is u="rad".
-
- Double_t vec[3];
- GetErrors(vec,f,u);
- for (Int_t i=0; i<3; i++)
- {
-  e[i]=vec[i];
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::Data(TString f,TString u) const
-{
-// Print vector components according to reference 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".
-
- if (f=="car" || f=="sph" || f=="cyl")
- {
-  Double_t vec[3],err[3];
-  GetVector(vec,f,u);
-  GetErrors(err,f,u);
-  cout << " Vector in " << f.Data() << " (" << u.Data() << ") coordinates : "
-       << vec[0] << " " << vec[1] << " " << vec[2] << endl; 
-  cout << "   Err. in " << f.Data() << " (" << u.Data() << ") coordinates : "
-       << err[0] << " " << err[1] << " " << err[2] << endl; 
- }
- else
- {
-  cout << " *Ali3Vector::Data* Unsupported frame : " << f.Data() << endl
-       << "  Possible frames are 'car', 'sph' and 'cyl'." << endl; 
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali3Vector::GetNorm()
-{
-// Provide the norm of the current vector
-// The error on the scalar result (norm) is updated accordingly
- Double_t e[3];
- GetErrors(e,"sph");
- fDresult=e[0]; 
- return fV;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali3Vector::GetPseudoRapidity()
-{
-// Provide the pseudo-rapidity w.r.t. the z-axis.
-// In other words : eta=-log(tan(theta/2))
-// The error on the scalar result (pseudo-rap.) is updated accordingly
- Double_t pi=acos(-1.);
- Double_t v[3];
- GetVector(v,"sph");
- Double_t thetahalf=v[1]/2.;
- Double_t arg=0;
- if (v[1]<pi) arg=tan(thetahalf);
- Double_t eta=9999;
- if (arg>0) eta=-log(arg);
- Double_t e[3];
- GetErrors(e,"sph");
- Double_t prod=cos(thetahalf)*sin(thetahalf);
- fDresult=0;
- if (prod) fDresult=fabs(e[1]/2.*prod);
- return eta;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali3Vector::Dot(Ali3Vector& q)
-{
-// Provide the dot product of the current vector with vector q
-// The error on the scalar result (dotproduct) is updated accordingly
-
- Double_t dotpro=0;
-
- if ((this) == &q) // Check for special case v.Dot(v)
- {
-  Double_t norm=GetNorm();
-  Double_t dnorm=GetResultError();
-  dotpro=pow(norm,2);
-  fDresult=2.*norm*dnorm;
- }
- else
- {
-  Double_t a[3],b[3];
-  Double_t ea[3],eb[3];
-  Double_t d2=0;
-
-  GetVector(a,"car");
-  GetErrors(ea,"car");
-  q.GetVector(b,"car");
-  q.GetErrors(eb,"car");
-  for (Int_t i=0; i<3; i++)
-  {
-   dotpro+=a[i]*b[i];
-   d2+=pow(b[i]*ea[i],2)+pow(a[i]*eb[i],2);
-  }
-  fDresult=sqrt(d2);
- }
-
- return dotpro;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali3Vector::GetResultError() const
-{
-// Provide the error on the result of an operation yielding a scalar
-// E.g. GetNorm() or Dot()
- return fDresult;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::Cross(Ali3Vector& q) const
-{
-// Provide the cross product of the current vector with vector q
-// Error propagation is performed automatically
- Double_t a[3],b[3],c[3];
- Double_t ea[3],eb[3],ec[3],d2;
-
- GetVector(a,"car");
- GetErrors(ea,"car");
- q.GetVector(b,"car");
- q.GetErrors(eb,"car");
-
- c[0]=a[1]*b[2]-a[2]*b[1];
- c[1]=a[2]*b[0]-a[0]*b[2];
- c[2]=a[0]*b[1]-a[1]*b[0];
-
- d2=pow(b[2]*ea[1],2)+pow(a[1]*eb[2],2)
-   +pow(b[1]*ea[2],2)+pow(a[2]*eb[1],2);
- ec[0]=sqrt(d2);
-
- d2=pow(b[0]*ea[2],2)+pow(a[2]*eb[0],2)
-   +pow(b[2]*ea[0],2)+pow(a[0]*eb[2],2);
- ec[1]=sqrt(d2);
-
- d2=pow(b[1]*ea[0],2)+pow(a[0]*eb[1],2)
-   +pow(b[0]*ea[1],2)+pow(a[1]*eb[0],2);
- ec[2]=sqrt(d2);
-
- Ali3Vector v;
- v.SetVector(c,"car");
- v.SetErrors(ec,"car");
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::operator+(Ali3Vector& q) const
-{
-// Add vector q to the current vector
-// Error propagation is performed automatically
- Double_t a[3],b[3],ea[3],eb[3];
-
- GetVector(a,"car");
- GetErrors(ea,"car");
- q.GetVector(b,"car");
- q.GetErrors(eb,"car");
-
- for (Int_t i=0; i<3; i++)
- {
-  a[i]+=b[i];
-  ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
- }
-
- Ali3Vector v;
- v.SetVector(a,"car");
- v.SetErrors(ea,"car");
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::operator-(Ali3Vector& q) const
-{
-// Subtract vector q from the current vector
-// Error propagation is performed automatically
- Double_t a[3],b[3],ea[3],eb[3];
-
- GetVector(a,"car");
- GetErrors(ea,"car");
- q.GetVector(b,"car");
- q.GetErrors(eb,"car");
-
- for (Int_t i=0; i<3; i++)
- {
-  a[i]-=b[i];
-  ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
- }
-
- Ali3Vector v;
- v.SetVector(a,"car");
- v.SetErrors(ea,"car");
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::operator*(Double_t s) const
-{
-// Multiply the current vector with a scalar s.
-// Error propagation is performed automatically.
- Double_t a[3],ea[3];
-
- GetVector(a,"car");
- GetErrors(ea,"car");
-
- for (Int_t i=0; i<3; i++)
- {
-  a[i]*=s;
-  ea[i]*=s;
- }
-
- Ali3Vector v;
- v.SetVector(a,"car");
- v.SetErrors(ea,"car");
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::operator/(Double_t s) const
-{
-// Divide the current vector by a scalar s
-// Error propagation is performed automatically
-
- if (fabs(s)<1.e-20) // Protect against division by 0
- {
-  cout << " *Ali3Vector::/* Division by 0 detected. No action taken." << endl;
-  return *this;
- }
- else
- {
-  Double_t a[3],ea[3];
-
-  GetVector(a,"car");
-  GetErrors(ea,"car");
-
-  for (Int_t i=0; i<3; i++)
-  {
-   a[i]/=s;
-   ea[i]/=s;
-  }
-
-  Ali3Vector v;
-  v.SetVector(a,"car");
-  v.SetErrors(ea,"car");
-  
-  return v;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector& Ali3Vector::operator+=(Ali3Vector& q)
-{
-// Add vector q to the current vector
-// Error propagation is performed automatically
- Double_t a[3],b[3],ea[3],eb[3];
-
- GetVector(a,"car");
- GetErrors(ea,"car");
- q.GetVector(b,"car");
- q.GetErrors(eb,"car");
-
- for (Int_t i=0; i<3; i++)
- {
-  a[i]+=b[i];
-  ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
- }
-
- SetVector(a,"car");
- SetErrors(ea,"car");
-  
- return *this;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector& Ali3Vector::operator-=(Ali3Vector& q)
-{
-// Subtract vector q from the current vector
-// Error propagation is performed automatically
- Double_t a[3],b[3],ea[3],eb[3];
-
- GetVector(a,"car");
- GetErrors(ea,"car");
- q.GetVector(b,"car");
- q.GetErrors(eb,"car");
-
- for (Int_t i=0; i<3; i++)
- {
-  a[i]-=b[i];
-  ea[i]=sqrt(pow(ea[i],2)+pow(eb[i],2));
- }
-
- SetVector(a,"car");
- SetErrors(ea,"car");
-  
- return *this;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector& Ali3Vector::operator*=(Double_t s)
-{
-// Multiply the current vector with a scalar s
-// Error propagation is performed automatically
- Double_t a[3],ea[3];
-
- GetVector(a,"car");
- GetErrors(ea,"car");
-
- for (Int_t i=0; i<3; i++)
- {
-  a[i]*=s;
-  ea[i]*=s;
- }
-
- SetVector(a,"car");
- SetErrors(ea,"car");
-  
- return *this;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector& Ali3Vector::operator/=(Double_t s)
-{
-// Divide the current vector by a scalar s
-// Error propagation is performed automatically
-
- if (fabs(s)<1.e-20) // Protect against division by 0
- {
-  cout << " *Ali3Vector::/=* Division by 0 detected. No action taken." << endl;
-  return *this;
- }
- else
- {
-  Double_t a[3],ea[3];
-
-  GetVector(a,"car");
-  GetErrors(ea,"car");
-
-  for (Int_t i=0; i<3; i++)
-  {
-   a[i]/=s;
-   ea[i]/=s;
-  }
-
-  SetVector(a,"car");
-  SetErrors(ea,"car");
-  
-  return *this;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::GetVecTrans() const
-{
-// Provide the transverse vector w.r.t. z-axis.
-// Error propagation is performed automatically
- Double_t pi=acos(-1.);
- Double_t a[3],ea[3];
-
- GetVector(a,"sph");
- GetErrors(ea,"sph");
-
- Double_t vt,dvt2;
- vt=a[0]*sin(a[1]);
- dvt2=pow((sin(a[1])*ea[0]),2)+pow((a[0]*cos(a[1])*ea[1]),2);
-
- a[0]=fabs(vt);
- a[1]=pi/2.;
-
- ea[0]=sqrt(dvt2);
- ea[1]=0;
-
- Ali3Vector v;
- v.SetVector(a,"sph");
- v.SetErrors(ea,"sph");
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::GetVecLong() const
-{
-// Provide the longitudinal vector w.r.t. z-axis.
-// Error propagation is performed automatically
- Double_t pi=acos(-1.);
- Double_t a[3],ea[3];
-
- GetVector(a,"sph");
- GetErrors(ea,"sph");
-
- Double_t vl,dvl2;
- vl=a[0]*cos(a[1]);
- dvl2=pow((cos(a[1])*ea[0]),2)+pow((a[0]*sin(a[1])*ea[1]),2);
-
- a[0]=fabs(vl);
- a[1]=0;
- if (vl<0) a[1]=pi;
- a[2]=0;
-
- ea[0]=sqrt(dvl2);
- ea[1]=0;
- ea[2]=0;
-
- Ali3Vector v;
- v.SetVector(a,"sph");
- v.SetErrors(ea,"sph");
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali3Vector::GetPrimed(TRotMatrix* m) const
-{
-// Provide vector components (and errors) in a rotated frame.
-// The orientation of the rotated frame is described by the TRotMatrix
-// input argument.
- Ali3Vector v=*this;
- if (!m) return v;
-
- Double_t* mat=m->GetMatrix();
-
- Double_t a[3],aprim[3];
-
- GetVector(a,"car");
- aprim[0]=a[0]*mat[0]+a[1]*mat[1]+a[2]*mat[2];
- aprim[1]=a[0]*mat[3]+a[1]*mat[4]+a[2]*mat[5];
- aprim[2]=a[0]*mat[6]+a[1]*mat[7]+a[2]*mat[8];
- v.SetVector(aprim,"car");
-
- GetErrors(a,"car");
- aprim[0]=sqrt(pow(a[0]*mat[0],2)+pow(a[1]*mat[1],2)+pow(a[2]*mat[2],2));
- aprim[1]=sqrt(pow(a[0]*mat[3],2)+pow(a[1]*mat[4],2)+pow(a[2]*mat[5],2));
- aprim[2]=sqrt(pow(a[0]*mat[6],2)+pow(a[1]*mat[7],2)+pow(a[2]*mat[8],2));
- v.SetErrors(aprim,"car");
-
- 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;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali3Vector::GetX(Int_t i,TString f,TString u)
-{
-// Provide i-th vector component according to reference 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 default is u="rad".
-//
-// The vector components are addressed via the generic x1,x2,x3 notation.
-// So, i=1 denotes the first vector component.
-// The error on the selected component can be obtained via the
-// usual GetResultError() facility.
- fDresult=0;
-
- if (i<1 || i>3) return 0;
-
- Double_t vec[3];
- Double_t err[3];
- GetVector(vec,f,u);
- GetErrors(err,f,u);
-
- fDresult=err[i-1];
-
- return vec[i-1];
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali3Vector::GetOpeningAngle(Ali3Vector& q,TString u)
-{
-// Provide the opening angle with vector q.
-// The string argument "u" allows to choose between different output units.
-// u = "rad" : opening angle provided in radians
-//     "deg" : opening angle provided in degrees
-//
-// The default is u="rad".
-
- Double_t ang=0;
-
- if (GetNorm()<=0. || q.GetNorm()<=0.) return ang;
-
- Double_t vec[3];
- Double_t err[3];
-
- Ali3Vector v1;
- GetVector(vec,"sph");
- GetErrors(err,"sph");
- vec[0]=1.;
- err[0]=0.;
- v1.SetVector(vec,"sph");
- v1.SetErrors(err,"sph");
-
- Ali3Vector v2;
- q.GetVector(vec,"sph");
- q.GetErrors(err,"sph");
- vec[0]=1.;
- err[0]=0.;
- v2.SetVector(vec,"sph");
- v2.SetErrors(err,"sph");
-
- Double_t x=v1.Dot(v2);
- Double_t dx=fDresult;
- if (x>1.) x=1;
- if (x<-1.) x=-1;
- ang=acos(x);
- fDresult=0;
- if (fabs(x)<1.-dx) fDresult=dx/sqrt(1.-x*x);
-
- if (u == "deg")
- {
-  Double_t pi=acos(-1.);
-  ang*=180./pi;
-  fDresult*=180./pi;
- }
-
- return ang;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/Ali3Vector.h b/RALICE/Ali3Vector.h
deleted file mode 100644 (file)
index 8fcfabd..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef ALI3VECTOR_H
-#define ALI3VECTOR_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include <math.h>
-#include "TObject.h"
-#include "TString.h"
-#include "TRotMatrix.h"
-class Ali3Vector
-{
- public:
-  Ali3Vector();                                  // Default constructor
-  virtual ~Ali3Vector();                         // Destructor
-  Ali3Vector(const Ali3Vector& v);               // Copy constructor
-  virtual void Load(Ali3Vector& q);              // Load all attributes of input Ali3Vector
-  virtual void SetZero();                        // (Re)set all attributes to zero.
-  void SetVector(Double_t* v,TString f,TString u="rad");       // Store vector v in frame f with ang units u
-  void GetVector(Double_t* v,TString f,TString u="rad") const; // Provide vector v in frame f in ang units u
-  void SetVector(Float_t*  v,TString f,TString u="rad");       // Store vector v in frame f with ang units u
-  void GetVector(Float_t*  v,TString f,TString u="rad") const; // Provide vector v in frame f in ang units u
-  void SetErrors(Double_t* e,TString f,TString u="rad");       // Store errors of vector in frame f with ang units u
-  void GetErrors(Double_t* e,TString f,TString u="rad") const; // Provide errors of vector in frame f in ang units u
-  void SetErrors(Float_t*  e,TString f,TString u="rad");       // Store errors of vector in frame f with ang units u
-  void GetErrors(Float_t*  e,TString f,TString u="rad") const; // Provide errors of vector in frame f in ang units u
-  virtual void Data(TString f="car",TString u="rad") const;    // Print vector components in frame f in ang units u
-  Double_t GetNorm();                            // Provide norm of the vector
-  Double_t Dot(Ali3Vector& q);                   // Provide dot product with q
-  Double_t GetPseudoRapidity();                  // Provide the pseudorapidity w.r.t z-axis
-  Double_t GetResultError() const;               // Provide error on scalar result (e.g. norm)
-  Ali3Vector Cross(Ali3Vector& q) const;         // Provide cross product with q
-  Ali3Vector operator+(Ali3Vector& q) const;     // Add vector q
-  Ali3Vector operator-(Ali3Vector& q) const;     // Subtract vector q
-  Ali3Vector operator*(Double_t s) const;        // Multiply vector with scalar s
-  Ali3Vector operator/(Double_t s) const;        // Divide vector by scalar s
-  Ali3Vector& operator+=(Ali3Vector& q);         // Add vector q
-  Ali3Vector& operator-=(Ali3Vector& q);         // Subtract vector q
-  Ali3Vector& operator*=(Double_t s);            // Multiply with scalar s
-  Ali3Vector& operator/=(Double_t s);            // Divide by scalar s
-  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
-  Double_t GetX(Int_t i,TString f,TString u="rad"); // Provide i-th vector component in frame f in units u
-  virtual Double_t GetOpeningAngle(Ali3Vector& q,TString u="rad"); // Provide opening angle with q in units u
-
- protected:
-  Double32_t fV,fTheta,fPhi;    // Vector in spherical coordinates
-  Double32_t fDx,fDy,fDz;       // Errors on Cartesian coordinates
-  Double32_t fDresult;          //! Error on scalar result (e.g. norm or dotproduct)
-
- ClassDef(Ali3Vector,11) // Handling of 3-vectors in various reference frames.
-};
-#endif
diff --git a/RALICE/Ali3VectorObj.cxx b/RALICE/Ali3VectorObj.cxx
deleted file mode 100644 (file)
index a9da443..0000000
+++ /dev/null
@@ -1,83 +0,0 @@
-/**************************************************************************
- * 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 Ali3VectorObj
-// Handling of 3-vectors in various reference frames.
-//
-// This class is meant to provide an Ali3Vector object which is derived
-// from TObject such that it can be stored in e.g. TObjArray etc...
-// and that it can be written out using the ROOT I/O machinery.
-//
-// Example :
-// =========
-//
-// Float_t a[3]={1,2,3};
-// Float_t ea[3]={0.01,0.02,0.03};
-// Float_t b[3]={4,5,6};
-// Float_t eb[3]={0.04,0.05,0.06};
-//
-// Ali3Vector v,w;
-//
-// v.SetVector(a,"car");
-// v.SetErrors(ea,"car");
-// w.SetVector(b,"car");
-// w.SetErrors(eb,"car");
-//
-// Ali3Vector cross=v.Cross(w);
-//
-// Ali3Vector add=v+w;
-//
-// Ali3VectorObj vec1(cross);
-//
-// Ali3VectorObj vec2;
-// vec2.Load(add);
-//
-// vec1.Data();
-// vec2.Data();
-//
-//--- Author: Nick van Eijndhoven 18-oct-1999 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "Ali3VectorObj.h"
-ClassImp(Ali3VectorObj) // Class implementation to enable ROOT I/O
-Ali3VectorObj::Ali3VectorObj() : TObject(),Ali3Vector()
-{
-// Default constructor
-// Creation of an Ali3VectorObj object and initialisation of parameters.
-// All attributes initialised to 0.
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3VectorObj::Ali3VectorObj(Ali3Vector& q) : TObject(),Ali3Vector(q)
-{
-// Creation of an Ali3VectorObj object and initialisation of parameters.
-// All attributes are initialised to the values of the input Ali3Vector.
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3VectorObj::~Ali3VectorObj()
-{
-// Destructor to delete dynamically allocated memory.
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3VectorObj::Ali3VectorObj(Ali3VectorObj& v) : TObject(v),Ali3Vector(v)
-{
-// Copy constructor
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/Ali3VectorObj.h b/RALICE/Ali3VectorObj.h
deleted file mode 100644 (file)
index acd7719..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef ALI3VECTOROBJ_H
-#define ALI3VECTOROBJ_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include "TObject.h"
-
-#include "Ali3Vector.h"
-class Ali3VectorObj : public TObject,public Ali3Vector
-{
- public:
-  Ali3VectorObj();                       // Default constructor
-  Ali3VectorObj(Ali3Vector& q);          // Constructor
-  virtual ~Ali3VectorObj();              // Destructor
-  Ali3VectorObj(Ali3VectorObj& q);       // Copy constructor
-
- ClassDef(Ali3VectorObj,3) // Handling of 3-vectors in various reference frames.
-};
-#endif
diff --git a/RALICE/Ali4Vector.cxx b/RALICE/Ali4Vector.cxx
deleted file mode 100644 (file)
index cb3b665..0000000
+++ /dev/null
@@ -1,1042 +0,0 @@
-/**************************************************************************
- * 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 Ali4Vector
-// Handling of Lorentz 4-vectors in various reference frames.
-//
-// This class is meant to serve as a base class for ALICE objects
-// that have Lorentz 4-vector characteristics.
-// Error propagation is performed automatically.
-//
-// All 4-vectors are treated in the contravariant form and the convention
-// for the metric and the 4-vector components is according to the one
-// used in the book "Classical Electrodynamics" by J.D. Jackson.
-//
-// A 4-vector is said to have a scalar part and a 3-vector part,
-// which is indicated by the notation
-//
-//    x^i = (x^0,x^1,x^2,x^3)
-// 
-// The scalar part   = x^0
-// The 3-vector part = (x^1,x^2,x^3)
-//
-// In view of accuracy and the fact that e.g. particle identity (mass)
-// is preserved in many physics processes, the Lorentz invariant 
-// (x^i*x_i) is internally saved together with the scalar part.
-//
-// This allows the following two modes of functionality :
-//
-// Scalar mode    : The scalar part and the 3-vector part are considered
-//                  as basic quantities and the invariant with its error
-//                  is derived from these.  
-// Invariant mode : The invariant and the 3-vector part are considered
-//                  as basic quantities and the scalar with its error
-//                  is derived from these.
-//
-// The philosophy followed here is the following :
-// ===============================================
-//
-// 1) Invokation of SetVector() sets the scalar and 3-vector parts 
-//    and the invariant is calculated from these.
-//    Automatically the scalar mode is selected and invokation of
-//    SetErrors() will calculate the error on the invariant.
-//
-// 2) In case the scalar part is modified via SetScalar(), scalar mode is
-//    automatically selected and the Lorentz invariant (x^i*x_i) and its
-//    error are updated accordingly.
-//    The 3-vector part is NOT modified.
-//    This situation arises when one e.g. precisely determines the time
-//    or energy (x^0).     
-//
-// 3) In case the Lorentz invariant (x^i*x_i) is modified via SetInvariant(),
-//    invariant mode is selected automatically and the scalar part and its
-//    error are updated accordingly.
-//    The 3-vector part is NOT modified.
-//    This situation arises when one e.g. precisely determines the mass.     
-//
-// 4) In case the vector part is modified via Set3Vector(), then the 
-//    current mode determines whether the scalar or the invariant is updated. 
-//    Scalar mode    : The Lorentz invariant (x^i*x_i) and its error are updated;
-//                     the scalar part and its error are NOT modified. 
-//                     This situation arises when one e.g. improves the 3-position
-//                     vector for a particle with a very precise timing.     
-//    Invariant mode : The scalar part and its error are updated;
-//                     the Lorentz invariant (x^i*x_i) and its error are NOT modified.
-//                     This situation arises when one e.g. improves the 3-momentum
-//                     vector for a particle with known mass.     
-//
-// The dotproduct is defined such that p.Dot(p) yields the Lorentz invariant
-// scalar of the 4-vector p (i.e. m**2 in case p is a 4-momentum).   
-//
-// Note :
-// ------
-// Vectors (v), Errors (e), reference frames (f) and angular units (u)
-// are specified via
-// SetVector(Float_t* v,TString f,TString u)
-// SetErrors(Float_t* e,TString f,TString u)
-// under the following conventions :
-//
-// f="car" ==> v in Cartesian coordinates   (x,y,z)
-// f="sph" ==> v in Spherical coordinates   (r,theta,phi)
-// f="cyl" ==> v 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. 
-//
-// Example :
-// ---------
-//
-// Ali4Vector a;
-//
-// Float_t v[4]={25,-1,3,7};
-// a.SetVector(v,"car");
-//
-// Float_t vec[4];
-// a.GetVector(vec,"sph","deg");
-//
-// Ali4Vector b;
-// Float_t v2[4]={33,6,-18,2};
-// b.SetVector(v2,"car");
-//
-// Float_t dotpro=a.Dot(b);
-//
-// Float_t x0=16;
-// Ali3Vector x;
-// Float_t vec2[3]={1,2,3};
-// x.SetVector(vec2,"car");
-//
-// Ali4Vector c;
-// c.SetVector(x0,x);
-// c.GetVector(vec,"car");
-// c.Data("cyl");
-// c=a+b;
-// c=a-b;
-// c=a*5;
-//
-//--- Author: Nick van Eijndhoven 01-apr-1999 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "Ali4Vector.h"
-#include "Riostream.h"
-ClassImp(Ali4Vector) // Class implementation to enable ROOT I/O
-Ali4Vector::Ali4Vector()
-{
-// Creation of a contravariant 4-vector and initialisation of parameters.
-// All values are initialised to 0.
-// Scalar mode is initially selected.
- SetZero();
- fScalar=1;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector::~Ali4Vector()
-{
-// Destructor to delete dynamically allocated memory
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector::Ali4Vector(const Ali4Vector& v)
-{
-// Copy constructor
- fScalar=v.fScalar;
- fV2=v.fV2;
- fDv2=v.fDv2;
- fV0=v.fV0;
- fDv0=v.fDv0;
- fDresult=v.fDresult;
- fV=v.fV;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::Load(Ali4Vector& q)
-{
-// Load all attributes of the input Ali4Vector into this Ali4Vector object.
- Int_t temp1=q.GetScalarFlag();
- Double_t temp2=q.GetResultError();
- Double_t a[4];
- q.GetVector(a,"sph");
- SetVector(a,"sph");
- q.GetErrors(a,"car");
- SetErrors(a,"car");
- fScalar=temp1;
- fDresult=temp2;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetZero()
-{
-// (Re)set all attributes to zero.
-// Note : The (de)selection of the scalar mode is not modified.
- fV2=0;
- fDv2=0;
- fV0=0;
- fDv0=0;
- fDresult=0;
- fV.SetZero();
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetVector(Double_t v0,Ali3Vector& v)
-{
-// Store contravariant vector.
-// The error on the scalar part is initialised to 0.
-// The errors on the vector part are taken from the input Ali3Vector.
-// Scalar mode is automatically selected. 
-// The error on scalar result operations is reset to 0.
- fScalar=1;
- fV0=v0;
- fV=v;
- fV2=pow(v0,2)-fV.Dot(fV);
- SetScalarError(0);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetVector(Double_t* v,TString f,TString u)
-{
-// Store vector according to reference 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 default is u="rad".
-//
-// All errors are initialised to 0.
-//
-// Scalar mode is automatically selected. 
-// The error on scalar result operations is reset to 0.
-
- fScalar=1;
- Double_t a[3];
- for (Int_t i=0; i<3; i++)
- {
-  a[i]=v[i+1];
- }
- fV0=v[0];
- fV.SetVector(a,f,u);
- fV2=pow(fV0,2)-fV.Dot(fV);
- fDv2=0;
- fDv0=0;
- fDresult=0;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::GetVector(Double_t* v,TString f,TString u)
-{
-// Provide 4-vector components according to reference frame f
-// and according to the current mode.
-// Scalar mode    : The scalar part is directly returned via v[0].
-// Invariant mode : The scalar part is re-calculated via the value
-//                  of the Lorentz invariant and then returned via v[0].
-//
-// 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".
-
- if (fScalar)
- {
-  v[0]=fV0;
- }
- else
- {
-  v[0]=sqrt(fV.Dot(fV)+fV2);
- } 
- Double_t a[3];
- fV.GetVector(a,f,u);
- for (Int_t i=0; i<3; i++)
- {
-  v[i+1]=a[i];
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetVector(Float_t* v,TString f,TString u)
-{
-// Store vector according to reference 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 default is u="rad".
-//
-// All errors are initialised to 0.
-//
-// Scalar mode is automatically selected. 
-// The error on scalar result operations is reset to 0.
-
- Double_t vec[4];
- for (Int_t i=0; i<4; i++)
- {
-  vec[i]=v[i];
- }
- SetVector(vec,f,u);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::GetVector(Float_t* v,TString f,TString u)
-{
-// Provide 4-vector components according to reference frame f
-// and according to the current mode.
-// Scalar mode    : The scalar part is directly returned via v[0].
-// Invariant mode : The scalar part is re-calculated via the value
-//                  of the Lorentz invariant and then returned via v[0].
-//
-// 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".
-
- Double_t vec[4];
- GetVector(vec,f,u);
- for (Int_t i=0; i<4; i++)
- {
-  v[i]=vec[i];
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetScalar()
-{
-// Provide the scalar part.
-// The error on the scalar value is available via GetResultError()
-// after invokation of GetScalar().
- if (fScalar)
- {
-  fDresult=fDv0;
-  return fV0;
- }
- else
- {
-  Double_t dot=fV.Dot(fV);
-  Double_t ddot=fV.GetResultError();
-  Double_t v02=dot+fV2;
-  Double_t dv02=sqrt(pow(ddot,2)+pow(fDv2,2));
-  Double_t v0=sqrt(fabs(v02));
-  Double_t dv0=0;
-  if (v0) dv0=dv02/(2.*v0);
-  fDresult=dv0;
-  return v0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetResultError() const
-{
-// Provide the error on the result of an operation yielding a scalar
-// E.g. GetScalar(), GetInvariant() or Dot()
- return fDresult;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetScalar(Double_t v0,Double_t dv0)
-{
-// Modify the scalar part (v0) and its error (dv0).
-// The default value for dv0 is 0.
-// The vector part is not modified. 
-// Scalar mode is automatically selected
-// ==> Lorentz invariant and its error are updated. 
-// The error on scalar result operations is reset to 0.
- fScalar=1;
- fV0=v0;
- fV2=pow(v0,2)-fV.Dot(fV);
- SetScalarError(dv0);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetScalarError(Double_t dv0)
-{
-// Set the error on the scalar part.
-// If in scalar mode, update error on the invariant accordingly.
-// The error on scalar result operations is reset to 0.
- fDv0=dv0;
- if (fScalar)
- {
-  Double_t norm=fV.GetNorm();
-  Double_t dnorm=fV.GetResultError();
-  fDv2=sqrt(pow(2.*fV0*fDv0,2)+pow(2.*norm*dnorm,2));
- } 
- fDresult=0;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::Set3Vector(Ali3Vector& v)
-{
-// Set the 3-vector part, the errors are taken from the input Ali3Vector
-// Scalar mode    : The scalar part and its error are not modified,
-//                  the Lorentz invariantand its error are re-calculated.
-// Invariant mode : The Lorentz invariant and its error are not modified,
-//                  the scalar part and its error are re-calculated.
-// The error on scalar result operations is reset to 0.
- fV=v;
- if (fScalar)
- {
-  SetScalar(fV0,fDv0);
- }
- else
- {
-  SetInvariant(fV2,fDv2);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::Set3Vector(Double_t* v,TString f,TString u)
-{
-// Set the 3-vector part according to reference 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 default is u="rad".
-//
-// The errors on the vector part are initialised to 0
-//
-// Scalar mode    : The scalar part and its error are not modified,
-//                  the Lorentz invariantand its error are re-calculated.
-// Invariant mode : The Lorentz invariant and its error are not modified,
-//                  the scalar part and its error are re-calculated.
-// The error on scalar result operations is reset to 0.
-
- Double_t a[3];
- for (Int_t i=0; i<3; i++)
- {
-  a[i]=v[i];
- }
- fV.SetVector(a,f,u);
-
- if (fScalar)
- {
-  SetScalar(fV0,fDv0);
- }
- else
- {
-  SetInvariant(fV2,fDv2);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::Set3Vector(Float_t* v,TString f,TString u)
-{
-// Set the 3-vector part according to reference 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 default is u="rad".
-//
-// The errors on the vector part are initialised to 0
-// The Lorentz invariant is not modified
-// The error on scalar result operations is reset to 0.
-
- Double_t vec[3];
- for (Int_t i=0; i<3; i++)
- {
-  vec[i]=v[i];
- }
- Set3Vector(vec,f,u);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetInvariant(Double_t v2,Double_t dv2)
-{
-// Modify the Lorentz invariant (v2) quantity v^i*v_i and its error (dv2).
-// The default value for the error dv2 is 0.
-// The vector part is not modified.
-// Invariant mode is automatically selected
-// ==> the scalar part and its error are updated.
-// The error on scalar result operations is reset to 0.
-//
- fScalar=0;
- fV2=v2;
- fDv2=dv2;
- fV0=GetScalar();
- fDv0=GetResultError();
- fDresult=0;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetInvariantError(Double_t dv2)
-{
-// Set the error on the Lorentz invariant.
-// If in invariant mode, update error on the scalar part accordingly.
-// The error on scalar result operations is reset to 0.
- fDv2=dv2;
- if (!fScalar)
- {
-  fDv0=GetResultError();
- }
- fDresult=0; 
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetInvariant()
-{
-// Provide the Lorentz invariant v^i*v_i.
-// The error on the Lorentz invariant is available via GetResultError()
-// after invokation of GetInvariant().
- if (!fScalar)
- {
-  fDresult=fDv2;
-  return fV2;
- }
- else
- {
-  Double_t inv=Dot(*this);
-  return inv;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali4Vector::Get3Vector() const
-{
-// Provide the 3-vector part
- return fV;
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetErrors(Double_t* e,TString f,TString u)
-{
-// Store errors for vector v^i according to reference 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 default is u="rad".
-//
-// If in scalar mode, update error on the invariant accordingly.
-// The error on scalar result operations is reset to 0.
-
- Double_t a[3];
- for (Int_t i=0; i<3; i++)
- {
-  a[i]=e[i+1];
- }
- SetScalarError(e[0]);
- fV.SetErrors(a,f,u);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::SetErrors(Float_t* e,TString f,TString u)
-{
-// Store errors for vector v^i according to reference 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 default is u="rad".
-//
-// If in scalar mode, update error on the invariant accordingly.
-// The error on scalar result operations is reset to 0.
-
- Double_t a[4];
- for (Int_t i=0; i<4; i++)
- {
-  a[i]=e[i];
- }
- SetErrors(a,f,u);
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::GetErrors(Double_t* e,TString f,TString u)
-{
-// Provide errors for vector v^i according to reference frame f
-// and according to the current mode.
-// Scalar mode    : The error on the scalar part is directly returned via e[0].
-// Invariant mode : The error on the scalar part is re-calculated via the error
-//                  value on the Lorentz invariant and then returned via e[0].
-//
-// 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".
-
- Double_t a[3];
- fV.GetErrors(a,f,u);
-
- // Dummy invokation of GetScalar to obtain automatic proper error determination 
- e[0]=GetScalar();
-
- e[0]=GetResultError();
-
- for (Int_t i=0; i<3; i++)
- {
-  e[i+1]=a[i];
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::GetErrors(Float_t* e,TString f,TString u)
-{
-// Provide errors for vector v^i according to reference frame f
-// and according to the current mode.
-// Scalar mode    : The error on the scalar part is directly returned via e[0].
-// Invariant mode : The error on the scalar part is re-calculated via the error
-//                  value on the Lorentz invariant and then returned via e[0].
-//
-// 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".
-
- Double_t a[4];
- GetErrors(a,f,u);
- for (Int_t i=0; i<4; i++)
- {
-  e[i]=a[i];
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::Data(TString f,TString u)
-{
-// Print contravariant vector components and errors according to
-// reference frame f and according to the current mode.
-// Scalar mode    : The scalar part and its error are directly returned.
-// Invariant mode : The scalar part and its error are re-calculated via the
-//                  value (and error) of the Lorentz invariant.
-//
-// 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".
-
- if (f=="car" || f=="sph" || f=="cyl")
- {
-  Double_t vec[4],err[4];
-  GetVector(vec,f,u);
-  GetErrors(err,f,u);
-  Double_t inv=GetInvariant();
-  Double_t dinv=GetResultError();
-  cout << " Contravariant vector in " << f.Data() << " (" << u.Data() << ") coordinates : "
-       << vec[0] << " " << vec[1] << " " << vec[2] << " " << vec[3] << endl; 
-  cout << " ------------- Errors in " << f.Data() << " (" << u.Data() << ") coordinates : "
-       << err[0] << " " << err[1] << " " << err[2] << " " << err[3] << endl; 
-  cout << " --- Lorentz invariant (v^i*v_i) : " << inv << " error : " << dinv << endl;
- }
- else
- {
-  cout << " *Ali4Vector::Data* Unsupported frame : " << f.Data() << endl
-       << "  Possible frames are 'car', 'sph' and 'cyl'." << endl; 
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::Dot(Ali4Vector& q)
-{
-// Provide the dot product of the current vector with vector q
- Double_t dotpro=0;
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- if ((this) == &q) // Check for special case v.Dot(v)
- {
-  Double_t norm=fV.GetNorm();
-  Double_t dnorm=fV.GetResultError();
-  dotpro=pow(a0,2)-pow(norm,2);
-  fDresult=sqrt(pow(2.*a0*da0,2)+pow(2.*norm*dnorm,2));
- }
- else
- {
-  Double_t b0=q.GetScalar();
-  Double_t db0=q.GetResultError();
-  Ali3Vector b=q.Get3Vector();
-
-  Double_t dot=fV.Dot(b);
-  Double_t ddot=fV.GetResultError();
-
-  dotpro=a0*b0-dot;
-
-  fDresult=sqrt(pow(b0*da0,2)+pow(a0*db0,2)+pow(ddot,2));
- }
-
- return dotpro;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector Ali4Vector::operator+(Ali4Vector& q)
-{
-// Add 4-vector q to the current 4-vector
-// Error propagation is performed automatically
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- Ali3Vector a=Get3Vector();
- Double_t b0=q.GetScalar();
- Double_t db0=q.GetResultError();
- Ali3Vector b=q.Get3Vector();
-
- Double_t c0=a0+b0;
- Ali3Vector c=a+b;
- Double_t dc0=sqrt(pow(da0,2)+pow(db0,2));
-
- Ali4Vector v;
- v.SetVector(c0,c);
- v.SetScalarError(dc0);  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector Ali4Vector::operator-(Ali4Vector& q)
-{
-// Subtract 4-vector q from the current 4-vector
-// Error propagation is performed automatically
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- Ali3Vector a=Get3Vector();
- Double_t b0=q.GetScalar();
- Double_t db0=q.GetResultError();
- Ali3Vector b=q.Get3Vector();
-
- Double_t c0=a0-b0;
- Ali3Vector c=a-b;
- Double_t dc0=sqrt(pow(da0,2)+pow(db0,2));
-
- Ali4Vector v;
- v.SetVector(c0,c);
- v.SetScalarError(dc0);  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector Ali4Vector::operator*(Double_t s)
-{
-// Multiply the current 4-vector with a scalar s
-// Error propagation is performed automatically
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- Ali3Vector a=Get3Vector();
-
- a0*=s;
- a*=s;
- da0*=s;
-
- Ali4Vector v;
- v.SetVector(a0,a);
- v.SetScalarError(da0);  
-  
- return v;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector Ali4Vector::operator/(Double_t s)
-{
-// Divide the current vector by a scalar s
-// Error propagation is performed automatically
-
- if (fabs(s)<1.e-20) // Protect against division by 0
- {
-  cout << " *Ali4Vector::/* Division by 0 detected. No action taken." << endl;
-  return *this;
- }
- else
- {
-  Double_t a0=GetScalar();
-  Double_t da0=GetResultError();
-  Ali3Vector a=Get3Vector();
-
-  a0/=s;
-  a/=s;
-  da0/=s;
-
-  Ali4Vector v;
-  v.SetVector(a0,a);
-  v.SetScalarError(da0);  
-  
-  return v;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector& Ali4Vector::operator+=(Ali4Vector& q)
-{
-// Add 4-vector q to the current 4-vector
-// Error propagation is performed automatically
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- Ali3Vector a=Get3Vector();
- Double_t b0=q.GetScalar();
- Double_t db0=q.GetResultError();
- Ali3Vector b=q.Get3Vector();
-
- Double_t c0=a0+b0;
- Ali3Vector c=a+b;
- Double_t dc0=sqrt(pow(da0,2)+pow(db0,2));
-
- SetVector(c0,c);
- SetScalarError(dc0);  
-  
- return *this;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector& Ali4Vector::operator-=(Ali4Vector& q)
-{
-// Subtract 4-vector q from the current 4-vector
-// Error propagation is performed automatically
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- Ali3Vector a=Get3Vector();
- Double_t b0=q.GetScalar();
- Double_t db0=q.GetResultError();
- Ali3Vector b=q.Get3Vector();
-
- Double_t c0=a0-b0;
- Ali3Vector c=a-b;
- Double_t dc0=sqrt(pow(da0,2)+pow(db0,2));
-
- SetVector(c0,c);
- SetScalarError(dc0);  
-
- return *this;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector& Ali4Vector::operator*=(Double_t s)
-{
-// Multiply the current 4-vector with a scalar s
-// Error propagation is performed automatically
- Double_t a0=GetScalar();
- Double_t da0=GetResultError();
- Ali3Vector a=Get3Vector();
-
- a0*=s;
- a*=s;
- da0*=s;
-
- SetVector(a0,a);
- SetScalarError(da0);  
-
- return *this;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector& Ali4Vector::operator/=(Double_t s)
-{
-// Divide the current vector by a scalar s
-// Error propagation is performed automatically
-
- if (fabs(s)<1.e-20) // Protect against division by 0
- {
-  cout << " *Ali4Vector::/* Division by 0 detected. No action taken." << endl;
-  return *this;
- }
- else
- {
-  Double_t a0=GetScalar();
-  Double_t da0=GetResultError();
-  Ali3Vector a=Get3Vector();
-
-  a0/=s;
-  a/=s;
-  da0/=s;
-
-  SetVector(a0,a);
-  SetScalarError(da0);  
-  
-  return *this;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t Ali4Vector::GetScalarFlag() const
-{
-// Provide the value of the fScalar flag (for internal use only).
- return fScalar;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali4Vector::GetVecTrans() const
-{
-// Provide the transverse vector part w.r.t. z-axis.
-// Error propagation is performed automatically
-  
- return fV.GetVecTrans();
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali4Vector::GetVecLong() const
-{
-// Provide the longitudinal vector part w.r.t. z-axis.
-// Error propagation is performed automatically
-  
- return fV.GetVecLong();
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetScaTrans()
-{
-// Provide the "transverse value" of the scalar part w.r.t. z-axis.
-// This provides a basis for e.g. E_trans calculation.
-// Note : the returned value is always positive or zero.
-// The error on the value is available via GetResultError()
-// after invokation of GetScaTrans().
- Double_t a[3],ea[3];
-
- fV.GetVector(a,"sph");
- fV.GetErrors(ea,"sph");
-
- Double_t s=GetScalar();
- Double_t ds=GetResultError();
-
- Double_t st,dst2;
- st=s*sin(a[1]);
- dst2=pow((sin(a[1])*ds),2)+pow((s*cos(a[1])*ea[1]),2);
-
- fDresult=sqrt(dst2);  
- return fabs(st);
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetScaLong()
-{
-// Provide the "longitudinal value" of the scalar part w.r.t. z-axis.
-// This provides a basis for e.g. E_long calculation.
-// Note : the returned value can also be negative.
-// The error on the value is available via GetResultError()
-// after invokation of GetScaLong().
- Double_t a[3],ea[3];
-
- fV.GetVector(a,"sph");
- fV.GetErrors(ea,"sph");
-
- Double_t s=GetScalar();
- Double_t ds=GetResultError();
-
- Double_t sl,dsl2;
- sl=s*cos(a[1]);
- dsl2=pow((cos(a[1])*ds),2)+pow((s*sin(a[1])*ea[1]),2);
-
- fDresult=sqrt(dsl2);  
- return sl;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetPseudoRapidity()
-{
-// Provide the pseudorapidity value of the vector part w.r.t. z-axis.
-// The error on the value is available via GetResultError()
-// after invokation of GetPseudoRapidity().
- Double_t eta=fV.GetPseudoRapidity();
- fDresult=fV.GetResultError();
- return eta;
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector Ali4Vector::GetBetaVector() const
-{
-// Provide the beta 3-vector corresponding to this 4-vector.
- Ali3Vector beta;
- if (fabs(fV0)>0.) beta=fV/fV0;
- if (fabs(fDv0)>0.)
- {
-  Double_t vecv[3],errv[3],errb[3];
-  Double_t sqerr=0;
-  fV.GetVector(vecv,"car");
-  fV.GetErrors(errv,"car");
-  for (Int_t i=0; i<3; i++)
-  {
-   sqerr=pow((errv[i]/fV0),2)+pow((vecv[i]*fDv0/(fV0*fV0)),2);
-   errb[i]=sqrt(sqerr);
-  }
-  beta.SetErrors(errb,"car");
- }
- return beta;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetBeta()
-{
-// Provide the beta value (i.e. v/c) corresponding to this 4-vector.
- Ali3Vector beta=GetBetaVector();
- Double_t val=beta.GetNorm();
- fDresult=beta.GetResultError();
- return val;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetGamma()
-{
-// Provide the Lorentz gamma factor corresponding to this 4-vector.
-// In case the gamma factor is infinite a value of -1 is returned.
- Double_t gamma=-1;
- fDresult=0;
- Double_t inv=sqrt(fabs(fV2));
- if (inv>0.)
- {
-  Double_t dinv=fDv2/(2.*inv);
-  gamma=fV0/inv;
-  Double_t sqerr=pow((fDv0/inv),2)+pow((fV0*dinv/fV2),2);
-  fDresult=sqrt(sqerr);
- }
- return gamma;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetX(Int_t i,TString f,TString u)
-{
-// Provide i-th vector component according to reference 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 default is u="rad".
-//
-// The vector components are addressed via the generic x0,x1,x2,x3 notation.
-// So, i=0 denotes the scalar component and i=1 denotes the first 3-vector component.
-// The error on the selected component can be obtained via the
-// usual GetResultError() facility.
- fDresult=0;
-
- if (i<0 || i>3) return 0;
-
- Double_t x=0;
-
- if (i==0)
- {
-  x=GetScalar();
- }
- else
- {
-  x=fV.GetX(i,f,u);
-  fDresult=fV.GetResultError();
- }
-
- return x;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetOpeningAngle(Ali4Vector& q,TString u)
-{
-// Provide the opening angle between 3-vector parts with 4-vector q.
-// The string argument "u" allows to choose between different output units.
-// u = "rad" : opening angle provided in radians
-//     "deg" : opening angle provided in degrees
-//
-// The default is u="rad".
-
- Ali3Vector v1=fV;
- Ali3Vector v2=q.Get3Vector();
-
- Double_t ang=v1.GetOpeningAngle(v2,u);
- fDresult=v1.GetResultError();
-
- return ang;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t Ali4Vector::GetOpeningAngle(Ali3Vector& q,TString u)
-{
-// Provide the opening angle between the 3-vector part and 3-vector q.
-// The string argument "u" allows to choose between different output units.
-// u = "rad" : opening angle provided in radians
-//     "deg" : opening angle provided in degrees
-//
-// The default is u="rad".
-
- Ali3Vector v1=fV;
-
- Double_t ang=v1.GetOpeningAngle(q,u);
- fDresult=v1.GetResultError();
-
- return ang;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/Ali4Vector.h b/RALICE/Ali4Vector.h
deleted file mode 100644 (file)
index ea10191..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
-#ifndef ALI4VECTOR_H
-#define ALI4VECTOR_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include <math.h>
-#include "Ali3Vector.h"
-class Ali4Vector
-{
- public:
-  Ali4Vector();                                     // Default constructor for contravariant vector
-  virtual ~Ali4Vector();                            // Destructor
-  Ali4Vector(const Ali4Vector& v);                  // Copy constructor
-  virtual void Load(Ali4Vector& q);                 // Load all attributes of input Ali4Vector
-  virtual void SetZero();                           // (Re)set all attributes to zero
-  void SetVector(Double_t v0,Ali3Vector& v);        // Store contravariant vector
-  void SetVector(Double_t* v,TString f,TString u="rad"); // Store contravariant vector v^i in frame f with ang units u
-  void GetVector(Double_t* v,TString f,TString u="rad"); // Provide contravariant vector v^i in frame f in ang units u
-  void SetVector(Float_t*  v,TString f,TString u="rad"); // Store contravariant vector v^i in frame f with ang units u
-  void GetVector(Float_t*  v,TString f,TString u="rad"); // Provide contravariant vector v^i in frame f in ang units u
-  void SetScalar(Double_t v0,Double_t dv0=0);       // Set the scalar part (with error) of v
-  void SetScalarError(Double_t dv0);                // Set error on the scalar part of v
-  Double_t GetScalar();                             // Provide the scalar part of v
-  void Set3Vector(Ali3Vector& v);                   // Set the 3-vector part of v
-  void Set3Vector(Double_t* v,TString f,TString u="rad"); // Set the 3-vector part of v in frame f with ang units u
-  void Set3Vector(Float_t*  v,TString f,TString u="rad"); // Set the 3-vector part of v in frame f with ang units u
-  Ali3Vector Get3Vector() const;                    // Provide the 3-vector part of v
-  void SetInvariant(Double_t v2,Double_t dv2=0);    // Set the Lorentz invariant (with error)
-  void SetInvariantError(Double_t dv2);             // Set error on the Lorentz invariant
-  Double_t GetInvariant();                          // Provide the Lorentz invariant
-  void SetErrors(Double_t* v,TString f,TString u="rad"); // Store errors of vector v^i in frame f with ang units u
-  void GetErrors(Double_t* v,TString f,TString u="rad"); // Provide errors of vector v^i in frame f in ang units u
-  void SetErrors(Float_t*  v,TString f,TString u="rad"); // Store errors of vector v^i in frame f with ang units u
-  void GetErrors(Float_t*  v,TString f,TString u="rad"); // Provide errors of vector v^i in frame f in ang units u
-  virtual void Data(TString f="car",TString u="rad");    // Print contravariant components in frame f in ang units u
-  Double_t Dot(Ali4Vector& q);                      // Provide dot product v^i*q_i
-  Double_t GetResultError() const;                  // Provide error on scalar result (e.g. Dot)
-  Ali4Vector operator+(Ali4Vector& q);              // Add contravariant vector q
-  Ali4Vector operator-(Ali4Vector& q);              // Subtract contravariant vector q
-  Ali4Vector operator*(Double_t s);                 // Multiply contravariant vector with scalar s
-  Ali4Vector operator/(Double_t s);                 // Divide contravariant vector by scalar s
-  Ali4Vector& operator+=(Ali4Vector& q);            // Add contravariant vector q
-  Ali4Vector& operator-=(Ali4Vector& q);            // Subtract contravariant vector q
-  Ali4Vector& operator*=(Double_t s);               // Multiply with scalar s
-  Ali4Vector& operator/=(Double_t s);               // Divide by scalar s
-  Int_t GetScalarFlag() const;                      // Provide the fScalar flag value
-  Ali3Vector GetVecTrans() const;                   // Provide transverse vector part w.r.t. z-axis
-  Ali3Vector GetVecLong() const;                    // Provide longitudinal vector part w.r.t. z-axis
-  Double_t GetPseudoRapidity();                     // Provide pseudorapidity of vector part w.r.t z-axis
-  Ali3Vector GetBetaVector() const;                 // Provide the beta 3-vector
-  Double_t GetBeta();                               // Provide the norm of the beta 3-vector, i.e. v/c
-  Double_t GetGamma();                              // Provide the Lorentz gamma factor
-  Double_t GetX(Int_t i,TString f,TString u="rad"); // Provide i-th vector component in frame f in units u
-  virtual Double_t GetOpeningAngle(Ali4Vector& q,TString u="rad"); // Opening angle between 3-vector parts in units u
-  virtual Double_t GetOpeningAngle(Ali3Vector& q,TString u="rad"); // Opening angle with 3-vector q in units u
-
- protected:
-  Double32_t fV2;      // The Lorentz invariant (v^i*v_i)
-  Double32_t fV0;      // The scalar part
-  Ali3Vector fV;       // The 3-vector part
-  Double32_t fDv2;     // The error on the Lorentz invariant
-  Double32_t fDv0;     // The error on the scalar part
-  Double32_t fDresult; //! The error on the scalar result of an operation (e.g. dotproduct) 
-  Int_t fScalar;       // Flag denoting scalar mode
-  Double_t GetScaTrans(); // Provide "transverse value" of scalar part w.r.t. z-axis
-  Double_t GetScaLong();  // Provide "longitudinal value" of scalar part w.r.t. z-axis
-
- ClassDef(Ali4Vector,11) // Handling of Lorentz 4-vectors in various reference frames.
-};
-#endif
diff --git a/RALICE/Ali4VectorObj.cxx b/RALICE/Ali4VectorObj.cxx
deleted file mode 100644 (file)
index 7b27c45..0000000
+++ /dev/null
@@ -1,83 +0,0 @@
-/**************************************************************************
- * 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 Ali4VectorObj
-// Handling of Lorentz 4-vectors in various reference frames.
-//
-// This class is meant to provide an Ali4Vector object which is derived
-// from TObject such that it can be stored in e.g. TObjArray etc...
-// and that it can be written out using the ROOT I/O machinery.
-//
-// Example :
-// =========
-//
-// Float_t a[4]={5,1,2,3};
-// Float_t ea[4]={0.05,0.01,0.02,0.03};
-// Float_t b[4]={10,4,5,6};
-// Float_t eb[4]={0.1,0.04,0.05,0.06};
-//
-// Ali4Vector v,w;
-//
-// v.SetVector(a,"car");
-// v.SetErrors(ea,"car");
-// w.SetVector(b,"car");
-// w.SetErrors(eb,"car");
-//
-// Ali4Vector add=v+w;
-//
-// Ali4Vector sub=v-w;
-//
-// Ali4VectorObj vec1(add);
-//
-// Ali4VectorObj vec2;
-// vec2.Load(sub);
-//
-// vec1.Data();
-// vec2.Data();
-//
-//--- Author: Nick van Eijndhoven 18-oct-1999 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "Ali4VectorObj.h"
-ClassImp(Ali4VectorObj) // Class implementation to enable ROOT I/O
-Ali4VectorObj::Ali4VectorObj() : TObject(),Ali4Vector()
-{
-// Default constructor
-// Creation of an Ali4VectorObj object and initialisation of parameters.
-// All attributes initialised to 0.
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4VectorObj::Ali4VectorObj(Ali4Vector& q) : TObject(),Ali4Vector(q)
-{
-// Creation of an Ali3VectorObj object and initialisation of parameters.
-// All attributes are initialised to the values of the input Ali4Vector.
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4VectorObj::~Ali4VectorObj()
-{
-// Destructor to delete dynamically allocated memory.
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4VectorObj::Ali4VectorObj(Ali4VectorObj& v) : TObject(v),Ali4Vector(v)
-{
-// Copy constructor
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/Ali4VectorObj.h b/RALICE/Ali4VectorObj.h
deleted file mode 100644 (file)
index 52d6985..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef ALI4VECTOROBJ_H
-#define ALI4VECTOROBJ_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include "TObject.h"
-
-#include "Ali4Vector.h"
-class Ali4VectorObj : public TObject,public Ali4Vector
-{
- public:
-  Ali4VectorObj();                       // Default constructor
-  Ali4VectorObj(Ali4Vector& q);          // Constructor
-  virtual ~Ali4VectorObj();              // Destructor
-  Ali4VectorObj(Ali4VectorObj& q);       // Copy constructor
-
- ClassDef(Ali4VectorObj,3) // Handling of Lorentz 4-vectors in various reference frames.
-};
-#endif
diff --git a/RALICE/AliAstrolab.cxx b/RALICE/AliAstrolab.cxx
deleted file mode 100644 (file)
index 452c3a2..0000000
+++ /dev/null
@@ -1,2904 +0,0 @@
-/**************************************************************************
- * 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 AliAstrolab
-// Virtual lab to correlate measurements with astrophysical phenomena.
-//
-// This class is derived from TTask, but the only reason for this
-// is to enable this class to serve as a base class for other TTask
-// derived classes (e.g. AliEventSelector) without the need for
-// multiple virtual inheritance.
-// So, this AliAstrolab class itself does not provide any TTask
-// related functionality.
-//
-// The lab can be given a terrestrial location via the usual longitude
-// and latitude specifications.
-// Since this class is derived from AliTimestamp, a lab can also be
-// given a specific timestamp. Together with the terrestrial location
-// this provides access to local (sidereal) times etc...
-// In addition to the usual astronomical reference frames, a local
-// lab reference frame can also be specified. Together with the lab's
-// timestamp this uniquely defines all the coordinate transformations
-// between the various reference frames.
-// These lab characteristics allow a space-time correlation of lab
-// observations with external (astrophysical) phenomena.
-//
-// Observations are entered as generic signals containing a position,
-// reference frame specification and a timestamp.
-// These observations can then be analysed in various reference frames
-// via the available GET functions.
-//
-// Various external (astrophysical) phenomena may be entered as
-// so-called reference signals.
-// This class provides facilities (e.g. MatchRefSignal) to check
-// correlations of the stored measurement with these reference signals.
-// Also graphical facilities (e.g. DisplaySignals) are available to
-// provide skymaps in various projections.
-// 
-// Coding example :
-// ----------------
-// gSystem->Load("ralice");
-//
-// AliAstrolab lab("IceCube","The South Pole Neutrino Observatory");
-// lab.SetLabPosition(0,-90,"deg"); // South Pole
-//
-// lab.SetLocalFrame(90,180,90,270,0,0); // Local frame has X-axis to the North
-//
-// lab.Data(1,"dms"); // Print laboratory parameters
-//
-// // Enter some observed event to be investigated
-// AliTimestamp ts;
-// ts.SetUT(1989,7,30,8,14,23,738504,0);
-// Float_t vec[3]={1,23.8,118.65};
-// Ali3Vector r;
-// r.SetVector(vec,"sph","deg");
-// lab.SetSignal(&r,"loc","M",&ts,0,"Event10372");
-//
-// // Enter some reference signals
-// Float_t alpha=194818.0;
-// Float_t delta=84400.;
-// lab.SetSignal(alpha,delta,"B",1950,"M",-1,"Altair");
-// alpha=124900.0;
-// delta=272400.;
-// lab.SetSignal(alpha,delta,"B",1950,"M",-1,"NGP");
-// alpha=64508.917;
-// delta=-164258.02;
-// lab.SetSignal(alpha,delta,"J",2000,"M",-1,"Sirius");
-// alpha=23149.08;
-// delta=891550.8;
-// lab.SetSignal(alpha,delta,"J",2000,"M",-1,"Polaris");
-// alpha=43600.;
-// delta=163100.;
-// lab.SetSignal(alpha,delta,"J",2000,"M",-1,"Aldebaran");
-// Float_t l=327.531;
-// Float_t b=-35.8903;
-// Float_t pos[3]={1,90.-b,l};
-// r.SetVector(pos,"sph","deg");
-// lab.SetUT(1989,7,30,8,14,16,0,0);
-// lab.SetSignal(&r,"gal","M",0,-1,"GRB890730");
-//
-// // List all stored objects
-// lab.ListSignals("equ","M",5);
-//
-// // Determine minimal space and time differences with reference signals
-// Double_t da,dt;
-// Int_t ia,it;
-// da=lab.GetDifference(0,"deg",dt,"s",1,&ia,&it);
-// cout << " Minimal differences damin (deg) : " << da << " dtmin (s) : " << dt
-//      << " damin-index : " << ia << " dtmin-index : " << it << endl;
-// cout << " damin for "; lab->PrintSignal("equ","T",&ts,5,ia); cout << endl;
-// cout << " dtmin for "; lab->PrintSignal("equ","T",&ts,5,it); cout << endl;
-//
-// // Search for space and time match with the reference signals
-// da=5;
-// dt=10;
-// TArrayI* arr=lab.MatchRefSignal(da,"deg",dt,"s");
-// Int_t index=0;
-// if (arr)
-// {
-//  for (Int_t i=0; i<arr->GetSize(); i++)
-//  {
-//   index=arr->At(i);
-//   cout << " Match found for index : " << index << endl;
-//   cout << " Corresponding ref. object "; lab->PrintSignal("equ","T",&ts,5,index); cout << endl;
-//  }
-// }
-//
-// // Display all stored objects in a skymap (Hammer projection)
-// lab.DisplaySignals("equ","M",&ts,"ham",1);
-//
-//--- Author: Nick van Eijndhoven 15-mar-2007 Utrecht University
-//- Modified: NvE $Date$ Utrecht University
-///////////////////////////////////////////////////////////////////////////
-
-#include <cstdlib>
-#include "AliAstrolab.h"
-#include "Riostream.h"
-ClassImp(AliAstrolab) // Class implementation to enable ROOT I/O
-AliAstrolab::AliAstrolab(const char* name,const char* title) : TTask(name,title),AliTimestamp()
-{
-// Default constructor
-
- fToffset=0;
- fXsig=0;
- fRefs=0;
- fBias=0;
- fGal=0;
- fIndices=0;
- fMeridian=-999;
- fProj="none";
- fCanvas=0;
- fHist=0;
- fMarkers=0;
-}
-///////////////////////////////////////////////////////////////////////////
-AliAstrolab::~AliAstrolab()
-{
-// Destructor to delete all allocated memory.
-
- if (fXsig)
- {
-  delete fXsig;
-  fXsig=0;
- }
- if (fRefs)
- {
-  delete fRefs;
-  fRefs=0;
- }
- if (fIndices)
- {
-  delete fIndices;
-  fIndices=0;
- }
- if (fHist)
- {
-  delete fHist;
-  fHist=0;
- }
- if (fMarkers)
- {
-  delete fMarkers;
-  fMarkers=0;
- }
- if (fCanvas)
- {
-  delete fCanvas;
-  fCanvas=0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-AliAstrolab::AliAstrolab(const AliAstrolab& t) : TTask(t),AliTimestamp(t)
-{
-// Copy constructor
-
- fToffset=t.fToffset;
- fLabPos=t.fLabPos;
- fXsig=0;
- if (t.fXsig) fXsig=new AliSignal(*(t.fXsig));
- fRefs=0;
- if (t.fRefs)
- {
-  Int_t size=t.fRefs->GetSize();
-  fRefs=new TObjArray(size);
-  for (Int_t i=0; i<size; i++)
-  {
-   AliSignal* sx=(AliSignal*)t.fRefs->At(i);
-   if (sx) fRefs->AddAt(sx->Clone(),i);
-  }
- }
- fBias=0;
- fGal=0;
- fIndices=0;
- fMeridian=-999;
- fProj="none";
- fCanvas=0;
- fHist=0;
- fMarkers=0;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::Data(Int_t mode,TString u)
-{
-// Provide lab information.
-//
-// "mode" indicates the mode of the timestamp info (see AliTimestamp::Date).
-//
-// 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
-//     "dms" : angles provided in ddd:mm:ss.sss
-//     "hms" : angles provided in hh:mm:ss.sss
-//
-// The defaults are mode=1 and u="deg".
- const char* name=GetName();
- const char* title=GetTitle();
- cout << " *" << ClassName() << "::Data*";
- if (strlen(name))  cout << " Name : " << GetName();
- if (strlen(title)) cout << " Title : " << GetTitle();
- cout << endl;
-
- Double_t l,b;
- GetLabPosition(l,b,"deg");
- cout << " Lab position longitude : "; PrintAngle(l,"deg",u,2);
- cout << " latitude : "; PrintAngle(b,"deg",u,2);
- cout << endl;
- cout << " Lab time offset w.r.t. UT : "; PrintTime(fToffset,12); cout << endl;
-
- // UT and Local time info
- Date(mode,fToffset);
-} 
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetLabPosition(Ali3Vector& p)
-{
-// Set the lab position in the terrestrial coordinates.
-// The right handed reference frame is defined such that the North Pole
-// corresponds to a polar angle theta=0 and the Greenwich meridian corresponds
-// to an azimuth angle phi=0, with phi increasing eastwards.
-
- fLabPos.SetPosition(p);
-
- // Determine local time offset in fractional hours w.r.t. UT.
- Double_t vec[3];
- p.GetVector(vec,"sph","deg");
- Double_t l=vec[2];
- fToffset=l/15.;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetLabPosition(Double_t l,Double_t b,TString u)
-{
-// Set the lab position in the terrestrial longitude (l) and latitude (b).
-// Positions north of the equator have b>0, whereas b<0 indicates
-// locations south of the equator.
-// Positions east of Greenwich have l>0, whereas l<0 indicates
-// locations west of Greenwich.
-//
-// The string argument "u" allows to choose between different angular units
-// u = "rad" : angles provided in radians
-//     "deg" : angles provided in degrees
-//     "dms" : angles provided in dddmmss.sss
-//     "hms" : angles provided in hhmmss.sss
-//
-// The default is u="deg".
-
- Double_t r=1,theta=0,phi=0;
-
- l=ConvertAngle(l,u,"deg");
- b=ConvertAngle(b,u,"deg");
-
- Double_t offset=90.;
-
- theta=offset-b;
- phi=l;
-
- Double_t p[3]={r,theta,phi};
- fLabPos.SetPosition(p,"sph","deg");
-
- // Local time offset in fractional hours w.r.t. UT.
- fToffset=l/15.;
-}
-///////////////////////////////////////////////////////////////////////////
-AliPosition AliAstrolab::GetLabPosition() const
-{
-// Provide the lab position in the terrestrial coordinates.
-// The right handed reference frame is defined such that the North Pole
-// corresponds to a polar angle theta=0 and the Greenwich meridian corresponds
-// to an azimuth angle phi=0, with phi increasing eastwards.
-
- return fLabPos;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::GetLabPosition(Double_t& l,Double_t& b,TString u) const
-{
-// Provide the lab position in the terrestrial longitude (l) and latitude (b).
-// Positions north of the equator have b>0, whereas b<0 indicates
-// locations south of the equator.
-// Positions east of Greenwich have l>0, whereas l<0 indicates
-// locations west of Greenwich.
-//
-// The string argument "u" allows to choose between different angular units
-// u = "rad" : angles provided in radians
-//     "deg" : angles provided in degrees
-//
-// The default is u="deg".
-
- Double_t pi=acos(-1.);
-
- Double_t offset=90.;
- if (u=="rad") offset=pi/2.;
-
- Double_t p[3];
- fLabPos.GetPosition(p,"sph",u);
- b=offset-p[1];
- l=p[2];
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::GetLT()
-{
-// Provide the Lab's local time in fractional hours.
-// A mean solar day lasts 24h (i.e. 86400s).
-//
-// In case a hh:mm:ss format is needed, please use the Convert() facility. 
- Double_t h=GetLT(fToffset);
- return h;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::GetLMST()
-{
-// Provide the Lab's Local Mean Sidereal Time (LMST) in fractional hours.
-// A sidereal day corresponds to 23h 56m 04.09s (i.e. 86164.09s) mean solar time.
-// The definition of GMST is such that a sidereal clock corresponds with
-// 24 sidereal hours per revolution of the Earth.
-// As such, local time offsets w.r.t. UT and GMST can be treated similarly. 
-//
-// In case a hh:mm:ss format is needed, please use the Convert() facility. 
-
- Double_t h=GetLMST(fToffset);
- return h;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::GetLAST()
-{
-// Provide the Lab's Local Apparent Sidereal Time (LAST) in fractional hours.
-// A sidereal day corresponds to 23h 56m 04.09s (i.e. 86164.09s) mean solar time.
-// The definition of GMST and GAST is such that a sidereal clock corresponds with
-// 24 sidereal hours per revolution of the Earth.
-// As such, local time offsets w.r.t. UT, GMST and GAST can be treated similarly. 
-//
-// In case a hh:mm:ss format is needed, please use the Convert() facility. 
-
- Double_t h=GetLAST(fToffset);
- return h;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::PrintAngle(Double_t a,TString in,TString out,Int_t ndig) const
-{
-// Printing of angles in various formats.
-//
-// The input argument "a" denotes the angle to be printed. 
-// The string arguments "in" and "out" specify the angular I/O formats.
-//
-// in = "rad" : input angle provided in radians
-//      "deg" : input angle provided in degrees
-//      "dms" : input angle provided in dddmmss.sss
-//      "hms" : input angle provided in hhmmss.sss
-//
-// out = "rad" : output angle provided in radians
-//       "deg" : output angle provided in degrees
-//       "dms" : output angle provided in dddmmss.sss
-//       "hms" : output angle provided in hhmmss.sss
-//
-// The argument "ndig" specifies the number of digits for the fractional
-// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
-// No rounding will be performed, so an arcsecond count of 3.473 with ndig=1
-// will appear as 03.4 on the output.
-// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
-//
-// The default is ndig=1.
-//
-// Note : The angle info is printed without additional spaces or "endline".
-//        This allows the print to be included in various composite output formats.
-
- Double_t b=ConvertAngle(a,in,out);
-
- if (out=="deg" || out=="rad")
- {
-  cout.setf(ios::fixed,ios::floatfield);
-  cout << setprecision(ndig) << b << " " << out.Data();
-  cout.unsetf(ios::fixed);
-  return; 
- }
-
- Double_t epsilon=1.e-12; // Accuracy in (arc)seconds
- Int_t word=0,ddd=0,hh=0,mm=0,ss=0;
- Double_t s;
- ULong64_t sfrac=0;
-
- if (out=="dms")
- {
-  word=Int_t(b);
-  word=abs(word);
-  ddd=word/10000;
-  word=word%10000;
-  mm=word/100;
-  ss=word%100;
-  s=fabs(b)-Double_t(ddd*10000+mm*100+ss);
-  if (s>(1.-epsilon))
-  {
-   s=0.;
-   ss++;
-  }
-  while (ss>=60)
-  {
-   ss-=60;
-   mm++;
-  }
-  while (mm>=60)
-  {
-   mm-=60;
-   ddd++;
-  }
-  while (ddd>=360)
-  {
-   ddd-=360;
-  }
-  s*=pow(10.,ndig);
-  sfrac=ULong64_t(s);
-  if (b<0) cout << "-";
-  cout << ddd << "d " << mm << "' " << ss << "."
-       << setfill('0') << setw(ndig) << sfrac << "\"";
-  return;
- }
-
- if (out=="hms")
- {
-  word=Int_t(b);
-  word=abs(word);
-  hh=word/10000;
-  word=word%10000;
-  mm=word/100;
-  ss=word%100;
-  s=fabs(b)-Double_t(hh*10000+mm*100+ss);
-  if (s>(1.-epsilon))
-  {
-   s=0.;
-   ss++;
-  }
-  while (ss>=60)
-  {
-   ss-=60;
-   mm++;
-  }
-  while (mm>=60)
-  {
-   mm-=60;
-   hh++;
-  }
-  while (hh>=24)
-  {
-   hh-=24;
-  }
-  s*=pow(10.,ndig);
-  sfrac=ULong64_t(s);
-  if (b<0) cout << "-";
-  cout << hh << "h " << mm << "m " << ss << "."
-       << setfill('0') << setw(ndig) << sfrac << "s";
-  return;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetSignal(Ali3Vector* r,TString frame,TString mode,AliTimestamp* ts,Int_t jref,TString name)
-{
-// Store a signal as specified by the position r and the timestamp ts.
-// The position is stored in International Celestial Reference System (ICRS) coordinates.
-// The ICRS is a fixed, time independent frame and as such provides a unique reference
-// frame without the need of specifying any epoch etc...
-// The ICRS coordinate definitions match within 20 mas with the mean ones of the J2000.0
-// equatorial system. Nevertheless, to obtain the highest accuracy, the slight
-// coordinate correction between J2000 and ICRS is performed here via the
-// so-called frame bias matrix.
-// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
-// which is available on http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the components of r refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d),
-//                    where the "sph" components of r correspond to theta=(pi/2)-d and phi=a.
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b),
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "hor" ==> Horizontal coordinates at the AliAstrolab location, where the "sph"
-//                    components of r correspond to theta=zenith angle and phi=pi-azimuth.
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b),
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "loc" ==> Local coordinates at the AliAstrolab location, where the "sph"
-//                    components of r correspond to the usual theta and phi angles.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "jref" allows the user to store so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Storage of the measurement
-//        j --> Storage of a reference signal at the j-th position (j=1 is first)
-//      < 0 --> Add a reference signal at the next available position
-//
-// Via the input argument "name" the user can give the stored signal also a name.
-//
-// The default values are jref=0 and name="".
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- if (!r)
- {
-  if (!jref && fXsig)
-  {
-   delete fXsig;
-   fXsig=0;
-  }
-  return;
- }
-
- if (frame!="equ" && frame!="gal" && frame!="ecl" && frame!="hor" && frame!="icr" && frame!="loc")
- {
-  if (!jref && fXsig)
-  {
-   delete fXsig;
-   fXsig=0;
-  }
-  return;
- }
-
- if (frame=="equ" && mode!="M" && mode!="m" && mode!="T" && mode!="t")
- {
-  if (!jref && fXsig)
-  {
-   delete fXsig;
-   fXsig=0;
-  }
-  return;
- }
-
- if (!ts) ts=(AliTimestamp*)this;
-
- Double_t vec[3]={1,0,0};
- vec[1]=r->GetX(2,"sph","rad");
- vec[2]=r->GetX(3,"sph","rad");
- Ali3Vector q;
- q.SetVector(vec,"sph","rad"); 
-
- AliSignal* sxref=0;
-
- if (!jref) // Storage of the measurement
- {
-  if (!fXsig)
-  {
-   fXsig=new AliSignal();
-  }
-  else
-  {
-   fXsig->Reset(1);
-  }
-  if (name != "") fXsig->SetName(name);
-  fXsig->SetTitle("Event in ICRS coordinates");
-  fXsig->SetTimestamp(*ts);
- }
- else // Storage of a reference signal
- {
-  if (!fRefs) 
-  {
-   fRefs=new TObjArray();
-   fRefs->SetOwner();
-  }
-  // Expand array size if needed
-  if (jref>0 && jref>=fRefs->GetSize()) fRefs->Expand(jref+1);
-  sxref=new AliSignal();
-  if (name != "") sxref->SetName(name);
-  sxref->SetTitle("Reference event in ICRS coordinates");
-  sxref->SetTimestamp(*ts);
- }
-
- if (frame=="loc")
- {
-  // Convert to horizontal coordinates
-  q=q.GetUnprimed(&fL);
-
-  // Store the signal
-  SetSignal(&q,"hor",mode,ts,jref);
-  return;
- }
-
- if (frame=="equ")
- {
-  // Convert to "mean" values at specified epoch
-  if (mode=="T" || mode=="t")
-  {
-   SetNmatrix(ts);
-   q=q.GetUnprimed(&fN);
-  }
-
-  // Convert to "mean" values at J2000
-  SetPmatrix(ts);
-  q=q.GetUnprimed(&fP);
-
-  // Convert to ICRS values
-  if (!fBias) SetBmatrix(); 
-  q=q.GetUnprimed(&fB);
- }
-
- if (frame=="gal")
- {
-  // Convert to J2000 equatorial mean coordinates
-  if (fGal != 2) SetGmatrix("J");
-  q=q.GetUnprimed(&fG);
-
-  // Convert to ICRS values
-  if (!fBias) SetBmatrix(); 
-  q=q.GetUnprimed(&fB);
- }
-
- if (frame=="ecl")
- {
-  // Convert to mean equatorial values at specified epoch
-  SetEmatrix(ts);
-  q=q.GetUnprimed(&fE);
-
-  // Convert to "mean" values at J2000
-  SetPmatrix(ts);
-  q=q.GetUnprimed(&fP);
-
-  // Convert to ICRS values
-  if (!fBias) SetBmatrix(); 
-  q=q.GetUnprimed(&fB);
- }
-
- if (frame=="hor")
- {
-  // Convert to "true" equatorial values at the specified timestamp
-  SetHmatrix(ts);
-  q=q.GetUnprimed(&fH);
-
-  // Convert to "mean" values at specified timestamp
-  SetNmatrix(ts);
-  q=q.GetUnprimed(&fN);
-
-  // Convert to "mean" values at J2000
-  SetPmatrix(ts);
-  q=q.GetUnprimed(&fP);
-
-  // Convert to ICRS values
-  if (!fBias) SetBmatrix(); 
-  q=q.GetUnprimed(&fB);
- }
-
- // Store the signal in ICRS coordinates
- if (!jref) // Storage of a regular signal
- {
-  fXsig->SetPosition(q);
- }
- else // Storage of a reference signal
- {
-  sxref->SetPosition(q);
-  if (jref<0)
-  {
-   fRefs->Add(sxref);
-  }
-  else
-  {
-   fRefs->AddAt(sxref,jref-1);
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetSignal(Double_t a,Double_t d,TString s,Double_t e,TString mode,Int_t jref,TString name)
-{
-// Store a signal with right ascension (a) and declination (d) given for epoch e.
-// The position is stored in International Celestial Reference System (ICRS) coordinates.
-// The ICRS is a fixed, time independent frame and as such provides a unique reference
-// frame without the need of specifying any epoch etc...
-// The ICRS coordinate definitions match within 20 mas the mean ones of the J2000.0
-// equatorial system. Nevertheless, to obtain the highest accuracy, the slight
-// coordinate correction between J2000 and ICRS is performed here via the
-// so-called frame bias matrix.
-// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
-// which is available on http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-//
-// The coordinates (a,d) can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input (a,d) coordinates.
-//
-// a    : Right ascension in hhmmss.sss
-// d    : Declination in dddmmss.sss
-// s    = "B" --> Besselian reference epoch.
-//        "J" --> Julian reference epoch.
-// e    : Reference epoch for the input coordinates (e.g. 1900, 1950, 2000,...)
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "jref" allows the user to store so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Storage of the measurement
-//        j --> Storage of a reference signal at the j-th position (j=1 is first)
-//      < 0 --> Add a reference signal at the next available position
-//
-// Via the input argument "name" the user can give the stored signal also a name.
-//
-// The default values are jref=0 and name="".
-
- if (s!="B" && s!="b" && s!="J" && s!="j")
- {
-  if (!jref && fXsig)
-  {
-   delete fXsig;
-   fXsig=0;
-  }
-  return;
- }
-
- if (mode!="M" && mode!="m" && mode!="T" && mode!="t")
- {
-  if (!jref && fXsig)
-  {
-   delete fXsig;
-   fXsig=0;
-  }
-  return;
- }
-
- // Convert coordinates to fractional degrees.
- a=ConvertAngle(a,"hms","deg");
- d=ConvertAngle(d,"dms","deg");
-
-
- AliTimestamp tx;
- tx.SetEpoch(e,s);
-
- Ali3Vector r;
- Double_t vec[3]={1.,90.-d,a};
- r.SetVector(vec,"sph","deg");
-
- SetSignal(&r,"equ",mode,&tx,jref,name);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetSignal(Double_t a,Double_t d,TString mode,AliTimestamp* ts,Int_t jref,TString name)
-{
-// Store a signal with right ascension (a) and declination (d) given for timestamp ts.
-// The position is stored in International Celestial Reference System (ICRS) coordinates.
-// The ICRS is a fixed, time independent frame and as such provides a unique reference
-// frame without the need of specifying any epoch etc...
-// The ICRS coordinate definitions match within 20 mas the mean ones of the J2000.0
-// equatorial system. Nevertheless, to obtain the highest accuracy, the slight
-// coordinate correction between J2000 and ICRS is performed here via the
-// so-called frame bias matrix.
-// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
-// which is available on http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-//
-// The coordinates (a,d) can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input (a,d) coordinates.
-//
-// a    : Right ascension in hhmmss.sss
-// d    : Declination in dddmmss.sss
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "jref" allows the user to store so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Storage of the measurement
-//        j --> Storage of a reference signal at the j-th position (j=1 is first)
-//      < 0 --> Add a reference signal at the next available position
-//
-// Via the input argument "name" the user can give the stored signal also a name.
-//
-// The default values are jref=0 and name="".
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- // Convert coordinates to fractional degrees.
- a=ConvertAngle(a,"hms","deg");
- d=ConvertAngle(d,"dms","deg");
-
- Ali3Vector r;
- Double_t vec[3]={1.,90.-d,a};
- r.SetVector(vec,"sph","deg");
-
- SetSignal(&r,"equ",mode,ts,jref,name);
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Ali3Vector& r,TString frame,TString mode,AliTimestamp* ts,Int_t jref)
-{
-// Provide the user specified coordinates of a signal at the specific timestamp ts.
-// The coordinates are returned via the vector argument "r".
-// In addition also a pointer to the stored signal object is provided.
-// In case no stored signal was available or one of the input arguments was
-// invalid, the returned pointer will be 0.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the components of r refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d),
-//                    where the "sph" components of r correspond to theta=(pi/2)-d and phi=a.
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b),
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "hor" ==> Horizontal coordinates at the AliAstrolab location, where the "sph"
-//                    components of r correspond to theta=zenith angle and phi=pi-azimuth.
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b),
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "loc" ==> Local coordinates at the AliAstrolab location, where the "sph"
-//                    components of r correspond to the usual theta and phi angles.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "jref" allows the user to access so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Access to the measurement
-//        j --> Access to the reference signal at the j-th position (j=1 is first)
-//
-// Default value is jref=0.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- r.SetZero();
-
- if (frame!="equ" && frame!="gal" && frame!="ecl" && frame!="hor" && frame!="icr" && frame!="loc") return 0;
-
- if (frame=="equ" && mode!="M" && mode!="m" && mode!="T" && mode!="t") return 0;
-
- AliSignal* sx=GetSignal(jref);
-
- if (!sx) return 0;
-
- if (!ts) ts=(AliTimestamp*)this;
-
- Double_t vec[3];
- sx->GetPosition(vec,"sph","rad");
- Ali3Vector q;
- q.SetVector(vec,"sph","rad");
-
- if (frame=="icr")
- {
-  r.Load(q);
-  return sx;
- }
-
- // Convert from ICRS to equatorial J2000 coordinates
- if (!fBias) SetBmatrix();
- q=q.GetPrimed(&fB);
-
- if (frame=="equ")
- {
-  // Precess to specified timestamp
-  AliTimestamp ts1;
-  ts1.SetEpoch(2000,"J");
-  Precess(q,&ts1,ts);
-
-  // Nutation correction if requested
-  if (mode=="T" || mode=="t") Nutate(q,ts);
- }
-
- if (frame=="gal")
- {
-  // Convert from equatorial J2000 to galactic
-  if (fGal != 2) SetGmatrix("J");
-  q=q.GetPrimed(&fG);
- }
-
- if (frame=="ecl")
- {
-  // Precess to specified timestamp
-  AliTimestamp ts1;
-  ts1.SetEpoch(2000,"J");
-  Precess(q,&ts1,ts);
-
-  // Convert from equatorial to ecliptic coordinates
-  SetEmatrix(ts);
-  q=q.GetPrimed(&fE);
- }
-
- if (frame=="hor")
- {
-  // Precess to specified timestamp
-  AliTimestamp ts1;
-  ts1.SetEpoch(2000,"J");
-  Precess(q,&ts1,ts);
-
-  // Nutation correction
-  Nutate(q,ts);
-
-  // Convert from equatorial to horizontal coordinates
-  SetHmatrix(ts);
-  q=q.GetPrimed(&fH);
- }
-
- if (frame=="loc")
- {
-  // Get the signal in horizontal coordinates
-  GetSignal(q,"hor",mode,ts);
-
-  // Convert from horizontal local-frame coordinates
-  q=q.GetPrimed(&fL);
- }
-
- r.Load(q);
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Ali3Vector& r,TString frame,TString mode,AliTimestamp* ts,TString name)
-{
-// Provide the user specified coordinates of the signal with the specified
-// name at the specific timestamp ts.
-// The coordinates are returned via the vector argument "r".
-// In addition also a pointer to the stored signal object is provided.
-// In case no such stored signal was available or one of the input arguments was
-// invalid, the returned pointer will be 0.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the components of r refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d),
-//                    where the "sph" components of r correspond to theta=(pi/2)-d and phi=a.
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b),
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "hor" ==> Horizontal coordinates at the AliAstrolab location, where the "sph"
-//                    components of r correspond to theta=zenith angle and phi=pi-azimuth.
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b),
-//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
-//          "loc" ==> Local coordinates at the AliAstrolab location, where the "sph"
-//                    components of r correspond to the usual theta and phi angles.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- AliSignal* sx=0;
- Int_t j=GetSignalIndex(name);
- if (j>=0) sx=GetSignal(r,frame,mode,ts,j);
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Double_t& a,Double_t& d,TString mode,AliTimestamp* ts,Int_t jref)
-{
-// Provide precession (and nutation) corrected right ascension (a) and
-// declination (d) of the stored signal object at the specified timestamp.
-// In addition also a pointer to the stored signal object is provided.
-// In case no stored signal was available or one of the input arguments was
-// invalid, the returned pointer will be 0.
-//
-// The coordinates (a,d) can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to select either
-// "mean" or "true" values for (a,d).
-//
-// The correction methods used are the new IAU 2000 ones as described in the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-//
-// a    : Right ascension in hhmmss.sss
-// d    : Declination in dddmmss.sss
-// mode = "M" --> Output coordinates are the mean values 
-//        "T" --> Output coordinates are the true values 
-// ts   : Timestamp at which the corrected coordinate values are requested.
-//
-// The input parameter "jref" allows the user to access so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored regular signal (e.g. coincidence of the stored signal with transient phenomena).
-//
-// jref = 0 --> Access to the measurement
-//        j --> Access to the reference signal at the j-th position (j=1 is first)
-//
-// Default value is jref=0.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- a=0;
- d=0;
-
- Ali3Vector r;
- AliSignal* sx=GetSignal(r,"equ",mode,ts,jref);
-
- if (!sx) return 0;
-
- // Retrieve the requested (a,d) values
- Double_t vec[3];
- r.GetVector(vec,"sph","deg");
- d=90.-vec[1];
- a=vec[2];
-
- while (a<-360.)
- {
-  a+=360.;
- }
- while (a>360.)
- {
-  a-=360.;
- }
- while (d<-90.)
- {
-  d+=90.;
- }
- while (d>90.)
- {
-  d-=90.;
- }
-
- // Convert coordinates to appropriate format
- a=ConvertAngle(a,"deg","hms");
- d=ConvertAngle(d,"deg","dms");
-
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Double_t& a,Double_t& d,TString mode,AliTimestamp* ts,TString name)
-{
-// Provide precession (and nutation) corrected right ascension (a) and
-// declination (d) of the stored signal object with the specified name
-// at the specific timestamp ts.
-// In addition also a pointer to the stored signal object is provided.
-// In case no stored signal was available or one of the input arguments was
-// invalid, the returned pointer will be 0.
-//
-// The coordinates (a,d) can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to select either
-// "mean" or "true" values for (a,d).
-//
-// The correction methods used are the new IAU 2000 ones as described in the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-//
-// a    : Right ascension in hhmmss.sss
-// d    : Declination in dddmmss.sss
-// mode = "M" --> Output coordinates are the mean values 
-//        "T" --> Output coordinates are the true values 
-// ts   : Timestamp at which the corrected coordinate values are requested.
-// name : Name of the requested signal object
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- AliSignal* sx=0;
- Int_t j=GetSignalIndex(name);
- if (j>=0) sx=GetSignal(a,d,mode,ts,j);
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Double_t& a,Double_t& d,TString s,Double_t e,TString mode,Int_t jref)
-{
-// Provide precession (and nutation) corrected right ascension (a) and
-// declination (d) of the stored signal object at the specified epoch e.
-// In addition also a pointer to the stored signal object is provided.
-// In case no stored signal was available or one of the input arguments was
-// invalid, the returned pointer will be 0.
-//
-// The coordinates (a,d) can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input (a,d) coordinates.
-//
-// a    : Right ascension in hhmmss.sss
-// d    : Declination in dddmmss.sss
-// s    = "B" --> Besselian reference epoch.
-//        "J" --> Julian reference epoch.
-// e    : Reference epoch for the input coordinates (e.g. 1900, 1950, 2000,...)
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "jref" allows the user to access so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Access to the measurement
-//        j --> Access to the reference signal at the j-th position (j=1 is first)
-//
-// Default value is jref=0.
-
- a=0;
- d=0;
-
- if (s!="B" && s!="b" && s!="J" && s!="j") return 0;
-
- if (mode!="M" && mode!="m" && mode!="T" && mode!="t") return 0;
-
- // Convert coordinates to fractional degrees.
- a=ConvertAngle(a,"hms","deg");
- d=ConvertAngle(d,"dms","deg");
-
-
- AliTimestamp tx;
- tx.SetEpoch(e,s);
-
- AliSignal* sx=GetSignal(a,d,mode,&tx,jref);
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Double_t& a,Double_t& d,TString s,Double_t e,TString mode,TString name)
-{
-// Provide precession (and nutation) corrected right ascension (a) and
-// declination (d) of the stored signal object with the specified name
-// at the specific epoch e.
-// In addition also a pointer to the stored signal object is provided.
-// In case no stored signal was available or one of the input arguments was
-// invalid, the returned pointer will be 0.
-//
-// The coordinates (a,d) can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input (a,d) coordinates.
-//
-// a    : Right ascension in hhmmss.sss
-// d    : Declination in dddmmss.sss
-// s    = "B" --> Besselian reference epoch.
-//        "J" --> Julian reference epoch.
-// e    : Reference epoch for the input coordinates (e.g. 1900, 1950, 2000,...)
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-// name : Name of the requested signal object
-
- AliSignal* sx=0;
- Int_t j=GetSignalIndex(name);
- if (j>=0) sx=GetSignal(a,d,s,e,mode,j);
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(Int_t jref)
-{
-// Provide the pointer to a stored signal object.
-//
-// The input parameter "jref" allows the user to access so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Access to the measurement
-//        j --> Access to the reference signal at the j-th position (j=1 is first)
-//
-// Default value is jref=0.
-
- AliSignal* sx=0;
- if (!jref)
- {
-  sx=fXsig;
- }
- else
- {
-  if (jref>0 && jref<fRefs->GetSize()) sx=(AliSignal*)fRefs->At(jref-1);
- }
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliAstrolab::GetSignal(TString name)
-{
-// Provide the pointer to the stored signal object with the specified name.
-
- AliSignal* sx=0;
- Int_t j=GetSignalIndex(name);
- if (j>=0) sx=GetSignal(j);
- return sx;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::RemoveRefSignal(Int_t j,Int_t compress)
-{
-// Remove the reference signal which was stored at the j-th position (j=1 is first).
-// Note : j=0 means that all stored reference signals will be removed.
-//        j<0 allows array compression (see below) without removing any signals. 
-//
-// The "compress" parameter allows compression of the ref. signal storage array.
-//
-// compress = 1 --> Array will be compressed
-//            0 --> Array will not be compressed
-//
-// Note : Compression of the storage array means that the indices of the
-//        reference signals in the storage array will change.
-
- if (!fRefs) return;
-
- // Clearing of the complete storage
- if (!j)
- {
-  delete fRefs;
-  fRefs=0;
-  return;
- }
-
- // Removing a specific reference signal
- if (j>0 && j<fRefs->GetSize())
- {
-  TObject* obj=fRefs->RemoveAt(j-1);
-  if (obj) delete obj;
- }
-
- // Compression of the storage array
- if (compress) fRefs->Compress();
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::RemoveRefSignal(TString name,Int_t compress)
-{
-// Remove the reference signal with the specified name.
-//
-// The "compress" parameter allows compression of the ref. signal storage array.
-//
-// compress = 1 --> Array will be compressed
-//            0 --> Array will not be compressed
-//
-// Note : Compression of the storage array means that the indices of the
-//        reference signals in the storage array will change.
-
- Int_t j=GetSignalIndex(name);
- if (j>0) RemoveRefSignal(j,compress);
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAstrolab::GetSignalIndex(TString name)
-{
-// Provide storage index of the signal with the specified name.
-// In case the name matches with the stored measurement,
-// the value 0 is returned.
-// In case no signal with the specified name was found, the value -1 is returned.
-
- Int_t index=-1;
- if (fXsig)
- {
-  if (name==fXsig->GetName()) return 0;
- }
-
- if (!fRefs) return -1;
-
- for (Int_t i=0; i<fRefs->GetSize(); i++)
- {
-  AliSignal* sx=(AliSignal*)fRefs->At(i);
-  if (!sx) continue;
-
-  if (name==sx->GetName())
-  {
-   index=i+1;
-   break;
-  }
- }
-
- return index;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::PrintSignal(TString frame,TString mode,AliTimestamp* ts,Int_t ndig,Int_t jref)
-{
-// Print data of a stored signal in user specified coordinates at the specific timestamp ts.
-// In case no stored signal was available or one of the input arguments was
-// invalid, no printout is produced.
-//
-// The argument "ndig" specifies the number of digits for the fractional
-// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
-// No rounding will be performed, so an arcsecond count of 3.473 with ndig=1
-// will appear as 03.4 on the output.
-// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
-//
-// Note : The angle info is printed without additional spaces or "endline".
-//        This allows the print to be included in various composite output formats.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the coordinates refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
-//
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b).
-//
-//          "hor" ==> Horizontal azimuth and altitude coordinates at the AliAstrolab location.
-//
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
-//
-//          "loc" ==> Local spherical angles theta and phi at the AliAstrolab location.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "mode" also determines which type of time and
-// local hour angle will appear in the printout.
-//
-// mode = "M" --> Mean Sidereal Time (MST) and Local Mean Hour Angle (LMHA)
-//        "T" --> Apparent Sidereal Time (AST) and Local Apparent Hour Angle (LAHA)
-//
-// The input parameter "jref" allows printing of a so-called "reference" signal.
-// These reference signals may serve to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Printing of the measurement
-//        j --> Printing of the j-th reference signal
-//
-// Default value is jref=0.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- Ali3Vector r;
- AliSignal* sx=GetSignal(r,frame,mode,ts,jref);
-
- if (!sx) return;
-
- // Local Hour Angle of the signal
- Double_t lha=GetHourAngle("A",ts,jref);
- TString slha="LAHA";
- if (mode=="M" || mode=="m")
- {
-  lha=GetHourAngle("M",ts,jref);
-  slha="LMHA";
- }
-
- TString name=sx->GetName();
- if (name != "") cout << name.Data() << " ";
-
- if (frame=="equ")
- {
-  Double_t a,d;
-  d=90.-r.GetX(2,"sph","deg");
-  a=r.GetX(3,"sph","rad");
-  cout << "Equatorial (" << mode.Data() <<") a : "; PrintAngle(a,"rad","hms",ndig);
-  cout << " d : "; PrintAngle(d,"deg","dms",ndig);
-  cout << " " << slha.Data() << " : "; PrintAngle(lha,"deg","hms",ndig);
-  return;
- }
-
- if (frame=="gal")
- {
-  Double_t l,b;
-  b=90.-r.GetX(2,"sph","deg");
-  l=r.GetX(3,"sph","deg");
-  cout << "Galactic l : "; PrintAngle(l,"deg","deg",ndig);
-  cout << " b : "; PrintAngle(b,"deg","deg",ndig); 
-  cout << " " << slha.Data() << " : "; PrintAngle(lha,"deg","hms",ndig);
-  return;
- }
-
- if (frame=="icr")
- {
-  Double_t a,d;
-  d=90.-r.GetX(2,"sph","deg");
-  a=r.GetX(3,"sph","rad");
-  cout << "ICRS l : "; PrintAngle(a,"rad","hms",ndig);
-  cout << " b : "; PrintAngle(d,"deg","dms",ndig);
-  cout << " " << slha.Data() << " : "; PrintAngle(lha,"deg","hms",ndig);
-  return;
- }
-
- if (frame=="ecl")
- {
-  Double_t a,d;
-  d=90.-r.GetX(2,"sph","deg");
-  a=r.GetX(3,"sph","deg");
-  cout << "Ecliptic l : "; PrintAngle(a,"deg","deg",ndig);
-  cout << " b : "; PrintAngle(d,"deg","deg",ndig);
-  cout << " " << slha.Data() << " : "; PrintAngle(lha,"deg","hms",ndig);
-  return;
- }
-
- if (frame=="hor")
- {
-  Double_t alt=90.-r.GetX(2,"sph","deg");
-  Double_t azi=180.-r.GetX(3,"sph","deg");
-  while (azi>360)
-  {
-   azi-=360.;
-  }
-  while (azi<0)
-  {
-   azi+=360.;
-  }
-  cout << "Horizontal azi : "; PrintAngle(azi,"deg","deg",ndig);
-  cout << " alt : "; PrintAngle(alt,"deg","deg",ndig);
-  cout << " " << slha.Data() << " : "; PrintAngle(lha,"deg","hms",ndig);
-  return;
- }
-
- if (frame=="loc")
- {
-  Double_t theta=r.GetX(2,"sph","deg");
-  Double_t phi=r.GetX(3,"sph","deg");
-  cout << "Local-frame phi : "; PrintAngle(phi,"deg","deg",ndig);
-  cout << " theta : "; PrintAngle(theta,"deg","deg",ndig);
-  cout << " " << slha.Data() << " : "; PrintAngle(lha,"deg","hms",ndig);
-  return;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::PrintSignal(TString frame,TString mode,AliTimestamp* ts,Int_t ndig,TString name)
-{
-// Print data of the stored signal with the specified name in user specified coordinates
-// at the specific timestamp ts.
-// In case no such stored signal was available or one of the input arguments was
-// invalid, no printout is produced.
-//
-// The argument "ndig" specifies the number of digits for the fractional
-// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
-// No rounding will be performed, so an arcsecond count of 3.473 with ndig=1
-// will appear as 03.4 on the output.
-// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
-//
-// Note : The angle info is printed without additional spaces or "endline".
-//        This allows the print to be included in various composite output formats.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the coordinates refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
-//
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b).
-//
-//          "hor" ==> Horizontal azimuth and altitude coordinates at the AliAstrolab location.
-//
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
-//
-//          "loc" ==> Local spherical angles theta and phi at the AliAstrolab location.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "mode" also determines which type of time and
-// local hour angle will appear in the printout.
-//
-// mode = "M" --> Mean Sidereal Time (MST) and Local Mean Hour Angle (LMHA)
-//        "T" --> Apparent Sidereal Time (AST) and Local Apparent Hour Angle (LAHA)
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- Int_t j=GetSignalIndex(name);
- if (j>=0) PrintSignal(frame,mode,ts,ndig,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::ListSignals(TString frame,TString mode,Int_t ndig)
-{
-// List all stored signals in user specified coordinates at the timestamp
-// of the actual recording of the stored measurement under investigation.
-// In case no (timestamp of the) actual measurement is available,
-// the current timestamp of the lab will be taken.
-// In case no stored signal is available or one of the input arguments is
-// invalid, no printout is produced.
-//
-// The argument "ndig" specifies the number of digits for the fractional
-// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
-// No rounding will be performed, so an arcsecond count of 3.473 with ndig=1
-// will appear as 03.4 on the output.
-// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
-//
-// The default value is ndig=1.
-//
-// Note : The angle info is printed without additional spaces or "endline".
-//        This allows the print to be included in various composite output formats.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the coordinates refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
-//
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b).
-//
-//          "hor" ==> Horizontal azimuth and altitude coordinates at the AliAstrolab location.
-//
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
-//
-//          "loc" ==> Local spherical angles theta and phi at the AliAstrolab location.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "mode" also determines which type of time and
-// local hour angle will appear in the listing.
-//
-// mode = "M" --> Mean Sidereal Time (MST) and Local Mean Hour Angle (LMHA)
-//        "T" --> Apparent Sidereal Time (AST) and Local Apparent Hour Angle (LAHA)
-
- Int_t iprint=0;
-
- AliTimestamp* tx=0;
-
- Int_t dform=1;
- if (mode=="T" || mode=="t") dform=-1;
-
- if (fXsig)
- {
-  tx=fXsig->GetTimestamp();
-  if (!tx) tx=(AliTimestamp*)this;
-  cout << " *AliAstrolab::ListSignals* List of all stored signals." << endl;
-  cout << " === The measurement under investigation ===" << endl;
-  cout << " Timestamp of the actual observation" << endl;
-  tx->Date(dform,fToffset);
-  cout << " Location of the actual observation" << endl;
-  cout << " "; PrintSignal(frame,mode,tx,ndig); cout << endl;
-  iprint=1;
- }
-
- if (!fRefs) return;
-
- for (Int_t i=1; i<=fRefs->GetSize(); i++)
- {
-  AliSignal* sx=GetSignal(i);
-  if (!sx) continue;
-
-  if (!iprint)
-  {
-   cout << " *AliAstrolab::ListRefSignals* List of all stored signals." << endl;
-   tx=(AliTimestamp*)this;
-   cout << " Current timestamp of the laboratory" << endl;
-   tx->Date(dform,fToffset);
-   iprint=1;
-  }
-  if (iprint==1)
-  {
-   cout << " === All stored reference signals according to the above timestamp ===" << endl;
-   iprint=2;
-  }
-  cout << " Index : " << i << " "; PrintSignal(frame,mode,tx,ndig,i); cout << endl;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::Precess(Ali3Vector& r,AliTimestamp* ts1,AliTimestamp* ts2)
-{
-// Correct mean right ascension and declination given for Julian date "jd"
-// for the earth's precession corresponding to the specified timestamp.
-// The results are the so-called "mean" (i.e. precession corrected) values,
-// corresponding to the specified timestamp.
-// The method used is the new IAU 2000 one as described in the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-// Since the standard reference epoch is J2000, this implies that all
-// input (a,d) coordinates will be first internally converted to the
-// corresponding J2000 values before the precession correction w.r.t. the
-// specified lab timestamp will be applied.
-//
-// r  : Input vector containing the right ascension and declination information
-//      in the form of standard Ali3Vector coordinates.
-//      In spherical coordinates the phi corresponds to the right ascension,
-//      whereas the declination corresponds to (pi/2)-theta.
-// jd : Julian date corresponding to the input coordinate values.
-// ts : Timestamp corresponding to the requested corrected coordinate values.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- // Convert back to J2000 values
- Ali3Vector r0;
- SetPmatrix(ts1);
- r0=r.GetUnprimed(&fP);
-
- // Precess to the specified timestamp
- if (!ts2) ts2=(AliTimestamp*)this;
- SetPmatrix(ts2);
- r=r0.GetPrimed(&fP);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::Nutate(Ali3Vector& r,AliTimestamp* ts)
-{
-// Correct mean right ascension and declination for the earth's nutation
-// corresponding to the specified timestamp.
-// The results are the so-called "true" (i.e. nutation corrected) values,
-// corresponding to the specified timestamp.
-// The method used is the new IAU 2000 one as described in the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-//
-// r  : Input vector containing the right ascension and declination information
-//      in the form of standard Ali3Vector coordinates.
-//      In spherical coordinates the phi corresponds to the right ascension,
-//      whereas the declination corresponds to (pi/2)-theta.
-// ts : Timestamp for which the corrected coordinate values are requested.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- // Nutation correction for the specified timestamp
- if (!ts) ts=(AliTimestamp*)this;
- SetNmatrix(ts);
- r=r.GetPrimed(&fN);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetBmatrix()
-{
-// Set the frame bias matrix elements.
-// The formulas and numerical constants used are the ones from the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-
- Double_t pi=acos(-1.);
- // Parameters in mas
- Double_t a=-14.6;
- Double_t x=-16.6170;
- Double_t e=-6.8192;
-
- // Convert to radians
- a*=pi/(180.*3600.*1000.);
- x*=pi/(180.*3600.*1000.);
- e*=pi/(180.*3600.*1000.);
-
- Double_t mat[9];
- mat[0]=1.-0.5*(a*a+x*x);
- mat[1]=a;
- mat[2]=-x;
- mat[3]=-a-e*x;
- mat[4]=1.-0.5*(a*a+e*e);
- mat[5]=-e;
- mat[6]=x-e*a;
- mat[7]=e+x*a;
- mat[8]=1.-0.5*(e*e+x*x);
-
- fB.SetMatrix(mat);
- fBias=1;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetPmatrix(AliTimestamp* ts)
-{
-// Set precession matrix elements for Julian date jd w.r.t. J2000.
-// The formulas and numerical constants used are the ones from the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-// All numerical constants refer to the standard reference epoch J2000.
-
- Double_t mat[9]={0,0,0,0,0,0,0,0,0};
- if (!ts)
- {
-  fP.SetMatrix(mat);
-  return;
- }
-
- Double_t pi=acos(-1.);
-
- Double_t t=(ts->GetJD()-2451545.0)/36525.; // Julian centuries since J2000.0
-
- // Parameters for the precession matrix in arcseconds
- Double_t eps0=84381.406; // Mean ecliptic obliquity at J2000.0
- Double_t psi=5038.481507*t-1.0790069*pow(t,2)-0.00114045*pow(t,3)+0.000132851*pow(t,4)
-                -0.0000000951*pow(t,4);
- Double_t om=eps0-0.025754*t+0.0512623*pow(t,2)-0.00772503*pow(t,3)-0.000000467*pow(t,4)
-                 +0.0000003337*pow(t,5);
- Double_t chi=10.556403*t-2.3814292*pow(t,2)-0.00121197*pow(t,3)+0.000170663*pow(t,4)
-              -0.0000000560*pow(t,5);
-
- // Convert to radians
- eps0*=pi/(180.*3600.);
- psi*=pi/(180.*3600.);
- om*=pi/(180.*3600.);
- chi*=pi/(180.*3600.);
-
- Double_t s1=sin(eps0);
- Double_t s2=sin(-psi);
- Double_t s3=sin(-om);
- Double_t s4=sin(chi);
- Double_t c1=cos(eps0);
- Double_t c2=cos(-psi);
- Double_t c3=cos(-om);
- Double_t c4=cos(chi);
-
- mat[0]=c4*c2-s2*s4*c3;
- mat[1]=c4*s2*c1+s4*c3*c2*c1-s1*s4*s3;
- mat[2]=c4*s2*s1+s4*c3*c2*s1+c1*s4*s3;
- mat[3]=-s4*c2-s2*c4*c3;
- mat[4]=-s4*s2*c1+c4*c3*c2*c1-s1*c4*s3;
- mat[5]=-s4*s2*s1+c4*c3*c2*s1+c1*c4*s3;
- mat[6]=s2*s3;
- mat[7]=-s3*c2*c1-s1*c3;
- mat[8]=-s3*c2*s1+c3*c1;
-
- fP.SetMatrix(mat);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetNmatrix(AliTimestamp* ts)
-{
-// Set nutation matrix elements for the specified Julian date jd.
-// The formulas and numerical constants used are the ones from the 
-// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
-// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
-
- Double_t mat[9]={0,0,0,0,0,0,0,0,0};
- if (!ts)
- {
-  fN.SetMatrix(mat);
-  return;
- }
-
- Double_t pi=acos(-1.);
- Double_t dpsi,deps,eps;
- ts->Almanac(&dpsi,&deps,&eps);
-
- // Convert to radians
- dpsi*=pi/(180.*3600.);
- deps*=pi/(180.*3600.);
- eps*=pi/(180.*3600.);
-
- Double_t s1=sin(eps);
- Double_t s2=sin(-dpsi);
- Double_t s3=sin(-(eps+deps));
- Double_t c1=cos(eps);
- Double_t c2=cos(-dpsi);
- Double_t c3=cos(-(eps+deps));
-
- mat[0]=c2;
- mat[1]=s2*c1;
- mat[2]=s2*s1;
- mat[3]=-s2*c3;
- mat[4]=c3*c2*c1-s1*s3;
- mat[5]=c3*c2*s1+c1*s3;
- mat[6]=s2*s3;
- mat[7]=-s3*c2*c1-s1*c3;
- mat[8]=-s3*c2*s1+c3*c1;
-
- fN.SetMatrix(mat);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetGmatrix(TString mode)
-{
-// Set the mean equatorial to galactic coordinate conversion matrix.
-// The B1950 parameters were taken from section 22.3 of the book
-// "An Introduction to Modern Astrophysics" by Carrol and Ostlie (1996).
-// The J2000 parameters are obtained by precession of the B1950 values.
-//
-// Via the input argument "mode" the required epoch can be selected
-// mode = "B" ==> B1950
-//        "J" ==> J2000
-
- Ali3Vector x; // The Galactic x-axis in the equatorial frame
- Ali3Vector y; // The Galactic y-axis in the equatorial frame
- Ali3Vector z; // The Galactic z-axis in the equatorial frame
-
- Double_t a,d;
- Double_t vec[3]={1,0,0};
-
- fGal=1; // Set flag to indicate B1950 matrix values
-
- // B1950 equatorial coordinates of the North Galactic Pole (NGP)
- a=124900.;
- d=272400.;
- a=ConvertAngle(a,"hms","deg");
- d=ConvertAngle(d,"dms","deg");
- vec[1]=90.-d;
- vec[2]=a;
- z.SetVector(vec,"sph","deg");
-
- // B1950 equatorial coordinates of the Galactic l=b=0 point
- a=174224.;
- d=-285500.;
- a=ConvertAngle(a,"hms","deg");
- d=ConvertAngle(d,"dms","deg");
- vec[1]=90.-d;
- vec[2]=a;
- x.SetVector(vec,"sph","deg");
-
- // Precess to the corresponding J2000 values if requested
- if (mode=="J")
- {
-  fGal=2; // Set flag to indicate J2000 matrix values
-  AliTimestamp t1;
-  t1.SetEpoch(1950,"B");
-  AliTimestamp t2;
-  t2.SetEpoch(2000,"J");
-  Precess(z,&t1,&t2);
-  Precess(x,&t1,&t2);
- }
-
- // The Galactic y-axis is determined for the right handed frame
- y=z.Cross(x);
-
- fG.SetAngles(x.GetX(2,"sph","deg"),x.GetX(3,"sph","deg"),
-              y.GetX(2,"sph","deg"),y.GetX(3,"sph","deg"),
-              z.GetX(2,"sph","deg"),z.GetX(3,"sph","deg"));
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetEmatrix(AliTimestamp* ts)
-{
-// Set the mean equatorial to ecliptic coordinate conversion matrix
-// for the specified timestamp.
-// A nice sketch and explanation of the two frames can be found
-// in chapter 3 of the book "Astronomy Methods" by Hale Bradt (2004).
-
- Double_t dpsi,deps,eps;
- ts->Almanac(&dpsi,&deps,&eps);
-
- // Convert to degrees
- eps/=3600.;
-
- // Positions of the ecliptic axes w.r.t. the equatorial ones
- // at the moment of the specified timestamp 
- Double_t theta1=90; // Ecliptic x-axis
- Double_t phi1=0;
- Double_t theta2=90.-eps; //Ecliptic y-axis
- Double_t phi2=90;
- Double_t theta3=eps; // Ecliptic z-axis
- Double_t phi3=270;
-
- fE.SetAngles(theta1,phi1,theta2,phi2,theta3,phi3);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetHmatrix(AliTimestamp* ts)
-{
-// Set the mean equatorial to horizontal coordinate conversion matrix
-// for the specified timestamp.
-// A nice sketch and explanation of the two frames can be found
-// in chapter 3 of the book "Astronomy Methods" by Hale Bradt (2004).
-//
-// Note : In order to simplify the calculations, we use here a
-//        right-handed horizontal frame.
-
- Ali3Vector x; // The (South pointing) horizontal x-axis in the equatorial frame
- Ali3Vector y; // The (East pointing) horizontal y-axis in the equatorial frame
- Ali3Vector z; // The (Zenith pointing) horizontal z-axis in the equatorial frame
-
- Double_t l,b;
- GetLabPosition(l,b,"deg");
-
- Double_t a;
- Double_t vec[3]={1,0,0};
-
- // Equatorial coordinates of the horizontal z-axis
- // at the moment of the specified timestamp 
- a=ts->GetLAST(fToffset);
- a*=15.; // Convert fractional hours to degrees 
- vec[1]=90.-b;
- vec[2]=a;
- z.SetVector(vec,"sph","deg");
-
- // Equatorial coordinates of the horizontal x-axis
- // at the moment of the specified timestamp 
- vec[1]=180.-b;
- vec[2]=a;
- x.SetVector(vec,"sph","deg");
-
- // The horizontal y-axis is determined for the right handed frame
- y=z.Cross(x);
-
- fH.SetAngles(x.GetX(2,"sph","deg"),x.GetX(3,"sph","deg"),
-              y.GetX(2,"sph","deg"),y.GetX(3,"sph","deg"),
-              z.GetX(2,"sph","deg"),z.GetX(3,"sph","deg"));
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetLocalFrame(Double_t t1,Double_t p1,Double_t t2,Double_t p2,Double_t t3,Double_t p3)
-{
-// Specification of the orientations of the local-frame axes.
-// The input arguments represent the angles (in degrees) of the local-frame axes
-// w.r.t. a so called Master Reference Frame (MRF), with the same convention
-// as the input arguments of TRotMatrix::SetAngles.
-//
-// The right handed Master Reference Frame is defined as follows :
-//  Z-axis : Points to the local Zenith
-//  X-axis : Makes an angle of 90 degrees with the Z-axis and points South
-//  Y-axis : Makes an angle of 90 degrees with the Z-axis and points East
-//
-// Once the user has specified the local reference frame, any observed event
-// can be related to astronomical space-time locations via the SetSignal
-// and GetSignal memberfunctions.
-
- // Set the matrix for the conversion of our reference frame coordinates
- // into the local-frame ones.
-
- fL.SetAngles(t1,p1,t2,p2,t3,p3);
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::ConvertAngle(Double_t a,TString in,TString out) const
-{
-// Conversion of various angular formats.
-//
-// The input argument "a" denotes the angle to be converted. 
-// The string arguments "in" and "out" specify the angular I/O formats.
-//
-// in = "rad" : input angle provided in radians
-//      "deg" : input angle provided in degrees
-//      "dms" : input angle provided in dddmmss.sss
-//      "hms" : input angle provided in hhmmss.sss
-//      "hrs" : input angle provided in fractional hours
-//
-// out = "rad" : output angle provided in radians
-//       "deg" : output angle provided in degrees
-//       "dms" : output angle provided in dddmmss.sss
-//       "hms" : output angle provided in hhmmss.sss
-//       "hrs" : output angle provided in fractional hours
- if (in==out) return a;
-
- // Convert input to its absolute value in (fractional) degrees. 
- Double_t pi=acos(-1.);
- Double_t epsilon=1.e-12; // Accuracy in (arc)seconds
- Int_t word=0,ddd=0,hh=0,mm=0,ss=0;
- Double_t s=0;
-
- Double_t b=fabs(a);
-
- if (in=="rad") b*=180./pi;
-
- if (in=="hrs") b*=15.;
-
- if (in=="dms")
- {
-  word=Int_t(b);
-  ddd=word/10000;
-  word=word%10000;
-  mm=word/100;
-  ss=word%100;
-  s=b-Double_t(ddd*10000+mm*100+ss);
-  b=Double_t(ddd)+Double_t(mm)/60.+(Double_t(ss)+s)/3600.;
- }
-
- if (in=="hms")
- {
-  word=Int_t(b);
-  hh=word/10000;
-  word=word%10000;
-  mm=word/100;
-  ss=word%100;
-  s=b-Double_t(hh*10000+mm*100+ss);
-  b=15.*(Double_t(hh)+Double_t(mm)/60.+(Double_t(ss)+s)/3600.);
- }
-
- while (b>360)
- {
-  b-=360.;
- }
-
- if (out=="rad") b*=pi/180.;
-
- if (out=="hrs") b/=15.;
-
- if (out=="dms")
- {
-  ddd=Int_t(b);
-  b=b-Double_t(ddd);
-  b*=60.;
-  mm=Int_t(b);
-  b=b-Double_t(mm);
-  b*=60.;
-  ss=Int_t(b);
-  s=b-Double_t(ss);
-  if (s>(1.-epsilon))
-  {
-   s=0.;
-   ss++;
-  }
-  while (ss>=60)
-  {
-   ss-=60;
-   mm++;
-  }
-  while (mm>=60)
-  {
-   mm-=60;
-   ddd++;
-  }
-  while (ddd>=360)
-  {
-   ddd-=360;
-  }
-  b=Double_t(10000*ddd+100*mm+ss)+s;
- }
-
- if (out=="hms")
- {
-  b/=15.;
-  hh=Int_t(b);
-  b=b-Double_t(hh);
-  b*=60.;
-  mm=Int_t(b);
-  b=b-Double_t(mm);
-  b*=60.;
-  ss=Int_t(b);
-  s=b-Double_t(ss);
-  if (s>(1.-epsilon))
-  {
-   s=0.;
-   ss++;
-  }
-  while (ss>=60)
-  {
-   ss-=60;
-   mm++;
-  }
-  while (mm>=60)
-  {
-   mm-=60;
-   hh++;
-  }
-  while (hh>=24)
-  {
-   hh-=24;
-  }
-  b=Double_t(10000*hh+100*mm+ss)+s;
- }
-
- if (a<0) b=-b;
-
- return b;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::GetHourAngle(TString mode,AliTimestamp* ts,Int_t jref)
-{
-// Provide the Local Hour Angle (in fractional degrees) of a stored signal
-// object at the specified timestamp.
-//
-// The input parameter "mode" allows the user to select either the
-// "mean" or "apparent" value for the returned Hour Angle.
-//
-// mode = "M" --> Output is the Mean Hour Angle
-//        "A" --> Output is the Apparent Hour Angle
-// ts   : Timestamp at which the hour angle is requested.
-//
-// The input parameter "jref" allows the user to specify so-called "reference" signals.
-// These reference signals may be used to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Use the stored measurement
-//        j --> Use the reference signal at the j-th position (j=1 is first)
-//
-// Default value is jref=0.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-
- if (!ts) ts=(AliTimestamp*)this;
-
- // Get corrected right ascension and declination for the specified timestamp.
- Double_t a,d;
- if (mode=="M" || mode=="m") GetSignal(a,d,"M",ts,jref);
- if (mode=="A" || mode=="a") GetSignal(a,d,"T",ts,jref);
-
- // Convert coordinates to fractional degrees.
- a=ConvertAngle(a,"hms","deg");
- d=ConvertAngle(d,"dms","deg");
-
- a/=15.; // Convert a to fractional hours
- Double_t ha=0;
- if (mode=="M" || mode=="m") ha=ts->GetLMST(fToffset)-a;
- if (mode=="A" || mode=="a") ha=ts->GetLAST(fToffset)-a;
- ha*=15.; // Convert to (fractional) degrees
-
- return ha;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetLT(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns,Int_t ps)
-{
-// Set the AliTimestamp parameters corresponding to the LT date and time
-// in the Gregorian calendar as specified by the input arguments.
-//
-// The input arguments represent the following :
-// y  : year in LT (e.g. 1952, 2003 etc...)
-// m  : month in LT (1=jan  2=feb etc...)
-// d  : day in LT (1-31)
-// hh : elapsed hours in LT (0-23) 
-// mm : elapsed minutes in LT (0-59)
-// ss : elapsed seconds in LT (0-59)
-// ns : remaining fractional elapsed second of LT in nanosecond
-// ps : remaining fractional elapsed nanosecond of LT in picosecond
-//
-// Note : ns=0 and ps=0 are the default values.
-//
-
- SetLT(fToffset,y,m,d,hh,mm,ss,ns,ps);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetLT(Int_t y,Int_t d,Int_t s,Int_t ns,Int_t ps)
-{
-// Set the AliTimestamp parameters corresponding to the specified elapsed
-// timespan since the beginning of the new LT year.
-//
-// The LT year and elapsed time span is entered via the following input arguments :
-//
-// y  : year in LT (e.g. 1952, 2003 etc...)
-// d  : elapsed number of days 
-// s  : (remaining) elapsed number of seconds
-// ns : (remaining) elapsed number of nanoseconds
-// ps : (remaining) elapsed number of picoseconds
-//
-// The specified d, s, ns and ps values will be used in an additive
-// way to determine the elapsed timespan.
-// So, specification of d=1, s=100, ns=0, ps=0 will result in the
-// same elapsed time span as d=0, s=24*3600+100, ns=0, ps=0.
-// However, by making use of the latter the user should take care
-// of possible integer overflow problems in the input arguments,
-// which obviously will provide incorrect results. 
-//
-// Note : ns=0 and ps=0 are the default values.
-
- SetLT(fToffset,y,d,s,ns,ps);
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::GetDifference(Int_t j,TString au,Double_t& dt,TString tu,Int_t mode,Int_t* ia,Int_t* it)
-{
-// Provide space and time difference between the j-th reference signal
-// (j=1 indicates first) and the stored measurement.
-// 
-// The return value of this memberfunction provides the positional angular
-// difference, whereas the output argument "dt" provides the time difference.
-//
-// The units of the angular difference can be specified via the the "au"
-// input argument, where
-//
-// au = "rad" --> Angular difference in (fractional) radians
-//      "deg" --> Angular difference in (fractional) degrees
-//
-// The units of the time difference can be specified via the "tu" and "mode"
-// input arguments. For details please refer to AliTimestamp::GetDifference().
-// Also here mode=1 is the default value.
-//
-// For the time difference the reference signal is used as the standard.
-// This means that in case of a positive time difference, the stored
-// measurement occurred later than the reference signal.
-//
-// In case j=0, the stored measurement will be compared with each
-// reference signal and the returned angular and time differences are
-// the minimal differences which were encountered.
-// In this case the user may obtain the indices of the two stored reference signals
-// which had the minimal angular and minimal time difference via the output
-// arguments "ia" and "it" as follows :
-//
-// ia = Index of the stored reference signal with minimial angular difference
-// it = Index of the stored reference signal with minimial time difference
-//
-// In case these indices are the same, there obviously was 1 single reference signal
-// which showed both the minimal angular and time difference.
-//
-// The default values are mode=1, ia=0 and it=0;
-
- Double_t dang=999;
- dt=1.e20;
- if (ia) *ia=0;
- if (it) *it=0;
-
- if (!fRefs) return dang;
-
- Ali3Vector rx; // Position of the measurement
- Ali3Vector r0; // Position of the reference signal
-
- AliSignal* sx=GetSignal(rx,"icr","M",0);
- if (!sx) return dang;
-
- AliTimestamp* tx=sx->GetTimestamp();
- if (!tx) return dang;
-
- // Space and time difference w.r.t. a specific reference signal
- if (j>0)
- {
-  AliSignal* s0=GetSignal(r0,"icr","M",0,j);
-  if (!s0) return dang;
-  AliTimestamp* t0=s0->GetTimestamp();
-
-  if (!t0) return dang;
-
-  dang=r0.GetOpeningAngle(rx,au);
-  dt=t0->GetDifference(tx,tu,mode);
-  return dang;
- }
-
- // Minimal space and time difference encountered over all reference signals
- Double_t dangmin=dang;
- Double_t dtmin=dt;
- for (Int_t i=1; i<=fRefs->GetSize(); i++)
- {
-  AliSignal* s0=GetSignal(r0,"icr","M",0,i);
-  if (!s0) continue;
-  AliTimestamp* t0=s0->GetTimestamp();
-  if (!t0) continue;
-  dang=r0.GetOpeningAngle(rx,au);
-  dt=t0->GetDifference(tx,tu,mode);
-  if (fabs(dang)<dangmin)
-  {
-   dangmin=fabs(dang);
-   *ia=i;
-  }
-  if (fabs(dt)<dtmin)
-  {
-   dtmin=fabs(dt);
-   *it=i;
-  }
- }
-
- dt=dtmin;
- return dangmin;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliAstrolab::GetDifference(TString name,TString au,Double_t& dt,TString tu,Int_t mode)
-{
-// Provide space and time difference between the reference signal
-// with the specified name and the stored measurement.
-// 
-// The return value of this memberfunction provides the positional angular
-// difference, whereas the output argument "dt" provides the time difference.
-//
-// The units of the angular difference can be specified via the the "au"
-// input argument, where
-//
-// au = "rad" --> Angular difference in (fractional) radians
-//      "deg" --> Angular difference in (fractional) degrees
-//
-// The units of the time difference can be specified via the "tu" and "mode"
-// input arguments. For details please refer to AliTimestamp::GetDifference().
-// Also here mode=1 is the default value.
-//
-// For the time difference the reference signal is used as the standard.
-// This means that in case of a positive time difference, the stored
-// measurement occurred later than the reference signal.
-
- Double_t dang=999;
- dt=1.e20;
-
- Int_t j=GetSignalIndex(name);
- if (j>0) dang=GetDifference(j,au,dt,tu,mode);
- return dang;
-}
-///////////////////////////////////////////////////////////////////////////
-TArrayI* AliAstrolab::MatchRefSignal(Double_t da,TString au,Double_t dt,TString tu,Int_t mode)
-{
-// Provide the storage indices of the reference signals which match in space
-// and time with the stored measurement.
-// The indices are returned via a pointer to a TArrayI object.
-// In case no matches were found, the null pointer is returned.
-// A reference signal is regarded as matching with the stored measurement
-// if the positional angular difference doesn't exceed "da" and the absolute
-// value of the time difference doesn't exceed "dt".
-//
-// The units of the angular difference "da" can be specified via the the "au"
-// input argument, where
-//
-// au = "rad" --> Angular difference in (fractional) radians
-//      "deg" --> Angular difference in (fractional) degrees
-//
-// The units of the time difference "dt" can be specified via the "tu" and "mode"
-// input arguments. For details please refer to AliTimestamp::GetDifference().
-// Also here mode=1 is the default value.
-
- if (!fXsig || !fRefs) return 0;
-
- Int_t nrefs=fRefs->GetEntries();
-
- if (fIndices) delete fIndices;
- fIndices=new TArrayI(nrefs);
-
- Double_t dang,dtime;
- Int_t jfill=0; 
- for (Int_t i=1; i<=fRefs->GetSize(); i++)
- {
-  dang=GetDifference(i,au,dtime,tu,mode);
-  if (fabs(dang)<=da && fabs(dtime)<=dt)
-  {
-   fIndices->AddAt(i,jfill);
-   jfill++;
-  }
- }
-
- fIndices->Set(jfill);
- return fIndices;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::DisplaySignal(TString frame,TString mode,AliTimestamp* ts,Int_t jref,TString proj,Int_t clr)
-{
-// Display a stored signal in a user specified coordinate projection
-// at the specific timestamp ts.
-//
-// In case no stored signal was available or one of the input arguments was
-// invalid, no display is produced.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the coordinates refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
-//
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b).
-//
-//          "hor" ==> Horizontal azimuth and altitude coordinates at the AliAstrolab location.
-//
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
-//
-//          "loc" ==> Local spherical angles theta and phi at the AliAstrolab location.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "jref" allows display of a so-called "reference" signal.
-// These reference signals may serve to check space-time event coincidences with the
-// stored measurement (e.g. coincidence of the measurement with transient phenomena).
-//
-// jref = 0 --> Display of the measurement
-//        j --> Display of the j-th reference signal
-//
-// Default value is jref=0.
-//
-// The input parameter "proj" allows the user to specify the desired projection.
-// The available projection modes are :
-//
-// cyl  : Cylindrical projection plotted with colored markers
-// cylh : Cylindrical projection plotted in a 2-D histogram
-// ham  : Hammer equal area projection plotted with colored markers
-// hamh : Hammer equal area projection plotted in a 2-D histogram
-// ait  : Aitoff projection plotted with colored markers
-// aith : Aitoff projection plotted in a 2-D histogram
-// mer  : Mercator projection plotted with colored markers
-// merh : Mercator projection plotted in a 2-D histogram
-// ang  : Straight cos(b) vs. l plot with colored markers
-// angh : Straight cos(b) vs. l plot in a 2-D histogram
-//
-// Note : The ang(h) plot allows for easy identification of a homogeneous distribution.
-//
-// The input argument "clr" allows to clear (1) the display before drawing or not (0).
-//
-// The default values are : jref=0, proj="ham" and clr=0.
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Ali3Vector r;
- AliSignal* sx=GetSignal(r,frame,mode,ts,jref);
-
- if (!sx) return;
-
- // The generic input angles (in rad) for the projections 
- Double_t theta=0;
- Double_t phi=0;
-
- Double_t pi=acos(-1.);
-
- if (frame=="equ" || frame=="gal" || frame=="icr" || frame=="ecl" || frame=="loc")
- {
-  theta=(pi/2.)-r.GetX(2,"sph","rad");
-  phi=r.GetX(3,"sph","rad");
- }
-
- if (frame=="hor")
- {
-  theta=(pi/2.)-r.GetX(2,"sph","rad");
-  phi=pi-r.GetX(3,"sph","rad");
- }
-
- // Automatic choice of central meridian if not selected by the user
- if (fMeridian<-pi)
- {
-  if (frame=="gal")
-  {
-   fMeridian=0;
-  }
-  else
-  {
-   fMeridian=pi;
-  }
- }
-
- // Obtain the projected (x,y) position
- Double_t x=0;
- Double_t y=0;
- Project(phi,theta,proj,x,y);
-
- Int_t hist=0;
- if (proj=="hamh" || proj=="aith" || proj=="merh" || proj=="cylh" || proj=="angh") hist=1;
-
- // Update the display for this signal position
-
- // Create a new canvas if needed
- if (!fCanvas) fCanvas=new TCanvas("AliAstrolab","Skymap");
-
- // Construct the title string for this map
- TString title="Projection : ";
- title+=frame;
- title+=" ";
- title+=proj;
- title+="   Center : ";
- Int_t ang,h,m,s,d;
- if (frame=="equ" || frame=="icr")
- {
-  ang=int(ConvertAngle(fMeridian,"rad","hms"));
-  h=ang/10000;
-  ang=ang%10000;
-  m=ang/100;
-  s=ang%100;
-  title+=h;
-  title+="h ";
-  title+=m;
-  title+="m ";
-  title+=s;
-  title+="s";
- }
- else
- {
-  ang=int(ConvertAngle(fMeridian,"rad","dms"));
-  d=ang/10000;
-  ang=ang%10000;
-  m=ang/100;
-  s=ang%100;
-  title+=d;
-  title+="d ";
-  title+=m;
-  title+="' ";
-  title+=s;
-  title+="\"";
- }
-
- if (!hist) // 2-D Marker display (i.e. not a histogram) 
- {
-  // Remove existing markers, grid and outline from display if needed
-  if (clr==1 || proj!=fProj)
-  {
-   if (fMarkers)
-   {
-    delete fMarkers;
-    fMarkers=0;
-   }
-   fCanvas->Clear();
-   fProj=proj;
-  }
-
-  if (!fMarkers)
-  {
-   fMarkers=new TObjArray();
-   fMarkers->SetOwner();
-   // Set canvas range, header and axes
-   if (proj=="mer")
-   {
-    fCanvas->Range(-2.2,-6.,2.2,6.);
-    TText* header=new TText;
-    fMarkers->Add(header);
-    header->DrawText(-1.4,5.5,title.Data());
-    TLine* line=new TLine(-2,0,2,0);
-    fMarkers->Add(line);
-    line->Draw();
-    line=new TLine(0,5.5,0,-5.5);
-    fMarkers->Add(line);
-    line->Draw();
-   }
-   else
-   {
-    fCanvas->Range(-2.2,-1.2,2.2,1.2);
-    TText* header=new TText;
-    fMarkers->Add(header);
-    header->DrawText(-1.4,1.1,title.Data());
-    TLine* line=new TLine(-2,0,2,0);
-    fMarkers->Add(line);
-    line->Draw();
-    line=new TLine(0,1,0,-1);
-    fMarkers->Add(line);
-    line->Draw();
-   }
-   // Draw the outline 
-   if (proj=="ham" || proj=="ait")
-   {
-    // Draw ellips outline with axes
-    TEllipse* outline=new TEllipse(0,0,2,1);
-    fMarkers->Add(outline);
-    outline->Draw();
-   }
-  }
-  TMarker* marker=0;
-  if (!jref) // The measurement
-  {
-   marker=new TMarker(x,y,29);
-   marker->SetMarkerColor(kRed);
-  }
-  else // The reference signal(s)
-  {
-   marker=new TMarker(x,y,20);
-   marker->SetMarkerColor(kBlue);
-  }
-  marker->SetMarkerSize(1);
-  fMarkers->Add(marker);
-  marker->Draw();
- }
- else if (hist==1) // 2-D display via histogram
- {
-  // Reset the histogram if needed
-  if (clr==1 || proj!=fProj)
-  {
-   fCanvas->Clear();
-   if (!fHist) fHist=new TH2F();
-   fHist->Reset();
-   fHist->SetMarkerStyle(20);
-   fHist->SetMarkerSize(1);
-   fHist->SetMarkerColor(kBlue);
-   fHist->SetNameTitle("SkyMap",title.Data());
-   if (proj=="merh")
-   {
-    fHist->SetBins(100,-2.2,2.2,100,-5.5,5.5);
-   }
-   else
-   {
-    fHist->SetBins(100,-2.2,2.2,100,-1.1,1.1);
-   }
-   fProj=proj;
-  }
-  fHist->Fill(x,y);
-  fHist->Draw();
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::DisplaySignal(TString frame,TString mode,AliTimestamp* ts,TString name,TString proj,Int_t clr)
-{
-// Display the stored signal with the specified name in a user specified
-// coordinate projection at the specific timestamp ts.
-//
-// Note : In case ts=0 the current timestamp of the lab will be taken.
-//
-// In case no such stored signal was available or one of the input arguments was
-// invalid, no display is produced.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the coordinates refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
-//
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b).
-//
-//          "hor" ==> Horizontal azimuth and altitude coordinates at the AliAstrolab location.
-//
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
-//
-//          "loc" ==> Local spherical angles theta and phi at the AliAstrolab location.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "proj" allows the user to specify the desired projection.
-// The available projection modes are :
-//
-// cyl  : Cylindrical projection plotted with colored markers
-// cylh : Cylindrical projection plotted in a 2-D histogram
-// ham  : Hammer equal area projection plotted with colored markers
-// hamh : Hammer equal area projection plotted in a 2-D histogram
-// ait  : Aitoff projection plotted with colored markers
-// aith : Aitoff projection plotted in a 2-D histogram
-// mer  : Mercator projection plotted with colored markers
-// merh : Mercator projection plotted in a 2-D histogram
-// ang  : Straight cos(b) vs. l plot with colored markers
-// angh : Straight cos(b) vs. l plot in a 2-D histogram
-//
-// Note : The ang(h) plot allows for easy identification of a homogeneous distribution.
-//
-// The input argument "clr" allows to clear (1) the display before drawing or not (0).
-//
-// The default values are : proj="ham" and clr=0.
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Int_t j=GetSignalIndex(name);
- if (j>=0) DisplaySignal(frame,mode,ts,j,proj,clr);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::DisplaySignals(TString frame,TString mode,AliTimestamp* ts,TString proj,Int_t clr)
-{
-// Display of all stored signals in user specified coordinate projection
-// at the specific timestamp ts.
-// In case ts=0, the timestamp of the actual recording of the stored measurement
-// under investigation will be used.
-// In case no (timestamp of the) actual measurement is available,
-// the current timestamp of the lab will be taken.
-// In case no stored signal is available or one of the input arguments is
-// invalid, no display is produced.
-//
-// The input parameter "frame" allows the user to specify the frame to which
-// the coordinates refer. Available options are :
-//
-//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
-//
-//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
-//
-//          "ecl" ==> Ecliptic coordinates with longitude (l) and latitude (b).
-//
-//          "hor" ==> Horizontal azimuth and altitude coordinates at the AliAstrolab location.
-//
-//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
-//
-//          "loc" ==> Local spherical angles theta and phi at the AliAstrolab location.
-//
-// In case the coordinates are the equatorial right ascension and declination (a,d),
-// they can represent so-called "mean" and "true" values.
-// The distinction between these two representations is the following :
-//
-// mean values : (a,d) are only corrected for precession and not for nutation
-// true values : (a,d) are corrected for both precession and nutation
-//
-// The input parameter "mode" allows the user to specifiy either "mean" or "true"
-// values for the input in case of equatorial (a,d) coordinates.
-//
-// mode = "M" --> Input coordinates are the mean values 
-//        "T" --> Input coordinates are the true values 
-//
-// The input parameter "proj" allows the user to specify the desired projection.
-// The available projection modes are :
-//
-// cyl  : Cylindrical projection plotted with colored markers
-// cylh : Cylindrical projection plotted in a 2-D histogram
-// ham  : Hammer equal area projection plotted with colored markers
-// hamh : Hammer equal area projection plotted in a 2-D histogram
-// ait  : Aitoff projection plotted with colored markers
-// aith : Aitoff projection plotted in a 2-D histogram
-// mer  : Mercator projection plotted with colored markers
-// merh : Mercator projection plotted in a 2-D histogram
-// ang  : Straight cos(b) vs. l plot with colored markers
-// angh : Straight cos(b) vs. l plot in a 2-D histogram
-//
-// Note : The ang(h) plot allows for easy identification of a homogeneous distribution.
-//
-// The input argument "clr" allows to clear (1) the display before drawing or not (0).
-//
-// The default values are : proj="ham" and clr=0.
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- AliTimestamp* tx=ts;
- if (fXsig && !tx) tx=fXsig->GetTimestamp();
- if (!tx) tx=(AliTimestamp*)this;
-
- // Display all stored reference signals
- if (fRefs)
- {
-  for (Int_t i=1; i<=fRefs->GetSize(); i++)
-  {
-   DisplaySignal(frame,mode,tx,i,proj,clr);
-   clr=0; // No display clear for subsequent signals
-  }
- }
-
- // Display the measurement
- DisplaySignal(frame,mode,tx,0,proj,clr);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::SetCentralMeridian(Double_t phi,TString u)
-{
-// Set the central meridian for the sky display.
-// Setting a value smaller than -pi will induce automatic meridian setting
-// in the display.
-// By default the central meridian is set at -999 in the constructor.
-//
-// The string argument "u" allows to choose between different angular units
-// u = "rad" : angle provided in radians
-//     "deg" : angle provided in degrees
-//     "dms" : angle provided in dddmmss.sss
-//     "hms" : angle provided in hhmmss.sss
-//
-// The default is u="deg".
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- fMeridian=ConvertAngle(phi,u,"rad");
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::Project(Double_t l,Double_t b,TString proj,Double_t& x,Double_t& y)
-{
-// Generic interface for projection of a (long,lat) pair onto a (x,y) pair.
-//
-// Meaning of the arguments :
-// --------------------------
-// l    : Longitude (e.g. right ascension)
-// b    : Latitude (e.g. declination)
-// proj : Projection mode (e.g. "ham")
-// x    : The resulting x coordinate for the selected projection
-// y    : The resulting x coordinate for the selected projection
-//
-// The available projection modes are :
-//
-// cyl  : Cylindrical projection plotted with colored markers
-// cylh : Cylindrical projection plotted in a 2-D histogram
-// ham  : Hammer equal area projection plotted with colored markers
-// hamh : Hammer equal area projection plotted in a 2-D histogram
-// ait  : Aitoff projection plotted with colored markers
-// aith : Aitoff projection plotted in a 2-D histogram
-// mer  : Mercator projection plotted with colored markers
-// merh : Mercator projection plotted in a 2-D histogram
-// ang  : Straight cos(b) vs. l plot with colored markers
-// angh : Straight cos(b) vs. l plot in a 2-D histogram
-//
-// Note : The ang(h) plot allows for easy identification of a homogeneous distribution.
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Double_t pi=acos(-1.);
-
- // Subtract central meridian from longitude
- l-=fMeridian;
-
- // Take l between -180 and 180 degrees
- while (l>pi)
- {
-  l-=2*pi;
- }
- while (l<-pi)
- {
-  l+=2*pi;
- }
-
- x=0;
- y=0;
-
- // Convert (l,b) to (x,y) with -2 < x <= 2 
- if (proj=="cyl" || proj=="cylh") ProjectCylindrical(l,b,x,y);
- if (proj=="ham" || proj=="hamh") ProjectHammer(l,b,x,y);
- if (proj=="ait" || proj=="aith") ProjectAitoff(l,b,x,y);
- if (proj=="mer" || proj=="merh") ProjectMercator(l,b,x,y);
- if (proj=="ang" || proj=="angh")
- {
-  x=2*l/pi;
-  y=cos(b);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::ProjectCylindrical(Double_t l,Double_t b,Double_t& x, Double_t& y)
-{
-// Cylindrical projection of a (long,lat) coordinate pair 
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Double_t pi=acos(-1.);
- x=2*l/pi;
- y=2*b/pi;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::ProjectHammer(Double_t l,Double_t b,Double_t& x,Double_t& y)
-{
-// Hammer-Aitoff projection of a (long,lat) coordinate pair. 
-// This is an equal-area projection.
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Double_t k=1./sqrt(1.+cos(b)*cos(l/2.));
- x=2.*k*cos(b)*sin(l/2.);
- y=k*sin(b);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::ProjectAitoff(Double_t l,Double_t b,Double_t& x,Double_t& y)
-{
-// Aitoff projection of a (long,lat) coordinate pair. 
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Double_t pi=acos(-1.);
- x=0;
- y=0;
- Double_t k=acos(cos(b)*cos(l/2.));
- if(sin(k)!=0)
- {
-  x=4.*k*cos(b)*sin(l/2.)/(pi*sin(k));
-  y=2.*k*sin(b)/(pi*sin(k));
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAstrolab::ProjectMercator(Double_t l,Double_t b,Double_t& x,Double_t& y)
-{
-// Mercator projection of a (long,lat) coordinate pair 
-//
-// This routine is based on the work by Garmt de Vries-Uiterweerd.
-
- Double_t pi=acos(-1.);
- x=2.*l/pi;
- y=0;
- if (b >= 89.*pi/180.) b=89.*pi/180.;
- if (b <= -89.*pi/180.) y=-89.*pi/180.;
- if (fabs(y) < 1) y=log((1.+sin(b))/(1.-sin(b)))/2.;
-}
-///////////////////////////////////////////////////////////////////////////
-TObject* AliAstrolab::Clone(const char* name) const
-{
-// Make a deep copy of the current object and provide the pointer to the copy.
-// This memberfunction enables automatic creation of new objects of the
-// correct type depending on the object type, a feature which may be very useful
-// for containers when adding objects in case the container owns the objects.
-
- AliAstrolab* lab=new AliAstrolab(*this);
- if (name)
- {
-  if (strlen(name)) lab->SetName(name);
- }
- return lab;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliAstrolab.h b/RALICE/AliAstrolab.h
deleted file mode 100644 (file)
index 910e3a4..0000000
+++ /dev/null
@@ -1,116 +0,0 @@
-#ifndef ALIASTROLAB_H
-#define ALIASTROLAB_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include <math.h>
-
-#include "TTask.h"
-#include "TString.h"
-#include "TRotMatrix.h"
-#include "TObjArray.h"
-#include "TArrayI.h"
-#include "TCanvas.h"
-#include "TEllipse.h"
-#include "TLine.h"
-#include "TText.h"
-#include "TH2.h"
-#include "TMarker.h"
-
-#include "AliTimestamp.h"
-#include "AliPosition.h"
-#include "AliSignal.h"
-class AliAstrolab : public TTask,public AliTimestamp
-{
- public:
-  AliAstrolab(const char* name="AliAstrolab",const char* title="Generic lab"); // Constructor
-  virtual ~AliAstrolab();                                      // Destructor
-  AliAstrolab(const AliAstrolab& t);                           // Copy constructor
-  virtual TObject* Clone(const char* name="") const;           // Make a deep copy and provide its pointer
-  void Data(Int_t mode=1,TString u="deg");                     // Lab info in angular units u
-  void SetLabPosition(Ali3Vector& r);                          // Set lab position in terrestrial frame
-  void SetLabPosition(Double_t l,Double_t b,TString u="deg");  // Set lab terrestrial position
-  AliPosition GetLabPosition() const;                          // Provide the lab terrestrial position 
-  void GetLabPosition(Double_t& l,Double_t& b,TString u="deg") const;// Provide the lab terrestrial position
-  using AliTimestamp::GetLT;
-  Double_t GetLT();  // Provide Local Time (LT) in fractional hours
-  using AliTimestamp::GetLMST;
-  Double_t GetLMST(); // Provide Local Mean Sidereal Time (LMST) in fractional hours
-  using AliTimestamp::GetLAST;
-  Double_t GetLAST(); // Provide Local Apparent Sidereal Time (LAST) in fractional hours
-  using AliTimestamp::SetLT;
-  void SetLT(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns=0,Int_t ps=0); // Set specified LT
-  void SetLT(Int_t y,Int_t d,Int_t s,Int_t ns=0,Int_t ps=0); // Set LT based on elapsed days, secs etc...
-  Double_t ConvertAngle(Double_t a,TString in,TString out) const;       // Angular format conversions
-  void PrintAngle(Double_t a,TString in,TString out,Int_t ndig=1) const;// Print angle in various formats
-  void SetSignal(Ali3Vector* r,TString frame,TString mode,AliTimestamp* ts,Int_t jref=0,TString name=""); // Store a generic signal
-  void SetSignal(Double_t a,Double_t d,TString s,Double_t e,TString mode,Int_t jref=0,TString name="");   // Store RA, decl. and time
-  void SetSignal(Double_t a,Double_t d,TString mode,AliTimestamp* ts,Int_t jref=0,TString name="");       // Store RA, decl. and time
-  AliSignal* GetSignal(Ali3Vector& r,TString frame,TString mode,AliTimestamp* ts,Int_t jref=0);// Provide stored signal data
-  AliSignal* GetSignal(Ali3Vector& r,TString frame,TString mode,AliTimestamp* ts,TString name);// Provide stored signal data
-  AliSignal* GetSignal(Double_t& a,Double_t& d,TString mode,AliTimestamp* ts,Int_t jref=0);    // Provide corrected RA and decl.
-  AliSignal* GetSignal(Double_t& a,Double_t& d,TString mode,AliTimestamp* ts,TString name);    // Provide corrected RA and decl.
-  AliSignal* GetSignal(Double_t& a,Double_t& d,TString s,Double_t e,TString mode,Int_t jref=0);// Provide corrected RA and decl.
-  AliSignal* GetSignal(Double_t& a,Double_t& d,TString s,Double_t e,TString mode,TString name);// Provide corrected RA and decl.
-  AliSignal* GetSignal(Int_t jref=0);                // Provide pointer to a stored signal object
-  AliSignal* GetSignal(TString name);                // Provide pointer to a stored signal object
-  void RemoveRefSignal(Int_t j,Int_t compress);      // Remove a stored reference signal object
-  void RemoveRefSignal(TString name,Int_t compress); // Remove a stored reference signal object
-  void PrintSignal(TString frame,TString mode,AliTimestamp* ts,Int_t ndig,Int_t jref=0); // Print stored signal data
-  void PrintSignal(TString frame,TString mode,AliTimestamp* ts,Int_t ndig,TString name); // Print stored signal data
-  void ListSignals(TString frame,TString mode,Int_t ndig=1); // List all stored signals
-  Int_t GetSignalIndex(TString name); // Provide storage index of the signal with the specified name
-  Double_t GetHourAngle(TString mode,AliTimestamp* ts,Int_t jref=0);// Provide the Local Hour Angle in degrees
-  void SetLocalFrame(Double_t t1,Double_t p1,Double_t t2,Double_t p2,Double_t t3,Double_t p3); // Define local coordinate frame
-  using AliTimestamp::GetDifference;
-  Double_t GetDifference(Int_t jref,TString au,Double_t& dt,TString tu,Int_t mode=1,Int_t* ia=0,Int_t* it=0); // Provide space and time difference
-  Double_t GetDifference(TString name,TString au,Double_t& dt,TString tu,Int_t mode=1);// Provide space and time difference
-  TArrayI* MatchRefSignal(Double_t da,TString au,Double_t dt,TString tu,Int_t mode=1); // Provide space and time matching reference signals
-  void DisplaySignal(TString frame,TString mode,AliTimestamp* ts,Int_t jref=0,TString proj="ham",Int_t clr=0); // Display stored signal
-  void DisplaySignal(TString frame,TString mode,AliTimestamp* ts,TString name,TString proj="ham",Int_t clr=0); // Display stored signal
-  void DisplaySignals(TString frame,TString mode,AliTimestamp* ts,TString proj="ham",Int_t clr=0);             // Display all stored signals
-  void SetCentralMeridian(Double_t phi,TString u="deg"); // Set central meridian for the sky display
- protected:
-  AliPosition fLabPos;   // Position of the lab in the terrestrial longitude-latitude frame
-  Double_t fToffset;     // Lab time offset in fractional hours w.r.t. UT
-  AliSignal* fXsig;      // Signal entry for object or event studies
-  TObjArray* fRefs;      // Array holding the reference signals
-  TRotMatrix fB;         //! The frame bias matrix for conversion of ICRS to J2000 coordinates
-  Int_t fBias;           //! Initialisation flag for fB values (0=uninitialised  1=initialised)
-  TRotMatrix fP;         //! Matrix for precession correction  
-  TRotMatrix fN;         //! Matrix for nutation correction  
-  TRotMatrix fG;         //! Matrix for conversion of equatorial to galactic coordinates
-  Int_t fGal;            //! Type indicator for fG values (0=uninitialised  1=B1950  2=J2000)
-  TRotMatrix fE;         //! Matrix for conversion of equatorial to ecliptic coordinates
-  TRotMatrix fH;         //! Matrix for conversion of equatorial to horizontal coordinates
-  TRotMatrix fL;         //! Matrix for conversion of horizontal to local-frame coordinates
-  TArrayI* fIndices;     //! Storage indices of the matching reference signals
-  void SetBmatrix();                 // Set the frame bias matrix
-  void SetPmatrix(AliTimestamp* ts); // Set precession matrix for Julian date jd w.r.t. J2000.
-  void SetNmatrix(AliTimestamp* ts); // Set nutation matrix for Julian date jd w.r.t. J2000.
-  void SetGmatrix(TString mode);     // Set the equatorial to galactic conversion matrix
-  void SetEmatrix(AliTimestamp* ts); // Set the equatorial to ecliptic conversion matrix
-  void SetHmatrix(AliTimestamp* ts); // Set the equatorial to horizontal conversion matrix
-  void Precess(Ali3Vector& r,AliTimestamp* ts1,AliTimestamp* ts2); // Correct RA and decl. for earth's precession
-  void Nutate(Ali3Vector& r,AliTimestamp* ts); // Correct RA and decl. for earth's nutation
-
-  // The skymap display facilities of Garmt
-  Double_t fMeridian;  //! Central meridian (in rad) for the sky display
-  TString fProj;       //! Projection which is currently in use
-  TCanvas* fCanvas;    //! The canvas for the skymap
-  TH1* fHist;          //! Temp. histogram for the sky display
-  TObjArray* fMarkers; //! Temp. array to hold the markers for the signal display
-  void Project(Double_t l,Double_t b,TString proj,Double_t& x,Double_t& y);// Projection of (l,b) pair
-  void ProjectCylindrical(Double_t l,Double_t b,Double_t& x,Double_t& y);  // Cylindrical projection of (l,b) pair
-  void ProjectHammer(Double_t l,Double_t b,Double_t& x,Double_t& y);       // Hammer-Aitoff projection of (l,b) pair
-  void ProjectAitoff(Double_t l,Double_t b,Double_t& x,Double_t& y);       // Aitoff projection of (l,b) pair
-  void ProjectMercator(Double_t l,Double_t b,Double_t& x,Double_t& y);     // Mercator projection of (l,b) pair
- ClassDef(AliAstrolab,3) // Virtual lab to relate measurements with astrophysical phenomena
-};
-#endif
diff --git a/RALICE/AliAttrib.cxx b/RALICE/AliAttrib.cxx
deleted file mode 100644 (file)
index 1a8f9b0..0000000
+++ /dev/null
@@ -1,1788 +0,0 @@
-/**************************************************************************
- * 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 AliAttrib
-// Generic handling of detector signal (calibration) attributes.
-// Normally this class is only used as a base class to provide the various
-// attributes to the derived class. An example of this is AliSignal.
-// However, one can of course also use this class on its own as shown
-// in the simple example hereafter.
-//
-// Example :
-// ---------
-// AliAttrib a;
-// a.SetSlotName("PMT amplitude in Volt");
-// a.SetGain(250.7);
-// a.SetSlotName("Time of flight in ns",2);
-// a.SetOffset(-22.5,2);
-// a.SetSlotName("PMT amplitude in ADC",3);
-// a.SetGain(1340,3);
-// a.SetSlotName("TDC",4);
-// a.SetOffset(10.75,"TDC");
-// a.SetEdgeOn(3);
-// a.SetDead(1);
-// a.List();
-//
-//--- Author: Nick van Eijndhoven 18-sep-2003 Utrecht University
-//- Modified: NvE $Date$ Utrecht University
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliAttrib.h"
-#include "Riostream.h"
-ClassImp(AliAttrib) // Class implementation to enable ROOT I/O
-AliAttrib::AliAttrib()
-{
-// Creation of an AliAttrib object and initialisation of parameters.
-// Several values of the same type (e.g. gain) can be stored in different slots.
-// If needed, the storage for values will be expanded automatically
-// when entering values.
- fGains=0;
- fOffsets=0;
- fCalflags=0;
- fNames=0;
- fCalfuncs=0;
- fDecalfuncs=0;
-}
-///////////////////////////////////////////////////////////////////////////
-AliAttrib::~AliAttrib()
-{
-// Destructor to delete dynamically allocated memory
- if (fGains)
- {
-  delete fGains;
-  fGains=0;
- }
- if (fOffsets)
- {
-  delete fOffsets;
-  fOffsets=0;
- }
- if (fCalflags)
- {
-  delete fCalflags;
-  fCalflags=0;
- }
- if (fNames)
- {
-  delete fNames;
-  fNames=0;
- }
- if (fCalfuncs)
- {
-  delete fCalfuncs;
-  fCalfuncs=0;
- }
- if (fDecalfuncs)
- {
-  delete fDecalfuncs;
-  fDecalfuncs=0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-AliAttrib::AliAttrib(const AliAttrib& a)
-{
-// Copy constructor
- fGains=0;
- fOffsets=0;
- fCalflags=0;
- fNames=0;
- fCalfuncs=0;
- fDecalfuncs=0;
-
- Int_t n=0;
- Double_t val=0;
-
- n=a.GetNgains();
- for (Int_t ig=1; ig<=n; ig++)
- {
-  val=a.GetGain(ig);
-  if (a.GetGainFlag(ig)) SetGain(val,ig);
- }
-
- n=a.GetNoffsets();
- for (Int_t io=1; io<=n; io++)
- {
-  val=a.GetOffset(io);
-  if (a.GetOffsetFlag(io)) SetOffset(val,io);
- }
-
- n=a.GetNcalflags();
- for (Int_t ic=1; ic<=n; ic++)
- {
-  SetEdgeValue(a.GetEdgeValue(ic),ic);
-  if (a.GetLockValue(ic)) Lock(ic);
-  if (a.GetDeadValue(ic)) SetDead(ic);
- }
-
- n=a.GetNnames();
- TString s;
- for (Int_t in=1; in<=n; in++)
- {
-  s=a.GetSlotName(in);
-  if (s!="") SetSlotName(s,in);
- }
-
- n=a.GetNcalfuncs();
- for (Int_t icalf=1; icalf<=n; icalf++)
- {
-  TF1* f=a.GetCalFunction(icalf);
-  if (f) SetCalFunction(f,icalf);
- }
-
- n=a.GetNdecalfuncs();
- for (Int_t idecalf=1; idecalf<=n; idecalf++)
- {
-  TF1* f=a.GetDecalFunction(idecalf);
-  if (f) SetDecalFunction(f,idecalf);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNgains() const
-{
-// Provide the number of specified gains for this attribute.
-
- if (!fGains) return 0;
-
- Int_t n=0;
- for (Int_t i=1; i<=fGains->GetSize(); i++)
- {
-  if (GetGainFlag(i)) n=i;
- }
-
- return n;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNoffsets() const
-{
-// Provide the number of specified offsets for this attribute.
-
- if (!fOffsets) return 0;
-
- Int_t n=0;
- for (Int_t i=1; i<=fOffsets->GetSize(); i++)
- {
-  if (GetOffsetFlag(i)) n=i;
- }
-
- return n;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNcalflags() const
-{
-// Provide the number of specified calib. flags for this attribute.
-
- if (!fCalflags) return 0;
-
- Int_t n=0;
- for (Int_t i=1; i<=fCalflags->GetSize(); i++)
- {
-  if (fCalflags->At(i-1)) n=i;
- }
-
- return n;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNnames() const
-{
-// Provide the maximum number of specified names for this attribute.
-
- if (!fNames) return 0;
-
- Int_t n=0;
- for (Int_t i=1; i<=fNames->GetSize(); i++)
- {
-  if (fNames->At(i-1)) n=i;
- }
-
- return n;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetGain(Double_t gain,Int_t j)
-{
-// Store gain value of the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for gain values, the number of reserved slots for the gain
-// values is increased automatically.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetGain* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fGains)
- {
-  fGains=new TArrayF(j);
- }
-
- Int_t size=fGains->GetSize();
-
- if (j>size)
- {
-  fGains->Set(j);
- }
-
- fGains->AddAt(float(gain),j-1);
-
- Int_t oflag=GetOffsetFlag(j);
-
- SetCalFlags(1,oflag,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetGain(Double_t gain,TString name)
-{
-// Store gain value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetGain(gain,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetOffset(Double_t off,Int_t j)
-{
-// Store offset value of the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for offset values, the number of reserved slots for the offset
-// values is increased automatically.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fOffsets)
- {
-  fOffsets=new TArrayF(j);
- }
-
- Int_t size=fOffsets->GetSize();
-
- if (j>size)
- {
-  fOffsets->Set(j);
- }
-
- fOffsets->AddAt(float(off),j-1);
-
- Int_t gflag=GetGainFlag(j);
-
- SetCalFlags(gflag,1,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetOffset(Double_t off,TString name)
-{
-// Store offset value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetOffset(off,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetCalFlags(Int_t gainflag,Int_t offsetflag,Int_t j)
-{
-// Store calibration flags of the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the calib. flags, the number of reserved slots for the calib.
-// flags is increased automatically.
-// The value stored is : 10000*edge +1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetCalFlags* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags)
- {
-  fCalflags=new TArrayI(j);
- }
-
- Int_t size=fCalflags->GetSize();
-
- if (j>size)
- {
-  fCalflags->Set(j);
- }
-
- Int_t edge=GetEdgeValue(j);
- Int_t lock=GetLockValue(j);
- Int_t dead=GetDeadValue(j);
-
- Int_t word=10000*edge+1000*lock+100*dead+10*gainflag+offsetflag;
- fCalflags->AddAt(word,j-1);
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetGainFlag(Int_t j) const
-{
-// Provide gain flag of the j-th (default j=1) attribute slot.
-//
-// flag = 1 : Gain was set
-//        0 : Gain was not set
-//
-// Note : The first attribute slot is at j=1.
-// In case j is invalid, 0 is returned.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetGainFlag* Invalid argument j = " << j << endl;
-  return 0;
- }
- Int_t gflag=0;
- if (fCalflags)
- {
-  if (j>0 && j<=(fCalflags->GetSize()))
-  {
-   Int_t word=fCalflags->At(j-1);
-   word=word%100;
-   gflag=word/10;
-  }
- }
- return gflag;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetGainFlag(TString name) const
-{
-// Provide gain flag of the name-specified attribute slot.
-//
-// flag = 1 : Gain was set
-//        0 : Gain was not set
-//
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Int_t flag=0;
- if (j>0) flag=GetGainFlag(j);
- return flag;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetOffsetFlag(Int_t j) const
-{
-// Provide offset flag of the j-th (default j=1) attribute slot.
-//
-// flag = 1 : Offset was set
-//        0 : Offset was not set
-//
-// Note : The first attribute slot is at j=1.
-// In case j is invalid, 0 is returned.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetOffsetFlag* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Int_t oflag=0;
- if (fCalflags)
- {
-  if (j>0 && j<=(fCalflags->GetSize()))
-  {
-   Int_t word=fCalflags->At(j-1);
-   oflag=word%10;
-  }
- }
- return oflag;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetOffsetFlag(TString name) const
-{
-// Provide ofset flag of the name-specified attribute slot.
-//
-// flag = 1 : Offset was set
-//        0 : Offset was not set
-//
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Int_t flag=0;
- if (j>0) flag=GetOffsetFlag(j);
- return flag;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetCalWord(Int_t j) const
-{
-// Provide calib. word of the j-th (default j=1) attribute slot.
-// The word value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-//
-// Note : The first attribute slot is at j=1.
-// In case j is invalid, 0 is returned.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetCalWord* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Int_t word=0;
- if (fCalflags)
- {
-  if (j>0 && j<=(fCalflags->GetSize())) word=fCalflags->At(j-1);
- }
- return word;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetCalWord(TString name) const
-{
-// Provide calib. word of the name-specified attribute slot.
-// The word value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Int_t word=0;
- if (j>0) word=GetCalWord(j);
- return word;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliAttrib::GetGain(Int_t j) const
-{
-// Provide gain value of the j-th (default j=1) attribute slot.
-// The first attribute slot is at j=1.
-// In case no gain value was set or the argument j is invalid, 0 is returned.
-// Note : Use GetGainFlag(j) to check whether this gain was set or not.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetGain* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Float_t gain=0;
- if (fGains)
- {
-  if (j>0 && j<=(fGains->GetSize()))
-  {
-   if (GetGainFlag(j)) gain=fGains->At(j-1);
-  }
- }
- return gain;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliAttrib::GetGain(TString name) const
-{
-// Provide gain value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Float_t gain=0;
- if (j>0) gain=GetGain(j);
- return gain;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliAttrib::GetOffset(Int_t j) const
-{
-// Provide offset value of the j-th (default j=1) attribute slot.
-// The first attribute slot at j=1.
-// In case no offset value was set or the argument j is invalid, 0 is returned.
-// Note : Use GetOffsetFlag(j) to check whether this offset was set or not.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetOffset* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Float_t offset=0;
- if (fOffsets)
- {
-  if (j>0 && j<=(fOffsets->GetSize()))
-  {
-   if (GetOffsetFlag(j)) offset=fOffsets->At(j-1);
-  }
- }
- return offset;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliAttrib::GetOffset(TString name) const
-{
-// Provide offset value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Float_t offset=0;
- if (j>0) offset=GetOffset(j);
- return offset;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::ResetGain(Int_t j)
-{
-// Reset the gain value of the j-th (default j=1) attribute slot.
-// Notes : The first attribute slot is at j=1.
-//         j=0 ==> All gain values will be reset.
- if (!fGains) return;
-
- Int_t size=fGains->GetSize();
-
- if ((j>=0) && (j<=size))
- {
-  if (j)
-  {
-   fGains->AddAt(0,j-1);
-   Int_t oflag=GetOffsetFlag(j);
-   SetCalFlags(0,oflag,j);
-  }
-  else
-  {
-   for (Int_t i=0; i<size; i++)
-   {
-    fGains->AddAt(0,i);
-    Int_t oflag=GetOffsetFlag(i);
-    SetCalFlags(0,oflag,i);
-   }
-  }
- }
- else
- {
-  cout << " *AliAttrib::ResetGain* Index j = " << j << " invalid." << endl;
-  return;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::ResetGain(TString name)
-{
-// Reset the gain value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) ResetGain(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::ResetOffset(Int_t j)
-{
-// Reset the offset value of the j-th (default j=1) attribute slot.
-// Notes : The first attribute slot is at j=1.
-//         j=0 ==> All offset values will be reset.
- if (!fOffsets) return;
-
- Int_t size=fOffsets->GetSize();
-
- if ((j>=0) && (j<=size))
- {
-  if (j)
-  {
-   fOffsets->AddAt(0,j-1);
-   Int_t gflag=GetGainFlag(j);
-   SetCalFlags(gflag,0,j);
-  }
-  else
-  {
-   for (Int_t i=0; i<size; i++)
-   {
-    fOffsets->AddAt(0,i);
-    Int_t gflag=GetGainFlag(i);
-    SetCalFlags(gflag,0,i);
-   }
-  }
- }
- else
- {
-  cout << " *AliAttrib::ResetOffset* Index j = " << j << " invalid." << endl;
-  return;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::ResetOffset(TString name)
-{
-// Reset the offset value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) ResetOffset(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::DeleteCalibrations(Int_t mode)
-{
-// User selected delete of all gains and/or offsets.
-// mode = 0 : All attributes (names,gains,offsets,(de)calfuncs, edge and dead values) are deleted.
-//        1 : Only the gains are deleted.
-//        2 : Only the offsets are deleted.
-//        3 : Gains, offsets and (de)calfuncs are deleted, but names, edge and dead values are kept.
-//        4 : Only the calib. functions are deleted.
-//        5 : Only the de-calib. functions are deleted.
-//        6 : Only the calib. and de-calib. functions are deleted.
-//
-// The default when invoking DeleteCalibrations() corresponds to mode=0.
-
- if (mode<0 || mode>6)
- {
-  cout << " *AliAttrib::DeleteCalibrations* Unknown mode : " << mode << endl;
-  cout << " Default mode=0 will be used." << endl;
-  mode=0;
- }
-
- if (mode==0 || mode==3)
- {
-  ResetGain(0);
-  if (fGains)
-  {
-   delete fGains;
-   fGains=0;
-  }
-  ResetOffset(0);
-  if (fOffsets)
-  {
-   delete fOffsets;
-   fOffsets=0;
-  }
-  if (fCalflags && mode==0)
-  {
-   delete fCalflags;
-   fCalflags=0;
-  }
-  if (fNames && mode==0)
-  {
-   delete fNames;
-   fNames=0;
-  }
-  if (fCalfuncs)
-  {
-   delete fCalfuncs;
-   fCalfuncs=0;
-  }
-  if (fDecalfuncs)
-  {
-   delete fDecalfuncs;
-   fDecalfuncs=0;
-  }
-  return;
- }
-
- if (mode==1)
- {
-  ResetGain(0);
-  if (fGains)
-  {
-   delete fGains;
-   fGains=0;
-  }
- }
-
- if (mode==2)
- {
-  ResetOffset(0);
-  if (fOffsets)
-  {
-   delete fOffsets;
-   fOffsets=0;
-  }
- }
-
- if (mode==4 || mode==6)
- {
-  if (fCalfuncs)
-  {
-   delete fCalfuncs;
-   fCalfuncs=0;
-  }
- }
-
- if (mode==5 || mode==6)
- {
-  if (fDecalfuncs)
-  {
-   delete fDecalfuncs;
-   fDecalfuncs=0;
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetDead(Int_t j)
-{
-// Set the dead flag to 1 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, the number of reserved slots for the flags
-// is increased automatically.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetDead* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags)
- {
-  fCalflags=new TArrayI(j);
- }
-
- Int_t size=fCalflags->GetSize();
-
- if (j>size)
- {
-  fCalflags->Set(j);
- }
-
- Int_t dead=1;
- Int_t oflag=GetOffsetFlag(j);
- Int_t gflag=GetGainFlag(j);
- Int_t lock=GetLockValue(j);
- Int_t edge=GetEdgeValue(j);
-
- Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
- fCalflags->AddAt(word,j-1);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetDead(TString name)
-{
-// Set the dead flag to 1 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetDead(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetAlive(Int_t j)
-{
-// Set the dead flag to 0 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, no action is taken since by default the dead flag is 0.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetAlive* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags || j>fCalflags->GetSize()) return;
-
- Int_t dead=0;
- Int_t oflag=GetOffsetFlag(j);
- Int_t gflag=GetGainFlag(j);
- Int_t lock=GetLockValue(j);
- Int_t edge=GetEdgeValue(j);
-
- Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
- fCalflags->AddAt(word,j-1);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetAlive(TString name)
-{
-// Set the dead flag to 0 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetAlive(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::Lock(Int_t j)
-{
-// Set the lock flag to 1 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, the number of reserved slots for the flags
-// is increased automatically.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::Lock* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags)
- {
-  fCalflags=new TArrayI(j);
- }
-
- Int_t size=fCalflags->GetSize();
-
- if (j>size)
- {
-  fCalflags->Set(j);
- }
-
- Int_t lock=1;
- Int_t dead=GetDeadValue(j);
- Int_t oflag=GetOffsetFlag(j);
- Int_t gflag=GetGainFlag(j);
- Int_t edge=GetEdgeValue(j);
-
- Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
- fCalflags->AddAt(word,j-1);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::Lock(TString name)
-{
-// Set the lock flag to 1 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) Lock(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::Unlock(Int_t j)
-{
-// Set the lock flag to 0 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, no action is taken since by default the dead flag is 0.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::Unlock* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags || j>fCalflags->GetSize()) return;
-
- Int_t lock=0;
- Int_t dead=GetDeadValue();
- Int_t oflag=GetOffsetFlag(j);
- Int_t gflag=GetGainFlag(j);
- Int_t edge=GetEdgeValue(j);
-
- Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
- fCalflags->AddAt(word,j-1);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::Unlock(TString name)
-{
-// Set the lock flag to 0 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) Unlock(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetEdgeOn(Int_t j)
-{
-// Set the edge value to 1 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, the number of reserved slots for the flags
-// is increased automatically.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetEdgeOn* Invalid argument j = " << j << endl;
-  return;
- }
-
- SetEdgeValue(1,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetEdgeOn(TString name)
-{
-// Set the edge value to 1 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetEdgeOn(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetEdgeOff(Int_t j)
-{
-// Set the edge value to 0 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, no action is taken since by default the edge flag is 0.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetEdgeOff* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags || j>fCalflags->GetSize()) return;
-
- SetEdgeValue(0,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetEdgeOff(TString name)
-{
-// Set the edge value to 0 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetEdgeOff(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetEdgeValue(Int_t val,Int_t j)
-{
-// Set the edge value to "val" for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, the number of reserved slots for the flags
-// is increased automatically.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetEdgeValue* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fCalflags)
- {
-  fCalflags=new TArrayI(j);
- }
-
- Int_t size=fCalflags->GetSize();
-
- if (j>size)
- {
-  fCalflags->Set(j);
- }
-
- Int_t edge=val;
- Int_t lock=GetLockValue(j);
- Int_t dead=GetDeadValue(j);
- Int_t gflag=GetGainFlag(j);
- Int_t oflag=GetOffsetFlag(j);
-
- Int_t word=10000*edge+1000*lock+100*dead+10*gflag+oflag;
- fCalflags->AddAt(word,j-1);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetEdgeValue(Int_t val,TString name)
-{
-// Set the edge value to "val" for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetEdgeValue(val,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::IncreaseEdgeValue(Int_t j)
-{
-// Increase the edge value by 1 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, the number of reserved slots for the flags
-// is increased automatically.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::IncreaseEdgeValue* Invalid argument j = " << j << endl;
-  return;
- }
-
- Int_t edge=GetEdgeValue();
- SetEdgeValue(edge+1,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::IncreaseEdgeValue(TString name)
-{
-// Increase the edge value by 1 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) IncreaseEdgeValue(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::DecreaseEdgeValue(Int_t j)
-{
-// Decrease the edge value by 1 for the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the flags, the number of reserved slots for the flags
-// is increased automatically.
-// The value stored is : 10000*edge + 1000*lock + 100*dead + 10*gainflag + offsetflag.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::DecreaseEdgeValue* Invalid argument j = " << j << endl;
-  return;
- }
-
- Int_t edge=GetEdgeValue();
- SetEdgeValue(edge-1,j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::DecreaseEdgeValue(TString name)
-{
-// Decrease the edge value by 1 for the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) DecreaseEdgeValue(j);
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetEdgeValue(Int_t j) const
-{
-// Provide edge value of the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case j is invalid, 0 is returned.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetEdgeValue* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Int_t edge=0;
- if (fCalflags)
- {
-  if (j>0 && j<=(fCalflags->GetSize()))
-  {
-   Int_t word=fCalflags->At(j-1);
-   edge=word/10000;
-  }
- }
- return edge;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetEdgeValue(TString name) const
-{
-// Provide edge value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Int_t val=0;
- if (j>0) val=GetEdgeValue(j);
- return val;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetDeadValue(Int_t j) const
-{
-// Provide dead value of the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case j is invalid, 0 is returned.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetDeadValue* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Int_t dead=0;
- if (fCalflags)
- {
-  if (j>0 && j<=(fCalflags->GetSize()))
-  {
-   Int_t word=fCalflags->At(j-1);
-   word=word%1000;
-   dead=word/100;
-  }
- }
- return dead;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetDeadValue(TString name) const
-{
-// Provide dead value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Int_t val=0;
- if (j>0) val=GetDeadValue(j);
- return val;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetLockValue(Int_t j) const
-{
-// Provide lock value of the j-th (default j=1) attribute slot.
-// Note : The first attribute slot is at j=1.
-// In case j is invalid, 0 is returned.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::GetLockValue* Invalid argument j = " << j << endl;
-  return 0;
- }
-
- Int_t lock=0;
- if (fCalflags)
- {
-  if (j>0 && j<=(fCalflags->GetSize()))
-  {
-   Int_t word=fCalflags->At(j-1);
-   word=word%10000;
-   lock=word/1000;
-  }
- }
- return lock;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetLockValue(TString name) const
-{
-// Provide lock value of the name-specified attribute slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- Int_t val=0;
- if (j>0) val=GetLockValue(j);
- return val;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNslots() const
-{
-// Provide the number of existing slots.
-
-  Int_t n=GetNcalflags();
-  Int_t nn=GetNnames();
-  Int_t ncalf=GetNcalfuncs();
-  Int_t ndecalf=GetNdecalfuncs();
-  if (n<nn) n=nn;
-  if (n<ncalf) n=ncalf;
-  if (n<ndecalf) n=ndecalf;
-
-  return n;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::AddNamedSlot(TString s)
-{
-// Add a new slot with the specified name.
-// In case a slot with the specified name already exists, no action is taken.
-
- if (GetSlotIndex(s)) return;
-
- Int_t n=GetNslots();
- SetSlotName(s,n+1);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetSlotName(TString s,Int_t j)
-{
-// Set a user defined name for the j-th (default j=1) slot. 
-// Note : The first attribute slot is at j=1.
-// In case the value of the index j exceeds the maximum number of reserved
-// slots for the names, the number of reserved slots for the names
-// is increased automatically to the corresponding value.
-
- if (j<1) 
- {
-  cout << " *AliAttrib::SetSlotName* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (!fNames)
- {
-  fNames=new TObjArray(j);
-  fNames->SetOwner();
- }
-
- if (j>fNames->GetSize()) fNames->Expand(j);
-
- TObjString* so=(TObjString*)fNames->At(j-1);
- if (!so)
- {
-  so=new TObjString(s.Data());
-  fNames->AddAt(so,j-1);
- }
- else
- {
-  so->SetString(s);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-TString AliAttrib::GetSlotName(Int_t j) const
-{
-// Provide the user defined name for the j-th (default j=1) slot. 
-// Note : The first attribute slot is at j=1.
-
- TString s="";
- if (j<1) 
- {
-  cout << " *AliAttrib::GetSlotName* Invalid argument j = " << j << endl;
-  return s;
- }
-
- if (fNames)
- {
-  if (j<=fNames->GetSize())
-  {
-   TObjString* so=(TObjString*)fNames->At(j-1);
-   if (so) s=so->GetString();
-  }
- }
- return s;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetSlotIndex(TString name) const
-{
-// Provide the slot index for the matching name.
-// If no matching name is found, 0 is returned.
-// Note : The first attribute slot is at j=1.
-
- Int_t index=0;
-
- if (fNames)
- {
-  TString s;
-  Int_t size=fNames->GetSize();
-  for (Int_t i=0; i<size; i++)
-  {
-   TObjString* so=(TObjString*)fNames->At(i);
-   if (so) s=so->GetString();
-   if (s==name)
-   {
-    index=i+1;
-    break;
-   }
-  }
- }
- return index;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::List(Int_t j) const
-{
-// Provide attribute information for the j-th slot.
-// The first slot is at j=1.
-// In case j=0 (default) the data of all slots will be listed.
-
- if (j<0) 
- {
-  cout << " *AliAttrib::Data* Invalid argument j = " << j << endl;
-  return;
- }
-
- if (j>0)
- {
-  if (GetGainFlag(j)) cout << " gain : " << GetGain(j);
-  if (GetOffsetFlag(j)) cout << " offset : " << GetOffset(j);
-  if (GetEdgeValue(j)) cout << " edge : " << GetEdgeValue(j);
-  if (GetDeadValue(j)) cout << " dead : " << GetDeadValue(j);
-  if (GetLockValue(j)) cout << " lock : " << GetLockValue(j);
-  if (GetCalFunction(j)) cout << " *Fcalib*";
-  if (GetDecalFunction(j)) cout << " *Fdecalib*";
-  TString s=GetSlotName(j);
-  if (s!="") cout << " name : " << s.Data();
- }
- else
- {
-  Int_t ng=GetNgains();
-  Int_t no=GetNoffsets();
-  Int_t nf=0;
-  if (fCalflags) nf=fCalflags->GetSize();
-  Int_t nn=GetNnames();
-  Int_t n=ng;
-  if (n<no) n=no;
-  if (n<nn) n=nn;
-  if (n<nf) n=nf;
-  Int_t printf=0;
-  TString s;
-  for (Int_t i=1; i<=n; i++)
-  {
-   printf=0;
-   if (GetGainFlag(i))      {cout << " gain : " << GetGain(i); printf=1;}
-   if (GetOffsetFlag(i))    {cout << " offset : " << GetOffset(i); printf=1;}
-   if (GetEdgeValue(i))     {cout << " edge : " << GetEdgeValue(i); printf=1;}
-   if (GetDeadValue(i))     {cout << " dead : " << GetDeadValue(i); printf=1;}
-   if (GetLockValue(i))     {cout << " lock : " << GetLockValue(i); printf=1;}
-   if (GetCalFunction(i))   {cout << " *Fcalib*"; printf=1;}
-   if (GetDecalFunction(i)) {cout << " *Fdecalib*"; printf=1;}
-   s=GetSlotName(i);
-   if (s!="") {cout << " name : " << s.Data(); printf=1;}
-   if (printf) cout << endl;
-  }
- }
-} 
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::List(TString name) const
-{
-// Provide attribute information for the name-specified slot.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) List(j);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::Load(AliAttrib& a,Int_t j)
-{
-// Load attributes of the j-th slot of the input AliAttrib into this AliAttrib object.
-// 
-// Note : if j=0, then all attributes of all slots are loaded
-//
-// The default is j=0.
-
- if (j<0) 
- {
-  cout << " *AliAttrib::Load* Invalid argument j = " << j << endl;
-  return;
- }
-
- Int_t n=0;
-
- if (j==0) // load attributes for all slots
- {
-  n=a.GetNgains();
-  for (Int_t ig=1; ig<=n; ig++)
-  {
-   if (a.GetGainFlag(ig))
-   {
-    SetGain(a.GetGain(ig),ig);
-   }
-   else
-   {
-    ResetGain(ig);
-   }
-  }
-  n=a.GetNoffsets();
-  for (Int_t io=1; io<=n; io++)
-  {
-   if (a.GetOffsetFlag(io))
-   {
-    SetOffset(a.GetOffset(io),io);
-   }
-   else
-   {
-    ResetOffset(io);
-   }
-  }
-  n=a.GetNcalflags();
-  for (Int_t ic=1; ic<=n; ic++)
-  {
-   SetEdgeValue(a.GetEdgeValue(ic),ic);
-   if (a.GetLockValue(ic))
-   {
-    Lock(ic);
-   }
-   else
-   {
-    Unlock(ic);
-   }
-   if (a.GetDeadValue(ic))
-   {
-    SetDead(ic);
-   }
-   else
-   {
-    SetAlive(ic);
-   }
-  }
-  n=a.GetNnames();
-  TString s;
-  for (Int_t in=1; in<=n; in++)
-  {
-   s=a.GetSlotName(in);
-   SetSlotName(s,in);
-  }
-  n=a.GetNcalfuncs();
-  for (Int_t icalf=1; icalf<=n; icalf++)
-  {
-   TF1* f=a.GetCalFunction(icalf);
-   SetCalFunction(f,icalf);
-  }
-  n=a.GetNdecalfuncs();
-  for (Int_t idecalf=1; idecalf<=n; idecalf++)
-  {
-   TF1* f=a.GetDecalFunction(idecalf);
-   SetDecalFunction(f,idecalf);
-  }
- }
- else // load attributes for specified j-th slot only
- {
-  n=a.GetNgains();
-  if (j<=n)
-  {
-   if (a.GetGainFlag(j))
-   {
-    SetGain(a.GetGain(j),j);
-   }
-   else
-   {
-    ResetGain(j);
-   }
-  }
-  n=a.GetNoffsets();
-  if (j<=n)
-  {
-   if (a.GetOffsetFlag(j))
-   {
-    SetOffset(a.GetOffset(j),j);
-   }
-   else
-   {
-    ResetOffset(j);
-   } 
-  }
-  n=a.GetNcalflags();
-  if (j<=n)
-  {
-   SetEdgeValue(a.GetEdgeValue(j),j);
-   if (a.GetLockValue(j))
-   {
-    Lock(j);
-   }
-   else
-   {
-    Unlock(j);
-   }
-   if (a.GetDeadValue(j))
-   {
-    SetDead(j);
-   }
-   else
-   {
-    SetAlive(j);
-   }
-  }
-  n=a.GetNnames();
-  TString s;
-  if (j<=n)
-  {
-   s=a.GetSlotName(j);
-   SetSlotName(s,j);
-  }
-  n=a.GetNcalfuncs();
-  if (j<=n)
-  {
-   TF1* f=a.GetCalFunction(j);
-   SetCalFunction(f,j);
-  }
-  n=a.GetNdecalfuncs();
-  if (j<=n)
-  {
-   TF1* f=a.GetDecalFunction(j);
-   SetDecalFunction(f,j);
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::Load(AliAttrib& a,TString name)
-{
-// Load attributes of the name-specified slot of the input AliAttrib into
-// this AliAttrib object.
-//
-// This procedure involves a slot-index search based on the specified name
-// at each invokation. This may become slow in case many slots have been
-// defined and/or when this procedure is invoked many times.
-// In such cases it is preferable to use indexed addressing in the user code
-// either directly or via a few invokations of GetSlotIndex().
-
- Int_t j=GetSlotIndex(name);
- if (j>0) Load(a,j);
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNcalfuncs() const
-{
-// Provide the number of specified calib. functions for this attribute.
-
- if (!fCalfuncs) return 0;
-
- Int_t n=0;
- for (Int_t i=1; i<=fCalfuncs->GetSize(); i++)
- {
-  if (fCalfuncs->At(i-1)) n=i;
- }
- return n;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliAttrib::GetNdecalfuncs() const
-{
-// Provide the number of specified de-calib. functions for this attribute.
-
- if (!fDecalfuncs) return 0;
-
- Int_t n=0;
- for (Int_t i=1; i<=fDecalfuncs->GetSize(); i++)
- {
-  if (fDecalfuncs->At(i-1)) n=i;
- }
- return n;
-}
-///////////////////////////////////////////////////////////////////////////
-TF1* AliAttrib::GetCalFunction(Int_t j) const
-{
-// Provide pointer to the calib. function of the j-th (default j=1) slot.
-// Note : The first attribute slot is at j=1.
-
- TF1* f=0;
- if (j>0 && j<=GetNcalfuncs()) f=(TF1*)fCalfuncs->At(j-1);
- return f;
-}
-///////////////////////////////////////////////////////////////////////////
-TF1* AliAttrib::GetCalFunction(TString name) const
-{
-// Provide pointer to the calib. function of the name-specified slot.
-// In case no match is found, zero is returned.
-
- TF1* f=0;
- Int_t j=GetSlotIndex(name);
- if (j>0) f=GetCalFunction(j);
- return f;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetCalFunction(TF1* f,Int_t j)
-{
-// Set the calib. function of the j-th (default j=1) slot.
-// Note : The first attribute slot is at j=1.
-//
-// In case the value of the index j exceeds the maximum number of reserved
-// positions for the functions, the number of reserved positions for the functions
-// is increased automatically.
-//
-// In case the function pointer argument has the same value as the current function
-// pointer value, no action is taken since the user has already modified the actual
-// function.
-//
-// In case the function pointer argument is zero, the current function
-// is deleted and the pointer set to zero.
-//
-// In all other cases the current function is deleted and a new
-// copy of the input function is created which becomes the current function.
-
- if (j<1) return;
-
- if (!fCalfuncs)
- {
-  fCalfuncs=new TObjArray(j);
-  fCalfuncs->SetOwner();
- }
-
- if (j > fCalfuncs->GetSize()) fCalfuncs->Expand(j);
-
- TF1* fcur=(TF1*)fCalfuncs->At(j-1);
- if (f != fcur)
- {
-  if (fcur)
-  {
-   fCalfuncs->Remove(fcur);
-   delete fcur;
-   fcur=0;
-  }
-  if (f)
-  {
-   fcur=new TF1(*f);
-   fCalfuncs->AddAt(fcur,j-1);
-  }
- } 
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetCalFunction(TF1* f,TString name)
-{
-// Set the calib. function of the name-specified slot.
-//
-// In case the function pointer argument has the same value as the current function
-// pointer value, no action is taken since the user has already modified the actual
-// function.
-//
-// In case the function pointer argument is zero, the current function
-// is deleted and the pointer set to zero.
-//
-// In all other cases the current function is deleted and a new
-// copy of the input function is created which becomes the current function.
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetCalFunction(f,j);
-}
-///////////////////////////////////////////////////////////////////////////
-TF1* AliAttrib::GetDecalFunction(Int_t j) const
-{
-// Provide pointer to the de-calib. function of the j-th (default j=1) slot.
-// Note : The first attribute slot is at j=1.
-
- TF1* f=0;
- if (j>0 && j<=GetNdecalfuncs()) f=(TF1*)fDecalfuncs->At(j-1);
- return f;
-}
-///////////////////////////////////////////////////////////////////////////
-TF1* AliAttrib::GetDecalFunction(TString name) const
-{
-// Provide pointer to the de-calib. function of the name-specified slot.
-// In case no match is found, zero is returned.
-
- TF1* f=0;
- Int_t j=GetSlotIndex(name);
- if (j>0) f=GetDecalFunction(j);
- return f;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetDecalFunction(TF1* f,Int_t j)
-{
-// Set the de-calib. function of the j-th (default j=1) slot.
-// Note : The first attribute slot is at j=1.
-//
-// In case the value of the index j exceeds the maximum number of reserved
-// positions for the functions, the number of reserved positions for the functions
-// is increased automatically.
-//
-// In case the function pointer argument has the same value as the current function
-// pointer value, no action is taken since the user has already modified the actual
-// function.
-//
-// In case the function pointer argument is zero, the current function
-// is deleted and the pointer set to zero.
-//
-// In all other cases the current function is deleted and a new
-// copy of the input function is created which becomes the current function.
-
- if (j<1) return;
-
- if (!fDecalfuncs)
- {
-  fDecalfuncs=new TObjArray(j);
-  fDecalfuncs->SetOwner();
- }
-
- if (j > fDecalfuncs->GetSize()) fDecalfuncs->Expand(j);
-
- TF1* fcur=(TF1*)fDecalfuncs->At(j-1);
- if (f != fcur)
- {
-  if (fcur)
-  {
-   fDecalfuncs->Remove(fcur);
-   delete fcur;
-   fcur=0;
-  }
-  if (f)
-  {
-   fcur=new TF1(*f);
-   fDecalfuncs->AddAt(fcur,j-1);
-  }
- } 
-}
-///////////////////////////////////////////////////////////////////////////
-void AliAttrib::SetDecalFunction(TF1* f,TString name)
-{
-// Set the de-calib. function of the name-specified slot.
-//
-// In case the function pointer argument has the same value as the current function
-// pointer value, no action is taken since the user has already modified the actual
-// function.
-//
-// In case the function pointer argument is zero, the current function
-// is deleted and the pointer set to zero.
-//
-// In all other cases the current function is deleted and a new
-// copy of the input function is created which becomes the current function.
-
- Int_t j=GetSlotIndex(name);
- if (j>0) SetDecalFunction(f,j);
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliAttrib.h b/RALICE/AliAttrib.h
deleted file mode 100644 (file)
index c890014..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-#ifndef ALIATTRIB_H
-#define ALIATTRIB_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include "TArrayF.h"
-#include "TArrayI.h"
-#include "TObjArray.h"
-#include "TObjString.h"
-#include "TString.h"
-#include "TF1.h"
-
-class AliAttrib
-{
- public:
-  AliAttrib();                                 // Default constructor
-  virtual ~AliAttrib();                        // Destructor
-  AliAttrib(const AliAttrib& a);               // Copy constructor
-  Int_t GetNgains() const;                     // Provide the number of specified gains
-  Int_t GetNoffsets() const;                   // Provide the number of specified offsets
-  Int_t GetNcalflags() const;                  // Provide the number of specified calib. flags
-  Int_t GetNnames() const;                     // Provide the maximum number of specified names
-  void SetGain(Double_t gain,Int_t j=1);       // Set gain of the j-th attribute slot
-  void SetGain(Double_t gain,TString name);    // Set gain of the name-specified attribute slot
-  Float_t GetGain(Int_t j=1) const;            // Provide gain of the j-th attribute slot
-  Float_t GetGain(TString name) const;         // Provide gain of the name-specified attribute slot
-  void SetOffset(Double_t off,Int_t j=1);      // Set offset value of the j-th attribute slot
-  void SetOffset(Double_t off,TString name);   // Set offset value of the name specified attribute slot
-  Float_t GetOffset(Int_t j=1) const;          // Provide offset value of the j-th attribute slot
-  Float_t GetOffset(TString name) const;       // Provide offset value of the name-specified attribute slot
-  Int_t GetGainFlag(Int_t j=1) const;          // Provide gain flag of the j-th attribute slot
-  Int_t GetGainFlag(TString name) const;       // Provide gain flag of the name-specified attribute slot
-  Int_t GetOffsetFlag(Int_t j=1) const;        // Provide offset flag of the j-th attribute slot
-  Int_t GetOffsetFlag(TString name) const;     // Provide offset flag of the name-specified attribute slot
-  Int_t GetCalWord(Int_t j=1) const;           // Provide calib. word of the j-th attribute slot
-  Int_t GetCalWord(TString name) const;        // Provide calib word of the name-specified attribute slot
-  void ResetGain(Int_t j=1);                   // Reset j-th gain value and flag
-  void ResetGain(TString name);                // Reset name-specified gain value and flag
-  void ResetOffset(Int_t j=1);                 // Reset j-th offset value and flag
-  void ResetOffset(TString name);              // Reset name-specified offset value and flag
-  void DeleteCalibrations(Int_t mode=0);       // User selected delete of gains and/or offsets
-  void SetDead(Int_t j=1);                     // Indicate j-th attribute slot as 'dead'
-  void SetDead(TString name);                  // Indicate name-specified attribute slot as 'dead'
-  void SetAlive(Int_t j=1);                    // Indicate j-th attribute slot as 'active'
-  void SetAlive(TString name);                 // Indicate name-specified attribute slot as 'active'
-  Int_t GetDeadValue(Int_t j=1) const;         // Return the 'dead flag' of the j-th attribute slot
-  Int_t GetDeadValue(TString name) const;      // Return the 'dead flag' of the name-specified attribute slot
-  void Lock(Int_t j=1);                        // Indicate j-th attribute slot as 'locked'
-  void Lock(TString name);                     // Indicate name-specified attribute slot as 'locked'
-  void Unlock(Int_t j=1);                      // Indicate j-th attribute slot as 'unlocked'
-  void Unlock(TString name);                   // Indicate name-specified attribute slot as 'unlocked'
-  Int_t GetLockValue(Int_t j=1) const;         // Return the 'lock flag' of the j-th attribute slot
-  Int_t GetLockValue(TString name) const;      // Return the 'lock flag' of the name-specified attribute slot
-  void SetEdgeOn(Int_t j=1);                   // Indicate j-th slot as 'detector edge module'
-  void SetEdgeOn(TString name);                // Indicate name-spcified slot as 'detector edge module'
-  void SetEdgeOff(Int_t j=1);                  // Indicate j-th slot as 'detector non-edge module'
-  void SetEdgeOff(TString name);               // Indicate name-specified slot as 'detector non-edge module'
-  void IncreaseEdgeValue(Int_t j=1);           // Increase the edge value of the j-th slot by 1
-  void IncreaseEdgeValue(TString name);        // Increase the edge value of the name-specified slot by 1
-  void DecreaseEdgeValue(Int_t j=1);           // Decrease the edge value of the j-th slot by 1
-  void DecreaseEdgeValue(TString name);        // Decrease the edge value of the name-specified slot by 1
-  void SetEdgeValue(Int_t val,Int_t j=1);      // Set a specific edge value for the j-th slot
-  void SetEdgeValue(Int_t val,TString name);   // Set a specific edge value for the name-specified slot
-  Int_t GetEdgeValue(Int_t j=1) const;         // Provide the edge value of the j-th slot
-  Int_t GetEdgeValue(TString name) const;      // Provide the edge value of the name-specified slot
-  virtual void List(Int_t j=0) const;          // Printout of attribute data
-  virtual void List(TString name) const;       // Printout of name-specified attribute data
-  virtual void Load(AliAttrib& a,Int_t j=0);   // Load j-th slot or all attributes of the input AliAttrib
-  virtual void Load(AliAttrib& a,TString name);// Load name-specified slot attributes of the input AliAttrib
-  void AddNamedSlot(TString s);                // Add a new slot with the specified name
-  virtual Int_t GetNslots() const;             // Provide the number of exising slots
-  void SetSlotName(TString s,Int_t j=1);       // Set user defined name for the j-th slot
-  TString GetSlotName(Int_t j=1) const;        // Provide user defined name for the j-th slot
-  Int_t GetSlotIndex(TString name) const;      // Provide the slot index of the matching name
-  void SetCalFunction(TF1* f,Int_t j=1);       // Set calibration function of the j-th attribute slot
-  void SetCalFunction(TF1* f,TString name);    // Set calibration function of the name-specified attribute slot
-  void SetDecalFunction(TF1* f,Int_t j=1);     // Set de-calibration function of the j-th attribute slot
-  void SetDecalFunction(TF1* f,TString name);  // Set de-calibration function of the name-specified attribute slot
-  TF1* GetCalFunction(Int_t j=1) const;        // Get calibration function of the j-th attribute slot
-  TF1* GetCalFunction(TString name) const;     // Get calibration function of the name-specified attribute slot
-  TF1* GetDecalFunction(Int_t j=1) const;      // Get de-calibration function of the j-th attribute slot
-  TF1* GetDecalFunction(TString name) const;   // Get de-calibration function of the name-specified attribute slot
-  Int_t GetNcalfuncs() const;                  // Provide the number of calibration functions
-  Int_t GetNdecalfuncs() const;                // Provide the number of de-calibration functions
-
- protected:
-  void SetCalFlags(Int_t gf,Int_t of,Int_t j); // Set flags for gain and/or offset settings
-  TArrayF* fGains;                             // Gain values
-  TArrayF* fOffsets;                           // Offset values
-  TArrayI* fCalflags;                          // Flags to mark dead, edge, and gain/offset calibrated signals
-  TObjArray* fNames;                           // User defined names for the various slots
-  TObjArray* fCalfuncs;                        // Explicit signal calibration functions
-  TObjArray* fDecalfuncs;                      // Explicit signal de-calibration functions
-
- ClassDef(AliAttrib,6) // Generic handling of detector signal (calibration) attributes.
-};
-#endif
diff --git a/RALICE/AliAttribObj.cxx b/RALICE/AliAttribObj.cxx
deleted file mode 100644 (file)
index 86ad114..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-/**************************************************************************
- * 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 AliAttribObj
-// Generic handling of detector signal (calibration) attributes.
-//
-// This class is meant to provide an AliAttrib object which is derived
-// from TObject such that it can be stored in e.g. TObjArray etc...
-// and that it can be written out using the ROOT I/O machinery.
-//
-// Example :
-// ---------
-// AliAttrib a;
-// a.SetGain(250.7);
-// a.SetGain(1340,3);
-// a.SetEdgeOn(3);
-// a.SetOffset(-22.5,2);
-// a.SetDead(1);
-// a.Data();
-//
-// AliAttribObj b(a);
-// b.Data();
-//
-// AliAttribObj c;
-// c.Load(a);
-// c.Data();
-//
-//--- Author: Nick van Eijndhoven 18-sep-2003 Utrecht University
-//- Modified: NvE $Date$ Utrecht University
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliAttribObj.h"
-#include "Riostream.h"
-ClassImp(AliAttribObj) // Class implementation to enable ROOT I/O
-AliAttribObj::AliAttribObj() : TObject(),AliAttrib()
-{
-// Creation of an AliAttrib object and initialisation of parameters.
-// Several values of the same type (e.g. gain) can be stored in different slots.
-// If needed, the storage for values will be expanded automatically
-// when entering values.
-}
-///////////////////////////////////////////////////////////////////////////
-AliAttribObj::AliAttribObj(AliAttrib& a) : TObject(),AliAttrib(a)
-{
-// Creation of an AliAttrib object and initialisation of parameters.
-// All attributes are initialised to the values of the input AliAttrib.
-}
-///////////////////////////////////////////////////////////////////////////
-AliAttribObj::~AliAttribObj()
-{
-// Destructor to delete dynamically allocated memory
-}
-///////////////////////////////////////////////////////////////////////////
-AliAttribObj::AliAttribObj(const AliAttribObj& a) : TObject(a),AliAttrib(a)
-{
-// Copy constructor
-}
-///////////////////////////////////////////////////////////////////////////
-TObject* AliAttribObj::Clone(const char* name) const
-{
-// Make a deep copy of the current object and provide the pointer to the copy.
-// This memberfunction enables automatic creation of new objects of the
-// correct type depending on the object type, a feature which may be very useful
-// for containers when adding objects in case the container owns the objects.
-
- AliAttribObj* att=new AliAttribObj(*this);
- if (name)
- {
-  if (strlen(name))
-  {
-   cout << " *" << ClassName() << "::Clone* No support for SetName." << endl;
-  }
- }
- return att;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliAttribObj.h b/RALICE/AliAttribObj.h
deleted file mode 100644 (file)
index fbcd67d..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef ALIATTRIBOBJ_H
-#define ALIATTRIBOBJ_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include "TObject.h"
-
-#include "AliAttrib.h"
-
-class AliAttribObj : public TObject,public AliAttrib
-{
- public:
-  AliAttribObj();                                    // Default constructor
-  AliAttribObj(AliAttrib& a);                        // Constructor
-  virtual ~AliAttribObj();                           // Destructor
-  AliAttribObj(const AliAttribObj& a);               // Copy constructor
-  virtual TObject* Clone(const char* name="") const; // Make a deep copy and provide its pointer
-
- ClassDef(AliAttribObj,4) // Generic handling of detector signal (calibration) attributes.
-};
-#endif
diff --git a/RALICE/AliBoost.cxx b/RALICE/AliBoost.cxx
deleted file mode 100644 (file)
index 52519aa..0000000
+++ /dev/null
@@ -1,306 +0,0 @@
-/**************************************************************************
- * 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 AliBoost
-// Perform various Lorentz transformations.
-//
-// Example :
-// =========
-//
-// Float_t a[3]={0.1,0.2,0.3};
-// Float_t ea[3]={0.01,0.02,0.03};
-// Ali3Vector beta;
-// beta.SetVector(a,"car");
-// beta.SetErrors(ea,"car");
-//
-// AliBoost b1;
-// b1.SetBeta(beta);
-// b1.Data();
-//
-// Float_t b[4]={14,1,2,3};
-// Float_t eb[4]={1.4,0.1,0.2,0.3};
-// Ali4Vector p;
-// p.SetVector(b,"car");
-// p.SetErrors(eb,"car");
-// Ali4Vector pprim=b1.Boost(p);
-// p.Data();
-// pprim.Data();
-//
-// p=b1.Inverse(pprim);
-// pprim.Data();
-// p.Data();
-//
-// Float_t c[4]={5,0,0,4};
-// Float_t ec[4]={0.5,0,0,0.4};
-// Ali4Vector q;
-// q.SetVector(c,"car");
-// q.SetErrors(ec,"car");
-//
-// AliBoost b2;
-// b2.Set4Momentum(q);
-// b2.Data("sph");
-//
-//--- Author: Nick van Eijndhoven 14-may-1996 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliBoost.h"
-#include "Riostream.h"
-ClassImp(AliBoost) // Class implementation to enable ROOT I/O
-AliBoost::AliBoost() : TObject()
-{
-// Creation of a Lorentz boost object and initialisation of parameters.
-// Beta is set to (0,0,0) and consequently Gamma=1. 
-// All errors are initialised to 0. 
- Double_t a[3]={0,0,0};
- fBeta.SetVector(a,"sph");
- fGamma=1;
- fDgamma=0;
- fDresult=0;
-}
-///////////////////////////////////////////////////////////////////////////
-AliBoost::~AliBoost()
-{
-// Default destructor.
-}
-///////////////////////////////////////////////////////////////////////////
-AliBoost::AliBoost(const AliBoost& b) : TObject(b)
-{
-// Copy constructor
- fBeta=b.fBeta;
- fGamma=b.fGamma;
- fDgamma=b.fDgamma;
- fDresult=b.fDresult;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliBoost::SetBeta(Ali3Vector& b)
-{
-// Setting of boost parameters on basis of beta 3-vector.
-// The errors on the beta 3-vector are taken from the input 3-vector.
-// The gamma value and its error are calculated accordingly.
- fBeta=b;
- Double_t beta2=fBeta.Dot(fBeta);
- Double_t dbeta2=fBeta.GetResultError();
-
- if (beta2 > 1.)
- {
-  cout << " *AliBoost::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 AliBoost::Set4Momentum(Ali4Vector& p)
-{
-// Setting of boost parameters on basis of momentum 4-vector data.
-// The errors of the input 4-vector are used to calculate the
-// errors on the beta 3-vector and the gamma factor.
- Double_t E=p.GetScalar();
- Double_t dE=p.GetResultError();
- if (E <= 0.)
- {
-  cout << " *AliBoost::Set4Momentum* Unphysical situation." << endl;
-  p.Data();
- }
- else
- {
-  Ali3Vector 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);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Ali3Vector AliBoost::GetBetaVector() const
-{
-// Provide the beta 3-vector.
- return fBeta;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliBoost::GetBeta()
-{
-// Provide the norm of the beta 3-vector.
-// The error on the value can be obtained via GetResultError().
- Double_t norm=fBeta.GetNorm();
- fDresult=fBeta.GetResultError();
- return norm;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliBoost::GetGamma()
-{
-// Provide the gamma factor.
-// The error on the value can be obtained via GetResultError().
- fDresult=fDgamma;
- return fGamma;
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliBoost::GetResultError() const
-{
-// Provide the error on the result of an operation yielding a scalar.
-// E.g. GetBeta() or GetGamma()
- return fDresult;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliBoost::Data(TString f)
-{
-// Printing of the boost parameter info in coordinate frame f.
- Double_t beta=fBeta.GetNorm();
- Double_t dbeta=fBeta.GetResultError();
- cout << " *AliBoost::Data* beta : " << beta << " error : " << dbeta
-      << " gamma : " << fGamma << " error : " << fDgamma << endl;
- cout << "  Beta"; 
- fBeta.Data(f);
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector AliBoost::Boost(Ali4Vector& v)
-{
-// Perform the Lorentz boost on the 4-vector v.
-// Error propagation is performed automatically.
-// Note : As an approximation Beta and p.Dot(Beta) are considered as
-//        independent quantities.
-
- 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();
-
-  Ali3Vector 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;
-  Ali3Vector 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
-  Ali3Vector pprim=p+add;
-
-  // Set the components and errors of the new 4-vector 
-  Ali4Vector w;
-  w.SetVector(Eprim,pprim);
-  w.SetScalarError(dEprim);
-
-  return w;
- }
- else
- {
-  return v;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Ali4Vector AliBoost::Inverse(Ali4Vector& vprim)
-{
-// Perform the inverse Lorentz boost on the 4-vector vprim.
-// Error propagation is performed automatically.
-// Note : As an approximation Beta and pprim.Dot(Beta) are considered as
-//        independent quantities.
-
- 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();
-
-  Ali3Vector 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;
-  Ali3Vector 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
-  Ali3Vector p=pprim+add;
-
-  // Set the components and errors of the new 4-vector 
-  Ali4Vector w;
-  w.SetVector(E,p);
-  w.SetScalarError(dE);
-
-  return w;
- }
- else
- {
-  return vprim;
- }
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliBoost.h b/RALICE/AliBoost.h
deleted file mode 100644 (file)
index dfe442e..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef ALIBOOST_H
-#define ALIBOOST_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include <math.h>
-#include "TObject.h"
-
-#include "Ali4Vector.h" 
-
-class AliBoost : public TObject
-{
- public:
-  AliBoost();                             // Default constructor
-  virtual ~AliBoost();                    // Default destructor
-  AliBoost(const AliBoost& b);            // Copy constructor
-  void SetBeta(Ali3Vector& b);            // Set boost parameters by beta 3-vector
-  void Set4Momentum(Ali4Vector& p);       // Set boost parameters by 4-momentum
-  Ali3Vector GetBetaVector() const;       // Provide the beta 3-vector
-  Double_t GetBeta();                     // Provide norm of beta 3-vector
-  Double_t GetGamma();                    // Provide gamma value
-  void Data(TString f="car");             // Print boost parameter info in coord. frame f
-  Ali4Vector Boost(Ali4Vector& v);        // Perform Lorentz boost on 4-vector v
-  Ali4Vector Inverse(Ali4Vector& v);      // Perform inverse Lorentz boost on 4-vector v
-  Double_t GetResultError() const;        // Provide error on scalar result
- protected:
-  Ali3Vector fBeta;    // The beta 3-vector
-  Double32_t fGamma;   // The gamma factor
-  Double32_t fDgamma;  // Error on the gamma value
-  Double32_t fDresult; //! Error on scalar result
- ClassDef(AliBoost,5) // Perform various Lorentz transformations.
-};
-#endif
diff --git a/RALICE/AliCalcluster.cxx b/RALICE/AliCalcluster.cxx
deleted file mode 100644 (file)
index 393df68..0000000
+++ /dev/null
@@ -1,424 +0,0 @@
-/**************************************************************************
- * 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 AliCalcluster
-// Description of a cluster of calorimeter modules.
-// A 2D (matrix) geometry is assumed in which a cluster center is identified
-// by two integer indices (i,j), e.g. row and column indicators.
-//
-// The 1st signal value is the signal of the complete cluster.
-// This is the signal which is provided as default by invoking GetSignal().
-//
-// In case clustering/grouping of module signals was performed over several
-// rings around the center (see e.g. AliCalorimeter::Group), the following
-// additional information is provided by the various signal values :
-//
-// The 2nd signal value is the original signal of the central module.
-// The 3rd signal value is the total signal within the 1st (i.e. 3x3) ring of
-// modules around the cluster center.
-// The 4th signal value is the total signal within the 2nd (i.e. 5x5) ring of
-// modules around the cluster center.
-// Etc....
-//
-// Note : In case the cluster consists of only 1 module, then only the
-//        1st signal value will be present (for obvious reasons).
-//
-// Some dispersion info about cluster topology is provided in order
-// to enable EM or hadronic cluster identification.
-//
-//--- Author: Nick van Eijndhoven 13-jun-1997 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliCalcluster.h"
-#include "Riostream.h"
-ClassImp(AliCalcluster) // Class implementation to enable ROOT I/O
-AliCalcluster::AliCalcluster() : AliSignal()
-{
-// Default constructor, all data is set to 0
- fRow=0;
- fCol=0;
- fNmods=0;
- fRowdisp=0.;
- fColdisp=0.;
- fNvetos=0;
- fVetos=0;
- SetName("AliCalcluster [sig, sig11, sig33, sig55,...]");
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalcluster::~AliCalcluster()
-{
-// Destructor to delete dynamically allocated memory
- if (fVetos)
- {
-  delete fVetos;
-  fVetos=0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalcluster::AliCalcluster(const AliCalcluster& c) : AliSignal(c)
-{
-// Copy constructor
- fRow=c.fRow;
- fCol=c.fCol;
- fNmods=c.fNmods;
- fRowdisp=c.fRowdisp;
- fColdisp=c.fColdisp;
- fNvetos=c.fNvetos;
-
- fVetos=new TObjArray();
- fVetos->SetOwner();
-
- for (Int_t i=1; i<=fNvetos; i++)
- {
-  AliSignal* sx=c.GetVetoSignal(i);
-  fVetos->Add(new AliSignal(*sx));
- }
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalcluster::AliCalcluster(AliCalmodule& m) : AliSignal()
-{
-// Cluster constructor with module m as center.
-// Module data is only entered for a module which contains a signal,
-// has not been used in a cluster yet, and is not declared dead.
-//
-// Note :
-// It is advised NOT to start a cluster with modules situated at a detector edge.
-// This feature is automatically checked when using the built-in clustering
-// of AliCalorimeter.  
-
- Ali3Vector r;
-
- Float_t sig=m.GetClusteredSignal();
-
- if (sig>0. && m.GetDeadValue()==0)
- {
-  fRow=m.GetRow();
-  fCol=m.GetColumn();
-  r=m.GetPosition();
-  SetPosition(r);
-  sig=m.GetSignal(1,1); // Use the gain etc... corrected module signal
-  SetSignal(sig);
-  fNmods=1;
-  fRowdisp=0.;
-  fColdisp=0.;
-  m.SetClusteredSignal(0.); // mark module as used in cluster
-  fNvetos=0;
-  fVetos=0;
- }
- else
- {
-  fRow=0;
-  fCol=0;
-  SetPosition(r);
-  fNmods=0;
-  fRowdisp=0.;
-  fColdisp=0.;
-  fNvetos=0;
-  fVetos=0;
- }
- SetName("AliCalcluster [sig, sig11, sig33, sig55,...]");
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalcluster::GetRow() const
-{
-// Provide the row number of the cluster center
- return fRow;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalcluster::GetColumn() const
-{
-// Provide the column number of the cluster center
- return fCol;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalcluster::GetNmodules() const
-{
-// Provide the number of modules in the cluster
- return fNmods;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalcluster::GetRowDispersion() const
-{
-// Provide the normalised row dispersion of the cluster.
- Float_t sig=GetSignal();
- if (sig > 0.)
- {
-  return fRowdisp/sig;
- }
- else
- {
-  return 0.;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalcluster::GetColumnDispersion() const
-{
-// Provide the normalised column dispersion of the cluster
- Float_t sig=GetSignal();
- if (sig > 0.)
- {
-  return fColdisp/sig;
- }
- else
- {
-  return 0.;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalcluster::Start(AliCalmodule& m)
-{
-// Reset cluster data and start with module m.
-// A module can only start a cluster when it contains a signal,
-// has not been used in a cluster yet, and is not declared dead.
-//
-// Note :
-// It is advised NOT to start a cluster with modules situated at a detector edge.
-// This feature is automatically checked when using the built-in clustering
-// of AliCalorimeter.  
-
- AliSignal::Reset();
-
- Ali3Vector r;
-
- if (m.GetClusteredSignal()>0. && m.GetDeadValue()==0)
- {
-  fRow=m.GetRow();
-  fCol=m.GetColumn();
-  r=m.GetPosition();
-  SetPosition(r);
-  SetSignal(m.GetSignal(1,1)); // Use the gain etc... corrected module signal
-  fNmods=1;
-  fRowdisp=0.;
-  fColdisp=0.;
-  m.SetClusteredSignal(0.); // mark module as used in cluster
- }
- else
- {
-  fRow=0;
-  fCol=0;
-  SetPosition(r);
-  fNmods=0;
-  fRowdisp=0.;
-  fColdisp=0.;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalcluster::Add(AliCalmodule& m)
-{
-// Add module data to the cluster.
-// Dead modules are NOT added to the cluster.
-// According to the distance of the module w.r.t. the cluster center
-// the various signal values are updated.
-
- if (fNmods)
- {
-  if (m.GetClusteredSignal()>0. && m.GetDeadValue()==0) // only add unused modules
-  {
-   Float_t sigm=m.GetSignal(1,1); // Use the gain etc... corrected module signal
-
-   Int_t drow=int(fabs(double(GetRow()-m.GetRow())));       // row distance to center
-   Int_t dcol=int(fabs(double(GetColumn()-m.GetColumn()))); // column distance to center 
-
-   // Determine the ring index for this module around the cluster center
-   Int_t jring=drow;
-   if (dcol>drow) jring=dcol;
-
-   Int_t nvalues=GetNvalues();
-
-   if ((jring+2)<=nvalues) // Module within existing ring(s) ==> Add module signal to the enclosing ring(s)
-   {
-    for (Int_t i=(jring+2); i<=nvalues; i++)
-    {
-     AddSignal(sigm,i);
-    }
-   }
-   else  // Module outside all existing rings ==> Init. new ring signals with existing enclosed signal(s)
-   {
-    for (Int_t j=(nvalues+1); j<=(jring+2); j++)
-    {
-     SetSignal(GetSignal(j-1),j);
-    }
-    // Add current module signal to the signal value for the corresponding ring
-    AddSignal(sigm,(jring+2));
-   }
-
-   // Update total cluster signal
-   AddSignal(sigm);
-   fNmods+=1;
-   fRowdisp+=sigm*float(drow*drow);
-   fColdisp+=sigm*float(dcol*dcol);
-   m.SetClusteredSignal(0.); // mark module as used in cluster
-  }
- }
- else
- {
-  cout << " *AliCalcluster::Add* No action. Cluster should be started first."
-       << endl;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalcluster::AddVetoSignal(AliSignal& s,Int_t extr)
-{
-// Associate an (extrapolated) AliSignal as veto to the cluster.
-// By default a straight line extrapolation is performed which extrapolates
-// the signal position until the length of its position vector matches that
-// of the position vector of the cluster.
-// In this extrapolation procedure the error propagation is performed 
-// automatically.  
-// Based on the cluster and extrapolated veto signal (x,y) positions and
-// position errors the confidence level of association is calculated
-// and stored as an additional signal value.
-// By means of the GetVetoSignal memberfunction the confidence level of
-// association can always be updated by the user.
-// In case the user wants to invoke a more detailed extrapolation procedure,
-// the automatic extrapolation can be suppressed by setting the argument
-// extr=0. In this case it is assumed that the AliSignal as entered via
-// the argument contains already the extrapolated position vector and
-// corresponding errors. 
-// Note : Three additional values are added to the original AliSignal
-//        to hold the chi2, ndf and confidence level values of the association. 
- if (!fVetos)
- {
-  fNvetos=0;
-  fVetos=new TObjArray();
-  fVetos->SetOwner();
- } 
-
- Int_t nvalues=s.GetNvalues();
- AliSignal* sx=new AliSignal(s); // Additional values will be added
- TString name=s.GetName();
- name.Append(" + additional chi2, ndf and CL values");
- sx->SetName(name);
-
- Double_t vecc[3],vecv[3];
- if (extr)
- {
-  // Extrapolate the veto hit position
-  Double_t scale=1;
-  GetPosition(vecc,"sph");
-  s.GetPosition(vecv,"sph"); 
-  if (vecv[0]) scale=vecc[0]/vecv[0];
-  Ali3Vector r=s*scale;
-  sx->SetPosition(r);
- }
-
- // Calculate the confidence level of association
- GetPosition(vecc,"car");
- sx->GetPosition(vecv,"car"); 
- Double_t dx=vecc[0]-vecv[0];
- Double_t dy=vecc[1]-vecv[1];
- GetPositionErrors(vecc,"car");
- sx->GetPositionErrors(vecv,"car"); 
- Double_t sxc2=vecc[0]*vecc[0];
- Double_t syc2=vecc[1]*vecc[1];
- Double_t sxv2=vecv[0]*vecv[0];
- Double_t syv2=vecv[1]*vecv[1];
- Double_t sumx2=sxc2+sxv2;
- Double_t sumy2=syc2+syv2;
- Double_t chi2=0;
- if (sumx2>0 && sumy2>0) chi2=(dx*dx/sumx2)+(dy*dy/sumy2);
- Int_t ndf=2;
- AliMath m;
- Double_t prob=m.Prob(chi2,ndf);
- if (chi2>0) sx->SetSignal(chi2,nvalues+1);
- if (ndf>0) sx->SetSignal(ndf,nvalues+2);
- if (prob>0) sx->SetSignal(prob,nvalues+3);
-
- fVetos->Add(sx);
- fNvetos++;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalcluster::GetNvetos() const
-{
-// Provide the number of veto signals associated to the cluster
- return fNvetos;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliCalcluster::GetVetoSignal(Int_t i) const
-{
-// Provide access to the i-th veto signal of this cluster.
-// Note : The first hit corresponds to i=1.
- if (!fVetos)
- {
-  cout << " *AliCalcluster::GetVetoSignal* No veto signals present." << endl;
-  return 0;
- }
- else
- {
-  if (i>0 && i<=fNvetos)
-  {
-   return (AliSignal*)fVetos->At(i-1);
-  }
-  else
-  {
-   cout << " *AliCalcluster::GetVetoSignal* Signal number " << i << " out of range."
-        << " Nvetos = " << fNvetos << endl;
-   return 0;
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalcluster::GetVetoLevel() const
-{
-// Provide the confidence level of best associated veto signal.
- Float_t cl=0;
- Float_t clmax=0;
- AliSignal* s=0;
- Int_t nvalues=0;
- if (fVetos)
- {
-  for (Int_t i=0; i<fNvetos; i++)
-  {
-   s=((AliSignal*)fVetos->At(i));
-   if (s)
-   {
-    nvalues=s->GetNvalues();
-    cl=s->GetSignal(nvalues);
-    if (cl>clmax) clmax=cl;
-   }
-  }
- }
- return clmax;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalcluster::HasVetoHit(Double_t cl) const
-{
-// Investigate if cluster has an associated veto hit with conf. level > cl.
-// Returns 1 if there is such an associated veto hit, otherwise returns 0.
-// Note : This function is faster than GetVetoLevel().
- AliSignal* s=0;
- Int_t nvalues=0;
- if (fVetos)
- {
-  for (Int_t i=0; i<fNvetos; i++)
-  {
-   s=((AliSignal*)fVetos->At(i));
-   if (s)
-   {
-    nvalues=s->GetNvalues();
-    if (s->GetSignal(nvalues) > cl) return 1;
-   }
-  }
- }
- return 0;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliCalcluster.h b/RALICE/AliCalcluster.h
deleted file mode 100644 (file)
index 22aaf73..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef ALICALCLUSTER_H
-#define ALICALCLUSTER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include <math.h>
-#include "TObjArray.h"
-#include "TString.h"
-#include "AliCalmodule.h"
-#include "AliMath.h"
-class AliCalcluster : public AliSignal
-{
- public:
-  AliCalcluster();                         // Default constructor, all data initialised to 0
-  virtual ~AliCalcluster();                // Default destructor
-  AliCalcluster(const AliCalcluster& c);   // Copy constructor
-  AliCalcluster(AliCalmodule& m);          // Create new cluster starting at module m
-  Int_t GetRow() const;                    // Return row number of cluster center
-  Int_t GetColumn() const;                 // Return column number of cluster center
-  Int_t GetNmodules() const;               // Return number of modules in cluster
-  Float_t GetRowDispersion() const;        // Return normalised row dispersion of cluster
-  Float_t GetColumnDispersion() const;     // Return normalised column dispersion of cluster
-  void Start(AliCalmodule& m);             // Reset cluster data to start with module m
-  void Add(AliCalmodule& m);               // Add module data to cluster
-  void AddVetoSignal(AliSignal& s,Int_t extr=1); // Associate (extrapolated) signal
-  void AddVetoSignal(AliSignal* s,Int_t extr=1) { AddVetoSignal(*s,extr); }
-  AliSignal* GetVetoSignal(Int_t j) const; // Access to veto signal number j
-  Int_t GetNvetos() const;                 // Provide the number of veto signals
-  Float_t GetVetoLevel() const;            // Provide confidence level of best associated veto hit
-  Int_t HasVetoHit(Double_t cl) const;     // Check for ass. veto hit with conf. level > cl
- protected:
-  Int_t fRow;            // Row index of the central module of the cluster
-  Int_t fCol;            // Column index of the central module of the cluster
-  Int_t fNmods;          // The number of modules in the cluster
-  Float_t fRowdisp;      // Row dispersion of cluster (not normalised)
-  Float_t fColdisp;      // Column dispersion of cluster (not normalised)
-  Int_t fNvetos;         // The number of associated veto signals
-  TObjArray* fVetos;     // The array of associated veto signals
- ClassDef(AliCalcluster,5) // Description of a cluster of calorimeter modules.
-};
-#endif
diff --git a/RALICE/AliCalmodule.cxx b/RALICE/AliCalmodule.cxx
deleted file mode 100644 (file)
index a503a2d..0000000
+++ /dev/null
@@ -1,142 +0,0 @@
-/**************************************************************************
- * 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 AliCalmodule
-// Description of a module in a calorimeter system.
-// A matrix geometry is assumed, such that a module
-// is identified by (row,col) and contains a certain signal.
-// Note : row and col start counting at 1.
-//
-//--- Author: Nick van Eijndhoven 13-jun-1997 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliCalmodule.h"
-#include "Riostream.h"
-ClassImp(AliCalmodule) // Class implementation to enable ROOT I/O
-AliCalmodule::AliCalmodule() : AliSignal()
-{
-// Default constructor, all module data is set to 0
- fRow=0;
- fCol=0;
- fSigc=0;
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalmodule::~AliCalmodule()
-{
-// Default destructor
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalmodule::AliCalmodule(const AliCalmodule& m) : AliSignal(m)
-{
-// Copy constructor
- fRow=m.fRow;
- fCol=m.fCol;
- fSigc=m.fSigc;
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalmodule::AliCalmodule(Int_t row,Int_t col,Double_t sig) : AliSignal()
-{
-// Module constructor with initialisation of module data
- fRow=row;
- fCol=col;
- AliSignal::SetSignal(sig);
- fSigc=sig;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalmodule::SetRow(Int_t i)
-{
-// Set the row number for this module
- fRow=i;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalmodule::SetColumn(Int_t i)
-{
-// Set the column number for this module
- fCol=i;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalmodule::SetSignal(Double_t sig,Int_t j)
-{
-// Set or change the data of the module.
-// This is an extension of AliSignal::SetSignal in view of the clustered signal.
- AliSignal::SetSignal(sig,j);
- if (j==1) fSigc=sig;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalmodule::AddSignal(Double_t sig,Int_t j)
-{
-// Add or change the data of the module
-// This is an extension of AliSignal::AddSignal in view of the clustered signal.
- AliSignal::AddSignal(sig,j);
- if (j==1) fSigc+=sig;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalmodule::SetClusteredSignal(Double_t sig)
-{
-// Set or change the signal of the module after clustering
- fSigc=sig;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalmodule::GetRow() const
-{
-// Provide the row number of the module
- return fRow;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalmodule::GetColumn() const
-{
-// Provide the column number of the module
- return fCol;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalmodule::GetClusteredSignal() const
-{
-// Provide the signal of the module after clustering.
- Int_t dead=GetDeadValue();
- if (!dead)
- {
-  return fSigc;
- }
- else
- {
-  return 0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-TObject* AliCalmodule::Clone(const char* name) const
-{
-// Make a deep copy of the current object and provide the pointer to the copy.
-// This memberfunction enables automatic creation of new objects of the
-// correct type depending on the object type, a feature which may be very useful
-// for containers like AliCalorimeter when adding objects in case the
-// container owns the objects. This feature allows e.g. AliCalorimeter
-// to store either AliCalmodule objects or objects derived from AliCalmodule
-// via tha AddSignal memberfunction, provided these derived classes also have
-// a proper Clone memberfunction. 
-
- AliCalmodule* m=new AliCalmodule(*this);
- if (name)
- {
-  if (strlen(name)) m->SetName(name);
- }
- return m;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliCalmodule.h b/RALICE/AliCalmodule.h
deleted file mode 100644 (file)
index 1357708..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef ALICALMODULE_H
-#define ALICALMODULE_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include "AliSignal.h"
-class AliCalmodule : public AliSignal
-{
- public:
-  AliCalmodule();                                          // Default constructor
-  virtual ~AliCalmodule();                                 // Default destructor
-  AliCalmodule(const AliCalmodule& m);                     // Copy constructor
-  AliCalmodule(Int_t row,Int_t col,Double_t sig);          // Create a module and initialise data
-  virtual TObject* Clone(const char* name="") const;       // Make a deep copy and provide its pointer
-  using AliSignal::SetSignal;
-  virtual void SetSignal(Double_t sig,Int_t j=1);          // Set or change data for certain module
-  using AliSignal::AddSignal;
-  virtual void AddSignal(Double_t sig,Int_t j=1);          // Add signal to a certain module
-  void SetRow(Int_t i);                                    // Set the row number of the module
-  void SetColumn(Int_t i);                                 // Set the column number of the module
-  Int_t GetRow() const;                                    // Return the row number of the module
-  Int_t GetColumn() const;                                 // Return the column number of the module
-  void SetClusteredSignal(Double_t val);                   // Set the signal of the module after clustering
-  Float_t GetClusteredSignal() const;                      // Return module signal after clustering
- protected:
-  Int_t fRow;        // The current row number
-  Int_t fCol;        // The current column number
-  Float_t fSigc;     // The signal after clustering
- ClassDef(AliCalmodule,9) // Description of a module in a calorimeter system.
-};
-#endif
diff --git a/RALICE/AliCalorimeter.cxx b/RALICE/AliCalorimeter.cxx
deleted file mode 100644 (file)
index 23d2d03..0000000
+++ /dev/null
@@ -1,1683 +0,0 @@
-/**************************************************************************
- * 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 AliCalorimeter
-// Description of a modular calorimeter system.
-// A generic 2D geometry is used in which a module is identified by (row,col).
-// Obviously this geometry can be a matrix, but also any other regular
-// structure is supported, provided the user has adopted a proper convention
-// to uniquely address a module via the (row,col) indices.  
-// Note : First module is identified as (1,1).
-//
-// This is the way to define and enter signals into a calorimeter :
-//
-//   AliCalorimeter cal;
-//
-//   cal.AddSignal(5,7,85.4);
-//   cal.AddSignal(5,7,25.9);
-//   cal.AddSignal(3,5,1000);
-//   cal.SetSignal(5,7,10.3);
-//   cal.Reset(3,5);             // Reset module (3,5) as being 'not fired'
-//                               // All module data are re-initialised.
-//   cal.SetEdgeOn(1,1);         // Declare module (1,1) as an 'edge module'
-//   cal.SetDead(8,3);
-//   cal.SetGain(2,8,3.2);
-//
-//   Float_t vec[3]={6,1,20};
-//   cal.SetPosition(2,8,vec,"car");
-//
-//   AliSignal s;
-//   Float_t loc[3]={-1,12,3};
-//   s.SetPosition(loc,"car");
-//   s.SetSignal(328);
-//   cal.AddVetoSignal(s); // Associate (extrapolated) signal as a veto
-//
-//   cal.Group(2);      // Group 'fired' modules into clusters
-//                      // Perform grouping over 2 rings around the center
-//   cal.Reset();       // Reset the complete calorimeter
-//                      // Normally to prepare for the next event data
-//                      // Note : Module gain, offset, edge and dead flags remain
-//
-//--- Author: Nick van Eijndhoven 13-jun-1997 UU-SAP Utrecht
-//- Modified: NvE $Date$ UU-SAP Utrecht
-///////////////////////////////////////////////////////////////////////////
-
-#include "AliCalorimeter.h"
-#include "Riostream.h"
-
-ClassImp(AliCalorimeter) // Class implementation to enable ROOT I/O
-AliCalorimeter::AliCalorimeter() : AliDevice()
-{
-// Default constructor, all parameters set to 0.
-// Create a calorimeter module matrix with fixed row and column size.
-// Note : Due to the dynamic size extension when signals are set,
-//        the  "edge modules" can NOT be marked automatically.
-//        This has to be done manually by the user via the SetEdgeOn() 
-//        memberfunction.
- fNrows=0;
- fNcolumns=0;
- fSwap=0;
- fMatrix=0;
- fClusters=0;
- fHmodules=0;
- fHclusters=0;
- fVetos=0;
- fAttributes=0;
- fPositions=0;
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalorimeter::~AliCalorimeter()
-{
-// Destructor to delete memory allocated to the various arrays and matrices
- if (fClusters)
- {
-  delete fClusters;
-  fClusters=0;
- }
- if (fVetos)
- {
-  delete fVetos;
-  fVetos=0;
- }
- if (fHmodules)
- {
-  delete fHmodules;
-  fHmodules=0;
- }
- if (fHclusters)
- {
-  delete fHclusters;
-  fHclusters=0;
- }
- if (fMatrix)
- {
-  delete fMatrix;
-  fMatrix=0;
- }
- if (fPositions)
- {
-  delete fPositions;
-  fPositions=0;
- }
- if (fAttributes)
- {
-  delete fAttributes;
-  fAttributes=0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalorimeter::AliCalorimeter(Int_t nrow,Int_t ncol) : AliDevice()
-{
-// Create a calorimeter module matrix with fixed row and column size.
-// The modules at the edges are automatically marked as "edge modules".
- fNrows=nrow;
- fNcolumns=ncol;
- fClusters=0;
-
- fSwap=0;
- fMatrix=0;
- fPositions=0;
-
- fAttributes=new TObjArray(nrow);
- fAttributes->SetOwner();
- // Mark the edge modules
- for (Int_t row=1; row<=nrow; row++)
- {
-  AliAttribObj* a=new AliAttribObj();
-  if (row==1 || row==nrow)
-  {
-   for (Int_t col=1; col<=ncol; col++)
-   {
-    a->SetEdgeOn(col);
-   }
-  }
-  else
-  {
-   a->SetEdgeOn(1);
-   a->SetEdgeOn(ncol);
-  }
-  fAttributes->Add(a);
- }
- fHmodules=0;
- fHclusters=0;
-
- fVetos=0;
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalorimeter::AliCalorimeter(const AliCalorimeter& c) : AliDevice(c)
-{
-// Copy constructor
- fClusters=0;
- fVetos=0;
-
- fAttributes=0;
-
- fHmodules=0;
- fHclusters=0;
-
- fMatrix=0;
- fPositions=0;
-
- fNrows=c.fNrows;
- fNcolumns=c.fNcolumns;
-
- fSwap=c.fSwap;
-
- if (c.fPositions)
- {
-  Int_t nrows=(c.fPositions)->GetMaxRow();
-  Int_t ncols=(c.fPositions)->GetMaxColumn();
-  for (Int_t irow=1; irow<=nrows; irow++)
-  {
-   for (Int_t icol=1; icol<=ncols; icol++)
-   {
-    AliPosition* p=(AliPosition*)(c.fPositions->GetObject(irow,icol));
-    if (p) SetPosition(irow,icol,*p);
-   } 
-  }  
- }
-
- Int_t size=0;
- if (c.fAttributes) size=c.fAttributes->GetSize();
- if (size)
- {
-  fAttributes=new TObjArray(size);
-  fAttributes->SetOwner();
-  for (Int_t ia=0; ia<size; ia++)
-  {
-   AliAttribObj* a=(AliAttribObj*)(c.fAttributes->At(ia));
-   if (a) fAttributes->AddAt(new AliAttribObj(*a),ia);
-  }
- }
-
- Int_t n=0;
- n=c.GetNclusters();
- if (n)
- {
-  fClusters=new TObjArray();
-  fClusters->SetOwner();
-  for (Int_t icl=1; icl<=n; icl++)
-  {
-   AliCalcluster* cl=c.GetCluster(icl);
-   if (cl) fClusters->Add(new AliCalcluster(*cl));
-  }
- }
-
- n=c.GetNvetos();
- for (Int_t iv=1; iv<=n; iv++)
- {
-  AliSignal* s=c.GetVetoSignal(iv);
-  if (s) AddVetoSignal(s);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNrows()
-{
-// Provide the number of rows for the calorimeter module matrix
- Int_t nrows=fNrows;
- if (!fMatrix) LoadMatrix();
- if (fMatrix && !nrows) nrows=fMatrix->GetMaxRow();
- return nrows;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNcolumns()
-{
-// Provide the number of columns for the calorimeter module matrix
- Int_t ncols=fNcolumns;
- if (!fMatrix) LoadMatrix();
- if (fMatrix && !ncols) ncols=fMatrix->GetMaxColumn();
- return ncols;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetSignal(Int_t row,Int_t col,Float_t sig)
-{
-// Set the signal for a certain calorimeter module.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetSignal* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- if (!fMatrix) LoadMatrix();
-
- if (!fMatrix)
- {
-  fMatrix=new AliObjMatrix();
-  fMatrix->SetSwapMode(fSwap);
- }
-
- AliCalmodule* mx=GetModule(row,col);
- if (mx) // Existing module
- {
-  mx->SetSignal(sig);
- }
- else // Initialise for a new module
- {
-  AliCalmodule m;
-  m.SetRow(row);
-  m.SetColumn(col);
-  m.SetSignal(sig);
-  AliPosition* r=0;
-  if (fPositions) r=(AliPositionObj*)fPositions->GetObject(row,col);
-  if (r) m.SetPosition(*r);
-  if (fAttributes)
-  {
-   AliAttribObj* a=0;
-   if (row <= fAttributes->GetSize()) a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (a->GetGainFlag(col)) m.SetGain(a->GetGain(col));
-    if (a->GetOffsetFlag(col)) m.SetOffset(a->GetOffset(col));
-    if (a->GetDeadValue(col)) m.SetDead();
-    if (a->GetEdgeValue(col)) m.SetEdgeValue(a->GetEdgeValue(col));
-   }
-  }
-  AddHit(m);
-  fMatrix->EnterObject(row,col,fHits->Last());
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::AddSignal(Int_t row, Int_t col, Float_t sig)
-{
-// Add the signal to a certain calorimeter module.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::AddSignal* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-  AliCalmodule* m=GetModule(row,col);
-  if (!m) // initialise for new modules
-  {
-   SetSignal(row,col,sig);
-  }
-  else
-  {
-   m->AddSignal(sig);
-  }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::AddSignal(AliCalmodule* mod)
-{
-// Add the signal of module mod to the current calorimeter data.
-// This enables mixing of calorimeter data of various events.
-//
-// Note : The position and attributes according to the user provided data
-//        for the corresponding (row,col) location will be used.
-//        In case there is no user provided data present, the position and
-//        attributes of the first module added to the corresponding (row,col)
-//        location will be taken, except for the "edge" and "dead" indicators.
-//        The latter will then both be set to 0.
-
- if (!mod) return;
- Int_t row=mod->GetRow();
- Int_t col=mod->GetColumn();
- Float_t sig=mod->GetSignal();
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::AddSignal* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- if (!fMatrix) LoadMatrix();
- if (!fMatrix)
- {
-  fMatrix=new AliObjMatrix();
-  fMatrix->SetSwapMode(fSwap);
- }
-
- AliCalmodule* mx=GetModule(row,col);
- if (!mx) // No module existed yet at this position
- {
-  AliCalmodule m(*mod);
-  AliPosition* r=0;
-  if (fPositions) r=(AliPositionObj*)fPositions->GetObject(row,col);
-  if (r) m.SetPosition(*r);
-  // Don't take the dead and edge attributes from this module,
-  // but from the calorimeter dbase, if present.
-  m.SetEdgeOff();
-  m.SetAlive();
-  if (fAttributes)
-  {
-   AliAttribObj* a=0;
-   if (row <= fAttributes->GetSize()) a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (a->GetGainFlag(col)) m.SetGain(a->GetGain(col));
-    if (a->GetOffsetFlag(col)) m.SetOffset(a->GetOffset(col));
-    if (a->GetDeadValue(col)) m.SetDead();
-    if (a->GetEdgeValue(col)) m.SetEdgeValue(a->GetEdgeValue(col));
-   }
-  }
-  AddHit(m);
-  fMatrix->EnterObject(row,col,fHits->Last());
- }
- else
- {
-  mx->AddSignal(sig);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::Reset(Int_t row,Int_t col)
-{
-// Reset the signal for a certain calorimeter module.
-// Note : Module position and attributes remain unchanged.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::Reset* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
- AliCalmodule* m=GetModule(row,col);
- if (m)
- {
-  RemoveHit(m);
-  fMatrix->RemoveObject(row,col);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::Reset(Int_t mode)
-{
-// Reset the signals for the complete calorimeter.
-// Normally this is done to prepare for the data of the next event.
-//
-// mode = 0 : Swap mode, module positions and attributes remain unchanged.
-//        1 : Swap mode, module positions and attributes are cleared.
-//
-// The default is mode=0.
-//
-// Note : In the case of reading AliCalorimeter objects from a data file,
-//        one has to reset the AliCalorimeter object with mode=1
-//        (or explicitly delete it) before reading-in the next object
-//        in order to prevent memory leaks.
-
- if (mode<0 || mode>1)
- {
-  cout << " *AliCalorimeter::Reset* Wrong argument. mode = " << mode << endl;
-  return;
- }
-
- AliDevice::Reset(mode);
-
- if (fClusters)
- {
-  delete fClusters;
-  fClusters=0;
- }
-
- if (fVetos)
- {
-  delete fVetos;
-  fVetos=0;
- }
-
- if (mode==1)
- {
-  if (fMatrix)
-  {
-   delete fMatrix;
-   fMatrix=0;
-  }
-  if (fPositions)
-  {
-   delete fPositions;
-   fPositions=0;
-  }
- }
- else
- {
-  if (fMatrix) fMatrix->Reset();
- }
-
- // Free memory allocated for the various arrays.
- if (mode==1)
- {
-  if (fAttributes)
-  {
-   delete fAttributes;
-   fAttributes=0;
-  }
-  if (fHmodules)
-  {
-   delete fHmodules;
-   fHmodules=0;
-  }
-  if (fHclusters)
-  {
-   delete fHclusters;
-   fHclusters=0;
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetSignal(Int_t row,Int_t col,Int_t mode)
-{
-// Provide the signal of a certain calorimeter module.
-// In case the module was marked dead, 0 is returned.
-//
-// mode = 0 : Just the module signal is returned
-//        1 : The module signal is corrected for the gain and offset.
-//            In case the gain value was not set, gain=1 will be assumed.
-//            In case the gain value was 0, a signal value of 0 is returned.
-//            In case the offset value was not set, offset=0 will be assumed.
-//
-// The corrected signal (sigc) is determined as follows :
-//
-//              sigc=(signal/gain)-offset 
-//
-// The default is mode=0.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetSignal* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
- Float_t signal=0;
- Float_t gain=1;
- Float_t offset=0;
- AliCalmodule* m=GetModule(row,col);
- if (m)
- {
-  Int_t dead=m->GetDeadValue();
-  if (!dead) signal=m->GetSignal();
-
-  if (mode==0 || dead) return signal;
-
-  // Correct the signal for the gain and offset
-  if (GetGainFlag(row,col))
-  {
-   gain=GetGain(row,col);
-  }
-  else
-  {
-   if (m->GetGainFlag()) gain=m->GetGain();
-  }
-
-  if (GetOffsetFlag(row,col))
-  {
-   offset=GetOffset(row,col);
-  }
-  else
-  {
-   if (m->GetOffsetFlag()) offset=m->GetOffset();
-  }
-
-  if (fabs(gain)>0.)
-  {
-   signal=(signal/gain)-offset;
-  }
-  else
-  {
-   signal=0;
-  }
- }
- return signal;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetEdgeOn(Int_t row,Int_t col)
-{
-// Indicate a certain calorimeter module as 'edge module'.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetEdgeOn* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- if (!fAttributes)
- {
-  fAttributes=new TObjArray(row);
-  fAttributes->SetOwner();
- }
- else
- {
-  if (row > fAttributes->GetSize()) fAttributes->Expand(row);
- }
-
- AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
- if (a)
- {
-  a->SetEdgeOn(col);
- }
- else
- {
-  a=new AliAttribObj();
-  a->SetEdgeOn(col);
-  fAttributes->AddAt(a,row-1);
- } 
-
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetEdgeOn();
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetEdgeOff(Int_t row,Int_t col)
-{
-// Indicate a certain calorimeter module as 'non-edge module'.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetEdgeOff* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- // Only action on fAttributes in case an attribute is present at (row,col),
- // since by default a module has edge=0 unless explicitly set otherwise.
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a) a->SetEdgeOff(col);
-  }
- } 
-
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetEdgeOff();
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetDead(Int_t row,Int_t col)
-{
-// Indicate a certain calorimeter module as 'dead module'
-
- // Check for (row,col) boundaries in case of a fixed size calorimeter
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetDead* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- // Make Attributes storage 1 row (and also 1 column) larger than needed
- // because the 'edge value' of the (future) surrounding modules has
- // to be updated as well.
- if (!fAttributes)
- {
-  fAttributes=new TObjArray(row+1);
-  fAttributes->SetOwner();
- }
- else
- {
-  if (row >= fAttributes->GetSize()) fAttributes->Expand(row+1);
- }
-
- AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
- if (a)
- {
-  a->SetDead(col);
- }
- else
- {
-  a=new AliAttribObj();
-  a->SetDead(col);
-  fAttributes->AddAt(a,row-1);
- } 
-
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetDead();
- // Increase the 'edge value' of surrounding modules
- Int_t rlow=row-1;
- Int_t rup=row+1;
- Int_t clow=col-1;
- Int_t cup=col+1;
- if (rlow < 1) rlow=row;
- if (clow < 1) clow=col;
- for (Int_t i=rlow; i<=rup; i++)
- {
-  for (Int_t j=clow; j<=cup; j++)
-  {
-   if (i!=row || j!=col) // No increase of edge value for the 'dead' module itself
-   {
-    a=(AliAttribObj*)fAttributes->At(i-1);
-    if (a)
-    {
-     a->IncreaseEdgeValue(j);
-    }
-    else
-    {
-    a=new AliAttribObj();
-    a->SetEdgeOn(j);
-    fAttributes->AddAt(a,i-1);
-    } 
-
-    m=GetModule(i,j);
-    if (m) m->IncreaseEdgeValue();
-   }
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetAlive(Int_t row,Int_t col)
-{
-// Indicate a certain calorimeter module as 'active module'.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetAlive* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- // Only action on fAttributes in case an attribute is present at (row,col),
- // since by default a module has dead=0 unless explicitly set otherwise.
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a) a->SetAlive(col);
-  }
- } 
-
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetAlive();
- // Decrease the 'edge value' of surrounding modules
- Int_t rlow=row-1;
- Int_t rup=row+1;
- Int_t clow=col-1;
- Int_t cup=col+1;
- if (rlow < 1) rlow=row;
- if (clow < 1) clow=col;
-
- for (Int_t i=rlow; i<=rup; i++)
- {
-  for (Int_t j=clow; j<=cup; j++)
-  {
-   if (i!=row || j!=col) // No decrease of edge value for the 'alive' module itself
-   {
-    if (i <= fAttributes->GetSize())
-    {
-     AliAttribObj* a=(AliAttribObj*)fAttributes->At(i-1);
-     if (a) a->DecreaseEdgeValue(j);
-    }
-    m=GetModule(i,j);
-    if (m) m->DecreaseEdgeValue();
-   }
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetGain(Int_t row,Int_t col,Float_t gain)
-{
-// Set the gain value for a certain calorimeter module.
-// See the memberfunction GetSignal() for a definition of the gain value.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetGain* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- if (!fAttributes)
- {
-  fAttributes=new TObjArray(row);
-  fAttributes->SetOwner();
- }
- else
- {
-  if (row > fAttributes->GetSize()) fAttributes->Expand(row);
- }
-
- AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
- if (a)
- {
-  a->SetGain(gain,col);
- }
- else
- {
-  a=new AliAttribObj();
-  a->SetGain(gain,col);
-  fAttributes->AddAt(a,row-1);
- } 
-
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetGain(gain);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetOffset(Int_t row,Int_t col,Float_t offset)
-{
-// Set the offset value for a certain calorimeter module.
-// See the memberfunction GetSignal() for a definition of the offset value.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetOffset* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- if (!fAttributes)
- {
-  fAttributes=new TObjArray(row);
-  fAttributes->SetOwner();
- }
- else
- {
-  if (row > fAttributes->GetSize()) fAttributes->Expand(row);
- }
-
- AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
- if (a)
- {
-  a->SetOffset(offset,col);
- }
- else
- {
-  a=new AliAttribObj();
-  a->SetOffset(offset,col);
-  fAttributes->AddAt(a,row-1);
- } 
-
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetOffset(offset);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetPosition(Int_t row,Int_t col,Float_t* vec,TString f)
-{
-// Set the position in user coordinates for a certain calorimeter module
- Ali3Vector r;
- r.SetVector(vec,f);
- SetPosition(row,col,r);
-} 
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetPosition(Int_t row,Int_t col,Ali3Vector& r)
-{
-// Set the position for a certain calorimeter module
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::SetPosition* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return;
- }
-
- if (!fPositions)
- {
-  fPositions=new AliObjMatrix();
-  fPositions->SetOwner();
-  fPositions->SetSwapMode(fSwap);
- }
-
- AliPositionObj* p=(AliPositionObj*)fPositions->GetObject(row,col);
-
- if (p)
- {
-  p->Load(r);
- }
- else
- {
-  p=new AliPositionObj();
-  p->Load(r);
-  fPositions->EnterObject(row,col,p);
- }
-
- // Update the position of the calorimeter module itself as well if it exists
- AliCalmodule* m=GetModule(row,col);
- if (m) m->SetPosition(r);
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetEdgeValue(Int_t row,Int_t col)
-{
-// Provide the value of the edge flag of a certain module.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetEdgeValue* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- Int_t edge=0;
-
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (col <= a->GetNcalflags())
-    {
-     edge=a->GetEdgeValue(col);
-     return edge;
-    }
-   }
-  }
- }
-
- AliCalmodule* m=GetModule(row,col);
- if (m) edge=m->GetEdgeValue();
- return edge;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetDeadValue(Int_t row,Int_t col)
-{
-// Provide the value of the dead flag of a certain module
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetDeadValue* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- Int_t dead=0;
-
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (col <= a->GetNcalflags())
-    {
-     dead=a->GetDeadValue(col);
-     return dead;
-    }
-   }
-  }
- }
-
- AliCalmodule* m=GetModule(row,col);
- if (m) dead=m->GetDeadValue();
- return dead;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetGainFlag(Int_t row,Int_t col)
-{
-// Provide the value of the gain flag of a certain module.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetGainFlag* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- Int_t gf=0;
-
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (col <= a->GetNcalflags())
-    {
-     gf=a->GetGainFlag(col);
-     return gf;
-    }
-   }
-  }
- }
-
- AliCalmodule* m=GetModule(row,col);
- if (m) gf=m->GetGainFlag();
- return gf;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetOffsetFlag(Int_t row,Int_t col)
-{
-// Provide the value of the offset flag of a certain module.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetOffsetFlag* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- Int_t of=0;
-
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (col <= a->GetNcalflags())
-    {
-     of=a->GetOffsetFlag(col);
-     return of;
-    }
-   }
-  }
- }
-
- AliCalmodule* m=GetModule(row,col);
- if (m) of=m->GetOffsetFlag();
- return of;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetGain(Int_t row,Int_t col)
-{
-// Provide the gain value of a certain module.
-// See the memberfunction GetSignal() for a definition of the gain value.
-//
-// In case the gain value is unknown, the value 0 will be returned. 
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetGain* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- Float_t gain=0;
-
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (col <= a->GetNcalflags())
-    {
-     if (a->GetGainFlag(col))
-     {
-      gain=a->GetGain(col);
-      return gain;
-     }
-    }
-   }
-  }
- }
-
- AliCalmodule* m=GetModule(row,col);
- if (m)
- {
-  if (m->GetGainFlag())
-  {
-   gain=m->GetGain();
-  }
- }
- return gain;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetOffset(Int_t row,Int_t col)
-{
-// Provide the offset value of a certain module.
-// See the memberfunction GetSignal() for a definition of the offset value.
-//
-// In case the offset value is unknown, the value 0 will be returned. 
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetOffset* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- Float_t offset=0;
-
- if (fAttributes)
- {
-  if (row <= fAttributes->GetSize())
-  {
-   AliAttribObj* a=(AliAttribObj*)fAttributes->At(row-1);
-   if (a)
-   {
-    if (col <= a->GetNcalflags())
-    {
-     if (a->GetOffsetFlag(col))
-     {
-      offset=a->GetOffset(col);
-      return offset;
-     }
-    }
-   }
-  }
- }
-
- AliCalmodule* m=GetModule(row,col);
- if (m)
- {
-  if (m->GetOffsetFlag())
-  {
-   offset=m->GetOffset();
-  }
- }
- return offset;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::GetPosition(Int_t row,Int_t col,Float_t* vec,TString f)
-{
-// Return the position in user coordinates for a certain calorimeter module
- vec[0]=0;
- vec[1]=0;
- vec[2]=0;
-
- AliPosition* p=GetPosition(row,col);
- if (p) p->GetVector(vec,f);
-}
-///////////////////////////////////////////////////////////////////////////
-AliPosition* AliCalorimeter::GetPosition(Int_t row,Int_t col)
-{
-// Access to the position of a certain calorimeter module.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetPosition* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
-
- AliPositionObj* po=0;
- if (fPositions) po=(AliPositionObj*)fPositions->GetObject(row,col);
- if (po) return po;
-
- AliCalmodule* m=GetModule(row,col);
- return m;
-}
-///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetClusteredSignal(Int_t row,Int_t col)
-{
-// Provide the module signal after clustering.
-
- // Check for (row,col) boundaries.
- if (row<1 || col<1 || (fNrows && fNcolumns && (row>fNrows || col>fNcolumns)))
- {
-  cout << " *AliCalorimeter::GetClusteredSignal* row,col : " << row << "," << col
-       << " out of range." << endl;
-  if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
-  return 0;
- }
- Float_t sig=0;
-
- AliCalmodule* m=GetModule(row,col);
- if (m) sig=m->GetClusteredSignal();
-
- return sig;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNsignals() const
-{
-// Provide the number of modules that contain a signal
-// Note : The number of modules marked 'dead' but which had a signal
-//        are included.
- return GetNhits();
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::Group(Int_t n,Int_t mode)
-{
-// Group the individual modules into clusters.
-// Module signals of n rings around the central module will be grouped.
-// The grouping process will start with the module containing the highest signal
-// in an iterative way.
-// For this all fired modules are ordered w.r.t. decreasing signal.
-// The search mode for the module signal hierarchy can be specified by the user.
-//
-// mode = 1 : Search performed via the (row,col) structure of the matrix (SortM)
-//        2 : Search performed via the linear array of fired modules (SortA)
-//
-// See the docs of the memberfunctions SortM and SortA for additional details.
-//
-// Default values : n=1 mode=1.
-
- if (mode<1 || mode>2)
- {
-  cout << " *AliCalorimeter::Group* Invalid mode : " << mode << endl;
-  cout << " Default value mode=1 will be used." << endl;
-  mode=1;
- }
-
- if (fClusters)
- {
-  delete fClusters;
-  fClusters=0;
- }
-
- if (!fMatrix) LoadMatrix();
-
- if (!fMatrix) return;
- Int_t nsignals=GetNsignals();
- if (nsignals > 0) // Only continue if there are fired modules
- {
-  if (GetNclusters() > 0) Ungroup(); // Restore unclustered situation if needed
-  // Order the modules with decreasing signal
-  if (mode==1) SortM(); 
-  if (mode==2) SortA();
-
-  Int_t nord=0;
-  if (fOrdered) nord=fOrdered->GetEntries();
-  // Clustering of modules. Start with the highest signal.
-  fClusters=new TObjArray();
-  fClusters->SetOwner();
-  Int_t row=0;
-  Int_t col=0;
-  AliCalcluster* c=0;
-  for (Int_t i=0; i<nord; i++)
-  {
-   AliCalmodule* m=(AliCalmodule*)fOrdered->At(i);
-   if (!m) continue;
-
-   row=m->GetRow();    // row number of cluster center
-   col=m->GetColumn(); // column number of cluster center
-
-   // only use modules not yet used in a cluster
-   if (m->GetClusteredSignal() > 0.)
-   {
-    Int_t edge=GetEdgeValue(row,col);
-    c=new AliCalcluster();
-    if (!edge) c->Start(*m);   // module to start the cluster if not on edge
-    if (c->GetNmodules() > 0)  // cluster started successfully (no edge)
-    {
-     fClusters->Add(c);
-     AddRing(row,col,n); // add signals of n rings around the center
-    }
-    else
-    {
-     if (c) delete c;
-     c=0;
-    }
-   }
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SortM()
-{
-// Order the modules with decreasing signal by looping over the (row,col) grid
-// of the matrix.
-// Modules which were declared as "Dead" will be rejected.
-// The gain etc... corrected module signals will be used in the ordering process.
-//
-// Note : This method may become slow for large, very finely granulated calorimeters.
-//
-// Very specific case :
-// ====================
-// In case of various overlapping showers of which the central modules have
-// EXACTLY the same signal this ordering procedure may have the following
-// advantages and disadvantages.
-//
-// Advantages :
-// ------------
-// * In case of multi-overlapping showers, the central shower will NOT
-//   be "eaten-up" from both sides, resulting in a slightly more accurate
-//   cluster signal.
-// * This method produces re-producable results, irrespective of the filling
-//   order of the matrix modules.
-//
-// Disadvantages :
-// ---------------
-// * In case of a very high occupancy, there might be a slight effect on the
-//   cluster signals depending on the geometrical location in the detector matrix.
-
- if (fOrdered)
- {
-  delete fOrdered;
-  fOrdered=0;
- }
-
- Int_t nrows=fMatrix->GetMaxRow();
- Int_t ncols=fMatrix->GetMaxColumn();
-
- Float_t signal=0.;
- Int_t nord=0;
- for (Int_t irow=1; irow<=nrows; irow++) // loop over all modules of the matrix
- {
-  for (Int_t icol=1; icol<=ncols; icol++)
-  {
-   AliCalmodule* m=(AliCalmodule*)fMatrix->GetObject(irow,icol);
-   if (!m) continue;
-
-   signal=m->GetSignal(1,1);   // get the gain etc... corrected signal
-   if (signal <= 0.) continue; // only take alive modules with a signal
-   if (nord == 0) // store the first module with a signal at the first ordered position
-   {
-    if (!fOrdered)
-    {
-     Int_t nhits=GetNhits();
-     fOrdered=new TObjArray(nhits);
-    }
-    nord++;
-    fOrdered->AddAt(m,nord-1);
-    continue;
-   }
-   for (Int_t j=0; j<=nord; j++) // put module in the right ordered position
-   {
-    if (j == nord) // module has smallest signal seen so far
-    {
-     nord++;
-     fOrdered->AddAt(m,j); // add module at the end
-     break; // go for next matrix module
-    }
-    if (signal < ((AliCalmodule*)fOrdered->At(j))->GetSignal(1,1)) continue;
-    nord++;
-    for (Int_t k=nord-1; k>j; k--) // create empty position
-    {
-     fOrdered->AddAt(fOrdered->At(k-1),k);
-    }
-    fOrdered->AddAt(m,j); // put module at empty position
-    break; // go for next matrix module
-   }
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SortA()
-{
-// Order the modules with decreasing signal by looping over the linear array
-// of fired modules.
-// Modules which were declared as "Dead" will be rejected.
-// The gain etc... corrected module signals will be used in the ordering process.
-//
-// Note : This method is rather fast even for large, very finely granulated calorimeters.
-//
-// Very specific case :
-// ====================
-// In case of various overlapping showers of which the central modules have
-// EXACTLY the same signal this ordering procedure may have the following
-// advantages and disadvantages.
-//
-// Advantages :
-// ------------
-// * Even in case of a very high occupancy, the resulting cluster signals
-//   will in general NOT depend on the geometrical location in the detector matrix.
-//
-// Disadvantages :
-// ---------------
-// * In case of multi-overlapping showers, the central shower might be
-//   "eaten-up" from both sides, resulting in a slightly too low value
-//   of the resulting cluster signal.
-// * This method might produce results depending on the filling
-//   order of the matrix modules.
-
- SortHits();
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::AddRing(Int_t row, Int_t col, Int_t n)
-{
-// Add module signals of 1 ring around (row,col) to current cluster.
-// The gain etc... corrected module signals will be used in this process.
-// The parameter n denotes the maximum number of rings around cluster center.
-// Note : This function is used recursively.
-
- if (!fMatrix) return;
-
- Int_t nrows=fMatrix->GetMaxRow();
- Int_t ncols=fMatrix->GetMaxColumn();
- if (n >= 1) // Check if any rings left for recursive calls
- {
-  Float_t signal=GetSignal(row,col,1); // Gain etc... corrected signal of (row,col) module
-  Int_t lrow=row-1; if (lrow < 1) lrow=1;         // row lowerbound for ring
-  Int_t urow=row+1; if (urow > nrows) urow=nrows; // row upperbound for ring
-  Int_t lcol=col-1; if (lcol < 1) lcol=1;         // col lowerbound for ring
-  Int_t ucol=col+1; if (ucol > ncols) ucol=ncols; // row upperbound for ring
-  for (Int_t i=lrow; i<=urow; i++)
-  {
-   for (Int_t j=lcol; j<=ucol; j++)
-   {
-    // add module(i,j) to cluster if the signal <= signal(row,col)
-    if (GetSignal(i,j,1) <= signal)
-    {
-     AliCalmodule* m=(AliCalmodule*)fMatrix->GetObject(i,j);
-     if (m) ((AliCalcluster*)fClusters->At(GetNclusters()-1))->Add(*m);
-    }
-    AddRing(i,j,n-1); // Go for ring of modules around this (i,j) one
-   }
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNclusters() const
-{
-// Provide the number of clusters
- Int_t nclu=0;
- if (fClusters) nclu=fClusters->GetEntries();
- return nclu;
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalcluster* AliCalorimeter::GetCluster(Int_t j) const
-{
-// Provide cluster number j
-// Note : j=1 denotes the first cluster
-
- if (!fClusters) return 0;
-
- if ((j >= 1) && (j <= GetNclusters()))
- {
-  return (AliCalcluster*)fClusters->At(j-1);
- }
- else
- {
-  cout << " *AliCalorimeter::GetCluster* cluster number : " << j
-       << " out of range ==> 0 returned." << endl;
-  return 0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalmodule* AliCalorimeter::GetModule(Int_t j) const
-{
-// Provide 'fired' module number j
-// Note : j=1 denotes the first 'fired' module
-
- AliCalmodule* m=(AliCalmodule*)GetHit(j);
- return m;
-}
-///////////////////////////////////////////////////////////////////////////
-AliCalmodule* AliCalorimeter::GetModule(Int_t row,Int_t col)
-{
-// Provide access to module (row,col).
-// Note : first module is at (1,1).
-
- AliCalmodule* m=0;
- if (!fMatrix) LoadMatrix();
- if (fMatrix) m=(AliCalmodule*)fMatrix->GetObject(row,col);
- return m;
-}
-///////////////////////////////////////////////////////////////////////////
-TH2F* AliCalorimeter::DrawModules(Float_t thresh,Int_t mode)
-{
-// Provide a lego plot of the module signals.
-// The input parameter mode (default mode=0) has the same meaning as
-// specified in the memberfunction GetSignal(row,col,mode).
-// Only modules with a (corrected) signal value above the threshold
-// (default thresh=0) will be displayed.
-
- Int_t nrows=fNrows;
- Int_t ncols=fNcolumns;
-
- if (!fMatrix) LoadMatrix();
-
- if (fMatrix && !nrows && !ncols)
- {
-  nrows=fMatrix->GetMaxRow();
-  ncols=fMatrix->GetMaxColumn();
- }
- if (fHmodules)
- {
-  fHmodules->Reset();
- }
- else
- {
-  fHmodules=new TH2F("fHmodules","Module signals",
-            ncols,0.5,float(ncols)+0.5,nrows,0.5,float(nrows)+0.5);
-  fHmodules->SetDirectory(0); // Suppress global character of histo pointer
- }
- Int_t nmods=GetNsignals();
-
- Int_t row,col;
- Float_t signal;
- Int_t dead;
- for (Int_t i=1; i<=nmods; i++)
- {
-  AliCalmodule* m=(AliCalmodule*)fMatrix->GetObject(i);
-  if (m)
-  {
-   row=m->GetRow();
-   col=m->GetColumn();
-   dead=m->GetDeadValue();
-   signal=0;
-   if (!dead) signal=GetSignal(row,col,mode);
-   if (signal>thresh) fHmodules->Fill(float(col),float(row),signal);
-  }
- }
- fHmodules->Draw("lego");
- return fHmodules;
-}
-///////////////////////////////////////////////////////////////////////////
-TH2F* AliCalorimeter::DrawClusters(Float_t thresh)
-{
-// Provide a lego plot of the cluster signals.
-// Only clusters with a signal value above the threshold (default thresh=0)
-// will be displayed.
-
- Int_t nrows=fNrows;
- Int_t ncols=fNcolumns;
-
- if (!fMatrix) LoadMatrix();
-
- if (fMatrix && !nrows && !ncols)
- {
-  nrows=fMatrix->GetMaxRow();
-  ncols=fMatrix->GetMaxColumn();
- }
- if (fHclusters)
- {
-  fHclusters->Reset();
- }
- else
- {
-  fHclusters=new TH2F("fHclusters","Cluster signals",
-            ncols,0.5,float(ncols)+0.5,nrows,0.5,float(nrows)+0.5);
-  fHclusters->SetDirectory(0); // Suppress global character of histo pointer
- }
- AliCalcluster* c;
- Int_t row,col;
- Float_t signal;
- for (Int_t i=0; i<GetNclusters(); i++)
- {
-  c=(AliCalcluster*)fClusters->At(i);
-  if (c)
-  {
-   row=c->GetRow();
-   col=c->GetColumn();
-   signal=c->GetSignal();
-   if (signal>thresh) fHclusters->Fill(float(col),float(row),signal);
-  }
- }
- fHclusters->Draw("lego");
- return fHclusters;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::Ungroup()
-{
-// Set the module signals back to the non-clustered situation
-
- if (!fMatrix) LoadMatrix();
-
- if (!fMatrix) return;
- Int_t nsig=GetNsignals();
-
- Float_t signal=0;
- for (Int_t j=1; j<=nsig; j++)
- {
-  AliCalmodule* m=(AliCalmodule*)fMatrix->GetObject(j);
-  if (m)
-  {
-   signal=m->GetSignal();
-   m->SetClusteredSignal(signal);
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::AddVetoSignal(AliSignal& s)
-{
-// Associate an (extrapolated) AliSignal as veto to the calorimeter.
- if (!fVetos)
- {
-  fVetos=new TObjArray();
-  fVetos->SetOwner();
- } 
-
- AliSignal* sx=new AliSignal(s);
-
- fVetos->Add(sx);
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNvetos() const
-{
-// Provide the number of veto signals associated to the calorimeter.
- Int_t nvetos=0;
- if (fVetos) nvetos=fVetos->GetEntries();
- return nvetos;
-}
-///////////////////////////////////////////////////////////////////////////
-AliSignal* AliCalorimeter::GetVetoSignal(Int_t i) const
-{
-// Provide access to the i-th veto signal of this calorimeter
-// Note : The first hit corresponds to i=1
-
- if (i>0 && i<=GetNvetos())
- {
-  return (AliSignal*)fVetos->At(i-1);
- }
- else
- {
-  cout << " *AliCalorimeter::GetVetoSignal* Signal number " << i
-       << " out of range ==> 0 returned." << endl;
-  return 0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SetMatrixSwapMode(Int_t swap)
-{
-// Set the swap mode for the module and position matrices.
-// At invokation of this memberfunction the default argument is swap=1.
-// For further details see the documentation of AliObjMatrix.
- if (swap==0 || swap==1)
- {
-  fSwap=swap;
- }
- else
- {
-  cout << " *AliCalorimeter::SetMatrixSwapMode* Invalid argument : swap = " << swap << endl; 
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetMatrixSwapMode() const
-{
-// Provide the swap mode for the module and position matrices.
-// For further details see the documentation of AliObjMatrix.
- return fSwap;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::LoadMatrix()
-{
-// Load the matrix lookup table of module pointers from the linear hit array.
- Int_t nhits=GetNhits();
- if (!nhits) return;
-
- fMatrix=new AliObjMatrix();
- fMatrix->SetSwapMode(fSwap);
-
- Int_t row=0;
- Int_t col=0;
- for (Int_t i=1; i<=nhits; i++)
- {
-  AliCalmodule* m=(AliCalmodule*)GetHit(i);
-  if (m)
-  {
-   row=m->GetRow();
-   col=m->GetColumn();
-   fMatrix->EnterObject(row,col,m);
-  }
- }
-}
-///////////////////////////////////////////////////////////////////////////
-TObject* AliCalorimeter::Clone(const char* name) const
-{
-// Make a deep copy of the current object and provide the pointer to the copy.
-// This memberfunction enables automatic creation of new objects of the
-// correct type depending on the object type, a feature which may be very useful
-// for containers like AliEvent when adding objects in case the
-// container owns the objects.
-
- AliCalorimeter* cal=new AliCalorimeter(*this);
- if (name)
- {
-  if (strlen(name)) cal->SetName(name);
- } 
- return cal;
-}
-///////////////////////////////////////////////////////////////////////////
diff --git a/RALICE/AliCalorimeter.h b/RALICE/AliCalorimeter.h
deleted file mode 100644 (file)
index b69acee..0000000
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef ALICALORIMETER_H
-#define ALICALORIMETER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-// $Id$
-
-#include <math.h>
-#include "TNamed.h"
-#include "TObjArray.h"
-#include "TH2.h"
-#include "TString.h"
-
-#include "AliDevice.h"
-#include "AliObjMatrix.h"
-#include "AliCalmodule.h"
-#include "AliCalcluster.h"
-#include "AliPositionObj.h"
-#include "AliAttribObj.h"
-class AliCalorimeter : public AliDevice
-{
- public:
-  AliCalorimeter();                                      // Default constructor
-  AliCalorimeter(Int_t nrow,Int_t ncol);                 // Create a calorimeter matrix
-  virtual ~AliCalorimeter();                             // Destructor
-  AliCalorimeter(const AliCalorimeter& c);               // Copy constructor
-  virtual TObject* Clone(const char* name="") const;     // Make a deep copy and provide pointer of the copy
-  Int_t GetNrows();                                      // Return number of rows of the matrix
-  Int_t GetNcolumns();                                   // Return number of columns of the matrix
-  using AliDevice::SetSignal;
-  void SetSignal(Int_t row,Int_t col,Float_t s);         // Set signal for a certain module
-  using AliDevice::AddSignal;
-  void AddSignal(Int_t row,Int_t col,Float_t s);         // Add signal to a certain module
-  void AddSignal(AliCalmodule* m);                       // Add module signal to current calorimeter
-  void Reset(Int_t row,Int_t col);                       // Reset signal for a certain module
-  virtual void Reset(Int_t mode=0);                      // Reset the complete calorimeter
-  using AliDevice::GetSignal;
-  virtual Float_t GetSignal(Int_t row,Int_t col=0) { return GetSignal(row,col,0); }
-  Float_t GetSignal(Int_t row,Int_t col,Int_t mode);     // Provide signal of a certain module
-  Int_t GetNsignals() const;                             // Return number of modules with a signal
-  void Group(Int_t n=1,Int_t mode=1);                    // Group modules into clusters (n rings)
-  Int_t GetNclusters() const;                            // Return number of clusters
-  Float_t GetClusteredSignal(Int_t row,Int_t col);       // Provide module signal after clustering
-  AliCalcluster* GetCluster(Int_t j) const;              // Access to cluster number j
-  AliCalmodule* GetModule(Int_t j) const;                // Access to 'fired' module number j
-  AliCalmodule* GetModule(Int_t row,Int_t col);          // Access to module at (row,col)
-  using AliDevice::SetEdgeOn;
-  void SetEdgeOn(Int_t row,Int_t col);                   // Indicate module as 'edge module'
-  using AliDevice::SetEdgeOff;
-  void SetEdgeOff(Int_t row,Int_t col);                  // Indicate module as 'non-edge module'
-  using AliDevice::GetEdgeValue;
-  Int_t GetEdgeValue(Int_t row,Int_t col);               // Provide the edge flag of a module
-  using AliDevice::SetDead;
-  void SetDead(Int_t row,Int_t col);                     // Indicate module as 'dead module'
-  using AliDevice::SetAlive;
-  void SetAlive(Int_t row,Int_t col);                    // Indicate module as 'active module'
-  using AliDevice::GetDeadValue;
-  Int_t GetDeadValue(Int_t row,Int_t col);               // Provide the dead flag of a module
-  using AliDevice::SetGain;
-  void SetGain(Int_t row,Int_t col,Float_t g);           // Set the gain value for a module
-  using AliDevice::SetOffset;
-  void SetOffset(Int_t row,Int_t col,Float_t o);         // Set the offset value for a module
-  using AliDevice::GetGain;
-  Float_t GetGain(Int_t row,Int_t col);                  // Provide the gain value of a module
-  using AliDevice::GetGainFlag;
-  Int_t GetGainFlag(Int_t row,Int_t col);                // Provide the gain flag value of a module
-  using AliDevice::GetOffset;
-  Float_t GetOffset(Int_t row,Int_t col);                // Provide the offset value of a module
-  using AliDevice::GetOffsetFlag;
-  Int_t GetOffsetFlag(Int_t row,Int_t col);              // Provide the offset flag value of a module
-  using AliDevice::SetPosition;
-  void SetPosition(Int_t row,Int_t col,Float_t* r,TString f); // Set module position
-  void SetPosition(Int_t row,Int_t col,Ali3Vector& r);   // Set module position
-  using AliDevice::GetPosition;
-  void GetPosition(Int_t row,Int_t col,Float_t* r,TString f); // Return module position
-  AliPosition* GetPosition(Int_t row,Int_t col);         // Access to module position
-  TH2F* DrawModules(Float_t thresh=0.,Int_t mode=0);     // Lego plot of module (corr.) signals above threshold
-  TH2F* DrawClusters(Float_t thresh=0.);                 // Lego plot of cluster signals above threshold
-  void AddVetoSignal(AliSignal& s);                      // Associate (extrapolated) signal
-  void AddVetoSignal(AliSignal* s) { AddVetoSignal(*s); }
-  AliSignal* GetVetoSignal(Int_t j) const;               // Access to veto signal number j
-  Int_t GetNvetos() const;                               // Provide the number of veto signals
-  void SetMatrixSwapMode(Int_t swap=1);                  // Set the swapmode for the storage of the matrices
-  Int_t GetMatrixSwapMode() const;                       // Provide the swapmode for the storage of the matrices
- protected:
-  Int_t fNrows;                              // The number of rows
-  Int_t fNcolumns;                           // The number of columns
-  AliObjMatrix* fMatrix;                     //! Matrix lookup table of module pointers
-  Int_t fSwap;                               // The swapmode for the module and position matrices
-  void SortM();                              // Order the modules with decreasing signal (matrix search)
-  void SortA();                              // Order the modules with decreasing signal (fired array search)
-  TObjArray* fClusters;                      // The array of clusters
-  void AddRing(Int_t row,Int_t col,Int_t n); // add signals of n rings around cluster center
-  void Ungroup();                            // Restore module matrix as before clustering
-  TH2F* fHmodules;                           //! The module 2-D histogram for event display
-  TH2F* fHclusters;                          //! The cluster 2-D histogram for event display
-  TObjArray* fVetos;                         // The array of associated (extrapolated) veto signals
-  TObjArray* fAttributes;                    //! Matrix dbase with module attributes (e.g. gain, offset etc...)
-  AliObjMatrix* fPositions;                  //! Matrix dbase of module position pointers
-  void LoadMatrix();                         // Loading of matrix lookup table from the linear hit array
- ClassDef(AliCalorimeter,11) // Description of a modular calorimeter system.
-};
-#endif
diff --git a/RALICE/AliCollider.cxx b/RALICE/AliCollider.cxx
deleted file mode 100644 (file)
index 224d060..0000000
+++ /dev/null
@@ -1,1234 +0,0 @@
-/**************************************************************************
- * 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: AliCollider.cxx,v 1.12 2004/05/04 15:33:04 nick Exp $
-
-///////////////////////////////////////////////////////////////////////////
-// Class AliCollider
-// Pythia based universal physics event generator.
-// This class is derived from TPythia6 and has some extensions to
-// support also generation of nucleus-nucleus interactions and to allow
-// investigation of the effect of detector resolving power.
-// Furthermore, the produced event information is provided in a format
-// using the AliEvent structure.
-// For the produced AliTrack objects, the particle ID code is set to the
-// Pythia KF value, which is compatible with the PDG identifier.
-// This will allow a direct analysis of the produced data using the
-// Ralice physics analysis tools.
-//
-// For further details concerning the produced output structure,
-// see the docs of the memberfunctions SetVertexMode and SetResolution.
-//
-// Example job of minimum biased Pb+Pb interactions :
-// --------------------------------------------------
-// {
-//  gSystem->Load("libEG");
-//  gSystem->Load("libEGPythia6");
-//  gSystem->Load("ralice");
-//
-//  AliCollider* gen=new AliCollider();
-//
-//  gen->SetOutputFile("test.root");
-//  gen->SetVertexMode(3);    
-//  gen->SetResolution(1e-6); // 1 micron vertex resolution
-//
-//  gen->SetRunNumber(1);
-//
-//  Int_t zp=82;
-//  Int_t ap=208;
-//  Int_t zt=82;
-//  Int_t at=208;
-//
-//  gen->Init("fixt",zp,ap,zt,at,158);
-//
-//  gen->SetTitle("SPS Pb-Pb collision at 158A GeV/c beam energy");
-//
-//  Int_t nevents=5;
-//
-//  AliRandom rndm;
-//  Float_t* rans=new Float_t[nevents];
-//  rndm.Uniform(rans,nevents,2,ap+at);
-//  Int_t npart;
-//  for (Int_t i=0; i<nevents; i++)
-//  {
-//   npart=rans[i];
-//   gen->MakeEvent(npart);
-//
-//   AliEvent* evt=gen->GetEvent();
-//  
-//   evt->List();
-//  }
-//
-//  gen->EndRun();
-// }
-//
-//
-// Example job of a cosmic nu+p atmospheric interaction.
-// -----------------------------------------------------
-// {
-//  gSystem->Load("libEG");
-//  gSystem->Load("libEGPythia6");
-//  gSystem->Load("ralice");
-//
-//  AliCollider* gen=new AliCollider();
-//
-//  gen->SetOutputFile("test.root");
-//
-//  gen->SetRunNumber(1);
-//
-//  gen->Init("fixt","nu_mu","p",1e11);
-//
-//  gen->SetTitle("Atmospheric nu_mu-p interaction at 1e20 eV");
-//
-//  Int_t nevents=10;
-//
-//  for (Int_t i=0; i<nevents; i++)
-//  {
-//   gen->MakeEvent(0,1);
-//
-//   AliEvent* evt=gen->GetEvent();
-//  
-//   evt->Data();
-//  }
-//
-//  gen->EndRun();
-// }
-//
-//
-//--- Author: Nick van Eijndhoven 22-nov-2002 Utrecht University
-//- Modified: NvE $Date: 2004/05/04 15:33:04 $ Utrecht University
-///////////////////////////////////////////////////////////////////////////
-
-#include <cstdlib>
-#include "AliCollider.h"
-#include "Riostream.h"
-ClassImp(AliCollider) // Class implementation to enable ROOT I/O
-AliCollider::AliCollider() : TPythia6()
-{
-// Default constructor.
-// All variables initialised to default values.
-//
-// Some Pythia default MC parameters are automatically modified to provide
-// more suitable running conditions for soft processes in view of
-// nucleus-nucleus interactions and astrophysical processes.
-// The user may initialise the generator with all the default Pythia
-// parameters and obtain full user control to modify the settings by means
-// of the SetUserControl memberfunction.
-//
-// Refer to the SetElastic memberfunction for the inclusion of elastic
-// and diffractive processes.
-// By default these processes are not included.
-
- fVertexmode=0;    // No vertex structure creation
- fResolution=1e-7; // Standard resolution is 0.1 micron
- fRunnum=0;
- fEventnum=0;
- fPrintfreq=1;
- fUserctrl=0; // Automatic optimisation of some MC parameters 
- fElastic=0;  // No elastic and diffractive processes
-
- fEvent=0;
-
- fSpecpmin=0;
-
- fFrame=new char[5];
- strcpy(fFrame,"none");
- fWin=0;
-
- fNucl=0;
- fZproj=0;
- fAproj=0;
- fZtarg=0;
- fAtarg=0;
- fFracpp=0;
- fFracnp=0;
- fFracpn=0;
- fFracnn=0;
-
- fOutFile=0;
- fOutTree=0;
-
- fSelections=0;
- fSelect=0;
-
- TString s=GetName();
- s+=" (AliCollider)";
- SetName(s.Data());
-}
-///////////////////////////////////////////////////////////////////////////
-AliCollider::~AliCollider()
-{
-// Default destructor
- if (fEvent)
- {
-  delete fEvent;
-  fEvent=0;
- }
- if (fOutFile)
- {
-  delete fOutFile;
-  fOutFile=0;
- }
- if (fOutTree)
- {
-  delete fOutTree;
-  fOutTree=0;
- }
- if (fSelections)
- {
-  delete fSelections;
-  fSelections=0;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetOutputFile(TString s)
-{
-// Create the output file containing all the data in ROOT output format.
- if (fOutFile)
- {
-  delete fOutFile;
-  fOutFile=0;
- }
- fOutFile=new TFile(s.Data(),"RECREATE","AliCollider data");
-
- if (fOutTree)
- {
-  delete fOutTree;
-  fOutTree=0;
- }
- fOutTree=new TTree("T","AliCollider event data");
-
- Int_t bsize=32000;
- Int_t split=0;
- fOutTree->Branch("Events","AliEvent",&fEvent,bsize,split);
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetVertexMode(Int_t mode)
-{
-// Set the mode of the vertex structure creation.
-//
-// By default all generated tracks will only appear in the AliEvent
-// structure without any primary (and secondary) vertex structure.
-// The user can build the vertex structure if he/she wants by means
-// of the beginpoint location of each AliTrack.
-//
-// However, one can also let AliCollider automatically create
-// the primary (and secondary) vertex structure(s).
-// In this case the primary vertex is given Id=1 and all sec. vertices
-// are given Id's 2,3,4,....
-// All vertices are created as standalone entities in the AliEvent structure
-// without any linking between the various vertices.
-// For this automated process, the user-selected resolution
-// (see SetResolution) is used to decide whether or not certain vertex
-// locations can be resolved.
-// In case no vertex creation is selected (i.e. the default mode=0),
-// the value of the resolution is totally irrelevant.
-//
-// The user can also let AliCollider automatically connect the sec. vertices
-// to the primary vertex (i.e. mode=3). This process will also automatically
-// generate the tracks connecting the vertices.
-// Note that the result of the mode=3 operation may be very sensitive to
-// the resolution parameter. Therefore, no attempt is made to distinguish
-// between secondary, tertiary etc... vertices. All sec. vertices are
-// linked to the primary one.
-//  
-// Irrespective of the selected mode, all generated tracks can be obtained
-// directly from the AliEvent structure.
-// In case (sec.) vertex creation is selected, all generated vertices can
-// also be obtained directly from the AliEvent structure. 
-// These (sec.) vertices contain only the corresponding pointers to the various
-// tracks which are stored in the AliEvent structure.
-//
-// Overview of vertex creation modes :
-// -----------------------------------
-// mode = 0 ==> No vertex structure will be created
-//        1 ==> Only primary vertex structure will be created
-//        2 ==> Unconnected primary and secondary vertices will be created
-//        3 ==> Primary and secondary vertices will be created where all the
-//              sec. vertices will be connected to the primary vertex.
-//              Also the vertex connecting tracks will be automatically
-//              generated. 
-//
- if (mode<0 || mode >3)
- {
-  cout << " *AliCollider::SetVertexMode* Invalid argument mode : " << mode << endl;
-  fVertexmode=0;
- }
- else
- {
-  fVertexmode=mode;
- }
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCollider::GetVertexMode() const
-{
-// Provide the current mode for vertex structure creation.
- return fVertexmode;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetResolution(Double_t res)
-{
-// Set the resolution (in meter) for resolving (sec.) vertices.
-// By default this resolution is set to 0.1 micron.
-// Note : In case no vertex creation has been selected, the value of
-//        the resolution is totally irrelevant.
- fResolution=fabs(res);
-}
-///////////////////////////////////////////////////////////////////////////
-Double_t AliCollider::GetResolution() const
-{
-// Provide the current resolution (in meter) for resolving (sec.) vertices.
- return fResolution;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetRunNumber(Int_t run)
-{
-// Set the user defined run number.
-// By default the run number is set to 0.
- fRunnum=run;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCollider::GetRunNumber() const
-{
-// Provide the user defined run number.
- return fRunnum;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetPrintFreq(Int_t n)
-{
-// Set the print frequency for every 'n' events.
-// By default the printfrequency is set to 1 (i.e. every event).
- fPrintfreq=n;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCollider::GetPrintFreq() const
-{
-// Provide the user selected print frequency.
- return fPrintfreq;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetUserControl(Int_t flag)
-{
-// Set the user control flag w.r.t. disabling automatic optimisation
-// of some Pythia default MC parameters for soft interactions in view of
-// nucleus-nucleus collisions and astrophysical processes.
-// Flag = 0 : Limited user control (automatic optimisation enabled)
-//        1 : Full user control (automatic optimisation disabled)
-// By default the user control is set to 0 (i.e. automatic optimisation).
-// See the Init() memberfunctions for further details w.r.t. the optimisations.
- fUserctrl=flag;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCollider::GetUserControl() const
-{
-// Provide the value of the user control flag.
- return fUserctrl;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::SetElastic(Int_t flag)
-{
-// Set the flag w.r.t. inclusion of elastic and diffractive processes.
-// By default these processes are not included.
-// Flag = 0 : Do not include elastic and diffractive processes
-//        1 : Elastic and diffractive processes will be included
- fElastic=flag;
-}
-///////////////////////////////////////////////////////////////////////////
-Int_t AliCollider::GetElastic() const
-{
-// Provide the value of the control flag for elastic and diffractive processes.
- return fElastic;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::Init(char* frame,char* beam,char* target,Float_t win)
-{
-// Initialisation of the underlying Pythia generator package.
-// The event number is reset to 0.
-// This routine just invokes TPythia6::Initialize(...) and the arguments
-// have the corresponding meaning.
-// Some Pythia default MC parameters are automatically modified to provide
-// more suitable running conditions for soft processes in view of
-// astrophysical processes.
-// The optimisations consist of : 
-// * Usage of real photons for photon beams or targets
-// * Minimum CMS energy of 3 GeV for the event
-// * Activation of the default K factor values
-//   with separate settings for ordinary and color annihilation graphs.
-// The user may initialise the generator with all the default Pythia
-// parameters and obtain full user control to modify the settings by means
-// of invoking the SetUserControl memberfunction before this initialisation.
-// Note that the inclusion of elastic and diffractive processes is controlled
-// by invokation of the SetElastic memberfunction before this initialisation,
-// irrespective of the UserControl selection.
-
- if (!fUserctrl) // Optimisation of some MC parameters
- {
-  SetMSTP(14,10); // Real photons for photon beams or targets
-  SetPARP(2,3.);  // Minimum CMS energy for the event
-  SetMSTP(33,2);  // Activate K factor. Separate for ordinary and color annih. graphs
- }
-
- if (fElastic) SetMSEL(2); // Include low-Pt, elastic and diffractive events
-
- fEventnum=0;
- fNucl=0;
- fFrame=frame;
- fWin=win;
- Initialize(frame,beam,target,win);
-
- cout << endl;
- cout << " *AliCollider::Init* Standard Pythia initialisation." << endl;
- cout << " Beam particle : " << beam << " Target particle : " << target
-      << " Frame = " << frame << " Energy = " << win
-      << endl;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::Init(char* frame,Int_t zp,Int_t ap,Int_t zt,Int_t at,Float_t win)
-{
-// Initialisation of the underlying Pythia generator package for the generation
-// of nucleus-nucleus interactions.
-// The event number is reset to 0.
-// In addition to the Pythia standard arguments 'frame' and 'win', the user
-// can specify here (Z,A) values of the projectile and target nuclei.
-//
-// Note : The 'win' value denotes either the cms energy per nucleon-nucleon collision
-//        (i.e. frame="cms") or the momentum per nucleon in all other cases.
-//
-// Some Pythia default MC parameters are automatically modified to provide
-// more suitable running conditions for soft processes in view of
-// nucleus-nucleus interactions and astrophysical processes.
-// The optimisations consist of : 
-// * Minimum CMS energy of 3 GeV for the event
-// * Activation of the default K factor values
-//   with separate settings for ordinary and color annihilation graphs.
-// The user may initialise the generator with all the default Pythia
-// parameters and obtain full user control to modify the settings by means
-// of invoking the SetUserControl memberfunction before this initialisation.
-// Note that the inclusion of elastic and diffractive processes is controlled
-// by invokation of the SetElastic memberfunction before this initialisation,
-// irrespective of the UserControl selection.
-
- if (!fUserctrl) // Optimisation of some MC parameters
- {
-  SetPARP(2,3.);  // Minimum CMS energy for the event
-  SetMSTP(33,2);  // Activate K factor. Separate for ordinary and color annih. graphs
- }
-
- if (fElastic) SetMSEL(2); // Include low-Pt, elastic and diffractive events
-
- fEventnum=0;
- fNucl=1;
- fFrame=frame;
- fWin=win;
- fZproj=0;
- fAproj=0;
- fZtarg=0;
- fAtarg=0;
- fFracpp=0;
- fFracnp=0;
- fFracpn=0;
- fFracnn=0;
-
- if (ap<1 || at<1 || zp>ap || zt>at)
- {
-  cout << endl;
-  cout << " *AliCollider::Init* Invalid input value(s). Zproj = " << zp
-       << " Aproj = " << ap << " Ztarg = " << zt << " Atarg = " << at << endl;
-  return;
- }
-
- fZproj=zp;
- fAproj=ap;
- fZtarg=zt;
- fAtarg=at;
-
- cout << endl;
- cout << " *AliCollider::Init* Nucleus-Nucleus generator initialisation." << endl;
- cout << " Zproj = " << zp << " Aproj = " << ap << " Ztarg = " << zt << " Atarg = " << at
-      << " Frame = " << frame << " Energy = " << win
-      << endl;
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::GetFractions(Float_t zp,Float_t ap,Float_t zt,Float_t at)
-{
-// Determine the fractions for the various N-N collision processes.
-// The various processes are : p+p, n+p, p+n and n+n.
- if (zp<0) zp=0;
- if (zt<0) zt=0;
-
- fFracpp=0;
- fFracnp=0;
- fFracpn=0;
- fFracnn=0;
-
- if (ap>0 && at>0)
- {
-  fFracpp=(zp/ap)*(zt/at);
-  fFracnp=(1.-zp/ap)*(zt/at);
-  fFracpn=(zp/ap)*(1.-zt/at);
-  fFracnn=(1.-zp/ap)*(1.-zt/at);
- }
-}
-///////////////////////////////////////////////////////////////////////////
-void AliCollider::MakeEvent(Int_t npt,Int_t mlist,Int_t medit)
-{
-// Generate one event.
-// In case of a nucleus-nucleus interaction, the argument 'npt' denotes
-// the number of participant nucleons.
-// Normally also the spectator tracks will be stored into the event structure.
-// The spectator tracks have a negative user Id to distinguish them from the
-// ordinary generated tracks.
-// In case the user has selected the creation of vertex structures, the spectator
-// tracks will be linked to the primary vertex.
-// However, specification of npt<0 will suppress the storage of spectator tracks.
-// In the latter case abs(npt) will be taken as the number of participants.  
-// In case of a standard Pythia run for 'elementary' particle interactions,
-// the value of npt is totally irrelevant.
-//
-// The argument 'mlist' denotes the list mode used for Pylist().
-// Note : mlist<0 suppresses the invokation of Pylist().
-// By default, no listing is produced (i.e. mlist=-1).
-//
-// The argument 'medit' denotes the edit mode used for Pyedit().
-// Note : medit<0 suppresses the invokation of Pyedit().
-// By default, only 'stable' final particles are kept (i.e. medit=1). 
-//
-// In the case of a standard Pythia run concerning 'elementary' particle
-// interactions, the projectile and target particle ID's for the created
-// event structure are set to the corresponding Pythia KF codes.
-// All the A and Z values are in that case set to zero.
-// In case of a nucleus-nucleus interaction, the proper A and Z values for 
-// the projectile and target particles are set in the event structure.
-// However, in this case both particle ID's are set to zero.
-//
-// Note : Only in case an event passed the selection criteria as specified
-//        via SelectEvent(), the event will appear on the output file.
-
- fEventnum++; 
-
- Int_t specmode=1;
- if (npt<0)
- {
-  specmode=0;
-  npt=abs(npt);
- }
-
- // Counters for the various (proj,targ) combinations : p+p, n+p, p+n and n+n
- Int_t ncols[4]={0,0,0,0};
-
- Int_t zp=0;
- Int_t ap=0;
- Int_t zt=0;
- Int_t at=0;
-
- Int_t ncol=1;
- if (fNucl)
- {
-  if (npt<1 || npt>(fAproj+fAtarg))
-  {
-   cout << " *AliCollider::MakeEvent* Invalid input value. npt = " << npt
-        << " Aproj = " << fAproj << " Atarg = " << fAtarg << endl;
-   return;
-  }
-
-  // Determine the number of nucleon-nucleon collisions
-  ncol=npt/2;
-  if (npt%2 && fRan.Uniform()>0.5) ncol+=1;
-
-  // Determine the number of the various types of N+N interactions
-  zp=fZproj;
-  ap=fAproj;
-  zt=fZtarg;
-  at=fAtarg;
-  Int_t maxa=2; // Indicator whether proj (1) or target (2) has maximal A left
-  if (ap>at) maxa=1;
-  Float_t* rans=new Float_t[ncol];
-  fRan.Uniform(rans,ncol);
-  Float_t rndm=0;
-  for (Int_t i=0; i<ncol; i++)
-  {
-   GetFractions(zp,ap,zt,at);
-   rndm=rans[i];
-   if (rndm<=fFracpp) // p+p interaction
-   {
-    ncols[0]++;
-    if (maxa==2)
-    {
-     at--;
-     zt--;
-    } 
-    else
-    {
-     ap--;
-     zp--;
-    }
-   }
-   if (rndm>fFracpp && rndm<=(fFracpp+fFracnp)) // n+p interaction
-   {
-    ncols[1]++;
-    if (maxa==2)
-    {
-     at--;
-     zt--;
-    } 
-    else
-    {
-     ap--;
-    }
-   }
-   if (rndm>(fFracpp+fFracnp) && rndm<=(fFracpp+fFracnp+fFracpn)) // p+n interaction
-   {
-    ncols[2]++;
-    if (maxa==2)
-    {
-     at--;
-    } 
-    else
-    {
-     ap--;
-     zp--;
-    }
-   }
-   if (rndm>(fFracpp+fFracnp+fFracpn)) // n+n interaction
-   {
-    ncols[3]++; 
-    if (maxa==2)
-    {
-     at--;
-    } 
-    else
-    {
-     ap--;
-    }
-   }
-  }
-  delete [] rans;
- }
-
- if (!(fEventnum%fPrintfreq))
- {
-  cout << " *AliCollider::MakeEvent* Run : " << fRunnum << " Event : " << fEventnum
-       << endl;
-  if (fNucl)
-  {
-   cout << " npart = " << npt << " ncol = " << ncol 
-        << " ncolpp = " << ncols[0] << " ncolnp = " << ncols[1]
-        << " ncolpn = " << ncols[2] << " ncolnn = " << ncols[3] << endl;
-  }
- }
-
- if (!fEvent)
- {
-  fEvent=new AliEvent();
-  fEvent->SetOwner();
-  fEvent->SetName(GetName());
-  fEvent->SetTitle(GetTitle());
- }
-
- fEvent->Reset();
- fEvent->SetRunNumber(fRunnum);
- fEvent->SetEventNumber(fEventnum);
-
- AliTrack t;
- Ali3Vector p;
- AliPosition r,rx;
- Float_t v[3];
- AliVertex vert;
- Ali3Vector pproj,ptarg;
-
- if (fVertexmode)
- {
-  // Make sure the primary vertex gets correct location and Id=1
-  v[0]=0;
-  v[1]=0;
-  v[2]=0;
-  r.SetPosition(v,"car");
-  v[0]=fResolution;
-  v[1]=fResolution;
-  v[2]=fResolution;
-  r.SetPositionErrors(v,"car");
-
-  vert.SetId(1);
-  vert.SetTrackCopy(0);
-  vert.SetVertexCopy(0);
-  vert.SetPosition(r);
-  fEvent->AddVertex(vert,0);
- }
-
- Int_t kf=0;
- Float_t charge=0,mass=0;
- TString name;
-
- Int_t ntypes=4;
-
- // Singular settings for a normal Pythia elementary particle interation 
- if (!fNucl)
- {
-  ntypes=1;
-  ncols[0]=1;
- }
-
- // Generate all the various collisions
- fSelect=0;      // Flag to indicate whether the total event is selected or not 
- Int_t select=0; // Flag to indicate whether the sub-event is selected or not 
- Int_t first=1;  // Flag to indicate the first collision process
- Double_t pnucl;
- Int_t npart=0,ntk=0;
- Double_t dist=0;
- for (Int_t itype=0; itype<ntypes; itype++)
- {
-  if (fNucl)
-  {
-   if (itype==0 && ncols[itype]) Initialize(fFrame,"p","p",fWin);
-   if (itype==1 && ncols[itype]) Initialize(fFrame,"n","p",fWin);
-   if (itype==2 && ncols[itype]) Initialize(fFrame,"p","n",fWin);
-   if (itype==3 && ncols[itype]) Initialize(fFrame,"n","n",fWin);
-  }
-  for (Int_t jcol=0; jcol<ncols[itype]; jcol++)
-  {
-   GenerateEvent();
-
-   select=IsSelected();
-   if (select) fSelect=1;
-
-   if (first) // Store generator parameter information in the event structure
-   {
-    // Enter generator parameters as a device in the event
-    AliSignal params;
-    params.SetNameTitle("AliCollider","AliCollider generator parameters");
-    params.SetSlotName("Medit",1);
-    params.SetSlotName("Vertexmode",2);
-    params.SetSlotName("Resolution",3);
-    params.SetSlotName("Userctrl",4);
-    params.SetSlotName("Elastic",5);
-
-    params.SetSignal(medit,1);
-    params.SetSignal(fVertexmode,2);
-    params.SetSignal(fResolution,3);
-    params.SetSignal(fUserctrl,4);
-    params.SetSignal(fElastic,5);
-
-    // Store projectile and target information in the event structure
-    if (fNucl)
-    {
-     v[0]=GetP(1,1);
-     v[1]=GetP(1,2);
-     v[2]=GetP(1,3);
-     pproj.SetVector(v,"car");
-     pnucl=pproj.GetNorm();
-     fEvent->SetProjectile(fAproj,fZproj,pnucl);
-     v[0]=GetP(2,1);
-     v[1]=GetP(2,2);
-     v[2]=GetP(2,3);
-     ptarg.SetVector(v,"car");
-     pnucl=ptarg.GetNorm();
-     fEvent->SetTarget(fAtarg,fZtarg,pnucl);
-
-     params.AddNamedSlot("specmode");
-     params.AddNamedSlot("Specpmin");
-     params.AddNamedSlot("npart");
-     params.AddNamedSlot("ncolpp");
-     params.AddNamedSlot("ncolnp");
-     params.AddNamedSlot("ncolpn");
-     params.AddNamedSlot("ncolnn");
-
-     params.SetSignal(specmode,"specmode");
-     params.SetSignal(fSpecpmin,"Specpmin");
-     params.SetSignal(npt,"npart");
-     params.SetSignal(ncols[0],"ncolpp");
-     params.SetSignal(ncols[1],"ncolnp");
-     params.SetSignal(ncols[2],"ncolpn");
-     params.SetSignal(ncols[3],"ncolnn");
-    }
-    else
-    {
-     v[0]=GetP(1,1);
-     v[1]=GetP(1,2);
-     v[2]=GetP(1,3);
-     pnucl=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
-     kf=GetK(1,2);
-     fEvent->SetProjectile(0,0,pnucl,kf);
-     v[0]=GetP(2,1);
-     v[1]=GetP(2,2);
-     v[2]=GetP(2,3);
-     pnucl=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
-     kf=GetK(2,2);
-     fEvent->SetTarget(0,0,pnucl,kf);
-    }
-
-    fEvent->AddDevice(params);
-
-    first=0;
-   }
-
-   if (medit >= 0) Pyedit(medit); // Define which particles are to be kept
-
-   if (mlist>=0 && select)
-   {
-    Pylist(mlist);
-    cout << endl;
-   }
-
-   npart=GetN();
-   for (Int_t jpart=1; jpart<=npart; jpart++)
-   {
-    kf=GetK(jpart,2);
-    charge=Pychge(kf)/3.;
-    mass=GetP(jpart,5);
-    name=GetPyname(kf);
-
-    // 3-momentum in GeV/c
-    v[0]=GetP(jpart,1);
-    v[1]=GetP(jpart,2);
-    v[2]=GetP(jpart,3);
-    p.SetVector(v,"car");
-
-    // Production location in meter.
-    v[0]=GetV(jpart,1)/1000.;
-    v[1]=GetV(jpart,2)/1000.;
-    v[2]=GetV(jpart,3)/1000.;
-    r.SetPosition(v,"car");
-
-    ntk++;
-
-    t.Reset();
-    t.SetId(ntk);
-    t.SetParticleCode(kf);
-    t.SetName(name.Data());
-    t.SetCharge(charge);
-    t.SetMass(mass);
-    t.Set3Momentum(p);
-    t.SetBeginPoint(r);
-
-    fEvent->AddTrack(t);
-
-    // Build the vertex structures if requested
-    if (fVertexmode)
-    {
-     // Check if track belongs within the resolution to an existing vertex
-     Int_t add=0;  
-     for (Int_t jv=1; jv<=fEvent->GetNvertices(); jv++)
-     {
-      AliVertex* vx=fEvent->GetVertex(jv);
-      if (vx)
-      {
-       rx=vx->GetPosition();
-       dist=rx.GetDistance(r);
-       if (dist < fResolution)
-       {
-        AliTrack* tx=fEvent->GetIdTrack(ntk);
-        if (tx)
-        { 
-         vx->AddTrack(tx);
-         add=1;
-        }
-       }
-      }
-      if (add) break; // No need to look further for vertex candidates
-     }
-
-     // If track was not close enough to an existing vertex
-     // a new secondary vertex is created      
-     if (!add && fVertexmode>1)
-     {
-      AliTrack* tx=fEvent->GetIdTrack(ntk);
-      if (tx)
-      {
-       v[0]=fResolution;
-       v[1]=fResolution;
-       v[2]=fResolution;
-       r.SetPositionErrors(v,"car");
-       vert.Reset();
-       vert.SetTrackCopy(0);
-       vert.SetVertexCopy(0);
-       vert.SetId((fEvent->GetNvertices())+1);
-       vert.SetPosition(r);
-       vert.AddTrack(tx);
-       fEvent->AddVertex(vert,0);
-      } 
-     }
-    }
-   } // End of loop over the produced particles for each collision
-  } // End of loop over number of collisions for each type
- } // End of loop over collision types
-
- // Link sec. vertices to primary if requested
- // Note that also the connecting tracks are automatically created
- if (fVertexmode>2)
- {
-  AliVertex* vp=fEvent->GetIdVertex(1); /