CDCTriggerMLPData.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 CDCTRIGGERMLPDATA_H
#define CDCTRIGGERMLPDATA_H
 
#include <framework/logging/Logger.h>
#include <iostream>
#include <fstream>
#include <TObject.h>
#include "boost/iostreams/filter/gzip.hpp"
#include "boost/iostreams/filtering_streambuf.hpp"
#include "boost/iostreams/filtering_stream.hpp"
#include "boost/multi_array.hpp"
#define BOOST_MULTI_ARRAY_NO_GENERATORS
 
namespace Belle2 {
  class CDCTriggerMLPData : public TObject {
  public:
    struct HeaderSet {
      float relID[18];
      unsigned exPert;
      HeaderSet() {}
      HeaderSet(std::vector<float> line)
      {
        if (line.size() == 19) {
          exPert = line[0];
          for (unsigned i = 1; i <= 19; i++) {
            relID[i] = line[i];
          }
        } else {B2ERROR("ERROR! wrong lengthof relID vector!");}
      }
      void operator= (std::vector<float> line)
      {
        if (line.size() == 19) {
          exPert = line[0];
          for (unsigned i = 1; i <= 19; i++) {
            relID[i] = line[i];
          }
        } else {B2ERROR("ERROR! wrong length of relID vector!");}
 
 
      }
      HeaderSet(unsigned expert, std::vector<float> relevantID)
      {
        if (relevantID.size() == 18) {
          for (unsigned i = 0; i < 18; ++i) {relID[i] = relevantID[i];}
        } else {B2ERROR("ERROR! wrong length of relID vector!");}
        exPert = expert;
      }
      friend std::ostream& operator << (std::ostream& out, const HeaderSet& hset)
      {
        out << hset.exPert << '\t';
        for (unsigned i = 0; i < 18; ++i) { out << hset.relID[i] << '\t';}
        return out;
      }
      friend std::istream& operator >> (std::istream& in, HeaderSet& hset)
      {
        std::string help;
        std::string helpline;
        help = "";
        helpline = "";
        std::getline(in, helpline, '\n');
        if (helpline.length() < 2) {return in;}
        std::stringstream ss(helpline);
        std::getline(ss, help, '\t');
 
        hset.exPert = std::stoul(help);
        for (unsigned i = 0; i < 18; ++i) {
          help = "";
          std::getline(ss, help, '\t');
          hset.relID[i] = std::stof(help);
        }
        return in;
      }
 
 
    };

    //template <const unsigned intype>  -- no longer need template for vector
    struct NeuroSet {
      //To make it suitable for any input, change it to vector
      std::vector<float> input;
      std::vector<float> target;
      int exp;
      int run;
      int subrun;
      int evt;
      int track;
      int ntracks;
      float nnscalez;
      float nnscaletheta;
      int nnrawz;
      int nnrawtheta;
      float inphi;
      float intheta;
      unsigned expert;
      float ininvpt;
      float pt; // Add to check pt dependence
      std::string headline;
      NeuroSet(int inlen = 27)
      {
        headline = "Experiment\tRun\tSubrun\tEvent\tTrack\tnTracks\tExpert\tiNodes\toNodes\t";
        unsigned InputPerSL = inlen / 9; // Suppose always use 9 SL
        for (unsigned i = 0; i < inlen / InputPerSL; ++i) {
          headline += "SL" + std::to_string(i) + "-relID\t";
          headline += "SL" + std::to_string(i) + "-driftT\t";
          headline += "SL" + std::to_string(i) + "-alpha\t";
          for (unsigned j = 0; j < InputPerSL - 3; ++j) {
            headline += "SL" + std::to_string(i) + "-extra_input" + std::to_string(j) + "\t";
          }
        }
        headline += "RecoZ\tRecoTheta\tScaleZ\tRawZ\tScaleTheta\tRawTheta\t2DPhi\t3DTheta\t2DinvPt\t2DPt\n";
      }
 
