[u/mrichter/AliRoot.git] / ITS / AliITSv11.cxx

/**************************************************************************
 * Copyright(c) 2007-2008, 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.                  *
 **************************************************************************/


//************************************************************************
//
//                 Inner Traking System geometry v11
//
//  Based on ROOT geometrical modeler
//
// B. Nilsen, L. Gaudichet
//************************************************************************

#include <TClonesArray.h>
#include <TGeoManager.h>
#include <TGeoPcon.h>
#include <TGeoVolume.h>
#include <TLorentzVector.h>
#include <TVirtualMC.h>

#include "AliITS.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSDetTypeSim.h"
#include "AliITShit.h"
#include "AliITSsegmentationSDD.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSsegmentationSSD.h"
#include "AliITSv11.h"
#include "AliITSv11GeometrySDD.h"
#include "AliITSv11GeometrySPD.h"
#include "AliITSv11GeometrySSD.h"
#include "AliITSv11GeometrySupport.h"
#include "AliMC.h"
#include "AliMagF.h"
#include "AliRun.h"
#include "AliTrackReference.h"

ClassImp(AliITSv11)
 
//______________________________________________________________________
AliITSv11::AliITSv11() : 
fByThick(kTRUE),
fMajorVersion(IsVersion()),
fMinorVersion(0),
fSPDgeom(),
fSDDgeom(0),
fSSDgeom(),
fSupgeom(),
fIgm(kv11)
{
  //    Standard default constructor for the ITS version 11.

    fIdN          = 0;
    fIdName       = 0;
    fIdSens       = 0;
}


//______________________________________________________________________
AliITSv11::AliITSv11(const char *name, const char *title): 
AliITS("ITS", title),
fByThick(kTRUE),
fMajorVersion(IsVersion()),
fMinorVersion(0),
fSPDgeom(),
fSDDgeom(0),
fSSDgeom(),
fSupgeom(),
fIgm(kv11)
{
  //    Standard constructor for the ITS version 11.

  fSDDgeom = new AliITSv11GeometrySDD(0);

  Int_t i;
  fIdN = 6;
  fIdName = new TString[fIdN];
  fIdName[0] = name; // removes warning message
  fIdName[0] = "ITS1";
  fIdName[1] = "ITS2";
  fIdName[2] = fSDDgeom->GetSenstiveVolumeName3();
  fIdName[3] = fSDDgeom->GetSenstiveVolumeName4();
  fIdName[4] = "ITS5";
  fIdName[5] = "ITS6";
  fIdSens    = new Int_t[fIdN];
  for(i=0;i<fIdN;i++) fIdSens[i] = 0;
  // not needed, fByThick set to kTRUE in in the member initialization lis
  
}
//______________________________________________________________________
AliITSv11::AliITSv11(Int_t /* debugITS */,Int_t debugSPD,Int_t debugSDD,
		   Int_t debugSSD,Int_t debugSUP) :
AliITS("ITS","ITS geometry v11"),
fByThick(kTRUE),
fMajorVersion(IsVersion()),
fMinorVersion(0),
fSPDgeom(),
fSDDgeom(0),
fSSDgeom(),
fSupgeom(),
fIgm(kv11)
{
  // Standard default constructor for the ITS version 11.


  fSPDgeom = new AliITSv11GeometrySPD(debugSPD);
  fSDDgeom = new AliITSv11GeometrySDD(debugSDD);
  fSDDgeom->SetDebug(debugSDD);
  fSSDgeom = new AliITSv11GeometrySSD();
  fSSDgeom->SetDebug(debugSSD);
  fSupgeom = new AliITSv11GeometrySupport(debugSUP);

  Int_t i;
  fIdN = 6;
  fIdName = new TString[fIdN];
  fIdName[0] = fSPDgeom->GetSenstiveVolumeName1();
  fIdName[1] = fSPDgeom->GetSenstiveVolumeName2();
  fIdName[2] = fSDDgeom->GetSenstiveVolumeName3();
  fIdName[3] = fSDDgeom->GetSenstiveVolumeName4();
  fIdName[4] = fSSDgeom->GetSenstiveVolumeName5();
  fIdName[5] = fSSDgeom->GetSenstiveVolumeName6();
  fIdSens    = new Int_t[fIdN];
  for(i=0;i<fIdN;i++) fIdSens[i] = 0;
  //  debugITS = (debugSPD && debugSSD && debugSUP && debugSDD); //remove temp. warnings
}
//______________________________________________________________________
AliITSv11::~AliITSv11() {
  delete fSDDgeom;
}
//______________________________________________________________________
void AliITSv11::CreateGeometry(){
    //
    // Create ROOT geometry
    //
    // These constant character strings are set by cvs during commit
    // do not change them unless you know what you are doing!
    const Char_t *cvsDate="$Date$";
    const Char_t *cvsRevision="$Revision$";

    TGeoManager *geoManager = gGeoManager;
    TGeoVolume *vALIC = geoManager->GetTopVolume();

    TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);

    // DefineSection(section number, Z, Rmin, Rmax).
    const Double_t kcm = 1.0;
    sITS->DefineSection(0,-300.0*kcm,0.01*kcm,50.0*kcm);
    sITS->DefineSection(1,+300.0*kcm,0.01*kcm,50.0*kcm);

    TGeoMedium *air = gGeoManager->GetMedium("ITS_AIR$");
    TGeoVolume *vITS = new TGeoVolume("ITSV",sITS,air);
    vITS->SetVisibility(kFALSE);
    const Int_t length=100;
    Char_t vstrng[length];
    if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
                               fMinorVersion,cvsDate,cvsRevision))
        vITS->SetTitle(vstrng);
    //printf("Title set to %s\n",vstrng);
    vALIC->AddNode(vITS,1,0);

