physics.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// GRINS - General Reacting Incompressible Navier-Stokes
//
// Copyright (C) 2014-2015 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/grins_physics_names.h"
#include "grins/cached_values.h"
#include "grins/parameter_user.h"

//libMesh
#include "libmesh/libmesh.h"
#include "libmesh/point.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 ParameterMultiPointer;
}

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 read_input_options( const GetPot& input );

    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;


    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 mass_residual( bool compute_jacobian,
                                AssemblyContext& context,
                                CachedValues& cache );

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

    void init_bcs( libMesh::FEMSystem* system );

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

    void attach_neumann_bound_func( GRINS::NBCContainer& neumann_bcs );

    void attach_dirichlet_bound_func( const GRINS::DBCContainer& dirichlet_bc );

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

    BCHandlingBase* get_bc_handler(); 

    ICHandlingBase* get_ic_handler(); 

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

  protected:
    

    const PhysicsName _physics_name;

    GRINS::BCHandlingBase* _bc_handler;

    GRINS::ICHandlingBase* _ic_handler;

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

    static bool _is_steady;

    bool _is_axisymmetric;

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

  private:
    Physics();

  }; // End Physics class declarations

  /* ------------------------- Inline Functions -------------------------*/

  inline
  BCHandlingBase* Physics::get_bc_handler()
  {
    return _bc_handler;
  }

  inline
  ICHandlingBase* Physics::get_ic_handler()
  {
    return _ic_handler;
  }

} // End namespace GRINS

#endif //GRINS_PHYSICS_H