Commit 5a3d5bfd authored by drslebedev's avatar drslebedev
Browse files

Implement CbmEvent for RICH reconstruction.

* Add CbmEvent to RICH track extrapolation procedure.
* Add CbmEvent to the RICH track projection procedure.
* Add CbmEvent to ring reconstruction procedure.
* Add CbmEvent to ring fitting procedure.
* Add CbmEvent to ring-track matching procedure.
* Update run macros.
* Fix compilation error, include Logger.h
* Fix problem when CbmEvent::GetNofData return -1.
* Change some LOG outputs to debug mode.
parent ee94af22
......@@ -9,9 +9,9 @@
#define CBMDEFS_H 1
#include <RtypesCore.h> // for Double_t
#include <type_traits> // for underlying_type
#include <iostream> // for ostream
#include <type_traits> // for underlying_type
#include <iostream> // for ostream
// Convert an element of enum class to its underlying intergral type
// since with C++11 the return type can't be deduced automatically it has
......@@ -21,8 +21,8 @@
// E.g. ToIntegralType(ECbmModuleId::KSts) should be evaluated at compile
// time and should not affect the run time performance at all
template<typename T>
constexpr auto ToIntegralType(T enumerator) ->
typename std::underlying_type<T>::type {
constexpr auto ToIntegralType(T enumerator) -> typename std::underlying_type<T>::type
{
return static_cast<typename std::underlying_type<T>::type>(enumerator);
}
......@@ -30,7 +30,8 @@ constexpr auto ToIntegralType(T enumerator) ->
** or passive (magnet, beam pipe, target etc.)
** In order to loop over all detectors, loop until kNofSystems.
**/
enum class ECbmModuleId {
enum class ECbmModuleId
{
kRef = 0, ///< Reference plane
kMvd = 1, ///< Micro-Vertex Detector
kSts = 2, ///< Silicon Tracking System
......@@ -73,7 +74,8 @@ std::ostream& operator<<(std::ostream&, const ECbmModuleId&);
/** Enumerator for CBM data types **/
enum class ECbmDataType {
enum class ECbmDataType
{
kUnknown = -1,
kMCTrack = 0,
kMvdPoint = ToIntegralType(ECbmModuleId::kMvd) * 100,
......@@ -88,7 +90,9 @@ enum class ECbmDataType {
kRichPoint = ToIntegralType(ECbmModuleId::kRich) * 100,
kRichDigi,
kRichHit,
kRichRing, // RICH
kRichRing,
kRichTrackParamZ,
kRichTrackProjection, // RICH
kMuchPoint = ToIntegralType(ECbmModuleId::kMuch) * 100,
kMuchDigi,
kMuchCluster,
......@@ -127,7 +131,12 @@ std::ostream& operator<<(std::ostream&, const ECbmDataType&);
** to first entry
** kRandom: Random choice of entries between first and last one.
**/
enum class ECbmTreeAccess { kRegular, kRepeat, kRandom };
enum class ECbmTreeAccess
{
kRegular,
kRepeat,
kRandom
};
/** Global functions for particle masses **/
......
void run_digi(
const string& mcFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/mc.00000.root",
const string& parFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/param.00000.root",
const string& digiFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/digi.00000.root",
int nEvents = 10) {
void run_digi(const string& traFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/tra.00000.root",
const string& parFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/par.00000.root",
const string& digiFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/raw.00000.root",
int nEvents = 3)
{
TTree::SetMaxTreeSize(90000000000);
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
......@@ -21,11 +18,12 @@ void run_digi(
timer.Start();
CbmDigitization run;
run.AddInput(mcFile.c_str(), eventRate);
run.AddInput(traFile.c_str(), eventRate);
run.SetOutputFile(digiFile.c_str(), overwrite);
run.SetParameterRootFile(parFile.c_str());
run.SetTimeSliceLength(timeSliceLength);
run.SetEventMode(eventMode);
run.SetProduceNoise(false);
run.SetMonitorFile("");
CbmRichDigitizer* richDigitizer = new CbmRichDigitizer();
......@@ -39,7 +37,6 @@ void run_digi(
std::cout << "Macro finished successfully." << std::endl;
std::cout << "Digi file is " << digiFile << std::endl;
std::cout << "Parameter file is " << parFile << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time "
<< timer.CpuTime() << " s" << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time " << timer.CpuTime() << " s" << std::endl;
std::cout << "Test passed" << std::endl << "All ok" << std::endl;
}
void run_reco(
const string& mcFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/mc.00000.root",
const string& parFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/param.00000.root",
const string& digiFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/digi.00000.root",
const string& recoFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/reco.00000.root",
const string& geoSetup = "sis100_electron",
const string& resultDir = "results_recoqa_newqa/",
int nEvents = 100) {
void run_reco(const string& traFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/tra.00000.root",
const string& parFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/par.00000.root",
const string& digiFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/raw.00000.root",
const string& recoFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/reco.00000.root",
const string& geoSetup = "sis100_electron", const string& resultDir = "results_recoqa_newqa/",
int nofTimeSlices = 3)
{
TTree::SetMaxTreeSize(90000000000);
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
remove(recoFile.c_str());
TString myName = "run_reco";
TString srcDir = gSystem->Getenv("VMCWORKDIR");
remove(recoFile.c_str());
CbmSetup* geo = CbmSetup::Instance();
geo->LoadSetup(geoSetup.c_str());
CbmSetup::Instance()->LoadSetup(geoSetup.c_str());
TString sEvBuildRaw = "";
Bool_t useMC = true;
Bool_t eventBased = (sEvBuildRaw != "");
Bool_t useMvd = geo->IsActive(ECbmModuleId::kMvd);
Bool_t useSts = geo->IsActive(ECbmModuleId::kSts);
Bool_t useRich = geo->IsActive(ECbmModuleId::kRich);
Bool_t useMuch = geo->IsActive(ECbmModuleId::kMuch);
Bool_t useTrd = geo->IsActive(ECbmModuleId::kTrd);
Bool_t useTof = geo->IsActive(ECbmModuleId::kTof);
Bool_t usePsd = geo->IsActive(ECbmModuleId::kPsd);
std::cout << std::endl
<< "-I- " << myName << ": Defining parameter files " << std::endl;
TList* parFileList = new TList();
TString geoTag;
......@@ -29,68 +36,260 @@ void run_reco(
const Char_t* npar[4] = {"asic", "digi", "gas", "gain"};
TObjString* trdParFile(NULL);
for (Int_t i(0); i < 4; i++) {
trdParFile = new TObjString(srcDir + "/parameters/trd/trd_" + geoTag + "."
+ npar[i] + ".par");
trdParFile = new TObjString(srcDir + "/parameters/trd/trd_" + geoTag + "." + npar[i] + ".par");
parFileList->Add(trdParFile);
std::cout << "-I- " << myName << ": Using parameter file "
<< trdParFile->GetString() << std::endl;
std::cout << "-I- "
<< ": Using parameter file " << trdParFile->GetString() << std::endl;
}
}
// - TOF digitisation parameters
if (CbmSetup::Instance()->GetGeoTag(ECbmModuleId::kTof, geoTag)) {
TObjString* tofFile =
new TObjString(srcDir + "/parameters/tof/tof_" + geoTag + ".digi.par");
parFileList->Add(tofFile);
std::cout << "-I- " << myName << ": Using parameter file "
<< tofFile->GetString() << std::endl;
TObjString* tofBdfFile =
new TObjString(srcDir + "/parameters/tof/tof_" + geoTag + ".digibdf.par");
TObjString* tofBdfFile = new TObjString(srcDir + "/parameters/tof/tof_" + geoTag + ".digibdf.par");
parFileList->Add(tofBdfFile);
std::cout << "-I- " << myName << ": Using parameter file "
<< tofBdfFile->GetString() << std::endl;
std::cout << "-I- "
<< ": Using parameter file " << tofBdfFile->GetString() << std::endl;
}
TStopwatch timer;
timer.Start();
gDebug = 0;
FairRunAna* run = new FairRunAna();
FairFileSource* inputSource = new FairFileSource(digiFile.c_str());
inputSource->AddFriend(mcFile.c_str());
if (useMC) { inputSource->AddFriend(traFile.c_str()); }
run->SetSource(inputSource);
run->SetOutputFile(recoFile.c_str());
run->SetGenerateRunInfo(kTRUE);
run->SetGenerateRunInfo(true);
if (useMC) {
CbmMCDataManager* mcManager = new CbmMCDataManager("MCDataManager", 0);
mcManager->AddFile(traFile.c_str());
run->AddTask(mcManager);
}
if (eventBased) {
if (sEvBuildRaw.EqualTo("Ideal", TString::ECaseCompare::kIgnoreCase)) {
FairTask* evBuildRaw = new CbmBuildEventsIdeal();
run->AddTask(evBuildRaw);
std::cout << "-I- "
<< ": Added task " << evBuildRaw->GetName() << std::endl;
eventBased = kTRUE;
}
else if (sEvBuildRaw.EqualTo("Real", TString::ECaseCompare::kIgnoreCase)) {
CbmTaskBuildRawEvents* evBuildRaw = new CbmTaskBuildRawEvents();
//Choose between NoOverlap, MergeOverlap, AllowOverlap
evBuildRaw->SetEventOverlapMode(EOverlapModeRaw::AllowOverlap);
// Remove detectors where digis not found
if (!useRich) evBuildRaw->RemoveDetector(kRawEventBuilderDetRich);
if (!useMuch) evBuildRaw->RemoveDetector(kRawEventBuilderDetMuch);
if (!usePsd) evBuildRaw->RemoveDetector(kRawEventBuilderDetPsd);
if (!useTof) evBuildRaw->RemoveDetector(kRawEventBuilderDetTof);
if (!useTrd) evBuildRaw->RemoveDetector(kRawEventBuilderDetTrd);
if (!useSts) {
std::cerr << "-E- "
<< ": Sts must be present for raw event "
<< "building using ``Real2019'' option. Terminating macro." << std::endl;
return;
}
// Set STS as reference detector
evBuildRaw->SetReferenceDetector(kRawEventBuilderDetSts);
evBuildRaw->SetTsParameters(0.0, 1.e7, 0.0);
// Use CbmMuchDigi instead of CbmMuchBeamtimeDigi
evBuildRaw->ChangeMuchBeamtimeDigiFlag(kFALSE);
evBuildRaw->SetTriggerMinNumber(ECbmModuleId::kSts, 1000);
evBuildRaw->SetTriggerMaxNumber(ECbmModuleId::kSts, -1);
evBuildRaw->SetTriggerWindow(ECbmModuleId::kSts, -500, 500);
run->AddTask(evBuildRaw);
std::cout << "-I- "
<< ": Added task " << evBuildRaw->GetName() << std::endl;
eventBased = kTRUE;
} //? Real raw event building
else {
std::cerr << "-E- "
<< ": Unknown option " << sEvBuildRaw << " for raw event building! Terminating macro execution."
<< std::endl;
return;
}
}
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
if (eventBased && useMC) {
CbmBuildEventsQA* evBuildQA = new CbmBuildEventsQA();
run->AddTask(evBuildQA);
}
CbmMCDataManager* mcManager = new CbmMCDataManager("MCManager", 1);
mcManager->AddFile(mcFile.c_str());
run->AddTask(mcManager);
if (useMvd) {
// Reconstruction tasks
TString macroName = srcDir + "/macro/run/modules/reconstruct.C";
std::cout << "Loading macro " << macroName << std::endl;
gROOT->LoadMacro(macroName);
Bool_t recoSuccess = gROOT->ProcessLine("reconstruct(true,true)");
if (!recoSuccess) {
std::cerr << "-E-" << myName << ": error in executing " << macroName
<< std::endl;
return;
CbmMvdClusterfinder* mvdCluster = new CbmMvdClusterfinder("MVD Cluster Finder", 0, 0);
run->AddTask(mvdCluster);
std::cout << "-I- : Added task " << mvdCluster->GetName() << std::endl;
CbmMvdHitfinder* mvdHit = new CbmMvdHitfinder("MVD Hit Finder", 0, 0);
mvdHit->UseClusterfinder(kTRUE);
run->AddTask(mvdHit);
std::cout << "-I- "
<< ": Added task " << mvdHit->GetName() << std::endl;
}
std::cout << "-I-" << myName << ": " << macroName << " excuted successfully"
<< std::endl;
CbmMatchRecoToMC* matchRecoToMc = new CbmMatchRecoToMC();
run->AddTask(matchRecoToMc);
std::cout << std::endl
<< std::endl
<< "-I- " << myName << ": Set runtime DB" << std::endl;
if (useSts) {
CbmRecoSts* stsReco = new CbmRecoSts(kCbmRecoTimeslice);
if (eventBased) stsReco->SetMode(kCbmRecoEvent);
run->AddTask(stsReco);
std::cout << "-I- "
<< ": Added task " << stsReco->GetName() << std::endl;
}
if (useRich) {
CbmRichHitProducer* richHitProd = new CbmRichHitProducer();
run->AddTask(richHitProd);
std::cout << "-I- "
<< ": Added task " << richHitProd->GetName() << std::endl;
}
if (useTrd) {
Double_t triggerThreshold = 0.5e-6; // SIS100
CbmTrdClusterFinder* trdCluster = new CbmTrdClusterFinder();
if (eventBased) trdCluster->SetTimeBased(kFALSE);
else
trdCluster->SetTimeBased(kTRUE);
trdCluster->SetNeighbourEnable(true, false);
trdCluster->SetMinimumChargeTH(triggerThreshold);
trdCluster->SetRowMerger(true);
// Uncomment if you want to use all available digis.
// In that case clusters hits will not be added to the CbmEvent
// trdCluster->SetUseOnlyEventDigis(kFALSE);
run->AddTask(trdCluster);
std::cout << "-I- "
<< ": Added task " << trdCluster->GetName() << std::endl;
CbmTrdHitProducer* trdHit = new CbmTrdHitProducer();
run->AddTask(trdHit);
std::cout << "-I- "
<< ": Added task " << trdHit->GetName() << std::endl;
}
if (useTof) {
CbmTofSimpClusterizer* tofCluster = new CbmTofSimpClusterizer("TofSimpClusterizer", 0);
tofCluster->SetOutputBranchPersistent("TofHit", kTRUE);
tofCluster->SetOutputBranchPersistent("TofDigiMatch", kTRUE);
run->AddTask(tofCluster);
std::cout << "-I- "
<< ": Added task " << tofCluster->GetName() << std::endl;
}
// ------------------------------------------------------------------------
if (useMC) {
CbmMatchRecoToMC* match1 = new CbmMatchRecoToMC();
run->AddTask(match1);
}
if (useMvd || useSts) {
CbmKF* kalman = new CbmKF();
run->AddTask(kalman);
CbmL1* l1 = 0;
if (useMC) { l1 = new CbmL1("L1", 2, 3); }
else {
l1 = new CbmL1("L1", 0);
}
l1->SetDataMode(!eventBased);
// --- Material budget file names
TString mvdGeoTag;
if (geo->GetGeoTag(ECbmModuleId::kMvd, mvdGeoTag)) {
TString parFile = gSystem->Getenv("VMCWORKDIR");
parFile += "/parameters/mvd/mvd_matbudget_" + mvdGeoTag + ".root";
std::cout << "Using material budget file " << parFile << std::endl;
l1->SetMvdMaterialBudgetFileName(parFile.Data());
}
TString stsGeoTag;
if (geo->GetGeoTag(ECbmModuleId::kSts, stsGeoTag)) {
TString parFile = gSystem->Getenv("VMCWORKDIR");
parFile += "/parameters/sts/sts_matbudget_" + stsGeoTag + ".root";
std::cout << "Using material budget file " << parFile << std::endl;
l1->SetStsMaterialBudgetFileName(parFile.Data());
}
run->AddTask(l1);
std::cout << "-I- "
<< ": Added task " << l1->GetName() << std::endl;
CbmStsTrackFinder* stsTrackFinder = new CbmL1StsTrackFinder();
if (eventBased) {
FairTask* stsFindTracks = new CbmStsFindTracksEvents(stsTrackFinder, useMvd);
run->AddTask(stsFindTracks);
std::cout << "-I- "
<< ": Added task " << stsFindTracks->GetName() << std::endl;
}
else {
FairTask* stsFindTracks = new CbmStsFindTracks(0, stsTrackFinder, useMvd);
run->AddTask(stsFindTracks);
std::cout << "-I- "
<< ": Added task " << stsFindTracks->GetName() << std::endl;
}
}
// ------------------------------------------------------------------------
// --- Global track finding -----------------------------------------
CbmLitFindGlobalTracks* finder = new CbmLitFindGlobalTracks();
finder->SetTrackingType("branch");
finder->SetMergerType("nearest_hit");
run->AddTask(finder);
std::cout << "-I- : Added task " << finder->GetName() << std::endl;
// ----------------------------------------------------------------------
// ----- RICH reconstruction ----------------------------------------
if (useRich) {
CbmRichReconstruction* richReco = new CbmRichReconstruction();
run->AddTask(richReco);
std::cout << "-I- : Added task " << richReco->GetName() << std::endl;
}
// ----------------------------------------------------------------------
// ==== From here on, the time-based and the event-based reconstruction
// ==== chains differ, since time-based version of primary vertex finding
// ==== and global tracking are not yet available. For time-based
// ==== reconstruction, a track-based event finder is used; no global
// ==== tracks are produced.
if (eventBased) {
//----- Primary vertex finding -------------------------------------
CbmPrimaryVertexFinder* pvFinder = new CbmPVFinderKF();
CbmFindPrimaryVertex* findVertex = new CbmFindPrimaryVertex(pvFinder);
run->AddTask(findVertex);
std::cout << "-I- "
<< ": Added task " << findVertex->GetName() << std::endl;
// ----------------------------------------------------------------------
} //? event-based reco
else {
// -----  Event building from STS tracks -----------------------------
run->AddTask(new CbmBuildEventsFromTracksReal());
// ----------------------------------------------------------------------
} //? time-based reco
// ----- Parameter database --------------------------------------------
std::cout << std::endl << std::endl;
std::cout << "-I- "
<< ": Set runtime DB" << std::endl;
FairRuntimeDb* rtdb = run->GetRuntimeDb();
FairParRootFileIo* parIo1 = new FairParRootFileIo();
FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo();
......@@ -100,23 +299,41 @@ void run_reco(
parIo2->open(parFileList, "in");
rtdb->setSecondInput(parIo2);
}
// ------------------------------------------------------------------------
std::cout << std::endl << "-I- " << myName << ": Initialise run" << std::endl;
run->Init();
// ----- Run initialisation -------------------------------------------
std::cout << std::endl;
std::cout << "-I- "
<< ": Initialise run" << std::endl;
run->Init();
rtdb->setOutput(parIo1);
rtdb->saveOutput();
rtdb->print();
// ------------------------------------------------------------------------
std::cout << "-I- " << myName << ": Starting run" << std::endl;
run->Run(0, nEvents);
// ----- Register light ions (d, t, He3, He4) -------------------------
std::cout << std::endl;
TString registerLightIonsMacro = gSystem->Getenv("VMCWORKDIR");
registerLightIonsMacro += "/macro/KF/registerLightIons.C";
std::cout << "Loading macro " << registerLightIonsMacro << std::endl;
gROOT->LoadMacro(registerLightIonsMacro);
gROOT->ProcessLine("registerLightIons()");
// ------------------------------------------------------------------------
// ----- Start run ----------------------------------------------------
std::cout << std::endl << std::endl;
std::cout << "-I- "
<< ": Starting run" << std::endl;
run->Run(0, nofTimeSlices);
// ------------------------------------------------------------------------
timer.Stop();
std::cout << std::endl << std::endl;
std::cout << "Macro finished succesfully." << std::endl;
std::cout << "Output file is " << recoFile << std::endl;
std::cout << "Parameter file is " << parFile << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time "
<< timer.CpuTime() << " s" << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time " << timer.CpuTime() << " s" << std::endl;
std::cout << std::endl << "Test passed" << std::endl << "All ok" << std::endl;
}
void run_sim(
const string& urqmdFile =
"/Users/slebedev/Development/cbm/data/urqmd/auau/8gev/centr/"
"urqmd.auau.8gev.centr.00001.root", // if "", no urqmd
const string& mcFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/mc.00000.root",
const string& parFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/param.00000.root",
const string& geoFile =
"/Users/slebedev/Development/cbm/data/sim/rich/reco/geosim.00000.root",
int nofElectrons =
5, // number of e- to be generated, if <=0 no electrons are embedded into event
int nofPositrons =
5, // number of e- to be generated, if <=0 no positrons are embedded into event
const string& plutoFile =
"", // if "", no pluto particles are embedded into event
const string& geoSetup = "sis100_electron_rich_pal_bcarb",
int nEvents = 10) {
void run_transport(const string& urqmdFile = "/Users/slebedev/Development/cbm/data/urqmd/auau/8gev/centr/"
"urqmd.auau.8gev.centr.00001.root", // if "", no urqmd
const string& traFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/tra.00000.root",
const string& parFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/par.00000.root",
const string& geoFile = "/Users/slebedev/Development/cbm/data/sim/rich/reco/geo.00000.root",
int nofElectrons = 5, // number of e- to be generated, if <=0 no e- are embedded into event
int nofPositrons = 5, // number of e+ to be generated, if <=0 no e+ are embedded into event
const string& plutoFile = "", // if "", no pluto particles are embedded into event
const string& geoSetup = "sis100_electron", int nEvents = 3)
{
TTree::SetMaxTreeSize(90000000000);
FairLogger::GetLogger()->SetLogScreenLevel("INFO");
FairLogger::GetLogger()->SetLogVerbosityLevel("LOW");
remove(parFile.c_str());
remove(mcFile.c_str());
remove(traFile.c_str());
remove(geoFile.c_str());
TStopwatch timer;
......@@ -53,22 +45,22 @@ void run_sim(
if (plutoFile.length() > 0) { run.AddInput(plutoFile.c_str(), kPluto); }
run.SetOutFileName(mcFile.c_str());
run.SetOutFileName(traFile.c_str());
run.SetParFileName(parFile.c_str());
run.SetGeoFileName(geoFile.c_str());
run.LoadSetup(geoSetup.c_str());
run.SetTarget("Gold", 0.025, 2.5);
run.SetBeamPosition(0., 0., 0.1, 0.1);
run.SetRandomEventPlane();
run.Run(nEvents);
timer.Stop();
std::cout << std::endl << std::endl;
std::cout << "Macro finished successfully." << std::endl;
std::cout << "Output file is " << mcFile << std::endl;
std::cout << "Output file is " << traFile << std::endl;
std::cout << "Parameter file is " << parFile << std::endl;
std::cout << "Geometry file is " << geoFile << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time "
<< timer.CpuTime() << "s" << std::endl;
std::cout << "Real time " << timer.RealTime() << " s, CPU time " << timer.CpuTime() << "s" << std::endl;
std::cout << "Test passed" << std::endl << "All ok" << std::endl;
}
......@@ -17,20 +17,23 @@
// CBM includes
#include "CbmL1RichENNRingFinder.h"
#include "CbmL1RichENNRingFinderParallel.h"
#include "CbmEvent.h"
#include "CbmL1RichENNRingFinderParallel.h"
#include "CbmRichHit.h"
#include "CbmRichRing.h"
#include "TClonesArray.h"
#include "TStopwatch.h"
#include "assert.h"
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#include <cmath>
#include "assert.h"
using std::cout;
using std::endl;
using std::fabs;
......@@ -44,15 +47,17 @@ ClassImp(CbmL1RichENNRingFinder)