doxygen/libmesh/tests_2mesh_2mesh__function_8C_source.html

#include <libmesh/equation_systems.h>

#include <libmesh/replicated_mesh.h>

#include <libmesh/mesh_generation.h>

#include <libmesh/dof_map.h>

#include <libmesh/system.h>

#include <libmesh/mesh_function.h>

#include <libmesh/numeric_vector.h>

#include <libmesh/elem.h>


#include "test_comm.h"

#include "libmesh_cppunit.h"

#include "libmesh/enum_xdr_mode.h"


using namespace libMesh;


Number projection_function (const Point & p,

                            const Parameters &,

                            const std::string &,

                            const std::string &)

{

  return

    cos(.5*libMesh::pi*p(0)) *

    sin(.5*libMesh::pi*p(1)) *

    cos(.5*libMesh::pi*p(2));

}


Number trilinear_function (const Point & p,

                           const Parameters &,

                           const std::string &,

                           const std::string &)

{

  return 8*p(0) + 80*p(1) + 800*p(2);

}


Number bilinear_function (const Point & p,

                          const Parameters &,

                          const std::string &,

                          const std::string &)

{

  return 8*p(0) + 80*p(1);

}


Number biquadratic_function (const Point & p,

                             const Parameters &,

                             const std::string &,

                             const std::string &)

{

  return 7.5*p(0)*p(0) + 75*p(1)*p(1) + 0.75*p(1)*p(0);

}


class MeshFunctionTest : public CppUnit::TestCase

{

public:

  LIBMESH_CPPUNIT_TEST_SUITE( MeshFunctionTest );


#if LIBMESH_DIM > 1

  CPPUNIT_TEST( test_subdomain_id_sets );

  CPPUNIT_TEST( test_bad_gradient_var_with_out_of_mesh_value );

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES

  CPPUNIT_TEST( test_bad_hessian_var_with_out_of_mesh_value );

#endif

#ifdef LIBMESH_HAVE_PETSC

  CPPUNIT_TEST( vectorMeshFunctionLagrange );

  CPPUNIT_TEST( vectorMeshFunctionNedelec );

  CPPUNIT_TEST( vectorMeshFunctionRaviartThomas );

  CPPUNIT_TEST( mixedScalarAndVectorVariables );

#endif // LIBMESH_HAVE_PETSC

#endif

#if LIBMESH_DIM > 2

#ifdef LIBMESH_ENABLE_AMR

  CPPUNIT_TEST( test_p_level );

#endif

#endif


  CPPUNIT_TEST_SUITE_END();


protected:


public:

  void setUp() {}


  void tearDown() {}


  // test that mesh function works correctly with subdomain id sets.


  void test_subdomain_id_sets()

