[u/mrichter/AliRoot.git] / ITS / AliITSmodule.cxx

/**************************************************************************
 * 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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.12  2002/06/10 17:31:03  nilsen
Replaced TArrayI expansion with Root version.

Revision 1.11  2002/06/04 18:43:15  nilsen
Fix to avoid divide by zero problem in MedianHitG and MedianHitL for track
that enter and exit the same side of a detector sensitive volume. Needed
for Fast simulation. Thanks to Nicola Carrer.

Revision 1.10  2002/03/15 17:21:54  nilsen
Removed zero-ing of fModules variable in constructors.

Revision 1.9  2000/10/04 19:46:39  barbera
Corrected by F. Carminati for v3.04

Revision 1.8  2000/10/02 16:32:57  barbera
Forward declarations added and formatting

Revision 1.3.4.8  2000/10/02 15:55:26  barbera
Forward declarations added and formatting

Revision 1.7  2000/09/22 12:36:38  nilsen
Minor changes to improve compilation and create less NOISE.

Revision 1.6  2000/07/10 16:07:18  fca
Release version of ITS code

Revision 1.3.4.2  2000/03/02 21:42:29  nilsen 
Linked AliDetector::fDigit to AliITSmodule::fDigitsM and AliITS::fITSRecPoints
to AliITSmodule::fRecPointsM. Renamed AliITSmodule::fPointsM to fRecPointsM.
Removed the deletion of fDigitsM from the distructor since it is only a copy
of what is in AliDetector. Fixed a bug in the functions LineSegmentL and
LineSegmentG. Added two new versions of LineSegmentL and LineSegmentG to
additionaly return track number from the hit. Removed FastPoint function,
haven't found anywere it was used, also it had very many problems, should
just call FastPointSPD... .

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/10/04 15:20:12  fca
Correct syntax accepted by g++ but not standard for static members, remove minor warnings

Revision 1.2  1999/09/29 09:24:20  fca
Introduction of the Copyright and cvs Log

*/

#include <TArrayI.h>

#include <stdlib.h>

#include "AliRun.h"
#include "AliITS.h"
#include "AliITShit.h"
#include "AliITSmodule.h"
#include "AliITSgeom.h"

ClassImp(AliITSmodule)

//_______________________________________________________________________
//
// Impementation of class AliITSmodule
//
// created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski 
//             R. Barbers, B. Batyunia, B. S. Nilsen
// ver 1.0     CERN 16.09.1999
//_______________________________________________________________________
//________________________________________________________________________
// 
// Constructors and deconstructor
//________________________________________________________________________
//
AliITSmodule::AliITSmodule() {
    // constructor

    fHitsM       = 0;
    fTrackIndex  = 0;
    fHitIndex    = 0;
    fITS         = 0;

}
//_________________________________________________________________________
AliITSmodule::AliITSmodule(Int_t index) {
  // constructor

    fIndex      = index;
    fHitsM      = new TObjArray();
    fTrackIndex = new TArrayI(16);
    fHitIndex   = new TArrayI(16);
    fITS        = (AliITS*)(gAlice->GetDetector("ITS"));
}
//__________________________________________________________________________
AliITSmodule::~AliITSmodule() {
    // The destructor for AliITSmodule. Before destoring AliITSmodule
    // we must first destroy all of it's members.

    if(fHitsM){
	for(Int_t i=0;i<fHitsM->GetEntriesFast();i++) 
	    delete ((AliITShit *)(fHitsM->At(i)));
	// must delete each object in the TObjArray.
	delete fHitsM;
    } // end if
    delete fTrackIndex;
    delete fHitIndex;
    fITS = 0; // We don't delete this pointer since it is just a copy.
}
//____________________________________________________________________________
AliITSmodule::AliITSmodule(const AliITSmodule &source){
////////////////////////////////////////////////////////////////////////
//     Copy Constructor 
////////////////////////////////////////////////////////////////////////
  printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
  exit(1);
}

//_____________________________________________________________________________
AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
////////////////////////////////////////////////////////////////////////
//    Assignment operator 
////////////////////////////////////////////////////////////////////////
  printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
  exit(1);
  return *this; // fake return neded on Sun
} 

