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

/* $Id$ */

#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():
fITS(0),
fIndex(0),
fHitsM(0),
fTrackIndex(0),
fHitIndex(0) {
    // constructor

}
//_________________________________________________________________________
AliITSmodule::AliITSmodule(Int_t index):
fITS(0),
fIndex(index),
fHitsM(0),
fTrackIndex(0),
fHitIndex(0) {
  // constructor

    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):TObject(source),
fITS(source.fITS),
fIndex(source.fIndex),
fHitsM(source.fHitsM),
fTrackIndex(source.fTrackIndex),
fHitIndex(source.fHitIndex){
////////////////////////////////////////////////////////////////////////
//     Copy Constructor 
////////////////////////////////////////////////////////////////////////

}
//_____________________________________________________________________________
AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
////////////////////////////////////////////////////////////////////////
//    Assignment operator 
////////////////////////////////////////////////////////////////////////
  this->~AliITSmodule();
  new(this) AliITSmodule(source);
  return *this;
}
//_________________________________________________________________________
// 
// 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(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(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) const{
  // 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
    AliITShit *h1;
    Double_t t;

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

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    de = h1->GetIonization();
    h1->GetPositionL0(a,c,e,t);
    h1->GetPositionL(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    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
    AliITShit *h1;
    Double_t t;

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

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    de = h1->GetIonization();
    h1->GetPositionG0(a,c,e,t);
    h1->GetPositionG(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    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
    AliITShit *h1;
    Double_t t;

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

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	track = h1->GetTrack();
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    de = h1->GetIonization();
    h1->GetPositionL0(a,c,e,t);
    h1->GetPositionL(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    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
    AliITShit *h1;
    Double_t t;

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

    h1 = (AliITShit *) (fHitsM->At(hitindex));
    if(h1->StatusEntering()){ // if track entering volume, get index for next
	                      // step
	track = h1->GetTrack();
	return kFALSE;
    } // end if StatusEntering()
    // else stepping
    de = h1->GetIonization();
    h1->GetPositionG0(a,c,e,t);
    h1->GetPositionG(b,d,f);
    b = b - a;
    d = d - c;
    f = f - e;
    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) const{
  // 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. *
803d1ab0	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
803d1ab0	16	/* $Id$ */
4c039060	17
ff61221e	18	#include <TArrayI.h>
ff61221e	19
114da3a4	20	#include <stdlib.h>
3bd79107	21
58005f18	22	#include "AliRun.h"
3bd79107	23	#include "AliITS.h"
ff61221e	24	#include "AliITShit.h"
	25	#include "AliITSmodule.h"
	26	#include "AliITSgeom.h"
58005f18	27
	28	ClassImp(AliITSmodule)
	29
	30	//_______________________________________________________________________
	31	//
	32	// Impementation of class AliITSmodule
	33	//
3bd79107	34	// created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski
58005f18	35	// R. Barbers, B. Batyunia, B. S. Nilsen
	36	// ver 1.0 CERN 16.09.1999
	37	//_______________________________________________________________________
58005f18	38	//________________________________________________________________________
	39	//
	40	// Constructors and deconstructor
	41	//________________________________________________________________________
	42	//
7537d03c	43	AliITSmodule::AliITSmodule():
	44	fITS(0),
	45	fIndex(0),
	46	fHitsM(0),
	47	fTrackIndex(0),
	48	fHitIndex(0) {
b0f0d5a5	49	// constructor
b0f0d5a5	50
3bd79107	51	}
3bd79107	52	//_________________________________________________________________________
7537d03c	53	AliITSmodule::AliITSmodule(Int_t index):
	54	fITS(0),
	55	fIndex(index),
	56	fHitsM(0),
	57	fTrackIndex(0),
	58	fHitIndex(0) {
3bd79107	59	// constructor
58005f18	60
3bd79107	61	fHitsM = new TObjArray();
	62	fTrackIndex = new TArrayI(16);
	63	fHitIndex = new TArrayI(16);
	64	fITS = (AliITS*)(gAlice->GetDetector("ITS"));
	65	}
	66	//__________________________________________________________________________
	67	AliITSmodule::~AliITSmodule() {
	68	// The destructor for AliITSmodule. Before destoring AliITSmodule
	69	// we must first destroy all of it's members.
58005f18	70
3bd79107	71	if(fHitsM){
279a35d7	72	fHitsM->Delete();
	73	delete fHitsM;
	74	fHitsM = 0;
3bd79107	75	} // end if
	76	delete fTrackIndex;
	77	delete fHitIndex;
	78	fITS = 0; // We don't delete this pointer since it is just a copy.
	79	}
	80	//____________________________________________________________________________
7537d03c	81	AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source),
	82	fITS(source.fITS),
	83	fIndex(source.fIndex),
	84	fHitsM(source.fHitsM),
	85	fTrackIndex(source.fTrackIndex),
	86	fHitIndex(source.fHitIndex){
3bd79107	87	////////////////////////////////////////////////////////////////////////
	88	// Copy Constructor
	89	////////////////////////////////////////////////////////////////////////
7537d03c	90
58005f18	91	}
3bd79107	92	//_____________________________________________________________________________
	93	AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
	94	////////////////////////////////////////////////////////////////////////
	95	// Assignment operator
	96	////////////////////////////////////////////////////////////////////////
7537d03c	97	this->~AliITSmodule();
	98	new(this) AliITSmodule(source);
	99	return *this;
88cb7938	100	}
58005f18	101	//_________________________________________________________________________
3bd79107	102	//
	103	// Hits management
	104	//__________________________________________________________________________
	105	Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
	106	// Hits management
58005f18	107
ff61221e	108	//printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
3bd79107	109	fHitsM->AddLast(new AliITShit(*hit));
	110	Int_t fNhitsM = fHitsM->GetEntriesFast();
	111	if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
ea008941	112	fTrackIndex->Set(fNhitsM+64);
3bd79107	113	} // end if
3bd79107	114	if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
ea008941	115	fHitIndex->Set(fNhitsM+64);
3bd79107	116	} // end if
	117	(*fTrackIndex)[fNhitsM-1] = t;
	118	(*fHitIndex)[fNhitsM-1] = h;
	119	return fNhitsM;
	120	}
