void run(TString runNumber)
{
TStopwatch timer;
timer.Start();
TString dirIn1 = "/Volumes/Data/kresan/s438/data/";
TString dirIn2 = "/Volumes/Data/kresan/s438/tcal/";
TString dirOut = "/Volumes/Data/kresan/s438/digi/";
TString tdiffParName = "tdiff_" + runNumber + ".dat";
TString inputFileName1 = dirIn2 + runNumber + "_tcal.root"; // name of input file
TString parFileName = dirIn1 + "params_" + runNumber + "_raw.root"; // name of parameter file
TString outputFileName = dirOut + runNumber + "_digi.root"; // name of output file
// Create analysis run -------------------------------------------------------
FairRunAna* run = new FairRunAna();
run->SetInputFile(inputFileName1.Data());
run->SetOutputFile(outputFileName.Data());
// ---------------------------------------------------------------------------
// ----- Runtime DataBase info -----------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFileName);
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ---------------------------------------------------------------------------
// Tdiff calibration ---------------------------------------------------------
R3BLandTdiff* landTdiff = new R3BLandTdiff("LandTdiff", 1);
landTdiff->SetTdiffParName(tdiffParName.Data());
run->AddTask(landTdiff);
// ---------------------------------------------------------------------------
// Analysis ------------------------------------------------------------------
R3BLandAna* landAna = new R3BLandAna("LandAna", 1);
landAna->SetNofBars(100);
run->AddTask(landAna);
// ---------------------------------------------------------------------------
// Initialize ----------------------------------------------------------------
run->Init();
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
// ---------------------------------------------------------------------------
// Run -----------------------------------------------------------------------
run->Run();
// ---------------------------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outputFileName << endl;
cout << "Parameter file is " << parFileName << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl;
}
void much_ana(Int_t nEvents=1000){
TTree::SetMaxTreeSize(90000000000);
TString script = TString(gSystem->Getenv("LIT_SCRIPT"));
TString parDir = TString(gSystem->Getenv("VMCWORKDIR")) + TString("/parameters");
// Input and output data
TString dir = "events/much_anna_omega_8gev_10k/"; // Output directory
TString mcFile = dir + "mc.0000.root"; // MC transport file
TString parFile = dir + "param.0000.root"; // Parameters file
TString globalRecoFile = dir + "global.reco.0000.root"; // File with reconstructed tracks and hits
TString analysisFile = dir + "analysis.0000.root"; // Output analysis file
TString muchDigiFile = parDir + "/much/much_v12c.digi.root"; // MUCH digi file
if (script == "yes") {
mcFile = TString(gSystem->Getenv("LIT_MC_FILE"));
parFile = TString(gSystem->Getenv("LIT_PAR_FILE"));
globalRecoFile = TString(gSystem->Getenv("LIT_GLOBAL_RECO_FILE"));
analysisFile = TString(gSystem->Getenv("LIT_ANALYSIS_FILE"));
muchDigiFile = TString(gSystem->Getenv("LIT_MUCH_DIGI"));
}
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C");
muchlibs();
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(mcFile);
fRun->AddFriend(globalRecoFile);
fRun->SetOutputFile(analysisFile);
TString muchDigiFile = gSystem->Getenv("VMCWORKDIR");
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile);
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ------------------------------------------------------------------------
CbmKF* kf = new CbmKF();
CbmAnaDimuonAnalysis* ana = new CbmAnaDimuonAnalysis("DimuonAnalysis", muchDigiFile, 1);
ana->SetVerbose(0);
ana->SetStsPointsAccQuota(4);
ana->SetStsTrueHitQuota(0.7);
fRun->AddTask(kf);
fRun->AddTask(ana);
fRun->Init();
fRun->Run(0,nEvents);
}
void event_display()
{
TString dir = "events/mvd/";
TString mcFile = dir + "mc.0000.root"; // MC transport file
TString parFile = dir + "param.0000.root"; // Parameter file
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/cbmrootlibs.C");
cbmrootlibs();
gSystem->Load("libEve");
gSystem->Load("libEventDisplay");
FairRunAna *run= new FairRunAna();
run->SetInputFile(mcFile);
run->SetOutputFile("test.root");
FairEventManager* eventManager= new FairEventManager();
FairMCTracks* mcTracks = new FairMCTracks("Monte-Carlo Tracks");
FairMCPointDraw* richPoints = new FairMCPointDraw("RichPoint", kOrange, kFullSquare);
FairMCPointDraw* tofPoints = new FairMCPointDraw("TofPoint", kBlue, kFullSquare);
FairMCPointDraw* trdPoints = new FairMCPointDraw("TrdPoint", kTeal, kFullSquare);
FairMCPointDraw* muchPoints = new FairMCPointDraw("MuchPoint", kRed, kFullSquare);
FairMCPointDraw* ecalPoints = new FairMCPointDraw("EcalPoint", kYellow, kFullSquare);
FairMCPointDraw* refPlanePoints = new FairMCPointDraw("RefPlanePoint", kPink, kFullSquare);
FairMCPointDraw* stsPoints = new FairMCPointDraw("StsPoint", kCyan, kFullSquare);
eventManager->AddTask(mcTracks);
eventManager->AddTask(richPoints);
eventManager->AddTask(ecalPoints);
eventManager->AddTask(tofPoints);
eventManager->AddTask(trdPoints);
eventManager->AddTask(muchPoints);
eventManager->AddTask(refPlanePoints);
eventManager->AddTask(stsPoints);
// ----- Parameter database --------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile.Data());
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ------------------------------------------------------------------------
eventManager->Init();
}
Int_t califa_test()
{
// Create a Runtime Database singleton.
FairRuntimeDb* db = FairRuntimeDb::instance();
// Create in memory the relevant container
R3BCaloCalPar* par = (R3BCaloCalPar*)(db->getContainer("CaloCalPar"));
// Set the SQL IO as first input
FairParAsciiFileIo* inp = new FairParAsciiFileIo();
TString filename ="ducals.par";
inp->open(filename.Data(),"in");
db->setFirstInput(inp);
// Generate a unique RunID
FairRunIdGenerator runID;
UInt_t runId = runID.generateId();
db->initContainers(runId);
// Get the container after initialisation
// from the RuntimeDB
R3BCaloCalPar* par = (R3BCaloCalPar*)(db->getContainer("CaloCalPar"));
// Dump the Parameters
cout << endl;
cout << "-I- Reading Parameter data from Ascii File: \n" << filename.Data() << endl;
cout << endl;
par->Print();
cout << endl;
// Convert in ROOT format
par->setChanged();
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open("califa_cal_par.root");
db->setOutput(parOut);
db->saveOutput();
db->print();
// ------------------------------------------------------------------------
if (db) delete db;
return 0;
}
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 global_reco(Int_t nEvents = 100, Int_t seed = 555)
{
gRandom->SetSeed(seed);
TTree::SetMaxTreeSize(90000000000);
TString script = TString(gSystem->Getenv("LIT_SCRIPT"));
TString parDir = TString(gSystem->Getenv("VMCWORKDIR")) + TString("/parameters");
// Input and output data
TString dir = "events/much_anna_omega_8gev_10k/"; // Output directory
TString mcFile = dir + "mc.0000.root"; // MC transport file
TString parFile = dir + "param.0000.root"; // Parameters file
TString globalRecoFile = dir + "global.reco.0000.root"; // Output file with reconstructed tracks and hits
// Digi files
TList* parFileList = new TList();
TObjString stsDigiFile = parDir + "/sts/sts_v12b_std.digi.par"; // STS digi file
TObjString trdDigiFile = parDir + "/trd/trd_v13g.digi.par"; // TRD digi file
TString muchDigiFile = parDir + "/much/much_v12c.digi.root"; // MUCH digi file
TString stsMatBudgetFile = parDir + "/sts/sts_matbudget_v12b.root";
TObjString tofDigiFile = parDir + "/tof/tof_v13b.digi.par";// TOF digi file
// Reconstruction parameters
TString globalTrackingType = "nn"; // Global tracking type
TString trdHitProducerType = "smearing"; // TRD hit producer type: smearing, digi, clustering
TString muchHitProducerType = "advanced"; // MUCH hit producer type: simple, advanced
if (script == "yes") {
mcFile = TString(gSystem->Getenv("LIT_MC_FILE"));
parFile = TString(gSystem->Getenv("LIT_PAR_FILE"));
globalRecoFile = TString(gSystem->Getenv("LIT_GLOBAL_RECO_FILE"));
stsDigiFile = TString(gSystem->Getenv("LIT_STS_DIGI"));
trdDigiFile = TString(gSystem->Getenv("LIT_TRD_DIGI"));
muchDigiFile = TString(gSystem->Getenv("LIT_MUCH_DIGI"));
tofDigiFile = TString(gSystem->Getenv("LIT_TOF_DIGI"));
stsMatBudgetFile = TString(gSystem->Getenv("LIT_STS_MAT_BUDGET_FILE"));
}
parFileList->Add(&stsDigiFile);
parFileList->Add(&trdDigiFile);
parFileList->Add(&tofDigiFile);
Int_t iVerbose = 1;
TStopwatch timer;
timer.Start();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C");
loadlibs();
FairRunAna *run = new FairRunAna();
run->SetInputFile(mcFile);
run->SetOutputFile(globalRecoFile);
// ----- STS -------------------------------------------------
Double_t threshold = 4;
Double_t noiseWidth = 0.01;
Int_t nofBits = 12;
Double_t ElectronsPerAdc = 10.;
Double_t StripDeadTime = 0.1;
CbmStsDigitize* stsDigitize = new CbmStsDigitize("STS Digitiser", iVerbose);
stsDigitize->SetRealisticResponse();
stsDigitize->SetFrontThreshold(threshold);
stsDigitize->SetBackThreshold(threshold);
stsDigitize->SetFrontNoiseWidth(noiseWidth);
stsDigitize->SetBackNoiseWidth(noiseWidth);
stsDigitize->SetFrontNofBits(nofBits);
stsDigitize->SetBackNofBits(nofBits);
stsDigitize->SetFrontNofElPerAdc(ElectronsPerAdc);
stsDigitize->SetBackNofElPerAdc(ElectronsPerAdc);
stsDigitize->SetStripDeadTime(StripDeadTime);
run->AddTask(stsDigitize);
FairTask* stsClusterFinder = new CbmStsClusterFinder("STS Cluster Finder",iVerbose);
run->AddTask(stsClusterFinder);
FairTask* stsFindHits = new CbmStsFindHits("STS Hit Finder", iVerbose);
run->AddTask(stsFindHits);
FairTask* stsMatchHits = new CbmStsMatchHits("STS Hit Matcher", iVerbose);
run->AddTask(stsMatchHits);
FairTask* kalman = new CbmKF();
run->AddTask(kalman);
CbmL1* l1 = new CbmL1();
//l1->SetExtrapolateToTheEndOfSTS(true);
l1->SetMaterialBudgetFileName(stsMatBudgetFile);
run->AddTask(l1);
CbmStsTrackFinder* trackFinder = new CbmL1StsTrackFinder();
FairTask* findTracks = new CbmStsFindTracks(iVerbose, trackFinder);
run->AddTask(findTracks);
FairTask* stsMatchTracks = new CbmStsMatchTracks("STSMatchTracks", iVerbose);
run->AddTask(stsMatchTracks);
// ------------------------------------------------------------------------
if (IsMuch(parFile)) {
// -------- MUCH digitization ------------
CbmMuchDigitizeGem* digitize = new CbmMuchDigitizeGem(muchDigiFile.Data());
if (muchHitProducerType == "simple") {
digitize->SetAlgorithm(0);
} else if (muchHitProducerType == "advanced") {
digitize->SetAlgorithm(1);
}
run->AddTask(digitize);
CbmMuchFindHitsGem* findHits = new CbmMuchFindHitsGem(muchDigiFile.Data());
run->AddTask(findHits);
CbmMuchDigitizeStraws* strawDigitize = new CbmMuchDigitizeStraws("MuchDigitizeStraws", muchDigiFile.Data(), iVerbose);
run->AddTask(strawDigitize);
CbmMuchFindHitsStraws* strawFindHits = new CbmMuchFindHitsStraws("MuchFindHitsStraws", muchDigiFile.Data(), iVerbose);
strawFindHits->SetMerge(1);
run->AddTask(strawFindHits);
// -----------------------------------------------------------------
}
if (IsTrd(parFile)) {
// ----- TRD reconstruction-----------------------------------------
// Update of the values for the radiator F.U. 17.08.07
Int_t trdNFoils = 130; // number of polyetylene foils
Float_t trdDFoils = 0.0013; // thickness of 1 foil [cm]
Float_t trdDGap = 0.02; // thickness of gap between foils [cm]
Bool_t simpleTR = kTRUE; // use fast and simple version for TR production
CbmTrdRadiator *radiator = new CbmTrdRadiator(simpleTR, trdNFoils, trdDFoils, trdDGap);
if (trdHitProducerType == "smearing") {
CbmTrdHitProducerSmearing* trdHitProd = new CbmTrdHitProducerSmearing(radiator);
trdHitProd->SetUseDigiPar(false);
run->AddTask(trdHitProd);
} else if (trdHitProducerType == "digi") {
CbmTrdDigitizer* trdDigitizer = new CbmTrdDigitizer(radiator);
run->AddTask(trdDigitizer);
CbmTrdHitProducerDigi* trdHitProd = new CbmTrdHitProducerDigi();
run->AddTask(trdHitProd);
} else if (trdHitProducerType == "clustering") {
// ----- TRD clustering -----
CbmTrdDigitizerPRF* trdClustering = new CbmTrdDigitizerPRF("TRD Clusterizer", "TRD task", radiator, false, true);
run->AddTask(trdClustering);
CbmTrdClusterFinderFast* trdClusterfindingfast = new CbmTrdClusterFinderFast(true, true, false, 5.0e-7);
run->AddTask(trdClusterfindingfast);
CbmTrdHitProducerCluster* trdClusterHitProducer = new CbmTrdHitProducerCluster();
run->AddTask(trdClusterHitProducer);
// ----- End TRD Clustering -----
}
// ------------------------------------------------------------------------
}
if (IsTof(parFile)) {
// ------ TOF hits --------------------------------------------------------
CbmTofHitProducerNew* tofHitProd = new CbmTofHitProducerNew("TOF HitProducerNew",iVerbose);
tofHitProd->SetInitFromAscii(kFALSE);
run->AddTask(tofHitProd);
// ------------------------------------------------------------------------
}
// ------ Global track reconstruction -------------------------------------
CbmLitFindGlobalTracks* finder = new CbmLitFindGlobalTracks();
//CbmLitFindGlobalTracksParallel* finder = new CbmLitFindGlobalTracksParallel();
// Tracking method to be used
// "branch" - branching tracking
// "nn" - nearest neighbor tracking
// "nn_parallel" - nearest neighbor parallel tracking
finder->SetTrackingType(std::string(globalTrackingType));
// Hit-to-track merger method to be used
// "nearest_hit" - assigns nearest hit to the track
finder->SetMergerType("nearest_hit");
run->AddTask(finder);
if (IsTrd(parFile)) {
CbmTrdMatchTracks* trdMatchTracks = new CbmTrdMatchTracks();
run->AddTask(trdMatchTracks);
}
if (IsMuch(parFile)) {
CbmMuchMatchTracks* muchMatchTracks = new CbmMuchMatchTracks();
run->AddTask(muchMatchTracks);
}
// ----- Primary vertex finding --------------------------------------
CbmPrimaryVertexFinder* pvFinder = new CbmPVFinderKF();
CbmFindPrimaryVertex* findVertex = new CbmFindPrimaryVertex(pvFinder);
run->AddTask(findVertex);
// -----------------------------------------------------------------------
// ----- Parameter database --------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo();
parIo1->open(parFile.Data());
parIo2->open(parFileList, "in");
rtdb->setFirstInput(parIo1);
rtdb->setSecondInput(parIo2);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ------------------------------------------------------------------------
// ----- Initialize and run --------------------------------------------
run->Init();
run->Run(0, nEvents);
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
cout << "Macro finished successfully." << endl;
cout << "Test passed"<< endl;
cout << " All ok " << endl;
cout << "Output file is " << globalRecoFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << timer.RealTime() << " s, CPU time " << timer.CpuTime() << " s" << 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);
}
void run_litqa(Int_t nEvents = 1000)
{
TTree::SetMaxTreeSize(90000000000);
TString script = TString(gSystem->Getenv("SCRIPT"));
TString parDir = TString(gSystem->Getenv("VMCWORKDIR")) + TString("/parameters");
//gRandom->SetSeed(10);
TString dir = "/hera/cbm/users/slebedev/mc/dielectron/sep13/25gev/trd/1.0field/nomvd/rho0/";
TString mcFile = dir + "mc.auau.25gev.centr.00001.root";
TString parFile = dir + "/params.auau.25gev.centr.00001.root";
TString recoFile = dir + "/test.reco.test.auau.25gev.centr.00001.root";
TString qaFile = dir + "/test.litqa.test.auau.25gev.centr.00001.root";
TString delta = "no"; // if "yes" Delta electrons will be embedded
TString deltaFile = "";
TList *parFileList = new TList();
TObjString stsDigiFile = parDir + "/sts/sts_v13c_std.digi.par"; // STS digi file
TObjString trdDigiFile = parDir + "/trd/trd_v13p_3e.digi.par"; // TRD digi file
TObjString tofDigiFile = parDir + "/tof/tof_v13b.digi.par"; // TRD digi file
TString stsMatBudgetFileName = parDir + "/sts/sts_matbudget_v13c.root"; // Material budget file for L1 STS tracking
TString resultDir = "results_litqa/";
Double_t trdAnnCut = 0.85;
Int_t minNofPointsTrd = 6;
if (script == "yes") {
mcFile = TString(gSystem->Getenv("MC_FILE"));
parFile = TString(gSystem->Getenv("PAR_FILE"));
recoFile = TString(gSystem->Getenv("RECO_FILE"));
qaFile = TString(gSystem->Getenv("LITQA_FILE"));
delta = TString(gSystem->Getenv("DELTA"));
deltaFile = TString(gSystem->Getenv("DELTA_FILE"));
stsDigiFile = TString(gSystem->Getenv("STS_DIGI"));
trdDigiFile = TString(gSystem->Getenv("TRD_DIGI"));
tofDigiFile = TString(gSystem->Getenv("TOF_DIGI"));
resultDir = TString(gSystem->Getenv("RESULT_DIR"));
stsMatBudgetFileName = TString(gSystem->Getenv("STS_MATERIAL_BUDGET_FILE"));
trdAnnCut = TString(gSystem->Getenv("TRD_ANN_CUT")).Atof();
minNofPointsTrd = TString(gSystem->Getenv("MIN_NOF_POINTS_TRD")).Atof();
}
parFileList->Add(&stsDigiFile);
parFileList->Add(&trdDigiFile);
parFileList->Add(&tofDigiFile);
TStopwatch timer;
timer.Start();
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C");
loadlibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/determine_setup.C");
// ----- Reconstruction run -------------------------------------------
FairRunAna *run= new FairRunAna();
if (mcFile != "") run->SetInputFile(mcFile);
if (recoFile != "") run->AddFriend(recoFile);
if (qaFile != "") run->SetOutputFile(qaFile);
CbmKF* kalman = new CbmKF();
run->AddTask(kalman);
CbmL1* l1 = new CbmL1();
l1->SetMaterialBudgetFileName(stsMatBudgetFileName);
run->AddTask(l1);
// Reconstruction Qa
CbmLitTrackingQa* trackingQa = new CbmLitTrackingQa();
trackingQa->SetMinNofPointsSts(4);
trackingQa->SetUseConsecutivePointsInSts(true);
trackingQa->SetMinNofPointsTrd(minNofPointsTrd);
trackingQa->SetMinNofPointsMuch(10);
trackingQa->SetMinNofPointsTof(1);
trackingQa->SetQuota(0.7);
trackingQa->SetMinNofHitsTrd(minNofPointsTrd);
trackingQa->SetMinNofHitsMuch(10);
trackingQa->SetVerbose(0);
trackingQa->SetMinNofHitsRich(7);
trackingQa->SetQuotaRich(0.6);
trackingQa->SetPRange(30, 0., 6.);
trackingQa->SetOutputDir(std::string(resultDir));
std::vector<std::string> trackCat, richCat;
trackCat.push_back("All");
trackCat.push_back("Electron");
richCat.push_back("All");
richCat.push_back("Electron");
richCat.push_back("ElectronReference");
trackingQa->SetTrackCategories(trackCat);
trackingQa->SetRingCategories(richCat);
trackingQa->SetTrdAnnCut(trdAnnCut);
run->AddTask(trackingQa);
CbmLitFitQa* fitQa = new CbmLitFitQa();
fitQa->SetMvdMinNofHits(0);
fitQa->SetStsMinNofHits(4);
fitQa->SetMuchMinNofHits(10);
fitQa->SetTrdMinNofHits(minNofPointsTrd);
fitQa->SetPRange(30, 0., 3.);
fitQa->SetOutputDir(std::string(resultDir));
run->AddTask(fitQa);
/* CbmLitClusteringQa* clusteringQa = new CbmLitClusteringQa();
clusteringQa->SetMuchDigiFileName(muchDigiFile.Data());
clusteringQa->SetOutputDir(std::string(resultDir));
run->AddTask(clusteringQa);*/
CbmLitTofQa* tofQa = new CbmLitTofQa();
tofQa->SetOutputDir(std::string(resultDir));
run->AddTask(tofQa);
// ----- Parameter database --------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo();
parIo1->open(parFile.Data());
parIo2->open(parFileList, "in");
rtdb->setFirstInput(parIo1);
rtdb->setSecondInput(parIo2);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
run->Init();
run->Run(0, nEvents);
// ----- Finish -------------------------------------------------------
timer.Stop();
std::cout << "Macro finished successfully." << std::endl;
std::cout << "Output file is " << recoFile << std::endl;
std::cout << "Parameter file is " << parFile << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time " << timer.CpuTime() << " s" << std::endl;
std::cout << " Test passed" << std::endl;
std::cout << " All ok " << std::endl;
}
void run_digi_Fi4()
{
// ----- Files ---------------------------------------------------------------
TString inFile = "sim2.root";
TString parFile = "par2.root";
TString outFile = "hits2.root";
// ---------------------------------------------------------------------------
// ----- Timer ---------------------------------------------------------------
TStopwatch timer;
timer.Start();
// ---------------------------------------------------------------------------
// ----- Digitization --------------------------------------------------------
FairRunAna* run = new FairRunAna();
run->SetInputFile(inFile);
run->SetOutputFile(outFile);
// ---------------------------------------------------------------------------
// ----- Connect the Digitization Task ---------------------------------------
/*R3BCalifaCrystalCal2Hit* califa_digitizer = new R3BCalifaCrystalCal2Hit();
run->AddTask(califa_digitizer);
// mTOF
R3BmTofDigitizer* mtof_digitizer = new R3BmTofDigitizer();
run->AddTask(mtof_digitizer);
// STaRTrack
R3BSTaRTraHitFinder* tra_digitizer = new R3BSTaRTraHitFinder();
run->AddTask(tra_digitizer);
// MFI
R3BMfiDigitizer* mfi_digitizer = new R3BMfiDigitizer();
run->AddTask(mfi_digitizer);
// PSP
R3BPspDigitizer* psp_digitizer = new R3BPspDigitizer();
run->AddTask(psp_digitizer);*/
// Fi4,5,6
R3BFi4Digitizer* Fi4_digitizer = new R3BFi4Digitizer(0.001,0.01,1);
run->AddTask(Fi4_digitizer);
// sfi
R3BsfiDigitizer* sfi_digitizer = new R3BsfiDigitizer(0.001,0.01);
run->AddTask(sfi_digitizer);
// ---------------------------------------------------------------------------
// ----- Runtime DataBase info -----------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile.Data());
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ---------------------------------------------------------------------------
// ----- Intialise and run ---------------------------------------------------
run->Init();
run->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 writen: " << outFile << endl;
cout << "Parameter file writen " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << " s" << endl;
cout << endl;
cout << " Test passed" << endl;
cout << " All ok " << endl;
cout << " Digitization successful." << endl;
// ---------------------------------------------------------------------------
RemoveGeoManager();
}
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);
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_reco( TString mcEngine="TGeant3", Bool_t AlignDone=true )
{
// ---- Load libraries -------------------------------------------------
FairLogger *logger = FairLogger::GetLogger();
// logger->SetLogFileName("MyLog.log");
logger->SetLogToScreen(kTRUE);
// logger->SetLogToFile(kTRUE);
// logger->SetLogVerbosityLevel("HIGH");
// logger->SetLogFileLevel("DEBUG4");
logger->SetLogScreenLevel("INFO");
// Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug)
Int_t iVerbose = 0; // just forget about it, for the moment
TString Align= "";
if (AlignDone) {
Align= "align_";
}
TString InDir = "./data/";
// Input file (MC Events)
TString inFile ="testrun_";
inFile = InDir +inFile + Align + mcEngine + ".root";
// Output file name
TString outFile ="testreco_";
outFile = InDir + outFile + Align + mcEngine + ".root";
// Parameter file
TString parFile ="testparams_";
parFile = InDir + parFile + Align + mcEngine + ".root";
// Millepede file name
TString milleFile ="testmille_";
milleFile = InDir + milleFile + Align + mcEngine;
TList *parFileList = new TList();
TString workDir = gSystem->Getenv("VMCWORKDIR");
TString paramDir = workDir + "/simulation/Tutorial4/parameters/";
TString paramFile = paramDir + "example.par";
TObjString tutDetDigiFile;
tutDetDigiFile.SetString(paramFile);
parFileList->Add(&tutDetDigiFile);
// ----- Timer --------------------------------------------------------
TStopwatch timer;
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
FairFileSource *fFileSource = new FairFileSource(inFile);
fRun->SetSource(fFileSource);
fRun->SetSink(new FairRootFileSink(outFile));
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo();
parIo2->open(parFileList, "in");
parInput1->open(parFile.Data());
parIo2->open(parFileList, "in");
rtdb->setFirstInput(parInput1);
rtdb->setSecondInput(parIo2);
rtdb->setOutput(parInput1);
rtdb->saveOutput();
// ----- TorinoDetector hit producers ---------------------------------
FairTutorialDet4HitProducerIdealMisalign* hitProducer = new FairTutorialDet4HitProducerIdealMisalign();
hitProducer->DoMisalignment(kFALSE);
fRun->AddTask(hitProducer);
FairTutorialDet4StraightLineFitter* fitter = new FairTutorialDet4StraightLineFitter();
fitter->SetVersion(2);
fRun->AddTask(fitter);
FairTutorialDet4MilleWriter* writer = new FairTutorialDet4MilleWriter();
// writer->SetWriteAscii(kTRUE);
writer->SetVersion(2);
writer->SetFileName(milleFile);
fRun->AddTask(writer);
fRun->Init();
timer.Start();
fRun->Run();
// ----- 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 simall(Int_t nEvents = 1,
TObjArray& fDetList,
Bool_t fVis=kFALSE,
TString fMC="TGeant3",
TString fGenerator="mygenerator",
Bool_t fUserPList= kFALSE
)
{
TString dir = getenv("VMCWORKDIR");
TString simdir = dir + "/macros";
TString sim_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",sim_geomdir.Data());
TString sim_confdir = dir + "gconfig";
gSystem->Setenv("CONFIG_DIR",sim_confdir.Data());
// Output files
TString OutFile = "simout.root";
TString ParFile = "simpar.root";
// 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("libGenVector");
gSystem->Load("libGeoBase");
gSystem->Load("libFairDB");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libMCStack");
gSystem->Load("libField");
gSystem->Load("libGen");
//---- Load specific libraries ---------------------------------------
gSystem->Load("libEnsarbase");
gSystem->Load("libEnsarGen");
gSystem->Load("libEnsarData");
gSystem->Load("libEnsarMyDet");
// ----- 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("g4Config.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 geometry --------------------------------------------
if (fDetList.FindObject("MYDET") ) {
//My Detector definition
EnsarDetector* mydet = new EnsarMyDet("MyDet", 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)
mydet->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
mydet->SetTranslation(tx,ty,tz);
run->AddModule(mydet);
}
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (fGenerator.CompareTo("mygenerator") == 0 ) {
// 2- Define the 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
Int_t multiplicity = 50; // multiplicity (nb particles per event)
FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId,multiplicity);
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);
}
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
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 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 -------------------------------------------------------
}
// 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);
}
/********************************************************************************
* 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_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;
}
void run_sample_data()
{
TStopwatch timer;
timer.Start();
const Int_t nev = -1; // number of events to read, -1 - untill CTRL+C
const Int_t trigger = -1; // 1 - onspill, 2 - offspill. -1 - all
TString filename = "sample_data_2.lmd";
TString outputFileName = "output_raw_land.root"; // name of output file
const Int_t refresh = 100000; // refresh rate for saving control histograms
TString parFileName = "params_raw_land.root"; // name of parameter file
const Int_t updateRate = 150000;
const Int_t minStats = 10000; // minimum number of entries for TCAL calibration
const Int_t nModules = 800; // number of photomultipliers (for TCAL calibration)
// Create source with unpackers ----------------------------------------------
TString ntuple_options = "UNPACK:EVENTNO,UNPACK:TRIGGER,RAW";
TString ucesb_dir = getenv("UCESB_DIR");
TString ucesb_path = ucesb_dir + "/../upexps/s438b/s438b";
EXT_STR_h101 ucesb_struct;
R3BUcesbSource* source = new R3BUcesbSource(filename, ntuple_options, ucesb_path, &ucesb_struct, sizeof(ucesb_struct));
source->SetMaxEvents(nev);
source->AddReader(new R3BUnpackReader((EXT_STR_h101_unpack*)&ucesb_struct.unpack, offsetof(EXT_STR_h101, unpack)));
source->AddReader(new R3BNeulandTacquilaReader((EXT_STR_h101_raw_nnp*)&ucesb_struct.nnp, offsetof(EXT_STR_h101, nnp)));
source->AddReader(new R3BLosReader((EXT_STR_h101_LOS*)&ucesb_struct.los, offsetof(EXT_STR_h101, los)));
// ---------------------------------------------------------------------------
// Create online run ---------------------------------------------------------
FairRunOnline* run = new FairRunOnline(source);
run->SetOutputFile(outputFileName.Data());
run->SetRunId(1111);
// ---------------------------------------------------------------------------
// Create ALADIN field map ---------------------------------------------------
R3BAladinFieldMap* magField = new R3BAladinFieldMap("AladinMaps");
Double_t fMeasCurrent = 2500.; // I_current [A]
magField->SetCurrent(fMeasCurrent);
magField->SetScale(1.);
run->SetField(magField);
// ---------------------------------------------------------------------------
// TCAL ----------------------------------------------------------------------
R3BNeulandMapped2CalPar* tcalFill = new R3BNeulandMapped2CalPar("TcalFill");
tcalFill->SetUpdateRate(updateRate);
tcalFill->SetMinStats(minStats);
tcalFill->SetTrigger(trigger);
tcalFill->SetNofModules(nModules);
run->AddTask(tcalFill);
R3BLosMapped2CalPar* losTcalFill = new R3BLosMapped2CalPar("LosTcalFill");
losTcalFill->SetUpdateRate(updateRate);
losTcalFill->SetMinStats(minStats);
losTcalFill->SetNofModules(1, 4);
run->AddTask(losTcalFill);
// ---------------------------------------------------------------------------
// Add analysis task ---------------------------------------------------------
R3BNeulandMappedHist* ana = new R3BNeulandMappedHist("LandRawAna", 1);
run->AddTask(ana);
// ---------------------------------------------------------------------------
// Initialize ----------------------------------------------------------------
run->Init();
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
// ---------------------------------------------------------------------------
// Runtime data base ---------------------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
R3BFieldPar* fieldPar = (R3BFieldPar*)rtdb->getContainer("R3BFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFileName);
rtdb->setOutput(parOut);
rtdb->print();
// ---------------------------------------------------------------------------
// Run -----------------------------------------------------------------------
if(nev < 0)
{
run->Run(nev, 0);
}
else
{
run->Run(0, nev);
}
rtdb->saveOutput();
// ---------------------------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outputFileName << endl;
cout << "Parameter file is " << parFileName << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl;
if(ana->GetNItemsTotal() > 3800)
{
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
delete run;
}
void run(TString runNumber)
{
TStopwatch timer;
timer.Start();
const Int_t nModules = 200;
TString dirIn1 = "/Volumes/Data/kresan/s438/data/";
TString dirIn2 = "/Volumes/Data/kresan/s438/tcal/";
TString dirOut = "/Volumes/Data/kresan/s438/tcal/";
TString inputFileName1 = dirIn1 + runNumber + "_tcal.root"; // name of input file
TString inputFileName2 = dirIn2 + runNumber + "_tcal_1.root"; // name of input file
TString parFileName = dirIn1 + "params_" + runNumber + "_tcal.root"; // name of parameter file
TString outputFileName = dirOut + runNumber + "_tcal_temp.root"; // name of output file
// Create analysis run -------------------------------------------------------
Int_t nFiles;
if (0 == runNumber.CompareTo("r122"))
{
nFiles = 22;
}
else if (0 == runNumber.CompareTo("r126"))
{
nFiles = 2;
}
// Create analysis run -------------------------------------------------------
FairRunAna* run = new FairRunAna();
run->SetInputFile(inputFileName1.Data());
run->AddFriend(inputFileName2.Data());
for (Int_t i = 1; i < nFiles; i++)
{
inputFileName1 = dirIn1 + runNumber + "_tcal_";
inputFileName1 += i;
inputFileName1 += ".root";
run->AddFile(inputFileName1.Data());
}
run->SetOutputFile(outputFileName.Data());
// ---------------------------------------------------------------------------
// ----- Runtime DataBase info -----------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFileName);
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
// Set the SQL IO as second input
FairParTSQLIo* inp = new FairParTSQLIo();
inp->SetVerbosity(1);
inp->open();
rtdb->setFirstInput(inp);
rtdb->saveOutput();
// ---------------------------------------------------------------------------
// Time calibration ----------------------------------------------------------
R3BLandTcal* landTcal = new R3BLandTcal("LandTcal", 1);
landTcal->SetNofModules(nModules, 40);
run->AddTask(landTcal);
R3BLosTcal* losTcal = new R3BLosTcal("LosTcal", 1);
losTcal->SetNofModules(20);
run->AddTask(losTcal);
// ---------------------------------------------------------------------------
// Initialize ----------------------------------------------------------------
run->Init();
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
// ---------------------------------------------------------------------------
// Run -----------------------------------------------------------------------
run->Run(0, 100000);
// ---------------------------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outputFileName << endl;
cout << "Parameter file is " << parFileName << 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 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;
// ------------------------------------------------------------------------
}
/********************************************************************************
* 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 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;
}
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 much_reco(){
Int_t nEvents=10;
TString dir = "data/";
TString mcFile = dir + "mc.root";
TString stsRecoFile = dir + "sts.reco.0.root";
TString outFile = dir + "much.reco.0.root";
TString parFile = dir + "param.root";
TString digiFile = gSystem->Getenv("VMCWORKDIR");
digiFile += "/parameters/much/much_v11a.digi.root";
TChain* mcFileChain = new TChain("cbmsim");
mcFileChain->AddFile(dir+"/mc.root");
Int_t iVerbose = 2;
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C");
muchlibs();
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(mcFile);
fRun->AddFriend(stsRecoFile);
fRun->SetOutputFile(outFile);
// --- MuCh digitizer ----------------------------------------------------
CbmMuchDigitizeAdvancedGem* digitize = new CbmMuchDigitizeAdvancedGem("MuchDigitizeAdvancedGem", digiFile, iVerbose);
digitize->SetSpotRadius(0.05);
digitize->SetQMaximum(500000);
digitize->SetNADCChannels(256);
digitize->SetMeanGasGain(17000);
digitize->SetDeadTime(500); // ns
digitize->SetDTime(4); // ns
fRun->AddTask(digitize);
CbmMuchFindHitsAdvancedGem* findHits = new CbmMuchFindHitsAdvancedGem("MuchFindHitsAdvancedGem", digiFile, iVerbose);
findHits->SetAlgorithm(3);
fRun->AddTask(findHits);
CbmLitFindGlobalTracks* finder = new CbmLitFindGlobalTracks();
finder->SetTrackingType("branch");
finder->SetMergerType("nearest_hit");
fRun->AddTask(finder);
CbmMuchMatchTracks* muchMatchTracks = new CbmMuchMatchTracks();
fRun->AddTask(muchMatchTracks);
// ------------------------------------------------------------------------
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile);
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
fRun->Init();
fRun->Run(0,nEvents);
return;
}
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;
// ------------------------------------------------------------------------
}
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());
}
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;
// ------------------------------------------------------------------------
}
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 r3blandreco(Int_t nNeutrons, Int_t beamE, Int_t Erel)
{
Int_t d;
if(Erel == 100){
d = 35;
}
else{
d = 14;
}
// ----- Files ---------------------------------------------------------------
char strDir[] = ".";
char str[100];
char str2[100];
sprintf(str, "%1dAMeV.%1dn.%1dkeV.%1dm.root", beamE,nNeutrons, Erel, d);
sprintf(str2, "%1dAMeV.%1dkeV.%1dm", beamE, Erel, d);
TString inFile = TString(strDir) + "/r3bsim." + TString(str);
TString digiFile = TString(strDir) + "/r3bcalibr." + TString(str);
TString parFile = TString(strDir) + "/r3bpar." + TString(str);
TString calibrFile = TString(strDir) + "/r3bcalibr." + TString(str2) + ".txt";
TString outFile = TString(strDir) + "/r3breco." + TString(str);
// ---------------------------------------------------------------------------
// ----- Timer ---------------------------------------------------------------
TStopwatch timer;
timer.Start();
// ---------------------------------------------------------------------------
// ----- Digitization --------------------------------------------------------
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(inFile);
fRun->AddFriend(digiFile);
fRun->SetOutputFile(outFile);
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
Double_t beamEnergy;
Double_t beamBeta;
if(200 == beamE) {
beamEnergy=200.;
beamBeta=0.5676881;
} else if(600 == beamE) {
beamEnergy=600.;
beamBeta=0.7937626;
} else if(1000 == beamE) {
beamEnergy=1000.;
beamBeta=0.8760237;
}
// ---------------------------------------------------------------------------
// ----- Connect the Tracking Task -------------------------------------------
R3BNeutronTracker2D* tracker = new R3BNeutronTracker2D();
tracker->UseBeam(beamEnergy, beamBeta);
tracker->ReadCalibrFile(calibrFile.Data());
fRun->AddTask(tracker);
// ---------------------------------------------------------------------------
// ----- Runtime DataBase info -----------------------------------------------
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile.Data());
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ---------------------------------------------------------------------------
// ----- Number of events to process -----------------------------------------
Int_t nEvents = 10000;
// ---------------------------------------------------------------------------
// ----- Intialise and run ---------------------------------------------------
fRun->Init();
fRun->Run(0, 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 writen: " << outFile << endl;
cout << "Parameter file writen " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << " s" << endl;
cout << 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;
}