composite_conv_check.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Markus Breit
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__LIB_DISC__OPERATOR__COMPOSITE_CONVERGENCE_CHECK__
#define __H__LIB_DISC__OPERATOR__COMPOSITE_CONVERGENCE_CHECK__
 
#include <ostream>
#include <sstream>
#include <string>
#include <limits>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <list>
#include <math.h>
 
#include "common/common.h"
#include "common/stopwatch.h"
#include "lib_algebra/operator/convergence_check.h"
#include "lib_disc/dof_manager/dof_distribution.h"
#include "lib_disc/function_spaces/approximation_space.h"
#include "lib_disc/common/function_group.h"
 
namespace ug{
 
// Composite convergence check
 
template <class TVector, class TDomain>
class CompositeConvCheck : public IConvergenceCheck<TVector>
{
  public:
    CompositeConvCheck(SmartPtr<ApproximationSpace<TDomain> > approx);
    CompositeConvCheck(SmartPtr<ApproximationSpace<TDomain> > spApproxSpace,
                       int maxSteps, number minDefect, number relReduction);
 
    virtual ~CompositeConvCheck() {};
 
    void set_level(int level);
 
    void set_maximum_steps(int maxSteps) {m_maxSteps = maxSteps;}
 
    void set_rest_check(number minDefect, number relReduction){
      m_bCheckRest = true;
      m_restMinDefect = minDefect; m_restRelReduction = relReduction;
      update_rest_check();
    }
 
    void disable_rest_check(){m_bCheckRest = false; update_rest_check();}
 
    void set_component_check(const std::string& vFctName,
                             const std::vector<number>& vMinDefect,
                             const std::vector<number>& vRelReduction);
 
    void set_component_check(const std::vector<std::string>& vFctName,
                             const std::vector<number>& vMinDefect,
                             const std::vector<number>& vRelReduction);
 
    void set_component_check(const std::vector<std::string>& vFctName,
                 const number minDefect,
                 const number relReduction);
 
    void set_component_check(const std::string& fctName,
                 const number minDefect,
                 const number relReduction);
 
    void set_all_component_check(const number minDefect,
                                 const number relReduction);
 
    void set_group_check(const std::vector<std::string>& vFctName,
               const number minDefect,
               const number relReduction);
 
    void set_group_check(const std::string& fctNames,
               const number minDefect,
               const number relReduction);
 
    void start_defect(number initialDefect);
    void start(const TVector& d);
    void update_defect(number newDefect);
    void update(const TVector& d);
    bool iteration_ended();
    bool post();
 
    int step() const {return m_currentStep;}
    number defect() const {return defect_all();};
    number reduction() const {return defect_all()/initial_defect_all();};
    number rate() const {return defect_all()/last_defect_all();}
    number avg_rate() const {return std::pow(defect_all()/initial_defect_all(), 1.0/m_currentStep);}
 
    int get_offset() const {return m_offset;};
    void set_offset(int offset){m_offset = offset;};
    void set_symbol(char symbol){m_symbol = symbol;};
    void set_name(std::string name) {m_name = name;};
    void set_info(std::string info) {m_info = info;};
 
    void set_verbose(bool level) {m_verbose = level;};
 
    void set_supress_unsuccessful(bool bsupress) {m_supress_unsuccessful = bsupress;}
 
    void set_time_measurement(bool yesOrNo) {m_bTimeMeas = yesOrNo;};
 
    void set_adaptive(bool adapt) {m_bAdaptive = adapt;}
 
    virtual SmartPtr<IConvergenceCheck<TVector> > clone();
 
    void print_line(std::string line);
 
    virtual std::string config_string() const
    {
      std::stringstream ss;
      ss << "CompositeConvCheck( max steps = " << m_maxSteps << ")";
      ss << " Components:\n";
      for(size_t i=0; i<m_CmpInfo.size(); i++)
        ss << " | " << m_CmpInfo[i].config_string() << "\n";
      return ss.str();
    }
 
  protected:
    void print_offset();
    bool is_valid_number(number value);
    const std::string& fctName(size_t i) {return m_CmpInfo[i].name;};
 
    template <typename TBaseElem>
    void extract_dof_indices(ConstSmartPtr<DoFDistribution> dd);
 
    void extract_dof_indices(ConstSmartPtr<DoFDistribution> dd);
 
    number norm(const TVector& vec, const std::vector<DoFIndex>& index);
 
  protected:
    SmartPtr<ApproximationSpace<TDomain> > m_spApprox;
 
    struct NativCmpInfo{
      std::string name;   
 
      number initDefect;  
      number currDefect;  
      number lastDefect;  
 
      std::vector<DoFIndex> vMultiIndex; 
    };
 
    std::vector<NativCmpInfo> m_vNativCmpInfo;
    size_t m_numAllDoFs;
 
    number defect_all() const {
      number defect = 0.0;
      for(size_t fct = 0; fct < m_vNativCmpInfo.size(); ++fct)
        defect += pow(m_vNativCmpInfo[fct].currDefect, 2);
      return sqrt(defect);
    }
 
    number last_defect_all() const {
      number defect = 0.0;
      for(size_t fct = 0; fct < m_vNativCmpInfo.size(); ++fct)
        defect += pow(m_vNativCmpInfo[fct].lastDefect, 2);
      return sqrt(defect);
    }
 
    number initial_defect_all() const {
      number defect = 0.0;
      for(size_t fct = 0; fct < m_vNativCmpInfo.size(); ++fct)
        defect += pow(m_vNativCmpInfo[fct].initDefect, 2);
      return sqrt(defect);
    }
 
  protected:
    struct CmpInfo
    {
      CmpInfo() : isRest(false) {}
 
      std::vector<int> vFct;  
      std::string name;     
 
      number initDefect;  
      number currDefect;  
      number lastDefect;  
 
      number minDefect; 
      number relReduction;
 
      bool isRest;  
 
      std::string config_string() const
      {
        std::stringstream ss;
        if(isRest) ss << "[Remaining Components]";
        else ss << "Component " << name;
        ss << ": minDefect = " << minDefect << ", relReduction = " << relReduction;
        return ss.str();
      }
 
    };
 
    std::vector<CmpInfo> m_CmpInfo;
 
    bool m_bCheckRest;
    number m_restMinDefect;
    number m_restRelReduction;
    void update_rest_check();
 
    int m_currentStep;
 
    int m_maxSteps;
 
  protected:
    bool m_verbose;
 
    bool m_supress_unsuccessful;
 
    int m_offset;
 
    char m_symbol;
 
    std::string m_name;
 
    std::string m_info;
 
  protected:
    bool m_bTimeMeas;
 
    Stopwatch m_stopwatch;
 
    // TODO: maybe solve this using an adaption/distribution event listener
    bool m_bAdaptive;
};
 
} // end namespace ug
 
#include "composite_conv_check_impl.h"
 
#endif /* __H__LIB_DISC__OPERATOR__COMPOSITE_CONVERGENCE_CHECK__ */