3bd79107	121	//___________________________________________________________________________
475c592b	122	Double_t AliITSmodule::PathLength(AliITShit *itsHit1,
7d62fb64	123	AliITShit *itsHit2) {
3bd79107	124	// path lenght
	125	Float_t x1g,y1g,z1g;
	126	Float_t x2g,y2g,z2g;
	127	Double_t s;
58005f18	128
3bd79107	129	itsHit1->GetPositionG(x1g,y1g,z1g);
3bd79107	130	itsHit2->GetPositionG(x2g,y2g,z2g);
58005f18	131
3bd79107	132	s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
	133	((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
	134	((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g)) );
	135	return s;
	136	}
	137	//___________________________________________________________________________
475c592b	138	void AliITSmodule::PathLength(Float_t x,Float_t y,Float_t z,
3bd79107	139	Int_t status,Int_t &nseg,
	140	Float_t &x1,Float_t &y1,Float_t &z1,
	141	Float_t &dx1,Float_t &dy1,Float_t &dz1,
7d62fb64	142	Int_t &flag) const{
3bd79107	143	// path length
3bd79107	144	static Float_t x0,y0,z0;
58005f18	145
7e3ded1b	146	if ((status&0x0002)!=0){ // entering
3bd79107	147	x0 = x;
	148	y0 = y;
	149	z0 = z;
	150	nseg = 0;
	151	flag = 1;
	152	}else{
	153	x1 = x0;
	154	y1 = y0;
	155	z1 = z0;
	156	dx1 = x-x1;
	157	dy1 = y-y1;
	158	dz1 = z-z1;
	159	nseg++;
7e3ded1b	160	if ((status&0x0004)!=0) flag = 0; //exiting
	161	if ((status&0x0001)!=0) flag = 2; // inside
	162	else flag = 2; //inside ?
3bd79107	163	x0 = x;
	164	y0 = y;
	165	z0 = z;
	166	} // end if
58005f18	167	}
3bd79107	168	//___________________________________________________________________________
	169	Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
	170	Double_t &c,Double_t &d,
	171	Double_t &e,Double_t &f,Double_t &de){
	172	// line segment
88cb7938	173	AliITShit *h1;
88cb7938	174	Double_t t;
58005f18	175
3bd79107	176	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
58005f18	177
3bd79107	178	h1 = (AliITShit *) (fHitsM->At(hitindex));
	179	if(h1->StatusEntering()){ // if track entering volume, get index for next
	180	// step
3bd79107	181	return kFALSE;
	182	} // end if StatusEntering()
	183	// else stepping
3bd79107	184	de = h1->GetIonization();
88cb7938	185	h1->GetPositionL0(a,c,e,t);
3bd79107	186	h1->GetPositionL(b,d,f);
	187	b = b - a;
	188	d = d - c;
	189	f = f - e;
3bd79107	190	return kTRUE;
	191	}
	192	//___________________________________________________________________________
	193	Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
	194	Double_t &c,Double_t &d,
	195	Double_t &e,Double_t &f,Double_t &de){
	196	// line segment
88cb7938	197	AliITShit *h1;
88cb7938	198	Double_t t;
58005f18	199
3bd79107	200	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	201
	202	h1 = (AliITShit *) (fHitsM->At(hitindex));
	203	if(h1->StatusEntering()){ // if track entering volume, get index for next
	204	// step
3bd79107	205	return kFALSE;
	206	} // end if StatusEntering()
	207	// else stepping
3bd79107	208	de = h1->GetIonization();
88cb7938	209	h1->GetPositionG0(a,c,e,t);
3bd79107	210	h1->GetPositionG(b,d,f);
	211	b = b - a;
	212	d = d - c;
	213	f = f - e;
3bd79107	214	return kTRUE;
	215	}
	216	//___________________________________________________________________________
	217	Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
	218	Double_t &c,Double_t &d,
	219	Double_t &e,Double_t &f,
	220	Double_t &de,Int_t &track){
	221	// line segmente
88cb7938	222	AliITShit *h1;
88cb7938	223	Double_t t;
3bd79107	224
	225	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	226
	227	h1 = (AliITShit *) (fHitsM->At(hitindex));
	228	if(h1->StatusEntering()){ // if track entering volume, get index for next
	229	// step
3bd79107	230	track = h1->GetTrack();
	231	return kFALSE;
	232	} // end if StatusEntering()
	233	// else stepping
3bd79107	234	de = h1->GetIonization();
88cb7938	235	h1->GetPositionL0(a,c,e,t);
3bd79107	236	h1->GetPositionL(b,d,f);
	237	b = b - a;
	238	d = d - c;
	239	f = f - e;
3bd79107	240	track = h1->GetTrack();
	241	return kTRUE;
	242	}
	243	//___________________________________________________________________________
	244	Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
	245	Double_t &c,Double_t &d,
	246	Double_t &e,Double_t &f,
	247	Double_t &de,Int_t &track){
	248	// line segment
88cb7938	249	AliITShit *h1;
88cb7938	250	Double_t t;
3bd79107	251
	252	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	253
	254	h1 = (AliITShit *) (fHitsM->At(hitindex));
	255	if(h1->StatusEntering()){ // if track entering volume, get index for next
	256	// step
3bd79107	257	track = h1->GetTrack();
	258	return kFALSE;
	259	} // end if StatusEntering()
	260	// else stepping
3bd79107	261	de = h1->GetIonization();
88cb7938	262	h1->GetPositionG0(a,c,e,t);
3bd79107	263	h1->GetPositionG(b,d,f);
	264	b = b - a;
	265	d = d - c;
	266	f = f - e;
3bd79107	267	track = h1->GetTrack();
3bd79107	268	return kTRUE;
58005f18	269	}
7e3ded1b	270	//______________________________________________________________________
	271	Bool_t AliITSmodule::MedianHitG(AliITShit h1,AliITShit h2,
	272	Float_t &x,Float_t &y,Float_t &z){
	273	// Computes the mean hit location for a set of hits that make up a track
	274	// passing through a volume. Returns kFALSE untill the the track leaves
	275	// the volume.
	276	// median hit
	277	AliITSgeom *gm = fITS->GetITSgeom();
	278	Float_t x1l=0.,y1l=0.,z1l=0.;
	279	Float_t x2l=0.,y2l=0.,z2l=0.;
	280	Float_t xMl,yMl=0,zMl;
	281	Float_t l[3], g[3];
	282
	283	h1->GetPositionG(x1l,y1l,z1l);
	284	h2->GetPositionG(x2l,y2l,z2l);
	285
6d48704c	286	if((y2l*y1l)<0.) {
7e3ded1b	287	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
	288	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
	289	} else {
	290	xMl = 0.5*(x1l+x2l);
	291	zMl = 0.5*(z1l+z2l);
	292	}
	293
	294	l[0] = xMl;
	295	l[1] = yMl;
	296	l[2] = zMl;
	297	gm->LtoG(h1->GetModule(),l,g);
	298	x = g[0];
	299	y = g[1];
	300	z = g[2];
	301	return kTRUE;
	302	}
	303	//___________________________________________________________________________
	304	void AliITSmodule::MedianHitG(Int_t index,
	305	Float_t hitx1,Float_t hity1,Float_t hitz1,
	306	Float_t hitx2,Float_t hity2,Float_t hitz2,
	307	Float_t &xMg, Float_t &yMg, Float_t &zMg){
	308	// median hit
	309	AliITSgeom *gm = fITS->GetITSgeom();
	310	Float_t x1l,y1l,z1l;
	311	Float_t x2l,y2l,z2l;
	312	Float_t xMl,yMl=0,zMl;
	313	Float_t l[3], g[3];
	314
	315	g[0] = hitx1;
	316	g[1] = hity1;
	317	g[2] = hitz1;
	318	gm->GtoL(index,g,l);
	319	x1l = l[0];
	320	y1l = l[1];
	321	z1l = l[2];
	322
	323	g[0] = hitx2;
	324	g[1] = hity2;
	325	g[2] = hitz2;
	326	gm->GtoL(index,g,l);
	327	x2l = l[0];
	328	y2l = l[1];
	329	z2l = l[2];
	330
6d48704c	331	if((y2l*y1l)<0.) {
7e3ded1b	332	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
	333	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
	334	} else {
	335	xMl = 0.5*(x1l+x2l);
	336	zMl = 0.5*(z1l+z2l);
	337	}
	338
	339	l[0] = xMl;
	340	l[1] = yMl;
	341	l[2] = zMl;
	342	gm->LtoG(index,l,g);
	343	xMg = g[0];
	344	yMg = g[1];
	345	zMg = g[2];
	346	}
