Skip to content

[MFT] Improved handling of MFT tracking for B=0 #7200

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
shahor02 merged 6 commits into from
Oct 6, 2021
Merged

[MFT] Improved handling of MFT tracking for B=0 #7200

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
cbe185c
Converting MFT classes to templates - for B=0
rpezzi Sep 22, 2021
fe1e6f3
Fix cluster sorting, increment MFT TrackLTF ClassDefNV
rpezzi Sep 22, 2021
42f96ff
Limit cluster sorting to CA tracks
rpezzi Sep 23, 2021
f21efa8
Simple MFT track fitting for B=0
rpezzi Oct 4, 2021
d8aaa14
Reduce MFT tracker verbosity
rpezzi Oct 4, 2021
df7a986
Update TrackCA.h
rpezzi Oct 4, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 3 additions & 2 deletions Detectors/ITSMFT/MFT/tracking/include/MFTTracking/IOUtils.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -56,9 +56,10 @@ constexpr float DefClusErrorCol = o2::itsmft::SegmentationAlpide::PitchCol * 0.5
constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;

int loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& events, gsl::span<const itsmft::CompClusterExt> clusters,
template <typename T>
int loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe<T>& events, gsl::span<const itsmft::CompClusterExt> clusters,
gsl::span<const unsigned char>::iterator& pattIt, const itsmft::TopologyDictionary& dict,
const dataformats::MCTruthContainer<MCCompLabel>* mClsLabels = nullptr, const o2::mft::Tracker* tracker = nullptr);
const dataformats::MCTruthContainer<MCCompLabel>* mClsLabels = nullptr, const o2::mft::Tracker<T>* tracker = nullptr);

