[u/mrichter/AliRoot.git] / PHOS / AliPHOSv1.cxx

/////////////////////////////////////////////////////////
//  Manager and hits classes for set:PHOS version 1    //
/////////////////////////////////////////////////////////
 
// --- ROOT system ---
#include "TH1.h"
#include "TRandom.h"
#include "TFile.h"
#include "TTree.h"
#include "TMath.h"

// --- galice header files ---
#include "AliPHOSv1.h"
#include "AliRun.h"

ClassImp(AliPHOSv1)

//______________________________________________________________________________


AliPHOSv1::AliPHOSv1()
{
}
 
//______________________________________________________________________________

AliPHOSv1::AliPHOSv1(const char *name, const char *title)
          : AliPHOS(name, title)
{
}
 
//___________________________________________
void AliPHOSv1::CreateGeometry()
{

  AliPHOS *PHOS_tmp = (AliPHOS*)gAlice->GetModule("PHOS");
  if( NULL==PHOS_tmp )
  {
    printf("There isn't PHOS detector!\n");
    return;
  }
//  AliPHOS &PHOS = *PHOS_tmp;

  //////////////////////////////////////////////////////////////////////////////

  Int_t                 rotation_matrix_number=0;
  Float_t               par[11],
                        x,y,z;

  const float           cell_length             = GetCrystalLength()+GetAirThickness()+GetWrapThickness()+GetPIN_Length(),
                        cell_side_size          = GetCrystalSideSize()+2*GetAirThickness()+2*GetWrapThickness(),
//                        cell_angle              = 180/kPI * 2 * atan(cell_side_size/2 / GetRadius()),        // radians
                        cradle_thikness         = cell_length + GetCPV_Thickness() + GetCPV_PHOS_Distance(),
                        distance_to_CPV         = GetRadius() - GetCPV_Thickness() - GetCPV_PHOS_Distance();

  //////////////////////////////////////////////////////////////////////////////
  // CELL volume and subvolumes creation
  //////////////////////////////////////////////////////////////////////////////

  par[0] = GetCrystalSideSize()/2 + GetWrapThickness();
  par[1] = GetCrystalSideSize()/2 + GetWrapThickness();
  par[2] = GetCrystalLength()  /2 + GetWrapThickness()/2;
  gMC->Gsvolu("WRAP","BOX ",GetPHOS_IDTMED_Tyvek(),par,3);

  par[0] = GetCrystalSideSize()/2;
  par[1] = GetCrystalSideSize()/2;
  par[2] = GetCrystalLength()/2;
  gMC->Gsvolu("CRST","BOX ",GetPHOS_IDTMED_PbWO4(),par,3);

  // PIN
  par[0] = GetPIN_SideSize()/2;
  par[1] = GetPIN_SideSize()/2;
  par[2] = GetPIN_Length()/2;
  gMC->Gsvolu("PIN ","BOX ",GetPHOS_IDTMED_PIN(),par,3);

  //////////////////////////////////////////////////////////////////////////////
  // CRADLE,CPV creation.
  //////////////////////////////////////////////////////////////////////////////

  par[0] = cell_side_size/2 * GetNz();
  par[1] = cell_side_size/2 * GetNphi();
  par[2] = cradle_thikness/2;
  gMC->Gsvolu("PHOS","BOX ",GetPHOS_IDTMED_AIR(),par,3);

//par[0] : the same as above
//par[1] : the same as above
  par[2] = GetCPV_Thickness()/2;
  gMC->Gsvolu("CPV ","BOX ",GetPHOS_IDTMED_CPV(),par,3);

  x = 0;
  y = 0;
  z = (cell_length+GetCPV_PHOS_Distance())/2;
  gMC->Gspos("CPV ",1,"PHOS",x,y,z,0,"ONLY");

  par[0] = cell_side_size/2 * GetNz();
  par[1] = cell_side_size/2 * GetNphi();
  par[2] = cell_length/2;
  gMC->Gsvolu("CRS0","BOX ",GetPHOS_IDTMED_AIR(),par,3);

  x = 0;
  y = 0;
  z = -(cradle_thikness-cell_length)/2;
  gMC->Gspos("CRS0",1,"PHOS",x,y,z,0,"ONLY");

  gMC->Gsdvn("CRS1","CRS0",GetNphi(),2);
  gMC->Gsdvn("CELL","CRS1",GetNz()  ,1);

  //////////////////////////////////////////////////////////////////////////////
  // CELL creation
  //////////////////////////////////////////////////////////////////////////////

  x = 0;
  y = 0;
  z = -GetWrapThickness()/2;
  gMC->Gspos("CRST",1,"WRAP",x,y,z,0,"ONLY");

  x = 0;
  y = 0;
  z = GetPIN_Length()/2;
  gMC->Gspos("WRAP",1,"CELL",x,y,z,0,"ONLY");

  x = 0;
  y = 0;
  z = -GetCrystalLength()/2-GetWrapThickness()/2;
  gMC->Gspos("PIN ",1,"CELL",x,y,z,0,"ONLY");

  //////////////////////////////////////////////////////////////////////////////
  // CELL has been created.
  //////////////////////////////////////////////////////////////////////////////

//   int n=0;
//   z = -(GetCPV_Thickness()+GetCPV_PHOS_Distance())/2;
//
//   for( int iy=0; iy<GetNphi(); iy++ )
//   {
//     y = (iy-(GetNphi()-1)/2.)*cell_side_size;
//     for( int ix=0; ix<GetNz(); ix++ )
//     {
//       x = (ix-(GetNz()-1)/2.)*cell_side_size;
//       gMC->Gspos("CELL",++n,"PHOS",x,y,z,0,"ONLY");
//     }
//   }

  //////////////////////////////////////////////////////////////////////////////
  // End of CRADLE creation.
  //////////////////////////////////////////////////////////////////////////////


  //////////////////////////////////////////////////////////////////////////////
  // PHOS creation
  //////////////////////////////////////////////////////////////////////////////

  for( int i=0; i<GetCradlesAmount(); i++ )
  {
    float c                = distance_to_CPV,           // Distance to CPV
          l                = cell_side_size*GetNphi()/2,      // Cradle half size around beam (for rect. geom.)
          cradle_angle     = 360/kPI*atan(l/c),
          cradle_angle_pos = -90+(i-(GetCradlesAmount()-1)/2.) * (cradle_angle+GetAngleBetweenCradles());
    // Cradles are numerated in clock reversed order. (general way of angle increment)

    float   r       = GetRadius() + cradle_thikness/2;
    x = r*cos(cradle_angle_pos*kPI/180);
    y = r*sin(cradle_angle_pos*kPI/180);
    z = 0;
    AliMatrix(rotation_matrix_number, 0,0 , 90,90+cradle_angle_pos , 90,180+cradle_angle_pos);
    gMC->Gspos("PHOS",i+1,"ALIC",x,y,z,rotation_matrix_number,"ONLY");

    GetCradleAngle(i) = cradle_angle_pos;
//
//    int n = PHOS.fCradles->GetEntries();
//    PHOS.fCradles->Add(new AliPHOSCradle( 1,            // geometry.
//                                          GetCrystalSideSize    (),
//                                          GetCrystalLength      (),
//                                          GetWrapThickness      (),
//                                          GetAirThickness       (),
//                                          GetPIN_SideSize       (),
//                                          GetPIN_Length         (),
//                                          GetRadius             (),
//                                          GetCPV_Thickness      (),
//                                          GetCPV_PHOS_Distance  (),
//                                          GetNz                 (),
//                                          GetNphi               (),
//                                          cradle_angle_pos      ));
//
//    if( n+1 != PHOS.fCradles->GetEntries() ||
//        NULL == PHOS.fCradles->At(n) )
//    {
//      cout << "  Can not create or add AliPHOSCradle.\n";
//      exit(1);
//    }
  }
  AddPHOSCradles();

  //////////////////////////////////////////////////////////////////////////////
  // All is done.
  // Print some information.
  //////////////////////////////////////////////////////////////////////////////
}