3bd79107	347	//___________________________________________________________________________
7e3ded1b	348	Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1,
3bd79107	349	AliITShit *itsHit2,
7d62fb64	350	Float_t &xMl, Float_t &yMl, Float_t &zMl) const{
3bd79107	351	// median hit
	352	Float_t x1l,y1l,z1l;
	353	Float_t x2l,y2l,z2l;
	354
	355	itsHit1->GetPositionL(x1l,y1l,z1l);
	356	itsHit2->GetPositionL(x2l,y2l,z2l);
58005f18	357
3bd79107	358	yMl = 0.0;
6d48704c	359	if((y2l*y1l)<0.) {
37ffef26	360	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
	361	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
	362	} else {
	363	xMl = 0.5*(x1l+x2l);
	364	zMl = 0.5*(z1l+z2l);
	365	}
7e3ded1b	366	return kTRUE;
3bd79107	367	}
58005f18	368	//___________________________________________________________________________
3bd79107	369	void AliITSmodule::MedianHit(Int_t index,
	370	Float_t xg,Float_t yg,Float_t zg,
	371	Int_t status,
	372	Float_t &xMg,Float_t &yMg,Float_t &zMg,
	373	Int_t &flag){
	374	// median hit
	375	static Float_t x1,y1,z1;
	376
7e3ded1b	377	if ((status&0x0002)!=0){ // entering
3bd79107	378	x1 = xg;
	379	y1 = yg;
	380	z1 = zg;
	381	flag = 1;
7e3ded1b	382	} else if ((status&0x0004)!=0){ // exiting
3bd79107	383	MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
	384	flag = 0;
	385	} // end if
7e3ded1b	386	else flag = 1;
58005f18	387	}
3bd79107	388	//___________________________________________________________________________
	389	void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
	390	// get ID
	391	fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
	392	return ;
	393	}
	394