Int_t RunHLTITS(Int_t nev=1,Int_t run=0) {
// gSystem->Load("libAliHLTITS");
TStopwatch timer;
timer.Start();
if (gAlice) {
delete gAlice->GetRunLoader();
delete gAlice;
gAlice=0;
}
AliRunLoader *rl = AliRunLoader::Open("galice.root");
if (rl == 0x0) {
cerr<<"Can not open session"<<endl;
return 1;
}
Int_t retval = rl->LoadgAlice();
if (retval) {
cerr<<"AliESDtest.C : LoadgAlice returned error"<<endl;
delete rl;
return 1;
}
retval = rl->LoadHeader();
if (retval) {
cerr<<"AliESDtest.C : LoadHeader returned error"<<endl;
delete rl;
return 2;
}
gAlice=rl->GetAliRun();
AliTracker::SetFieldMap(gAlice->Field());
AliITSLoader* itsl = (AliITSLoader*)rl->GetLoader("ITSLoader");
if (itsl == 0x0) {
cerr<<"AliESDtest.C : Can not get the ITS loader"<<endl;
return 3;
}
itsl->LoadRecPoints("read");
AliITS *dITS = (AliITS*)gAlice->GetDetector("ITS");
if (!dITS) {
cerr<<"AliESDtest.C : Can not find the ITS detector !"<<endl;
return 4;
}
// AliITSgeom *geom = dITS->GetITSgeom();
AliITSgeom *geom = new AliITSgeom();
geom->ReadNewFile("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det");
//An instance of the HLT ITS tracker
AliHLTITStracker itsTracker(geom);
TFile *ef=TFile::Open("AliESDs.root");
if (!ef || !ef->IsOpen()) {cerr<<"Can't AliESDs.root !\n"; return 1;}
AliESD* event = new AliESD;
TTree* tree = (TTree*) ef->Get("esdTree");
if (!tree) {cerr<<"no ESD tree found\n"; return 1;};
tree->SetBranchAddress("ESD", &event);
TFile *itsf=TFile::Open("AliESDits.root","RECREATE");
if ((!itsf)||(!itsf->IsOpen())) {
cerr<<"Can't AliESDits.root !\n"; return 1;
}
Int_t rc=0;
if (nev>rl->GetNumberOfEvents()) nev=rl->GetNumberOfEvents();
//The loop over events
for (Int_t i=0; i<nev; i++) {
cerr<<"\n\nProcessing event number : "<<i<<endl;
tree->GetEvent(i);
rl->GetEvent(i);
TArrayF v(3);
rl->GetHeader()->GenEventHeader()->PrimaryVertex(v);
Double_t vtx[3]={v[0],v[1],v[2]};
Double_t cvtx[3]={0.005,0.005,0.010};
cout<<"MC vertex position: "<<v[2]<<endl;
AliHLTITSVertexerZ vertexer("null");
AliESDVertex* vertex = NULL;
TStopwatch timer2;
timer2.Start();
TTree* treeClusters = itsl->TreeR();
// vertex = vertexer.FindVertexForCurrentEvent(i);
// AliESDVertex *vertex = vertexer.FindVertexForCurrentEvent(geom,treeClusters);
vertex = new AliESDVertex(vtx,cvtx);
timer2.Stop();
timer2.Print();
if(!vertex){
cerr<<"Vertex not found"<<endl;
vertex = new AliESDVertex(vtx,cvtx);
}
else {
vertex->SetTruePos(vtx); // store also the vertex from MC
}
event->SetVertex(vertex);
Double_t vtxPos[3];
Double_t vtxErr[3];
vertex->GetXYZ(vtxPos);
vertex->GetSigmaXYZ(vtxErr);
itsTracker.SetVertex(vtxPos,vtxErr);
TTree *itsTree=itsl->TreeR();
if (!itsTree) {
cerr<<"Can't get the ITS cluster tree !\n";
return 4;
}
itsTracker.LoadClusters(itsTree);
rc+=itsTracker.Clusters2Tracks(event);
// rc+=itsTracker.PropagateBack(event);
itsTracker.UnloadClusters();
if (rc==0) {
TTree* tree = new TTree("esdTree", "Tree with ESD objects");
tree->Branch("ESD", "AliESD", &event);
tree->Fill();
itsf->cd();
tree->Write();
}
if (rc) {
cerr<<"Something bad happened...\n";
}
}
delete event;
itsf->Close();
ef->Close();
// delete rl;
timer.Stop();
timer.Print();
return rc;
}
void Config()
{
// Get settings from environment variables
ProcessEnvironmentVars();
gRandom->SetSeed(seed);
cerr<<"Seed for random number generation= "<<seed<<endl;
// Libraries required by geant321
#if defined(__CINT__)
gSystem->Load("liblhapdf"); // Parton density functions
gSystem->Load("libEGPythia6"); // TGenerator interface
if (proc != kPythia6D6T) {
gSystem->Load("libpythia6"); // Pythia 6.2
} else {
gSystem->Load("libqpythia"); // Pythia 6.4
}
gSystem->Load("libAliPythia6"); // ALICE specific implementations
gSystem->Load("libgeant321");
#endif
new TGeant3TGeo("C++ Interface to Geant3");
//=======================================================================
// Create the output file
AliRunLoader* rl=0x0;
cout<<"Config.C: Creating Run Loader ..."<<endl;
rl = AliRunLoader::Open("galice.root",
AliConfig::GetDefaultEventFolderName(),
"recreate");
if (rl == 0x0)
{
gAlice->Fatal("Config.C","Can not instatiate the Run Loader");
return;
}
rl->SetCompressionLevel(2);
rl->SetNumberOfEventsPerFile(1000);
gAlice->SetRunLoader(rl);
// gAlice->SetGeometryFromFile("geometry.root");
// gAlice->SetGeometryFromCDB();
// Set the trigger configuration: proton-proton
gAlice->SetTriggerDescriptor("p-p");
//
//=======================================================================
// ************* STEERING parameters FOR ALICE SIMULATION **************
// --- Specify event type to be tracked through the ALICE setup
// --- All positions are in cm, angles in degrees, and P and E in GeV
gMC->SetProcess("DCAY",1);
gMC->SetProcess("PAIR",1);
gMC->SetProcess("COMP",1);
gMC->SetProcess("PHOT",1);
gMC->SetProcess("PFIS",0);
gMC->SetProcess("DRAY",0);
gMC->SetProcess("ANNI",1);
gMC->SetProcess("BREM",1);
gMC->SetProcess("MUNU",1);
gMC->SetProcess("CKOV",1);
gMC->SetProcess("HADR",1);
gMC->SetProcess("LOSS",2);
gMC->SetProcess("MULS",1);
gMC->SetProcess("RAYL",1);
Float_t cut = 1.e-3; // 1MeV cut by default
Float_t tofmax = 1.e10;
gMC->SetCut("CUTGAM", cut);
gMC->SetCut("CUTELE", cut);
gMC->SetCut("CUTNEU", cut);
gMC->SetCut("CUTHAD", cut);
gMC->SetCut("CUTMUO", cut);
gMC->SetCut("BCUTE", cut);
gMC->SetCut("BCUTM", cut);
gMC->SetCut("DCUTE", cut);
gMC->SetCut("DCUTM", cut);
gMC->SetCut("PPCUTM", cut);
gMC->SetCut("TOFMAX", tofmax);
//======================//
// Set External decayer //
//======================//
TVirtualMCDecayer* decayer = new AliDecayerPythia();
decayer->SetForceDecay(kAll);
decayer->Init();
gMC->SetExternalDecayer(decayer);
//=========================//
// Generator Configuration //
//=========================//
AliGenerator* gener = 0x0;
if (proc == kPythia6) {
gener = MbPythia();
} else if (proc == kPythia6D6T) {
gener = MbPythiaTuneD6T();
} else if (proc == kPhojet) {
gener = MbPhojet();
} else if (proc == kFlatJPsi) {
gener = FlatJPsi();
} else if (proc == kJPsi7TeV) {
gener = JPsi7TeV();
}
// PRIMARY VERTEX
//
Double_t xv = 0;
Double_t yv = 0;
Double_t zv = 0;
Double_t vtxPos[3];
Double_t vtxErr[3];
for (Int_t i = 0; i < 3; i++) {
vtxPos[i] = 0.;
vtxErr[i] = 0.;
}
vtxErr[2] = 4.5;
if(AliCDBManager::Instance()->IsDefaultStorageSet()){
AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
AliESDVertex* vertex = dynamic_cast<AliESDVertex*> (entry->GetObject());
vertex->GetXYZ(vtxPos);
vertex->GetSigmaXYZ(vtxErr);
}
printf("Vertex position from OCDB entry: x = %13.3f, y = %13.3f, z = %13.3f (sigma = %13.3f)\n",
vtxPos[0], vtxPos[1], vtxPos[2], vtxErr[2]);
gener->SetOrigin(vtxPos[0], vtxPos[1] + 0.04, vtxPos[2]); // vertex position
//
//
// Size of the interaction diamond
// Longitudinal
Float_t sigmaz = 5.4 / TMath::Sqrt(2.); // [cm]
if (energy == 900)
//sigmaz = 10.5 / TMath::Sqrt(2.); // [cm]
//sigmaz = 3.7;
if (energy == 7000)
sigmaz = 6.3 / TMath::Sqrt(2.); // [cm]
sigmaz = vtxErr[2];
//
// Transverse
Float_t betast = 10; // beta* [m]
Float_t eps = 3.75e-6; // emittance [m]
Float_t gamma = energy / 2.0 / 0.938272; // relativistic gamma [1]
Float_t sigmaxy = TMath::Sqrt(eps * betast / gamma) / TMath::Sqrt(2.) * 100.; // [cm]
printf("\n \n Diamond size x-y: %10.3e z: %10.3e\n \n", sigmaxy, sigmaz);
gener->SetSigma(sigmaxy, sigmaxy, sigmaz); // Sigma in (X,Y,Z) (cm) on IP position
gener->SetCutVertexZ(3.); // Truncate at 3 sigma
gener->SetVertexSmear(kPerEvent);
gener->Init();
// FIELD
//
AliMagF* field = 0x0;
if (mag == kNoField) {
comment = comment.Append(" | L3 field 0.0 T");
field = new AliMagF("Maps","Maps", 0., 0., AliMagF::k5kGUniform,AliMagF::kBeamTypepp, energy/2.0);
} else if (mag == k5kG) {
comment = comment.Append(" | L3 field 0.5 T");
field = new AliMagF("Maps","Maps", -1., -1., AliMagF::k5kG, AliMagF::kBeamTypepp, energy/2.0);
}
printf("\n \n Comment: %s \n \n", comment.Data());
TGeoGlobalMagField::Instance()->SetField(field);
rl->CdGAFile();
Int_t iABSO = 1;
Int_t iACORDE= 0;
Int_t iDIPO = 1;
Int_t iEMCAL = 1;
Int_t iFMD = 1;
Int_t iFRAME = 1;
Int_t iHALL = 1;
Int_t iITS = 1;
Int_t iMAG = 1;
Int_t iMUON = 1;
Int_t iPHOS = 1;
Int_t iPIPE = 1;
Int_t iPMD = 1;
Int_t iHMPID = 1;
Int_t iSHIL = 1;
Int_t iT0 = 1;
Int_t iTOF = 1;
Int_t iTPC = 1;
Int_t iTRD = 1;
Int_t iVZERO = 1;
Int_t iZDC = 1;
//=================== Alice BODY parameters =============================
AliBODY *BODY = new AliBODY("BODY", "Alice envelop");
if (iMAG)
{
//=================== MAG parameters ============================
// --- Start with Magnet since detector layouts may be depending ---
// --- on the selected Magnet dimensions ---
AliMAG *MAG = new AliMAG("MAG", "Magnet");
}
if (iABSO)
{
//=================== ABSO parameters ============================
AliABSO *ABSO = new AliABSOv3("ABSO", "Muon Absorber");
}
if (iDIPO)
{
//=================== DIPO parameters ============================
AliDIPO *DIPO = new AliDIPOv3("DIPO", "Dipole version 3");
}
if (iHALL)
{
//=================== HALL parameters ============================
AliHALL *HALL = new AliHALLv3("HALL", "Alice Hall");
}
if (iFRAME)
{
//=================== FRAME parameters ============================
AliFRAMEv2 *FRAME = new AliFRAMEv2("FRAME", "Space Frame");
FRAME->SetHoles(1);
}
if (iSHIL)
{
//=================== SHIL parameters ============================
AliSHIL *SHIL = new AliSHILv3("SHIL", "Shielding Version 3");
}
if (iPIPE)
{
//=================== PIPE parameters ============================
AliPIPE *PIPE = new AliPIPEv3("PIPE", "Beam Pipe");
}
if (iITS)
{
//=================== ITS parameters ============================
AliITS *ITS = new AliITSv11Hybrid("ITS","ITS v11Hybrid");
}
if (iTPC)
{
//============================ TPC parameters =====================
AliTPC *TPC = new AliTPCv2("TPC", "Default");
}
if (iTOF) {
//=================== TOF parameters ============================
AliTOF *TOF = new AliTOFv6T0("TOF", "normal TOF");
}
if (iHMPID)
{
//=================== HMPID parameters ===========================
AliHMPID *HMPID = new AliHMPIDv3("HMPID", "normal HMPID");
}
if (iZDC)
{
//=================== ZDC parameters ============================
AliZDC *ZDC = new AliZDCv3("ZDC", "normal ZDC");
}
if (iTRD)
{
//=================== TRD parameters ============================
// 7 TRDs only : 0, 1, 7, 8, 9, 10, 17
AliTRD *TRD = new AliTRDv1("TRD", "TRD slow simulator");
AliTRDgeometry *geoTRD = TRD->GetGeometry();
// Partial geometry: modules at 0,1,7,8,9,16,17
// starting at 3h in positive direction
geoTRD->SetSMstatus(2,0);
geoTRD->SetSMstatus(3,0);
geoTRD->SetSMstatus(4,0);
geoTRD->SetSMstatus(5,0);
geoTRD->SetSMstatus(6,0);
geoTRD->SetSMstatus(11,0);
geoTRD->SetSMstatus(12,0);
geoTRD->SetSMstatus(13,0);
geoTRD->SetSMstatus(14,0);
geoTRD->SetSMstatus(15,0);
geoTRD->SetSMstatus(16,0);
}
if (iFMD)
{
//=================== FMD parameters ============================
AliFMD *FMD = new AliFMDv1("FMD", "normal FMD");
}
if (iMUON)
{
//=================== MUON parameters ===========================
// New MUONv1 version (geometry defined via builders)
AliMUON *MUON = new AliMUONv1("MUON", "default");
}
if (iPHOS)
{
//=================== PHOS parameters ===========================
AliPHOS *PHOS = new AliPHOSv1("PHOS", "IHEP");
//Set simulation parameters different from the default ones.
AliPHOSSimParam* simEmc = AliPHOSSimParam::GetInstance() ;
// APD noise of warm (+20C) PHOS:
// a2 = a1*(Y1/Y2)*(M1/M2), where a1 = 0.012 is APD noise at -25C,
// Y1 = 4.3 photo-electrons/MeV, Y2 = 1.7 p.e/MeV - light yields at -25C and +20C,
// M1 = 50, M2 = 50 - APD gain factors chosen for t1 = -25C and t2 = +20C,
// Y = MeanLightYield*APDEfficiency.
Float_t apdNoise = 0.012*2.5;
simEmc->SetAPDNoise(apdNoise);
//Raw Light Yield at +20C
simEmc->SetMeanLightYield(18800);
//ADC channel width at +18C.
simEmc->SetADCchannelW(0.0125);
}
if (iPMD)
{
//=================== PMD parameters ============================
AliPMD *PMD = new AliPMDv1("PMD", "normal PMD");
}
if (iT0)
{
//=================== T0 parameters ============================
AliT0 *T0 = new AliT0v1("T0", "T0 Detector");
}
if (iEMCAL)
{
//=================== EMCAL parameters ============================
AliEMCAL *EMCAL = new AliEMCALv2("EMCAL", "EMCAL_COMPLETE");
}
if (iACORDE)
{
//=================== ACORDE parameters ============================
AliACORDE *ACORDE = new AliACORDEv1("ACORDE", "normal ACORDE");
}
if (iVZERO)
{
//=================== ACORDE parameters ============================
AliVZERO *VZERO = new AliVZEROv7("VZERO", "normal VZERO");
}
}
