PHG4ForwardEcalDetector.h

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

// Tell emacs that this is a C++ source
//  -*- C++ -*-.
#ifndef G4DETECTORS_PHG4FORWARDECALDETECTOR_H
#define G4DETECTORS_PHG4FORWARDECALDETECTOR_H

#include <g4main/PHG4Detector.h>

#include <Geant4/G4Material.hh>
#include <Geant4/G4SystemOfUnits.hh>

#include <cassert>
#include <map>
#include <set>
#include <string>
#include <utility>  // for pair, make_pair

class G4LogicalVolume;
class G4VPhysicalVolume;
class PHCompositeNode;
class PHG4ForwardEcalDisplayAction;
class PHG4Subsystem;
class PHG4GDMLConfig;
class PHParameters;

class PHG4ForwardEcalDetector : public PHG4Detector
{
 public:
  PHG4ForwardEcalDetector(PHG4Subsystem *subsys, PHCompositeNode *Node, PHParameters *parameters, const std::string &dnam);

  virtual ~PHG4ForwardEcalDetector() {}

  virtual void ConstructMe(G4LogicalVolume *world);

  int IsInForwardEcal(G4VPhysicalVolume *) const;

  void SetTowerDimensions(double dx, double dy, double dz, int type);

  void DoFullLightProp(bool doProp) { m_doLightProp = doProp; }

  void SetPlace(double place_in_x, double place_in_y, double place_in_z)
  {
    m_PlaceX = place_in_x;
    m_PlaceY = place_in_y;
    m_PlaceZ = place_in_z;
  }
  void SetPlaceX(double place_x) { m_PlaceX = place_x; }
  void SetPlaceY(double place_y) { m_PlaceY = place_y; }
  void SetPlaceZ(double place_z) { m_PlaceZ = place_z; }

  double GetPlaceX() const { return m_PlaceX; }
  double GetPlaceY() const { return m_PlaceY; }
  double GetPlaceZ() const { return m_PlaceZ; }

  void SetXRot(double rot_in_x) { m_XRot = rot_in_x; }
  void SetYRot(double rot_in_y) { m_YRot = rot_in_y; }
  void SetZRot(double rot_in_z) { m_ZRot = rot_in_z; }

  double GetXRot() const { return m_XRot; }
  double GetYRot() const { return m_YRot; }
  double GetZRot() const { return m_ZRot; }

  double GetRMin(int i) const
  {
    assert(i >= 0 && i <= 1);
    return m_RMin[i];
  }
  double GetRMax(int i) const
  {
    assert(i >= 0 && i <= 1);
    return m_RMax[i];
  }

  void SetRMin(int i, double val)
  {
    assert(i >= 0 && i <= 1);
    m_RMin[i] = val;
  }
  void SetRMax(int i, double val)
  {
    assert(i >= 0 && i <= 1);
    m_RMax[i] = val;
  }

  double GetdZ() const { return m_dZ; }

  void SetdZ(double val) { m_dZ = val; }

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

  int get_Layer() const { return m_Layer; }
  int get_TowerType() const { return m_TowerType; }

  PHG4ForwardEcalDisplayAction *GetDisplayAction() { return m_DisplayAction; }

 private:
  G4LogicalVolume *ConstructTower(int type);
  G4LogicalVolume *ConstructTowerType2();
  G4LogicalVolume *ConstructTowerType3_4_5_6(int type);
  int PlaceTower(G4LogicalVolume *envelope, G4LogicalVolume *tower[6]);
  int ParseParametersFromTable();
  G4Material *GetWLSFiberFEMCMaterial();
  G4Material *GetScintillatorMaterial();
  G4Material *GetCoatingMaterial();
  void SurfaceTable(G4LogicalVolume *vol);
  struct towerposition
  {
    double x;
    double y;
    double z;
    int type;
    int idx_j;
    int idx_k;
  };

  PHG4ForwardEcalDisplayAction *m_DisplayAction = nullptr;
  PHParameters *m_Params = nullptr;
  PHG4GDMLConfig *m_GdmlConfig = nullptr;

  /* ECAL tower geometry */
  double m_TowerDx[7];
  double m_TowerDy[7];
  double m_TowerDz[7];

  double m_XRot = 0.;
  double m_YRot = 0.;
  double m_ZRot = 0.;

  double m_PlaceX = 0.0 * mm;
  double m_PlaceY = 0.0 * mm;
  double m_PlaceZ = 3150.0 * mm;

  double m_RMin[2];
  double m_RMax[2];

  double m_dZ = 170 * mm;

  int m_ActiveFlag = 0;
  int m_AbsorberActiveFlag = 0;
  int m_Layer = 0;
  int m_TowerType = 0;

  std::string m_SuperDetector = "NONE";
  std::string m_TowerLogicNamePrefix = "hEcalTower";

  std::map<std::string, towerposition> m_TowerPositionMap;
  std::map<std::string, double> m_GlobalParameterMap;

  std::set<G4LogicalVolume *> m_AbsorberLogicalVolSet;
  std::set<G4LogicalVolume *> m_ScintiLogicalVolSet;

 protected:
  const std::string TowerLogicNamePrefix() const { return m_TowerLogicNamePrefix; }
  PHParameters *GetParams() const { return m_Params; }
  void AbsorberLogicalVolSetInsert(G4LogicalVolume *logvol)
  {
    m_AbsorberLogicalVolSet.insert(logvol);
  }
  void ScintiLogicalVolSetInsert(G4LogicalVolume *logvol)
  {
    m_ScintiLogicalVolSet.insert(logvol);
  }
  std::map<std::string, double>::const_iterator FindIter(const std::string &name) { return m_GlobalParameterMap.find(name); }
  std::map<std::string, double>::const_iterator EndIter() { return m_GlobalParameterMap.end(); }
  void InsertParam(const std::string &parname, double parval) { m_GlobalParameterMap.insert(make_pair(parname, parval)); }

  bool m_doLightProp;
};

#endif