Skip to content

Commit c2b489f

Browse files
rahulverma012rahulverma012
authored
Merge branch 'AliceO2Group:master' into kaonIsospinFluctuation2_EffCorrAdded
2 parents 1e63b27 + 4e98452 commit c2b489f

155 files changed

Lines changed: 11461 additions & 4598 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎ALICE3/Core/FastTracker.cxx‎

Lines changed: 117 additions & 109 deletions
Large diffs are not rendered by default.

‎ALICE3/Core/FastTracker.h‎

Lines changed: 56 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,12 @@
99
// granted to it by virtue of its status as an Intergovernmental Organization
1010
// or submit itself to any jurisdiction.
1111

12+
/// \file FastTracker.h
13+
/// \brief On the fly implementation of DelphesO2 solveTrack
14+
/// \author David Dobrigkeit Chinellato
15+
/// \author Nicolò Jacazio
16+
/// \author Jesper Karlsson Gumprecht
17+
1218
#ifndef ALICE3_CORE_FASTTRACKER_H_
1319
#define ALICE3_CORE_FASTTRACKER_H_
1420

@@ -27,9 +33,7 @@
2733
#include <string>
2834
#include <vector>
2935

30-
namespace o2
31-
{
32-
namespace fastsim
36+
namespace o2::fastsim
3337
{
3438

3539
// +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+
@@ -46,30 +50,30 @@ class FastTracker
4650
virtual ~FastTracker() {}
4751

4852
// Layer and layer configuration
49-
DetLayer* AddLayer(const TString& name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0);
53+
DetLayer* addLayer(const TString& name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0);
5054

5155
/// Add a dead region in phi for a specific layer
5256
/// \param layerName Name of the layer to modify
5357
/// \param phiStart Start angle of the dead region (in radians)
5458
/// \param phiEnd End angle of the dead region (in radians)
5559
void addDeadPhiRegionInLayer(const std::string& layerName, float phiStart, float phiEnd);
56-
DetLayer GetLayer(const int layer) const { return layers[layer]; }
57-
std::vector<DetLayer> GetLayers() const { return layers; }
58-
int GetLayerIndex(const std::string& name) const;
59-
size_t GetNLayers() const { return layers.size(); }
60-
bool IsLayerInert(const int layer) const { return layers[layer].isInert(); }
61-
void ClearLayers() { layers.clear(); }
62-
void SetRadiationLength(const std::string& layerName, float x0) { layers[GetLayerIndex(layerName)].setRadiationLength(x0); }
63-
void SetRadius(const std::string& layerName, float r) { layers[GetLayerIndex(layerName)].setRadius(r); }
64-
void SetResolutionRPhi(const std::string& layerName, float resRPhi) { layers[GetLayerIndex(layerName)].setResolutionRPhi(resRPhi); }
65-
void SetResolutionZ(const std::string& layerName, float resZ) { layers[GetLayerIndex(layerName)].setResolutionZ(resZ); }
66-
void SetResolution(const std::string& layerName, float resRPhi, float resZ)
60+
[[nodiscard]] DetLayer getLayer(const int layer) const { return layers[layer]; }
61+
[[nodiscard]] std::vector<DetLayer> getLayers() const { return layers; }
62+
[[nodiscard]] int getLayerIndex(const std::string& name) const;
63+
[[nodiscard]] size_t getNLayers() const { return layers.size(); }
64+
[[nodiscard]] bool isLayerInert(const int layer) const { return layers[layer].isInert(); }
65+
void clearLayers() { layers.clear(); }
66+
void setRadiationLength(const std::string& layerName, float x0) { layers[getLayerIndex(layerName)].setRadiationLength(x0); }
67+
void setRadius(const std::string& layerName, float r) { layers[getLayerIndex(layerName)].setRadius(r); }
68+
void setResolutionRPhi(const std::string& layerName, float resRPhi) { layers[getLayerIndex(layerName)].setResolutionRPhi(resRPhi); }
69+
void setResolutionZ(const std::string& layerName, float resZ) { layers[getLayerIndex(layerName)].setResolutionZ(resZ); }
70+
void setResolution(const std::string& layerName, float resRPhi, float resZ)
6771
{
68-
SetResolutionRPhi(layerName, resRPhi);
69-
SetResolutionZ(layerName, resZ);
72+
setResolutionRPhi(layerName, resRPhi);
73+
setResolutionZ(layerName, resZ);
7074
}
7175

72-
void AddTPC(float phiResMean, float zResMean);
76+
void addTPC(float phiResMean, float zResMean);
7377

7478
/**
7579
* @brief Adds a generic detector configuration from the specified file.
@@ -80,9 +84,9 @@ class FastTracker
8084
*
8185
* @param configMap Configuration map describing the detector.
8286
*/
83-
void AddGenericDetector(const o2::fastsim::GeometryEntry& configMap, o2::ccdb::BasicCCDBManager* ccdbManager = nullptr);
87+
void addGenericDetector(const o2::fastsim::GeometryEntry& configMap, o2::ccdb::BasicCCDBManager* ccdbManager = nullptr);
8488

85-
void Print();
89+
void print();
8690

8791
/**
8892
* @brief Performs fast tracking on the input track parameters.
@@ -95,44 +99,44 @@ class FastTracker
9599
* @param nch Charged particle multiplicity (used for hit density calculations).
96100
* @return int i.e. number of intercepts (implementation-defined).
97101
*/
98-
int FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackParCov& outputTrack, const float nch, const float maxRadius = 100.f);
102+
int fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackParCov& outputTrack, const float nch, const float maxRadius = 100.f);
99103

