CDCTriggerUnpackerModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Tzu-An Sheng                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#ifndef CDCTRIGGERUNPACKERMODULE_H
#define CDCTRIGGERUNPACKERMODULE_H
 
#include <framework/core/Module.h>
#include <rawdata/dataobjects/RawTRG.h>
#include <framework/datastore/StoreArray.h>
#include <framework/database/DBObjPtr.h>
 
#include <trg/cdc/dataobjects/Bitstream.h>
#include <trg/cdc/Unpacker.h>
#include <trg/cdc/dataobjects/CDCTriggerTrack.h>
#include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
#include <trg/cdc/dataobjects/CDCTriggerFinderClone.h>
#include <trg/cdc/dataobjects/CDCTriggerMLPInput.h>
#include <trg/cdc/dbobjects/CDCTrigger2DConfig.h>
#include <trg/cdc/dataobjects/CDCTriggerMLP.h>
#include <trg/cdc/dbobjects/CDCTriggerNeuroConfig.h>
 
#include <array>
#include <bitset>
#include <vector>
#include <string>
#include <iomanip>
 
namespace Belle2 {
  using NodeList = std::vector<std::vector<int> >;
 
  static constexpr int mergerWidth = 256;
  static constexpr int nAllMergers = 146;
  static constexpr int wordWidth = 32;
  static constexpr int nFinesse = 4;
  using MergerBus = std::array<std::bitset<mergerWidth>, nAllMergers>;
  using MergerBits = Bitstream<MergerBus>;
 
  struct SubTrigger {
    SubTrigger(std::string inName,
               unsigned inEventWidth, unsigned inOffset,
               int inHeaderSize, std::vector<int> inNodeID,
               int& inDelay, int& inCnttrg, int inDebugLevel = 0) :
      name(inName), eventWidth(inEventWidth), offset(inOffset),
      headerSize(inHeaderSize), iNode(inNodeID.front()),
      iFinesse(inNodeID.back()), delay(inDelay),
      cnttrg(inCnttrg),
      debugLevel(inDebugLevel) {};
 
    std::string name;
    unsigned eventWidth;
    unsigned offset;
    int headerSize;
    int iNode;
    int iFinesse;
 
    /* information from Belle2Link header */
    std::string firmwareType;
    std::string firmwareVersion;
    int& delay;
    int& cnttrg;
 
    int debugLevel;
 
    virtual void reserve(int, std::array<int, nFinesse>) {};
 
    virtual void unpack(int,
                        std::array<int*, nFinesse>,
                        std::array<int, nFinesse>) {};
 
    virtual int getHeaders(int subDetectorId,
                           std::array<int*, 4> data32tab,
                           std::array<int, 4> nWords)
    {
      if (subDetectorId != iNode) {
        return 0;
      }
      // int nWordsize = 3075;  // temporary solution to hard coded the correct event size (for 2D only?)
      // empty data buffer
      if (nWords[iFinesse] < headerSize) {
        B2WARNING("The module " << name << " does not have enough data (" <<
                  nWords[iFinesse] << "). Nothing will be unpacked.");
        return 0;
      } else if (nWords[iFinesse] == headerSize) {
        B2DEBUG(20, "The module " << name <<
                " contains only the header. Nothing will be unpacked.");
        return 0;
      }
 
      // need one more check, give a warning if the event has wrong data size
 
      // event data block header:
      // 0xdddd  --> correct event data (for 2D only?)
      // 0xbbbb  --> dummy buffer supposed to be used for only suppressed events.
      if (nWords[iFinesse] > headerSize) {
        //dataHeader = CDCTriggerUnpacker::rawIntToAscii(data32tab.at(iFinesse)[headerSize]&0xFFFF0000 >> 16);
        //bool dataHeader = ( (data32tab.at(iFinesse)[headerSize]&0xffff0000) == 0xdddd0000);
        long dataHeader = (data32tab.at(iFinesse)[headerSize] & 0xffff0000);
        if (dataHeader != 0xdddd0000) {
          B2DEBUG(30, "The module " << name << " has an event data header " << std::hex << std::setfill('0') << std::setw(4) <<
                  (dataHeader >> 16) <<
                  " in this event. It will be ignore.");
          return 0;
        }
        B2DEBUG(50, "subdet and head size " <<  std::setfill('0') << std::hex << std::setw(8) << iNode << ", " << std::dec <<  std::setw(
                  0) << nWords[iFinesse] <<
                " : " << std::hex << std::setw(8) << data32tab.at(iFinesse)[0] << " " << data32tab.at(iFinesse)[1] << " " << data32tab.at(
                  iFinesse)[2] <<
                " " << data32tab.at(iFinesse)[3] << " dataheader = " << dataHeader);
      }
 
      /* get event header information
       * Ideally, these parameters should not change in the same run,
       * so it is more efficiency to do it in beginRun().
       * However, since they are present in all events,
       * let's check if they really remain unchanged.
       */
      if (headerSize >= 2) {
        // supposedly these two Words will stay for all the versions
        firmwareType = CDCTriggerUnpacker::rawIntToAscii(data32tab.at(iFinesse)[0]);
        firmwareVersion = CDCTriggerUnpacker::rawIntToString(data32tab.at(iFinesse)[1]);
        //int cnttrg = 0;    // temporary solution, this should be one as a reference for comparison
        int l1_revoclk = -1;
 
        if (headerSize >= 3) {
          std::bitset<wordWidth> thirdWord(data32tab.at(iFinesse)[2]);
          l1_revoclk = CDCTriggerUnpacker::subset<32, 0, 11>(thirdWord).to_ulong();
 
          if (firmwareType == "2D  ") {  // temporary solcuion, the following version number check is valid only for 2D
 
            if (firmwareVersion >  "19041700")  {  // started since 19041705
              // the third word is cnttrg and L1_revoclk
              int newCnttrg = CDCTriggerUnpacker::subset<32, 12, 31>(thirdWord).to_ulong();
              cnttrg = newCnttrg;
            } else if (firmwareVersion > "17121900") {  // upto that version, headerSize == 2?
              // the third word is b2l delay and L1_revoclk
              int newDelay = CDCTriggerUnpacker::subset<32, 12, 20>
                             (thirdWord).to_ulong();   // or should be <32,12,19>? bit 31-20 are for prescale?
              if (delay > 0 && delay != newDelay) {
                B2WARNING(" the Belle2Link delay for " << name <<
                          "has changed from " << delay << " to " << newDelay << "!");
              }
              delay = newDelay;
            }
          }
        }
 
        B2DEBUG(20, name << ": " << firmwareType << ", version " <<
                firmwareVersion << ", node " << std::hex << iNode <<
                ", finesse " << iFinesse << ", delay: " << delay <<
                ", cnttrg: " << cnttrg << std::dec << " == " << cnttrg <<  ", L1_revoclk " << l1_revoclk);
 
 
      }
      return 1;
    };
    virtual ~SubTrigger() {};
  };
 
