---

CalDigi.h

Go to the documentation of this file.

#ifndef GlastEvent_CalDigi_H
#define GlastEvent_CalDigi_H 1


// Include files
#include <iostream>
#include <vector>
#include "idents/CalLogId.h"

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/ObjectVector.h"
#include "GlastEvent/TopLevel/Definitions.h"


class CalLogReadout : virtual public ContainedObject  { 

public:
        CalLogReadout(char rangeP, short adcP, char rangeM, short adcM) :
                m_rangeP(rangeP), 
                m_adcP(adcP), 
                m_rangeM(adcM), 
                m_adcM(adcM)
        {};

        ~CalLogReadout() {};

        typedef enum
        {
                POS = 0,
                NEG
        } LogFace;

        // retrieve pulse height from specified face
        inline short getAdc(LogFace face) const {return face == POS ? m_adcP : m_adcM;};

        // retrieve energy range from specified face
        inline char getRange(LogFace face) const {return face == POS ? m_rangeP : m_rangeM;};

        inline StreamBuffer& serialize( StreamBuffer& s ) const
        {
                s = ContainedObject::serialize(s);
                return s << m_rangeP 
                                 << m_adcP 
                                 << m_rangeM 
                                 << m_adcM;
        }
        inline StreamBuffer& serialize( StreamBuffer& s )
        {
                s = ContainedObject::serialize(s);
                s >> m_rangeP
                  >> m_adcP
                  >> m_rangeM
                  >> m_adcM;
                return s;
        }

private:

        short m_adcP, m_adcM;
        char  m_rangeP, m_rangeM;

};




extern const CLID& CLID_CalDigi;

class CalDigi : virtual public ContainedObject  { 

public:
        typedef enum
        {
                LEX8 = 0,
                LEX1,
                HEX8,
                HEX1
        } AdcRange;

        typedef enum
        {
            BESTRANGE = 0,
            ALLRANGE = 2
        } CalTrigMode;

        enum {POS_OFFSET = 14,                                          // shift for POSitive face
                RANGE_OFFSET = 12, RANGE_MASK = 0x3000,         // energy range bits
                ADC_VAL_MASK = 0xfff};                                          // Adc value bits

        CalDigi() {};

        CalDigi(CalTrigMode mode, idents::CalLogId CalLogId, ObjectVector<CalLogReadout> readout) : 
                m_mode(mode),
                m_logId(CalLogId),
                m_readout(readout)
        {};

        virtual ~CalDigi() { };

        virtual const CLID& clID() const   { return CalDigi::classID(); }
        static const CLID& classID()       { return CLID_CalDigi; }

        inline const CalTrigMode getMode() const { return m_mode; };

        inline const idents::CalLogId getPackedId() const { return m_logId; };
        
        inline char getRange(short readoutIndex, CalLogReadout::LogFace face) const
        {
                return (readoutIndex < m_readout.size()) ? (*(m_readout[readoutIndex])).getRange(face) : (char)-1;
        }

        inline short getAdc(short readoutIndex, CalLogReadout::LogFace face) const
        {
                return (readoutIndex < m_readout.size()) ? (*(m_readout[readoutIndex])).getAdc(face) : (short)-1;
        }

        inline const CalLogReadout* getLogReadout(short readoutIndex)
        {
                return (readoutIndex < m_readout.size()) ? m_readout[readoutIndex] : NULL;
        }

        inline short getAdcSelectedRange(char range, CalLogReadout::LogFace face) const
        {
                char nRanges = (char)m_readout.size();
                if (nRanges == 1)
                        return (range == (*(m_readout[0])).getRange(face)) ? (*(m_readout[0])).getAdc(face) : (short)-1;
                else
                        return (*(m_readout[(nRanges + range - (*(m_readout[0])).getRange(face)) % nRanges])).getAdc(face);
        }

        virtual StreamBuffer& serialize( StreamBuffer& s ) const;
        virtual StreamBuffer& serialize( StreamBuffer& s );
        virtual std::ostream& fillStream( std::ostream& s ) const;

private:

        CalTrigMode m_mode;
        idents::CalLogId m_logId;
        ObjectVector<CalLogReadout> m_readout;

};


template <class TYPE> class ObjectVector;
typedef ObjectVector<CalDigi> CalDigiVector;


inline StreamBuffer& CalDigi::serialize( StreamBuffer& s ) const
{
        s = ContainedObject::serialize(s);
        s << m_mode;
        s = m_logId.serialize(s);
        s = (*(m_readout[0])).serialize(s);
        if (m_mode == ALLRANGE)
                for (int rangeIndex=1; rangeIndex<4; rangeIndex++)
                        s = (*(m_readout[rangeIndex])).serialize(s);
  
        return s;
}


inline StreamBuffer& CalDigi::serialize( StreamBuffer& s )
{
        s = ContainedObject::serialize(s);
        int mode;
        s >> mode; m_mode = (mode==CalTrigMode::ALLRANGE) ? ALLRANGE:BESTRANGE;
// For now by default m_mode is considered to be BESTRANGE
        
        s = m_logId.serialize(s);
        s = (*(m_readout[0])).serialize(s);
        if (m_mode == ALLRANGE)
                for (int rangeIndex = 1; rangeIndex < 4; rangeIndex++)
                        s = (*(m_readout[rangeIndex])).serialize(s);

        return s;
}


inline std::ostream& CalDigi::fillStream( std::ostream& s ) const
{
    s << "    base class CalDigi :"
    << "\n        CalTrigMode = ( "
    << GlastEventFloatFormat( GlastEvent::width, GlastEvent::precision )
    << m_mode << " )"
    << "\n        ID = ( "
    << GlastEventFloatFormat( GlastEvent::width, GlastEvent::precision )
    << m_logId << " )"
    << "\n        Best plus-face range and pulseheight  = ( "
    << GlastEventFloatFormat( GlastEvent::width, GlastEvent::precision )
    << CalDigi::getRange(BESTRANGE,CalLogReadout::LogFace::POS) << ", " << CalDigi::getAdc(BESTRANGE,CalLogReadout::LogFace::POS) << " )"
    << "\n        Best minus-face range and pulseheight = "
    << GlastEventFloatFormat( GlastEvent::width, GlastEvent::precision )
    << CalDigi::getRange(BESTRANGE,CalLogReadout::LogFace::NEG) << ", " << CalDigi::getAdc(BESTRANGE,CalLogReadout::LogFace::NEG) << " )";

        if (m_mode == ALLRANGE)
        {
                for (int rangeIndex = 1; rangeIndex < 4; rangeIndex++)
                {
                        s << "\n        Next plus-face range and pulseheight  = "
                    << GlastEventFloatFormat( GlastEvent::width, GlastEvent::precision )
                        << CalDigi::getRange(rangeIndex,CalLogReadout::LogFace::POS) << ", " << CalDigi::getAdc(rangeIndex,CalLogReadout::LogFace::POS) << " )"
                        << "\n        Next minus-face range and pulseheight = "
                        << GlastEventFloatFormat( GlastEvent::width, GlastEvent::precision )
                        << CalDigi::getRange(rangeIndex,CalLogReadout::LogFace::NEG) << ", " << CalDigi::getAdc(rangeIndex,CalLogReadout::LogFace::NEG) << " )";
                }
        }

        s << " )\n";

        return s;
}
#endif

---