[u/mrichter/AliRoot.git] / ITS / AliITSvtest.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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.7  2001/02/09 20:06:26  nilsen
Fixed bug in distructor. Can't distroy fixxed length arrays. Thanks Peter.

Revision 1.6  2001/02/09 00:05:31  nilsen
Added fMajor/MinorVersion variables and made other changes to better make
use of the new code changes in AliITSgeom related classes.

Revision 1.5  2001/01/30 09:23:14  hristov
Streamers removed (R.Brun)

Revision 1.4  2001/01/18 06:25:09  barbera
ITS geometry using test Euclid files

Revision 1.1.2.8  2000/10/05 20:28:18  nilsen
Now using root generated streamer function.

Revision 1.1.2.7  2000/07/31 13:51:22  barbera
Updated from the release

Revision 1.2  2000/07/10 16:07:19  fca
Release version of ITS code

Revision 1.1.2.2  2000/03/02 21:53:36  nilsen
to make it compatable with the changes in AliRun/AliModule.

Revision 1.1.2.1  2000/01/12 20:19:03  nilsen
	The changes made with this latest inclusion of code is very large.
Many of the new files were added just in December when P. Cerello added his
SDD simulations to the distrobutions. Also added are some file of P. Skowronski
for SSD cluster finding and ghost RecPoints. None of this "new" code has been
proporly tested. Other code new to this cvs repository is explained in the
ITS Off-line web page. In general the changes are too large to give a resonable
discription of them but probably should be taken as the starting point for
the developement branch (ITS-working).
    B. S. Nilsen

Revision 1.13  1999/10/16 19:49:00  BSN
$Name$
$Author$
$Id$
*/

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Inner Traking System version Test                                        //
//  This class contains the base procedures for the Inner Tracking System    //
//                                                                           //
// Authors: R. Barbera, B. S. Nilsen.                                        //
// version  Test                                                             //
// Created October 16 1999.                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <TMath.h>
#include <TGeometry.h>
#include <TNode.h>
#include <TTUBE.h>
#include <TFile.h>    // only required for Tracking function?
#include <TCanvas.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TClonesArray.h>
#include <TLorentzVector.h>
#include <TBRIK.h>
#include <TSystem.h>

#include "AliMC.h"
#include "AliRun.h"
#include "../TGeant3/TGeant3.h"
#include "AliITSGeant3Geometry.h"
#include "AliITShit.h"
#include "AliITS.h"
#include "AliITSvtest.h"
#include "AliITSgeom.h"
#include "AliITSgeomSPD.h"
#include "AliITSgeomSDD.h"
#include "AliITSgeomSSD.h"

ClassImp(AliITSvtest)
 
//_____________________________________________________________________________
AliITSvtest::AliITSvtest() {
    // Standard constructor for the ITS
    Int_t i;

    fIdN    = 0;
    fIdName = 0;
    fIdSens = 0;
    fEuclidOut    = kFALSE; // Don't write Euclide file
    fGeomDetOut   = kFALSE; // Don't write .det file
    fGeomDetIn    = kTRUE; // Read .det file
    fMajorVersion = IsVersion();
    fMinorVersion = -1;
    for(i=0;i<60;i++) fRead[i] = '\0';
    for(i=0;i<60;i++) fWrite[i] = '\0';
    for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
}
//____________________________________________________________________________
AliITSvtest::AliITSvtest(const AliITSvtest &source){
////////////////////////////////////////////////////////////////////////
//     Copy Constructor for ITS test version.
////////////////////////////////////////////////////////////////////////
    if(&source == this) return;
    Warning("Copy Constructor","Not allowed to copy AliITSvtest");
    return;
}
//_____________________________________________________________________________
AliITSvtest& AliITSvtest::operator=(const AliITSvtest &source){
////////////////////////////////////////////////////////////////////////
//    Assignment operator for the ITS version 1.
////////////////////////////////////////////////////////////////////////
	if(&source == this) return *this;
	Warning("= operator","Not allowed to copy AliITSvtest");
	return *this;
}
//_____________________________________________________________________________
AliITSvtest::~AliITSvtest() {
    // Standard destructor for the ITS
}
//_____________________________________________________________________________
AliITSvtest::AliITSvtest(const char *fileeuc,const char *filetme,
			 const char *name, const char *title) 
    : AliITS(name, title){
    //
    // Standard constructor for the ITS
    //
    fIdN    = 6;
    fIdName    = new TString[fIdN];
    fIdName[0] = "ITS1";
    fIdName[1] = "ITS2";
    fIdName[2] = "ITS3";
    fIdName[3] = "ITS4";
    fIdName[4] = "ITS5";
    fIdName[5] = "ITS6";
    fIdSens    = new Int_t[fIdN];
    for (Int_t i=0;i<fIdN;i++) fIdSens[i] = 0;
    fMajorVersion = IsVersion();
    fMinorVersion = 1;
    fEuclidOut    = kFALSE; // Don't write Euclide file
    fGeomDetOut   = kFALSE; // Don't write .det file
    fGeomDetIn    = kTRUE; // Read .det file

    fEuclidMaterial = filetme;
    fEuclidGeometry = fileeuc;
    strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_PPR.det",60);
    strncpy(fRead,fEuclidGeomDet,60);
    strncpy(fWrite,fEuclidGeomDet,60);
//  The .det file for the geometry must have the same name as fileeuc with
//  .euc replaced by .det.
}

 
//_____________________________________________________________________________
void AliITSvtest::CreateMaterials(){
  //
  // Read materials for the ITS
  //
    char *filtmp;
//
  filtmp = gSystem->ExpandPathName(fEuclidMaterial.Data());
//  FILE *file = fopen(fEuclidMaterial.Data(),"r");
  FILE *file = fopen(filtmp,"r");
  if(file) {
    fclose(file);
//    ReadEuclidMedia(fEuclidMaterial.Data(),this);
    ReadEuclidMedia(filtmp);
  } else {
    Error("CreateMaterials"," THE MEDIA FILE %s DOES NOT EXIST !",
//	  fEuclidMaterial.Data());
	  filtmp);
    exit(1);
  } // end if(file)
}

