ReadoutPmtChannel.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************

#ifndef ReadoutEvent_ReadoutPmtChannel_H
#define ReadoutEvent_ReadoutPmtChannel_H 1

// Include files
#include "Conventions/Electronics.h"
#include "GaudiKernel/boost_allocator.h"
#include "GaudiKernel/SerializeSTL.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations
  class ReadoutPmtCrate;
  using GaudiUtils::operator<<;
  

  class ReadoutPmtChannel
  {
  public:

  ReadoutPmtChannel(const DayaBay::FeeChannelId& channelId,
                      DayaBay::ReadoutPmtCrate* readout);
  
    ReadoutPmtChannel() : m_readout(0),
                          m_mode(0x0),
                          m_channelId(0),
                          m_adc(),
                          m_pedestal(),
                          m_adcRange(),
                          m_adcCycle(),
                          m_tdc(),
                          m_tdcHitCount(),
                          m_waveAdcHigh(),
                          m_waveAdcLow(),
                          m_waveAdcCycle() {}
  
    virtual ~ReadoutPmtChannel() {}
  
   virtual std::ostream& fillStream(std::ostream& s) const;
  
    unsigned int size() const;
  
    int peakAdc(unsigned int index) const;
  
    int peakAdcRange(unsigned int index) const;
  
    int peakAdcCycle(unsigned int index) const;
  
    int adc(unsigned int index) const;
  
    int adcRange(unsigned int index) const;
  
    int adcCycle(unsigned int index) const;
  
    int pedestal(unsigned int index) const;
  
    int tdc(unsigned int index) const;
  
    int tdcHitCount(unsigned int index) const;
  
    int maxAdcIndex() const;
  
    int maxAdc() const;
  
    int sumAdc() const;
  
    int earliestTdcIndex() const;
  
    int earliestTdc() const;
  
    int earliestAdc() const;
  
    unsigned int waveSize() const;
  
    int waveAdcCycle(unsigned int index) const;
  
    int waveAdcHigh(unsigned int index) const;
  
    int waveAdcLow(unsigned int index) const;
  
  const DayaBay::ReadoutPmtCrate* readout() const;
  
  void setReadout(DayaBay::ReadoutPmtCrate* value);
  
  int mode() const;
  
  void setMode(int value);
  
  const DayaBay::FeeChannelId& channelId() const;
  
  void setChannelId(const DayaBay::FeeChannelId& value);
  
  const std::vector<int>& adc() const;
  
  std::vector<int>& adc();
  
  void setAdc(const std::vector<int>& value);
  
  const std::vector<int>& pedestal() const;
  
  std::vector<int>& pedestal();
  
  void setPedestal(const std::vector<int>& value);
  
  const std::vector<int>& adcRange() const;
  
  std::vector<int>& adcRange();
  
  void setAdcRange(const std::vector<int>& value);
  
  const std::vector<int>& adcCycle() const;
  
  std::vector<int>& adcCycle();
  
  void setAdcCycle(const std::vector<int>& value);
  
  const std::vector<int>& tdc() const;
  
  std::vector<int>& tdc();
  
  void setTdc(const std::vector<int>& value);
  
  const std::vector<int>& tdcHitCount() const;
  
  std::vector<int>& tdcHitCount();
  
  void setTdcHitCount(const std::vector<int>& value);
  
  const std::vector<int>& waveAdcHigh() const;
  
  void setWaveAdcHigh(const std::vector<int>& value);
  
  const std::vector<int>& waveAdcLow() const;
  
  void setWaveAdcLow(const std::vector<int>& value);
  
  const std::vector<int>& waveAdcCycle() const;
  
  void setWaveAdcCycle(const std::vector<int>& value);
  
  
  #ifndef GOD_NOALLOC

    static void* operator new ( size_t size )
    {
      return ( sizeof(ReadoutPmtChannel) == size ? 
               boost::singleton_pool<ReadoutPmtChannel, sizeof(ReadoutPmtChannel)>::malloc() :
               ::operator new(size) );
    }
  
    static void* operator new ( size_t size, void* pObj )
    {
      return ::operator new (size,pObj);
    }
  
    static void operator delete ( void* p )
    {
      boost::singleton_pool<ReadoutPmtChannel, sizeof(ReadoutPmtChannel)>::is_from(p) ?
      boost::singleton_pool<ReadoutPmtChannel, sizeof(ReadoutPmtChannel)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    DayaBay::ReadoutPmtCrate* m_readout;      
    int                       m_mode;         
    DayaBay::FeeChannelId     m_channelId;    
    std::vector<int>          m_adc;          
    std::vector<int>          m_pedestal;     
    std::vector<int>          m_adcRange;     
    std::vector<int>          m_adcCycle;     
    std::vector<int>          m_tdc;          
    std::vector<int>          m_tdcHitCount;  
    std::vector<int>          m_waveAdcHigh;  
    std::vector<int>          m_waveAdcLow;   
    std::vector<int>          m_waveAdcCycle; 
  
  }; // class ReadoutPmtChannel

  inline std::ostream& operator<< (std::ostream& str, const ReadoutPmtChannel& obj)
  {
    return obj.fillStream(str);
  }
  
} // namespace DayaBay;

