CDCGeometryPar.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/gearbox/GearDir.h>
#include <framework/database/DBArray.h>
#include <framework/database/DBObjPtr.h>
#include <framework/dbobjects/HardwareClockSettings.h>
#include <framework/geometry/B2Vector3.h>
 
#include <cdc/dataobjects/WireID.h>
#include <cdc/dbobjects/CDCTimeZeros.h>
#include <cdc/dbobjects/CDCBadWires.h>
#include <cdc/dbobjects/CDCPropSpeeds.h>
#include <cdc/dbobjects/CDCTimeWalks.h>
#include <cdc/dbobjects/CDCXtRelations.h>
#include <cdc/dbobjects/CDCSpaceResols.h>
#include <cdc/dbobjects/CDCFudgeFactorsForSigma.h>
#include <cdc/dbobjects/CDCChannelMap.h>
#include <cdc/dbobjects/CDCDisplacement.h>
#include <cdc/dbobjects/CDCAlignment.h>
#include <cdc/dbobjects/CDCMisalignment.h>
#include <cdc/dbobjects/CDCGeometry.h>
#include <cdc/dbobjects/CDCEDepToADCConversions.h>
 
#include <cdc/geometry/CDCGeometryParConstants.h>
 
#include <vector>
#include <string>
#include <map>
//#include <fstream>
 
 
namespace Belle2 {
  namespace CDC {
 
 
    class CDCGeometryPar {
 
    public:
 
      enum EWirePosition {c_Base = 0, c_Misaligned, c_Aligned};
 
      virtual ~CDCGeometryPar();
 
 
      static CDCGeometryPar& Instance(const CDCGeometry* = nullptr);
 
      void clear();
 
      void Print() const;
 
      void readFromDB(const CDCGeometry&);
 
      //      /**
      //       * Read z-corrections.
      //       * @param GearDir Gear Dir.
      //       */
      //      void readDeltaz(const GearDir);
      //
      //      /**
      //       * Read z-corrections from DB.
      //       *
      //       */
      //      void readDeltaz(const CDCGeometry&);
 
      //      /**
      //       * Open a file
      //       * @param[in] ifs input file-stream
      //       * @param[in] fileName0 file-name on cdc/data directory
      //       */
      //      void openFile(std::ifstream& ifs, const std::string& fileName0) const;
 
      //      void readWirePositionParams(EWirePosition set, const CDCGeometry*,  const GearDir);
      void readWirePositionParams(EWirePosition set, const CDCGeometry* geom);
 
      void setWirPosAlignParams();
 
      void setWirPosMisalignParams();
 
      void readXT(const GearDir& gbxParams, int mode = 0);
 
      void newReadXT(const GearDir& gbxParams, int mode = 0);
 
      void setXT();
 
      void setXtRel();
 
      void readSigma(const GearDir& gbxParams, int mode = 0);
 
      void newReadSigma(const GearDir& gbxParams, int mode = 0);
 
      void readFFactor(const GearDir& gbxParams, int mode = 0);
 
      void setSResol();
 
      void setFFactor();
 
      void readPropSpeed(const GearDir& gbxParams, int mode = 0);
 
      void setPropSpeed();
 
      void readT0(const GearDir& gbxParams, int mode = 0);
 
      void setT0();
 
      void calcMeanT0(double minT0 = 3800, double maxT0 = 5800, int maxIt = 10, double nStdv = 3, double epsi = 0.1);
 
      //      /**
      //       * Read bad-wires (from a file).
      //       * @param GearDir Gear Dir.
      //       * @param mode 0: read simulation file, 1: read reconstruction file.
      //       */
      //      void readBadWire(const GearDir, int mode = 0);
 
      void setBadWire();
 
      //      void readChMap(const GearDir);
      void readChMap();
 
      void setChMap();
 
      void readTW(const GearDir& gbxParams, int mode = 0);
 
