TPCScaler.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_TPC_TPCSCALER
#define ALICEO2_TPC_TPCSCALER
 
#include "DataFormatsTPC/Defs.h"
#include <vector>
 
class TTree;
 
namespace o2::tpc
{
 
/*
Class for storing the scalers which are used to calculate an estimate for the mean space-charge density for the last ion drift time
*/
 
struct TPCScalerWeights {
  float getWeight(float deltaTime) const;
  bool isInRange(float deltaTime) const;
  bool isValid() const { return (mSamplingTimeMS > 0 && !mWeights.empty()); }
  float getDurationMS() const { return mSamplingTimeMS * mWeights.size(); }
  float mSamplingTimeMS = -1;  
  float mFirstTimeStampMS = 0; 
  std::vector<float> mWeights; 
 
  ClassDefNV(TPCScalerWeights, 1);
};
 
class TPCScaler
{
 public:
  TPCScaler() = default;
 
  TPCScaler& operator=(TPCScaler&& other) = default;
 
  int getNValues(o2::tpc::Side side) const { return (side == o2::tpc::Side::A ? mScalerA.size() : mScalerC.size()); }
 
  void setScaler(const std::vector<float>& values, const o2::tpc::Side side) { (side == o2::tpc::Side::A ? (mScalerA = values) : (mScalerC = values)); }
 
  void setIonDriftTimeMS(float ionDriftTimeMS) { mIonDriftTimeMS = ionDriftTimeMS; }
 
  void setRun(int run) { mRun = run; }
 
  void setFirstTFOrbit(unsigned int firstTFOrbit) { mFirstTFOrbit = firstTFOrbit; }
 
  void setStartTimeStampMS(double timeStampMS) { mTimeStampMS = timeStampMS; }
 
  void setIntegrationTimeMS(float integrationTimeMS) { mIntegrationTimeMS = integrationTimeMS; }
 
  void dumpToFile(const char* file, const char* name);
 
  void dumpToFile(const char* file, const char* name, double startTimeMS, double endTimeMS);
 
  void dumpToFileSlices(const char* file, const char* name, int minutesPerObject, float marginMS = 500, float marginCCDBMinutes = 1);
 
  void loadFromFile(const char* inpf, const char* name);
 
  void setFromTree(TTree& tpcScalerTree);
 
  float getScalers(unsigned int idx, o2::tpc::Side side) const { return (side == o2::tpc::Side::A) ? mScalerA[idx] : mScalerC[idx]; }
 
  const auto& getScalers(o2::tpc::Side side) const { return (side == o2::tpc::Side::A) ? mScalerA : mScalerC; }
 
  float getIonDriftTimeMS() const { return mIonDriftTimeMS; }
 
  int getRun() const { return mRun; }
 
  unsigned int getFirstTFOrbit() const { return mFirstTFOrbit; }
 
  double getStartTimeStampMS() const { return mTimeStampMS; }
 
  double getEndTimeStampMS(o2::tpc::Side side) const { return mTimeStampMS + getDurationMS(side); }
 
  float getIntegrationTimeMS() const { return mIntegrationTimeMS; }
 
  int getNValuesIonDriftTime() const { return mIonDriftTimeMS / mIntegrationTimeMS + 0.5; }
 
  float getMeanScaler(double timestamp, o2::tpc::Side side) const;
 
  float getDurationMS(o2::tpc::Side side) const { return mIntegrationTimeMS * getNValues(side); }
 
  void clampScalers(float minThreshold, float maxThreshold, Side side);
 
  void setScalerWeights(const TPCScalerWeights& weights) { mScalerWeights = weights; }
 
  const auto& getScalerWeights() const { return mScalerWeights; }
 
  void useWeights(bool useWeights) { mUseWeights = useWeights; }
 
  bool weightsUsed() const { return mUseWeights; }
 
 private:
  float mIonDriftTimeMS{200};        
  int mRun{};                        
  unsigned int mFirstTFOrbit{};      
  double mTimeStampMS{};             
  float mIntegrationTimeMS{1.};      
  std::vector<float> mScalerA{};     
  std::vector<float> mScalerC{};     
  TPCScalerWeights mScalerWeights{}; 
  bool mUseWeights{false};           
 
  // get index to data for given timestamp
  int getDataIdx(double timestamp) const { return (timestamp - mTimeStampMS) / mIntegrationTimeMS + 0.5; }
 
  ClassDefNV(TPCScaler, 2);
};
 
} // namespace o2::tpc
#endif