  {

    LOG_UNIT_TEST;


    ReplicatedMesh mesh(*TestCommWorld);


    MeshTools::Generation::build_square (mesh,

                                         4, 4,

                                         0., 1.,

                                         0., 1.,

                                         QUAD4);


    // Set a subdomain id for all elements, based on location.

    for (auto & elem : mesh.active_element_ptr_range())

      {

        Point c = elem->vertex_average();

        elem->subdomain_id() =

          subdomain_id_type(c(0)*4) + subdomain_id_type(c(1)*4)*10;

      }


    // Add a discontinuous variable so we can easily see what side of

    // an interface we're querying

    EquationSystems es(mesh);

    System & sys = es.add_system<System> ("SimpleSystem");

    unsigned int u_var = sys.add_variable("u", CONSTANT, MONOMIAL);


    es.init();

    sys.project_solution(trilinear_function, nullptr, es.parameters);


    MeshFunction mesh_function (sys.get_equation_systems(),

                                *sys.current_local_solution,

                                sys.get_dof_map(),

                                u_var);


    // Checkerboard pattern

    const std::set<subdomain_id_type> sbdids1 {0,2,11,13,20,22,31,33};

    const std::set<subdomain_id_type> sbdids2 {1,3,10,12,21,23,30,32};

    mesh_function.init();

    mesh_function.enable_out_of_mesh_mode(DenseVector<Number>());

    mesh_function.set_subdomain_ids(&sbdids1);


    DenseVector<Number> vec_values;

    const std::string dummy;


    // Make sure the MeshFunction's values interpolate the projected solution

    // at the nodes

    for (auto & elem : mesh.active_local_element_ptr_range())

      {

        const Point c = elem->vertex_average();

        const Real expected_value =

          libmesh_real(trilinear_function(c, es.parameters, dummy, dummy));

        const std::vector<Point> offsets

          {{0,-1/8.}, {1/8.,0}, {0,1/8.}, {-1/8.,0}};

        for (Point offset : offsets)

          {

            const Point p = c + offset;

            mesh_function(p, 0, vec_values, &sbdids1);

            const Number retval1 = vec_values.empty() ? -12345 : vec_values(0);

            mesh_function(p, 0, vec_values, &sbdids2);

            const Number retval2 = vec_values.empty() ? -12345 : vec_values(0);

            mesh_function(c, 0, vec_values, nullptr);

            const Number retval3 = vec_values.empty() ? -12345 : vec_values(0);


            LIBMESH_ASSERT_NUMBERS_EQUAL

              (retval3, expected_value, TOLERANCE * TOLERANCE);


            if (sbdids1.count(elem->subdomain_id()))

              {

                CPPUNIT_ASSERT(!sbdids2.count(elem->subdomain_id()));

                LIBMESH_ASSERT_NUMBERS_EQUAL

                  (retval1, expected_value, TOLERANCE * TOLERANCE);


                mesh_function(c, 0, vec_values, &sbdids2);

                CPPUNIT_ASSERT(vec_values.empty());

              }

            else

              {

                LIBMESH_ASSERT_NUMBERS_EQUAL

                  (retval2, expected_value, TOLERANCE * TOLERANCE);


                mesh_function(c, 0, vec_values, &sbdids1);

                CPPUNIT_ASSERT(vec_values.empty());

              }

          }

      }

  }


  void test_bad_gradient_var_with_out_of_mesh_value()

  {

    LOG_UNIT_TEST;


    ReplicatedMesh mesh(*TestCommWorld);


    MeshTools::Generation::build_square(mesh,

                                        4, 4,

                                        0., 1.,

                                        0., 1.,

                                        QUAD4);


    EquationSystems es(mesh);

    System & sys = es.add_system<System>("SimpleSystem");

    const unsigned int u_var = sys.add_variable("u", FIRST, LAGRANGE);

    const unsigned int v_var = sys.add_variable("v", CONSTANT, MONOMIAL);


    es.init();

    sys.project_solution(bilinear_function, nullptr, es.parameters);


    std::vector<unsigned int> variables {u_var, v_var, libMesh::invalid_uint};

    MeshFunction mesh_function(es,

                               *sys.current_local_solution,

                               sys.get_dof_map(),

                               variables);

    mesh_function.init();


    DenseVector<Number> out_of_mesh_value(3);

    out_of_mesh_value(0) = -99.0;

    out_of_mesh_value(1) = 5.25;

    out_of_mesh_value(1) = 42;

    mesh_function.enable_out_of_mesh_mode(out_of_mesh_value);


    // Pick an element centroid so u and v agree

    const Point good_p(0.375, 0.625, 0.0);


    // On a distributed mesh not every processor may have every

    // element

    const Elem * elem = (*mesh.sub_point_locator())(good_p);

    bool someone_found_elem = elem;

    mesh.comm().max(someone_found_elem);

    CPPUNIT_ASSERT(someone_found_elem);


    std::vector<Gradient> gradients;

    mesh_function.gradient(good_p, 0.0, gradients);


    CPPUNIT_ASSERT_EQUAL(std::size_t(3), gradients.size());


    // Let's only test our evaluation where we know we can evaluate, in parallel

    if (!elem || elem->processor_id() != mesh.processor_id())

      return;


    LIBMESH_ASSERT_NUMBERS_EQUAL(8.0, gradients[0](0), TOLERANCE * TOLERANCE);

    LIBMESH_ASSERT_NUMBERS_EQUAL(80.0, gradients[0](1), TOLERANCE * TOLERANCE);

    if (LIBMESH_DIM > 2)

      LIBMESH_ASSERT_NUMBERS_EQUAL(0.0, gradients[0](2), TOLERANCE * TOLERANCE);


    // Piecewise-constant functions have zero gradients

    for (unsigned int d = 0; d < LIBMESH_DIM; ++d)

      LIBMESH_ASSERT_NUMBERS_EQUAL(0, gradients[1](d), TOLERANCE * TOLERANCE);


    LIBMESH_ASSERT_NUMBERS_EQUAL(out_of_mesh_value(2),

                                 gradients[2](0),

                                 TOLERANCE * TOLERANCE);

    for (unsigned int d = 1; d < LIBMESH_DIM; ++d)

      LIBMESH_ASSERT_NUMBERS_EQUAL(0, gradients[2](d),

                                   TOLERANCE * TOLERANCE);


    const Point bad_p(1.375, 0.625, 0.0);

    mesh_function.gradient(bad_p, 0.0, gradients);


    for (unsigned int vn = 0; vn != 3; ++vn)

      {

        LIBMESH_ASSERT_NUMBERS_EQUAL(out_of_mesh_value(vn),

                                     gradients[vn](0),

                                     TOLERANCE * TOLERANCE);

        for (unsigned int d = 1; d < LIBMESH_DIM; ++d)

          LIBMESH_ASSERT_NUMBERS_EQUAL(0, gradients[vn](d),

                                       TOLERANCE * TOLERANCE);

      }

  }


#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES


  void test_bad_hessian_var_with_out_of_mesh_value()

  {

    LOG_UNIT_TEST;


    // Hessian calculations are a little weaker in FP on some systems

    const Real tol = TOLERANCE * std::sqrt(TOLERANCE);


    ReplicatedMesh mesh(*TestCommWorld);


    MeshTools::Generation::build_square(mesh,

                                        4, 4,

                                        0., 1.,

                                        0., 1.,

                                        QUAD9);


    EquationSystems es(mesh);

    System & sys = es.add_system<System>("SimpleSystem");

    unsigned int u_var = sys.add_variable("u", SECOND, LAGRANGE);

    unsigned int v_var = sys.add_variable("v", CONSTANT, MONOMIAL);


    es.init();

    sys.project_solution(biquadratic_function, nullptr, es.parameters);


    std::vector<unsigned int> variables {u_var, v_var, libMesh::invalid_uint};

    MeshFunction mesh_function(es,

                               *sys.current_local_solution,

                               sys.get_dof_map(),

                               variables);

    mesh_function.init();


    DenseVector<Number> out_of_mesh_value(3);

    out_of_mesh_value(0) = -99.0;

    out_of_mesh_value(1) = 5.25;

    out_of_mesh_value(2) = 42;

    mesh_function.enable_out_of_mesh_mode(out_of_mesh_value);


    std::vector<Tensor> hessians;

    const Point p(0.4, 0.6, 0.0);


    // On a distributed mesh not every processor may have every

    // element

    const Elem * elem = (*mesh.sub_point_locator())(p);

    bool someone_found_elem = elem;

    mesh.comm().max(someone_found_elem);

    CPPUNIT_ASSERT(someone_found_elem);


    mesh_function.hessian(p, 0.0, hessians);


    CPPUNIT_ASSERT_EQUAL(std::size_t(3), hessians.size());


    // Let's only test our evaluation where we know we can evaluate, in parallel

    if (!elem || elem->processor_id() != mesh.processor_id())

      return;


    LIBMESH_ASSERT_NUMBERS_EQUAL(15.0, hessians[0](0,0), tol);

    LIBMESH_ASSERT_NUMBERS_EQUAL(0.75, hessians[0](0,1), tol);

    LIBMESH_ASSERT_NUMBERS_EQUAL(0.75, hessians[0](1,0), tol);

    LIBMESH_ASSERT_NUMBERS_EQUAL(150.0, hessians[0](1,1), tol);


    if (LIBMESH_DIM > 2)

       for (unsigned int d = 0; d < LIBMESH_DIM; ++d)

         for (unsigned int d2 = 0; d2 < LIBMESH_DIM; ++d2)

           if (d>1 || d2>1)

             LIBMESH_ASSERT_NUMBERS_EQUAL(0, hessians[0](d,d2),

                                          tol);


    // Piecewise-constant functions have zero Hessians

    for (unsigned int d = 0; d < LIBMESH_DIM; ++d)

      for (unsigned int d2 = 0; d2 < LIBMESH_DIM; ++d2)

        LIBMESH_ASSERT_NUMBERS_EQUAL(0, hessians[1](d,d2), tol);


    LIBMESH_ASSERT_NUMBERS_EQUAL(out_of_mesh_value(2),

                                 hessians[2](0,0),

                                 tol);

    for (unsigned int d = 0; d < LIBMESH_DIM; ++d)

      for (unsigned int d2 = 0; d2 < LIBMESH_DIM; ++d2)

        if (d || d2)

          LIBMESH_ASSERT_NUMBERS_EQUAL(0, hessians[2](d,d2),

                                       tol);


    const Point bad_p(1.375, 0.625, 0.0);

    mesh_function.hessian(bad_p, 0.0, hessians);


    for (unsigned int vn = 0; vn != 2; ++vn)

      {

        LIBMESH_ASSERT_NUMBERS_EQUAL(out_of_mesh_value(vn),

                                     hessians[vn](0,0), tol);

        for (unsigned int d = 0; d < LIBMESH_DIM; ++d)

          for (unsigned int d2 = 0; d2 < LIBMESH_DIM; ++d2)

            if (d || d2)

              LIBMESH_ASSERT_NUMBERS_EQUAL(0, hessians[vn](d,d2), tol);

      }

  }


#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES


