Interface.h

Go to the documentation of this file.

#ifndef INTERFACE_HEADER
#define INTERFACE_HEADER

#include <cstdarg>
#include <errno.h>
#include <fstream.h>
#include <iomanip.h>
#include <iostream.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>

#include "TChain.h"
#include "TFile.h"
#include "TGraph.h"
#include "TH1F.h"
#include "TLeaf.h"
#include "TObjArray.h"
#include "TTree.h"
#include "TTreeFormula.h"

#include "Pattern.h"
#include "PatternManager.h"
#include "SnnsKrui.h"
#include "TVariable.h"

extern Int_t errno;

class Interface : public SnnsKrui, public PatternManager {

protected:

  std::vector<TVariable>  fInputVariables;
  std::vector<TVariable>  fTargetVariables;
  std::string             _pathto_ff_bignet;
  std::string             fNetFilePrefix;
  std::string             fNetFileSuffix;
  std::string             fNetName;
  std::string             fTreeName;
  std::string             fDirName;
  std::string             fSelection;
  TObjArray              *fInputTrees;
  TFile                  *fOutFile;
  TTree                  *fMasterTree;
  TTree                  *fPatternTree;
  TTree                  *fPerformaceTree;
  Bool_t                  fWriteMasterTree;
  Bool_t                  fWritePerformanceTree;
  Bool_t                  fWritePatternTree;
  Bool_t                  fWriteErrorHistograms;
  Bool_t                  fBannerPrinted;
  Int_t                   fMaxEpochs;
  Int_t                   fUpdEpochs;
  Double_t                averageValidError;
  Double_t                minimumValidError;
  Int_t                   minimumValidErrorEpoch;
  Double_t                RMSTestError;
  Int_t                   hiddenLayerSize;
  Int_t                   fRandomSeed;

public:

  Interface();
  Interface(std::string trName, std::string dirName, std::string fileName);
  ~Interface();

  //inline const char* GetName() const { return "Interface"; }
  inline void         SetInputVariableAt(Int_t index, TVariable var);
  inline void         SetTargetVariableAt(Int_t index, TVariable var);
  inline TVariable&   GetInputVariable(Int_t index);
  inline TVariable&   GetTargetVariable(Int_t index);
  inline std::string  getTreeName() const { return fTreeName; }
  inline std::string  getNetName() { return fNetName; }
  inline TFile       *GetOutFile() { return fOutFile; }

  inline Double_t     getAverageValidError() const { return averageValidError; }
  inline Double_t     getMinimumValidError() const { return minimumValidError; }
  inline Int_t        getMinimumValidErrorEpoch() const { return minimumValidErrorEpoch; }

  inline void         SetMaximumEpochs(Int_t i);
  inline void         SetUpdateEpochs(Int_t i);

  inline void         setTreeName(std::string name) { fTreeName = name; }
  inline void         setNetName(std::string name) { fNetName = name; }
  inline void         setOutDirectory(std::string name) { fDirName = name; }
  inline void         WriteMasterTree(Bool_t flag);
  inline void         WritePerformanceTree(Bool_t flag);
  inline void         WritePatternTree(Bool_t flag);
  inline void         WriteErrorHistograms(Bool_t flag);
  inline Bool_t       WriteMasterTree();
  inline Bool_t       WritePerformanceTree();
  inline Bool_t       WritePatternTree();
  inline Bool_t       WriteErrorHistograms();
  inline void         setMinimumValidError(Double_t value) { minimumValidError = value; }

  Int_t        PrintVariables();
  void         AddInputVariable(TString formula, TString name,
                  Double_t defValue = 0.0);
  void         AddInputVariable(TString formula, Double_t defValue = 0.0);
  void         AddTargetVariable(TString formula, TString name,
                  Double_t defValue = 0.0);
  void         AddTargetVariable(TString formula, Double_t defValue = 0.0);
  Int_t        AllocatePatternSet(std::string type = "");
  void         SetSelection(std::string selection = "");
  void         FillPatternSet(std::string fileName, Int_t startEvent=0,
                  Int_t nOfEvents=-1, std::string type="");
  void         savePatternSets();
  std::string  runtimeInput2string();
  std::string  CreateNN(std::vector<Int_t> numHiddenNodes);
  void         InitializeNN(std::vector<Float_t> initParams = 0,
                  std::string initFunc = "Randomize_Weights",
                  Int_t randomSeed = 12345);
  void         TrainValidate(std::string trainType, std::string validType,
                  std::vector<Double_t> learnParams);
  void         TrainValidateApply(std::string trainType, std::string validType,
                  std::vector<Double_t> learnParams, std::string genErrType);
  void         PropagatePatterns(std::string type = "");
  void         ActivateInputs(Pattern pattern);
  void         FillPerformanceTree();
  void         CalculateError(std::string type);
  Int_t        AllocNewPatternSet();
  void         LoadNN();
  void         LoadNN(char *filename, char **netname);
  void         SaveNN(char *filename, char *netname);
  void         SetSeedNo(long seed);
  void         SetLearnFunc(char *learning_func);
  char        *GetLearnFunc();
  void         Finalize();
  void         PrintProgress(Int_t i, Int_t iMax);
  Int_t        Timer(Int_t i);
  std::string  TimeStoHMS(UInt_t diffTime);

  ClassDef(Interface, 1)
};

inline void Interface::SetInputVariableAt(Int_t index, TVariable var)
{
   fInputVariables[index] = var;
}

inline void Interface::SetTargetVariableAt(Int_t index, TVariable var)
{
   fTargetVariables[index] = var;
}

inline TVariable& Interface::GetInputVariable(Int_t index)
{
   return fInputVariables[index];
}

inline TVariable& Interface::GetTargetVariable(Int_t index)
{
   return  fTargetVariables[index];
}

inline void Interface::SetMaximumEpochs(Int_t i) {
   (i > 0) ? fMaxEpochs = i : fMaxEpochs = 500;
}

inline void Interface::SetUpdateEpochs(Int_t i) {
   (i > 0) ? fUpdEpochs = i : fUpdEpochs = 50;
}

inline void Interface::WriteMasterTree(Bool_t flag)
{
   fWriteMasterTree = flag;
}

inline Bool_t Interface::WriteMasterTree()
{
   return fWriteMasterTree;
}

inline void Interface::WritePerformanceTree(Bool_t flag)
{
   fWritePerformanceTree = flag;
}

inline Bool_t Interface::WritePerformanceTree()
{
   return fWritePerformanceTree;
}

inline void Interface::WritePatternTree(Bool_t flag)
{
   fWritePatternTree = flag;
}

inline Bool_t Interface::WritePatternTree()
{
   return fWritePatternTree;
}

inline void Interface::WriteErrorHistograms(Bool_t flag)
{
   fWriteErrorHistograms = flag;
}

inline Bool_t Interface::WriteErrorHistograms()
{
   return fWriteErrorHistograms;
}

#endif

---