GGSSimReader.h

Go to the documentation of this file.

/*
 * GGSSimReader.h
 *
 *  Created on: 18 Jan 2021
 *      Author: Valerio Formato
 */

#ifndef HERD_GGSSIMREADER_H_
#define HERD_GGSSIMREADER_H_

#ifndef GGSSMARTLOG_H_
#define HERD_GGSSIMREADER_H_UNDEF_LOGGING
#endif

// GGS headers
#include "montecarlo/readers/GGSTHadrIntReader.h"
#include "montecarlo/readers/GGSTHitsReader.h"
#include "montecarlo/readers/GGSTMCTruthReader.h"
#include "montecarlo/readers/GGSTPrimaryDisReader.h"
#include "montecarlo/readers/GGSTRootReader.h"

#ifdef HERD_GGSSIMREADER_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

// HerdSoftware headers
#include "common/DefaultValues.h"
#include "dataobjects/CaloHits.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"
#include "dataproviders/readers/DataReader.h"

// c++ headers
#include <functional>
#include <string>

using namespace EA;

namespace Herd {

// clang-format off
// clang-format on

class GGSSimReader : public DataReader {
public:
  GGSSimReader(std::shared_ptr<GGSTRootReader> reader, std::string fileName);

  virtual ~GGSSimReader() = default;

  virtual bool SetCurrentEvent(unsigned int) final;

  virtual bool IsObjectAvailable(const std::string &name) final;

  virtual bool IsObjectKnown(const std::string &name) final;

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

  virtual std::vector<std::string> FreeObjects(const std::vector<std::string> &, Memory::Status) final;

  bool IsFileValid() { return m_hitReader || m_mcReader; }

  void SetFileName(std::string fileName) { m_fileName = std::move(fileName); }

  void SetCaloHitIDFromGGSPos(std::function<unsigned int(const float *)> conversionFunction) {
    m_caloVolIDFromGGSPos = conversionFunction;
  };

  void SetFitGeoParamsColl(observer_ptr<FitGeoParamsColl> fitGeoParamsColl);

  void SetStkGeoParamsColl(observer_ptr<StkGeoParamsColl> stkGeoParamsColl);

  void SetScdGeoParamsColl(observer_ptr<ScdGeoParamsColl> scdGeoParamsColl);

  void SetPsdGeoParamsColl(observer_ptr<PsdGeoParamsColl> psdGeoParamsColl);

  void SetSideFitFirstVolumeID(std::array<int, 4> sideFitFirstVolumeID) {
    m_sideFitFirstVolumeID = sideFitFirstVolumeID;
  }

  void SetSideStkFirstWaferID(std::array<int, 4> sideStkFirstWaferID) { m_sideStkFirstWaferID = sideStkFirstWaferID; }

  void SetSideStkFirstStripID(std::array<int, 4> sideStkFirstStripID) { m_sideStkFirstStripID = sideStkFirstStripID; }

  void SetSideScdFirstWaferID(std::array<int, 4> sideScdFirstWaferID) { m_sideScdFirstWaferID = sideScdFirstWaferID; }

  void SetSideScdFirstStripID(std::array<int, 4> sideScdFirstStripID) { m_sideScdFirstStripID = sideScdFirstStripID; }

  enum class PsdType : int { NONE = -1, tiles = 0, bars = 1 };
  void SetPsdType(PsdType type) { m_psdType = type; }

private:
  struct ObjDescriptor {
    std::string name;
    std::vector<std::string> aliases;
    bool isOnSource;
    std::function<ObjectWrapper(GGSSimReader *)> retriever;
    std::function<bool(GGSSimReader *)> checker;
  };

  std::vector<ObjDescriptor> m_knownObjects;

  unsigned int m_currEv;
  unsigned int m_currReadEv;

  std::string m_fileName;
  std::shared_ptr<GGSTRootReader> m_ggsreader;
  GGSTHitsReader *m_hitReader = nullptr;
  GGSTMCTruthReader *m_mcReader = nullptr;
  GGSTHadrIntReader *m_hadrIntReader = nullptr;
  GGSTPrimaryDisReader *m_primDisReader = nullptr;

  void CheckAvailableObjects();
  std::vector<ParticleHit> ConvertParticles(GGSTIntHit &ggsIntHit);

  // MC GEN
  bool m_mcGenRead = false;

  MCGenerationInfo m_mcGenInfo;
  bool IsMCGenAvailable();
  ObjectWrapper GetMCGen();

  // MC TRUTH
  bool m_mcTruthRead = false;
  bool m_hadrIntChecked = false;
  bool m_PrimDisAvailable = false;

  MCTruth m_mcTruth;
  bool IsMCTruthAvailable();
  ObjectWrapper GetMCTruth();

  // CALO
  std::function<unsigned int(const float *)> m_caloVolIDFromGGSPos;
  int m_caloDetIndex = std::numeric_limits<int>::lowest();
  CaloHits m_caloHits;
  bool IsCaloHitsAvailable();
  ObjectWrapper GetCaloHits();

  // FIT
  bool m_areFitHitsRead = false;
  bool m_readFitParticleHits = false;
  bool m_areFitParticleHitsRead = false;
  bool m_areFitHitsConverted = false;
  bool m_isTopFitDetectorSet = false;
  bool m_isSideFitDetectorSet = false;

  observer_ptr<FitGeoParamsColl> m_fitGeoParamsColl = nullptr;
  int m_topFitDetIndex = std::numeric_limits<int>::lowest();
  int m_sideFitDetIndex = std::numeric_limits<int>::lowest();
  std::array<int, 4> m_sideFitFirstVolumeID; // ID of the first Volume on each lateral FIT, indexed as in GGS files
  bool SetupFitReadout();

