timestep_control.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//    $Id: timestep_control.h 1348 2013-08-16 00:45:07Z secanell $
//
//    Copyright (C) 2006, 2007 by Guido Kanschat
//
//    This file is subject to QPL and may not be  distributed
//    without copyright and license information. Please refer
//    to the file deal.II/doc/license.html for the  text  and
//    further information on this license.
//
//---------------------------------------------------------------------------

#ifndef __deal2__appframe__timestep_control_h
#define __deal2__appframe__timestep_control_h

#include <base/subscriptor.h>
#include <base/smartpointer.h>
#include <lac/vector_memory.h>
#include <cstdio>


using namespace dealii;

namespace dealii
{
  class ParameterHandler;
}

namespace AppFrame
{
class TimestepControl : public Subscriptor
{
  public:
    enum Strategy
    {
          uniform,
          doubling,
          
          inner_residual
    };

    TimestepControl (double start = 0.,
                     double final = 1.,
                     double tolerance = 1.e-2,
                     double start_step = 1.e-2,
                     double print_step = -1.,
                     bool autonomous = false);
    
    static void declare_parameters (ParameterHandler& param);
    void parse_parameters (ParameterHandler& param);

    double start () const;
    double final () const;
    double tolerance () const;
    double step () const;
    double now () const;
    double next (const double indicator);

    bool autonomous () const;

    void start (double);
    void final (double);
    void tolerance (double);
    void strategy (Strategy);
    
    void start_step (double);
    
    void max_step (double);
    
    void autonomous (bool);

    void restart ();
    bool print ();
    void file_name_format (const char*);
    const char* file_name_format ();
  private:
    
    double start_val;
    double final_val;
    double tolerance_val;
    Strategy strategy_val;
    double start_step_val;
    double max_step_val;
    double min_step_val;
    double current_step_val;
    double step_val;
    bool is_autonomous;
    
    double now_val;
    double print_step;
    double next_print_val;
    
    char format[30];
};


inline double
TimestepControl::start () const
{
  return start_val;
}


inline double
TimestepControl::final () const
{
  return final_val;
}


inline double
TimestepControl::step () const
{
  return current_step_val;
}


inline double
TimestepControl::tolerance () const
{
  return tolerance_val;
}


inline double
TimestepControl::now () const
{
  return now_val;
}


inline void
TimestepControl::start (double t)
{
  start_val = t;
}


inline void
TimestepControl::final (double t)
{
  final_val = t;
}


inline void
TimestepControl::tolerance (double t)
{
  tolerance_val = t;
}


inline void
TimestepControl::strategy (Strategy t)
{
  strategy_val = t;
}


inline void
TimestepControl::start_step (double t)
{
  start_step_val = t;
}


inline void
TimestepControl::max_step (double t)
{
  max_step_val = t;
}


inline void
TimestepControl::restart ()
{
  now_val = start_val;
  step_val = (strategy_val == uniform)
             ? tolerance_val
             : start_step_val;
  current_step_val = step_val;
  if (print_step > 0.)
    next_print_val = now_val + print_step;
  else
    next_print_val = now_val - 1.;
}


inline void
TimestepControl::file_name_format (const char* fmt)
{
  strcpy(format, fmt);
}


inline const char*
TimestepControl::file_name_format ()
{
  return format;
}


inline bool
TimestepControl::autonomous () const
{
  return is_autonomous;
}


inline void
TimestepControl::autonomous (bool b)
{
  is_autonomous = b;
}
 
}

#endif