  // test that mesh function works correctly with non-zero

  // Elem::p_level() values.

#ifdef LIBMESH_ENABLE_AMR


  void test_p_level()

  {

    LOG_UNIT_TEST;


    ReplicatedMesh mesh(*TestCommWorld);


    MeshTools::Generation::build_cube (mesh,

                                       5, 5, 5,

                                       0., 1.,

                                       0., 1.,

                                       0., 1.,

                                       HEX20);


    // Bump the p-level for all elements. We will create a system with

    // a FIRST, LAGRANGE variable and then use the additional p-level

    // to solve with quadratic elements. Note: set_p_level(1) actually

    // _increases_ the existing variable order by 1, it does not set

    // it to 1.

    for (auto & elem : mesh.active_element_ptr_range())

      elem->set_p_level(1);


    EquationSystems es(mesh);

    System & sys = es.add_system<System> ("SimpleSystem");

    unsigned int u_var = sys.add_variable("u", FIRST, LAGRANGE);


    es.init();

    sys.project_solution(projection_function, nullptr, es.parameters);


    std::unique_ptr<NumericVector<Number>> mesh_function_vector

      = NumericVector<Number>::build(sys.comm());

    mesh_function_vector->init(sys.n_dofs(), sys.n_local_dofs(),

                               sys.get_dof_map().get_send_list(), false,

                               GHOSTED);


    sys.solution->localize(*mesh_function_vector,

                           sys.get_dof_map().get_send_list());


    // So the MeshFunction knows which variables to compute values for.

    // std::make_unique doesn't like if we try to use {u_var} in-place?

    std::vector<unsigned int> variables {u_var};


    auto mesh_function =

      std::make_unique<MeshFunction>(sys.get_equation_systems(),

                                        *mesh_function_vector,

                                        sys.get_dof_map(),

                                        variables);


    mesh_function->init();

    mesh_function->set_point_locator_tolerance(0.0001);

    DenseVector<Number> vec_values;

    std::string dummy;


    // Make sure the MeshFunction's values interpolate the projected solution

    // at the nodes

    for (const auto & node : mesh.local_node_ptr_range())

      {

        (*mesh_function)(*node, /*time=*/ 0., vec_values);

        Number mesh_function_value =

          projection_function(*node,

                              es.parameters,

                              dummy,

                              dummy);


        LIBMESH_ASSERT_NUMBERS_EQUAL

          (vec_values(0), mesh_function_value, TOLERANCE*TOLERANCE);

      }

  }


#endif // LIBMESH_ENABLE_AMR


#ifdef LIBMESH_HAVE_PETSC