//_____________________________________________________________________________
void AliITSvtest::CreateGeometry(){
//////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
// Read geometry for the ITS
//
    char topvol[5];
    char *filtmp;
//
  filtmp = gSystem->ExpandPathName(fEuclidGeometry.Data());
  FILE *file = fopen(filtmp,"r");
  delete [] filtmp;
  if(file) {
    fclose(file);
    printf("Ready to read Euclid geometry file\n");
    ReadEuclid(fEuclidGeometry.Data(),topvol);
    printf("Read in euclid geometries\n");
  } else {
    Error("CreateGeometry"," THE GEOM FILE %s DOES NOT EXIST !",
	  fEuclidGeometry.Data());
    exit(1);
  } // end if(file)
  //
  //---Place the ITS ghost volume ITSV in its mother volume (ALIC) and make it
  //     invisible
  //
  gMC->Gspos("ITSV",1,"ALIC",0,0,0,0,"ONLY");
  //
  //---Outputs the geometry tree in the EUCLID/CAD format
  
    if (fEuclidOut) {
      gMC->WriteEuclid("ITSgeometry", "ITSV", 1, 5);
    } // end if (fEuclidOut)
    cout <<"finished with euclid geometrys"<< endl;
}
//______________________________________________________________________
void AliITSvtest::InitAliITSgeom(){
//     Based on the geometry tree defined in Geant 3.21, this
// routine initilizes the Class AliITSgeom from the Geant 3.21 ITS geometry
// sturture.
    if(!(dynamic_cast<TGeant3*>(gMC))) {
	Error("InitAliITSgeom",
		"Wrong Monte Carlo. InitAliITSgeom uses TGeant3 calls");
	return;
    } // end if
    cout << "Reading Geometry transformation directly from Geant 3." << endl;
    const Int_t nlayers = 6;
    const Int_t ndeep = 9;
    Int_t itsGeomTreeNames[nlayers][ndeep],lnam[20],lnum[20];
    Int_t nlad[nlayers],ndet[nlayers];
    Double_t t[3],r[10];
    Float_t  par[20],att[20];
    Int_t    npar,natt,idshape,imat,imed;
    AliITSGeant3Geometry *ig = new AliITSGeant3Geometry();
    Int_t mod,lay,lad,det,i,j,k;
    char *names[nlayers][ndeep] = {
     {"ALIC","ITSV","ITSD","IT12","I12B","I10B","I107","I101","ITS1"}, // lay=1
     {"ALIC","ITSV","ITSD","IT12","I12B","I20B","I1D7","I1D1","ITS2"}, // lay=2
     {"ALIC","ITSV","ITSD","IT34","I004","I302","ITS3","    ","    "}, // lay=3
     {"ALIC","ITSV","ITSD","IT34","I005","I402","ITS4","    ","    "}, // lay=4
     {"ALIC","ITSV","ITSD","IT56","I565","I562","ITS5","    ","    "}, // lay=5
     {"ALIC","ITSV","ITSD","IT56","I569","I566","ITS6","    ","    "}};// lay=6
    Int_t itsGeomTreeCopys[nlayers][ndeep] = {{1,1,1,1,10, 2, 4, 1, 1},// lay=1
					      {1,1,1,1,10, 4, 4, 1, 1},// lay=2
					      {1,1,1,1,14, 6, 1, 0, 0},// lay=3
					      {1,1,1,1,22, 8, 1, 0, 0},// lay=4
					      {1,1,1,1,34,22, 1, 0, 0},// lay=5
					      {1,1,1,1,38,25, 1, 0, 0}};//lay=6

    // Sorry, but this is not very pritty code. It should be replaced
    // at some point with a version that can search through the geometry
    // tree its self.
    cout << "Reading Geometry informaton from Geant3 common blocks" << endl;
    for(i=0;i<20;i++) lnam[i] = lnum[i] = 0;
    for(i=0;i<nlayers;i++)for(j=0;j<ndeep;j++) 
	itsGeomTreeNames[i][j] = ig->StringToInt(names[i][j]);
    mod = 0;
    for(i=0;i<nlayers;i++){
	k = 1;
	for(j=0;j<ndeep;j++) if(itsGeomTreeCopys[i][j]!=0)
	    k *= TMath::Abs(itsGeomTreeCopys[i][j]);
	mod += k;
    } // end for i

    if(fITSgeom!=0) delete fITSgeom;
    nlad[0]=20;nlad[1]=40;nlad[2]=14;nlad[3]=22;nlad[4]=34;nlad[5]=38;
    ndet[0]=4;ndet[1]=4;ndet[2]=6;ndet[3]=8;ndet[4]=22;ndet[5]=25;
    fITSgeom = new AliITSgeom(0,6,nlad,ndet,mod);
    mod = -1;
    for(lay=1;lay<=nlayers;lay++){
	for(j=0;j<ndeep;j++) lnam[j] = itsGeomTreeNames[lay-1][j];
	for(j=0;j<ndeep;j++) lnum[j] = itsGeomTreeCopys[lay-1][j];
	switch (lay){
	case 1: case 2: // layers 1 and 2 are a bit special
	    lad = 0;
	    for(j=1;j<=itsGeomTreeCopys[lay-1][4];j++){
		lnum[4] = j;
		for(k=1;k<=itsGeomTreeCopys[lay-1][5];k++){
		    lad++;
		    lnum[5] = k;
		    for(det=1;det<=itsGeomTreeCopys[lay-1][6];det++){
			lnum[6] = det;
			mod++;
			ig->GetGeometry(ndeep,lnam,lnum,t,r,idshape,npar,natt,
					par,att,imat,imed);
			fITSgeom->CreatMatrix(mod,lay,lad,det,kSPD,t,r);
			if(!(fITSgeom->IsShapeDefined((Int_t)kSPD)))
			    if(fMinorVersion==1){
                             fITSgeom->ReSetShape(kSPD,
						  new AliITSgeomSPD425Short());
			    } else if(fMinorVersion==2)
                             fITSgeom->ReSetShape(kSPD,
						  new AliITSgeomSPD425Short());
		    } // end for det
		} // end for k
            } // end for j
	    break;
	case 3: case 4: case 5: case 6: // layers 3-6
	    lnum[6] = 1;
	    for(lad=1;lad<=itsGeomTreeCopys[lay-1][4];lad++){
		lnum[4] = lad;
		for(det=1;det<=itsGeomTreeCopys[lay-1][5];det++){
		    lnum[5] = det;
		    mod++;
		    ig->GetGeometry(7,lnam,lnum,t,r,idshape,npar,natt,
				    par,att,imat,imed);
		    switch (lay){
		    case 3: case 4:
			fITSgeom->CreatMatrix(mod,lay,lad,det,kSDD,t,r);
			if(!(fITSgeom->IsShapeDefined(kSDD))) 
			    fITSgeom->ReSetShape(kSDD,new AliITSgeomSDD256());
			    break;
			case 5:
			    fITSgeom->CreatMatrix(mod,lay,lad,det,kSSD,t,r);
			    if(!(fITSgeom->IsShapeDefined(kSSD))) 
				fITSgeom->ReSetShape(kSSD,new AliITSgeomSSD275and75());
			    break;
			case 6:
			    fITSgeom->CreatMatrix(mod,lay,lad,det,kSSDp,t,r);
			    if(!(fITSgeom->IsShapeDefined(kSSDp))) 
				fITSgeom->ReSetShape(kSSDp,new AliITSgeomSSD75and275());
			    break;
			} // end switch
		} // end for det
	    } // end for lad
	    break;
	} // end switch
    } // end for lay
    return;
}
//_____________________________________________________________________________
void AliITSvtest::Init(){
////////////////////////////////////////////////////////////////////////
//     Initialise the ITS after it has been created.
////////////////////////////////////////////////////////////////////////
    Int_t i;

    cout << endl;
    for(i=0;i<29;i++) cout << "*";cout << " ITSvtest_Init ";
    for(i=0;i<28;i++) cout << "*";cout << endl;
//
    if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60);
    if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60);
    if(fITSgeom!=0) delete fITSgeom;
    fITSgeom = new AliITSgeom();
    if(fGeomDetIn) fITSgeom->ReadNewFile(fRead);
    if(!fGeomDetIn) this->InitAliITSgeom();
    if(fGeomDetOut) fITSgeom->WriteNewFile(fWrite);
    AliITS::Init();
