ARICHGeoCooling.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 <arich/dbobjects/ARICHGeoBase.h>
#include <string>
 
//root
#include <Math/Vector3D.h>
 
namespace Belle2 {
  class ARICHGeoCooling: public ARICHGeoBase {
 
  public:
 
    ARICHGeoCooling()
    {}
 
    void setCoolingPipeMaterialName(const std::string& materialName) {m_coolingPipeMaterialName = materialName;}
 
    void setRmin(double rmin) {m_Rmin = rmin;}
 
    void setRmax(double rmax) {m_Rmax = rmax;}
 
    void setEnvelopeOuterRadius(double envelopeOuterRadius) {m_envelopeOuterRadius = envelopeOuterRadius;}
 
    void setEnvelopeInnerRadius(double envelopeInnerRadius) {m_envelopeInnerRadius = envelopeInnerRadius;}
 
    void setEnvelopeThickness(double envelopeThickness) {m_envelopeThickness = envelopeThickness;}
 
    void setEnvelopeCenterPosition(double x0, double y0, double z0) { m_envelopeX0 = x0; m_envelopeY0 = y0; m_envelopeZ0 = z0; }
 
    void setCoolingGeometryID(const std::vector<double>& coolingGeometryID) { m_coolingGeometryID = coolingGeometryID; }
 
    void setCoolingL(const std::vector<double>& coolingL) { m_coolingL = coolingL;}
 
    void setCoolingPosPhi(const std::vector<double>& coolingPosPhi) { m_coolingPosPhi = coolingPosPhi; }
 
    void setCoolingPosR(const std::vector<double>& coolingPosR) { m_coolingPosR = coolingPosR; }
 
    void setCoolinRotationAngle(const std::vector<double>& coolinRotationAngle) { m_coolinRotationAngle = coolinRotationAngle; }
 
    void setCoolingTestPlateMaterialName(const std::string& materialName) {m_coolingTestPlateMaterialName = materialName;}
 
    void setColdTubeMaterialName(const std::string& materialName) {m_coldTubeMaterialName = materialName;}
 
    void setCoolingTestPlateslengths(double lx, double ly, double lz) { m_coolingTestPlateslengthX = lx; m_coolingTestPlateslengthY = ly; m_coolingTestPlateslengthZ = lz; }
 
    void setColdTubeR(double coldTubeR) {m_coldTubeR = coldTubeR;}
 
    void setColdTubeSubtractedR(double coldTubeSubtractedR) {m_coldTubeSubtractedR = coldTubeSubtractedR;}
 
    void setColdTubeWallThickness(double coldTubeWallThickness) {m_coldTubeWallThickness = coldTubeWallThickness;}
 
    void setDepthColdTubeInPlate(double depthColdTubeInPlate) {m_depthColdTubeInPlate = depthColdTubeInPlate;}
 
    void setColdTubeSpacing(double coldTubeSpacing) {m_coldTubeSpacing = coldTubeSpacing;}
 
    void setColdTubeNumber(int coldTubeNumber) {m_coldTubeNumber = coldTubeNumber;}
 
    void setCoolingTestPlatePosR(const std::vector<double>& coolingTestPlatePosR) { m_coolingTestPlatePosR = coolingTestPlatePosR; }
 
    void setCoolingTestPlatePosPhi(const std::vector<double>& coolingTestPlatePosPhi) { m_coolingTestPlatePosPhi = coolingTestPlatePosPhi; }
 
    void setCoolingTestPlatePosZ0(const std::vector<double>& coolingTestPlatePosZ0) {  m_coolingTestPlatePosZ0 = coolingTestPlatePosZ0; }
 
    const std::string& getCoolingPipeMaterialName() const { return m_coolingPipeMaterialName; }
 
    double getRmin() const { return m_Rmin; }
 
    double getRmax() const { return m_Rmax; }
 
    double getEnvelopeOuterRadius() const { return m_envelopeOuterRadius; }
 
    double getEnvelopeInnerRadius() const { return m_envelopeInnerRadius; }
 
