GeoVXDComponents.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#ifndef GEOVXDCOMPONENTS_H
#define GEOVXDCOMPONENTS_H
 
#include <vxd/geometry/SensorInfoBase.h>
 
#include <string>
#include <vector>
 
class G4LogicalVolume;
 
namespace Belle2 {
  class VXDGeoPlacement {
  public:
    enum EPosW {
      c_below,  
      c_bottom, 
      c_center, 
      c_top,    
      c_above   
    };

    VXDGeoPlacement(const std::string& name = "", double u = 0, double v = 0,
                    std::string w = "bottom", double woffset = 0);
    const std::string& getName() const { return m_name; }
    double getU() const { return m_u; }
    double getV() const { return m_v; }
    EPosW getW() const { return m_w; }
    double getWOffset() const { return m_woffset; }
  private:
    std::string m_name;
    double m_u;
    double m_v;
    EPosW m_w;
    double m_woffset;
  };

  class VXDGeoComponent {
  public:
    VXDGeoComponent(const std::string& material = "", const std::string& color = "",
                    double width = 0, double width2 = 0, double length = 0, double height = 0):
      m_volume(0), m_material(material), m_color(color), m_width(width), m_width2(width2), m_length(length),
      m_height(height) {}

    G4LogicalVolume* getVolume() const { return m_volume; }
    void setVolume(G4LogicalVolume* volume) { m_volume = volume; }
    const std::string& getMaterial() const { return m_material; }
    const std::string& getColor() const { return m_color; }
    double getWidth() const { return m_width; }
    void setWidth(double width) { m_width = width; m_width2 = 0; }
    double getWidth2() const { return m_width2; }
    double getLength() const { return m_length; }
    void setLength(double length) { m_length = length; }
    double& getHeight() { return m_height; }
    double getHeight() const { return m_height; }
  private:
    G4LogicalVolume* m_volume; 
    std::string m_material;
    std::string m_color;
    double m_width;
    double m_width2;
    double m_length;
    double m_height;
  };

  class VXDGeoSensor: public VXDGeoComponent {
  public:
    VXDGeoSensor(const std::string& material = "", const std::string& color = "",
                 double width = 0, double width2 = 0, double length = 0, double height = 0, bool slanted = false):
      VXDGeoComponent(material, color, width, width2, length, height), m_info(0), m_slanted(slanted) {}

    void setActive(const VXDGeoComponent& area, const VXDGeoPlacement& placement)
    {
      m_activeArea = area; m_activePlacement = placement;
    }

    VXDGeoComponent& getActiveArea() { return m_activeArea; }
    const VXDGeoPlacement& getActivePlacement() { return m_activePlacement; }
    void setComponents(const std::vector<VXDGeoPlacement>& component) { m_components = component; }
    const std::vector<VXDGeoPlacement>& getComponents() const { return m_components; }
    void setSensorInfo(VXD::SensorInfoBase* info) { m_info = info; }
    const VXD::SensorInfoBase* getSensorInfo() const { return m_info; }
    bool getSlanted() const { return m_slanted; }
  private:
    VXDGeoComponent m_activeArea;
    VXDGeoPlacement m_activePlacement;
    VXD::SensorInfoBase* m_info;
    bool m_slanted;
    std::vector<VXDGeoPlacement> m_components;
  };

  class VXDGeoSensorPlacement {
  public:
    VXDGeoSensorPlacement(int sensorID = 0, const std::string& sensorTypeID = "", double z = 0,
                          bool flipU = false, bool flipV = false, bool flipW = false):
      m_sensorID(sensorID), m_sensorTypeID(sensorTypeID), m_z(z), m_flipU(flipU), m_flipV(flipV), m_flipW(flipW) {}

    int getSensorID() const { return m_sensorID; }
    const std::string& getSensorTypeID() const { return m_sensorTypeID; }
    double getZ() const { return m_z; }
    bool getFlipU() const { return m_flipU; }
    bool getFlipV() const { return m_flipV; }
    bool getFlipW() const { return m_flipW; }
  private:
    int m_sensorID;
    std::string m_sensorTypeID;
    double m_z;
    bool m_flipU;
    bool m_flipV;
    bool m_flipW;
  };

  class VXDGeoLadder {
  public:
    VXDGeoLadder(int layerID = 0, double shift = 0, double radius = 0,
                 double slantedAngle = 0, double slantedRadius = 0,
                 double glueSize = -1, const std::string& glueMaterial = ""):
      m_layerID(layerID), m_shift(shift), m_radius(radius),
      m_slantedAngle(slantedAngle), m_slantedRadius(slantedRadius),
      m_glueSize(glueSize), m_glueMaterial(glueMaterial) {}

    int getLayerID() const { return m_layerID; }
    double getShift() const { return m_shift; }
    double getRadius() const { return m_radius; }
    double getSlantedAngle() const { return m_slantedAngle; }
    double getSlantedRadius() const { return m_slantedRadius; }
    double getGlueSize() const { return m_glueSize; }
    const std::string& getGlueMaterial() const { return m_glueMaterial; }
    const std::vector<VXDGeoSensorPlacement>& getSensors() const { return m_sensors; }
    void addSensor(const VXDGeoSensorPlacement& sensor) { m_sensors.push_back(sensor); }
  private:
    int m_layerID;
    double m_shift;
    double m_radius;
    double m_slantedAngle;
    double m_slantedRadius;
    double m_glueSize;
    std::string m_glueMaterial;
    std::vector<VXDGeoSensorPlacement> m_sensors;
  };

} // namespace Belle2
 
#endif /* GEOVXDCOMPONENTS_H */