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"

#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"

// additional HerdSoftware headers
// these depend on EA headers so they must be included after the #undef
#include "dataproviders/readers/GGSSimReader.h"
#include "dataproviders/readers/ParametricGeoReader.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;

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

  struct ObjDescriptor;
  using ObjPrerequisite = std::pair<ObjDescriptor, std::function<void(DataReader *, DataReader *)>>;
  struct ObjDescriptor {
    std::string name;
    std::vector<std::string> aliases;
    ObjectCategory category;
    DataReader *reader;
    bool hasPrerequisites;
    // VF: This is fun! We allow for more than one prerequisite object to be loaded before
    // we can actually get this object. After the each prerequisite is loaded, a callback
    // can be called on both readers (object and prerequisite) to pass data around
    std::vector<ObjPrerequisite> prerequisites;
  };
  std::vector<ObjDescriptor> m_objDescriptors;

  // helper function to allow recursive load of prerequisites for ObjectDescriptors
  bool _LoadPrerequisites(ObjDescriptor &objDesc);

  // Names and aliases of the data objects
  const std::pair<std::string, std::vector<std::string>> m_caloHitsNames{"caloHitsGGS", {"caloHitsMC", "caloHitsGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_fitHitsCollNames{"fitHitsCollGGS",
                                                                            {"fitHitsCollMC", "fitHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_fitParticleHitsCollNames{
      "fitParticleHitsCollGGS", {"fitParticleHitsCollMC", "fitParticleHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_stkStripHitsCollNames{"stkStripHitsCollGGS",
                                                                                 {"stkHitsCollMC", "stkHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_stkWaferHitsCollNames{
      "stkWaferHitsCollGGS", {"stkWaferHitsCollMC", "stkWaferHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_stkWaferParticleHitsCollNames{
      "stkWaferParticleHitsCollGGS", {"stkWaferParticleHitsCollMC", "stkWaferParticleHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_scdStripHitsCollNames{"scdStripHitsCollGGS",
                                                                                 {"scdHitsCollMC", "scdHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_scdWaferHitsCollNames{
      "scdWaferHitsCollGGS", {"scdWaferHitsCollMC", "scdWaferHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_scdWaferParticleHitsCollNames{
      "scdWaferParticleHitsCollGGS", {"scdWaferParticleHitsCollMC", "scdWaferParticleHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_psdHitsCollNames{"psdHitsCollGGS",
                                                                            {"psdHitsCollMC", "psdHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_psdParticleHitsCollNames{
      "psdParticleHitsCollGGS", {"psdParticleHitsCollMC", "psdParticleHitsCollGeV"}};
  const std::pair<std::string, std::vector<std::string>> m_mcTruthNames{"mcTruth", {}};

  std::unique_ptr<ParametricGeoReader> m_geoReader;
  std::unique_ptr<GGSSimReader> m_evReader;
};

} // namespace Herd

#endif /* HERD_GGSDATAPROVIDER_H_ */