      void readEDepToADC(const GearDir& gbxParams, int mode = 0);
 
      void setTW();
 
      void setEDepToADCConversions();
 
      double getEDepToADCConvFactor(unsigned short layer, unsigned short cell, double edep, double dx, double costh);
 
 
      double getEDepToADCMainFactor(unsigned short layer, unsigned short cell, double costh = 0)
      {
        return m_eDepToADCParams[layer][cell][0] + m_eDepToADCParams[layer][cell][4] * (costh - m_eDepToADCParams[layer][cell][5]);
      };
 
      double getEDepToADCSigma(unsigned short layer, unsigned short cell)
      {
        return m_eDepToADCParams[layer][cell][6];
      };
 
 
      void generateXML(const std::string& of);
 
 
      std::string version() const;
 
 
      double motherInnerR() const;
 
 
      double motherOuterR() const;
 
 
      double motherLength() const;
 
 
      int momBound() const;
 
 
      double momZ(int iBound) const;
 
 
      double momRmin(int iBound) const;
 
 
      unsigned cellId(unsigned layerId, const B2Vector3D& position) const;
 
 
      double innerRadiusOuterWall() const;
 
 
      double outerRadiusOuterWall() const;
 
 
      double zOuterWall() const;
 
 
      double zOffsetOuterWall() const;
 
 
      double innerRadiusInnerWall() const;
 
 
      double outerRadiusInnerWall() const;
 
 
      double zInnerWall() const;
 
 
      double zOffsetInnerWall() const;
 
 
      double senseWireDiameter() const;
 
 
      double fieldWireDiameter() const;
 
 
      unsigned nWireLayers() const;
 
 
      unsigned nWiresInLayer(int layerId) const;
 
 
      const double* innerRadiusWireLayer() const;
 
 
      const double* outerRadiusWireLayer() const;
 
 
      const double* zForwardWireLayer() const;
 
 
      const double* zBackwardWireLayer() const;
 
 
      double zOffsetWireLayer(unsigned i) const;
 
 
      double getMeanT0() const;
 
 
      const B2Vector3D wireForwardPosition(uint layerId, int cellId, EWirePosition set = c_Base) const;
 
      const B2Vector3D wireForwardPosition(const WireID& wireID, EWirePosition set = c_Base) const
      {
        return wireForwardPosition(wireID.getICLayer(), wireID.getIWire(), set);
      }
 
 
      const B2Vector3D wireForwardPosition(uint layerId, int cellId, double z, EWirePosition set = c_Base) const;
      const B2Vector3D wireForwardPosition(const WireID& wireID, double z,
                                           EWirePosition set = c_Base) const
      {
        return wireForwardPosition(wireID.getICLayer(), wireID.getIWire(), z, set);
      }
 
 
      const B2Vector3D wireBackwardPosition(uint layerId, int cellId, EWirePosition set = c_Base) const;
 
      const B2Vector3D wireBackwardPosition(const WireID& wireID, EWirePosition set = c_Base) const
      {
        return wireBackwardPosition(wireID.getICLayer(), wireID.getIWire(), set);
      }
 
 
      const B2Vector3D wireBackwardPosition(uint layerId, int cellId, double z, EWirePosition set = c_Base) const;
      const B2Vector3D wireBackwardPosition(const WireID& wireID, double z, EWirePosition set = c_Base) const
      {
        return wireBackwardPosition(wireID.getICLayer(), wireID.getIWire(), z, set);
      }
 
 
      double getWireSagCoef(EWirePosition set, uint layerId, int cellId) const;
 
 
 
      double getThresholdEnerguDeposit() const
      {
        return m_thresholdEnergyDeposit;
      }
 
 
      double getMinTrackLength() const
      {
        return m_minTrackLength;
      }
 
 
      bool isWireSagOn() const
      {
        return m_wireSag;
      }
 
 
      bool isModifiedLeftRightFlagOn() const
      {
        return  m_modLeftRightFlag;
      }
 
 
 