  class CDCTriggerUnpackerModule : public Module {
 
  public:
 
    CDCTriggerUnpackerModule();
 
    virtual void initialize() override;
 
    virtual void terminate() override;
 
    virtual void beginRun();
 
    virtual void event() override;
 
    std::vector<float> unscaleNNOutput(std::vector<float> input) const;
    static constexpr std::array<int, 9> nMergers = {10, 10, 12, 14, 16, 18, 20, 22, 24};
 
  private:
    int m_headerSize;
 
    StoreArray<RawTRG> m_rawTriggers; 
    NodeList m_mergerNodeID; 
    bool m_unpackMerger;  
    MergerBits m_mergerBitsPerClock; 
    StoreArray<MergerBits> m_mergerBits; 
    bool m_decodeTSHit;  
    NodeList m_tracker2DNodeID; 
    bool m_unpackTracker2D;  
    bool m_decode2DFinderTrack;  
    bool m_decode2DFinderInputTS;  
    bool m_alignFoundTime;  
    int  m_n2DTS;  
    NodeList m_neuroNodeID;  
    bool m_unpackNeuro;  
    bool m_decodeNeuro;  
    std::vector<int> m_delayNNOutput; 
    std::vector<int> m_delayNNSelect; 
    StoreArray<CDCTriggerUnpacker::TSFOutputBitStream> m_bitsTo2D;
 
    StoreArray<CDCTriggerSegmentHit> m_TSHits;
 
    StoreArray<CDCTriggerUnpacker::T2DOutputBitStream> m_bits2DTo3D;
 
    StoreArray<CDCTriggerTrack> m_2DFinderTracks;
 
    StoreArray<CDCTriggerFinderClone> m_2DFinderClones;
 
 
    StoreArray<CDCTriggerUnpacker::NNBitStream> m_bitsNN;
 
    StoreArray<CDCTriggerTrack> m_NeuroTracks;
 
    StoreArray<CDCTriggerMLPInput> m_NeuroInputs;
 
    StoreArray<CDCTriggerTrack> m_NNInput2DFinderTracks;
 
    StoreArray<CDCTriggerSegmentHit> m_NNInputTSHits;
 
    StoreArray<CDCTriggerSegmentHit> m_NNInputTSHitsAll;
 
    int m_debugLevel = 0;
 
    int m_mergerDelay = 0;
 
    //int m_2DFinderDelay = 0;
    // since version 19041705, the B2L delay is removed, it should a fixed number for a long period and recorded in database.
    int m_2DFinderDelay = 45;   // 0x2d: changed from 0x28 since some time in 201902-03
 
    int m_NeuroDelay = 0;
 
    // int m_Cnttrg = 0; // not used, commented out at 2019/07/31 by ytlai
    int m_mergerCnttrg = 0;
    int m_2DFinderCnttrg = 0;
    int m_NeuroCnttrg = 0;
 
    unsigned m_exp = 0;
    unsigned m_run = 0;
 
    std::vector<SubTrigger*> m_subTrigger;
 
    //condition database for number of TS in 2D
    DBObjPtr<CDCTrigger2DConfig> m_dbn2DTS;
    DBObjPtr<CDCTriggerNeuroConfig> m_cdctriggerneuroconfig;
    std::vector<float> m_NNOutputScale;
    CDCTriggerMLP m_mlp_scale;
    bool m_useDB;
    bool m_sim13dt;
  };
 
 
}
 
#endif /* CDCTRIGGERUNPACKERMODULE_H */