GRPObject.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_DATA_GRPOBJECT_H_
#define ALICEO2_DATA_GRPOBJECT_H_
 
#include <Rtypes.h>
#include <cstdint>
#include <ctime>
#include <climits>
#include "CommonConstants/LHCConstants.h"
#include "CommonTypes/Units.h"
#include "DetectorsCommonDataFormats/DetID.h"
 
namespace o2
{
namespace parameters
{
/*
 * Collects parameters describing the run, like the beam, magnet settings
 * masks for participating and triggered detectors etc.
 */
 
class GRPObject
{
  using beamDirection = o2::constants::lhc::BeamDirection;
  using DetID = o2::detectors::DetID;
 
 public:
  using timePoint = uint64_t; // std::time_t;
 
  enum ROMode : int { ABSENT = 0,
                      PRESENT = 0x1,
                      CONTINUOUS = PRESENT + (0x1 << 1),
                      TRIGGERING = PRESENT + (0x1 << 2) };
 
  GRPObject() = default;
  ~GRPObject() = default;
 
  timePoint getTimeStart() const { return mTimeStart; }
  timePoint getTimeEnd() const { return mTimeEnd; }
  void setTimeStart(timePoint t) { mTimeStart = t; }
  void setTimeEnd(timePoint t) { mTimeEnd = t; }
 
  void setNHBFPerTF(uint32_t n) { mNHBFPerTF = n; }
  uint32_t getNHBFPerTF() const { return mNHBFPerTF; }
 
  void setFirstOrbit(uint32_t o) { mFirstOrbit = o; }
  uint32_t getFirstOrbit() const { return mFirstOrbit; }
 
  o2::units::AngleRad_t getCrossingAngle() const { return mCrossingAngle; }
  void setCrossingAngle(o2::units::AngleRad_t v) { mCrossingAngle = v; }
  int getBeamZ(beamDirection beam) const { return mBeamAZ[static_cast<int>(beam)] & 0xffff; }
  int getBeamA(beamDirection beam) const { return mBeamAZ[static_cast<int>(beam)] >> 16; }
  float getBeamZ2A(beamDirection beam) const;
  void setBeamAZ(int a, int z, beamDirection beam) { mBeamAZ[static_cast<int>(beam)] = (a << 16) + z; }
  void setBeamEnergyPerZ(float v) { mBeamEnergyPerZ = v; }
  float getBeamEnergyPerZ() const { return mBeamEnergyPerZ; }
  float getBeamEnergyPerNucleon(beamDirection beam) const { return mBeamEnergyPerZ * getBeamZ2A(beam); }
  float getSqrtS() const;
 
  o2::units::Current_t getL3Current() const { return mL3Current; }
  o2::units::Current_t getDipoleCurrent() const { return mDipoleCurrent; }
  bool getFieldUniformity() const { return mUniformField; }
  void setL3Current(o2::units::Current_t v) { mL3Current = v; }
  void setDipoleCurrent(o2::units::Current_t v) { mDipoleCurrent = v; }
  void setFieldUniformity(bool v) { mUniformField = v; }
  int8_t getNominalL3Field();
  const std::string& getDataPeriod() const { return mDataPeriod; }
  void setDataPeriod(const std::string v) { mDataPeriod = v; }
  const std::string& getLHCState() const { return mLHCState; }
  void setLHCState(const std::string v) { mLHCState = v; }
  // getter/setter for run identifier
  void setRun(int r) { mRun = r; }
  int getRun() const { return mRun; }
  void setFill(int f) { mFill = f; }
  int getFill() const { return mFill; }
  DetID::mask_t getDetsReadOut() const { return mDetsReadout; }
  void setDetsReadOut(DetID::mask_t mask) { mDetsReadout = mask; }
  DetID::mask_t getDetsContinuousReadOut() const { return mDetsContinuousRO; }
  void setDetsContinuousReadOut(DetID::mask_t mask) { mDetsContinuousRO = mask; }
  DetID::mask_t getDetsTrigger() const { return mDetsTrigger; }
  void setDetsTrigger(DetID::mask_t mask) { mDetsTrigger = mask; }
  void addDetReadOut(DetID id) { mDetsReadout |= id.getMask(); }
  void remDetReadOut(DetID id)
  {
    mDetsReadout &= ~id.getMask();
    remDetContinuousReadOut(id);
    remDetTrigger(id);
  }
  void addDetContinuousReadOut(DetID id) { mDetsContinuousRO |= id.getMask(); }
  void remDetContinuousReadOut(DetID id) { mDetsContinuousRO &= ~id.getMask(); }
  void addDetTrigger(DetID id) { mDetsTrigger |= id.getMask(); }
  void remDetTrigger(DetID id) { mDetsTrigger &= ~id.getMask(); }
  bool isDetReadOut(DetID id) const { return (mDetsReadout & id.getMask()) != 0; }
  bool isDetContinuousReadOut(DetID id) const { return (mDetsContinuousRO & id.getMask()) != 0; }
  bool isDetTriggers(DetID id) const { return (mDetsTrigger & id.getMask()) != 0; }
  void setDetROMode(DetID id, ROMode status);
  ROMode getDetROMode(DetID id) const;
 
  DetID::mask_t getDetsReadOut(DetID::mask_t only, DetID::mask_t skip = 0) const { return only.any() ? (mDetsReadout & only) : (mDetsReadout ^ skip); }
  DetID::mask_t getDetsReadOut(const std::string& only, const std::string& skip = "") const { return getDetsReadOut(DetID::getMask(only), DetID::getMask(skip)); }
 
  bool isMC() const { return mIsMC; }
  void setIsMC(bool v = true) { mIsMC = v; }
 
  void print() const;
 
  static GRPObject* loadFrom(const std::string& grpFileName = "");
 
 private:
  timePoint mTimeStart = 0;      
  timePoint mTimeEnd = LONG_MAX; 
 
  uint32_t mFirstOrbit = 0;  
  uint32_t mNHBFPerTF = 256; 
 
  DetID::mask_t mDetsReadout;      
  DetID::mask_t mDetsContinuousRO; 
  DetID::mask_t mDetsTrigger;      
 
  o2::units::AngleRad_t mCrossingAngle = 0.f; 
  o2::units::Current_t mL3Current = 0.f;      
  o2::units::Current_t mDipoleCurrent = 0.f;  
  bool mUniformField = false;                 
  float mBeamEnergyPerZ = 0.f;                
 
  int8_t mNominalL3Field = 0;        
  bool mNominalL3FieldValid = false; 
  bool mIsMC = false;                // flag GRP for MC
  int mBeamAZ[beamDirection::NBeamDirections] = {0, 0}; 
 
  int mRun = 0;                 
  int mFill = 0;                
  std::string mDataPeriod = ""; 
  std::string mLHCState = "";   
 
  ClassDefNV(GRPObject, 8);
};
 
//______________________________________________
inline float GRPObject::getBeamZ2A(beamDirection b) const
{
  // Z/A of beam 0 or 1
  int a = getBeamA(b);
  return a ? getBeamZ(b) / static_cast<float>(a) : 0.f;
}
 
//______________________________________________
inline int8_t GRPObject::getNominalL3Field()
{
  // compute nominal L3 field in kG
 
  if (mNominalL3FieldValid == false) {
    mNominalL3Field = std::lround(5.f * mL3Current / 30000.f);
    mNominalL3FieldValid = true;
  }
  return mNominalL3Field;
}
 
} // namespace parameters
} // namespace o2
 
#endif