  // A helper function that populates the solution data from output files


  DenseVector<Number> read_variable_info_from_output_data(const std::string & mesh_name,

                                                          const std::string & solutions_name)

  {

    DenseVector<Number> output;


    // Reading mesh and solution information from XDA files

    ReplicatedMesh mesh(*TestCommWorld);

    mesh.read(mesh_name);

    EquationSystems es(mesh);

    es.read(solutions_name, READ,

            EquationSystems::READ_HEADER |

                EquationSystems::READ_DATA |

                EquationSystems::READ_ADDITIONAL_DATA);

    es.update();


    // Pulling the correct system and variable information from

    // the XDA files (the default system name is "nl0")

    System & sys = es.get_system<System>("nl0");

    std::unique_ptr<NumericVector<Number>> mesh_function_vector =

        NumericVector<Number>::build(es.comm());

    mesh_function_vector->init(sys.n_dofs(), false, SERIAL);

    sys.solution->localize(*mesh_function_vector);


    // Pulling the total number of variables stored in XDA file

    std::vector<unsigned int> variables;

    sys.get_all_variable_numbers(variables);

    std::sort(variables.begin(),variables.end());


    // Setting up libMesh::MeshFunction

    MeshFunction mesh_function(es, *mesh_function_vector,

                                sys.get_dof_map(), variables);

    mesh_function.init();


    // Defining input parameters for MeshFunction::operator()

    const std::set<subdomain_id_type> * subdomain_ids = nullptr;

    const Point & p = Point(0.5, 0.5);


    // Supplying the variable values at center of mesh to output

    (mesh_function)(p, 0.0, output, subdomain_ids);


    return output;

  }


  // Tests the projection of Lagrange Vectors using MeshFunction


  void vectorMeshFunctionLagrange()

  {

    LOG_UNIT_TEST;


    // Populating the solution data using a helper function

    DenseVector<Number> output = read_variable_info_from_output_data("solutions/lagrange_vec_solution_mesh.xda","solutions/lagrange_vec_solution.xda");

    Gradient output_vec = VectorValue(output(0),output(1));


    // Expected value at center mesh

    Gradient output_expected = VectorValue(0.100977281077292,0.201954562154583);


    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_vec(0)), libMesh::libmesh_real(output_expected(0)),

                            TOLERANCE * TOLERANCE);

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_vec(1)), libMesh::libmesh_real(output_expected(1)),

                            TOLERANCE * TOLERANCE);

  }


  // Tests the projection of Nedelec Vectors using MeshFunction


  void vectorMeshFunctionNedelec()

  {

    LOG_UNIT_TEST;


    // Populating the solution data using a helper function

    DenseVector<Number> output = read_variable_info_from_output_data("solutions/nedelec_one_solution_mesh.xda","solutions/nedelec_one_solution.xda");

    Gradient output_vec = VectorValue(output(0),output(1));


    // Expected value at center mesh

    Gradient output_expected = VectorValue(0.0949202883998996,-0.0949202883918033);


    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_vec(0)), libMesh::libmesh_real(output_expected(0)),

                            TOLERANCE * TOLERANCE);

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_vec(1)), libMesh::libmesh_real(output_expected(1)),

                            TOLERANCE * TOLERANCE);

  }


  // Tests the projection of Raviart Thomas Vectors using MeshFunction


  void vectorMeshFunctionRaviartThomas()

  {

    LOG_UNIT_TEST;


    // Populating the solution data using a helper function

    DenseVector<Number> output = read_variable_info_from_output_data("solutions/raviart_thomas_solution_mesh.xda","solutions/raviart_thomas_solution.xda");

    Gradient output_vec = VectorValue(output(0),output(1));


    // Expected value at center mesh

    Gradient output_expected = VectorValue(0.0772539939808116,-0.0772537479511396);


    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_vec(0)), libMesh::libmesh_real(output_expected(0)),

                            TOLERANCE * TOLERANCE);

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_vec(1)), libMesh::libmesh_real(output_expected(1)),

                            TOLERANCE * TOLERANCE);

  }


  // Tests MeshFunction for mixed scalar and vector variable outputs

  // In this case, the variables types are:

  //  - variable index: 0, variable family: Raviart Thomas, Order: First

  //  - variable index: 1, variable family: Monomial, Order: Constant

  //  - variable index: 2, variable family: Scalar, Order: First


  void mixedScalarAndVectorVariables()

  {

    LOG_UNIT_TEST;


    // Populating the solution data using a helper function

    DenseVector<Number> output = read_variable_info_from_output_data("solutions/raviart_thomas_solution_mesh.xda","solutions/raviart_thomas_solution.xda");

    Gradient output_raviart_thomas = VectorValue(output(0),output(1));


    // Expected value at center mesh

    Gradient raviart_thomas_expected = VectorValue(0.0772539939808116,-0.0772537479511396);

    Number monomial_expected = -0.44265566716952;

    Number scalar_expected = -2.86546e-18;


    // Checking Raviart Thomas variable family values

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_raviart_thomas(0)), libMesh::libmesh_real(raviart_thomas_expected(0)),

                            TOLERANCE * TOLERANCE);

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output_raviart_thomas(1)), libMesh::libmesh_real(raviart_thomas_expected(1)),

                            TOLERANCE * TOLERANCE);

    // Checking Monomial variable family value

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output(2)), libMesh::libmesh_real(monomial_expected),

                            TOLERANCE * TOLERANCE);

    // Checking scalar variable family value

    LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(output(3)), libMesh::libmesh_real(scalar_expected),

                            TOLERANCE * TOLERANCE);

  }