//
    for(i=0;i<72;i++) cout << "*";
    cout << endl;
}
//_____________________________________________________________________________
void AliITSvtest::StepManager(){
  //
  // Called for every step in the ITS
  //
  Int_t          copy, id;
  Int_t          copy1,copy2;
  Float_t        hits[8];
  Int_t          vol[4];
  TLorentzVector position, momentum;
  TClonesArray   &lhits = *fHits;
  //
  // Track status
  vol[3] = 0;
  if(gMC->IsTrackInside())      vol[3] +=  1;
  if(gMC->IsTrackEntering())    vol[3] +=  2;
  if(gMC->IsTrackExiting())     vol[3] +=  4;
  if(gMC->IsTrackOut())         vol[3] +=  8;
  if(gMC->IsTrackDisappeared()) vol[3] += 16;
  if(gMC->IsTrackStop())        vol[3] += 32;
  if(gMC->IsTrackAlive())       vol[3] += 64;
  //
  // Fill hit structure.
  if(!(gMC->TrackCharge())) return;
  //
  // Only entering charged tracks
  if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
      vol[0] = 1;
      id = gMC->CurrentVolOffID(0,copy);
      //detector copy in the ladder = 1<->4  (ITS1)
      vol[1] = copy;
      gMC->CurrentVolOffID(1,copy1);
      //ladder copy in the module   = 1<->2  (I186)
      gMC->CurrentVolOffID(2,copy2);
      //module copy in the layer    = 1<->10 (I132)
      vol[2] = copy1+(copy2-1)*2;//# of ladders in one module  = 2
  } else if(id == fIdSens[1]){
      vol[0] = 2;
      id = gMC->CurrentVolOffID(0,copy);
      //detector copy in the ladder = 1<->4  (ITS2)
      vol[1] = copy;
      gMC->CurrentVolOffID(1,copy1);
      //ladder copy in the module   = 1<->4  (I131)
      gMC->CurrentVolOffID(2,copy2);
      //module copy in the layer    = 1<->10 (I132)
      vol[2] = copy1+(copy2-1)*4;//# of ladders in one module  = 4
  } else if(id == fIdSens[2]){
      vol[0] = 3;
      id = gMC->CurrentVolOffID(1,copy);
      //detector copy in the ladder = 1<->5  (ITS3 is inside I314)
      vol[1] = copy;
      id = gMC->CurrentVolOffID(2,copy);
      //ladder copy in the layer    = 1<->12 (I316)
      vol[2] = copy;
  } else if(id == fIdSens[3]){
      vol[0] = 4;
      id = gMC->CurrentVolOffID(1,copy);
      //detector copy in the ladder = 1<->8  (ITS4 is inside I414)
      vol[1] = copy;
      id = gMC->CurrentVolOffID(2,copy);
      //ladder copy in the layer    = 1<->22 (I417)
      vol[2] = copy;
  }else if(id == fIdSens[4]){
      vol[0] = 5;
      id = gMC->CurrentVolOffID(1,copy);
      //detector copy in the ladder = 1<->23  (ITS5 is inside I562)
      vol[1] = copy;
      id = gMC->CurrentVolOffID(2,copy);
     //ladder copy in the layer    = 1<->34 (I565)
      vol[2] = copy;
  }else if(id == fIdSens[5]){
      vol[0] = 6;
      id = gMC->CurrentVolOffID(1,copy);
      //detector copy in the ladder = 1<->26  (ITS6 is inside I566)
      vol[1] = copy;
      id = gMC->CurrentVolOffID(2,copy);
      //ladder copy in the layer = 1<->38 (I569)
      vol[2] = copy;
  } else {
      return; // not an ITS volume?
  } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
