[u/mrichter/AliRoot.git] / T0 / AliT0v2.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$ */

/////////////////////////////////////////////////////////////////////
//                                                                 //
// T0 ( T-zero) detector  version 0                        //
//
//Begin Html       
/*
<img src="gif/AliT0v2Class.gif">
*/
//End Html
//                                                                  //
//                                                                  //
//////////////////////////////////////////////////////////////////////

#define RIGHT_ARRAY		1
#define LEFT_ARRAY		2

#include <Riostream.h>
#include <stdlib.h>

#include <TLorentzVector.h>
#include <TMath.h>
#include <TVirtualMC.h>

#include "AliMagF.h"
#include "AliRun.h"
#include "AliT0hit.h"
#include "AliT0v2.h"
#include "AliMC.h"

ClassImp(AliT0v2)


//////////////////////////////////////////////////////////////////////
// Standart constructor for T0 Detector version 2
//////////////////////////////////////////////////////////////////////
AliT0v2::AliT0v2(const char *name, const char *title):
 AliT0(name,title)
{
  fIdSens1 = 0;
//  setBufferSize(128000);
}


//////////////////////////////////////////////////////////////////////
// Create the geometry of T0 Detector version 2
//////////////////////////////////////////////////////////////////////
void AliT0v2::CreateGeometry()
{
  /*
     <img src="gif/AliT0v2.gif">
  */

  Int_t 	*idtmed;
  Int_t 	idrotm[999];
  Int_t 	i, j;
  Float_t 	x, y, z;
  Float_t 	zRight;
  Float_t	zLeft;
  Float_t  	phi[3];
  Float_t 	theta;
  Double_t 	angel;
  
  Float_t 	pstart[3]	= {4.5,  10.7,   5.3};
  Float_t 	pinstart[3]	= {0.,    1.31,  5.25};
  Float_t 	ppmt[3]		= {0.,    1.31,  3.5};
  Float_t 	ptop[3]		= {0.,    1.3,   1.5};
//  Float_t 	preg[3]		= {0.,    1.3,   0.005};
  Float_t 	preg[3]		= {0.,    0.875, 0.005};
  Float_t 	pdes[3]		= {0.875, 1.3,   0.005};


  zRight = 75.;
  zLeft  = 350.;
  theta  = (180 / TMath::Pi()) * TMath::ATan(6.5 / zRight);
  angel  = 2 * TMath::Pi() / 12;
  idtmed = fIdtmed->GetArray();
    

  AliMatrix (idrotm[901], 90., 0., 90., 90., 180., 0.);
    
  gMC->Gsvolu ("0RST", "TUBE", idtmed[3], pstart, 3);
  gMC->Gsvolu ("0LST", "TUBE", idtmed[3], pstart, 3);
  gMC->Gspos ("0RST", 1, "ALIC", 0., 0., -zRight, 0, "ONLY");
  gMC->Gspos ("0LST", 1, "ALIC", 0., 0., zLeft, idrotm[901], "ONLY");

//  12 unit: PMT + divider
  gMC->Gsvolu("0INS", "TUBE", idtmed[3], pinstart, 3);   
  z = 0;
  for (i = 0; i < 12; i++)
  {
     x = 6.5 * TMath::Sin(i * angel);
     y = 6.5 * TMath::Cos(i * angel);
	
     phi[0] = -30 * i;
     phi[1] = 90 - i * 30;
     phi[2] = 90 - i * 30;
     for (j = 0; j < 3; j++)
	if (phi[j] < 0)  phi[j] += 360;
	
     AliMatrix (idrotm[902 + i], 90.,         phi[0],
		                 90. + theta, phi[1],
		                 theta,       phi[2]);  

     gMC->Gspos ("0INS", i + 1, "0RST", x, y, z, idrotm[902 + i], "ONLY");
     gMC->Gspos ("0INS", i + 13, "0LST", x, y, z, 0, "ONLY");
  }

  gMC->Gsvolu ("0PMT", "TUBE", idtmed[1], ppmt, 3);     
  x = y = 0;      
  z = -pinstart[2] + ppmt[2];
  gMC->Gspos ("0PMT", 1, "0INS", x, y, z, 0, "ONLY");
    
// PMT
  // Entry window (glass)
  gMC->Gsvolu ("0TOP", "TUBE", idtmed[6], ptop, 3);
  z = -ppmt[2] + ptop[2];
  gMC->Gspos ("0TOP", 1, "0PMT", 0, 0, z, 0, "ONLY");

  gMC->Gsvolu ("0REG", "TUBE", idtmed[6], preg, 3);
  z = -ppmt[2] + 2 * ptop[2] + preg[2];
  gMC->Gspos ("0REG", 1, "0PMT", 0, 0, z, 0, "ONLY");

  gMC->Gsvolu ("0DES", "TUBE", idtmed[6], pdes, 3);
  z = -ppmt[2] + 2 * ptop[2] + preg[2];
  gMC->Gspos ("0DES", 1, "0PMT", 0, 0, z, 0, "ONLY");
}   
 

