[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUModule.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: AliITSUModule.cxx 53509 2011-12-10 18:55:52Z masera $ */

#include <TArrayI.h>

#include <stdlib.h>

#include "AliRun.h"
#include "AliITS.h"
#include "AliITSUModule.h"
#include "AliITSUGeomTGeo.h"
using namespace TMath;

ClassImp(AliITSUModule)

//_______________________________________________________________________
//
// Impementation of class AliITSUModule
//
// 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
//________________________________________________________________________
//
AliITSUModule::AliITSUModule()
:  fHitsM(0)
  ,fGeomTG(0)
{
  // constructor
}

//_________________________________________________________________________
AliITSUModule::AliITSUModule(Int_t index, AliITSUGeomTGeo* tg)
  :fHitsM(new TObjArray())
  ,fGeomTG(tg)
{
  // constructor
  SetIndex(index);
}

//__________________________________________________________________________
AliITSUModule::~AliITSUModule() 
{
  // The destructor for AliITSUModule. Before destoring AliITSUModule
  // we must first destroy all of it's members.
  if (fHitsM) fHitsM->Clear();
  delete fHitsM;
}

//____________________________________________________________________________
AliITSUModule::AliITSUModule(const AliITSUModule &source)
 :TObject(source)
 ,fHitsM(source.fHitsM)
 ,fGeomTG(source.fGeomTG)
{
//     Copy Constructor 
}

//_____________________________________________________________________________
AliITSUModule& AliITSUModule::operator=(const AliITSUModule &source)
{
  //    Assignment operator 
  if (this!=&source) {
    this->~AliITSUModule();
    new(this) AliITSUModule(source);
  }
  return *this;
}

//___________________________________________________________________________
Double_t AliITSUModule::PathLength(const AliITSUHit *itsHit1,const AliITSUHit *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 = 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 AliITSUModule::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 AliITSUModule::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
  AliITSUHit *h1;
  Double_t t;
  //  
  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
  //
  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
  if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
  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 AliITSUModule::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
  AliITSUHit *h1;
  Double_t t;
  //
  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
  if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
  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 AliITSUModule::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,Double_t &tof, Int_t &track)
{
  // line segmente
  AliITSUHit *h1;
  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
  //
  h1 = (AliITSUHit *) (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,tof);
  h1->GetPositionL(b,d,f);
  b = b - a;
  d = d - c;
  f = f - e;
  track = h1->GetTrack();
  return kTRUE;
}

//___________________________________________________________________________
Bool_t AliITSUModule::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,Double_t &tof, Int_t &track)
{
  // line segment
  AliITSUHit *h1;
  if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
  //
  h1 = (AliITSUHit *) (fHitsM->At(hitindex));
  if(h1->StatusEntering()){ // if track entering volume, get index for next
    // step
    track = h1->GetTrack();
    return kFALSE;
  } // end if StatusEntering()
  de = h1->GetIonization();
  h1->GetPositionG0(a,c,e,tof);
  h1->GetPositionG(b,d,f);
  b = b - a;
  d = d - c;
  f = f - e;
  track = h1->GetTrack();
  return kTRUE;
}

//______________________________________________________________________
Bool_t AliITSUModule::MedianHitG(AliITSUHit *h1,AliITSUHit *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
  Float_t x1l=0.,y1l=0.,z1l=0.;
  Float_t x2l=0.,y2l=0.,z2l=0.;
  Float_t xMl,yMl=0,zMl;
  Double_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;
  fGeomTG->LocalToGlobal(h1->GetModule(),l,g);
  x = g[0];
  y = g[1];
  z = g[2];
  return kTRUE;
}

