Skip to content

Commit 3dacfca

Browse files
martenoledavidrohr
martenole
authored and
davidrohr
committed
TPC residual aggregator optionally writes binned residuals, unbinned residuals or track data
1 parent a56e678 commit 3dacfca

13 files changed

Lines changed: 256 additions & 93 deletions

File tree

‎Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCInterpolationSpec.h‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ namespace tpc
3737
class TPCInterpolationDPL : public Task
3838
{
3939
public:
40-
TPCInterpolationDPL(std::shared_ptr<o2::globaltracking::DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool processITSTPConly, bool writeResiduals) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC), mProcessITSTPConly(processITSTPConly), mWriteResiduals(writeResiduals) {}
40+
TPCInterpolationDPL(std::shared_ptr<o2::globaltracking::DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool processITSTPConly, bool writeResiduals, bool sendTrackData) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC), mProcessITSTPConly(processITSTPConly), mWriteResiduals(writeResiduals), mSendTrackData(sendTrackData) {}
4141
~TPCInterpolationDPL() override = default;
4242
void init(InitContext& ic) final;
4343
void run(ProcessingContext& pc) final;
@@ -53,11 +53,12 @@ class TPCInterpolationDPL : public Task
5353
bool mUseMC{false}; ///< MC flag
5454
bool mProcessITSTPConly{false}; ///< should also tracks without outer point (ITS-TPC only) be processed?
5555
bool mWriteResiduals{false}; ///< whether or not the unbinned unfiltered residuals should be sent out
56+
bool mSendTrackData{false}; ///< if true, not only the clusters but also corresponding track data will be sent
5657
TStopwatch mTimer;
5758
};
5859

5960
/// create a processor spec
60-
framework::DataProcessorSpec getTPCInterpolationSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, bool processITSTPConly, bool writeResiduals);
61+
framework::DataProcessorSpec getTPCInterpolationSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, bool processITSTPConly, bool writeResiduals, bool sendTrackData);
6162

6263
} // namespace tpc
6364
} // namespace o2

‎Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h‎

Lines changed: 29 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ namespace calibration
3838
class ResidualAggregatorDevice : public o2::framework::Task
3939
{
4040
public:
41-
ResidualAggregatorDevice(std::shared_ptr<o2::base::GRPGeomRequest> req) : mCCDBRequest(req) {}
41+
ResidualAggregatorDevice(std::shared_ptr<o2::base::GRPGeomRequest> req, bool trackInput, bool writeUnbinnedResiduals, bool writeBinnedResiduals, bool writeTrackData) : mCCDBRequest(req), mTrackInput(trackInput), mWriteUnbinnedResiduals(writeUnbinnedResiduals), mWriteBinnedResiduals(writeBinnedResiduals), mWriteTrackData(writeTrackData) {}
4242

4343
void init(o2::framework::InitContext& ic) final
4444
{
@@ -67,7 +67,9 @@ class ResidualAggregatorDevice : public o2::framework::Task
6767
mAggregator->setSlotLength(slotLength);
6868
mAggregator->setMaxSlotsDelay(delay);
6969
mAggregator->setCheckIntervalInfiniteSlot(updateInterval);
70-
mAggregator->initOutput();
70+
mAggregator->setWriteBinnedResiduals(mWriteBinnedResiduals);
71+
mAggregator->setWriteUnbinnedResiduals(mWriteUnbinnedResiduals);
72+
mAggregator->setWriteTrackData(mWriteTrackData);
7173
}
7274

7375
void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
@@ -79,9 +81,20 @@ class ResidualAggregatorDevice : public o2::framework::Task
7981
{
8082
updateTimeDependentParams(pc);
8183

82-
auto data = pc.inputs().get<gsl::span<o2::tpc::TrackResiduals::UnbinnedResid>>("input");
84+
auto residualsData = pc.inputs().get<gsl::span<o2::tpc::TrackResiduals::UnbinnedResid>>("unbinnedRes");
85+
86+
// track data input is optional
87+
const gsl::span<const o2::tpc::TrackData>* trkDataPtr = nullptr;
88+
using trkDataType = std::decay_t<decltype(pc.inputs().get<gsl::span<o2::tpc::TrackData>>(""))>;
89+
std::optional<trkDataType> trkData;
90+
if (mTrackInput) {
91+
trkData.emplace(pc.inputs().get<gsl::span<o2::tpc::TrackData>>("trkData"));
92+
trkDataPtr = &trkData.value();
93+
}
94+
95+
auto data = std::make_pair<gsl::span<const o2::tpc::TrackData>, gsl::span<const o2::tpc::TrackResiduals::UnbinnedResid>>(std::move(*trkData), std::move(residualsData));
8396
o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mAggregator->getCurrentTFInfo());
84-
LOG(debug) << "Processing TF " << mAggregator->getCurrentTFInfo().tfCounter << " with " << data.size() << " unbinned residuals";
97+
LOG(debug) << "Processing TF " << mAggregator->getCurrentTFInfo().tfCounter << " with " << trkData->size() << " tracks and " << residualsData.size() << " unbinned residuals associated to them";
8598
mAggregator->process(data);
8699
}
87100

