CDCTriggerMLP.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.                  *
 **************************************************************************/
#ifndef CDCTRIGGERMLP_H
#define CDCTRIGGERMLP_H
 
#include <TObject.h>
#include <framework/logging/Logger.h>
 
namespace Belle2 {
  class CDCTriggerMLP : public TObject {
 
    // weights etc. are set only by the trainer
    friend class CDCTriggerNeuroTrainerModule;
    friend class NeuroTrigger;
 
  public:
    CDCTriggerMLP();
 
    CDCTriggerMLP(std::vector<unsigned short>& nodes,
                  unsigned short targets,
                  std::vector<float>& outputscale,
                  std::vector<float>& phirangeUse,
                  std::vector<float>& invptrangeUse,
                  std::vector<float>& thetarangeUse,
                  std::vector<float>& phirangeTrain,
                  std::vector<float>& invptrangeTrain,
                  std::vector<float>& thetarangeTrain,
                  unsigned short maxHits,
                  unsigned long pattern,
                  unsigned long patternMask,
                  unsigned short tmax,
                  const std::string& etoption);
 
    ~CDCTriggerMLP() { }
 
    bool isTrained() const { return trained; }
    unsigned nLayers() const { return nNodes.size(); }
    unsigned nNodesLayer(unsigned iLayer) const { return nNodes[iLayer]; }
    unsigned nWeights() const { return weights.size(); }
    unsigned nWeightsCal() const;
    std::vector<float> getWeights() const { return weights; }
    void setWeights(std::vector<float> xweights) {weights = xweights; }
    unsigned short getMaxHitsPerSL() const { return maxHitsPerSL; }
    unsigned long getSLpattern() const { return SLpattern & SLpatternMask; }
    unsigned long getSLpatternMask() const { return SLpatternMask; }
    unsigned long getSLpatternUnmasked() const { return SLpattern; }
    unsigned short getTMax() const { return tMax; }
    std::vector<float> getIDRange(unsigned iSL) const
    {
      return {relevantID[2 * iSL], relevantID[2 * iSL + 1]};
    }
    void setRelID(std::vector<float> relid) {relevantID = relid;}
    std::vector<float> getRelID() const {return relevantID;}
    std::string get_et_option() const { return et_option; }
 
    bool inPhiRangeUse(float phi) const;
    bool inPtRangeUse(float pt) const;
    bool inInvptRangeUse(float invpt) const;
    bool inThetaRangeUse(float theta) const;
    bool inPhiRangeTrain(float phi) const;
    bool inPtRangeTrain(float pt) const;
    bool inInvptRangeTrain(float invpt) const;
    bool inThetaRangeTrain(float theta) const;
    bool isRelevant(float relId, unsigned iSL) const;
 
    float scaleId(double relId, unsigned iSL) const;
    std::vector<float> scaleTarget(std::vector<float> target) const;
    std::vector<float> unscaleTarget(std::vector<float> target) const;
 
    int zIndex() const;
    int thetaIndex() const;
 
  private:
    std::vector<unsigned short> nNodes;
    std::vector<float> weights;
    bool trained;
 
    unsigned short targetVars;
    std::vector<float> outputScale;
 
    std::vector<float> phiRangeUse;
    std::vector<float> invptRangeUse;
    std::vector<float> thetaRangeUse;
    std::vector<float> phiRangeTrain;
    std::vector<float> invptRangeTrain;
    std::vector<float> thetaRangeTrain;
 
    unsigned short maxHitsPerSL;
    unsigned long SLpattern;
    unsigned long SLpatternMask;
 
    unsigned short tMax;
    std::vector<float> relevantID;
 
    std::string et_option;
 
    ClassDef(CDCTriggerMLP, 11);
  };
}
#endif