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(                            //
        const std::string &_name,        
        const 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_ */