PHG4SpacalDetector.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file PHG4SpacalDetector.h

// Tell emacs that this is a C++ source
//  -*- C++ -*-.

#ifndef G4DETECTORS_PHG4SPACALDETECTOR_H
#define G4DETECTORS_PHG4SPACALDETECTOR_H

#include "PHG4CellDefs.h"
#include "PHG4CylinderGeom_Spacalv1.h"

#include <g4main/PHG4Detector.h>

#include <Geant4/G4Transform3D.hh>
#include <Geant4/G4Types.hh>  // for G4double

#include <map>
#include <string>   // for string
#include <utility>  // for pair

class G4LogicalVolume;
class G4UserLimits;
class G4VPhysicalVolume;
class PHCompositeNode;
class PHG4CylinderGeom;
class PHG4GDMLConfig;
class PHG4SpacalDisplayAction;
class PHParameters;
class PHG4Subsystem;
class RawTowerGeomContainer;

class PHG4SpacalDetector : public PHG4Detector
{
 public:
  typedef PHG4CylinderGeom_Spacalv1 SpacalGeom_t;

  PHG4SpacalDetector(PHG4Subsystem* subsys, PHCompositeNode* Node, const std::string& dnam,
                     PHParameters* parameters, const int layer = 0, bool init_geom = true);

  ~PHG4SpacalDetector(void) override;

  void
  ConstructMe(G4LogicalVolume* world) override;

  virtual std::pair<G4LogicalVolume*, G4Transform3D>
  Construct_AzimuthalSeg();

  virtual G4LogicalVolume*
  Construct_Fiber(const G4double length, const std::string& id);

  void
  SetActive(const int i = 1)
  {
    active = i;
  }

  void
  SetAbsorberActive(const int i = 1)
  {
    absorberactive = i;
  }

  void
  SetDetectorType(const std::string& typ)
  {
    detector_type = typ;
  }

  int IsInCylinderActive(const G4VPhysicalVolume*);

  void
  SuperDetector(const std::string& name)
  {
    superdetector = name;
  }

  const std::string
  SuperDetector() const
  {
    return superdetector;
  }

  int get_Layer() const
  {
    return layer;
  }

  void
  Print(const std::string& what = "ALL") const override;

  const SpacalGeom_t*
  get_geom() const
  {
    return _geom;
  }

  virtual PHG4CylinderGeom* clone_geom() const
  {
    return new SpacalGeom_t(*_geom);
  }

  enum
  {
    FIBER_CORE = 1,
    FIBER_CLADING = 0,
    ABSORBER = -1,
    SUPPORT = -2,
    INACTIVE = -100
  };

  PHG4SpacalDisplayAction* GetDisplayAction() { return m_DisplayAction; }

  void CosmicSetup(const int i) { m_CosmicSetupFlag = i; }
  int CosmicSetup() { return m_CosmicSetupFlag; }

 private:
  PHG4SpacalDisplayAction* m_DisplayAction = nullptr;

 protected:
  void AddTowerGeometryNode();
  void AddCellGeometryNode();
  std::map<const G4VPhysicalVolume*, int> fiber_core_vol;

  std::map<const G4VPhysicalVolume*, int> fiber_vol;

  std::map<const G4VPhysicalVolume*, int> calo_vol;

  std::map<const G4VPhysicalVolume*, int> block_vol;

  int active = 0;
  int absorberactive = 0;
  int layer = -9999;
  int m_CosmicSetupFlag = 0;
  int m_CellBinning = PHG4CellDefs::undefined;
  int m_NumLayers = -1;
  int m_NumPhiBins = -1;
  int m_NumEtaBins = -1;
  double m_Emin = 1e-6;
  double m_EtaMin = NAN;
  double m_PhiMin = NAN;
  double m_EtaStep = NAN;
  double m_PhiStep = NAN;
  std::string detector_type;
  std::string superdetector;

  //  G4UserLimits * step_limits;
  //  G4UserLimits * clading_step_limits;
  G4UserLimits* fiber_core_step_limits = nullptr;

  PHG4GDMLConfig* gdml_config = nullptr;
  // private:

  SpacalGeom_t* _geom = nullptr;

  RawTowerGeomContainer* m_RawTowerGeomContainer = nullptr;
  std::string m_TowerGeomNodeName;
};

#endif