//___________________________________________________________________________
void AliITSUModule::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
  Float_t x1l,y1l,z1l;
  Float_t x2l,y2l,z2l;
  Float_t xMl,yMl=0,zMl;
  Double_t l[3], g[3];
  
  g[0] = hitx1;
  g[1] = hity1;
  g[2] = hitz1;
  fGeomTG->GlobalToLocal(index,g,l);
  x1l = l[0];
  y1l = l[1];
  z1l = l[2];
  
  g[0] = hitx2;
  g[1] = hity2;
  g[2] = hitz2;
  fGeomTG->GlobalToLocal(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;
  fGeomTG->LocalToGlobal(index,l,g);
  xMg = g[0];
  yMg = g[1];
  zMg = g[2];
}

//___________________________________________________________________________
Bool_t AliITSUModule::MedianHitL( AliITSUHit *itsHit1,AliITSUHit *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 AliITSUModule::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;
}
Commit	Line	Data
451f5018	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: AliITSUModule.cxx 53509 2011-12-10 18:55:52Z masera $ */
	17
	18	#include <TArrayI.h>
	19
	20	#include <stdlib.h>
	21
	22	#include "AliRun.h"
	23	#include "AliITS.h"
	24	#include "AliITSUModule.h"
	25	#include "AliITSUGeomTGeo.h"
a11ef2e4	26	using namespace TMath;
451f5018	27
	28	ClassImp(AliITSUModule)
	29
	30	//_______________________________________________________________________
	31	//
	32	// Impementation of class AliITSUModule
	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	AliITSUModule::AliITSUModule()
	44	: fHitsM(0)
	45	,fGeomTG(0)
	46	{
	47	// constructor
	48	}
	49
	50	//_________________________________________________________________________
	51	AliITSUModule::AliITSUModule(Int_t index, AliITSUGeomTGeo* tg)
	52	:fHitsM(new TObjArray())
	53	,fGeomTG(tg)
	54	{
	55	// constructor
	56	SetIndex(index);
	57	}
	58
	59	//__________________________________________________________________________
	60	AliITSUModule::~AliITSUModule()
	61	{
	62	// The destructor for AliITSUModule. Before destoring AliITSUModule
	63	// we must first destroy all of it's members.
	64	if (fHitsM) fHitsM->Clear();
	65	delete fHitsM;
	66	}
	67
	68	//____________________________________________________________________________
	69	AliITSUModule::AliITSUModule(const AliITSUModule &source)
	70	:TObject(source)
	71	,fHitsM(source.fHitsM)
	72	,fGeomTG(source.fGeomTG)
	73	{
	74	// Copy Constructor
	75	}
	76
	77	//_____________________________________________________________________________
	78	AliITSUModule& AliITSUModule::operator=(const AliITSUModule &source)
	79	{
	80	// Assignment operator
	81	if (this!=&source) {
	82	this->~AliITSUModule();
	83	new(this) AliITSUModule(source);
	84	}
	85	return *this;
	86	}
	87
	88	//___________________________________________________________________________
	89	Double_t AliITSUModule::PathLength(const AliITSUHit itsHit1,const AliITSUHit itsHit2)
	90	{
91	// path lenght
92	Float_t x1g,y1g,z1g;
93	Float_t x2g,y2g,z2g;
94	Double_t s;
95	//
96	itsHit1->GetPositionG(x1g,y1g,z1g);
97	itsHit2->GetPositionG(x2g,y2g,z2g);
98	//
a11ef2e4	99	s = Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
	100	((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
	101	((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g)) );
451f5018	102	return s;
	103	}
	104
	105	//___________________________________________________________________________
	106	void AliITSUModule::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,
	107	Float_t &dx1,Float_t &dy1,Float_t &dz1,Int_t &flag) const
	108	{
	109	// path length
	110	static Float_t x0,y0,z0;
	111	//
	112	if ((status&0x0002)!=0){ // entering
	113	x0 = x;
	114	y0 = y;
	115	z0 = z;
	116	nseg = 0;
	117	flag = 1;
	118	}else{
	119	x1 = x0;
	120	y1 = y0;
	121	z1 = z0;
	122	dx1 = x-x1;
	123	dy1 = y-y1;
	124	dz1 = z-z1;
	125	nseg++;
	126	if ((status&0x0004)!=0) flag = 0; //exiting
	127	if ((status&0x0001)!=0) flag = 2; // inside
	128	else flag = 2; //inside ?
	129	x0 = x;
	130	y0 = y;
	131	z0 = z;
	132	} // end if
	133	}
	134
	135	//___________________________________________________________________________
	136	Bool_t AliITSUModule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
	137	Double_t &e,Double_t &f,Double_t &de)
	138	{
	139	// line segment
	140	AliITSUHit *h1;
	141	Double_t t;
	142	//
	143	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	144	//
	145	h1 = (AliITSUHit *) (fHitsM->At(hitindex));
	146	if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
	147	de = h1->GetIonization();
	148	h1->GetPositionL0(a,c,e,t);
	149	h1->GetPositionL(b,d,f);
	150	b = b - a;
	151	d = d - c;
	152	f = f - e;
	153	return kTRUE;
	154	}
	155
	156	//___________________________________________________________________________
	157	Bool_t AliITSUModule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
	158	Double_t &e,Double_t &f,Double_t &de)
	159	{
	160	// line segment
	161	AliITSUHit *h1;
	162	Double_t t;
	163	//
	164	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	165	h1 = (AliITSUHit *) (fHitsM->At(hitindex));
166	if(h1->StatusEntering()) return kFALSE; // if track entering volume, get index for next step
167	de = h1->GetIonization();
168	h1->GetPositionG0(a,c,e,t);
169	h1->GetPositionG(b,d,f);
170	b = b - a;
171	d = d - c;
172	f = f - e;
173	return kTRUE;
174	}
175
176	//___________________________________________________________________________
177	Bool_t AliITSUModule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
0ebc85cf	178	Double_t &e,Double_t &f,Double_t &de,Double_t &tof, Int_t &track)
451f5018	179	{
	180	// line segmente
	181	AliITSUHit *h1;
451f5018	182	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	183	//
	184	h1 = (AliITSUHit *) (fHitsM->At(hitindex));
	185	if(h1->StatusEntering()){ // if track entering volume, get index for next
	186	// step
	187	track = h1->GetTrack();
	188	return kFALSE;
	189	} // end if StatusEntering()
	190	// else stepping
	191	de = h1->GetIonization();
0ebc85cf	192	h1->GetPositionL0(a,c,e,tof);
451f5018	193	h1->GetPositionL(b,d,f);
	194	b = b - a;
	195	d = d - c;
	196	f = f - e;
	197	track = h1->GetTrack();
	198	return kTRUE;
	199	}
	200
	201	//___________________________________________________________________________
	202	Bool_t AliITSUModule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,Double_t &c,Double_t &d,