//   fSPDgeom->CenteralSPD(vITS);

  fSDDgeom->Layer3(vITS);
  fSDDgeom->Layer4(vITS);

//     fSupgeom->SPDCone(vITS);
//     fSupgeom->SPDThermalSheald(vITS);
//     fSupgeom->SDDCone(vITS);
//     fSupgeom->SSDCone(vITS);
//     fSupgeom->ServicesCableSupport(vITS);

}
//______________________________________________________________________
void AliITSv11::CreateMaterials(){
    // Create Standard ITS Materials
    // Inputs:
    //  none.
    // Outputs:
    //  none.
    // Return:
    // none.

    
    //
    fSPDgeom->AliITSv11Geometry::CreateDefaultMaterials();
    // Detector specific material definistions
    fSPDgeom->CreateMaterials();
    fSDDgeom->CreateMaterials();
    fSSDgeom->CreateMaterials();
    fSupgeom->CreateMaterials();
}

//______________________________________________________________________
void AliITSv11::Init(){
  //
  //     Initialise the ITS after it has been created.
  //

  //AliInfo(Form("Minor version %d",fMinorVersion));
    //
    UpdateInternalGeometry();
    AliITS::Init();

}

//______________________________________________________________________
void AliITSv11::SetDefaults(){
  //
  // Set response and segmentation models for SPD, SDD and SSD
  //

//     if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
//     fDetTypeSim->SetITSgeom(GetITSgeom());
    if(!fDetTypeSim) {
      Warning("SetDefaults","Error fDetTypeSim not defined");
      return;
    }
  
    fDetTypeSim->ResetCalibrationArray();
    fDetTypeSim->ResetSegmentation();
    fDetTypeSim->SetDefaults();
    
    if(fgkNTYPES>3){
	Warning("SetDefaults",
		"Only the four basic detector types are initialised!");
    }// end if

    
    return;
}

// //______________________________________________________________________
// void AliITSv11::StepManager(){
//   //
//   //    Called for every step in the ITS, then calles the AliITShit class
//   // creator with the information to be recoreded about that hit.
//   //
//     Int_t         copy, id;
//     TLorentzVector position, momentum;
//     static TLorentzVector position0;
//     static Int_t stat0=0;

//     if(!(this->IsActive())){
// 	return;
//     } // end if !Active volume.

//     if(!(gMC->TrackCharge())) return;

//     id=gMC->CurrentVolID(copy);

//     Bool_t sensvol = kFALSE;
//     for(Int_t kk=0;kk<6;kk++)if(id == fIdSens[kk])sensvol=kTRUE;
//     if(sensvol && (gMC->IsTrackExiting())){
// 	copy = fTrackReferences->GetEntriesFast();
// 	TClonesArray &lTR = *fTrackReferences;
// 	// Fill TrackReference structure with this new TrackReference.
// 	new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
//     } // if Outer ITS mother Volume


