diff --git a/reco/L1/CbmL1.cxx b/reco/L1/CbmL1.cxx
index ca112aaf356e5fe5e78c1973ca5d59d18a7e828e..1f32cc5d8ca9f74df2aacb311830108e20715d81 100644
--- a/reco/L1/CbmL1.cxx
+++ b/reco/L1/CbmL1.cxx
@@ -994,6 +994,7 @@ InitStatus CbmL1::Init()
trackingIterFastPrim.SetMaxInvMom(1.0 / 0.5);
trackingIterFastPrim.SetMaxSlopePV(1.1f);
trackingIterFastPrim.SetMaxSlope(2.748f);
+ trackingIterFastPrim.SetMaxDZ(0);
auto trackingIterAllPrim = L1CAIteration("AllPrimIter");
trackingIterAllPrim.SetTrackChi2Cut(10.f);
@@ -1004,6 +1005,7 @@ InitStatus CbmL1::Init()
trackingIterAllPrim.SetMaxInvMom(1.0 / 0.05);
trackingIterAllPrim.SetMaxSlopePV(1.1f);
trackingIterAllPrim.SetMaxSlope(2.748f);
+ trackingIterAllPrim.SetMaxDZ(0.1);
auto trackingIterFastPrim2 = L1CAIteration("FastPrim2Iter");
trackingIterFastPrim2.SetTrackChi2Cut(10.f);
@@ -1014,6 +1016,7 @@ InitStatus CbmL1::Init()
trackingIterFastPrim2.SetMaxInvMom(1.0 / 0.5);
trackingIterFastPrim2.SetMaxSlopePV(1.1f);
trackingIterFastPrim2.SetMaxSlope(2.748f);
+ trackingIterFastPrim2.SetMaxDZ(0);
auto trackingIterAllSec = L1CAIteration("AllSecIter");
trackingIterAllSec.SetTrackChi2Cut(10.f);
@@ -1024,6 +1027,7 @@ InitStatus CbmL1::Init()
trackingIterAllSec.SetMaxInvMom(1.0 / 0.1);
trackingIterAllSec.SetMaxSlopePV(1.5f);
trackingIterAllSec.SetMaxSlope(2.748f);
+ trackingIterAllSec.SetMaxDZ(0.1);
auto trackingIterFastPrimJump = L1CAIteration("FastPrimJumpIter");
trackingIterFastPrimJump.SetTrackChi2Cut(10.f);
@@ -1034,6 +1038,7 @@ InitStatus CbmL1::Init()
trackingIterFastPrimJump.SetMaxInvMom(1.0 / 0.5);
trackingIterFastPrimJump.SetMaxSlopePV(1.1f);
trackingIterFastPrimJump.SetMaxSlope(2.748f);
+ trackingIterFastPrimJump.SetMaxDZ(0);
auto trackingIterAllPrimJump = L1CAIteration("AllPrimJumpIter");
trackingIterAllPrimJump.SetTrackChi2Cut(10.f);
@@ -1044,6 +1049,7 @@ InitStatus CbmL1::Init()
trackingIterAllPrimJump.SetMaxInvMom(1.0 / 0.1);
trackingIterAllPrimJump.SetMaxSlopePV(1.1f);
trackingIterAllPrimJump.SetMaxSlope(2.748f);
+ trackingIterAllPrimJump.SetMaxDZ(0.1);
auto trackingIterAllSecJump = L1CAIteration("AllSecJumpIter");
trackingIterAllSecJump.SetTrackChi2Cut(10.f);
@@ -1054,6 +1060,7 @@ InitStatus CbmL1::Init()
trackingIterAllSecJump.SetMaxInvMom(1.0 / 0.1);
trackingIterAllSecJump.SetMaxSlopePV(1.5f);
trackingIterAllSecJump.SetMaxSlope(2.748f);
+ trackingIterAllSecJump.SetMaxDZ(0.1);
auto trackingIterAllPrimE = L1CAIteration("AllPrimEIter");
trackingIterAllPrimE.SetTrackChi2Cut(10.f);
@@ -1064,6 +1071,7 @@ InitStatus CbmL1::Init()
trackingIterAllPrimE.SetMaxInvMom(1.0 / 0.05);
trackingIterAllPrimE.SetMaxSlopePV(1.1f);
trackingIterAllPrimE.SetMaxSlope(2.748f);
+ trackingIterAllPrimE.SetMaxDZ(0.1);
auto trackingIterAllSecE = L1CAIteration("AllSecEIter");
trackingIterAllSecE.SetTrackChi2Cut(10.f);
@@ -1074,6 +1082,7 @@ InitStatus CbmL1::Init()
trackingIterAllSecE.SetMaxInvMom(1.0 / 0.05);
trackingIterAllSecE.SetMaxSlopePV(1.5f);
trackingIterAllSecE.SetMaxSlope(2.748f);
+ trackingIterAllSecE.SetMaxDZ(0.1);
// Select default track finder
if (fTrackingMode == L1Algo::TrackingMode::kMcbm) {
diff --git a/reco/L1/L1Algo/L1Algo.h b/reco/L1/L1Algo/L1Algo.h
index b80d01f9c5c73902f3b5a79f381d53b6f65042fa..52cb703c50972161985c6e02044ab3f08d8000ad 100644
--- a/reco/L1/L1Algo/L1Algo.h
+++ b/reco/L1/L1Algo/L1Algo.h
@@ -206,7 +206,7 @@ public:
void L1KFTrackFitterMuch();
- float GetMaxInvMom() const { return MaxInvMom[0]; }
+ float GetMaxInvMom() const { return fMaxInvMom[0]; }
/// ----- Input data -----
// filled in CbmL1::ReadEvent();
@@ -647,24 +647,25 @@ private:
map<int, int> threadNumberToCpuMap {};
+ /// TODO: move to separate header with predefined utility values (S.Zharko)
static constexpr float kNaN {std::numeric_limits<float>::signaling_NaN()};
- float TRACK_CHI2_CUT {10.f};
- float TRIPLET_CHI2_CUT {5.f}; // cut for selecting triplets before collecting tracks.per one DoF
- float DOUBLET_CHI2_CUT {5.f};
- float TIME_CUT1 {0.f};
- float TIME_CUT2 {0.f};
+ float fTrackChi2Cut {10.f};
+ float fTripletChi2Cut {5.f}; // cut for selecting triplets before collecting tracks.per one DoF
+ float fDoubletChi2Cut {5.f};
+ float fTimeCut1 {0.f}; // TODO: please, specify "1" and "2" (S.Zharko)
+ float fTimeCut2 {0.f};
- fvec MaxDZ {
- kNaN}; // correction in order to take into account overlaping and iff z. if sort by y then it is max diff between same station's modules (~0.4cm)
+ /// correction in order to take into account overlaping and iff z. if sort by y then it is max diff between same station's modules (~0.4cm)
+ fvec fMaxDZ {kNaN};
/// parameters which are different for different iterations. Set in the begin of CAL1TrackFinder
- float Pick_gather {kNaN}; // same for attaching additional hits to track
- float PickNeighbour {kNaN}; // (PickNeighbour < dp/dp_error) => triplets are neighbours
- fvec MaxInvMom {kNaN}; // max considered q/p for tracks
- fvec MaxSlopePV {kNaN}; // max slope (tx\ty) in prim vertex
- float MaxSlope {kNaN}; // max slope (tx\ty) in 3d hit position of a triplet
+ float fPickGather {kNaN}; // same for attaching additional hits to track
+ float fPickNeighbour {kNaN}; // (fPickNeighbour < dp/dp_error) => triplets are neighbours
+ fvec fMaxInvMom {kNaN}; // max considered q/p for tracks
+ fvec fMaxSlopePV {kNaN}; // max slope (tx\ty) in prim vertex
+ float fMaxSlope {kNaN}; // max slope (tx\ty) in 3d hit position of a triplet
fvec fCbmTargetX {kNaN}; // target position
fvec fCbmTargetY {kNaN};
fvec fCbmTargetZ {kNaN};
diff --git a/reco/L1/L1Algo/L1Assert.h b/reco/L1/L1Algo/L1Assert.h
index ae7080d1bfe44fb023471df7494b675d92db5dd3..b91eacf34c67ff161f3a4727223db2f80561d453 100644
--- a/reco/L1/L1Algo/L1Assert.h
+++ b/reco/L1/L1Algo/L1Assert.h
@@ -46,7 +46,7 @@ namespace L1Assert
<< " ***** message/condition : " << msg << '\n'
<< " ***** file: " << fileName << '\n'
<< " ***** line: " << lineNo;
- std::abort(); // keep it here, because sometimes LOG(fatal) does not work (for example, in your tester)
+ std::abort(); // keep it here, because sometimes LOG(fatal) does not work (for example, in your unit testes)
}
return 1;
}
diff --git a/reco/L1/L1Algo/L1CAIteration.cxx b/reco/L1/L1Algo/L1CAIteration.cxx
index 9bd07054db86b0c50157327093f62e76af39d591..647f7956a40974b7be334b2a8a1240c5d73cbc36 100644
--- a/reco/L1/L1Algo/L1CAIteration.cxx
+++ b/reco/L1/L1Algo/L1CAIteration.cxx
@@ -6,13 +6,11 @@
#include <FairLogger.h>
-//----------------------------------------------------------------------------------------------------------------------
-//
-L1CAIteration::L1CAIteration() noexcept { LOG(debug) << "L1CAIteration: Default constructor called for " << this; }
+#include <sstream>
//----------------------------------------------------------------------------------------------------------------------
//
-L1CAIteration::~L1CAIteration() noexcept { LOG(debug) << "L1CAIteration: Destructor called for " << this; }
+L1CAIteration::L1CAIteration() noexcept { LOG(debug) << "L1CAIteration: Default constructor called for " << this; }
//----------------------------------------------------------------------------------------------------------------------
//
@@ -28,6 +26,7 @@ L1CAIteration::L1CAIteration(const L1CAIteration& other) noexcept
, fMaxInvMom(other.fMaxInvMom)
, fMaxSlopePV(other.fMaxSlopePV)
, fMaxSlope(other.fMaxSlope)
+ , fMaxDZ(other.fMaxDZ)
{
LOG(debug) << "L1CAIteration: Copy constructor called: " << &other << " was copied into " << this;
}
@@ -40,6 +39,17 @@ L1CAIteration::L1CAIteration(L1CAIteration&& other) noexcept
LOG(debug) << "L1CAIteration: Move constructor called: " << &other << " was moved into " << this;
}
+//----------------------------------------------------------------------------------------------------------------------
+//
+L1CAIteration::L1CAIteration(const std::string& name) noexcept : fName(name)
+{
+ LOG(debug) << "L1CAIteration: Constructor from name called for " << this;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+L1CAIteration::~L1CAIteration() noexcept { LOG(debug) << "L1CAIteration: Destructor called for " << this; }
+
//----------------------------------------------------------------------------------------------------------------------
//
L1CAIteration& L1CAIteration::operator=(const L1CAIteration& other) noexcept
@@ -61,6 +71,14 @@ L1CAIteration& L1CAIteration::operator=(L1CAIteration&& other) noexcept
return *this;
}
+//----------------------------------------------------------------------------------------------------------------------
+//
+void L1CAIteration::Print(int verbosityLevel) const
+{
+ if (verbosityLevel == 0) { LOG(info) << " - " << fName; }
+ if (verbosityLevel > 0) { LOG(info) << ToString(0); }
+}
+
//----------------------------------------------------------------------------------------------------------------------
//
void L1CAIteration::Swap(L1CAIteration& other) noexcept
@@ -76,29 +94,25 @@ void L1CAIteration::Swap(L1CAIteration& other) noexcept
std::swap(fMaxInvMom, other.fMaxInvMom);
std::swap(fMaxSlopePV, other.fMaxSlopePV);
std::swap(fMaxSlope, other.fMaxSlope);
+ std::swap(fMaxDZ, other.fMaxDZ);
}
//----------------------------------------------------------------------------------------------------------------------
//
-L1CAIteration::L1CAIteration(const std::string& name) noexcept : fName(name)
-{
- LOG(debug) << "L1CAIteration: Constructor from name called for " << this;
-}
-
-//----------------------------------------------------------------------------------------------------------------------
-//
-void L1CAIteration::Print(int verbosityLevel) const
+std::string L1CAIteration::ToString(int indentLevel) const
{
- if (verbosityLevel == 0) { LOG(info) << " - " << fName; }
- if (verbosityLevel > 0) {
- LOG(info) << "L1CAIteration: " << fName;
- LOG(info) << "\tTrack chi2 cut: " << fTrackChi2Cut;
- LOG(info) << "\tTriplet chi2 cut: " << fTripletChi2Cut;
- LOG(info) << "\tDoublet chi2 cut: " << fDoubletChi2Cut;
- LOG(info) << "\tPick gather: " << fPickGather;
- LOG(info) << "\tPick neighbour: " << fPickNeighbour;
- LOG(info) << "\tMax invariant momentum: " << fMaxInvMom;
- LOG(info) << "\tMax slope at primary vertex: " << fMaxSlopePV;
- LOG(info) << "\tMax slope: " << fMaxSlope;
- }
+ std::stringstream aStream {};
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << indent << "L1CAIteration: " << fName << '\n';
+ aStream << indent << indentChar << "Track chi2 cut: " << fTrackChi2Cut << '\n';
+ aStream << indent << indentChar << "Triplet chi2 cut: " << fTripletChi2Cut << '\n';
+ aStream << indent << indentChar << "Doublet chi2 cut: " << fDoubletChi2Cut << '\n';
+ aStream << indent << indentChar << "Pick gather: " << fPickGather << '\n';
+ aStream << indent << indentChar << "Pick neighbour: " << fPickNeighbour << '\n';
+ aStream << indent << indentChar << "Max invariant momentum: " << fMaxInvMom << '\n';
+ aStream << indent << indentChar << "Max slope at primary vertex: " << fMaxSlopePV << '\n';
+ aStream << indent << indentChar << "Max slope: " << fMaxSlope << '\n';
+ aStream << indent << indentChar << "Max DZ: " << fMaxDZ;
+ return aStream.str();
}
diff --git a/reco/L1/L1Algo/L1CAIteration.h b/reco/L1/L1Algo/L1CAIteration.h
index 372f12d163a6fc0e758413ab4a3ebf609144a6df..8f8fa7ad7182c6dc7d6b8b7799dfc5025e063c5b 100644
--- a/reco/L1/L1Algo/L1CAIteration.h
+++ b/reco/L1/L1Algo/L1CAIteration.h
@@ -14,142 +14,96 @@
#include <string>
-/// All possible iteration types of Track Finder algorithm to select
+/// Class L1CAIteration describes L1 Track finder iteration. Each iteration contains specific cuts and special
+/// flags.
///
-//enum class L1CAIterationType; // definition in CbmL1/BmnL1
-//{
-// kFastPrim, ///< primary fast tracks
-// kAllPrim, ///< primary all tracks
-// kAllPrimJump, ///< primary all tracks with jumped triplets
-// kAllSec, ///< secondary all tracks
-// kAllPrimE, ///< primary all electron tracks
-// kAllSecE, ///< secondary all electron tracks
-// kFastPrimJump, ///< primary fast tracks with jumped triplets
-// kAllSecJump, ///< secondary all tracks with jumped triplets
-// kEND ///< dummy item, represents number of iterations
-//};
-
-// TODO: insert names into separate structure
-
-/// Class describes L1 Track finder iteration
-///
-/// The class contains different for
class L1CAIteration {
public:
/// Default constructor
L1CAIteration() noexcept;
- /// Destructor
- ~L1CAIteration() noexcept;
/// Copy constructor
L1CAIteration(const L1CAIteration& other) noexcept;
/// Move constructor
L1CAIteration(L1CAIteration&& other) noexcept;
+ /// Constructor from L1CAIteration type
+ L1CAIteration(const std::string& name) noexcept;
+ /// Destructor
+ ~L1CAIteration() noexcept;
/// Copy operator=
L1CAIteration& operator=(const L1CAIteration& other) noexcept;
/// Move operator=
L1CAIteration& operator=(L1CAIteration&& other) noexcept;
- /// Constructor from L1CAIteration type
- L1CAIteration(const std::string& name) noexcept;
- /// Swap method
- void Swap(L1CAIteration& other) noexcept;
- //
- // BASIC METHODS
- //
+ /// Gets doublet chi2 upper cut
+ float GetDoubletChi2Cut() const { return fDoubletChi2Cut; }
+ ///
+ float GetMaxDZ() const { return fMaxDZ; }
+ /// Gets max considered q/p for tracks
+ float GetMaxInvMom() const { return fMaxInvMom; }
+ /// Gets max slope (tx\ty) in 3d hit position of a triplet
+ float GetMaxSlope() const { return fMaxSlope; }
+ /// Gets max slope (tx\ty) in prim vertex
+ float GetMaxSlopePV() const { return fMaxSlopePV; }
+ /// Gets the name of the iteration
+ const std::string& GetName() const { return fName; }
+ ///
+ float GetPickGather() const { return fPickGather; }
+ ///
+ float GetPickNeighbour() const { return fPickNeighbour; }
+ /// Gets track chi2 upper cut
+ float GetTrackChi2Cut() const { return fTrackChi2Cut; }
+ /// Gets triplet chi2 upper cut
+ float GetTripletChi2Cut() const { return fTripletChi2Cut; }
/// Prints iteration options
void Print(int verbosityLevel = 0) const;
- //
- // SETTERS
- //
-
- //-------------------------------------------------------------------------------------------------------------------
- // Basic fields setters
- //-------------------------------------------------------------------------------------------------------------------
-
- /// Sets type of the iteration
- //void SetType(L1CAIterationType type) { fType = type; }
- /// Sets name of the iteration
- void SetName(const std::string& name) { fName = name; }
-
- //-------------------------------------------------------------------------------------------------------------------
- // Cuts setters
- //-------------------------------------------------------------------------------------------------------------------
-
- /// Sets track chi2 upper cut
- void SetTrackChi2Cut(float input) { fTrackChi2Cut = input; }
- /// Sets triplet chi2 upper cut
- void SetTripletChi2Cut(float input) { fTripletChi2Cut = input; }
/// Sets doublet chi2 upper cut
void SetDoubletChi2Cut(float input) { fDoubletChi2Cut = input; }
///
- void SetPickGather(float input) { fPickGather = input; }
- ///
- void SetPickNeighbour(float input) { fPickNeighbour = input; }
- ///
+ void SetMaxDZ(float input) { fMaxDZ = input; }
+ /// Sets max considered q/p for tracks
void SetMaxInvMom(float input) { fMaxInvMom = input; }
- ///
- void SetMaxSlopePV(float input) { fMaxSlopePV = input; }
- ///
+ /// Sets max slope (tx\ty) in 3d hit position of a triplet
void SetMaxSlope(float input) { fMaxSlope = input; }
-
- //
- // GETTERS
- //
-
- //-------------------------------------------------------------------------------------------------------------------
- // Basic fields getters
- //-------------------------------------------------------------------------------------------------------------------
-
- /// Gets the type of the iteration
- //L1CAIterationType GetType() const { return fType; }
- /// Gets the name of the iteration
- const std::string& GetName() const { return fName; }
-
- //-------------------------------------------------------------------------------------------------------------------
- // Cuts getters
- //-------------------------------------------------------------------------------------------------------------------
-
- /// Gets track chi2 upper cut
- float GetTrackChi2Cut() const { return fTrackChi2Cut; }
- /// Gets triplet chi2 upper cut
- float GetTripletChi2Cut() const { return fTripletChi2Cut; }
- /// Gets doublet chi2 upper cut
- float GetDoubletChi2Cut() const { return fDoubletChi2Cut; }
- ///
- float GetPickGather() const { return fPickGather; }
- ///
- float GetPickNeighbour() const { return fPickNeighbour; }
- ///
- float GetMaxInvMom() const { return fMaxInvMom; }
+ /// Sets max slope (tx\ty) in prim vertex
+ void SetMaxSlopePV(float input) { fMaxSlopePV = input; }
+ /// Sets name of the iteration
+ void SetName(const std::string& name) { fName = name; }
///
- float GetMaxSlopePV() const { return fMaxSlopePV; }
+ void SetPickGather(float input) { fPickGather = input; }
///
- float GetMaxSlope() const { return fMaxSlope; }
+ void SetPickNeighbour(float input) { fPickNeighbour = input; }
+ /// Sets track chi2 upper cut
+ void SetTrackChi2Cut(float input) { fTrackChi2Cut = input; }
+ /// Sets triplet chi2 upper cut
+ void SetTripletChi2Cut(float input) { fTripletChi2Cut = input; }
+
+ /// Swap method
+ void Swap(L1CAIteration& other) noexcept;
+ /// String representation of the class contents
+ std::string ToString(int indentLevel = 0) const;
private:
//-------------------------------------------------------------------------------------------------------------------
- // Basic fields
+ // Basic class fields
//-------------------------------------------------------------------------------------------------------------------
-
- //L1CAIterationType fType {static_cast<L1CAIterationType>(0)}; ///< Iteration type
std::string fName {""}; ///< Iteration name
//-------------------------------------------------------------------------------------------------------------------
// Track finder dependent cuts
//-------------------------------------------------------------------------------------------------------------------
- // TODO: Iteratively change the literals to floats
- // TODO: Change the names of variables
+ // TODO: Iteratively change the literals to floats (S.Zharko)
float fTrackChi2Cut {10.f}; ///> track chi2 upper cut
float fTripletChi2Cut {21.1075f}; ///> triplet chi2 upper cut
float fDoubletChi2Cut {11.3449 * 2.f / 3.f}; ///> doublet chi2 upper cut
float fPickGather {3.0}; ///> size of region to attach new hits to the created track
- float fPickNeighbour {5.0};
- float fMaxInvMom {1.0 / 0.5};
- float fMaxSlopePV {1.1};
- float fMaxSlope {2.748};
+ float fPickNeighbour {5.0}; ///> min value of dp/dp_error, for which to tiplets are neighbours
+ float fMaxInvMom {1.0 / 0.5}; ///> max considered q/p for tracks
+ float fMaxSlopePV {1.1}; ///> max slope (tx\ty) in prim vertex
+ float fMaxSlope {2.748}; ///> max slope (tx\ty) in 3d hit position of a triplet
+ float fMaxDZ {0.f}; ///> Correction for accounting overlaping and iff z
};
#endif // L1CAIteration_h
diff --git a/reco/L1/L1Algo/L1CATrackFinder.cxx b/reco/L1/L1Algo/L1CATrackFinder.cxx
index 2157c987dd01a6e388f3b70f00d1f6d22c90fd9b..570528a45f7601f92db7cde7b55242f73f7a0f72 100644
--- a/reco/L1/L1Algo/L1CATrackFinder.cxx
+++ b/reco/L1/L1Algo/L1CATrackFinder.cxx
@@ -20,6 +20,7 @@
#include "L1Algo.h"
+#include "L1Assert.h"
#include "L1Extrapolation.h"
#include "L1Filtration.h"
#include "L1Fit.h"
@@ -234,9 +235,9 @@ inline void L1Algo::f11( /// input 1st stage of singlet search
T.C30 = T.C31 = T.C32 = 0;
T.C40 = T.C41 = T.C42 = T.C43 = 0;
T.C50 = T.C51 = T.C52 = T.C53 = T.C54 = 0;
- T.C22 = T.C33 = MaxSlopePV * MaxSlopePV / 9.;
+ T.C22 = T.C33 = fMaxSlopePV * fMaxSlopePV / 9.;
if (fTrackingMode == kGlobal || fTrackingMode == kMcbm) T.C22 = T.C33 = 10;
- T.C44 = MaxInvMom / 3. * MaxInvMom / 3.;
+ T.C44 = fMaxInvMom / 3. * fMaxInvMom / 3.;
T.C55 = timeEr * timeEr;
@@ -323,11 +324,11 @@ inline void L1Algo::f11( /// input 1st stage of singlet search
for (int ista = 0; ista <= istal - 1; ista++) {
#ifdef USE_RL_TABLE
- fit.L1AddMaterial(T, fRadThick[ista].GetRadThick(T.x, T.y), MaxInvMom, 1);
+ fit.L1AddMaterial(T, fRadThick[ista].GetRadThick(T.x, T.y), fMaxInvMom, 1);
#else // not USE_RL_TABLE
- fit.L1AddMaterial(T, vStations[ista].materialInfo, MaxInvMom, 1);
+ fit.L1AddMaterial(T, vStations[ista].materialInfo, fMaxInvMom, 1);
#endif // USE_RL_TABLE
- if (ista == NMvdStations - 1) fit.L1AddPipeMaterial(T, MaxInvMom, 1);
+ if (ista == NMvdStations - 1) fit.L1AddPipeMaterial(T, fMaxInvMom, 1);
}
// add left hit
@@ -359,13 +360,13 @@ inline void L1Algo::f11( /// input 1st stage of singlet search
#ifdef USE_RL_TABLE
- if (fTrackingMode != kMcbm) fit.L1AddMaterial(T, fRadThick[istal].GetRadThick(T.x, T.y), MaxInvMom, 1);
+ if (fTrackingMode != kMcbm) fit.L1AddMaterial(T, fRadThick[istal].GetRadThick(T.x, T.y), fMaxInvMom, 1);
if (fTrackingMode == kGlobal || fTrackingMode == kMcbm)
- fit.L1AddThickMaterial(T, fRadThick[istal].GetRadThick(T.x, T.y), MaxInvMom, 1, stal.materialInfo.thick, 1);
+ fit.L1AddThickMaterial(T, fRadThick[istal].GetRadThick(T.x, T.y), fMaxInvMom, 1, stal.materialInfo.thick, 1);
#else // not USE_RL_TABLE
- fit.L1AddMaterial(T, stal.materialInfo, MaxInvMom, 1);
+ fit.L1AddMaterial(T, stal.materialInfo, fMaxInvMom, 1);
#endif // USE_RL_TABLE
- if ((istam >= NMvdStations) && (istal <= NMvdStations - 1)) { fit.L1AddPipeMaterial(T, MaxInvMom, 1); }
+ if ((istam >= NMvdStations) && (istal <= NMvdStations - 1)) { fit.L1AddPipeMaterial(T, fMaxInvMom, 1); }
fvec dz = zstam - zl;
L1ExtrapolateTime(T, dz, stam.timeInfo);
@@ -406,7 +407,7 @@ inline void L1Algo::f20(
const int n2Saved = n2;
const fvec Pick_m22 =
- (DOUBLET_CHI2_CUT - T1.chi2); // if make it bigger the found hits will be rejected later because of the chi2 cut.
+ (fDoubletChi2Cut - T1.chi2); // if make it bigger the found hits will be rejected later because of the chi2 cut.
// Pick_m22 is not used, search for mean squared, 2nd version
// -- collect possible doublets --
@@ -416,8 +417,8 @@ inline void L1Algo::f20(
L1HitAreaTime areaTime(vGridTime[&stam - vStations], T1.x[i1_4] * iz, T1.y[i1_4] * iz,
- (sqrt(Pick_m22 * (T1.C00 + stam.XYInfo.C00)) + MaxDZ * fabs(T1.tx))[i1_4] * iz,
- (sqrt(Pick_m22 * (T1.C11 + stam.XYInfo.C11)) + MaxDZ * fabs(T1.ty))[i1_4] * iz, time,
+ (sqrt(Pick_m22 * (T1.C00 + stam.XYInfo.C00)) + fMaxDZ * fabs(T1.tx))[i1_4] * iz,
+ (sqrt(Pick_m22 * (T1.C11 + stam.XYInfo.C11)) + fMaxDZ * fabs(T1.ty))[i1_4] * iz, time,
sqrt(timeError) * 5);
@@ -507,7 +508,7 @@ inline void L1Algo::f20(
#ifdef DO_NOT_SELECT_TRIPLETS
if (isec != TRACKS_FROM_TRIPLETS_ITERATION)
#endif // DO_NOT_SELECT_TRIPLETS
- if (chi2[i1_4] > DOUBLET_CHI2_CUT) continue;
+ if (chi2[i1_4] > fDoubletChi2Cut) continue;
// T1.t[i1_4] = hitm.time;
#ifdef USE_EVENT_NUMBER
@@ -526,7 +527,7 @@ inline void L1Algo::f20(
#ifdef DO_NOT_SELECT_TRIPLETS
if (isec != TRACKS_FROM_TRIPLETS_ITERATION)
#endif // DO_NOT_SELECT_TRIPLETS
- if (chi2[i1_4] > DOUBLET_CHI2_CUT) continue;
+ if (chi2[i1_4] > fDoubletChi2Cut) continue;
i1_2.push_back(i1);
#ifdef DOUB_PERFORMANCE
@@ -681,7 +682,7 @@ inline void L1Algo::f30( // input
fit.L1AddMaterial(T2, fRadThick[istam].GetRadThick(T2.x, T2.y), T2.qp, 1);
if (fTrackingMode == kGlobal || fTrackingMode == kMcbm)
- fit.L1AddThickMaterial(T2, fRadThick[istam].GetRadThick(T2.x, T2.y), MaxInvMom, 1, stam.materialInfo.thick, 1);
+ fit.L1AddThickMaterial(T2, fRadThick[istam].GetRadThick(T2.x, T2.y), fMaxInvMom, 1, stam.materialInfo.thick, 1);
#else // not USE_RL_TABLE
fit.L1AddMaterial(T2, stam.materialInfo, T2.qp, 1);
#endif // USE_RL_TABLE
@@ -707,10 +708,10 @@ inline void L1Algo::f30( // input
if (fTrackingMode == kSts && (T2.C44[i2_4] < 0)) { continue; }
if (T2.C00[i2_4] < 0 || T2.C11[i2_4] < 0 || T2.C22[i2_4] < 0 || T2.C33[i2_4] < 0 || T2.C55[i2_4] < 0) continue;
- if (fabs(T2.tx[i2_4]) > MaxSlope) continue;
- if (fabs(T2.ty[i2_4]) > MaxSlope) continue;
+ if (fabs(T2.tx[i2_4]) > fMaxSlope) continue;
+ if (fabs(T2.ty[i2_4]) > fMaxSlope) continue;
- const fvec Pick_r22 = (TRIPLET_CHI2_CUT - T2.chi2);
+ const fvec Pick_r22 = (fTripletChi2Cut - T2.chi2);
const float& timeError = T2.C55[i2_4];
const float& time = T2.t[i2_4];
// find first possible hit
@@ -720,8 +721,8 @@ inline void L1Algo::f30( // input
#endif // DO_NOT_SELECT_TRIPLETS
const fscal iz = 1.f / (T2.z[i2_4] - fCbmTargetZ[0]);
L1HitAreaTime area(vGridTime[&star - vStations], T2.x[i2_4] * iz, T2.y[i2_4] * iz,
- (sqrt(Pick_r22 * (T2.C00 + stam.XYInfo.C00)) + MaxDZ * fabs(T2.tx))[i2_4] * iz,
- (sqrt(Pick_r22 * (T2.C11 + stam.XYInfo.C11)) + MaxDZ * fabs(T2.ty))[i2_4] * iz, time,
+ (sqrt(Pick_r22 * (T2.C00 + stam.XYInfo.C00)) + fMaxDZ * fabs(T2.tx))[i2_4] * iz,
+ (sqrt(Pick_r22 * (T2.C11 + stam.XYInfo.C11)) + fMaxDZ * fabs(T2.ty))[i2_4] * iz, time,
sqrt(timeError) * 5);
THitI irh = 0;
@@ -824,7 +825,7 @@ inline void L1Algo::f30( // input
#ifdef DO_NOT_SELECT_TRIPLETS
if (isec != TRACKS_FROM_TRIPLETS_ITERATION)
#endif // DO_NOT_SELECT_TRIPLETS
- if (chi2[i2_4] > TRIPLET_CHI2_CUT || C00[i2_4] < 0 || C11[i2_4] < 0 || T_cur.C55[i2_4] < 0)
+ if (chi2[i2_4] > fTripletChi2Cut || C00[i2_4] < 0 || C11[i2_4] < 0 || T_cur.C55[i2_4] < 0)
continue; // chi2_triplet < CHI2_CUT
// pack triplet
@@ -1153,7 +1154,7 @@ inline void L1Algo::f4( // input
#ifdef DO_NOT_SELECT_TRIPLETS
if (isec != TRACKS_FROM_TRIPLETS_ITERATION)
#endif // DO_NOT_SELECT_TRIPLETS
- if (!finite(chi2) || chi2 < 0 || chi2 > TRIPLET_CHI2_CUT) continue;
+ if (!finite(chi2) || chi2 < 0 || chi2 > fTripletChi2Cut) continue;
fscal qp = T3.qp[i3_4];
@@ -1169,8 +1170,8 @@ inline void L1Algo::f4( // input
// TODO: But for some reason, the efficiency degrades without them.
// TODO: It needs to be investigated. If the cuts are necessary, they need to be adjusted.
- fscal Cmax = 0.04 * MaxInvMom[0]; // minimal momentum: 0.05 - 0.1
- //if ( isec == kAllPrimJumpIter ) {
+ fscal Cmax = 0.04 * fMaxInvMom[0]; // minimal momentum: 0.05 - 0.1
+ //if ( isec == kAllPrimJumpIter ) {
if (Cqp > Cmax) {
//cout << "isec " << isec << " Cqp " << Cqp << " max " << Cmax << " add " << 0.05 * Cmax << endl;
Cqp = Cmax;
@@ -1279,7 +1280,7 @@ inline void L1Algo::f5( // input
// if (neigh.GetMSta() != istar) continue; // neighbours should have 2 common hits
// if (neigh.GetMHit() != ihitr) continue; //!!!
- if (fabs(trip.GetQp() - neigh.GetQp()) > PickNeighbour * (trip.GetCqp() + neigh.GetCqp()))
+ if (fabs(trip.GetQp() - neigh.GetQp()) > fPickNeighbour * (trip.GetCqp() + neigh.GetCqp()))
continue; // neighbours should have same qp
// calculate level
@@ -1526,7 +1527,7 @@ L1Algo::TripletsStaPort( /// creates triplets: input: @istal - start station nu
#else
fL1Eff_triplets->AddOne(iHits);
#endif
- if (T_3[i_V].chi2[i_4] < TRIPLET_CHI2_CUT) fL1Eff_triplets2->AddOne(iHits);
+ if (T_3[i_V].chi2[i_4] < fTripletChi2Cut) fL1Eff_triplets2->AddOne(iHits);
}
#endif // TRIP_PERFORMANCE
@@ -1762,19 +1763,15 @@ void L1Algo::CATrackFinder()
// ---- Loop over Track Finder iterations ----------------------------------------------------------------//
-#ifdef FIND_GAPED_TRACKS
- std::cout << "\033[1;32mFIND_GAPED_TRACKS\033[0m\n";
-#endif // FIND_GAPED_TRACKS
- std::cout << "Number of iterations: \033[1;31m" << fNFindIterations << "\033[0m\n";
- std::cout << "Number of iterations(new): \033[1;31m" << fParameters.CAIterationsContainer().size() << "\033[0m\n";
- std::cout << "Tracking mode: " << fTrackingMode << '\n';
- isec = 0; // TODO: temporary! (S.Zharko)
+ L1ASSERT(0, fNFindIterations == fParameters.CAIterationsContainer().size());
+ isec = 0; // TODO: temporary! (S.Zharko)
+ std::cout << "\033[1;31mfNThreads\033[0m = " << fNThreads << '\n';
for (const auto& caIteration : fParameters.CAIterationsContainer()) // all finder
{
std::cout << "CA Track Finder Iteration!!" << isec << '\n';
- if (fTrackingMode == kMcbm) {
- if (isec > 3) { continue; }
- }
+ //if (fTrackingMode == kMcbm) {
+ // if (isec > 3) { continue; }
+ //}
// n_g1.assign(n_g1.size(), Portion);
for (int n = 0; n < fNThreads; n++) {
@@ -1800,7 +1797,7 @@ void L1Algo::CATrackFinder()
vStsHitPointsUnused = vStsHitPointsUnused_buf;
vStsHitPointsUnused_buf = vStsHitsUnused_temp2;
}
-
+ // TODO: Replace NStations with fInitManager.GetStationsNumber() (S.Zharko)
for (int ist = 0; ist < NStations; ++ist) {
for (THitI ih = StsHitsUnusedStartIndex[ist]; ih < StsHitsUnusedStopIndex[ist]; ++ih) {
//SG!!
@@ -1823,54 +1820,54 @@ void L1Algo::CATrackFinder()
// if ( (isec == kAllSecIter) || (isec == kAllSecEIter) || (isec == kAllSecJumpIter) )
// FIRSTCASTATION = 2;
- DOUBLET_CHI2_CUT = caIteration.GetDoubletChi2Cut(); //11.3449 * 2.f / 3.f; // prob = 0.1
+ fDoubletChi2Cut = caIteration.GetDoubletChi2Cut(); //11.3449 * 2.f / 3.f; // prob = 0.1
- TRIPLET_CHI2_CUT = caIteration.GetTripletChi2Cut(); //21.1075; // prob = 0.01%
+ fTripletChi2Cut = caIteration.GetTripletChi2Cut(); //21.1075; // prob = 0.01%
//switch (isec) {
// case kFastPrimIter:
- // TRIPLET_CHI2_CUT = 7.815 * 3; // prob = 0.05
+ // fTripletChi2Cut = 7.815 * 3; // prob = 0.05
// break;
// case kAllPrimIter:
// case kAllPrimEIter:
- // TRIPLET_CHI2_CUT = 7.815 * 3; // prob = 0.05
+ // fTripletChi2Cut = 7.815 * 3; // prob = 0.05
// break;
// case kAllPrimJumpIter:
- // TRIPLET_CHI2_CUT = 6.252 * 3; // prob = 0.1
+ // fTripletChi2Cut = 6.252 * 3; // prob = 0.1
// break;
// case kAllSecIter:
// case kAllSecEIter:
- // TRIPLET_CHI2_CUT = 6.252 * 3; //2.706; // prob = 0.1
+ // fTripletChi2Cut = 6.252 * 3; //2.706; // prob = 0.1
// break;
//}
- Pick_gather =
- caIteration
- .GetPickGather(); //3.0; /// coefficient for size of region for attach new hits to the created track
+ /// coefficient for size of region for attach new hits to the created track
+ fPickGather = caIteration.GetPickGather(); //3.0;
//if ((isec == kAllPrimIter) || (isec == kAllPrimEIter) || (isec == kAllPrimJumpIter) || (isec == kAllSecIter)
// || (isec == kAllSecEIter) || (isec == kAllSecJumpIter))
- // Pick_gather = 4.0;
+ // fPickGather = 4.0;
- PickNeighbour =
- caIteration.GetPickGather(); //5.0; // (PickNeighbour < dp/dp_error) => triplets are neighbours
+ // (fPickNeighbour < dp/dp_error) => triplets are neighbours
+ fPickNeighbour = caIteration.GetPickNeighbour(); //5.0;
// if ( (isec == kFastPrimIter) )
- // PickNeighbour = 5.0*0.5; // TODO understand why works with 0.2
+ // fPickNeighbour = 5.0*0.5; // TODO understand why works with 0.2
- MaxInvMom = caIteration.GetMaxInvMom(); //1.0 / 0.5; // max considered q/p
+ fMaxInvMom = caIteration.GetMaxInvMom(); //1.0 / 0.5; // max considered q/p
- //if (fTrackingMode == kMcbm) MaxInvMom = 1 / 0.3; // max considered q/p
- //if ((isec == kAllPrimJumpIter) || (isec == kAllSecIter) || (isec == kAllSecJumpIter)) MaxInvMom = 1.0 / 0.1;
- //if ((isec == kAllPrimIter) || (isec == kAllPrimEIter) || (isec == kAllSecEIter)) MaxInvMom = 1. / 0.05;
+ //if (fTrackingMode == kMcbm) fMaxInvMom = 1 / 0.3; // max considered q/p
+ //if ((isec == kAllPrimJumpIter) || (isec == kAllSecIter) || (isec == kAllSecJumpIter)) fMaxInvMom = 1.0 / 0.1;
+ //if ((isec == kAllPrimIter) || (isec == kAllPrimEIter) || (isec == kAllSecEIter)) fMaxInvMom = 1. / 0.05;
//if ((isec == kAllPrimIter) || (isec == kAllPrimEIter) || (isec == kAllSecEIter))
- // if (fTrackingMode == kMcbm) MaxInvMom = 1 / 0.1; // max considered q/p
+ // if (fTrackingMode == kMcbm) fMaxInvMom = 1 / 0.1; // max considered q/p
- MaxSlopePV = caIteration.GetMaxSlopePV(); //1.1;
+ fMaxSlopePV = caIteration.GetMaxSlopePV(); //1.1;
//if ( // (isec == kAllPrimIter) || (isec == kAllPrimEIter) || (isec == kAllPrimJumpIter) ||
// (isec == kAllSecIter) || (isec == kAllSecEIter) || (isec == kAllSecJumpIter))
- // MaxSlopePV = 1.5;
+ // fMaxSlopePV = 1.5;
+
+ fMaxSlope = caIteration.GetMaxSlope(); //2.748; // corresponds to 70 grad
- MaxSlope = caIteration.GetMaxSlope(); //2.748; // corresponds to 70 grad
// define the target
fTargX = fCbmTargetX;
fTargY = fCbmTargetY;
@@ -1900,10 +1897,10 @@ void L1Algo::CATrackFinder()
/// Set correction in order to take into account overlaping and iff z.
/// The reason is that low momentum tracks are too curved and goes not from target direction. That's why sort by hit_y/hit_z is not work idealy
/// If sort by y then it is max diff between same station's modules (~0.4cm)
- MaxDZ = 0;
+ fMaxDZ = 0;
if ((isec == kAllPrimIter) || (isec == kAllPrimEIter) || (isec == kAllPrimJumpIter) || (isec == kAllSecIter)
|| (isec == kAllSecEIter) || (isec == kAllSecJumpIter))
- MaxDZ = 0.1;
+ fMaxDZ = 0.1;
if (NStations > (int) L1Parameters::kMaxNstations) cout << " CATrackFinder: Error: Too many Stations" << endl;
}
@@ -2642,7 +2639,7 @@ inline void L1Algo::CAFindTrack(int ista, L1Branch& best_tr, unsigned char& best
}
//if( curr_L < min_best_l - 1 ) return; // suppouse that only one hit can be added by extender
- if (curr_chi2 > TRACK_CHI2_CUT * (curr_L * 2 - 5.0)) return;
+ if (curr_chi2 > fTrackChi2Cut * (curr_L * 2 - 5.0)) return;
// // try to find more hits
@@ -2677,7 +2674,7 @@ inline void L1Algo::CAFindTrack(int ista, L1Branch& best_tr, unsigned char& best
// ID = curr_trip->neighbours[in];
// const fscal &qp2 = curr_trip->GetQp();
// fscal &Cqp2 = curr_trip->Cqp;
- // if (( fabs(qp - qp2) > PickNeighbour * (Cqp + Cqp2) ) ) continue;
+ // if (( fabs(qp - qp2) > fPickNeighbour * (Cqp + Cqp2) ) ) continue;
unsigned int Station = TripletId2Station(ID);
unsigned int Thread = TripletId2Thread(ID);
@@ -2693,7 +2690,7 @@ inline void L1Algo::CAFindTrack(int ista, L1Branch& best_tr, unsigned char& best
fscal Cqp = curr_trip->GetCqp();
Cqp += new_trip.GetCqp();
if (fTrackingMode != kMcbm) {
- if (dqp > PickNeighbour * Cqp) {
+ if (dqp > fPickNeighbour * Cqp) {
continue; // bad neighbour // CHECKME why do we need recheck it?? (it really change result)
}
}
@@ -2749,7 +2746,7 @@ inline void L1Algo::CAFindTrack(int ista, L1Branch& best_tr, unsigned char& best
else {
new_chi2 += dqp * dqp;
}
- if (new_chi2 > TRACK_CHI2_CUT * new_L) continue; // TODO: SG: it must be ( 2 * new_L )
+ if (new_chi2 > fTrackChi2Cut * new_L) continue; // TODO: SG: it must be ( 2 * new_L )
const int new_ista = ista + new_trip.GetMSta() - new_trip.GetLSta();
CAFindTrack(new_ista, best_tr, best_L, best_chi2, &new_trip, new_tr[ista], new_L, new_chi2, min_best_l, new_tr);
diff --git a/reco/L1/L1Algo/L1InitManager.cxx b/reco/L1/L1Algo/L1InitManager.cxx
index e3adcb2d1e3b659f517474061fe8f81b285f85e4..ed3c22f14c0f409d052beff1be2b376e9475f92c 100644
--- a/reco/L1/L1Algo/L1InitManager.cxx
+++ b/reco/L1/L1Algo/L1InitManager.cxx
@@ -152,6 +152,8 @@ void L1InitManager::PrintStations(int verbosityLevel) const
void L1InitManager::PushBackCAIteration(const L1CAIteration& iteration)
{
// TODO: probably some checks must be inserted here (S.Zharko)
+ //bool control = fInitController.GetFlag(InitKey::keCAIterationsNumberCrosscheck);
+ //std::cout << "L1InitManager::PushBackCAIteration " << control << '\n';
L1MASSERT(0, fInitController.GetFlag(InitKey::keCAIterationsNumberCrosscheck),
"Attempt to push back a CA track finder iteration before the number of iterations was defined");
diff --git a/reco/L1/L1Algo/L1Parameters.cxx b/reco/L1/L1Algo/L1Parameters.cxx
index 2927946e6779e79c1f74ecffc716846c21991e21..f33dd53c791b9a4ec976b0a3ba852e07f7e95b87 100644
--- a/reco/L1/L1Algo/L1Parameters.cxx
+++ b/reco/L1/L1Algo/L1Parameters.cxx
@@ -13,23 +13,31 @@
void L1Parameters::Print(int verbosityLevel) const
{
- LOG(info) << "== L1Algo parameters ==============================================================";
- LOG(info) << "";
- LOG(info) << " COMPILE TIME CONSTANTS";
- LOG(info) << " Bits to code one station: " << kStationBits;
- LOG(info) << " Bits to code one thread: " << kThreadBits;
- LOG(info) << " Bits to code one triplet: " << kTripletBits;
- LOG(info) << " Max number of stations: " << kMaxNstations;
- LOG(info) << " Max number of threads: " << kMaxNthreads;
- LOG(info) << " Max number of triplets: " << kMaxNtriplets;
- LOG(info) << "";
- LOG(info) << " RUNTIME CONSTANTS (CUTS)";
- LOG(info) << " Max number of doublets per singlet: " << fMaxDoubletsPerSinglet;
- LOG(info) << " Max number of triplets per doublet: " << fMaxTripletPerDoublets;
- LOG(info) << "";
- LOG(info) << " TRACK FINDER ITERATIONS";
- for (const auto& iteration : fCAIterationsContainer) {
- iteration.Print(verbosityLevel);
+ LOG(info) << "-------------- L1Algo parameters ---------------";
+ LOG(info) << ToString();
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+std::string L1Parameters::ToString(int indentLevel) const
+{
+ std::stringstream aStream {};
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << '\n';
+ aStream << indent << "COMPILE TIME CONSTANTS:\n";
+ aStream << indent << indentChar << "Bits to code one station: " << kStationBits << '\n';
+ aStream << indent << indentChar << "Bits to code one thread: " << kThreadBits << '\n';
+ aStream << indent << indentChar << "Bits to code one triplet: " << kTripletBits << '\n';
+ aStream << indent << indentChar << "Max number of stations: " << kMaxNstations << '\n';
+ aStream << indent << indentChar << "Max number of threads: " << kMaxNthreads << '\n';
+ aStream << indent << indentChar << "Max number of triplets: " << kMaxNtriplets << '\n';
+ aStream << indent << "RUNTIME CONSTANTS:\n";
+ aStream << indent << indentChar << "Max number of doublets per singlet: " << fMaxDoubletsPerSinglet << '\n';
+ aStream << indent << indentChar << "Max number of triplets per doublet: " << fMaxTripletPerDoublets << '\n';
+ aStream << indent << "CA TRACK FINDER ITERATIONS:\n";
+ for (int idx = 0; idx < static_cast<int>(fCAIterationsContainer.size()); ++idx) {
+ aStream << idx << ") " << fCAIterationsContainer[idx].ToString(indentLevel + 1) << '\n';
}
- LOG(info) << "===================================================================================";
+ return aStream.str();
}
diff --git a/reco/L1/L1Algo/L1Parameters.h b/reco/L1/L1Algo/L1Parameters.h
index 16613ea84d8ab694e1b2bfc39b4464073682f42a..e52ca5cedea58a302fd1f039711c0cc07d7c90f1 100644
--- a/reco/L1/L1Algo/L1Parameters.h
+++ b/reco/L1/L1Algo/L1Parameters.h
@@ -61,6 +61,8 @@ public:
/// Prints configuration
void Print(int verbosityLevel = 0) const;
+ /// String representation of the class contents
+ std::string ToString(int indentLevel = 0) const;
// TODO: change constant names with actual (human) names
diff --git a/reco/L1/L1Algo/L1TrackExtender.cxx b/reco/L1/L1Algo/L1TrackExtender.cxx
index 38f7afbd239d812296cdac107dc7a641a91a117c..4917b915cd47079d6bfa9037696bd136af686375 100644
--- a/reco/L1/L1Algo/L1TrackExtender.cxx
+++ b/reco/L1/L1Algo/L1TrackExtender.cxx
@@ -248,7 +248,7 @@ void L1Algo::FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir,
if (ista2 == FIRSTCASTATION) ista = ista2 + step;
- const fvec Pick_gather2 = Pick_gather * Pick_gather;
+ const fvec pickGather2 = fPickGather * fPickGather;
for (; (ista < NStations) && (ista >= 0); ista += step) { // CHECKME why ista2?
@@ -271,8 +271,8 @@ void L1Algo::FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir,
L1HitAreaTime area(vGridTime[ista], T.x[0] * iz, T.y[0] * iz,
- (sqrt(Pick_gather * (T.C00 + sta.XYInfo.C00)) + MaxDZ * fabs(T.tx))[0] * iz,
- (sqrt(Pick_gather * (T.C11 + sta.XYInfo.C11)) + MaxDZ * fabs(T.ty))[0] * iz, T.t[0],
+ (sqrt(fPickGather * (T.C00 + sta.XYInfo.C00)) + fMaxDZ * fabs(T.tx))[0] * iz,
+ (sqrt(fPickGather * (T.C11 + sta.XYInfo.C11)) + fMaxDZ * fabs(T.ty))[0] * iz, T.t[0],
sqrt(T.C55[0]));
THitI ih = 0;
@@ -291,7 +291,7 @@ void L1Algo::FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir,
fvec y, C11;
L1ExtrapolateYC11Line(T, zh, y, C11);
- // fscal dym_est = ( Pick_gather*sqrt(fabs(C11[0]+sta.XYInfo.C11[0])) );
+ // fscal dym_est = ( fPickGather * sqrt(fabs(C11[0]+sta.XYInfo.C11[0])) );
// fscal y_minus_new = y[0] - dym_est;
// if (yh < y_minus_new) continue; // CHECKME take into account overlaping?
@@ -303,7 +303,7 @@ void L1Algo::FindMoreHits(L1Branch& t, L1TrackPar& T, const bool dir,
fscal d2 = d_x * d_x + d_y * d_y;
if (d2 > r2_best) continue;
- fscal dxm_est2 = (Pick_gather2 * (fabs(C00 + sta.XYInfo.C00)))[0];
+ fscal dxm_est2 = (pickGather2 * (fabs(C00 + sta.XYInfo.C00)))[0];
if (d_x * d_x > dxm_est2) continue;
r2_best = d2;