  FitHitsColl m_fitHitsColl;
  bool IsFitHitsAvailable();
  ObjectWrapper GetFitHits();
  FitParticleHitsColl m_fitParticleHitsColl;
  bool IsFitParticleHitsAvailable();
  ObjectWrapper GetFitParticleHits();

  enum class SiliconDetectorType : int { UNKNOWN = -1, STRIP = 0, WAFER = 1 };

  enum class SiliconDetectorName { STK, SCD };
  std::array<int, 4> &SiliconDetectorFirstVolumeID(SiliconDetectorName detector, SiliconDetectorType type);
  ObjectWrapper GetSiliconDetectorHits(SiliconDetectorName detector, SiliconDetectorType type);
  ObjectWrapper GetSiliconDetectorWaferParticleHits(SiliconDetectorName detector);

  // STK
  SiliconDetectorType m_stkType = SiliconDetectorType::UNKNOWN;
  bool m_areStkHitsRead = false;
  bool m_areStkWaferParticleHitsRead = false;
  bool m_isTopStkDetectorSet = false;
  bool m_isSideStkDetectorSet = false;

  observer_ptr<StkGeoParamsColl> m_stkGeoParamsColl = nullptr;
  int m_topStkDetIndex = std::numeric_limits<int>::lowest();
  int m_sideStkHDetIndex = std::numeric_limits<int>::lowest();
  int m_sideStkVDetIndex = std::numeric_limits<int>::lowest();
  std::array<int, 4> m_sideStkFirstWaferID; // ID of the first Wafer on each lateral STK, indexed as in GGS files
  std::array<int, 4> m_sideStkFirstStripID; // ID of the first Strip on each lateral STK, indexed as in GGS files
  bool SetupStkReadout(SiliconDetectorType type);

  StkHitsColl m_stkHitsColl;
  bool IsStkWaferHitsAvailable();
  bool IsStkStripHitsAvailable();
  ObjectWrapper GetStkWaferHits() {
    return GetSiliconDetectorHits(SiliconDetectorName::STK, SiliconDetectorType::WAFER);
  };
  ObjectWrapper GetStkStripHits() {
    return GetSiliconDetectorHits(SiliconDetectorName::STK, SiliconDetectorType::STRIP);
  };
  StkParticleHitsColl m_stkWaferParticleHitsColl;
  bool IsStkWaferParticleHitsAvailable();
  ObjectWrapper GetStkWaferParticleHits() { return GetSiliconDetectorWaferParticleHits(SiliconDetectorName::STK); };

  // SCD
  SiliconDetectorType m_scdType = SiliconDetectorType::UNKNOWN;
  bool m_areScdHitsRead = false;
  bool m_areScdWaferParticleHitsRead = false;
  bool m_isTopScdDetectorSet = false;
  bool m_isSideScdDetectorSet = false;

  observer_ptr<ScdGeoParamsColl> m_scdGeoParamsColl = nullptr;
  int m_topScdDetIndex = std::numeric_limits<int>::lowest();
  int m_sideScdHDetIndex = std::numeric_limits<int>::lowest();
  int m_sideScdVDetIndex = std::numeric_limits<int>::lowest();
  std::array<int, 4> m_sideScdFirstWaferID; // ID of the first Wafer on each lateral SCD, indexed as in GGS files
  std::array<int, 4> m_sideScdFirstStripID; // ID of the first Strip on each lateral SCD, indexed as in GGS files
  bool SetupScdReadout(SiliconDetectorType type);

  ScdHitsColl m_scdHitsColl;
  bool IsScdWaferHitsAvailable();
  bool IsScdStripHitsAvailable();
  ObjectWrapper GetScdWaferHits() {
    return GetSiliconDetectorHits(SiliconDetectorName::SCD, SiliconDetectorType::WAFER);
  };
  ObjectWrapper GetScdStripHits() {
    return GetSiliconDetectorHits(SiliconDetectorName::SCD, SiliconDetectorType::STRIP);
  };
  ScdParticleHitsColl m_scdWaferParticleHitsColl;
  bool IsScdWaferParticleHitsAvailable();
  ObjectWrapper GetScdWaferParticleHits() { return GetSiliconDetectorWaferParticleHits(SiliconDetectorName::SCD); };

  // PSD
  enum class SidePsdSegmentation : int { NONE = -1, H = 0, V = 1 };

  struct PsdIDVolInfo {
    unsigned int _ID;
    unsigned int _layer;
    RefFrame::Side _side;
  };

  bool m_arePsdHitsRead = false;
  bool m_readPsdParticleHits = false;
  bool m_arePsdParticleHitsRead = false;
  bool m_isTopPsdDetectorSet = false;
  bool m_isSidePsdDetectorSet = false;

  PsdType m_psdType = PsdType::NONE;
  observer_ptr<PsdGeoParamsColl> m_psdGeoParamsColl = nullptr;
  int m_topPsdDetIndex = std::numeric_limits<int>::lowest();
  std::vector<int> m_sidePsdDetIndexes;
  bool SetupPsdReadout(bool readParticleHits);
  PsdIDVolInfo SidePsdHitIDLayerSideFromGGSID(int iGGSPsdID, SidePsdSegmentation sidePsdSegmentation);

  PsdHitsColl m_psdHitsColl;
  bool IsPsdHitsAvailable();
  ObjectWrapper GetPsdHits();
  PsdParticleHitsColl m_psdParticleHitsColl;
  bool IsPsdParticleHitsAvailable();
  ObjectWrapper GetPsdParticleHits();
};
} // namespace Herd

#endif