      float getT0(const WireID& wireID) const
      {
        //  std::cout << wireID.getICLayer() <<" "<< wireID.getIWire() << std::endl;
        unsigned int iclayer = wireID.getICLayer();
        unsigned int iwire = wireID.getIWire();
        if (iclayer >= c_maxNSenseLayers) iclayer = c_maxNSenseLayers - 1;
        if (iwire >= c_maxNDriftCells) iwire = c_maxNDriftCells - 1;
        return m_t0[iclayer][iwire];
      }
 
 
      unsigned short getBoardID(const WireID& wID) const
      {
        std::map<WireID, unsigned short>::const_iterator it = m_wireToBoard.find(wID);
        unsigned short iret = (it != m_wireToBoard.end()) ? it->second : -999;
        return iret;
      }
 
 
      unsigned short getChannelID(const WireID& wID) const
      {
        std::map<WireID, unsigned short>::const_iterator it = m_wireToChannel.find(wID);
        unsigned short iret = (it != m_wireToChannel.end()) ? it->second : -999;
        return iret;
      }
 
 
      const WireID getWireID(unsigned short bd, unsigned short ch) const
      {
        return WireID(m_boardAndChannelToWire[bd][ch]);
      }
 
 
      double getTimeWalk(const WireID& wID, unsigned short adcCount) const
      {
        std::map<WireID, unsigned short>::const_iterator it = m_wireToBoard.find(wID);
        //  std::cout <<"SL,L,W, bd#= " << wID.getISuperLayer() <<" "<< wID.getILayer() <<" "<< wID.getIWire() <<" "<< it->second << std::endl;
        double tw = 0.;
        if (it != m_wireToBoard.end() && adcCount > 0) {
          if (m_twParamMode == 0) {
            tw = m_timeWalkCoef[it->second][0] / sqrt(adcCount);
          } else if (m_twParamMode == 1) {
            double p0 = m_timeWalkCoef[it->second][0];
            double p1 = m_timeWalkCoef[it->second][1];
            tw = p0 * exp(-p1 * adcCount);
          }
        }
        //  std::cout <<"bd#,coef,adc,tw= " << it->second <<" "<< m_timeWalkCoef[it->second] <<" "<< adcCount <<" "<< tw << std::endl;
        return tw;
      }
 
 
      void setShiftInSuperLayer();
 
 
      signed short getShiftInSuperLayer(unsigned short iSuperLayer, unsigned short iLayer) const;
 
 
      double senseWireR(int layerId) const;
 
 
      double senseWireFZ(int layerId) const;
 
 
      double senseWireBZ(int layerId) const;
 
 
      double fieldWireR(int layerId) const;
 
 
      double fieldWireFZ(int layerId) const;
 
 
      double fieldWireBZ(int layerId) const;
 
 
      int nShifts(int layerId) const;
 
      double offset(int layerID) const;
 
 
      void setSenseWireR(int layerId, double r);
 
 
      void setSenseWireFZ(int layerId, double fz);
 
 
      void setSenseWireBZ(int layerId, double bz);
 
      inline unsigned short getTdcOffset() const
      {
        return m_tdcOffset;
      }
 
      inline double getTdcBinWidth() const
      {
        return m_tdcBinWidth;
      }
 
      inline double getNominalDriftV() const
      {
        return m_nominalDriftV;
      }
 
      inline double getNominalPropSpeed() const
      {
        return m_nominalPropSpeed;
      }
 
      inline double getNominalSpaceResol() const
      {
        return m_nominalSpaceResol;
      }
 
      inline int getMaterialDefinitionMode() const
      {
        return m_materialDefinitionMode;
      }
 
      inline int getSenseWireZposMode() const
      {
        return m_senseWireZposMode;
      }
 
      inline double getBwdDeltaZ(unsigned short layerID) const
      {
        return m_dzSBackwardLayer[layerID];
      }
 