void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
gsl::span<const unsigned char>::iterator& pattIt,
Expand Down
117 changes: 32 additions & 85 deletions Detectors/ITSMFT/MFT/tracking/include/MFTTracking/ROframe.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,13 +37,11 @@ namespace o2
namespace mft
{

class TrackCA;
class TrackLTF;

template <typename T>
class ROframe
{
public:
ROframe(Int_t ROframeId);
ROframe(const Int_t ROframeId) : mROframeId{ROframeId} {}
Int_t getROFrameId() const { return mROframeId; }
Int_t getTotalClusters() const;

Expand All @@ -57,31 +55,44 @@ class ROframe

const Int_t getClusterExternalIndex(Int_t layerId, const Int_t clusterId) const { return mClusterExternalIndices[layerId][clusterId]; }

std::vector<TrackLTF>& getTracksLTF();
TrackLTF& getCurrentTrackLTF();

std::vector<TrackCA>& getTracksCA();
TrackCA& getCurrentTrackCA();

Road& getCurrentRoad();

template <typename... T>
void addClusterToLayer(Int_t layer, T&&... args);
std::vector<T>& getTracks() { return mTracks; }
T& getCurrentTrack() { return mTracks.back(); }

void addClusterLabelToLayer(Int_t layer, const MCCompLabel label);
void addClusterExternalIndexToLayer(Int_t layer, const Int_t idx);
Road& getCurrentRoad() { return mRoads.back(); }

void addTrackLTF() { mTracksLTF.emplace_back(); }
template <typename... C>
void addClusterToLayer(Int_t layer, C&&... args)
{
mClusters[layer].emplace_back(std::forward<C>(args)...);
}
void addClusterLabelToLayer(Int_t layer, const MCCompLabel label) { mClusterLabels[layer].emplace_back(label); }
void addClusterExternalIndexToLayer(Int_t layer, const Int_t idx) { mClusterExternalIndices[layer].push_back(idx); }

void addTrackCA(const Int_t);
void addTrack(bool isCA = false)
{
mTracks.emplace_back(isCA);
}

void addRoad();
void addRoad() { mRoads.emplace_back(); }

void initialize(bool fullClusterScan = false);

void sortClusters();

void clear();
void clear()
{

for (Int_t iLayer = 0; iLayer < constants::mft::LayersNumber; ++iLayer) {
mClusters[iLayer].clear();
mClusterLabels[iLayer].clear();
mClusterExternalIndices[iLayer].clear();
for (Int_t iBin = 0; iBin < constants::index_table::MaxRPhiBins; ++iBin) {
mClusterBinIndexRange[iLayer][iBin] = std::pair<Int_t, Int_t>(0, -1);
}
}
mTracks.clear();
mRoads.clear();
}

const Int_t getNClustersInLayer(Int_t layerId) const { return mClusters[layerId].size(); }

Expand All @@ -91,74 +102,10 @@ class ROframe
std::array<std::vector<MCCompLabel>, constants::mft::LayersNumber> mClusterLabels;
std::array<std::vector<Int_t>, constants::mft::LayersNumber> mClusterExternalIndices;
std::array<std::array<std::pair<Int_t, Int_t>, constants::index_table::MaxRPhiBins>, constants::mft::LayersNumber> mClusterBinIndexRange;
std::vector<TrackLTF> mTracksLTF;
std::vector<TrackCA> mTracksCA;
std::vector<T> mTracks;
std::vector<Road> mRoads;
};

template <typename... T>
void ROframe::addClusterToLayer(Int_t layer, T&&... values)
{
mClusters[layer].emplace_back(std::forward<T>(values)...);
}

inline void ROframe::addClusterLabelToLayer(Int_t layer, const MCCompLabel label) { mClusterLabels[layer].emplace_back(label); }

inline void ROframe::addClusterExternalIndexToLayer(Int_t layer, const Int_t idx)
{
mClusterExternalIndices[layer].push_back(idx);
}

inline TrackLTF& ROframe::getCurrentTrackLTF()
{
return mTracksLTF.back();
}

inline std::vector<TrackLTF>& ROframe::getTracksLTF()
{
return mTracksLTF;
}

inline void ROframe::addRoad()
{
mRoads.emplace_back();
}

inline Road& ROframe::getCurrentRoad()
{
return mRoads.back();
}

inline void ROframe::addTrackCA(const Int_t roadId)
{
mTracksCA.emplace_back();
}

inline TrackCA& ROframe::getCurrentTrackCA()
{
return mTracksCA.back();
}

inline std::vector<TrackCA>& ROframe::getTracksCA()
{
return mTracksCA;
}

inline void ROframe::clear()
{
for (Int_t iLayer = 0; iLayer < constants::mft::LayersNumber; ++iLayer) {
mClusters[iLayer].clear();
mClusterLabels[iLayer].clear();
mClusterExternalIndices[iLayer].clear();
for (Int_t iBin = 0; iBin < constants::index_table::MaxRPhiBins; ++iBin) {
mClusterBinIndexRange[iLayer][iBin] = std::pair<Int_t, Int_t>(0, -1);
}
}
mTracksLTF.clear();
mTracksCA.clear();
mRoads.clear();
}

} // namespace mft
} // namespace o2

Expand Down
36 changes: 26 additions & 10 deletions Detectors/ITSMFT/MFT/tracking/include/MFTTracking/TrackCA.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,8 +32,11 @@ class TrackLTF : public TrackMFTExt
{
public:
TrackLTF() = default;
TrackLTF(const bool isCA) { setCA(isCA); }

TrackLTF(const TrackLTF& t) = default;
~TrackLTF() = default;

const std::array<Float_t, constants::mft::LayersNumber>& getXCoordinates() const { return mX; }
const std::array<Float_t, constants::mft::LayersNumber>& getYCoordinates() const { return mY; }
const std::array<Float_t, constants::mft::LayersNumber>& getZCoordinates() const { return mZ; }
Expand All @@ -56,23 +59,35 @@ class TrackLTF : public TrackMFTExt
std::array<Int_t, constants::mft::LayersNumber> mClusterId;
std::array<MCCompLabel, constants::mft::LayersNumber> mMCCompLabels;

ClassDefNV(TrackLTF, 10);
ClassDefNV(TrackLTF, 11);
};

