ARICHGeoAerogelPlane.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.                  *
 **************************************************************************/
 
#pragma once
#include <framework/logging/Logger.h>
 
#include <arich/dbobjects/ARICHGeoBase.h>
#include <string>
#include <Math/Vector3D.h>
#include <Math/Rotation3D.h>
#include <Math/RotationX.h>
#include <Math/RotationY.h>
#include <Math/RotationZ.h>
 
namespace Belle2 {
  class ARICHGeoAerogelPlane: public ARICHGeoBase {
 
  public:
 
    ARICHGeoAerogelPlane()
    {}
 
    struct layer {
 
      double thickness;
 
      double refIndex;
 
      double trLength;
 
      std::string material;
 
    };
 
    struct tilestr {
 
      int ring;
 
      int column;
 
      int layer;
 
      double n;
 
      double transmL;
 
      double thick;
 
      std::string material;
 
    };
 
    bool isConsistent() const override;
 
    void print(const std::string& title = "Aerogel plane parameters:") const override;
 
    void setPlacement(double x, double y, double z, double rx, double ry, double rz) {m_x = x; m_y = y; m_z = z; m_rx = rx; m_ry = ry; m_rz = rz;}
 
    void addSupportPlate(double inR, double outR, double thick, const std::string& material)
    {
      m_innerR = inR;
      m_outerR = outR;
      m_thickness = thick;
      m_supportMaterial = material;
    };
 
    void setWallThickness(double thick) {m_wallThickness = thick;}
 
    void setWallHeight(double height) {m_wallHeight = height;}
 
    void setTileGap(double gap) {m_tileGap = gap;}
 
    void addTileParameters(int ring, int column, int layerN, double n, double transmL, double thick, const std::string& material)
    {
      m_tiles.push_back({ ring, column, layerN, n, transmL, thick, material });
    }
 
    ROOT::Math::XYZVector getPosition() const {return ROOT::Math::XYZVector(m_x / s_unit, m_y / s_unit, m_z / s_unit);}
 
    ROOT::Math::Rotation3D getRotation() const
    {
      ROOT::Math::Rotation3D rot;
      ROOT::Math::RotationX rotX(m_rx);
      ROOT::Math::RotationY rotY(m_ry);
      ROOT::Math::RotationZ rotZ(m_rz);
      rot *= rotZ * rotY * rotX;
      return rot;
    }
 
    double getRotationX() const {return m_rx;}
 
    double getRotationY() const {return m_ry;}
 
    double getRotationZ() const {return m_rz;}
 
    double getSupportInnerR() const {return m_innerR / s_unit;};
 
    double getSupportOuterR() const {return m_outerR / s_unit;};
 
    double getSupportThickness() const {return m_thickness / s_unit;};
 
    double getWallThickness() const {return m_wallThickness / s_unit;};
 
    double getWallHeight() const {return m_wallHeight / s_unit;};
 
    double getTileGap() const {return m_tileGap / s_unit;};
 
    const std::string& getSupportMaterial() const {return m_supportMaterial;}
 
    void setWallRadius(std::vector<double>& rs) { m_r = rs; m_rSize = rs.size();}
 
    void setWallDPhi(std::vector<double>& dphi) { m_dPhi = dphi; m_dPhiSize = dphi.size();}
 
    void setAerogelLayer(unsigned ilayer, double thick, double rIndex, double trLen, const std::string& material)
    {
      if (ilayer == m_nLayers + 1) {
        m_layers.push_back({thick, rIndex, trLen, material});
        m_nLayers++;
      } else if (ilayer < m_nLayers + 1) {
        m_layers[ilayer - 1] = {thick, rIndex, trLen, material};
      } else B2ERROR("ARICHGeoAerogelPlane::setAerogelLayer: please set aerogel layers in consecutive order!");
    }
 
    void setNAeroSlotsIndividualRing(const std::vector<int>& nAeroSlotsIndividualRing) { m_nAeroSlotsIndividualRing = nAeroSlotsIndividualRing; }
 
    unsigned getNLayers() const {return m_nLayers;}
 
    unsigned getNRings() const {return m_rSize;}
 
    double getRingRadius(unsigned iRing) const { if (iRing > m_rSize || iRing == 0) B2ERROR("ARICHGeoAerogelPlane: invalid ring number!"); return m_r[iRing - 1] / s_unit;}
 
    double getRingDPhi(unsigned iRing) const { if (iRing > m_rSize || iRing == 0) B2ERROR("ARICHGeoAerogelPlane: invalid ring number!"); return m_dPhi[iRing - 1];}
 