#endif // LIBMESH_HAVE_PETSC

};


CPPUNIT_TEST_SUITE_REGISTRATION(MeshFunctionTest);

MeshFunctionTest
Definition mesh_function.C:57

MeshFunctionTest::read_variable_info_from_output_data
DenseVector< Number > read_variable_info_from_output_data(const std::string &mesh_name, const std::string &solutions_name)
Definition mesh_function.C:435

MeshFunctionTest::setUp
void setUp()
Definition mesh_function.C:88

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(vectorMeshFunctionNedelec)

MeshFunctionTest::test_p_level
void test_p_level()
Definition mesh_function.C:361

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(test_bad_gradient_var_with_out_of_mesh_value)

MeshFunctionTest::mixedScalarAndVectorVariables
void mixedScalarAndVectorVariables()
Definition mesh_function.C:537

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(test_bad_hessian_var_with_out_of_mesh_value)

MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value
void test_bad_gradient_var_with_out_of_mesh_value()
Definition mesh_function.C:180

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(test_subdomain_id_sets)

MeshFunctionTest::test_subdomain_id_sets
void test_subdomain_id_sets()
Definition mesh_function.C:93

MeshFunctionTest::vectorMeshFunctionLagrange
void vectorMeshFunctionLagrange()
Definition mesh_function.C:479

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(vectorMeshFunctionLagrange)

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(vectorMeshFunctionRaviartThomas)

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(test_p_level)

MeshFunctionTest::CPPUNIT_TEST_SUITE_END
CPPUNIT_TEST_SUITE_END()

MeshFunctionTest::LIBMESH_CPPUNIT_TEST_SUITE
LIBMESH_CPPUNIT_TEST_SUITE(MeshFunctionTest)
Tests for general MeshFunction capability.

MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value
void test_bad_hessian_var_with_out_of_mesh_value()
Definition mesh_function.C:263

MeshFunctionTest::vectorMeshFunctionRaviartThomas
void vectorMeshFunctionRaviartThomas()
Definition mesh_function.C:515

MeshFunctionTest::tearDown
void tearDown()
Definition mesh_function.C:90

MeshFunctionTest::CPPUNIT_TEST
CPPUNIT_TEST(mixedScalarAndVectorVariables)

MeshFunctionTest::vectorMeshFunctionNedelec
void vectorMeshFunctionNedelec()
Definition mesh_function.C:497

libMesh::Parallel::Communicator::max
void max(const T &r, T &o, Request &req) const

libMesh::DenseVector
Defines a dense vector for use in Finite Element-type computations.
Definition dense_vector.h:59

libMesh::DenseVector::empty
virtual bool empty() const override final
Definition dense_vector.h:109

