[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.15  2003/03/21 13:58:14  masera
Fix to avoid out-of-detector fast rec points (problem occurring for tracks entering and exiting the same side of a sensitive volume)

Revision 1.14  2002/10/14 14:57:00  hristov
Merging the VirtualMC branch to the main development branch (HEAD)

Revision 1.10.4.2  2002/07/24 09:27:50  alibrary
Updating on VirtualMC

Revision 1.13  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.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){
      fHitsM->Delete();
      delete fHitsM;
      fHitsM = 0;
    } // 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);

   if((y2l*y1l)<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];

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