//
  gMC->TrackPosition(position);
  gMC->TrackMomentum(momentum);
  hits[0]=position[0];
  hits[1]=position[1];
  hits[2]=position[2];
  hits[3]=momentum[0];
  hits[4]=momentum[1];
  hits[5]=momentum[2];
  hits[6]=gMC->Edep();
  hits[7]=gMC->TrackTime();
  // Fill hit structure with this new hit.
  new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
  return;
}
Commit	Line	Data
3fccfd9e	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	/*
	17	$Log$
9a4c6ea3	18	Revision 1.7 2001/02/09 20:06:26 nilsen
	19	Fixed bug in distructor. Can't distroy fixxed length arrays. Thanks Peter.
	20
58e13d99	21	Revision 1.6 2001/02/09 00:05:31 nilsen
	22	Added fMajor/MinorVersion variables and made other changes to better make
	23	use of the new code changes in AliITSgeom related classes.
	24
bae7e562	25	Revision 1.5 2001/01/30 09:23:14 hristov
	26	Streamers removed (R.Brun)
	27
a8a6107b	28	Revision 1.4 2001/01/18 06:25:09 barbera
	29	ITS geometry using test Euclid files
	30
3fccfd9e	31	Revision 1.1.2.8 2000/10/05 20:28:18 nilsen
	32	Now using root generated streamer function.
	33
	34	Revision 1.1.2.7 2000/07/31 13:51:22 barbera
	35	Updated from the release
	36
	37	Revision 1.2 2000/07/10 16:07:19 fca
	38	Release version of ITS code
	39
	40	Revision 1.1.2.2 2000/03/02 21:53:36 nilsen
	41	to make it compatable with the changes in AliRun/AliModule.
	42
	43	Revision 1.1.2.1 2000/01/12 20:19:03 nilsen
	44	The changes made with this latest inclusion of code is very large.
	45	Many of the new files were added just in December when P. Cerello added his
	46	SDD simulations to the distrobutions. Also added are some file of P. Skowronski
	47	for SSD cluster finding and ghost RecPoints. None of this "new" code has been
	48	proporly tested. Other code new to this cvs repository is explained in the
	49	ITS Off-line web page. In general the changes are too large to give a resonable
	50	discription of them but probably should be taken as the starting point for
	51	the developement branch (ITS-working).
	52	B. S. Nilsen
	53
	54	Revision 1.13 1999/10/16 19:49:00 BSN
	55	$Name$
	56	$Author$
	57	$Id$
	58	*/
	59
	60	///////////////////////////////////////////////////////////////////////////////
	61	// //
	62	// Inner Traking System version Test //
	63	// This class contains the base procedures for the Inner Tracking System //
	64	// //
	65	// Authors: R. Barbera, B. S. Nilsen. //
	66	// version Test //
	67	// Created October 16 1999. //
	68	// //
	69	///////////////////////////////////////////////////////////////////////////////
	70	#include <stdio.h>
	71	#include <stdlib.h>
	72	#include <TMath.h>
	73	#include <TGeometry.h>
	74	#include <TNode.h>
	75	#include <TTUBE.h>
	76	#include <TFile.h> // only required for Tracking function?
	77	#include <TCanvas.h>
	78	#include <TObjArray.h>
	79	#include <TObjString.h>
	80	#include <TClonesArray.h>
	81	#include <TLorentzVector.h>
	82	#include <TBRIK.h>
	83	#include <TSystem.h>
	84
	85	#include "AliMC.h"
	86	#include "AliRun.h"