      inline double getFwdDeltaZ(unsigned short layerID) const
      {
        return m_dzSForwardLayer[layerID];
      }
 
      inline void setNominalSpaceResol(double resol)
      {
        m_nominalSpaceResol = resol;
      }
 
      inline double getPropSpeedInv(const unsigned int layerID) const
      {
        return m_propSpeedInv[layerID];
      }
 
      inline bool isBadWire(const WireID& wid)
      {
        //        std::map<unsigned short, float>::iterator it = m_badWire.find(wid.getEWire());
        //        bool torf = (it != m_badWire.end()) ? true : false;
        //        return torf;
        bool torf = *m_badWireFromDB ? (*m_badWireFromDB)->isBadWire(wid) : false;
        return torf;
 
      }
 
      inline bool isDeadWire(const WireID& wid, double& eff)
      {
        bool torf = *m_badWireFromDB ? (*m_badWireFromDB)->isDeadWire(wid, eff) : false;
        return torf;
      }
 
      inline bool isHotWire(const WireID& wid)
      {
        bool torf = *m_badWireFromDB ? (*m_badWireFromDB)->isHotWire(wid) : false;
        return torf;
      }
 
      void getWireSagEffect(EWirePosition set, unsigned layerID, unsigned cellID, double zw, double& ywb_sag, double& ywf_sag) const;
 
      double getDriftV(double dt, unsigned short layer, unsigned short lr, double alpha = 0., double theta = 0.5 * M_PI) const;
 
      double getDriftLength(double dt, unsigned short layer, unsigned short lr, double alpha = 0., double theta = 0.5 * M_PI,
                            bool calculateMinTime = true, double minTime = 0.) const;
 
      double getDriftLength0(double dt, unsigned short layer, unsigned short lr, double alpha = 0., double theta = 0.5 * M_PI) const;
 
      double getMinDriftTime(unsigned short layer, unsigned short lr, double alpha = 0., double theta = 0.5 * M_PI) const;
 
      double getDriftTime(double dist, unsigned short layer, unsigned short lr, double alpha, double theta) const;
 
      double getSigma(double dist, unsigned short layer, unsigned short lr, double alpha = 0., double theta = 0.5 * M_PI) const;
 
      double getFudgeFactorForSigma(unsigned short target) const
      {
        return m_fudgeFactorForSigma[target];
      }
 
      unsigned short getOldLeftRight(const B2Vector3D& posOnWire, const B2Vector3D& posOnTrack, const B2Vector3D& momentum) const;
 
      unsigned short getNewLeftRightRaw(const B2Vector3D& posOnWire, const B2Vector3D& posOnTrack, const B2Vector3D& momentum) const;
 
      double getAlpha(const B2Vector3D& posOnWire, const B2Vector3D& momentum) const;
 
      double getTheta(const B2Vector3D& momentum) const;
 
 
      unsigned short getOutgoingLR(const unsigned short lr, const double alpha) const;
 
 
      double getOutgoingAlpha(const double alpha) const;
 
 
      double getOutgoingTheta(const double alpha, const double theta) const;
 
 
      void getClosestAlphaPoints(const double alpha, double& wal, unsigned short points[2], unsigned short lrs[2]) const;
 
      void getClosestAlphaPoints4Sgm(const double alpha, double& wal, unsigned short points[2], unsigned short lrs[2]) const;
 
      void getClosestThetaPoints(const double alpha, const double theta, double& wth, unsigned short points[2]) const;
 
      void getClosestThetaPoints4Sgm(const double alpha, const double theta, double& wth, unsigned short points[2]) const;
 
      void setDesignWirParam(unsigned layerID, unsigned cellID);
 
      void outputDesignWirParam(unsigned layerID, unsigned cellID) const;
 
      void setDisplacement();
 
 
      ushort getNumberOfSenseWires() const { return m_nSenseWires;}
 
      ushort getNumberOfFieldWires() const { return m_nFieldWires;}
 