    double getLayerThickness(unsigned iLayer) const {if (iLayer > m_nLayers || iLayer == 0) B2ERROR("ARICHGeoAerogelPlane: invalid aerogel layer number!"); return m_layers[iLayer - 1].thickness / s_unit;}
 
    double getLayerRefIndex(unsigned iLayer) const { if (iLayer > m_nLayers || iLayer == 0) B2ERROR("ARICHGeoAerogelPlane: invalid aerogel layer number!"); return m_layers[iLayer - 1].refIndex;}
 
    double getLayerTrLength(unsigned iLayer) const { if (iLayer > m_nLayers || iLayer == 0) B2ERROR("ARICHGeoAerogelPlane: invalid aerogel layer number!"); return m_layers[iLayer - 1].trLength / s_unit;}
 
    const std::string& getLayerMaterial(unsigned iLayer) const { if (iLayer > m_nLayers || iLayer == 0) B2ERROR("ARICHGeoAerogelPlane: invalid aerogel layer number!"); return m_layers[iLayer - 1].material;}
 
    unsigned getAerogelTileID(double x, double y) const;
 
    void setSimple(std::vector<double>& params)
    {
      if (params.size() != 5) B2ERROR("ARICHGeoAerogelPlane:setSimple: 5 parameters are needed for simple configuration!");
      m_simple = true;
      m_simpleParams = params;
    }
 
    bool isSimple() const
    {
      return m_simple;
    }
 
    const std::vector<double>& getSimpleParams() const
    {
      return m_simpleParams;
    }
 
    const std::vector<int>& getNAeroSlotsIndividualRing() const
    {
      return m_nAeroSlotsIndividualRing;
    }
 
    double getAerogelZPosition() const
    {
      return m_z / s_unit - (m_wallHeight / s_unit - m_thickness / s_unit) / 2.;
    }
 
    void setFullAerogelMaterialDescriptionKey(int fullAerogelMaterialDescriptionKey)
    {
      m_fullAerogelMaterialDescriptionKey = fullAerogelMaterialDescriptionKey;
    }
 
    int getFullAerogelMaterialDescriptionKey() const
    {
      return m_fullAerogelMaterialDescriptionKey;
    }
 
    unsigned getTileParameters(int ring, int column, int layerN, double& n, double& transmL, double& thick,
                               std::string& material) const;
 
    double getTileThickness(int ring, int column, int layerN) const;
 
    std::string getTileMaterialName(int ring, int column, int layerN) const;
 
    double getTotalTileThickness(int ring, int column) const;
 
    double getMaximumTotalTileThickness() const;
 
    void setImgTubeThickness(double imgTubeThickness)
    {
      m_imgTubeThickness = imgTubeThickness;
    }
 
    double getImgTubeThickness() const
    {
      return m_imgTubeThickness;
    }
 
    void setCompensationARICHairVolumeThick_min(double compensationARICHairVolumeThick_min)
    {
      m_compensationARICHairVolumeThick_min = compensationARICHairVolumeThick_min;
    }
 
    double getCompensationARICHairVolumeThick_min() const
    {
      return m_compensationARICHairVolumeThick_min;
    }
 
    void printTileParameters(const std::string& title = "Aerogel tiles parameters:") const;
 
    void printSingleTileParameters(unsigned i) const;
 
    void testGetTileParametersFunction() const;
 
  private:
 
    // position in local ARICH volume
    double m_x = 0;               
    double m_y = 0;               
    double m_z = 0;               
    // rotations in local ARICH volume
    double m_rx = 0;              
    double m_ry = 0;              
    double m_rz = 0;              
    std::vector<double> m_r;      
    std::vector<double> m_dPhi;   
    std::vector<int> m_nAeroSlotsIndividualRing; 
    std::vector<layer> m_layers;  
    std::vector<tilestr> m_tiles; 
    double m_tileGap = 0;         
    // support structure parameters
    std::string m_supportMaterial; 
    double m_innerR = 0;           
    double m_outerR = 0;           
    double m_thickness = 0;        
    double m_wallThickness = 0;    
    double m_wallHeight = 0;       
    unsigned m_rSize = 0;          
    unsigned m_dPhiSize = 0;       
    unsigned m_nLayers = 0;        
    bool m_simple = 0;             
    std::vector<double> m_simpleParams; 
    int m_fullAerogelMaterialDescriptionKey =
      0; 
    double m_imgTubeThickness =
      0.0; 
    double m_compensationARICHairVolumeThick_min = 0; 
    ClassDefOverride(ARICHGeoAerogelPlane, 3); 
  };
 
} // end namespace Belle2