//     Int_t   copy1,copy2;  
//     Int_t   vol[5];
//     TClonesArray &lhits = *fHits;
//     //
//     // Track status
//     vol[3] = 0;
//     vol[4] = 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(2,copy);
// 	//detector copy in the ladder = 1<->4  (ITS1 < I101 < I103 < I10A)
// 	vol[1] = copy;
// 	gMC->CurrentVolOffID(3,copy1);
// 	//ladder copy in the module   = 1<->2  (I10A < I12A)
// 	gMC->CurrentVolOffID(4,copy2);
// 	//module copy in the layer    = 1<->10 (I12A < IT12)
// 	vol[2] = copy1+(copy2-1)*2;//# of ladders in one module  = 2
//     } else if(id == fIdSens[1]){
// 	vol[0] = 2;
// 	id = gMC->CurrentVolOffID(2,copy);
// 	//detector copy in the ladder = 1<->4  (ITS2 < I1D1 < I1D3 < I20A)
// 	vol[1] = copy;
// 	gMC->CurrentVolOffID(3,copy1);
// 	//ladder copy in the module   = 1<->4  (I20A < I12A)
// 	gMC->CurrentVolOffID(4,copy2);
// 	//module copy in the layer    = 1<->10 (I12A < IT12)
// 	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<->6  (ITS3 < I302 < I004)
// 	vol[1] = copy;
// 	id = gMC->CurrentVolOffID(2,copy);
// 	//ladder copy in the layer    = 1<->14 (I004 < IT34)
// 	vol[2] = copy;
//     } else if(id == fIdSens[3]){
// 	vol[0] = 4;
// 	id = gMC->CurrentVolOffID(1,copy);
// 	//detector copy in the ladder = 1<->8  (ITS4 < I402 < I005)
// 	vol[1] = copy;
// 	id = gMC->CurrentVolOffID(2,copy);
// 	//ladder copy in the layer    = 1<->22 (I005 < IT34))
// 	vol[2] = copy;
//     }else if(id == fIdSens[4]){
// 	vol[0] = 5;
// 	id = gMC->CurrentVolOffID(1,copy);
// 	//detector copy in the ladder = 1<->22  (ITS5 < I562 < I565)
// 	vol[1] = copy;
// 	id = gMC->CurrentVolOffID(2,copy);
// 	//ladder copy in the layer    = 1<->34 (I565 < IT56)
// 	vol[2] = copy;
//     }else if(id == fIdSens[5]){
// 	vol[0] = 6;
// 	id = gMC->CurrentVolOffID(1,copy);
// 	//detector copy in the ladder = 1<->25  (ITS6 < I566 < I569)
// 	vol[1] = copy;
// 	id = gMC->CurrentVolOffID(2,copy);
// 	//ladder copy in the layer = 1<->38 (I569 < IT56)
// 	vol[2] = copy;
//     } else {
// 	return; // not an ITS volume?
//     } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
//     //
//     gMC->TrackPosition(position);
//     gMC->TrackMomentum(momentum);
//     vol[4] = stat0;
//     if(gMC->IsTrackEntering()){
// 	position0 = position;
// 	stat0 = vol[3];
// 	return;
//     } // end if IsEntering
//     // Fill hit structure with this new hit.
    
//     new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
// 				   gMC->Edep(),gMC->TrackTime(),position,
// 				   position0,momentum);

//     position0 = position;
//     stat0 = vol[3];

//     return;
// }


