diff --git a/reco/L1/CbmL1.cxx b/reco/L1/CbmL1.cxx
index f99495a50618a10f2ac8f44cf085b236a5f2e461..5f27f4defa16377cc5a2233e5516942487eb9038 100644
--- a/reco/L1/CbmL1.cxx
+++ b/reco/L1/CbmL1.cxx
@@ -931,7 +931,7 @@ InitStatus CbmL1::Init()
//algo->SetParameters(fParameters);
-#ifdef FEATURING_L1ALGO_INIT
+
/********************************************************************************************************************
* EXPERIMENTAL FEATURE: usage of L1InitManager for L1Algo initialization *
********************************************************************************************************************/
@@ -1251,8 +1251,6 @@ InitStatus CbmL1::Init()
/********************************************************************************************************************
********************************************************************************************************************/
-#endif // FEATURING_L1ALGO_INIT
-
algo->Init(geo, fUseHitErrors, fTrackingMode, fMissingHits);
geo.clear();
@@ -1558,15 +1556,17 @@ void CbmL1::Exec(Option_t* /*option*/) {}
void CbmL1::Reconstruct(CbmEvent* event)
{
-
static int nevent = 0;
vFileEvent.clear();
L1Vector<std::pair<double, int>> SortStsHits("CbmL1::SortStsHits");
SortStsHits.reserve(listStsHits->GetEntriesFast());
+ L1_SHOW(listStsHits->GetEntriesFast());
+
float start_t = 10000000000;
+ // TODO: move these values to CbmL1Parameters namespace (S.Zharko)
bool areDataLeft = true; // whole TS processed?
float TsStart = 0; // starting time of sub-TS
float TsLength = 10000; // length of sub-TS
@@ -1582,7 +1582,8 @@ void CbmL1::Reconstruct(CbmEvent* event)
}
TsStart = start_t; ///reco TS start time is set to smallest hit time
-
+
+ L1_SHOW(TsStart);
std::sort(SortStsHits.begin(), SortStsHits.end());
StsIndex.clear();
@@ -1592,13 +1593,18 @@ void CbmL1::Reconstruct(CbmEvent* event)
StsIndex.push_back(j);
};
+ L1_SHOW(fLegacyEventMode);
+ L1_SHOW(TsStart);
+
if (!fLegacyEventMode && fPerformance) {
int nofEvents = fEventList->GetNofEvents();
+ L1_SHOW(fEventList->GetNofEvents());
for (int iE = 0; iE < nofEvents; iE++) {
-
int fileId = fEventList->GetFileIdByIndex(iE);
int eventId = fEventList->GetEventIdByIndex(iE);
+ L1_SHOW(fileId);
+ L1_SHOW(eventId);
vFileEvent.insert(DFSET::value_type(fileId, eventId));
}
}
@@ -1608,14 +1614,15 @@ void CbmL1::Reconstruct(CbmEvent* event)
vFileEvent.insert(DFSET::value_type(iFile, iEvent));
}
- if (fVerbose > 1) { cout << endl << "CbmL1::Exec event " << ++nevent << " ..." << endl << endl; }
+ if (fVerbose > 1) { cout << "\nCbmL1::Exec event " << ++nevent << " ...\n\n"; }
#ifdef _OPENMP
omp_set_num_threads(1);
#endif
// repack data
L1Vector<CbmL1Track> vRTracksCur("CbmL1::vRTracksCur"); // reconstructed tracks
-
+ L1_SHOW(vRTracksCur.size());
+ L1_SHOW(vRTracksCur.capacity());
{
int nHits = 0;
int nSta = 1;
@@ -1629,11 +1636,15 @@ void CbmL1::Reconstruct(CbmEvent* event)
}
vRTracksCur.reserve(10 + (2 * nHits) / nSta);
}
+ L1_SHOW(vRTracksCur.size());
+ L1_SHOW(vRTracksCur.capacity());
fTrackingTime = 0;
- while (areDataLeft) {
+ while (areDataLeft) {
+
+ L1_SHOW(areDataLeft);
fData->Clear();
if (event) {
@@ -1647,6 +1658,7 @@ void CbmL1::Reconstruct(CbmEvent* event)
FstHitinTs = 0;
}
+ L1_SHOW(fSTAPDataMode);
if (fSTAPDataMode >= 2) { // 2,3
fData->ReadHitsFromFile(fSTAPDataDir.Data(), 1, fVerbose);
@@ -2078,7 +2090,7 @@ void CbmL1::WriteSTAPAlgoData() // must be called after ReadEvent
// write algo data in file
static int vNEvent = 1;
std::fstream fadata;
-
+
TString fadata_name = fSTAPDataDir + "data_algo.txt";
// if ( vNEvent <= maxNEvent ) {
if (1) {
@@ -2384,8 +2396,8 @@ void CbmL1::ReadSTAPAlgoData()
for (int i = 0; i < n; i++) {
L1Hit element;
fadata >> element_f >> element_b >> element_n >> element.z >> element.u >> element.v >> element.t;
- element.f = static_cast<THitI>(element_f);
- element.b = static_cast<THitI>(element_b);
+ element.f = static_cast<L1HitIndex_t>(element_f);
+ element.b = static_cast<L1HitIndex_t>(element_b);
algo->vStsHits->push_back(element);
}
if (fVerbose >= 4) {
diff --git a/reco/L1/CbmL1.h b/reco/L1/CbmL1.h
index 5cfef845d7f3a9cd75cf2fe93b1d189853195585..4944f6af5086b4fd7b2c6fa70e04b22427b92525 100644
--- a/reco/L1/CbmL1.h
+++ b/reco/L1/CbmL1.h
@@ -250,7 +250,7 @@ public:
bool fMissingHits {false};
L1Algo::TrackingMode fTrackingMode {L1Algo::TrackingMode::kSts};
- L1Vector<CbmL1Track> vRTracks {"CbmL1::vRTracks"}; // reconstructed tracks
+ L1Vector<CbmL1Track> vRTracks {"CbmL1::vRTracks"}; ///> reconstructed tracks
DFSET vFileEvent {};
L1Vector<CbmL1HitStore> vHitStore {"CbmL1::vHitStore"}; // diff hit information
diff --git a/reco/L1/CbmL1Hit.h b/reco/L1/CbmL1Hit.h
index 45957ddfffa94ffbf864d783a1a073394d03fe33..0faf887064006f44ebae74a1a1a1ad921853f681 100644
--- a/reco/L1/CbmL1Hit.h
+++ b/reco/L1/CbmL1Hit.h
@@ -16,15 +16,15 @@ struct CbmL1Hit {
CbmL1Hit(int hitId_, int extIndex_, int Det_) : hitId(hitId_), extIndex(extIndex_), Det(Det_) {};
- int hitId = 0; // index of L1Hit in algo->vStsHits array. Should be equal to index of this in L1->vStsHits
- int extIndex = 0; // index of hit in the TClonesArray array
- int Det = 0; // station index
- float x = 0.f; // measured X coordinate
- float y = 0.f; // measured Y coordinate
- float t = 0.f; // measured time
- int f = 0; // front strip index
- int b = 0; // back strip index
- int ID = 0; // TODO: check if this ID is redundant
+ int hitId = 0; ///> index of L1Hit in algo->vStsHits array. Should be equal to index of this in L1->vStsHits
+ int extIndex = 0; ///> index of hit in the TClonesArray array
+ int Det = 0; ///> station index
+ float x = 0.f; ///> measured X coordinate
+ float y = 0.f; ///> measured Y coordinate
+ float t = 0.f; ///> measured time
+ int f = 0; ///> front strip index
+ int b = 0; ///> back strip index
+ int ID = 0; ///> TODO: check if this ID is redundant
L1Vector<int> mcPointIds {"CbmL1Hit::mcPointIds"}; // indices of CbmL1MCPoint in L1->vMCPoints array
};
diff --git a/reco/L1/CbmL1ReadEvent.cxx b/reco/L1/CbmL1ReadEvent.cxx
index 5c8dcd469f94be1d221f58c1a4cb9f067e9d2c75..9cf9dbb9dfd47ad8e99ccdefcc17ae5610fc6d73 100644
--- a/reco/L1/CbmL1ReadEvent.cxx
+++ b/reco/L1/CbmL1ReadEvent.cxx
@@ -188,7 +188,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
for (int i = 0; i < NStation; i++) {
- fData_->StsHitsStartIndex[i] = static_cast<THitI>(-1);
+ fData_->StsHitsStartIndex[i] = static_cast<L1HitIndex_t>(-1);
fData_->StsHitsStopIndex[i] = 0;
}
@@ -1072,6 +1072,14 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
vHitStore.reserve(nHits);
vHitMCRef.reserve(nHits);
+ /*
+ * In this section the vStsHits, vHitStore and vHitMCRef vectors as well as fData->vStsHits are
+ * filled.
+ */
+
+ L1_SHOW(vStsHits.size());
+ L1_SHOW(vHitStore.size());
+ L1_SHOW(vHitMCRef.size());
for (int i = 0; i < nHits; i++) {
TmpHit& th = tmpHits[i];
@@ -1114,7 +1122,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
h.z = th.z;
- // save hit
+ // save hit
vStsHits.push_back(CbmL1Hit(fData->vStsHits.size(), th.ExtIndex, th.Det));
vStsHits[vStsHits.size() - 1].x = th.x;
@@ -1131,7 +1139,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
int sta = th.iStation;
- if (fData_->StsHitsStartIndex[sta] == static_cast<THitI>(-1)) fData_->StsHitsStartIndex[sta] = nEffHits;
+ if (fData_->StsHitsStartIndex[sta] == static_cast<L1HitIndex_t>(-1)) fData_->StsHitsStartIndex[sta] = nEffHits;
nEffHits++;
fData_->StsHitsStopIndex[sta] = nEffHits;
@@ -1139,15 +1147,23 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
vHitStore.push_back(s);
vHitMCRef.push_back(th.iMC);
}
+ L1_SHOW(&vStsHits);
+ L1_SHOW(vStsHits.size());
+ L1_SHOW(&(fData_->vStsHits));
+ L1_SHOW((fData_->vStsHits).size());
for (int i = 0; i < NStation; i++) {
-
- if (fData_->StsHitsStartIndex[i] == static_cast<THitI>(-1))
+ if (fData_->StsHitsStartIndex[i] == static_cast<L1HitIndex_t>(-1)) {
fData_->StsHitsStartIndex[i] = fData_->StsHitsStopIndex[i];
+ }
}
if (fVerbose >= 10) cout << "ReadEvent: mvd and sts are saved." << endl;
+ /*
+ * Translate gathered hits data to the L1Algo object. TODO: raplace it with L1DataManager functionality (S.Zharko)
+ */
+
algo->SetData(fData_->GetStsHits(), fData_->GetNStsStrips(), fData_->GetSFlag(), fData_->GetStsHitsStartIndex(),
fData_->GetStsHitsStopIndex());
diff --git a/reco/L1/L1Algo/L1Algo.cxx b/reco/L1/L1Algo/L1Algo.cxx
index 9f29749eb00489af6e4be2f6999305e96e4146fb..2d9196640b488619db661f6907b51d0c1ce130e1 100644
--- a/reco/L1/L1Algo/L1Algo.cxx
+++ b/reco/L1/L1Algo/L1Algo.cxx
@@ -273,15 +273,14 @@ void L1Algo::Init(const L1Vector<fscal>& geo, const bool UseHitErrors, const Tra
LOG(info) << "** Original L1Station array content **";
int nStations = fInitManager.GetStationsNumber();
for (int iSt = 0; iSt < nStations; ++iSt) {
- LOG(info) << "Station Global No: " << iSt;
- LOG(info) << '\n' << vStations[iSt].ToString(/*verbosity = */ 3);
- }
- LOG(info) << "** New L1Station array content **";
- nStations = fInitManager.GetStationsNumber();
- for (int iSt = 0; iSt < nStations; ++iSt) {
- LOG(info) << "Station Global No: " << iSt;
- LOG(info) << '\n' << fStationsNew[iSt].ToString(/*verbosity = */ 3);
+ LOG(info) << "Station Global No: " << iSt << ' ' << vStations[iSt].ToString(/*verbosity = */ 0);
}
+ //LOG(info) << "** New L1Station array content **";
+ //nStations = fInitManager.GetStationsNumber();
+ //for (int iSt = 0; iSt < nStations; ++iSt) {
+ // LOG(info) << "Station Global No: " << iSt;
+ // LOG(info) << '\n' << fStationsNew[iSt].ToString(/*verbosity = */ 0);
+ //}
// Print L1Parameters
fParameters.Print(/*verbosity=*/0);
@@ -289,7 +288,7 @@ void L1Algo::Init(const L1Vector<fscal>& geo, const bool UseHitErrors, const Tra
void L1Algo::SetData(L1Vector<L1Hit>& StsHits_, int nStsStrips_, L1Vector<unsigned char>& SFlag_,
- const THitI* StsHitsStartIndex_, const THitI* StsHitsStopIndex_)
+ const L1HitIndex_t* StsHitsStartIndex_, const L1HitIndex_t* StsHitsStopIndex_)
{
vStsHits = &StsHits_;
diff --git a/reco/L1/L1Algo/L1Algo.h b/reco/L1/L1Algo/L1Algo.h
index f7a386850f26aa6ada6209bb2fecdd6b8958a69f..5fcbc99a02ff5c3d0e1092c0315b93a0072d210e 100644
--- a/reco/L1/L1Algo/L1Algo.h
+++ b/reco/L1/L1Algo/L1Algo.h
@@ -37,17 +37,6 @@ class L1AlgoDraw;
//#define MERGE_CLONES
-/*********************************************************************************
- ************ TEMPORARY MACROS, SHOULD BE REMOVED (TODO!!, S. Zharko) ***********
- * */
-
-#define FEATURING_L1ALGO_INIT 1 // If defined, new initialization will be used, if not - the old one
-// Macro: 1 - new track finder loop, other - old track finder loop
-#define FEATURING_L1ALGO_CATRACKFINDER_ITERATIONLOOP 1
-
-/* *
- *********************************************************************************/
-
#include <array>
#include <iomanip>
#include <iostream>
@@ -100,19 +89,22 @@ public:
L1Algo(const L1Algo&) = delete;
L1Algo operator=(const L1Algo&) = delete;
- /// set a default particle mass for the track fit
+ /// Sets a default particle mass for the track fit
/// it is used during reconstruction
/// for the multiple scattering and energy loss estimation
+ /// \param mass Default particle mass
void SetDefaultParticleMass(float mass) { fDefaultMass = mass; }
- /// get default particle mass
+ /// Gets default particle mass
+ /// \return particle mass
float GetDefaultParticleMass() const { return fDefaultMass; }
- /// get default particle mass squared
+ /// Gets default particle mass squared
+ /// \return particle mass squared
float GetDefaultParticleMass2() const { return fDefaultMass * fDefaultMass; }
- float fDefaultMass = 0.10565800; // muon mass
- // TODO: make fDefaultMass a private member (S.Zh.)
+ float fDefaultMass = 0.10565800; // muon mass
+ // TODO: make fDefaultMass a private member (S.Zharko)
/// pack station, thread and triplet indices to an unique triplet ID
static unsigned int PackTripletId(unsigned int Station, unsigned int Thread, unsigned int Triplet)
@@ -166,8 +158,8 @@ public:
// vectors that are parallel to fTracks
L1Vector<unsigned short> fMergerTrackFirstStation {"L1Algo::fMergerTrackFirstStation"}; // first station of a track
L1Vector<unsigned short> fMergerTrackLastStation {"L1Algo::fMergerTrackLastStation"}; // last station of a track
- L1Vector<THitI> fMergerTrackFirstHit {"L1Algo::fMergerTrackFirstHit"}; // index of the first tracks hit
- L1Vector<THitI> fMergerTrackLastHit {"L1Algo::fMergerTrackLastHit"}; // index of the last tracks hit
+ L1Vector<L1HitIndex_t> fMergerTrackFirstHit {"L1Algo::fMergerTrackFirstHit"}; // index of the first tracks hit
+ L1Vector<L1HitIndex_t> fMergerTrackLastHit {"L1Algo::fMergerTrackLastHit"}; // index of the last tracks hit
L1Vector<unsigned short> fMergerTrackNeighbour {
"L1Algo::fMergerTrackNeighbour"}; // track that can be merged with the given track
L1Vector<float> fMergerTrackChi2 {"L1Algo::fMergerTrackChi2"}; // chi2 of the merge
@@ -176,7 +168,7 @@ public:
"L1Algo::fMergerTrackIsDownstreamNeighbour"}; // is the track a downstream neighbor of another track
// other vectors
L1Vector<L1Track> fMergerTracksNew {"L1Algo::fMergerTracksNew"}; // vector of tracks after the merge
- L1Vector<THitI> fMergerRecoHitsNew {"L1Algo::fMergerRecoHitsNew"}; // vector of track hits after the merge
+ L1Vector<L1HitIndex_t> fMergerRecoHitsNew {"L1Algo::fMergerRecoHitsNew"}; // vector of track hits after the merge
#ifdef DRAW
@@ -194,7 +186,7 @@ public:
void Init(const L1Vector<fscal>& geo, const bool UseHitErrors, const TrackingMode mode, const bool MissingHits);
void SetData(L1Vector<L1Hit>& StsHits_, int nStsStrips_, L1Vector<unsigned char>& SFlag_,
- const THitI* StsHitsStartIndex_, const THitI* StsHitsStopIndex_);
+ const L1HitIndex_t* StsHitsStartIndex_, const L1HitIndex_t* StsHitsStopIndex_);
void PrintHits();
@@ -225,20 +217,20 @@ public:
alignas(16) std::array<L1Station, L1Parameters::kMaxNstations> fStationsNew;
L1Vector<L1Material> fRadThick {"fRadThick"}; // material for each station
- int NStsStrips {0}; // number of strips
- L1Vector<L1Hit>* vStsHits {nullptr}; // hits as a combination of front-, backstrips and z-position
- L1Grid vGrid[L1Parameters::kMaxNstations]; // hits as a combination of front-, backstrips and z-position
- L1Grid vGridTime[L1Parameters::kMaxNstations];
+ int NStsStrips {0}; ///> number of strips
+ L1Vector<L1Hit>* vStsHits {nullptr}; ///> hits as a combination of front-, backstrips and z-position
+ L1Grid vGrid[L1Parameters::kMaxNstations]; ///> hits as a combination of front-, backstrips and z-position
+ L1Grid vGridTime[L1Parameters::kMaxNstations]; ///>
L1Vector<unsigned char>* fStripFlag {nullptr}; // information of hits station & using hits in tracks;
double fCATime {0.}; // time of track finding
L1Vector<L1Track> fTracks {"L1Algo::fTracks"}; // reconstructed tracks
- L1Vector<THitI> fRecoHits {"L1Algo::fRecoHits"}; // packed hits of reconstructed tracks
+ L1Vector<L1HitIndex_t> fRecoHits {"L1Algo::fRecoHits"}; // packed hits of reconstructed tracks
- const THitI* StsHitsStartIndex {nullptr}; // station-bounders in vStsHits array
- const THitI* StsHitsStopIndex {nullptr}; // station-bounders in vStsHits array
+ const L1HitIndex_t* StsHitsStartIndex {nullptr}; // station-bounders in vStsHits array
+ const L1HitIndex_t* StsHitsStopIndex {nullptr}; // station-bounders in vStsHits array
// L1Branch* pointer;
@@ -251,11 +243,11 @@ public:
L1Vector<L1HitPoint> vStsDontUsedHitsxy_buf {"L1Algo::vStsDontUsedHitsxy_buf"};
L1Vector<L1HitPoint> vStsDontUsedHitsxy_B {"L1Algo::vStsDontUsedHitsxy_B"};
L1Vector<L1Track> fTracks_local[L1Parameters::kMaxNthreads] {"L1Algo::fTracks_local"};
- L1Vector<THitI> fRecoHits_local[L1Parameters::kMaxNthreads] {"L1Algo::fRecoHits_local"};
+ L1Vector<L1HitIndex_t> fRecoHits_local[L1Parameters::kMaxNthreads] {"L1Algo::fRecoHits_local"};
- L1Vector<THitI> RealIHit_v {"L1Algo::RealIHit_v"};
- L1Vector<THitI> RealIHit_v_buf {"L1Algo::RealIHit_v_buf"};
- L1Vector<THitI> RealIHit_v_buf2 {"L1Algo::RealIHit_v_buf2"};
+ L1Vector<L1HitIndex_t> RealIHit_v {"L1Algo::RealIHit_v"};
+ L1Vector<L1HitIndex_t> RealIHit_v_buf {"L1Algo::RealIHit_v_buf"};
+ L1Vector<L1HitIndex_t> RealIHit_v_buf2 {"L1Algo::RealIHit_v_buf2"};
#ifdef _OPENMP
L1Vector<omp_lock_t> fHitToBestTrackF {"L1Algo::fHitToBestTrackF"};
@@ -299,15 +291,15 @@ public:
int isec {0}; // iteration
L1Vector<L1Hit>* vStsHitsUnused {nullptr};
- L1Vector<THitI>* RealIHitP {nullptr};
- L1Vector<THitI>* RealIHitPBuf {nullptr};
+ L1Vector<L1HitIndex_t>* RealIHitP {nullptr};
+ L1Vector<L1HitIndex_t>* RealIHitPBuf {nullptr};
L1Vector<L1HitPoint>* vStsHitPointsUnused {nullptr};
- THitI* RealIHit {nullptr}; // index in vStsHits indexed by index in vStsHitsUnused
+ L1HitIndex_t* RealIHit {nullptr}; // index in vStsHits indexed by index in vStsHitsUnused
- THitI StsHitsUnusedStartIndex[L1Parameters::kMaxNstations + 1] {0};
- THitI StsHitsUnusedStopIndex[L1Parameters::kMaxNstations + 1] {0};
- THitI StsHitsUnusedStartIndexEnd[L1Parameters::kMaxNstations + 1] {0};
- THitI StsHitsUnusedStopIndexEnd[L1Parameters::kMaxNstations + 1] {0};
+ L1HitIndex_t StsHitsUnusedStartIndex[L1Parameters::kMaxNstations + 1] {0};
+ L1HitIndex_t StsHitsUnusedStopIndex[L1Parameters::kMaxNstations + 1] {0};
+ L1HitIndex_t StsHitsUnusedStartIndexEnd[L1Parameters::kMaxNstations + 1] {0};
+ L1HitIndex_t StsHitsUnusedStopIndexEnd[L1Parameters::kMaxNstations + 1] {0};
L1Vector<int> TripForHit[2] {"L1Algo::TripForHit"}; // TODO: what does '2' stand for?
@@ -319,9 +311,9 @@ public:
nsL1::vector<L1TrackPar>::TSimd fT_3[L1Parameters::kMaxNthreads];
- L1Vector<THitI> fhitsl_3[L1Parameters::kMaxNthreads] {"L1Algo::fhitsl_3"};
- L1Vector<THitI> fhitsm_3[L1Parameters::kMaxNthreads] {"L1Algo::fhitsm_3"};
- L1Vector<THitI> fhitsr_3[L1Parameters::kMaxNthreads] {"L1Algo::fhitsr_3"};
+ L1Vector<L1HitIndex_t> fhitsl_3[L1Parameters::kMaxNthreads] {"L1Algo::fhitsl_3"};
+ L1Vector<L1HitIndex_t> fhitsm_3[L1Parameters::kMaxNthreads] {"L1Algo::fhitsm_3"};
+ L1Vector<L1HitIndex_t> fhitsr_3[L1Parameters::kMaxNthreads] {"L1Algo::fhitsr_3"};
nsL1::vector<fvec>::TSimd fu_front3[L1Parameters::kMaxNthreads];
nsL1::vector<fvec>::TSimd fu_back3[L1Parameters::kMaxNthreads];
@@ -371,7 +363,9 @@ public:
/// Sets L1Algo parameters object
+ /// \param other - reference to the L1Parameters object
void SetParameters(const L1Parameters& other) { fParameters = other; }
+ // TODO: remove it (S.Zharko)
/// Gets a pointer to the L1Algo parameters object
L1Parameters* GetParameters() { return &fParameters; }
@@ -385,7 +379,9 @@ private:
L1InitManager fInitManager {&fParameters}; ///< Object of L1Algo initialization manager class
- /// ================================= FUNCTIONAL PART =================================
+ /*********************************************************************************************//**
+ * ------ FUNCTIONAL PART ------
+ ************************************************************************************************/
/// ----- Subroutines used by L1Algo::CATrackFinder() ------
@@ -394,28 +390,33 @@ private:
L1Branch* new_tr);
- /// Fit track
- /// t - track with hits
- /// T - track params
- /// dir - 0 - forward, 1 - backward
- /// qp0 - momentum for extrapolation
- /// initialize - should be params ititialized. 1 - yes.
+ /// Fits track
+ /// \param t - track with hits
+ /// \param T - track parameters
+ /// \param dir - false - forward, true - backward
+ /// \param qp0 - momentum for extrapolation
+ /// \param initParams - should be params ititialized. 1 - yes.
void BranchFitterFast(const L1Branch& t, L1TrackPar& T, const bool dir, const fvec qp0 = 0.,
const bool initParams = true);
- /// Fit track. more precise than FitterFast
+ /// Fits track. more precise than FitterFast
+ /// \param t - track with hits
+ /// \param T - track parameters
+ /// \param dir - false - forward, true - backward
+ /// \param qp0 - momentum for extrapolation
+ /// \param initParams - should be params ititialized. 1 - yes.
void BranchFitter(const L1Branch& t, L1TrackPar& T, const bool dir, const fvec qp0 = 0.,
const bool initParams = true);
- /// Find additional hits for existing track
- /// t - track with hits
- /// T - track params
- /// dir - 0 - forward, 1 - backward
- /// qp0 - momentum for extrapolation
+ /// Finds additional hits for already found track
+ /// \param t - track with hits
+ /// \param T - track params
+ /// \param dir - 0 - forward, 1 - backward
+ /// \param qp0 - momentum for extrapolation
void FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir, const fvec qp0 = 0.0);
/// Find additional hits for existing track
- /// return chi2
+ /// \return chi2
fscal BranchExtender(L1Branch& t);
/// ----- Subroutines used by L1Algo::CAMergeClones() ------
@@ -462,7 +463,7 @@ private:
void f10( // input
Tindex start_lh, Tindex n1_l, L1HitPoint* StsHits_l,
// output
- fvec* u_front_l, fvec* u_back_l, fvec* zPos_l, THitI* hitsl, fvec* HitTime_l, fvec* HitTimeEr, fvec* Event_l,
+ fvec* u_front_l, fvec* u_back_l, fvec* zPos_l, L1HitIndex_t* hitsl, fvec* HitTime_l, fvec* HitTimeEr, fvec* Event_l,
fvec* d_x, fvec* d_y, fvec* d_xy, fvec* d_u, fvec* d_v);
/// Get the field approximation. Add the target to parameters estimation. Propagate to middle station.
@@ -475,29 +476,29 @@ private:
/// Find the doublets. Reformat data in the portion of doublets.
void f20( // input
- Tindex n1, L1Station& stal, L1Station& stam, L1HitPoint* vStsHits_m, L1TrackPar* T_1, THitI* hitsl_1,
+ Tindex n1, L1Station& stal, L1Station& stam, L1HitPoint* vStsHits_m, L1TrackPar* T_1, L1HitIndex_t* hitsl_1,
// output
- Tindex& n2, L1Vector<THitI>& i1_2,
+ Tindex& n2, L1Vector<L1HitIndex_t>& i1_2,
#ifdef DOUB_PERFORMANCE
- L1Vector<THitI>& hitsl_2,
+ L1Vector<L1HitIndex_t>& hitsl_2,
#endif // DOUB_PERFORMANCE
- L1Vector<THitI>& hitsm_2, fvec* Event, L1Vector<char>& lmDuplets);
+ L1Vector<L1HitIndex_t>& hitsm_2, fvec* Event, L1Vector<char>& lmDuplets);
/// Add the middle hits to parameters estimation. Propagate to right station.
/// Find the triplets (right hit). Reformat data in the portion of triplets.
void f30( // input
L1HitPoint* vStsHits_r, L1Station& stam, L1Station& star,
- int istam, int istar, L1HitPoint* vStsHits_m, L1TrackPar* T_1, L1FieldRegion* fld_1, THitI* hitsl_1,
+ int istam, int istar, L1HitPoint* vStsHits_m, L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1,
- Tindex n2, L1Vector<THitI>& hitsm_2, L1Vector<THitI>& i1_2,
+ Tindex n2, L1Vector<L1HitIndex_t>& hitsm_2, L1Vector<L1HitIndex_t>& i1_2,
const L1Vector<char>& mrDuplets,
// output
- Tindex& n3, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<THitI>& hitsl_3, L1Vector<THitI>& hitsm_3,
- L1Vector<THitI>& hitsr_3, nsL1::vector<fvec>::TSimd& u_front_3, nsL1::vector<fvec>::TSimd& u_back_3,
+ Tindex& n3, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3, L1Vector<L1HitIndex_t>& hitsm_3,
+ L1Vector<L1HitIndex_t>& hitsr_3, nsL1::vector<fvec>::TSimd& u_front_3, nsL1::vector<fvec>::TSimd& u_back_3,
nsL1::vector<fvec>::TSimd& z_Pos_3,
// nsL1::vector<fvec>::TSimd& dx_,
// nsL1::vector<fvec>::TSimd& dy_,
@@ -517,15 +518,15 @@ private:
/// Refit Triplets.
void f32( // input
- Tindex n3, int istal, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<THitI>& hitsl_3, L1Vector<THitI>& hitsm_3,
- L1Vector<THitI>& hitsr_3, int nIterations = 0);
+ Tindex n3, int istal, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3, L1Vector<L1HitIndex_t>& hitsm_3,
+ L1Vector<L1HitIndex_t>& hitsr_3, int nIterations = 0);
/// Select triplets. Save them into vTriplets.
void f4( // input
- Tindex n3, int istal, int istam, int istar, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<THitI>& hitsl_3,
- L1Vector<THitI>& hitsm_3, L1Vector<THitI>& hitsr_3,
+ Tindex n3, int istal, int istam, int istar, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3,
+ L1Vector<L1HitIndex_t>& hitsm_3, L1Vector<L1HitIndex_t>& hitsr_3,
// output
- Tindex& nstaltriplets, L1Vector<THitI>* hitsn_3 = 0, L1Vector<THitI>* hitsr_5 = 0
+ Tindex& nstaltriplets, L1Vector<L1HitIndex_t>* hitsn_3 = 0, L1Vector<L1HitIndex_t>* hitsr_5 = 0
// #ifdef XXX
// ,unsigned int &stat_n_trip
@@ -544,18 +545,18 @@ private:
int istal, int istam, Tindex ip, L1Vector<Tindex>& n_g, Tindex* portionStopIndex_,
// output
- L1TrackPar* T_1, L1FieldRegion* fld_1, THitI* hitsl_1,
+ L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1,
L1Vector<char>& lmDuplets,
- Tindex& n_2, L1Vector<THitI>& i1_2, L1Vector<THitI>& hitsm_2);
+ Tindex& n_2, L1Vector<L1HitIndex_t>& i1_2, L1Vector<L1HitIndex_t>& hitsm_2);
/// Find triplets on station
void TripletsStaPort( // input
- int istal, int istam, int istar, Tindex& nstaltriplets, L1TrackPar* T_1, L1FieldRegion* fld_1, THitI* hitsl_1,
+ int istal, int istam, int istar, Tindex& nstaltriplets, L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1,
- Tindex& n_2, L1Vector<THitI>& i1_2, L1Vector<THitI>& hitsm_2,
+ Tindex& n_2, L1Vector<L1HitIndex_t>& i1_2, L1Vector<L1HitIndex_t>& hitsm_2,
const L1Vector<char>& mrDuplets
diff --git a/reco/L1/L1Algo/L1AlgoTBB.h b/reco/L1/L1Algo/L1AlgoTBB.h
index a0005ff6d46ab93c8e8446cc850c01036d4de2b7..f31b3fd7ae6482cecd46aee6f1cf7e9cf9b4d89c 100644
--- a/reco/L1/L1Algo/L1AlgoTBB.h
+++ b/reco/L1/L1Algo/L1AlgoTBB.h
@@ -40,19 +40,19 @@ namespace tbb
unsigned* portionStopIndex;
L1TrackPar* T_g1;
L1FieldRegion* fld_g1;
- THitI* hitsl_g1;
+ L1HitIndex_t* hitsl_g1;
// fvec *x_minusV_g1; fvec *x_plusV_g1; fvec *y_minusV_g1; fvec *y_plusV_g1;
// output
- THitI* Duplets_start;
- THitI* Duplets_hits;
+ L1HitIndex_t* Duplets_start;
+ L1HitIndex_t* Duplets_hits;
Tindex* n_g2;
- THitI* i1_g2;
+ L1HitIndex_t* i1_g2;
// L1TrackPar *T_g2;
// L1FieldRegion *fld_g2;
// fvec *u_front_g2; fvec *u_back_g2;
- // THitI *hitsl_g2;
- THitI* hitsm_g2;
+ // L1HitIndex_t *hitsl_g2;
+ L1HitIndex_t* hitsm_g2;
// fvec *x_minusV_g2; fvec *x_plusV_g2; fvec *y_minusV_g2; fvec *y_plusV_g2;
public:
@@ -65,17 +65,17 @@ namespace tbb
double Pick_r_, double Pick_m_, double MaxInvMom_, fvec targX_, fvec targY_, fvec targZ_, L1FieldValue& targB_,
L1XYMeasurementInfo& TargetXYInfo_,
- Tindex* n_g1_, unsigned* portionStopIndex_, L1TrackPar* T_g1_, L1FieldRegion* fld_g1_, THitI* hitsl_g1_,
+ Tindex* n_g1_, unsigned* portionStopIndex_, L1TrackPar* T_g1_, L1FieldRegion* fld_g1_, L1HitIndex_t* hitsl_g1_,
// fvec *x_minusV_g1_, fvec *x_plusV_g1_, fvec *y_minusV_g1_, fvec *y_plusV_g1_,
// output
- THitI* Duplets_start_, THitI* Duplets_hits_,
+ L1HitIndex_t* Duplets_start_, L1HitIndex_t* Duplets_hits_,
- Tindex* n_g2_, THitI* i1_g2_,
+ Tindex* n_g2_, L1HitIndex_t* i1_g2_,
// L1TrackPar *T_g2_,
// L1FieldRegion *fld_g2_,
// fvec *u_front_g2_, fvec *u_back_g2_,
- // THitI *hitsl_g2_,
- THitI* hitsm_g2_
+ // L1HitIndex_t *hitsl_g2_,
+ L1HitIndex_t* hitsm_g2_
// fvec *x_minusV_g2_, fvec *x_plusV_g2_, fvec *y_minusV_g2_, fvec *y_plusV_g2_
)
: isec(isec_)
@@ -162,20 +162,20 @@ namespace tbb
Tindex* n_g1;
L1TrackPar* T_g1;
L1FieldRegion* fld_g1;
- THitI* hitsl_g1;
+ L1HitIndex_t* hitsl_g1;
Tindex* n_g2;
unsigned* portionStopIndex;
- THitI* i1_g2;
+ L1HitIndex_t* i1_g2;
/* L1FieldRegion *fld_g2;
fvec *u_front_g2; fvec *u_back_g2;
L1TrackPar *T_g2;*/
- // THitI *hitsl_g2;
- THitI* hitsm_g2;
+ // L1HitIndex_t *hitsl_g2;
+ L1HitIndex_t* hitsm_g2;
// fvec *x_minusV_g2; fvec *x_plusV_g2; fvec *y_minusV_g2; fvec *y_plusV_g2;
// output
- THitI* Duplets_start;
- THitI* Duplets_hits;
+ L1HitIndex_t* Duplets_start;
+ L1HitIndex_t* Duplets_hits;
std::vector<L1Triplet>* vTriplets_part;
unsigned* TripStartIndexH;
unsigned* TripStopIndexH;
@@ -188,17 +188,17 @@ namespace tbb
int isec_, L1Station* vStations_, int NStations_, Tindex* StsHitsStartIndex_, Tindex* StsHitsStopIndex_,
std::vector<L1HitPoint>& vStsHits_, double Pick_r_, double TRACK_CHI2_CUT_, double MaxInvMom_,
- Tindex* n_g1_, L1TrackPar* T_g1_, L1FieldRegion* fld_g1_, THitI* hitsl_g1_,
+ Tindex* n_g1_, L1TrackPar* T_g1_, L1FieldRegion* fld_g1_, L1HitIndex_t* hitsl_g1_,
- Tindex* n_g2_, unsigned* portionStopIndex_, THitI* i1_g2_,
+ Tindex* n_g2_, unsigned* portionStopIndex_, L1HitIndex_t* i1_g2_,
/*L1FieldRegion *fld_g2_,
fvec *u_front_g2_, fvec *u_back_g2_,
L1TrackPar *T_g2_,*/
- // THitI *hitsl_g2_,
- THitI* hitsm_g2_,
+ // L1HitIndex_t *hitsl_g2_,
+ L1HitIndex_t* hitsm_g2_,
// fvec *x_minusV_g2_, fvec *x_plusV_g2_, fvec *y_minusV_g2_, fvec *y_plusV_g2_,
// output
- THitI* Duplets_start_, THitI* Duplets_hits_, std::vector<L1Triplet>* vTriplets_part_, unsigned* TripStartIndexH_,
+ L1HitIndex_t* Duplets_start_, L1HitIndex_t* Duplets_hits_, std::vector<L1Triplet>* vTriplets_part_, unsigned* TripStartIndexH_,
unsigned* TripStopIndexH_)
: // input
isec(isec_)
diff --git a/reco/L1/L1Algo/L1BaseStationInfo.cxx b/reco/L1/L1Algo/L1BaseStationInfo.cxx
index 678edac2d55042477ab2bf40e0d4bf3f1fcff1b5..097e6e617bb0fa61ba8bee58d1e83c5edb0c0f8c 100644
--- a/reco/L1/L1Algo/L1BaseStationInfo.cxx
+++ b/reco/L1/L1Algo/L1BaseStationInfo.cxx
@@ -419,8 +419,8 @@ std::string L1BaseStationInfo::ToString(int verbosityLevel, int indentLevel) con
std::string indent(indentLevel, indentChar);
if (verbosityLevel == 0) {
- aStream << indent << "L1BaseStationInfo object: {stationID, detectorID, address} = {" << fStationID << ", "
- << static_cast<int>(fDetectorID) << ", " << this << '}';
+ aStream << indent << "L1BaseStationInfo object: {stationID, detectorID, z, address} = {" << fStationID << ", "
+ << static_cast<int>(fDetectorID) << ", " << fZPos << ", " << this << '}';
}
else if (verbosityLevel > 0) {
aStream << indent << "L1BaseStationInfo object: at " << this << '\n';
diff --git a/reco/L1/L1Algo/L1Branch.h b/reco/L1/L1Algo/L1Branch.h
index f6967b30623e9c0e91d45dcda671f7426c5588fe..ae6bd63d19684151b026fff4cd5b0015899bed00 100644
--- a/reco/L1/L1Algo/L1Branch.h
+++ b/reco/L1/L1Algo/L1Branch.h
@@ -24,7 +24,7 @@ struct L1Branch {
char NHits {0};
fscal chi2 {0.};
int CandIndex {0};
- L1Vector<THitI> fStsHits {"L1Branch::fStsHits"};
+ L1Vector<L1HitIndex_t> fStsHits {"L1Branch::fStsHits"};
// static bool compareCand(const L1Branch *a, const L1Branch *b){
//
diff --git a/reco/L1/L1Algo/L1CAMergeClones.cxx b/reco/L1/L1Algo/L1CAMergeClones.cxx
index 030a892d18f231141d616fcf6b59a63575f943f7..b9f14fadcdafb75744926abc6f97d254d79c9ae6 100644
--- a/reco/L1/L1Algo/L1CAMergeClones.cxx
+++ b/reco/L1/L1Algo/L1CAMergeClones.cxx
@@ -204,8 +204,8 @@ void L1Algo::CAMergeClones()
L1Vector<unsigned short>& firstStation = fMergerTrackFirstStation;
L1Vector<unsigned short>& lastStation = fMergerTrackLastStation;
- L1Vector<THitI>& firstHit = fMergerTrackFirstHit;
- L1Vector<THitI>& lastHit = fMergerTrackLastHit;
+ L1Vector<L1HitIndex_t>& firstHit = fMergerTrackFirstHit;
+ L1Vector<L1HitIndex_t>& lastHit = fMergerTrackLastHit;
L1Vector<unsigned short>& neighbour = fMergerTrackNeighbour;
L1Vector<float>& trackChi2 = fMergerTrackChi2;
L1Vector<char>& isStored = fMergerTrackIsStored;
@@ -220,7 +220,7 @@ void L1Algo::CAMergeClones()
// vector< L1Track > vTracksNew;
fMergerTracksNew.clear();
fMergerTracksNew.reserve(nTracks);
- // vector< THitI > fRecoHitsNew;
+ // vector< L1HitIndex_t > fRecoHitsNew;
fMergerRecoHitsNew.clear();
fMergerRecoHitsNew.reserve(fRecoHits.size());
@@ -233,7 +233,7 @@ void L1Algo::CAMergeClones()
neighbour.reset(nTracks);
isDownstreamNeighbour.reset(nTracks);
- THitI start_hit = 0;
+ L1HitIndex_t start_hit = 0;
#ifdef OMP
#pragma omp parallel for
@@ -397,7 +397,7 @@ void L1Algo::CAMergeClones()
fMergerTracksNew.push_back(fTracks[iTr]);
if (!isDownstreamNeighbour[iTr]) {
- for (THitI HI = firstHit[iTr]; HI <= lastHit[iTr]; HI++) {
+ for (L1HitIndex_t HI = firstHit[iTr]; HI <= lastHit[iTr]; HI++) {
fMergerRecoHitsNew.push_back(fRecoHits[HI]);
}
}
@@ -405,12 +405,12 @@ void L1Algo::CAMergeClones()
if (neighbour[iTr] < kNoNeighbour) {
isStored[neighbour[iTr]] = true;
fMergerTracksNew.back().NHits += fTracks[neighbour[iTr]].NHits;
- for (THitI HI = firstHit[neighbour[iTr]]; HI <= lastHit[neighbour[iTr]]; HI++)
+ for (L1HitIndex_t HI = firstHit[neighbour[iTr]]; HI <= lastHit[neighbour[iTr]]; HI++)
fMergerRecoHitsNew.push_back(fRecoHits[HI]);
}
if (isDownstreamNeighbour[iTr]) {
- for (THitI HI = firstHit[iTr]; HI <= lastHit[iTr]; HI++) {
+ for (L1HitIndex_t HI = firstHit[iTr]; HI <= lastHit[iTr]; HI++) {
fMergerRecoHitsNew.push_back(fRecoHits[HI]);
}
}
@@ -423,7 +423,7 @@ void L1Algo::CAMergeClones()
assert(fRecoHits.size() == fMergerRecoHitsNew.size());
fRecoHits.reset(fMergerRecoHitsNew.size());
- for (THitI iHi = 0; iHi < fMergerRecoHitsNew.size(); iHi++) {
+ for (L1HitIndex_t iHi = 0; iHi < fMergerRecoHitsNew.size(); iHi++) {
fRecoHits[iHi] = fMergerRecoHitsNew[iHi];
}
diff --git a/reco/L1/L1Algo/L1CATrackFinder.cxx b/reco/L1/L1Algo/L1CATrackFinder.cxx
index fa47f7b05a70f257f59df0b693c638322fe18c77..aecf7d61055581d20994e0e6b084a068f7d3e810 100644
--- a/reco/L1/L1Algo/L1CATrackFinder.cxx
+++ b/reco/L1/L1Algo/L1CATrackFinder.cxx
@@ -78,7 +78,7 @@ using std::endl;
inline void L1Algo::f10( // input
Tindex start_lh, Tindex n1_l, L1HitPoint* StsHits_l,
// output
- fvec* u_front_l, fvec* u_back_l, fvec* zPos_l, THitI* hitsl, fvec* HitTime_l, fvec* HitTimeEr,
+ fvec* u_front_l, fvec* u_back_l, fvec* zPos_l, L1HitIndex_t* hitsl, fvec* HitTime_l, fvec* HitTimeEr,
// comment unused parameters, FU, 18.01.21
fvec* /*Event_l*/, fvec* /*d_x*/, fvec* /*d_y*/, fvec* /*d_xy*/, fvec* d_u, fvec* d_v)
{
@@ -390,13 +390,13 @@ inline void L1Algo::f11( /// input 1st stage of singlet search
/// Find the doublets. Reformat data in the portion of doublets.
inline void L1Algo::f20(
/// input
- Tindex n1, L1Station& stal, L1Station& stam, L1HitPoint* vStsHits_m, L1TrackPar* T_1, THitI* hitsl_1,
+ Tindex n1, L1Station& stal, L1Station& stam, L1HitPoint* vStsHits_m, L1TrackPar* T_1, L1HitIndex_t* hitsl_1,
/// output
- Tindex& n2, L1Vector<THitI>& i1_2,
+ Tindex& n2, L1Vector<L1HitIndex_t>& i1_2,
#ifdef DOUB_PERFORMANCE
- L1Vector<THitI>& hitsl_2,
+ L1Vector<L1HitIndex_t>& hitsl_2,
#endif // DOUB_PERFORMANCE
- L1Vector<THitI>& hitsm_2, fvec* /*Event*/, L1Vector<char>& lmDuplets)
+ L1Vector<L1HitIndex_t>& hitsm_2, fvec* /*Event*/, L1Vector<char>& lmDuplets)
{
n2 = 0; // number of doublet
for (Tindex i1 = 0; i1 < n1; ++i1) // for each singlet
@@ -424,12 +424,12 @@ inline void L1Algo::f20(
sqrt(timeError) * 5);
- THitI imh = 0;
+ L1HitIndex_t imh = 0;
int irm1 = -1;
while (true) {
if (fTrackingMode == kGlobal || fTrackingMode == kMcbm) {
irm1++;
- if ((THitI) irm1 >= (StsHitsUnusedStopIndex[&stam - vStations] - StsHitsUnusedStartIndex[&stam - vStations]))
+ if ((L1HitIndex_t) irm1 >= (StsHitsUnusedStopIndex[&stam - vStations] - StsHitsUnusedStartIndex[&stam - vStations]))
break;
imh = irm1;
}
@@ -561,19 +561,19 @@ inline void L1Algo::f20(
/// Find the triplets(right hit). Reformat data in the portion of triplets.
inline void L1Algo::f30( // input
L1HitPoint* vStsHits_r, L1Station& stam, L1Station& star, int istam, int istar, L1HitPoint* vStsHits_m,
- L1TrackPar* T_1, L1FieldRegion* fld_1, THitI* hitsl_1, Tindex n2, L1Vector<THitI>& hitsm_2, L1Vector<THitI>& i1_2,
+ L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1, Tindex n2, L1Vector<L1HitIndex_t>& hitsm_2, L1Vector<L1HitIndex_t>& i1_2,
const L1Vector<char>& /*mrDuplets*/,
// output
- Tindex& n3, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<THitI>& hitsl_3, L1Vector<THitI>& hitsm_3,
- L1Vector<THitI>& hitsr_3, nsL1::vector<fvec>::TSimd& u_front_3, nsL1::vector<fvec>::TSimd& u_back_3,
+ Tindex& n3, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3, L1Vector<L1HitIndex_t>& hitsm_3,
+ L1Vector<L1HitIndex_t>& hitsr_3, nsL1::vector<fvec>::TSimd& u_front_3, nsL1::vector<fvec>::TSimd& u_back_3,
nsL1::vector<fvec>::TSimd& z_Pos_3,
// nsL1::vector<fvec>::TSimd& dx_,
// nsL1::vector<fvec>::TSimd& dy_,
nsL1::vector<fvec>::TSimd& dv_, nsL1::vector<fvec>::TSimd& du_, nsL1::vector<fvec>::TSimd& timeR,
nsL1::vector<fvec>::TSimd& timeER)
{
- THitI hitsl_2[fvecLen];
- THitI hitsm_2_tmp[fvecLen];
+ L1HitIndex_t hitsl_2[fvecLen];
+ L1HitIndex_t hitsm_2_tmp[fvecLen];
fvec fvec_0;
L1TrackPar L1TrackPar_0;
@@ -729,13 +729,13 @@ inline void L1Algo::f30( // input
(sqrt(Pick_r22 * (T2.C11 + stam.XYInfo.C11)) + fMaxDZ * fabs(T2.ty))[i2_4] * iz, time,
sqrt(timeError) * 5);
- THitI irh = 0;
- THitI Ntriplets = 0;
+ L1HitIndex_t irh = 0;
+ L1HitIndex_t Ntriplets = 0;
int irh1 = -1;
while (true) {
if (fTrackingMode == kGlobal || fTrackingMode == kMcbm) {
irh1++;
- if ((THitI) irh1 >= (StsHitsUnusedStopIndex[istar] - StsHitsUnusedStartIndex[istar])) break;
+ if ((L1HitIndex_t) irh1 >= (StsHitsUnusedStopIndex[istar] - StsHitsUnusedStartIndex[istar])) break;
irh = irh1;
}
else {
@@ -952,8 +952,8 @@ inline void L1Algo::f31( // input
/// Refit Triplets.
inline void L1Algo::f32( // input // TODO not updated after gaps introduction
- Tindex n3, int istal, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<THitI>& hitsl_3, L1Vector<THitI>& hitsm_3,
- L1Vector<THitI>& hitsr_3, int nIterations)
+ Tindex n3, int istal, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3, L1Vector<L1HitIndex_t>& hitsm_3,
+ L1Vector<L1HitIndex_t>& hitsr_3, int nIterations)
{
L1Fit fit;
fit.SetParticleMass(fDefaultMass);
@@ -976,7 +976,7 @@ inline void L1Algo::f32( // input // TODO not updated after gaps introduction
fscal& qp0 = T3.qp[i3_4];
// prepare data
- THitI ihit[NHits] = {(*RealIHitP)[hitsl_3[i3] + StsHitsUnusedStartIndex[ista[0]]],
+ L1HitIndex_t ihit[NHits] = {(*RealIHitP)[hitsl_3[i3] + StsHitsUnusedStartIndex[ista[0]]],
(*RealIHitP)[hitsm_3[i3] + StsHitsUnusedStartIndex[ista[1]]],
(*RealIHitP)[hitsr_3[i3] + StsHitsUnusedStartIndex[ista[2]]]};
@@ -1116,10 +1116,10 @@ inline void L1Algo::f32( // input // TODO not updated after gaps introduction
inline void L1Algo::f4( // input
- Tindex n3, int istal, int istam, int istar, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<THitI>& hitsl_3,
- L1Vector<THitI>& hitsm_3, L1Vector<THitI>& hitsr_3,
+ Tindex n3, int istal, int istam, int istar, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3,
+ L1Vector<L1HitIndex_t>& hitsm_3, L1Vector<L1HitIndex_t>& hitsr_3,
// output
- Tindex& nstaltriplets, L1Vector<THitI>* /*hitsn_3*/, L1Vector<THitI>* /*hitsr_5*/
+ Tindex& nstaltriplets, L1Vector<L1HitIndex_t>* /*hitsn_3*/, L1Vector<L1HitIndex_t>* /*hitsr_5*/
)
{
@@ -1131,7 +1131,7 @@ inline void L1Algo::f4( // input
unsigned int Thread = 0;
#endif // _OPENMP
- THitI ihitl_priv = 0;
+ L1HitIndex_t ihitl_priv = 0;
for (Tindex i3 = 0; i3 < n3; ++i3) {
const Tindex i3_V = i3 / fvecLen;
@@ -1142,9 +1142,9 @@ inline void L1Algo::f4( // input
// select
fscal& chi2 = T3.chi2[i3_4];
- const THitI ihitl = hitsl_3[i3] + StsHitsUnusedStartIndex[istal];
- const THitI ihitm = hitsm_3[i3] + StsHitsUnusedStartIndex[istam];
- const THitI ihitr = hitsr_3[i3] + StsHitsUnusedStartIndex[istar];
+ const L1HitIndex_t ihitl = hitsl_3[i3] + StsHitsUnusedStartIndex[istal];
+ const L1HitIndex_t ihitm = hitsm_3[i3] + StsHitsUnusedStartIndex[istam];
+ const L1HitIndex_t ihitr = hitsr_3[i3] + StsHitsUnusedStartIndex[istar];
L1_ASSERT(ihitl < StsHitsUnusedStopIndex[istal], ihitl << " < " << StsHitsUnusedStopIndex[istal]);
L1_ASSERT(ihitm < StsHitsUnusedStopIndex[istam], ihitm << " < " << StsHitsUnusedStopIndex[istam]);
L1_ASSERT(ihitr < StsHitsUnusedStopIndex[istar], ihitr << " < " << StsHitsUnusedStopIndex[istar]);
@@ -1264,9 +1264,9 @@ inline void L1Algo::f5( // input
unsigned char level = 0;
// float chi2 = trip->GetChi2();
- THitI ihitl = trip.GetLHit();
- THitI ihitm = trip.GetMHit();
- THitI ihitr = trip.GetRHit();
+ L1HitIndex_t ihitl = trip.GetLHit();
+ L1HitIndex_t ihitm = trip.GetMHit();
+ L1HitIndex_t ihitr = trip.GetRHit();
L1_ASSERT(ihitl < StsHitsUnusedStopIndex[istal], ihitl << " < " << StsHitsUnusedStopIndex[istal]);
L1_ASSERT(ihitm < StsHitsUnusedStopIndex[istam], ihitm << " < " << StsHitsUnusedStopIndex[istam]);
L1_ASSERT(ihitr < StsHitsUnusedStopIndex[istar], ihitr << " < " << StsHitsUnusedStopIndex[istar]);
@@ -1318,8 +1318,8 @@ inline void L1Algo::DupletsStaPort(
/// input:
int istal, int istam, Tindex ip, L1Vector<Tindex>& n_g, Tindex* portionStopIndex_,
/// output:
- L1TrackPar* T_1, L1FieldRegion* fld_1, THitI* hitsl_1, L1Vector<char>& lmDuplets, Tindex& n_2, L1Vector<THitI>& i1_2,
- L1Vector<THitI>& hitsm_2
+ L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1, L1Vector<char>& lmDuplets, Tindex& n_2, L1Vector<L1HitIndex_t>& i1_2,
+ L1Vector<L1HitIndex_t>& hitsm_2
///
)
{
@@ -1381,7 +1381,7 @@ inline void L1Algo::DupletsStaPort(
// TODO: repalce with constexpr if (C++17) (S.Zharko)
#ifdef DOUB_PERFORMANCE
- L1Vector<THitI> hitsl_2("L1CATrackFinder::hitsl_2");
+ L1Vector<L1HitIndex_t> hitsl_2("L1CATrackFinder::hitsl_2");
#endif // DOUB_PERFORMANCE
f20( // input
@@ -1398,12 +1398,12 @@ inline void L1Algo::DupletsStaPort(
hitsm_2[i] << " " << StsHitsUnusedStopIndex[istam] - StsHitsUnusedStartIndex[istam]);
#ifdef DOUB_PERFORMANCE
- THitI* RealIHitL = &((*RealIHitP)[StsHitsUnusedStartIndex[istal]]);
- THitI* RealIHitM = &((*RealIHitP)[StsHitsUnusedStartIndex[istam]]);
+ L1HitIndex_t* RealIHitL = &((*RealIHitP)[StsHitsUnusedStartIndex[istal]]);
+ L1HitIndex_t* RealIHitM = &((*RealIHitP)[StsHitsUnusedStartIndex[istam]]);
for (Tindex i = 0; i < n2; ++i) {
// int i_4 = i%4;
// int i_V = i/4;
- THitI iHits[2] = {RealIHitL[hitsl_2[i]], RealIHitM[hitsm_2[i]]};
+ L1HitIndex_t iHits[2] = {RealIHitL[hitsl_2[i]], RealIHitM[hitsm_2[i]]};
fL1Eff_doublets->AddOne(iHits);
}
#endif // DOUB_PERFORMANCE
@@ -1421,9 +1421,9 @@ L1Algo::TripletsStaPort( /// creates triplets: input: @istal - start station nu
/// @&n_2 - number of douplets,@&i1_2 - index of 1st hit in portion indexed by doublet index, @&hitsm_2 - index of middle hit in hits array indexed by doublet index
- Tindex& nstaltriplets, L1TrackPar* T_1, L1FieldRegion* fld_1, THitI* hitsl_1,
+ Tindex& nstaltriplets, L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1,
- Tindex& n_2, L1Vector<THitI>& i1_2, L1Vector<THitI>& hitsm_2,
+ Tindex& n_2, L1Vector<L1HitIndex_t>& i1_2, L1Vector<L1HitIndex_t>& hitsm_2,
const L1Vector<char>& mrDuplets
@@ -1453,9 +1453,9 @@ L1Algo::TripletsStaPort( /// creates triplets: input: @istal - start station nu
#endif
nsL1::vector<L1TrackPar>::TSimd& T_3 = fT_3[Thread];
- L1Vector<THitI>& hitsl_3 = fhitsl_3[Thread];
- L1Vector<THitI>& hitsm_3 = fhitsm_3[Thread];
- L1Vector<THitI>& hitsr_3 = fhitsr_3[Thread];
+ L1Vector<L1HitIndex_t>& hitsl_3 = fhitsl_3[Thread];
+ L1Vector<L1HitIndex_t>& hitsm_3 = fhitsm_3[Thread];
+ L1Vector<L1HitIndex_t>& hitsr_3 = fhitsr_3[Thread];
nsL1::vector<fvec>::TSimd& u_front3 = fu_front3[Thread];
nsL1::vector<fvec>::TSimd& u_back3 = fu_back3[Thread];
nsL1::vector<fvec>::TSimd& z_pos3 = fz_pos3[Thread];
@@ -1523,13 +1523,13 @@ L1Algo::TripletsStaPort( /// creates triplets: input: @istal - start station nu
// f32( n3, istal, _RealIHit, T_3, hitsl_3, hitsm_3, hitsr_3, 0 );
#ifdef TRIP_PERFORMANCE
- THitI* RealIHitL = &((*RealIHitP)[StsHitsUnusedStartIndex[istal]]);
- THitI* RealIHitM = &((*RealIHitP)[StsHitsUnusedStartIndex[istam]]);
- THitI* RealIHitR = &((*RealIHitP)[StsHitsUnusedStartIndex[istar]]);
+ L1HitIndex_t* RealIHitL = &((*RealIHitP)[StsHitsUnusedStartIndex[istal]]);
+ L1HitIndex_t* RealIHitM = &((*RealIHitP)[StsHitsUnusedStartIndex[istam]]);
+ L1HitIndex_t* RealIHitR = &((*RealIHitP)[StsHitsUnusedStartIndex[istar]]);
for (Tindex i = 0; i < n3; ++i) {
Tindex i_4 = i % 4;
Tindex i_V = i / 4;
- THitI iHits[3] = {RealIHitL[hitsl_3[i]], RealIHitM[hitsm_3[i]], RealIHitR[hitsr_3[i]]};
+ L1HitIndex_t iHits[3] = {RealIHitL[hitsl_3[i]], RealIHitM[hitsm_3[i]], RealIHitR[hitsr_3[i]]};
#ifdef PULLS
if (fL1Eff_triplets->AddOne(iHits)) fL1Pulls->AddOne(T_3[i_V], i_4, iHits[2]);
#else
@@ -1565,21 +1565,14 @@ L1Algo::TripletsStaPort( /// creates triplets: input: @istal - start station nu
// {
// omp_destroy_lock(&Occupied);
// }
-///**********************************************************************************************************************
-///**********************************************************************************************************************
-///**********************************************************************************************************************
-///* *
-///* *
-///* *
-///* CATrackFinder procedure *
-///* *
-///* *
-///* *
-///**********************************************************************************************************************
-///**********************************************************************************************************************
-///**********************************************************************************************************************
+/***********************************************************************************************//**
+ * *
+ * ------ CATrackFinder procedure ------ *
+ * *
+ **************************************************************************************************/
+
void L1Algo::CATrackFinder()
{
@@ -1587,6 +1580,9 @@ void L1Algo::CATrackFinder()
omp_set_num_threads(fNThreads);
#endif
+ /*******************************//**
+ * Performance monitors setting
+ **********************************/
#ifdef PULLS
static L1AlgoPulls* l1Pulls_ = new L1AlgoPulls();
@@ -1644,9 +1640,7 @@ void L1Algo::CATrackFinder()
static L1CATFIterTimerInfo stat_gti = gti;
static L1CATFTimerInfo stat_ti = ti;
-
-
-#endif
+#endif // XXX
#ifdef COUNTERS
static Tindex stat_nStartHits = 0;
@@ -1661,6 +1655,10 @@ void L1Algo::CATrackFinder()
static Tindex stat_nTrCandidates[fNFindIterations] = {0};
#endif
+ /********************************//**
+ * CATrackFinder routine setting
+ ***********************************/
+
RealIHitP = &RealIHit_v;
RealIHitPBuf = &RealIHit_v_buf;
vStsHitsUnused = &vStsDontUsedHits_B; /// array of hits used on current iteration
@@ -1687,10 +1685,9 @@ void L1Algo::CATrackFinder()
float lasttime = 0;
float starttime = std::numeric_limits<float>::max();
- ;
for (int ist = 0; ist < NStations; ++ist)
- for (THitI ih = StsHitsStartIndex[ist]; ih < StsHitsStopIndex[ist]; ++ih) {
+ for (L1HitIndex_t ih = StsHitsStartIndex[ist]; ih < StsHitsStopIndex[ist]; ++ih) {
const float& time = (*vStsHits)[ih].t;
if ((lasttime < time) && (!std::isinf(time))) lasttime = time;
@@ -1701,8 +1698,7 @@ void L1Algo::CATrackFinder()
#ifdef XXX
c_time.Start();
c_timerG.Start();
-
-#endif
+#endif // XXX
float yStep = 1.5 / sqrt(nDontUsedHits); // empirics. 0.01*sqrt(2374) ~= 0.5
@@ -1739,19 +1735,17 @@ void L1Algo::CATrackFinder()
for (int ist = 0; ist < NStations; ++ist)
- for (THitI ih = StsHitsStartIndex[ist]; ih < StsHitsStopIndex[ist]; ++ih) {
+ for (L1HitIndex_t ih = StsHitsStartIndex[ist]; ih < StsHitsStopIndex[ist]; ++ih) {
L1Hit& h = (*vStsHits)[ih];
SetFUnUsed((*fStripFlag)[h.f]);
SetFUnUsed((*fStripFlag)[h.b]);
}
for (int ista = 0; ista < NStations; ++ista) {
-
-
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 5)
#endif
- for (THitI ih = StsHitsStartIndex[ista]; ih < StsHitsStopIndex[ista]; ++ih) {
+ for (L1HitIndex_t ih = StsHitsStartIndex[ista]; ih < StsHitsStopIndex[ista]; ++ih) {
CreateHitPoint(vStsDontUsedHits_Buf[ih], vStsDontUsedHitsxy_B[ih]);
}
}
@@ -1769,6 +1763,10 @@ void L1Algo::CATrackFinder()
TStopwatch c_time1;
c_time1.Start();
+ /********************************//**
+ * Loop over tracking iterations
+ ***********************************/
+
// ---- Loop over Track Finder iterations ----------------------------------------------------------------//
L1ASSERT(0, fNFindIterations == fParameters.CAIterationsContainer().size());
@@ -1793,7 +1791,7 @@ void L1Algo::CATrackFinder()
#endif
if (isec != 0) {
- L1Vector<THitI>* RealIHitPTmp = RealIHitP;
+ L1Vector<L1HitIndex_t>* RealIHitPTmp = RealIHitP;
RealIHitP = RealIHitPBuf;
RealIHitPBuf = RealIHitPTmp;
@@ -1807,7 +1805,7 @@ void L1Algo::CATrackFinder()
}
// TODO: Replace NStations with fInitManager.GetStationsNumber() (S.Zharko)
for (int ist = 0; ist < NStations; ++ist) {
- for (THitI ih = StsHitsUnusedStartIndex[ist]; ih < StsHitsUnusedStopIndex[ist]; ++ih) {
+ for (L1HitIndex_t ih = StsHitsUnusedStartIndex[ist]; ih < StsHitsUnusedStopIndex[ist]; ++ih) {
//SG!!
TripForHit[0][ih] = 0;
TripForHit[1][ih] = 0;
@@ -2000,18 +1998,18 @@ void L1Algo::CATrackFinder()
const Tindex vPortion = Portion / fvecLen;
L1TrackPar T_1[vPortion];
L1FieldRegion fld_1[vPortion];
- THitI hitsl_1[Portion];
+ L1HitIndex_t hitsl_1[Portion];
L1TrackPar TG_1[vPortion];
L1FieldRegion fldG_1[vPortion];
- THitI hitslG_1[Portion];
+ L1HitIndex_t hitslG_1[Portion];
- L1Vector<THitI> hitsm_2("L1CATrackFinder::hitsm_2"); /// middle hits indexed by number of doublets in portion(i2)
- L1Vector<THitI> i1_2(
+ L1Vector<L1HitIndex_t> hitsm_2("L1CATrackFinder::hitsm_2"); /// middle hits indexed by number of doublets in portion(i2)
+ L1Vector<L1HitIndex_t> i1_2(
"L1CATrackFinder::i1_2"); /// index in portion of singlets(i1) indexed by index in portion of doublets(i2)
- L1Vector<THitI> hitsmG_2("L1CATrackFinder::hitsmG_2"); /// middle hits indexed by number of doublets in portion(i2)
- L1Vector<THitI> i1G_2(
+ L1Vector<L1HitIndex_t> hitsmG_2("L1CATrackFinder::hitsmG_2"); /// middle hits indexed by number of doublets in portion(i2)
+ L1Vector<L1HitIndex_t> i1G_2(
"L1CATrackFinder::i1G_2"); /// index in portion of singlets(i1) indexed by index in portion of doublets(i2)
L1Vector<char> lmDuplets[L1Parameters::kMaxNstations] {
"L1CATrackFinder::lmDuplets"}; // is exist a doublet started from indexed by left hit
@@ -2260,7 +2258,7 @@ void L1Algo::CATrackFinder()
bool check = 1;
- for (L1Vector<THitI>::iterator phitIt = tr.fStsHits.begin(); /// used strips are marked
+ for (L1Vector<L1HitIndex_t>::iterator phitIt = tr.fStsHits.begin(); /// used strips are marked
phitIt != tr.fStsHits.end(); ++phitIt) {
const L1Hit& h = (*vStsHits)[*phitIt];
#ifdef _OPENMP
@@ -2342,7 +2340,7 @@ void L1Algo::CATrackFinder()
bool check = 1;
if (fTrackCandidates[i][iCandidate].CandIndex != -1) {
- for (L1Vector<THitI>::iterator phIt = tr.fStsHits.begin(); /// used strips are marked
+ for (L1Vector<L1HitIndex_t>::iterator phIt = tr.fStsHits.begin(); /// used strips are marked
phIt != tr.fStsHits.end(); ++phIt) {
const L1Hit& h = (((*vStsHits))[*phIt]);
if (((fStripToTrackB)[h.b] != tr.CandIndex) || ((fStripToTrack)[h.f] != tr.CandIndex)) {
@@ -2376,7 +2374,7 @@ void L1Algo::CATrackFinder()
#endif
- for (L1Vector<THitI>::iterator phIt = tr.fStsHits.begin(); /// used strips are marked
+ for (L1Vector<L1HitIndex_t>::iterator phIt = tr.fStsHits.begin(); /// used strips are marked
phIt != tr.fStsHits.end(); ++phIt) {
L1Hit& h = (*vStsHits)[*phIt];
@@ -2461,7 +2459,7 @@ void L1Algo::CATrackFinder()
int start = StsHitsUnusedStartIndex[ista];
int Nelements = StsHitsUnusedStopIndex[ista] - start;
L1Hit* staHits = nullptr; // to avoid out-of-range error in ..[start]
- THitI* staHitIndices = nullptr;
+ L1HitIndex_t* staHitIndices = nullptr;
L1HitPoint* staHitPoints = nullptr;
if (Nelements > 0) {
staHits = &((*vStsHitsUnused)[start]);
@@ -2576,7 +2574,7 @@ void L1Algo::CATrackFinder()
NBranches += stat_max_n_branches;
BranchSize += stat_max_BranchSize;
NTracks += fTracks.size();
- TrackSize += sizeof(L1Track)*fTracks.size() + sizeof(THitI)*fRecoHits.size();
+ TrackSize += sizeof(L1Track)*fTracks.size() + sizeof(L1HitIndex_t)*fRecoHits.size();
int k = 1024*NTimes;
cout<<"L1 Event size: \n"
@@ -2640,8 +2638,8 @@ inline void L1Algo::CAFindTrack(int ista, L1Branch& best_tr, unsigned char& best
{
// -- finish with current track
// add rest of hits
- const THitI& ihitm = curr_trip->GetMHit();
- const THitI& ihitr = curr_trip->GetRHit();
+ const L1HitIndex_t& ihitm = curr_trip->GetMHit();
+ const L1HitIndex_t& ihitr = curr_trip->GetRHit();
if (!GetFUsed((*fStripFlag)[(*vStsHitsUnused)[ihitm].f] | (*fStripFlag)[(*vStsHitsUnused)[ihitm].b])) {
diff --git a/reco/L1/L1Algo/L1Def.h b/reco/L1/L1Algo/L1Def.h
index f60d2607d534b6c44dbca71b877671c08ce4ba11..0b4e6f0f97d3df58c627fbff769dfdd9048d66a5 100644
--- a/reco/L1/L1Algo/L1Def.h
+++ b/reco/L1/L1Algo/L1Def.h
@@ -49,6 +49,8 @@ T finite(T x)
#if defined(NDEBUG) || defined(L1_NO_ASSERT)
#define L1_ASSERT(v, msg)
#define L1_assert(v)
+// Prints expression value to the std::cout
+#define L1_SHOW(expr)
#else
#define L1_ASSERT(v, msg) \
if (v) {} \
@@ -58,9 +60,14 @@ T finite(T x)
abort(); \
}
#define L1_assert(v) assert(v)
+#define L1_SHOW(expr) \
+ std::cout << __FILE__ << ":" << __LINE__ << ": \033[01;38;5;208m" << (#expr) << "\033[0m = " << (expr) << "\n"
#endif
typedef int index_type;
+
+
+
#endif
diff --git a/reco/L1/L1Algo/L1Grid.cxx b/reco/L1/L1Algo/L1Grid.cxx
index 3de8de7d235e97c0ad3628fb761e107f0bc550ba..071d3804c80eb47156f83d63614296a4ddf28d36 100644
--- a/reco/L1/L1Algo/L1Grid.cxx
+++ b/reco/L1/L1Algo/L1Grid.cxx
@@ -37,7 +37,7 @@ inline void memset(T* dest, T i, size_t num)
}
-void L1Grid::UpdateIterGrid(unsigned int Nelements, L1Hit* hits, L1Vector<THitI>* indicesBuf, THitI* indices,
+void L1Grid::UpdateIterGrid(unsigned int Nelements, L1Hit* hits, L1Vector<L1HitIndex_t>* indicesBuf, L1HitIndex_t* indices,
L1Vector<L1Hit>* hits2, L1Vector<L1HitPoint>* pointsBuf, L1HitPoint* points,
int& NHitsOnStation, char iS, L1Algo& Algo, const L1Vector<unsigned char>* vSFlag)
{
@@ -50,14 +50,14 @@ void L1Grid::UpdateIterGrid(unsigned int Nelements, L1Hit* hits, L1Vector<THitI>
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 250) firstprivate(xs, ys)
#endif
- for (THitI x = 0; x < Nelements; x++) {
+ for (L1HitIndex_t x = 0; x < Nelements; x++) {
const L1Hit& hit = hits[x];
if (!L1Algo::GetFUsed((*vSFlag)[hit.f] | (*vSFlag)[hit.b])) {
Algo.GetHitCoor(hit, xs, ys, iS);
- const THitI& bin = GetBinBounded(xs, ys, hit.t);
+ const L1HitIndex_t& bin = GetBinBounded(xs, ys, hit.t);
fHitsInBin[x] = fFirstHitInBin[bin + 1];
#ifdef _OPENMP
@@ -93,18 +93,18 @@ void L1Grid::UpdateIterGrid(unsigned int Nelements, L1Hit* hits, L1Vector<THitI>
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 250) firstprivate(xs, ys)
#endif
- for (THitI x = 0; x < Nelements; x++) {
+ for (L1HitIndex_t x = 0; x < Nelements; x++) {
const L1Hit& hit = hits[x];
if (!L1Algo::GetFUsed((*vSFlag)[hit.f] | (*vSFlag)[hit.b])) {
Algo.GetHitCoor(hit, xs, ys, iS);
- const THitI& bin = GetBinBounded(xs, ys, hit.t);
+ const L1HitIndex_t& bin = GetBinBounded(xs, ys, hit.t);
{
- const THitI& index1 = fHitsInBin[x] + fFirstHitInBin[bin];
+ const L1HitIndex_t& index1 = fHitsInBin[x] + fFirstHitInBin[bin];
(*hits2)[index1 + NHitsOnStation] = hits[x];
(*indicesBuf)[index1 + NHitsOnStation] = indices[x];
@@ -134,8 +134,8 @@ void L1Grid::AllocateMemory(int NThreads)
// {
// delete[] fFirstHitInBinArray[i];
// delete[] fFirstHitInBin[i];
- // fFirstHitInBinArray[i] = new THitI[binsGrid];// TODO calculate safe number of bins
- // fFirstHitInBin[i] = new THitI[binsGrid];
+ // fFirstHitInBinArray[i] = new L1HitIndex_t[binsGrid];// TODO calculate safe number of bins
+ // fFirstHitInBin[i] = new L1HitIndex_t[binsGrid];
// }
// fOffsets.resize(fNThreads +1, 0);
// fNumberHitsInBin.resize(binsGrid, 0);
@@ -165,8 +165,8 @@ void L1Grid::BuildBins(float yMin, float yMax, float zMin, float zMax, float tMi
}
-void L1Grid::StoreHits(THitI nhits, const L1Hit* hits, char iS, L1Algo& Algo, THitI n, L1Hit* hitsBuf1,
- const L1Hit* hits1, THitI* indices1)
+void L1Grid::StoreHits(L1HitIndex_t nhits, const L1Hit* hits, char iS, L1Algo& Algo, L1HitIndex_t n, L1Hit* hitsBuf1,
+ const L1Hit* hits1, L1HitIndex_t* indices1)
{
fscal xs = 0;
@@ -177,7 +177,7 @@ void L1Grid::StoreHits(THitI nhits, const L1Hit* hits, char iS, L1Algo& Algo, TH
#ifdef _OPENMP
#pragma omp parallel for firstprivate(xs, ys)
#endif
- for (THitI x = 0; x < nhits; x++) {
+ for (L1HitIndex_t x = 0; x < nhits; x++) {
Algo.GetHitCoor((hits)[x], xs, ys, iS);
@@ -214,16 +214,16 @@ void L1Grid::StoreHits(THitI nhits, const L1Hit* hits, char iS, L1Algo& Algo, TH
#pragma omp parallel for firstprivate(xs, ys)
- for (THitI x = 0; x < nhits; x++) {
+ for (L1HitIndex_t x = 0; x < nhits; x++) {
Algo.GetHitCoor((hits1)[x], xs, ys, iS);
- const THitI& bin = GetBinBounded(xs, ys, (hits1)[x].t);
+ const L1HitIndex_t& bin = GetBinBounded(xs, ys, (hits1)[x].t);
{
- const THitI& index1 = fHitsInBin[x] + fFirstHitInBin[bin];
+ const L1HitIndex_t& index1 = fHitsInBin[x] + fFirstHitInBin[bin];
(hitsBuf1)[index1] = hits[x];
diff --git a/reco/L1/L1Algo/L1Grid.h b/reco/L1/L1Algo/L1Grid.h
index 89a38a8a1cc35b8d9281b14e0daccb181ecec059..ae31722216605b79e06f8296294e6a616b6a3a47 100644
--- a/reco/L1/L1Algo/L1Grid.h
+++ b/reco/L1/L1Algo/L1Grid.h
@@ -43,21 +43,21 @@ public:
~L1Grid() = default;
- void StoreHits(THitI nhits, const L1Hit* hits, char iS, L1Algo& Algo, THitI n, L1Hit* hitsBuf1, const L1Hit* hits1,
- THitI* indices1);
+ void StoreHits(L1HitIndex_t nhits, const L1Hit* hits, char iS, L1Algo& Algo, L1HitIndex_t n, L1Hit* hitsBuf1, const L1Hit* hits1,
+ L1HitIndex_t* indices1);
void CreatePar0(float yMin, float yMax, float zMin, float zMax, float sy, float sz);
void BuildBins(float yMin, float yMax, float zMin, float zMax, float tMin, float tMax, float sy, float sz, float st);
- void HitsSort(L1HitPoint* pointsBuf, L1Hit* hitsBuf, const L1Hit* hits, THitI* indices, THitI* indicesBuf,
- L1HitPoint* points, THitI n, THitI nhits, char iS, L1Algo& Algo);
+ void HitsSort(L1HitPoint* pointsBuf, L1Hit* hitsBuf, const L1Hit* hits, L1HitIndex_t* indices, L1HitIndex_t* indicesBuf,
+ L1HitPoint* points, L1HitIndex_t n, L1HitIndex_t nhits, char iS, L1Algo& Algo);
void Initial1(int NThreads);
void AllocateMemory(int NThreads);
void Create(float yMin, float yMax, float zMin, float zMax, float sy, float sz);
- void Fill(const L1HitPoint* points, THitI n); // call after sort
- void FillPar(const L1HitPoint* points, THitI n);
+ void Fill(const L1HitPoint* points, L1HitIndex_t n); // call after sort
+ void FillPar(const L1HitPoint* points, L1HitIndex_t n);
int GetBin(float Y, float Z) const;
@@ -84,7 +84,7 @@ public:
unsigned short Nz() const { return fNz; }
unsigned short Nt() const { return fNt; }
- THitI FirstHitInBin(unsigned int i) const
+ L1HitIndex_t FirstHitInBin(unsigned int i) const
{
if (i < (fN + 1)) return fFirstHitInBin[i];
else
@@ -100,7 +100,7 @@ public:
// };
- void UpdateIterGrid(unsigned int Nelements, L1Hit* hits, L1Vector<THitI>* indicesBuf, THitI* indices,
+ void UpdateIterGrid(unsigned int Nelements, L1Hit* hits, L1Vector<L1HitIndex_t>* indicesBuf, L1HitIndex_t* indices,
L1Vector<L1Hit>* hits2, L1Vector<L1HitPoint>* pointsBuf, L1HitPoint* points, int& NHitsOnStation,
char iS, L1Algo& Algo, const L1Vector<unsigned char>* vSFlag);
@@ -119,8 +119,8 @@ private:
int fBinInGrid {0};
unsigned short fNThreads {0};
- L1Vector<THitI> fFirstHitInBin {"L1Grid::fFirstHitInBin"};
- L1Vector<THitI> fHitsInBin {"L1Grid::fHitsInBin"};
+ L1Vector<L1HitIndex_t> fFirstHitInBin {"L1Grid::fFirstHitInBin"};
+ L1Vector<L1HitIndex_t> fHitsInBin {"L1Grid::fHitsInBin"};
// vector <omp_lock_t> lock;
};
diff --git a/reco/L1/L1Algo/L1Hit.h b/reco/L1/L1Algo/L1Hit.h
index 4852b0db033c99b1ba3b23cd259cea320493c1c3..dc18c3043ad34fb326765583f5eee4fe343d2688 100644
--- a/reco/L1/L1Algo/L1Hit.h
+++ b/reco/L1/L1Algo/L1Hit.h
@@ -12,23 +12,27 @@
#ifndef L1Hit_h
#define L1Hit_h
-typedef unsigned /*short*/ int THitI; // hit index type
-typedef unsigned /*short*/ int TStripI; // strip index type
+using L1HitIndex_t = unsigned /*short*/ int; ///> Index of L1Hit
+using L1StripIndex_t = unsigned /*short*/ int; ///> Index of the station strip
+
+/// TODO: replace typedef with using (C++11) (S.Zharko)
+/// TODO: change naming: THitI -> L1HitIndex_t, TStripI -> L1StripIndex_t (S.Zharko)
+
///
/// L1Hit class describes a generic hit for CA tracker
///
struct L1Hit {
- TStripI f = 0; // front strip index
- TStripI b = 0; // back strip index
- float u = 0.f; // measured U coordinate
- float v = 0.f; // measured V coordinate
- float t = 0.f; // measured time
- float z = 0.f; // fixed Z coordinate
- float du = 0.f; // mean squared error of u
- float dv = 0.f; // mean squared error of v
- float dt = 0.f; // mean squared error of t
- int ID = 0; // TODO: check if this ID is redundant
+ L1StripIndex_t f {0}; ///> front strip index
+ L1StripIndex_t b {0}; ///> back strip index
+ float u {0.f}; ///> measured U coordinate
+ float v {0.f}; ///> measured V coordinate
+ float t {0.f}; ///> measured time
+ float z {0.f}; ///> fixed Z coordinate
+ float du {0.f}; ///> mean squared error of u
+ float dv {0.f}; ///> mean squared error of v
+ float dt {0.f}; ///> mean squared error of t
+ int ID {0}; ///> TODO: check if this ID is redundant
};
#endif
diff --git a/reco/L1/L1Algo/L1HitArea.h b/reco/L1/L1Algo/L1HitArea.h
index 6d3fda118c9e1859c92b13ff3f23956953422b28..ea8f248147fe54358fbf9949647853394bd14cf8 100644
--- a/reco/L1/L1Algo/L1HitArea.h
+++ b/reco/L1/L1Algo/L1HitArea.h
@@ -19,7 +19,7 @@ public:
* look up the next hit in the requested area.
* Sets h to the coordinates and returns the index for the hit data
*/
- bool GetNext(THitI& i);
+ bool GetNext(L1HitIndex_t& i);
protected:
const L1Grid& fGrid;
@@ -28,8 +28,8 @@ protected:
unsigned short fBDY; // Y distance of bin indexes
unsigned int fIndYmin; // minimum index for
unsigned short fIz; // current Z bin index (incremented while iterating)
- THitI fHitYlst; // last possible hit index in current z-line
- THitI fIh; // hit index iterating inside the bins
+ L1HitIndex_t fHitYlst; // last possible hit index in current z-line
+ L1HitIndex_t fIh; // hit index iterating inside the bins
int fNy; // Number of bins in Y direction
};
@@ -64,7 +64,7 @@ inline L1HitArea::L1HitArea(const L1Grid& grid, float y, float z, float dy, floa
fHitYlst = fGrid.FirstHitInBin(fIndYmin + fBDY);
}
-inline bool L1HitArea::GetNext(THitI& i)
+inline bool L1HitArea::GetNext(L1HitIndex_t& i)
{
bool yIndexOutOfRange = fIh >= fHitYlst; // current y is not in the area
bool nextZIndexOutOfRange = (fIz >= fBZmax); // there isn't any new z-line
@@ -105,7 +105,7 @@ public:
* look up the next hit in the requested area.
* Sets h to the coordinates and returns the index for the hit data
*/
- bool GetNext(THitI& i);
+ bool GetNext(L1HitIndex_t& i);
protected:
const L1Grid& fGrid;
@@ -114,8 +114,8 @@ protected:
unsigned short fBDY; // Y distance of bin indexes
unsigned int fIndYmin; // minimum index for
unsigned short fIz; // current Z bin index (incremented while iterating)
- THitI fHitYlst; // last possible hit index in current z-line
- THitI fIh; // hit index iterating inside the bins
+ L1HitIndex_t fHitYlst; // last possible hit index in current z-line
+ L1HitIndex_t fIh; // hit index iterating inside the bins
int fNy; // Number of bins in Y direction
int fNz;
@@ -176,7 +176,7 @@ inline L1HitAreaTime::L1HitAreaTime(const L1Grid& grid, float y, float z, float
fHitYlst = fGrid.FirstHitInBin(fIndYmin + fBDY);
}
-inline bool L1HitAreaTime::GetNext(THitI& i)
+inline bool L1HitAreaTime::GetNext(L1HitIndex_t& i)
{
bool yIndexOutOfRange = fIh >= fHitYlst; // current y is not in the area
bool nextZIndexOutOfRange = (fIz >= fBZmax); // there isn't any new z-line
diff --git a/reco/L1/L1Algo/L1HitsSortHelper.cxx b/reco/L1/L1Algo/L1HitsSortHelper.cxx
index a0af17682b81969de1c84de86477554abeb449c0..8e2f7e9433b9f1a46b85ab9cf92bdc3731b30e7b 100644
--- a/reco/L1/L1Algo/L1HitsSortHelper.cxx
+++ b/reco/L1/L1Algo/L1HitsSortHelper.cxx
@@ -13,8 +13,8 @@
using std::vector;
-L1HitsSortHelper::L1HitsSortHelper(vector<L1Hit>& hits, vector<L1HitPoint>& points, vector<THitI>& indices,
- const L1Grid* grid, THitI* iStart, THitI* iStop, int nStations, int nDontUsedHits)
+L1HitsSortHelper::L1HitsSortHelper(vector<L1Hit>& hits, vector<L1HitPoint>& points, vector<L1HitIndex_t>& indices,
+ const L1Grid* grid, L1HitIndex_t* iStart, L1HitIndex_t* iStop, int nStations, int nDontUsedHits)
: fD()
, fHits(hits)
, fPoints(points)
@@ -30,7 +30,7 @@ L1HitsSortHelper::L1HitsSortHelper(vector<L1Hit>& hits, vector<L1HitPoint>& poin
fD.resize(NHits);
//float x,y=0;
for (int iS = 0; iS < fNStations; ++iS)
- for (THitI i = fStsHitsUnusedStartIndex[iS]; i < fStsHitsUnusedStopIndex[iS]; i++) {
+ for (L1HitIndex_t i = fStsHitsUnusedStartIndex[iS]; i < fStsHitsUnusedStopIndex[iS]; i++) {
fD[i].h = &(hits[i]);
fD[i].p = &(points[i]);
fD[i].i = indices[i];
diff --git a/reco/L1/L1Algo/L1HitsSortHelper.h b/reco/L1/L1Algo/L1HitsSortHelper.h
index 554a324cf09c2a69aa06001873ac675ac4868754..6461be2cab9d8e5bb6ac591d1fcc50c078d68d3b 100644
--- a/reco/L1/L1Algo/L1HitsSortHelper.h
+++ b/reco/L1/L1Algo/L1HitsSortHelper.h
@@ -18,7 +18,7 @@ struct L1HitsSortHelperData {
L1Hit* h;
L1HitPoint* p;
unsigned int bin;
- THitI i;
+ L1HitIndex_t i;
static bool compare(const L1HitsSortHelperData& a, const L1HitsSortHelperData& b)
{
@@ -28,8 +28,8 @@ struct L1HitsSortHelperData {
class L1HitsSortHelper {
public:
- L1HitsSortHelper(vector<L1Hit>& hits, vector<L1HitPoint>& points, vector<THitI>& indices, const L1Grid* grid,
- THitI* iStart, THitI* iStop, int nStations, int nDontUsedHits);
+ L1HitsSortHelper(vector<L1Hit>& hits, vector<L1HitPoint>& points, vector<L1HitIndex_t>& indices, const L1Grid* grid,
+ L1HitIndex_t* iStart, L1HitIndex_t* iStop, int nStations, int nDontUsedHits);
void Sort();
@@ -37,9 +37,9 @@ private:
vector<L1HitsSortHelperData> fD;
vector<L1Hit>& fHits;
vector<L1HitPoint>& fPoints;
- vector<THitI>& fIndices;
+ vector<L1HitIndex_t>& fIndices;
const L1Grid* fGrid;
- THitI *fStsHitsUnusedStartIndex, *fStsHitsUnusedStopIndex;
+ L1HitIndex_t *fStsHitsUnusedStartIndex, *fStsHitsUnusedStopIndex;
int fNStations;
int fnDontUsedHits;
diff --git a/reco/L1/L1Algo/L1Station.cxx b/reco/L1/L1Algo/L1Station.cxx
index 24195990585b5be2e041992e793e1cb05066866b..c6ca03183b26dc9fc554c5ee4423015b8ea45d03 100644
--- a/reco/L1/L1Algo/L1Station.cxx
+++ b/reco/L1/L1Algo/L1Station.cxx
@@ -65,10 +65,13 @@ std::string L1Station::ToString(int verbosityLevel, int indentLevel) const
// TODO: probably we can have verbosity level and address for each underlying object (S.Zharko)
aStream << indent << "Address: " << this << '\n';
}
- aStream << indent << "Station type ID: " << std::setw(12) << std::setfill(' ') << type << '\n';
- aStream << indent << "If time info used: " << std::setw(12) << std::setfill(' ') << timeInfo << '\n';
- aStream << indent << "z position [cm]: " << std::setw(12) << std::setfill(' ') << z[0] << '\n';
- if (verbosityLevel > 0) {
+ if (verbosityLevel == 0) {
+ aStream << indent << "- L1Station {z [cm], typeID} = " << std::setw(12) << std::setfill(' ') << z[0] << ", " << std::setw(4) << std::setfill(' ') << type;
+ }
+ else {
+ aStream << indent << "Station type ID: " << std::setw(12) << std::setfill(' ') << type << '\n';
+ aStream << indent << "If time info used: " << std::setw(12) << std::setfill(' ') << timeInfo << '\n';
+ aStream << indent << "z position [cm]: " << std::setw(12) << std::setfill(' ') << z[0] << '\n';
aStream << indent << "Rmin [cm]: " << std::setw(12) << std::setfill(' ') << Rmin[0] << '\n';
aStream << indent << "Rmax [cm]: " << std::setw(12) << std::setfill(' ') << Rmax[0] << '\n';
aStream << materialInfo.ToString(indentLevel) << '\n';
diff --git a/reco/L1/L1Algo/L1TrackExtender.cxx b/reco/L1/L1Algo/L1TrackExtender.cxx
index 4917b915cd47079d6bfa9037696bd136af686375..8d3bde8615c31f6e0caf8344379849a10a7399e4 100644
--- a/reco/L1/L1Algo/L1TrackExtender.cxx
+++ b/reco/L1/L1Algo/L1TrackExtender.cxx
@@ -33,7 +33,7 @@ void L1Algo::BranchFitterFast(const L1Branch& t, L1TrackPar& T, const bool dir,
fit.SetParticleMass(GetDefaultParticleMass());
// get hits of current track
- const L1Vector<THitI>& hits = t.fStsHits; // array of indeses of hits of current track
+ const L1Vector<L1HitIndex_t>& hits = t.fStsHits; // array of indeses of hits of current track
const int nHits = t.NHits;
const signed short int step = -2 * static_cast<int>(dir) + 1; // increment for station index
@@ -196,7 +196,7 @@ void L1Algo::BranchFitter(const L1Branch& t, L1TrackPar& T, const bool dir, cons
void L1Algo::FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir,
const fvec qp0) // TODO take into account pipe
{
- L1Vector<THitI> newHits {"L1TrackExtender::newHits"};
+ L1Vector<L1HitIndex_t> newHits {"L1TrackExtender::newHits"};
newHits.reserve(NStations);
L1Fit fit;
fit.SetParticleMass(GetDefaultParticleMass());
@@ -275,7 +275,7 @@ void L1Algo::FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir,
(sqrt(fPickGather * (T.C11 + sta.XYInfo.C11)) + fMaxDZ * fabs(T.ty))[0] * iz, T.t[0],
sqrt(T.C55[0]));
- THitI ih = 0;
+ L1HitIndex_t ih = 0;
while (area.GetNext(ih)) {
ih += StsHitsUnusedStartIndex[ista];
diff --git a/reco/L1/L1Algo/L1Triplet.h b/reco/L1/L1Algo/L1Triplet.h
index a97b47f3649e05c28391a240867440e3b914b0cf..681ce98e15cca0d88acb264cb9adf863e1db3245 100644
--- a/reco/L1/L1Algo/L1Triplet.h
+++ b/reco/L1/L1Algo/L1Triplet.h
@@ -46,9 +46,9 @@ public:
void SetLevel(unsigned char Level) { fLevel = Level; }
unsigned char GetLevel() const { return fLevel; }
- THitI GetLHit() const { return fHitL; }
- THitI GetMHit() const { return fHitM; }
- THitI GetRHit() const { return fHitR; }
+ L1HitIndex_t GetLHit() const { return fHitL; }
+ L1HitIndex_t GetMHit() const { return fHitM; }
+ L1HitIndex_t GetRHit() const { return fHitR; }
void SetNNeighbours(char n) { fNneighbours = n; }
char GetNNeighbours() const { return fNneighbours; }
@@ -83,9 +83,9 @@ private:
fscal fCty = 0.f; // RMS of ty
unsigned int fFirstNeighbour = 0; // ID of the first neighbouring triplet
- THitI fHitL = 0; // left hit index (16b) in vStsHits array
- THitI fHitM = 0; // middle hit index (16b)
- THitI fHitR = 0; // right hit index (16b)
+ L1HitIndex_t fHitL = 0; // left hit index (16b) in vStsHits array
+ L1HitIndex_t fHitM = 0; // middle hit index (16b)
+ L1HitIndex_t fHitR = 0; // right hit index (16b)
char fNneighbours = 0; // n of neighbouring triplets
unsigned char fLevel = 0; // triplet level
// == its possible position on the longest track candidate it belongs to.
diff --git a/reco/L1/L1Algo/utils/L1AlgoDraw.cxx b/reco/L1/L1Algo/utils/L1AlgoDraw.cxx
index 5427fc419695e4a0987db16519e81f0429b04100..b83b8eeeacd2116a9b9eec700a0357884db94966 100644
--- a/reco/L1/L1Algo/utils/L1AlgoDraw.cxx
+++ b/reco/L1/L1Algo/utils/L1AlgoDraw.cxx
@@ -235,7 +235,7 @@ void L1AlgoDraw::DrawRecoTracks()
// CbmL1 &L1 = *CbmL1::Instance();
int curRecoHit = 0;
- L1Vector<THitI>& recoHits = algo->fRecoHits;
+ L1Vector<L1HitIndex_t>& recoHits = algo->fRecoHits;
for (vector<L1Track>::iterator it = algo->fTracks.begin(); it != algo->fTracks.end(); ++it) {
L1Track& T = *it;
int nHits = T.NHits;
@@ -300,7 +300,7 @@ void L1AlgoDraw::DrawRecoTracks()
XYZ->Update();
}
-void L1AlgoDraw::DrawTriplets(vector<L1Triplet>& triplets, const THitI* realIHit)
+void L1AlgoDraw::DrawTriplets(vector<L1Triplet>& triplets, const L1HitIndex_t* realIHit)
{
// vector <L1Triplet> triplets = algo->vTriplets;
for (unsigned int iTrip = 0; iTrip < triplets.size(); iTrip++) {
@@ -364,14 +364,14 @@ void L1AlgoDraw::DrawTriplet(int il, int im, int ir)
marker.DrawMarker(lx[nHits - 1], ly[nHits - 1]);
}
-void L1AlgoDraw::DrawDoublets(vector<THitI>* Duplets_hits, map<THitI, THitI>* Duplets_start, const int /*MaxArrSize*/,
- THitI* StsRestHitsStartIndex, unsigned int* realIHit)
+void L1AlgoDraw::DrawDoublets(vector<L1HitIndex_t>* Duplets_hits, map<L1HitIndex_t, L1HitIndex_t>* Duplets_start, const int /*MaxArrSize*/,
+ L1HitIndex_t* StsRestHitsStartIndex, unsigned int* realIHit)
{
for (int iSta = 0; iSta < NStations - 1; iSta++) {
const int firstHitOnSta = StsRestHitsStartIndex[iSta];
const int firstHitOnNextSta = StsRestHitsStartIndex[iSta + 1];
- THitI* staDupletsHits = &(Duplets_hits[iSta][0]);
- map<THitI, THitI>& staDupletsStart = Duplets_start[iSta];
+ L1HitIndex_t* staDupletsHits = &(Duplets_hits[iSta][0]);
+ map<L1HitIndex_t, L1HitIndex_t>& staDupletsStart = Duplets_start[iSta];
for (int iRestLHit = firstHitOnSta; iRestLHit < firstHitOnNextSta; iRestLHit++) {
const int ilh = iRestLHit - firstHitOnSta;
@@ -397,13 +397,13 @@ void L1AlgoDraw::DrawDoublets(vector<THitI>* Duplets_hits, map<THitI, THitI>* Du
YX->Update();
};
-void L1AlgoDraw::DrawDoubletsOnSta(int iSta, THitI* Duplets_hits, THitI* Duplets_start, const int MaxArrSize,
- THitI* StsRestHitsStartIndex, unsigned int* realIHit)
+void L1AlgoDraw::DrawDoubletsOnSta(int iSta, L1HitIndex_t* Duplets_hits, L1HitIndex_t* Duplets_start, const int MaxArrSize,
+ L1HitIndex_t* StsRestHitsStartIndex, unsigned int* realIHit)
{
const int firstHitOnSta = StsRestHitsStartIndex[iSta];
const int firstHitOnNextSta = StsRestHitsStartIndex[iSta + 1];
- THitI* staDupletsHits = Duplets_hits + MaxArrSize * iSta;
- THitI* staDupletsStart = Duplets_start + MaxArrSize * iSta;
+ L1HitIndex_t* staDupletsHits = Duplets_hits + MaxArrSize * iSta;
+ L1HitIndex_t* staDupletsStart = Duplets_start + MaxArrSize * iSta;
for (int iRestLHit = firstHitOnSta; iRestLHit < firstHitOnNextSta; iRestLHit++) {
const int ilh = iRestLHit - firstHitOnSta;
@@ -659,7 +659,7 @@ void L1AlgoDraw::DrawInputHits()
} // DrawInputHits
-void L1AlgoDraw::DrawRestHits(THitI* StsRestHitsStartIndex, THitI* StsRestHitsStopIndex, unsigned int* realIHit)
+void L1AlgoDraw::DrawRestHits(L1HitIndex_t* StsRestHitsStartIndex, L1HitIndex_t* StsRestHitsStopIndex, unsigned int* realIHit)
{
TLatex latex;
@@ -687,7 +687,7 @@ void L1AlgoDraw::DrawRestHits(THitI* StsRestHitsStartIndex, THitI* StsRestHitsSt
L1Station& st = vStations[ista];
Int_t n_poly = 0;
Int_t n_poly_fake = 0;
- for (THitI iRestHit = StsRestHitsStartIndex[ista]; iRestHit < StsRestHitsStopIndex[ista]; iRestHit++) {
+ for (L1HitIndex_t iRestHit = StsRestHitsStartIndex[ista]; iRestHit < StsRestHitsStopIndex[ista]; iRestHit++) {
int ih = realIHit[iRestHit];
L1Hit& h = vStsHits[ih];
int iMC = CbmL1::Instance()->vHitMCRef[ih];
diff --git a/reco/L1/L1Algo/utils/L1AlgoDraw.h b/reco/L1/L1Algo/utils/L1AlgoDraw.h
index bd678b94c4b996c9535d7377f5c9a0c04e2635cf..5a42880723a5efab4cd9d52de50800b8942918ad 100644
--- a/reco/L1/L1Algo/utils/L1AlgoDraw.h
+++ b/reco/L1/L1Algo/utils/L1AlgoDraw.h
@@ -31,15 +31,15 @@ public:
void DrawMCTracks();
void DrawRecoTracks();
- void DrawTriplets(std::vector<L1Triplet>& triplets, const THitI* realIHit);
- void DrawDoublets(std::vector<THitI>* Duplets_hits, std::map<THitI, THitI>* Duplets_start, const int MaxArrSize,
- THitI* StsHitsStartIndex, unsigned int* realIHit);
- void DrawDoubletsOnSta(int iSta, THitI* Duplets_hits, THitI* Duplets_start, const int MaxArrSize,
- THitI* StsRestHitsStartIndex, unsigned int* realIHit);
+ void DrawTriplets(std::vector<L1Triplet>& triplets, const L1HitIndex_t* realIHit);
+ void DrawDoublets(std::vector<L1HitIndex_t>* Duplets_hits, std::map<L1HitIndex_t, L1HitIndex_t>* Duplets_start, const int MaxArrSize,
+ L1HitIndex_t* StsHitsStartIndex, unsigned int* realIHit);
+ void DrawDoubletsOnSta(int iSta, L1HitIndex_t* Duplets_hits, L1HitIndex_t* Duplets_start, const int MaxArrSize,
+ L1HitIndex_t* StsRestHitsStartIndex, unsigned int* realIHit);
void DrawTarget();
void DrawInputHits(); // draw all hits, which TF have gotten
- void DrawRestHits(THitI* StsRestHitsStartIndex, THitI* StsRestHitsStopIndex,
+ void DrawRestHits(L1HitIndex_t* StsRestHitsStartIndex, L1HitIndex_t* StsRestHitsStopIndex,
unsigned int* realIHit); // draw only hits which leave on current iteration.
void DrawInfo();
diff --git a/reco/L1/L1Algo/utils/L1AlgoEfficiencyPerformance.h b/reco/L1/L1Algo/utils/L1AlgoEfficiencyPerformance.h
index dc62da303a2e1ed3dd52837a4b4444cd926240fe..7e7625e509d3fb51e7471c3d4d25be1f38e9ed6d 100644
--- a/reco/L1/L1Algo/utils/L1AlgoEfficiencyPerformance.h
+++ b/reco/L1/L1Algo/utils/L1AlgoEfficiencyPerformance.h
@@ -49,7 +49,7 @@ template<int NHits>
class L1RTracklet : public L1Tracklet<NHits> {
public:
L1RTracklet() = default;
- L1RTracklet(THitI* ih_) : L1Tracklet<NHits>()
+ L1RTracklet(L1HitIndex_t* ih_) : L1Tracklet<NHits>()
{
for (int iih = 0; iih < NHits; iih++) {
i[iih] = ih_[iih];
@@ -71,7 +71,7 @@ public:
}
bool operator!=(const L1RTracklet<NHits>& a) { return !operator==(a); }
- THitI i[NHits] {0}; // indices of left, middle and right hits
+ L1HitIndex_t i[NHits] {0}; // indices of left, middle and right hits
};
// MC Tracklet
@@ -120,7 +120,7 @@ public:
L1AlgoEfficiencyPerformance() = default;
void Init();
- bool AddOne(THitI* ih_); // add one recoTracklets. Return is it reconstructed or not
+ bool AddOne(L1HitIndex_t* ih_); // add one recoTracklets. Return is it reconstructed or not
void CalculateEff();
void Print(); // Print efficiencies
void Print(TString title = "Triplets performance statistic",
@@ -215,7 +215,7 @@ void L1AlgoEfficiencyPerformance<NHits>::FillMC()
template<int NHits>
-bool L1AlgoEfficiencyPerformance<NHits>::AddOne(THitI* iHits)
+bool L1AlgoEfficiencyPerformance<NHits>::AddOne(L1HitIndex_t* iHits)
{
L1RecoTracklet trlet(iHits);
@@ -264,7 +264,7 @@ bool L1AlgoEfficiencyPerformance<NHits>::AddOne(THitI* iHits)
recoTracklets.push_back(trlet);
return (trlet.mcTrackId >= 0);
-}; // inline bool L1AlgoEfficiencyPerformance::AddOne(THitI ihl, THitI ihm, THitI ihr)
+}; // inline bool L1AlgoEfficiencyPerformance::AddOne(L1HitIndex_t ihl, L1HitIndex_t ihm, L1HitIndex_t ihr)
template<int NHits>
diff --git a/reco/L1/L1Algo/utils/L1AlgoPulls.cxx b/reco/L1/L1Algo/utils/L1AlgoPulls.cxx
index 39a19f0348116fe678cc0feed389b7bebfeff5ba..a3e5707935ae0dd13035bf19c7e3866fa2d28997 100644
--- a/reco/L1/L1Algo/utils/L1AlgoPulls.cxx
+++ b/reco/L1/L1Algo/utils/L1AlgoPulls.cxx
@@ -99,13 +99,13 @@ void L1AlgoPulls::Init()
}
};
-// void L1AlgoPulls::AddVec(L1TrackPar& T_, THitI ih)
+// void L1AlgoPulls::AddVec(L1TrackPar& T_, L1HitIndex_t ih)
// {
// for (int i = 0; i < fvecLen; i++)
// AddOne(T_,i,ih);
// }
-void L1AlgoPulls::AddOne(L1TrackPar& T_, int i, THitI ih)
+void L1AlgoPulls::AddOne(L1TrackPar& T_, int i, L1HitIndex_t ih)
{
fNAllPulls++;
TL1TrackParameters T(T_, i);
diff --git a/reco/L1/L1Algo/utils/L1AlgoPulls.h b/reco/L1/L1Algo/utils/L1AlgoPulls.h
index 46065b8b284cbd57b1881d39af50c4ebc7830dfd..452f9c7114677108ecb12af8347231dbde37989c 100644
--- a/reco/L1/L1Algo/utils/L1AlgoPulls.h
+++ b/reco/L1/L1Algo/utils/L1AlgoPulls.h
@@ -83,8 +83,8 @@ public:
void Init();
- // void AddVec(L1TrackPar& T, THitI ih);
- void AddOne(L1TrackPar& T, int i, THitI ih);
+ // void AddVec(L1TrackPar& T, L1HitIndex_t ih);
+ void AddOne(L1TrackPar& T, int i, L1HitIndex_t ih);
void Print(); // fast method to see pulls :)
void Build(bool draw = 1);
diff --git a/reco/L1/L1AlgoInputData.cxx b/reco/L1/L1AlgoInputData.cxx
index cd782e207be131610bc9b8ecad797c167008e987..6b9e035a8efe3e9b18cac6e2faf4cd9e1ea1b1d0 100644
--- a/reco/L1/L1AlgoInputData.cxx
+++ b/reco/L1/L1AlgoInputData.cxx
@@ -29,8 +29,8 @@ void L1AlgoInputData::SetData( const vector< L1Hit > & StsHits_,
const vector< L1Strip > & StsStripsB_,
const vector< unsigned char > & SFlag_,
const vector< unsigned char > & SFlagB_,
- const THitI* StsHitsStartIndex_,
- const THitI* StsHitsStopIndex_ )
+ const L1HitIndex_t* StsHitsStartIndex_,
+ const L1HitIndex_t* StsHitsStopIndex_ )
{
vStsHits.resize(StsHits_.size());
vStsStrips.resize(StsStrips_.size());
@@ -126,8 +126,8 @@ bool L1AlgoInputData::ReadHitsFromFile(const char work_dir[100], const int maxNE
for (int i = 0; i < n; i++) {
L1Hit element;
fadata >> element_f >> element_b >> element_n >> element.z >> element.u >> element.v >> element.t;
- element.f = static_cast<THitI>(element_f);
- element.b = static_cast<THitI>(element_b);
+ element.f = static_cast<L1HitIndex_t>(element_f);
+ element.b = static_cast<L1HitIndex_t>(element_b);
#ifdef USE_EVENT_NUMBER
element.n = static_cast<unsigned short int>(element_n);
#endif
diff --git a/reco/L1/L1AlgoInputData.h b/reco/L1/L1AlgoInputData.h
index 9e78094dab44cab2f6c8eb8e5002d92fb5fb61ff..0de39001886091ac4611c60292f956b4c2d60a5a 100644
--- a/reco/L1/L1AlgoInputData.h
+++ b/reco/L1/L1AlgoInputData.h
@@ -21,8 +21,8 @@ public:
L1Vector<L1Hit>& GetStsHits() { return vStsHits; }
int GetNStsStrips() const { return NStsStrips; }
L1Vector<unsigned char>& GetSFlag() { return fStripFlag; }
- const THitI* GetStsHitsStartIndex() const { return StsHitsStartIndex; }
- const THitI* GetStsHitsStopIndex() const { return StsHitsStopIndex; }
+ const L1HitIndex_t* GetStsHitsStartIndex() const { return StsHitsStartIndex; }
+ const L1HitIndex_t* GetStsHitsStopIndex() const { return StsHitsStopIndex; }
bool ReadHitsFromFile(const char work_dir[100], const int maxNEvent, const int iVerbose);
@@ -71,8 +71,8 @@ public:
L1Vector<unsigned char> fStripFlag {
"L1AlgoInputData::fStripFlag"}; // information of hits station & used hits in tracks;
- THitI StsHitsStartIndex[MaxNStations + 1] {0}; // station-bounders in vStsHits array
- THitI StsHitsStopIndex[MaxNStations + 1] {0}; // station-bounders in vStsHits array
+ L1HitIndex_t StsHitsStartIndex[MaxNStations + 1] {0}; // station-bounders in vStsHits array
+ L1HitIndex_t StsHitsStopIndex[MaxNStations + 1] {0}; // station-bounders in vStsHits array
} _fvecalignment;