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); }