Skip to content

Commit 084c366

Browse files
matthias-kleinerehellbar
matthias-kleiner
authored and
ehellbar
committed
TPC: add option for disabling corrections
- add option for using static corrections instead of main corrections
1 parent f8f5d1e commit 084c366

5 files changed

Lines changed: 96 additions & 41 deletions

File tree

‎Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx‎

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,8 +28,13 @@ using namespace o2::framework;
2828
void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc, float tpcScaler)
2929
{
3030
pc.inputs().get<o2::tpc::CorrMapParam*>("tpcCorrPar");
31-
pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
32-
pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
31+
const auto lumiMode = getLumiScaleMode();
32+
if (lumiMode != LumiScaleMode::NoCorrection && lumiMode != LumiScaleMode::StaticMapOnly) {
33+
pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
34+
}
35+
if (lumiMode != LumiScaleMode::NoCorrection) {
36+
pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
37+
}
3338
const int maxDumRep = 5;
3439
int dumRep = 0;
3540
o2::ctp::LumiInfo lumiObj;
@@ -97,6 +102,10 @@ void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, con
97102
// for MC corrections
98103
addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapMC), {}, 1)}); // time-dependent
99104
addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMapMC), {}, 1)}); // time-dependent
105+
} else if (gloOpts.lumiMode == LumiScaleMode::NoCorrection) {
106+
// no correction maps needed — a dummy map is created at runtime
107+
} else if (gloOpts.lumiMode == LumiScaleMode::StaticMapOnly) {
108+
addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
100109
} else {
101110
LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
102111
}

‎Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,13 @@ CorrectionMapsGloOpts CorrectionMapsOptions::parseGlobalOptions(const o2::framew
2121
{
2222
CorrectionMapsGloOpts tpcopt;
2323
auto lumiTypeVal = opts.get<int>("lumi-type");
24-
if (lumiTypeVal < -1 || lumiTypeVal > 2) {
24+
if (lumiTypeVal < static_cast<int>(LumiScaleType::Unset) || lumiTypeVal >= static_cast<int>(LumiScaleType::Count)) {
2525
LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
2626
}
2727
tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
2828

2929
auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
30-
if (lumiModeVal < -1 || lumiModeVal > 2) {
30+
if (lumiModeVal < static_cast<int>(LumiScaleMode::Unset) || lumiModeVal >= static_cast<int>(LumiScaleMode::Count)) {
3131
LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
3232
}
3333
tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);

‎Detectors/TPC/workflow/src/TPCScalerSpec.cxx‎

Lines changed: 34 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -183,40 +183,45 @@ class TPCScalerSpec : public Task
183183

184184
void buildMap(ProcessingContext& pc)
185185
{
186-
// reference map
187-
auto* corrMap = mTPCCorrMapsLoader.getCorrMap();
188-
189-
// // new correction map
186+
const auto lumiMode = mTPCCorrMapsLoader.getLumiScaleMode();
190187
o2::gpu::TPCFastTransform finalMap;
191-
finalMap.cloneFromObject(*corrMap, nullptr);
192-
finalMap.setApplyCorrectionOn();
193-
194-
const auto* corrMapRef = mTPCCorrMapsLoader.getCorrMapRef();
195-
const float lumiScale = mTPCCorrMapsLoader.getLumiScale();
196188
std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> additionalCorrections;
197189

198-
// if standard scaling is used: map(lumi) = (mean_map - ref_map) * lumiScale + ref_map
199-
if (mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::Linear) {
200-
const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step0{{&(corrMapRef->getCorrection()), -1.f}};
201-
// finalMap = (mean_map - finalMap)
202-
TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, step0, true);
203-
204-
// finalMap = finalMap * lumiScale + ref_map
205-
const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step1{{&(corrMapRef->getCorrection()), 1.f}};
206-
TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), lumiScale, step1, true);
207-
208-
} else if (mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::DerivativeMap || mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::DerivativeMapMC) {
209-
additionalCorrections.emplace_back(&(corrMapRef->getCorrection()), lumiScale);
210-
}
190+
if (lumiMode == LumiScaleMode::NoCorrection) {
191+
std::unique_ptr<o2::gpu::TPCFastTransform> dummy(TPCFastTransformHelperO2::instance()->create(0));
192+
finalMap.cloneFromObject(*dummy, nullptr);
193+
finalMap.setApplyCorrectionOff();
194+
} else {
195+
auto* corrMap = mTPCCorrMapsLoader.getCorrMap();
196+
const auto* corrMapRef = mTPCCorrMapsLoader.getCorrMapRef();
197+
finalMap.cloneFromObject(lumiMode == LumiScaleMode::StaticMapOnly && corrMapRef ? *corrMapRef : *corrMap, nullptr);
198+
finalMap.setApplyCorrectionOn();
199+
200+
const float lumiScale = mTPCCorrMapsLoader.getLumiScale();
201+
202+
// if standard scaling is used: map(lumi) = (mean_map - ref_map) * lumiScale + ref_map
203+
if (lumiMode == LumiScaleMode::Linear) {
204+
const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step0{{&(corrMapRef->getCorrection()), -1.f}};
205+
// finalMap = (mean_map - finalMap)
206+
TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, step0, true);
207+
208+
// finalMap = finalMap * lumiScale + ref_map
209+
const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step1{{&(corrMapRef->getCorrection()), 1.f}};
210+
TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), lumiScale, step1, true);
211+
212+
} else if (lumiMode == LumiScaleMode::DerivativeMap || lumiMode == LumiScaleMode::DerivativeMapMC) {
213+
additionalCorrections.emplace_back(&(corrMapRef->getCorrection()), lumiScale);
214+
}
211215