      ushort getNumberOfSenseLayers() const { return m_maxNSenseLayers;}
 
      ushort getNumberOfFieldLayers() const { return m_maxNFieldLayers;}
 
      ushort getMaxNumberOfSuperLayers() const { return m_maxNSuperLayers;}
 
      ushort getOffsetOfFirstLayer() const { return m_firstLayerOffset;}
 
      ushort getOffsetOfFirstSuperLayer() const { return m_firstSuperLayerOffset;}
 
      ushort getMaxNumberOfCellsPerLayer() const { return m_maxNCellsPerLayer;}
 
    private:
      CDCGeometryPar(const CDCGeometry* = nullptr);
      CDCGeometryPar(const CDCGeometryPar&);
      CDCGeometryPar& operator=(const CDCGeometryPar&);
 
      bool m_debug;          
      bool m_linearInterpolationOfXT;  
      bool m_linearInterpolationOfSgm; 
      bool m_XTetc;          
      bool m_displacement;   
      bool m_misalignment;   
      bool m_alignment;      
      bool m_XTetc4Recon;    
      bool m_wireSag;        
      bool m_modLeftRightFlag; 
      std::string m_version; 
      int m_materialDefinitionMode; 
      int m_senseWireZposMode; 
      int m_xtFileFormat;      
      int m_xtParamMode;       
      int m_sigmaFileFormat;   
      int m_sigmaParamMode;    
      int m_twParamMode;       
      int m_nSLayer;         
      int m_nFLayer;         
      unsigned short m_nAlphaPoints;  
      unsigned short m_nThetaPoints;  
      unsigned short m_nAlphaPoints4Sgm;  
      unsigned short m_nThetaPoints4Sgm;  
      signed short m_shiftInSuperLayer[c_nSuperLayers][8]; 
      double m_rWall[4];     
      double m_zWall[4][2];  
      double m_rSLayer[c_maxNSenseLayers];          
      double m_zSForwardLayer[c_maxNSenseLayers];   
      double m_dzSForwardLayer[c_maxNSenseLayers];   
      double m_zSBackwardLayer[c_maxNSenseLayers];  
      double m_dzSBackwardLayer[c_maxNSenseLayers]; 
      double m_rFLayer[c_maxNFieldLayers];          
      double m_zFForwardLayer[c_maxNFieldLayers];   
      double m_zFBackwardLayer[c_maxNFieldLayers];  
      double m_offSet[c_maxNSenseLayers];           
      double m_cellSize[c_maxNSenseLayers];         
      int m_nShifts[c_maxNSenseLayers];             
      unsigned m_nWires[c_maxNSenseLayers];         
      double m_senseWireDiameter;                   
      double m_senseWireTension;                    
      double m_senseWireDensity;                    
      double m_fieldWireDiameter;                   
      double m_globalPhiRotation;  
      double m_momZ[7];      
      double m_momRmin[7];   
      //      double m_bwdDz[c_maxNSenseLayers];  /*!< Tentative backward z-corrections.*/
      //      double m_fwdDz[c_maxNSenseLayers];  /*!< Tentative forward  z-corrections.*/
 