//_________________________________________________________________________________________________
class TrackCA : public TrackLTF
class TrackLTFL : public TrackLTF // A track model for B=0
{
using SMatrix44Sym = ROOT::Math::SMatrix<double, 4, 4, ROOT::Math::MatRepSym<double, 4>>;

public:
TrackCA()
TrackLTFL() = default;
TrackLTFL(const bool isCA) { setCA(isCA); }
TrackLTFL(const TrackLTFL& t) = default;
~TrackLTFL() = default;

// Kalman filter/fitting update for linear tracks
bool update(const std::array<float, 2>& p, const std::array<float, 2>& cov)
{
TrackLTF();
this->setCA(true);
// TODO
return true;
}
TrackCA(const TrackCA& t) = default;
~TrackCA() = default;

private:
ClassDefNV(TrackCA, 10);
/// Covariance matrix of track parameters, ordered as follows: <pre>
/// <X,X> <Y,X> <SlopeX,X> <SlopeY,X>
/// <X,Y> <Y,Y> <SlopeX,Y> <SlopeY,Y>
/// <X,SlopeX> <Y,SlopeX> <SlopeX,SlopeX> <SlopeY,SlopeX>
/// <X,SlopeY> <Y,SlopeY> <SlopeX,SlopeY> <SlopeY,SlopeY>
SMatrix44Sym mCovariances{}; ///< \brief Covariance matrix of track parameters
ClassDefNV(TrackLTFL, 0);
};

//_________________________________________________________________________________________________
Expand Down Expand Up @@ -153,16 +168,17 @@ inline void TrackLTF::sort()

namespace framework
{

template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::mft::TrackCA> : std::true_type {
struct is_messageable<o2::mft::TrackLTF> : std::true_type {
};

template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::mft::TrackLTF> : std::true_type {
struct is_messageable<o2::mft::TrackLTFL> : std::true_type {
};

} // namespace framework
Expand Down
16 changes: 9 additions & 7 deletions Detectors/ITSMFT/MFT/tracking/include/MFTTracking/TrackFitter.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,7 +29,8 @@ namespace o2
namespace mft
{

/// Class to fit a track to a set of clusters
/// Class to fit a forward track to a set of clusters
template <typename T>
class TrackFitter
{

Expand All @@ -50,16 +51,16 @@ class TrackFitter
void setVerbosity(float v) { mVerbose = v; }
void setTrackModel(float m) { mTrackModel = m; }

bool initTrack(TrackLTF& track, bool outward = false);
bool fit(TrackLTF& track, bool outward = false);
bool initTrack(T& track, bool outward = false);
bool fit(T& track, bool outward = false);

/// Return the maximum chi2 above which the track can be considered as abnormal
static constexpr double getMaxChi2() { return SMaxChi2; }

private:
bool propagateToZ(TrackLTF& track, double z);
bool propagateToNextClusterWithMCS(TrackLTF& track, double z, int& startingLayerID, const int& newLayerID);
bool computeCluster(TrackLTF& track, int cluster, int& startingLayerID);
bool propagateToZ(T& track, double z);
bool propagateToNextClusterWithMCS(T& track, double z, int& startingLayerID, const int& newLayerID);
bool computeCluster(T& track, int cluster, int& startingLayerID);

bool mFieldON = true;
Float_t mBZField; // kiloGauss.
Expand All @@ -71,7 +72,8 @@ class TrackFitter
};

// Functions to estimate momentum and charge from track curvature
Double_t invQPtFromFCF(const TrackLTF& track, Double_t bFieldZ, Double_t& chi2);
template <typename T>
Double_t invQPtFromFCF(const T& track, Double_t bFieldZ, Double_t& chi2);
Bool_t LinearRegression(Int_t nVal, std::vector<double>& xVal, std::vector<double>& yVal, std::vector<double>& yErr, Double_t& a, Double_t& ae, Double_t& b, Double_t& be);

} // namespace mft
Expand Down
Loading