//_________________________________________________________________________
// 
// Hits management
//__________________________________________________________________________
Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
// Hits management

  //printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
    fHitsM->AddLast(new AliITShit(*hit));
    Int_t fNhitsM = fHitsM->GetEntriesFast();
    if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
      fTrackIndex->Set(fNhitsM+64);
    } // end if
    if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
      fHitIndex->Set(fNhitsM+64);
    } // end if
    (*fTrackIndex)[fNhitsM-1] = t;
    (*fHitIndex)[fNhitsM-1]   = h;
    return fNhitsM;
}
//___________________________________________________________________________
Double_t AliITSmodule::PathLength(Int_t index,AliITShit *itsHit1,
				  AliITShit *itsHit2){
  // path lenght
   Float_t  x1g,y1g,z1g;   
   Float_t  x2g,y2g,z2g;
   Double_t s;

   itsHit1->GetPositionG(x1g,y1g,z1g);
   itsHit2->GetPositionG(x2g,y2g,z2g);

   s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
		    ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
		    ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
   return s;
}
//___________________________________________________________________________
void AliITSmodule::PathLength(Int_t index,
			      Float_t x,Float_t y,Float_t z,
			      Int_t status,Int_t &nseg,
			      Float_t &x1,Float_t &y1,Float_t &z1,
			      Float_t &dx1,Float_t &dy1,Float_t &dz1,
			      Int_t &flag){
  // path length
    static Float_t x0,y0,z0;

    if ((status&0x0002)!=0){ // entering
	x0 = x;
	y0 = y;
	z0 = z;
	nseg = 0;
	flag = 1;
    }else{
	x1 = x0;
	y1 = y0;
	z1 = z0;
	dx1 = x-x1;
	dy1 = y-y1;
	dz1 = z-z1;
	nseg++;
	if ((status&0x0004)!=0) flag = 0; //exiting
	if ((status&0x0001)!=0) flag = 2; // inside
	else flag = 2; //inside ?
	x0 = x;
	y0 = y;
	z0 = z;
    } // end if
}
//___________________________________________________________________________
Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
				  Double_t &c,Double_t &d,
				  Double_t &e,Double_t &f,Double_t &de){
  // line segment
    static Int_t hitindex0;
    AliITShit *h0,*h1;

    if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	hitindex0 = hitindex;
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    h0 = (AliITShit *) (fHitsM->At(hitindex0));
    de = h1->GetIonization();
    h0->GetPositionL(a,c,e);
    h1->GetPositionL(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    hitindex0 = hitindex;
    return kTRUE;
}
//___________________________________________________________________________
Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
				  Double_t &c,Double_t &d,
				  Double_t &e,Double_t &f,Double_t &de){
  // line segment
    static Int_t hitindex0;
    AliITShit *h0,*h1;

    if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	hitindex0 = hitindex;
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    h0 = (AliITShit *) (fHitsM->At(hitindex0));
    de = h1->GetIonization();
    h0->GetPositionG(a,c,e);
    h1->GetPositionG(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    hitindex0 = hitindex;
    return kTRUE;
}
//___________________________________________________________________________
Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
				  Double_t &c,Double_t &d,
				  Double_t &e,Double_t &f,
				  Double_t &de,Int_t &track){
  // line segmente
    static Int_t hitindex0;
    AliITShit *h0,*h1;

    if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	hitindex0 = hitindex;
	track = h1->GetTrack();
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    h0 = (AliITShit *) (fHitsM->At(hitindex0));
    de = h1->GetIonization();
    h0->GetPositionL(a,c,e);
    h1->GetPositionL(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    hitindex0 = hitindex;
    track = h1->GetTrack();
    return kTRUE;
}
//___________________________________________________________________________
Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
				  Double_t &c,Double_t &d,
				  Double_t &e,Double_t &f,
				  Double_t &de,Int_t &track){
  // line segment
    static Int_t hitindex0;
    AliITShit *h0,*h1;

    if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	hitindex0 = hitindex;
	track = h1->GetTrack();
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    h0 = (AliITShit *) (fHitsM->At(hitindex0));
    de = h1->GetIonization();
    h0->GetPositionG(a,c,e);
    h1->GetPositionG(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    hitindex0 = hitindex;
    track = h1->GetTrack();
    return kTRUE;
}
//______________________________________________________________________
Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
				Float_t &x,Float_t &y,Float_t &z){
    // Computes the mean hit location for a set of hits that make up a track
    // passing through a volume. Returns kFALSE untill the the track leaves
    // the volume.
    // median hit
   AliITSgeom *gm = fITS->GetITSgeom();
   Float_t x1l=0.,y1l=0.,z1l=0.;
   Float_t x2l=0.,y2l=0.,z2l=0.;
   Float_t xMl,yMl=0,zMl;
   Float_t l[3], g[3];

   h1->GetPositionG(x1l,y1l,z1l);
   h2->GetPositionG(x2l,y2l,z2l);

   // Modified by N.Carrer. In very rare occasions the track may be just
   // tangent to the module. Therefore the entrance and exit points have the
   // same y.
   if( (y2l-y1l) != 0.0 ) {
     xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
     zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
   } else {
     xMl = 0.5*(x1l+x2l);
     zMl = 0.5*(z1l+z2l);
   }

   l[0] = xMl;
   l[1] = yMl;
   l[2] = zMl;
   gm->LtoG(h1->GetModule(),l,g);
   x = g[0];
   y = g[1];
   z = g[2];
   return kTRUE;
}
//___________________________________________________________________________
void AliITSmodule::MedianHitG(Int_t index,
			      Float_t hitx1,Float_t hity1,Float_t hitz1,
			      Float_t hitx2,Float_t hity2,Float_t hitz2,
			      Float_t &xMg, Float_t &yMg, Float_t &zMg){
  // median hit
   AliITSgeom *gm = fITS->GetITSgeom();
   Float_t x1l,y1l,z1l;
   Float_t x2l,y2l,z2l;
   Float_t xMl,yMl=0,zMl;
   Float_t l[3], g[3];

   g[0] = hitx1;
   g[1] = hity1;
   g[2] = hitz1;
   gm->GtoL(index,g,l);
   x1l = l[0];
   y1l = l[1];
   z1l = l[2];

   g[0] = hitx2;
   g[1] = hity2;
   g[2] = hitz2;
   gm->GtoL(index,g,l);
   x2l = l[0];
   y2l = l[1];
   z2l = l[2];

   // Modified by N.Carrer. In very rare occasions the track may be just
   // tangent to the module. Therefore the entrance and exit points have the
   // same y.
   if( (y2l-y1l) != 0.0 ) {
     xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
     zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
   } else {
     xMl = 0.5*(x1l+x2l);
     zMl = 0.5*(z1l+z2l);
   }

   l[0] = xMl;
   l[1] = yMl;
   l[2] = zMl;
   gm->LtoG(index,l,g);
   xMg = g[0];
   yMg = g[1];
   zMg = g[2];
}
//___________________________________________________________________________
Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1, 
	       	    	     AliITShit *itsHit2, 
	       		     Float_t &xMl, Float_t &yMl, Float_t &zMl){
  // median hit
   Float_t x1l,y1l,z1l;
   Float_t x2l,y2l,z2l;

   itsHit1->GetPositionL(x1l,y1l,z1l);
   itsHit2->GetPositionL(x2l,y2l,z2l);

   yMl = 0.0;
   // Modified by N.Carrer. In very rare occasions the track may be just
   // tangent to the module. Therefore the entrance and exit points have the
   // same y.
   if( (y2l-y1l) != 0.0 ) {
     xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
     zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;	     
   } else {
     xMl = 0.5*(x1l+x2l);
     zMl = 0.5*(z1l+z2l);
   }
   return kTRUE;
}
//___________________________________________________________________________
void AliITSmodule::MedianHit(Int_t index,
			     Float_t xg,Float_t yg,Float_t zg,
			     Int_t status,
			     Float_t &xMg,Float_t &yMg,Float_t &zMg,
			     Int_t &flag){
  // median hit
   static Float_t x1,y1,z1;

   if ((status&0x0002)!=0){ // entering
       x1 = xg;
       y1 = yg;
       z1 = zg;
       flag = 1;
   } else if ((status&0x0004)!=0){ // exiting
       MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
       flag = 0;
   } // end if
   else  flag = 1;
}
//___________________________________________________________________________
void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
  // get ID
	fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
	return ;
}
Commit	Line	Data
4c039060	1	/**************************************************************************
4c039060	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3bd79107	3	* *
4c039060	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/*
	17	$Log$
7e3ded1b	18	Revision 1.12 2002/06/10 17:31:03 nilsen
	19	Replaced TArrayI expansion with Root version.
	20
ea008941	21	Revision 1.11 2002/06/04 18:43:15 nilsen
	22	Fix to avoid divide by zero problem in MedianHitG and MedianHitL for track
	23	that enter and exit the same side of a detector sensitive volume. Needed
	24	for Fast simulation. Thanks to Nicola Carrer.
	25
37ffef26	26	Revision 1.10 2002/03/15 17:21:54 nilsen
	27	Removed zero-ing of fModules variable in constructors.
	28
b0f0d5a5	29	Revision 1.9 2000/10/04 19:46:39 barbera
	30	Corrected by F. Carminati for v3.04
	31
114da3a4	32	Revision 1.8 2000/10/02 16:32:57 barbera
	33	Forward declarations added and formatting
	34
0b2d41b4	35	Revision 1.3.4.8 2000/10/02 15:55:26 barbera
	36	Forward declarations added and formatting
	37
	38	Revision 1.7 2000/09/22 12:36:38 nilsen
	39	Minor changes to improve compilation and create less NOISE.
	40
ff61221e	41	Revision 1.6 2000/07/10 16:07:18 fca
	42	Release version of ITS code
	43
3bd79107	44	Revision 1.3.4.2 2000/03/02 21:42:29 nilsen
	45	Linked AliDetector::fDigit to AliITSmodule::fDigitsM and AliITS::fITSRecPoints
	46	to AliITSmodule::fRecPointsM. Renamed AliITSmodule::fPointsM to fRecPointsM.
	47	Removed the deletion of fDigitsM from the distructor since it is only a copy
	48	of what is in AliDetector. Fixed a bug in the functions LineSegmentL and
	49	LineSegmentG. Added two new versions of LineSegmentL and LineSegmentG to
	50	additionaly return track number from the hit. Removed FastPoint function,
	51	haven't found anywere it was used, also it had very many problems, should
	52	just call FastPointSPD... .
	53
	54	Revision 1.3.4.1 2000/01/12 19:03:32 nilsen
	55	This is the version of the files after the merging done in December 1999.
	56	See the ReadMe110100.txt file for details
	57
	58	Revision 1.3 1999/10/04 15:20:12 fca
	59	Correct syntax accepted by g++ but not standard for static members, remove minor warnings
	60
ad0e60d9	61	Revision 1.2 1999/09/29 09:24:20 fca
	62	Introduction of the Copyright and cvs Log
	63
4c039060	64	*/
4c039060	65
ff61221e	66	#include <TArrayI.h>
ff61221e	67
114da3a4	68	#include <stdlib.h>
3bd79107	69
58005f18	70	#include "AliRun.h"
3bd79107	71	#include "AliITS.h"
ff61221e	72	#include "AliITShit.h"
	73	#include "AliITSmodule.h"
	74	#include "AliITSgeom.h"