      NeuroSet(std::vector<float> xin, std::vector<float> xout,  int xexp, int xrun, int xsubrun, int xevt, int xtrack, unsigned xexpert,
               int xntracks, int xnnrawz, int xnnrawtheta, float xnnscalez, float xnnscaletheta, float xinphi, float xintheta, float xininvpt,
               float xinpt)
      {
        input = xin;
        target  = xout;
        exp = xexp;
        run = xrun;
        subrun = xsubrun;
        evt = xevt;
        track = xtrack;
        expert = xexpert;
 
        ntracks = xntracks;
        nnscalez = xnnscalez;
        nnscaletheta = xnnscaletheta;
        nnrawz = xnnrawz;
        nnrawtheta = xnnrawtheta;
        inphi = xinphi;
        intheta = xintheta;
        ininvpt = xininvpt;
        pt = xinpt;
        headline = "Experiment\tRun\tSubrun\tEvent\tTrack\tnTracks\tExpert\tiNodes\toNodes\t";
        unsigned inlen = input.size();
        unsigned InputPerSL = inlen / 9; // Suppose always use 9 SL
        for (unsigned i = 0; i < inlen / InputPerSL; ++i) {
          headline += "SL" + std::to_string(i) + "-relID\t";
          headline += "SL" + std::to_string(i) + "-driftT\t";
          headline += "SL" + std::to_string(i) + "-alpha\t";
          for (unsigned j = 0; j < InputPerSL - 3; ++j) {
            headline += "SL" + std::to_string(i) + "-extra_input" + std::to_string(j) + "\t";
          }
        }
        headline += "RecoZ\tRecoTheta\tScaleZ\tRawZ\tScaleTheta\tRawTheta\t2DPhi\t3DTheta\t2DinvPt\t2DPt\n";
 
      }
      friend std::ostream& operator << (std::ostream& out, const NeuroSet& dset)
      {
        out << dset.exp << '\t' << dset.run << '\t' << dset.subrun << '\t' << dset.evt << '\t' << dset.track << '\t' << dset.ntracks << '\t'
            << dset.expert << '\t'
            << dset.input.size() << '\t' << dset.target.size() << '\t';
        for (auto indata : dset.input) {out << indata << '\t';}
        for (auto outdata : dset.target) {out << outdata << '\t';}
        out << dset.nnscalez << '\t' << dset.nnrawz << '\t' << dset.nnscaletheta << '\t' << dset.nnrawtheta << '\t' << dset.inphi << '\t' <<
            dset.intheta << '\t' << dset.ininvpt << '\t' << dset.pt;
        return out;
      }
      friend std::istream& operator >> (std::istream& in, NeuroSet& dset)
      {
        std::string help;
        help = "";
        std::getline(in, help, '\t');
        if (help.length() < 2) {return in;}
        dset.exp = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.run = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.subrun = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.evt = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.track = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.ntracks = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.expert = std::stoul(help);
        // check if input and target size match:
        std::string insize = "";
        std::string outsize = "";
        std::getline(in, insize, '\t');
        dset.input.assign(std::stoul(insize), -1);
        /*
        if (std::stoul(insize) != inLen) {
          B2ERROR("Input and output format of neurotrigger training data does not  match!");
        }
        */
        std::getline(in, outsize, '\t');
        dset.target.assign(std::stoul(outsize), -1);
        /*
        if (std::stoul(outsize) != outLen) {
          B2ERROR("Input and output format of neurotrigger training data does not  match!");
        }
        */
        for (unsigned i = 0; i < std::stoul(insize); ++i) {
          help = "";
          std::getline(in, help, '\t');
          try {
            dset.input[i] = std::stof(help);
          } catch (const std::out_of_range& oor) {
            B2WARNING("out of range error: " << help << " is not in float range!");
            dset.input[i] = 0.;
          }
        }
        for (unsigned i = 0; i < std::stoul(outsize); ++i) {
          help = "";
          std::getline(in, help, '\t');
          try {
            dset.target[i] = std::stof(help);
          } catch (const std::out_of_range& oor) {
            B2WARNING("out of range error: " << help << " is not in float range!");
            dset.target[i] = 0.;
          }
        }
        help = "";
        std::getline(in, help, '\t');
        dset.nnscalez = std::stof(help);
        help = "";
        std::getline(in, help, '\t');
        dset.nnrawz = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.nnscaletheta = std::stof(help);
        help = "";
        std::getline(in, help, '\t');
        dset.nnrawtheta = std::stoi(help);
        help = "";
        std::getline(in, help, '\t');
        dset.inphi = std::stof(help);
        help = "";
        std::getline(in, help, '\t');
        dset.intheta = std::stof(help);
        help = "";
        std::getline(in, help, '\t');
        dset.ininvpt = std::stof(help);
        help = "";
        return in;
      }
    };