void AliPHOSv1::StepManager()
{
  static Bool_t inwold=0;   // Status of previous ctrak->inwvol
  Int_t copy;

  int cradle_number, cell_Z, cell_Phi;  // Variables that describe cell position.

  if( gMC->GetMedium() == GetPHOS_IDTMED_PIN() && (gMC->IsTrackInside() || gMC->IsTrackExiting()==2) && inwold && gMC->TrackCharge()!=0 )
  {
    // GEANT particle just have entered into PIN diode.

    AliPHOS &PHOS = *(AliPHOS*)gAlice->GetModule("PHOS");

    gMC->CurrentVolOffID(4,copy);
    cradle_number  = copy-1;
    gMC->CurrentVolOffID(1,copy);
    cell_Z         = copy-1;
    gMC->CurrentVolOffID(2,copy);
    cell_Phi       = copy-1;
/*
        cradle_number  = cvolu->number[cvolu->nlevel-5]-1;
        cell_Z         = cvolu->number[cvolu->nlevel-2]-1;
        cell_Phi       = cvolu->number[cvolu->nlevel-3]-1;
*/

    TH2S &h = PHOS.GetCradle(cradle_number).fChargedTracksInPIN;
    h.AddBinContent(h.GetBin(cell_Z,cell_Phi));
  }

  //////////////////////////////////////////////////////////////////////////////

  if( gMC->GetMedium() == GetPHOS_IDTMED_PbWO4() )
  {
    // GEANT particle into crystal.

    AliPHOS &PHOS = *(AliPHOS*)gAlice->GetModule("PHOS");

    gMC->CurrentVolOffID(5,copy);
    cradle_number  = copy-1;
    gMC->CurrentVolOffID(2,copy);
    cell_Z         = copy-1;
    gMC->CurrentVolOffID(3,copy);
    cell_Phi       = copy-1;
/*
        cradle_number  = cvolu->number[cvolu->nlevel-6]-1;
        cell_Z         = cvolu->number[cvolu->nlevel-3]-1;
        cell_Phi       = cvolu->number[cvolu->nlevel-4]-1;
*/
    TH2F &h = PHOS.GetCradle(cradle_number).fCellEnergy;
    h.AddBinContent(h.GetBin(cell_Z,cell_Phi),gMC->Edep());
  }

  //////////////////////////////////////////////////////////////////////////////

  if( gMC->GetMedium()==GetPHOS_IDTMED_CPV() && (gMC->IsTrackInside() || gMC->IsTrackExiting()) && inwold )
  {
    // GEANT particle just have entered into CPV detector.

    AliPHOS &PHOS = *(AliPHOS*)gAlice->GetModule("PHOS");

    gMC->CurrentVolOffID(1,cradle_number);
    cradle_number--;
//        cradle_number  = cvolu->number[cvolu->nlevel-2]-1;

    // Save CPV x,y hits position of charged particles.

    AliPHOSCradle  &cradle = PHOS.GetCradle(cradle_number);

    TLorentzVector xyz;
    TVector3 v;
    gMC->TrackPosition(xyz);

    float x,y,l;
    float R = cradle.GetRadius() - cradle.GetCPV_PHOS_Distance() - cradle.GetCPV_Thikness();
    cradle.GetXY(xyz.Vect(),v,R,x,y,l);
    if( PHOS.fDebugLevel>0 )
      if( l<0 )
        printf("PHOS_STEP:  warning: negative distance to CPV!! %f\n", l);

    // Store current particle in the list of Cradle particles.
    TLorentzVector  pmom;
    gMC->TrackMomentum(pmom);
    float     Px      =       pmom[0],
              Py      =       pmom[1],
              Pz      =       pmom[2];
    Int_t     Ipart   =       gMC->TrackPid();

//     TClonesArray &P=cradle.GetParticles();
//     new( P[P.GetEntries()] ) AliPHOSgamma(x,0,y,0,ctrak->getot,0,Px,Py,Pz);
    cradle.GetParticles().Add(new AliPHOSgamma(x,y,gMC->Etot(),Px,Py,Pz,Ipart));

    if( gMC->TrackCharge()!=0 )
      cradle.AddCPVHit(x,y);
  }

  inwold=gMC->IsTrackEntering();         // Save current status of GEANT variable.
}
Commit	Line	Data
fe4da5cc	1	/////////////////////////////////////////////////////////
	2	// Manager and hits classes for set:PHOS version 1 //
	3	/////////////////////////////////////////////////////////
	4
	5	// --- ROOT system ---
	6	#include "TH1.h"
	7	#include "TRandom.h"
	8	#include "TFile.h"
	9	#include "TTree.h"
