CDCUnpackerModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <framework/database/DBArray.h>
#include <framework/database/DBObjPtr.h>
#include <cdc/dataobjects/CDCHit.h>
#include <cdc/dataobjects/CDCRawHit.h>
#include <cdc/dataobjects/CDCRawHitWaveForm.h>
#include <cdc/dataobjects/WireID.h>
#include <cdc/dbobjects/CDCChannelMap.h>
#include <cdc/dbobjects/CDCADCDeltaPedestals.h>
#include <rawdata/dataobjects/RawCDC.h>
 
namespace Belle2 {
  namespace CDC {
 
    class CDCUnpackerModule : public Module {
 
    public:
      CDCUnpackerModule();
 
      virtual ~CDCUnpackerModule();
 
      void initialize() override;
 
      void beginRun() override;
 
      void event() override;
 
      void endRun() override;
 
      void terminate() override;
 
      void setCDCPacketHeader(const int* buf)
      {
 
        if ((buf[0] & 0xff000000) == 0x22000000) { // raw data mode.
          m_dataType = 1;
        } else if ((buf[0] & 0xff000000) == 0x20000000) { // suppressed data mode.
          m_dataType = 2;
        } else {
          B2ERROR("Undefined data type");
        }
 
        m_version = ((buf[0] & 0xff0000) >> 16); // Always zero.
        m_boardId = (buf[0] & 0xffff);
        m_triggerTime = ((buf[1] & 0xffff0000) >> 16);
        m_dataLength = (buf[1] & 0xffff);
        m_triggerNumber = buf[2];
 
      }
 
      int getDataType()
      {
        return m_dataType;
      }
 
      int getTriggerTime()
      {
        return m_triggerTime;
      }
 
      int getDataLength()
      {
        return m_dataLength;
      }
 
      int getTriggerNumber()
      {
        return m_triggerNumber;
      }
 
 
      int getBoardId()
      {
        return m_boardId;
      }
 
      void loadMap();
 
      void setADCPedestal();
 
 
      WireID getWireID(int iBoard, int iCh) const;
 
      void printBuffer(int* buf, int nwords);
 
      bool isValidBoardChannel(WireID wireId)
      {
        if (wireId.getEWire() == 65535) {
          return false;
        } else {
          return true;
        }
      }
    private:
 
      int m_dataType;
 
      int m_version;
 
      int m_boardId;
 
      int m_triggerTime;
 
      int m_dataLength;
 
      int m_triggerNumber;
 
      bool m_enableStoreCDCRawHit;
 
      bool m_enablePrintOut;
 
 
      std::string m_rawCDCName;
 
      std::string m_cdcRawHitName;
 
      std::string m_cdcRawHitWaveFormName;
 
      std::string m_cdcHitName;
 
      std::string m_xmlMapFileName;
 
      std::vector<unsigned short> m_buffer;
 
      WireID m_map[300][48];
 
      int m_fadcThreshold;
 
      int m_tdcOffset;
 
      int m_tdcAuxOffset;
      int m_boardIDTrig;
 
      int m_channelTrig;
 
      bool m_subtractTrigTiming;
 
      bool m_enableDatabase;
 
      bool m_enable2ndHit;
 
      DBArray<CDCChannelMap>* m_channelMapFromDB;
      // DBArray<CDCChannelMap> m_channelMapFromDB;
 
      DBObjPtr<CDCADCDeltaPedestals>* m_adcPedestalFromDB = nullptr;
 
      bool m_pedestalSubtraction = true;
 
      StoreArray<RawCDC> m_rawCDCs;
 
      StoreArray<CDCRawHitWaveForm> m_CDCRawHitWaveForms;
 
      StoreArray<CDCRawHit> m_CDCRawHits;
 
      StoreArray<CDCHit> m_CDCHits;
 
      bool m_dataLengthError;
 
      bool m_dataSizeError;
 
      bool m_recoverBoardIdError;
 
    };//end class declaration
 
 
  } //end CDC namespace;
} // end namespace Belle2