bae7e562	87	#include "../TGeant3/TGeant3.h"
bae7e562	88	#include "AliITSGeant3Geometry.h"
3fccfd9e	89	#include "AliITShit.h"
	90	#include "AliITS.h"
	91	#include "AliITSvtest.h"
	92	#include "AliITSgeom.h"
bae7e562	93	#include "AliITSgeomSPD.h"
	94	#include "AliITSgeomSDD.h"
	95	#include "AliITSgeomSSD.h"
3fccfd9e	96
	97	ClassImp(AliITSvtest)
	98
	99	//_____________________________________________________________________________
	100	AliITSvtest::AliITSvtest() {
3fccfd9e	101	// Standard constructor for the ITS
bae7e562	102	Int_t i;
bae7e562	103
3fccfd9e	104	fIdN = 0;
	105	fIdName = 0;
	106	fIdSens = 0;
bae7e562	107	fEuclidOut = kFALSE; // Don't write Euclide file
	108	fGeomDetOut = kFALSE; // Don't write .det file
	109	fGeomDetIn = kTRUE; // Read .det file
	110	fMajorVersion = IsVersion();
3fccfd9e	111	fMinorVersion = -1;
bae7e562	112	for(i=0;i<60;i++) fRead[i] = '\0';
	113	for(i=0;i<60;i++) fWrite[i] = '\0';
	114	for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
3fccfd9e	115	}
	116	//____________________________________________________________________________
	117	AliITSvtest::AliITSvtest(const AliITSvtest &source){
	118	////////////////////////////////////////////////////////////////////////
	119	// Copy Constructor for ITS test version.
	120	////////////////////////////////////////////////////////////////////////
	121	if(&source == this) return;
bae7e562	122	Warning("Copy Constructor","Not allowed to copy AliITSvtest");
3fccfd9e	123	return;
	124	}
	125	//_____________________________________________________________________________
	126	AliITSvtest& AliITSvtest::operator=(const AliITSvtest &source){
	127	////////////////////////////////////////////////////////////////////////
	128	// Assignment operator for the ITS version 1.
	129	////////////////////////////////////////////////////////////////////////
	130	if(&source == this) return *this;
bae7e562	131	Warning("= operator","Not allowed to copy AliITSvtest");
3fccfd9e	132	return *this;
	133	}
	134	//_____________________________________________________________________________
	135	AliITSvtest::~AliITSvtest() {
3fccfd9e	136	// Standard destructor for the ITS
3fccfd9e	137	}
	138	//_____________________________________________________________________________
	139	AliITSvtest::AliITSvtest(const char fileeuc,const char filetme,
	140	const char name, const char title)
	141	: AliITS(name, title){
	142	//
	143	// Standard constructor for the ITS
	144	//
	145	fIdN = 6;
3fccfd9e	146	fIdName = new TString[fIdN];
	147	fIdName[0] = "ITS1";
	148	fIdName[1] = "ITS2";
	149	fIdName[2] = "ITS3";
	150	fIdName[3] = "ITS4";
	151	fIdName[4] = "ITS5";
	152	fIdName[5] = "ITS6";
	153	fIdSens = new Int_t[fIdN];
	154	for (Int_t i=0;i<fIdN;i++) fIdSens[i] = 0;
bae7e562	155	fMajorVersion = IsVersion();
3fccfd9e	156	fMinorVersion = 1;
bae7e562	157	fEuclidOut = kFALSE; // Don't write Euclide file
	158	fGeomDetOut = kFALSE; // Don't write .det file
	159	fGeomDetIn = kTRUE; // Read .det file
3fccfd9e	160
	161	fEuclidMaterial = filetme;
	162	fEuclidGeometry = fileeuc;
bae7e562	163	strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_PPR.det",60);
	164	strncpy(fRead,fEuclidGeomDet,60);
	165	strncpy(fWrite,fEuclidGeomDet,60);
3fccfd9e	166	// The .det file for the geometry must have the same name as fileeuc with
	167	// .euc replaced by .det.
	168	}
	169
	170
	171	//_____________________________________________________________________________
	172	void AliITSvtest::CreateMaterials(){
	173	//
	174	// Read materials for the ITS
	175	//
	176	char *filtmp;
	177	//
	178	filtmp = gSystem->ExpandPathName(fEuclidMaterial.Data());
	179	// FILE *file = fopen(fEuclidMaterial.Data(),"r");
	180	FILE *file = fopen(filtmp,"r");
	181	if(file) {
	182	fclose(file);
	183	// ReadEuclidMedia(fEuclidMaterial.Data(),this);
	184	ReadEuclidMedia(filtmp);
	185	} else {
	186	Error("CreateMaterials"," THE MEDIA FILE %s DOES NOT EXIST !",
	187	// fEuclidMaterial.Data());
	188	filtmp);
	189	exit(1);
	190	} // end if(file)
	191	}
	192
	193	//_____________________________________________________________________________
	194	void AliITSvtest::CreateGeometry(){
	195	//////////////////////////////////////////////////////////////////////
	196	////////////////////////////////////////////////////////////////////////
	197	// Read geometry for the ITS
	198	//
3fccfd9e	199	char topvol[5];
	200	char *filtmp;
	201	//
	202	filtmp = gSystem->ExpandPathName(fEuclidGeometry.Data());
	203	FILE *file = fopen(filtmp,"r");
	204	delete [] filtmp;
	205	if(file) {
	206	fclose(file);
	207	printf("Ready to read Euclid geometry file\n");
	208	ReadEuclid(fEuclidGeometry.Data(),topvol);
	209	printf("Read in euclid geometries\n");
	210	} else {
	211	Error("CreateGeometry"," THE GEOM FILE %s DOES NOT EXIST !",
	212	fEuclidGeometry.Data());
	213	exit(1);
	214	} // end if(file)
	215	//
	216	//---Place the ITS ghost volume ITSV in its mother volume (ALIC) and make it
	217	// invisible
	218	//
	219	gMC->Gspos("ITSV",1,"ALIC",0,0,0,0,"ONLY");
	220	//
	221	//---Outputs the geometry tree in the EUCLID/CAD format
	222
	223	if (fEuclidOut) {
	224	gMC->WriteEuclid("ITSgeometry", "ITSV", 1, 5);
	225	} // end if (fEuclidOut)
bae7e562	226	cout <<"finished with euclid geometrys"<< endl;
3fccfd9e	227	}
bae7e562	228	//______________________________________________________________________
	229	void AliITSvtest::InitAliITSgeom(){
	230	// Based on the geometry tree defined in Geant 3.21, this
	231	// routine initilizes the Class AliITSgeom from the Geant 3.21 ITS geometry
	232	// sturture.
9a4c6ea3	233	if(!(dynamic_cast<TGeant3*>(gMC))) {
bae7e562	234	Error("InitAliITSgeom",
	235	"Wrong Monte Carlo. InitAliITSgeom uses TGeant3 calls");
	236	return;
	237	} // end if
	238	cout << "Reading Geometry transformation directly from Geant 3." << endl;
	239	const Int_t nlayers = 6;
	240	const Int_t ndeep = 9;
	241	Int_t itsGeomTreeNames[nlayers][ndeep],lnam[20],lnum[20];
	242	Int_t nlad[nlayers],ndet[nlayers];
	243	Double_t t[3],r[10];
	244	Float_t par[20],att[20];
	245	Int_t npar,natt,idshape,imat,imed;
	246	AliITSGeant3Geometry *ig = new AliITSGeant3Geometry();
	247	Int_t mod,lay,lad,det,i,j,k;
	248	char *names[nlayers][ndeep] = {
	249	{"ALIC","ITSV","ITSD","IT12","I12B","I10B","I107","I101","ITS1"}, // lay=1
	250	{"ALIC","ITSV","ITSD","IT12","I12B","I20B","I1D7","I1D1","ITS2"}, // lay=2
	251	{"ALIC","ITSV","ITSD","IT34","I004","I302","ITS3"," "," "}, // lay=3
	252	{"ALIC","ITSV","ITSD","IT34","I005","I402","ITS4"," "," "}, // lay=4
	253	{"ALIC","ITSV","ITSD","IT56","I565","I562","ITS5"," "," "}, // lay=5
	254	{"ALIC","ITSV","ITSD","IT56","I569","I566","ITS6"," "," "}};// lay=6
	255	Int_t itsGeomTreeCopys[nlayers][ndeep] = {{1,1,1,1,10, 2, 4, 1, 1},// lay=1
	256	{1,1,1,1,10, 4, 4, 1, 1},// lay=2
	257	{1,1,1,1,14, 6, 1, 0, 0},// lay=3
	258	{1,1,1,1,22, 8, 1, 0, 0},// lay=4
	259	{1,1,1,1,34,22, 1, 0, 0},// lay=5
	260	{1,1,1,1,38,25, 1, 0, 0}};//lay=6
	261
	262	// Sorry, but this is not very pritty code. It should be replaced
	263	// at some point with a version that can search through the geometry
	264	// tree its self.
	265	cout << "Reading Geometry informaton from Geant3 common blocks" << endl;
	266	for(i=0;i<20;i++) lnam[i] = lnum[i] = 0;
	267	for(i=0;i<nlayers;i++)for(j=0;j<ndeep;j++)
	268	itsGeomTreeNames[i][j] = ig->StringToInt(names[i][j]);
	269	mod = 0;
	270	for(i=0;i<nlayers;i++){
	271	k = 1;
	272	for(j=0;j<ndeep;j++) if(itsGeomTreeCopys[i][j]!=0)
	273	k *= TMath::Abs(itsGeomTreeCopys[i][j]);
	274	mod += k;
	275	} // end for i
3fccfd9e	276
bae7e562	277	if(fITSgeom!=0) delete fITSgeom;
	278	nlad[0]=20;nlad[1]=40;nlad[2]=14;nlad[3]=22;nlad[4]=34;nlad[5]=38;
	279	ndet[0]=4;ndet[1]=4;ndet[2]=6;ndet[3]=8;ndet[4]=22;ndet[5]=25;
	280	fITSgeom = new AliITSgeom(0,6,nlad,ndet,mod);
	281	mod = -1;
	282	for(lay=1;lay<=nlayers;lay++){
	283	for(j=0;j<ndeep;j++) lnam[j] = itsGeomTreeNames[lay-1][j];
	284	for(j=0;j<ndeep;j++) lnum[j] = itsGeomTreeCopys[lay-1][j];
	285	switch (lay){
	286	case 1: case 2: // layers 1 and 2 are a bit special
	287	lad = 0;
	288	for(j=1;j<=itsGeomTreeCopys[lay-1][4];j++){
	289	lnum[4] = j;
	290	for(k=1;k<=itsGeomTreeCopys[lay-1][5];k++){
	291	lad++;
	292	lnum[5] = k;
	293	for(det=1;det<=itsGeomTreeCopys[lay-1][6];det++){
	294	lnum[6] = det;
	295	mod++;
	296	ig->GetGeometry(ndeep,lnam,lnum,t,r,idshape,npar,natt,
	297	par,att,imat,imed);
	298	fITSgeom->CreatMatrix(mod,lay,lad,det,kSPD,t,r);
	299	if(!(fITSgeom->IsShapeDefined((Int_t)kSPD)))
	300	if(fMinorVersion==1){
	301	fITSgeom->ReSetShape(kSPD,
	302	new AliITSgeomSPD425Short());
	303	} else if(fMinorVersion==2)
	304	fITSgeom->ReSetShape(kSPD,
	305	new AliITSgeomSPD425Short());
	306	} // end for det
	307	} // end for k
	308	} // end for j
	309	break;
	310	case 3: case 4: case 5: case 6: // layers 3-6
	311	lnum[6] = 1;
	312	for(lad=1;lad<=itsGeomTreeCopys[lay-1][4];lad++){
	313	lnum[4] = lad;
	314	for(det=1;det<=itsGeomTreeCopys[lay-1][5];det++){
	315	lnum[5] = det;
	316	mod++;
	317	ig->GetGeometry(7,lnam,lnum,t,r,idshape,npar,natt,
	318	par,att,imat,imed);
	319	switch (lay){
	320	case 3: case 4:
	321	fITSgeom->CreatMatrix(mod,lay,lad,det,kSDD,t,r);
	322	if(!(fITSgeom->IsShapeDefined(kSDD)))
	323	fITSgeom->ReSetShape(kSDD,new AliITSgeomSDD256());
	324	break;
	325	case 5:
	326	fITSgeom->CreatMatrix(mod,lay,lad,det,kSSD,t,r);
	327	if(!(fITSgeom->IsShapeDefined(kSSD)))
	328	fITSgeom->ReSetShape(kSSD,new AliITSgeomSSD275and75());
	329	break;
	330	case 6:
	331	fITSgeom->CreatMatrix(mod,lay,lad,det,kSSDp,t,r);
	332	if(!(fITSgeom->IsShapeDefined(kSSDp)))
	333	fITSgeom->ReSetShape(kSSDp,new AliITSgeomSSD75and275());
	334	break;
	335	} // end switch
	336	} // end for det
	337	} // end for lad
	338	break;
	339	} // end switch
	340	} // end for lay
341	return;
342	}
3fccfd9e	343	//_____________________________________________________________________________
3fccfd9e	344	void AliITSvtest::Init(){
bae7e562	345	////////////////////////////////////////////////////////////////////////
	346	// Initialise the ITS after it has been created.
	347	////////////////////////////////////////////////////////////////////////
	348	Int_t i;
	349
	350	cout << endl;
	351	for(i=0;i<29;i++) cout << "*";cout << " ITSvtest_Init ";
	352	for(i=0;i<28;i++) cout << "*";cout << endl;
	353	//
	354	if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60);
	355	if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60);
	356	if(fITSgeom!=0) delete fITSgeom;
	357	fITSgeom = new AliITSgeom();
	358	if(fGeomDetIn) fITSgeom->ReadNewFile(fRead);
	359	if(!fGeomDetIn) this->InitAliITSgeom();
	360	if(fGeomDetOut) fITSgeom->WriteNewFile(fWrite);
