void run_sim(Int_t nEvents = 2)
{
// ========================================================================
// Adjust this part according to your requirements
// ----- Paths and file names --------------------------------------------
TString inDir = gSystem->Getenv("VMCWORKDIR");
TString inFile = inDir + "/input/urqmd.ftn14";
TString outDir = "data";
TString outFile = outDir + "/test.mc.root";
TString parFile = outDir + "/params.root";
TString HsdFile = "./jpsiHsd.auau25gev.000";
// ----- Geometries -----------------------------------------------------
TString caveGeom = "cave.geo";
TString targetGeom = "target_au_250mu.geo";
TString pipeGeom = "pipe_standard.geo";
TString magnetGeom = "passive/magnet_v09e.geo";
TString mvdGeom = "mvd/mvd_v07a.geo";
TString stsGeom = "sts/sts_v11a.geo";
TString richGeom = "rich/rich_v08a.geo";
TString trdGeom = "trd/trd_v11c.geo";
TString tofGeom = "tof/tof_v07a.geo";
// TString ecalGeom = "ecal/ecal_v08a.geo";
// ----- Magnetic field -----------------------------------------------
TString fieldMap = "field_v10e"; // name of field map
Double_t fieldZ = 50.; // field centre z position
Double_t fieldScale = 1.; // field scaling factor
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libCbmBase");
gSystem->Load("libCbmData");
gSystem->Load("libField");
gSystem->Load("libGen");
gSystem->Load("libCbmGenerators");
gSystem->Load("libPassive");
gSystem->Load("libEcal");
gSystem->Load("libKF");
gSystem->Load("libMvd");
gSystem->Load("libSts");
gSystem->Load("libRich");
gSystem->Load("libTrd");
gSystem->Load("libTof");
// -----------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3"); // Transport engine
fRun->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
fRun->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create detectors and passive volumes -------------------------
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
}
if ( targetGeom != "" ) {
FairModule* target = new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
fRun->AddModule(target);
}
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
}
if ( mvdGeom != "" ) {
FairDetector* mvd = new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
fRun->AddModule(mvd);
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
fRun->AddModule(sts);
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
fRun->AddModule(rich);
}
if ( trdGeom != "" ) {
FairDetector* trd = new CbmTrd("TRD",kTRUE );
trd->SetGeometryFileName(trdGeom);
fRun->AddModule(trd);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
fRun->AddModule(tof);
}
/*
if ( ecalGeom != "" ) {
FairDetector* ecal = new CbmEcal("ECAL", kTRUE, ecalGeom.Data());
fRun->AddModule(ecal);
}
*/
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile);
primGen->AddGenerator(urqmdGen);
CbmHsdGenerator* hsdGen = new CbmHsdGenerator(HsdFile,"Jpsi");
primGen->AddGenerator(hsdGen);
fRun->SetGenerator(primGen);
// ------------------------------------------------------------------------
// Decay J/Psi using Pythia
fRun->SetPythiaDecayer("./DecayConfig.C");
// -Trajectories Visualization (TGeoManager Only )
// Switch this on if you want to visualize tracks in the
// eventdisplay.
// This is normally switch off, because of the huge files created
// when it is switched on.
// fRun->SetStoreTraj(kTRUE);
// ----- Run initialisation -------------------------------------------
fRun->Init();
// ------------------------------------------------------------------------
// Set cuts for storing the trajectories.
// Switch this on only if trajectories are stored.
// Choose this cuts according to your needs, but be aware
// that the file size of the output file depends on these cuts
// FairTrajFilter* trajFilter = FairTrajFilter::Instance();
// trajFilter->SetStepSizeCut(0.01); // 1 cm
// trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
// trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
// trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
// trajFilter->SetStorePrimaries(kTRUE);
// trajFilter->SetStoreSecondaries(kTRUE);
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
fRun->Run(nEvents);
// ------------------------------------------------------------------------
fRun->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void r3ball(Int_t nEvents = 1,
TMap* fDetList = NULL,
TString Target = "LeadTarget",
Bool_t fVis = kFALSE,
TString fMC = "TGeant3",
TString fGenerator = "box",
Bool_t fUserPList = kFALSE,
Bool_t fR3BMagnet = kTRUE,
Double_t fMeasCurrent = 2000.,
TString OutFile = "r3bsim.root",
TString ParFile = "r3bpar.root",
TString InFile = "evt_gen.dat")
{
TString dir = getenv("VMCWORKDIR");
TString r3bdir = dir + "/macros";
TString r3b_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",r3b_geomdir.Data());
TString r3b_confdir = dir + "gconfig";
gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data());
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(fMC.Data()); // Transport engine
run->SetOutputFile(OutFile.Data()); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// R3B Special Physics List in G4 case
if ( (fUserPList == kTRUE ) &&
(fMC.CompareTo("TGeant4") == 0)) {
run->SetUserConfig("g4R3bConfig.C");
run->SetUserCuts("SetR3BCuts.C");
}
// ----- Create media -------------------------------------------------
run->SetMaterials("media_r3b.geo"); // Materials
// Magnetic field map type
Int_t fFieldMap = 0;
// Global Transformations
//- Two ways for a Volume Rotation are supported
//-- 1) Global Rotation (Euler Angles definition)
//-- This represent the composition of : first a rotation about Z axis with
//-- angle phi, then a rotation with theta about the rotated X axis, and
//-- finally a rotation with psi about the new Z axis.
Double_t phi,theta,psi;
//-- 2) Rotation in Ref. Frame of the Volume
//-- Rotation is Using Local Ref. Frame axis angles
Double_t thetaX,thetaY,thetaZ;
//- Global Translation Lab. frame.
Double_t tx,ty,tz;
// ----- Create R3B geometry --------------------------------------------
//R3B Cave definition
FairModule* cave= new R3BCave("CAVE");
cave->SetGeometryFileName("r3b_cave.geo");
run->AddModule(cave);
//R3B Target definition
if (fDetList->FindObject("TARGET") ) {
R3BModule* target= new R3BTarget(Target.Data());
target->SetGeometryFileName(((TObjString*)fDetList->GetValue("TARGET"))->GetString().Data());
run->AddModule(target);
}
//R3B SiTracker Cooling definition
if (fDetList->FindObject("VACVESSELCOOL") ) {
R3BModule* vesselcool= new R3BVacVesselCool(Target.Data());
vesselcool->SetGeometryFileName(((TObjString*)fDetList->GetValue("VACVESSELCOOL"))->GetString().Data());
run->AddModule(vesselcool);
}
//R3B Magnet definition
if (fDetList->FindObject("ALADIN") ) {
fFieldMap = 0;
R3BModule* mag = new R3BMagnet("AladinMagnet");
mag->SetGeometryFileName(((TObjString*)fDetList->GetValue("ALADIN"))->GetString().Data());
run->AddModule(mag);
}
//R3B Magnet definition
if (fDetList->FindObject("GLAD") ) {
fFieldMap = 1;
R3BModule* mag = new R3BGladMagnet("GladMagnet");
mag->SetGeometryFileName(((TObjString*)fDetList->GetValue("GLAD"))->GetString().Data());
run->AddModule(mag);
}
if (fDetList->FindObject("CRYSTALBALL") ) {
//R3B Crystal Calorimeter
R3BDetector* xball = new R3BXBall("XBall", kTRUE);
xball->SetGeometryFileName(((TObjString*)fDetList->GetValue("CRYSTALBALL"))->GetString().Data());
run->AddModule(xball);
}
if (fDetList->FindObject("CALIFA") ) {
// CALIFA Calorimeter
R3BDetector* calo = new R3BCalo("Califa", kTRUE);
((R3BCalo *)calo)->SelectGeometryVersion(10);
//Selecting the Non-uniformity of the crystals (1 means +-1% max deviation)
((R3BCalo *)calo)->SetNonUniformity(1.0);
calo->SetGeometryFileName(((TObjString*)fDetList->GetValue("CALIFA"))->GetString().Data());
run->AddModule(calo);
}
// Tracker
if (fDetList->FindObject("TRACKER") ) {
R3BDetector* tra = new R3BTra("Tracker", kTRUE);
tra->SetGeometryFileName(((TObjString*)fDetList->GetValue("TRACKER"))->GetString().Data());
tra->SetEnergyCut(1e-4);
run->AddModule(tra);
}
// STaRTrack
if (fDetList->FindObject("STaRTrack") ) {
R3BDetector* tra = new R3BSTaRTra("STaRTrack", kTRUE);
tra->SetGeometryFileName(((TObjString*)fDetList->GetValue("STaRTrack"))->GetString().Data());
run->AddModule(tra);
}
// DCH drift chambers
if (fDetList->FindObject("DCH") ) {
R3BDetector* dch = new R3BDch("Dch", kTRUE);
dch->SetGeometryFileName(((TObjString*)fDetList->GetValue("DCH"))->GetString().Data());
run->AddModule(dch);
}
// Tof
if (fDetList->FindObject("TOF") ) {
R3BDetector* tof = new R3BTof("Tof", kTRUE);
tof->SetGeometryFileName(((TObjString*)fDetList->GetValue("TOF"))->GetString().Data());
run->AddModule(tof);
}
// mTof
if (fDetList->FindObject("MTOF") ) {
R3BDetector* mTof = new R3BmTof("mTof", kTRUE);
mTof->SetGeometryFileName(((TObjString*)fDetList->GetValue("MTOF"))->GetString().Data());
run->AddModule(mTof);
}
// dTof
if (fDetList->FindObject("DTOF") ) {
R3BDetector* dTof = new R3BdTof("dTof", kTRUE);
dTof->SetGeometryFileName(((TObjString*)fDetList->GetValue("DTOF"))->GetString().Data());
run->AddModule(dTof);
}
// GFI detector
if (fDetList->FindObject("GFI") ) {
R3BDetector* gfi = new R3BGfi("Gfi", kTRUE);
gfi->SetGeometryFileName(((TObjString*)fDetList->GetValue("GFI"))->GetString().Data());
run->AddModule(gfi);
}
// Land Detector
if (fDetList->FindObject("LAND") ) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(1);
land->SetGeometryFileName(((TObjString*)fDetList->GetValue("LAND"))->GetString().Data());
run->AddModule(land);
}
// NeuLand Scintillator Detector
if(fDetList->FindObject("SCINTNEULAND")) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(1);
land->SetGeometryFileName(((TObjString*)fDetList->GetValue("SCINTNEULAND"))->GetString().Data());
run->AddModule(land);
}
// MFI Detector
if(fDetList->FindObject("MFI")) {
R3BDetector* mfi = new R3BMfi("Mfi", kTRUE);
mfi->SetGeometryFileName(((TObjString*)fDetList->GetValue("MFI"))->GetString().Data());
run->AddModule(mfi);
}
// PSP Detector
if(fDetList->FindObject("PSP")) {
R3BDetector* psp = new R3BPsp("Psp", kTRUE);
psp->SetGeometryFileName(((TObjString*)fDetList->GetValue("PSP"))->GetString().Data());
run->AddModule(psp);
}
// Luminosity detector
if (fDetList->FindObject("LUMON") ) {
R3BDetector* lumon = new ELILuMon("LuMon", kTRUE);
lumon->SetGeometryFileName(((TObjString*)fDetList->GetValue("LUMON"))->GetString().Data());
run->AddModule(lumon);
}
// ----- Create R3B magnetic field ----------------------------------------
Int_t typeOfMagneticField = 0;
Int_t fieldScale = 1;
Bool_t fVerbose = kFALSE;
//NB: <D.B>
// If the Global Position of the Magnet is changed
// the Field Map has to be transformed accordingly
FairField *magField = NULL;
if (fFieldMap == 0) {
magField = new R3BAladinFieldMap("AladinMaps");
((R3BAladinFieldMap*)magField)->SetCurrent(fMeasCurrent);
((R3BAladinFieldMap*)magField)->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} else if(fFieldMap == 1){
magField = new R3BGladFieldMap("R3BGladMap");
((R3BGladFieldMap*)magField)->SetPosition(0., 0., +350-119.94);
((R3BGladFieldMap*)magField)->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} //! end of field map section
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (fGenerator.CompareTo("box") == 0 ) {
// 2- Define the BOX generator
Int_t pdgId = 211; // pion beam
Double32_t theta1 = 0.; // polar angle distribution
Double32_t theta2 = 7.;
Double32_t momentum = 0.8;
FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 50);
boxGen->SetThetaRange(theta1, theta2);
boxGen->SetPRange(momentum, momentum*2.);
boxGen->SetPhiRange(0, 360);
boxGen->SetXYZ(0.0, 0.0, -1.5);
// boxGen->SetXYZ(0.0, 0.0, -300.);
// add the box generator
primGen->AddGenerator(boxGen);
}
if (fGenerator.CompareTo("ascii") == 0 ) {
R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir+"/input/"+InFile).Data());
primGen->AddGenerator(gen);
}
if (fGenerator.CompareTo("r3b") == 0 ) {
R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator();
// R3bGen properties
pR3bGen->SetBeamInteractionFlag("off");
pR3bGen->SetBeamInteractionFlag("off");
pR3bGen->SetRndmFlag("off");
pR3bGen->SetRndmEneFlag("off");
pR3bGen->SetBoostFlag("off");
pR3bGen->SetReactionFlag("on");
pR3bGen->SetGammasFlag("off");
pR3bGen->SetDecaySchemeFlag("off");
pR3bGen->SetDissociationFlag("off");
pR3bGen->SetBackTrackingFlag("off");
pR3bGen->SetSimEmittanceFlag("off");
// R3bGen Parameters
pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV
pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV
pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code
pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV
Int_t fMultiplicity = 50;
pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult.
// Reaction type
// 1: "Elas"
// 2: "iso"
// 3: "Trans"
pR3bGen->SetReactionType("Elas");
// Target type
// 1: "LeadTarget"
// 2: "Parafin0Deg"
// 3: "Parafin45Deg"
// 4: "LiH"
pR3bGen->SetTargetType(Target.Data());
Double_t thickness = (0.11/2.)/10.; // cm
pR3bGen->SetTargetHalfThicknessPara(thickness); // cm
pR3bGen->SetTargetThicknessLiH(3.5); // cm
pR3bGen->SetTargetRadius(1.); // cm
pR3bGen->SetSigmaXInEmittance(1.); //cm
pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm
// Dump the User settings
pR3bGen->PrintParameters();
primGen->AddGenerator(pR3bGen);
}
run->SetGenerator(primGen);
//-------Set visualisation flag to true------------------------------------
run->SetStoreTraj(fVis);
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------ Increase nb of step for CALO
Int_t nSteps = -15000;
gMC->SetMaxNStep(nSteps);
// ----- Runtime database ---------------------------------------------
R3BFieldPar* fieldPar = (R3BFieldPar*) rtdb->getContainer("R3BFieldPar");
if(NULL != magField)
{
fieldPar->SetParameters(magField);
fieldPar->setChanged();
}
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(ParFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ----- Start run ----------------------------------------------------
if(nEvents > 0) {
run->Run(nEvents);
}
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << OutFile << endl;
cout << "Parameter file is " << ParFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void run_sim(Int_t nEvents = 100, TString mcEngine = "TGeant4")
{
// Output file name
TString outFile ="test.root";
// Parameter file name
TString parFile="params.root";
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(new FairRootFileSink(outFile)); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new MyCave("CAVE");
cave->SetGeometryFileName("cave.geo");
run->AddModule(cave);
FairModule* magnet = new MyMagnet("Magnet");
run->AddModule(magnet);
FairModule* pipe = new MyPipe("Pipe");
run->AddModule(pipe);
FairDetector* NewDet = new NewDetector("TestDetector", kTRUE);
run->AddModule(NewDet);
// ------------------------------------------------------------------------
// ----- Magnetic field -------------------------------------------
// Constant Field
MyConstField *fMagField = new MyConstField();
fMagField->SetField(0., 20. ,0. ); // values are in kG
fMagField->SetFieldRegion(-200, 200,-200, 200, -200, 200); // values are in cm
// (xmin,xmax,ymin,ymax,zmin,zmax)
run->SetField(fMagField);
// --------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
// Add a box generator also to the run
FairBoxGenerator* boxGen = new FairBoxGenerator(13, 5); // 13 = muon; 1 = multipl.
boxGen->SetPRange(20,25); // GeV/c
boxGen->SetPhiRange(0., 360.); // Azimuth angle range [degree]
boxGen->SetThetaRange(0., 90.); // Polar angle in lab system range [degree]
boxGen->SetXYZ(0., 0., 0.); // cm
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
//---Store the visualiztion info of the tracks, this make the output file very large!!
//--- Use it only to display but not for production!
run->SetStoreTraj(kTRUE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
//You can export your ROOT geometry ot a separate file
run->CreateGeometryFile("geofile_full.root");
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
}
void run_sim(Int_t nEvents = 10, TString mcEngine = "TGeant3", Int_t fileId = 0)
{
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/MQ/9-PixelDetector";
TString tut_geomdir = dir + "/common/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/common/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
TString partName[] = {"pions","eplus","proton"};
Int_t partPdgC[] = { 211, 11, 2212};
Int_t chosenPart = 0;
TString outDir = "./";
// Output file name
TString outFile;
if ( fileId == 0 ) outFile = Form("%s/pixel_%s.mc.root",
outDir.Data(),
mcEngine.Data());
else outFile = Form("%s/pixel_%s.mc.f%d.root",
outDir.Data(),
mcEngine.Data(),
fileId);
// Parameter file name
TString parFile = Form("%s/pixel_%s.params.root",
outDir.Data(),
mcEngine.Data());
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
Pixel* det = new Pixel("Tut9", kTRUE);
det->SetGeometryFileName("pixel.geo");
// det->SetMisalignDetector(kTRUE);
run->AddModule(det);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 5);
boxGen->SetPRange(1,2);
boxGen->SetThetaRange(0,40);
boxGen->SetPhiRange(0,360);
// boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
run->SetStoreTraj(kFALSE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
run->CreateGeometryFile("geofile_full.root");
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_sim(Int_t nEvents=100, TString mcEngine="TGeant3")
{
TStopwatch timer;
timer.Start();
gDebug=0;
// Use non default gconfig and geometry directories
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/Tutorial6";
TString ex_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",ex_geomdir.Data());
TString ex_configdir = dir + "/gconfig";
gSystem->Setenv("CONFIG_DIR",ex_configdir.Data());
// create Instance of Run Manager class
FairRunSim *fRun = new FairRunSim();
// set the MC version used
// ------------------------
fRun->SetName(mcEngine);
TString outfile = "data/testrun_";
outfile = outfile + mcEngine + ".root";
TString outparam = "data/testparams_";
outparam = outparam + mcEngine + ".root";
fRun->SetOutputFile(outfile);
// ----- Magnetic field -------------------------------------------
// Constant Field
FairConstField *fMagField = new FairConstField();
fMagField->SetField(0., 10. ,0. ); // values are in kG
fMagField->SetFieldRegion(-50, 50,-50, 50, 350, 450);// values are in cm (xmin,xmax,ymin,ymax,zmin,zmax)
fRun->SetField(fMagField);
// --------------------------------------------------------------------
// Set Material file Name
//-----------------------
fRun->SetMaterials("media.geo");
// Create and add detectors
//-------------------------
FairModule *Cave= new FairCave("CAVE");
Cave->SetGeometryFileName("cave.geo");
fRun->AddModule(Cave);
FairModule *Magnet= new FairMagnet("MAGNET");
Magnet->SetGeometryFileName("magnet.geo");
fRun->AddModule(Magnet);
FairDetector *Torino= new FairTestDetector("TORINO", kTRUE);
Torino->SetGeometryFileName("torino.geo");
fRun->AddModule(Torino);
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
fRun->SetGenerator(primGen);
// Box Generator
FairBoxGenerator* boxGen = new FairBoxGenerator(2212, 10); // 13 = muon; 1 = multipl.
boxGen->SetPRange(2., 2.); // GeV/c //setPRange vs setPtRange
boxGen->SetPhiRange(0, 360); // Azimuth angle range [degree]
boxGen->SetThetaRange(3, 10); // Polar angle in lab system range [degree]
boxGen->SetCosTheta();//uniform generation on all the solid angle(default)
// boxGen->SetXYZ(0., 0.37, 0.);
primGen->AddGenerator(boxGen);
fRun->SetStoreTraj(kTRUE);
fRun->Init();
// -Trajectories Visualization (TGeoManager Only )
// -----------------------------------------------
// Set cuts for storing the trajectpries
/* FairTrajFilter* trajFilter = FairTrajFilter::Instance();
trajFilter->SetStepSizeCut(0.01); // 1 cm
trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
trajFilter->SetStorePrimaries(kTRUE);
trajFilter->SetStoreSecondaries(kTRUE);
*/
// Fill the Parameter containers for this run
//-------------------------------------------
FairRuntimeDb *rtdb=fRun->GetRuntimeDb();
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(outparam);
rtdb->setOutput(output);
rtdb->saveOutput();
rtdb->print();
// Transport nEvents
// -----------------
// Int_t nEvents = 1;
fRun->Run(nEvents);
TString geoFile = tutdir + "/data/geofile_full.root";
fRun->CreateGeometryFile(geoFile.Data());
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
printf("RealTime=%f seconds, CpuTime=%f seconds\n",rtime,ctime);
cout << "Macro finished successfully." << endl;
}
sim_upto_emc(Int_t nEvents = 20000)
{
//-----User Settings:-----------------------------------------------
TString OutputFile ="sim_complete_20k_upto_emc.root";
TString ParOutputfile ="simparams_20k_upto_emc.root";
TString MediaFile ="media_pnd.geo";
gDebug = 0;
TString digiFile = "all.par"; //The emc run the hit producer directly
double BeamMomentum =15.0; // ** change HERE if you run Box generator
TString SimEngine ="TGeant4";
//------------------------------------------------------------------
TStopwatch timer;
timer.Start();
gRandom->SetSeed();
// Create the Simulation run manager--------------------------------
FairRunSim *fRun = new FairRunSim();
fRun->SetName(SimEngine.Data() );
fRun->SetOutputFile(OutputFile.Data());
fRun->SetWriteRunInfoFile(kFALSE);
fRun->SetBeamMom(BeamMomentum);
fRun->SetMaterials(MediaFile.Data());
fRun->SetRadLenRegister(true);
//fRun->SetRadMapRegister(true);
//fRun->SetRadGridRegister(true);
FairRuntimeDb *rtdb=fRun->GetRuntimeDb();
// Set the parameters
//-------------------------------
TString allDigiFile = gSystem->Getenv("VMCWORKDIR");
allDigiFile += "/macro/params/";
allDigiFile += digiFile;
//-------Set the parameter output --------------------
FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
parIo1->open(allDigiFile.Data(),"in");
rtdb->setFirstInput(parIo1);
//---------------------Set Parameter output ----------
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(ParOutputfile.Data());
rtdb->setOutput(output);
// Create and add detectors
//------------------------- CAVE -----------------
FairModule *Cave= new PndCave("CAVE");
Cave->SetGeometryFileName("pndcave.geo");
fRun->AddModule(Cave);
//------------------------- Magnet -----------------
FairModule *Magnet= new PndMagnet("MAGNET");
//Magnet->SetGeometryFileName("FullSolenoid_V842.root");
Magnet->SetGeometryFileName("FullSuperconductingSolenoid_v831.root");
fRun->AddModule(Magnet);
FairModule *Dipole= new PndMagnet("MAGNET");
Dipole->SetGeometryFileName("dipole.geo");
fRun->AddModule(Dipole);
//------------------------- Pipe -----------------
FairModule *Pipe= new PndPipe("PIPE");
Pipe->SetGeometryFileName("beampipe_201309.root");
fRun->AddModule(Pipe);
//------------------------- STT -----------------
FairDetector *Stt= new PndStt("STT", kTRUE);
Stt->SetGeometryFileName("straws_skewed_blocks_35cm_pipe.geo");
fRun->AddModule(Stt);
//------------------------- MVD -----------------
FairDetector *Mvd = new PndMvdDetector("MVD", kTRUE);
Mvd->SetGeometryFileName("Mvd-2.1_FullVersion.root");
fRun->AddModule(Mvd);
//------------------------- GEM -----------------
FairDetector *Gem = new PndGemDetector("GEM", kTRUE);
Gem->SetGeometryFileName("gem_3Stations.root");
fRun->AddModule(Gem);
//------------------------- EMC -----------------
PndEmc *Emc = new PndEmc("EMC",kTRUE);
Emc->SetGeometryVersion(1);
Emc->SetStorageOfData(kFALSE);
fRun->AddModule(Emc);
////------------------------- SCITIL -----------------
//FairDetector *SciT = new PndSciT("SCIT",kTRUE);
//SciT->SetGeometryFileName("barrel-SciTil_07022013.root");
//fRun->AddModule(SciT);
//
////------------------------- DRC -----------------
//PndDrc *Drc = new PndDrc("DIRC", kTRUE);
//Drc->SetGeometryFileName("dirc_l0_p0_updated.root");
//Drc->SetRunCherenkov(kFALSE);
//fRun->AddModule(Drc);
//
////------------------------- DISC -----------------
//PndDsk* Dsk = new PndDsk("DSK", kTRUE);
//Dsk->SetStoreCerenkovs(kFALSE);
//Dsk->SetStoreTrackPoints(kFALSE);
//fRun->AddModule(Dsk);
//
////------------------------- MDT -----------------
//PndMdt *Muo = new PndMdt("MDT",kTRUE);
//Muo->SetBarrel("fast");
//Muo->SetEndcap("fast");
//Muo->SetMuonFilter("fast");
//Muo->SetForward("fast");
//Muo->SetMdtMagnet(kTRUE);
//Muo->SetMdtMFIron(kTRUE);
//fRun->AddModule(Muo);
//
////------------------------- FTS -----------------
//FairDetector *Fts= new PndFts("FTS", kTRUE);
//Fts->SetGeometryFileName("fts.geo");
//fRun->AddModule(Fts);
//
////------------------------- FTOF -----------------
//FairDetector *FTof = new PndFtof("FTOF",kTRUE);
//FTof->SetGeometryFileName("ftofwall.root");
//fRun->AddModule(FTof);
//
////------------------------- RICH ----------------
//FairDetector *Rich= new PndRich("RICH",kFALSE);
//Rich->SetGeometryFileName("rich_v2_shift.geo");
//fRun->AddModule(Rich);
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
fRun->SetGenerator(primGen);
FairBoxGenerator* boxGen = new FairBoxGenerator(0, 1);
boxGen->SetPRange(2.0,2.0); // GeV/c
boxGen->SetPhiRange(0., 360.); // Azimuth angle range [degree]
boxGen->SetThetaRange(0., 180.); // Polar angle in lab system range [degree]
boxGen->SetXYZ(0., 0., 0.); // cm
primGen->AddGenerator(boxGen);
//---------------------Create and Set the Field(s)----------
PndMultiField *fField= new PndMultiField("FULL");
fRun->SetField(fField);
// EMC Hit producer
//-------------------------------
PndEmcHitProducer* emcHitProd = new PndEmcHitProducer();
fRun->AddTask(emcHitProd);
//------------------------- Initialize the RUN -----------------
fRun->Init();
//------------------------- Run the Simulation -----------------
fRun->Run(nEvents);
//------------------------- Save the parameters -----------------
rtdb->saveOutput();
//------------------------Print some info and exit----------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
printf("RealTime=%f seconds, CpuTime=%f seconds\n",rtime,ctime);
cout << " Test passed" << endl;
cout << " All ok " << endl;
//exit(0);
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_tutorial1(Int_t nEvents = 10, TString mcEngine = "TGeant3")
{
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/Tutorial1";
TString tut_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
TString partName[] = {"pions","eplus","proton"};
Int_t partPdgC[] = { 211, 11, 2212};
Int_t chosenPart = 0;
Double_t momentum = 2.;
Double_t theta = 0.;
TString outDir = "./";
// Output file name
TString outFile = Form("%s/tutorial1_%s_%s.mc_p%1.3f_t%1.0f_n%d.root",
outDir.Data(),
mcEngine.Data(),
partName[chosenPart].Data(),
momentum,
theta,
nEvents);
// Parameter file name
TString parFile = Form("%s/tutorial1_%s_%s.params_p%1.3f_t%1.0f_n%d.root",
outDir.Data(),
mcEngine.Data(),
partName[chosenPart].Data(),
momentum,
theta,
nEvents);
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
FairDetector* tutdet = new FairTutorialDet1("TUTDET", kTRUE);
tutdet->SetGeometryFileName("double_sector.geo");
run->AddModule(tutdet);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 1);
boxGen->SetThetaRange ( theta, theta+0.01);
boxGen->SetPRange (momentum,momentum+0.01);
boxGen->SetPhiRange (0.,360.);
boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
run->CreateGeometryFile("geofile_full.root");
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
}
void run_sim(Int_t gen=1, Int_t nEvents = 1, Int_t fileNum = 100)
{
TString rootVersion = "feb16";
const char* setup = "sis100_electron";
TString sfileNum = "";
sfileNum += fileNum;
// ========================================================================
// Adjust this part according to your requirements
// ----- Paths and file names --------------------------------------------
TString inDir = "/hera/cbm/users/klochkov/cbm/data/input/au10au/shield/test_10k/";
TString inFile = inDir + "au10au_" + sfileNum + ".root";
TString outDir = "/hera/cbm/users/klochkov/cbm/data/au10au_10k_test_1/";
TString outFile = outDir + "sim/mc_" + sfileNum + ".root";
TString parFile = outDir + "sim/params_" + sfileNum + ".root";
TString geoFileNamePsd = outDir + "geo/psd_geo_xy_" + sfileNum + ".txt";
TString geoFileName = outDir + "geo/geofile_" + sfileNum + ".root";
TString SourceDir = gSystem->Getenv("VMCWORKDIR");
TString setupFile = SourceDir + "/geometry/setup/sis100_electron_setup.C"; //TODO
TString setupFunct = setup;
setupFunct += "_setup()";
gROOT->LoadMacro(setupFile);
gInterpreter->ProcessLine(setupFunct);
// Function needed for CTest runtime dependency
// TString depFile = Remove_CTest_Dependency_File(outDir, "run_sim" , setup);
// --- Logger settings ----------------------------------------------------
TString logLevel = "INFO"; // "DEBUG";
TString logVerbosity = "LOW";
// ------------------------------------------------------------------------
// --- Define the target geometry -----------------------------------------
//
// The target is not part of the setup, since one and the same setup can
// and will be used with different targets.
// The target is constructed as a tube in z direction with the specified
// diameter (in x and y) and thickness (in z). It will be placed at the
// specified position as daughter volume of the volume present there. It is
// in the responsibility of the user that no overlaps or extrusions are
// created by the placement of the target.
//
TString targetElement = "Gold";
Double_t targetThickness = 0.025; // full thickness in cm
Double_t targetDiameter = 2.5; // diameter in cm
Double_t targetPosX = 0.; // target x position in global c.s. [cm]
Double_t targetPosY = 0.; // target y position in global c.s. [cm]
Double_t targetPosZ = 0.; // target z position in global c.s. [cm]
Double_t targetRotY = 0.; // target rotation angle around the y axis [deg]
// ------------------------------------------------------------------------
// --- Define the creation of the primary vertex ------------------------
//
// By default, the primary vertex point is sampled from a Gaussian
// distribution in both x and y with the specified beam profile width,
// and from a flat distribution in z over the extension of the target.
// By setting the respective flags to kFALSE, the primary vertex will always
// at the (0., 0.) in x and y and in the z centre of the target, respectively.
//
Bool_t smearVertexXY = kTRUE;
Bool_t smearVertexZ = kTRUE;
Double_t beamWidthX = 1.; // Gaussian sigma of the beam profile in x [cm]
Double_t beamWidthY = 1.; // Gaussian sigma of the beam profile in y [cm]
// ------------------------------------------------------------------------
// In general, the following parts need not be touched
// ========================================================================
cout << "[INFO ] Setup: " << setup << endl;
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName("TGeant4"); // Transport engine
run->SetOutputFile(outFile); // Output file
run->SetGenerateRunInfo(kTRUE); // Create FairRunInfo file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Logger settings ----------------------------------------------
gLogger->SetLogScreenLevel(logLevel.Data());
gLogger->SetLogVerbosityLevel(logVerbosity.Data());
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create detectors and passive volumes -------------------------
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
run->AddModule(cave);
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
run->AddModule(pipe);
}
// --- Target
CbmTarget* target = new CbmTarget(targetElement.Data(),
targetThickness,
targetDiameter);
target->SetPosition(targetPosX, targetPosY, targetPosZ);
target->SetRotation(targetRotY);
run->AddModule(target);
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
run->AddModule(magnet);
}
if ( platformGeom != "" ) {
FairModule* platform = new CbmPlatform("PLATFORM");
platform->SetGeometryFileName(platformGeom);
run->AddModule(platform);
}
if ( mvdGeom != "" ) {
FairDetector* mvd = new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
mvd->SetMotherVolume("pipevac1");
run->AddModule(mvd);
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmStsMC(kTRUE);
sts->SetGeometryFileName(stsGeom);
run->AddModule(sts);
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
run->AddModule(rich);
}
if ( muchGeom != "" ) {
FairDetector* much = new CbmMuch("MUCH", kTRUE);
much->SetGeometryFileName(muchGeom);
run->AddModule(much);
}
if ( shieldGeom != "" ) {
FairModule* shield = new CbmShield("SHIELD");
shield->SetGeometryFileName(shieldGeom);
run->AddModule(shield);
}
if ( trdGeom != "" ) {
FairDetector* trd = new CbmTrd("TRD",kTRUE );
trd->SetGeometryFileName(trdGeom);
run->AddModule(trd);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
run->AddModule(tof);
}
if ( ecalGeom != "" ) {
FairDetector* ecal = new CbmEcal("ECAL", kTRUE, ecalGeom.Data());
run->AddModule(ecal);
}
// if ( psdGeom != "" ) {
TString geoFileNamePsd = outDir + "geo/psd_geo_xy_" + sfileNum + ".txt";
cout << "Constructing PSD" << endl;
// CbmPsdv1* psd= new CbmPsdv1("PSD", kTRUE);
CbmPsdTest* psd= new CbmPsdTest("PSD", kTRUE);
psd->SetZposition(psdZpos); // in cm
psd->SetXshift(psdXpos); // in cm
psd->SetGeoFile(geoFileNamePsd);
psd->SetHoleSize(6);
run->AddModule(psd);
// }
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = NULL;
if ( 2 == fieldSymType ) {
magField = new CbmFieldMapSym2(fieldMap);
} else if ( 3 == fieldSymType ) {
magField = new CbmFieldMapSym3(fieldMap);
}
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
run->SetField(magField);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
// --- Uniform distribution of event plane angle
// primGen->SetEventPlane(0., 2. * TMath::Pi()); //TODO (ask Vitaly) check event plane
// --- Get target parameters
Double_t tX = 0.;
Double_t tY = 0.;
Double_t tZ = 0.;
Double_t tDz = 0.;
if ( target ) {
target->GetPosition(tX, tY, tZ);
tDz = target->GetThickness();
}
primGen->SetTarget(tZ, tDz);
primGen->SetBeam(0., 0., beamWidthX, beamWidthY);
primGen->SmearGausVertexXY(smearVertexXY);
primGen->SmearVertexZ(smearVertexZ);
//
// TODO: Currently, there is no guaranteed consistency of the beam profile
// and the transversal target dimension, i.e., that the sampled primary
// vertex falls into the target volume. This would require changes
// in the FairPrimaryGenerator class.
// ------------------------------------------------------------------------
// Use the CbmUnigenGenrator for the input
if (gen == 0) {
CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(inFile);
urqmdGen->SetEventPlane(-TMath::Pi(), TMath::Pi());
primGen->AddGenerator(urqmdGen);
}
if (gen == 1) {
CbmShieldGeneratorNew* shieldGen = new CbmShieldGeneratorNew (inFile);
primGen->AddGenerator(shieldGen);
}
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
// Visualisation of trajectories (TGeoManager Only)
// Switch this on if you want to visualise tracks in the event display.
// This is normally switch off, because of the huge files created
// when it is switched on.
run->SetStoreTraj(kFALSE);
// ----- Run initialisation -------------------------------------------
run->Init();
// ------------------------------------------------------------------------
// Set cuts for storing the trajectories.
// Switch this on only if trajectories are stored.
// Choose this cuts according to your needs, but be aware
// that the file size of the output file depends on these cuts
FairTrajFilter* trajFilter = FairTrajFilter::Instance();
if ( trajFilter ) {
trajFilter->SetStepSizeCut(0.01); // 1 cm
trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
trajFilter->SetStorePrimaries(kTRUE);
trajFilter->SetStoreSecondaries(kTRUE);
}
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(run->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
run->CreateGeometryFile(geoFileName);
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
std::cout << std::endl << std::endl;
std::cout << "Macro finished successfully." << std::endl;
std::cout << "Output file is " << outFile << std::endl;
std::cout << "Parameter file is " << parFile << std::endl;
std::cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << std::endl << std::endl;
// ------------------------------------------------------------------------
std::cout << " Test passed" << std::endl;
std::cout << " All ok " << std::endl;
// Function needed for CTest runtime dependency
// Generate_CTest_Dependency_File(depFile);
}
void r3ball(Int_t nEvents = 1,
TMap& fDetList,
TString Target = "LeadTarget",
Bool_t fVis = kFALSE,
TString fMC = "TGeant3",
TString fGenerator = "box",
Bool_t fUserPList = kFALSE,
Bool_t fR3BMagnet = kTRUE,
Bool_t fCalifaHitFinder = kFALSE,
Bool_t fStarTrackHitFinder = kFALSE,
Double_t fMeasCurrent = 2000.,
TString OutFile = "r3bsim.root",
TString ParFile = "r3bpar.root",
TString InFile = "evt_gen.dat",
double energy1, double energy2)
{
TString dir = getenv("VMCWORKDIR");
TString r3bdir = dir + "/macros";
TString r3b_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",r3b_geomdir.Data());
TString r3b_confdir = dir + "gconfig";
gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data());
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(fMC.Data()); // Transport engine
run->SetOutputFile(OutFile.Data()); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairLogger::GetLogger()->SetLogScreenLevel("DEBUG");
// R3B Special Physics List in G4 case
if ( (fUserPList == kTRUE ) &&
(fMC.CompareTo("TGeant4") == 0)
){
run->SetUserConfig("g4R3bConfig.C");
run->SetUserCuts("SetCuts.C");
}
// ----- Create media -------------------------------------------------
run->SetMaterials("media_r3b.geo"); // Materials
// Magnetic field map type
Int_t fFieldMap = 0;
// Global Transformations
//- Two ways for a Volume Rotation are supported
//-- 1) Global Rotation (Euler Angles definition)
//-- This represent the composition of : first a rotation about Z axis with
//-- angle phi, then a rotation with theta about the rotated X axis, and
//-- finally a rotation with psi about the new Z axis.
Double_t phi,theta,psi;
//-- 2) Rotation in Ref. Frame of the Volume
//-- Rotation is Using Local Ref. Frame axis angles
Double_t thetaX,thetaY,thetaZ;
//- Global Translation Lab. frame.
Double_t tx,ty,tz;
// ----- Create R3B geometry --------------------------------------------
//R3B Cave definition
FairModule* cave= new R3BCave("CAVE");
cave->SetGeometryFileName("r3b_cave.geo");
run->AddModule(cave);
//R3B Target definition
if (fDetList.FindObject("TARGET") ) {
R3BModule* target= new R3BTarget(Target.Data());
target->SetGeometryFileName(((TObjString*)fDetList.GetValue("TARGET"))->GetString().Data());
run->AddModule(target);
}
//R3B SiTracker Cooling definition
if (fDetList.FindObject("VACVESSELCOOL") ) {
R3BModule* vesselcool= new R3BVacVesselCool(Target.Data());
vesselcool->SetGeometryFileName(((TObjString*)fDetList.GetValue("VACVESSELCOOL"))->GetString().Data());
run->AddModule(vesselcool);
}
//R3B Magnet definition
if (fDetList.FindObject("ALADIN") ) {
fFieldMap = 0;
R3BModule* mag = new R3BMagnet("AladinMagnet");
mag->SetGeometryFileName(((TObjString*)fDetList.GetValue("ALADIN"))->GetString().Data());
run->AddModule(mag);
}
//R3B Magnet definition
if (fDetList.FindObject("GLAD") ) {
fFieldMap = 1;
R3BModule* mag = new R3BGladMagnet("GladMagnet", ((TObjString*)fDetList->GetValue("GLAD"))->GetString(), "GLAD Magnet");
run->AddModule(mag);
}
if (fDetList.FindObject("CRYSTALBALL") ) {
//R3B Crystal Calorimeter
R3BDetector* xball = new R3BXBall("XBall", kTRUE);
xball->SetGeometryFileName(((TObjString*)fDetList.GetValue("CRYSTALBALL"))->GetString().Data());
run->AddModule(xball);
}
if (fDetList.FindObject("CALIFA") ) {
// CALIFA Calorimeter
R3BDetector* califa = new R3BCalifa("Califa", kTRUE);
// ((R3BCalifa *)califa)->SelectGeometryVersion(0x438b);
((R3BCalifa *)califa)->SelectGeometryVersion(17);
//Selecting the Non-uniformity of the crystals (1 means +-1% max deviation)
((R3BCalifa *)califa)->SetNonUniformity(.0);
califa->SetGeometryFileName(((TObjString*)fDetList.GetValue("CALIFA"))->GetString().Data());
run->AddModule(califa);
}
// Tracker
if (fDetList.FindObject("TRACKER") ) {
R3BDetector* tra = new R3BTra("Tracker", kTRUE);
tra->SetGeometryFileName(((TObjString*)fDetList.GetValue("TRACKER"))->GetString().Data());
run->AddModule(tra);
}
// STaRTrack
if (fDetList.FindObject("STaRTrack") ) {
R3BDetector* tra = new R3BSTaRTra("STaRTrack", kTRUE);
tra->SetGeometryFileName(((TObjString*)fDetList.GetValue("STaRTrack"))->GetString().Data());
run->AddModule(tra);
}
// DCH drift chambers
if (fDetList.FindObject("DCH") ) {
R3BDetector* dch = new R3BDch("Dch", kTRUE);
dch->SetGeometryFileName(((TObjString*)fDetList.GetValue("DCH"))->GetString().Data());
run->AddModule(dch);
}
// Tof
if (fDetList.FindObject("TOF") ) {
R3BDetector* tof = new R3BTof("Tof", kTRUE);
tof->SetGeometryFileName(((TObjString*)fDetList.GetValue("TOF"))->GetString().Data());
run->AddModule(tof);
}
// mTof
if (fDetList.FindObject("MTOF") ) {
R3BDetector* mTof = new R3BmTof("mTof", kTRUE);
mTof->SetGeometryFileName(((TObjString*)fDetList.GetValue("MTOF"))->GetString().Data());
run->AddModule(mTof);
}
// GFI detector
if (fDetList.FindObject("GFI") ) {
R3BDetector* gfi = new R3BGfi("Gfi", kTRUE);
gfi->SetGeometryFileName(((TObjString*)fDetList.GetValue("GFI"))->GetString().Data());
run->AddModule(gfi);
}
// Land Detector
if (fDetList.FindObject("LAND") ) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(1);
land->SetGeometryFileName(((TObjString*)fDetList.GetValue("LAND"))->GetString().Data());
run->AddModule(land);
}
// NeuLand Scintillator Detector
if(fDetList.FindObject("SCINTNEULAND")) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(1);
land->SetGeometryFileName(((TObjString*)fDetList.GetValue("SCINTNEULAND"))->GetString().Data());
run->AddModule(land);
}
// MFI Detector
if(fDetList.FindObject("MFI")) {
R3BDetector* mfi = new R3BMfi("Mfi", kTRUE);
mfi->SetGeometryFileName(((TObjString*)fDetList.GetValue("MFI"))->GetString().Data());
run->AddModule(mfi);
}
// PSP Detector
if(fDetList.FindObject("PSP")) {
R3BDetector* psp = new R3BPsp("Psp", kTRUE);
psp->SetGeometryFileName(((TObjString*)fDetList.GetValue("PSP"))->GetString().Data());
run->AddModule(psp);
}
// Luminosity detector
if (fDetList.FindObject("LUMON") ) {
R3BDetector* lumon = new ELILuMon("LuMon", kTRUE);
lumon->SetGeometryFileName(((TObjString*)fDetList.GetValue("LUMON"))->GetString().Data());
run->AddModule(lumon);
}
// ----- Create R3B magnetic field ----------------------------------------
Int_t typeOfMagneticField = 0;
Int_t fieldScale = 1;
Bool_t fVerbose = kFALSE;
//NB: <D.B>
// If the Global Position of the Magnet is changed
// the Field Map has to be transformed accordingly
if (fFieldMap == 0) {
R3BAladinFieldMap* magField = new R3BAladinFieldMap("AladinMaps");
magField->SetCurrent(fMeasCurrent);
magField->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} else if(fFieldMap == 1){
R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap");
magField->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} //! end of field map section
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (fGenerator.CompareTo("ion") == 0 ) {
// R3B Ion Generator
Int_t z = 30; // Atomic number
Int_t a = 65; // Mass number
Int_t q = 0; // Charge State
Int_t m = 1; // Multiplicity
Double_t px = 40./a; // X-Momentum / per nucleon!!!!!!
Double_t py = 600./a; // Y-Momentum / per nucleon!!!!!!
Double_t pz = 0.01/a; // Z-Momentum / per nucleon!!!!!!
R3BIonGenerator* ionGen = new R3BIonGenerator(z,a,q,m,px,py,pz);
ionGen->SetSpotRadius(1,1,0);
// add the ion generator
primGen->AddGenerator(ionGen);
}
if (fGenerator.CompareTo("ascii") == 0 ) {
R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir+"/input/"+InFile).Data());
primGen->AddGenerator(gen);
}
if (fGenerator.CompareTo("box") == 0 ) {
// 2- Define the BOX generator
Double_t pdgId=2212; // proton beam
Double_t theta1= 25.; // polar angle distribution
//Double_t theta2= 7.;
Double_t theta2= 66.;
// Double_t momentum=1.09008; // 500 MeV/c
// Double_t momentum=0.4445834; // 100 MeV/c
Double_t momentum1=TMath::Sqrt(energy1*energy1 + 2*energy1*0.938272046);
Double_t momentum2=TMath::Sqrt(energy2*energy2 + 2*energy2*0.938272046);
FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 1);
boxGen->SetThetaRange ( theta1, theta2);
boxGen->SetPRange (momentum1,momentum2);
boxGen->SetPhiRange (0,360.);
//boxGen->SetXYZ(0.0,0.0,-1.5);
boxGen->SetXYZ(0.0,0.0,0.0);
boxGen->SetDebug(kFALSE);
// add the box generator
primGen->AddGenerator(boxGen);
//primGen->SetTarget(0.25, 0.5);
//primGen->SmearVertexZ(kTRUE);
}
if (fGenerator.CompareTo("gammas") == 0 ) {
// 2- Define the CALIFA Test gamma generator
//Double_t pdgId=22; // gamma emission
Double_t pdgId=2212; // proton emission
Double_t theta1= 10.; // polar angle distribution
Double_t theta2= 40.;
//Double_t theta2= 90.;
//Double_t momentum=0.002; // 0.010 GeV/c = 10 MeV/c
Double_t momentumI=0.002; // 0.010 GeV/c = 10 MeV/c
Double_t momentumF=0.002; // 0.010 GeV/c = 10 MeV/c
//Double_t momentumF=0.808065; // 0.808065 GeV/c (300MeV Kin Energy for protons)
//Double_t momentumI=0.31016124; // 0.31016124 GeV/c (50MeV Kin Energy for protons)
//Double_t momentum=0.4442972; // 0.4442972 GeV/c (100MeV Kin Energy for protons)
//Double_t momentum=0.5509999; // 0.5509999 GeV/c (150MeV Kin Energy for protons)
//Double_t momentumI=0.64405; // 0.64405 GeV/c (200MeV Kin Energy for protons)
Int_t multiplicity = 1;
R3BCALIFATestGenerator* gammasGen = new R3BCALIFATestGenerator(pdgId, multiplicity);
gammasGen->SetThetaRange (theta1, theta2);
gammasGen->SetCosTheta();
gammasGen->SetPRange(momentumI,momentumF);
gammasGen->SetPhiRange(-180.,180.);
//gammasGen->SetXYZ(0.0,0.0,-1.5);
//gammasGen->SetXYZ(0.0,0.0,0);
gammasGen->SetBoxXYZ(-0.1,0.1,-0.1,0.1,-0.1,0.1);
//gammasGen->SetLorentzBoost(0.8197505718204776); //beta=0.81975 for 700 A MeV
// add the gamma generator
primGen->AddGenerator(gammasGen);
}
if (fGenerator.CompareTo("r3b") == 0 ) {
R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator();
// R3bGen properties
pR3bGen->SetBeamInteractionFlag("off");
pR3bGen->SetRndmFlag("off");
pR3bGen->SetRndmEneFlag("off");
pR3bGen->SetBoostFlag("off");
pR3bGen->SetReactionFlag("on");
pR3bGen->SetGammasFlag("off");
pR3bGen->SetDecaySchemeFlag("off");
pR3bGen->SetDissociationFlag("off");
pR3bGen->SetBackTrackingFlag("off");
pR3bGen->SetSimEmittanceFlag("off");
// R3bGen Parameters
pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV
pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV
pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code
pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV
Int_t fMultiplicity = 50;
pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult.
// Reaction type
// 1: "Elas"
// 2: "iso"
// 3: "Trans"
pR3bGen->SetReactionType("Elas");
// Target type
// 1: "LeadTarget"
// 2: "Parafin0Deg"
// 3: "Parafin45Deg"
// 4: "LiH"
pR3bGen->SetTargetType(Target.Data());
Double_t thickness = (0.11/2.)/10.; // cm
pR3bGen->SetTargetHalfThicknessPara(thickness); // cm
pR3bGen->SetTargetThicknessLiH(3.5); // cm
pR3bGen->SetTargetRadius(1.); // cm
pR3bGen->SetSigmaXInEmittance(1.); //cm
pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm
// Dump the User settings
pR3bGen->PrintParameters();
primGen->AddGenerator(pR3bGen);
}
if (fGenerator.CompareTo("p2p") == 0 ) {
R3Bp2pGenerator* gen = new R3Bp2pGenerator(("/lustre/nyx/fairgsi/mwinkel/r3broot/input/p2p/build/" + InFile).Data());
primGen->AddGenerator(gen);
#if 0
// Coincident gammas
R3BGammaGenerator *gammaGen = new R3BGammaGenerator();
gammaGen->SetEnergyLevel(0, 0.);
gammaGen->SetEnergyLevel(1, 3E-3);
gammaGen->SetEnergyLevel(2, 4E-3);
gammaGen->SetBranchingRatio(2, 1, 0.5);
gammaGen->SetBranchingRatio(2, 0, 0.5);
gammaGen->SetBranchingRatio(1, 0, 1.);
gammaGen->SetInitialLevel(2);
gammaGen->SetLorentzBoost(TVector3(0, 0, 0.777792));
primGen->AddGenerator(gammaGen);
#endif
}
run->SetGenerator(primGen);
//-------Set visualisation flag to true------------------------------------
run->SetStoreTraj(fVis);
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
// ----- Initialize CalifaHitFinder task (CrystalCal to Hit) ------------------------------------
if(fCalifaHitFinder) {
R3BCalifaCrystalCal2Hit* califaHF = new R3BCalifaCrystalCal2Hit();
califaHF->SetClusteringAlgorithm(1,0);
califaHF->SetDetectionThreshold(0.000050);//50 KeV
califaHF->SetExperimentalResolution(6.); //percent @ 1 MeV
//califaHF->SetComponentResolution(.25); //sigma = 0.5 MeV
califaHF->SetPhoswichResolution(3.,5.); //percent @ 1 MeV for LaBr and LaCl
califaHF->SelectGeometryVersion(17);
califaHF->SetAngularWindow(0.25,0.25); //[0.25 around 14.3 degrees, 3.2 for the complete calorimeter]
run->AddTask(califaHF);
}
// ----- Initialize StarTrackHitfinder task ------------------------------------
if(fStarTrackHitFinder) {
R3BSTaRTraHitFinder* trackHF = new R3BSTaRTraHitFinder();
//trackHF->SetClusteringAlgorithm(1,0);
trackHF->SetDetectionThreshold(0.000050); //50 KeV
trackHF->SetExperimentalResolution(0.);
//trackHF->SetAngularWindow(0.15,0.15); //[0.25 around 14.3 degrees, 3.2 for the complete calorimeter]
run->AddTask(trackHF);
}
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------ Increase nb of step for CALO
Int_t nSteps = 150000;
TVirtualMC::GetMC()->SetMaxNStep(nSteps);
// ----- Runtime database ---------------------------------------------
R3BFieldPar* fieldPar = (R3BFieldPar*) rtdb->getContainer("R3BFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(ParFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ----- Start run ----------------------------------------------------
if(nEvents > 0) {
run->Run(nEvents);
}
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << OutFile << endl;
cout << "Parameter file is " << ParFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void run_rad(Int_t nEvents = 100, TString mcEngine="TGeant3")
{
TString dir = gSystem->Getenv("VMCWORKDIR");
TString tutdir = dir + "/rutherford/macros";
TString tut_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
TString outDir = "data";
TString outFile = outDir + "/test1_";
outFile = outFile + mcEngine + ".mc.root";
TString parFile = outDir + "/params1_";
parFile = parFile + mcEngine + ".root";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
FairLogger *logger = FairLogger::GetLogger();
// define log file name
logger->SetLogFileName("MyLog.log");
// log to screen and to file
logger->SetLogToScreen(kTRUE);
logger->SetLogToFile(kTRUE);
// Print very accurate output. Levels are LOW, MEDIUM and HIGH
logger->SetLogVerbosityLevel("HIGH");
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
//----Start the radiation length manager ----------------------------------
run->SetRadLenRegister(kTRUE);
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
FairModule* target= new FairTarget("Target");
target->SetGeometryFileName("target_rutherford.geo");
run->AddModule(target);
FairDetector* rutherford = new FairRutherford("RutherfordDetector", kFALSE);
rutherford->SetGeometryFileName("rutherford.geo");
run->AddModule(rutherford);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
run->SetGenerator(primGen);
FairBoxGenerator* boxGen1 = new FairBoxGenerator(0, 1);
boxGen1->SetPRange(.005,.005);
boxGen1->SetPhiRange(0.,0.);
boxGen1->SetThetaRange(-90.,90.);
boxGen1->SetXYZ(0.,0.,-3.);
primGen->AddGenerator(boxGen1);
// ------------------------------------------------------------------------
run->SetStoreTraj(kTRUE);
// ----- Run initialisation -------------------------------------------
run->Init();
// ------------------------------------------------------------------------
// Set cuts for storing the trajectories.
// Switch this on only if trajectories are stored.
// Choose this cuts according to your needs, but be aware
// that the file size of the output file depends on these cuts
FairTrajFilter* trajFilter = FairTrajFilter::Instance();
// trajFilter->SetStepSizeCut(0.01); // 1 cm
// trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
// trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
// trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
trajFilter->SetStorePrimaries(kTRUE);
trajFilter->SetStoreSecondaries(kTRUE);
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
run->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
}
void he6_sim(Int_t nEvents = 10000, TString mcEngine = "TGeant4")
{
TString dir = getenv("VMCWORKDIR");
// Output file name
TString outFile ="./data/attpcsim.root";
// Parameter file name
TString parFile="./data/attpcpar.root";
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
//gSystem->Load("libAtGen.so");
ATVertexPropagator* vertex_prop = new ATVertexPropagator();
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new AtCave("CAVE");
cave->SetGeometryFileName("cave.geo");
run->AddModule(cave);
FairModule* magnet = new AtMagnet("Magnet");
run->AddModule(magnet);
/*FairModule* pipe = new AtPipe("Pipe");
run->AddModule(pipe);*/
FairDetector* ATTPC = new AtTpc("ATTPC", kTRUE);
ATTPC->SetGeometryFileName("ATTPC_Proto_v1.0.root");
//ATTPC->SetModifyGeometry(kTRUE);
run->AddModule(ATTPC);
// ------------------------------------------------------------------------
// ----- Magnetic field -------------------------------------------
// Constant Field
AtConstField *fMagField = new AtConstField();
fMagField->SetField(0., 0. ,0. ); // values are in kG
fMagField->SetFieldRegion(-50, 50,-50, 50, -10,230); // values are in cm
// (xmin,xmax,ymin,ymax,zmin,zmax)
run->SetField(fMagField);
// --------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
// Beam Information
Int_t z = 2; // Atomic number
Int_t a = 8; // Mass number
Int_t q = 0; // Charge State
Int_t m = 1; // Multiplicity NOTE: Due the limitation of the TGenPhaseSpace accepting only pointers/arrays the maximum multiplicity has been set to 10 particles.
Double_t px = 0.000/a; // X-Momentum / per nucleon!!!!!!
Double_t py = 0.000/a; // Y-Momentum / per nucleon!!!!!!
Double_t pz = 0.504708/a; // Z-Momentum / per nucleon!!!!!!
Double_t BExcEner = 0.0;
Double_t Bmass = 7.483551; //Mass in GeV
Double_t NomEnergy = 17.0; //Nominal Energy of the beam: Only used for cross section calculation (Tracking energy is determined with momentum). TODO: Change this to the energy after the IC
Double_t TargetMass = 3.728401;//Mass in GeV
ATTPCIonGenerator* ionGen = new ATTPCIonGenerator("Ion",z,a,q,m,px,py,pz,BExcEner,Bmass,NomEnergy);
ionGen->SetSpotRadius(0,-100,0);
// add the ion generator
primGen->AddGenerator(ionGen);
//primGen->SetBeam(1,1,0,0); //These parameters change the position of the vertex of every track added to the Primary Generator
// primGen->SetTarget(30,0);
// Variables for 2-Body kinematics reaction
std::vector<Int_t> Zp; // Zp
std::vector<Int_t> Ap; // Ap
std::vector<Int_t> Qp;//Electric charge
Int_t mult; //Number of particles
std::vector<Double_t> Pxp; //Px momentum X
std::vector<Double_t> Pyp; //Py momentum Y
std::vector<Double_t> Pzp; //Pz momentum Z
std::vector<Double_t> Mass; // Masses
std::vector<Double_t> ExE; // Excitation energy
Double_t ResEner; // Energy of the beam (Useless for the moment)
// Note: Momentum will be calculated from the phase Space according to the residual energy of the beam
mult = 4; //Number of Nuclei involved in the reaction (Should be always 4) THIS DEFINITION IS MANDATORY (and the number of particles must be the same)
ResEner = 0.0; // Useless
// ---- Beam ----
Zp.push_back(z); // TRACKID=0
Ap.push_back(a); //
Qp.push_back(q);
Pxp.push_back(px);
Pyp.push_back(py);
Pzp.push_back(pz);
Mass.push_back(Bmass);
ExE.push_back(BExcEner);
// ---- Target ----
Zp.push_back(2); //
Ap.push_back(4); //
Qp.push_back(0); //
Pxp.push_back(0.0);
Pyp.push_back(0.0);
Pzp.push_back(0.0);
Mass.push_back(3.728401);
ExE.push_back(0.0);//In MeV
//--- Scattered -----
Zp.push_back(2); // TRACKID=1
Ap.push_back(6); //
Qp.push_back(0);
Pxp.push_back(0.0);
Pyp.push_back(0.0);
Pzp.push_back(0.0);
Mass.push_back(5.606559);
ExE.push_back(0.0);
// ---- Recoil -----
Zp.push_back(2); // TRACKID=2
Ap.push_back(6); //
Qp.push_back(0); //
Pxp.push_back(0.0);
Pyp.push_back(0.0);
Pzp.push_back(0.0);
Mass.push_back(5.606559);
ExE.push_back(0.0);//In MeV
Double_t ThetaMinCMS = 0.0;
Double_t ThetaMaxCMS = 180.0;
ATTPC2Body* TwoBody = new ATTPC2Body("TwoBody",&Zp,&Ap,&Qp,mult,&Pxp,&Pyp,&Pzp,&Mass,&ExE,ResEner, ThetaMinCMS,ThetaMaxCMS);
primGen->AddGenerator(TwoBody);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
//---Store the visualiztion info of the tracks, this make the output file very large!!
//--- Use it only to display but not for production!
run->SetStoreTraj(kTRUE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
//You can export your ROOT geometry ot a separate file
run->CreateGeometryFile("./data/geofile_proto_full.root");
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
}
void Step0_R3BNeulandSim(
const UInt_t particle_id,
const UInt_t num_events,
const Double_t momentum,
const TString base_name,
const TString base_path = "."
)
{
TStopwatch timer;
timer.Start();
// System paths
const TString working_directory = getenv("VMCWORKDIR");
gSystem->Setenv("GEOMPATH", working_directory + "/geometry");
gSystem->Setenv("CONFIG_DIR", working_directory + "/gconfig");
// Output files
const TString out_file = base_path + "/sim." + base_name + ".root";
const TString par_file = base_path + "/par." + base_name + ".root";
// Basic simulation setup
FairRunSim *run = new FairRunSim();
run->SetName("TGeant3");
run->SetOutputFile(out_file);
run->SetMaterials("media_r3b.geo");
// Geometry: Cave
FairModule *cave = new R3BCave("CAVE");
cave->SetGeometryFileName("r3b_cave.geo");
run->AddModule(cave);
// Geometry: Neuland
R3BDetector *land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(0);
land->SetGeometryFileName("neuland_v12a_14m.geo.root");
run->AddModule(land);
// Primary particle generator
FairBoxGenerator *boxGen = new FairBoxGenerator(particle_id);
boxGen->SetThetaRange(0., 1.);
boxGen->SetPhiRange(0., 360.);
boxGen->SetPRange(momentum, momentum);
boxGen->SetXYZ(0., 0., 0.);
boxGen->SetDebug(1);
FairPrimaryGenerator *primGen = new FairPrimaryGenerator();
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// Further setup options and initialization
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
run->SetStoreTraj(kTRUE);
run->Init();
// Connect runtime parameter file
FairParRootFileIo *par_file_io = new FairParRootFileIo(kTRUE);
par_file_io->open(par_file);
FairRuntimeDb *rtdb = run->GetRuntimeDb();
rtdb->setOutput(par_file_io);
rtdb->saveOutput();
// Simulate
run->Run(num_events);
// Report
timer.Stop();
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << out_file << endl;
cout << "Parameter file is " << par_file << endl;
cout << "Real time " << timer.RealTime() << " s, CPU time " << timer.CpuTime() << "s" << endl << endl;
}
void run_sim_fission(Int_t nEvents = 10, TString mcEngine = "TGeant4")
{
TString dir = getenv("VMCWORKDIR");
// Output file name
TString outFile ="./data/attpcsim_2.root";
// Parameter file name
TString parFile="./data/attpcpar.root";
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
//gSystem->Load("libAtGen.so");
ATVertexPropagator* vertex_prop = new ATVertexPropagator();
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new AtCave("CAVE");
cave->SetGeometryFileName("cave.geo");
run->AddModule(cave);
FairModule* magnet = new AtMagnet("Magnet");
run->AddModule(magnet);
/*FairModule* pipe = new AtPipe("Pipe");
run->AddModule(pipe);*/
FairDetector* ATTPC = new AtTpc("ATTPC", kTRUE);
ATTPC->SetGeometryFileName("ATTPC_v1.1.root");
//ATTPC->SetModifyGeometry(kTRUE);
run->AddModule(ATTPC);
// ------------------------------------------------------------------------
// ----- Magnetic field -------------------------------------------
// Constant Field
AtConstField *fMagField = new AtConstField();
fMagField->SetField(0., 0. ,17.58 ); // values are in kG
fMagField->SetFieldRegion(-50, 50,-50, 50, -10,230); // values are in cm
// (xmin,xmax,ymin,ymax,zmin,zmax)
run->SetField(fMagField);
// --------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
// Beam Information
Int_t z = 18; // Atomic number
Int_t a = 40; // Mass number
Int_t q = 0; // Charge State
Int_t m = 1; // Multiplicity NOTE: Due the limitation of the TGenPhaseSpace accepting only pointers/arrays the maximum multiplicity has been set to 10 particles.
Double_t px = 0.000/a; // X-Momentum / per nucleon!!!!!!
Double_t py = 0.000/a; // Y-Momentum / per nucleon!!!!!!
Double_t pz = 3.663/a; // Z-Momentum / per nucleon!!!!!!
Double_t BExcEner = 0.0;
Double_t Bmass = 37.22472; //Mass in GeV
Double_t NomEnergy = 179.83; //Nominal Energy of the beam: Only used for cross section calculation (Tracking energy is determined with momentum). TODO: Change this to the energy after the IC
Double_t TargetMass = 0.938272;//Mass in GeV
ATTPCIonGenerator* ionGen = new ATTPCIonGenerator("Ion",z,a,q,m,px,py,pz,BExcEner,Bmass,NomEnergy);
ionGen->SetSpotRadius(0,-100,0);
// add the ion generator
primGen->AddGenerator(ionGen);
//primGen->SetBeam(1,1,0,0); //These parameters change the position of the vertex of every track added to the Primary Generator
// primGen->SetTarget(30,0);
ATTPCFissionGenerator* Fission = new ATTPCFissionGenerator("Fission","240Cf.root");
primGen->AddGenerator(Fission);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
//---Store the visualiztion info of the tracks, this make the output file very large!!
//--- Use it only to display but not for production!
run->SetStoreTraj(kTRUE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
//You can export your ROOT geometry ot a separate file
run->CreateGeometryFile("./data/geofile_proto_full.root");
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
}
void run_tutorial4(Int_t nEvents = 10)
{
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/Tutorial4";
TString tut_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/Tutorial4/macros/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
Double_t momentum = 2.;
Double_t theta = 2.;
TString outDir = "./";
// Output file name
TString outFile ="data/testrun.root";
TString parFile ="data/testparams.root";
TList *parFileList = new TList();
TString workDir = gSystem->Getenv("VMCWORKDIR");
paramDir = workDir + "/Tutorial4/macros/parameters/";
TObjString tutDetDigiFile = paramDir + "example.par";
parFileList->Add(&tutDetDigiFile);
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
//Does not work with automatic loading pf libraries. The info is not in the rootmap file
// gLogger->SetLogScreenLevel("INFO");
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName("TGeant3"); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
FairTutorialDet4* tutdet = new FairTutorialDet4("TUTDET", kTRUE);
tutdet->SetGeometryFileName("tutorial4.root");
tutdet->SetModifyGeometry(kTRUE);
run->AddModule(tutdet);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(2212, 1);
boxGen->SetThetaRange ( theta, theta+0.1);
// boxGen->SetThetaRange ( 0., 0.);
boxGen->SetPRange (momentum,momentum+0.01);
boxGen->SetPhiRange (0.,360.);
boxGen->SetBoxXYZ (-20.,-20.,20.,20., 0.);
// boxGen->SetBoxXYZ (0.,0.,0.,0., 0.);
// boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
// ----- Initialize simulation run ------------------------------------
run->SetStoreTraj(kTRUE);
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
FairParAsciiFileIo* parIn = new FairParAsciiFileIo();
parOut->open(parFile.Data());
parIn->open(parFileList, "in");
rtdb->setFirstInput(parIn);
rtdb->setOutput(parOut);
// ------------------------------------------------------------------------
run->Init();
// -Trajectories Visualization (TGeoManager Only )
// -----------------------------------------------
// Set cuts for storing the trajectpries
/* FairTrajFilter* trajFilter = FairTrajFilter::Instance();
trajFilter->SetStepSizeCut(0.01); // 1 cm
trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
trajFilter->SetStorePrimaries(kTRUE);
trajFilter->SetStoreSecondaries(kTRUE);
*/
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
run->CreateGeometryFile("data/geofile_full.root");
// ------------------------------------------------------------------------
rtdb->saveOutput();
rtdb->print();
delete run;
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
// Macro created 03/05/2011 by S.Spataro
// It creates an evtgen simulation for the tracking TDR
run_sim_stt_evt(Int_t nEvents=10, UInt_t seed=0){
gRandom->SetSeed(seed);
TStopwatch timer;
timer.Start();
gDebug=0;
// Load basic libraries
// If it does not work, please check the path of the libs and put it by hands
gROOT->LoadMacro("$VMCWORKDIR/gconfig/rootlogon.C");
rootlogon();
TString digiFile = "all.par";
TString parFile = "evt_params_stt.root";
FairRunSim *fRun = new FairRunSim();
// set the MC version used
// ------------------------
fRun->SetName("TGeant3");
//fRun->SetName("TGeant4");
fRun->SetOutputFile("evt_points_stt.root");
// Set the parameters
//-------------------------------
TString allDigiFile = gSystem->Getenv("VMCWORKDIR");
allDigiFile += "/macro/params/";
allDigiFile += digiFile;
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
parIo1->open(allDigiFile.Data(),"in");
rtdb->setFirstInput(parIo1);
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(parFile);
rtdb->setOutput(output);
// Set Material file Name
//-----------------------
fRun->SetMaterials("media_pnd.geo");
// Create and add detectors
//-------------------------
FairModule *Cave= new PndCave("CAVE");
Cave->SetGeometryFileName("pndcave.geo");
fRun->AddModule(Cave);
FairModule *Magnet= new PndMagnet("MAGNET");
//Magnet->SetGeometryFileName("FullSolenoid_V842.root");
Magnet->SetGeometryFileName("FullSuperconductingSolenoid_v831.root");
fRun->AddModule(Magnet);
FairModule *Dipole= new PndMagnet("MAGNET");
Dipole->SetGeometryFileName("dipole.geo");
fRun->AddModule(Dipole);
FairModule *Pipe= new PndPipe("PIPE");
fRun->AddModule(Pipe);
FairDetector *Stt= new PndStt("STT", kTRUE);
Stt->SetGeometryFileName("straws_skewed_blocks_35cm_pipe.geo");
fRun->AddModule(Stt);
FairDetector *Mvd = new PndMvdDetector("MVD", kTRUE);
Mvd->SetGeometryFileName("Mvd-2.1_FullVersion.root");
fRun->AddModule(Mvd);
PndEmc *Emc = new PndEmc("EMC",kTRUE);
Emc->SetGeometryVersion(2);
Emc->SetStorageOfData(kFALSE);
fRun->AddModule(Emc);
PndMdt *Muo = new PndMdt("MDT",kTRUE);
Muo->SetBarrel("fast");
Muo->SetEndcap("fast");
Muo->SetMuonFilter("fast");
Muo->SetMdtMagnet(kTRUE);
Muo->SetMdtMFIron(kTRUE);
fRun->AddModule(Muo);
FairDetector *Gem = new PndGemDetector("GEM", kTRUE);
Gem->SetGeometryFileName("gem_3Stations.root");
fRun->AddModule(Gem);
PndDsk* Dsk = new PndDsk("DSK", kTRUE);
Dsk->SetGeometryFileName("dsk.root");
Dsk->SetStoreCerenkovs(kFALSE);
Dsk->SetStoreTrackPoints(kFALSE);
fRun->AddModule(Dsk);
PndDrc *Drc = new PndDrc("DIRC", kTRUE);
Drc->SetGeometryFileName("dirc_l0_p0.root");
Drc->SetRunCherenkov(kFALSE); // for fast sim Cherenkov -> kFALSE
fRun->AddModule(Drc);
FairDetector *Fts= new PndFts("FTS", kTRUE);
Fts->SetGeometryFileName("fts.geo");
fRun->AddModule(Fts);
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
primGen->SetTarget(0., 0.5/2.355);
primGen->SmearVertexZ(kTRUE);
primGen->SmearGausVertexZ(kTRUE);
primGen->SetBeam(0., 0., 0.1, 0.1);
primGen->SmearVertexXY(kTRUE);
fRun->SetGenerator(primGen);
// ... generate your signal on the fly
PndEvtGenDirect *EvtGen = new PndEvtGenDirect("pbarpSystem","EtaCInclusive_2phi.dec",3.6772);
EvtGen->SetStoreTree(kFALSE);
primGen->AddGenerator(EvtGen);
// Create and Set Magnetic Field
//-------------------------------
fRun->SetBeamMom(3.6772);
PndMultiField *fField= new PndMultiField("FULL");
fRun->SetField(fField);
// EMC Hit producer
//-------------------------------
PndEmcHitProducer* emcHitProd = new PndEmcHitProducer();
fRun->AddTask(emcHitProd);
/**Initialize the session*/
fRun->Init();
rtdb->setOutput(output);
rtdb->saveOutput();
rtdb->print();
// Transport nEvents
// -----------------
fRun->Run(nEvents);
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
printf("RealTime=%f seconds, CpuTime=%f seconds\n",rtime,ctime);
}
void run_CbmIonGenerator(Int_t nEvents = 1)
{
// ========================================================================
// Adjust this part according to your requirements
// Input file
//TString inPath = "/d/cbm03/urqmd/auau/25gev/centr/";
//TString inFile = inPath + "urqmd.auau.25gev.centr.0000.ftn14";
// Output file
TString outFile = Form("sts.mc.root",nEvents);
// Parameter file
TString parFile = Form("params.root",nEvents);
// Cave geometry
TString caveGeom = "cave.geo";
// Target geometry
TString targetGeom = "target_au_250mu.geo";
// Beam pipe geometry
TString pipeGeom = "pipe_standard.geo";
// Magnet geometry and field map
TString magnetGeom = "passive/magnet_v09e.geo";
TString fieldMap = "field_v10e";
Double_t fieldZ = 50.; // z position of field centre
Double_t fieldScale = 1.; // field scaling factor
// MVD geometry
TString mvdGeom = "mvd/mvd_v07a.geo";
// STS geometry
TString stsGeom = "sts/sts_v11a.geo";
//STS geometry for the same z position of all sensors
//TString stsGeom = "sts_same_z.geo";
targetGeom = "";
magnetGeom = "";
stsGeom = "";
mvdGeom = "";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libCbmBase");
gSystem->Load("libCbmData");
gSystem->Load("libField");
gSystem->Load("libGen");
gSystem->Load("libPassive");
gSystem->Load("libMvd");
gSystem->Load("libSts");
gSystem->Load("libCbmGenerators"); // for CbmIonGenerator
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName("TGeant3"); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
run->AddModule(cave);
FairModule* pipe= new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
run->AddModule(pipe);
if( targetGeom != "") {
FairModule* target= new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
run->AddModule(target);
}
if( magnetGeom != "") {
FairModule* magnet= new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
run->AddModule(magnet);
}
if( mvdGeom != ""){
FairDetector* mvd= new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
run->AddModule(mvd);
}
if( stsGeom != "") {
FairDetector* sts= new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
run->AddModule(sts);
}
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
if(magnetGeom!="") {
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
run->SetField(magField);
}
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
//FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile);
//primGen->AddGenerator(urqmdGen);
// CbmIonGenerator - check in Load libraries: gSystem->Load("libCbmGenerators");
Int_t nions=10; // number of ions/event
cout<<"@@@@@> CbmIonGenerator is ON with "<<nions<<" ion(s)/event !!!"<<endl;
Int_t z=79, a=197, q=79; // Au-ion
Double_t p=8.; // in AGeV/c
Double_t vz=-0.0126; // in cm - z-pos. of vertex
Double_t meanX=0.3; // in cm - spatial distr. (XOY)
Double_t meanY=-0.2; // in cm
Double_t sigmaX = 0.078; // in cm - spatial distr. (XOY)
Double_t sigmaY = 0.032; // in cm
Double_t sigmatX = 0.00117885; // in rad (Px/P) - angular distr. (mean=0)
Double_t sigmatY = 0.00094955; // in rad (Py/P)
// Parameters of the trapezoid are set with respect to mean of Gaussian, NOT necesseraly in absolute coordinates.
// x1 < x2 < 0 < x3 < x4
Double_t x1=-0.10452, x2=-0.06942, x3=0.06942, x4=0.10452; // in cm - trapezoid distr.
Double_t y1=-0.04448, y2=-0.02688, y3=0.02688, y4=0.04448; // in cm
Double_t tX1=-0.00157966, tX2=-0.001049177, tX3=0.001049177, tX4=0.00157966; // in rad
Double_t tY1=-0.00131987, tY2=-0.000797622, tY3=0.000797622, tY4=0.00131987; // in rad
// CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY);
// CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz);
CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz,
x1, x2, x3, x4, y1, y2, y3, y4, tX1, tX2, tX3, tX4, tY1, tY2, tY3, tY4);
primGen->AddGenerator(IonGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
// run->SetStoreTraj(kTRUE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
if(magnetGeom!="") {
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(run->GetRunId(),1);
}
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
//run->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
exit(0);
}
void makeDummy(const Int_t nEvents = 10)
{
gRandom -> SetSeed(time(0));
//TString dir = gSystem->Getenv("SPIRITDIR");
//TString geomdir = dir + "/geometry";
//gSystem->Setenv("GEOMPATH", geomdir.Data());
FairLogger *logger = FairLogger::GetLogger();
logger->SetLogToScreen(kTRUE);
logger->SetLogVerbosityLevel("MEDIUM");
TString outFile = "mc.dummy.root";
TString parFile = "param.dummy.root";
// ----- Create simulation run ----------------------------------------
//
FairRunSim* run = new FairRunSim();
run->SetName("TGeant4"); // Transport engine
run->SetOutputFile(outFile); // Output file
run->SetWriteRunInfoFile(kFALSE);
FairRuntimeDb* rtdb = run->GetRuntimeDb();
ATVertexPropagator* vertex_prop = new ATVertexPropagator();
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
/*FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
FairModule* target= new FairTarget("SnTarget");
target->SetGeometryFileName("target.geo");
run->AddModule(target);
FairDetector* spirit = new STDetector("STDetector", kTRUE);
spirit->SetGeometryFileName("spirit_v03.1.root");
run->AddModule(spirit);*/
FairModule* cave= new AtCave("CAVE");
cave->SetGeometryFileName("cave.geo");
run->AddModule(cave);
FairModule* magnet = new AtMagnet("Magnet");
run->AddModule(magnet);
FairModule* pipe = new AtPipe("Pipe");
run->AddModule(pipe);
FairDetector* ATTPC = new AtTpc("ATTPC", kTRUE);
ATTPC->SetGeometryFileName("ATTPC_v1.1.root");
//ATTPC->SetModifyGeometry(kTRUE);
run->AddModule(ATTPC);
// ------------------------------------------------------------------------
run->SetMaterials("media.geo");
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator *primGen = new FairPrimaryGenerator();
FairParticleGenerator *particleGen = new FairParticleGenerator(2112, 1, 0, 0, 0, 0, 0, 0);
primGen->AddGenerator(particleGen);
run->SetGenerator(primGen);
/*
Int_t dnum=7;
const int gennum=pid[dnum].size();
cout << gennum << endl;
FairParticleGenerator *fIongen[gennum];
for (Int_t i=0; i<gennum; i++) {
fIongen[i] = new FairParticleGenerator(pid[dnum][i],1,pxl[dnum][i],pyl[dnum][i],pzl[dnum][i],0.0,-21.33,-3.52);
//cout << pid[dnum][i] << "\t" << pxl[dnum][i] << "\t" << pyl[dnum][i] << "\t" << pzl[dnum][i] << "\t" << kinl[dnum][i] << endl;
primGen->AddGenerator(fIongen[i]);
}
//primGen->AddTrack(pdg,pionpC[0][i],pionpC[1][i],pionpC[2][i],pionrC[0][i]*1.0E-13,pionrC[1][i]*1.0E-13-21.33,pionrC[2][i]*1.0E-13-3.52);
//fIongen[i] = new FairParticleGenerator(pdg,1,pionpC[0][i],pionpC[1][i],pionpC[2][i],pionrC[0][i]*1.0E-13,pionrC[1][i]*1.0E-13-21.33,pionrC[2][i]*1.0E-13-3.52);
//fIongen[i] = new FairParticleGenerator(pdg,1,px,py,pz,0.0,-21.33,-3.52);
//primGen->AddGenerator(fIongen[i]);
//primGen->AddTrack(pdg,pionpC[0][i],pionpC[1][i],pionpC[2][i],pionrC[0][i]*1.0E-13,pionrC[1][i]*1.0E-13-21.33,pionrC[2][i]*1.0E-13-3.52);
//}
//}
// if (partt==0) FairBoxGenerator* boxGen1 = new FairBoxGenerator(2212, 1);
// if (partt==1) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000010020, 1);
// if (partt==2) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000010030, 1);
// if (partt==3) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000020030, 1);
// if (partt==4) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000020040, 1);
// if (partt==5) FairBoxGenerator* boxGen1 = new FairBoxGenerator(211, 1);
// if (partt==6) FairBoxGenerator* boxGen1 = new FairBoxGenerator(-211, 1);
// if (partt==7) FairBoxGenerator* boxGen1 = new FairBoxGenerator(11, 1);
// if (partt==8) FairBoxGenerator* boxGen1 = new FairBoxGenerator(-11, 1);
// //FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000020040, 1);
// boxGen1->SetPRange(0.25,0.5); //GeV/c ??
// boxGen1->SetPhiRange(0.,360.); //degrees
// boxGen1->SetThetaRange(0.,90.); //degrees
// boxGen1->SetXYZ(0.,-21.33, -3.52); // cm
// primGen->AddGenerator(boxGen1);
// ------------------------------------------------------------------------
run->SetStoreTraj(kTRUE);
*/
// ----- Run initialisation -------------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ----- Finish -------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_tutorial1_mesh(Int_t nEvents = 10, TString mcEngine = "TGeant3")
{
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/Tutorial1";
TString tut_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
TString partName[] = {"pions","eplus","proton"};
Int_t partPdgC[] = { 211, 11, 2212};
Int_t chosenPart = 0;
Double_t momentum = 2.;
Double_t theta = 0.;
TString outDir = "./";
// Output file name
TString outFile = Form("%s/tutorial1_mesh%s_%s.mc_p%1.3f_t%1.0f_n%d.root",
outDir.Data(),
mcEngine.Data(),
partName[chosenPart].Data(),
momentum,
theta,
nEvents);
// Parameter file name
TString parFile = Form("%s/tutorial1_mesh%s_%s.params_p%1.3f_t%1.0f_n%d.root",
outDir.Data(),
mcEngine.Data(),
partName[chosenPart].Data(),
momentum,
theta,
nEvents);
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
FairDetector* tutdet = new FairTutorialDet1("TUTDET", kTRUE);
tutdet->SetGeometryFileName("double_sector.geo");
run->AddModule(tutdet);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 1);
boxGen->SetThetaRange ( theta, theta+0.01);
boxGen->SetPRange (momentum,momentum+0.01);
boxGen->SetPhiRange (0.,360.);
boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
run->SetStoreTraj(kFALSE); // to store particle trajectories
run->SetRadGridRegister(kTRUE); // activate RadGridManager
// define two example meshs for dosimetry
FairMesh* aMesh1 = new FairMesh("test1");
aMesh1->SetX(-40,40,200);
aMesh1->SetY(-40,40,200);
aMesh1->SetZ(5.2,5.4,1);
FairMesh* aMesh2 = new FairMesh("test2");
aMesh2->SetX(-20,20,20);
aMesh2->SetY(-20,20,20);
aMesh2->SetZ(-5.0,5.0,1);
aMesh1->print();
aMesh2->print();
run->AddMesh( aMesh1 );
run->AddMesh( aMesh2 );
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
void global_sim(Int_t nEvents = 10, Int_t seed = 555)
{
gRandom->SetSeed(seed);
TString script = TString(gSystem->Getenv("LIT_SCRIPT"));
// Files
// TString urqmdFile = "/Users/andrey/Development/cbm/d/urqmd/auau/25gev/centr/urqmd.auau.25gev.centr.0000.ftn14"; // input UrQMD file
TString urqmdFile = "../../input/urqmd.auau.25gev.centr.0000.ftn14"; // input UrQMD file
TString dir = "data/"; // Directory for output simulation files
TString mcFile = dir + "mc.0000.root"; //MC file name
TString parFile = dir + "param.0000.root"; //Parameter file name
// Geometry
TString caveGeom = "cave.geo";
TString targetGeom = "target_au_250mu.geo";
TString pipeGeom = "pipe_standard.geo";
TString stsGeom = "sts/sts_v12b.geo.root";
TString richGeom = "rich/rich_v08a.geo";
TString tofGeom = "tof/tof_V13b.geo";
TString fieldMap = "field_v12a";
TString magnetGeom = "passive/magnet_v12a.geo";
// If SCRIPT environment variable is set to "yes", i.e. macro is run via script
if (script == "yes") {
urqmdFile = TString(gSystem->Getenv("LIT_URQMD_FILE"));
mcFile = TString(gSystem->Getenv("LIT_MC_FILE"));
parFile = TString(gSystem->Getenv("LIT_PAR_FILE"));
}
// ----- Magnetic field -----------------------------------------------
Double_t fieldZ = 50.; // field center z position
Double_t fieldScale = 1.; // field scaling factor
TStopwatch timer;
timer.Start();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C");
loadlibs();
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3"); // Transport engine
fRun->SetOutputFile(mcFile); // Output file
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
fRun->SetMaterials("media.geo"); // Materials
// fRun->SetStoreTraj(kTRUE);
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
cout << " --- " << caveGeom << endl;
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
cout << " --- " << pipeGeom << endl;
}
if ( targetGeom != "" ) {
FairModule* target = new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
fRun->AddModule(target);
cout << " --- " << targetGeom << endl;
}
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
cout << " --- " << magnetGeom << endl;
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
fRun->AddModule(sts);
cout << " --- " << stsGeom << endl;
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
fRun->AddModule(rich);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
fRun->AddModule(tof);
cout << " --- " << tofGeom << endl;
}
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ------------------------------------------------------------------------
CbmMCEventHeader* mcHeader = new CbmMCEventHeader();
fRun->SetMCEventHeader(mcHeader);
// ------------------------------------------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
// CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(urqmdFile);
CbmUrqmdGenerator* urqmdGen = new CbmUrqmdGenerator(urqmdFile);
primGen->AddGenerator(urqmdGen);
fRun->SetGenerator(primGen);
fRun->Init();
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
fRun->Run(nEvents);
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished successfully." << endl;
cout << "Test passed"<< endl;
cout << " All ok " << endl;
cout << "Output file is " << mcFile << endl;
cout << "Real time used: " << rtime << "s " << endl;
cout << "CPU time used : " << ctime << "s " << endl << endl << endl;
// ------------------------------------------------------------------------
}
void r3ball_batch(Int_t nEvents = 1,
TObjArray& fDetList,
TString Target = "LeadTarget",
Bool_t fVis=kFALSE,
TString fMC="TGeant3",
TString fGenerator="box",
Bool_t fUserPList= kFALSE,
Bool_t fR3BMagnet= kTRUE,
Double_t fEnergyP=1.0,
Int_t fMult=1,
Int_t fGeoVer=5,
Double_t fNonUni=1.0
)
{
TString dir = getenv("VMCWORKDIR");
TString r3bdir = dir + "/macros";
TString r3b_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",r3b_geomdir.Data());
TString r3b_confdir = dir + "gconfig";
gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data());
// Output files
TString OutFile = "r3bsim.root";
TString ParFile = "r3bpar.root";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(fMC.Data()); // Transport engine
run->SetOutputFile(OutFile.Data()); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// R3B Special Physics List in G4 case
if ( (fUserPList == kTRUE ) &&
(fMC.CompareTo("TGeant4") == 0)
){
run->SetUserConfig("g4R3bConfig.C");
run->SetUserCuts("SetR3BCuts.C");
}
// ----- Create media -------------------------------------------------
run->SetMaterials("media_r3b.geo"); // Materials
// Magnetic field map type
Int_t fFieldMap = 0;
// Global Transformations
//- Two ways for a Volume Rotation are supported
//-- 1) Global Rotation (Euler Angles definition)
//-- This represent the composition of : first a rotation about Z axis with
//-- angle phi, then a rotation with theta about the rotated X axis, and
//-- finally a rotation with psi about the new Z axis.
Double_t phi,theta,psi;
//-- 2) Rotation in Ref. Frame of the Volume
//-- Rotation is Using Local Ref. Frame axis angles
Double_t thetaX,thetaY,thetaZ;
//- Global Translation Lab. frame.
Double_t tx,ty,tz;
// - Polar angular limits
Double_t minTheta=35., maxTheta=55.;
// ----- Create R3B geometry --------------------------------------------
//R3B Cave definition
FairModule* cave= new R3BCave("CAVE");
cave->SetGeometryFileName("r3b_cave.geo");
run->AddModule(cave);
//R3B Target definition
if (fDetList.FindObject("TARGET") ) {
R3BModule* target= new R3BTarget(Target.Data());
// Global Lab. Rotation
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
//target->SetRotAnglesEuler(phi,theta,psi);
target->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
target->SetTranslation(tx,ty,tz);
run->AddModule(target);
}
//R3B Magnet definition
if (fDetList.FindObject("ALADIN") ) {
fFieldMap = 0;
R3BModule* mag = new R3BMagnet("AladinMagnet");
mag->SetGeometryFileName("aladin_v13a.geo.root");
run->AddModule(mag);
}
//R3B Magnet definition
if (fDetList.FindObject("GLAD") ) {
fFieldMap = 1;
R3BModule* mag = new R3BGladMagnet("GladMagnet");
// Global position of the Module
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
//mag->SetRotAnglesEuler(phi,theta,psi);
mag->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
mag->SetTranslation(tx,ty,tz);
run->AddModule(mag);
}
if (fDetList.FindObject("CRYSTALBALL") ) {
//R3B Crystal Calorimeter
R3BDetector* xball = new R3BXBall("XBall", kTRUE);
xball->SetGeometryFileName("cal_v13a.geo.root");
run->AddModule(xball);
}
if (fDetList.FindObject("CALIFA") ) {
// CALIFA Calorimeter
R3BDetector* calo = new R3BCalo("Califa", kTRUE);
((R3BCalo *)calo)->SelectGeometryVersion(10);
//Selecting the Non-uniformity of the crystals (1 means +-1% max deviation)
((R3BCalo *)calo)->SetNonUniformity(1.0);
calo->SetGeometryFileName("califa_v13_811.geo.root");
run->AddModule(calo);
}
// Tracker
if (fDetList.FindObject("TRACKER") ) {
R3BDetector* tra = new R3BTra("Tracker", kTRUE);
// Global position of the Module
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
//tra->SetRotAnglesEuler(phi,theta,psi);
tra->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
tra->SetTranslation(tx,ty,tz);
// User defined Energy CutOff
Double_t fCutOffSi = 1.0e-06; // Cut-Off -> 10KeV only in Si
((R3BTra*) tra)->SetEnergyCutOff(fCutOffSi);
run->AddModule(tra);
}
// DCH drift chambers
if (fDetList.FindObject("DCH") ) {
R3BDetector* dch = new R3BDch("Dch", kTRUE);
((R3BDch*) dch )->SetHeliumBag(kTRUE);
// Global position of the Module
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
//dch->SetRotAnglesEuler(phi,theta,psi);
dch->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
dch->SetTranslation(tx,ty,tz);
run->AddModule(dch);
}
// Tof
if (fDetList.FindObject("TOF") ) {
R3BDetector* tof = new R3BTof("Tof", kTRUE);
// Global position of the Module
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
tof->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
tof->SetTranslation(tx,ty,tz);
// User defined Energy CutOff
Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci.
((R3BTof*) tof)->SetEnergyCutOff(fCutOffSci);
run->AddModule(tof);
}
// mTof
if (fDetList.FindObject("MTOF") ) {
R3BDetector* mTof = new R3BmTof("mTof", kTRUE);
// Global position of the Module
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
//mTof->SetRotAnglesEuler(phi,theta,psi);
mTof->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
mTof->SetTranslation(tx,ty,tz);
// User defined Energy CutOff
Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci.
((R3BmTof*) mTof)->SetEnergyCutOff(fCutOffSci);
run->AddModule(mTof);
}
// GFI detector
if (fDetList.FindObject("GFI") ) {
R3BDetector* gfi = new R3BGfi("Gfi", kTRUE);
// Global position of the Module
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
gfi->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
gfi->SetTranslation(tx,ty,tz);
// User defined Energy CutOff
Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci.
((R3BGfi*) gfi)->SetEnergyCutOff(fCutOffSci);
run->AddModule(gfi);
}
// Land Detector
if (fDetList.FindObject("LAND") ) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetGeometryFileName("land_v12a_10m.geo.root");
run->AddModule(land);
}
// Chimera
if (fDetList.FindObject("CHIMERA") ) {
R3BDetector* chim = new R3BChimera("Chimera", kTRUE);
chim->SetGeometryFileName("chimera.root");
// Global position of the Module
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
chim->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
chim->SetTranslation(tx,ty,tz);
// User defined Energy CutOff
//Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci.
//((R3BChimera*) chim)->SetEnergyCutOff(fCutOffSci);
run->AddModule(chim);
}
// Luminosity detector
if (fDetList.FindObject("LUMON") ) {
R3BDetector* lumon = new ELILuMon("LuMon", kTRUE);
//lumon->SetGeometryFileName("lumon.root");
// Global position of the Module
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 200.0; // (cm)
lumon->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
lumon->SetTranslation(tx,ty,tz);
// User defined Energy CutOff
//Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci.
//((ELILuMon*) lumon)->SetEnergyCutOff(fCutOffSci);
run->AddModule(lumon);
}
// ----- Create R3B magnetic field ----------------------------------------
Int_t typeOfMagneticField = 0;
Int_t fieldScale = 1;
Bool_t fVerbose = kFALSE;
//NB: <D.B>
// If the Global Position of the Magnet is changed
// the Field Map has to be transformed accordingly
if (fFieldMap == 0) {
R3BFieldMap* magField = new R3BFieldMap(typeOfMagneticField,fVerbose);
magField->SetPosition(0., 0., 0.);
magField->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} else if(fFieldMap == 1){
R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap");
magField->SetPosition(0., 0., +350-119.94);
magField->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} //! end of field map section
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (fGenerator.CompareTo("box") == 0 ) {
// 2- Define the BOX generator
Double_t pdgId=211; // pion beam
Double_t theta1= 0.; // polar angle distribution
Double_t theta2= 7.;
Double_t momentum=.8; // 10 GeV/c
FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 50);
boxGen->SetThetaRange ( theta1, theta2);
boxGen->SetPRange (momentum,momentum*2.);
boxGen->SetPhiRange (0.,360.);
boxGen->SetXYZ(0.0,0.0,-1.5);
// add the box generator
primGen->AddGenerator(boxGen);
}
if (fGenerator.CompareTo("gammas") == 0 ) {
// 2- Define the CALIFA Test gamma generator
Double_t pdgId=22; // 22 for gamma emission, 2212 for proton emission
Double_t theta1=minTheta; // polar angle distribution: lower edge
Double_t theta2=maxTheta; // polar angle distribution: upper edge
Double_t momentum=fEnergyP; // GeV/c
//Double_t momentum=0.808065; // 0.808065 GeV/c (300MeV Kin Energy for protons)
//Double_t momentum=0.31016124; // 0.31016124 GeV/c (50MeV Kin Energy for protons)
//Double_t momentum=0.4442972; // 0.4442972 GeV/c (100MeV Kin Energy for protons)
//Double_t momentum=0.5509999; // 0.5509999 GeV/c (150MeV Kin Energy for protons)
//Double_t momentum=0.64405; // 0.64405 GeV/c (200MeV Kin Energy for protons)
Int_t multiplicity = fMult;
R3BCALIFATestGenerator* gammasGen = new R3BCALIFATestGenerator(pdgId, multiplicity);
gammasGen->SetThetaRange(theta1,theta2);
gammasGen->SetCosTheta();
gammasGen->SetPRange(momentum,momentum);
gammasGen->SetPhiRange(0.,360.);
gammasGen->SetBoxXYZ(-0.1,0.1,-0.1,0.1,-0.1,0.1);
gammasGen->SetLorentzBoost(0.8197505718204776); //beta=0.81975 for 700 A MeV
// add the gamma generator
primGen->AddGenerator(gammasGen);
}
if (fGenerator.CompareTo("r3b") == 0 ) {
R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator();
// R3bGen properties
pR3bGen->SetBeamInteractionFlag("off");
pR3bGen->SetBeamInteractionFlag("off");
pR3bGen->SetRndmFlag("off");
pR3bGen->SetRndmEneFlag("off");
pR3bGen->SetBoostFlag("off");
pR3bGen->SetReactionFlag("on");
pR3bGen->SetGammasFlag("off");
pR3bGen->SetDecaySchemeFlag("off");
pR3bGen->SetDissociationFlag("off");
pR3bGen->SetBackTrackingFlag("off");
pR3bGen->SetSimEmittanceFlag("off");
// R3bGen Parameters
pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV
pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV
pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code
pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV
Int_t fMultiplicity = 50;
pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult.
// Reaction type
// 1: "Elas"
// 2: "iso"
// 3: "Trans"
pR3bGen->SetReactionType("Elas");
// Target type
// 1: "LeadTarget"
// 2: "Parafin0Deg"
// 3: "Parafin45Deg"
// 4: "LiH"
pR3bGen->SetTargetType(Target.Data());
Double_t thickness = (0.11/2.)/10.; // cm
pR3bGen->SetTargetHalfThicknessPara(thickness); // cm
pR3bGen->SetTargetThicknessLiH(3.5); // cm
pR3bGen->SetTargetRadius(1.); // cm
pR3bGen->SetSigmaXInEmittance(1.); //cm
pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm
// Dump the User settings
pR3bGen->PrintParameters();
primGen->AddGenerator(pR3bGen);
}
run->SetGenerator(primGen);
//-------Set visualisation flag to true------------------------------------
if (fVis==kTRUE){
run->SetStoreTraj(kTRUE);
}else{
run->SetStoreTraj(kFALSE);
}
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------ Increase nb of step for CALO
Int_t nSteps = -15000;
gMC->SetMaxNStep(nSteps);
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(ParFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ----- Start run ----------------------------------------------------
if (nEvents>0) run->Run(nEvents);
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << OutFile << endl;
cout << "Parameter file is " << ParFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void run_sim_tpc(Int_t nEvents = 10, TString mcEngine = "TGeant3")
{
TString dir = getenv("VMCWORKDIR");
TString geom_dir = dir + "/Detectors/Geometry/";
gSystem->Setenv("GEOMPATH",geom_dir.Data());
TString tut_configdir = dir + "/Detectors/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
// Output file name
char fileout[100];
sprintf(fileout, "AliceO2_%s.tpc.mc_%i_event.root", mcEngine.Data(), nEvents);
TString outFile = fileout;
// Parameter file name
char filepar[100];
sprintf(filepar, "AliceO2_%s.tpc.params_%i.root", mcEngine.Data(), nEvents);
TString parFile = filepar;
// In general, the following parts need not be touched
// Debug option
gDebug = 0;
// Timer
TStopwatch timer;
timer.Start();
// Create simulation run
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// Create media
run->SetMaterials("media.geo"); // Materials
// Create geometry
AliceO2::Passive::Cave* cave = new AliceO2::Passive::Cave("CAVE");
cave->SetGeometryFileName("cave.geo");
run->AddModule(cave);
// ===| Add TPC |============================================================
AliceO2::TPC::Detector* tpc = new AliceO2::TPC::Detector("TPC", kTRUE);
tpc->SetGeoFileName("TPCGeometry.root");
run->AddModule(tpc);
// Create PrimaryGenerator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(2212, 1); /*protons*/
//boxGen->SetThetaRange(0.0, 90.0);
boxGen->SetEtaRange(-0.9,0.9);
boxGen->SetPRange(100, 100.01);
boxGen->SetPhiRange(0., 360.);
boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// store track trajectories
// run->SetStoreTraj(kTRUE);
// Initialize simulation run
run->Init();
// Runtime database
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// Start run
run->Run(nEvents);
// run->CreateGeometryFile("geofile_full.root");
// Finish
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl;
}
// Macro created 20/09/2006 by S.Spataro
// It creates a geant simulation file for emc
run_sim_tpc_dpm(Int_t nEvents=10, Float_t mom = 3.6772, Int_t mode =1, UInt_t seed=0){
gRandom->SetSeed(seed);
TStopwatch timer;
timer.Start();
gDebug=0;
// Load basic libraries
// If it does not work, please check the path of the libs and put it by hands
gROOT->LoadMacro("$VMCWORKDIR/gconfig/rootlogon.C");
rootlogon();
TString digiFile = "all.par";
TString parFile = "dpm_params_tpc.root";
TString mcMode = "TGeant3";
FairRunSim *fRun = new FairRunSim();
// set the MC version used
// ------------------------
fRun->SetName(mcMode);
fRun->SetOutputFile("dpm_points_tpc.root");
// Set the parameters
//-------------------------------
TString allDigiFile = gSystem->Getenv("VMCWORKDIR");
allDigiFile += "/macro/params/";
allDigiFile += digiFile;
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
parIo1->open(allDigiFile.Data(),"in");
rtdb->setFirstInput(parIo1);
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(parFile);
rtdb->setOutput(output);
// Set Material file Name
//-----------------------
fRun->SetMaterials("media_pnd.geo");
// Create and add detectors
//-------------------------
FairModule *Cave= new PndCave("CAVE");
Cave->SetGeometryFileName("pndcave.geo");
fRun->AddModule(Cave);
FairModule *Magnet= new PndMagnet("MAGNET");
//Magnet->SetGeometryFileName("FullSolenoid_V842.root");
Magnet->SetGeometryFileName("FullSuperconductingSolenoid_v831.root");
fRun->AddModule(Magnet);
FairModule *Pipe= new PndPipe("PIPE");
fRun->AddModule(Pipe);
PndTpcDetector *Tpc = new PndTpcDetector("TPC", kTRUE);
Tpc->SetGeometryFileName("TPC_V1.1.root"); //new ROOT geometry
if(mcMode=="TGeant3") Tpc->SetAliMC();
fRun->AddModule(Tpc);
FairDetector *Mvd = new PndMvdDetector("MVD", kTRUE);
Mvd->SetGeometryFileName("Mvd-2.1_FullVersion.root");
fRun->AddModule(Mvd);
PndEmc *Emc = new PndEmc("EMC",kFALSE);
Emc->SetGeometryVersion(19);
Emc->SetStorageOfData(kFALSE);
fRun->AddModule(Emc);
//PndMdt *Muo = new PndMdt("MDT",kTRUE);
//Muo->SetMdtMagnet(kTRUE);
// Muo->SetMdtMFIron(kFALSE);
//Muo->SetMdtCoil(kTRUE);
//Muo->SetBarrel("muon_TS_barrel_strip_v1_noGeo.root");
//Muo->SetEndcap("muon_TS_endcap_strip_v1_noGeo.root");
//Muo->SetForward("muon_Forward_strip_v1_noGeo.root");
//Muo->SetMuonFilter("muon_MuonFilter_strip_v1_noGeo.root");
//fRun->AddModule(Muo);
FairDetector *Gem = new PndGemDetector("GEM", kTRUE);
Gem->SetGeometryFileName("gem_3Stations.root");
fRun->AddModule(Gem);
PndDsk* Dsk = new PndDsk("DSK", kFALSE);
Dsk->SetGeometryFileName("dsk.root");
Dsk->SetStoreCerenkovs(kFALSE);
Dsk->SetStoreTrackPoints(kFALSE);
fRun->AddModule(Dsk);
PndDrc *Drc = new PndDrc("DIRC", kFALSE);
Drc->SetGeometryFileName("dirc_l0_p0.root");
Drc->SetRunCherenkov(kFALSE); // for fast sim Cherenkov -> kFALSE
fRun->AddModule(Drc);
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
primGen->SetTarget(0., 0.5/2.355);
primGen->SmearVertexZ(kTRUE);
primGen->SmearGausVertexZ(kTRUE);
primGen->SetBeam(0., 0., 0.1, 0.1);
primGen->SmearVertexXY(kTRUE);
fRun->SetGenerator(primGen);
PndDpmDirect *dpmGen = new PndDpmDirect(mom,mode, gRandom->GetSeed());
primGen->AddGenerator(dpmGen);
// Create and Set Magnetic Field
//-------------------------------
fRun->SetBeamMom(mom);
PndMultiField *fField= new PndMultiField("FULL");
fRun->SetField(fField);
/**Initialize the session*/
fRun->Init();
rtdb->setOutput(output);
rtdb->saveOutput();
rtdb->print();
// Transport nEvents
// -----------------
fRun->Run(nEvents);
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
printf("RealTime=%f seconds, CpuTime=%f seconds\n",rtime,ctime);
}
emc_complete(Int_t nEvents = 10, Float_t mom = 1., Int_t charge = 1,
TString phys_list, Bool_t full_panda,
TString out_dat, TString out_par){
TStopwatch timer;
timer.Start();
gDebug=0;
// Load basic libraries
// If it does not work, please check the path of the libs and put it by hands
gROOT->LoadMacro("$VMCWORKDIR/gconfig/rootlogon.C");
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
rootlogon();
basiclibs();
//gSystem->ListLibraries();
FairRunSim *fRun = new FairRunSim();
// set the MC version used
// ------------------------
Bool_t G3 = strncmp(phys_list.Data(),"G3_",3)==0;
cout << "Setting up MC engine to " << (G3?"TGeant3":"TGeant4") << " with " << (full_panda?"full PANDA":"EMCal only")<< endl;
fRun->SetName(G3?"TGeant3":"TGeant4");
fRun->SetOutputFile(out_dat);
/**Get the run time data base for this session and set the needed input*/
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
/**Set the digitization parameters */
TString emcDigiFile = gSystem->Getenv("VMCWORKDIR");
emcDigiFile += "/macro/params/emc.par";
FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
parIo1->open(emcDigiFile.Data(),"in");
rtdb->setFirstInput(parIo1);
/**Parameters created for this simulation goes to the out put*/
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(out_par);
rtdb->setOutput(output);
// Set Material file Name
//-----------------------
fRun->SetMaterials("media_pnd.geo");
// Create and add detectors
//-------------------------
FairModule *Cave= new PndCave("CAVE");
Cave->SetGeometryFileName("pndcave.geo");
fRun->AddModule(Cave);
if (full_panda) {
//------------------------- Magnet -----------------
FairModule *Magnet= new PndMagnet("MAGNET");
//Magnet->SetGeometryFileName("FullSolenoid_V842.root");
Magnet->SetGeometryFileName("FullSuperconductingSolenoid_v831.root");
fRun->AddModule(Magnet);
FairModule *Dipole= new PndMagnet("MAGNET");
Dipole->SetGeometryFileName("dipole.geo");
fRun->AddModule(Dipole);
//------------------------- Pipe -----------------
FairModule *Pipe= new PndPipe("PIPE");
Pipe->SetGeometryFileName("beampipe_201112.root");
fRun->AddModule(Pipe);
//------------------------- STT -----------------
FairDetector *Stt= new PndStt("STT", kTRUE);
Stt->SetGeometryFileName("straws_skewed_blocks_35cm_pipe.geo");
fRun->AddModule(Stt);
//------------------------- MVD -----------------
FairDetector *Mvd = new PndMvdDetector("MVD", kTRUE);
Mvd->SetGeometryFileName("Mvd-2.1_FullVersion.root");
fRun->AddModule(Mvd);
//------------------------- GEM -----------------
FairDetector *Gem = new PndGemDetector("GEM", kTRUE);
Gem->SetGeometryFileName("gem_3Stations.root");
fRun->AddModule(Gem);
}
//------------------------- EMC -----------------
PndEmc *Emc = new PndEmc("EMC",kTRUE);
Emc->SetGeometryVersion(1);
Emc->SetStorageOfData(kFALSE);
fRun->AddModule(Emc);
if (full_panda) {
//------------------------- SCITIL -----------------
FairDetector *SciT = new PndSciT("SCIT",kTRUE);
SciT->SetGeometryFileName("barrel-SciTil_07022013.root");
fRun->AddModule(SciT);
//------------------------- DRC -----------------
PndDrc *Drc = new PndDrc("DIRC", kTRUE);
Drc->SetGeometryFileName("dirc_l0_p0_updated.root");
Drc->SetRunCherenkov(kFALSE);
fRun->AddModule(Drc);
//------------------------- DISC -----------------
PndDsk* Dsk = new PndDsk("DSK", kTRUE);
Dsk->SetStoreCerenkovs(kFALSE);
Dsk->SetStoreTrackPoints(kFALSE);
fRun->AddModule(Dsk);
//------------------------- MDT -----------------
PndMdt *Muo = new PndMdt("MDT",kTRUE);
Muo->SetBarrel("fast");
Muo->SetEndcap("fast");
Muo->SetMuonFilter("fast");
Muo->SetForward("fast");
Muo->SetMdtMagnet(kTRUE);
Muo->SetMdtMFIron(kTRUE);
fRun->AddModule(Muo);
//------------------------- FTS -----------------
FairDetector *Fts= new PndFts("FTS", kTRUE);
Fts->SetGeometryFileName("fts.geo");
fRun->AddModule(Fts);
//------------------------- FTOF -----------------
FairDetector *FTof = new PndFtof("FTOF",kTRUE);
FTof->SetGeometryFileName("ftofwall.root");
fRun->AddModule(FTof);
//------------------------- RICH ----------------
FairDetector *Rich= new PndRich("RICH",kFALSE);
Rich->SetGeometryFileName("rich_v2.geo");
fRun->AddModule(Rich);
}
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
fRun->SetGenerator(primGen);
// Box Generator. first number: PDG particle code: 2nd number: particle multiplicity per event
FairBoxGenerator* boxGen = new FairBoxGenerator(charge*211, 1); // 13 = muon // 1 = multipl. // 211 = pi+ // -211 = pi-
boxGen->SetPRange(mom,mom); // GeV/c
// boxGen->SetPtRange(1.,1.); // GeV/c
boxGen->SetPhiRange(0., 360.); // Azimuth angle range [degree]
boxGen->SetThetaRange(85., 95.); // Polar angle in lab system range [degree] - restrict to small rapidity
boxGen->SetXYZ(0., 0., 0.); // vertex coordinates [mm]
primGen->AddGenerator(boxGen);
fRun->SetStoreTraj(kTRUE); // to store particle trajectories
fRun->SetBeamMom(15);
//---------------------Create and Set the Field(s)----------
PndMultiField *fField= new PndMultiField("FULL");
fRun->SetField(fField);
//----------- Add Hit producer task to the simulation ------
PndEmcHitProducer* emcHitProd = new PndEmcHitProducer();
emcHitProd->SetStorageOfData(kFALSE);
fRun->AddTask(emcHitProd);
PndEmcHitsToWaveform* emcHitsToWaveform= new PndEmcHitsToWaveform(0);
PndEmcWaveformToDigi* emcWaveformToDigi=new PndEmcWaveformToDigi(0);
//emcHitsToWaveform->SetStorageOfData(kFALSE);
//emcWaveformToDigi->SetStorageOfData(kFALSE);
fRun->AddTask(emcHitsToWaveform); // full digitization
fRun->AddTask(emcWaveformToDigi); // full digitization
PndEmcMakeCluster* emcMakeCluster= new PndEmcMakeCluster(0);
//emcMakeCluster->SetStorageOfData(kFALSE);
fRun->AddTask(emcMakeCluster);
PndEmcHdrFiller* emcHdrFiller = new PndEmcHdrFiller();
fRun->AddTask(emcHdrFiller); // ECM header
PndEmcMakeBump* emcMakeBump= new PndEmcMakeBump();
//emcMakeBump->SetStorageOfData(kFALSE);
fRun->AddTask(emcMakeBump);
PndEmcMakeRecoHit* emcMakeRecoHit= new PndEmcMakeRecoHit();
fRun->AddTask(emcMakeRecoHit);
/**Initialize the session*/
fRun->Init();
PndEmcMapper *emcMap = PndEmcMapper::Init(1);
/**After initialization now we can save the field parameters */
PndMultiFieldPar* Par = (PndMultiFieldPar*) rtdb->getContainer("PndMultiFieldPar");
if (fField) { Par->SetParameters(fField); }
Par->setInputVersion(fRun->GetRunId(),1);
Par->setChanged();
/**All parameters are initialized and ready to be saved*/
rtdb->saveOutput();
rtdb->print();
// Transport nEvents
// -----------------
fRun->Run(nEvents);
timer.Stop();
printf("RealTime=%f seconds, CpuTime=%f seconds\n",timer.RealTime(),timer.CpuTime());
}
sim_complete_boxgen_pions(Int_t nEvents = 100, TString pre="", Float_t mom = 6.231552, TString SimEngine ="TGeant3")
{
//-----User Settings:-----------------------------------------------
if(pre == ""){
TString OutputFile ="sim_complete.root";
TString ParOutputfile ="simparams.root";
}
else{
TString OutputFile = pre + "_sim_complete.root";
TString ParOutputfile =pre + "_simparams.root";
}
TString MediaFile ="media_pnd.geo";
gDebug = 0;
TString digiFile = "all.par"; //The emc run the hit producer directly
// choose your event generator
Bool_t UseEvtGenDirect =kFALSE;
Bool_t UseDpm =kFALSE;
Bool_t UseFtf =kFALSE;
Bool_t UseBoxGenerator =kTRUE;
TString evtPdlFile = "evt.pdl";
Double_t BeamMomentum = 0.; // beam momentum ONLY for the scaling of the dipole field.
if (UseBoxGenerator)
{
BeamMomentum =mom; // ** change HERE if you run Box generator
}
else
{
BeamMomentum = mom; // for DPM/EvtGen BeamMomentum is always = mom
}
//------------------------------------------------------------------
TLorentzVector fIni(0, 0, mom, sqrt(mom*mom+9.3827203e-01*9.3827203e-01)+9.3827203e-01);
TDatabasePDG::Instance()->AddParticle("pbarpSystem","pbarpSystem",fIni.M(),kFALSE,0.1,0, "",88888);
//------------------------------------------------------------------
TStopwatch timer;
timer.Start();
gRandom->SetSeed();
// Create the Simulation run manager--------------------------------
FairRunSim *fRun = new FairRunSim();
fRun->SetName(SimEngine.Data() );
fRun->SetOutputFile(OutputFile.Data());
fRun->SetGenerateRunInfo(kFALSE);
fRun->SetBeamMom(BeamMomentum);
fRun->SetMaterials(MediaFile.Data());
fRun->SetUseFairLinks(kTRUE);
FairRuntimeDb *rtdb=fRun->GetRuntimeDb();
// Set the parameters
//-------------------------------
TString allDigiFile = gSystem->Getenv("VMCWORKDIR");
allDigiFile += "/macro/params/";
allDigiFile += digiFile;
//-------Set the parameter output --------------------
FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
parIo1->open(allDigiFile.Data(),"in");
rtdb->setFirstInput(parIo1);
//---------------------Set Parameter output ----------
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(ParOutputfile.Data());
rtdb->setOutput(output);
// Create and add detectors
//------------------------- CAVE -----------------
FairModule *Cave= new PndCave("CAVE");
Cave->SetGeometryFileName("pndcave.geo");
fRun->AddModule(Cave);
//------------------------- Magnet -----------------
//FairModule *Magnet= new PndMagnet("MAGNET");
//Magnet->SetGeometryFileName("FullSolenoid_V842.root");
//Magnet->SetGeometryFileName("FullSuperconductingSolenoid_v831.root");
//fRun->AddModule(Magnet);
FairModule *Dipole= new PndMagnet("MAGNET");
Dipole->SetGeometryFileName("dipole.geo");
fRun->AddModule(Dipole);
//------------------------- Pipe -----------------
FairModule *Pipe= new PndPipe("PIPE");
Pipe->SetGeometryFileName("beampipe_201309.root");
fRun->AddModule(Pipe);
//------------------------- STT -----------------
FairDetector *Stt= new PndStt("STT", kTRUE);
Stt->SetGeometryFileName("straws_skewed_blocks_35cm_pipe.geo");
fRun->AddModule(Stt);
//------------------------- MVD -----------------
FairDetector *Mvd = new PndMvdDetector("MVD", kTRUE);
Mvd->SetGeometryFileName("Mvd-2.1_FullVersion.root");
fRun->AddModule(Mvd);
//------------------------- GEM -----------------
FairDetector *Gem = new PndGemDetector("GEM", kTRUE);
Gem->SetGeometryFileName("gem_3Stations_Tube.root");
fRun->AddModule(Gem);
//------------------------- EMC -----------------
PndEmc *Emc = new PndEmc("EMC",kTRUE);
Emc->SetGeometryVersion(1);
Emc->SetStorageOfData(kFALSE);
fRun->AddModule(Emc);
//------------------------- SCITIL -----------------
FairDetector *SciT = new PndSciT("SCIT",kTRUE);
SciT->SetGeometryFileName("SciTil_201504.root");
fRun->AddModule(SciT);
//------------------------- DRC -----------------
PndDrc *Drc = new PndDrc("DIRC", kTRUE);
Drc->SetGeometryFileName("dirc_l0_p0_updated.root");
Drc->SetRunCherenkov(kFALSE);
fRun->AddModule(Drc);
//------------------------- DISC -----------------
PndDsk* Dsk = new PndDsk("DSK", kTRUE);
Dsk->SetStoreCerenkovs(kFALSE);
Dsk->SetStoreTrackPoints(kFALSE);
fRun->AddModule(Dsk);
//------------------------- MDT -----------------
PndMdt *Muo = new PndMdt("MDT",kTRUE);
Muo->SetBarrel("fast");
Muo->SetEndcap("fast");
Muo->SetMuonFilter("fast");
Muo->SetForward("fast");
Muo->SetMdtMagnet(kTRUE);
Muo->SetMdtCoil(kTRUE);
Muo->SetMdtMFIron(kTRUE);
fRun->AddModule(Muo);
//------------------------- FTS -----------------
FairDetector *Fts= new PndFts("FTS", kTRUE);
Fts->SetGeometryFileName("fts.geo");
fRun->AddModule(Fts);
//------------------------- FTOF -----------------
FairDetector *FTof = new PndFtof("FTOF",kTRUE);
FTof->SetGeometryFileName("ftofwall.root");
fRun->AddModule(FTof);
//------------------------- RICH ----------------
FairDetector *Rich= new PndRich("RICH",kFALSE);
Rich->SetGeometryFileName("rich_v2_shift.geo");
fRun->AddModule(Rich);
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
fRun->SetGenerator(primGen);
if(UseBoxGenerator){ // Box Generator
FairBoxGenerator* boxGenPiM = new FairBoxGenerator(-211, 1); // 13 = muon; 1 = multipl.
boxGenPiM->SetPRange(0., 0.6); // GeV/c
boxGenPiM->SetPhiRange(0., 360.); // Azimuth angle range [degree]
boxGenPiM->SetThetaRange(0., 70); // Polar angle in lab system range [degree]
boxGenPiM->SetXYZ(0., 0., 0.); // cm
primGen->AddGenerator(boxGenPiM);
FairBoxGenerator* boxGenPiP = new FairBoxGenerator(211, 1); // 13 = muon; 1 = multipl.
boxGenPiP->SetPRange(0.,0.6); // GeV/c
boxGenPiP->SetPhiRange(0., 360.); // Azimuth angle range [degree]
boxGenPiP->SetThetaRange(0., 70); // Polar angle in lab system range [degree]
boxGenPiP->SetXYZ(0., 0., 0.); // cm
primGen->AddGenerator(boxGenPiP);
}
if(UseDpm){
PndDpmDirect *Dpm= new PndDpmDirect(mom,1);
primGen->AddGenerator(Dpm);
}
if(UseFtf){
// TString macfile = gSystem->Getenv("VMCWORKDIR");
// macfile += "/pgenerators/FtfEvtGen/PbarP.mac";
// PndFtfDirect *Ftf = new PndFtfDirect(macfile.Data());
PndFtfDirect *Ftf = new PndFtfDirect("anti_proton", "G4_H", 1, "ftfp", mom, 123456);
primGen->AddGenerator(Ftf);
}
if(UseEvtGenDirect){
// TString EvtInput =gSystem->Getenv("VMCWORKDIR");
// EvtInput+="/macro/run/psi2s_Jpsi2pi_Jpsi_mumu.dec";
TString EvtInput="/home/ikp1/puetz/panda/mysimulations/analysis/XiMinus_1820_lambda0_K.dec";
// PndEvtGenDirect *EvtGen = new PndEvtGenDirect("pbarpSystem", EvtInput.Data(), mom);
PndEvtGenDirect * EvtGen = new PndEvtGenDirect("pbarpSystem", EvtInput.Data(), mom, -1, "", evtPdlFile.Data());
EvtGen->SetStoreTree(kTRUE);
primGen->AddGenerator(EvtGen);
}
//---------------------Create and Set the Field(s)----------
PndMultiField *fField= new PndMultiField("AUTO");
fRun->SetField(fField);
// EMC Hit producer
//-------------------------------
PndEmcHitProducer* emcHitProd = new PndEmcHitProducer();
fRun->AddTask(emcHitProd);
//------------------------- Initialize the RUN -----------------
fRun->Init();
//------------------------- Run the Simulation -----------------
fRun->Run(nEvents);
//------------------------- Save the parameters -----------------
rtdb->saveOutput();
//------------------------Print some info and exit----------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
printf("RealTime=%f seconds, CpuTime=%f seconds\n",rtime,ctime);
cout << " Test passed" << endl;
cout << " All ok " << endl;
exit(0);
};
void sim(Int_t file_nr=0, Int_t nEvents=1, Int_t s=0, Int_t seed=1){
Char_t filenr[4];
sprintf(filenr,"%04d",file_nr);
printf("Filenr: %s\n", filenr);
TString signal;
if (s!=3312 && s!=3334) signal = "la";
else if (s==3312) signal = "xi";
else if (s==3334) signal = "om";
// ----- Paths and file names --------------------------------------------
TString inDir = gSystem->Getenv("URQMD_INPUT_PATH");
TString inFile = inDir + "/urqmd.auau.25gev.centr." + filenr + ".ftn14";
TString outDir= TString(filenr);
outDir+= "/";
gSystem->mkdir(outDir.Data());
TString outFile = outDir+signal+".mc.root";
TString parFile = outDir+signal+".par.root";
// ----- Geometries -----------------------------------------------------
TString caveGeom = "cave.geo";
TString pipeGeom = "pipe_standard.geo";
TString targetGeom = "target_au_250mu.geo";
TString magnetGeom = "magnet_standard.geo";
TString stsGeom = "sts_Standard_s3055AAFK5.SecD.geo";
// ----- Magnetic field -----------------------------------------------
TString fieldMap = "FieldMuonMagnet"; // name of field map
Double_t fieldZ = 50.; // field centre z position
Double_t fieldScale = 1.; // field scaling factor
gDebug = 0;
gRandom->SetSeed(seed);
// ---- Load libraries -------------------------------------------------
cout << endl << "=== much_sim.C : Loading libraries ..." << endl;
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/analysis/hyperon/analysislibs.C");
analysislibs();
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3");
fRun->SetOutputFile(outFile.Data());
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
fRun->SetMaterials("media.geo");
// ----- Create detectors and passive volumes -------------------------
cout << endl << "=== much_sim.C : Create geeometry ..." << endl;
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
cout << " --- " << caveGeom << endl;
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
cout << " --- " << pipeGeom << endl;
}
if ( targetGeom != "" ) {
FairModule* target = new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
fRun->AddModule(target);
cout << " --- " << targetGeom << endl;
}
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
cout << " --- " << magnetGeom << endl;
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
cout << " --- " << stsGeom << endl;
fRun->AddModule(sts);
}
// ----- Create magnetic field ----------------------------------------
cout << endl << "=== much_sim.C : Create magnetic field ..." << endl;
CbmFieldMap* magField = NULL;
if ( fieldMap == "FieldActive" || fieldMap == "FieldIron")
magField = new CbmFieldMapSym3(fieldMap);
else if ( fieldMap == "FieldAlligator" )
magField = new CbmFieldMapSym2(fieldMap);
else if ( fieldMap == "FieldMuonMagnet" )
magField = new CbmFieldMapSym3(fieldMap);
else {
cout << "===> ERROR: Field map " << fieldMap << " unknown! " << endl;
exit;
}
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ----- Create PrimaryGenerator --------------------------------------
cout << endl << "=== much_sim.C : Create generators ..." << endl;
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (signal=="om"){
delete gRandom;
gRandom = new TRandom3();
CbmAnaHypYPtGenerator* gen = new CbmAnaHypYPtGenerator(3334);
gen->SetDistributionPt(0.1603); // 6 GeV
gen->SetDistributionY(1.277,0.412); // 6 GeV
//gen->SetDistributionPt(0.149808); // 25 GeV
//gen->SetDistributionY(1.9875,0.546669); // 25 GeV
gen->Init();
primGen->AddGenerator(gen);
} else if (signal=="xi"){
delete gRandom;
gRandom = new TRandom3();
CbmAnaHypYPtGenerator* gen = new CbmAnaHypYPtGenerator(3312);
gen->SetDistributionPt(0.1603); // 6 GeV
gen->SetDistributionY(1.277,0.412); // 6 GeV
//gen->SetDistributionPt(0.154319); // 25 GeV
//gen->SetDistributionY(1.98604,0.617173); // 25 GeV
gen->Init();
primGen->AddGenerator(gen);
}
FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile.Data());
primGen->AddGenerator(urqmdGen);
fRun->SetGenerator(primGen);
// ------------------------------------------------------------------------
fRun->Init();
// ------------------------------------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile);
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
TStopwatch timer;
timer.Start();
fRun->Run(nEvents);
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "=== sim.C : Macro finished successfully." << endl;
cout << "=== sim.C : Output file is " << outFile << endl;
cout << "=== sim.C : Real time used: " << rtime << "s " << endl;
cout << "=== sim.C : CPU time used : " << ctime << "s " << endl;
cout << endl << endl;
// ------------------------------------------------------------------------
}
void run_sim()
{
TString transport = "TGeant4";
Bool_t userPList = kFALSE; // option for TGeant4
TString outFile = "sim.root";
TString parFile = "par.root";
Bool_t magnet = kTRUE;
Float_t fieldScale = -0.68;
TString generator1 = "box";
TString generator2 = "ascii";
TString generator3 = "r3b";
TString generator = generator1;
TString inputFile = "";
Int_t nEvents = 1;
Bool_t storeTrajectories = kTRUE;
Int_t randomSeed = 335566; // 0 for time-dependent random numbers
// Target type
TString target1 = "LeadTarget";
TString target2 = "Para";
TString target3 = "Para45";
TString target4 = "LiH";
TString targetType = target4;
// ------------------------------------------------------------------------
// Stable part ------------------------------------------------------------
TString dir = getenv("VMCWORKDIR");
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(transport); // Transport engine
run->SetOutputFile(outFile.Data()); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// R3B Special Physics List in G4 case
if ((userPList == kTRUE) && (transport.CompareTo("TGeant4") == 0))
{
run->SetUserConfig("g4R3bConfig.C");
run->SetUserCuts("SetCuts.C");
}
// ----- Create media -------------------------------------------------
run->SetMaterials("media_r3b.geo"); // Materials
// ----- Create R3B geometry --------------------------------------------
// R3B Cave definition
FairModule* cave = new R3BCave("CAVE");
cave->SetGeometryFileName("r3b_cave.geo");
run->AddModule(cave);
// To skip the detector comment out the line with: run->AddModule(...
// Target
run->AddModule(new R3BTarget(targetType, "target_" + targetType + ".geo.root"));
// GLAD
//run->AddModule(new R3BGladMagnet("glad_v17_flange.geo.root")); // GLAD should not be moved or rotated
// PSP
run->AddModule(new R3BPsp("psp_v13a.geo.root", {}, -221., -89., 94.1));
// R3B SiTracker Cooling definition
//run->AddModule(new R3BVacVesselCool(targetType, "vacvessel_v14a.geo.root"));
// STaRTrack
//run->AddModule(new R3BSTaRTra("startra_v16-300_2layers.geo.root", { 0., 0., 20. }));
// CALIFA
R3BCalifa* califa = new R3BCalifa("califa_10_v8.11.geo.root");
califa->SelectGeometryVersion(10);
// Selecting the Non-uniformity of the crystals (1 means +-1% max deviation)
califa->SetNonUniformity(1.0);
//run->AddModule(califa);
// Tof
//run->AddModule(new R3BTof("tof_v17a.geo.root", { -417.359574, 2.400000, 960.777114 }, { "", -90., +31., 90. }));
// mTof
run->AddModule(new R3BmTof("mtof_v17a.geo.root", { -155.824045, 0.523976, 761.870346 }, { "", -90., +16.7, 90. }));
// MFI
//run->AddModule(new R3BMfi("mfi_v17a.geo.root", { -63.82, 0., 520.25 }, { "", 90., +13.5, 90. })); // s412
// NeuLAND
// run->AddModule(new R3BNeuland("neuland_test.geo.root", { 0., 0., 1400. + 12 * 5. }));
// ----- Create R3B magnetic field ----------------------------------------
// NB: <D.B>
// If the Global Position of the Magnet is changed
// the Field Map has to be transformed accordingly
R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap");
magField->SetScale(fieldScale);
if (magnet == kTRUE)
{
run->SetField(magField);
}
else
{
run->SetField(NULL);
}
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (generator.CompareTo("box") == 0)
{
FairIonGenerator* boxGen = new FairIonGenerator(50, 128, 50, 1, 0., 0., 1.3, 0., 0., 0.);
primGen->AddGenerator(boxGen);
}
if (generator.CompareTo("ascii") == 0)
{
R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir + "/input/" + inputFile).Data());
primGen->AddGenerator(gen);
}
run->SetGenerator(primGen);
run->SetStoreTraj(storeTrajectories);
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
// ----- Initialize simulation run ------------------------------------
run->Init();
TVirtualMC::GetMC()->SetRandom(new TRandom3(randomSeed));
// ------ Increase nb of step for CALO
Int_t nSteps = -15000;
TVirtualMC::GetMC()->SetMaxNStep(nSteps);
// ----- Runtime database ---------------------------------------------
R3BFieldPar* fieldPar = (R3BFieldPar*)rtdb->getContainer("R3BFieldPar");
if (NULL != magField)
{
fieldPar->SetParameters(magField);
fieldPar->setChanged();
}
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ----- Start run ----------------------------------------------------
if (nEvents > 0)
{
run->Run(nEvents);
}
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl;
cout << " Test passed" << endl;
cout << " All ok " << endl;
// Snap a picture of the geometry
// If this crashes, set "OpenGL.SavePicturesViaFBO: no" in your .rootrc
/*gStyle->SetCanvasPreferGL(kTRUE);
gGeoManager->GetTopVolume()->Draw("ogl");
TGLViewer* v = (TGLViewer*)gPad->GetViewer3D();
v->SetStyle(TGLRnrCtx::kOutline);
v->RequestDraw();
v->SavePicture("run_sim-side.png");
v->SetPerspectiveCamera(TGLViewer::kCameraPerspXOZ, 25., 0, 0, -90. * TMath::DegToRad(), 0. * TMath::DegToRad());
v->SavePicture("run_sim-top.png");*/
}
void run_sim(Int_t nEvents = 2)
{
TTree::SetMaxTreeSize(90000000000);
Int_t iVerbose = 0;
TString script = TString(gSystem->Getenv("SCRIPT"));
TString parDir = TString(gSystem->Getenv("VMCWORKDIR")) + TString("/parameters");
//gRandom->SetSeed(10);
TString inFile = "/Users/slebedev/Development/cbm/data/urqmd/auau/25gev/centr/urqmd.auau.25gev.centr.00001.root";
TString parFile = "/Users/slebedev/Development/cbm/data/simulations/rich/richreco/param.0001.root";
TString outFile = "/Users/slebedev/Development/cbm/data/simulations/rich/richreco/mc.0001.root";
TString caveGeom = "cave.geo";
TString pipeGeom = "pipe/pipe_standard.geo";
TString magnetGeom = "magnet/magnet_v12a.geo";
TString mvdGeom = "";
TString stsGeom = "sts/sts_v13d.geo.root";
TString richGeom= "rich/rich_v13c_pipe_1_al_1.root";
TString trdGeom = "trd/trd_v13g.geo.root";
TString tofGeom = "tof/tof_v13b.geo.root";
TString ecalGeom = "";
TString fieldMap = "field_v12a";
TString electrons = "yes"; // If "yes" than primary electrons will be generated
Int_t NELECTRONS = 5; // number of e- to be generated
Int_t NPOSITRONS = 5; // number of e+ to be generated
TString urqmd = "yes"; // If "yes" than UrQMD will be used as background
TString pluto = "no"; // If "yes" PLUTO particles will be embedded
TString plutoFile = "";
TString plutoParticle = "";
Double_t fieldZ = 50.; // field center z position
Double_t fieldScale = 1.0; // field scaling factor
if (script == "yes") {
inFile = TString(gSystem->Getenv("IN_FILE"));
outFile = TString(gSystem->Getenv("MC_FILE"));
parFile = TString(gSystem->Getenv("PAR_FILE"));
caveGeom = TString(gSystem->Getenv("CAVE_GEOM"));
pipeGeom = TString(gSystem->Getenv("PIPE_GEOM"));
mvdGeom = TString(gSystem->Getenv("MVD_GEOM"));
stsGeom = TString(gSystem->Getenv("STS_GEOM"));
richGeom = TString(gSystem->Getenv("RICH_GEOM"));
trdGeom = TString(gSystem->Getenv("TRD_GEOM"));
tofGeom = TString(gSystem->Getenv("TOF_GEOM"));
ecalGeom = TString(gSystem->Getenv("ECAL_GEOM"));
fieldMap = TString(gSystem->Getenv("FIELD_MAP"));
magnetGeom = TString(gSystem->Getenv("MAGNET_GEOM"));
NELECTRONS = TString(gSystem->Getenv("NELECTRONS")).Atoi();
NPOSITRONS = TString(gSystem->Getenv("NPOSITRONS")).Atoi();
electrons = TString(gSystem->Getenv("ELECTRONS"));
urqmd = TString(gSystem->Getenv("URQMD"));
pluto = TString(gSystem->Getenv("PLUTO"));
plutoFile = TString(gSystem->Getenv("PLUTO_FILE"));
plutoParticle = TString(gSystem->Getenv("PLUTO_PARTICLE"));
fieldScale = TString(gSystem->Getenv("FIELD_MAP_SCALE")).Atof();
}
gDebug = 0;
TStopwatch timer;
timer.Start();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C");
loadlibs();
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3"); // Transport engine
fRun->SetOutputFile(outFile);
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
//fRun->SetStoreTraj(kTRUE);
fRun->SetMaterials("media.geo"); // Materials
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
}
CbmTarget* target = new CbmTarget("Gold", 0.025); // 250 mum
fRun->AddModule(target);
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
}
if ( mvdGeom != "" ) {
FairDetector* mvd = new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
fRun->AddModule(mvd);
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmStsMC(kTRUE);
sts->SetGeometryFileName(stsGeom);
fRun->AddModule(sts);
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
fRun->AddModule(rich);
}
if ( trdGeom != "" ) {
FairDetector* trd = new CbmTrd("TRD",kTRUE );
trd->SetGeometryFileName(trdGeom);
fRun->AddModule(trd);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
fRun->AddModule(tof);
}
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = NULL;
magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (urqmd == "yes"){
//CbmUrqmdGenerator* urqmdGen = new CbmUrqmdGenerator(inFile);
CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(inFile);
urqmdGen->SetEventPlane(0. , 360.);
primGen->AddGenerator(urqmdGen);
}
//add electrons
if (electrons == "yes"){
FairBoxGenerator* boxGen1 = new FairBoxGenerator(11, NPOSITRONS);
boxGen1->SetPtRange(0.,3.);
boxGen1->SetPhiRange(0.,360.);
boxGen1->SetThetaRange(2.5,25.);
boxGen1->SetCosTheta();
boxGen1->Init();
primGen->AddGenerator(boxGen1);
FairBoxGenerator* boxGen2 = new FairBoxGenerator(-11, NELECTRONS);
boxGen2->SetPtRange(0.,3.);
boxGen2->SetPhiRange(0.,360.);
boxGen2->SetThetaRange(2.5,25.);
boxGen2->SetCosTheta();
boxGen2->Init();
primGen->AddGenerator(boxGen2);
// CbmLitPolarizedGenerator *polGen;
// polGen = new CbmLitPolarizedGenerator(443, NELECTRONS);
// polGen->SetDistributionPt(0.176); // 25 GeV
// polGen->SetDistributionY(1.9875,0.228); // 25 GeV
// polGen->SetRangePt(0.,3.);
// polGen->SetRangeY(1.,3.);
// polGen->SetBox(0);
// polGen->SetRefFrame(CbmLitPolarizedGenerator::kHelicity);
// polGen->SetDecayMode(CbmLitPolarizedGenerator::kDiElectron);
// polGen->SetAlpha(0);
// polGen->Init();
// primGen->AddGenerator(polGen);
}
if (pluto == "yes") {
FairPlutoGenerator *plutoGen= new FairPlutoGenerator(plutoFile);
primGen->AddGenerator(plutoGen);
}
fRun->SetGenerator(primGen);
fRun->Init();
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
fRun->Run(nEvents);
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << " Test passed" << endl;
cout << " All ok " << endl;
}