domain_disc_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Andreas Vogel
 * 
 * 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__UG__LIB_DISC__SPATIAL_DISC__DOMAIN_DISC_INTERFACE__
#define __H__UG__LIB_DISC__SPATIAL_DISC__DOMAIN_DISC_INTERFACE__
 
#include "lib_algebra/cpu_algebra_types.h"
#include "lib_disc/assemble_interface.h"
#include "lib_disc/time_disc/solution_time_series.h"
#include "lib_disc/spatial_disc/constraints/constraint_interface.h"
#include "lib_grid/refinement/refiner_interface.h"
#include "lib_disc/function_spaces/error_elem_marking_strategy.h"
 
namespace ug {
 
 
template <typename TAlgebra>
class IDomainErrorIndicator
{
public:
  typedef typename TAlgebra::vector_type vector_type;
 
  typedef typename CPUAlgebra::vector_type error_vector_type;
 
  // (virtual) destructor
  virtual ~IDomainErrorIndicator() {};
 
      virtual void calc_error
      ( const vector_type& u,
        const GridLevel& gl,
        error_vector_type* u_vtk = NULL
      ) = 0;
      virtual void calc_error
      ( const vector_type& u,
        ConstSmartPtr<DoFDistribution> dd,
        error_vector_type* u_vtk = NULL
      ) = 0;
 
      virtual void calc_error
      ( ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
        ConstSmartPtr<DoFDistribution> dd,
        const std::vector<number>& vScaleMass,
        const std::vector<number>& vScaleStiff,
        error_vector_type* u_vtk
      ) = 0;
 
      virtual void calc_error
      ( ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
        const std::vector<number>& vScaleMass,
        const std::vector<number>& vScaleStiff,
        const GridLevel& gl,
        error_vector_type* u_vtk
      ) = 0;
 
  virtual void invalidate_error() = 0;
 
  virtual bool is_error_valid() = 0;
};
class IDomainErrorIndicator {…};
 
template <typename TDomain>
class IDomainMarker
{
public:
  typedef IElementMarkingStrategy<TDomain> element_marking_strategy_type;
 
  // (virtual) destructor
  virtual ~IDomainMarker() {};
 
  virtual void mark_with_strategy
  ( IRefiner& refiner,
    SmartPtr<element_marking_strategy_type> spMarkingStrategy
  ) = 0 ;
};
class IDomainMarker {…};
 
 
template <typename TAlgebra>
class IDomainDiscretization : public IAssemble<TAlgebra>, public IDomainErrorIndicator<TAlgebra>
{
  using IAssemble<TAlgebra>::assemble_rhs;
  
  public:
    typedef TAlgebra algebra_type;
 
    typedef typename algebra_type::matrix_type matrix_type;
 
    typedef typename algebra_type::vector_type vector_type;
    virtual ~IDomainDiscretization() {};
 
  public:
 
    virtual void assemble_jacobian(matrix_type& J, const vector_type& u, const GridLevel& gl) = 0;
    virtual void assemble_jacobian(matrix_type& J, const vector_type& u, ConstSmartPtr<DoFDistribution> dd) = 0;
 
 
    virtual void assemble_defect(vector_type& d, const vector_type& u, const GridLevel& gl) = 0;
    virtual void assemble_defect(vector_type& d, const vector_type& u, ConstSmartPtr<DoFDistribution> dd) = 0;
 
 
    virtual void assemble_linear(matrix_type& A, vector_type& b, const GridLevel& gl) = 0;
    virtual void assemble_linear(matrix_type& A, vector_type& b, ConstSmartPtr<DoFDistribution> dd) = 0;
 
    virtual void assemble_rhs(vector_type& rhs, const vector_type& u, const GridLevel& gl) = 0;
    virtual void assemble_rhs(vector_type& rhs, const vector_type& u, ConstSmartPtr<DoFDistribution> dd) = 0;
 
    virtual void assemble_rhs(vector_type& b, const GridLevel& gl) = 0;
    virtual void assemble_rhs(vector_type& b, ConstSmartPtr<DoFDistribution> dd) = 0;
 
 
    virtual void adjust_solution(vector_type& u, const GridLevel& gl) = 0;
    virtual void adjust_solution(vector_type& u, ConstSmartPtr<DoFDistribution> dd) = 0;
 
    virtual void assemble_mass_matrix(matrix_type& M, const vector_type& u, const GridLevel& gl) = 0;
    virtual void assemble_mass_matrix(matrix_type& M, const vector_type& u, ConstSmartPtr<DoFDistribution> dd) = 0;
 
    virtual void assemble_stiffness_matrix(matrix_type& A, const vector_type& u, const GridLevel& gl) = 0;
    virtual void assemble_stiffness_matrix(matrix_type& A, const vector_type& u, ConstSmartPtr<DoFDistribution> dd) = 0;
 
 
  public:
 
