* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.21 2002/12/03 09:03:06 hristov
-Changes needed on Itanium (F.Carminati)
-
-Revision 1.20 2002/10/22 14:45:42 alibrary
-Introducing Riostream.h
-
-Revision 1.19 2002/10/14 14:57:00 hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.13.6.3 2002/08/28 15:06:50 alibrary
-Updating to v3-09-01
-
-Revision 1.18 2002/08/07 18:37:53 nilsen
-Removed endl from print function. should be supplied by user as wanted.
-
-Revision 1.17 2002/06/20 09:10:14 hristov
-Data member ft0 initialized
-
-Revision 1.16 2002/06/19 21:12:37 nilsen
-Fixed bug with non-zero-ed new data members in constructors. Thanks Jiri
-for finding it and pointing it out.
-
-Revision 1.15 2002/06/12 18:59:47 nilsen
-Added Starting track location to hit class and related changes to modules.
-This is at present still fully backwards compatible since starting hits
-are still written to the file. When aliroot v4.0 will be released, this
-backwards compatiblity will be broken by removing the enterence hit, and making
-the nessesary changes to module at that time.
-
-Revision 1.14 2002/05/19 18:17:03 hristov
-Changes needed by ICC/IFC compiler (Intel)
-
-Revision 1.13 2002/03/09 18:35:35 nilsen
-Added functions to print out Hit data members.
-
-Revision 1.12 2002/03/08 16:05:05 nilsen
-Standeard io streamers added to make debugging et al. easier.
-
-Revision 1.11 2001/01/30 09:23:13 hristov
-Streamers removed (R.Brun)
-
-Revision 1.10 2001/01/26 20:01:19 hristov
-Major upgrade of AliRoot code
-
-Revision 1.9 2000/10/02 16:32:51 barbera
-Automatic streamer used and forward declarations added
-
-Revision 1.3.4.7 2000/10/02 15:54:49 barbera
-Automatic streamer used and forward declarations added
-
-Revision 1.8 2000/09/22 12:35:21 nilsen
-Traps placed incase it is used without a properly initilized AliITSgeom class.
-
-Revision 1.7 2000/07/10 16:07:18 fca
-Release version of ITS code
-
-Revision 1.3.4.2 2000/03/04 23:43:57 nilsen
-Fixed up the comments/documentation.
-
-Revision 1.3.4.1 2000/01/12 19:03:32 nilsen
-This is the version of the files after the merging done in December 1999.
-See the ReadMe110100.txt file for details
-
-Revision 1.3 1999/09/29 09:24:20 fca
-Introduction of the Copyright and cvs Log
-
-*/
+/* $Id$ */
#include <Riostream.h>
-#include <TMath.h>
-#include <TRandom.h>
-#include <TVector.h>
-#include <TGeometry.h>
-#include <TNode.h>
-#include <TTUBE.h>
-#include "TParticle.h"
+#include <TLorentzVector.h>
+#include <TParticle.h>
#include "AliRun.h"
#include "AliITS.h"
#include "AliITSgeom.h"
#include "AliITShit.h"
+#include "AliMC.h"
+#include "AliStack.h"
ClassImp(AliITShit)
//
////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-AliITShit::AliITShit():AliHit(){
+AliITShit::AliITShit():AliHit(),
+fStatus(0), // Track Status
+fModule(0), // Module number
+fPx(0.0), // PX of particle at the point of the hit
+fPy(0.0), // PY of particle at the point of the hit
+fPz(0.0), // PZ of particle at the point of the hit
+fDestep(0.0), // Energy deposited in the current step
+fTof(0.0), // Time of flight at the point of the hit
+fStatus0(0),// Track Status of Starting point
+fx0(0.0), // Starting point of this step
+fy0(0.0), // Starting point of this step
+fz0(0.0), // Starting point of this step
+ft0(0.0) // Starting point of this step
+{
// Default Constructor
// Zero data member just to be safe.
// Intputs:
// Return:
// A default created AliITShit class.
- fStatus = 0; // Track Status
- fLayer = 0; // Layer number
- fLadder = 0; // Ladder number
- fDet = 0; // Detector number
- fPx = 0.0; // PX of particle at the point of the hit
- fPy = 0.0; // PY of particle at the point of the hit
- fPz = 0.0; // PZ of particle at the point of the hit
- fDestep = 0.0; // Energy deposited in the current step
- fTof = 0.0; // Time of flight at the point of the hit
- fStatus0 = 0; // zero status bit by default.
- fx0 = 0.0; // Starting point of this step
- fy0 = 0.0; // Starting point of this step
- fz0 = 0.0; // Starting point of this step
- ft0 = 0.0; // Starting point of this step
}
+//----------------------------------------------------------------------
AliITShit::AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,
- Float_t tof,TLorentzVector &x,TLorentzVector &x0,
- TLorentzVector &p) : AliHit(shunt, track){
-////////////////////////////////////////////////////////////////////////
-// Create ITS hit
-// The creator of the AliITShit class. The variables shunt and
-// track are passed to the creator of the AliHit class. See the AliHit
-// class for a full description. In the units of the Monte Carlo
-////////////////////////////////////////////////////////////////////////
- // Intputs:
+ Float_t tof,TLorentzVector &x,TLorentzVector &x0,
+ TLorentzVector &p) :
+AliHit(shunt, track), // AliHit
+fStatus(vol[3]), // Track Status
+fModule(vol[0]), // Module number
+fPx(p.Px()), // PX of particle at the point of the hit
+fPy(p.Py()), // PY of particle at the point of the hit
+fPz(p.Pz()), // PZ of particle at the point of the hit
+fDestep(edep), // Energy deposited in the current step
+fTof(tof), // Time of flight at the point of the hit
+fStatus0(vol[4]),// Track Status of Starting point
+fx0(x0.X()), // Starting point of this step
+fy0(x0.Y()), // Starting point of this step
+fz0(x0.Z()), // Starting point of this step
+ft0(x0.T()) // Starting point of this step
+{
+ // Create ITS hit
+ // The creator of the AliITShit class. The variables shunt and
+ // track are passed to the creator of the AliHit class. See the AliHit
+ // class for a full description. In the units of the Monte Carlo
+ // Inputs:
// Int_t shunt See AliHit
// Int_t track Track number, see AliHit
// Int_t *vol Array of integer hit data,
- // vol[0] Layer where the hit is, 1-6 typicaly
- // vol[1] Ladder where the hit is.
- // vol[2] Detector number where the hit is
+ // vol[0] module
+ // vol[1] not used
+ // vol[2] not used
// vol[3] Set of status bits
// vol[4] Set of status bits at start
+ // Float_t edep The energy deposited GeV during the transport
+ // of this step
+ // Float_t tof The time of flight of this particle at this step
+ // TLorenzVector &x The Global position of this step [cm]
+ // TLorenzVector &x0 The Global position of where this step
+ // started from [cm]
+ // TLorenzVector &p The Global momentum of the particle at this
+ // step [GeV/c]
// Outputs:
// none.
// Return:
// A default created AliITShit class.
- fLayer = vol[0]; // Layer number
- fLadder = vol[2]; // Ladder number
- fDet = vol[1]; // Detector number
- fStatus = vol[3]; // Track status flags
- fStatus0 = vol[4]; // Track status flag for start position.
- fX = x.X(); // Track X global position
- fY = x.Y(); // Track Y global position
- fZ = x.Z(); // Track Z global position
- fPx = p.Px(); // Track X Momentum
- fPy = p.Py(); // Track Y Momentum
- fPz = p.Pz(); // Track Z Momentum
- fDestep = edep; // Track dE/dx for this step
- fTof = tof ; // Track Time of Flight for this step
- fx0 = x0.X(); // Track X global position
- fy0 = x0.Y(); // Track Y global position
- fz0 = x0.Z(); // Track Z global position
- ft0 = x0.T(); // Starting point of this step
+ SetPosition(x);
}
//______________________________________________________________________
AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
- AliHit(shunt, track){
-////////////////////////////////////////////////////////////////////////
-// Create ITS hit
-// The creator of the AliITShit class. The variables shunt and
-// track are passed to the creator of the AliHit class. See the AliHit
-// class for a full description. the integer array *vol contains, in order,
-// fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
-// The array *hits contains, in order, fX = hits[0], fY = hits[1],
-// fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
-// fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
-////////////////////////////////////////////////////////////////////////
+ AliHit(shunt, track), // AliHit
+fStatus(vol[3]), // Track Status
+fModule(vol[0]), // Module number
+fPx(hits[3]), // PX of particle at the point of the hit
+fPy(hits[4]), // PY of particle at the point of the hit
+fPz(hits[5]), // PZ of particle at the point of the hit
+fDestep(hits[6]), // Energy deposited in the current step
+fTof(hits[7]), // Time of flight at the point of the hit
+fStatus0(vol[4]),// Track Status of Starting point
+fx0(hits[8]), // Starting point of this step
+fy0(hits[9]), // Starting point of this step
+fz0(hits[10]), // Starting point of this step
+ft0(hits[11]) // Starting point of this step
+{
+ // Create ITS hit
+ // The creator of the AliITShit class. The variables shunt and
+ // track are passed to the creator of the AliHit class. See the AliHit
+ // class for a full description. the integer array *vol contains, in order,
+ // fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
+ // The array *hits contains, in order, fX = hits[0], fY = hits[1],
+ // fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
+ // fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
// Intputs:
// Int_t shunt See AliHit
// Int_t track Track number, see AliHit
// Int_t *vol Array of integer hit data,
- // vol[0] Layer where the hit is, 1-6 typicaly
- // vol[1] Ladder where the hit is.
- // vol[2] Detector number where the hit is
+ // vol[0] module number
+ // vol[1] not used
+ // vol[2] not used
// vol[3] Set of status bits
+ // vol[4] Set of status bits at start
// Float_t *hits Array of hit information
// hits[0] X global position of this hit
// hits[1] Y global position of this hit
// hits[5] Pz global position of this hit
// hits[6] Energy deposited by this step
// hits[7] Time of flight of this particle at this step
+ // hits[8] X0 global position of start of step
+ // hits[9] Y0 global position of start of step
+ // hits[10] Z0 global position of start of step
+ // hits[11] Time of flight of this particle before step
// Outputs:
// none.
// Return:
// A standard created AliITShit class.
- fLayer = vol[0]; // Layer number
- fLadder = vol[2]; // Ladder number
- fDet = vol[1]; // Detector number
- fStatus = vol[3]; // Track status flags
- fX = hits[0]; // Track X global position
- fY = hits[1]; // Track Y global position
- fZ = hits[2]; // Track Z global position
- fPx = hits[3]; // Track X Momentum
- fPy = hits[4]; // Track Y Momentum
- fPz = hits[5]; // Track Z Momentum
- fDestep = hits[6]; // Track dE/dx for this step
- fTof = hits[7]; // Track Time of Flight for this step
- fStatus0 = 0;// Track Status of Starting point
- fx0 = 0.0; // Starting point of this step
- fy0 = 0.0; // Starting point of this step
- fz0 = 0.0; // Starting point of this step
- ft0 = 0.0; // Starting point of this step
+
+ fX = hits[0]; // Track X global position
+ fY = hits[1]; // Track Y global position
+ fZ = hits[2]; // Track Z global position
}
//______________________________________________________________________
-void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
-////////////////////////////////////////////////////////////////////////
-// Returns the position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
+AliITShit::AliITShit(const AliITShit &h):
+AliHit(h), // AliHit
+fStatus(h.fStatus), // Track Status
+fModule(h.fModule), // Module number
+fPx(h.fPx), // PX of particle at the point of the hit
+fPy(h.fPy), // PY of particle at the point of the hit
+fPz(h.fPz), // PZ of particle at the point of the hit
+fDestep(h.fDestep), // Energy deposited in the current step
+fTof(h.fTof), // Time of flight at the point of the hit
+fStatus0(h.fStatus0),// Track Status of Starting point
+fx0(h.fx0), // Starting point of this step
+fy0(h.fy0), // Starting point of this step
+fz0(h.fz0), // Starting point of this step
+ft0(h.ft0) // Starting point of this step
+{
+ // The standard copy constructor
+ // Inputs:
+ // AliITShit &h the sourse of this copy
+ // Outputs:
+ // none.
+ // Return:
+ // A copy of the sourse hit h
- g[0] = fX;
- g[1] = fY;
- g[2] = fZ;
- if(gm) {
- gm->GtoL(fLayer,fLadder,fDet,g,l);
- x = l[0];
- y = l[1];
- z = l[2];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- // AliITSv7 - SDD case
- x=fX;
- y=fY;
- z=fZ;
- }
+ //Info("CopyConstructor","Coping hit");
+
+ if(this == &h) return;
return;
}
//______________________________________________________________________
+AliITShit& AliITShit::operator=(const AliITShit &h){
+ // The standard = operator
+ // Inputs:
+ // AliITShit &h the sourse of this copy
+ // Outputs:
+ // none.
+ // Return:
+ // A copy of the sourse hit h
+
+ if(this == &h) return *this;
+ this->fStatus = h.fStatus;
+ this->fModule = h.fModule;
+ this->fPx = h.fPx;
+ this->fPy = h.fPy;
+ this->fPz = h.fPz;
+ this->fDestep = h.fDestep;
+ this->fTof = h.fTof;
+ this->fStatus0 = h.fStatus0;
+ this->fx0 = h.fx0;
+ this->fy0 = h.fy0;
+ this->fz0 = h.fz0;
+ this->ft0 = h.ft0;
+ return *this;
+}
+//______________________________________________________________________
+void AliITShit::SetShunt(Int_t shunt){
+ // Sets track flag based on shunt value. Code copied from
+ // AliHit standar constructor.
+ // Inputs:
+ // Int_t shunt A flag to indecate what to do with track numbers
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+ Int_t primary,track,current,parent;
+ TParticle *part;
+
+ track = fTrack;
+ if(shunt == 1) {
+ primary = gAlice->GetMCApp()->GetPrimary(track);
+ gAlice->GetMCApp()->Particle(primary)->SetBit(kKeepBit);
+ fTrack=primary;
+ }else if (shunt == 2) {
+ // the "primary" particle associated to the hit is
+ // the last track that has been flagged in the StepManager
+ // used by PHOS to associate the hit with the decay gamma
+ // rather than with the original pi0
+ parent=track;
+ while (1) {
+ current=parent;
+ part = gAlice->GetMCApp()->Particle(current);
+ parent=part->GetFirstMother();
+ if(parent<0 || part->TestBit(kKeepBit))
+ break;
+ }
+ fTrack=current;
+ }else {
+ fTrack=track;
+ gAlice->GetMCApp()->FlagTrack(fTrack);
+ } // end if shunt
+}
+//______________________________________________________________________
void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
-////////////////////////////////////////////////////////////////////////
-// Returns the position and time of flight of this hit in the local
-// coordinates of this module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
+ // Returns the position and time of flight of this hit in the local
+ // coordinates of this module, and in the units of the Monte Carlo.
+ // Inputs:
+ // none.
+ // Outputs:
+ // Float_t x Global position of this hit [cm]
+ // Float_t y Global position of this hit [cm]
+ // Float_t z Global poistion of this hit [cm]
+ // Float_t tof Time of flight of particle at this hit
+ // Return:
+ // none.
AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
Float_t g[3],l[3];
g[1] = fY;
g[2] = fZ;
if(gm) {
- gm->GtoL(fLayer,fLadder,fDet,g,l);
- x = l[0];
- y = l[1];
- z = l[2];
+ gm->GtoL(fModule,g,l);
+ x = l[0];
+ y = l[1];
+ z = l[2];
} else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- // AliITSv7 - SDD case
- x=fX;
- y=fY;
- z=fZ;
- }
+ Error("AliITShit","NULL pointer to the geometry! return smth else");
+ // AliITSv7 - SDD case
+ x=fX;
+ y=fY;
+ z=fZ;
+ } // end if
tof = fTof;
return;
}
//______________________________________________________________________
void AliITShit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,
- Double_t &tof){
-////////////////////////////////////////////////////////////////////////
-// Returns the initial position and time of flight of this hit in the local
-// coordinates of this module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
+ Double_t &tof){
+ // Returns the initial position and time of flight of this hit
+ // in the local coordinates of this module, and in the units of the
+ // Monte Carlo.
+ // Inputs:
+ // none.
+ // Outputs:
+ // Double_t x Global position of this hit [cm]
+ // Double_t y Global position of this hit [cm]
+ // Double_t z Global poistion of this hit [cm]
+ // Double_t tof Time of flight of particle at this hit
+ // Return:
+ // none.
AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
Float_t g[3],l[3];
g[1] = fy0;
g[2] = fz0;
if(gm) {
- gm->GtoL(fLayer,fLadder,fDet,g,l);
- x = l[0];
- y = l[1];
- z = l[2];
+ gm->GtoL(fModule,g,l);
+ x = l[0];
+ y = l[1];
+ z = l[2];
} else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- // AliITSv7 - SDD case
- x=fx0;
- y=fy0;
- z=fz0;
+ Error("AliITShit","NULL pointer to the geometry! return smth else");
+ x=fx0;
+ y=fy0;
+ z=fz0;
}
tof = ft0;
return;
}
//______________________________________________________________________
-Float_t AliITShit::GetXL(){
-////////////////////////////////////////////////////////////////////////
-// Returns the x position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
-
- g[0] = fX;
- g[1] = fY;
- g[2] = fZ;
- if(gm) {
- gm->GtoL(fLayer,fLadder,fDet,g,l);
- return l[0];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return fX;
- }
-}
-//______________________________________________________________________
-Float_t AliITShit::GetYL(){
-////////////////////////////////////////////////////////////////////////
-// Returns the y position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
-
- g[0] = fX;
- g[1] = fY;
- g[2] = fZ;
- if (gm) {
- gm->GtoL(fLayer,fLadder,fDet,g,l);
- return l[1];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return fZ;
- }
-}
-//______________________________________________________________________
-Float_t AliITShit::GetZL(){
-////////////////////////////////////////////////////////////////////////
-// Returns the z position of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
-
- g[0] = fX;
- g[1] = fY;
- g[2] = fZ;
- if(gm) {
- gm->GtoL(fLayer,fLadder,fDet,g,l);
- return l[2];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return fY;
- }
-}
-//______________________________________________________________________
void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
-////////////////////////////////////////////////////////////////////////
-// Returns the momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
+ // Returns the momentum of this hit in the local coordinates of this
+ // module, and in the units of the Monte Carlo.
+ // Inputs:
+ // none.
+ // Outputs:
+ // Float_t px Track x momentum at this hit [GeV/c]
+ // Float_t py Track y momentum at this hit [GeV/c]
+ // Float_t pz Track z momentum at this hit [GeV/c]
+ // Return:
+ // none.
AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
Float_t g[3],l[3];
g[1] = fPy;
g[2] = fPz;
if (gm) {
- gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
- px = l[0];
- py = l[1];
- pz = l[2];
+ gm->GtoLMomentum(fModule,g,l);
+ px = l[0];
+ py = l[1];
+ pz = l[2];
} else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- px=fPx;
- py=fPy;
- pz=fPz;
- }
+ Error("AliITShit","NULL pointer to the geometry! return smth else");
+ px=fPx;
+ py=fPy;
+ pz=fPz;
+ } // end if
return;
}
//______________________________________________________________________
-Float_t AliITShit::GetPXL(){
-////////////////////////////////////////////////////////////////////////
-// Returns the X momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
-
- g[0] = fPx;
- g[1] = fPy;
- g[2] = fPz;
- if (gm) {
- gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
- return l[0];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return fPx;
- }
-}
-//______________________________________________________________________
-Float_t AliITShit::GetPYL(){
-////////////////////////////////////////////////////////////////////////
-// Returns the Y momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
-
- g[0] = fPx;
- g[1] = fPy;
- g[2] = fPz;
- if (gm) {
- gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
- return l[1];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return fPy;
- }
-
-}
-//______________________________________________________________________
-Float_t AliITShit::GetPZL(){
-////////////////////////////////////////////////////////////////////////
-// Returns the Z momentum of this hit in the local coordinates of this
-// module, and in the units of the Monte Carlo.
-////////////////////////////////////////////////////////////////////////
- AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- Float_t g[3],l[3];
-
- g[0] = fPx;
- g[1] = fPy;
- g[2] = fPz;
- if (gm) {
- gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
- return l[2];
- } else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return fPz;
- }
+TParticle * AliITShit::GetParticle() const {
+ // Returns the pointer to the TParticle for the particle that created
+ // this hit. From the TParticle all kinds of information about this
+ // particle can be found. See the TParticle class.
+ // Inputs:
+ // none.
+ // Outputs:
+ // none.
+ // Return:
+ // The TParticle of the track that created this hit.
+ return gAlice->GetMCApp()->Particle(GetTrack());
}
-//___________________________________________________________________________;
-Int_t AliITShit::GetModule(){
-////////////////////////////////////////////////////////////////////////
-// Returns the module index number of the module where this hit was in.
-////////////////////////////////////////////////////////////////////////
+//----------------------------------------------------------------------
+void AliITShit::GetDetectorID(Int_t &layer,Int_t &ladder,Int_t &det)const{
+ // Returns the layer ladder and detector number lables for this
+ // ITS module. The use of layer, ladder and detector number for
+ // discribing the ITS is obsoleate.
+ // Inputs:
+ // none.
+ // Outputs:
+ // Int_t &layer Layer lable
+ // Int_t &ladder Ladder lable
+ // Int_t &det Detector lable
+ // Return:
+ // none.
AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
- if (gm) return gm->GetModuleIndex(fLayer,fLadder,fDet);
- else {
- Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
- return 0;
- }
-}
-//______________________________________________________________________
-TParticle * AliITShit::GetParticle(){
-////////////////////////////////////////////////////////////////////////
-// Returns the pointer to the TParticle for the particle that created
-// this hit. From the TParticle all kinds of information about this
-// particle can be found. See the TParticle class.
-////////////////////////////////////////////////////////////////////////
- return gAlice->Particle(GetTrack());
+ gm->GetModuleId(fModule,layer,ladder,det);
+ return;
}
//----------------------------------------------------------------------
-void AliITShit::Print(ostream *os){
-////////////////////////////////////////////////////////////////////////
-// Standard output format for this class.
-////////////////////////////////////////////////////////////////////////
+void AliITShit::Print(ostream *os) const {
+ // Standard output format for this class.
+ // Inputs:
+ // ostream *os The output stream
+ // Outputs:
+ // none.
+ // Return:
+ // none.
+
#if defined __GNUC__
#if __GNUC__ > 2
ios::fmtflags fmt;
Int_t fmt;
#endif
#else
-#if defined __ICC || defined __ECC
+#if defined __ICC || defined __ECC || defined __xlC__
ios::fmtflags fmt;
#else
Int_t fmt;
fmt = os->setf(ios::hex); // set hex for fStatus only.
*os << fStatus << " ";
fmt = os->setf(ios::dec); // every thing else decimel.
- *os << fLayer << " " << fLadder << " " << fDet << " ";;
+ *os << fModule << " ";
*os << fPx << " " << fPy << " " << fPz << " ";
*os << fDestep << " " << fTof;
*os << " " << fx0 << " " << fy0 << " " << fz0;
return;
}
//----------------------------------------------------------------------
-void AliITShit::Read(istream *is){
-////////////////////////////////////////////////////////////////////////
-// Standard input format for this class.
-////////////////////////////////////////////////////////////////////////
-
+void AliITShit::Read(istream *is) {
+ // Standard input format for this class.
+ // Inputs:
+ // istream *is the input stream
+ // Outputs:
+ // none.
+ // Return:
+ // none.
*is >> fTrack >> fX >> fY >> fZ;
- *is >> fStatus >> fLayer >> fLadder >> fDet >> fPx >> fPy >> fPz >>
- fDestep >> fTof;
+ *is >> fStatus >> fModule >> fPx >> fPy >> fPz >> fDestep >> fTof;
*is >> fx0 >> fy0 >> fz0;
return;
}
//----------------------------------------------------------------------
ostream &operator<<(ostream &os,AliITShit &p){
-////////////////////////////////////////////////////////////////////////
-// Standard output streaming function.
-////////////////////////////////////////////////////////////////////////
-
+ // Standard output streaming function.
+ // Inputs:
+ // ostream os The output stream
+ // AliITShit p The his to be printed out
+ // Outputs:
+ // none.
+ // Return:
+ // The input stream
+
p.Print(&os);
return os;
}
//----------------------------------------------------------------------
istream &operator>>(istream &is,AliITShit &r){
-////////////////////////////////////////////////////////////////////////
-// Standard input streaming function.
-////////////////////////////////////////////////////////////////////////
-
+ // Standard input streaming function.
+ // Inputs:
+ // istream is The input stream
+ // AliITShit p The AliITShit class to be filled from this input stream
+ // Outputs:
+ // none.
+ // Return:
+ // The input stream
+
r.Read(&is);
return is;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff