ePHENIXRICHConstruction.h

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

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

#ifndef G4DETECTORS_EPHENIXRICHCONSTRUCTION_H
#define G4DETECTORS_EPHENIXRICHCONSTRUCTION_H

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


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

class G4VPhysicalVolume;
class G4LogicalVolume;
class G4OpticalSurface;
class G4PVPlacement;
class PHG4RICHDisplayAction;
class PHG4Subsystem;
class G4Material;

namespace ePHENIXRICH
{
class RICH_Geometry
{
 public:
  RICH_Geometry()
    : RICH_Mirror_OpticalSurface(nullptr)
  {
    SetDefault();
    CreateOpticalSurfaces();
  }

  void
  SetDefault();

  void
  CreateOpticalSurfaces();

  static double Unit_cm() { return cm; }

  double
  get_R_max() const
  {
    return R_mirror_ref + dR_mirror + dR_mirror_spt + dR_backwindow;
  }

  double
  get_cone_size_z() const
  {
    return (z_shift + get_R_max()) * 2;
  }

  double
  get_R_frontwindow() const;

  double
  get_half_angle_HBD() const;

  double
  get_RZ_Seg1_HBD() const;

  double
  get_RZ_Seg2_HBD() const;

  double
  get_R_Tip_HBD() const;

  double
  get_Z_Tip_HBD() const;

  double
  get_Rotation_HBD() const;

  double
  get_R_beam_pipe_front() const
  {
    return R_beam_pipe_front;
  }
  double
  get_R_beam_pipe_back() const
  {
    return R_beam_pipe_back;
  }
  double
  get_R_beam_pipe_min() const
  {
    return R_beam_pipe_front<R_beam_pipe_back ? R_beam_pipe_front : R_beam_pipe_back;
  }

  double
  get_frontwindow_DisplaceRatio() const
  {
    return frontwindow_DisplaceRatio;
  }

  double
  get_min_eta() const
  {
    return min_eta;
  }

  double
  get_R_mirror_ref() const
  {
    return R_mirror_ref;
  }

  double
  get_dR_backwindow() const
  {
    return dR_backwindow;
  }

  double
  get_dR_frontwindow() const
  {
    return dR_frontwindow;
  }

  double
  get_dR_frontwindow_shrink() const
  {
    return dR_frontwindow_shrink;
  }

  double
  get_dR_mirror() const
  {
    return dR_mirror;
  }

  double
  get_dR_mirror_spt() const
  {
    return dR_mirror_spt;
  }

  G4String
  get_RICH_gas_mat() const
  {
    return RICH_gas_mat;
  }

  G4String
  get_RICH_Gas_Window_mat() const
  {
    return RICH_Gas_Window_mat;
  }

  G4String
  get_RICH_Mirror_mat() const
  {
    return RICH_Mirror_mat;
  }

  G4OpticalSurface*
  get_RICH_Mirror_OpticalSurface() const
  {
    return RICH_Mirror_OpticalSurface;
  }

  int get_N_RICH_Sector() const
  {
    return N_RICH_Sector;
  }

  double
  get_z_shift() const
  {
    return z_shift;
  }

  double
  get_R_shift() const
  {
    return R_shift;
  }

  int get_n_GEM_layers() const
  {
    return n_GEM_layers;
  }

  double
  get_HBD_thickness() const
  {
    return HBD_thickness;
  }

  G4OpticalSurface*
  get_RICH_Photocathode_OpticalSurface() const
  {
    return RICH_Photocathode_OpticalSurface;
  }


  void
  set_R_beam_pipe_front(double beamPipe)
  {
    R_beam_pipe_front = beamPipe;
  }


  void
  set_R_beam_pipe_back(double beamPipe)
  {
    R_beam_pipe_back = beamPipe;
  }

  void
  set_frontwindow_DisplaceRatio(double frontwindowDisplaceRatio)
  {
    frontwindow_DisplaceRatio = frontwindowDisplaceRatio;
  }

  void
  set_min_eta(double minEta)
  {
    min_eta = minEta;
  }

  void
  set_R_mirror_ref(double mirrorRef)
  {
    R_mirror_ref = mirrorRef;
  }

  void
  set_dR_backwindow(double rBackwindow)
  {
    dR_backwindow = rBackwindow;
  }

  void
  set_dR_frontwindow(double rFrontwindow)
  {
    dR_frontwindow = rFrontwindow;
  }

  void
  set_dR_frontwindow_shrink(double rFrontwindowShrink)
  {
    dR_frontwindow_shrink = rFrontwindowShrink;
  }

  void
  set_dR_mirror(double rMirror)
  {
    dR_mirror = rMirror;
  }

  void
  set_dR_mirror_spt(double rMirrorSpt)
  {
    dR_mirror_spt = rMirrorSpt;
  }

  void
  set_RICH_gas_mat(G4String richGasMat)
  {
    RICH_gas_mat = richGasMat;
  }

  void
  set_RICH_Gas_Window_mat(G4String richGasWindowMat)
  {
    RICH_Gas_Window_mat = richGasWindowMat;
  }

  void
  set_RICH_Mirror_mat(G4String richMirrorMat)
  {
    RICH_Mirror_mat = richMirrorMat;
  }

  void
  set_N_RICH_Sector(int richSector)
  {
    N_RICH_Sector = richSector;
  }

  void
  set_z_shift(double shift)
  {
    z_shift = shift;
  }

  void
  set_R_shift(double shift)
  {
    R_shift = shift;
  }

  void
  set_n_GEM_layers(int gemLayers)
  {
    n_GEM_layers = gemLayers;
  }

  void
  set_HBD_thickness(double hbdThickness)
  {
    HBD_thickness = hbdThickness;
  }

 private:
  int N_RICH_Sector;

  double min_eta;
  double R_beam_pipe_front;
  double R_beam_pipe_back;

  double z_shift;
  double R_shift;
  double frontwindow_DisplaceRatio;  // Displace R,Z and radius simultainously
  double dR_frontwindow_shrink;
  double R_mirror_ref;

  double dR_mirror;
  double dR_mirror_spt;
  double dR_backwindow;
  double dR_frontwindow;

  int n_GEM_layers;
  double HBD_thickness;

  G4String RICH_gas_mat;
  G4String RICH_Mirror_mat;
  G4String RICH_Gas_Window_mat;

  G4OpticalSurface* RICH_Mirror_OpticalSurface;
  G4OpticalSurface* RICH_Photocathode_OpticalSurface;
};


class ePHENIXRICHConstruction
{
 public:
  virtual ~ePHENIXRICHConstruction() {}
  ePHENIXRICHConstruction(PHG4Subsystem* subsys);
  ePHENIXRICHConstruction(PHG4Subsystem* subsys, const RICH_Geometry& g);

  virtual void
  OverlapCheck(bool check)
  {
    overlapcheck_rich = check;
  }

  G4LogicalVolume*
  Construct_RICH(G4LogicalVolume*);

  G4LogicalVolume*
  Construct_HBD(G4LogicalVolume* RICHSecLog);

  G4LogicalVolume*
  Construct_HBD_Layers(G4LogicalVolume* RICHHBDLog, const G4String name,
                       const G4String material, const double start_z, const double thickness);

  RICH_Geometry geom;

  int is_in_sector(G4VPhysicalVolume*) const;
  PHG4RICHDisplayAction* GetDisplayAction() { return m_DisplayAction; }

 protected:
  static G4Material *GetDetectorMaterial(const std::string &name, const bool quit = true);

  G4LogicalVolume*
  RegisterLogicalVolume(G4LogicalVolume*);

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

  G4PVPlacement*
  RegisterPhysicalVolume(G4PVPlacement*);

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

  PHG4RICHDisplayAction* m_DisplayAction;
  map_phy_vol_t map_phy_vol;

  bool overlapcheck_rich;

  std::set<G4VPhysicalVolume*> sector_vec;
};

}  //namespace ePHENIXRICH

#endif // G4DETECTORS_EPHENIXRICHCONSTRUCTION_H