STRGeometryPar.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Alexandre BEAULIEU                                       *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <vector>
 
#include <TObject.h>
#include <string>
 
namespace Belle2 {
  class STRGeometryPar: public TObject {
 
  public:
 
    STRGeometryPar();
 
    ~STRGeometryPar();
 
    //
    // Setters and Getters
    //
 
    int getVersion() const { return m_Version; }
 
    void setVersion(int version) { m_Version = version; }
 
    //
    // Shield parameters
    //
 
 
    int getNLayers(int shield) const { return m_NLayers[shield] ; }
 
    void setNLayers(int shield, int nLayers)
    {
      m_NLayers[shield] = nLayers ;
 
      // Resize std::vectors according to the number of layers
      m_LayerMaterial[shield].resize(nLayers);
      m_LayerNPlanes[shield].resize(nLayers);
      m_LayerPlaneZ[shield].resize(nLayers);
      m_LayerPlaneInnerRadius[shield].resize(nLayers);
      m_LayerPlaneOuterRadius[shield].resize(nLayers);
 
    }
 
    std::string getLayerMaterial(int shield, int layer) const { return m_LayerMaterial[shield].at(layer);}
 
    void setLayerMaterial(int shield, int layer, const std::string& material) { m_LayerMaterial[shield].at(layer) = material; }
 
    int getLayerNPlanes(int shield, int layer) const
    {
      return m_LayerNPlanes[shield].at(layer);
    }
 
    void setLayerNPlanes(int shield, int layer, int nplanes)
    {
      m_LayerNPlanes[shield].at(layer) = nplanes;
 
      // Resize std::vectors according to the number of planes in each layer
      m_LayerPlaneZ[shield].at(layer).resize(nplanes);
      m_LayerPlaneInnerRadius[shield].at(layer).resize(nplanes);
      m_LayerPlaneOuterRadius[shield].at(layer).resize(nplanes);
    }
 
    double getLayerPlaneZ(int shield, int layer, int plane) const
    {
      return m_LayerPlaneZ[shield].at(layer).at(plane);
    }
 
    const double* getLayerPlaneZ(int shield, int layer) const
    {
      return &m_LayerPlaneZ[shield].at(layer).at(0);
    }
 
 
    void setLayerPlaneZ(int shield, int layer, int plane, double z)
    {
      m_LayerPlaneZ[shield].at(layer).at(plane) = z;
    }
 
 
    double getLayerPlaneInnerRadius(int shield, int layer, int plane) const
    {
      return m_LayerPlaneInnerRadius[shield].at(layer).at(plane);
    }
 
    const  double* getLayerPlaneInnerRadius(int shield, int layer) const
    {
      return &m_LayerPlaneInnerRadius[shield].at(layer).at(0);
    }
 
    void setLayerPlaneInnerRadius(int shield, int layer, int plane, double r)
    {
      m_LayerPlaneInnerRadius[shield].at(layer).at(plane) = r;
    }
 
    double getLayerPlaneOuterRadius(int shield, int layer, int plane) const
    {
      return m_LayerPlaneOuterRadius[shield].at(layer).at(plane);
    }
 
    const double* getLayerPlaneOuterRadius(int shield, int layer) const
    {
      return &m_LayerPlaneOuterRadius[shield].at(layer).at(0);
    }
 
    void setLayerPlaneOuterRadius(int shield, int layer, int plane, double r)
    {
      m_LayerPlaneOuterRadius[shield].at(layer).at(plane) = r;
    }
 
    //
    // POLE Pieces
    //
    std::string getPoleMaterial(int pole) const
    {
      return m_PoleMaterial[pole];
    }
 
    void setPoleMaterial(int pole, const std::string& material)
    {
      m_PoleMaterial[pole] = material;
    }
 
    int getPoleNPlanes(int pole) const
    {
      return m_PoleNPlanes[pole];
    }
 
    void setPoleNPlanes(int pole, int nplanes)
    {
      m_PoleNPlanes[pole] = nplanes;
 
      // Resize std::vectors according to the number of planes in each layer
      m_PolePlaneZ[pole].resize(nplanes);
      m_PolePlaneInnerRadius[pole].resize(nplanes);
      m_PolePlaneOuterRadius[pole].resize(nplanes);
    }
 
    double getPolePlaneZ(int pole, int plane) const
    {
      return m_PolePlaneZ[pole].at(plane);
    }
 
    const double* getPolePlaneZ(int pole) const
    {
      return &m_PolePlaneZ[pole].at(0);
    }
 
 
    void setPolePlaneZ(int pole, int plane, double z)
    {
      m_PolePlaneZ[pole].at(plane) = z;
    }
 
 
    double getPolePlaneInnerRadius(int pole, int plane) const
    {
      return m_PolePlaneInnerRadius[pole].at(plane);
    }
 
    const  double* getPolePlaneInnerRadius(int pole) const
    {
      return &m_PolePlaneInnerRadius[pole].at(0);
    }
 
    void setPolePlaneInnerRadius(int pole, int plane, double r)
    {
      m_PolePlaneInnerRadius[pole].at(plane) = r;
    }
 
    double getPolePlaneOuterRadius(int pole, int plane) const
    {
      return m_PolePlaneOuterRadius[pole].at(plane);
    }
 
    const double* getPolePlaneOuterRadius(int pole) const
    {
      return &m_PolePlaneOuterRadius[pole].at(0);
    }
 
    void setPolePlaneOuterRadius(int pole, int plane, double r)
    {
      m_PolePlaneOuterRadius[pole].at(plane) = r;
    }
 
 
 
    //
    // Constants that will _always_ be true
    // These ate not design parameters but fundamental
    // characteristics of the system. e.g. we will always
    // have only one forward and one backward shield.
    //
    static const int NECLSHIELDS = 2;
    static const int FWD_ECLSHIELD = 0;
    static const int BWD_ECLSHIELD = 1;
 
    static const int NPOLEPIECES = 2;
    static const int FWD_POLEPIECE = 0;
    static const int BWD_POLEPIECE = 1;
 
 
 
  private:
 
 
    static STRGeometryPar* m_Instance;
 
 
    //
    //         Data members:
    // these are the geometry parameters
    //
 
    int m_Version;
 
    //
    // ECL Shields
    //
 
    int m_NLayers[NECLSHIELDS];
 
    std::vector<std::string> m_LayerMaterial[NECLSHIELDS];
 
    std::vector<int> m_LayerNPlanes[NECLSHIELDS];
 
    std::vector< std::vector<double> > m_LayerPlaneZ[NECLSHIELDS];
 
    std::vector< std::vector<double> > m_LayerPlaneInnerRadius[NECLSHIELDS];
 
    std::vector< std::vector<double> > m_LayerPlaneOuterRadius[NECLSHIELDS];
 
 
    //
    // POLE Pieces
    //
 
    std::string m_PoleMaterial[NPOLEPIECES];
 
    int m_PoleNPlanes[NPOLEPIECES];
 
    std::vector<double> m_PolePlaneZ[NPOLEPIECES];
 
    std::vector<double> m_PolePlaneInnerRadius[NPOLEPIECES];
 
    std::vector<double> m_PolePlaneOuterRadius[NPOLEPIECES];
 
 
 
    //
    // For ROOT objects
    //
 
    ClassDef(STRGeometryPar, 1);  
  };
} // end of namespace Belle2