bc9ab547	10	#include "TMath.h"
fe4da5cc	11
	12	// --- galice header files ---
	13	#include "AliPHOSv1.h"
	14	#include "AliRun.h"
fe4da5cc	15
	16	ClassImp(AliPHOSv1)
	17
	18	//______________________________________________________________________________
	19
	20
8c933dd7	21	AliPHOSv1::AliPHOSv1()
fe4da5cc	22	{
	23	}
	24
	25	//______________________________________________________________________________
	26
	27	AliPHOSv1::AliPHOSv1(const char name, const char title)
	28	: AliPHOS(name, title)
	29	{
	30	}
	31
	32	//___________________________________________
	33	void AliPHOSv1::CreateGeometry()
	34	{
	35
6435828c	36	AliPHOS PHOS_tmp = (AliPHOS)gAlice->GetModule("PHOS");
fe4da5cc	37	if( NULL==PHOS_tmp )
	38	{
	39	printf("There isn't PHOS detector!\n");
	40	return;
	41	}
	42	// AliPHOS &PHOS = *PHOS_tmp;
	43
	44	//////////////////////////////////////////////////////////////////////////////
	45
	46	Int_t rotation_matrix_number=0;
	47	Float_t par[11],
	48	x,y,z;
	49
	50	const float cell_length = GetCrystalLength()+GetAirThickness()+GetWrapThickness()+GetPIN_Length(),
	51	cell_side_size = GetCrystalSideSize()+2GetAirThickness()+2GetWrapThickness(),
bc9ab547	52	// cell_angle = 180/kPI * 2 * atan(cell_side_size/2 / GetRadius()), // radians
fe4da5cc	53	cradle_thikness = cell_length + GetCPV_Thickness() + GetCPV_PHOS_Distance(),
	54	distance_to_CPV = GetRadius() - GetCPV_Thickness() - GetCPV_PHOS_Distance();
	55
	56	//////////////////////////////////////////////////////////////////////////////
	57	// CELL volume and subvolumes creation
	58	//////////////////////////////////////////////////////////////////////////////
	59
	60	par[0] = GetCrystalSideSize()/2 + GetWrapThickness();
	61	par[1] = GetCrystalSideSize()/2 + GetWrapThickness();
	62	par[2] = GetCrystalLength() /2 + GetWrapThickness()/2;
cfce8870	63	gMC->Gsvolu("WRAP","BOX ",GetPHOS_IDTMED_Tyvek(),par,3);
fe4da5cc	64
	65	par[0] = GetCrystalSideSize()/2;
	66	par[1] = GetCrystalSideSize()/2;
	67	par[2] = GetCrystalLength()/2;
cfce8870	68	gMC->Gsvolu("CRST","BOX ",GetPHOS_IDTMED_PbWO4(),par,3);
fe4da5cc	69
	70	// PIN
	71	par[0] = GetPIN_SideSize()/2;
	72	par[1] = GetPIN_SideSize()/2;
	73	par[2] = GetPIN_Length()/2;
cfce8870	74	gMC->Gsvolu("PIN ","BOX ",GetPHOS_IDTMED_PIN(),par,3);
fe4da5cc	75
	76	//////////////////////////////////////////////////////////////////////////////
	77	// CRADLE,CPV creation.
	78	//////////////////////////////////////////////////////////////////////////////
	79
	80	par[0] = cell_side_size/2 * GetNz();
	81	par[1] = cell_side_size/2 * GetNphi();
	82	par[2] = cradle_thikness/2;
cfce8870	83	gMC->Gsvolu("PHOS","BOX ",GetPHOS_IDTMED_AIR(),par,3);
fe4da5cc	84
	85	//par[0] : the same as above
	86	//par[1] : the same as above
	87	par[2] = GetCPV_Thickness()/2;
cfce8870	88	gMC->Gsvolu("CPV ","BOX ",GetPHOS_IDTMED_CPV(),par,3);
fe4da5cc	89
	90	x = 0;
	91	y = 0;
	92	z = (cell_length+GetCPV_PHOS_Distance())/2;
cfce8870	93	gMC->Gspos("CPV ",1,"PHOS",x,y,z,0,"ONLY");
fe4da5cc	94
	95	par[0] = cell_side_size/2 * GetNz();
	96	par[1] = cell_side_size/2 * GetNphi();
	97	par[2] = cell_length/2;
cfce8870	98	gMC->Gsvolu("CRS0","BOX ",GetPHOS_IDTMED_AIR(),par,3);
fe4da5cc	99
	100	x = 0;
	101	y = 0;
	102	z = -(cradle_thikness-cell_length)/2;
cfce8870	103	gMC->Gspos("CRS0",1,"PHOS",x,y,z,0,"ONLY");
fe4da5cc	104
cfce8870	105	gMC->Gsdvn("CRS1","CRS0",GetNphi(),2);
cfce8870	106	gMC->Gsdvn("CELL","CRS1",GetNz() ,1);
fe4da5cc	107
	108	//////////////////////////////////////////////////////////////////////////////
	109	// CELL creation
	110	//////////////////////////////////////////////////////////////////////////////
	111
	112	x = 0;
	113	y = 0;
	114	z = -GetWrapThickness()/2;
cfce8870	115	gMC->Gspos("CRST",1,"WRAP",x,y,z,0,"ONLY");
fe4da5cc	116
	117	x = 0;
	118	y = 0;
	119	z = GetPIN_Length()/2;
cfce8870	120	gMC->Gspos("WRAP",1,"CELL",x,y,z,0,"ONLY");
fe4da5cc	121
	122	x = 0;
	123	y = 0;
	124	z = -GetCrystalLength()/2-GetWrapThickness()/2;
cfce8870	125	gMC->Gspos("PIN ",1,"CELL",x,y,z,0,"ONLY");
fe4da5cc	126
	127	//////////////////////////////////////////////////////////////////////////////
	128	// CELL has been created.
	129	//////////////////////////////////////////////////////////////////////////////
	130
	131	// int n=0;
	132	// z = -(GetCPV_Thickness()+GetCPV_PHOS_Distance())/2;
	133	//
	134	// for( int iy=0; iy<GetNphi(); iy++ )
	135	// {
	136	// y = (iy-(GetNphi()-1)/2.)*cell_side_size;
	137	// for( int ix=0; ix<GetNz(); ix++ )
	138	// {
	139	// x = (ix-(GetNz()-1)/2.)*cell_side_size;
cfce8870	140	// gMC->Gspos("CELL",++n,"PHOS",x,y,z,0,"ONLY");
fe4da5cc	141	// }
	142	// }
	143
	144	//////////////////////////////////////////////////////////////////////////////
	145	// End of CRADLE creation.
	146	//////////////////////////////////////////////////////////////////////////////
	147
	148
	149	//////////////////////////////////////////////////////////////////////////////
	150	// PHOS creation
	151	//////////////////////////////////////////////////////////////////////////////
	152
	153	for( int i=0; i<GetCradlesAmount(); i++ )
	154	{
	155	float c = distance_to_CPV, // Distance to CPV
	156	l = cell_side_size*GetNphi()/2, // Cradle half size around beam (for rect. geom.)
bc9ab547	157	cradle_angle = 360/kPI*atan(l/c),
fe4da5cc	158	cradle_angle_pos = -90+(i-(GetCradlesAmount()-1)/2.) * (cradle_angle+GetAngleBetweenCradles());
	159	// Cradles are numerated in clock reversed order. (general way of angle increment)
	160
	161	float r = GetRadius() + cradle_thikness/2;
bc9ab547	162	x = rcos(cradle_angle_poskPI/180);
bc9ab547	163	y = rsin(cradle_angle_poskPI/180);
fe4da5cc	164	z = 0;
fe4da5cc	165	AliMatrix(rotation_matrix_number, 0,0 , 90,90+cradle_angle_pos , 90,180+cradle_angle_pos);
cfce8870	166	gMC->Gspos("PHOS",i+1,"ALIC",x,y,z,rotation_matrix_number,"ONLY");
fe4da5cc	167
	168	GetCradleAngle(i) = cradle_angle_pos;
	169	//
	170	// int n = PHOS.fCradles->GetEntries();
	171	// PHOS.fCradles->Add(new AliPHOSCradle( 1, // geometry.
	172	// GetCrystalSideSize (),
	173	// GetCrystalLength (),
	174	// GetWrapThickness (),
	175	// GetAirThickness (),
	176	// GetPIN_SideSize (),
	177	// GetPIN_Length (),
	178	// GetRadius (),
	179	// GetCPV_Thickness (),
	180	// GetCPV_PHOS_Distance (),
	181	// GetNz (),
	182	// GetNphi (),
	183	// cradle_angle_pos ));
	184	//
	185	// if( n+1 != PHOS.fCradles->GetEntries() \|\|
	186	// NULL == PHOS.fCradles->At(n) )
	187	// {
	188	// cout << " Can not create or add AliPHOSCradle.\n";
	189	// exit(1);
	190	// }
	191	}
	192	AddPHOSCradles();
	193
	194	//////////////////////////////////////////////////////////////////////////////
	195	// All is done.
	196	// Print some information.
	197	//////////////////////////////////////////////////////////////////////////////
	198	}
	199
	200	void AliPHOSv1::StepManager()
	201	{
	202	static Bool_t inwold=0; // Status of previous ctrak->inwvol
fe4da5cc	203	Int_t copy;
fe4da5cc	204
fe4da5cc	205	int cradle_number, cell_Z, cell_Phi; // Variables that describe cell position.
fe4da5cc	206
0a6d8768	207	if( gMC->GetMedium() == GetPHOS_IDTMED_PIN() && (gMC->IsTrackInside() \|\| gMC->IsTrackExiting()==2) && inwold && gMC->TrackCharge()!=0 )
fe4da5cc	208	{
	209	// GEANT particle just have entered into PIN diode.
	210
6435828c	211	AliPHOS &PHOS = (AliPHOS)gAlice->GetModule("PHOS");
fe4da5cc	212
0a6d8768	213	gMC->CurrentVolOffID(4,copy);
fe4da5cc	214	cradle_number = copy-1;
0a6d8768	215	gMC->CurrentVolOffID(1,copy);
fe4da5cc	216	cell_Z = copy-1;
0a6d8768	217	gMC->CurrentVolOffID(2,copy);
fe4da5cc	218	cell_Phi = copy-1;
	219	/*
	220	cradle_number = cvolu->number[cvolu->nlevel-5]-1;
	221	cell_Z = cvolu->number[cvolu->nlevel-2]-1;
	222	cell_Phi = cvolu->number[cvolu->nlevel-3]-1;
	223	*/
	224
	225	TH2S &h = PHOS.GetCradle(cradle_number).fChargedTracksInPIN;
	226	h.AddBinContent(h.GetBin(cell_Z,cell_Phi));
	227	}
	228
	229	//////////////////////////////////////////////////////////////////////////////
	230
cfce8870	231	if( gMC->GetMedium() == GetPHOS_IDTMED_PbWO4() )
fe4da5cc	232	{
	233	// GEANT particle into crystal.
	234
6435828c	235	AliPHOS &PHOS = (AliPHOS)gAlice->GetModule("PHOS");
fe4da5cc	236
0a6d8768	237	gMC->CurrentVolOffID(5,copy);
fe4da5cc	238	cradle_number = copy-1;
0a6d8768	239	gMC->CurrentVolOffID(2,copy);
fe4da5cc	240	cell_Z = copy-1;
0a6d8768	241	gMC->CurrentVolOffID(3,copy);
fe4da5cc	242	cell_Phi = copy-1;
	243	/*
	244	cradle_number = cvolu->number[cvolu->nlevel-6]-1;
	245	cell_Z = cvolu->number[cvolu->nlevel-3]-1;
	246	cell_Phi = cvolu->number[cvolu->nlevel-4]-1;
	247	*/
	248	TH2F &h = PHOS.GetCradle(cradle_number).fCellEnergy;
cfce8870	249	h.AddBinContent(h.GetBin(cell_Z,cell_Phi),gMC->Edep());
fe4da5cc	250	}
	251
	252	//////////////////////////////////////////////////////////////////////////////
	253
0a6d8768	254	if( gMC->GetMedium()==GetPHOS_IDTMED_CPV() && (gMC->IsTrackInside() \|\| gMC->IsTrackExiting()) && inwold )
fe4da5cc	255	{
	256	// GEANT particle just have entered into CPV detector.
	257
6435828c	258	AliPHOS &PHOS = (AliPHOS)gAlice->GetModule("PHOS");
fe4da5cc	259
0a6d8768	260	gMC->CurrentVolOffID(1,cradle_number);
fe4da5cc	261	cradle_number--;
	262	// cradle_number = cvolu->number[cvolu->nlevel-2]-1;
	263
	264	// Save CPV x,y hits position of charged particles.
	265
	266	AliPHOSCradle &cradle = PHOS.GetCradle(cradle_number);
	267
0a6d8768	268	TLorentzVector xyz;
0a6d8768	269	TVector3 v;
cfce8870	270	gMC->TrackPosition(xyz);
fe4da5cc	271
	272	float x,y,l;
	273	float R = cradle.GetRadius() - cradle.GetCPV_PHOS_Distance() - cradle.GetCPV_Thikness();
0a6d8768	274	cradle.GetXY(xyz.Vect(),v,R,x,y,l);
fe4da5cc	275	if( PHOS.fDebugLevel>0 )
	276	if( l<0 )
	277	printf("PHOS_STEP: warning: negative distance to CPV!! %f\n", l);
	278
	279	// Store current particle in the list of Cradle particles.
0a6d8768	280	TLorentzVector pmom;
cfce8870	281	gMC->TrackMomentum(pmom);
0a6d8768	282	float Px = pmom[0],
	283	Py = pmom[1],
	284	Pz = pmom[2];
cfce8870	285	Int_t Ipart = gMC->TrackPid();
fe4da5cc	286
	287	// TClonesArray &P=cradle.GetParticles();
	288	// new( P[P.GetEntries()] ) AliPHOSgamma(x,0,y,0,ctrak->getot,0,Px,Py,Pz);
cfce8870	289	cradle.GetParticles().Add(new AliPHOSgamma(x,y,gMC->Etot(),Px,Py,Pz,Ipart));
fe4da5cc	290
cfce8870	291	if( gMC->TrackCharge()!=0 )
fe4da5cc	292	cradle.AddCPVHit(x,y);
	293	}
	294
0a6d8768	295	inwold=gMC->IsTrackEntering(); // Save current status of GEANT variable.
fe4da5cc	296	}
fe4da5cc	297