AltNeuralNetI.cxx

Go to the documentation of this file.

// $Id: AltNeuralNetI.cxx,v 1.3 2003/12/09 12:08:25 costas Exp $
//
// AltNeuralNetI.cxx
//
//   -- Neural Net Input abstract base class
//   -- This is adapted for AltReco from my Neural Network Foundation Classes
//      (NNFC) package that I use for some of my Neural Net analyses.
//      NNFC is not intended to be part of the minos offline, so I just adapted
//      this single file here.
//
// Costas Andreopoulos <C.V.Andreopoulos@rl.ac.uk>
// CCLRC, Rutherford Appleton Laboratory
// July 01, 2003

#include<sstream>
#include<cassert>

#include "AltNeuralNetI.h"

#include "LeakChecker/Lea.h"
#include "MessageService/MsgService.h"

ClassImp(AltNeuralNetI)

//_______________________________________________________________________________
CVSID("$Id: AltNeuralNetI.cxx,v 1.3 2003/12/09 12:08:25 costas Exp $");
//_______________________________________________________________________________
AltNeuralNetI::AltNeuralNetI() :
TNamed()
{
  MSG("AltNeuralNet",Msg::kDebug) 
                       << "Begin of AltNeuralNetI::AltNeuralNetI() ctor" << endl;
  LEA_CTOR;
}
//_______________________________________________________________________________
AltNeuralNetI::AltNeuralNetI(const char * name, const char * title) :
TNamed(name, title)
{
  MSG("AltNeuralNet",Msg::kDebug) 
     << "Begin of AltNeuralNetI::AltNeuralNetI(const char *, const char * ) ctor" 
     << endl;

  fTitle = std::string(title);
      
  LEA_CTOR;
}
//_______________________________________________________________________________
AltNeuralNetI::AltNeuralNetI(const AltNeuralNetI & cneti):
TNamed(cneti.GetName(), cneti.GetTitle())
{
  MSG("AltNeuralNet",Msg::kDebug) 
     << "Begin of AltNeuralNetI::AltNeuralNetI(const AltNeuralNetI & cneto) ctor" 
     << endl;
         
  LEA_CTOR;
}
//_______________________________________________________________________________
AltNeuralNetI::~AltNeuralNetI()
{
  MSG("AltNeuralNet",Msg::kDebug) 
                      << "Begin of AltNeuralNetI::~AltNeuralNetI() dtor" << endl;
                           
  LEA_DTOR;
}
//_______________________________________________________________________________
void AltNeuralNetI::printI(const Option_t * opt) 
{
  MSG("AltNeuralNet",Msg::kVerbose) << "Printing Neural Net Pattern" << endl;
  std::string option(opt);
  
  std::map<std::string, double>::iterator input_iter;

  if( option.find("FULL") > 0 ) {                       
  
     for( input_iter = fSinglePattern.begin(); 
                             input_iter != fSinglePattern.end(); ++input_iter) {
                 
         MSG("AltNeuralNet",Msg::kVerbose)
           << (*input_iter).first << "..............." << (*input_iter).second 
           << endl;
     }
  
  } else {
       std::string values = "--> ";
       std::ostringstream o;
       
       for(input_iter = fSinglePattern.begin(); 
                             input_iter != fSinglePattern.end(); ++input_iter) {
                 
           o << (*input_iter).second;
           values.append( o.str() ); 
           values += " / ";              
       }
       MSG("AltNeuralNet",Msg::kVerbose) << values << endl;
  }  
}
//_______________________________________________________________________________  
void AltNeuralNetI::setInputVar(std::string varName, double varValue)
{
  assert( fSinglePattern.count(varName) == 1 );
  fSinglePattern[varName] = varValue;
}
//_______________________________________________________________________________
double AltNeuralNetI::getInputVar(std::string varName)
{
  assert( fSinglePattern.count(varName) == 1 );
  std::map<std::string, double>::iterator var = fSinglePattern.find(varName);
  return (*var).second;      
}
//_______________________________________________________________________________
double AltNeuralNetI::getTarget(void) const {  return fTarget; }
//_______________________________________________________________________________
void AltNeuralNetI::normalizeInputs(std::map<std::string, double> norm_consts)
{
// value --> norm_const * value;

  for(std::map<std::string, double>::iterator iterNorm = 
               norm_consts.begin(); iterNorm != norm_consts.end(); ++iterNorm) {
        
      assert( fSinglePattern.count( (*iterNorm).first ) == 1 );  
      //fSinglePattern[ (*iterNorm).first ) ] *= (*iterNorm).second;                    
  }
  
  if(! isWithinLimits() ) {
     MSG("AltNeuralNet",Msg::kWarning) 
                           << "Input pattern values not in [0,1] range" << endl;
     printI("FULL");     
  }
}
//_______________________________________________________________________________
void AltNeuralNetI::copyInputsToArray(float * inputs)
{
  int pos = 0;
  std::map<std::string, double>::iterator input_iter;

  for(input_iter = fSinglePattern.begin();
               input_iter != fSinglePattern.end(); ++input_iter) 
                                   inputs[pos++] = (float) (*input_iter).second;   
}
//_______________________________________________________________________________
void AltNeuralNetI::raiseSignalFlag(void) { fTarget = kSignal;}
//_______________________________________________________________________________
void AltNeuralNetI::raiseBackgroundFlag(void){  fTarget = kBackground;}
//_______________________________________________________________________________
bool AltNeuralNetI::isSignal(void) const { return fTarget == kSignal; }
//_______________________________________________________________________________
bool AltNeuralNetI::isBackground(void) const { return fTarget == kBackground; }
//_______________________________________________________________________________
bool AltNeuralNetI::isWithinLimits(void) 
{
  bool within_limits = true;
  
  for(std::map<std::string, double>::iterator input_iter = 
     fSinglePattern.begin(); input_iter != fSinglePattern.end(); ++input_iter) {
     
         within_limits = within_limits && ( (*input_iter).second >= 0. &&
                                            (*input_iter).second <= 1.  );
   }                         
  return within_limits;
}
//_______________________________________________________________________________
void AltNeuralNetI::resetPattern(void)
{
  for(std::map<std::string, double>::iterator iter = 
                fSinglePattern.begin(); iter != fSinglePattern.end(); ++iter) {
                       
      fSinglePattern.erase( (*iter).first );
  }  
  assert( fSinglePattern.size() == 0);
}
//_______________________________________________________________________________
void AltNeuralNetI::resetPatternValues(void)
{
  for(std::map<std::string, double>::iterator iter = 
       fSinglePattern.begin(); iter != fSinglePattern.end(); ++iter) 
                                                           (*iter).second = 0.0;
}
//_______________________________________________________________________________
int AltNeuralNetI::getNumberOfInputs(void) const {
                                           return (int) fSinglePattern.size(); }
//_______________________________________________________________________________
std::vector<std::string> AltNeuralNetI::getInputNames(void) 
{
  std::vector<std::string> names;
  std::map<std::string, double>::iterator input_iter;
  
  for(input_iter = fSinglePattern.begin();
                      input_iter != fSinglePattern.end(); ++input_iter)         
                                         names.push_back( (*input_iter).first );    
  return names;
}
//_______________________________________________________________________________
void AltNeuralNetI::initPattern(const std::string * var_names, const int n_vars)
{
  for(int ivar=0; ivar<n_vars; ivar++)
         fSinglePattern.insert(
                  std::map<std::string, double>::value_type(var_names[ivar],-1));
}
//_______________________________________________________________________________

---