3fccfd9e	361	AliITS::Init();
bae7e562	362	//
	363	for(i=0;i<72;i++) cout << "*";
	364	cout << endl;
	365	}
3fccfd9e	366	//_____________________________________________________________________________
	367	void AliITSvtest::StepManager(){
	368	//
	369	// Called for every step in the ITS
	370	//
	371	Int_t copy, id;
	372	Int_t copy1,copy2;
	373	Float_t hits[8];
	374	Int_t vol[4];
	375	TLorentzVector position, momentum;
	376	TClonesArray &lhits = *fHits;
	377	//
	378	// Track status
	379	vol[3] = 0;
	380	if(gMC->IsTrackInside()) vol[3] += 1;
	381	if(gMC->IsTrackEntering()) vol[3] += 2;
	382	if(gMC->IsTrackExiting()) vol[3] += 4;
	383	if(gMC->IsTrackOut()) vol[3] += 8;
	384	if(gMC->IsTrackDisappeared()) vol[3] += 16;
	385	if(gMC->IsTrackStop()) vol[3] += 32;
	386	if(gMC->IsTrackAlive()) vol[3] += 64;
	387	//
	388	// Fill hit structure.
	389	if(!(gMC->TrackCharge())) return;
	390	//
	391	// Only entering charged tracks
	392	if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
	393	vol[0] = 1;
	394	id = gMC->CurrentVolOffID(0,copy);
	395	//detector copy in the ladder = 1<->4 (ITS1)
	396	vol[1] = copy;
	397	gMC->CurrentVolOffID(1,copy1);
	398	//ladder copy in the module = 1<->2 (I186)
	399	gMC->CurrentVolOffID(2,copy2);
	400	//module copy in the layer = 1<->10 (I132)
	401	vol[2] = copy1+(copy2-1)*2;//# of ladders in one module = 2
	402	} else if(id == fIdSens[1]){
	403	vol[0] = 2;
	404	id = gMC->CurrentVolOffID(0,copy);
	405	//detector copy in the ladder = 1<->4 (ITS2)
	406	vol[1] = copy;
	407	gMC->CurrentVolOffID(1,copy1);
	408	//ladder copy in the module = 1<->4 (I131)
	409	gMC->CurrentVolOffID(2,copy2);
	410	//module copy in the layer = 1<->10 (I132)
	411	vol[2] = copy1+(copy2-1)*4;//# of ladders in one module = 4
	412	} else if(id == fIdSens[2]){
	413	vol[0] = 3;
	414	id = gMC->CurrentVolOffID(1,copy);
	415	//detector copy in the ladder = 1<->5 (ITS3 is inside I314)
	416	vol[1] = copy;
	417	id = gMC->CurrentVolOffID(2,copy);
	418	//ladder copy in the layer = 1<->12 (I316)
	419	vol[2] = copy;
	420	} else if(id == fIdSens[3]){
	421	vol[0] = 4;
	422	id = gMC->CurrentVolOffID(1,copy);
	423	//detector copy in the ladder = 1<->8 (ITS4 is inside I414)
	424	vol[1] = copy;
	425	id = gMC->CurrentVolOffID(2,copy);
	426	//ladder copy in the layer = 1<->22 (I417)
	427	vol[2] = copy;
	428	}else if(id == fIdSens[4]){
	429	vol[0] = 5;
430	id = gMC->CurrentVolOffID(1,copy);
431	//detector copy in the ladder = 1<->23 (ITS5 is inside I562)
432	vol[1] = copy;
433	id = gMC->CurrentVolOffID(2,copy);
434	//ladder copy in the layer = 1<->34 (I565)
435	vol[2] = copy;
436	}else if(id == fIdSens[5]){
437	vol[0] = 6;
438	id = gMC->CurrentVolOffID(1,copy);
439	//detector copy in the ladder = 1<->26 (ITS6 is inside I566)
440	vol[1] = copy;
441	id = gMC->CurrentVolOffID(2,copy);
442	//ladder copy in the layer = 1<->38 (I569)
443	vol[2] = copy;
444	} else {
445	return; // not an ITS volume?
446	} // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
447	//
448	gMC->TrackPosition(position);
449	gMC->TrackMomentum(momentum);
450	hits[0]=position[0];
451	hits[1]=position[1];
452	hits[2]=position[2];
453	hits[3]=momentum[0];
454	hits[4]=momentum[1];
455	hits[5]=momentum[2];
456	hits[6]=gMC->Edep();
457	hits[7]=gMC->TrackTime();
458	// Fill hit structure with this new hit.
459	new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
460	return;
461	}
3fccfd9e	462