algorithm_base.hh

Go to the documentation of this file.

#ifndef ALGORITHM_BASE_HH
#define ALGORITHM_BASE_HH
 
#include <vector>
#include <string>
#include <iostream>
 
namespace LQAction 
{
 
enum toDo {LogValue, Reset, Devalidate};
 
typedef enum toDo ToDo;
}
 
namespace Kaskade
{
  enum class RegularityTest {Failed, Passed};
  enum class AcceptanceTest {InitialGuess, FailedRecompute, Failed, NormalStepFailed, TangentialStepFailed, Passed, LeftAdmissibleDomain};
  enum class Convergence {Missed, Achieved};
 
 
template<typename T> 
class LoggedQuantity
{
public:
  void doAction(LQAction::ToDo td, std::string const& name_="noName")
  {
    switch(td)
    {
    case LQAction::LogValue : logValue(); break;
    case LQAction::Reset : reset(name_); break;
    case LQAction::Devalidate : devalidate(); break;
    default : assert(!"strange error in doAction");
    }
  }
 
  void reset(std::string const& name_) 
  { 
    logged=false; 
    valid=false; 
    name=name_; 
    logger.resize(0); 
    zero=0.0; 
  }
 
 
  LoggedQuantity(std::string const& name_) { reset(name_); }
  LoggedQuantity() { reset("noName");}
 
  void logValue() { 
    if(valid && !logged) logger.push_back(currentValue); 
    if(!valid) logger.resize(logger.size()+1);
    logged=true; 
  }
 
  void logValue(int i) { if(valid) logger[i]=currentValue; logged=true; }
 
  LoggedQuantity<T>& operator=(T const& rvalue) { currentValue=rvalue; logged=false; valid=true; return *this; }
 
  int size() {int sz= logger.size(); if(valid && !logged) sz++; return sz;}
 
  bool isValid() {return valid;}
 
  void devalidate() {valid=false;}
 
  bool isLogged() {return logged;}
 
  T const& operator[](int i) 
  { 
    if(i < logger.size() && i >= 0) return logger[i]; 
    if(i==logger.size() && valid && !logged) return currentValue; 
    namedAssertion(false,"Index failure!");
    return currentValue;
  }
 
  operator T&() { namedAssertion(valid,"TypeCast: operator T&()"); return currentValue;}
 
 
  T& value_nonconst() { valid = true;  namedAssertion(valid,"TypeCast: value_nonconst()"); return currentValue;}
 
  T const& value() const { namedAssertion(valid,"TypeCast: value()"); return currentValue;}
 
  void print(std::ostream& s)
  {
    s.setf(std::ios::scientific,std::ios::floatfield);
    s.precision(16);
    for(int i=0; i!=size(); i++)
      s << (*this)[i] << std::endl;
  }
 
private:
  std::vector<T> logger;
  T currentValue;
  bool logged;
  bool valid;
  std::string name;
  void namedAssertion(bool val,std::string caller) const
  { 
    if(!val) 
    {
      std::cout << name << " from " << caller << ":" << std::endl; 
      assert(0); 
    }
  }
  double zero;
};
 
//--------------------------------------------------
class IterationParameters
{
public:
  IterationParameters(double desiredAccuracy_, int maxSteps_)
    : desiredAccuracy(desiredAccuracy_), 
      maxSteps(maxSteps_)
  {
  }
 
//Parameters with values that must be supplied by client
  double desiredAccuracy;
  int maxSteps;
  int termination;
 
  virtual ~IterationParameters() {}
 
  void logStep() { 
    doForAll(LQAction::LogValue);
  }
  
  virtual void reset() {
    doForAll(LQAction::Reset);
  }
  
protected:
 
 
  virtual void doForAll(LQAction::ToDo td)
  {
  }
 
 
  friend class NewtonsMethod;
};
 
 
//-------------------------------------------------------------------------------------------
 
class AbstractFunctionSpaceElement;
 
class Algorithm
{
public:
    
  Algorithm() : report(0), measureTime(false) {}
  virtual ~Algorithm(){}
 
  void performTiming(bool doit) {measureTime=doit; }
  void reportOnIteration(int level) {report=level; }
 
protected:
  virtual void initialize(){};
  virtual void finalize(int){};
  virtual void terminationMessage(int);
  int algorithmWrapper();
  int oneStepWrapper();
 
  int report;
 
private:
  virtual int runAlgorithm()=0;
 
  bool measureTime;
};
 
}  // namespace Kaskade
 
#endif