NanoSliceVersionConvention.h

Go to the documentation of this file.

/* 
 * File:   NanoSliceVersionConvention.h
 * Author: denis
 *
 * This class holds conventions for the nanoslice version.
 * For a version of a Nanoslice, it tells the FEB Firmware registers values
 *
 * Created on October 22, 2013, 8:52 AM
 */

#ifndef NANOSLICEVERSIONCONVENTION_H
#define NANOSLICEVERSIONCONVENTION_H

#include "DAQDataFormats/RawDAQData.h"  // Macros for function pointer bindings
#include "DAQDataFormats/DataFormatException.h"  // Macros for function pointer bindings

#include <iostream>
#include <vector>
#include <stdint.h>             // uint32_t, etc
#ifndef DARWINBUILD
 #include <boost/lexical_cast.hpp>
#endif

namespace daqdataformats {

     /// All encoding types
     enum Encode_Type {
                       DCSENCODE_12_in_16 = 0x0
                      ,RAWENCODE_12_in_16 = 0x1
                      ,ENCODE_UNKNOWN     = 0xFFFFF
     };// end of NanoSliceHeaderMASKS



     /// Class describing the values of the FEB registers for the NanoSlice version
     class FEBVersioningRegisters{
        public:
            FEBVersioningRegisters():
                _encode              (DCSENCODE_12_in_16)
               ,_nSamples            (0)
               ,_nPretriggeredSamples(0)
            {
            }
            FEBVersioningRegisters(const Encode_Type encode
                                  ,const uint32_t    nsamples
                                  ,const uint32_t    npretriggered_samples
                                  ):
                _encode              (encode)
               ,_nSamples            (nsamples)
               ,_nPretriggeredSamples(npretriggered_samples)
            {
            }
            FEBVersioningRegisters(const FEBVersioningRegisters& copy):
                _encode              (copy._encode)
               ,_nSamples            (copy._nSamples)
               ,_nPretriggeredSamples(copy._nPretriggeredSamples)

            {
            }

            ~FEBVersioningRegisters(){}

            bool setEncode(const Encode_Type encode)
            {
                _encode = encode;
                return true;
            }
            bool setNSamples(const uint32_t nsamples)
            {
                _nSamples = nsamples;
                return true;
            }
            bool setNPretriggeredSamples(const uint32_t nsamples)
            {
                _nPretriggeredSamples = nsamples;
                return true;
            }
                
            Encode_Type getEncode() const               {return _encode;}
            uint32_t    getNSamples() const             {return _nSamples;}
            uint32_t    getNPretriggeredSamples() const {return _nPretriggeredSamples;}

            std::ostream& print(std::ostream& os=std::cout) const
            {
                os<<"Encode="<<_encode
                  <<", NSamples="<<_nSamples
                  <<", NPretriggeredSamples="<<_nPretriggeredSamples<<"\n";

                return os;
            }


        private:
           Encode_Type _encode;               ///< Encoding for a sample. Compression type.
           uint32_t    _nSamples;             ///< Total number of samples to record
           uint32_t    _nPretriggeredSamples; ///< Number of pretriggered samples to record. Must be less than NSamples
     };// end of
     



    class NanoSliceVersionConvention {

        public:
            NanoSliceVersionConvention() {setup();}
            ~NanoSliceVersionConvention(){}

            std::ostream& print(std::ostream& os=std::cout) const
            {

                const int nversions = _versionRegisters.size();
                os<<"Total Number of versions="<<nversions<<"\n";


                for(int i=0; i<nversions; ++i){
                    os<<"Version "<<i<<":";
                    try{
                        if(checkVersion(i, false)){
                            _versionRegisters[i].print(os);
                        }
                        else{os<<"NOT ALLOWED\n";}
                    }
                    catch(...){
                        os<<"NOT ALLOWED\n";
                    }

                }

                return os;
            }

            /// Get the encoding type
            Encode_Type getEncodeType(const version_t ver) const
            {
                if(!checkVersion(ver)) return ENCODE_UNKNOWN;
                return _versionRegisters[(int)ver].getEncode();
            }
            /// Get the number of samples
            uint32_t    getNSamples(const version_t ver) const
            {
                if(!checkVersion(ver)) return 0;
                return _versionRegisters[(int)ver].getNSamples();
            }
            /// Get number of pretriggered samples
            uint32_t    getNPretriggeredSamples(const version_t ver) const
            {
                if(!checkVersion(ver)) return 0;
                return _versionRegisters[(int)ver].getNPretriggeredSamples();
            }


        private:
            bool setup()
            {
               _versionRegisters.push_back(FEBVersioningRegisters(DCSENCODE_12_in_16,  1, 0));
               _versionRegisters.push_back(FEBVersioningRegisters(DCSENCODE_12_in_16,  0, 0));
               _versionRegisters.push_back(FEBVersioningRegisters(RAWENCODE_12_in_16,  8, 3));
               _versionRegisters.push_back(FEBVersioningRegisters(RAWENCODE_12_in_16,  4, 3));
               _versionRegisters.push_back(FEBVersioningRegisters(RAWENCODE_12_in_16, 14, 0));
               _versionRegisters.push_back(FEBVersioningRegisters(RAWENCODE_12_in_16, 20, 0));
               return true;
            }

            /// Check the version of nanoslice
            /// If it's wrong, throw an exception
            bool checkVersion(const version_t ver, const bool throw_exception=true) const
            {

                /// See if it's an allowed version
                if(   ver == rawdaqdataformat::DAQDATAFORMAT_UNKNOWN_VERSION
                   || ver == 1
                   || ver >= (int)_versionRegisters.size()
                   || ver <  0
                  ){

                    if(throw_exception){
#ifndef DARWINBUILD
                      //                        GENERATE_DATAFORMAT_EXCEPTION("NanoSlice Version " + boost::lexical_cast<std::string>(ver) + " is not allowed");
#else
                        GENERATE_DATAFORMAT_EXCEPTION("NanoSlice Version is not allowed");
#endif
                    }
                    return false;
                }// end of checking the version

                return true;
            }
        private:

            std::vector <FEBVersioningRegisters> _versionRegisters;

    };// end of class NOvACheckSum

}// end of daqdataformats namespace

#endif  /* NANOSLICEVERSIONCONVENTION_H */