libMesh::DofMap::get_send_list
const std::vector< dof_id_type > & get_send_list() const
Definition dof_map.h:533

libMesh::DofObject::processor_id
processor_id_type processor_id() const
Definition dof_object.h:881

libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition elem.h:96

libMesh::EquationSystems
This is the EquationSystems class.
Definition equation_systems.h:72

libMesh::EquationSystems::update
void update()
Updates local values for all the systems.
Definition equation_systems.C:342

libMesh::EquationSystems::read
void read(std::string_view name, const XdrMODE, const unsigned int read_flags=(READ_HEADER|READ_DATA), bool partition_agnostic=true)
Read & initialize the systems from disk using the XDR data format.
Definition equation_systems_io.C:90

libMesh::EquationSystems::parameters
Parameters parameters
Data structure holding arbitrary parameters.
Definition equation_systems.h:608

libMesh::EquationSystems::READ_ADDITIONAL_DATA
@ READ_ADDITIONAL_DATA
Definition equation_systems.h:80

libMesh::EquationSystems::READ_HEADER
@ READ_HEADER
Definition equation_systems.h:78

libMesh::EquationSystems::READ_DATA
@ READ_DATA
Definition equation_systems.h:79

libMesh::EquationSystems::init
virtual void init()
Initialize all the systems.
Definition equation_systems.C:80

libMesh::EquationSystems::add_system
virtual System & add_system(std::string_view system_type, std::string_view name)
Add the system of type system_type named name to the systems array.
Definition equation_systems.C:353

libMesh::EquationSystems::get_system
const T_sys & get_system(std::string_view name) const
Definition equation_systems.h:776

libMesh::MeshBase::read
virtual void read(const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false, bool skip_detect_interior_parents=false)=0
Interfaces for reading/writing a mesh to/from a file.

libMesh::MeshBase::sub_point_locator
std::unique_ptr< PointLocatorBase > sub_point_locator() const
Definition mesh_base.C:1833

libMesh::MeshFunction
This class provides function-like objects for data distributed over a mesh.
Definition mesh_function.h:56

libMesh::MeshFunction::hessian
Tensor hessian(const Point &p, const Real time=0.)
Definition mesh_function.C:197

libMesh::MeshFunction::set_subdomain_ids
void set_subdomain_ids(const std::set< subdomain_id_type > *subdomain_ids)
Choose a default list of subdomain ids to be searched for points.
Definition mesh_function.C:869

libMesh::MeshFunction::init
virtual void init() override
Override the FunctionBase::init() member function.
Definition mesh_function.C:104

libMesh::MeshFunction::gradient
Gradient gradient(const Point &p, const Real time=0.)
Definition mesh_function.C:171

libMesh::MeshFunction::enable_out_of_mesh_mode
void enable_out_of_mesh_mode(const DenseVector< Number > &value)
Enables out-of-mesh mode.
Definition mesh_function.C:836

libMesh::NumericVector::build
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, SolverPackage solver_package=libMesh::default_solver_package(), ParallelType parallel_type=AUTOMATIC)
Builds a NumericVector on the processors in communicator comm using the linear solver package specifi...
Definition numeric_vector.C:61

libMesh::ParallelObject::processor_id
processor_id_type processor_id() const
Definition parallel_object.h:114

libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const
Definition parallel_object.h:97

libMesh::Parameters
This class provides the ability to map between arbitrary, user-defined strings and several data types...
Definition parameters.h:75

libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:40

libMesh::ReplicatedMesh
The ReplicatedMesh class is derived from the MeshBase class, and is used to store identical copies of...
Definition replicated_mesh.h:47

libMesh::System
Manages consistently variables, degrees of freedom, and coefficient vectors.
Definition system.h:100

libMesh::System::project_solution
void project_solution(FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, std::optional< ConstElemRange > active_local_range=std::nullopt, std::optional< std::vector< unsigned int > > variable_numbers=std::nullopt) const
Projects arbitrary functions onto the current solution.
Definition system_projection.C:1065

libMesh::System::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
All the values I need to compute my contribution to the simulation at hand.
Definition system.h:1667