100104
// For efficiency calculation
101-
float Dist(float z, float radius);
102-
float OneEventHitDensity(float multiplicity, float radius);
103-
float IntegratedHitDensity(float multiplicity, float radius);
104-
float UpcHitDensity(float radius);
105-
float HitDensity(float radius);
106-
float ProbGoodChiSqHit(float radius, float searchRadiusRPhi, float searchRadiusZ);
105+
float dist(float z, float radius);
106+
float oneEventHitDensity(float multiplicity, float radius);
107+
float integratedHitDensity(float multiplicity, float radius);
108+
float upcHitDensity(float radius);
109+
float hitDensity(float radius);
110+
float probGoodChiSqHit(float radius, float searchRadiusRPhi, float searchRadiusZ);
107111

108112
// Setters and getters for configuration
109-
void SetIntegrationTime(float t) { integrationTime = t; }
110-
void SetMaxRadiusOfSlowDetectors(float r) { maxRadiusSlowDet = r; }
111-
void SetAvgRapidity(float y) { avgRapidity = y; }
112-
void SetdNdEtaCent(int d) { dNdEtaCent = d; }
113-
void SetLhcUPCscale(float s) { lhcUPCScale = s; }
114-
void SetBField(float b) { magneticField = b; }
115-
void SetMinRadTrack(float r) { fMinRadTrack = r; }
116-
void SetMagneticField(float b) { magneticField = b; }
117-
void SetApplyZacceptance(bool b) { mApplyZacceptance = b; }
118-
void SetApplyMSCorrection(bool b) { mApplyMSCorrection = b; }
119-
void SetApplyElossCorrection(bool b) { mApplyElossCorrection = b; }
120-
void SetApplyEffCorrection(bool b) { mApplyEffCorrection = b; }
113+
void setIntegrationTime(float t) { integrationTime = t; }
114+
void setMaxRadiusOfSlowDetectors(float r) { maxRadiusSlowDet = r; }
115+
void setAvgRapidity(float y) { avgRapidity = y; }
116+
void setdNdEtaCent(int d) { dNdEtaCent = d; }
117+
void setLhcUPCscale(float s) { lhcUPCScale = s; }
118+
void setBField(float b) { magneticField = b; }
119+
void setMinRadTrack(float r) { fMinRadTrack = r; }
120+
void setMagneticField(float b) { magneticField = b; }
121+
void setApplyZacceptance(bool b) { mApplyZacceptance = b; }
122+
void setApplyMSCorrection(bool b) { mApplyMSCorrection = b; }
123+
void setApplyElossCorrection(bool b) { mApplyElossCorrection = b; }
124+
void setApplyEffCorrection(bool b) { mApplyEffCorrection = b; }
121125