    double getEnvelopeThickness() const { return m_envelopeThickness; }
 
    ROOT::Math::XYZVector getEnvelopeCenterPosition() const
    {
      return ROOT::Math::XYZVector(m_envelopeX0, m_envelopeY0, m_envelopeZ0);
    }
 
    const std::vector<double>& getCoolingGeometryID() const { return m_coolingGeometryID; }
 
    const std::vector<double>& getCoolingL() const { return m_coolingL; }
 
    const std::vector<double>& getCoolingPosPhi() const { return m_coolingPosPhi; }
 
    const std::vector<double>& getCoolingPosR() const { return m_coolingPosR; }
 
    const std::vector<double>& getCoolinRotationAngle() const { return m_coolinRotationAngle; }
 
    const std::string& getCoolingTestPlateMaterialName() const { return m_coolingTestPlateMaterialName; }
 
    const std::string& getColdTubeMaterialName() const { return m_coldTubeMaterialName; }
 
    ROOT::Math::XYZVector getCoolingTestPlateslengths() const
    {
      return ROOT::Math::XYZVector(m_coolingTestPlateslengthX, m_coolingTestPlateslengthY, m_coolingTestPlateslengthZ);
    }
 
    double getColdTubeR() const { return m_coldTubeR; }
 
    double getColdTubeSubtractedR() const { return m_coldTubeSubtractedR; }
 
    double getColdTubeWallThickness() const { return m_coldTubeWallThickness; }
 
    double getDepthColdTubeInPlate() const { return m_depthColdTubeInPlate; }
 
    double getColdTubeSpacing() const { return m_coldTubeSpacing; }
 
    int getColdTubeNumber() const { return m_coldTubeNumber; }
 
    const std::vector<double>& getCoolingTestPlatePosR() const { return m_coolingTestPlatePosR; }
 
    const std::vector<double>& getCoolingTestPlatePosPhi() const { return m_coolingTestPlatePosPhi; }
 
    const std::vector<double>& getCoolingTestPlatePosZ0() const { return m_coolingTestPlatePosZ0; }
 
    void print(const std::string& title = "Cooling system geometry parameters") const;
 
    void checkCoolingSystemDataConsistency() const;
 
  private:
 
    std::string m_coolingPipeMaterialName;      
    double m_Rmin = 0.0;                        
    double m_Rmax = 0.0;                        
    double m_envelopeOuterRadius = 0.0;         
    double m_envelopeInnerRadius = 0.0;         
    double m_envelopeThickness = 0.0;           
    double m_envelopeX0 = 0.0;                  
    double m_envelopeY0 = 0.0;                  
    double m_envelopeZ0 = 0.0;                  
    std::vector<double> m_coolingGeometryID;    
    std::vector<double> m_coolingL;             
    std::vector<double>
    m_coolingPosPhi;        
    std::vector<double>
    m_coolingPosR;          
    std::vector<double>
    m_coolinRotationAngle;  
    //Please note that ARICH detector envelope does not have enough
    //space for 8 mm thick cooling test plate (5.5 mm is only available).
    //For this reason the material assigned to the volume (aluminum)
    //will have a bigger dencity for effective descrption of the material.
    std::string m_coolingTestPlateMaterialName; 
    std::string m_coldTubeMaterialName;         
    double m_coolingTestPlateslengthX = 0.0;    
    double m_coolingTestPlateslengthY = 0.0;    
    double m_coolingTestPlateslengthZ = 0.0;    
    double m_coldTubeR                = 0.0;    
    double m_coldTubeSubtractedR      = 0.0;    
    double m_coldTubeWallThickness    = 0.0;    
    double m_depthColdTubeInPlate     = 0.0;    
    double m_coldTubeSpacing = 0.0;             
    int m_coldTubeNumber     = 0;               
    std::vector<double> m_coolingTestPlatePosR;   
    std::vector<double>
    m_coolingTestPlatePosPhi; 
    std::vector<double> m_coolingTestPlatePosZ0;  
    ClassDef(ARICHGeoCooling, 1);               
  };
 
} // end namespace Belle2