//______________________________________________________________________
void AliITSv11::StepManager(){
  //
  //    Called for every step in the ITS, then calles the AliITShit class
  // creator with the information to be recoreded about that hit.
  //
    Int_t         copy, id;
    TLorentzVector position, momentum;
    static TLorentzVector position0;
    static Int_t stat0=0;

    if(!(this->IsActive())){
	return;
    } // end if !Active volume.

    if(!(gMC->TrackCharge())) return;

    id=gMC->CurrentVolID(copy);

    Bool_t sensvol = kFALSE;
    for(Int_t kk=0;kk<6;kk++)if(id == fIdSens[kk])sensvol=kTRUE;
    if(sensvol && (gMC->IsTrackExiting())){
	AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), AliTrackReference::kITS);
    } // if Outer ITS mother Volume


    Int_t   copy1,copy2;  
    Int_t   vol[5];
    TClonesArray &lhits = *fHits;
    //
    // Track status
    vol[3] = 0;
    vol[4] = 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(2,copy);
	//detector copy in the ladder = 1<->4  (ITS1 < I101 < I103 < I10A)
	vol[1] = copy;
	gMC->CurrentVolOffID(3,copy1);
	//ladder copy in the module   = 1<->2  (I10A < I12A)
	gMC->CurrentVolOffID(4,copy2);
	//module copy in the layer    = 1<->10 (I12A < IT12)
	vol[2] = copy1+(copy2-1)*2;//# of ladders in one module  = 2

    } else if(id == fIdSens[1]){
	vol[0] = 2;
	id = gMC->CurrentVolOffID(2,copy);
	//detector copy in the ladder = 1<->4  (ITS2 < I1D1 < I1D3 < I20A)
	vol[1] = copy;
	gMC->CurrentVolOffID(3,copy1);
	//ladder copy in the module   = 1<->4  (I20A < I12A)
	gMC->CurrentVolOffID(4,copy2);
	//module copy in the layer    = 1<->10 (I12A < IT12)
	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<->6  (ITS3 < I302 < I004)
	vol[1] = copy;
	id = gMC->CurrentVolOffID(2,copy);
	//ladder copy in the layer    = 1<->14 (I004 < IT34)
	vol[2] = copy;

    } else if(id == fIdSens[3]){
	vol[0] = 4;
	id = gMC->CurrentVolOffID(1,copy);
	//detector copy in the ladder = 1<->8  (ITS4 < I402 < I005)
	vol[1] = copy;
	id = gMC->CurrentVolOffID(2,copy);
	//ladder copy in the layer    = 1<->22 (I005 < IT34))
	vol[2] = copy;

    }else if(id == fIdSens[4]){
	vol[0] = 5;
	id = gMC->CurrentVolOffID(1,copy);
	//detector copy in the ladder = 1<->22  (ITS5 < I562 < I565)
	vol[1] = copy;
	id = gMC->CurrentVolOffID(2,copy);
	//ladder copy in the layer    = 1<->34 (I565 < IT56)
	vol[2] = copy;

    }else if(id == fIdSens[5]){
	vol[0] = 6;
	id = gMC->CurrentVolOffID(1,copy);
	//detector copy in the ladder = 1<->25  (ITS6 < I566 < I569)
	vol[1] = copy;
	id = gMC->CurrentVolOffID(2,copy);
	//ladder copy in the layer = 1<->38 (I569 < IT56)
	vol[2] = copy;
    } else {
	return; // not an ITS volume?
    } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
    //
    gMC->TrackPosition(position);
    gMC->TrackMomentum(momentum);
    vol[4] = stat0;
    if(gMC->IsTrackEntering()){
	position0 = position;
	stat0 = vol[3];
	return;
    } // end if IsEntering
    // Fill hit structure with this new hit.
    
    new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
				   gMC->Edep(),gMC->TrackTime(),position,
				   position0,momentum);

    position0 = position;
    stat0 = vol[3];

    return;
}
Commit	Line	Data
2b680d9b	1	/**************************************************************************
effd7456	2	* Copyright(c) 2007-2008, ALICE Experiment at CERN, All rights reserved. *
2b680d9b	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
effd7456	16
b7943f00	17	//************************************************************************
effd7456	18	//
b7943f00	19	// Inner Traking System geometry v11
	20	//
	21	// Based on ROOT geometrical modeler
b7943f00	22	//
	23	// B. Nilsen, L. Gaudichet
	24	//************************************************************************
	25
541f7ba6	26	#include <TClonesArray.h>
7dd2cbe4	27	#include <TGeoManager.h>
	28	#include <TGeoPcon.h>
	29	#include <TGeoVolume.h>
2b680d9b	30	#include <TLorentzVector.h>
7dd2cbe4	31	#include <TVirtualMC.h>
b7943f00	32
b7943f00	33	#include "AliITS.h"
7dd2cbe4	34	#include "AliITSCalibrationSDD.h"
531d6cdc	35	#include "AliITSDetTypeSim.h"
b7943f00	36	#include "AliITShit.h"
2b680d9b	37	#include "AliITSsegmentationSDD.h"
b7943f00	38	#include "AliITSsegmentationSPD.h"
b7943f00	39	#include "AliITSsegmentationSSD.h"
108bd0fe	40	#include "AliITSv11.h"
db486a6e	41	#include "AliITSv11GeometrySDD.h"
7dd2cbe4	42	#include "AliITSv11GeometrySPD.h"
54c9a3d9	43	#include "AliITSv11GeometrySSD.h"
54c9a3d9	44	#include "AliITSv11GeometrySupport.h"
7dd2cbe4	45	#include "AliMC.h"
	46	#include "AliMagF.h"
	47	#include "AliRun.h"
	48	#include "AliTrackReference.h"
541f7ba6	49
b7943f00	50	ClassImp(AliITSv11)
b7943f00	51
33ddec7d	52	//______________________________________________________________________
012f0f4c	53	AliITSv11::AliITSv11() :
012f0f4c	54	fByThick(kTRUE),
	55	fMajorVersion(IsVersion()),
	56	fMinorVersion(0),
54c9a3d9	57	fSPDgeom(),
012f0f4c	58	fSDDgeom(0),
54c9a3d9	59	fSSDgeom(),
54c9a3d9	60	fSupgeom(),
012f0f4c	61	fIgm(kv11)
33ddec7d	62	{
b7943f00	63	// Standard default constructor for the ITS version 11.
f7315efc	64
531d6cdc	65	fIdN = 0;
	66	fIdName = 0;
	67	fIdSens = 0;
2b680d9b	68	}
b7943f00	69
fa4639a3	70
fa4639a3	71	//______________________________________________________________________
012f0f4c	72	AliITSv11::AliITSv11(const char name, const char title):
012f0f4c	73	AliITS("ITS", title),
012f0f4c	74	fByThick(kTRUE),
	75	fMajorVersion(IsVersion()),
	76	fMinorVersion(0),
54c9a3d9	77	fSPDgeom(),
012f0f4c	78	fSDDgeom(0),
54c9a3d9	79	fSSDgeom(),
54c9a3d9	80	fSupgeom(),
012f0f4c	81	fIgm(kv11)
33ddec7d	82	{
fa4639a3	83	// Standard constructor for the ITS version 11.
fa4639a3	84
531d6cdc	85	fSDDgeom = new AliITSv11GeometrySDD(0);
fa4639a3	86
fa4639a3	87	Int_t i;
531d6cdc	88	fIdN = 6;
	89	fIdName = new TString[fIdN];
	90	fIdName[0] = name; // removes warning message
	91	fIdName[0] = "ITS1";
	92	fIdName[1] = "ITS2";
108bd0fe	93	fIdName[2] = fSDDgeom->GetSenstiveVolumeName3();
108bd0fe	94	fIdName[3] = fSDDgeom->GetSenstiveVolumeName4();
531d6cdc	95	fIdName[4] = "ITS5";
531d6cdc	96	fIdName[5] = "ITS6";
fa4639a3	97	fIdSens = new Int_t[fIdN];
531d6cdc	98	for(i=0;i<fIdN;i++) fIdSens[i] = 0;
33ddec7d	99	// not needed, fByThick set to kTRUE in in the member initialization lis
531d6cdc	100
fa4639a3	101	}
2b680d9b	102	//______________________________________________________________________
112d72a8	103	AliITSv11::AliITSv11(Int_t /* debugITS */,Int_t debugSPD,Int_t debugSDD,
b7943f00	104	Int_t debugSSD,Int_t debugSUP) :
012f0f4c	105	AliITS("ITS","ITS geometry v11"),
012f0f4c	106	fByThick(kTRUE),
	107	fMajorVersion(IsVersion()),
	108	fMinorVersion(0),