      double m_thresholdEnergyDeposit; 
      double m_minTrackLength;         
      float m_FWirPos[c_maxNSenseLayers][c_maxNDriftCells][3]; 
      float m_BWirPos[c_maxNSenseLayers][c_maxNDriftCells][3]; 
      float m_WireSagCoef[c_maxNSenseLayers][c_maxNDriftCells]; 
      float m_FWirPosMisalign[c_maxNSenseLayers][c_maxNDriftCells][3]; 
      float m_BWirPosMisalign[c_maxNSenseLayers][c_maxNDriftCells][3]; 
      float m_WireSagCoefMisalign[c_maxNSenseLayers][c_maxNDriftCells]; 
      float m_FWirPosAlign[c_maxNSenseLayers][c_maxNDriftCells][3]; 
      float m_BWirPosAlign[c_maxNSenseLayers][c_maxNDriftCells][3]; 
      float m_WireSagCoefAlign[c_maxNSenseLayers][c_maxNDriftCells]; 
      float m_eDepToADCParams[c_maxNSenseLayers][c_maxNDriftCells][7] = {}; 
      float m_alphaPoints[c_maxNAlphaPoints]; 
      float m_thetaPoints[c_maxNThetaPoints]; 
      float m_alphaPoints4Sgm[c_maxNAlphaPoints]; 
      float m_thetaPoints4Sgm[c_maxNThetaPoints]; 
      float m_XT[c_maxNSenseLayers][2][c_maxNAlphaPoints][c_maxNThetaPoints][c_nXTParams];  
      float m_Sigma[c_maxNSenseLayers][2][c_maxNAlphaPoints][c_maxNThetaPoints][c_nSigmaParams];      
      float m_propSpeedInv[c_maxNSenseLayers];  
      float m_t0[c_maxNSenseLayers][c_maxNDriftCells] = {};  
      float m_timeWalkCoef[c_nBoards][2];  
      //      float m_meanT0;  /*!< mean t0 over all wires. */
      double m_meanT0;  
      std::map<WireID, unsigned short> m_wireToBoard;  
      std::map<WireID, unsigned short> m_wireToChannel; 
      unsigned short m_boardAndChannelToWire[c_nBoards][48]; 
      //      std::map<unsigned short, float> m_badWire;  /*!< list of bad-wires. */
 
      unsigned short m_tdcOffset;  
      double m_clockFreq4TDC;      
      double m_tdcBinWidth;        
      double m_nominalDriftV;      
      double m_nominalDriftVInv;   
      double m_nominalPropSpeed;   
      double m_nominalSpaceResol;  
      double m_maxSpaceResol;      
      double m_fudgeFactorForSigma[3];     
      DBObjPtr<CDCTimeZeros>* m_t0FromDB; 
      DBObjPtr<CDCBadWires>* m_badWireFromDB; 
      DBObjPtr<CDCPropSpeeds>* m_propSpeedFromDB; 
      DBObjPtr<CDCTimeWalks>* m_timeWalkFromDB; 
      DBObjPtr<CDCXtRelations>* m_xtRelFromDB; 
      DBObjPtr<CDCSpaceResols>* m_sResolFromDB; 
      DBObjPtr<CDCFudgeFactorsForSigma>* m_fFactorFromDB; 
      DBArray<CDCChannelMap>* m_chMapFromDB; 
      DBArray<CDCDisplacement>* m_displacementFromDB; 
      DBObjPtr<CDCAlignment>* m_alignmentFromDB; 
      DBObjPtr<CDCMisalignment>* m_misalignmentFromDB; 
      DBObjPtr<CDCEDepToADCConversions>* m_eDepToADCConversionsFromDB; 
      DBObjPtr<HardwareClockSettings> m_clockSettings; 
      static CDCGeometryPar* m_B4CDCGeometryParDB; 
      ushort m_nSenseWires            = c_nSenseWires;      
      ushort m_nFieldWires            = c_nFieldWires;      
      ushort m_maxNSenseLayers        = c_maxNSenseLayers;  
      ushort m_maxNFieldLayers        = c_maxNFieldLayers;  
      ushort m_maxNSuperLayers        = c_nSuperLayers;     
      ushort m_firstLayerOffset       = 0;                  
      ushort m_firstSuperLayerOffset  = 0;                  
      ushort m_maxNCellsPerLayer      = c_maxNDriftCells;   
    };
 
//-----------------------------------------------------------------------------
//  Inline functions
//-----------------------------------------------------------------------------
    inline std::string CDCGeometryPar::version() const
    {
      return m_version;
    }
 
    inline double CDCGeometryPar::momZ(int iBound) const
    {
      return m_momZ[iBound];
    }
 