libMesh::System::get_all_variable_numbers
void get_all_variable_numbers(std::vector< unsigned int > &all_variable_numbers) const
Fills all_variable_numbers with all the variable numbers for the variables that have been added to th...
Definition system.C:1403

libMesh::System::n_dofs
dof_id_type n_dofs() const
Definition system.C:118

libMesh::System::add_variable
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
Definition system.C:1344

libMesh::System::n_local_dofs
dof_id_type n_local_dofs() const
Definition system.C:155

libMesh::System::solution
std::unique_ptr< NumericVector< Number > > solution
Data structure to hold solution values.
Definition system.h:1655

libMesh::System::get_dof_map
const DofMap & get_dof_map() const
Definition system.h:2417

libMesh::System::get_equation_systems
const EquationSystems & get_equation_systems() const
Definition system.h:767

libMesh::VectorValue
This class defines a vector in LIBMESH_DIM dimensional Real or Complex space.
Definition vector_value.h:48

TestCommWorld
Communicator * TestCommWorld

libmesh_cppunit.h

mesh
MeshBase & mesh
Definition mesh_communication.C:1460

libMesh::MeshTools::Generation::build_square
void build_square(UnstructuredMesh &mesh, const unsigned int nx, const unsigned int ny, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
A specialized build_cube() for 2D meshes.
Definition mesh_generation.C:1981

libMesh::MeshTools::Generation::build_cube
void build_cube(UnstructuredMesh &mesh, const unsigned int nx=0, const unsigned int ny=0, const unsigned int nz=0, const Real xmin=0., const Real xmax=1., const Real ymin=0., const Real ymax=1., const Real zmin=0., const Real zmax=1., const ElemType type=INVALID_ELEM, const bool gauss_lobatto_grid=false)
Builds a  (elements) cube.
Definition mesh_generation.C:317

libMesh
The libMesh namespace provides an interface to certain functionality in the library.

libMesh::SERIAL
@ SERIAL
Definition enum_parallel_type.h:35

libMesh::GHOSTED
@ GHOSTED
Definition enum_parallel_type.h:37

libMesh::HEX20
@ HEX20
Definition enum_elem_type.h:48

libMesh::QUAD9
@ QUAD9
Definition enum_elem_type.h:43

libMesh::QUAD4
@ QUAD4
Definition enum_elem_type.h:41

libMesh::libmesh_real
T libmesh_real(T a)
Definition libmesh_common.h:189

libMesh::invalid_uint
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
Definition libmesh.h:303

libMesh::subdomain_id_type
TestClass subdomain_id_type
Based on the 4-byte comment warning above, this probably doesn't work with exodusII at all....
Definition id_types.h:43

libMesh::pi
const Real pi
.
Definition libmesh.h:292

libMesh::Number
Real Number
Definition libmesh_common.h:253

libMesh::TOLERANCE
static constexpr Real TOLERANCE
Definition libmesh_common.h:151

libMesh::LAGRANGE
@ LAGRANGE
Definition enum_fe_family.h:36

libMesh::MONOMIAL
@ MONOMIAL
Definition enum_fe_family.h:39

libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:144

libMesh::FIRST
@ FIRST
Definition enum_order.h:42

libMesh::CONSTANT
@ CONSTANT
Definition enum_order.h:41

libMesh::SECOND
@ SECOND
Definition enum_order.h:43

libMesh::READ
@ READ
Definition enum_xdr_mode.h:41

test_comm.h

CPPUNIT_TEST_SUITE_REGISTRATION
CPPUNIT_TEST_SUITE_REGISTRATION(MeshFunctionTest)

biquadratic_function
Number biquadratic_function(const Point &p, const Parameters &, const std::string &, const std::string &)
Definition mesh_function.C:46

bilinear_function
Number bilinear_function(const Point &p, const Parameters &, const std::string &, const std::string &)
Definition mesh_function.C:37

trilinear_function
Number trilinear_function(const Point &p, const Parameters &, const std::string &, const std::string &)
Definition mesh_function.C:28

projection_function
Number projection_function(const Point &p, const Parameters &, const std::string &, const std::string &)
Definition mesh_function.C:17