// -----------------------------------------------------------------------------
// end of class
// -----------------------------------------------------------------------------

// Including forward declarations
#include "ReadoutPmtCrate.h"


inline DayaBay::ReadoutPmtChannel::ReadoutPmtChannel(const DayaBay::FeeChannelId& channelId,
                                                     DayaBay::ReadoutPmtCrate* readout) 
{

          setChannelId(channelId);
                setReadout(readout);
        
}

inline std::ostream& DayaBay::ReadoutPmtChannel::fillStream(std::ostream& s) const
{
  s << "{ " << "readout :       " << m_readout << std::endl
            << "mode :  " << m_mode << std::endl
            << "channelId :     " << m_channelId << std::endl
            << "adc :   " << m_adc << std::endl
            << "pedestal :      " << m_pedestal << std::endl
            << "adcRange :      " << m_adcRange << std::endl
            << "adcCycle :      " << m_adcCycle << std::endl
            << "tdc :   " << m_tdc << std::endl
            << "tdcHitCount :   " << m_tdcHitCount << std::endl
            << "waveAdcHigh :   " << m_waveAdcHigh << std::endl
            << "waveAdcLow :    " << m_waveAdcLow << std::endl
            << "waveAdcCycle :  " << m_waveAdcCycle << std::endl << " }";
  return s;
}


inline const DayaBay::ReadoutPmtCrate* DayaBay::ReadoutPmtChannel::readout() const 
{
  return m_readout;
}

inline void DayaBay::ReadoutPmtChannel::setReadout(DayaBay::ReadoutPmtCrate* value) 
{
  m_readout = value;
}

inline int DayaBay::ReadoutPmtChannel::mode() const 
{
  return m_mode;
}

inline void DayaBay::ReadoutPmtChannel::setMode(int value) 
{
  m_mode = value;
}

inline const DayaBay::FeeChannelId& DayaBay::ReadoutPmtChannel::channelId() const 
{
  return m_channelId;
}