    inline double CDCGeometryPar::momRmin(int iBound) const
    {
      return m_momRmin[iBound];
    }
 
    inline int CDCGeometryPar::nShifts(int layerID) const
    {
      return m_nShifts[layerID];
    }
 
    inline double CDCGeometryPar::offset(int layerID) const
    {
      return m_offSet[layerID];
    }
 
    inline unsigned CDCGeometryPar::nWiresInLayer(int layerID) const
    {
      return m_nWires[layerID];
    }
 
    inline void CDCGeometryPar::setSenseWireR(int layerId, double r)
    {
      m_rSLayer[layerId] = r;
    }
 
    inline void CDCGeometryPar::setSenseWireFZ(int layerId, double fz)
    {
      m_zSForwardLayer[layerId] = fz;
    }
 
    inline void CDCGeometryPar::setSenseWireBZ(int layerId, double bz)
    {
      m_zSBackwardLayer[layerId] = bz;
    }
 
    inline double CDCGeometryPar::senseWireR(int layerID) const
    {
      return m_rSLayer[layerID];
    }
 
    inline double CDCGeometryPar::senseWireFZ(int layerID) const
    {
      return m_zSForwardLayer[layerID];
    }
 
    inline double CDCGeometryPar::senseWireBZ(int layerID) const
    {
      return m_zSBackwardLayer[layerID];
    }
 
    inline double CDCGeometryPar::fieldWireR(int layerID) const
    {
      return m_rFLayer[layerID];
    }
 
    inline double CDCGeometryPar::fieldWireFZ(int layerID) const
    {
      return m_zFForwardLayer[layerID];
    }
 
    inline double CDCGeometryPar::fieldWireBZ(int layerID) const
    {
      return m_zFBackwardLayer[layerID];
    }
 
    inline double CDCGeometryPar::innerRadiusOuterWall() const
    {
      return m_rWall[2];
    }
 
    inline double CDCGeometryPar::outerRadiusOuterWall() const
    {
      return m_rWall[3];
    }
 
    inline double CDCGeometryPar::zOuterWall() const
    {
      return (m_zWall[2][1] - m_zWall[2][0]);
    }
 
    inline double CDCGeometryPar::innerRadiusInnerWall() const
    {
      return m_rWall[0];
    }
 
    inline double CDCGeometryPar::outerRadiusInnerWall() const
    {
      return m_rWall[1];
    }
 
    inline double CDCGeometryPar::zInnerWall() const
    {
      return (m_zWall[0][1] - m_zWall[0][0]);
    }
 
    inline double CDCGeometryPar::zOffsetOuterWall() const
    {
      return (m_zWall[2][0] + zOuterWall() / 2);
    }
 
    inline double CDCGeometryPar::zOffsetInnerWall() const
    {
      return (m_zWall[0][0] + zInnerWall() / 2);
    }
 
    inline double CDCGeometryPar::senseWireDiameter() const
    {
      return m_senseWireDiameter;
    }
 
    inline double CDCGeometryPar::fieldWireDiameter() const
    {
      return m_fieldWireDiameter;
    }
 
    inline unsigned CDCGeometryPar::nWireLayers() const
    {
      return c_maxNSenseLayers;
    }
 
    inline const double* CDCGeometryPar::zForwardWireLayer() const
    {
      return m_zSForwardLayer;
    }
 
    inline const double* CDCGeometryPar::zBackwardWireLayer() const
    {
      return m_zSBackwardLayer;
    }
 
    inline double CDCGeometryPar::zOffsetWireLayer(unsigned i) const
    {
      return (m_zSBackwardLayer[i] + (m_zSForwardLayer[i] - m_zSBackwardLayer[i]) / 2);
    }
 
    inline double CDCGeometryPar::getMeanT0() const
    {
      return m_meanT0;
    }
 
  } // end of namespace CDC
} // end of namespace Belle2