Merge 6232cbc into sapling-pr-archive-ktf

Author: ktf

DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h

@@ -49,14 +49,19 @@ class Cluster : public o2::BaseCluster<float>
          kDownRight = 4, // 2^4, 5th bit
          kDown = 5,      // 2^5, 6th bit
          kDownLeft = 6,  // 2^6, 7th bit
-         kLeft = 7 };    // 2^7, 8th bit
+         kLeft = 7,      // 2^7, 8th bit
+         //
+         FrameBit = 6 }; // this bit set means that the cluster is in the nominal (alpha=20*sector+10 deg.) sector frame rather than aligned
 
   Cluster() = default;
 
   Cluster(std::int16_t sensid, float x, float y, float z, float sy2, float sz2, float syz, double timeRaw, double time, float tot, int L0L1latency, int deltaBC, float geanttime = 0.0, double t0 = 0.0);
 
   ~Cluster() = default;
 
+  bool isInNominalSector() const { return isBitSet(FrameBit); }
+  void setInNominalSector() { setBit(FrameBit); }
+
   std::int8_t getSector() const { return getCount(); }
   void setSector(std::int8_t value) { setCount(value); }
 

DataFormats/Detectors/TPC/include/DataFormatsTPC/LtrCalibData.h

@@ -42,6 +42,7 @@ struct LtrCalibData {
   std::vector<uint16_t> matchedLtrIDs; ///< matched laser track IDs
   std::vector<uint16_t> nTrackTF;      ///< number of laser tracks per TF
   std::vector<float> dEdx;             ///< dE/dx of each track
+  float tp{0.f};                       ///< temperature over pressure ratio
 
   bool isValid() const
   {
@@ -138,7 +139,7 @@ struct LtrCalibData {
     dEdx.clear();
   }
 
-  ClassDefNV(LtrCalibData, 4);
+  ClassDefNV(LtrCalibData, 5);
 };
 
 } // namespace o2::tpc

DataFormats/Detectors/TPC/include/DataFormatsTPC/VDriftCorrFact.h

@@ -26,27 +26,35 @@ namespace o2::tpc
 {
 
 struct VDriftCorrFact {
-  long firstTime{};       ///< first time stamp of processed TFs
-  long lastTime{};        ///< last time stamp of processed TFs
-  long creationTime{};    ///< time of creation
-  float corrFact{1.0};    ///< drift velocity correction factor (multiplicative)
-  float corrFactErr{0.0}; ///< stat error of correction factor
-  float refVDrift{0.};    ///< reference vdrift for which factor was extracted
+  long firstTime{};         ///< first time stamp of processed TFs
+  long lastTime{};          ///< last time stamp of processed TFs
+  long creationTime{};      ///< time of creation
+  float corrFact{1.0};      ///< drift velocity correction factor (multiplicative)
+  float corrFactErr{0.0};   ///< stat error of correction factor
+  float refVDrift{0.};      ///< reference vdrift for which factor was extracted
   float refTimeOffset{0.};  ///< additive time offset reference (\mus)
   float timeOffsetCorr{0.}; ///< additive time offset correction (\mus)
+  float refTP{0.};          ///< reference temperature / pressure for which refVDrift was extracted
 
   float getVDrift() const { return refVDrift * corrFact; }
   float getVDriftError() const { return refVDrift * corrFactErr; }
 
   float getTimeOffset() const { return refTimeOffset + timeOffsetCorr; }
 
   // renormalize VDrift reference and correction either to provided new reference (if >0) or to correction 1 wrt current reference
-  void normalize(float newVRef = 0.f)
+  void normalize(float newVRef = 0.f, float tp = 0.f)
   {
+    float normVDrift = newVRef;
     if (newVRef == 0.f) {
-      newVRef = refVDrift * corrFact;
+      normVDrift = refVDrift * corrFact;
+      newVRef = normVDrift;
+      if ((tp > 0) && (refTP > 0)) {
+        // linear scaling based on relative change of T/P
+        normVDrift *= refTP / tp;
+        refTP = tp; // update reference T/P
+      }
     }
-    float fact = refVDrift / newVRef;
+    float fact = refVDrift / normVDrift;
     refVDrift = newVRef;
     corrFactErr *= fact;
     corrFact *= fact;
@@ -66,7 +74,7 @@ struct VDriftCorrFact {
     }
   }
 
-  ClassDefNV(VDriftCorrFact, 2);
+  ClassDefNV(VDriftCorrFact, 3);
 };
 
 } // namespace o2::tpc

Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx

@@ -125,11 +125,9 @@ int main(int argc, char** argv)
     } else {
       std::cout << "Storing:" << ccdbPath << " tmin:" << tmin << " tmax:" << tmax << " ts:" << tt << std::endl;
       std::string filename = "orbitReset.root";
-      TClass* tcls = TClass::GetClass(typeid(vect));
-      auto ti = tcls->GetTypeInfo();
       auto classname = "std::vector<int64_t>";
       metadata["adjustableEOV"] = "true";
-      ret = api.storeAsTFile_impl(&(vect), *ti, ccdbPath, metadata, tmin, tmax);
+      ret = api.storeAsTFileAny(&(vect), ccdbPath, metadata, tmin, tmax);
       o2::ccdb::CcdbObjectInfo oi(ccdbPath, classname, filename, metadata, tmin, tmax);
       adjustOverriddenEOV(api, oi);
     }

Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx

@@ -157,9 +157,14 @@ int ctpCCDBManager::saveOrbitReset(long timeStamp)
   o2::ccdb::CcdbApi api;
   std::map<std::string, std::string> metadata; // can be empty
   api.init(mCCDBHost.c_str());  // or http://localhost:8080 for a local installation
-
-  // store abitrary user object in strongly typed manner
-  int ret = api.storeAsTFileAny(&vect, mCCDBPathOrbitReset, metadata, tmin, tmax);
+  // int ret = api.storeAsTFileAny(&vect, mCCDBPathOrbitReset, metadata, tmin, tmax);
+  std::cout << "Storing:" << mCCDBPathOrbitReset << " tmin:" << tmin << " tmax:" << tmax << " ts:" << timeStamp << std::endl;
+  std::string filename = "orbitReset.root";
+  auto classname = "std::vector<int64_t>";
+  metadata["adjustableEOV"] = "true";
+  int ret = api.storeAsTFileAny(&(vect), mCCDBPathOrbitReset, metadata, tmin, tmax);
+  o2::ccdb::CcdbObjectInfo oi(mCCDBPathOrbitReset, classname, filename, metadata, tmin, tmax);
+  adjustOverriddenEOV(api, oi);
   if (ret == 0) {
     LOG(info) << "Orbit reset  saved in ccdb:" << mCCDBHost << " tmin:" << tmin << " tmax:" << tmax;
   } else {

Detectors/Calibration/include/DetectorsCalibration/IntegratedClusterCalibrator.h

@@ -331,6 +331,9 @@ struct TimeSeriesdEdx {
 };
 
 struct TimeSeriesITSTPC {
+  float mVDrift = 0;                          ///< drift velocity in cm/us
+  float mPressure = 0;                        ///< pressure
+  float mTemperature = 0;                     ///< temperature
   TimeSeries mTSTPC;                          ///< TPC standalone DCAs
   TimeSeries mTSITSTPC;                       ///< ITS-TPC standalone DCAs
   ITSTPC_Matching mITSTPCAll;                 ///< ITS-TPC matching efficiency for ITS standalone + afterburner
@@ -499,7 +502,7 @@ struct TimeSeriesITSTPC {
     nVertexContributors_Quantiles.resize(nTotalQ);
   }
 
-  ClassDefNV(TimeSeriesITSTPC, 5);
+  ClassDefNV(TimeSeriesITSTPC, 6);
 };
 
 } // end namespace tpc

Detectors/GlobalTracking/src/MatchTPCITS.cxx

@@ -101,7 +101,7 @@ void MatchTPCITS::run(const o2::globaltracking::RecoContainer& inp,
       break;
     }
     if (mVDriftCalibOn) { // in the beginning of the output vector we send the full and reference VDrift used for this TF
-      calib.emplace_back(mTPCVDrift, mTPCDrift.refVDrift, -999.);
+      calib.emplace_back(mTPCVDrift, mTPCDrift.refVDrift, mTPCDrift.refTP);
       calib.emplace_back(mTPCDriftTimeOffset, mTPCDrift.refTimeOffset, -999.);
     }
 

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