58005f18	75
	76	ClassImp(AliITSmodule)
	77
	78	//_______________________________________________________________________
	79	//
	80	// Impementation of class AliITSmodule
	81	//
3bd79107	82	// created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski
58005f18	83	// R. Barbers, B. Batyunia, B. S. Nilsen
	84	// ver 1.0 CERN 16.09.1999
	85	//_______________________________________________________________________
58005f18	86	//________________________________________________________________________
	87	//
	88	// Constructors and deconstructor
	89	//________________________________________________________________________
	90	//
3bd79107	91	AliITSmodule::AliITSmodule() {
b0f0d5a5	92	// constructor
b0f0d5a5	93
3bd79107	94	fHitsM = 0;
	95	fTrackIndex = 0;
	96	fHitIndex = 0;
	97	fITS = 0;
58005f18	98
3bd79107	99	}
	100	//_________________________________________________________________________
	101	AliITSmodule::AliITSmodule(Int_t index) {
	102	// constructor
58005f18	103
3bd79107	104	fIndex = index;
	105	fHitsM = new TObjArray();
	106	fTrackIndex = new TArrayI(16);
	107	fHitIndex = new TArrayI(16);
	108	fITS = (AliITS*)(gAlice->GetDetector("ITS"));
	109	}
	110	//__________________________________________________________________________
	111	AliITSmodule::~AliITSmodule() {
	112	// The destructor for AliITSmodule. Before destoring AliITSmodule
	113	// we must first destroy all of it's members.
58005f18	114
3bd79107	115	if(fHitsM){
e8189707	116	for(Int_t i=0;i<fHitsM->GetEntriesFast();i++)
3bd79107	117	delete ((AliITShit *)(fHitsM->At(i)));
	118	// must delete each object in the TObjArray.
	119	delete fHitsM;
	120	} // end if
	121	delete fTrackIndex;
	122	delete fHitIndex;
	123	fITS = 0; // We don't delete this pointer since it is just a copy.
	124	}
	125	//____________________________________________________________________________
	126	AliITSmodule::AliITSmodule(const AliITSmodule &source){
	127	////////////////////////////////////////////////////////////////////////
	128	// Copy Constructor
	129	////////////////////////////////////////////////////////////////////////
	130	printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
	131	exit(1);
58005f18	132	}
58005f18	133
3bd79107	134	//_____________________________________________________________________________
	135	AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
	136	////////////////////////////////////////////////////////////////////////
	137	// Assignment operator
	138	////////////////////////////////////////////////////////////////////////
	139	printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
	140	exit(1);