inline void DayaBay::ReadoutPmtChannel::setChannelId(const DayaBay::FeeChannelId& value) 
{
  m_channelId = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::adc() const 
{
  return m_adc;
}

inline std::vector<int>& DayaBay::ReadoutPmtChannel::adc() 
{
  return m_adc;
}

inline void DayaBay::ReadoutPmtChannel::setAdc(const std::vector<int>& value) 
{
  m_adc = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::pedestal() const 
{
  return m_pedestal;
}

inline std::vector<int>& DayaBay::ReadoutPmtChannel::pedestal() 
{
  return m_pedestal;
}

inline void DayaBay::ReadoutPmtChannel::setPedestal(const std::vector<int>& value) 
{
  m_pedestal = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::adcRange() const 
{
  return m_adcRange;
}

inline std::vector<int>& DayaBay::ReadoutPmtChannel::adcRange() 
{
  return m_adcRange;
}

inline void DayaBay::ReadoutPmtChannel::setAdcRange(const std::vector<int>& value) 
{
  m_adcRange = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::adcCycle() const 
{
  return m_adcCycle;
}

inline std::vector<int>& DayaBay::ReadoutPmtChannel::adcCycle() 
{
  return m_adcCycle;
}

inline void DayaBay::ReadoutPmtChannel::setAdcCycle(const std::vector<int>& value) 
{
  m_adcCycle = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::tdc() const 
{
  return m_tdc;
}

inline std::vector<int>& DayaBay::ReadoutPmtChannel::tdc() 
{
  return m_tdc;
}

inline void DayaBay::ReadoutPmtChannel::setTdc(const std::vector<int>& value) 
{
  m_tdc = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::tdcHitCount() const 
{
  return m_tdcHitCount;
}

inline std::vector<int>& DayaBay::ReadoutPmtChannel::tdcHitCount() 
{
  return m_tdcHitCount;
}

inline void DayaBay::ReadoutPmtChannel::setTdcHitCount(const std::vector<int>& value) 
{
  m_tdcHitCount = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::waveAdcHigh() const 
{
  return m_waveAdcHigh;
}

inline void DayaBay::ReadoutPmtChannel::setWaveAdcHigh(const std::vector<int>& value) 
{
  m_waveAdcHigh = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::waveAdcLow() const 
{
  return m_waveAdcLow;
}

inline void DayaBay::ReadoutPmtChannel::setWaveAdcLow(const std::vector<int>& value) 
{
  m_waveAdcLow = value;
}

inline const std::vector<int>& DayaBay::ReadoutPmtChannel::waveAdcCycle() const 
{
  return m_waveAdcCycle;
}

inline void DayaBay::ReadoutPmtChannel::setWaveAdcCycle(const std::vector<int>& value) 
{
  m_waveAdcCycle = value;
}

inline unsigned int DayaBay::ReadoutPmtChannel::size() const 
{

    return m_tdc.size();
  
}

inline int DayaBay::ReadoutPmtChannel::peakAdc(unsigned int index) const 
{

    return index >= m_adc.size() ? 0 : m_adc[index];
  
}

inline int DayaBay::ReadoutPmtChannel::peakAdcRange(unsigned int index) const 
{

    return index >= m_adcRange.size() ? 0 : m_adcRange[index];
  
}

inline int DayaBay::ReadoutPmtChannel::peakAdcCycle(unsigned int index) const 
{

    return index >= m_adcCycle.size() ? 0 : m_adcCycle[index];
  
}

inline int DayaBay::ReadoutPmtChannel::adc(unsigned int index) const 
{

    return peakAdc(index);
  
}

inline int DayaBay::ReadoutPmtChannel::adcRange(unsigned int index) const 
{

    return peakAdcRange(index);
  
}

inline int DayaBay::ReadoutPmtChannel::adcCycle(unsigned int index) const 
{

    return peakAdcCycle(index);
  
}

inline int DayaBay::ReadoutPmtChannel::pedestal(unsigned int index) const 
{

    return index >= m_pedestal.size() ? 0 : m_pedestal[index];
  
}

inline int DayaBay::ReadoutPmtChannel::tdc(unsigned int index) const 
{

    return index >= m_tdc.size() ? 0 : m_tdc[index];
  
}

inline int DayaBay::ReadoutPmtChannel::tdcHitCount(unsigned int index) const 
{

    return index >= m_tdcHitCount.size() ? 0 : m_tdcHitCount[index];
  
}

inline int DayaBay::ReadoutPmtChannel::maxAdcIndex() const 
{

          if( m_adc.empty() ) return 0;
          int maxAdcIndex = 0;
    int maxAdc = 0;
    for(unsigned i=0; i<m_adc.size(); i++) {
      if( m_adc[i] > maxAdc ) {
        maxAdc = m_adc[i];
        maxAdcIndex = i;
      }
    }
          return maxAdcIndex;
        
}

inline int DayaBay::ReadoutPmtChannel::maxAdc() const 
{

          if( m_adc.empty() ) return 0;
          return m_adc[maxAdcIndex()];
        
}

inline int DayaBay::ReadoutPmtChannel::sumAdc() const 
{

          if( m_adc.empty() ) return 0;
          int sumAdc = 0;
    for(unsigned i=0; i<m_adc.size(); i++) {
      sumAdc += m_adc[i];
    }
          return sumAdc;
        
}

inline int DayaBay::ReadoutPmtChannel::earliestTdcIndex() const 
{

          if( m_tdc.empty() ) return 0;
          int earliestTdc = 0;
    int earliestTdcIndex = 0;
          for(unsigned int i=0; i < m_tdc.size(); i++) {
      if( i == 0 || m_tdc[i] > earliestTdc ) {
        earliestTdc = m_tdc[i];
        earliestTdcIndex = i;
      }
    }
          return earliestTdcIndex;
        
}

inline int DayaBay::ReadoutPmtChannel::earliestTdc() const 
{

          if( m_tdc.empty() ) return 0;
          return m_tdc[earliestTdcIndex()];
        
}

inline int DayaBay::ReadoutPmtChannel::earliestAdc() const 
{

          if( m_adc.empty() ) return 0;
          return m_adc[earliestTdcIndex()];
        
}

inline unsigned int DayaBay::ReadoutPmtChannel::waveSize() const 
{

    return m_waveAdcCycle.size();
  
}

inline int DayaBay::ReadoutPmtChannel::waveAdcCycle(unsigned int index) const 
{

    return index >= m_waveAdcCycle.size() ? 0 : m_waveAdcCycle[index];
  
}

inline int DayaBay::ReadoutPmtChannel::waveAdcHigh(unsigned int index) const 
{

    return index >= m_waveAdcHigh.size() ? 0 : m_waveAdcHigh[index];
  
}

inline int DayaBay::ReadoutPmtChannel::waveAdcLow(unsigned int index) const 
{

    return index >= m_waveAdcLow.size() ? 0 : m_waveAdcLow[index];
  
}


#endif ///ReadoutEvent_ReadoutPmtChannel_H