ReadoutPmtCrate.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_ReadoutPmtCrate_H
#define ReadoutEvent_ReadoutPmtCrate_H 1

// Include files
#include "Event/Readout.h"
#include "Conventions/Electronics.h"
#include "Event/ReadoutPmtChannel.h"
#include "Event/DaqPmtCrate.h"
#include "GaudiKernel/boost_allocator.h"
#include <ostream>

// Forward declarations

namespace DayaBay 
{

  // Forward declarations
  class ReadoutTriggerDataPkg;
  

  class ReadoutPmtCrate: public Readout
  {
  public:

    typedef std::map<DayaBay::FeeChannelId,DayaBay::ReadoutPmtChannel> PmtChannelReadouts;
    typedef std::map<DayaBay::FadcChannelId,DayaBay::DigitalSignal> FadcReadouts;
  
  ReadoutPmtCrate(const DayaBay::Detector& detector,
                    unsigned int triggerNumber,
                    const TimeStamp& triggerTime,
                    const DayaBay::Trigger::TriggerType_t& triggerType) : Readout(detector,
                                                                         triggerNumber,
                                                                         triggerTime,
                                                                         triggerType),
                                                                                      m_triggerDataPkg(0) {}
  
  ReadoutPmtCrate(const DayaBay::ReadoutPmtCrate& rhs);
  
    ReadoutPmtCrate() : m_channelReadout(),
                        m_fadcReadout(),
                        m_triggerDataPkg(0) {}
  
  ~ReadoutPmtCrate();
  
    ReadoutPmtCrate& operator=(const DayaBay::ReadoutPmtCrate& rhs);
  
    void addChannel(const DayaBay::FeeChannelId& channelId);
  
    ReadoutPmtChannel& channel(const DayaBay::FeeChannelId& channelId);
  
    std::vector<DayaBay::FeeChannelId> channels();
  
    const DayaBay::DaqCrate* daqCrate(const unsigned int run,
                                      const unsigned int event,
                                      const unsigned int ltbSlot) const;
  
    const DayaBay::DaqLtb* dummyLtb() const;
  
    std::ostream& fillStream(std::ostream& s) const;
  
  const PmtChannelReadouts& channelReadout() const;
  
  void setChannelReadout(const PmtChannelReadouts& value);
  
  const FadcReadouts& fadcReadout() const;
  
  FadcReadouts& fadcReadout();
  
  void setFadcReadout(const FadcReadouts& value);
  
  const DayaBay::ReadoutTriggerDataPkg* triggerDataPkg() const;
  
  void setTriggerDataPkg(DayaBay::ReadoutTriggerDataPkg* value);
  
  
  #ifndef GOD_NOALLOC

    static void* operator new ( size_t size )
    {
      return ( sizeof(ReadoutPmtCrate) == size ? 
               boost::singleton_pool<ReadoutPmtCrate, sizeof(ReadoutPmtCrate)>::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<ReadoutPmtCrate, sizeof(ReadoutPmtCrate)>::is_from(p) ?
      boost::singleton_pool<ReadoutPmtCrate, sizeof(ReadoutPmtCrate)>::free(p) :
      ::operator delete(p);
    }
  
    static void operator delete ( void* p, void* pObj )
    {
      ::operator delete (p, pObj);
    }
  #endif
  protected:

  private:

    PmtChannelReadouts              m_channelReadout; 
    FadcReadouts                    m_fadcReadout;    
    DayaBay::ReadoutTriggerDataPkg* m_triggerDataPkg; 
  
  }; // class ReadoutPmtCrate

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

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

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


inline const DayaBay::ReadoutPmtCrate::PmtChannelReadouts& DayaBay::ReadoutPmtCrate::channelReadout() const 
{
  return m_channelReadout;
}

inline void DayaBay::ReadoutPmtCrate::setChannelReadout(const PmtChannelReadouts& value) 
{
  m_channelReadout = value;
}

inline const DayaBay::ReadoutPmtCrate::FadcReadouts& DayaBay::ReadoutPmtCrate::fadcReadout() const 
{
  return m_fadcReadout;
}

inline DayaBay::ReadoutPmtCrate::FadcReadouts& DayaBay::ReadoutPmtCrate::fadcReadout() 
{
  return m_fadcReadout;
}

inline void DayaBay::ReadoutPmtCrate::setFadcReadout(const FadcReadouts& value) 
{
  m_fadcReadout = value;
}

inline const DayaBay::ReadoutTriggerDataPkg* DayaBay::ReadoutPmtCrate::triggerDataPkg() const 
{
  return m_triggerDataPkg;
}

inline void DayaBay::ReadoutPmtCrate::setTriggerDataPkg(DayaBay::ReadoutTriggerDataPkg* value) 
{
  m_triggerDataPkg = value;
}

inline void DayaBay::ReadoutPmtCrate::addChannel(const DayaBay::FeeChannelId& channelId) 
{

          m_channelReadout[channelId] = DayaBay::ReadoutPmtChannel(channelId,
                                                                   this);
        
}

inline DayaBay::ReadoutPmtChannel& DayaBay::ReadoutPmtCrate::channel(const DayaBay::FeeChannelId& channelId) 
{
return m_channelReadout[channelId];
}

inline std::vector<DayaBay::FeeChannelId> DayaBay::ReadoutPmtCrate::channels() 
{

          DayaBay::ReadoutPmtCrate::PmtChannelReadouts::iterator crIter = m_channelReadout.begin();
          std::vector<DayaBay::FeeChannelId> channels;
          for(;crIter != m_channelReadout.end(); crIter++) 
            channels.push_back(crIter->first);
          return channels;
        
}


#endif ///ReadoutEvent_ReadoutPmtCrate_H