physics.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// GRINS - General Reacting Incompressible Navier-Stokes
//
// Copyright (C) 2014-2016 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"

//libMesh
#include "libmesh/libmesh.h"
#include "libmesh/point.h"
#include "libmesh/fe_base.h"

// GRVY
#ifdef GRINS_HAVE_GRVY
#include "grvy.h" // GRVY timers
#endif

// 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 AssemblyContext;
  class MultiphysicsSystem;

  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 ) = 0;

    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 );

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

    virtual void element_time_derivative( bool compute_jacobian,
                                          AssemblyContext& context,
                                          CachedValues& cache );

    virtual void side_time_derivative( bool compute_jacobian,
                                       AssemblyContext& context,
                                       CachedValues& cache );

    virtual void nonlocal_time_derivative( bool compute_jacobian,
                                           AssemblyContext& context,
                                           CachedValues& cache );

    virtual void element_constraint( bool compute_jacobian,
                                     AssemblyContext& context,
                                     CachedValues& cache );

    virtual void side_constraint( bool compute_jacobian,
                                  AssemblyContext& context,
                                  CachedValues& cache );

    virtual void nonlocal_constraint( bool compute_jacobian,
                                      AssemblyContext& context,
                                      CachedValues& cache );

    virtual void damping_residual( bool compute_jacobian,
                                   AssemblyContext& context,
                                   CachedValues& cache );

    virtual void mass_residual( bool compute_jacobian,
                                AssemblyContext& context,
                                CachedValues& cache );

    virtual void nonlocal_mass_residual( bool compute_jacobian,
                                         AssemblyContext& context,
                                         CachedValues& cache );

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

    virtual void compute_element_time_derivative_cache( const AssemblyContext& context,
                                                        CachedValues& cache );

    virtual void compute_side_time_derivative_cache( const AssemblyContext& context,
                                                     CachedValues& cache );

    virtual void compute_nonlocal_time_derivative_cache( const AssemblyContext& context,
                                                         CachedValues& cache );

    virtual void compute_element_constraint_cache( const AssemblyContext& context,
                                                   CachedValues& cache );

    virtual void compute_side_constraint_cache( const AssemblyContext& context,
                                                CachedValues& cache );

    virtual void compute_nonlocal_constraint_cache( const AssemblyContext& context,
                                                    CachedValues& cache );

    virtual void compute_damping_residual_cache( const AssemblyContext& context,
                                                 CachedValues& cache );

    virtual void compute_mass_residual_cache( const AssemblyContext& context,
                                              CachedValues& cache );

    virtual void compute_nonlocal_mass_residual_cache( const AssemblyContext& context,
                                                       CachedValues& cache );

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

    ICHandlingBase* get_ic_handler();

#ifdef GRINS_USE_GRVY_TIMERS
    void attach_grvy_timer( GRVY::GRVY_Timer_Class* grvy_timer );
#endif

  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 );


    const PhysicsName _physics_name;

    GRINS::ICHandlingBase* _ic_handler;

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


    static bool _is_steady;

    static bool _is_axisymmetric;

#ifdef GRINS_USE_GRVY_TIMERS
    GRVY::GRVY_Timer_Class* _timer;
#endif

  private:
    Physics();

  }; // End Physics class declarations

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

} // End namespace GRINS

#endif //GRINS_PHYSICS_H