212-
// if mshape map valid
213-
if (!mTPCCorrMapsLoader.isCorrMapMShapeDummy()) {
214-
LOGP(info, "Adding M-shape correction to the final map with scaling factor {}", mMShapeScalingFac);
215-
additionalCorrections.emplace_back(&(mTPCCorrMapsLoader.getCorrMapMShape()->getCorrection()), 1.f);
216-
}
216+
// if mshape map valid
217+
if (!mTPCCorrMapsLoader.isCorrMapMShapeDummy()) {
218+
LOGP(info, "Adding M-shape correction to the final map with scaling factor {}", mMShapeScalingFac);
219+
additionalCorrections.emplace_back(&(mTPCCorrMapsLoader.getCorrMapMShape()->getCorrection()), 1.f);
220+
}
217221

218-
if (!additionalCorrections.empty()) {
219-
TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, additionalCorrections, true);
222+
if (!additionalCorrections.empty()) {
223+
TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, additionalCorrections, true);
224+
}
220225
}
221226

222227
Output corrMapOutput{header::gDataOriginTPC, "TPCCORRMAP", 0};

‎GPU/TPCFastTransformation/CorrectionMapsHelper.cxx‎

Lines changed: 40 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,10 @@ void CorrectionMapsHelper::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&&
3838
void CorrectionMapsHelper::updateLumiScale(bool report)
3939
{
4040
if (!canUseCorrections()) {
41+
if (mLumiScaleMode != LumiScaleMode::NoCorrection) {
42+
LOGP(warning, "Negative meanLumi={} detected, switching to NoCorrection mode for backward compatibility", mMeanLumi);
43+
mLumiScaleMode = LumiScaleMode::NoCorrection;
44+
}
4145
mLumiScale = -1.f;
4246
} else if ((mLumiScaleMode == LumiScaleMode::DerivativeMap) || (mLumiScaleMode == LumiScaleMode::DerivativeMapMC)) {
4347
mLumiScale = mMeanLumiRef ? (mInstLumi - mMeanLumi) / mMeanLumiRef : 0.f;
@@ -54,7 +58,40 @@ void CorrectionMapsHelper::updateLumiScale(bool report)
5458
//________________________________________________________
5559
void CorrectionMapsHelper::reportScaling()
5660
{
57-
LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={}, meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape map valid: {}, M-Shape default: {}",
58-
mLumiScaleType == LumiScaleType::NoScaling ? "NoScaling" : (mLumiScaleType == LumiScaleType::CTPLumi ? "LumiCTP" : "TPCScaler"), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
59-
mLumiScaleMode == LumiScaleMode::Linear ? "Linear" : "Derivative", (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
61+
auto lumiTypeName = [](LumiScaleType t) {
62+
switch (t) {
63+
case LumiScaleType::NoScaling:
64+
return "NoScaling";
65+
case LumiScaleType::CTPLumi:
66+
return "CTPLumi";
67+
case LumiScaleType::TPCScaler:
68+
return "TPCScaler";
69+
default:
70+
return "Unknown";
71+
}
72+
};
73+
74+
const bool mshapeValid = (mCorrMapMShape != nullptr) && !isCorrMapMShapeDummy();
75+
76+
if (mLumiScaleMode == LumiScaleMode::NoCorrection) {
77+
LOGP(info, "Map scaling update: mode=NoCorrection (corrections disabled, dummy map in use)");
78+
} else if (mLumiScaleMode == LumiScaleMode::StaticMapOnly) {
79+
LOGP(info, "Map scaling update: mode=StaticMapOnly (static reference map, no lumi scaling), M-Shape correction: {}", mshapeValid ? "applied" : "not applied");
80+
} else {
81+
auto lumiModeName = [](LumiScaleMode m) {
82+
switch (m) {
83+
case LumiScaleMode::Linear:
84+
return "Linear";
85+
case LumiScaleMode::DerivativeMap:
86+
return "DerivativeMap";
87+
case LumiScaleMode::DerivativeMapMC:
88+
return "DerivativeMapMC";
89+
default:
90+
return "Unknown";
91+
}
92+
};
93+
LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={} meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape correction: {}",
94+
lumiTypeName(mLumiScaleType), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
95+
lumiModeName(mLumiScaleMode), mshapeValid ? "applied" : "not applied");
96+
}
6097
}

‎GPU/TPCFastTransformation/CorrectionMapsTypes.h‎

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,18 @@ enum class LumiScaleType : int {
2222
Unset = -1, ///< init value
2323
NoScaling = 0, ///< no scaling, use map as is
2424
CTPLumi = 1, ///< use CTP luminosity for scaling
25-
TPCScaler = 2 ///< use TPC scaler for scaling
25+
TPCScaler = 2, ///< use TPC scaler for scaling
26+
Count ///< sentinel - keep last
2627
};
2728

2829
enum class LumiScaleMode : int {
29-
Unset = -1, ///< init value
30-
Linear = 0, ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
31-
DerivativeMap = 1, ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
32-
DerivativeMapMC = 2 ///< same DerivativeMap, but for MC
30+
Unset = -1, ///< init value
31+
Linear = 0, ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
32+
DerivativeMap = 1, ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
33+
DerivativeMapMC = 2, ///< same DerivativeMap, but for MC
34+
NoCorrection = 3, ///< no corrections at all
35+
StaticMapOnly = 4, ///< use only static map instead of main map
36+
Count ///< sentinel - keep last
3337
};
3438

3539
struct CorrectionMapsGloOpts {

0 commit comments

Comments
 (0)