54c9a3d9	109	fSPDgeom(),
012f0f4c	110	fSDDgeom(0),
54c9a3d9	111	fSSDgeom(),
54c9a3d9	112	fSupgeom(),
012f0f4c	113	fIgm(kv11)
012f0f4c	114	{
b7943f00	115	// Standard default constructor for the ITS version 11.
b7943f00	116
b7943f00	117
112d72a8	118	fSPDgeom = new AliITSv11GeometrySPD(debugSPD);
531d6cdc	119	fSDDgeom = new AliITSv11GeometrySDD(debugSDD);
531d6cdc	120	fSDDgeom->SetDebug(debugSDD);
325d8c32	121	fSSDgeom = new AliITSv11GeometrySSD();
325d8c32	122	fSSDgeom->SetDebug(debugSSD);
112d72a8	123	fSupgeom = new AliITSv11GeometrySupport(debugSUP);
531d6cdc	124
	125	Int_t i;
	126	fIdN = 6;
	127	fIdName = new TString[fIdN];
54c9a3d9	128	fIdName[0] = fSPDgeom->GetSenstiveVolumeName1();
54c9a3d9	129	fIdName[1] = fSPDgeom->GetSenstiveVolumeName2();
108bd0fe	130	fIdName[2] = fSDDgeom->GetSenstiveVolumeName3();
108bd0fe	131	fIdName[3] = fSDDgeom->GetSenstiveVolumeName4();
54c9a3d9	132	fIdName[4] = fSSDgeom->GetSenstiveVolumeName5();
54c9a3d9	133	fIdName[5] = fSSDgeom->GetSenstiveVolumeName6();
531d6cdc	134	fIdSens = new Int_t[fIdN];
531d6cdc	135	for(i=0;i<fIdN;i++) fIdSens[i] = 0;
112d72a8	136	// debugITS = (debugSPD && debugSSD && debugSUP && debugSDD); //remove temp. warnings
162acd47	137	}
dfefbaec	138	//______________________________________________________________________
b7943f00	139	AliITSv11::~AliITSv11() {
b7943f00	140	delete fSDDgeom;
2b680d9b	141	}
2b680d9b	142	//______________________________________________________________________
aa9bc63b	143	void AliITSv11::CreateGeometry(){
012f0f4c	144	//
	145	// Create ROOT geometry
	146	//
	147	// These constant character strings are set by cvs during commit
	148	// do not change them unless you know what you are doing!
	149	const Char_t *cvsDate="$Date$";
	150	const Char_t *cvsRevision="$Revision$";
	151
	152	TGeoManager *geoManager = gGeoManager;
	153	TGeoVolume *vALIC = geoManager->GetTopVolume();
	154
	155	TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);
	156
	157	// DefineSection(section number, Z, Rmin, Rmax).
	158	const Double_t kcm = 1.0;
	159	sITS->DefineSection(0,-300.0kcm,0.01kcm,50.0*kcm);
	160	sITS->DefineSection(1,+300.0kcm,0.01kcm,50.0*kcm);
	161
	162	TGeoMedium *air = gGeoManager->GetMedium("ITS_AIR$");
	163	TGeoVolume *vITS = new TGeoVolume("ITSV",sITS,air);
	164	vITS->SetVisibility(kFALSE);
	165	const Int_t length=100;
	166	Char_t vstrng[length];
	167	if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
	168	fMinorVersion,cvsDate,cvsRevision))
	169	vITS->SetTitle(vstrng);
	170	//printf("Title set to %s\n",vstrng);
	171	vALIC->AddNode(vITS,1,0);
