utest-proto-internals.cpp

Go to the documentation of this file.

// Copyright (C) 2010-2011 von Karman Institute for Fluid Dynamics, Belgium
//
// This software is distributed under the terms of the
// GNU Lesser General Public License version 3 (LGPLv3).
// See doc/lgpl.txt and doc/gpl.txt for the license text.

#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE "Test module for proto operators"

#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/max.hpp>

#include <boost/foreach.hpp>
#include <boost/test/unit_test.hpp>

#include "solver/Model.hpp"
#include "solver/Solver.hpp"

#include "solver/actions/Proto/ElementLooper.hpp"
#include "solver/actions/Proto/Expression.hpp"
#include "solver/actions/Proto/Functions.hpp"
#include "solver/actions/Proto/NodeLooper.hpp"
#include "solver/actions/Proto/Terminals.hpp"

#include "common/Core.hpp"
#include "common/Log.hpp"

#include "math/MatrixTypes.hpp"

#include "mesh/Domain.hpp"
#include "mesh/Mesh.hpp"
#include "mesh/Region.hpp"
#include "mesh/Elements.hpp"
#include "mesh/MeshReader.hpp"
#include "mesh/ElementData.hpp"
#include "mesh/FieldManager.hpp"
#include "mesh/Dictionary.hpp"

#include "mesh/Integrators/Gauss.hpp"
#include "mesh/ElementTypes.hpp"

#include "physics/PhysModel.hpp"

#include "Tools/MeshGeneration/MeshGeneration.hpp"
#include "Tools/Testing/TimedTestFixture.hpp"
#include "Tools/Testing/ProfiledTestFixture.hpp"

using namespace cf3;
using namespace cf3::solver::actions::Proto;

using namespace cf3::math::Consts;

inline void check_close(const RealMatrix2& a, const RealMatrix2& b, const Real threshold)
{
  for(Uint i = 0; i != a.rows(); ++i)
    for(Uint j = 0; j != a.cols(); ++j)
      BOOST_CHECK_CLOSE(a(i,j), b(i,j), threshold);
}

static boost::proto::terminal< void(*)(const RealMatrix2&, const RealMatrix2&, Real) >::type const _check_close = {&check_close};


typedef boost::mpl::vector3< mesh::LagrangeP1::Line1D,
                             mesh::LagrangeP1::Quad2D,
                             mesh::LagrangeP1::Hexa3D
> HigherIntegrationElements;

typedef boost::mpl::vector5< mesh::LagrangeP1::Line1D,
                             mesh::LagrangeP1::Triag2D,
                             mesh::LagrangeP1::Quad2D,
                             mesh::LagrangeP1::Hexa3D,
                             mesh::LagrangeP1::Tetra3D
> VolumeTypes;

BOOST_AUTO_TEST_SUITE( ProtoOperatorsSuite )

template<typename T>
void print_type(T)
{
  std::cout << common::demangle(typeid(T).name()) << std::endl;
}

template<typename T>
void print_type()
{
  std::cout << common::demangle(typeid(T).name()) << std::endl;
}

template<typename ExprT>
void print_variables(const ExprT&)
{
  print_type<typename ExpressionProperties<ExprT>::VariablesT>();
}

template<typename GrammarT, typename ExprT>
bool get_result(const GrammarT&, const ExprT&)
{
  return boost::result_of<GrammarT(ExprT)>::type::value;
}


BOOST_AUTO_TEST_CASE( EquationVars )
{
  static const boost::proto::terminal< RestrictToElementTypeTag< boost::mpl::vector0<> > >::type for_generic_elements = {};
  
  Real tau_ps, tau_su, tau_bulk;
  FieldVariable<0, VectorField> u("Velocity", "navier_stokes_u_solution");
  FieldVariable<1, ScalarField> p("Pressure", "navier_stokes_p_solution");
  FieldVariable<2, VectorField> u_adv("AdvectionVelocity", "linearized_velocity");
  FieldVariable<3, VectorField> u1("AdvectionVelocity1", "linearized_velocity");
  FieldVariable<4, VectorField> u2("AdvectionVelocity2", "linearized_velocity");
  FieldVariable<5, VectorField> u3("AdvectionVelocity3", "linearized_velocity");
  FieldVariable<6, ScalarField> nu_eff("EffectiveViscosity", "navier_stokes_viscosity");
  PhysicsConstant rho("density");
  PhysicsConstant nu("kinematic_viscosity");
  
  print_variables(group
  (
    _A = _0, _T = _0, _a = _0,
    for_generic_elements
    (
      element_quadrature
      (
        _A(u[_i], u[_i]) += nu_eff * transpose(nabla(u)) * nabla(u) + transpose(N(u) + tau_su*u_adv*nabla(u)) * u_adv*nabla(u), // Diffusion + advection
        _a[u[_i]]     += transpose(N(u) + tau_su*u_adv*nabla(u)) * nabla(p)[_i] / rho * nodal_values(p), // Pressure gradient (standard and SUPG)
        _A(u[_i], u[_j]) += transpose((tau_bulk + 0.33333333333333*nu_eff)*nabla(u)[_i] // Bulk viscosity and second viscosity effect
                              + 0.5*u_adv[_i]*(N(u) + tau_su*u_adv*nabla(u))) * nabla(u)[_j],  // skew symmetric part of advection (standard +SUPG)
        _T(u[_i], u[_i]) += transpose(N(u) + tau_su*u_adv*nabla(u)) * N(u) // Time, standard and SUPG
      )
    )
  ));
}

BOOST_AUTO_TEST_CASE( SubExpressions )
{
  FieldVariable<0, VectorField> u("Velocity", "navier_stokes_u_solution");
  BOOST_CHECK(!get_result(solver::actions::Proto::detail::HasEvalVar<0>(), _A(u[_i], u[_i]) += transpose(N(u))*N(u)));
  BOOST_CHECK(get_result(solver::actions::Proto::detail::HasEvalVar<0>(), _A(u[_i], u[_i]) += transpose(N(u)) * u*nabla(u)));
}

BOOST_AUTO_TEST_SUITE_END()

---

Generated on Sun Jun 14 2015 21:20:17 for COOLFluiD by  1.8.9.1

Send comments to: COOLFluiD Web Admin