122126
// Getters for the last track
123-
int GetNIntercepts() const { return nIntercepts; }
124-
int GetNSiliconPoints() const { return nSiliconPoints; }
125-
int GetNGasPoints() const { return nGasPoints; }
126-
float GetGoodHitProb(int layer) const
127+
[[nodiscard]] int getNIntercepts() const { return nIntercepts; }
128+
[[nodiscard]] int getNSiliconPoints() const { return nSiliconPoints; }
129+
[[nodiscard]] int getNGasPoints() const { return nGasPoints; }
130+
[[nodiscard]] float getGoodHitProb(int layer) const
127131
{
128132
return (layer >= 0 && static_cast<size_t>(layer) < goodHitProbability.size()) ? goodHitProbability[layer] : 0.0f;
129133
}
130-
std::size_t GetNHits() const { return hits.size(); }
131-
float GetHitX(const int i) const { return hits[i][0]; }
132-
float GetHitY(const int i) const { return hits[i][1]; }
133-
float GetHitZ(const int i) const { return hits[i][2]; }
134-
uint64_t GetCovMatOK() const { return covMatOK; }
135-
uint64_t GetCovMatNotOK() const { return covMatNotOK; }
134+
[[nodiscard]] std::size_t getNHits() const { return hits.size(); }
135+
[[nodiscard]] float getHitX(const int i) const { return hits[i][0]; }
136+
[[nodiscard]] float getHitY(const int i) const { return hits[i][1]; }
137+
[[nodiscard]] float getHitZ(const int i) const { return hits[i][2]; }
138+
uint64_t getCovMatOK() const { return covMatOK; }
139+
uint64_t getCovMatNotOK() const { return covMatNotOK; }
136140

137141
private:
138142
// Definition of detector layers
@@ -146,8 +150,8 @@ class FastTracker
146150
bool mApplyEffCorrection = true; /// Apply correction for hit efficiency
147151
int mVerboseLevel = 0; /// 0: not verbose, >0 more verbose
148152
const float mCrossSectionMinB = 8; /// Minimum bias Cross section for event under study (PbPb MinBias ~ 8 Barns)
149-
int dNdEtaCent = 2200; /// dN/deta e.g. at centrality 0-5% (for 5 TeV PbPb)
150-
int dNdEtaMinB = 1; /// dN/deta for minimum bias events
153+
float dNdEtaCent = 2200.f; /// dN/deta e.g. at centrality 0-5% (for 5 TeV PbPb)
154+
float dNdEtaMinB = 1.f; /// dN/deta for minimum bias events
151155
float integrationTime = 0.02f; /// Integration time in ms
152156
float magneticField = 20.f; /// Magnetic field in kiloGauss (5 = 0.5T, 20 = 2T, etc)
153157
float covMatFactor = 0.99f; /// covmat off-diagonal factor to use for covmat fix (negative: no factor)
@@ -175,7 +179,6 @@ class FastTracker
175179

176180
// +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+
177181

178-
} // namespace fastsim
179-
} // namespace o2
182+
} // namespace o2::fastsim
180183

181184
#endif // ALICE3_CORE_FASTTRACKER_H_

