In This Package:

RawDataEvent.h

Go to the documentation of this file.

#ifndef RAWDATAEVENT_H
#define RAWDATAEVENT_H

#include <iostream>
#include <vector>
#include "bit_utility.h"
#include "Conventions/Electronics.h"
#include "Event/Readout.h"
#include "RawDataFormat.h"

class RawDataEvent
{
  public:
    class FileHeader
    {
      public:
      void print();

      // in file_start_record
      unsigned int m_version;
      unsigned int m_fileNumber;
      unsigned int m_date;  // DDMMYYYY
      unsigned int m_time;  // HHMMSS
      unsigned int m_sizeLimitBlocks; // file size limit in # of data blocks
      unsigned int m_sizeLimitMB; // ... in MBytes

      // file_name_strings
      std::string m_appName;
      std::string m_fileNameTag;

      // run_parameters_record
      unsigned int m_runNumber;
      unsigned int m_recEnable;
      unsigned int m_triggerType;
      unsigned int m_detectorMask;

      // optional metadata strings
      std::vector<std::string> m_metadataString;

    };


    class FileFooter
    {
      public:
        unsigned int m_dateEnd;
        unsigned int m_timeEnd;
        unsigned int m_eventsInFile; // in this file
        unsigned int m_dataInFile; // in MB
        unsigned int m_eventsInRun; // in this run
        unsigned int m_dataInRun;  // in MB
        unsigned int m_status;  // non-zero for the last file

        void print();
    };


    class PmtChannel
    {
      public:

        int m_channel;  // -1: no value
        std::vector<int> m_adc;
        std::vector<int> m_adcPeakingCycle;
        std::vector<int> m_adcRange;
        std::vector<int> m_tdc;
        std::vector<int> m_tdcHitCount;
        std::vector<int> m_pedestal;

        PmtChannel() {
          m_channel = -1;
        }

        bool filled() {
          return m_channel != -1;
        }

        DayaBay::FeeGain::FeeGain_t feeGain() { return (DayaBay::FeeGain::FeeGain_t) (m_adc.size()==0 ? 0 : 1+m_adcRange[0]); }

        void clear() {
          m_channel = -1;
          m_adc.clear();
          m_adcPeakingCycle.clear();
          m_adcRange.clear();
          m_tdc.clear();
          m_tdcHitCount.clear();
          m_pedestal.clear();
        }

        void print();
    };

    class Rom
    {
      public:
        // data members
        // information in ROM header
        int m_size;   // total size of bytes including header
        int m_slot;  // slot number
        int m_type;  // module type

        // information in CBLT header and footer
        int m_cbltGA;  // VME module Geographic Address
        int m_cbltModuleType;
        int m_cbltDataLength; // bytes from CBLT head to foot

        // function members
        Rom() {}
        virtual ~Rom() {}

        virtual void print();
    };


    class RomFee : public Rom
    {
      public:
        // information in data header and footer
        int m_triggerNum;  // 8-bit loop integers from 0
        int m_triggerType; // local:0000, cross:0001
        int m_version;     // data format version
        int m_status;
        int m_dataLength;  // bytes from data head to foot
        std::vector<PmtChannel> m_channels;

        void print();
    };

    class FadcChannel
    {
      public:

        int m_channel;  // -1: no value
        std::vector<int> m_adcData;

        FadcChannel() {
          m_channel = -1;
        }

        bool filled() {
          return m_channel != -1;
        }

        void clear() {
          m_channel = -1;
          m_adcData.clear();
        }

        void print();
    };

    class RomFadc : public Rom
    {
      public:
        // information in data header and footer
        int m_triggerNum;  // 8-bit loop integers from 0
        int m_triggerType; // local:0000, cross:0001
        int m_version;     // data format version
        int m_status;
        int m_dataLength;  // bytes from data head to foot
        std::vector<FadcChannel> m_channels;

        void print();
    };

    class LtbFrame
    {
      public:
        bool m_accStat; // Accumulation status
        bool m_GPSValid;  // GPS valid
        bool m_timestampType; // Timestamp type 1: UTC, 0: UNIX.
        bool m_clockSystemValid; // Clock system valid
        int m_iltSn; // Raw trigger sequence number
        int m_rot;  // Read Out Type
        int m_triggerSrc;  // status of 16 trigger sources
        unsigned int m_nanoSecondLow;
        unsigned int m_nanoSecondHigh; // Number of 0.5ns
        int m_accumulationLow;
        int m_accumulationHigh; // Number of 0.5ns
        int m_hsum;  // sum of hits
        int m_esumComp;
        int m_esumADC;
        int m_blockedValidTrigger;  // the number of local trigger which is blocked by 
                                    // buffer full between two packeged local trigger
        int m_crossTriggerSrc;  
        bool m_feeBufferStat; // FEE buffer status
        bool m_ltbBufferStat; // LTB buffer status

        virtual void print();

        virtual TimeStamp timeStamp() const = 0;
        virtual ~LtbFrame() {;}

    };

