GGSDataProvider.h

Go to the documentation of this file.

/*
 * GGSDataProvider.h
 *
 *  Created on: 14 Nov 2018
 *      Author: Nicola Mori
 */

#ifndef HERD_GGSDATAPROVIDER_H_
#define HERD_GGSDATAPROVIDER_H_

// HerdSoftware headers
#include "dataobjects/CaloGeoParams.h"
#include "dataobjects/CaloHits.h"
#include "dataobjects/CssGeoParams.h"
#include "dataobjects/FitGeoParamsColl.h"
#include "dataobjects/FitHitsColl.h"
#include "dataobjects/FitParticleHitsColl.h"
#include "dataobjects/MCGenerationInfo.h"
#include "dataobjects/MCTruth.h"
#include "dataobjects/PsdGeoParamsColl.h"
#include "dataobjects/PsdHitsColl.h"
#include "dataobjects/PsdParticleHitsColl.h"
#include "dataobjects/ScdGeoParamsColl.h"
#include "dataobjects/ScdHitsColl.h"
#include "dataobjects/ScdParticleHitsColl.h"
#include "dataobjects/StkGeoParamsColl.h"
#include "dataobjects/StkHitsColl.h"
#include "dataobjects/StkParticleHitsColl.h"

// HS readers
#include "dataproviders/readers/global/GGSMCGenReader.h"
#include "dataproviders/readers/global/GGSTGeoReader.h"
#include "dataproviders/readers/global/ParametricGeoCaloReader.h"
#include "dataproviders/readers/global/ParametricGeoCssReader.h"
#include "dataproviders/readers/global/ParametricGeoFitReader.h"
#include "dataproviders/readers/global/ParametricGeoPsdReader.h"
#include "dataproviders/readers/global/ParametricGeoSiliconDetectorReader.h"

#include "dataproviders/readers/event/GGSCaloHitsReader.h"
#include "dataproviders/readers/event/GGSFitHitsReader.h"
#include "dataproviders/readers/event/GGSMCTruthReader.h"
#include "dataproviders/readers/event/GGSPsdHitsReader.h"
#include "dataproviders/readers/event/GGSSiliconDetectorHitsReader.h"

#ifndef GGSSMARTLOG_H_
#define HERD_GGSDATAPROVIDER_H_UNDEF_LOGGING
#endif

// GGS headers
#include "montecarlo/dataobjs/GGSTHits.h"
#include "montecarlo/readers/GGSTRootReader.h"

class GGSTHitsReader;
class GGSTMCTruthReader;
class GGSTHadrIntReader;
class GGSTPrimaryDisReader;

#ifdef HERD_GGSDATAPROVIDER_H_UNDEF_LOGGING
// Remove the definitions of GGS output macros (would conflict with the same macros defined in EventAnalysis)
// We only do this if GGSSmartLog.h is being parsed in this TU, otherwise there would be nothing to undef
// (or we could even be undefining the EA macros)
#undef COUT
#undef CCOUT
#undef ENDL
#endif

// EventAnalysis headers
#include "data/DataProvider.h"

// ROOT headers
#include "TGeoManager.h"

// Standard C++ hedaders
#include <functional>
#include <vector>

using namespace EA;

namespace Herd {
// clang-format off
// clang-format on

class GGSDataProvider : public DataProvider {
public:
  GGSDataProvider(const std::string &name, const std::string &source);

  bool Connect() override;

  // avoid other overloads from base class to be hidden by derived version
  using DataProvider::SetCurrentEvent;

  bool SetCurrentEvent(unsigned int event) override;

  // avoid other overloads from base class to be hidden by derived version
  using DataProvider::GetObject;

  RetrievalResult GetObject(const std::string &name, ObjectCategory category, ObjectWrapper &wrapper,
                            std::string &actualName) override;

  std::vector<std::string> FreeObjects(const std::vector<std::string> &objs, Memory::Status memStatus) override;

private:
  unsigned int m_currEv;
  unsigned int m_currReadEv;
  // Utility class that wraps a std::function<bool()> and adds automatic caching,
  // for actually calling a function only once.
  class CachedFunction {
  public:
    CachedFunction() {}
    template <typename T> CachedFunction(T func) : function{func} {}
    template <typename T> CachedFunction &operator=(T func) {
      function = func;
      return *this;
    }
    bool operator()() {
      if (called) {
        return result;
      }
      called = true;
      return (result = function());
    }

  private:
    std::function<bool()> function;
    bool called = false;
    bool result = true;
  };
  // generic struct to describe an object
  struct ObjDescriptor {
    std::string name;
    std::vector<std::string> aliases;
    ObjectCategory category;
    // these closures should capture "this" so they can see everything in the dataprovider
    CachedFunction is_available;
    std::function<RetrievalResult(ObjectWrapper &)> get;
    std::function<void()> post_load;
    // a list of objects this object depends on
    std::vector<ObjDescriptor> prerequisites;
  };

  std::vector<ObjDescriptor> m_objDescriptors = {};

  bool LoadPrerequisites(ObjDescriptor &objDesc);

  // GGS
  std::shared_ptr<GGSTRootReader> m_reader;

  // HS readers
  std::unique_ptr<Readers::GGSMCGenReader> m_mcGenReader = nullptr;
  std::unique_ptr<Readers::GGSTGeoReader> m_mcTGeoReader = nullptr;
  std::unique_ptr<Readers::ParametricGeoCssReader> m_mcPGCssReader = nullptr;
  std::unique_ptr<Readers::ParametricGeoCaloReader> m_mcPGCaloReader = nullptr;
  std::unique_ptr<Readers::ParametricGeoFitReader> m_mcPGFitReader = nullptr;
  std::unique_ptr<Readers::ParametricGeoPsdReader> m_mcPGPsdReader = nullptr;
  std::unique_ptr<Readers::ParametricGeoSiliconDetectorReader> m_mcPGStkReader = nullptr;
  std::unique_ptr<Readers::ParametricGeoSiliconDetectorReader> m_mcPGScdReader = nullptr;

  std::unique_ptr<Readers::GGSMCTruthReader> m_mcTruthReader = nullptr;
  std::unique_ptr<Readers::GGSCaloHitsReader> m_caloHitsReader = nullptr;
  std::unique_ptr<Readers::GGSSiliconDetectorHitsReader> m_stkHitsReader = nullptr;
  std::unique_ptr<Readers::GGSSiliconDetectorHitsReader> m_scdHitsReader = nullptr;
  std::unique_ptr<Readers::GGSFitHitsReader> m_fitHitsReader = nullptr;
  std::unique_ptr<Readers::GGSPsdHitsReader> m_psdHitsReader = nullptr;
};

} // namespace Herd

#endif /* HERD_GGSDATAPROVIDER_H_ */