PHG4SectorConstructor.h

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

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

#ifndef G4DETECTORS_PHG4SECTORCONSTRUCTOR_H
#define G4DETECTORS_PHG4SECTORCONSTRUCTOR_H

#include <Geant4/G4PhysicalConstants.hh>
#include <Geant4/G4String.hh>  // for G4String
#include <Geant4/G4SystemOfUnits.hh>
#include <Geant4/G4Types.hh>   // for G4int


class G4LogicalVolume;
class G4PVPlacement;
class G4VSolid;
class PHG4SectorDisplayAction;
class PHG4Subsystem;

#include <map>
#include <utility>

#include <cassert>
#include <cmath>
#include <string>
#include <vector>

namespace PHG4Sector
{
class Layer
{
 public:
  Layer(  
      const std::string &_name,

      const std::string &_material,

      double _depth,

      double _percentage_filled,

      bool _active)
    : name(_name)
    , material(_material)
    , depth(_depth)
    , percentage_filled(
          _percentage_filled)
    , active(_active)
  {
  }

 public:
  std::string name;

  std::string material;

  double depth;

  double percentage_filled;

  bool active;
};

class Sector_Geometry
{
 public:
  Sector_Geometry()
  {
    SetDefault();
  }

  void
  SetDefault();

  int get_N_Sector() const
  {
    return N_Sector;
  }

  std::vector<Layer> &
  get_layer_list()
  {
    return layer_list;
  }

  std::string
  get_material() const
  {
    return material;
  }

  double
  get_max_polar_angle() const
  {
    return max_polar_angle;
  }

  double
  get_min_polar_angle() const
  {
    return min_polar_angle;
  }

  double
  get_normal_polar_angle() const
  {
    return normal_polar_angle;
  }

  double
  get_normal_start() const
  {
    return normal_start;
  }

  void
  set_N_Sector(int sector)
  {
    assert(sector >= 1);

    N_Sector = sector;
  }

  void
  set_layer_list(const std::vector<Layer> &layerList)
  {
    layer_list = layerList;
  }

  void
  set_material(const std::string &_material)
  {
    material = _material;
  }

  void
  set_max_polar_angle(double maxPolarAngle)
  {
    assert(maxPolarAngle >= 0);
    assert(maxPolarAngle <= pi);

    max_polar_angle = maxPolarAngle;
  }

  void
  set_min_polar_angle(double minPolarAngle)
  {
    assert(minPolarAngle >= 0);
    assert(minPolarAngle <= pi);

    min_polar_angle = minPolarAngle;
  }

  void
  set_normal_polar_angle(double normalPolarAngle)
  {
    assert(normalPolarAngle >= 0);
    assert(normalPolarAngle <= pi);

    normal_polar_angle = normalPolarAngle;
  }

  void
  set_normal_start(double normalZStart)
  {
    normal_start = normalZStart;
  }

  // derivative constants

  //   ! max radius from IP
  double
  get_max_R() const;

  double
  get_total_thickness() const;

  static double
  Unit_cm()
  {
    return cm;
  }

  void
  set_normal_start(const double z_intercept, const double angle_intercept)
  {
    set_normal_start(
        z_intercept / cos(angle_intercept) * cos(normal_polar_angle - angle_intercept));
  }

  static double
  eta_to_polar_angle(const double eta)
  {
    return 2. * atan(exp(-eta));
  }

  // layer descriptions
 public:

  typedef std::vector<Layer> t_layer_list;
  t_layer_list layer_list;

  int GetNumActiveLayers() const
  {
    int n = 0;
    for (t_layer_list::const_iterator it = layer_list.begin();
         it != layer_list.end(); ++it)
      if ((*it).active)
        n++;
    return n;
  }

  void
  AddLayer(                            //
      std::string _name,               
      std::string _material,           
      double _depth,                   
      bool _active = false,            
      double _percentage_filled = 100  
  )
  {
    layer_list.push_back(
        Layer(_name, _material, _depth, _percentage_filled, _active));
  }

  void
  AddLayers_DriftVol_COMPASS(const double drift_vol_thickness = 3 * mm);

  void
  AddLayers_HBD_GEM(const int n_GEM_layers = 3);

  void
  AddLayers_HBD_Readout();

  void
  AddLayers_AeroGel_ePHENIX(const double radiator_length = 2 * cm,
                            const double expansion_length = 18 * cm, std::string radiator = "Default");

 public:
  typedef enum
  {

    kConeEdge = 0,

    kFlatEdge = 1

  } e_edge_typ;

  static e_edge_typ
  ConeEdge()
  {
    return kConeEdge;
  }

  static e_edge_typ
  FlatEdge()
  {
    return kFlatEdge;
  }

  e_edge_typ
  get_max_polar_edge() const
  {
    return max_polar_edge;
  }

  e_edge_typ
  get_min_polar_edge() const
  {
    return min_polar_edge;
  }

  void
  set_max_polar_edge(e_edge_typ maxPolarEdge)
  {
    max_polar_edge = maxPolarEdge;
  }

  void
  set_min_polar_edge(e_edge_typ minPolarEdge)
  {
    min_polar_edge = minPolarEdge;
  }

 private:
  int N_Sector;

  double normal_polar_angle;

  double min_polar_angle;

  e_edge_typ min_polar_edge;

  double max_polar_angle;

  e_edge_typ max_polar_edge;

  double normal_start;

  std::string material;
};


class PHG4SectorConstructor
{
 public:
  PHG4SectorConstructor(const std::string &name, PHG4Subsystem *subsys);
  virtual ~PHG4SectorConstructor() {}

  void
  Construct_Sectors(G4LogicalVolume *WorldLog);

  void
  OverlapCheck(bool check)
  {
    overlapcheck_sector = check;
  }

  void Verbosity(int v) {m_Verbosity = v;}
  int Verbosity() const {return m_Verbosity;}

 protected:
  bool overlapcheck_sector;

  G4VSolid *
  Construct_Sectors_Plane(           //
      const std::string &name,       //
      const double start_z,          //
      const double thickness,        //
      G4VSolid *SecConeBoundary_Det  //
  );

 public:
  // properties

  std::string name_base;

  Sector_Geometry geom;

 private:
  PHG4SectorDisplayAction *m_DisplayAction;
  int m_Verbosity;

 protected:
  G4LogicalVolume *
  RegisterLogicalVolume(G4LogicalVolume *);

  typedef std::map<G4String, G4LogicalVolume *> map_log_vol_t;
  map_log_vol_t map_log_vol;

  G4PVPlacement *
  RegisterPhysicalVolume(G4PVPlacement *v, const bool active = false);

  typedef std::pair<G4String, G4int> phy_vol_idx_t;
  typedef std::map<phy_vol_idx_t, G4PVPlacement *> map_phy_vol_t;
  map_phy_vol_t map_phy_vol;         
  map_phy_vol_t map_active_phy_vol;  
};

}  // namespace PHG4Sector
#endif /* PHG4SectorConstructor_H_ */