/********************************************************************************
* 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" *
********************************************************************************/
Int_t sql_params_read()
{
// Create a Runtime Database singleton.
FairRuntimeDb* db = FairRuntimeDb::instance();
// Set the SQL IO as first input
FairParTSQLIo* inp = new FairParTSQLIo();
// Verbosity level
inp->SetVerbosity(1);
inp->open();
db->setFirstInput(inp);
// Create the container via the factory if not already created
FairDbTutPar* p1 = (FairDbTutPar*)(db->getContainer("TUTParDefault"));
FairDbTutPar* p2 = (FairDbTutPar*)(db->getContainer("TUTParAlternative"));
// Create a dummy runID using date in UTC from which
// corresponding parameters will be initialised
ValTimeStamp tStamp(2015,02,20,10,10,10);
UInt_t runId = tStamp.GetSec();
cout << "-I- looking for parameters at runID# " << runId << endl;
cout << "-I- corresponding time in runID (UTC) " << tStamp.Format("iso") << endl;
// Use the generated RunID to initialised the parameter
// using the SQL-based IO input
db->initContainers(runId);
// Get the container after initialisation
// from the RuntimeDB
FairDbTutPar* pp1 = (FairDbTutPar*)(db->getContainer("TUTParDefault"));
FairDbTutPar* pp2 = (FairDbTutPar*)(db->getContainer("TUTParAlternative"));
cout << endl;
cout << "-I- Reading Parameter data from SQL Database: \n" << endl;
cout << endl;
pp1->Print();
pp2->Print();
cout << endl;
if (db) delete db;
return 0;
}
Int_t calgeo_read()
{
// Create a Runtime Database singleton.
FairRuntimeDb* db = FairRuntimeDb::instance();
// Set the SQL IO as first input
FairParTSQLIo* inp = new FairParTSQLIo();
// Verbosity level
//inp->SetVerbosity(1);
inp->open();
db->setFirstInput(inp);
// Create in memory the relevant container
R3BCaloGeometryPar* par = (R3BCaloGeometryPar*)(db->getContainer("CaloGeometryPar"));
// Create a dummy runID using date in UTC from which
// corresponding parameters will be initialised
ValTimeStamp tStamp(2014,03,21,18,00,00);
UInt_t runId = tStamp.GetSec();
cout << "-I- looking for parameters at runID# " << runId << endl;
cout << "-I- corresponding time in runID (UTC) " << tStamp.Format("iso") << endl;
// Use the generated RunID to initialised the parameter
// using the SQL-based IO input
db->initContainers(runId);
// Get the container after initialisation
// from the RuntimeDB
R3BCaloGeometryPar* par = (R3BCaloGeometryPar*)(db->getContainer("CaloGeometryPar"));
cout << endl;
cout << "-I- Reading Parameter data from SQL Database: \n" << endl;
cout << endl;
par->Print();
cout << endl;
if (db) delete db;
return 0;
}
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(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 run_CbmIonGenerator(Int_t nEvents = 1)
{
// ========================================================================
// Adjust this part according to your requirements
// Input file
//TString inPath = "/d/cbm03/urqmd/auau/25gev/centr/";
//TString inFile = inPath + "urqmd.auau.25gev.centr.0000.ftn14";
// Output file
TString outFile = Form("sts.mc.root",nEvents);
// Parameter file
TString parFile = Form("params.root",nEvents);
// Cave geometry
TString caveGeom = "cave.geo";
// Target geometry
TString targetGeom = "target_au_250mu.geo";
// Beam pipe geometry
TString pipeGeom = "pipe_standard.geo";
// Magnet geometry and field map
TString magnetGeom = "passive/magnet_v09e.geo";
TString fieldMap = "field_v10e";
Double_t fieldZ = 50.; // z position of field centre
Double_t fieldScale = 1.; // field scaling factor
// MVD geometry
TString mvdGeom = "mvd/mvd_v07a.geo";
// STS geometry
TString stsGeom = "sts/sts_v11a.geo";
//STS geometry for the same z position of all sensors
//TString stsGeom = "sts_same_z.geo";
targetGeom = "";
magnetGeom = "";
stsGeom = "";
mvdGeom = "";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libCbmBase");
gSystem->Load("libCbmData");
gSystem->Load("libField");
gSystem->Load("libGen");
gSystem->Load("libPassive");
gSystem->Load("libMvd");
gSystem->Load("libSts");
gSystem->Load("libCbmGenerators"); // for CbmIonGenerator
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName("TGeant3"); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
run->AddModule(cave);
FairModule* pipe= new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
run->AddModule(pipe);
if( targetGeom != "") {
FairModule* target= new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
run->AddModule(target);
}
if( magnetGeom != "") {
FairModule* magnet= new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
run->AddModule(magnet);
}
if( mvdGeom != ""){
FairDetector* mvd= new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
run->AddModule(mvd);
}
if( stsGeom != "") {
FairDetector* sts= new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
run->AddModule(sts);
}
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
if(magnetGeom!="") {
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
run->SetField(magField);
}
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
//FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile);
//primGen->AddGenerator(urqmdGen);
// CbmIonGenerator - check in Load libraries: gSystem->Load("libCbmGenerators");
Int_t nions=10; // number of ions/event
cout<<"@@@@@> CbmIonGenerator is ON with "<<nions<<" ion(s)/event !!!"<<endl;
Int_t z=79, a=197, q=79; // Au-ion
Double_t p=8.; // in AGeV/c
Double_t vz=-0.0126; // in cm - z-pos. of vertex
Double_t meanX=0.3; // in cm - spatial distr. (XOY)
Double_t meanY=-0.2; // in cm
Double_t sigmaX = 0.078; // in cm - spatial distr. (XOY)
Double_t sigmaY = 0.032; // in cm
Double_t sigmatX = 0.00117885; // in rad (Px/P) - angular distr. (mean=0)
Double_t sigmatY = 0.00094955; // in rad (Py/P)
// Parameters of the trapezoid are set with respect to mean of Gaussian, NOT necesseraly in absolute coordinates.
// x1 < x2 < 0 < x3 < x4
Double_t x1=-0.10452, x2=-0.06942, x3=0.06942, x4=0.10452; // in cm - trapezoid distr.
Double_t y1=-0.04448, y2=-0.02688, y3=0.02688, y4=0.04448; // in cm
Double_t tX1=-0.00157966, tX2=-0.001049177, tX3=0.001049177, tX4=0.00157966; // in rad
Double_t tY1=-0.00131987, tY2=-0.000797622, tY3=0.000797622, tY4=0.00131987; // in rad
// CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY);
// CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz);
CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz,
x1, x2, x3, x4, y1, y2, y3, y4, tX1, tX2, tX3, tX4, tY1, tY2, tY3, tY4);
primGen->AddGenerator(IonGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
// run->SetStoreTraj(kTRUE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
if(magnetGeom!="") {
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(run->GetRunId(),1);
}
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
//run->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
exit(0);
}
void 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 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;
}
/********************************************************************************
* 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" *
********************************************************************************/
Int_t sql_params_read_bin()
{
// ---- 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("libTutorial5");
// Create a Runtime Database singleton.
FairRuntimeDb* db = FairRuntimeDb::instance();
// Set the SQL IO as first input
FairParTSQLIo* inp = new FairParTSQLIo();
// Verbosity level
inp->SetVerbosity(1);
inp->open();
db->setFirstInput(inp);
// Create the container via the factory if not already created
FairDbTutParBin* p1 = (FairDbTutParBin*)(db->getContainer("TUTParBin"));
p1->Print();
// Create a dummy runID using date in UTC from which
// corresponding parameters will be initialised
ValTimeStamp tStamp(2015,02,20,10,07,48);
UInt_t runId = tStamp.GetSec();
cout << "-I- looking for parameters at runID# " << runId << endl;
cout << "-I- corresponding time in runID (UTC) " << tStamp.AsString("c") << endl;
// Use the generated RunID to initialised the parameter
// using the SQL-based IO input
db->initContainers(runId);
cout << endl;
cout << "-I- Initialisation from SQL Database:" << endl;
cout << endl;
// Get the container after initialisation
// from the RuntimeDB
FairDbTutParBin* pp1 = (FairDbTutParBin*)(db->getContainer("TUTParBin"));
pp1->Print();
cout << endl;
if (db) delete db;
return 0;
}
void sim(Int_t file_nr=0, Int_t nEvents=1, Int_t s=0, Int_t seed=1){
Char_t filenr[4];
sprintf(filenr,"%04d",file_nr);
printf("Filenr: %s\n", filenr);
TString signal;
if (s!=3312 && s!=3334) signal = "la";
else if (s==3312) signal = "xi";
else if (s==3334) signal = "om";
// ----- Paths and file names --------------------------------------------
TString inDir = gSystem->Getenv("URQMD_INPUT_PATH");
TString inFile = inDir + "/urqmd.auau.25gev.centr." + filenr + ".ftn14";
TString outDir= TString(filenr);
outDir+= "/";
gSystem->mkdir(outDir.Data());
TString outFile = outDir+signal+".mc.root";
TString parFile = outDir+signal+".par.root";
// ----- Geometries -----------------------------------------------------
TString caveGeom = "cave.geo";
TString pipeGeom = "pipe_standard.geo";
TString targetGeom = "target_au_250mu.geo";
TString magnetGeom = "magnet_standard.geo";
TString stsGeom = "sts_Standard_s3055AAFK5.SecD.geo";
// ----- Magnetic field -----------------------------------------------
TString fieldMap = "FieldMuonMagnet"; // name of field map
Double_t fieldZ = 50.; // field centre z position
Double_t fieldScale = 1.; // field scaling factor
gDebug = 0;
gRandom->SetSeed(seed);
// ---- Load libraries -------------------------------------------------
cout << endl << "=== much_sim.C : Loading libraries ..." << endl;
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/analysis/hyperon/analysislibs.C");
analysislibs();
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3");
fRun->SetOutputFile(outFile.Data());
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
fRun->SetMaterials("media.geo");
// ----- Create detectors and passive volumes -------------------------
cout << endl << "=== much_sim.C : Create geeometry ..." << endl;
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
cout << " --- " << caveGeom << endl;
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
cout << " --- " << pipeGeom << endl;
}
if ( targetGeom != "" ) {
FairModule* target = new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
fRun->AddModule(target);
cout << " --- " << targetGeom << endl;
}
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
cout << " --- " << magnetGeom << endl;
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
cout << " --- " << stsGeom << endl;
fRun->AddModule(sts);
}
// ----- Create magnetic field ----------------------------------------
cout << endl << "=== much_sim.C : Create magnetic field ..." << endl;
CbmFieldMap* magField = NULL;
if ( fieldMap == "FieldActive" || fieldMap == "FieldIron")
magField = new CbmFieldMapSym3(fieldMap);
else if ( fieldMap == "FieldAlligator" )
magField = new CbmFieldMapSym2(fieldMap);
else if ( fieldMap == "FieldMuonMagnet" )
magField = new CbmFieldMapSym3(fieldMap);
else {
cout << "===> ERROR: Field map " << fieldMap << " unknown! " << endl;
exit;
}
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ----- Create PrimaryGenerator --------------------------------------
cout << endl << "=== much_sim.C : Create generators ..." << endl;
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (signal=="om"){
delete gRandom;
gRandom = new TRandom3();
CbmAnaHypYPtGenerator* gen = new CbmAnaHypYPtGenerator(3334);
gen->SetDistributionPt(0.1603); // 6 GeV
gen->SetDistributionY(1.277,0.412); // 6 GeV
//gen->SetDistributionPt(0.149808); // 25 GeV
//gen->SetDistributionY(1.9875,0.546669); // 25 GeV
gen->Init();
primGen->AddGenerator(gen);
} else if (signal=="xi"){
delete gRandom;
gRandom = new TRandom3();
CbmAnaHypYPtGenerator* gen = new CbmAnaHypYPtGenerator(3312);
gen->SetDistributionPt(0.1603); // 6 GeV
gen->SetDistributionY(1.277,0.412); // 6 GeV
//gen->SetDistributionPt(0.154319); // 25 GeV
//gen->SetDistributionY(1.98604,0.617173); // 25 GeV
gen->Init();
primGen->AddGenerator(gen);
}
FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile.Data());
primGen->AddGenerator(urqmdGen);
fRun->SetGenerator(primGen);
// ------------------------------------------------------------------------
fRun->Init();
// ------------------------------------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile);
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
TStopwatch timer;
timer.Start();
fRun->Run(nEvents);
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "=== sim.C : Macro finished successfully." << endl;
cout << "=== sim.C : Output file is " << outFile << endl;
cout << "=== sim.C : Real time used: " << rtime << "s " << endl;
cout << "=== sim.C : CPU time used : " << ctime << "s " << endl;
cout << endl << endl;
// ------------------------------------------------------------------------
}
void run_sim(Int_t nEvents = 2)
{
// ========================================================================
// Adjust this part according to your requirements
// ----- Paths and file names --------------------------------------------
TString inDir = gSystem->Getenv("VMCWORKDIR");
TString inFile = inDir + "/input/urqmd.ftn14";
TString outDir = "data";
TString outFile = outDir + "/test.mc.root";
TString parFile = outDir + "/params.root";
TString HsdFile = "./jpsiHsd.auau25gev.000";
// ----- Geometries -----------------------------------------------------
TString caveGeom = "cave.geo";
TString targetGeom = "target_au_250mu.geo";
TString pipeGeom = "pipe_standard.geo";
TString magnetGeom = "passive/magnet_v09e.geo";
TString mvdGeom = "mvd/mvd_v07a.geo";
TString stsGeom = "sts/sts_v11a.geo";
TString richGeom = "rich/rich_v08a.geo";
TString trdGeom = "trd/trd_v11c.geo";
TString tofGeom = "tof/tof_v07a.geo";
// TString ecalGeom = "ecal/ecal_v08a.geo";
// ----- Magnetic field -----------------------------------------------
TString fieldMap = "field_v10e"; // name of field map
Double_t fieldZ = 50.; // field centre z position
Double_t fieldScale = 1.; // field scaling factor
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libCbmBase");
gSystem->Load("libCbmData");
gSystem->Load("libField");
gSystem->Load("libGen");
gSystem->Load("libCbmGenerators");
gSystem->Load("libPassive");
gSystem->Load("libEcal");
gSystem->Load("libKF");
gSystem->Load("libMvd");
gSystem->Load("libSts");
gSystem->Load("libRich");
gSystem->Load("libTrd");
gSystem->Load("libTof");
// -----------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3"); // Transport engine
fRun->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
fRun->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create detectors and passive volumes -------------------------
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
}
if ( targetGeom != "" ) {
FairModule* target = new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
fRun->AddModule(target);
}
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
}
if ( mvdGeom != "" ) {
FairDetector* mvd = new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
fRun->AddModule(mvd);
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
fRun->AddModule(sts);
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
fRun->AddModule(rich);
}
if ( trdGeom != "" ) {
FairDetector* trd = new CbmTrd("TRD",kTRUE );
trd->SetGeometryFileName(trdGeom);
fRun->AddModule(trd);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
fRun->AddModule(tof);
}
/*
if ( ecalGeom != "" ) {
FairDetector* ecal = new CbmEcal("ECAL", kTRUE, ecalGeom.Data());
fRun->AddModule(ecal);
}
*/
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile);
primGen->AddGenerator(urqmdGen);
CbmHsdGenerator* hsdGen = new CbmHsdGenerator(HsdFile,"Jpsi");
primGen->AddGenerator(hsdGen);
fRun->SetGenerator(primGen);
// ------------------------------------------------------------------------
// Decay J/Psi using Pythia
fRun->SetPythiaDecayer("./DecayConfig.C");
// -Trajectories Visualization (TGeoManager Only )
// Switch this on if you want to visualize tracks in the
// eventdisplay.
// This is normally switch off, because of the huge files created
// when it is switched on.
// fRun->SetStoreTraj(kTRUE);
// ----- Run initialisation -------------------------------------------
fRun->Init();
// ------------------------------------------------------------------------
// Set cuts for storing the trajectories.
// Switch this on only if trajectories are stored.
// Choose this cuts according to your needs, but be aware
// that the file size of the output file depends on these cuts
// FairTrajFilter* trajFilter = FairTrajFilter::Instance();
// trajFilter->SetStepSizeCut(0.01); // 1 cm
// trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
// trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
// trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
// trajFilter->SetStorePrimaries(kTRUE);
// trajFilter->SetStoreSecondaries(kTRUE);
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
fRun->Run(nEvents);
// ------------------------------------------------------------------------
fRun->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void global_sim(Int_t nEvents = 10, Int_t seed = 555)
{
gRandom->SetSeed(seed);
TString script = TString(gSystem->Getenv("LIT_SCRIPT"));
// Files
// TString urqmdFile = "/Users/andrey/Development/cbm/d/urqmd/auau/25gev/centr/urqmd.auau.25gev.centr.0000.ftn14"; // input UrQMD file
TString urqmdFile = "../../input/urqmd.auau.25gev.centr.0000.ftn14"; // input UrQMD file
TString dir = "data/"; // Directory for output simulation files
TString mcFile = dir + "mc.0000.root"; //MC file name
TString parFile = dir + "param.0000.root"; //Parameter file name
// Geometry
TString caveGeom = "cave.geo";
TString targetGeom = "target_au_250mu.geo";
TString pipeGeom = "pipe_standard.geo";
TString stsGeom = "sts/sts_v12b.geo.root";
TString richGeom = "rich/rich_v08a.geo";
TString tofGeom = "tof/tof_V13b.geo";
TString fieldMap = "field_v12a";
TString magnetGeom = "passive/magnet_v12a.geo";
// If SCRIPT environment variable is set to "yes", i.e. macro is run via script
if (script == "yes") {
urqmdFile = TString(gSystem->Getenv("LIT_URQMD_FILE"));
mcFile = TString(gSystem->Getenv("LIT_MC_FILE"));
parFile = TString(gSystem->Getenv("LIT_PAR_FILE"));
}
// ----- Magnetic field -----------------------------------------------
Double_t fieldZ = 50.; // field center z position
Double_t fieldScale = 1.; // field scaling factor
TStopwatch timer;
timer.Start();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C");
loadlibs();
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3"); // Transport engine
fRun->SetOutputFile(mcFile); // Output file
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
fRun->SetMaterials("media.geo"); // Materials
// fRun->SetStoreTraj(kTRUE);
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
cout << " --- " << caveGeom << endl;
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
cout << " --- " << pipeGeom << endl;
}
if ( targetGeom != "" ) {
FairModule* target = new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
fRun->AddModule(target);
cout << " --- " << targetGeom << endl;
}
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
cout << " --- " << magnetGeom << endl;
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
fRun->AddModule(sts);
cout << " --- " << stsGeom << endl;
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
fRun->AddModule(rich);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
fRun->AddModule(tof);
cout << " --- " << tofGeom << endl;
}
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ------------------------------------------------------------------------
CbmMCEventHeader* mcHeader = new CbmMCEventHeader();
fRun->SetMCEventHeader(mcHeader);
// ------------------------------------------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
// CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(urqmdFile);
CbmUrqmdGenerator* urqmdGen = new CbmUrqmdGenerator(urqmdFile);
primGen->AddGenerator(urqmdGen);
fRun->SetGenerator(primGen);
fRun->Init();
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
fRun->Run(nEvents);
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished successfully." << endl;
cout << "Test passed"<< endl;
cout << " All ok " << endl;
cout << "Output file is " << mcFile << endl;
cout << "Real time used: " << rtime << "s " << endl;
cout << "CPU time used : " << ctime << "s " << endl << endl << endl;
// ------------------------------------------------------------------------
}
void r3ball(Int_t nEvents = 1,
TMap& fDetList,
TString Target = "LeadTarget",
Bool_t fVis = kFALSE,
TString fMC = "TGeant3",
TString fGenerator = "box",
Bool_t fUserPList = kFALSE,
Bool_t fR3BMagnet = kTRUE,
Bool_t fCalifaHitFinder = kFALSE,
Bool_t fStarTrackHitFinder = kFALSE,
Double_t fMeasCurrent = 2000.,
TString OutFile = "r3bsim.root",
TString ParFile = "r3bpar.root",
TString InFile = "evt_gen.dat",
double energy1, double energy2)
{
TString dir = getenv("VMCWORKDIR");
TString r3bdir = dir + "/macros";
TString r3b_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",r3b_geomdir.Data());
TString r3b_confdir = dir + "gconfig";
gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data());
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(fMC.Data()); // Transport engine
run->SetOutputFile(OutFile.Data()); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairLogger::GetLogger()->SetLogScreenLevel("DEBUG");
// R3B Special Physics List in G4 case
if ( (fUserPList == kTRUE ) &&
(fMC.CompareTo("TGeant4") == 0)
){
run->SetUserConfig("g4R3bConfig.C");
run->SetUserCuts("SetCuts.C");
}
// ----- Create media -------------------------------------------------
run->SetMaterials("media_r3b.geo"); // Materials
// Magnetic field map type
Int_t fFieldMap = 0;
// Global Transformations
//- Two ways for a Volume Rotation are supported
//-- 1) Global Rotation (Euler Angles definition)
//-- This represent the composition of : first a rotation about Z axis with
//-- angle phi, then a rotation with theta about the rotated X axis, and
//-- finally a rotation with psi about the new Z axis.
Double_t phi,theta,psi;
//-- 2) Rotation in Ref. Frame of the Volume
//-- Rotation is Using Local Ref. Frame axis angles
Double_t thetaX,thetaY,thetaZ;
//- Global Translation Lab. frame.
Double_t tx,ty,tz;
// ----- Create R3B geometry --------------------------------------------
//R3B Cave definition
FairModule* cave= new R3BCave("CAVE");
cave->SetGeometryFileName("r3b_cave.geo");
run->AddModule(cave);
//R3B Target definition
if (fDetList.FindObject("TARGET") ) {
R3BModule* target= new R3BTarget(Target.Data());
target->SetGeometryFileName(((TObjString*)fDetList.GetValue("TARGET"))->GetString().Data());
run->AddModule(target);
}
//R3B SiTracker Cooling definition
if (fDetList.FindObject("VACVESSELCOOL") ) {
R3BModule* vesselcool= new R3BVacVesselCool(Target.Data());
vesselcool->SetGeometryFileName(((TObjString*)fDetList.GetValue("VACVESSELCOOL"))->GetString().Data());
run->AddModule(vesselcool);
}
//R3B Magnet definition
if (fDetList.FindObject("ALADIN") ) {
fFieldMap = 0;
R3BModule* mag = new R3BMagnet("AladinMagnet");
mag->SetGeometryFileName(((TObjString*)fDetList.GetValue("ALADIN"))->GetString().Data());
run->AddModule(mag);
}
//R3B Magnet definition
if (fDetList.FindObject("GLAD") ) {
fFieldMap = 1;
R3BModule* mag = new R3BGladMagnet("GladMagnet", ((TObjString*)fDetList->GetValue("GLAD"))->GetString(), "GLAD Magnet");
run->AddModule(mag);
}
if (fDetList.FindObject("CRYSTALBALL") ) {
//R3B Crystal Calorimeter
R3BDetector* xball = new R3BXBall("XBall", kTRUE);
xball->SetGeometryFileName(((TObjString*)fDetList.GetValue("CRYSTALBALL"))->GetString().Data());
run->AddModule(xball);
}
if (fDetList.FindObject("CALIFA") ) {
// CALIFA Calorimeter
R3BDetector* califa = new R3BCalifa("Califa", kTRUE);
// ((R3BCalifa *)califa)->SelectGeometryVersion(0x438b);
((R3BCalifa *)califa)->SelectGeometryVersion(17);
//Selecting the Non-uniformity of the crystals (1 means +-1% max deviation)
((R3BCalifa *)califa)->SetNonUniformity(.0);
califa->SetGeometryFileName(((TObjString*)fDetList.GetValue("CALIFA"))->GetString().Data());
run->AddModule(califa);
}
// Tracker
if (fDetList.FindObject("TRACKER") ) {
R3BDetector* tra = new R3BTra("Tracker", kTRUE);
tra->SetGeometryFileName(((TObjString*)fDetList.GetValue("TRACKER"))->GetString().Data());
run->AddModule(tra);
}
// STaRTrack
if (fDetList.FindObject("STaRTrack") ) {
R3BDetector* tra = new R3BSTaRTra("STaRTrack", kTRUE);
tra->SetGeometryFileName(((TObjString*)fDetList.GetValue("STaRTrack"))->GetString().Data());
run->AddModule(tra);
}
// DCH drift chambers
if (fDetList.FindObject("DCH") ) {
R3BDetector* dch = new R3BDch("Dch", kTRUE);
dch->SetGeometryFileName(((TObjString*)fDetList.GetValue("DCH"))->GetString().Data());
run->AddModule(dch);
}
// Tof
if (fDetList.FindObject("TOF") ) {
R3BDetector* tof = new R3BTof("Tof", kTRUE);
tof->SetGeometryFileName(((TObjString*)fDetList.GetValue("TOF"))->GetString().Data());
run->AddModule(tof);
}
// mTof
if (fDetList.FindObject("MTOF") ) {
R3BDetector* mTof = new R3BmTof("mTof", kTRUE);
mTof->SetGeometryFileName(((TObjString*)fDetList.GetValue("MTOF"))->GetString().Data());
run->AddModule(mTof);
}
// GFI detector
if (fDetList.FindObject("GFI") ) {
R3BDetector* gfi = new R3BGfi("Gfi", kTRUE);
gfi->SetGeometryFileName(((TObjString*)fDetList.GetValue("GFI"))->GetString().Data());
run->AddModule(gfi);
}
// Land Detector
if (fDetList.FindObject("LAND") ) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(1);
land->SetGeometryFileName(((TObjString*)fDetList.GetValue("LAND"))->GetString().Data());
run->AddModule(land);
}
// NeuLand Scintillator Detector
if(fDetList.FindObject("SCINTNEULAND")) {
R3BDetector* land = new R3BLand("Land", kTRUE);
land->SetVerboseLevel(1);
land->SetGeometryFileName(((TObjString*)fDetList.GetValue("SCINTNEULAND"))->GetString().Data());
run->AddModule(land);
}
// MFI Detector
if(fDetList.FindObject("MFI")) {
R3BDetector* mfi = new R3BMfi("Mfi", kTRUE);
mfi->SetGeometryFileName(((TObjString*)fDetList.GetValue("MFI"))->GetString().Data());
run->AddModule(mfi);
}
// PSP Detector
if(fDetList.FindObject("PSP")) {
R3BDetector* psp = new R3BPsp("Psp", kTRUE);
psp->SetGeometryFileName(((TObjString*)fDetList.GetValue("PSP"))->GetString().Data());
run->AddModule(psp);
}
// Luminosity detector
if (fDetList.FindObject("LUMON") ) {
R3BDetector* lumon = new ELILuMon("LuMon", kTRUE);
lumon->SetGeometryFileName(((TObjString*)fDetList.GetValue("LUMON"))->GetString().Data());
run->AddModule(lumon);
}
// ----- Create R3B magnetic field ----------------------------------------
Int_t typeOfMagneticField = 0;
Int_t fieldScale = 1;
Bool_t fVerbose = kFALSE;
//NB: <D.B>
// If the Global Position of the Magnet is changed
// the Field Map has to be transformed accordingly
if (fFieldMap == 0) {
R3BAladinFieldMap* magField = new R3BAladinFieldMap("AladinMaps");
magField->SetCurrent(fMeasCurrent);
magField->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} else if(fFieldMap == 1){
R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap");
magField->SetScale(fieldScale);
if ( fR3BMagnet == kTRUE ) {
run->SetField(magField);
} else {
run->SetField(NULL);
}
} //! end of field map section
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (fGenerator.CompareTo("ion") == 0 ) {
// R3B Ion Generator
Int_t z = 30; // Atomic number
Int_t a = 65; // Mass number
Int_t q = 0; // Charge State
Int_t m = 1; // Multiplicity
Double_t px = 40./a; // X-Momentum / per nucleon!!!!!!
Double_t py = 600./a; // Y-Momentum / per nucleon!!!!!!
Double_t pz = 0.01/a; // Z-Momentum / per nucleon!!!!!!
R3BIonGenerator* ionGen = new R3BIonGenerator(z,a,q,m,px,py,pz);
ionGen->SetSpotRadius(1,1,0);
// add the ion generator
primGen->AddGenerator(ionGen);
}
if (fGenerator.CompareTo("ascii") == 0 ) {
R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir+"/input/"+InFile).Data());
primGen->AddGenerator(gen);
}
if (fGenerator.CompareTo("box") == 0 ) {
// 2- Define the BOX generator
Double_t pdgId=2212; // proton beam
Double_t theta1= 25.; // polar angle distribution
//Double_t theta2= 7.;
Double_t theta2= 66.;
// Double_t momentum=1.09008; // 500 MeV/c
// Double_t momentum=0.4445834; // 100 MeV/c
Double_t momentum1=TMath::Sqrt(energy1*energy1 + 2*energy1*0.938272046);
Double_t momentum2=TMath::Sqrt(energy2*energy2 + 2*energy2*0.938272046);
FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 1);
boxGen->SetThetaRange ( theta1, theta2);
boxGen->SetPRange (momentum1,momentum2);
boxGen->SetPhiRange (0,360.);
//boxGen->SetXYZ(0.0,0.0,-1.5);
boxGen->SetXYZ(0.0,0.0,0.0);
boxGen->SetDebug(kFALSE);
// add the box generator
primGen->AddGenerator(boxGen);
//primGen->SetTarget(0.25, 0.5);
//primGen->SmearVertexZ(kTRUE);
}
if (fGenerator.CompareTo("gammas") == 0 ) {
// 2- Define the CALIFA Test gamma generator
//Double_t pdgId=22; // gamma emission
Double_t pdgId=2212; // proton emission
Double_t theta1= 10.; // polar angle distribution
Double_t theta2= 40.;
//Double_t theta2= 90.;
//Double_t momentum=0.002; // 0.010 GeV/c = 10 MeV/c
Double_t momentumI=0.002; // 0.010 GeV/c = 10 MeV/c
Double_t momentumF=0.002; // 0.010 GeV/c = 10 MeV/c
//Double_t momentumF=0.808065; // 0.808065 GeV/c (300MeV Kin Energy for protons)
//Double_t momentumI=0.31016124; // 0.31016124 GeV/c (50MeV Kin Energy for protons)
//Double_t momentum=0.4442972; // 0.4442972 GeV/c (100MeV Kin Energy for protons)
//Double_t momentum=0.5509999; // 0.5509999 GeV/c (150MeV Kin Energy for protons)
//Double_t momentumI=0.64405; // 0.64405 GeV/c (200MeV Kin Energy for protons)
Int_t multiplicity = 1;
R3BCALIFATestGenerator* gammasGen = new R3BCALIFATestGenerator(pdgId, multiplicity);
gammasGen->SetThetaRange (theta1, theta2);
gammasGen->SetCosTheta();
gammasGen->SetPRange(momentumI,momentumF);
gammasGen->SetPhiRange(-180.,180.);
//gammasGen->SetXYZ(0.0,0.0,-1.5);
//gammasGen->SetXYZ(0.0,0.0,0);
gammasGen->SetBoxXYZ(-0.1,0.1,-0.1,0.1,-0.1,0.1);
//gammasGen->SetLorentzBoost(0.8197505718204776); //beta=0.81975 for 700 A MeV
// add the gamma generator
primGen->AddGenerator(gammasGen);
}
if (fGenerator.CompareTo("r3b") == 0 ) {
R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator();
// R3bGen properties
pR3bGen->SetBeamInteractionFlag("off");
pR3bGen->SetRndmFlag("off");
pR3bGen->SetRndmEneFlag("off");
pR3bGen->SetBoostFlag("off");
pR3bGen->SetReactionFlag("on");
pR3bGen->SetGammasFlag("off");
pR3bGen->SetDecaySchemeFlag("off");
pR3bGen->SetDissociationFlag("off");
pR3bGen->SetBackTrackingFlag("off");
pR3bGen->SetSimEmittanceFlag("off");
// R3bGen Parameters
pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV
pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV
pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code
pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV
Int_t fMultiplicity = 50;
pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult.
// Reaction type
// 1: "Elas"
// 2: "iso"
// 3: "Trans"
pR3bGen->SetReactionType("Elas");
// Target type
// 1: "LeadTarget"
// 2: "Parafin0Deg"
// 3: "Parafin45Deg"
// 4: "LiH"
pR3bGen->SetTargetType(Target.Data());
Double_t thickness = (0.11/2.)/10.; // cm
pR3bGen->SetTargetHalfThicknessPara(thickness); // cm
pR3bGen->SetTargetThicknessLiH(3.5); // cm
pR3bGen->SetTargetRadius(1.); // cm
pR3bGen->SetSigmaXInEmittance(1.); //cm
pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm
// Dump the User settings
pR3bGen->PrintParameters();
primGen->AddGenerator(pR3bGen);
}
if (fGenerator.CompareTo("p2p") == 0 ) {
R3Bp2pGenerator* gen = new R3Bp2pGenerator(("/lustre/nyx/fairgsi/mwinkel/r3broot/input/p2p/build/" + InFile).Data());
primGen->AddGenerator(gen);
#if 0
// Coincident gammas
R3BGammaGenerator *gammaGen = new R3BGammaGenerator();
gammaGen->SetEnergyLevel(0, 0.);
gammaGen->SetEnergyLevel(1, 3E-3);
gammaGen->SetEnergyLevel(2, 4E-3);
gammaGen->SetBranchingRatio(2, 1, 0.5);
gammaGen->SetBranchingRatio(2, 0, 0.5);
gammaGen->SetBranchingRatio(1, 0, 1.);
gammaGen->SetInitialLevel(2);
gammaGen->SetLorentzBoost(TVector3(0, 0, 0.777792));
primGen->AddGenerator(gammaGen);
#endif
}
run->SetGenerator(primGen);
//-------Set visualisation flag to true------------------------------------
run->SetStoreTraj(fVis);
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
// ----- Initialize CalifaHitFinder task (CrystalCal to Hit) ------------------------------------
if(fCalifaHitFinder) {
R3BCalifaCrystalCal2Hit* califaHF = new R3BCalifaCrystalCal2Hit();
califaHF->SetClusteringAlgorithm(1,0);
califaHF->SetDetectionThreshold(0.000050);//50 KeV
califaHF->SetExperimentalResolution(6.); //percent @ 1 MeV
//califaHF->SetComponentResolution(.25); //sigma = 0.5 MeV
califaHF->SetPhoswichResolution(3.,5.); //percent @ 1 MeV for LaBr and LaCl
califaHF->SelectGeometryVersion(17);
califaHF->SetAngularWindow(0.25,0.25); //[0.25 around 14.3 degrees, 3.2 for the complete calorimeter]
run->AddTask(califaHF);
}
// ----- Initialize StarTrackHitfinder task ------------------------------------
if(fStarTrackHitFinder) {
R3BSTaRTraHitFinder* trackHF = new R3BSTaRTraHitFinder();
//trackHF->SetClusteringAlgorithm(1,0);
trackHF->SetDetectionThreshold(0.000050); //50 KeV
trackHF->SetExperimentalResolution(0.);
//trackHF->SetAngularWindow(0.15,0.15); //[0.25 around 14.3 degrees, 3.2 for the complete calorimeter]
run->AddTask(trackHF);
}
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------ Increase nb of step for CALO
Int_t nSteps = 150000;
TVirtualMC::GetMC()->SetMaxNStep(nSteps);
// ----- Runtime database ---------------------------------------------
R3BFieldPar* fieldPar = (R3BFieldPar*) rtdb->getContainer("R3BFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(ParFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ----- Start run ----------------------------------------------------
if(nEvents > 0) {
run->Run(nEvents);
}
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << OutFile << endl;
cout << "Parameter file is " << ParFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void run(TString runNumber)
{
TStopwatch timer;
timer.Start();
const Int_t nev = -1; // number of events to read, -1 - untill CTRL+C
TString inDir = "/Volumes/Data/kresan/s438b/lmd/"; // directory with lmd files
TString outDir = "/Volumes/Data/kresan/s438b/data/"; // output directory
TString histDir = "/Users/kresan/Sites/"; // web-server directory
TString outputFileName = outDir + runNumber + "_raw.root"; // name of output file
TString histFileName = histDir + "hist_s438b_" + runNumber + "_raw.root"; // name of file with control histograms
const Int_t refresh = 100000; // refresh rate for saving control histograms
TString parFileName = outDir + "params_" + runNumber + "_raw.root"; // name of parameter file
//const Long64_t maxSize = 1 * 1024 * 1024 * 1024; // 1 GByte // file split size
const char *landMappingName = "cfg_neuland_s438b.hh"; // mapping file
const Int_t nBarsPerPlane = 50;
const Int_t updateRate = 150000;
const Int_t minStats = 5000;
const Int_t nModules = 800;
// Create source with unpackers ----------------------------------------------
Int_t iFile = 0;
Int_t kFile = 0;
if(runNumber.Contains("run331"))
{
iFile = 5209;
kFile = 5229;
}
FairLmdSource* source = new FairLmdSource();
char strName[1000];
for(Int_t i = iFile; i < kFile; i++)
{
sprintf(strName, "%s%s_%4d.lmd", inDir.Data(), runNumber.Data(), i);
for(Int_t j = 0; j < 1000; j++) if(' ' == strName[j]) strName[j] = '0';
cout << strName << endl;
source->AddFile(strName);
}
R3BEventHeaderUnpack *event_unpack = new R3BEventHeaderUnpack();
source->AddUnpacker(event_unpack);
// NeuLAND MBS parameters -------------------------------
Short_t type = 94;
Short_t subType = 9400;
Short_t procId = 12;
Short_t subCrate = 0;
Short_t control = 3;
source->AddUnpacker(new R3BLandUnpack(type, subType, procId, subCrate, control));
// ------------------------------------------------------
// LOS MBS parameters -----------------------------------
type = 88;
subType = 8800;
procId = 10;
subCrate = 7;
control = 5;
//source->AddUnpacker(new R3BLosUnpack(type, subType, procId, subCrate, control));
// ------------------------------------------------------
// ---------------------------------------------------------------------------
// Create online run ---------------------------------------------------------
FairRunOnline* run = new FairRunOnline(source);
run->SetOutputFile(outputFileName.Data());
run->SetGenerateHtml(kTRUE, histFileName.Data(), refresh);
// ---------------------------------------------------------------------------
// 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);
// ---------------------------------------------------------------------------
// Channel mapping -----------------------------------------------------------
R3BLandMapping* map = new R3BLandMapping();
map->SetFileName(landMappingName);
map->SetNofBarsPerPlane(nBarsPerPlane);
run->AddTask(map);
// ---------------------------------------------------------------------------
// TCAL ----------------------------------------------------------------------
R3BLandTcalFill* tcalFill = new R3BLandTcalFill("TcalFill");
tcalFill->SetUpdateRate(updateRate);
tcalFill->SetMinStats(minStats);
tcalFill->SetTrigger(2);
tcalFill->SetNofModules(nModules, 50);
run->AddTask(tcalFill);
R3BLosTcalFill* losTcalFill = new R3BLosTcalFill("LosTcalFill");
losTcalFill->SetUpdateRate(updateRate);
losTcalFill->SetMinStats(minStats);
losTcalFill->SetNofModules(20);
//run->AddTask(losTcalFill);
// ---------------------------------------------------------------------------
// Add analysis task ---------------------------------------------------------
R3BLandRawAna* ana = new R3BLandRawAna("LandRawAna", 1);
run->AddTask(ana);
// ---------------------------------------------------------------------------
// Initialize ----------------------------------------------------------------
run->Init();
//((TTree*)gFile->Get("cbmsim"))->SetMaxTreeSize(maxSize);
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 -----------------------------------------------------------------------
run->Run(nev, 0);
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;
}
/********************************************************************************
* 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" *
********************************************************************************/
Int_t sql_params_write_bin()
{
// ---- 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("libTutorial5");
// Generate a unique RunID
FairRunIdGenerator runID;
UInt_t runId = runID.generateId();
FairRuntimeDb* db = FairRuntimeDb::instance();
cout << "-I- FairRuntimeDb created ----> " << db << endl;
// Create in memory the relevant container
FairDbTutParBin* p1 = (FairDbTutParBin*)(db->getContainer("TUTParBin"));
// Set the Ascii IO as first input
FairParAsciiFileIo* inp1 = new FairParAsciiFileIo();
//TString work = getenv("VMCWORKDIR");
TString filename = "ascii-example_bin.par";
inp1->open(filename.Data(),"in");
db->setFirstInput(inp1);
// Set the SQL based IO as second input
FairParTSQLIo* inp2 = new FairParTSQLIo();
inp2->open();
db->setSecondInput(inp2);
// <INIT> containers from Ascii input
// with assigned RunId
db->initContainers(runId);
// Additionnally prime some dummy values to the data members that are not
// initialized using the ascii input file .
p1->FillDummy();
cout << endl;
cout << "\n -I- FAIRDB: RuntimeDB::init from Ascii File done using RunID# " << runId << endl;
cout << endl;
// <WRITE> back containers to the user-defined
// Database using the Sql based IO of the
// second input.
db->setOutput(inp2);
db->writeContainers();
cout << endl;
cout << "-I- FAIRDB: RuntimeDB Parameters successfully written to DB with RunID# " << runId << endl;
cout << endl;
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");*/
}
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 = 2)
{
TTree::SetMaxTreeSize(90000000000);
Int_t iVerbose = 0;
TString script = TString(gSystem->Getenv("SCRIPT"));
TString parDir = TString(gSystem->Getenv("VMCWORKDIR")) + TString("/parameters");
//gRandom->SetSeed(10);
TString inFile = "/Users/slebedev/Development/cbm/data/urqmd/auau/25gev/centr/urqmd.auau.25gev.centr.00001.root";
TString parFile = "/Users/slebedev/Development/cbm/data/simulations/rich/richreco/param.0001.root";
TString outFile = "/Users/slebedev/Development/cbm/data/simulations/rich/richreco/mc.0001.root";
TString caveGeom = "cave.geo";
TString pipeGeom = "pipe/pipe_standard.geo";
TString magnetGeom = "magnet/magnet_v12a.geo";
TString mvdGeom = "";
TString stsGeom = "sts/sts_v13d.geo.root";
TString richGeom= "rich/rich_v13c_pipe_1_al_1.root";
TString trdGeom = "trd/trd_v13g.geo.root";
TString tofGeom = "tof/tof_v13b.geo.root";
TString ecalGeom = "";
TString fieldMap = "field_v12a";
TString electrons = "yes"; // If "yes" than primary electrons will be generated
Int_t NELECTRONS = 5; // number of e- to be generated
Int_t NPOSITRONS = 5; // number of e+ to be generated
TString urqmd = "yes"; // If "yes" than UrQMD will be used as background
TString pluto = "no"; // If "yes" PLUTO particles will be embedded
TString plutoFile = "";
TString plutoParticle = "";
Double_t fieldZ = 50.; // field center z position
Double_t fieldScale = 1.0; // field scaling factor
if (script == "yes") {
inFile = TString(gSystem->Getenv("IN_FILE"));
outFile = TString(gSystem->Getenv("MC_FILE"));
parFile = TString(gSystem->Getenv("PAR_FILE"));
caveGeom = TString(gSystem->Getenv("CAVE_GEOM"));
pipeGeom = TString(gSystem->Getenv("PIPE_GEOM"));
mvdGeom = TString(gSystem->Getenv("MVD_GEOM"));
stsGeom = TString(gSystem->Getenv("STS_GEOM"));
richGeom = TString(gSystem->Getenv("RICH_GEOM"));
trdGeom = TString(gSystem->Getenv("TRD_GEOM"));
tofGeom = TString(gSystem->Getenv("TOF_GEOM"));
ecalGeom = TString(gSystem->Getenv("ECAL_GEOM"));
fieldMap = TString(gSystem->Getenv("FIELD_MAP"));
magnetGeom = TString(gSystem->Getenv("MAGNET_GEOM"));
NELECTRONS = TString(gSystem->Getenv("NELECTRONS")).Atoi();
NPOSITRONS = TString(gSystem->Getenv("NPOSITRONS")).Atoi();
electrons = TString(gSystem->Getenv("ELECTRONS"));
urqmd = TString(gSystem->Getenv("URQMD"));
pluto = TString(gSystem->Getenv("PLUTO"));
plutoFile = TString(gSystem->Getenv("PLUTO_FILE"));
plutoParticle = TString(gSystem->Getenv("PLUTO_PARTICLE"));
fieldScale = TString(gSystem->Getenv("FIELD_MAP_SCALE")).Atof();
}
gDebug = 0;
TStopwatch timer;
timer.Start();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C");
loadlibs();
FairRunSim* fRun = new FairRunSim();
fRun->SetName("TGeant3"); // Transport engine
fRun->SetOutputFile(outFile);
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
//fRun->SetStoreTraj(kTRUE);
fRun->SetMaterials("media.geo"); // Materials
if ( caveGeom != "" ) {
FairModule* cave = new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
fRun->AddModule(cave);
}
if ( pipeGeom != "" ) {
FairModule* pipe = new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
fRun->AddModule(pipe);
}
CbmTarget* target = new CbmTarget("Gold", 0.025); // 250 mum
fRun->AddModule(target);
if ( magnetGeom != "" ) {
FairModule* magnet = new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
fRun->AddModule(magnet);
}
if ( mvdGeom != "" ) {
FairDetector* mvd = new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
fRun->AddModule(mvd);
}
if ( stsGeom != "" ) {
FairDetector* sts = new CbmStsMC(kTRUE);
sts->SetGeometryFileName(stsGeom);
fRun->AddModule(sts);
}
if ( richGeom != "" ) {
FairDetector* rich = new CbmRich("RICH", kTRUE);
rich->SetGeometryFileName(richGeom);
fRun->AddModule(rich);
}
if ( trdGeom != "" ) {
FairDetector* trd = new CbmTrd("TRD",kTRUE );
trd->SetGeometryFileName(trdGeom);
fRun->AddModule(trd);
}
if ( tofGeom != "" ) {
FairDetector* tof = new CbmTof("TOF", kTRUE);
tof->SetGeometryFileName(tofGeom);
fRun->AddModule(tof);
}
// ----- Create magnetic field ----------------------------------------
CbmFieldMap* magField = NULL;
magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
fRun->SetField(magField);
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (urqmd == "yes"){
//CbmUrqmdGenerator* urqmdGen = new CbmUrqmdGenerator(inFile);
CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(inFile);
urqmdGen->SetEventPlane(0. , 360.);
primGen->AddGenerator(urqmdGen);
}
//add electrons
if (electrons == "yes"){
FairBoxGenerator* boxGen1 = new FairBoxGenerator(11, NPOSITRONS);
boxGen1->SetPtRange(0.,3.);
boxGen1->SetPhiRange(0.,360.);
boxGen1->SetThetaRange(2.5,25.);
boxGen1->SetCosTheta();
boxGen1->Init();
primGen->AddGenerator(boxGen1);
FairBoxGenerator* boxGen2 = new FairBoxGenerator(-11, NELECTRONS);
boxGen2->SetPtRange(0.,3.);
boxGen2->SetPhiRange(0.,360.);
boxGen2->SetThetaRange(2.5,25.);
boxGen2->SetCosTheta();
boxGen2->Init();
primGen->AddGenerator(boxGen2);
// CbmLitPolarizedGenerator *polGen;
// polGen = new CbmLitPolarizedGenerator(443, NELECTRONS);
// polGen->SetDistributionPt(0.176); // 25 GeV
// polGen->SetDistributionY(1.9875,0.228); // 25 GeV
// polGen->SetRangePt(0.,3.);
// polGen->SetRangeY(1.,3.);
// polGen->SetBox(0);
// polGen->SetRefFrame(CbmLitPolarizedGenerator::kHelicity);
// polGen->SetDecayMode(CbmLitPolarizedGenerator::kDiElectron);
// polGen->SetAlpha(0);
// polGen->Init();
// primGen->AddGenerator(polGen);
}
if (pluto == "yes") {
FairPlutoGenerator *plutoGen= new FairPlutoGenerator(plutoFile);
primGen->AddGenerator(plutoGen);
}
fRun->SetGenerator(primGen);
fRun->Init();
// ----- Runtime database ---------------------------------------------
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(fRun->GetRunId(),1);
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
fRun->Run(nEvents);
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << " Test passed" << endl;
cout << " All ok " << endl;
}