outputhandler.h

Go to the documentation of this file.

#ifndef DOPE_OUTPUT_HANDLER_H_
#define DOPE_OUTPUT_HANDLER_H_

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <sstream>
#include <deal.II/lac/vector.h>

#include "optproblemcontainer.h"
#include "controlvector.h"
#include "parameterreader.h"

namespace DOpE
{
//Predeclaration necessary
template<typename VECTOR> class ReducedProblemInterface_Base;

template<typename VECTOR>
class DOpEOutputHandler
{
  public:

    DOpEOutputHandler(ReducedProblemInterface_Base<VECTOR>* SI, ParameterReader &param_reader);
    ~DOpEOutputHandler();

    static void declare_params(ParameterReader &param_reader);

    void WriteAux(std::string msg, std::string file, bool append=true);

    void Write(std::string msg, int priority = 20, unsigned int pre_newlines = 0,
               unsigned int post_newlines = 0);
    void Write(std::stringstream& msg, int priority = 20, unsigned int pre_newlines = 0,
               unsigned int post_newlines = 0);
    void Write(const VECTOR&q, std::string name, std::string dof_type);

    void
    WriteElementwise(const Vector<double>&q, std::string name,
        std::string dof_type);

    void Write(const ControlVector<VECTOR>& q, std::string name, std::string dof_type);
    //    /**
    //     * same as above for ControlVector<dealii::Vector<double> >
    //     *
    //     */
    //    void Write(const ControlVector<dealii::Vector<double> >& q, std::string name, std::string dof_type);
    void Write(const std::vector<double>& q, std::string name, std::string dof_type);
    void WriteError(std::string msg);
    void SetIterationNumber(unsigned int iteration, std::string type);
    void ReInit();
    std::string ZeroTolerance(double value, double reference_value);
    void InitNewtonOut(std::stringstream& msg);
    void InitOut(std::stringstream& msg);

    void DisallowAllOutput() { disallow_all_ = true; };
    void ResumeOutput() { disallow_all_ = false; }

    std::string
    ConstructOutputName(std::string name, std::string dof_type);

    void StartSaveCTypeOutputToLog();
    void StopSaveCTypeOutputToLog();

    std::string GetResultsDir() const;

  protected:
    std::map<std::string, unsigned int>::const_iterator ReorderAndInsert(std::string type);
    std::string GetPostIndex();
    ReducedProblemInterface_Base<VECTOR>* GetReducedProblem()
    {
      if(NULL != Solver_)
        return Solver_;
      else
      {
        abort();
      }
    }

    bool AllowWrite(std::string name);
    bool AllowIteration(std::string name);
    void ParseString(const std::string tmp, std::vector<std::string>& list);

  private:
    std::map<std::string, unsigned int> iteration_type_pos_;
    std::vector<unsigned int> iteration_number_;
    int printlevel_;
    std::string results_basedir_, results_outdir_, ending_, control_ending_, logfile_;
    ReducedProblemInterface_Base<VECTOR>* Solver_;
    unsigned int n_reinits_;
    bool debug_;
    unsigned int number_precision_;
    unsigned int functional_number_precision_;
    double user_eps_machine_;
    bool disallow_all_;

    std::vector<std::string> never_write_list;
    std::vector<std::string> ignore_iterations;

    std::ofstream log_;

    fpos_t std_out_pos_;
    int    stdout_backup_; 

    void PrintCopyrightNotice();

};

}
#endif