[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() {
    // 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):TObject(source){
////////////////////////////////////////////////////////////////////////
//     Copy Constructor 
////////////////////////////////////////////////////////////////////////
  Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
  exit(1);
}
//_____________________________________________________________________________
AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
////////////////////////////////////////////////////////////////////////
//    Assignment operator 
////////////////////////////////////////////////////////////////////////
    if(&source == this) return *this;
    Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
    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;

   index = 0;
   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;

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