b7943f00	172
b7943f00	173	// fSPDgeom->CenteralSPD(vITS);
fa4639a3	174
b7943f00	175	fSDDgeom->Layer3(vITS);
b7943f00	176	fSDDgeom->Layer4(vITS);
fa4639a3	177
b7943f00	178	// fSupgeom->SPDCone(vITS);
	179	// fSupgeom->SPDThermalSheald(vITS);
	180	// fSupgeom->SDDCone(vITS);
	181	// fSupgeom->SSDCone(vITS);
	182	// fSupgeom->ServicesCableSupport(vITS);
	183
541f7ba6	184	}
	185	//______________________________________________________________________
	186	void AliITSv11::CreateMaterials(){
54c9a3d9	187	// Create Standard ITS Materials
	188	// Inputs:
	189	// none.
	190	// Outputs:
	191	// none.
	192	// Return:
	193	// none.
531d6cdc	194
531d6cdc	195
54c9a3d9	196	//
	197	fSPDgeom->AliITSv11Geometry::CreateDefaultMaterials();
	198	// Detector specific material definistions
	199	fSPDgeom->CreateMaterials();
	200	fSDDgeom->CreateMaterials();
	201	fSSDgeom->CreateMaterials();
	202	fSupgeom->CreateMaterials();
dfefbaec	203	}
b7943f00	204
dfefbaec	205	//______________________________________________________________________
dfefbaec	206	void AliITSv11::Init(){
b7943f00	207	//
	208	// Initialise the ITS after it has been created.
	209	//
	210
531d6cdc	211	//AliInfo(Form("Minor version %d",fMinorVersion));
531d6cdc	212	//
012f0f4c	213	UpdateInternalGeometry();
012f0f4c	214	AliITS::Init();
012f0f4c	215
dfefbaec	216	}
b7943f00	217
dfefbaec	218	//______________________________________________________________________
dfefbaec	219	void AliITSv11::SetDefaults(){
b7943f00	220	//
108bd0fe	221	// Set response and segmentation models for SPD, SDD and SSD
b7943f00	222	//
b7943f00	223
108bd0fe	224	// if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
	225	// fDetTypeSim->SetITSgeom(GetITSgeom());
	226	if(!fDetTypeSim) {
	227	Warning("SetDefaults","Error fDetTypeSim not defined");
	228	return;
	229	}
531d6cdc	230
531d6cdc	231	fDetTypeSim->ResetCalibrationArray();
	232	fDetTypeSim->ResetSegmentation();
	233	fDetTypeSim->SetDefaults();
	234
531d6cdc	235	if(fgkNTYPES>3){
	236	Warning("SetDefaults",
	237	"Only the four basic detector types are initialised!");
	238	}// end if
	239
	240
	241	return;
dfefbaec	242	}
b7943f00	243
108bd0fe	244	// //______________________________________________________________________
	245	// void AliITSv11::StepManager(){
	246	// //
	247	// // Called for every step in the ITS, then calles the AliITShit class
	248	// // creator with the information to be recoreded about that hit.
	249	// //
	250	// Int_t copy, id;
	251	// TLorentzVector position, momentum;
	252	// static TLorentzVector position0;
	253	// static Int_t stat0=0;
	254
	255	// if(!(this->IsActive())){
	256	// return;
	257	// } // end if !Active volume.
	258
	259	// if(!(gMC->TrackCharge())) return;
	260
	261	// id=gMC->CurrentVolID(copy);
	262
	263	// Bool_t sensvol = kFALSE;
	264	// for(Int_t kk=0;kk<6;kk++)if(id == fIdSens[kk])sensvol=kTRUE;
	265	// if(sensvol && (gMC->IsTrackExiting())){
	266	// copy = fTrackReferences->GetEntriesFast();
	267	// TClonesArray &lTR = *fTrackReferences;
	268	// // Fill TrackReference structure with this new TrackReference.
	269	// new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
	270	// } // if Outer ITS mother Volume
	271
	272
	273	// Int_t copy1,copy2;
	274	// Int_t vol[5];
	275	// TClonesArray &lhits = *fHits;
	276	// //
	277	// // Track status
	278	// vol[3] = 0;
	279	// vol[4] = 0;
	280	// if(gMC->IsTrackInside()) vol[3] += 1;
	281	// if(gMC->IsTrackEntering()) vol[3] += 2;
	282	// if(gMC->IsTrackExiting()) vol[3] += 4;
	283	// if(gMC->IsTrackOut()) vol[3] += 8;
	284	// if(gMC->IsTrackDisappeared()) vol[3] += 16;
	285	// if(gMC->IsTrackStop()) vol[3] += 32;
	286	// if(gMC->IsTrackAlive()) vol[3] += 64;
	287	// //
	288	// // Fill hit structure.
	289	// if(!(gMC->TrackCharge())) return;
	290	// //
	291	// // Only entering charged tracks
	292	// if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
	293	// vol[0] = 1;
	294	// id = gMC->CurrentVolOffID(2,copy);
	295	// //detector copy in the ladder = 1<->4 (ITS1 < I101 < I103 < I10A)
	296	// vol[1] = copy;
	297	// gMC->CurrentVolOffID(3,copy1);
	298	// //ladder copy in the module = 1<->2 (I10A < I12A)
	299	// gMC->CurrentVolOffID(4,copy2);
	300	// //module copy in the layer = 1<->10 (I12A < IT12)
	301	// vol[2] = copy1+(copy2-1)*2;//# of ladders in one module = 2
	302	// } else if(id == fIdSens[1]){
	303	// vol[0] = 2;
	304	// id = gMC->CurrentVolOffID(2,copy);
	305	// //detector copy in the ladder = 1<->4 (ITS2 < I1D1 < I1D3 < I20A)
	306	// vol[1] = copy;
	307	// gMC->CurrentVolOffID(3,copy1);