‎ALICE3/Core/FlatLutWriter.cxx‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,7 @@ bool FlatLutWriter::fatSolve(lutEntry_t& lutEntry,
8585
o2::upgrade::convertTLorentzVectorToO2Track(q, tlv, {0.f, 0.f, 0.f}, trkIn);
8686

8787
o2::track::TrackParCov trkOut;
88-
const int status = fat.FastTrack(trkIn, trkOut, nch);
88+
const int status = fat.fastTrack(trkIn, trkOut, nch);
8989
if (status <= mAtLeastHits) {
9090
LOGF(debug, "fatSolve: FastTrack failed with status %d (threshold %d)", status, mAtLeastHits);
9191
return false;
@@ -94,8 +94,8 @@ bool FlatLutWriter::fatSolve(lutEntry_t& lutEntry,
9494
LOGF(debug, "fatSolve: FastTrack succeeded with status %d", status);
9595

9696
lutEntry.valid = true;
97-
lutEntry.itof = fat.GetGoodHitProb(itof);
98-
lutEntry.otof = fat.GetGoodHitProb(otof);
97+
lutEntry.itof = fat.getGoodHitProb(itof);
98+
lutEntry.otof = fat.getGoodHitProb(otof);
9999

100100
static constexpr int nCov = 15;
101101
for (int i = 0; i < nCov; ++i)
@@ -104,16 +104,16 @@ bool FlatLutWriter::fatSolve(lutEntry_t& lutEntry,
104104
// Define the efficiency
105105
auto totfake = 0.f;
106106
lutEntry.eff = 1.f;
107-
for (size_t i = 1; i < fat.GetNLayers(); ++i) {
108-
if (fat.IsLayerInert(i))
107+
for (size_t i = 1; i < fat.getNLayers(); ++i) {
108+
if (fat.isLayerInert(i))
109109
continue; // skip inert layers
110-
auto igoodhit = fat.GetGoodHitProb(i);
110+
auto igoodhit = fat.getGoodHitProb(i);
111111
if (igoodhit <= 0.f || i == itof || i == otof)
112112
continue;
113113
lutEntry.eff *= igoodhit;
114114
auto pairfake = 0.f;
115-
for (size_t j = i + 1; j < fat.GetNLayers(); ++j) {
116-
auto jgoodhit = fat.GetGoodHitProb(j);
115+
for (size_t j = i + 1; j < fat.getNLayers(); ++j) {
116+
auto jgoodhit = fat.getGoodHitProb(j);
117117
if (jgoodhit <= 0.f || j == itof || j == otof)
118118
continue;
119119
pairfake = (1.f - igoodhit) * (1.f - jgoodhit);
@@ -290,7 +290,7 @@ void FlatLutWriter::lutWrite(const char* filename, int pdg, float field, size_t
290290
LOGF(info, "Writing nch bin %d/%d", inch, nnch);
291291
auto nch = lutHeader.nchmap.eval(inch);
292292
lutEntry.nch = nch;
293-
fat.SetdNdEtaCent(nch);
293+
fat.setdNdEtaCent(nch);
294294

295295
for (int irad = 0; irad < nrad; ++irad) {
296296
for (int ieta = 0; ieta < neta; ++ieta) {

‎ALICE3/Core/OTFParticle.h‎

Lines changed: 55 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -40,21 +40,20 @@ class OTFParticle
4040
OTFParticle() = default;
4141

4242
template <typename TParticle>
43-
explicit OTFParticle(const TParticle& particle)
43+
explicit OTFParticle(const TParticle& particle) : mPdgCode(particle.pdgCode()),
44+
mGlobalIndex(particle.globalIndex()),
45+
mCollisionId(particle.mcCollisionId()),
46+
mVx(particle.vx()),
47+
mVy(particle.vy()),
48+
mVz(particle.vz()),
49+
mVt(particle.vt()),
50+
mPx(particle.px()),
51+
mPy(particle.py()),
52+
mPz(particle.pz()),
53+
mE(particle.e()),
54+
mStatusCode(particle.statusCode()),
55+
mFlag(particle.flags())
4456
{
45-
mPdgCode = particle.pdgCode();
46-
mGlobalIndex = particle.globalIndex();
47-
mCollisionId = particle.mcCollisionId();
48-
mPx = particle.px();
49-
mPy = particle.py();
50-
mPz = particle.pz();
51-
mE = particle.e();
52-
mVx = particle.vx();
53-
mVy = particle.vy();
54-
mVz = particle.vz();
55-
mVt = particle.vt();
56-
mFlag = particle.flags();
57-
mStatusCode = particle.statusCode();
5857
setBitOff(DecayerBits::ProducedByDecayer);
5958
if (particle.has_mothers()) {
6059
mIndicesMother = {particle.mothersIds().front(), particle.mothersIds().back()};
@@ -102,84 +101,82 @@ class OTFParticle
102101
}
103102

104103
// Getters
105-
int pdgCode() const { return mPdgCode; }
106-
int globalIndex() const { return mGlobalIndex; }
107-
int collisionId() const { return mCollisionId; }
108-
bool isAlive() const { return checkBit(DecayerBits::IsAlive); }
109-
bool isPrimary() const { return checkBit(DecayerBits::IsPrimary); }
110-
bool isFromMcParticles() const { return !checkBit(DecayerBits::ProducedByDecayer); }
111-
float weight() const
104+
[[nodiscard]] int pdgCode() const { return mPdgCode; }
105+
[[nodiscard]] int globalIndex() const { return mGlobalIndex; }
106+
[[nodiscard]] int collisionId() const { return mCollisionId; }
107+
[[nodiscard]] bool isAlive() const { return checkBit(DecayerBits::IsAlive); }
108+
[[nodiscard]] bool isPrimary() const { return checkBit(DecayerBits::IsPrimary); }
109+
[[nodiscard]] bool isFromMcParticles() const { return !checkBit(DecayerBits::ProducedByDecayer); }
110+
[[nodiscard]] float weight() const
112111
{
113112
static constexpr float Weight = 1.f;
114113
return Weight;
115114
}
116-
uint8_t flags() const { return mFlag; }
117-
int statusCode() const { return mStatusCode; }
118-
float vx() const { return mVx; }
119-
float vy() const { return mVy; }
120-
float vz() const { return mVz; }
121-
float vt() const { return mVt; }
122-
float px() const { return mPx; }
123-
float py() const { return mPy; }
124-
float pz() const { return mPz; }
125-
float e() const { return mE; }
126-
float radius() const { return std::hypot(mVx, mVy); }
127-
float decayRadius() const { return mDecayRadius; }
128-
float r() const { return radius(); }
129-
float pt() const { return std::hypot(mPx, mPy); }
130-
float p() const { return std::hypot(mPx, mPy, mPz); }
131-
float phi() const { return o2::constants::math::PI + std::atan2(-1.0f * py(), -1.0f * px()); }
132-
float eta() const
115+
[[nodiscard]] uint8_t flags() const { return mFlag; }
116+
[[nodiscard]] int statusCode() const { return mStatusCode; }
117+
[[nodiscard]] float vx() const { return mVx; }
118+
[[nodiscard]] float vy() const { return mVy; }
119+
[[nodiscard]] float vz() const { return mVz; }
120+
[[nodiscard]] float vt() const { return mVt; }
121+
[[nodiscard]] float px() const { return mPx; }
122+
[[nodiscard]] float py() const { return mPy; }
123+
[[nodiscard]] float pz() const { return mPz; }
124+
[[nodiscard]] float e() const { return mE; }
125+
[[nodiscard]] float radius() const { return std::hypot(mVx, mVy); }
126+
[[nodiscard]] float decayRadius() const { return mDecayRadius; }
127+
[[nodiscard]] float r() const { return radius(); }
128+
[[nodiscard]] float pt() const { return std::hypot(mPx, mPy); }
129+
[[nodiscard]] float p() const { return std::hypot(mPx, mPy, mPz); }
130+
[[nodiscard]] float phi() const { return o2::constants::math::PI + std::atan2(-1.0f * py(), -1.0f * px()); }
131+
[[nodiscard]] float eta() const
133132
{
134133
// Conditionally defined to avoid FPEs
135134
// As https://github.com/AliceO2Group/AliceO2/blob/dev/Framework/Core/include/Framework/AnalysisDataModel.h#L1959
136135
static constexpr float Tolerance = 1e-7f;
137136
if ((p() - mPz) < Tolerance) {
138137
return (mPz < 0.0f) ? -100.0f : 100.0f;
139-
} else {
140-
return 0.5f * std::log((p() + mPz) / (p() - mPz));
141138
}
139+
return 0.5f * std::log((p() + mPz) / (p() - mPz));
142140
}
143-
float y() const
141+
[[nodiscard]] float y() const
144142
{
145143
// Conditionally defined to avoid FPEs
146144
// As https://github.com/AliceO2Group/AliceO2/blob/dev/Framework/Core/include/Framework/AnalysisDataModel.h#L1980
147145
static constexpr float Tolerance = 1e-7f;
148146
if ((e() - mPz) < Tolerance) {
149147
return (mPz < 0.0f) ? -100.0f : 100.0f;
150-
} else {
151-
return 0.5f * std::log((mE + mPz) / (mE - mPz));
152148
}
149+
return 0.5f * std::log((mE + mPz) / (mE - mPz));
153150
}
154-
int getMotherIndexStart() const { return mIndicesMother[0]; }
155-
int getMotherIndexStop() const { return mIndicesMother[1]; }
156-
int getDaughterIndexStart() const { return mIndicesDaughter[0]; }
157-
int getDaughterIndexStop() const { return mIndicesDaughter[1]; }
158-
const std::array<int, 2>& getMothers() const { return mIndicesMother; }
159-
const std::array<int, 2>& getDaughters() const { return mIndicesDaughter; }
160-
std::span<const int> getMotherSpan() const { return hasMothers() ? std::span<const int>(mIndicesMother.data(), 2) : std::span<const int>(); }
151+
[[nodiscard]] int getMotherIndexStart() const { return mIndicesMother[0]; }
152+
[[nodiscard]] int getMotherIndexStop() const { return mIndicesMother[1]; }
153+
[[nodiscard]] int getDaughterIndexStart() const { return mIndicesDaughter[0]; }
154+
[[nodiscard]] int getDaughterIndexStop() const { return mIndicesDaughter[1]; }
155+
[[nodiscard]] const std::array<int, 2>& getMothers() const { return mIndicesMother; }
156+
[[nodiscard]] const std::array<int, 2>& getDaughters() const { return mIndicesDaughter; }
157+
[[nodiscard]] std::span<const int> getMotherSpan() const { return hasMothers() ? std::span<const int>(mIndicesMother.data(), 2) : std::span<const int>(); }
161158

162159
// Checks
163-
bool hasDaughters() const { return (mIndicesDaughter[0] >= 0); }
164-
bool hasMothers() const { return (mIndicesMother[0] >= 0); }
165-
bool hasNaN() const
160+
[[nodiscard]] bool hasDaughters() const { return (mIndicesDaughter[0] >= 0); }
161+
[[nodiscard]] bool hasMothers() const { return (mIndicesMother[0] >= 0); }
162+
[[nodiscard]] bool hasNaN() const
166163
{
167164
return std::isnan(mPx) || std::isnan(mPy) || std::isnan(mPz) || std::isnan(mE) ||
168165
std::isnan(mVx) || std::isnan(mVy) || std::isnan(mVz);
169166
}
170-
bool hasIndex() const
167+
[[nodiscard]] bool hasIndex() const
171168
{
172169
return (mGlobalIndex != -1);
173170
}
174171

175172
// Bits
176-
bool checkBit(DecayerBits bit) const { return mBits.test(static_cast<size_t>(bit)); }
173+
[[nodiscard]] bool checkBit(DecayerBits bit) const { return mBits.test(static_cast<size_t>(bit)); }
177174
void setBit(DecayerBits bit, bool value = true) { mBits.set(static_cast<size_t>(bit), value); }
178175
void setBitOn(DecayerBits bit) { mBits.set(static_cast<size_t>(bit), true); }
179176
void setBitOff(DecayerBits bit) { mBits.set(static_cast<size_t>(bit), false); }
180177

181-
const std::bitset<8>& getBits() const { return mBits; }
182-
uint8_t getBitsValue() const { return static_cast<uint8_t>(mBits.to_ulong()); }
178+
[[nodiscard]] const std::bitset<8>& getBits() const { return mBits; }
179+
[[nodiscard]] uint8_t getBitsValue() const { return static_cast<uint8_t>(mBits.to_ulong()); }
183180
void setBits(std::bitset<8> bits) { mBits = bits; }
184181

185182
private:
@@ -191,7 +188,7 @@ class OTFParticle
191188

192189
int mStatusCode{};
193190
uint8_t mFlag{};
194-
std::bitset<8> mBits{};
191+
std::bitset<8> mBits;
195192
std::array<int, 2> mIndicesMother{-1, -1}, mIndicesDaughter{-1, -1};
196193
};
197194

0 commit comments

Comments
 (0)