NeuroTrigger.h

#ifndef NEUROTRIGGER_H
#define NEUROTRIGGER_H
 
#include <trg/cdc/dataobjects/CDCTriggerMLP.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/database/DBObjPtr.h>
#include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
#include <trg/cdc/dbobjects/CDCTriggerNeuroConfig.h>
#include <framework/dataobjects/BinnedEventT0.h>
 
namespace Belle2 {
  class CDCTriggerTrack;
 
  class NeuroTrigger {
  public:
    struct Parameters {
      unsigned nMLP = 1;
      std::vector<std::vector<float>> nHidden = {{3.}};
      bool targetZ = true;
      bool targetTheta = false;
      bool multiplyHidden = true;
      std::vector<std::vector<float>> outputScale = {{ -1., 1.}};
      std::vector<std::vector<float>> phiRange = {{0., 360.}};
      std::vector<std::vector<float>> invptRange = {{ -5., 5.}};
      std::vector<std::vector<float>> thetaRange = {{17., 150.}};
      std::vector<std::vector<float>> phiRangeTrain = {{0., 360.}};
      std::vector<std::vector<float>> invptRangeTrain = {{ -5., 5.}};
      std::vector<std::vector<float>> thetaRangeTrain = {{17., 150.}};
      std::vector<unsigned short> maxHitsPerSL = {1};
      std::vector<unsigned long> SLpattern = {0};
      std::vector<unsigned long> SLpatternMask = {0};
      unsigned tMax = 256;
      std::string et_option = "etf_or_fastestpriority";
      bool T0fromHits = false;
 
    };
 
    NeuroTrigger() {}
 
    virtual ~NeuroTrigger() {}
 
    void initialize(const Parameters& p);
 
    std::vector<unsigned> getRangeIndices(const Parameters& p, unsigned isector);
 
    void save(const std::string& filename, const std::string& arrayname = "MLPs");
    bool load(const std::string& filename, const std::string& arrayname = "MLPs");
 
    void setConstants();
 
    void setPrecision(std::vector<unsigned> precision) { m_precision = precision; }
 
    void initializeCollections(std::string hitCollectionName, std::string eventTimeName, std::string et_option);
 
    CDCTriggerMLP& operator[](unsigned index) { return m_MLPs[index]; }
    const CDCTriggerMLP& operator[](unsigned index) const { return m_MLPs[index]; }
 
    unsigned nSectors() const { return m_MLPs.size(); }
 
    void addMLP(const CDCTriggerMLP& newMLP) { m_MLPs.push_back(newMLP); }
 
    std::vector<int> selectMLPs(float phi0, float invpt, float theta);
 
    int selectMLPbyPattern(std::vector<int>& MLPs, unsigned long pattern, const bool neurotrackinputmode);
 
    void updateTrack(const CDCTriggerTrack& track);
 
    void updateTrackFix(const CDCTriggerTrack& track);
 
    double getRelId(const CDCTriggerSegmentHit& hit);
    void getEventTime(unsigned isector, const CDCTriggerTrack& track, std::string et_option, const bool);
 
    void getEventTime(unsigned isector, const CDCTriggerTrack& track);
 
    std::string get_et_option()
    {
      std::string eto = m_MLPs[0].get_et_option();
      for (unsigned int i = 0; i < m_MLPs.size(); ++i) {
        if (m_MLPs[i].get_et_option() != eto) {
          B2ERROR("Timing options in the expert networks in the CDC Neurotrigger differ!");
        }
      }
      return eto;
 
    }
 
    unsigned long getInputPattern(unsigned isector, const CDCTriggerTrack& track, const bool neurotrackinputmode);
 
    std::vector<unsigned> selectHitsHWSim(unsigned isector, const CDCTriggerTrack& track);
 
    std::vector<unsigned> selectHits(unsigned isector, const CDCTriggerTrack& track,
                                     bool returnAllRelevant = false);
 
    std::vector<float> getInputVector(unsigned isector, const std::vector<unsigned>& hitIds);
 
    std::vector<float> runMLP(unsigned isector, std::vector<float> input);
 
    std::vector<float> runMLPFix(unsigned isector, std::vector<float> input);
 
  private:
    std::vector<CDCTriggerMLP> m_MLPs = {};
    double m_radius[9][2] = {};
    unsigned m_TSoffset[10] = {};
    double m_idRef[9][2] = {};
    double m_alpha[9][2] = {};
    int m_T0 = 0;
    bool m_hasT0 = false;
    std::vector<unsigned> m_precision;
 
    StoreArray<CDCTriggerSegmentHit> m_segmentHits;
    StoreObjPtr<BinnedEventT0> m_eventTime;
    std::string m_hitCollectionName;
    DBObjPtr<CDCTriggerNeuroConfig> m_cdctriggerneuroconfig;
 
  };
}
#endif