RawNanoSliceV0.h

Go to the documentation of this file.

#ifndef RAWNANOSLICEV0_H
#define RAWNANOSLICEV0_H
#include "DAQDataFormats/RawNanoSliceHeader.h"
#include "DAQDataFormats/NanoSliceVersionConvention.h"

/// It is requred to
///   1. include DAQDataFormats/DataFormatFirst.inc
///   2. define CURRENT_CLASS
///   3.    define CURRENT_CLASS_VERSION for version of the class
///      OR define LAST_CLASS_VERSION    for the main structure of the class
///   4. (optional) define CURRENT_FIELDS_SUB_NAMESPACE
///   5. include DAQDataFormats/DataFormatLast.inc
/// before the declaration of the DataFormat version class in the header.
#include "DAQDataFormats/DataFormatFirst.inc"
#define  CURRENT_CLASS                RawNanoSlice
#define  CURRENT_CLASS_VERSION        0
#define  CURRENT_FIELDS_SUB_NAMESPACE rawnano
#include "DAQDataFormats/DataFormatLast.inc"



namespace daqdataformats {

  //! Data structure for holding all the nanoslice data of interest
  typedef struct {
    NanoSliceHeader Header;
    uint32_t    TimeStamp;
    uint32_t    PulseHeight;
    uint32_t    Reserved;
    // new data members : not used in V0, will be used in V1
    uint32_t    Value1;
    uint32_t    Value2;

  } NanoSlice;


  namespace  VERSION_NAMESPACE {
        namespace CURRENT_FIELDS_SUB_NAMESPACE {

            static const uint32_t  RAWNANOSLICE_SIZE = 3;
            static const uint32_t  cafe_word         = 0xCAFE;

            enum NanoSliceWORDS{
                WORD_TimeStamp    = 1,
                WORD_PulseHeight  = 2,
                WORD_Reserved     = 2
            };
            enum NanoSliceMASKS{
                MASK_TimeStamp    = 0xFFFFFFFF,
                MASK_PulseHeight  = 0x0FFF0000,
                MASK_Reserved     = 0x0000FFFF
            };

            DEFINE_SHIFT_FROM_MASK(TimeStamp  );
            DEFINE_SHIFT_FROM_MASK(PulseHeight);
            DEFINE_SHIFT_FROM_MASK(Reserved   );

        } // end of namespace rawnano

  //! Class to hold the data from the FEBs in correct formats
  /*!
    The RawNanoSlice class is designed to mimic the format of the actual data
    block that the NOvA Front End6
    Boards (FEBS) produce when they detect a signal
    above the zero suppression threshold.
    
    The class supports general initialization with or with out data blocks as
    well as copyin style initialization for use with STL containers.
    
    Pack and unpack methods for the data rely on two types of structured data
    blocks that are provided in association with the class.
    
    The NanoSliceBlock structure breaks the raw data block out into its related
    high and low half words to give the headers, time stamps and pulseheight information
    
    The NanoSliceHeader structure further breaks out the header blocks into the
    individual data information parts.
  */

  class RawNanoSlice: public PREVIOUS_VERSION_CLASS_NAME {
    
        public:
            // Constructors
            RawNanoSlice (const version_t);
            RawNanoSlice (const NanoSlice&);
            RawNanoSlice (const RawNanoSlice&);
            /// Destructor
            ~RawNanoSlice();

            void     init            ();
            using    PREVIOUS_VERSION_CLASS_NAME::print;
            void     print           (std::ostream& os=std::cout) const;
            uint32_t sizeofdata      () const { return VERSION_NAMESPACE::CURRENT_FIELDS_SUB_NAMESPACE::RAWNANOSLICE_SIZE;}
            bool     setBufferSource (const void* pointer);

            /// Nanoslice of version 0 is a fixed size format
            using    RawDAQData::readData;
            void*    readData(const void* pointer){return RawDAQData::readDataGeneral(pointer);};

            // Get/Set Value fields are not allowed for version 0,
            // because there are no such fields
            /// The meaning of the value could be different.
            /// It could be DCS
            uint32_t getValue(const uint32_t)               const {RETURN_FUNCTION(getPulseHeight)();}
            bool     setValue(const uint32_t sample_number [[gnu::unused]], const uint32_t value) {RETURN_FUNCTION(setPulseHeight)(value);}

            uint32_t getValue1()               const {RETURN_FUNCTION(getPulseHeight)();}
            bool     setValue1(const uint32_t value) {RETURN_FUNCTION(setPulseHeight)(value);}


            /// Get total number of samples in the nanoslice
            uint32_t getNSamples() const;
            /// Get number of pretriggered samples
            uint32_t getNPretriggeredSamples() const;
            /// get the type of encoding for the samples in the nanoslice
            Encode_Type getEncodeType() const;

        protected:
            IMPLEMENT_FIRST_GET_AND_SET(PulseHeight, uint32_t);
            IMPLEMENT_FIRST_GET_AND_SET(TimeStamp  , uint32_t);
            IMPLEMENT_FIRST_GET_AND_SET(Reserved   , uint32_t);

            INIT_FIRST(initWithData        ,      , void, const NanoSlice&);
            INIT_FIRST(setParameters       ,      , bool, const NanoSlice&);
            INIT_FIRST(checkReservedForCafe, const, bool, );
            INIT_FIRST(initWithDataInternal,      , void, );

        protected:
            /// The Nanoslice header pointer
            daqdataformats::RawNanoSliceHeader* _Header;  //! Header


    };// end of RawNanoSlice
  
  
}} // END NAMESPCE daqdataformats
#endif /* RAWNANOSLICEV0_H */