void run_trac_its(Int_t nEvents = 10, TString mcEngine = "TGeant3"){
// Initialize logger
FairLogger *logger = FairLogger::GetLogger();
logger->SetLogVerbosityLevel("LOW");
logger->SetLogScreenLevel("INFO");
// Input and output file name
std::stringstream inputfile, outputfile, paramfile;
inputfile << "AliceO2_" << mcEngine << ".clus_" << nEvents << "_event.root";
paramfile << "AliceO2_" << mcEngine << ".params_" << nEvents << ".root";
outputfile << "AliceO2_" << mcEngine << ".trac_" << nEvents << "_event.root";
// Setup timer
TStopwatch timer;
// Setup FairRoot analysis manager
FairRunAna * fRun = new FairRunAna();
FairFileSource *fFileSource = new FairFileSource(inputfile.str().c_str());
fRun->SetSource(fFileSource);
fRun->SetOutputFile(outputfile.str().c_str());
// Setup Runtime DB
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
parInput1->open(paramfile.str().c_str());
rtdb->setFirstInput(parInput1);
// Setup tracker
// To run with n threads call AliceO2::ITS::CookedTrackerTask(n)
AliceO2::ITS::CookedTrackerTask *trac = new AliceO2::ITS::CookedTrackerTask;
fRun->AddTask(trac);
fRun->Init();
AliceO2::Field::MagneticField* fld = (AliceO2::Field::MagneticField*)fRun->GetField();
if (!fld) {
std::cout << "Failed to get field instance from FairRunAna" << std::endl;
return;
}
trac->setBz(fld->solenoidField()); //in kG
timer.Start();
fRun->Run();
std::cout << std::endl << std::endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
std::cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
std::cout << maxMemory;
std::cout << "</DartMeasurement>" << std::endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Macro finished succesfully." << endl;
std::cout << endl << std::endl;
std::cout << "Output file is " << outputfile.str() << std::endl;
//std::cout << "Parameter file is " << parFile << std::endl;
std::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" *
********************************************************************************/
void run_tutorial1_mesh(Int_t nEvents = 10, TString mcEngine = "TGeant3")
{
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/Tutorial1";
TString tut_geomdir = dir + "/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
TString partName[] = {"pions","eplus","proton"};
Int_t partPdgC[] = { 211, 11, 2212};
Int_t chosenPart = 0;
Double_t momentum = 2.;
Double_t theta = 0.;
TString outDir = "./";
// Output file name
TString outFile = Form("%s/tutorial1_mesh%s_%s.mc_p%1.3f_t%1.0f_n%d.root",
outDir.Data(),
mcEngine.Data(),
partName[chosenPart].Data(),
momentum,
theta,
nEvents);
// Parameter file name
TString parFile = Form("%s/tutorial1_mesh%s_%s.params_p%1.3f_t%1.0f_n%d.root",
outDir.Data(),
mcEngine.Data(),
partName[chosenPart].Data(),
momentum,
theta,
nEvents);
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
FairDetector* tutdet = new FairTutorialDet1("TUTDET", kTRUE);
tutdet->SetGeometryFileName("double_sector.geo");
run->AddModule(tutdet);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 1);
boxGen->SetThetaRange ( theta, theta+0.01);
boxGen->SetPRange (momentum,momentum+0.01);
boxGen->SetPhiRange (0.,360.);
boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
run->SetStoreTraj(kFALSE); // to store particle trajectories
run->SetRadGridRegister(kTRUE); // activate RadGridManager
// define two example meshs for dosimetry
FairMesh* aMesh1 = new FairMesh("test1");
aMesh1->SetX(-40,40,200);
aMesh1->SetY(-40,40,200);
aMesh1->SetZ(5.2,5.4,1);
FairMesh* aMesh2 = new FairMesh("test2");
aMesh2->SetX(-20,20,20);
aMesh2->SetY(-20,20,20);
aMesh2->SetZ(-5.0,5.0,1);
aMesh1->print();
aMesh2->print();
run->AddMesh( aMesh1 );
run->AddMesh( aMesh2 );
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
void run_sim(Int_t nEvents = 10, TString mcEngine = "TGeant3", Int_t fileId = 0)
{
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/MQ/9-PixelDetector";
TString tut_geomdir = dir + "/common/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = dir + "/common/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
TString partName[] = {"pions","eplus","proton"};
Int_t partPdgC[] = { 211, 11, 2212};
Int_t chosenPart = 0;
TString outDir = "./";
// Output file name
TString outFile;
if ( fileId == 0 ) outFile = Form("%s/pixel_%s.mc.root",
outDir.Data(),
mcEngine.Data());
else outFile = Form("%s/pixel_%s.mc.f%d.root",
outDir.Data(),
mcEngine.Data(),
fileId);
// Parameter file name
TString parFile = Form("%s/pixel_%s.params.root",
outDir.Data(),
mcEngine.Data());
// In general, the following parts need not be touched
// ========================================================================
// ---- Debug option -------------------------------------------------
gDebug = 0;
// ------------------------------------------------------------------------
// ----- Timer --------------------------------------------------------
TStopwatch timer;
timer.Start();
// ------------------------------------------------------------------------
// ----- Create simulation run ----------------------------------------
FairRunSim* run = new FairRunSim();
run->SetName(mcEngine); // Transport engine
run->SetOutputFile(outFile); // Output file
FairRuntimeDb* rtdb = run->GetRuntimeDb();
// ------------------------------------------------------------------------
// ----- Create media -------------------------------------------------
run->SetMaterials("media.geo"); // Materials
// ------------------------------------------------------------------------
// ----- Create geometry ----------------------------------------------
FairModule* cave= new FairCave("CAVE");
cave->SetGeometryFileName("cave_vacuum.geo");
run->AddModule(cave);
Pixel* det = new Pixel("Tut9", kTRUE);
det->SetGeometryFileName("pixel.geo");
// det->SetMisalignDetector(kTRUE);
run->AddModule(det);
// ------------------------------------------------------------------------
// ----- Create PrimaryGenerator --------------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 5);
boxGen->SetPRange(1,2);
boxGen->SetThetaRange(0,40);
boxGen->SetPhiRange(0,360);
// boxGen->SetDebug(kTRUE);
primGen->AddGenerator(boxGen);
run->SetGenerator(primGen);
// ------------------------------------------------------------------------
run->SetStoreTraj(kFALSE);
// ----- Initialize simulation run ------------------------------------
run->Init();
// ------------------------------------------------------------------------
// ----- Runtime database ---------------------------------------------
Bool_t kParameterMerged = kTRUE;
FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
parOut->open(parFile.Data());
rtdb->setOutput(parOut);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
run->Run(nEvents);
run->CreateGeometryFile("geofile_full.root");
// ------------------------------------------------------------------------
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_reco_timebased( TString mcEngine="TGeant3" )
{
FairLogger *logger = FairLogger::GetLogger();
logger->SetLogFileName("MyLog.log");
// logger->SetLogToScreen(kTRUE);
// logger->SetLogToFile(kTRUE);
// logger->SetLogVerbosityLevel("HIGH");
// logger->SetLogFileLevel("DEBUG4");
// logger->SetLogScreenLevel("DEBUG");
// Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug)
Int_t iVerbose = 0; // just forget about it, for the moment
// Input file (MC events)
TString inFile = "data/testdigitimebased_";
inFile = inFile + mcEngine + ".root";
// Parameter file
TString parFile = "data/testparams_";
parFile = parFile + mcEngine + ".root";
// Output file
TString outFile = "data/testrecotimebased_";
outFile = outFile + mcEngine + ".root";
// ----- Timer --------------------------------------------------------
TStopwatch timer;
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(inFile);
fRun->SetOutputFile(outFile);
fRun->RunWithTimeStamps();
fRun->SetUseFairLinks(kTRUE);
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
parInput1->open(parFile.Data());
rtdb->setFirstInput(parInput1);
// ----- TorinoDetector hit producers ---------------------------------
FairTestDetectorTimeRecoTask* hitProducer = new FairTestDetectorTimeRecoTask();
fRun->AddTask(hitProducer);
fRun->Init();
timer.Start();
fRun->Run();
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
void run_DiReLo(Int_t nofFiles, TString mcEngine="TGeant3" )
{
FairLogger *logger = FairLogger::GetLogger();
// logger->SetLogFileName("MyLog.log");
// logger->SetLogToScreen(kTRUE);
// logger->SetLogToFile(kTRUE);
logger->SetLogVerbosityLevel("LOW");
// logger->SetLogFileLevel("DEBUG4");
// logger->SetLogScreenLevel("DEBUG");
TString workDir = gSystem->WorkingDirectory();
// Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug)
Int_t iVerbose = 0; // just forget about it, for the moment
// Input file (MC events)
// TString inFile = "data/testrun_";
// inFile = inFile + mcEngine + ".root";
// Parameter file
// TString parFile = "data/testparams_";
// parFile = parFile + mcEngine + ".root";
// Output file
TString outFile = Form("data/testDiReLo_%df_",nofFiles);
outFile = outFile + mcEngine + ".root";
// ----- Timer --------------------------------------------------------
TStopwatch timer;
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(Form("file://%s/data/testrun_%s_f%d.root",workDir.Data(),mcEngine.Data(),0));
for ( Int_t ifile = 1 ; ifile < nofFiles ; ifile++ ) {
cout << "fRun->AddFile(....f" << ifile << ".root" << endl;
fRun->AddFile (Form("file://%s/data/testrun_%s_f%d.root",workDir.Data(),mcEngine.Data(),ifile));
}
fRun->SetOutputFile(outFile);
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
TList* fnamelist = new TList();
for ( Int_t ifile = 0 ; ifile < nofFiles ; ifile++ )
fnamelist->Add(new TObjString(Form("%s/data/testpar_%s_f%d.root",workDir.Data(),mcEngine.Data(),ifile)));
cout << "PAR LIST CREATED" << endl;
parInput1->open(fnamelist);
// parInput1->open(parFile.Data());
rtdb->setFirstInput(parInput1);
FairTestDetectorDigiTask* digiTask = new FairTestDetectorDigiTask();
fRun->AddTask(digiTask);
FairTestDetectorRecoTask* hitProducer = new FairTestDetectorRecoTask();
fRun->AddTask(hitProducer);
fRun->Init();
timer.Start();
fRun->Run();
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
plots(Int_t nEvents = 1000, Int_t iout=1, TString mcEngine="TGeant3")
{
// Input data definitions
//-----User Settings:-----------------------------------------------
TString MCFile ="testrun_" + mcEngine + ".root";
TString ParFile ="testparams_" + mcEngine + ".root";
TString RecoFile ="testreco_"+ mcEngine + ".root";;
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
fRun->SetInputFile(MCFile.Data());
fRun->AddFriend(RecoFile.Data());
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
parInput1->open(ParFile.Data());
rtdb->setFirstInput(parInput1);
TFile *f1 = TFile::Open(MCFile);
TFile *f2 = TFile::Open(RecoFile);
TTree *t1 = f1->Get("cbmsim");
TTree *t2 = f2->Get("cbmsim");
FairMCEventHeader *MCEventHeader = new FairMCEventHeader();
TClonesArray *MCTracks = new TClonesArray("FairMCTrack");
TClonesArray *TutorialDetPoints = new TClonesArray("FairTutorialDet4Point");
TClonesArray *TutorialDetHits = new TClonesArray("FairTutorialDet4Hit");
t1->SetBranchAddress("MCEventHeader.",&MCEventHeader);
t1->SetBranchAddress("MCTrack", &MCTracks);
t1->SetBranchAddress("TutorialDetPoint", &TutorialDetPoints);
t2->SetBranchAddress("TutorialDetHit", &TutorialDetHits);
FairMCTrack *MCTrack;
FairTutorialDet4Point *Point;
FairTutorialDet4Hit *Hit;
//histograms
fRun->SetOutputFile("test.ana.root");
TFile *fHist = fRun->GetOutputFile();
Float_t xrange=80.;
Float_t yrange=80.;
TH2F* dxx = new TH2F("dxx","Hit; x; Delta x;",100,-xrange,xrange,50.,-10.,10.);
TH2F* dyy = new TH2F("dyy","Hit; y; Delta y;",100,-yrange,yrange,50.,-10.,10.);
TH1F* pullx = new TH1F("pullx","Hit; pullx;",100.,-5.,5.);
TH1F* pully = new TH1F("pully","Hit; pully;",100.,-5.,5.);
TH1F* pullz = new TH1F("pullz","Hit; pullz;",50.,-10.,10.);
TH1F* pointx = new TH1F("pointx","Hit; posx;",200.,-80.,80.);
TH1F* pointy = new TH1F("pointy","Hit; posy;",200.,-80.,80.);
Int_t nMCTracks, nPoints, nHits;
Float_t x_point, y_point, z_point, tof_point, SMtype_point, mod_point, cel_point, gap_point;
Float_t x_poi, y_poi, z_poi;
Float_t SMtype_poi, mod_poi, cel_poi, gap_poi;
Float_t p_MC, px_MC, py_MC, pz_MC;
Float_t x_hit, y_hit, z_hit, dy_hit;
Int_t nevent = t1->GetEntries();
if (nevent > nEvents) nevent=nEvents;
cout << "total number of events to process: " << nevent
<<endl;
// Event loop
for (Int_t iev=0; iev< nevent; iev++) {
// get entry
t1->GetEntry(iev);
t2->GetEntry(iev);
nMCTracks = MCTracks->GetEntriesFast();
nPoints = TutorialDetPoints->GetEntriesFast();
nHits = TutorialDetHits->GetEntriesFast();
cout << " Event" << iev << ":";
cout << nMCTracks << " MC tracks ";
cout << nPoints << " points ";
cout << nHits << " Hits "<<endl;
// Hit loop
for (Int_t j =0; j<nHits; j++) {
Hit = (FairTutorialDet4Hit*) TutorialDetHits->At(j);
Int_t l = Hit->GetRefIndex();
Point = (FairTutorialDet4Point*) TutorialDetPoints->At(l);
// Point info
x_poi = Point -> GetX();
y_poi = Point -> GetY();
z_poi = Point -> GetZ();
// Hit info
x_hit = Hit->GetX();
y_hit = Hit->GetY();
z_hit = Hit->GetZ();
dy_hit = Hit->GetDy();
// Int_t flg_hit = Hit->GetFlag();
Float_t delta_x = x_poi - x_hit;
Float_t delta_y = y_poi - y_hit;
Float_t delta_z = z_poi - z_hit;
dxx ->Fill(x_poi,delta_x);
dyy ->Fill(y_poi,delta_y);
pullx ->Fill(delta_x);
pully ->Fill(delta_y);
pullz ->Fill(delta_z);
pointx ->Fill(x_hit);
pointy ->Fill(y_hit);
} // Hit loop end
} // event loop end
// save histos to file
// TFile *fHist = TFile::Open("data/auaumbias.hst.root","RECREATE");
cout << "Processing done, outflag =" <<iout << endl;
if (iout==1){
fHist->Write();
if(0){ // explicit writing
TIter next(gDirectory->GetList());
TH1 *h;
TObject* obj;
while(obj= (TObject*)next()){
if(obj->InheritsFrom(TH1::Class())){
h = (TH1*)obj;
cout << "Write histo " << h->GetTitle() << endl;
h->Write();
}
}
}
fHist->ls();
fHist->Close();
}
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
void run_digi_tpc(Int_t nEvents = 10, TString mcEngine = "TGeant3"){
// Initialize logger
FairLogger *logger = FairLogger::GetLogger();
logger->SetLogVerbosityLevel("LOW");
logger->SetLogScreenLevel("INFO");
// Input and output file name
std::stringstream inputfile, outputfile, paramfile;
inputfile << "AliceO2_" << mcEngine << ".tpc.mc_" << nEvents << "_event.root";
paramfile << "AliceO2_" << mcEngine << ".tpc.params_" << nEvents << ".root";
outputfile << "AliceO2_" << mcEngine << ".tpc.digi_" << nEvents << "_event.root";
// Setup timer
TStopwatch timer;
// Setup FairRoot analysis manager
FairRunAna * fRun = new FairRunAna();
FairFileSource *fFileSource = new FairFileSource(inputfile.str().c_str());
fRun->SetSource(fFileSource);
fRun->SetOutputFile(outputfile.str().c_str());
// Setup Runtime DB
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
parInput1->open(paramfile.str().c_str());
rtdb->setFirstInput(parInput1);
// TGeoManager::Import("geofile_full.root");
// Setup digitizer
AliceO2::ITS::DigitizerTask *digi = new AliceO2::ITS::DigitizerTask;
fRun->AddTask(digi);
AliceO2::TPC::DigitizerTask *digiTPC = new AliceO2::TPC::DigitizerTask;
fRun->AddTask(digiTPC);
fRun->Init();
timer.Start();
fRun->Run();
std::cout << std::endl << std::endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
std::cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
std::cout << maxMemory;
std::cout << "</DartMeasurement>" << std::endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
std::cout << "Macro finished succesfully." << std::endl;
std::cout << endl << std::endl;
std::cout << "Output file is " << outputfile.str() << std::endl;
//std::cout << "Parameter file is " << parFile << std::endl;
std::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 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_reco( TString mcEngine="TGeant3", Bool_t AlignDone=true )
{
// ---- Load libraries -------------------------------------------------
FairLogger *logger = FairLogger::GetLogger();
// logger->SetLogFileName("MyLog.log");
logger->SetLogToScreen(kTRUE);
// logger->SetLogToFile(kTRUE);
// logger->SetLogVerbosityLevel("HIGH");
// logger->SetLogFileLevel("DEBUG4");
logger->SetLogScreenLevel("INFO");
// Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug)
Int_t iVerbose = 0; // just forget about it, for the moment
TString Align= "";
if (AlignDone) {
Align= "align_";
}
TString InDir = "./data/";
// Input file (MC Events)
TString inFile ="testrun_";
inFile = InDir +inFile + Align + mcEngine + ".root";
// Output file name
TString outFile ="testreco_";
outFile = InDir + outFile + Align + mcEngine + ".root";
// Parameter file
TString parFile ="testparams_";
parFile = InDir + parFile + Align + mcEngine + ".root";
// Millepede file name
TString milleFile ="testmille_";
milleFile = InDir + milleFile + Align + mcEngine;
TList *parFileList = new TList();
TString workDir = gSystem->Getenv("VMCWORKDIR");
TString paramDir = workDir + "/simulation/Tutorial4/parameters/";
TString paramFile = paramDir + "example.par";
TObjString tutDetDigiFile;
tutDetDigiFile.SetString(paramFile);
parFileList->Add(&tutDetDigiFile);
// ----- Timer --------------------------------------------------------
TStopwatch timer;
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
FairFileSource *fFileSource = new FairFileSource(inFile);
fRun->SetSource(fFileSource);
fRun->SetSink(new FairRootFileSink(outFile));
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo();
parIo2->open(parFileList, "in");
parInput1->open(parFile.Data());
parIo2->open(parFileList, "in");
rtdb->setFirstInput(parInput1);
rtdb->setSecondInput(parIo2);
rtdb->setOutput(parInput1);
rtdb->saveOutput();
// ----- TorinoDetector hit producers ---------------------------------
FairTutorialDet4HitProducerIdealMisalign* hitProducer = new FairTutorialDet4HitProducerIdealMisalign();
hitProducer->DoMisalignment(kFALSE);
fRun->AddTask(hitProducer);
FairTutorialDet4StraightLineFitter* fitter = new FairTutorialDet4StraightLineFitter();
fitter->SetVersion(2);
fRun->AddTask(fitter);
FairTutorialDet4MilleWriter* writer = new FairTutorialDet4MilleWriter();
// writer->SetWriteAscii(kTRUE);
writer->SetVersion(2);
writer->SetFileName(milleFile);
fRun->AddTask(writer);
fRun->Init();
timer.Start();
fRun->Run();
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_sim(Int_t nEvents=100, TString mcEngine="TGeant3")
{
TStopwatch timer;
timer.Start();
gDebug=0;
// Use non default gconfig and geometry directories
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/";
TString tut_geomdir = tutdir + "/common/geometry";
gSystem->Setenv("GEOMPATH",tut_geomdir.Data());
TString tut_configdir = tutdir + "/common/gconfig";
gSystem->Setenv("CONFIG_DIR",tut_configdir.Data());
// create Instance of Run Manager class
FairRunSim *fRun = new FairRunSim();
// set the MC version used
// ------------------------
fRun->SetName(mcEngine);
TString outFile = "data/testrun_";
outFile = outFile + mcEngine + ".root";
TString parFile = "data/testparams_";
parFile = parFile + mcEngine + ".root";
fRun->SetOutputFile(outFile);
// ----- Magnetic field -------------------------------------------
// Constant Field
FairConstField *fMagField = new FairConstField();
fMagField->SetField(0., 10. ,0. ); // values are in kG
fMagField->SetFieldRegion(-50, 50,-50, 50, 350, 450);// values are in cm (xmin,xmax,ymin,ymax,zmin,zmax)
fRun->SetField(fMagField);
// --------------------------------------------------------------------
// Set Material file Name
//-----------------------
fRun->SetMaterials("media.geo");
// Create and add detectors
//-------------------------
FairModule *Cave= new FairCave("CAVE");
Cave->SetGeometryFileName("cave.geo");
fRun->AddModule(Cave);
FairModule *Magnet= new FairMagnet("MAGNET");
Magnet->SetGeometryFileName("magnet.geo");
fRun->AddModule(Magnet);
FairDetector *Torino= new FairTestDetector("TORINO", kTRUE);
Torino->SetGeometryFileName("torino.geo");
fRun->AddModule(Torino);
// Create and Set Event Generator
//-------------------------------
FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
fRun->SetGenerator(primGen);
// Box Generator
FairBoxGenerator* boxGen = new FairBoxGenerator(2212, 10); // 13 = muon; 1 = multipl.
boxGen->SetPRange(2., 2.); // GeV/c //setPRange vs setPtRange
boxGen->SetPhiRange(0, 360); // Azimuth angle range [degree]
boxGen->SetThetaRange(3, 10); // Polar angle in lab system range [degree]
boxGen->SetCosTheta();//uniform generation on all the solid angle(default)
// boxGen->SetXYZ(0., 0.37, 0.);
primGen->AddGenerator(boxGen);
fRun->SetStoreTraj(kTRUE);
fRun->Init();
// -Trajectories Visualization (TGeoManager Only )
// -----------------------------------------------
// Set cuts for storing the trajectpries
/* FairTrajFilter* trajFilter = FairTrajFilter::Instance();
trajFilter->SetStepSizeCut(0.01); // 1 cm
trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.);
trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV
trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV
trajFilter->SetStorePrimaries(kTRUE);
trajFilter->SetStoreSecondaries(kTRUE);
*/
// Fill the Parameter containers for this run
//-------------------------------------------
FairRuntimeDb *rtdb=fRun->GetRuntimeDb();
Bool_t kParameterMerged=kTRUE;
FairParRootFileIo* output=new FairParRootFileIo(kParameterMerged);
output->open(parFile);
rtdb->setOutput(output);
rtdb->saveOutput();
rtdb->print();
// Transport nEvents
// -----------------
// Int_t nEvents = 1;
fRun->Run(nEvents);
fRun->CreateGeometryFile("data/geofile_full.root");
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void run_hits( TString mcEngine="TGeant3" )
{
// Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug)
Int_t iVerbose = 0; // just forget about it, for the moment
// Input file (MC events)
TString inFile = "pixel_";
inFile = inFile + mcEngine + ".digi.root";
// Parameter file
TString parFile = "pixel_";
parFile = parFile + mcEngine + ".params.root";
// Digitization parameter file
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/MQ/pixelDetector";
TString digParFile = tutdir + "/param/pixel_digi.par";
// Output file
TString outFile = "pixel_";
outFile = outFile + mcEngine + ".hits.root";
// ----- Timer --------------------------------------------------------
TStopwatch timer;
// ----- Reconstruction run -------------------------------------------
FairRunAna *fRun= new FairRunAna();
FairFileSource *fFileSource = new FairFileSource(inFile);
fRun->SetSource(fFileSource);
fRun->SetSink(new FairRootFileSink(outFile));
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
// fRun->AddFile(inFile);
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
FairParRootFileIo* parInput1 = new FairParRootFileIo();
parInput1->open(parFile.Data());
FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
parIo1->open(digParFile.Data(),"in");
rtdb->setFirstInput(parInput1);
rtdb->setSecondInput(parIo1);
// ----- TorinoDetector hit producers ---------------------------------
PixelFindHits* hitFinderTask = new PixelFindHits();
fRun->AddTask(hitFinderTask);
fRun->Init();
timer.Start();
fRun->Run();
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
/********************************************************************************
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence version 3 (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
void create_digis(){
TStopwatch timer;
timer.Start();
gDebug=0;
TString dir = getenv("VMCWORKDIR");
TString tutdir = dir + "/simulation/Tutorial2";
TString inFile = "./tutorial2_pions.mc_p2.000_t0_n10.root";
TString parFile = "./tutorial2_pions.params_p2.000_t0_n10.root";
TString outFile = "./digis.mc.root";
cout << "******************************" << endl;
cout << "InFile: " << inFile << endl;
cout << "ParamFile: " << parFile << endl;
cout << "OutFile: " << outFile << endl;
cout << "******************************" << endl;
FairRunAna *fRun= new FairRunAna();
FairFileSource *fFileSource = new FairFileSource(inFile);
fRun->SetSource(fFileSource);
fRun->SetOutputFile(outFile);
// Init Simulation Parameters from Root File
FairRuntimeDb* rtdb=fRun->GetRuntimeDb();
FairParRootFileIo* io1=new FairParRootFileIo();
io1->open(parFile.Data(),"UPDATE");
FairParAsciiFileIo* parInput2 = new FairParAsciiFileIo();
TString tutDetDigiFile = gSystem->Getenv("VMCWORKDIR");
tutDetDigiFile += "/simulation/Tutorial2/parameters/tutdet.digi.par";
parInput2->open(tutDetDigiFile.Data(),"in");
rtdb->setFirstInput(io1);
rtdb->setSecondInput(parInput2);
rtdb->print();
//** TUt Det Digi Producer **//
FairTutorialDet2Digitizer *digi = new FairTutorialDet2Digitizer("tutdet","tut det task");
// add the task
fRun->AddTask( digi );
fRun->Init();
rtdb->getContainer("FairTutorialDet2DigiPar")->print();
FairTutorialDet2DigiPar* DigiPar = (FairTutorialDet2DigiPar*)
rtdb->getContainer("FairTutorialDet2DigiPar");
DigiPar->setChanged();
DigiPar->setInputVersion(fRun->GetRunId(),1);
rtdb->setOutput(io1);
rtdb->saveOutput();
rtdb->print();
fRun->Run();
// ----- Finish -------------------------------------------------------
cout << endl << endl;
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
timer.Stop();
Double_t rtime = timer.RealTime();
Double_t ctime = timer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl << endl;
cout << "Output file is " << outFile << endl;
cout << "Parameter file is " << parFile << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl << endl;
cout << "Macro finished successfully." << endl;
// ------------------------------------------------------------------------
}
void ana_complete(int nevts=0)
{
TDatabasePDG::Instance()->AddParticle("pbarpSystem","pbarpSystem",1.9,kFALSE,0.1,0,"",88888);
TStopwatch fTimer;
// *** some variables
int i=0,j=0, k=0, l=0;
gStyle->SetOptFit(1011);
// *** the output file for FairRunAna
TString OutFile="output.root";
// *** the files coming from the simulation
TString inPidFile = "psi2s_jpsi2pi_jpsi_mumu_pid.root"; // this file contains the PndPidCandidates and McTruth
TString inParFile = "psi2s_jpsi2pi_jpsi_mumu_par.root";
// *** PID table with selection thresholds; can be modified by the user
TString pidParFile = TString(gSystem->Getenv("VMCWORKDIR"))+"/macro/params/all_day1.par";
// *** initialization
FairLogger::GetLogger()->SetLogToFile(kFALSE);
FairRunAna* fRun = new FairRunAna();
FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
fRun->SetInputFile(inPidFile);
// *** setup parameter database
FairParRootFileIo* parIO = new FairParRootFileIo();
parIO->open(inParFile);
FairParAsciiFileIo* parIOPid = new FairParAsciiFileIo();
parIOPid->open(pidParFile.Data(),"in");
rtdb->setFirstInput(parIO);
rtdb->setSecondInput(parIOPid);
rtdb->setOutput(parIO);
fRun->SetOutputFile(OutFile);
fRun->Init();
// *** create an output file for all histograms
TFile *out = TFile::Open("output_ana.root","RECREATE");
// *** create some histograms
TH1F *hmomtrk = new TH1F("hmomtrk","track momentum (all)",200,0,5);
TH1F *hthttrk = new TH1F("hthttrk","track theta (all)",200,0,3.1415);
TH1F *hjpsim_all = new TH1F("hjpsim_all","J/#psi mass (all)",200,0,4.5);
TH1F *hpsim_all = new TH1F("hpsim_all","#psi(2S) mass (all)",200,0,5);
TH1F *hjpsim_lpid = new TH1F("hjpsim_lpid","J/#psi mass (loose pid)",200,0,4.5);
TH1F *hpsim_lpid = new TH1F("hpsim_lpid","#psi(2S) mass (loose pid)",200,0,5);
TH1F *hjpsim_tpid = new TH1F("hjpsim_tpid","J/#psi mass (tight pid)",200,0,4.5);
TH1F *hpsim_tpid = new TH1F("hpsim_tpid","#psi(2S) mass (tight pid)",200,0,5);
TH1F *hjpsim_trpid = new TH1F("hjpsim_trpid","J/#psi mass (true pid)",200,0,4.5);
TH1F *hpsim_trpid = new TH1F("hpsim_trpid","#psi(2S) mass (true pid)",200,0,5);
TH1F *hjpsim_ftm = new TH1F("hjpsim_ftm","J/#psi mass (full truth match)",200,0,4.5);
TH1F *hpsim_ftm = new TH1F("hpsim_ftm","#psi(2S) mass (full truth match)",200,0,5);
TH1F *hjpsim_nm = new TH1F("hjpsim_nm","J/#psi mass (no truth match)",200,0,4.5);
TH1F *hpsim_nm = new TH1F("hpsim_nm","#psi(2S) mass (no truth match)",200,0,5);
TH1F *hjpsim_diff = new TH1F("hjpsim_diff","J/#psi mass diff to truth",100,-2,2);
TH1F *hpsim_diff = new TH1F("hpsim_diff","#psi(2S) mass diff to truth",100,-2,2);
TH1F *hjpsim_vf = new TH1F("hjpsim_vf","J/#psi mass (vertex fit)",200,0,4.5);
TH1F *hjpsim_4cf = new TH1F("hjpsim_4cf","J/#psi mass (4C fit)",200,0,4.5);
TH1F *hjpsim_mcf = new TH1F("hjpsim_mcf","J/#psi mass (mass constraint fit)",200,0,4.5);
TH1F *hjpsi_chi2_vf = new TH1F("hjpsi_chi2_vf", "J/#psi: #chi^{2} vertex fit",100,0,10);
TH1F *hpsi_chi2_4c = new TH1F("hpsi_chi2_4c", "#psi(2S): #chi^{2} 4C fit",100,0,250);
TH1F *hjpsi_chi2_mf = new TH1F("hjpsi_chi2_mf", "J/#psi: #chi^{2} mass fit",100,0,10);
TH1F *hjpsi_prob_vf = new TH1F("hjpsi_prob_vf", "J/#psi: Prob vertex fit",100,0,1);
TH1F *hpsi_prob_4c = new TH1F("hpsi_prob_4c", "#psi(2S): Prob 4C fit",100,0,1);
TH1F *hjpsi_prob_mf = new TH1F("hjpsi_prob_mf", "J/#psi: Prob mass fit",100,0,1);
TH2F *hvpos = new TH2F("hvpos","(x,y) projection of fitted decay vertex",100,-2,2,100,-2,2);
//
// Now the analysis stuff comes...
//
// *** the data reader object
PndAnalysis* theAnalysis = new PndAnalysis();
if (nevts==0) nevts= theAnalysis->GetEntries();
// *** RhoCandLists for the analysis
RhoCandList chrg, muplus, muminus, piplus, piminus, jpsi, psi2s;
// *** Mass selector for the jpsi cands
double m0_jpsi = TDatabasePDG::Instance()->GetParticle("J/psi")->Mass(); // Get nominal PDG mass of the J/psi
RhoMassParticleSelector *jpsiMassSel=new RhoMassParticleSelector("jpsi",m0_jpsi,1.0);
// *** the lorentz vector of the initial psi(2S)
TLorentzVector ini(0, 0, 6.231552, 7.240065);
// ***
// the event loop
// ***
int cntdbltrk=0, cntdblmc=0, cntdblboth=0, cnttrk=0, cnt_dbl_jpsi=0, cnt_dbl_psip=0;
while (theAnalysis->GetEvent() && i++<nevts)
{
if ((i%100)==0) cout<<"evt " << i << endl;
// *** Select with no PID info ('All'); type and mass are set
theAnalysis->FillList(chrg, "Charged");
theAnalysis->FillList(muplus, "MuonAllPlus");
theAnalysis->FillList(muminus, "MuonAllMinus");
theAnalysis->FillList(piplus, "PionAllPlus");
theAnalysis->FillList(piminus, "PionAllMinus");
// *** momentum and theta histograms
for (j=0;j<muplus.GetLength();++j)
{
hmomtrk->Fill(muplus[j]->P());
hthttrk->Fill(muplus[j]->P4().Theta());
}
for (j=0;j<muminus.GetLength();++j)
{
hmomtrk->Fill(muminus[j]->P());
hthttrk->Fill(muminus[j]->P4().Theta());
}
cnttrk += chrg.GetLength();
int n1, n2, n3;
countDoubles(chrg,n1,n2,n3);
cntdbltrk += n1;
cntdblmc += n2;
cntdblboth += n3;
// *** combinatorics for J/psi -> mu+ mu-
jpsi.Combine(muplus, muminus);
// ***
// *** do the TRUTH MATCH for jpsi
// ***
jpsi.SetType(443);
int nm = 0;
for (j=0;j<jpsi.GetLength();++j)
{
hjpsim_all->Fill( jpsi[j]->M() );
if (theAnalysis->McTruthMatch(jpsi[j]))
{
nm++;
hjpsim_ftm->Fill( jpsi[j]->M() );
hjpsim_diff->Fill( jpsi[j]->GetMcTruth()->M() - jpsi[j]->M() );
}
else
hjpsim_nm->Fill( jpsi[j]->M() );
}
if (nm>1) cnt_dbl_jpsi++;
// ***
// *** do VERTEX FIT (J/psi)
// ***
for (j=0;j<jpsi.GetLength();++j)
{
PndKinVtxFitter vtxfitter(jpsi[j]); // instantiate a vertex fitter
vtxfitter.Fit();
double chi2_vtx = vtxfitter.GetChi2(); // access chi2 of fit
double prob_vtx = vtxfitter.GetProb(); // access probability of fit
hjpsi_chi2_vf->Fill(chi2_vtx);
hjpsi_prob_vf->Fill(prob_vtx);
if ( prob_vtx > 0.01 ) // when good enough, fill some histos
{
RhoCandidate *jfit = jpsi[j]->GetFit(); // access the fitted cand
TVector3 jVtx=jfit->Pos(); // and the decay vertex position
hjpsim_vf->Fill(jfit->M());
hvpos->Fill(jVtx.X(),jVtx.Y());
}
}
// *** some rough mass selection
jpsi.Select(jpsiMassSel);
// *** combinatorics for psi(2S) -> J/psi pi+ pi-
psi2s.Combine(jpsi, piplus, piminus);
// ***
// *** do the TRUTH MATCH for psi(2S)
// ***
psi2s.SetType(88888);
nm = 0;
for (j=0;j<psi2s.GetLength();++j)
{
hpsim_all->Fill( psi2s[j]->M() );
if (theAnalysis->McTruthMatch(psi2s[j]))
{
nm++;
hpsim_ftm->Fill( psi2s[j]->M() );
hpsim_diff->Fill( psi2s[j]->GetMcTruth()->M() - psi2s[j]->M() );
}
else
hpsim_nm->Fill( psi2s[j]->M() );
}
if (nm>1) cnt_dbl_psip++;
// ***
// *** do 4C FIT (initial psi(2S) system)
// ***
for (j=0;j<psi2s.GetLength();++j)
{
PndKinFitter fitter(psi2s[j]); // instantiate the kin fitter in psi(2S)
fitter.Add4MomConstraint(ini); // set 4 constraint
fitter.Fit(); // do fit
double chi2_4c = fitter.GetChi2(); // get chi2 of fit
double prob_4c = fitter.GetProb(); // access probability of fit
hpsi_chi2_4c->Fill(chi2_4c);
hpsi_prob_4c->Fill(prob_4c);
if ( prob_4c > 0.01 ) // when good enough, fill some histo
{
RhoCandidate *jfit = psi2s[j]->Daughter(0)->GetFit(); // get fitted J/psi
hjpsim_4cf->Fill(jfit->M());
}
}
// ***
// *** do MASS CONSTRAINT FIT (J/psi)
// ***
for (j=0;j<jpsi.GetLength();++j)
{
PndKinFitter mfitter(jpsi[j]); // instantiate the PndKinFitter in psi(2S)
mfitter.AddMassConstraint(m0_jpsi); // add the mass constraint
mfitter.Fit(); // do fit
double chi2_m = mfitter.GetChi2(); // get chi2 of fit
double prob_m = mfitter.GetProb(); // access probability of fit
hjpsi_chi2_mf->Fill(chi2_m);
hjpsi_prob_mf->Fill(prob_m);
if ( prob_m > 0.01 ) // when good enough, fill some histo
{
RhoCandidate *jfit = jpsi[j]->GetFit(); // access the fitted cand
hjpsim_mcf->Fill(jfit->M());
}
}
// ***
// *** TRUE PID combinatorics
// ***
// *** do MC truth match for PID type
SelectTruePid(theAnalysis, muplus);
SelectTruePid(theAnalysis, muminus);
SelectTruePid(theAnalysis, piplus);
SelectTruePid(theAnalysis, piminus);
// *** all combinatorics again with true PID
jpsi.Combine(muplus, muminus);
for (j=0;j<jpsi.GetLength();++j) hjpsim_trpid->Fill( jpsi[j]->M() );
jpsi.Select(jpsiMassSel);
psi2s.Combine(jpsi, piplus, piminus);
for (j=0;j<psi2s.GetLength();++j) hpsim_trpid->Fill( psi2s[j]->M() );
// ***
// *** LOOSE PID combinatorics
// ***
// *** and again with PidAlgoMvd;PidAlgoStt;PidAlgoDrc and loose selection
theAnalysis->FillList(muplus, "MuonLoosePlus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc;PidAlgoMdtHardCuts");
theAnalysis->FillList(muminus, "MuonLooseMinus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc;PidAlgoMdtHardCuts");
theAnalysis->FillList(piplus, "PionLoosePlus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc");
theAnalysis->FillList(piminus, "PionLooseMinus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc");
jpsi.Combine(muplus, muminus);
for (j=0;j<jpsi.GetLength();++j) hjpsim_lpid->Fill( jpsi[j]->M() );
jpsi.Select(jpsiMassSel);
psi2s.Combine(jpsi, piplus, piminus);
for (j=0;j<psi2s.GetLength();++j) hpsim_lpid->Fill( psi2s[j]->M() );
// ***
// *** TIGHT PID combinatorics
// ***
// *** and again with PidAlgoMvd;PidAlgoStt and tight selection
theAnalysis->FillList(muplus, "MuonTightPlus", "PidAlgoMdtHardCuts");
theAnalysis->FillList(muminus, "MuonTightMinus", "PidAlgoMdtHardCuts");
theAnalysis->FillList(piplus, "PionLoosePlus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc");
theAnalysis->FillList(piminus, "PionLooseMinus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc");
jpsi.Combine(muplus, muminus);
for (j=0;j<jpsi.GetLength();++j) hjpsim_tpid->Fill( jpsi[j]->M() );
jpsi.Select(jpsiMassSel);
psi2s.Combine(jpsi, piplus, piminus);
for (j=0;j<psi2s.GetLength();++j) hpsim_tpid->Fill( psi2s[j]->M() );
}
// *** write out all the histos
out->cd();
hmomtrk->Write();
hthttrk->Write();
hjpsim_all->Write();
hpsim_all->Write();
hjpsim_lpid->Write();
hpsim_lpid->Write();
hjpsim_tpid->Write();
hpsim_tpid->Write();
hjpsim_trpid->Write();
hpsim_trpid->Write();
hjpsim_ftm->Write();
hpsim_ftm->Write();
hjpsim_nm->Write();
hpsim_nm->Write();
hpsim_diff->Write();
hjpsim_diff->Write();
hjpsim_vf->Write();
hjpsim_4cf->Write();
hjpsim_mcf->Write();
hjpsi_chi2_vf->Write();
hpsi_chi2_4c->Write();
hjpsi_chi2_mf->Write();
hjpsi_prob_vf->Write();
hpsi_prob_4c->Write();
hjpsi_prob_mf->Write();
hvpos->Write();
out->Save();
// Extract the maximal used memory an add is as Dart measurement
// This line is filtered by CTest and the value send to CDash
FairSystemInfo sysInfo;
Float_t maxMemory=sysInfo.GetMaxMemory();
cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
cout << maxMemory;
cout << "</DartMeasurement>" << endl;
fTimer.Stop();
Double_t rtime = fTimer.RealTime();
Double_t ctime = fTimer.CpuTime();
Float_t cpuUsage=ctime/rtime;
cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
cout << cpuUsage;
cout << "</DartMeasurement>" << endl;
cout << endl;
cout << "Real time " << rtime << " s, CPU time " << ctime
<< "s" << endl;
cout << "CPU usage " << cpuUsage*100. << "%" << endl;
cout << "Max Memory " << maxMemory << " MB" << endl;
cout << "Macro finished successfully." << endl;
exit(0);
}