    CDCTriggerMLPData(): m_inputSamples(), m_targetSamples(), m_hitCounters(), m_trackCounter(0) { }
    ~CDCTriggerMLPData() { }

    void addCounters(unsigned nWires)
    {
      std::vector<unsigned short> counters;
      counters.assign(nWires, 0);
      m_hitCounters.push_back(counters);
    }

    void addHit(unsigned iSL, int iTS);
    void countTrack() { ++m_trackCounter; }
    //template<unsigned inLen, unsigned outLen>
    //void addSample(const NeuroSet<inLen, outLen>& dsample)
    void addSample(const NeuroSet& dsample)
    {
      //std::vector<float> in(dsample.input, dsample.input + sizeof dsample.input / sizeof dsample.input[0]);
      m_inputSamples.push_back(dsample.input);
      //std::vector<float> out(dsample.target, dsample.target + sizeof dsample.target / sizeof dsample.target[0]);
      m_targetSamples.push_back(dsample.target);
      m_expList.push_back(dsample.exp);
      m_runList.push_back(dsample.run);
      m_subRunList.push_back(dsample.subrun);
      m_evtList.push_back(dsample.evt);
      m_trackList.push_back(dsample.track);
 
    }

    void addSample(const std::vector<float>& input, const std::vector<float>& target, const int& expnumber, const int& runnumber,
                   const int& subrunnumber, const int& eventnumber, const int& tracknumber)
    {
      m_inputSamples.push_back(input);
      m_targetSamples.push_back(target);
      m_expList.push_back(expnumber);
      m_runList.push_back(runnumber);
      m_subRunList.push_back(subrunnumber);
      m_evtList.push_back(eventnumber);
      m_trackList.push_back(tracknumber);
    }

    short getTrackCounter() const { return m_trackCounter; }
    unsigned short getHitCounter(unsigned iSL, int iTS) const;
    unsigned nSamples() const { return m_targetSamples.size(); }
    const std::vector<float>& getInput(unsigned i) const { return m_inputSamples[i]; }
    const std::vector<float>& getTarget(unsigned i) const { return m_targetSamples[i]; }
    const std::vector<int>& getevtList() const { return getEvtList(); }
    const std::vector<int>& getEvtList() const { return m_evtList; }
    const std::vector<int>& getExpList() const { return m_expList; }
    const std::vector<int>& getRunList() const { return m_runList; }
    const std::vector<int>& getSubRunList() const { return m_subRunList; }
    const std::vector<int>& getTrackList() const { return m_trackList; }
    const int& getevtnum(unsigned i) const { return m_evtList[i]; }
  private:
    std::vector<std::vector<float>> m_inputSamples;
    std::vector<std::vector<float>> m_targetSamples;
    std::vector<std::vector<unsigned short>> m_hitCounters;
    short m_trackCounter;
    std::vector<int> m_expList;
    std::vector<int> m_runList;
    std::vector<int> m_subRunList;
    std::vector<int> m_evtList;
    std::vector<int> m_trackList;

    ClassDef(CDCTriggerMLPData, 5);
  };

}
#endif