308	// //ladder copy in the module = 1<->4 (I20A < I12A)
309	// gMC->CurrentVolOffID(4,copy2);
310	// //module copy in the layer = 1<->10 (I12A < IT12)
311	// vol[2] = copy1+(copy2-1)*4;//# of ladders in one module = 4
312	// } else if(id == fIdSens[2]){
313	// vol[0] = 3;
314	// id = gMC->CurrentVolOffID(1,copy);
315	// //detector copy in the ladder = 1<->6 (ITS3 < I302 < I004)
316	// vol[1] = copy;
317	// id = gMC->CurrentVolOffID(2,copy);
318	// //ladder copy in the layer = 1<->14 (I004 < IT34)
319	// vol[2] = copy;
320	// } else if(id == fIdSens[3]){
321	// vol[0] = 4;
322	// id = gMC->CurrentVolOffID(1,copy);
323	// //detector copy in the ladder = 1<->8 (ITS4 < I402 < I005)
324	// vol[1] = copy;
325	// id = gMC->CurrentVolOffID(2,copy);
326	// //ladder copy in the layer = 1<->22 (I005 < IT34))
327	// vol[2] = copy;
328	// }else if(id == fIdSens[4]){
329	// vol[0] = 5;
330	// id = gMC->CurrentVolOffID(1,copy);
331	// //detector copy in the ladder = 1<->22 (ITS5 < I562 < I565)
332	// vol[1] = copy;
333	// id = gMC->CurrentVolOffID(2,copy);
334	// //ladder copy in the layer = 1<->34 (I565 < IT56)
335	// vol[2] = copy;
336	// }else if(id == fIdSens[5]){
337	// vol[0] = 6;
338	// id = gMC->CurrentVolOffID(1,copy);
339	// //detector copy in the ladder = 1<->25 (ITS6 < I566 < I569)
340	// vol[1] = copy;
341	// id = gMC->CurrentVolOffID(2,copy);
342	// //ladder copy in the layer = 1<->38 (I569 < IT56)
343	// vol[2] = copy;
344	// } else {
345	// return; // not an ITS volume?
346	// } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
347	// //
348	// gMC->TrackPosition(position);
349	// gMC->TrackMomentum(momentum);
350	// vol[4] = stat0;
351	// if(gMC->IsTrackEntering()){
352	// position0 = position;
353	// stat0 = vol[3];
354	// return;
355	// } // end if IsEntering
356	// // Fill hit structure with this new hit.
357
358	// new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
359	// gMC->Edep(),gMC->TrackTime(),position,
360	// position0,momentum);
361
362	// position0 = position;
363	// stat0 = vol[3];
364
365	// return;
366	// }
367
368
dfefbaec	369	//______________________________________________________________________
dfefbaec	370	void AliITSv11::StepManager(){
b7943f00	371	//
	372	// Called for every step in the ITS, then calles the AliITShit class
	373	// creator with the information to be recoreded about that hit.
	374	//
531d6cdc	375	Int_t copy, id;
	376	TLorentzVector position, momentum;
	377	static TLorentzVector position0;
	378	static Int_t stat0=0;
	379
	380	if(!(this->IsActive())){
	381	return;
	382	} // end if !Active volume.
	383
	384	if(!(gMC->TrackCharge())) return;
	385
	386	id=gMC->CurrentVolID(copy);
	387
	388	Bool_t sensvol = kFALSE;
	389	for(Int_t kk=0;kk<6;kk++)if(id == fIdSens[kk])sensvol=kTRUE;
	390	if(sensvol && (gMC->IsTrackExiting())){
e6add757	391	AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), AliTrackReference::kITS);
531d6cdc	392	} // if Outer ITS mother Volume
	393
	394
	395	Int_t copy1,copy2;
	396	Int_t vol[5];
	397	TClonesArray &lhits = *fHits;
	398	//
	399	// Track status
	400	vol[3] = 0;
	401	vol[4] = 0;
	402	if(gMC->IsTrackInside()) vol[3] += 1;
	403	if(gMC->IsTrackEntering()) vol[3] += 2;
	404	if(gMC->IsTrackExiting()) vol[3] += 4;
	405	if(gMC->IsTrackOut()) vol[3] += 8;
	406	if(gMC->IsTrackDisappeared()) vol[3] += 16;
	407	if(gMC->IsTrackStop()) vol[3] += 32;
	408	if(gMC->IsTrackAlive()) vol[3] += 64;
	409	//
	410	// Fill hit structure.
	411	if(!(gMC->TrackCharge())) return;
