void test_E01(const TString& configMacro, Bool_t oldGeometry)
{
/// Macro function for testing example E01
/// \param configMacro configuration macro loaded in initialization
/// \param oldGeometry if true - geometry is defined via VMC, otherwise
/// via TGeo
// Load basic libraries
gROOT->LoadMacro("macro/basiclibs.C");
basiclibs();
// Load MC libraries
TString mc = configMacro(0, 2);
if ( mc == "g3" ) {
// Geant3 libraries
gROOT->LoadMacro("macro/g3libs.C");
g3libs();
}
else if ( mc == "g4" ) {
// Geant4 libraries
gROOT->LoadMacro("macro/g4libs.C");
g4libs();
}
else if ( mc == "fl" ) {
// Fluka libraries
gROOT->LoadMacro("macro/fllibs.C");
fllibs();
// Prepare Fluka working directory
gSystem->Exec("macro/run_fluka.sh");
// Enter in Fluka working directory
gSystem->cd("fluka_out");
}
// Load this example library
gSystem->Load("libexample01");
// MC application
Ex01MCApplication* appl
= new Ex01MCApplication("Example01", "The example01 MC application");
// Set geometry defined via VMC
appl->SetOldGeometry(oldGeometry);
// Initialize MC
appl->InitMC(configMacro);
// Run MC
appl->RunMC(1);
// Print info
//cout << endl
// << "Test VMC geometry getters << endl << endl;
// Test VMC geometry getters
appl->TestVMCGeometryGetters();
delete appl;
}
eventDisplay()
{
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libMCStack");
gSystem->Load("libField");
gSystem->Load("libGen");
//---- Load R3B specific libraries ---------------------------------------
gSystem->Load("libR3Bbase");
gSystem->Load("libR3BPassive");
gSystem->Load("libR3BGen");
gSystem->Load("libR3BData");
gSystem->Load("libR3BXBall");
gSystem->Load("libR3BCalifa");
gSystem->Load("libR3BDch");
gSystem->Load("libR3BGfi");
gSystem->Load("libR3BLand");
gSystem->Load("libR3BmTof");
gSystem->Load("libR3BTof");
gSystem->Load("libR3BTra");
//---- Load vis. specific libraries ---------------------------------------
gSystem->Load("libEve");
gSystem->Load("libEventDisplay");
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
TFile* file = new TFile("elipar.root");
file->Get("FairBaseParSet");
fRun->SetInputFile("elisim.root");
fRun->SetOutputFile("test.root");
fRun->LoadGeometry();
FairEventManager *fMan= new FairEventManager();
FairMCTracks *Track = new FairMCTracks ("Monte-Carlo Tracks");
FairMCPointDraw *LandPoints = new FairMCPointDraw ("LandPoint",kOrange, kFullSquare);
fMan->AddTask(Track);
fMan->AddTask(LandPoints);
fMan->Init();
}
void Create_TOF_Geometry_v12a() {
// Load the necessary FairRoot libraries
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
// Load needed material definition from media.geo file
create_materials_from_media_file();
// Get the GeoManager for later usage
gGeoMan = (TGeoManager*) gROOT->FindObject("FAIRGeom");
gGeoMan->SetVisLevel(7);
// Create the top volume
/*
TGeoBBox* topbox= new TGeoBBox("", 1000., 1000., 1000.);
TGeoVolume* top = new TGeoVolume("top", topbox, gGeoMan->GetMedium("air"));
gGeoMan->SetTopVolume(top);
*/
TGeoVolume* top = new TGeoVolumeAssembly("TOP");
gGeoMan->SetTopVolume(top);
TGeoVolume* tof = new TGeoVolumeAssembly(geoVersion);
top->AddNode(tof, 1);
for(Int_t counterType = 0; counterType < NumberOfDifferentCounterTypes; counterType++) {
gCounter = create_new_counter(counterType);
}
for(Int_t moduleType = 0; moduleType < NofModuleTypes; moduleType++) {
gModules[moduleType] = create_new_tof_module(moduleType);
}
gPole = create_tof_pole();
position_tof_poles();
position_inner_tof_modules();
position_outer_tof_modules();
gGeoMan->CloseGeometry();
gGeoMan->CheckOverlaps(0.001);
gGeoMan->PrintOverlaps();
gGeoMan->Test();
TFile* outfile = new TFile(FileName,"RECREATE");
top->Write();
//gGeoMan->Write();
outfile->Close();
// top->Draw("ogl");
//top->Raytrace();
}
eventDisplay()
{
//-----User Settings:-----------------------------------------------
TString SimEngine ="TGeant4";
TString InputFile ="ship.10.0.Pythia8-TGeant4_D.root";
TString ParFile ="ship.params.10.0.Pythia8-TGeant4_D.root";
TString OutFile ="tst.root";
//----Load the default libraries------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(InputFile.Data());
fRun->SetOutputFile(OutFile.Data());
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
parInput1->open(ParFile.Data());
rtdb->setFirstInput(parInput1);
FairEventManager *fMan= new FairEventManager();
//----------------------Tracks and points -------------------------------------
FairMCTracks *Track = new FairMCTracks("Monte-Carlo Tracks");
FairMCPointDraw *VetoPoints = new FairMCPointDraw("vetoPoint", kBlue, kFullDiamond);
FairMCPointDraw *StrawPoints = new FairMCPointDraw("strawtubesPoint", kGreen, kFullCircle);
FairMCPointDraw *EcalPoints = new FairMCPointDraw("EcalPoint", kRed, kFullSquare);
FairMCPointDraw *HcalPoints = new FairMCPointDraw("HcalPoint", kMagenta, kFullSquare);
FairMCPointDraw *MuonPoints = new FairMCPointDraw("muonPoint", kYellow, kFullSquare);
FairMCPointDraw *RpcPoints = new FairMCPointDraw("ShipRpcPoint", kOrange, kFullSquare);
fMan->AddTask(Track);
fMan->AddTask(VetoPoints);
fMan->AddTask(StrawPoints);
fMan->AddTask(EcalPoints);
fMan->AddTask(HcalPoints);
fMan->AddTask(MuonPoints);
fMan->AddTask(RpcPoints);
fMan->Init(1,4,10000);
gGeoManager->GetVolume("rockD")->SetVisibility(0);
gGeoManager->GetVolume("rockS")->SetVisibility(0);
gGeoManager->GetVolume("wire")->SetVisibility(0);
gGeoManager->GetVolume("gas")->SetVisibility(0);
gGeoManager->GetVolume("Ecal")->SetVisibility(1);
gGeoManager->GetVolume("Hcal")->SetVisibility(1);
gGeoManager->GetVolume("Ecal")->SetLineColor(kYellow);
gGeoManager->GetVolume("Hcal")->SetLineColor(kOrange+3);
TEveElement* geoscene = gEve->GetScenes()->FindChild("Geometry scene");
gEve->ElementChanged(geoscene,true,true);
}
void much_ana(Int_t nEvents=1000){
TTree::SetMaxTreeSize(90000000000);
TString script = TString(gSystem->Getenv("LIT_SCRIPT"));
TString parDir = TString(gSystem->Getenv("VMCWORKDIR")) + TString("/parameters");
// Input and output data
TString dir = "events/much_anna_omega_8gev_10k/"; // Output directory
TString mcFile = dir + "mc.0000.root"; // MC transport file
TString parFile = dir + "param.0000.root"; // Parameters file
TString globalRecoFile = dir + "global.reco.0000.root"; // File with reconstructed tracks and hits
TString analysisFile = dir + "analysis.0000.root"; // Output analysis file
TString muchDigiFile = parDir + "/much/much_v12c.digi.root"; // MUCH digi file
if (script == "yes") {
mcFile = TString(gSystem->Getenv("LIT_MC_FILE"));
parFile = TString(gSystem->Getenv("LIT_PAR_FILE"));
globalRecoFile = TString(gSystem->Getenv("LIT_GLOBAL_RECO_FILE"));
analysisFile = TString(gSystem->Getenv("LIT_ANALYSIS_FILE"));
muchDigiFile = TString(gSystem->Getenv("LIT_MUCH_DIGI"));
}
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C");
muchlibs();
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(mcFile);
fRun->AddFriend(globalRecoFile);
fRun->SetOutputFile(analysisFile);
TString muchDigiFile = gSystem->Getenv("VMCWORKDIR");
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile);
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ------------------------------------------------------------------------
CbmKF* kf = new CbmKF();
CbmAnaDimuonAnalysis* ana = new CbmAnaDimuonAnalysis("DimuonAnalysis", muchDigiFile, 1);
ana->SetVerbose(0);
ana->SetStsPointsAccQuota(4);
ana->SetStsTrueHitQuota(0.7);
fRun->AddTask(kf);
fRun->AddTask(ana);
fRun->Init();
fRun->Run(0,nEvents);
}
void draw_dedx() {
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/cbmrootlibs.C");
cbmrootlibs();
CbmLitCheckEnergyLossMuons checker;
checker.SetMaterial("iron");
checker.Check();
// CbmLitCheckBrem checker;
// checker.SetMaterial("iron");
// checker.Check();
}
void event_display()
{
TString dir = "events/mvd/";
TString mcFile = dir + "mc.0000.root"; // MC transport file
TString parFile = dir + "param.0000.root"; // Parameter file
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/cbmrootlibs.C");
cbmrootlibs();
gSystem->Load("libEve");
gSystem->Load("libEventDisplay");
FairRunAna *run= new FairRunAna();
run->SetInputFile(mcFile);
run->SetOutputFile("test.root");
FairEventManager* eventManager= new FairEventManager();
FairMCTracks* mcTracks = new FairMCTracks("Monte-Carlo Tracks");
FairMCPointDraw* richPoints = new FairMCPointDraw("RichPoint", kOrange, kFullSquare);
FairMCPointDraw* tofPoints = new FairMCPointDraw("TofPoint", kBlue, kFullSquare);
FairMCPointDraw* trdPoints = new FairMCPointDraw("TrdPoint", kTeal, kFullSquare);
FairMCPointDraw* muchPoints = new FairMCPointDraw("MuchPoint", kRed, kFullSquare);
FairMCPointDraw* ecalPoints = new FairMCPointDraw("EcalPoint", kYellow, kFullSquare);
FairMCPointDraw* refPlanePoints = new FairMCPointDraw("RefPlanePoint", kPink, kFullSquare);
FairMCPointDraw* stsPoints = new FairMCPointDraw("StsPoint", kCyan, kFullSquare);
eventManager->AddTask(mcTracks);
eventManager->AddTask(richPoints);
eventManager->AddTask(ecalPoints);
eventManager->AddTask(tofPoints);
eventManager->AddTask(trdPoints);
eventManager->AddTask(muchPoints);
eventManager->AddTask(refPlanePoints);
eventManager->AddTask(stsPoints);
// ----- Parameter database --------------------------------------------
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile.Data());
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ------------------------------------------------------------------------
eventManager->Init();
}
void read()
{
/// Macro for reading the Gflash simulated data from Root file
// Load basic libraries
basiclibs();
// Load this example library
gSystem->Load("libexampleGflash");
// MC application
VMC::Gflash::MCApplication* appl
= new VMC::Gflash::MCApplication("ExampleGflash", "The exampleGflash MC application", kRead);
for (Int_t i=0; i<5; i++) {
cout << " Event no " << i+1 << ":" << endl;
appl->ReadEvent(i);
appl->GetCalorimeterSD()->PrintTotal();
cout << endl;
}
}
rootlogon()
{
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
// Load this example libraries
gSystem->Load("libDpmEvtGen.so");
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libMCStack");
gSystem->Load("libField");
gSystem->Load("libPassive");
gSystem->Load("libGen");
gSystem->Load("libPGen");
gSystem->Load("libEmc");
gSystem->Load("libgenfit");
gSystem->Load("libtrackrep");
gSystem->Load("libriemann");
gSystem->Load("libtpc");
gSystem->Load("libtpcreco");
gSystem->Load("libStt");
gSystem->Load("libSttReco");
gSystem->Load("libTrkBase");
gSystem->Load("librecotasks");
gSystem->Load("libMvd");
gSystem->Load("libMvdReco");
gSystem->Load("libMvdTrk");
gSystem->Load("libTof");
gSystem->Load("libDrcProp");
gSystem->Load("libDrc");
gSystem->Load("libMdt");
gSystem->Load("libDch");
gSystem->Load("libLHETrack");
gSystem->Load("libGeane");
}
/********************************************************************************
* 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;
// ------------------------------------------------------------------------
}
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 sofiaall(TString InFiles = "runlist.dat",
TObjArray& fDetList )
{
// Output files
TString outFile = "./r3bunpack.root";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libFairTools");
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libR3BMbs");
gSystem->Load("libMbsAPI");
gSystem->Load("libSOFIAMCStack");
gSystem->Load("libR3BRootEvent");
gSystem->Load("libR3BLANDEvent");
gSystem->Load("libR3BUnpack");
//gSystem->Load("libR3BMusicEvent");
//gSystem->Load("libR3BProEvent");
//gSystem->Load("libR3BCrateEvent");
// ----- Create analysis run ----------------------------------------
FairRunAna *fRun= new FairRunAna();
fRun->SetOutputFile(outFile);
// ---- Load MBS
MBSUnpack *MBSunpack= new MBSUnpack("MBS unpack", InFiles);
fRun->AddTask(MBSunpack);
//SOFIA Crate 1
if (fDetList.FindObject("Crate1") ) {
CrateUnpack *CRATEunpack= new CrateUnpack("unpack");
fRun->AddTask(CRATEunpack);
}
//SOFIA Crate 2
if (fDetList.FindObject("Crate2") ) {
MUSICUnpack *MUSICunpack= new MUSICUnpack("MUSIC unpack");
fRun->AddTask(MUSICunpack);
}
// SOFIA Tof for LCP
if (fDetList.FindObject("LCP_TOF") ) {
ProUnpack *PROunpack= new ProUnpack("PROTON unpack");
fRun->AddTask(PROunpack);
}
// SOFIA Land Detector
if (fDetList.FindObject("LAND") ) {
LANDUnpack *LANDunpack= new LANDUnpack("LAND unpack");
fRun->AddTask(LANDunpack);
}
// ----- Initialize analysis run --------------------------------------
fRun->Init();
fRun->RunOnLmdFiles();
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Real time " << rtime/60.0 << " min, CPU time " << ctime/60.0
<< "min" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
void rec(Int_t file_nr=0, Int_t nEvents=1, Int_t s=0){
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 = TString(filenr);
inDir+="/";
TString mcFile = inDir+signal+".mc.root";
TString parFile = inDir+signal+".par.root";
TString rcFile = inDir+signal+".rc.root";
TString digiFile = "sts_Standard_s3055AAFK5.SecD.digi.par";
Int_t iVerbose = 1;
TStopwatch timer;
timer.Start();
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/analysis/hyperon/analysislibs.C");
analysislibs();
// ------------------------------------------------------------------------
// ----- Reconstruction run -------------------------------------------
FairRunAna* run= new FairRunAna();
run->SetInputFile(mcFile);
run->SetOutputFile(rcFile);
// ------------------------------------------------------------------------
// ----- STS digitiser ------------------------------------------------
FairTask* stsDigitize = new CbmStsDigitize("STSDigitize", iVerbose);
run->AddTask(stsDigitize);
// ------------------------------------------------------------------------
// --- STS hit finding -------------------------------------------------
FairTask* findHits = new CbmStsFindHits("STSFindHits", iVerbose);
run->AddTask(findHits);
// ------------------------------------------------------------------------
// --- STS hit matching ------------------------------------------------
FairTask* matchHits = new CbmStsMatchHits("STSMatchHits",
iVerbose);
run->AddTask(matchHits);
// ------------------------------------------------------------------------
// ----- STS track finding --------------------------------------------
FairTask* kalman= new CbmKF();
run->AddTask(kalman);
FairTask* l1 = new CbmL1();
run->AddTask(l1);
CbmStsTrackFinder* trackFinder = new CbmL1StsTrackFinder();
FairTask* findTracks = new CbmStsFindTracks(iVerbose, trackFinder);
run->AddTask(findTracks);
// ------------------------------------------------------------------------
// ----- STS track matching -------------------------------------------
FairTask* matchTracks = new CbmStsMatchTracks("Match tracks", iVerbose);
run->AddTask(matchTracks);
// ------------------------------------------------------------------------
// ----- STS track fitting --------------------------------------------
CbmStsTrackFitter* trackFitter = new CbmStsKFTrackFitter();
FairTask* fitTracks = new CbmStsFitTracks("STS Track Fitter", trackFitter, iVerbose);
run->AddTask(fitTracks);
// ------------------------------------------------------------------------
// ----- Primary vertex finder ----------------------------------------
CbmPVFinderKF *vfinder = new CbmPVFinderKF();
FairTask *vTask = new CbmFindPrimaryVertex("PV finder", "FairTask", vfinder);
run->AddTask(vTask);
// ------------------------------------------------------------------------
// ----- Parameter database --------------------------------------------
TString stsDigiFile = gSystem->Getenv("VMCWORKDIR");
stsDigiFile += "/parameters/sts/";
stsDigiFile += digiFile;
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo();
parIo1->open(parFile.Data());
parIo2->open(stsDigiFile.Data(),"in");
rtdb->setFirstInput(parIo1);
rtdb->setSecondInput(parIo2);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
// ------------------------------------------------------------------------
// ----- Initialise and run -------------------------------------------
run->LoadGeometry();
run->Init();
run->Run(0, nEvents);
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << rcFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime << " s" << endl;
cout << endl;
// ------------------------------------------------------------------------
}
void sts_reco( Int_t nEvents = 1, Int_t iVerbose = 0){
TString inFile = "data/mc_sector.root";
TString outFile = "data/sts_sector.root";
TString parFile = "data/params.root";
TString stsFile = "sts_v11a.digi.par";
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C");
muchlibs();
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(inFile);
fRun->SetOutputFile(outFile);
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
FairParAsciiFileIo* parInput2 = new FairParAsciiFileIo();
parInput1->open(parFile.Data());
parInput2->open(Form("%s/parameters/sts/%s",gSystem->Getenv("VMCWORKDIR"),stsFile.Data()),"in");
rtdb->setFirstInput(parInput1);
rtdb->setSecondInput(parInput2);
Double_t threshold = 4;
Double_t noiseWidth = 0.01;
Int_t nofBits = 20;
Double_t minStep = 0.01;
Double_t StripDeadTime = 0.1;
CbmStsDigitize* stsDigitize = new CbmStsDigitize("STS Digitiser", iVerbose);
stsDigitize->SetRealisticResponse();
stsDigitize->SetFrontThreshold (threshold);
stsDigitize->SetBackThreshold (threshold);
stsDigitize->SetFrontNoiseWidth(noiseWidth);
stsDigitize->SetBackNoiseWidth (noiseWidth);
stsDigitize->SetFrontNofBits (nofBits);
stsDigitize->SetBackNofBits (nofBits);
stsDigitize->SetFrontMinStep (minStep);
stsDigitize->SetBackMinStep (minStep);
stsDigitize->SetStripDeadTime (StripDeadTime);
fRun->AddTask(stsDigitize);
FairTask* stsClusterFinder = new CbmStsClusterFinder("STS Cluster Finder",iVerbose);
fRun->AddTask(stsClusterFinder);
FairTask* stsFindHits = new CbmStsFindHits("STS Hit Finder", iVerbose);
fRun->AddTask(stsFindHits);
FairTask* stsMatchHits = new CbmStsMatchHits("STS Hit Matcher", iVerbose);
fRun->AddTask(stsMatchHits);
// --- STS track finding ------------------------------------------------
CbmKF* kalman = new CbmKF();
fRun->AddTask(kalman);
CbmL1* l1 = new CbmL1();
fRun->AddTask(l1);
CbmStsTrackFinder* stsTrackFinder = new CbmL1StsTrackFinder();
FairTask* stsFindTracks = new CbmStsFindTracks(iVerbose, stsTrackFinder);
fRun->AddTask(stsFindTracks);
CbmStsMatchTracks* stsMatchTracks = new CbmStsMatchTracks(iVerbose);
fRun->AddTask(stsMatchTracks);
CbmStsTrackFitter* stsTrackFitter = new CbmStsKFTrackFitter();
FairTask* stsFitTracks = new CbmStsFitTracks(stsTrackFitter, iVerbose);
fRun->AddTask(stsFitTracks);
CbmPrimaryVertexFinder* pvFinder = new CbmPVFinderKF();
CbmFindPrimaryVertex* pvFindTask = new CbmFindPrimaryVertex(pvFinder);
fRun->AddTask(pvFindTask);
fRun->Init();
fRun->Run(0,nEvents);
}
void readTrigger()
{
TLorentzVector eplus[50], eminus[50];
TLorentzVector momentum, momentum_pair;
TVector3 mom;
Float_t px, py, pz;
Int_t pdg;
Int_t nplus=0, nminus=0, njpsi=0;
TH1F *hEl = new TH1F("hEl","number of electrons", 10,0,10);
TH1F *hPtel = new TH1F("hPtel"," dN/dPt ",100,0,4);
TH1F *hPel = new TH1F("hPel"," dN/dP ",100,0,30);
// Load basic libraries
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libPhysics");
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libCbmBase");
gSystem->Load("libCbmData");
gSystem->Load("libJpsi.so");
Char_t fileName[100];
Int_t fNevents = 0;
Int_t fElectronEvents=0;
for (Int_t ifile=0; ifile<1; ifile++)
{
TFile *f1 = new TFile(Form("jpsitrigger.25gev.pure.0000.root",ifile));
TTree* t1 =(TTree*) f1->Get("cbmsim");
TFolder *fd1 =(TFolder*) f1->Get("cbmout");
TClonesArray* fJpsi = (TClonesArray*)fd1->FindObjectAny("CbmJpsiTriggerElectron");
t1->SetBranchAddress("CbmJpsiTriggerElectron",&fJpsi);
Int_t nevent = t1->GetEntries();
cout<<nevent<<endl;
nplus=0; nminus=0;
for(Int_t i=0; i<nevent; i++)
{
nplus = 0;
nminus = 0;
fNevents++;
t1->GetEntry(i);
Int_t nel = fJpsi->GetEntries();
for ( Int_t iel=0; iel<nel; iel++)
{
CbmJpsiTriggerElectron *jel = (CbmJpsiTriggerElectron*)fJpsi->At(iel);
mom = jel->GetMomentum();
hPel->Fill(mom.Mag());
hPtel->Fill(mom.Pt());
if (mom.Pt() < 1.2) continue;
momentum.SetVectM(mom,0.000511);
pdg = jel -> GetPdg();
Double_t ann = jel -> GetAnn();
Double_t like = jel -> GetLike();
Double_t wkn = jel -> GetWkn();
Double_t ran = gRandom->Rndm();
if(ann > 0.8 )
{
eplus[nplus]=momentum;
nplus++;
eplus[nplus].SetXYZT(0,0,0,0);
}
}
hEl->Fill(nplus);
if ( nplus>1 ) fElectronEvents++;
} // event loop
f1->Close();
}
cout<< " ElectronEvents "<< fElectronEvents<<endl;
TFile *fmass = new TFile("jpsiTrigger.hist.root","RECREATE");
hEl->Scale(1./Float_t (fNevents));
hEl->Write();
hPel->Scale(1./Float_t (fNevents ));
hPel->Write();
hPtel->Scale(1./Float_t (fNevents));
hPtel->Write();
}
void simall(Int_t nEvents = 1,
TObjArray& fDetList,
Bool_t fVis=kFALSE,
TString fMC="TGeant3",
TString fGenerator="mygenerator",
Bool_t fUserPList= kFALSE
)
{
TString dir = getenv("VMCWORKDIR");
TString simdir = dir + "/macros";
TString sim_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",sim_geomdir.Data());
TString sim_confdir = dir + "gconfig";
gSystem->Setenv("CONFIG_DIR",sim_confdir.Data());
// Output files
TString OutFile = "simout.root";
TString ParFile = "simpar.root";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGenVector");
gSystem->Load("libGeoBase");
gSystem->Load("libFairDB");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libMCStack");
gSystem->Load("libField");
gSystem->Load("libGen");
//---- Load specific libraries ---------------------------------------
gSystem->Load("libEnsarbase");
gSystem->Load("libEnsarGen");
gSystem->Load("libEnsarData");
gSystem->Load("libEnsarMyDet");
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(fMC.Data()); // Transport engine
run->SetOutputFile(OutFile.Data()); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// R3B Special Physics List in G4 case
if ( (fUserPList == kTRUE ) &&
(fMC.CompareTo("TGeant4") == 0)
){
run->SetUserConfig("g4Config.C");
run->SetUserCuts("SetCuts.C");
}
// ----- Create media -------------------------------------------------
//run->SetMaterials("media_r3b.geo"); // Materials
// Magnetic field map type
// Int_t fFieldMap = 0;
// Global Transformations
//- Two ways for a Volume Rotation are supported
//-- 1) Global Rotation (Euler Angles definition)
//-- This represent the composition of : first a rotation about Z axis with
//-- angle phi, then a rotation with theta about the rotated X axis, and
//-- finally a rotation with psi about the new Z axis.
Double_t phi,theta,psi;
//-- 2) Rotation in Ref. Frame of the Volume
//-- Rotation is Using Local Ref. Frame axis angles
Double_t thetaX,thetaY,thetaZ;
//- Global Translation Lab. frame.
Double_t tx,ty,tz;
// ----- Create geometry --------------------------------------------
if (fDetList.FindObject("MYDET") ) {
//My Detector definition
EnsarDetector* mydet = new EnsarMyDet("MyDet", kTRUE);
// Global position of the Module
phi = 0.0; // (deg)
theta = 0.0; // (deg)
psi = 0.0; // (deg)
// Rotation in Ref. Frame.
thetaX = 0.0; // (deg)
thetaY = 0.0; // (deg)
thetaZ = 0.0; // (deg)
// Global translation in Lab
tx = 0.0; // (cm)
ty = 0.0; // (cm)
tz = 0.0; // (cm)
mydet->SetRotAnglesXYZ(thetaX,thetaY,thetaZ);
mydet->SetTranslation(tx,ty,tz);
run->AddModule(mydet);
}
// ----- Create PrimaryGenerator --------------------------------------
// 1 - Create the Main API class for the Generator
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
if (fGenerator.CompareTo("mygenerator") == 0 ) {
// 2- Define the generator
Double_t pdgId=211; // pion beam
Double_t theta1= 0.; // polar angle distribution
Double_t theta2= 7.;
Double_t momentum=.8; // 10 GeV/c
Int_t multiplicity = 50; // multiplicity (nb particles per event)
FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId,multiplicity);
boxGen->SetThetaRange ( theta1, theta2);
boxGen->SetPRange (momentum,momentum*2.);
boxGen->SetPhiRange (0.,360.);
boxGen->SetXYZ(0.0,0.0,-1.5);
// add the box generator
primGen->AddGenerator(boxGen);
}
run->SetGenerator(primGen);
//-------Set visualisation flag to true------------------------------------
if (fVis==kTRUE){
run->SetStoreTraj(kTRUE);
}else{
run->SetStoreTraj(kFALSE);
}
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------ Increase nb of step
Int_t nSteps = -15000;
gMC->SetMaxNStep(nSteps);
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(ParFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ----- Start run ----------------------------------------------------
if (nEvents>0) run->Run(nEvents);
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << OutFile << endl;
cout << "Parameter file is " << ParFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
}
/** * Performs reconstruction of simulated events * in the CBM MuCh setup: STS + MUCH. * * @author M.Ryzhinskiy [email protected] * @param inFile Input transport file * @param digiFile Input file containing segmentation parameters * @param outFile Output file for reconstruction data * @param nEvents Number of events to process */ void much_hits_straw(TString inFile = "", TString digiFile = "", TString outFile = "", Int_t nEvents = 5) { TString inputdir = gSystem->Getenv("VMCWORKDIR"); if (inFile == "") { inFile = inputdir + "/macro/much/data/Jpsi.auau.25gev.centr.mc.root"; } if (digiFile == "") { digiFile = inputdir + "/parameters/much/much_v11d.digi.root"; } if (outFile == "") { outFile = inputdir + "/macro/much/data/Jpsi.auau.25gev.centr.muchhits.root"; } // ======================================================================== // Adjust this part according to your requirements // Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug) Int_t iVerbose = 1; // ---- Load libraries ------------------------------------------------- gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C"); basiclibs(); gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C"); muchlibs(); // ------------------------------------------------------------------------ // ----- Reconstruction run ------------------------------------------- FairRunAna *fRun= new FairRunAna(); fRun->SetInputFile(inFile); fRun->SetOutputFile(outFile); // ------------------------------------------------------------------------ // ----- Parameter database -------------------------------------------- FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); FairParRootFileIo* parIo1 = new FairParRootFileIo(); parIo1->open(gFile); rtdb->setFirstInput(parIo1); rtdb->setOutput(parIo1); rtdb->saveOutput(); // ------------------------------------------------------------------------ // --- MuCh digitizer ---------------------------------------------------- CbmMuchDigitizeGem* digitize = new CbmMuchDigitizeGem(digiFile); fRun->AddTask(digitize); // --- MuCh straw digitizer ----------------------------------------------- CbmMuchDigitizeStraws* strawDigitize = new CbmMuchDigitizeStraws("MuchDigitizeStraws", digiFile, iVerbose); fRun->AddTask(strawDigitize); // ------------------------------------------------------------------------ // --- MuCh hit finder --------------------------------------------------- CbmMuchFindHitsGem* findHits = new CbmMuchFindHitsGem(digiFile); fRun->AddTask(findHits); // --- MuCh straw hit finder ---------------------------------------------- CbmMuchFindHitsStraws* strawFindHits = new CbmMuchFindHitsStraws("MuchFindHitsStraws", digiFile, iVerbose); fRun->AddTask(strawFindHits); // ------------------------------------------------------------------------ // ----- Intialise and run -------------------------------------------- fRun->Init(); fRun->Run(0,nEvents); // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; exit(0); }
void much_draw_digis(
TString mcFileName = "data/mc.root",
TString digiFileName = "data/much_digi_sector.root",
TString rcFileName = "data/hits.root",
Int_t iEvent = 0,
Int_t iStationSelected = 0,
Int_t iLayerSelected = 2,
Int_t iSideSelected = 0, // 0 - front, 1 - back, 2 - both
Double_t xmin = -250,
Double_t xmax = 250,
Double_t ymin = -250,
Double_t ymax = 250
){
TString paramDir = gSystem->Getenv("VMCWORKDIR");
TString digiFileName = paramDir+"/parameters/much/much_v12c.digi.root";
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C");
muchlibs();
// init digi scheme
TFile* digiFile = new TFile(digiFileName);
TObjArray* stations = (TObjArray*) digiFile->Get("stations");
CbmMuchGeoScheme* digiScheme = CbmMuchGeoScheme::Instance();
digiScheme->Init(stations);
// get TClonesArrays from trees
TFile* mcFile = new TFile(mcFileName);
TFile* rcFile = new TFile(rcFileName);
TTree* mcTree = mcFile ? (TTree*) mcFile->Get("cbmsim") : 0;
TTree* rcTree = rcFile ? (TTree*) rcFile->Get("cbmsim") : 0;
TClonesArray* points = new TClonesArray("CbmMuchPoint");
TClonesArray* digis = new TClonesArray("CbmMuchDigi");
TClonesArray* hits = new TClonesArray("CbmMuchPixelHit");
if (mcTree) mcTree->SetBranchAddress("MuchPoint",&points);
if (rcTree) rcTree->SetBranchAddress("MuchDigi",&digis);
if (rcTree) rcTree->SetBranchAddress("MuchPixelHit",&hits);
if (mcTree) mcTree->GetEntry(iEvent);
if (rcTree) rcTree->GetEntry(iEvent);
// Draw pads
TCanvas* c1 = new TCanvas("station","station",1000*(xmax-xmin)/(ymax-ymin),1000);
c1->Range(xmin,ymin,xmax,ymax);
for (Int_t iSide=1;iSide>=0;iSide--){
if (iSideSelected!=2 && iSide!=iSideSelected)continue;
CbmMuchLayerSide* side = digiScheme->GetLayerSide(iStationSelected,iLayerSelected,iSide);
for (Int_t iModule=0;iModule<side->GetNModules();++iModule) {
CbmMuchModuleGem* module = (CbmMuchModuleGem*) side->GetModule(iModule);
if (!module) continue;
module->Draw();
printf("%i\n",module->GetNPads());
}
}
return;
// Mark fired pads
for (Int_t i=0;i<digis->GetEntriesFast();i++){
CbmMuchDigi* digi = (CbmMuchDigi*) digis->At(i);
// Filter out points
Int_t detId = digi->GetDetectorId();
if (!IsSelected(detId,iStationSelected,iLayerSelected,iSideSelected)) continue;
CbmMuchModuleGem* module = (CbmMuchModuleGem*)digiScheme->GetModuleByDetId(detId);
if (!module) continue;
module->SetPadFired(digi->GetChannelId(),i,digi->GetADCCharge());
}
// Draw points
for (Int_t i=0;i<points->GetEntriesFast();i++){
CbmMuchPoint* point = (CbmMuchPoint*) points->At(i);
Int_t detId = point->GetDetectorId();
if (!IsSelected(detId,iStationSelected,iLayerSelected,iSideSelected)) continue;
TLine* l = new TLine(point->GetXIn()-0.1,point->GetYIn()-0.1,point->GetXOut()+0.1,point->GetYOut()+0.1);
l->SetLineColor(kBlack);
l->SetLineWidth(3);
l->Draw();
}
// Draw hits
for (Int_t i=0;i<hits->GetEntriesFast();i++){
CbmMuchPixelHit* hit = (CbmMuchPixelHit*) hits->At(i);
Int_t detId = hit->GetDetectorId();
if (!IsSelected(detId,iStationSelected,iLayerSelected,iSideSelected)) continue;
TEllipse* p = new TEllipse(hit->GetX(),hit->GetY(),0.08);
p->SetFillColor(kRed);
p->SetLineColor(kRed);
p->Draw();
}
// Draw a hole
TArc* holeArc = new TArc(0.,0.,digiScheme->GetStation(iStationSelected)->GetRmin());
holeArc->Draw();
c1->Print("station.png");
}
void run_CbmIonGenerator(Int_t nEvents = 1)
{
// ========================================================================
// Adjust this part according to your requirements
// Input file
//TString inPath = "/d/cbm03/urqmd/auau/25gev/centr/";
//TString inFile = inPath + "urqmd.auau.25gev.centr.0000.ftn14";
// Output file
TString outFile = Form("sts.mc.root",nEvents);
// Parameter file
TString parFile = Form("params.root",nEvents);
// Cave geometry
TString caveGeom = "cave.geo";
// Target geometry
TString targetGeom = "target_au_250mu.geo";
// Beam pipe geometry
TString pipeGeom = "pipe_standard.geo";
// Magnet geometry and field map
TString magnetGeom = "passive/magnet_v09e.geo";
TString fieldMap = "field_v10e";
Double_t fieldZ = 50.; // z position of field centre
Double_t fieldScale = 1.; // field scaling factor
// MVD geometry
TString mvdGeom = "mvd/mvd_v07a.geo";
// STS geometry
TString stsGeom = "sts/sts_v11a.geo";
//STS geometry for the same z position of all sensors
//TString stsGeom = "sts_same_z.geo";
targetGeom = "";
magnetGeom = "";
stsGeom = "";
mvdGeom = "";
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gSystem->Load("libGeoBase");
gSystem->Load("libParBase");
gSystem->Load("libBase");
gSystem->Load("libCbmBase");
gSystem->Load("libCbmData");
gSystem->Load("libField");
gSystem->Load("libGen");
gSystem->Load("libPassive");
gSystem->Load("libMvd");
gSystem->Load("libSts");
gSystem->Load("libCbmGenerators"); // for CbmIonGenerator
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName("TGeant3"); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new CbmCave("CAVE");
cave->SetGeometryFileName(caveGeom);
run->AddModule(cave);
FairModule* pipe= new CbmPipe("PIPE");
pipe->SetGeometryFileName(pipeGeom);
run->AddModule(pipe);
if( targetGeom != "") {
FairModule* target= new CbmTarget("Target");
target->SetGeometryFileName(targetGeom);
run->AddModule(target);
}
if( magnetGeom != "") {
FairModule* magnet= new CbmMagnet("MAGNET");
magnet->SetGeometryFileName(magnetGeom);
run->AddModule(magnet);
}
if( mvdGeom != ""){
FairDetector* mvd= new CbmMvd("MVD", kTRUE);
mvd->SetGeometryFileName(mvdGeom);
run->AddModule(mvd);
}
if( stsGeom != "") {
FairDetector* sts= new CbmSts("STS", kTRUE);
sts->SetGeometryFileName(stsGeom);
run->AddModule(sts);
}
// ------------------------------------------------------------------------
// ----- Create magnetic field ----------------------------------------
if(magnetGeom!="") {
CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap);
magField->SetPosition(0., 0., fieldZ);
magField->SetScale(fieldScale);
run->SetField(magField);
}
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
//FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile);
//primGen->AddGenerator(urqmdGen);
// CbmIonGenerator - check in Load libraries: gSystem->Load("libCbmGenerators");
Int_t nions=10; // number of ions/event
cout<<"@@@@@> CbmIonGenerator is ON with "<<nions<<" ion(s)/event !!!"<<endl;
Int_t z=79, a=197, q=79; // Au-ion
Double_t p=8.; // in AGeV/c
Double_t vz=-0.0126; // in cm - z-pos. of vertex
Double_t meanX=0.3; // in cm - spatial distr. (XOY)
Double_t meanY=-0.2; // in cm
Double_t sigmaX = 0.078; // in cm - spatial distr. (XOY)
Double_t sigmaY = 0.032; // in cm
Double_t sigmatX = 0.00117885; // in rad (Px/P) - angular distr. (mean=0)
Double_t sigmatY = 0.00094955; // in rad (Py/P)
// Parameters of the trapezoid are set with respect to mean of Gaussian, NOT necesseraly in absolute coordinates.
// x1 < x2 < 0 < x3 < x4
Double_t x1=-0.10452, x2=-0.06942, x3=0.06942, x4=0.10452; // in cm - trapezoid distr.
Double_t y1=-0.04448, y2=-0.02688, y3=0.02688, y4=0.04448; // in cm
Double_t tX1=-0.00157966, tX2=-0.001049177, tX3=0.001049177, tX4=0.00157966; // in rad
Double_t tY1=-0.00131987, tY2=-0.000797622, tY3=0.000797622, tY4=0.00131987; // in rad
// CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY);
// CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz);
CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz,
x1, x2, x3, x4, y1, y2, y3, y4, tX1, tX2, tX3, tX4, tY1, tY2, tY3, tY4);
primGen->AddGenerator(IonGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
// run->SetStoreTraj(kTRUE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
if(magnetGeom!="") {
CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar");
fieldPar->SetParameters(magField);
fieldPar->setChanged();
fieldPar->setInputVersion(run->GetRunId(),1);
}
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
//run->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
// ------------------------------------------------------------------------
cout << " Test passed" << endl;
cout << " All ok " << endl;
exit(0);
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence 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(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 calibrateEM()
{
// FIXME: There are two possibilities to execute the script:
// i) root run_hadron_g4.C
// root[] .L calibrateEM.C
// root[] calibrateEM()
// or ii) Include the basics from run_hadron_g4.C here and
// execute simply:
// root calibrateEM.C
// Load basic libraries
// Load basic libraries
gROOT->LoadMacro("/opt/geant4_vmc.2.15a/examples/macro/basiclibs.C");
basiclibs();
// Load Geant4 libraries
gROOT->LoadMacro("/opt/geant4_vmc.2.15a/examples/macro/g4libs.C");
g4libs();
// Load the tutorial application library
gSystem->Load("libTutorialApplication");
// MC application
TutorialApplication* app
= new TutorialApplication("TutorialApplication",
"Tutorial Application for HEP Lecture @EKP");
// configure Geant4
gROOT->LoadMacro("g4Config.C");
Config();
// instantiate graphical user interface for tutorial application
new TutorialMainFrame(app);
//FIXME: Load "CountChargedinScint.C"
gROOT->ProcessLine(".L CountChargedinScint.C");
//FIXME: Initialize the geometry
app->InitMC("geometry/calor(1,0.2)");
//FIXME: Set the primary particle to photon
app->SetPrimaryPDG(22);
// Profile histogram - will show us the mean numbers of counts in bins of the energy.
// The given binning refers to the energy, the other binning will be inferred automatically.
TProfile* hcounts = new TProfile("hcounts","Counts per particle energy",
10,0,10);
hcounts->SetXTitle("energy [GeV]");
hcounts->SetYTitle("mean number of counts");
// FIXME loop over different particle momenta, and for each momentum simulate several events (e.g. 10)
for(Int_t i = 0 ; i < 10 ; ++i) {
for(Int_t k = 0 ; k < 10; k ++) {
//FIXME: Set the momentum of the primary particle to p
Double_t p = i;
app->SetPrimaryMomentum(p);
//FIXME: Run the simulation
app->RunMC();
//FIXME: Fill both the momentum and the output from CountChargedinScint
// into the profile histogram hcounts
Double_t x = CountChargedinScint();
hcounts->Fill(p,x);
}
}
TCanvas* c = new TCanvas();
c->cd();
hcounts->Draw();
TF1 *fitter = new TF1("fitf","[0]*x", 0,10);
fitter->SetParameter(0,1.0);
fitter->SetParNames("calibration factor");
//FIXME: Fit the histogram to get the calibration factor
hcounts->Fit("fitf");
}
void much_reco(){
Int_t nEvents=10;
TString dir = "data/";
TString mcFile = dir + "mc.root";
TString stsRecoFile = dir + "sts.reco.0.root";
TString outFile = dir + "much.reco.0.root";
TString parFile = dir + "param.root";
TString digiFile = gSystem->Getenv("VMCWORKDIR");
digiFile += "/parameters/much/much_v11a.digi.root";
TChain* mcFileChain = new TChain("cbmsim");
mcFileChain->AddFile(dir+"/mc.root");
Int_t iVerbose = 2;
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/much/muchlibs.C");
muchlibs();
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(mcFile);
fRun->AddFriend(stsRecoFile);
fRun->SetOutputFile(outFile);
// --- MuCh digitizer ----------------------------------------------------
CbmMuchDigitizeAdvancedGem* digitize = new CbmMuchDigitizeAdvancedGem("MuchDigitizeAdvancedGem", digiFile, iVerbose);
digitize->SetSpotRadius(0.05);
digitize->SetQMaximum(500000);
digitize->SetNADCChannels(256);
digitize->SetMeanGasGain(17000);
digitize->SetDeadTime(500); // ns
digitize->SetDTime(4); // ns
fRun->AddTask(digitize);
CbmMuchFindHitsAdvancedGem* findHits = new CbmMuchFindHitsAdvancedGem("MuchFindHitsAdvancedGem", digiFile, iVerbose);
findHits->SetAlgorithm(3);
fRun->AddTask(findHits);
CbmLitFindGlobalTracks* finder = new CbmLitFindGlobalTracks();
finder->SetTrackingType("branch");
finder->SetMergerType("nearest_hit");
fRun->AddTask(finder);
CbmMuchMatchTracks* muchMatchTracks = new CbmMuchMatchTracks();
fRun->AddTask(muchMatchTracks);
// ------------------------------------------------------------------------
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
parIo1->open(parFile);
rtdb->setFirstInput(parIo1);
rtdb->setOutput(parIo1);
rtdb->saveOutput();
fRun->Init();
fRun->Run(0,nEvents);
return;
}
rootlogon()
{
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
// Load Panda libraries
if(isLibrary("libDpmEvtGen"))gSystem->Load("libDpmEvtGen");
if(isLibrary("libpythia8"))gSystem->Load("libpythia8");
if(isLibrary("libFlukaResults"))gSystem->Load("libFlukaResults");
if(isLibrary("libFairTools"))gSystem->Load("libFairTools");
if(isLibrary("libGeoBase"))gSystem->Load("libGeoBase");
if(isLibrary("libParBase"))gSystem->Load("libParBase");
if(isLibrary("libBase"))gSystem->Load("libBase");
if(isLibrary("libPhotos")){// these three depend on each other
gSystem->Load("libPhotos");
if(isLibrary("libEvtGen")){
gSystem->Load("libEvtGen");
if(isLibrary("libEvtGenDirect"))gSystem->Load("libEvtGenDirect");
}
}
if(isLibrary("libPndBase"))gSystem->Load("libPndBase");
if(isLibrary("libGlobalTasks"))gSystem->Load("libGlobalTasks");
if(isLibrary("libTrkBase"))gSystem->Load("libTrkBase");
if(isLibrary("libPndData"))gSystem->Load("libPndData");
if(isLibrary("libgeneralTools"))gSystem->Load("libgeneralTools");
if(isLibrary("libbuffers"))gSystem->Load("libbuffers");
if(isLibrary("libField"))gSystem->Load("libField");
if(isLibrary("libPassive"))gSystem->Load("libPassive");
if(isLibrary("libGen"))gSystem->Load("libGen");
if(isLibrary("libPGen"))gSystem->Load("libPGen");
if(isLibrary("libEmc"))gSystem->Load("libEmc");
if(isLibrary("libgenfit"))gSystem->Load("libgenfit");
if(isLibrary("libtrackrep"))gSystem->Load("libtrackrep");
if(isLibrary("libgenfitAdapters"))gSystem->Load("libgenfitAdapters");
if(isLibrary("libriemann"))gSystem->Load("libriemann");
if(isLibrary("libTpcBase"))gSystem->Load("libTpcBase");
if(isLibrary("libTpc"))gSystem->Load("libTpc");
if(isLibrary("libTpcReco"))gSystem->Load("libTpcReco");
if(isLibrary("libStt"))gSystem->Load("libStt");
if(isLibrary("libSttReco"))gSystem->Load("libSttReco");
if(isLibrary("libSds"))gSystem->Load("libSds");
if(isLibrary("libSdsReco"))gSystem->Load("libSdsReco");
if(isLibrary("libMvd"))gSystem->Load("libMvd");
if(isLibrary("libMvdReco"))gSystem->Load("libMvdReco");
if(isLibrary("libMvdTrk"))gSystem->Load("libMvdTrk");
if(isLibrary("libSttMvdTracking"))gSystem->Load("libSttMvdTracking");
if(isLibrary("libGem"))gSystem->Load("libGem");
if(isLibrary("libFts"))gSystem->Load("libFts");
if(isLibrary("libTof"))gSystem->Load("libTof");
if(isLibrary("libDrcProp"))gSystem->Load("libDrcProp");
if(isLibrary("libDrc"))gSystem->Load("libDrc");
if(isLibrary("libMdt"))gSystem->Load("libMdt");
if(isLibrary("libDch"))gSystem->Load("libDch");
if(isLibrary("libLheTrack"))gSystem->Load("libLheTrack");
if(isLibrary("libGeane"))gSystem->Load("libGeane");
if(isLibrary("libRpc"))gSystem->Load("libRpc");
if(isLibrary("libLumi"))gSystem->Load("libLumi");
if(isLibrary("libRho"))gSystem->Load("libRho");
if(isLibrary("libTMVA"))gSystem->Load("libTMVA.so");
if(isLibrary("libAnalysisTools"))gSystem->Load("libAnalysisTools");
if(isLibrary("libPid"))gSystem->Load("libPid");
if(isLibrary("librecotasks"))gSystem->Load("librecotasks");
if(isLibrary("libRecoHits"))gSystem->Load("libRecoHits");
if(isLibrary("libRecoTasks"))gSystem->Load("libRecoTasks");
if(isLibrary("libEnDrc"))gSystem->Load("libEnDrc");
if(isLibrary("libDsk"))gSystem->Load("libDsk");
if(isLibrary("libGlobal"))gSystem->Load("libGlobal");
if(isLibrary("libMCMatch"))gSystem->Load("libMCMatch");
if(isLibrary("libMva"))gSystem->Load("libMva");
//gSystem->Load("libMemStat");
}
void run_radius_correction ()
{
TStopwatch timer;
timer.Start();
gStyle->SetPalette(1,0);
gStyle->SetHistLineWidth(2);
// ---- Load libraries -------------------------------------------------
gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C");
basiclibs();
gROOT->LoadMacro("$VMCWORKDIR/macro/rich/cbmlibs.C");
cbmlibs();
// gROOT->LoadMacro("$VMCWORKDIR/macro/rich/setstyle.C");
// setphdStyle();
SetStyles();
char fileMC[200], fileRec[200];
sprintf(fileMC,"/d/cbm02/slebedev/rich/JUL09/correction/mc.00.root");
cout<<fileMC<<endl;
TFile *f1 = new TFile(fileMC,"R");
TTree* t1 = f1->Get("cbmsim");
TFolder *fd1 = f1->Get("cbmroot");
TClonesArray* fMCTracks = (TClonesArray*) fd1->FindObjectAny("MCTrack");
t1->SetBranchAddress(fMCTracks->GetName(),&fMCTracks);
sprintf(fileRec, "/d/cbm02/slebedev/rich/JUL09/correction/reco.00.root");
TFile *f = new TFile(fileRec,"R");
TTree* t = f->Get("cbmsim");
TFolder *fd = f->Get("cbmout");
TClonesArray *fRichRings = (TClonesArray*) fd->FindObjectAny("RichRing");
t->SetBranchAddress(fRichRings->GetName(),&fRichRings);
TClonesArray *fRichMatches = (TClonesArray*) fd->FindObjectAny("RichRingMatch");
t->SetBranchAddress(fRichMatches->GetName(),&fRichMatches);
//Int_t fNofBinsX = 40;
//Int_t fNofBinsY = 50;
Int_t fNofBinsX = 25;
Int_t fNofBinsY = 25;
///A axis
TH2D* fh_axisAXYCount;
TH2D* fh_axisAXYW;
TH2D* fh_axisAXY;
TH2D* fh_axisASigma;
TH2D* mapaxisAXY;
///B axis
TH2D* fh_axisBXYCount;
TH2D* fh_axisBXYW;
TH2D* fh_axisBXY;
TH2D* fh_axisBSigma;
TH2D* mapaxisBXY;
mapaxisAXY = new TH2D("fh_mapaxisAXY","dA distribution (x,y);X, [cm];Y, [cm]",fNofBinsX,-200,200,fNofBinsY,-250,250);
mapaxisBXY = new TH2D("fh_mapaxisBXY","dB distribution (x,y);X, [cm];Y, [cm]",fNofBinsX,-200,200,fNofBinsY,-250,250);
fh_axisAXYCount = new TH2D("fh_axisAXYCount","A Count",fNofBinsX,-200,200,fNofBinsY,-250,250);
fh_axisAXYW = new TH2D("fh_axisAXYW","",fNofBinsX,-200,200,fNofBinsY,-250,250);
fh_axisBXYCount = new TH2D("fh_axisBXYCount","B Count",fNofBinsX,-200,200,fNofBinsY,-250,250);
fh_axisBXYW = new TH2D("fh_axisBXYW","",fNofBinsX,-200,200,fNofBinsY,-250,250);
fh_axisAXY = new TH2D("fh_axisAXY","A distribution (x,y);X, [cm];Y, [cm]",fNofBinsX,-200,200,fNofBinsY,-250,250);
fh_axisBXY = new TH2D("fh_axisBXY","B distribution (x,y);X, [cm];Y, [cm]",fNofBinsX,-200,200,fNofBinsY,-250,250);
Double_t fMinAaxis = 4.5;
Double_t fMaxAaxis = 7.5;
///Set Mean value of A and B axeses, Compact RICH
//Double_t fMeanAaxis = 5.06;
//Double_t fMeanBaxis = 4.65;
///Set Mean value of A and B axeses, Large RICH
Double_t fMeanAaxis = 6.17;
Double_t fMeanBaxis = 5.6;
Int_t nEvents=t->GetEntries();
cout<<" nEvents ="<<nEvents<<endl;
for(Int_t ievent=0;ievent<nEvents; ievent++ ) {
cout<<"ievent = "<<ievent;
CbmRichRing *ring=NULL;
CbmRichRingMatch *match=NULL;
t->GetEntry(ievent);
t1->GetEntry(ievent);
Int_t nofRings = fRichRings->GetEntries();
cout<<" nofRings = "<<nofRings;
cout<<" nofMatches = "<< fRichMatches->GetEntries() ;
cout<<" nofMCTracks = "<<fMCTracks->GetEntries() << endl;
for(Int_t iRing=0; iRing < nofRings; iRing++){
ring = (CbmRichRing*)fRichRings->At(iRing);
if (!ring) continue;
match = (CbmRichRingMatch*)fRichMatches->At(iRing);
if (!match) continue;
Int_t trackId = match->GetMCTrackID();
if (trackId == -1) continue;
if (trackId > fMCTracks->GetEntries()) continue;
CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTracks->At(trackId);
if (!mcTrack) continue;
Int_t pdg = TMath::Abs(mcTrack->GetPdgCode());
Int_t motherId = mcTrack->GetMotherId();
if (pdg != 11) continue;
if (motherId != -1) continue;
Double_t radius = ring->GetRadius();
Double_t axisA = ring->GetAaxis();
Double_t axisB = ring->GetBaxis();
Double_t centerX = ring->GetCenterX();
Double_t centerY = ring->GetCenterY();
if (axisA > fMaxAaxis || axisB > fMaxAaxis) continue;
if (axisA < fMinAaxis || axisB < fMinAaxis) continue;
fh_axisAXYW->Fill(centerX, centerY, axisA);
fh_axisAXYCount->Fill(centerX, centerY);
fh_axisBXYW->Fill(centerX, centerY, axisB);
fh_axisBXYCount->Fill(centerX, centerY);
} //iRing
} //iEvent
fh_axisAXY->Divide(fh_axisAXYW,fh_axisAXYCount);
fh_axisBXY->Divide(fh_axisBXYW,fh_axisBXYCount);
///create two correction maps
for (Int_t iX = 1; iX < mapaxisAXY->GetNbinsX() + 1; iX++){
for (Int_t iY = 1; iY < mapaxisAXY->GetNbinsY() + 1; iY++){
if (fh_axisAXYCount->GetBinContent(iX, iY) != 0){
mapaxisAXY->SetBinContent(iX, iY, fMeanAaxis - fh_axisAXY->GetBinContent(iX, iY) );
} else {
mapaxisAXY->SetBinContent(iX, iY, -99999999.);
}
if (fh_axisBXYCount->GetBinContent(iX, iY) != 0){
mapaxisBXY->SetBinContent(iX, iY, fMeanBaxis - fh_axisBXY->GetBinContent(iX, iY) );
} else {
mapaxisBXY->SetBinContent(iX, iY, -99999999.);
}
}
}
c1_0 = new TCanvas("c1_0","c1_0",10,10,600,600);
c1_0->Divide(1,2);
c1_0->cd(1);
fh_axisAXYCount->Draw("COLZ");
c1_0->cd(2);
fh_axisBXYCount->Draw("COLZ");
c1 = new TCanvas("c1","c1",10,10,600,600);
c1->Divide(1,2);
c1->cd(1);
fh_axisAXY->SetMinimum(5.0);
fh_axisAXY->SetMaximum(6.4);
fh_axisAXY->Draw("COLZ");
c1->cd(2);
fh_axisBXY->SetMinimum(5.0);
fh_axisBXY->SetMaximum(6.0);
fh_axisBXY->Draw("COLZ");
c2 = new TCanvas("c2","c2",10,10,600,600);
c2->Divide(1,2);
c2->cd(1);
mapaxisAXY->SetMinimum(-0.5);
mapaxisAXY->SetMaximum(0.5);
mapaxisAXY->Draw("COLZ");
c2->cd(2);
mapaxisBXY->SetMinimum(-0.5);
mapaxisBXY->SetMaximum(0.5);
mapaxisBXY->Draw("COLZ");
///// Check correction procedure
TH1D* fh_Abefore = new TH1D("fh_Abefore","A before;A, [cm];yield", 300, 0., 9.);;
TH1D* fh_Bbefore= new TH1D("fh_Bbefore","B before;B, [cm];yield", 300, 0., 9.);;
TH1D* fh_A = new TH1D("fh_A","A after;A, [cm];yield", 300, 0., 9.);;
TH1D* fh_B = new TH1D("fh_B","B after;B, [cm];yield", 300, 0., 9.);;
cout <<"Check correction procedure......" << endl;
for(Int_t ievent=0;ievent<nEvents;ievent++ ) {
CbmRichRing *ring=NULL;
// if (ievent % 100 == 0) cout << ievent << " ";
//t1->GetEntry(ievent);
t->GetEntry(ievent);
t1->GetEntry(ievent);
Int_t nofRings = fRichRings->GetEntries();
for(Int_t iRing=0; iRing < nofRings; iRing++){
ring = (CbmRichRing*)fRichRings->At(iRing);
if (!ring) continue;
match = (CbmRichRingMatch*)fRichMatches->At(iRing);
if (!match) continue;
Int_t trackId = match->GetMCTrackID();
if (trackId == -1) continue;
if (trackId > fMCTracks->GetEntries()) continue;
CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTracks->At(trackId);
if (!mcTrack) continue;
Int_t pdg = TMath::Abs(mcTrack->GetPdgCode());
Int_t motherId = mcTrack->GetMotherId();
if (pdg != 11) continue;
if (motherId != -1) continue;
Double_t axisA = ring->GetAaxis();
Double_t axisB = ring->GetBaxis();
if (axisA > fMaxAaxis || axisB > fMaxAaxis) continue;
if (axisA < fMinAaxis || axisB < fMinAaxis) continue;
Double_t radius = ring->GetRadius();
Double_t centerX = ring->GetCenterX();
Double_t centerY = ring->GetCenterY();
Double_t axisAbefore = ring->GetAaxis();
Double_t axisBbefore = ring->GetBaxis();
fh_Abefore->Fill(axisAbefore);
fh_Bbefore->Fill(axisBbefore);
Double_t axisA = ring->GetAaxis();
Double_t axisB = ring->GetBaxis() ;
axisA += mapaxisAXY->GetBinContent(mapaxisAXY->FindBin(centerX,centerY));
axisB += mapaxisBXY->GetBinContent(mapaxisBXY->FindBin(centerX,centerY));
fh_A->Fill(axisA);
fh_B->Fill(axisB);
} //iRing
}//iEvent
// gStyle->SetOptStat(0);
c3 = new TCanvas("c3","c3",10,10,600,600);
c3->Divide(2,2);
c3->cd(1);
fh_Abefore->Scale(1./fh_Abefore->Integral());
fh_Abefore->SetMaximum(fh_Abefore->GetMaximum()*1.3);
fh_Abefore->Draw();
fh_Abefore->SetAxisRange(fMinAaxis, fMaxAaxis);
fh_Abefore->Fit("gaus");
Double_t sigmaAb = fh_Abefore->GetFunction("gaus")->GetParameter("Sigma");
char sigmaTxtAb[30];
sprintf(sigmaTxtAb,"sigma = %.3f",sigmaAb);
TText* txtAb = new TText(4.3, fh_Abefore->GetMaximum()*0.85, sigmaTxtAb);
txtAb->SetTextSize(0.1);
txtAb->Draw();
gPad->SetGridx(true);
gPad->SetGridy(true);
c3->cd(2);
fh_Bbefore->Scale(1./fh_Bbefore->Integral());
fh_Bbefore->SetMaximum(fh_Bbefore->GetMaximum()*1.3);
fh_Bbefore->Draw();
fh_Bbefore->SetAxisRange(fMinAaxis, fMaxAaxis);
fh_Bbefore->Fit("gaus");
Double_t sigmaBb = fh_Bbefore->GetFunction("gaus")->GetParameter("Sigma");
char sigmaTxtBb[30];
sprintf(sigmaTxtBb,"sigma = %.3f",sigmaBb);
TText* txtBb = new TText(4.3, fh_Bbefore->GetMaximum()*0.85, sigmaTxtBb);
txtBb->SetTextSize(0.1);
txtBb->Draw();
gPad->SetGridx(true);
gPad->SetGridy(true);
c3->cd(3);
fh_A->Scale(1./fh_A->Integral());
fh_A->SetMaximum(fh_A->GetMaximum()*1.3);
fh_A->SetAxisRange(fMinAaxis, fMaxAaxis);
fh_A->Draw();
fh_A->Fit("gaus");
Double_t sigmaA = fh_A->GetFunction("gaus")->GetParameter("Sigma");
char sigmaTxtA[30];
sprintf(sigmaTxtA,"sigma = %.3f",sigmaA);
TText* txtA = new TText(4.3, fh_A->GetMaximum()*0.85, sigmaTxtA);
txtA->SetTextSize(0.1);
txtA->Draw();
gPad->SetGridx(true);
gPad->SetGridy(true);
c3->cd(4);
fh_B->Scale(1./fh_B->Integral());
fh_B->SetMaximum(fh_B->GetMaximum()*1.3);
fh_B->SetAxisRange(fMinAaxis, fMaxAaxis);
fh_B->Draw();
fh_B->Fit("gaus");
Double_t sigmaB = fh_B->GetFunction("gaus")->GetParameter("Sigma");
char sigmaTxtB[30];
sprintf(sigmaTxtB,"sigma = %.3f",sigmaB);
TText* txtB = new TText(4.3, fh_B->GetMaximum()*0.85, sigmaTxtB);
txtB->SetTextSize(0.1);
txtB->Draw();
gPad->SetGridx(true);
gPad->SetGridy(true);
/// Write correction map to the file
TFile *file = new TFile("radius_correction_map.root", "recreate");
mapaxisAXY->Write();
mapaxisBXY->Write();
file->Close();
}
