GRPGeomHelper.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_GRPGEOM_HELPER
#define ALICEO2_GRPGEOM_HELPER
 
#include <vector>
#include <memory>
#include "DetectorsCommonDataFormats/DetID.h"
#include "DataFormatsParameters/GRPLHCIFData.h"
#include "DataFormatsParameters/GRPECSObject.h"
#include "DataFormatsParameters/GRPMagField.h"
#include "DataFormatsParameters/AggregatedRunInfo.h"
 
namespace o2::framework
{
class ProcessingContext;
class ConcreteDataMatcher;
class InputSpec;
} // namespace o2::framework
 
namespace o2::detectors
{
class AlignParam;
}
namespace o2::parameters
{
class GRPECSObject;
class GRPLHCIFData;
class GRPMagField;
} // namespace o2::parameters
 
namespace o2
{
namespace base
{
class MatLayerCylSet;
 
/*
 
 // Helper class to request CCDB condition data from the processor specs definition
 // User should request wanted objects in the device spec defintion by calling
 
 std::vector<InputSpec> inputs;
 ...
 auto ccdbRequest = std::make_shared<GRPGeomRequest>(..., inputs);
 // and pass it to the Device class, which must do in the constructor or init method:
 GRPGeomRequest::instance()->setRequest(ccdbRequest);
 
 // Then user should call the method GRPGeomRequest::instance()->finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 // from the device finaliseCCDB method and call the method GRPGeomRequest::instance()->checkUpdates(pc) in the beginning of the run method
 
 I.e the task should look like:
 class MyTask {
  public:
   MyTask(std::shared_ptr<GRPGeomRequest> req, ...) : mCCDBReq(req) {
     ...
   }
   void init(o2::framework::InitContext& ic) {
     GRPGeomHelper::instance().setRequest(mCCDBReq);
     ...
   }
   void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) {
     if (GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
       return;
     }
     ...
   }
   void run(ProcessingContext& pc) {
     GRPGeomHelper::instance().checkUpdates(pc);
     ...
   }
   protected:
     std::shared_ptr<GRPGeomRequest> mCCDBReq;
 }
*/
 
struct GRPGeomRequest {
  enum GeomRequest { None,
                     Aligned,
                     Ideal,
                     Alignments };
 
  bool askAggregateRunInfo = false;
  bool askGRPECS = false;
  bool askGRPLHCIF = false;
  bool askGRPMagField = false;
  bool askMatLUT = false;
  bool askTime = false;       // need orbit reset time for precise timestamp calculation
  bool askGeomAlign = false;  // load aligned geometry
  bool askGeomIdeal = false;  // load ideal geometry
  bool askAlignments = false; // load detector alignments but don't apply them
  bool askOnceAllButField = false; // for all entries but field query only once
  bool needPropagatorD = false;    // init also PropagatorD
 
  GRPGeomRequest() = delete;
  GRPGeomRequest(bool orbitResetTime, bool GRPECS, bool GRPLHCIF, bool GRPMagField, bool askMatLUT, GeomRequest geom, std::vector<o2::framework::InputSpec>& inputs, bool askOnce = false, bool needPropD = false, std::string detMaskString = "all");
  void requireAggregateRunInfo(std::vector<o2::framework::InputSpec>& inputs);
  void addInput(const o2::framework::InputSpec&& isp, std::vector<o2::framework::InputSpec>& inputs);
};
 
// Helper class to process and access GRPs and geometry objects.
 
class GRPGeomHelper
{
 
 public:
  static GRPGeomHelper& instance()
  {
    static GRPGeomHelper inst;
    return inst;
  }
  void setRequest(std::shared_ptr<GRPGeomRequest> req);
  bool finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj);
  void checkUpdates(o2::framework::ProcessingContext& pc);
 
  auto getAlignment(o2::detectors::DetID det) const { return mAlignments[det]; }
  auto getMatLUT() const { return mMatLUT; }
  auto getGRPECS() const { return mGRPECS; }
  auto getGRPLHCIF() const { return mGRPLHCIF; }
  auto getGRPMagField() const { return mGRPMagField; }
  auto getOrbitResetTimeMS() const { return mOrbitResetTimeMUS / 1000; }
  auto getOrbitResetTimeMUS() const { return mOrbitResetTimeMUS; }
  const o2::parameters::AggregatedRunInfo& getAggregatedRunInfo() const { return mAggregatedRunInfo; }
  static int getNHBFPerTF();
 
 private:
  GRPGeomHelper() = default;
 
  std::shared_ptr<GRPGeomRequest> mRequest;
 
  std::array<const std::vector<o2::detectors::AlignParam>*, o2::detectors::DetID::nDetectors> mAlignments{};
  const o2::base::MatLayerCylSet* mMatLUT = nullptr;
  const o2::parameters::GRPECSObject* mGRPECS = nullptr;
  const o2::parameters::GRPLHCIFData* mGRPLHCIF = nullptr;
  const o2::parameters::GRPMagField* mGRPMagField = nullptr;
  o2::parameters::AggregatedRunInfo mAggregatedRunInfo{};
  long mOrbitResetTimeMUS = 0; // orbit reset time in microseconds
};
 
} // namespace base
} // namespace o2
 
#endif