@@ -102,18 +115,26 @@ class ResidualAggregatorDevice : public o2::framework::Task
102115
mAggregator->setDataTakingContext(pc.services().get<DataTakingContext>());
103116
}
104117
}
105-
std::unique_ptr<o2::tpc::ResidualAggregator> mAggregator;
118+
std::unique_ptr<o2::tpc::ResidualAggregator> mAggregator; ///< the TimeSlotCalibration device
106119
std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
120+
bool mTrackInput{false}; ///< flag whether to expect track data as input
121+
bool mWriteBinnedResiduals{false}; ///< flag, whether to write binned residuals to output file
122+
bool mWriteUnbinnedResiduals{false}; ///< flag, whether to write unbinned residuals to output file
123+
bool mWriteTrackData{false}; ///< flag, whether to write track data to output file
107124
};
108125

109126
} // namespace calibration
110127

111128
namespace framework
112129
{
113130

114-
DataProcessorSpec getTPCResidualAggregatorSpec()
131+
DataProcessorSpec getTPCResidualAggregatorSpec(bool trackInput, bool writeUnbinnedResiduals, bool writeBinnedResiduals, bool writeTrackData)
115132
{
116-
std::vector<InputSpec> inputs{{"input", "GLO", "UNBINNEDRES"}};
133+
std::vector<InputSpec> inputs;
134+
inputs.emplace_back("unbinnedRes", "GLO", "UNBINNEDRES");
135+
if (trackInput) {
136+
inputs.emplace_back("trkData", "GLO", "TRKDATA");
137+
}
117138
auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true, // orbitResetTime
118139
true, // GRPECS=true
119140
false, // GRPLHCIF
@@ -125,7 +146,7 @@ DataProcessorSpec getTPCResidualAggregatorSpec()
125146
"residual-aggregator",
126147
inputs,
127148
Outputs{},
128-
AlgorithmSpec{adaptFromTask<o2::calibration::ResidualAggregatorDevice>(ccdbRequest)},
149+
AlgorithmSpec{adaptFromTask<o2::calibration::ResidualAggregatorDevice>(ccdbRequest, trackInput, writeUnbinnedResiduals, writeBinnedResiduals, writeTrackData)},
129150
Options{
130151
{"tf-per-slot", VariantType::UInt32, 6'000u, {"number of TFs per calibration time slot (put 0 for infinite slot length)"}},
131152
{"updateInterval", VariantType::UInt32, 6'000u, {"update interval in number of TFs in case slot length is infinite"}},

‎Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -149,6 +149,9 @@ void TPCInterpolationDPL::run(ProcessingContext& pc)
149149
pc.outputs().snapshot(Output{"GLO", "TPCINT_RES", 0, Lifetime::Timeframe}, mInterpolation.getClusterResiduals());
150150
}
151151
pc.outputs().snapshot(Output{"GLO", "UNBINNEDRES", 0, Lifetime::Timeframe}, mResidualProcessor.getUnbinnedResiduals());
152+
if (mSendTrackData) {
153+
pc.outputs().snapshot(Output{"GLO", "TRKDATA", 0, Lifetime::Timeframe}, mResidualProcessor.getTrackDataOut());
154+
}
152155

153156
mInterpolation.reset();
154157
mResidualProcessor.resetUnbinnedResiduals();
@@ -160,7 +163,7 @@ void TPCInterpolationDPL::endOfStream(EndOfStreamContext& ec)
160163
mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
161164
}
162165

163-
DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t src, bool useMC, bool processITSTPConly, bool writeResiduals)
166+
DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t src, bool useMC, bool processITSTPConly, bool writeResiduals, bool sendTrackData)
164167
{
165168
auto dataRequest = std::make_shared<DataRequest>();
166169
std::vector<OutputSpec> outputs;
@@ -185,12 +188,13 @@ DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t src, bool useMC, bool
185188
outputs.emplace_back("GLO", "TPCINT_RES", 0, Lifetime::Timeframe);
186189
}
187190
outputs.emplace_back("GLO", "UNBINNEDRES", 0, Lifetime::Timeframe);
191+
outputs.emplace_back("GLO", "TRKDATA", 0, Lifetime::Timeframe);
188192

189193
return DataProcessorSpec{
190194
"tpc-track-interpolation",
191195
dataRequest->inputs,
192196
outputs,
193-
AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, ggRequest, useMC, processITSTPConly, writeResiduals)},
197+
AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, ggRequest, useMC, processITSTPConly, writeResiduals, sendTrackData)},
194198
Options{}};
195199
}
196200