108bd0fe	412
531d6cdc	413	// Only entering charged tracks
	414	if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
	415	vol[0] = 1;
	416	id = gMC->CurrentVolOffID(2,copy);
	417	//detector copy in the ladder = 1<->4 (ITS1 < I101 < I103 < I10A)
	418	vol[1] = copy;
	419	gMC->CurrentVolOffID(3,copy1);
	420	//ladder copy in the module = 1<->2 (I10A < I12A)
	421	gMC->CurrentVolOffID(4,copy2);
	422	//module copy in the layer = 1<->10 (I12A < IT12)
	423	vol[2] = copy1+(copy2-1)*2;//# of ladders in one module = 2
108bd0fe	424
531d6cdc	425	} else if(id == fIdSens[1]){
	426	vol[0] = 2;
	427	id = gMC->CurrentVolOffID(2,copy);
	428	//detector copy in the ladder = 1<->4 (ITS2 < I1D1 < I1D3 < I20A)
	429	vol[1] = copy;
	430	gMC->CurrentVolOffID(3,copy1);
	431	//ladder copy in the module = 1<->4 (I20A < I12A)
	432	gMC->CurrentVolOffID(4,copy2);
	433	//module copy in the layer = 1<->10 (I12A < IT12)
	434	vol[2] = copy1+(copy2-1)*4;//# of ladders in one module = 4
108bd0fe	435
531d6cdc	436	} else if(id == fIdSens[2]){
	437	vol[0] = 3;
	438	id = gMC->CurrentVolOffID(1,copy);
	439	//detector copy in the ladder = 1<->6 (ITS3 < I302 < I004)
	440	vol[1] = copy;
	441	id = gMC->CurrentVolOffID(2,copy);
	442	//ladder copy in the layer = 1<->14 (I004 < IT34)
	443	vol[2] = copy;
108bd0fe	444
531d6cdc	445	} else if(id == fIdSens[3]){
	446	vol[0] = 4;
	447	id = gMC->CurrentVolOffID(1,copy);
	448	//detector copy in the ladder = 1<->8 (ITS4 < I402 < I005)
	449	vol[1] = copy;
	450	id = gMC->CurrentVolOffID(2,copy);
	451	//ladder copy in the layer = 1<->22 (I005 < IT34))
	452	vol[2] = copy;
108bd0fe	453
531d6cdc	454	}else if(id == fIdSens[4]){
	455	vol[0] = 5;
	456	id = gMC->CurrentVolOffID(1,copy);
	457	//detector copy in the ladder = 1<->22 (ITS5 < I562 < I565)
	458	vol[1] = copy;
	459	id = gMC->CurrentVolOffID(2,copy);
	460	//ladder copy in the layer = 1<->34 (I565 < IT56)
	461	vol[2] = copy;
108bd0fe	462
531d6cdc	463	}else if(id == fIdSens[5]){
	464	vol[0] = 6;
	465	id = gMC->CurrentVolOffID(1,copy);
	466	//detector copy in the ladder = 1<->25 (ITS6 < I566 < I569)
	467	vol[1] = copy;
	468	id = gMC->CurrentVolOffID(2,copy);
	469	//ladder copy in the layer = 1<->38 (I569 < IT56)
	470	vol[2] = copy;
	471	} else {
	472	return; // not an ITS volume?
	473	} // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
	474	//
	475	gMC->TrackPosition(position);
	476	gMC->TrackMomentum(momentum);
	477	vol[4] = stat0;
	478	if(gMC->IsTrackEntering()){
	479	position0 = position;
	480	stat0 = vol[3];
	481	return;
	482	} // end if IsEntering
	483	// Fill hit structure with this new hit.
b7943f00	484
531d6cdc	485	new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
	486	gMC->Edep(),gMC->TrackTime(),position,
	487	position0,momentum);
b7943f00	488
b7943f00	489	position0 = position;
b7943f00	490	stat0 = vol[3];
531d6cdc	491
b7943f00	492	return;
531d6cdc	493	}
108bd0fe	494