e8189707	141	return *this; // fake return neded on Sun
3bd79107	142	}
58005f18	143
58005f18	144	//_________________________________________________________________________
3bd79107	145	//
	146	// Hits management
	147	//__________________________________________________________________________
	148	Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
	149	// Hits management
58005f18	150
ff61221e	151	//printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
3bd79107	152	fHitsM->AddLast(new AliITShit(*hit));
	153	Int_t fNhitsM = fHitsM->GetEntriesFast();
	154	if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
ea008941	155	fTrackIndex->Set(fNhitsM+64);
3bd79107	156	} // end if
3bd79107	157	if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
ea008941	158	fHitIndex->Set(fNhitsM+64);
3bd79107	159	} // end if
	160	(*fTrackIndex)[fNhitsM-1] = t;
	161	(*fHitIndex)[fNhitsM-1] = h;
	162	return fNhitsM;
	163	}
3bd79107	164	//___________________________________________________________________________
	165	Double_t AliITSmodule::PathLength(Int_t index,AliITShit *itsHit1,
	166	AliITShit *itsHit2){
	167	// path lenght
	168	Float_t x1g,y1g,z1g;
	169	Float_t x2g,y2g,z2g;
	170	Double_t s;
58005f18	171
3bd79107	172	itsHit1->GetPositionG(x1g,y1g,z1g);
3bd79107	173	itsHit2->GetPositionG(x2g,y2g,z2g);
58005f18	174
3bd79107	175	s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
	176	((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
	177	((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g)) );
	178	return s;
	179	}
	180	//___________________________________________________________________________
	181	void AliITSmodule::PathLength(Int_t index,
	182	Float_t x,Float_t y,Float_t z,
	183	Int_t status,Int_t &nseg,
	184	Float_t &x1,Float_t &y1,Float_t &z1,
	185	Float_t &dx1,Float_t &dy1,Float_t &dz1,
	186	Int_t &flag){
	187	// path length
	188	static Float_t x0,y0,z0;
58005f18	189
7e3ded1b	190	if ((status&0x0002)!=0){ // entering
3bd79107	191	x0 = x;
	192	y0 = y;
	193	z0 = z;
	194	nseg = 0;
	195	flag = 1;
	196	}else{
	197	x1 = x0;
	198	y1 = y0;
	199	z1 = z0;
	200	dx1 = x-x1;
	201	dy1 = y-y1;
	202	dz1 = z-z1;
	203	nseg++;
7e3ded1b	204	if ((status&0x0004)!=0) flag = 0; //exiting
	205	if ((status&0x0001)!=0) flag = 2; // inside
	206	else flag = 2; //inside ?
3bd79107	207	x0 = x;
	208	y0 = y;
	209	z0 = z;
	210	} // end if
58005f18	211	}
3bd79107	212	//___________________________________________________________________________
	213	Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
	214	Double_t &c,Double_t &d,
	215	Double_t &e,Double_t &f,Double_t &de){
	216	// line segment
	217	static Int_t hitindex0;
	218	AliITShit h0,h1;
58005f18	219
3bd79107	220	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
58005f18	221
3bd79107	222	h1 = (AliITShit *) (fHitsM->At(hitindex));
	223	if(h1->StatusEntering()){ // if track entering volume, get index for next
	224	// step
	225	hitindex0 = hitindex;
	226	return kFALSE;
	227	} // end if StatusEntering()
	228	// else stepping
	229	h0 = (AliITShit *) (fHitsM->At(hitindex0));
	230	de = h1->GetIonization();
	231	h0->GetPositionL(a,c,e);
	232	h1->GetPositionL(b,d,f);
	233	b = b - a;
	234	d = d - c;
	235	f = f - e;
	236	hitindex0 = hitindex;
	237	return kTRUE;
	238	}
	239	//___________________________________________________________________________
	240	Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
	241	Double_t &c,Double_t &d,
	242	Double_t &e,Double_t &f,Double_t &de){
	243	// line segment
	244	static Int_t hitindex0;
	245	AliITShit h0,h1;
58005f18	246
3bd79107	247	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	248
	249	h1 = (AliITShit *) (fHitsM->At(hitindex));
	250	if(h1->StatusEntering()){ // if track entering volume, get index for next
	251	// step
	252	hitindex0 = hitindex;
	253	return kFALSE;
	254	} // end if StatusEntering()
	255	// else stepping
	256	h0 = (AliITShit *) (fHitsM->At(hitindex0));
	257	de = h1->GetIonization();
	258	h0->GetPositionG(a,c,e);
	259	h1->GetPositionG(b,d,f);
	260	b = b - a;
	261	d = d - c;
	262	f = f - e;
	263	hitindex0 = hitindex;
	264	return kTRUE;
	265	}
	266	//___________________________________________________________________________
	267	Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
	268	Double_t &c,Double_t &d,
	269	Double_t &e,Double_t &f,
	270	Double_t &de,Int_t &track){
	271	// line segmente
	272	static Int_t hitindex0;
	273	AliITShit h0,h1;
	274
	275	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	276
	277	h1 = (AliITShit *) (fHitsM->At(hitindex));
	278	if(h1->StatusEntering()){ // if track entering volume, get index for next
	279	// step
	280	hitindex0 = hitindex;
	281	track = h1->GetTrack();
	282	return kFALSE;
	283	} // end if StatusEntering()
	284	// else stepping
	285	h0 = (AliITShit *) (fHitsM->At(hitindex0));
	286	de = h1->GetIonization();
	287	h0->GetPositionL(a,c,e);
	288	h1->GetPositionL(b,d,f);
	289	b = b - a;
	290	d = d - c;
	291	f = f - e;
	292	hitindex0 = hitindex;
	293	track = h1->GetTrack();
	294	return kTRUE;
	295	}
	296	//___________________________________________________________________________
	297	Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
	298	Double_t &c,Double_t &d,
	299	Double_t &e,Double_t &f,
	300	Double_t &de,Int_t &track){
	301	// line segment
	302	static Int_t hitindex0;
	303	AliITShit h0,h1;
	304
	305	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	306
	307	h1 = (AliITShit *) (fHitsM->At(hitindex));
	308	if(h1->StatusEntering()){ // if track entering volume, get index for next
	309	// step
	310	hitindex0 = hitindex;
311	track = h1->GetTrack();
312	return kFALSE;
313	} // end if StatusEntering()
314	// else stepping
315	h0 = (AliITShit *) (fHitsM->At(hitindex0));
316	de = h1->GetIonization();
317	h0->GetPositionG(a,c,e);
318	h1->GetPositionG(b,d,f);
319	b = b - a;
320	d = d - c;
321	f = f - e;
322	hitindex0 = hitindex;
323	track = h1->GetTrack();
324	return kTRUE;
58005f18	325	}
7e3ded1b	326	//______________________________________________________________________
	327	Bool_t AliITSmodule::MedianHitG(AliITShit h1,AliITShit h2,
	328	Float_t &x,Float_t &y,Float_t &z){
	329	// Computes the mean hit location for a set of hits that make up a track
	330	// passing through a volume. Returns kFALSE untill the the track leaves
	331	// the volume.
	332	// median hit
	333	AliITSgeom *gm = fITS->GetITSgeom();
	334	Float_t x1l=0.,y1l=0.,z1l=0.;
	335	Float_t x2l=0.,y2l=0.,z2l=0.;
	336	Float_t xMl,yMl=0,zMl;
	337	Float_t l[3], g[3];
	338
	339	h1->GetPositionG(x1l,y1l,z1l);
	340	h2->GetPositionG(x2l,y2l,z2l);
	341
	342	// Modified by N.Carrer. In very rare occasions the track may be just
	343	// tangent to the module. Therefore the entrance and exit points have the
	344	// same y.
	345	if( (y2l-y1l) != 0.0 ) {
	346	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
	347	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
	348	} else {
	349	xMl = 0.5*(x1l+x2l);
	350	zMl = 0.5*(z1l+z2l);
	351	}
	352
	353	l[0] = xMl;
	354	l[1] = yMl;
	355	l[2] = zMl;
	356	gm->LtoG(h1->GetModule(),l,g);
	357	x = g[0];
	358	y = g[1];
	359	z = g[2];
	360	return kTRUE;
	361	}
	362	//___________________________________________________________________________
	363	void AliITSmodule::MedianHitG(Int_t index,
	364	Float_t hitx1,Float_t hity1,Float_t hitz1,
	365	Float_t hitx2,Float_t hity2,Float_t hitz2,
	366	Float_t &xMg, Float_t &yMg, Float_t &zMg){
	367	// median hit
	368	AliITSgeom *gm = fITS->GetITSgeom();
	369	Float_t x1l,y1l,z1l;
	370	Float_t x2l,y2l,z2l;
	371	Float_t xMl,yMl=0,zMl;
	372	Float_t l[3], g[3];
	373
	374	g[0] = hitx1;
	375	g[1] = hity1;
	376	g[2] = hitz1;
	377	gm->GtoL(index,g,l);
	378	x1l = l[0];
	379	y1l = l[1];
	380	z1l = l[2];
	381
	382	g[0] = hitx2;
	383	g[1] = hity2;
	384	g[2] = hitz2;
	385	gm->GtoL(index,g,l);
	386	x2l = l[0];
	387	y2l = l[1];
	388	z2l = l[2];
	389
390	// Modified by N.Carrer. In very rare occasions the track may be just
391	// tangent to the module. Therefore the entrance and exit points have the
392	// same y.
393	if( (y2l-y1l) != 0.0 ) {
394	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
395	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
396	} else {
397	xMl = 0.5*(x1l+x2l);
398	zMl = 0.5*(z1l+z2l);
399	}
400
401	l[0] = xMl;
402	l[1] = yMl;
403	l[2] = zMl;
404	gm->LtoG(index,l,g);
405	xMg = g[0];
406	yMg = g[1];
407	zMg = g[2];
408	}
3bd79107	409	//___________________________________________________________________________
7e3ded1b	410	Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1,
3bd79107	411	AliITShit *itsHit2,
	412	Float_t &xMl, Float_t &yMl, Float_t &zMl){
	413	// median hit
	414	Float_t x1l,y1l,z1l;
	415	Float_t x2l,y2l,z2l;
	416
	417	itsHit1->GetPositionL(x1l,y1l,z1l);
	418	itsHit2->GetPositionL(x2l,y2l,z2l);
58005f18	419
3bd79107	420	yMl = 0.0;
37ffef26	421	// Modified by N.Carrer. In very rare occasions the track may be just
	422	// tangent to the module. Therefore the entrance and exit points have the
	423	// same y.
	424	if( (y2l-y1l) != 0.0 ) {
	425	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
	426	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
	427	} else {
	428	xMl = 0.5*(x1l+x2l);
	429	zMl = 0.5*(z1l+z2l);
	430	}
7e3ded1b	431	return kTRUE;
3bd79107	432	}
58005f18	433	//___________________________________________________________________________
3bd79107	434	void AliITSmodule::MedianHit(Int_t index,
	435	Float_t xg,Float_t yg,Float_t zg,
	436	Int_t status,
	437	Float_t &xMg,Float_t &yMg,Float_t &zMg,
	438	Int_t &flag){
	439	// median hit
	440	static Float_t x1,y1,z1;
	441
7e3ded1b	442	if ((status&0x0002)!=0){ // entering
3bd79107	443	x1 = xg;
	444	y1 = yg;
	445	z1 = zg;
	446	flag = 1;
7e3ded1b	447	} else if ((status&0x0004)!=0){ // exiting
3bd79107	448	MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
	449	flag = 0;
	450	} // end if
7e3ded1b	451	else flag = 1;
58005f18	452	}
3bd79107	453	//___________________________________________________________________________
	454	void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
	455	// get ID
	456	fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
	457	return ;
	458	}
	459