    virtual void prepare_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, number future_time, ConstSmartPtr<DoFDistribution> dd) = 0;
    virtual void prepare_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, number future_time, const GridLevel& gl) = 0;
    virtual void prepare_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, number future_time)
    {prepare_timestep(vSol, future_time, GridLevel());}
    virtual void prepare_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, number future_time) {…}
 
 
    virtual void prepare_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, ConstSmartPtr<DoFDistribution> dd) = 0;
    virtual void prepare_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, const GridLevel& gl) = 0;
 
    void prepare_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol)
    {prepare_timestep_elem(vSol, GridLevel());}
    void prepare_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol) {…}
 
 
    virtual void assemble_jacobian(matrix_type& J,
                                   ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                                   const number s_a, const GridLevel& gl) = 0;
    virtual void assemble_jacobian(matrix_type& J,
                                   ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                                   const number s_a0,
                                   ConstSmartPtr<DoFDistribution> dd) = 0;
 
    void assemble_jacobian(matrix_type& J,
                           ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                           const number s_a)
    {assemble_jacobian(J, vSol, s_a, GridLevel());}
    void assemble_jacobian(matrix_type& J, {…}
 
 
 
    virtual void assemble_defect(vector_type& d,
                                 ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                                 const std::vector<number>& vScaleMass,
                                 const std::vector<number>& vScaleStiff,
                                 const GridLevel& gl) = 0;
    virtual void assemble_defect(vector_type& d,
                                 ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                                 const std::vector<number>& vScaleMass,
                                 const std::vector<number>& vScaleStiff,
                                 ConstSmartPtr<DoFDistribution> dd) = 0;
 
    void assemble_defect(vector_type& d,
                         ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                         const std::vector<number>& vScaleMass,
                         const std::vector<number>& vScaleStiff)
    {assemble_defect(d, vSol, vScaleMass, vScaleStiff, GridLevel());}
    void assemble_defect(vector_type& d, {…}
 
 
    virtual void assemble_linear(matrix_type& A, vector_type& b,
                                 ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                                 const std::vector<number>& vScaleMass,
                                 const std::vector<number>& vScaleStiff,
                                 const GridLevel& gl) = 0;
    virtual void assemble_linear(matrix_type& A, vector_type& b,
                   ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                   const std::vector<number>& vScaleMass,
                   const std::vector<number>& vScaleStiff,
                   ConstSmartPtr<DoFDistribution> dd) = 0;
 
    void assemble_linear(matrix_type& A, vector_type& b,
                         ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                         const std::vector<number>& vScaleMass,
                         const std::vector<number>& vScaleStiff)
    {assemble_linear(A,b,vSol,vScaleMass,vScaleStiff, GridLevel());}
    void assemble_linear(matrix_type& A, vector_type& b, {…}
 
 
    virtual void assemble_rhs(   vector_type& b,
                   ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                   const std::vector<number>& vScaleMass,
                   const std::vector<number>& vScaleStiff,
                   const GridLevel& gl) = 0;
    virtual void assemble_rhs(   vector_type& b,
                   ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
                   const std::vector<number>& vScaleMass,
                   const std::vector<number>& vScaleStiff,
                   ConstSmartPtr<DoFDistribution> dd) = 0;
 
    void assemble_rhs(vector_type& b,
               ConstSmartPtr<VectorTimeSeries<vector_type> > vSol,
               const std::vector<number>& vScaleMass,
               const std::vector<number>& vScaleStiff)
    {assemble_rhs(b,vSol,vScaleMass,vScaleStiff, GridLevel());}
    void assemble_rhs(vector_type& b, {…}
 
 
 
    virtual void adjust_solution(vector_type& u, number time, const GridLevel& gl) = 0;
    virtual void adjust_solution(vector_type& u, number time, ConstSmartPtr<DoFDistribution> dd) = 0;
 
    void adjust_solution(vector_type& u, number time)
    {adjust_solution(u,time, GridLevel());}
    void adjust_solution(vector_type& u, number time) {…}
 
 
    virtual void finish_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, ConstSmartPtr<DoFDistribution> dd) = 0;
    virtual void finish_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, const GridLevel& gl) = 0;
    virtual void finish_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol)
    {finish_timestep(vSol, GridLevel());}
    virtual void finish_timestep(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol) {…}
 
 
    virtual void finish_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, const GridLevel& gl) = 0;
    virtual void finish_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol, ConstSmartPtr<DoFDistribution> dd) = 0;
 
    void finish_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol)
      {finish_timestep_elem(vSol, GridLevel());}
    void finish_timestep_elem(ConstSmartPtr<VectorTimeSeries<vector_type> > vSol) {…}
 
 
 
 
    virtual size_t num_constraints() const = 0;
 
    virtual SmartPtr<IConstraint<TAlgebra> > constraint(size_t i) = 0;
};
class IDomainDiscretization : public IAssemble<TAlgebra>, public IDomainErrorIndicator<TAlgebra> {…};
 
 
}; // namespace ug
 
#endif /* __H__UG__LIB_DISC__SPATIAL_DISC__DOMAIN_DISC_INTERFACE__ */