prevent problems w.r.t. TObject::Info due to probable root/cint bug.
03-feb-2003 NvE File "gcclib" added to subdirectory "scripts" to provide Ralice installation
script for Linux machines using gcc.
Class AliObjMatrix introduced.
// Float_t e[3]={0.03,0.5,0.21};
// a.SetVector(v,"car");
// a.SetErrors(e,"car");
-// a.Info();
+// a.Data();
//
// Float_t vec[3];
// Float_t err[3];
// Float_t doterror=a.GetResultError();
//
// Ali3Vector c=a.Cross(b);
-// c.Info("sph");
+// c.Data("sph");
// c.GetVector(vec,"cyl");
// c.GetErrors(err,"cyl");
//
}
}
///////////////////////////////////////////////////////////////////////////
-void Ali3Vector::Info(TString f)
+void Ali3Vector::Data(TString f)
{
// Print vector components according to reference frame f
if (f=="car" || f=="sph" || f=="cyl")
}
else
{
- cout << " *Ali3Vector::Info* Unsupported frame : " << f << endl
+ cout << " *Ali3Vector::Data* Unsupported frame : " << f << endl
<< " Possible frames are 'car', 'sph' and 'cyl'." << endl;
}
}
virtual void GetErrors(Double_t* e,TString f); // Provide errors of vector in frame f
virtual void SetErrors(Float_t* e,TString f); // Store errors of vector in frame f
virtual void GetErrors(Float_t* e,TString f); // Provide errors of vector in frame f
- virtual void Info(TString f="car"); // Print vector components in frame f
+ virtual void Data(TString f="car"); // Print vector components in frame f
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 fDx,fDy,fDz; // Errors on Cartesian coordinates
Double_t fDresult; // Error on scalar result (e.g. norm or dotproduct)
- ClassDef(Ali3Vector,1) // Handling of 3-vectors in various reference frames.
+ ClassDef(Ali3Vector,2) // Handling of 3-vectors in various reference frames.
};
#endif
// Ali3VectorObj vec2;
// vec2.Load(add);
//
-// vec1.Info();
-// vec2.Info();
+// vec1.Data();
+// vec2.Data();
//
//--- Author: Nick van Eijndhoven 18-oct-1999 UU-SAP Utrecht
//- Modified: NvE $Date$ UU-SAP Utrecht
// Ali4Vector c;
// c.SetVector(x0,x);
// c.GetVector(vec,"car");
-// c.Info("cyl");
+// c.Data("cyl");
// c=a+b;
// c=a-b;
// c=a*5;
}
}
///////////////////////////////////////////////////////////////////////////
-void Ali4Vector::Info(TString f)
+void Ali4Vector::Data(TString f)
{
// Print contravariant vector components and errors according to
// reference frame f and according to the current mode.
}
else
{
- cout << " *Ali4Vector::Info* Unsupported frame : " << f << endl
+ cout << " *Ali4Vector::Data* Unsupported frame : " << f << endl
<< " Possible frames are 'car', 'sph' and 'cyl'." << endl;
}
}
virtual void GetErrors(Double_t* v,TString f); // Provide errors of vector v^i in frame f
virtual void SetErrors(Float_t* v,TString f); // Store errors of vector v^i in frame f
virtual void GetErrors(Float_t* v,TString f); // Provide errors of vector v^i in frame f
- virtual void Info(TString f="car"); // Print contravariant components in frame f
+ virtual void Data(TString f="car"); // Print contravariant components in frame f
Double_t Dot(Ali4Vector& q); // Provide dot product v^i*q_i
Double_t GetResultError(); // Provide error on scalar result (e.g. Dot)
Ali4Vector operator+(Ali4Vector& q); // Add contravariant vector q
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,1) // Handling of Lorentz 4-vectors in various reference frames.
+ ClassDef(Ali4Vector,2) // Handling of Lorentz 4-vectors in various reference frames.
};
#endif
// Ali4VectorObj vec2;
// vec2.Load(sub);
//
-// vec1.Info();
-// vec2.Info();
+// vec1.Data();
+// vec2.Data();
//
//--- Author: Nick van Eijndhoven 18-oct-1999 UU-SAP Utrecht
//- Modified: NvE $Date$ UU-SAP Utrecht
//
// AliBoost b1;
// b1.SetBeta(beta);
-// b1.Info();
+// b1.Data();
//
// Float_t b[4]={14,1,2,3};
// Float_t eb[4]={1.4,0.1,0.2,0.3};
// p.SetVector(b,"car");
// p.SetErrors(eb,"car");
// Ali4Vector pprim=b1.Boost(p);
-// p.Info();
-// pprim.Info();
+// p.Data();
+// pprim.Data();
//
// p=b1.Inverse(pprim);
-// pprim.Info();
-// p.Info();
+// pprim.Data();
+// p.Data();
//
// Float_t c[4]={5,0,0,4};
// Float_t ec[4]={0.5,0,0,0.4};
//
// AliBoost b2;
// b2.Set4Momentum(q);
-// b2.Info("sph");
+// b2.Data("sph");
//
//--- Author: Nick van Eijndhoven 14-may-1996 UU-SAP Utrecht
//- Modified: NvE $Date$ UU-SAP Utrecht
if (E <= 0.)
{
cout << " *AliBoost::Set4Momentum* Unphysical situation." << endl;
- p.Info();
+ p.Data();
}
else
{
return fDresult;
}
///////////////////////////////////////////////////////////////////////////
-void AliBoost::Info(TString f)
+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::Info* beta : " << beta << " error : " << dbeta
+ cout << " *AliBoost::Data* beta : " << beta << " error : " << dbeta
<< " gamma : " << fGamma << " error : " << fDgamma << endl;
cout << " Beta";
- fBeta.Info(f);
+ fBeta.Data(f);
}
///////////////////////////////////////////////////////////////////////////
Ali4Vector AliBoost::Boost(Ali4Vector& v)
Ali3Vector GetBetaVector(); // Provide the beta 3-vector
Double_t GetBeta(); // Provide norm of beta 3-vector
Double_t GetGamma(); // Provide gamma value
- void Info(TString f="car"); // Print boost parameter info in coord. frame f
+ 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(); // Provide error on scalar result
Double_t fDgamma; // Error on the gamma value
Double_t fDresult; // Error on scalar result
- ClassDef(AliBoost,1) // Perform various Lorentz transformations.
+ ClassDef(AliBoost,2) // Perform various Lorentz transformations.
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// $Id: AliCollider.cxx,v 1.3 2002/12/02 15:10:37 nick Exp $
+// $Id: AliCollider.cxx,v 1.4 2002/12/11 14:45:12 nick Exp $
///////////////////////////////////////////////////////////////////////////
// Class AliCollider
//
// AliEvent* evt=gen->GetEvent();
//
-// evt->Info();
+// evt->Data();
// }
//
// gen->EndRun();
//
//
//--- Author: Nick van Eijndhoven 22-nov-2002 Utrecht University
-//- Modified: NvE $Date: 2002/12/02 15:10:37 $ Utrecht University
+//- Modified: NvE $Date: 2002/12/11 14:45:12 $ Utrecht University
///////////////////////////////////////////////////////////////////////////
#include "AliCollider.h"
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// $Id: AliEvent.cxx,v 1.8 2002/12/02 15:10:37 nick Exp $
+// $Id: AliEvent.cxx,v 1.9 2003/01/09 16:06:35 nick Exp $
///////////////////////////////////////////////////////////////////////////
// Class AliEvent
// jx=v2.GetJet(2);
// evt.AddJet(jx,0);
//
-// evt.Info("sph");
+// evt.Data("sph");
// v1.ListAll();
// v2.List("cyl");
//
// Float_t loc[3];
// evt.GetPosition(loc,"sph");
// AliPosition r=v1.GetPosition();
-// r.Info();
+// r.Data();
// Int_t nt=v2.GetNtracks();
// AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
//
// Note : All quantities are in GeV, GeV/c or GeV/c**2
//
//--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
-//- Modified: NvE $Date: 2002/12/02 15:10:37 $ UU-SAP Utrecht
+//- Modified: NvE $Date: 2003/01/09 16:06:35 $ UU-SAP Utrecht
///////////////////////////////////////////////////////////////////////////
#include "AliEvent.h"
return fIdTarg;
}
///////////////////////////////////////////////////////////////////////////
-void AliEvent::HeaderInfo()
+void AliEvent::HeaderData()
{
// Provide event header information
Int_t date=fDaytime.GetDate();
char* c[12]={"jan","feb","mar","apr","may","jun",
"jul","aug","sep","oct","nov","dec"};
- cout << " *AliEvent::Info* Run : " << fRun << " Event : " << fEvent;
+ cout << " *AliEvent::Data* Run : " << fRun << " Event : " << fEvent;
cout.fill('0');
cout << " Date : " << setw(2) << day << "-" << c[month-1] << "-" << year
<< " Time : " << setw(2) << hh << ":" << setw(2) << mm << ":" << setw(2) << ss;
cout << " Ncalorimeters : " << fNcals << endl;
}
///////////////////////////////////////////////////////////////////////////
-void AliEvent::Info(TString f)
+void AliEvent::Data(TString f)
{
// Provide event information within the coordinate frame f
- HeaderInfo();
- AliVertex::Info(f);
+ HeaderData();
+ AliVertex::Data(f);
}
///////////////////////////////////////////////////////////////////////////
Int_t AliEvent::GetNcalorimeters()
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-// $Id: AliEvent.h,v 1.5 2002/10/28 14:41:34 nick Exp $
+// $Id: AliEvent.h,v 1.6 2002/12/02 15:10:38 nick Exp $
#include "Riostream.h"
#include <math.h>
TDatime GetDayTime(); // Provide the date and time stamp
Int_t GetRunNumber(); // Provide the run number
Int_t GetEventNumber(); // Provide the event number
- void HeaderInfo(); // Print the event header information
- void Info(TString f="car"); // Print the event info within coordinate frame f
+ void HeaderData(); // Print the event header information
+ void Data(TString f="car"); // Print the event info within coordinate frame f
void SetCalCopy(Int_t j); // (De)activate creation of private copies in fCalorimeters
Int_t GetCalCopy(); // Provide CalCopy flag value
void AddCalorimeter(AliCalorimeter& c); // Add a calorimeter system to the event
TObjArray* fCalorimeters; // Array to hold the pointers to the calorimeter systems
Int_t fCalCopy; // Flag to denote creation of private copies in fCalorimeters
- ClassDef(AliEvent,4) // Creation and investigation of an Alice physics event.
+ ClassDef(AliEvent,5) // Creation and investigation of an Alice physics event.
};
#endif
// tx->Reset();
// }
//
-// j1.Info();
-// j2.Info("sph");
+// j1.Data();
+// j2.Data("sph");
//
// Float_t e1=j1.GetEnergy();
// Float_t pnorm=j1->GetMomentum();
}
///////////////////////////////////////////////////////////////////////////
-void AliJet::Info(TString f)
+void AliJet::Data(TString f)
{
// Provide jet information within the coordinate frame f
- cout << " *AliJet::Info* Id : " << fUserId << " Invmass : " << GetInvmass() << " Charge : " << fQ
+ cout << " *AliJet::Data* Id : " << fUserId << " Invmass : " << GetInvmass() << " Charge : " << fQ
<< " Momentum : " << GetMomentum() << " Ntracks : " << fNtrk << endl;
cout << " ";
- Ali4Vector::Info(f);
+ Ali4Vector::Data(f);
}
///////////////////////////////////////////////////////////////////////////
void AliJet::List(TString f)
{
// Provide jet and primary track information within the coordinate frame f
- Info(f); // Information of the current jet
+ Data(f); // Information of the current jet
// The tracks of this jet
AliTrack* t;
{
cout << " ---Track no. " << it << endl;
cout << " ";
- t->Info(f);
+ t->Data(f);
}
else
{
{
// Provide jet and prim.+sec. track information within the coordinate frame f
- Info(f); // Information of the current jet
+ Data(f); // Information of the current jet
// The tracks of this jet
AliTrack* t;
void Reset(); // Reset all values
void AddTrack(AliTrack& t,Int_t copy=1);// Add a track to the jet
void AddTrack(AliTrack* t,Int_t copy=1) { AddTrack(*t,copy); }
- void Info(TString f); // Print jet information in coordinate frame f
+ void Data(TString f); // Print jet information in coordinate frame f
void List(TString f="car"); // Print jet prim. track information for coord. frame f
void ListAll(TString f="car"); // Print jet prim. and decay track information for coord. frame f
Double_t GetEnergy(); // Provide the total jet energy
Int_t fTrackCopy; // Flag to denote creation of private copies in fTracks
Int_t fUserId; // The user defined identifier
- ClassDef(AliJet,2) // Creation and investigation of a jet of particle tracks.
+ ClassDef(AliJet,3) // Creation and investigation of a jet of particle tracks.
};
#endif
--- /dev/null
+/**************************************************************************
+ * 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 AliObjMatrix
+// Handling of a matrix structure of objects.
+// All objects which are derived from TObject may be entered into the matrix
+// structure. This means that also TObjArray objects can be entered,
+// which implies an increase of the dimension of the resulting structure.
+//
+// Example :
+// =========
+//
+// AliObjMatrix* matrix=new AliObjMatrix();
+// matrix->SetOwner();
+// matrix->SetSwapMode();
+//
+// Float_t pos[3];
+//
+// AliSignal* s=0;
+//
+// s=new AliSignal();
+// s->SetSignal(135);
+// pos[0]=-120.4
+// pos[1]=78.25
+// pos[3]=12.93
+// s->SetPosition(pos,"car");
+// m->EnterObject(6,21,s);
+//
+// s=new AliSignal();
+// s->SetSignal(25.84);
+// pos[0]=68.7
+// pos[1]=-53.88
+// pos[3]=22.69
+// s->SetPosition(pos,"car");
+// m->EnterObject(8,13,s);
+//
+// s=new AliSignal();
+// s->SetSignal(87.25);
+// pos[0]=154.8
+// pos[1]=932.576
+// pos[3]=-1382.754
+// s->SetPosition(pos,"car");
+// m->EnterObject(64,3,s);
+//
+// Int_t nrows=matrix->GetMaxRow();
+// Int_t ncols=matrix->GetMaxColumn();
+//
+// cout << " Maxrow : " << nrows << " Maxcol : " << ncols
+// << " Nobjects : " << matrix->GetNobjects() << endl;
+//
+// for (Int_t i=1; i<=nrows; i++)
+// {
+// for (Int_t j=1; j<=ncols; j++)
+// {
+// s=(AliSignal*)matrix->GetObject(i,j);
+// if (s) cout << " At (" << i << "," << j << ") Signal : " << s->GetSignal() << endl;
+// }
+// }
+//
+//--- Author: Nick van Eijndhoven 23-jan-2003 Utrecht University
+//- Modified: NvE $Date$ Utrecht University
+///////////////////////////////////////////////////////////////////////////
+
+#include "AliObjMatrix.h"
+
+ClassImp(AliObjMatrix) // Class implementation to enable ROOT I/O
+
+AliObjMatrix::AliObjMatrix()
+{
+// Default constructor.
+// Note : The owner and swap mode flags will be initialised to 0.
+// See the memberfunctions SetOwner() and SetSwapMode() for further
+// details.
+ fRows=0;
+ fOwn=0;
+ fSwap=0;
+ fMaxrow=0;
+ fMaxcol=0;
+ fNobjects=0;
+}
+///////////////////////////////////////////////////////////////////////////
+AliObjMatrix::~AliObjMatrix()
+{
+// Default destructor.
+ if (fRows)
+ {
+ delete fRows;
+ fRows=0;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+void AliObjMatrix::Reset()
+{
+// Reset the whole matrix structure.
+// Note : The values of the owner and swap mode flags will not be modified.
+// To modify the ownership, use the memberfunction SetOwner().
+// To modify the swap mode, use the memberfunction SetSwapMode().
+ if (fRows)
+ {
+ delete fRows;
+ fRows=0;
+ }
+
+ fMaxrow=0;
+ fMaxcol=0;
+ fNobjects=0;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliObjMatrix::SetOwner(Int_t own)
+{
+// Set the owner flag (0/1) for the stored objects.
+// When the owner flag is set to 1, all entered objects are owned by the
+// matrix structure.
+// At invokation of this memberfunction the default argument is own=1.
+//
+ fOwn=own;
+
+ if (!fRows) return;
+
+ for (Int_t irow=0; irow<fRows->GetSize(); irow++)
+ {
+ TObjArray* mrow=(TObjArray*)fRows->At(irow);
+ if (mrow)
+ {
+ if (own)
+ {
+ mrow->SetOwner(kTRUE);
+ }
+ else
+ {
+ mrow->SetOwner(kFALSE);
+ }
+ }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliObjMatrix::GetOwner()
+{
+// Provide the owner flag for the stored objects.
+ return fOwn;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliObjMatrix::SetSwapMode(Int_t swap)
+{
+// Set the swap mode flag (0/1) for the internal matrix storage.
+// In case the number of rows differs considerably from the number of columns,
+// it might be more efficient (w.r.t. memory usage and/or output file size)
+// to internally store the matrix with the rows and colums swapped.
+// This swapping is only related with the internal storage and as such
+// is completely hidden for the user.
+// At invokation of this memberfunction the default argument is swap=1.
+//
+// Note : The swap mode can only be set as long as no objects have
+// been stored in the matrix structure (i.e. a new instance
+// of AliObjMatrix or after invokation of the Reset() function).
+//
+ if (!fRows)
+ {
+ fSwap=swap;
+ }
+ else
+ {
+ cout << " *AliObjMatrix::SetSwapMode* Matrix not empty ==> No action." << endl;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliObjMatrix::GetSwapMode()
+{
+// Provide the swap mode flag for this matrix.
+ return fSwap;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliObjMatrix::EnterObject(Int_t row,Int_t col,TObject* obj)
+{
+// Enter an object to the matrix structure at location (row,col).
+// In case the location already contained an object, the existing object
+// will first be removed before the new object is stored.
+// According to the status of the copy flag (see the SetCopy() function)
+// the existing object will also be deleted.
+// Note : The first location in the matrix is indicated as (1,1).
+ if (row<1 || col<1)
+ {
+ cout << " *AliObjMatrix::AddObject* Invalid argument(s) (row,col) : ("
+ << row << "," << col << ")" << endl;
+ return;
+ }
+
+ if (row>fMaxrow) fMaxrow=row;
+ if (col>fMaxcol) fMaxcol=col;
+
+ Int_t rowx=row;
+ if (fSwap) rowx=col;
+ Int_t colx=col;
+ if (fSwap) colx=row;
+
+ if (!fRows)
+ {
+ fRows=new TObjArray(rowx);
+ fRows->SetOwner();
+ }
+ else
+ {
+ if (rowx > fRows->GetSize()) fRows->Expand(rowx);
+ }
+
+ TObjArray* mrow=(TObjArray*)fRows->At(rowx-1);
+
+ if (!mrow)
+ {
+ TObjArray* columns=new TObjArray(colx);
+ if (fOwn) columns->SetOwner();
+ fRows->AddAt(columns,rowx-1);
+ mrow=columns;
+ }
+ else
+ {
+ if (colx > mrow->GetSize()) mrow->Expand(colx);
+ }
+
+ TObject* old=(TObject*)mrow->At(colx-1);
+ if (!old) fNobjects++;
+ if (old && fOwn) delete old;
+
+ mrow->AddAt(obj,colx-1);
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliObjMatrix::GetObject(Int_t row,Int_t col)
+{
+// Provide a pointer to the object stored at the matrix location (row,col).
+// In case no object was stored at the indicated location or the location
+// would reside outside the matrix boundaries, a value 0 will be returned.
+// Note : The first location in the matrix is indicated as (1,1).
+
+ TObject* obj=0;
+
+ if (!fRows || row<1 || col<1) return obj;
+
+
+ Int_t rowx=row;
+ if (fSwap) rowx=col;
+ Int_t colx=col;
+ if (fSwap) colx=row;
+
+ TObjArray* mrow=0;
+ if (rowx <= fRows->GetSize()) mrow=(TObjArray*)fRows->At(rowx-1);
+
+ if (!mrow) return obj;
+
+ if (colx <= mrow->GetSize()) obj=(TObject*)mrow->At(colx-1);
+
+ return obj;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliObjMatrix::GetMaxRow()
+{
+// Provide the maximum row number index.
+ return fMaxrow;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliObjMatrix::GetMaxColumn()
+{
+// Provide the maximum column number index.
+ return fMaxcol;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliObjMatrix::GetNobjects()
+{
+// Provide the number of stored objects.
+ return fNobjects;
+}
+///////////////////////////////////////////////////////////////////////////
--- /dev/null
+#ifndef ALIOBJMATRIX_H
+#define ALIOBJMATRIX_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+// $Id$
+
+#include "Riostream.h"
+
+#include "TObject.h"
+#include "TObjArray.h"
+
+class AliObjMatrix : public TObject
+{
+ public:
+ AliObjMatrix(); // Default constructor
+ ~AliObjMatrix(); // Default destructor
+ virtual void Reset(); // Reset the whole matrix structure
+ virtual void SetOwner(Int_t own=1); // Set the owner flag for the stored objects
+ virtual Int_t GetOwner(); // Provide the owner flag for the stored objects
+ virtual void SetSwapMode(Int_t swap=1); // Set the swap mode flag for this matrix
+ virtual Int_t GetSwapMode(); // Provide the swap mode flag for this matrix
+ virtual void EnterObject(Int_t row,Int_t col,TObject* obj); // Enter an object into the matrix
+ virtual TObject* GetObject(Int_t row,Int_t col); // Provide an object from the matrix
+ virtual Int_t GetMaxRow(); // Provide the maximum row number index
+ virtual Int_t GetMaxColumn(); // Provide the maximum column number index
+ virtual Int_t GetNobjects(); // Provide the number of stored objects
+
+ protected:
+ TObjArray* fRows; // Pointers to the various arrays representing the matrix rows
+ Int_t fOwn; // Flag to indicate whether the objects are owned by the matrix structure
+ Int_t fSwap; // Flag to indicate swapped mode for internal matrix storage
+ Int_t fMaxrow; // The maximum row number index
+ Int_t fMaxcol; // The maximum column number index
+ Int_t fNobjects; // The number of stored objects
+
+ ClassDef(AliObjMatrix,1) // Handling of a matrix structure of objects.
+};
+#endif
// rr2.Load(r2);
// AliPositionObj ssum(r1+r2);
//
-// rr1.Info();
-// rr2.Info();
-// ssum.Info();
+// rr1.Data();
+// rr2.Data();
+// ssum.Data();
//
//--- Author: Nick van Eijndhoven 18-oct-1999 UU-SAP Utrecht
//- Modified: NvE $Date$ UU-SAP Utrecht
// // The sequence is started at the location
// // denoted by the counters cnt1 and cnt2.
//
-// q.Info(); // Print the current seed, cnt1 and cnt2 values.
+// q.Data(); // Print the current seed, cnt1 and cnt2 values.
// q.GetSeed(); // Provide the current seed value.
// q.GetCnt1(); // Provide the current cnt1 value.
// q.GetCnt2(); // Provide the current cnt2 value.
return fCnt2;
}
///////////////////////////////////////////////////////////////////////////
-void AliRandom::Info()
+void AliRandom::Data()
{
// Print the current seed, cnt1 and cnt2 values
cout << " *Random* seed = " << fSeed
Int_t GetSeed(); // Provide current seed value
Int_t GetCnt1(); // Provide current counter value cnt1
Int_t GetCnt2(); // Provide current counter value cnt2
- void Info(); // Print current seed, cnt1 and cnt2
+ void Data(); // Print current seed, cnt1 and cnt2
Float_t Uniform(); // Uniform dist. within <0,1>
Float_t Uniform(Float_t a,Float_t b); // Uniform dist. within <a,b>
void Uniform(Float_t* vec,Int_t n); // n uniform randoms in <0,1>
Float_t fYamin,fYamax; //! The min. and max. y values of the area function
Int_t* fIbins; //! The bin numbers of the random x candidates
- ClassDef(AliRandom,1) // Generate universal random numbers on all common machines.
+ ClassDef(AliRandom,2) // Generate universal random numbers on all common machines.
};
#endif
// whereas the "Reset" function resets the complete sample to 'empty'.
// The info which can be extracted from a certain data sample are the
// sum, mean, variance, sigma, covariance and correlation.
-// The "Info" function provides all statistics data for a certain sample.
+// The "Data" function provides all statistics data for a certain sample.
// The variables for which these stat. parameters have to be calculated
// are indicated by the index of the variable which is passed as an
// argument to the various member functions.
// the mean_x can be obtained as s.GetMean(1) whereas the mean_y is obtained
// via s.GetMean(2).
// The correlation between x and y is available via s.GetCor(1,2).
-// The x-statistics are obtained via s.Info(1), y-statistics via s.Info(2),
-// and the covariance and correlation between x and y via s.Info(1,2).
-// All statistics of a sample are obtained via s.Info().
+// The x-statistics are obtained via s.Data(1), y-statistics via s.Data(2),
+// and the covariance and correlation between x and y via s.Data(1,2).
+// All statistics of a sample are obtained via s.Data().
//
//--- Author: Nick van Eijndhoven 30-mar-1996 CERN Geneva
//- Modified: NvE $Date$ UU-SAP Utrecht
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSample::Info()
+void AliSample::Data()
{
// Printing of statistics of all variables
for (Int_t i=0; i<fDim; i++)
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSample::Info(Int_t i)
+void AliSample::Data(Int_t i)
{
// Printing of statistics of ith variable
if (fDim < i)
{
- cout << " *AliSample::Info(i)* Error : Dimension less than " << i << endl;
+ cout << " *AliSample::Data(i)* Error : Dimension less than " << i << endl;
}
else
{
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSample::Info(Int_t i,Int_t j)
+void AliSample::Data(Int_t i,Int_t j)
{
// Printing of covariance and correlation between variables i and j
if ((fDim < i) || (fDim < j))
{
Int_t k=i;
if (j > i) k=j;
- cout << " *AliSample::Info(i,j)* Error : Dimension less than " << k << endl;
+ cout << " *AliSample::Data(i,j)* Error : Dimension less than " << k << endl;
}
else
{
Float_t GetSigma(Int_t i); // Standard deviation for i-th variable
Float_t GetCov(Int_t i, Int_t j); // Covariance for i-th and j-th variable
Float_t GetCor(Int_t i, Int_t j); // Correlation for i-th and j-th variable
- void Info(); // Stat. info for the complete sample
- void Info(Int_t i); // Stat. info for the i-th variable
- void Info(Int_t i, Int_t j); // Stat. info for i-th and j-th variable
+ void Data(); // Stat. info for the complete sample
+ void Data(Int_t i); // Stat. info for the i-th variable
+ void Data(Int_t i, Int_t j); // Stat. info for i-th and j-th variable
private:
Int_t fDim; // Dimension of the sample
}
}
///////////////////////////////////////////////////////////////////////////
-void AliSignal::Info(TString f)
+void AliSignal::Data(TString f)
{
// Provide signal information within the coordinate frame f
- cout << " *AliSignal::Info* For signal of kind : " << fName << endl;
+ cout << " *AliSignal::Data* For signal of kind : " << fName << endl;
cout << " Position";
- Ali3Vector::Info(f);
+ Ali3Vector::Data(f);
if (fSignal && fDsignal)
{
virtual void ResetSignals(); // Reset all signal values and errors to 0
virtual void ResetPosition(); // Reset position and errors to 0
virtual void Reset(); // Reset signal and pos. values and errors
- void Info(TString f="car"); // Print signal info for coord. frame f
+ void Data(TString f="car"); // Print signal info for coord. frame f
void SetName(TString name); // Set the name tag to indicate the kind of signal
TString GetName(); // Provide the name tag indicating the kind of signal
Int_t GetNvalues(); // Provide the number of signal values
TArrayF* fDsignal; // Errors on signal values
TString fName; // Name tag to identify the kind of signal
- ClassDef(AliSignal,3) // Handling of ALICE (extrapolated) signals.
+ ClassDef(AliSignal,4) // Handling of ALICE (extrapolated) signals.
};
#endif
// t2.SetCharge(0);
// t2.SetMass(1.115);
//
-// t1.Info();
-// t2.Info();
+// t1.Data();
+// t2.Data();
//
// Float_t pi=acos(-1.);
// Float_t thcms=0.2*pi; // decay theta angle in cms
fQ=q;
}
///////////////////////////////////////////////////////////////////////////
-void AliTrack::Info(TString f)
+void AliTrack::Data(TString f)
{
// Provide track information within the coordinate frame f
Double_t m=GetMass();
Double_t dm=GetResultError();
- cout << " *AliTrack::Info* Id : " << fUserId << " Code : " << fCode
+ cout << " *AliTrack::Data* Id : " << fUserId << " Code : " << fCode
<< " Mass : " << m << " error : " << dm << " Charge : " << fQ
<< " Momentum : " << GetMomentum() << " Nmass hyp. : " << fNmasses
<< " Ntracks : " << fNdec << " Nsignals : " << fNsig << endl;
<< " error : " << fDmasses->At(i) << " prob. : " << fPmasses->At(i)
<< endl;
}
- Ali4Vector::Info(f);
+ Ali4Vector::Data(f);
}
///////////////////////////////////////////////////////////////////////////
void AliTrack::List(TString f)
{
// Provide current track and decay level 1 information within coordinate frame f
- Info(f); // Information of the current track
+ Data(f); // Information of the current track
// Decay products of this track
AliTrack* td;
if (td)
{
cout << " ---Level 1 sec. track no. " << id << endl;
- td->Info(f);
+ td->Data(f);
}
else
{
{
// Provide complete track and decay information within the coordinate frame f
- Info(f); // Information of the current track
- cout << " Begin-point :"; fBegin.Info(f);
- cout << " End-point :"; fEnd.Info(f);
+ Data(f); // Information of the current track
+ cout << " Begin-point :"; fBegin.Data(f);
+ cout << " End-point :"; fEnd.Data(f);
for (Int_t is=1; is<=GetNsignals(); is++)
{
- ((AliSignal*)GetSignal(is))->Info(f);
+ ((AliSignal*)GetSignal(is))->Data(f);
}
AliTrack* t=this;
if (td)
{
cout << " ---Level " << n << " sec. track no. " << id << endl;
- td->Info(f);
+ td->Data(f);
for (Int_t is=1; is<=td->GetNsignals(); is++)
{
- ((AliSignal*)td->GetSignal(is))->Info(f);
+ ((AliSignal*)td->GetSignal(is))->Data(f);
}
// Go for next decay level of this decay track recursively
void SetMass(Double_t m,Double_t dm=0); // Set particle mass and error
void SetMass(); // Set mass and error to mass hypothesis with highest prob.
void SetCharge(Float_t q); // Set particle charge
- void Info(TString f="car"); // Print track information for coord. frame f
+ void Data(TString f="car"); // Print track information for coord. frame f
void List(TString f="car"); // Print track and decay level 1 information for coord. frame f
void ListAll(TString f="car"); // Print track and all decay level information for coord. frame f
Ali3Vector Get3Momentum(); // Provide track 3-momentum
private:
void Dump(AliTrack* t,Int_t n,TString f); // Recursively print all decay levels
- ClassDef(AliTrack,2) // Handling of the attributes of a reconstructed particle track.
+ ClassDef(AliTrack,3) // Handling of the attributes of a reconstructed particle track.
};
#endif
// Float_t r3[3]={6.2,4.8,1.3};
// v3.SetPosition(r3,"car");
//
-// v1.Info("sph");
+// v1.Data("sph");
// v2.ListAll();
// v3.List("cyl");
//
// Float_t loc[3];
// v1.GetPosition(loc,"sph");
// AliPosition r=v2.GetPosition();
-// r.Info();
+// r.Data();
// Int_t nt=v2.GetNtracks();
// AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
//
}
}
///////////////////////////////////////////////////////////////////////////
-void AliVertex::Info(TString f)
+void AliVertex::Data(TString f)
{
// Provide vertex information within the coordinate frame f
- cout << " *AliVertex::Info* Id : " << fUserId << " Invmass : " << GetInvmass()
+ cout << " *AliVertex::Data* Id : " << fUserId << " Invmass : " << GetInvmass()
<< " Charge : " << GetCharge() << " Momentum : " << GetMomentum()
<< " Ntracks : " << GetNtracks() << " Nvertices : " << fNvtx
<< " Njets : " << fNjets << endl;
cout << " ";
- Ali4Vector::Info(f);
+ Ali4Vector::Data(f);
cout << " Position";
- AliPosition::Info(f);
+ AliPosition::Data(f);
}
///////////////////////////////////////////////////////////////////////////
void AliVertex::List(TString f)
{
// Provide primary track and sec. vertex information within the coordinate frame f
- Info(f); // Information of the current vertex
+ Data(f); // Information of the current vertex
// The tracks of this vertex
AliTrack* t;
{
cout << " ---Track no. " << it << endl;
cout << " ";
- t->Info(f);
+ t->Data(f);
}
else
{
{
cout << " ---Level 1 sec. vertex no. " << iv << endl;
cout << " ";
- v->Info(f);
+ v->Data(f);
}
else
{
{
// Provide complete (sec) vertex and (decay) track info within the coordinate frame f
- Info(f); // Information of the current vertex
+ Data(f); // Information of the current vertex
// The tracks of this vertex
AliTrack* t;
{
cout << " ---Level " << n << " sec. vertex no. " << iv << endl;
cout << " ";
- vs->Info(f);
+ vs->Data(f);
// The tracks of this vertex
AliTrack* t;
void AddVertex(AliVertex& v,Int_t connect=1);// Add (and connect) a (sec.) vertex to the current vertex
void AddJet(AliJet* j,Int_t tracks=1) { AddJet(*j,tracks); }
void AddVertex(AliVertex* v,Int_t connect=1) { AddVertex(*v,connect); }
- void Info(TString f="car"); // Print the vertex info within coordinate frame f
+ void Data(TString f="car"); // Print the vertex info within coordinate frame f
void List(TString f="car"); // Print vertex prim. track information for coord. frame f
void ListAll(TString f="car"); // Print prim. + sec. vertex full track info for coord. frame f
Int_t GetNvertices(); // Return the number of (secondary) vertices
private:
void Dump(AliVertex* v,Int_t n,TString f); // Recursively print all sec. vertices
- ClassDef(AliVertex,3) // Creation and investigation of an AliVertex.
+ ClassDef(AliVertex,4) // Creation and investigation of an AliVertex.
};
#endif
#include "AliInvmass.h"
#include "AliEvent.h"
#include "AliCollider.h"
+#include "AliObjMatrix.h"
#pragma link C++ class AliInvmass+;
#pragma link C++ class AliEvent+;
#pragma link C++ class AliCollider+;
+ #pragma link C++ class AliObjMatrix+;
#endif
leaks in reading back AliCalorimeter objects from a data file.
Also unnecessary "LoadMatrix()" statement removed in AliCalorimeter::Reset().
Irrelevant cout statement removed from AliEvent constructor.
+01-feb-2003 NvE Memberfunction Info() renamed to Data() in various classes in order to
+ prevent problems w.r.t. TObject::Info due to probable root/cint bug.
+03-feb-2003 NvE File "gcclib" added to subdirectory "scripts" to provide Ralice installation
+ script for Linux machines using gcc.
+ Class AliObjMatrix introduced.
AliCalmodule.cxx AliCalorimeter.cxx AliInvmass.cxx AliJet.cxx \
AliMath.cxx AliPosition.cxx AliRandom.cxx AliSample.cxx AliSignal.cxx \
AliTrack.cxx AliVertex.cxx Ali3VectorObj.cxx Ali4VectorObj.cxx \
- AliPositionObj.cxx AliEvent.cxx AliCollider.cxx
+ AliPositionObj.cxx AliEvent.cxx AliCollider.cxx AliObjMatrix.cxx
HDRS= $(SRCS:.cxx=.h)
--- /dev/null
+### Shell script to create a ROOT loadable GCC shared lib out of .cxx source code
+###
+### NvE 23-may-2000 UU-SAP Utrecht
+#
+### Name of the produced shared library
+lib=ralice.so
+#
+### The option string for GCC shared lib compilation and linking ***
+### For the GCC ROOT loadable shared lib the strict requirements are ***
+### dropped to avoid many warnings from the rootcint generated code ***
+gccroot="-shared -g0 -ansi -pedantic -Wall -I$ROOTSYS/include -o $lib"
+#
+echo "lib = " $lib
+echo "gccroot = " $gccroot
+#
+### Create the dictionary files
+rootcint -f zzzralicedict.cxx -c RALICEHeaders.h RALICELinkDef.h
+#
+### Compile and create the ROOT loadable shared library
+g++ $gccroot *.cxx
+#
+rm zzzralicedict.*
+rm *.o
+#rm so_locations
+#
+echo ' '
+echo '*** gcclib done. Result in ralice.so'