@@ -38,7 +38,8 @@ namespace tpc
 class TPCInterpolationDPL : public Task
 {
  public:
-  TPCInterpolationDPL(std::shared_ptr<o2::globaltracking::DataRequest> dr, o2::dataformats::GlobalTrackID::mask_t src, o2::dataformats::GlobalTrackID::mask_t srcMap, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput) : mDataRequest(dr), mSources(src), mSourcesMap(srcMap), mGGCCDBRequest(gr), mUseMC(useMC), mProcessITSTPConly(processITSTPConly), mSendTrackData(sendTrackData), mDebugOutput(debugOutput) {}
+  TPCInterpolationDPL(std::shared_ptr<o2::globaltracking::DataRequest> dr, o2::dataformats::GlobalTrackID::mask_t src, o2::dataformats::GlobalTrackID::mask_t srcMap, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC,
+                      bool processITSTPConly, bool sendTrackData, bool debugOutput, bool extDetResid) : mDataRequest(dr), mSources(src), mSourcesMap(srcMap), mGGCCDBRequest(gr), mUseMC(useMC), mProcessITSTPConly(processITSTPConly), mSendTrackData(sendTrackData), mDebugOutput(debugOutput), mExtDetResid(extDetResid) {}
   ~TPCInterpolationDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -58,14 +59,16 @@ class TPCInterpolationDPL : public Task
   bool mProcessITSTPConly{false}; ///< should also tracks without outer point (ITS-TPC only) be processed?
   bool mProcessSeeds{false};      ///< process not only most complete track, but also its shorter parts
   bool mDebugOutput{false};       ///< add more information to the output (track points of ITS, TRD and TOF)
+  bool mExtDetResid{true};        ///< produce unbinned residuals for external detectors
   bool mSendTrackData{false};     ///< if true, not only the clusters but also corresponding track data will be sent
   uint32_t mSlotLength{600u};     ///< the length of one calibration slot required to calculate max number of tracks per TF
   int mMatCorr{2};                ///< the material correction to be used for track interpolation
   TStopwatch mTimer;
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getTPCInterpolationSpec(o2::dataformats::GlobalTrackID::mask_t srcCls, o2::dataformats::GlobalTrackID::mask_t srcVtx, o2::dataformats::GlobalTrackID::mask_t srcTrk, o2::dataformats::GlobalTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput);
+framework::DataProcessorSpec getTPCInterpolationSpec(o2::dataformats::GlobalTrackID::mask_t srcCls, o2::dataformats::GlobalTrackID::mask_t srcVtx, o2::dataformats::GlobalTrackID::mask_t srcTrk,
+                                                     o2::dataformats::GlobalTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput, bool extDetResid);
 
 } // namespace tpc
 } // namespace o2

Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx

@@ -105,8 +105,9 @@ void TPCInterpolationDPL::updateTimeDependentParams(ProcessingContext& pc)
   }
   if (mDebugOutput) {
     mInterpolation.setDumpTrackPoints();
-    mInterpolation.setITSClusterDictionary(mITSDict);
   }
+  mInterpolation.setExtDetResid(mExtDetResid);
+  mInterpolation.setITSClusterDictionary(mITSDict);
 }
 
 void TPCInterpolationDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
@@ -158,7 +159,7 @@ void TPCInterpolationDPL::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mask_t srcVtx, GTrackID::mask_t srcTrk, GTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput)
+DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mask_t srcVtx, GTrackID::mask_t srcTrk, GTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput, bool extDetResid)
 {
   auto dataRequest = std::make_shared<DataRequest>();
   std::vector<OutputSpec> outputs;
@@ -199,7 +200,7 @@ DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mas
     "tpc-track-interpolation",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, srcTrk, srcTrkMap, ggRequest, useMC, processITSTPConly, sendTrackData, debugOutput)},
+    AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, srcTrk, srcTrkMap, ggRequest, useMC, processITSTPConly, sendTrackData, debugOutput, extDetResid)},
     Options{
       {"matCorrType", VariantType::Int, 2, {"material correction type (definition in Propagator.h)"}},
       {"sec-per-slot", VariantType::UInt32, 600u, {"number of seconds per calibration time slot (put 0 for infinite slot length)"}},

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

@@ -42,6 +42,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"tracking-sources-map-extraction", VariantType::String, std::string{GID::ALL}, {"can be subset of \"tracking-sources\""}},
     {"send-track-data", VariantType::Bool, false, {"Send also the track information to the aggregator"}},
     {"debug-output", VariantType::Bool, false, {"Dump extended tracking information for debugging"}},
+    {"skip-ext-det-residuals", VariantType::Bool, false, {"Do not produce residuals for external detectors"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -104,8 +105,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   useMC = false; // force disabling MC as long as it is not implemented
   auto sendTrackData = configcontext.options().get<bool>("send-track-data");
   auto debugOutput = configcontext.options().get<bool>("debug-output");
+  auto extDetResid = !configcontext.options().get<bool>("skip-ext-det-residuals");
 
-  specs.emplace_back(o2::tpc::getTPCInterpolationSpec(srcClusters, srcVtx, srcTracks, srcTracksMap, useMC, processITSTPConly, sendTrackData, debugOutput));
+  specs.emplace_back(o2::tpc::getTPCInterpolationSpec(srcClusters, srcVtx, srcTracks, srcTracksMap, useMC, processITSTPConly, sendTrackData, debugOutput, extDetResid));
   if (!configcontext.options().get<bool>("disable-root-output")) {
     specs.emplace_back(o2::tpc::getTPCResidualWriterSpec(sendTrackData, debugOutput));
   }