‎Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
4040
{"enable-itsonly", VariantType::Bool, false, {"process tracks without outer point (ITS-TPC only)"}},
4141
{"tracking-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use for tracking"}},
4242
{"enable-residual-writer", VariantType::Bool, false, {"write unbinned and unfiltered residuals"}},
43+
{"send-track-data", VariantType::Bool, false, {"Send also the track information to the aggregator"}},
4344
{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
4445
o2::raw::HBFUtilsInitializer::addConfigOption(options);
4546
std::swap(workflowOptions, options);
@@ -74,10 +75,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
7475
useMC = false; // force disabling MC as long as it is not implemented
7576
auto processITSTPConly = configcontext.options().get<bool>("enable-itsonly");
7677
auto writeResiduals = configcontext.options().get<bool>("enable-residual-writer");
78+
auto sendTrackData = configcontext.options().get<bool>("send-track-data");
7779
GID::mask_t src = allowedSources & GID::getSourcesMask(configcontext.options().get<std::string>("tracking-sources"));
7880
LOG(info) << "Data sources: " << GID::getSourcesNames(src);
7981

80-
specs.emplace_back(o2::tpc::getTPCInterpolationSpec(src, useMC, processITSTPConly, writeResiduals));
82+
specs.emplace_back(o2::tpc::getTPCInterpolationSpec(src, useMC, processITSTPConly, writeResiduals, sendTrackData));
8183
if (!configcontext.options().get<bool>("disable-root-output") && writeResiduals) {
8284
specs.emplace_back(o2::tpc::getTPCResidualWriterSpec(useMC));
8385
}

‎Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx‎

Lines changed: 32 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,10 @@ using namespace o2::framework;
1818
// we need to add workflow options before including Framework/runDataProcessing
1919
void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
2020
{
21-
std::vector<o2::framework::ConfigParamSpec> options{{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
21+
std::vector<o2::framework::ConfigParamSpec> options{
22+
{"output-type", VariantType::String, "binnedResid", {"Comma separated list of outputs (without spaces). Valid strings: unbinnedResid, binnedResid, trackParams"}},
23+
{"enable-track-input", VariantType::Bool, false, {"Whether to expect track data from interpolation workflow"}},
24+
{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
2225
std::swap(workflowOptions, options);
2326
}
2427

@@ -29,8 +32,35 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
2932
WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
3033
{
3134
o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
35+
auto trkInput = configcontext.options().get<bool>("enable-track-input");
36+
37+
bool writeUnbinnedResiduals = false;
38+
bool writeBinnedResiduals = false;
39+
bool writeTrackData = false;
40+
auto outputType = configcontext.options().get<string>("output-type");
41+
std::vector<std::string> outputTypes;
42+
size_t pos = 0;
43+
while ((pos = outputType.find(",")) != std::string::npos) {
44+
outputTypes.push_back(outputType.substr(0, pos));
45+
outputType.erase(0, pos + 1);
46+
}
47+
outputTypes.push_back(outputType);
48+
for (const auto& out : outputTypes) {
49+
if (out == "unbinnedResid") {
50+
writeUnbinnedResiduals = true;
51+
} else if (out == "binnedResid") {
52+
writeBinnedResiduals = true;
53+
} else if (out == "trackParams") {
54+
if (!trkInput) {
55+
LOG(error) << "Track output will be empty, because it is not configured as input";
56+
}
57+
writeTrackData = true;
58+
} else {
59+
LOG(error) << "Invalid output requested: " << out;
60+
}
61+
}
3262

3363
WorkflowSpec specs;
34-
specs.emplace_back(getTPCResidualAggregatorSpec());
64+
specs.emplace_back(getTPCResidualAggregatorSpec(trkInput, writeUnbinnedResiduals, writeBinnedResiduals, writeTrackData));
3565
return specs;
3666
}

‎Detectors/TPC/calibration/SpacePoints/include/SpacePoints/ResidualAggregator.h‎

Lines changed: 18 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -42,11 +42,11 @@ struct ResidualsContainer {
4242
ResidualsContainer& operator=(const ResidualsContainer& src) = delete;
4343
~ResidualsContainer();
4444

45-
void init(const TrackResiduals* residualsEngine, std::string outputDir);
45+
void init(const TrackResiduals* residualsEngine, std::string outputDir, bool wBinnedResid, bool wUnbinnedResid, bool wTrackData);
4646
void fillStatisticsBranches();
4747
uint64_t getNEntries() const { return nResidualsTotal; }
4848

49-
void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const TrackResiduals::UnbinnedResid> data);
49+
void fill(const o2::dataformats::TFIDInfo& ti, const std::pair<gsl::span<const o2::tpc::TrackData>, gsl::span<const TrackResiduals::UnbinnedResid>> data);
5050
void merge(ResidualsContainer* prev);
5151
void print();
5252

@@ -58,19 +58,27 @@ struct ResidualsContainer {
5858
uint32_t runNumber; ///< run number (required for meta data file)
5959
std::vector<uint32_t> tfOrbits, *tfOrbitsPtr{&tfOrbits}; ///< first TF orbit
6060
std::vector<uint32_t> sumOfResiduals, *sumOfResidualsPtr{&sumOfResiduals}; ///< sum of residuals for each TF
61+
std::vector<TrackResiduals::UnbinnedResid> unbinnedRes, *unbinnedResPtr{&unbinnedRes}; // unbinned residuals
62+
std::vector<TrackData> trkData, *trkDataPtr{&trkData}; // track data and cluster ranges
6163

6264
std::string fileName{"o2tpc_residuals"};
6365
std::string treeNameResiduals{"resid"};
6466
std::string treeNameStats{"stats"};
6567
std::string treeNameRecords{"records"};
6668
std::unique_ptr<TFile> fileOut{nullptr};
69+
std::unique_ptr<TTree> treeOutResidualsUnbinned{nullptr};
70+
std::unique_ptr<TTree> treeOutTrackData{nullptr};
6771
std::unique_ptr<TTree> treeOutResiduals{nullptr};
6872
std::unique_ptr<TTree> treeOutStats{nullptr};
6973
std::unique_ptr<TTree> treeOutRecords{nullptr};
7074

75+
bool writeBinnedResid{false};
76+
bool writeUnbinnedResiduals{false};
77+
bool writeTrackData{false};
78+
7179
uint64_t nResidualsTotal{0};
7280

73-
ClassDefNV(ResidualsContainer, 1);
81+
ClassDefNV(ResidualsContainer, 2);
7482
};
7583

7684
class ResidualAggregator final : public o2::calibration::TimeSlotCalibration<TrackResiduals::UnbinnedResid, ResidualsContainer>
@@ -89,6 +97,9 @@ class ResidualAggregator final : public o2::calibration::TimeSlotCalibration<Tra
8997
mStoreMetaData = true;
9098
}
9199
void setLHCPeriod(std::string period) { mLHCPeriod = period; }
100+
void setWriteBinnedResiduals(bool f) { mWriteBinnedResiduals = f; }
101+
void setWriteUnbinnedResiduals(bool f) { mWriteUnbinnedResiduals = f; }
102+
void setWriteTrackData(bool f) { mWriteTrackData = f; }
92103

93104
bool hasEnoughData(const Slot& slot) const final;
94105
void initOutput() final;
@@ -102,9 +113,12 @@ class ResidualAggregator final : public o2::calibration::TimeSlotCalibration<Tra
102113
std::string mMetaOutputDir{"none"}; ///< the directory where the meta data file is stored
103114
std::string mLHCPeriod{""}; ///< the LHC period to be put into the meta file
104115
bool mStoreMetaData{false}; ///< flag, whether meta file is supposed to be stored
116+
bool mWriteBinnedResiduals{false}; ///< flag, whether to write binned residuals to output file
117+
bool mWriteUnbinnedResiduals{false}; ///< flag, whether to write unbinned residuals to output file
118+
bool mWriteTrackData{false}; ///< flag, whether to write track data to output file
105119
size_t mMinEntries; ///< the minimum number of residuals required for the map creation (per voxel)
106120

107-
ClassDefOverride(ResidualAggregator, 1);
121+
ClassDefOverride(ResidualAggregator, 2);
108122
};
109123

110124
} // namespace tpc

‎Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -57,22 +57,22 @@ struct TPCClusterResiduals {
5757
float tgl{}; ///< dip angle of track
5858
unsigned char sec{}; ///< sector number 0..35
5959
unsigned char dRow{}; ///< distance to previous row in units of pad rows
60-
short row{}; ///< TPC pad row (absolute units)
6160
void setDY(float val) { dy = fabs(val) < param::MaxResid ? val : std::copysign(param::MaxResid, val); }
6261
void setDZ(float val) { dz = fabs(val) < param::MaxResid ? val : std::copysign(param::MaxResid, val); }
6362
void setY(float val) { y = fabs(val) < param::MaxY ? val : std::copysign(param::MaxY, val); }
6463
void setZ(float val) { z = fabs(val) < param::MaxZ ? val : std::copysign(param::MaxZ, val); }
6564
void setPhi(float val) { phi = fabs(val) < param::MaxTgSlp ? val : std::copysign(param::MaxTgSlp, val); }
6665
void setTgl(float val) { tgl = fabs(val) < param::MaxTgSlp ? val : std::copysign(param::MaxTgSlp, val); }
67-
ClassDefNV(TPCClusterResiduals, 1);
66+
ClassDefNV(TPCClusterResiduals, 2);
6867
};
6968

7069
/// Structure filled for each track with track quality information and a vector with TPCClusterResiduals
7170
struct TrackData {
7271
o2::dataformats::GlobalTrackID gid{}; ///< global track ID for seeding track
73-
float eta{}; ///< track dip angle
74-
float phi{}; ///< track azimuthal angle
75-
float qPt{}; ///< track q/pT
72+
// the track parameters are taken from the ITS track
73+
float x{}; ///< track X position
74+
float alpha{}; ///< track alpha angle
75+
std::array<float, o2::track::kNParams> p{}; ///< track parameters
7676
float chi2TPC{}; ///< chi2 of TPC track
7777
float chi2ITS{}; ///< chi2 of ITS track
7878
unsigned short nClsTPC{}; ///< number of attached TPC clusters

‎Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -193,6 +193,9 @@ class TrackResiduals
193193
/// Returns the collected unbinned residuals after outlier rejection is applied
194194
std::vector<UnbinnedResid>& getUnbinnedResiduals() { return mUnbinnedResiduals; }
195195

196+
/// Returns the track parameters and cluster range reference for validated tracks (this is a subset of the input mTrackDataPtr)
197+
std::vector<TrackData>& getTrackDataOut() { return mTrackDataOut; }
198+
196199
/// Create output files for each sector with trees for local residuals
197200
void prepareLocalResidualTrees();
198201

@@ -556,14 +559,15 @@ class TrackResiduals
556559
TTree* mTreeInTracks{nullptr}; ///< tree with input track information
557560
std::vector<TrackData>* mTrackDataPtr{nullptr}; ///< vector with input track information
558561
TTree* mTreeInClRes{nullptr}; ///< tree with TPC cluster residuals
559-
std::vector<TPCClusterResiduals>* mClResPtr{nullptr}; ///< vector with TPC cluster residuals
562+
std::vector<TPCClusterResiduals>* mClResPtr{nullptr}; ///< vector with unbinned TPC cluster residuals
560563
std::vector<LocalResid> mLocalResidualsIn; ///< binned local residuals from aggregator
561564
std::vector<VoxStats> mVoxStatsIn, *mVoxStatsInPtr{&mVoxStatsIn}; ///< the statistics information for each voxel from the aggregator
562565
// output data
563566
std::unique_ptr<TFile> mFileOut; ///< output debug file
564567
std::unique_ptr<TTree> mTreeOut; ///< tree holding debug output
565568
std::vector<UnbinnedResid> mUnbinnedResiduals; ///< large vector for the unbinned residual data which is sent to the aggregator
566569
std::vector<UnbinnedResid>* mUnbinnedResidualsPtr{&mUnbinnedResiduals};
570+
std::vector<TrackData> mTrackDataOut; // the same as mTrackDataPtr, but the rejected tracks are removed, to be sent to the aggregator
567571
// status flags
568572
bool mIsInitialized{}; ///< initialize only once
569573
bool mPrintMem{}; ///< turn on to print memory usage at certain points
@@ -630,7 +634,7 @@ class TrackResiduals
630634
float mMaxRejFrac{.15f}; ///< if the fraction of rejected clusters of a track is higher, the full track is invalidated
631635
float mMaxRMSLong{.8f}; ///< maximum variance of the cluster residuals wrt moving avarage for a track to be considered
632636

633-
ClassDefNV(TrackResiduals, 1);
637+
ClassDefNV(TrackResiduals, 2);
634638
};
635639

636640
//_____________________________________________________

0 commit comments

Comments
 (0)