physics.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// GRINS - General Reacting Incompressible Navier-Stokes
//
// Copyright (C) 2014-2017 Paul T. Bauman, Roy H. Stogner
// Copyright (C) 2010-2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// This library 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.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-

#ifndef GRINS_PHYSICS_H
#define GRINS_PHYSICS_H

// C++
#include <string>
#include <set>

//GRINS
#include "grins_config.h"
#include "grins/variable_name_defaults.h"
#include "grins/var_typedefs.h"
#include "grins/physics_naming.h"
#include "grins/cached_values.h"
#include "grins/parameter_user.h"
#include "grins/assembly_context.h"

//libMesh
#include "libmesh/libmesh.h"
#include "libmesh/point.h"
#include "libmesh/fe_base.h"
#include "libmesh/system.h"
#include "libmesh/mesh_base.h"
#include "libmesh/auto_ptr.h"

// libMesh forward declarations
class GetPot;
namespace libMesh
{
  template <typename Scalar>
  class CompositeFunction;

  class FEMSystem;
  class Elem;

  template <typename Scalar>
  class ParameterMultiAccessor;
}

namespace GRINS
{
  // GRINS forward declarations
  class BCHandlingBase;
  class ICHandlingBase;
  class NBCContainer;
  class DBCContainer;
  class MultiphysicsSystem;
  class FEVariablesBase;

  template <typename Scalar>
  class PostProcessedQuantities;


  //TODO: is it F(u) or F(u_{\theta})?

  //  element* routines work on element interiors
  //  side* routines work on element sides

  //  *_time_derivative correspond to calculating terms for F(u)
  //  *_mass_residual correspond to calculating terms for M(u)\dot{u}

  class Physics : public ParameterUser
  {

  public:

    Physics( const GRINS::PhysicsName& physics_name, const GetPot& input );
    virtual ~Physics();

    virtual void init_variables( libMesh::FEMSystem* /*system*/ ){};

    virtual bool enabled_on_elem( const libMesh::Elem* elem );


    void set_is_steady( bool is_steady );

    bool is_steady() const;

    static void set_is_axisymmetric( bool is_axisymmetric )
    { _is_axisymmetric = is_axisymmetric; }

    static bool is_axisymmetric()
    { return _is_axisymmetric; }


    virtual void set_time_evolving_vars( libMesh::FEMSystem* system );


    virtual void auxiliary_init( MultiphysicsSystem& system );


    virtual void register_postprocessing_vars( const GetPot& input,
                                               PostProcessedQuantities<libMesh::Real>& postprocessing );

    virtual void init_context( AssemblyContext& context );

    virtual void preassembly( MultiphysicsSystem & /*system*/ ){};


    virtual void reinit( MultiphysicsSystem & /*system*/ ){};

    // residual and jacobian calculations
    // element_*, side_* as *time_derivative, *constraint, *mass_residual

    virtual void element_time_derivative( bool /*compute_jacobian*/,
                                          AssemblyContext & /*context*/ ){}

    virtual void side_time_derivative( bool /*compute_jacobian*/,
                                       AssemblyContext & /*context*/ ){}

    virtual void nonlocal_time_derivative( bool /*compute_jacobian*/,
                                           AssemblyContext & /*context*/ ){}

    virtual void element_constraint( bool /*compute_jacobian*/,
                                     AssemblyContext & /*context*/ ){}

    virtual void side_constraint( bool /*compute_jacobian*/,
                                  AssemblyContext & /*context*/ ){}

    virtual void nonlocal_constraint( bool /*compute_jacobian*/,
                                      AssemblyContext & /*context*/ ){}

    virtual void damping_residual( bool /*compute_jacobian*/,
                                   AssemblyContext & /*context*/ ){}

    virtual void mass_residual( bool /*compute_jacobian*/,
                                AssemblyContext & /*context*/ ){}

    virtual void nonlocal_mass_residual( bool /*compute_jacobian*/,
                                         AssemblyContext & /*context*/ ){}

    void init_ics( libMesh::FEMSystem* system,
                   libMesh::CompositeFunction<libMesh::Number>& all_ics );

    virtual void compute_element_time_derivative_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_side_time_derivative_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_nonlocal_time_derivative_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_element_constraint_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_side_constraint_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_nonlocal_constraint_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_damping_residual_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_mass_residual_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_nonlocal_mass_residual_cache( AssemblyContext & /*context*/ ){}

    virtual void compute_postprocessed_quantity( unsigned int quantity_index,
                                                 const AssemblyContext& context,
                                                 const libMesh::Point& point,
                                                 libMesh::Real& value );

    ICHandlingBase* get_ic_handler();

  protected:

    libMesh::UniquePtr<libMesh::FEGenericBase<libMesh::Real> > build_new_fe( const libMesh::Elem* elem,
                                                                             const libMesh::FEGenericBase<libMesh::Real>* fe,
                                                                             const libMesh::Point p );

    void parse_enabled_subdomains( const GetPot& input,
                                   const std::string& physics_name );

    void check_var_subdomain_consistency( const FEVariablesBase& var ) const;


    const PhysicsName _physics_name;

    GRINS::ICHandlingBase* _ic_handler;

    std::set<libMesh::subdomain_id_type> _enabled_subdomains;


    static bool _is_steady;

    static bool _is_axisymmetric;

  private:
    Physics();

  }; // End Physics class declarations

  /* ------------------------- Inline Functions -------------------------*/
  inline
  ICHandlingBase* Physics::get_ic_handler()
  {
    return _ic_handler;
  }

} // End namespace GRINS

#endif //GRINS_PHYSICS_H