    class LtbFrameUTC : public LtbFrame
    {
      public:
        int m_day;  // the number of day from Jan 1 of current year in binary code
        int m_hour; // the hour of current day in BCD code
        int m_minute; // the minute of current hour in BCD code 
        int m_second; // the second of current minute in BCD code
        virtual TimeStamp timeStamp() const {
          time_t sec = m_day*86400 + bcd2dec(m_hour)*3600 + bcd2dec(m_minute)*60 + bcd2dec(m_second);
          int nsec = ((m_nanoSecondHigh<<4 | m_nanoSecondLow) + (m_accumulationHigh<<4 | m_accumulationLow))/2;
          return TimeStamp(sec,nsec);
        }
        virtual void print();
        virtual ~LtbFrameUTC() {;}
    };

    class LtbFrameUnix : public LtbFrame
    {
      public:
        unsigned int m_unixSecLow; // the number of second since Jan 1th, 1970, low 16 bit
        unsigned int m_unixSecHigh; // the number of second since Jan 1th, 1970, high 16 bit
        virtual TimeStamp timeStamp() const {
          time_t sec = (m_unixSecHigh << 16) | m_unixSecLow;
          int nsec = ((m_nanoSecondHigh<<4 | m_nanoSecondLow) + (m_accumulationHigh<<4 | m_accumulationLow))/2;
          TimeStamp time(sec,nsec);
          return TimeStamp(sec,nsec);
        }
        virtual void print();
        virtual ~LtbFrameUnix() {;}
    };

    class RomLtb : public Rom
    {
      public:
        std::vector<LtbFrame*> m_frames;

        virtual ~RomLtb() {clear();}
        void print();

        void clear() {
          if (m_frames.empty()) return;
          for (unsigned int i = 0; i < m_frames.size(); i++) {
            delete m_frames[i];
          }
          m_frames.clear();
        }
    };


    RawDataEvent() {
      m_fileHeader = new FileHeader();
      m_fileFooter = new FileFooter();
    }

    virtual ~RawDataEvent() {
      delete m_fileHeader;
      delete m_fileFooter;
      m_rawBuffer.clear();
      clear();
    }

    void print();

    void clear() {
      if (m_modules.empty()) return;
      for (unsigned int i = 0; i < m_modules.size(); i++) {
        delete m_modules[i];
      }
      m_modules.clear();
    }


    // data members
    //______________________________________________________________________

    FileHeader* m_fileHeader;
    FileFooter* m_fileFooter;

    int m_dataBlockNum;   // # of the block
    int m_dataBlockSize;   // in bytes

    int m_formatVersionMajor;
    int m_formatVersionMinor;
    int m_evtSize;    // in bytes
    int m_detId;
    int m_siteId;   // m_detId[4:7]
    int m_positionId;   // m_detId[0:3]
    int m_runNum;
    int m_evtNum;
    int m_dataType;   // 0:normal, 1:calib, 2:elec. calib.
    int m_dataTypeSpecific;  // DAC for elec. calib.
    int m_dataStatus;
    std::vector<unsigned int> m_rawBuffer; 

    std::vector<Rom*> m_modules;

    bool isInvalidData()   {
      return test_bit(m_dataStatus, 0);
    }
    bool isNotMatchTriggerNumber()  {
      return test_bit(m_dataStatus, 1);
    }
    bool isCBLTRawFormat()   {
      return test_bit(m_dataStatus, 16);
    }
    bool isCBLTHeader()    {
      return test_bit(m_dataStatus, 17);
    }


    //Trigger Type, need to be refined
    DayaBay::Trigger::TriggerType_t triggerType() {

      unsigned int triType = 0;

      for (unsigned int i = 0; i < m_modules.size(); i++) {
        if(m_modules[i]->m_type == dyb::kRomLtb) {
          RawDataEvent::RomLtb* romLtb;
          romLtb = dynamic_cast<RawDataEvent::RomLtb*>(m_modules[i]);

          for (unsigned int j = 0; j < romLtb->m_frames.size(); j++) {
            //std::cout<<romLtb->m_frames[j].m_triggerSrc<<std::endl;
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<0) ) { //MANUAL_TRIGGER
              triType = triType | DayaBay::Trigger::kManual;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<1) ) { //CROSS_TRIGGER_IN
              triType = triType | DayaBay::Trigger::kExternal;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<2) ) { //PERIODIC_TRIGGER
              triType = triType | DayaBay::Trigger::kPeriodic;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<8) ) { //MULTIPLICITY_TRIGGER
              triType = triType | DayaBay::Trigger::kMult;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<9) ) { //ESUM_ADC_TRG
              triType = triType | DayaBay::Trigger::kESumADC;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<10) ) { //HIGH_ESUM_COMP_TRG
              triType = triType | DayaBay::Trigger::kESumHigh;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<11) ) { //LOW_ESUM_COMP_TRG
              triType = triType | DayaBay::Trigger::kESumLow;
            }
            if(romLtb->m_frames[j]->m_triggerSrc & (1<<12) ) { //ALL_ESUM_COMP_TRG
              triType = triType | DayaBay::Trigger::kESumAll;
            }

            break; // use the first ltb frame
          }

          break;
        }
      }

      return (DayaBay::Trigger::TriggerType_t)( triType | (detectorId() << 2));
    }


    Site::Site_t siteId() {
      return (Site::Site_t)(m_siteId == 0 ? m_siteId : 1 << (m_siteId - 1));
    }

    DetectorId::DetectorId_t detectorId() {
      return (DetectorId::DetectorId_t)m_positionId;
    }


  private:
};

#endif

---