SVDTransparentDigit.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 SVD_TRANSPARENT_DIGIT_H
#define SVD_TRANSPARENT_DIGIT_H
 
#include <string>
#include <sstream>
 
#include <vxd/dataobjects/VxdID.h>
 
#include <framework/datastore/RelationsObject.h>
 
namespace Belle2 {
  class SVDTransparentDigit : public RelationsObject {
 
  public:
 
    SVDTransparentDigit(const VxdID sensorID, const bool isU,
                        const unsigned short fadcID,
                        const unsigned short apvID,
                        const unsigned short nSample = 0,
                        const short** adc  = nullptr,
                        const short*  cmc1 = nullptr,
                        const short*  cmc2 = nullptr,
                        const short** corradc = nullptr,
                        const short** fine_cmc1 = nullptr,
                        const short** fine_cmc2 = nullptr,
                        const short** fine_corradc = nullptr)
      : m_sensorID(sensorID), m_isU(isU),
        m_fadcID(fadcID), m_apvID(apvID), m_nSample(nSample)
    {
      if (adc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_ADC[channel][index] = adc[channel][index];
          }
        }
      } else {
        memset(m_ADC, 0, sizeof(m_ADC));
      }
 
      if (cmc1 != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_cmc1[index] = cmc1[index];
        }
      } else {
        memset(m_cmc1, 0, sizeof(m_cmc1));
      }
 
      if (cmc2 != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_cmc2[index] = cmc2[index];
        }
      } else {
        memset(m_cmc2, 0, sizeof(m_cmc2));
      }
 
      if (corradc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_corrADC[channel][index] = corradc[channel][index];
          }
        }
      } else {
        memset(m_corrADC, 0, sizeof(m_corrADC));
      }
 
      if (fine_cmc1 != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_cmc1[channel][index] = fine_cmc1[channel][index];
          }
        }
      } else {
        memset(m_fine_cmc1, 0, sizeof(m_fine_cmc1));
      }
 
      if (fine_cmc2 != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_cmc2[channel][index] = fine_cmc2[channel][index];
          }
        }
      } else {
        memset(m_fine_cmc2, 0, sizeof(m_fine_cmc2));
      }
 
      if (fine_corradc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_corrADC[channel][index] = fine_corradc[channel][index];
          }
        }
      } else {
        memset(m_fine_corrADC, 0, sizeof(m_fine_corrADC));
      }
      memset(m_cmc, 0, sizeof(m_cmc));
      memset(m_fine_cmc, 0, sizeof(m_fine_cmc));
    }
 
    SVDTransparentDigit()
      : SVDTransparentDigit(0, true, 0, 0, 0, nullptr, nullptr, nullptr, nullptr)
    {}
 
    VxdID getSensorID() const { return m_sensorID; }
 
    bool isUStrip() const { return m_isU; }
 
    unsigned short getFadcID() const { return m_fadcID; }
 
    unsigned short getApvID() const { return m_apvID; }
 
    unsigned short getNSample() const { return m_nSample; }
 
    const short*  getADC(short channel) const
    {
      if (channel < 0 || 128 <= channel) return nullptr;
      else return m_ADC[channel];
    }
 
    short getADC(short channel, short index) const
    {
      //if(index<0||SVDPar::maxSample<=index) return -1;
      if (index < 0 || 6 <= index) return -9999;
      if (channel < 0 || 128 <= channel) return -9999;
      return m_ADC[channel][index];
    }
 
    const short* getCMC1() const { return m_cmc1; }
 
    short  getCMC1(short index) const
    {
      if (index < 0 || 6 <= index) return -9999;
      return m_cmc1[index];
    }
 
    const short* getCMC2() const { return m_cmc2; }
    short  getCMC2(short index) const
    {
      if (index < 0 || 6 <= index) return -9999;
      return m_cmc2[index];
    }
 
    const short* getCMC() const { return m_cmc; }
    short  getCMC(short index) const
    {
      if (index < 0 || 6 <= index) return -9999;
      return m_cmc[index] ;
    }
 
    const short*  getFineCMC1(short channel) const
    {
      if (channel < 0 || 128 <= channel) return nullptr;
      return m_fine_cmc1[channel];
    }
    short getFineCMC1(short channel, short index) const
    {
      //if(index<0||SVDPar::maxSample<=index) return -1;
      if (index < 0 || 6 <= index) return -9999;
      if (channel < 0 || 128 <= channel) return -9999;
      else return m_fine_cmc1[channel][index];
    }
    const short*  getFineCMC2(short channel) const
    {
      if (channel < 0 || 128 <= channel) return nullptr;
      return m_fine_cmc2[channel];
    }
    short getFineCMC2(short channel, short index) const
    {
      //if(index<0||SVDPar::maxSample<=index) return -1;
      if (index < 0 || 6 <= index) return -9999;
      if (channel < 0 || 128 <= channel) return -9999;
      else return m_fine_cmc2[channel][index];
    }
    const short*  getFineCMC(short channel) const
    {
      if (channel < 0 || 128 <= channel) return nullptr;
      return m_fine_cmc[channel];
    }
    short getFineCMC(short channel, short index) const
    {
      //if(index<0||SVDPar::maxSample<=index) return -1;
      if (index < 0 || 6 <= index) return -9999;
      if (channel < 0 || 128 <= channel) return -9999;
      else return m_fine_cmc[channel][index];
    }
 
    const short*  getCorrADC(short channel) const
    {
      if (channel < 0 || 128 <= channel) return nullptr;
      return m_corrADC[channel];
    }
    short getCorrADC(short channel, short index) const
    {
      //if(index<0||SVDPar::maxSample<=index) return -1;
      if (index < 0 || 6 <= index) return -9999;
      if (channel < 0 || 128 <= channel) return -9999;
      else return m_corrADC[channel][index];
    }
 
    const short*  getFineCorrADC(short channel) const
    {
      if (channel < 0 || 128 <= channel) return nullptr;
      return m_fine_corrADC[channel];
    }
    short getFineCorrADC(short channel, short index) const
    {
      //if(index<0||SVDPar::maxSample<=index) return -1;
      if (index < 0 || 6 <= index) return -9999;
      if (channel < 0 || 128 <= channel) return -9999;
      else return m_fine_corrADC[channel][index];
    }
 
 
    void setSensorID(VxdID vxdid) { m_sensorID = vxdid.getID(); }
 
    void setUStrip(bool isu) { m_isU = isu; }
 
    void setFadcID(unsigned short fadcID) { m_fadcID = fadcID; }
 
    void setApvID(unsigned short apvID) { m_apvID = apvID; }
 
    void setNSample(unsigned short nSample) { m_nSample = nSample; }
 
    void setADC(short** adc)
    {
      if (adc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_ADC[channel][index] = adc[channel][index];
          }
        }
      }
    }
    void setADC(short* adc, short channel)
    {
      if (adc != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_ADC[channel][index] = adc[index];
        }
      }
    }
    void setADC(short adc, short channel, short index)
    {
      if (0 <= index && index < 6 && 0 <= channel && channel < 128)
        m_ADC[channel][index] = adc;
    }
 
    void setCMC1(short* cmc1)
    {
      for (int index = 0; index < 6; index++) {
        m_cmc1[index] = cmc1[index];
      }
    }
 
    void setCMC1(short cmc1, int index)
    {
      if (0 <= index && index < 6) m_cmc1[index] = cmc1;
    }
 
    void setCMC2(short* cmc2)
    {
      for (int index = 0; index < 6; index++) {
        m_cmc2[index] = cmc2[index];
      }
    }
    void setCMC2(short cmc2, int index)
    {
      if (0 <= index && index < 6) m_cmc2[index] = cmc2;
    }
 
    void setCMC(short* cmc)
    {
      for (int index = 0; index < 6; index++) {
        m_cmc[index] = cmc[index];
      }
    }
    void setCMC(short cmc, int index)
    {
      if (0 <= index && index < 6) m_cmc[index] = cmc;
    }
 
    void setFineCMC1(short** fine_cmc1)
    {
      if (fine_cmc1 != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_cmc1[channel][index] = fine_cmc1[channel][index];
          }
        }
      }
    }
    void setFineCMC1(short* fine_cmc1, short channel)
    {
      if (fine_cmc1 != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_fine_cmc1[channel][index] = fine_cmc1[index];
        }
      }
    }
    void setFineCMC1(short fine_cmc1, short channel, short index)
    {
      if (0 <= index && index < 6 && 0 <= channel && channel < 128)
        m_fine_cmc1[channel][index] = fine_cmc1;
    }
 
    void setFineCMC2(short** fine_cmc2)
    {
      if (fine_cmc2 != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_cmc2[channel][index] = fine_cmc2[channel][index];
          }
        }
      }
    }
    void setFineCMC2(short* fine_cmc2, short channel)
    {
      if (fine_cmc2 != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_fine_cmc2[channel][index] = fine_cmc2[index];
        }
      }
    }
    void setFineCMC2(short fine_cmc2, short channel, short index)
    {
      if (0 <= index && index < 6 && 0 <= channel && channel < 128)
        m_fine_cmc2[channel][index] = fine_cmc2;
    }
 
    void setFineCMC(short** fine_cmc)
    {
      if (fine_cmc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_cmc[channel][index] = fine_cmc[channel][index];
          }
        }
      }
    }
    void setFineCMC(short* fine_cmc, short channel)
    {
      if (fine_cmc != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_fine_cmc[channel][index] = fine_cmc[index];
        }
      }
    }
    void setFineCMC(short fine_cmc, short channel, short index)
    {
      if (0 <= index && index < 6 && 0 <= channel && channel < 128)
        m_fine_cmc[channel][index] = fine_cmc;
    }
 
    void setCorrADC(short** corradc)
    {
      if (corradc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_corrADC[channel][index] = corradc[channel][index];
          }
        }
      }
    }
    void setCorrADC(short* corradc, short channel)
    {
      if (corradc != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_corrADC[channel][index] = corradc[index];
        }
      }
    }
    void setCorrADC(short corradc, short channel, short index)
    {
      if (0 <= index && index < 6 && 0 <= channel && channel < 128)
        m_corrADC[channel][index] = corradc;
    }
 
    void setFineCorrADC(short** corradc)
    {
      if (corradc != nullptr) {
        for (int channel = 0; channel < 128; channel++) {
          //for(int index=0;index<SVDPar::maxSample;index++) {
          for (int index = 0; index < 6; index++) {
            m_fine_corrADC[channel][index] = corradc[channel][index];
          }
        }
      }
    }
    void setFineCorrADC(short* corradc, short channel)
    {
      if (corradc != nullptr) {
        //for(int index=0;index<SVDPar::maxSample;index++) {
        for (int index = 0; index < 6; index++) {
          m_fine_corrADC[channel][index] = corradc[index];
        }
      }
    }
    void setFineCorrADC(short corradc, short channel, short index)
    {
      if (0 <= index && index < 6 && 0 <= channel && channel < 128)
        m_fine_corrADC[channel][index] = corradc;
    }
 
    std::string print()
    {
      VxdID thisSensorID = static_cast<VxdID>(m_sensorID);
      VxdID::baseType id      = thisSensorID.getID();
      VxdID::baseType layer   = thisSensorID.getLayerNumber();
      VxdID::baseType ladder  = thisSensorID.getLadderNumber();
      VxdID::baseType sensor  = thisSensorID.getSensorNumber();
      VxdID::baseType segment = thisSensorID.getSegmentNumber();
 
      std::ostringstream os;
      os << std::endl;
      os << "Sensor ID     : " << m_sensorID << ", (VXD ID: " << id << ")" << std::endl;
      os << "(layer: " << layer << ", ladder: " << ladder
         << ", sensor: " << sensor << ", segment: " << segment << ")"
         << std::endl;
      if (m_isU)
        os << "Strip side    : U" << std::endl;
      else
        os << "Strip side    : V" << std::endl;
 
      return os.str();
    }
 
  private:
 
    unsigned short m_sensorID; 
    bool m_isU;                
    unsigned short m_fadcID;   
    unsigned short m_apvID;    
    unsigned short m_nSample;  
    //int  m_ADC[SVDPar::maxSample];  /**< ADC values fo strip signal. Index represents samples.*/
    short  m_ADC[128][6];  
    short  m_cmc1[6];  
    short  m_cmc2[6];  
    short  m_cmc[6];  
    short  m_fine_cmc1[128][6];  
    short  m_fine_cmc2[128][6];  
    short  m_fine_cmc [128][6];  
    short  m_corrADC[128][6];  
    short  m_fine_corrADC[128][6];  
    ClassDef(SVDTransparentDigit, 3)
 
  }; // class SVDTransparentDigit
 
 
} // end namespace Belle2
 
#endif