0ebc85cf	203	Double_t &e,Double_t &f,Double_t &de,Double_t &tof, Int_t &track)
451f5018	204	{
	205	// line segment
	206	AliITSUHit *h1;
451f5018	207	if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
	208	//
	209	h1 = (AliITSUHit *) (fHitsM->At(hitindex));
	210	if(h1->StatusEntering()){ // if track entering volume, get index for next
	211	// step
	212	track = h1->GetTrack();
	213	return kFALSE;
	214	} // end if StatusEntering()
	215	de = h1->GetIonization();
0ebc85cf	216	h1->GetPositionG0(a,c,e,tof);
451f5018	217	h1->GetPositionG(b,d,f);
	218	b = b - a;
	219	d = d - c;
	220	f = f - e;
	221	track = h1->GetTrack();
	222	return kTRUE;
	223	}
	224
	225	//______________________________________________________________________
	226	Bool_t AliITSUModule::MedianHitG(AliITSUHit h1,AliITSUHit h2,Float_t &x,Float_t &y,Float_t &z)
	227	{
	228	// Computes the mean hit location for a set of hits that make up a track
	229	// passing through a volume. Returns kFALSE untill the the track leaves
	230	// the volume.
	231	// median hit
	232	Float_t x1l=0.,y1l=0.,z1l=0.;
	233	Float_t x2l=0.,y2l=0.,z2l=0.;
	234	Float_t xMl,yMl=0,zMl;
	235	Double_t l[3], g[3];
	236
	237	h1->GetPositionG(x1l,y1l,z1l);
	238	h2->GetPositionG(x2l,y2l,z2l);
	239
	240	if((y2l*y1l)<0.) {
	241	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
	242	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
	243	} else {
	244	xMl = 0.5*(x1l+x2l);
	245	zMl = 0.5*(z1l+z2l);
	246	}
	247
	248	l[0] = xMl;
	249	l[1] = yMl;
	250	l[2] = zMl;
	251	fGeomTG->LocalToGlobal(h1->GetModule(),l,g);
	252	x = g[0];
	253	y = g[1];
	254	z = g[2];
	255	return kTRUE;
	256	}
	257
	258	//___________________________________________________________________________
	259	void AliITSUModule::MedianHitG(Int_t index,Float_t hitx1,Float_t hity1,Float_t hitz1,Float_t hitx2,Float_t hity2,Float_t hitz2,
	260	Float_t &xMg, Float_t &yMg, Float_t &zMg)
	261	{
	262	// median hit
	263	Float_t x1l,y1l,z1l;
	264	Float_t x2l,y2l,z2l;
	265	Float_t xMl,yMl=0,zMl;
	266	Double_t l[3], g[3];
	267
	268	g[0] = hitx1;
	269	g[1] = hity1;
	270	g[2] = hitz1;
	271	fGeomTG->GlobalToLocal(index,g,l);
	272	x1l = l[0];
	273	y1l = l[1];
	274	z1l = l[2];
	275
	276	g[0] = hitx2;
	277	g[1] = hity2;
	278	g[2] = hitz2;
	279	fGeomTG->GlobalToLocal(index,g,l);
	280	x2l = l[0];
281	y2l = l[1];
282	z2l = l[2];
283
284	if((y2l*y1l)<0.) {
285	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
286	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
287	} else {
288	xMl = 0.5*(x1l+x2l);
289	zMl = 0.5*(z1l+z2l);
290	}
291
292	l[0] = xMl;
293	l[1] = yMl;
294	l[2] = zMl;
295	fGeomTG->LocalToGlobal(index,l,g);
296	xMg = g[0];
297	yMg = g[1];
298	zMg = g[2];
299	}
300
301	//___________________________________________________________________________
302	Bool_t AliITSUModule::MedianHitL( AliITSUHit itsHit1,AliITSUHit itsHit2, Float_t &xMl, Float_t &yMl, Float_t &zMl) const
303	{
304	// median hit
305	Float_t x1l,y1l,z1l;
306	Float_t x2l,y2l,z2l;
307
308	itsHit1->GetPositionL(x1l,y1l,z1l);
309	itsHit2->GetPositionL(x2l,y2l,z2l);
310
311	yMl = 0.0;
312	if((y2l*y1l)<0.) {
313	xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
314	zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
315	} else {
316	xMl = 0.5*(x1l+x2l);
317	zMl = 0.5*(z1l+z2l);
318	}
319	return kTRUE;
320	}
321
322	//___________________________________________________________________________
323	void AliITSUModule::MedianHit(Int_t index,Float_t xg,Float_t yg,Float_t zg,Int_t status,
324	Float_t &xMg,Float_t &yMg,Float_t &zMg,Int_t &flag)
325	{
326	// median hit
327	static Float_t x1,y1,z1;
328	//
329	if ((status&0x0002)!=0){ // entering
330	x1 = xg;
331	y1 = yg;
332	z1 = zg;
333	flag = 1;
334	} else if ((status&0x0004)!=0){ // exiting
335	MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
336	flag = 0;
337	} // end if
338	else flag = 1;
339	}
340
341