//////////////////////////////////////////////////////////////////////
// Definition of avaible T0 materials
//////////////////////////////////////////////////////////////////////
void AliT0v2::CreateMaterials()
{
   Int_t isxfld   = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();
   Float_t sxmgmx = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();
   
   Float_t a, z, d, radl, absl, buf[1];
   Int_t nbuf;

// Scintillator CH
   Float_t 	ascin[2] = {1.01, 12.01};
   Float_t 	zscin[2] = {1.,    6.};
   Float_t 	wscin[2] = {1.,    1.};
   Float_t 	denscin  = 1.03;
   
// PMT glass SiO2
   Float_t 	aglass[2] = {28.0855, 15.9994};
   Float_t 	zglass[2] = {14.,      8.};
   Float_t 	wglass[2] = { 1.,      2.};
   Float_t 	dglass    = 2.65;
   
// Ceramic   97.2% Al2O3 , 2.8% SiO2
   Float_t 	acer[2], zcer[2];
   Float_t 	wcer[2]	   = { 0.972,     0.028};
   Float_t 	aal2o3[2]  = {26.981539, 15.9994 };
   Float_t 	zal2o3[2]  = {13.,        8.};
   Float_t 	wal2o3[2]  = { 2.,        3.};
   Float_t 	denscer    = 3.6;

// Brass 80% Cu, 20% Zn
   Float_t abrass[2] = {63.546, 65.39};
   Float_t zbrass[2] = {29.,    30.};
   Float_t wbrass[2] = { 0.8,    0.2};
   Float_t denbrass  = 8.96;

//Ribber C6H12S
   Float_t aribber[3] = {12.,  1., 32.};
   Float_t zribber[3] = { 6.,  1., 16.};
   Float_t wribber[3] = { 6., 12.,  1.};
   Float_t denribber  = 0.8;
   
    
   AliMaterial (0, "T0 Steel$", 55.850, 26., 7.87, 1.76, 999);
   AliMaterial (1, "T0 Vacuum$", 1.e-16, 1.e-16, 1.e-16, 1.e16, 999);
   AliMaterial (2, "T0 Air$", 14.61, 7.3, .001205, 30423., 999); 
   
   AliMixture (3, "Al2O3   $", aal2o3, zal2o3, denscer, -2, wal2o3);
   AliMixture (4, "PMT glass   $", aglass, zglass, dglass, -2, wglass);
   char namate[21]="";
   gMC->Gfmate ((*fIdmate)[3], namate, a, z, d, radl, absl, buf, nbuf);
   acer[0] = a;
   zcer[0] = z;
   gMC->Gfmate ((*fIdmate)[4], namate, a, z, d, radl, absl, buf, nbuf);
   acer[1] = a;
   zcer[1] = z;
   
   AliMixture (5, "Scintillator$",ascin,zscin,denscin,-2,wscin);
   AliMixture (6, "Brass    $", abrass, zbrass, denbrass, 2, wbrass);
   AliMixture (7, "Ribber $",aribber,zribber,denribber,-3,wribber);
   AliMixture (9, "Ceramic    $", acer, zcer, denscer, 2, wcer);
   
   AliMedium (1, "T0 Air$", 2, 0, isxfld, sxmgmx, 10., .1, 1., .003, .003);
   AliMedium (2, "Scintillator$", 5, 1, isxfld, sxmgmx, 10., .01, 1., .003, .003);
   AliMedium (3, "Vacuum$", 1, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
   AliMedium (4, "Ceramic$", 9, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
   AliMedium (6, "Glass$", 4, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
   AliMedium (8, "Steel$", 0, 0, isxfld, sxmgmx, 1., .001, 1., .001, .001);
   AliMedium (9, "Ribber  $", 7, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
   AliMedium(11, "Brass  $", 6, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
}


//////////////////////////////////////////////////////////////////////
// Draw a shaded view of the Forward multiplicity detector version 2
//////////////////////////////////////////////////////////////////////
void AliT0v2::DrawModule() const
{  
  //Set ALIC mother transparent
  gMC->Gsatt ("ALIC", "SEEN", 0);

  //Set volumes visible
  gMC->Gsatt ("0STA", "SEEN", 0);
  gMC->Gsatt ("0PMT", "SEEN", 1);
  gMC->Gsatt ("0DIV", "SEEN", 1);

  gMC->Gdopt ("hide", "on");
  gMC->Gdopt ("shad", "on");
  gMC->SetClipBox (".");
  gMC->SetClipBox ("*", 0, 1000, -1000, 1000, -1000, 1000);
  gMC->DefaultRange();
  gMC->Gdraw ("alic", 40, 30, 0, 12, 9.5, 0.7, 0.7);
  gMC->Gdhead (1111, "T-Zero detector");
  gMC->Gdopt ("hide", "off");
}

//////////////////////////////////////////////////////////////////////
// Definition of optical properties for the Forward Multiplicity Detector
//////////////////////////////////////////////////////////////////////
void AliT0v2::DefineOpticalProperties()
{
// Optical properties definition.
// Definition Cherenkov parameters
  const Int_t NUMENTRIES = 32;

  Float_t ppckov[NUMENTRIES] =
            { 2.034E-9, 2.068E-9, 2.103E-9, 2.139E-9,
              2.177E-9, 2.216E-9, 2.256E-9, 2.298E-9,
              2.341E-9, 2.386E-9, 2.433E-9, 2.481E-9,
              2.532E-9, 2.585E-9, 2.640E-9, 2.697E-9,
              2.757E-9, 2.820E-9, 2.885E-9, 2.954E-9,
              3.026E-9, 3.102E-9, 3.181E-9, 3.265E-9,
              3.353E-9, 3.446E-9, 3.545E-9, 3.649E-9,
              3.760E-9, 3.877E-9, 4.002E-9, 4.136E-9 };

  Float_t rindex_qwarz[NUMENTRIES] =
            { 1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
              1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
              1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
              1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
              1.458, 1.458, 1.458, 1.458 };

  Float_t rindex_air[NUMENTRIES] =
            { 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
              1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
              1., 1., 1., 1. };

  Float_t effic_all[NUMENTRIES] =
            { 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
              1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
              1., 1., 1., 1. };
              
  Float_t absor_qwarz[NUMENTRIES] =
  	    { 2000., 2000., 2000., 2000., 2000., 2000., 2000., 
  	      2000., 2000., 2000., 2000., 2000., 2000., 2000.,
  	      2000., 2000., 2000., 2000., 2000., 2000., 2000.,
  	      2000., 2000., 2000., 2000., 2000., 2000., 2000.,
  	      2000., 2000., 2000., 2000. };

  Float_t absor_air[NUMENTRIES] =
  	    { 200., 200., 200., 200., 200., 200., 200., 
  	      200., 200., 200., 200., 200., 200., 200.,
  	      200., 200., 200., 200., 200., 200., 200.,
  	      200., 200., 200., 200., 200., 200., 200.,
  	      200., 200., 200., 200. };
   
  Int_t *idtmed = fIdtmed->GetArray();

   gMC->SetCerenkov (idtmed[6], NUMENTRIES, ppckov, absor_qwarz, effic_all, rindex_qwarz);
   gMC->SetCerenkov (idtmed[1], NUMENTRIES, ppckov, absor_air, effic_all, rindex_air);
}

//////////////////////////////////////////////////////////////////////
// Initialises version 2 of the Forward Multiplicity Detector
//////////////////////////////////////////////////////////////////////
void AliT0v2::Init()
{
  AliT0::Init();
  fIdSens1 = gMC->VolId ("0REG");
  printf ("*** T0 version 2 initialized ***\n");
}


//////////////////////////////////////////////////////////////////////
// Called for every step in the T0 Detector
//////////////////////////////////////////////////////////////////////
void AliT0v2::StepManager()
{
  Int_t 			id;
  Int_t				copy;
//  Int_t				copy1;
  Float_t			xyz[3];
  Float_t			XYZ[3];
  Float_t			hitPhoton[6];
  static Float_t 		hits[7];
  static Float_t 		edep;
  static Int_t 			vol[2];
  TLorentzVector 		pos;
  TLorentzVector		mom;
  
  
  if(!gMC->IsTrackAlive()) return; // particle has disappeared

//  TGeant3  *g3 = (TGeant3*) gMC;
//  g3->Gpcxyz();

  TClonesArray 	&lhits = *fHits;


///////////////////////////////////////////////
// If particles is photon then ...

  if (gMC->TrackPid() == 50000050)
  {
     id = gMC->CurrentVolID(copy);

     // Check the sensetive volume
     if (id == fIdSens1) 
     {
	if (gMC->IsTrackEntering()) 
	{
	   gMC->CurrentVolOffID(2,copy);
	   if (copy < 13) 
	     {
	       vol[0] = RIGHT_ARRAY;
	       vol[1] = copy;
	     }
	   else 
	     {
	       vol[0] = LEFT_ARRAY;
	       vol[1] = copy - 12;
	     }

	   gMC->TrackPosition(pos);
	   gMC->TrackMomentum(mom);
	   XYZ[0] = pos[0];
	   XYZ[1] = pos[1];
	   XYZ[2] = pos[2];
	   gMC->Gmtod (XYZ, xyz, 1);

	   hitPhoton[0] = sqrt (xyz[0] * xyz[0] + xyz[1] * xyz[1]);
	   hitPhoton[1] = mom[0];
	   hitPhoton[2] = mom[1];
	   hitPhoton[3] = mom[2];
	   hitPhoton[4] = 1e9 * gMC->TrackTime();
	   hitPhoton[5] = 1e9 * gMC->Etot();
	   
	   AddHitPhoton (gAlice->GetMCApp()->GetCurrentTrackNumber(), vol, hitPhoton);
	}
	gMC->StopTrack();
     }
     else  
	if (id == gMC->VolId ("0DES"))  gMC->StopTrack();
  }

// end photon particalary
///////////////////////////////////////////////


///////////////////////////////////////////////
// If particles is charge then ...
 
  // Float_t charge = gMC->TrackCharge();
  //  if(TMath::Abs(charge) <= 0.) return;
  id = gMC->CurrentVolID(copy);

  
  //  printf("gMC->ckine->ipart %d",gMC->ckine->ipart);
  // Check the sensetive volume
  if(id==gMC->VolId("0TOP") ) {
    if(gMC->IsTrackEntering()) {
      gMC->CurrentVolOffID(2,copy);
      if (copy < 13) 
	{
	  vol[0] = RIGHT_ARRAY;
	  vol[1] = copy;
	}
      else 
	{
	  vol[0] = LEFT_ARRAY;
	  vol[1] = copy - 12;
	}
      
      gMC->TrackPosition(pos);
      hits[0] = pos[0];
      hits[1] = pos[1];
      hits[2] = pos[2];
      Float_t etot = gMC->Etot();
      hits[4] = etot;
      Int_t part = gMC->TrackPid();
      hits[5] = part;
      Float_t ttime = gMC->TrackTime();
      hits[6] = ttime*1e9;
      edep = 0;
    }
    if(gMC->IsTrackInside()) 	{
      Float_t de = gMC->Edep(); 
      edep = edep + de;
      //       printf ("E deposition %f\n",edep);
      //    for (i=0; i<=6; i++){
      //    printf(" HITS on T0 inside %f\n",hits[i]); } 
    }
    if(gMC->IsTrackExiting())	{
      Float_t de = gMC->Edep(); 
      edep = edep + de;
      hits[3] = edep * 1e3;

      //       for (i=0; i<=6; i++){
      //	 printf(" HITS on T0 Exit %f\n",hits[i]); } 
      //for (i=0; i<=1; i++) { printf("T0 vol %d\n",vol[i]);}
     
      new(lhits[fNhits++]) AliT0hit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,hits);      
    }
  }

// end charge particles particalary
///////////////////////////////////////////////

}
Commit	Line	Data
dc7ca31d	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	/////////////////////////////////////////////////////////////////////
	19	// //
	20	// T0 ( T-zero) detector version 0 //
	21	//
	22	//Begin Html
	23	/*
	24	<img src="gif/AliT0v2Class.gif">
	25	*/
	26	//End Html
	27	// //
	28	// //
	29	//////////////////////////////////////////////////////////////////////
	30
	31	#define RIGHT_ARRAY 1
	32	#define LEFT_ARRAY 2
	33
	34	#include <Riostream.h>
	35	#include <stdlib.h>
	36
dc7ca31d	37	#include <TLorentzVector.h>
dc7ca31d	38	#include <TMath.h>
dc7ca31d	39	#include <TVirtualMC.h>
	40
	41	#include "AliMagF.h"
	42	#include "AliRun.h"
	43	#include "AliT0hit.h"
	44	#include "AliT0v2.h"
	45	#include "AliMC.h"
dc7ca31d	46
	47	ClassImp(AliT0v2)
	48
	49
	50	//////////////////////////////////////////////////////////////////////
	51	// Standart constructor for T0 Detector version 2
	52	//////////////////////////////////////////////////////////////////////
	53	AliT0v2::AliT0v2(const char name, const char title):
	54	AliT0(name,title)
	55	{
	56	fIdSens1 = 0;
	57	// setBufferSize(128000);
	58	}
	59
	60
	61	//////////////////////////////////////////////////////////////////////
	62	// Create the geometry of T0 Detector version 2
	63	//////////////////////////////////////////////////////////////////////
	64	void AliT0v2::CreateGeometry()
	65	{
	66	/*
	67	<img src="gif/AliT0v2.gif">
	68	*/
	69
	70	Int_t *idtmed;
	71	Int_t idrotm[999];
	72	Int_t i, j;
	73	Float_t x, y, z;
	74	Float_t zRight;
	75	Float_t zLeft;
	76	Float_t phi[3];
	77	Float_t theta;
	78	Double_t angel;
	79
	80	Float_t pstart[3] = {4.5, 10.7, 5.3};
	81	Float_t pinstart[3] = {0., 1.31, 5.25};
	82	Float_t ppmt[3] = {0., 1.31, 3.5};
	83	Float_t ptop[3] = {0., 1.3, 1.5};
	84	// Float_t preg[3] = {0., 1.3, 0.005};
	85	Float_t preg[3] = {0., 0.875, 0.005};
	86	Float_t pdes[3] = {0.875, 1.3, 0.005};
	87
	88
	89	zRight = 75.;
	90	zLeft = 350.;
	91	theta = (180 / TMath::Pi()) * TMath::ATan(6.5 / zRight);
	92	angel = 2 * TMath::Pi() / 12;
	93	idtmed = fIdtmed->GetArray();
	94
	95
	96	AliMatrix (idrotm[901], 90., 0., 90., 90., 180., 0.);
	97
	98	gMC->Gsvolu ("0RST", "TUBE", idtmed[3], pstart, 3);
	99	gMC->Gsvolu ("0LST", "TUBE", idtmed[3], pstart, 3);
	100	gMC->Gspos ("0RST", 1, "ALIC", 0., 0., -zRight, 0, "ONLY");
	101	gMC->Gspos ("0LST", 1, "ALIC", 0., 0., zLeft, idrotm[901], "ONLY");
	102
	103	// 12 unit: PMT + divider
	104	gMC->Gsvolu("0INS", "TUBE", idtmed[3], pinstart, 3);
	105	z = 0;
	106	for (i = 0; i < 12; i++)
	107	{
	108	x = 6.5 * TMath::Sin(i * angel);
	109	y = 6.5 * TMath::Cos(i * angel);
110
111	phi[0] = -30 * i;
112	phi[1] = 90 - i * 30;
113	phi[2] = 90 - i * 30;
114	for (j = 0; j < 3; j++)
115	if (phi[j] < 0) phi[j] += 360;
116
117	AliMatrix (idrotm[902 + i], 90., phi[0],
118	90. + theta, phi[1],
119	theta, phi[2]);
120
121	gMC->Gspos ("0INS", i + 1, "0RST", x, y, z, idrotm[902 + i], "ONLY");
122	gMC->Gspos ("0INS", i + 13, "0LST", x, y, z, 0, "ONLY");
123	}
124
125	gMC->Gsvolu ("0PMT", "TUBE", idtmed[1], ppmt, 3);
126	x = y = 0;
127	z = -pinstart[2] + ppmt[2];
128	gMC->Gspos ("0PMT", 1, "0INS", x, y, z, 0, "ONLY");
129
130	// PMT
131	// Entry window (glass)
132	gMC->Gsvolu ("0TOP", "TUBE", idtmed[6], ptop, 3);
133	z = -ppmt[2] + ptop[2];
134	gMC->Gspos ("0TOP", 1, "0PMT", 0, 0, z, 0, "ONLY");
135
136	gMC->Gsvolu ("0REG", "TUBE", idtmed[6], preg, 3);
137	z = -ppmt[2] + 2 * ptop[2] + preg[2];
138	gMC->Gspos ("0REG", 1, "0PMT", 0, 0, z, 0, "ONLY");
139
140	gMC->Gsvolu ("0DES", "TUBE", idtmed[6], pdes, 3);
141	z = -ppmt[2] + 2 * ptop[2] + preg[2];
142	gMC->Gspos ("0DES", 1, "0PMT", 0, 0, z, 0, "ONLY");
143	}
144
145
146	//////////////////////////////////////////////////////////////////////
147	// Definition of avaible T0 materials
148	//////////////////////////////////////////////////////////////////////
149	void AliT0v2::CreateMaterials()
150	{
f7a1cc68	151	Int_t isxfld = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();
f7a1cc68	152	Float_t sxmgmx = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();
dc7ca31d	153
	154	Float_t a, z, d, radl, absl, buf[1];
	155	Int_t nbuf;
	156
	157	// Scintillator CH
	158	Float_t ascin[2] = {1.01, 12.01};
	159	Float_t zscin[2] = {1., 6.};
	160	Float_t wscin[2] = {1., 1.};
	161	Float_t denscin = 1.03;
	162
	163	// PMT glass SiO2
	164	Float_t aglass[2] = {28.0855, 15.9994};
	165	Float_t zglass[2] = {14., 8.};
	166	Float_t wglass[2] = { 1., 2.};
	167	Float_t dglass = 2.65;
	168
	169	// Ceramic 97.2% Al2O3 , 2.8% SiO2
	170	Float_t acer[2], zcer[2];
	171	Float_t wcer[2] = { 0.972, 0.028};
	172	Float_t aal2o3[2] = {26.981539, 15.9994 };
	173	Float_t zal2o3[2] = {13., 8.};
	174	Float_t wal2o3[2] = { 2., 3.};
	175	Float_t denscer = 3.6;
	176
	177	// Brass 80% Cu, 20% Zn
	178	Float_t abrass[2] = {63.546, 65.39};
	179	Float_t zbrass[2] = {29., 30.};
	180	Float_t wbrass[2] = { 0.8, 0.2};
	181	Float_t denbrass = 8.96;
	182
	183	//Ribber C6H12S
	184	Float_t aribber[3] = {12., 1., 32.};
	185	Float_t zribber[3] = { 6., 1., 16.};
	186	Float_t wribber[3] = { 6., 12., 1.};
	187	Float_t denribber = 0.8;
	188
dc7ca31d	189
	190	AliMaterial (0, "T0 Steel$", 55.850, 26., 7.87, 1.76, 999);
	191	AliMaterial (1, "T0 Vacuum$", 1.e-16, 1.e-16, 1.e-16, 1.e16, 999);
	192	AliMaterial (2, "T0 Air$", 14.61, 7.3, .001205, 30423., 999);
	193
	194	AliMixture (3, "Al2O3 $", aal2o3, zal2o3, denscer, -2, wal2o3);
	195	AliMixture (4, "PMT glass $", aglass, zglass, dglass, -2, wglass);
	196	char namate[21]="";
	197	gMC->Gfmate ((*fIdmate)[3], namate, a, z, d, radl, absl, buf, nbuf);
	198	acer[0] = a;
	199	zcer[0] = z;
	200	gMC->Gfmate ((*fIdmate)[4], namate, a, z, d, radl, absl, buf, nbuf);
	201	acer[1] = a;
	202	zcer[1] = z;
	203
	204	AliMixture (5, "Scintillator$",ascin,zscin,denscin,-2,wscin);
	205	AliMixture (6, "Brass $", abrass, zbrass, denbrass, 2, wbrass);
	206	AliMixture (7, "Ribber $",aribber,zribber,denribber,-3,wribber);
	207	AliMixture (9, "Ceramic $", acer, zcer, denscer, 2, wcer);
	208
	209	AliMedium (1, "T0 Air$", 2, 0, isxfld, sxmgmx, 10., .1, 1., .003, .003);
	210	AliMedium (2, "Scintillator$", 5, 1, isxfld, sxmgmx, 10., .01, 1., .003, .003);
	211	AliMedium (3, "Vacuum$", 1, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
	212	AliMedium (4, "Ceramic$", 9, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
	213	AliMedium (6, "Glass$", 4, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
	214	AliMedium (8, "Steel$", 0, 0, isxfld, sxmgmx, 1., .001, 1., .001, .001);
	215	AliMedium (9, "Ribber $", 7, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
	216	AliMedium(11, "Brass $", 6, 0, isxfld, sxmgmx, 10., .01, .1, .003, .003);
dc7ca31d	217	}
	218
	219
	220	//////////////////////////////////////////////////////////////////////
	221	// Draw a shaded view of the Forward multiplicity detector version 2
	222	//////////////////////////////////////////////////////////////////////
	223	void AliT0v2::DrawModule() const
	224	{
	225	//Set ALIC mother transparent
	226	gMC->Gsatt ("ALIC", "SEEN", 0);
	227
	228	//Set volumes visible
	229	gMC->Gsatt ("0STA", "SEEN", 0);
	230	gMC->Gsatt ("0PMT", "SEEN", 1);
	231	gMC->Gsatt ("0DIV", "SEEN", 1);
	232
	233	gMC->Gdopt ("hide", "on");
	234	gMC->Gdopt ("shad", "on");
	235	gMC->SetClipBox (".");
	236	gMC->SetClipBox ("*", 0, 1000, -1000, 1000, -1000, 1000);
	237	gMC->DefaultRange();
	238	gMC->Gdraw ("alic", 40, 30, 0, 12, 9.5, 0.7, 0.7);
	239	gMC->Gdhead (1111, "T-Zero detector");
	240	gMC->Gdopt ("hide", "off");
	241	}
	242
dc7ca31d	243	//////////////////////////////////////////////////////////////////////
661663fa	244	// Definition of optical properties for the Forward Multiplicity Detector
dc7ca31d	245	//////////////////////////////////////////////////////////////////////
661663fa	246	void AliT0v2::DefineOpticalProperties()
dc7ca31d	247	{
661663fa	248	// Optical properties definition.
7235aed2	249	// Definition Cherenkov parameters
	250	const Int_t NUMENTRIES = 32;
	251
	252	Float_t ppckov[NUMENTRIES] =
	253	{ 2.034E-9, 2.068E-9, 2.103E-9, 2.139E-9,
	254	2.177E-9, 2.216E-9, 2.256E-9, 2.298E-9,
	255	2.341E-9, 2.386E-9, 2.433E-9, 2.481E-9,
	256	2.532E-9, 2.585E-9, 2.640E-9, 2.697E-9,
	257	2.757E-9, 2.820E-9, 2.885E-9, 2.954E-9,
	258	3.026E-9, 3.102E-9, 3.181E-9, 3.265E-9,
	259	3.353E-9, 3.446E-9, 3.545E-9, 3.649E-9,
	260	3.760E-9, 3.877E-9, 4.002E-9, 4.136E-9 };
	261
	262	Float_t rindex_qwarz[NUMENTRIES] =
	263	{ 1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
	264	1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
	265	1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
	266	1.458, 1.458, 1.458, 1.458, 1.458, 1.458, 1.458,
	267	1.458, 1.458, 1.458, 1.458 };
	268
	269	Float_t rindex_air[NUMENTRIES] =
	270	{ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
	271	1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
	272	1., 1., 1., 1. };
	273
	274	Float_t effic_all[NUMENTRIES] =
	275	{ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
	276	1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
	277	1., 1., 1., 1. };
	278
	279	Float_t absor_qwarz[NUMENTRIES] =
	280	{ 2000., 2000., 2000., 2000., 2000., 2000., 2000.,
	281	2000., 2000., 2000., 2000., 2000., 2000., 2000.,
	282	2000., 2000., 2000., 2000., 2000., 2000., 2000.,
	283	2000., 2000., 2000., 2000., 2000., 2000., 2000.,
	284	2000., 2000., 2000., 2000. };
	285
	286	Float_t absor_air[NUMENTRIES] =
	287	{ 200., 200., 200., 200., 200., 200., 200.,
	288	200., 200., 200., 200., 200., 200., 200.,
	289	200., 200., 200., 200., 200., 200., 200.,
	290	200., 200., 200., 200., 200., 200., 200.,
	291	200., 200., 200., 200. };
	292
	293	Int_t *idtmed = fIdtmed->GetArray();
	294
	295	gMC->SetCerenkov (idtmed[6], NUMENTRIES, ppckov, absor_qwarz, effic_all, rindex_qwarz);
	296	gMC->SetCerenkov (idtmed[1], NUMENTRIES, ppckov, absor_air, effic_all, rindex_air);
661663fa	297	}
dc7ca31d	298
661663fa	299	//////////////////////////////////////////////////////////////////////
	300	// Initialises version 2 of the Forward Multiplicity Detector
	301	//////////////////////////////////////////////////////////////////////
	302	void AliT0v2::Init()
	303	{
	304	AliT0::Init();
	305	fIdSens1 = gMC->VolId ("0REG");
dc7ca31d	306	printf ("* T0 version 2 initialized *\n");
	307	}
	308
	309
	310	//////////////////////////////////////////////////////////////////////
	311	// Called for every step in the T0 Detector
	312	//////////////////////////////////////////////////////////////////////
	313	void AliT0v2::StepManager()
	314	{
	315	Int_t id;
	316	Int_t copy;
	317	// Int_t copy1;
	318	Float_t xyz[3];
	319	Float_t XYZ[3];
	320	Float_t hitPhoton[6];
	321	static Float_t hits[7];
	322	static Float_t edep;
	323	static Int_t vol[2];
	324	TLorentzVector pos;
	325	TLorentzVector mom;
	326
	327
	328	if(!gMC->IsTrackAlive()) return; // particle has disappeared
	329
	330	// TGeant3 g3 = (TGeant3) gMC;
	331	// g3->Gpcxyz();
	332
	333	TClonesArray &lhits = *fHits;
	334
	335
	336	///////////////////////////////////////////////
	337	// If particles is photon then ...
	338
	339	if (gMC->TrackPid() == 50000050)
	340	{
	341	id = gMC->CurrentVolID(copy);
	342
	343	// Check the sensetive volume
	344	if (id == fIdSens1)
	345	{
	346	if (gMC->IsTrackEntering())
	347	{
	348	gMC->CurrentVolOffID(2,copy);
	349	if (copy < 13)
	350	{
	351	vol[0] = RIGHT_ARRAY;
	352	vol[1] = copy;
	353	}
	354	else
	355	{
	356	vol[0] = LEFT_ARRAY;
	357	vol[1] = copy - 12;
	358	}
	359
	360	gMC->TrackPosition(pos);
	361	gMC->TrackMomentum(mom);
	362	XYZ[0] = pos[0];
	363	XYZ[1] = pos[1];
	364	XYZ[2] = pos[2];
	365	gMC->Gmtod (XYZ, xyz, 1);
	366
	367	hitPhoton[0] = sqrt (xyz[0] * xyz[0] + xyz[1] * xyz[1]);
	368	hitPhoton[1] = mom[0];
	369	hitPhoton[2] = mom[1];
370	hitPhoton[3] = mom[2];
371	hitPhoton[4] = 1e9 * gMC->TrackTime();
372	hitPhoton[5] = 1e9 * gMC->Etot();
373
374	AddHitPhoton (gAlice->GetMCApp()->GetCurrentTrackNumber(), vol, hitPhoton);
375	}
376	gMC->StopTrack();
377	}
378	else
379	if (id == gMC->VolId ("0DES")) gMC->StopTrack();
380	}
381
382	// end photon particalary
383	///////////////////////////////////////////////
384
385
386	///////////////////////////////////////////////
387	// If particles is charge then ...
388
389	// Float_t charge = gMC->TrackCharge();
390	// if(TMath::Abs(charge) <= 0.) return;
391	id = gMC->CurrentVolID(copy);
392
393
394	// printf("gMC->ckine->ipart %d",gMC->ckine->ipart);
395	// Check the sensetive volume
396	if(id==gMC->VolId("0TOP") ) {
397	if(gMC->IsTrackEntering()) {
398	gMC->CurrentVolOffID(2,copy);
399	if (copy < 13)
400	{
401	vol[0] = RIGHT_ARRAY;
402	vol[1] = copy;
403	}
404	else
405	{
406	vol[0] = LEFT_ARRAY;
407	vol[1] = copy - 12;
408	}
409
410	gMC->TrackPosition(pos);
411	hits[0] = pos[0];
412	hits[1] = pos[1];
413	hits[2] = pos[2];
414	Float_t etot = gMC->Etot();
415	hits[4] = etot;
416	Int_t part = gMC->TrackPid();
417	hits[5] = part;
418	Float_t ttime = gMC->TrackTime();
419	hits[6] = ttime*1e9;
420	edep = 0;
421	}
422	if(gMC->IsTrackInside()) {
423	Float_t de = gMC->Edep();
424	edep = edep + de;
425	// printf ("E deposition %f\n",edep);
426	// for (i=0; i<=6; i++){
427	// printf(" HITS on T0 inside %f\n",hits[i]); }
428	}
429	if(gMC->IsTrackExiting()) {
430	Float_t de = gMC->Edep();
431	edep = edep + de;
432	hits[3] = edep * 1e3;
433
434	// for (i=0; i<=6; i++){
435	// printf(" HITS on T0 Exit %f\n",hits[i]); }
436	//for (i=0; i<=1; i++) { printf("T0 vol %d\n",vol[i]);}
437
438	new(lhits[fNhits++]) AliT0hit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,hits);
439	}
440	}
441
442	// end charge particles particalary
443	///////////////////////////////////////////////
444
445	}