doxygen/utest-ufem-buildsparsity_8cpp_source.html

 // 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 heat-conduction related proto operations"


 #include <boost/assign.hpp>

 #include <boost/test/unit_test.hpp>


 #include "common/Core.hpp"

 #include "common/Environment.hpp"


 #include "common/PE/CommPattern.hpp"


 #include "math/LSS/System.hpp"


 #include "mesh/Domain.hpp"

 #include "mesh/LagrangeP1/Line1D.hpp"


 #include "solver/Model.hpp"


 #include "solver/actions/Proto/ProtoAction.hpp"

 #include "solver/actions/Proto/Expression.hpp"


 #include "Tools/MeshGeneration/MeshGeneration.hpp"

 #include "mesh/MeshGenerator.hpp"


 #include "UFEM/LSSAction.hpp"

 #include "UFEM/Solver.hpp"

 #include "UFEM/SparsityBuilder.hpp"

 #include "UFEM/Tags.hpp"

 #include "math/LSS/SolveLSS.hpp"


 using namespace cf3;

 using namespace cf3::solver;

 using namespace cf3::solver::actions;

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

 using namespace cf3::common;

 using namespace cf3::math;

 using namespace cf3::math::Consts;

 using namespace cf3::mesh;


 using namespace boost::assign;


 struct UFEMBuildSparsityFixture

 {

   UFEMBuildSparsityFixture() :

     root( Core::instance().root() )

   {

   }


   Component& root;

 };


 BOOST_FIXTURE_TEST_SUITE( UFEMBuildSparsitySuite, UFEMBuildSparsityFixture )


 BOOST_AUTO_TEST_CASE( InitMPI )

 {

   common::PE::Comm::instance().init(boost::unit_test::framework::master_test_suite().argc, boost::unit_test::framework::master_test_suite().argv);

   BOOST_CHECK_EQUAL(common::PE::Comm::instance().size(), 1);

 }


 BOOST_AUTO_TEST_CASE( Sparsity1D )

 {

   Core::instance().environment().options().set("log_level", 4u);


   // Parameters

   Real length            = 5.;

   const Uint nb_segments = 5 ;

   const Uint nb_nodes = nb_segments + 1;


   // Setup a model

   Model& model = *root.create_component<Model>("Model");

   Domain& domain = model.create_domain("Domain");


   LSS::System& lss = *model.create_component<LSS::System>("LSS");

   lss.options().option("matrix_builder").change_value(std::string("cf3.math.LSS.TrilinosFEVbrMatrix"));


   // Setup mesh

   // Mesh& mesh = *domain.create_component<Mesh>("Mesh");

   // Tools::MeshGeneration::create_line(mesh, length, nb_segments);

   boost::shared_ptr<MeshGenerator> create_line = build_component_abstract_type<MeshGenerator>("cf3.mesh.SimpleMeshGenerator","create_line");

   create_line->options().set("mesh",domain.uri()/"Mesh");

   create_line->options().set("lengths",std::vector<Real>(DIM_1D, length));

   create_line->options().set("nb_cells",std::vector<Uint>(DIM_1D, nb_segments));

   Mesh& mesh = create_line->generate();


   // Setup sparsity

   std::vector<Uint> node_connectivity, starting_indices;

   Handle< List<Uint> > gids = domain.create_component< List<Uint> >("GIDs");

   Handle< List<Uint> > ranks = domain.create_component< List<Uint> >("Ranks");

   Handle< List<int> > used_node_map = domain.create_component< List<int> >("used_node_map");

   UFEM::build_sparsity(std::vector< Handle<Region> >(1, mesh.topology().handle<Region>()), mesh.geometry_fields(), node_connectivity, starting_indices, *gids, *ranks, *used_node_map);


   // Check result

   BOOST_CHECK_EQUAL(starting_indices[0], 0u);

   for(Uint i = 2; i != nb_nodes; ++i)

     BOOST_CHECK_EQUAL(starting_indices[i] - starting_indices[i-1], 3);


   PE::CommPattern& comm_pattern = *domain.create_component<PE::CommPattern>("CommPattern");

   comm_pattern.insert("gid",gids->array(),false);

   comm_pattern.setup(Handle<PE::CommWrapper>(comm_pattern.get_child("gid")),ranks->array());


   // Create the LSS

   lss.create(comm_pattern, 1u, node_connectivity, starting_indices);


   // Write the matrix

   lss.matrix()->print("utest-ufem-buildsparsity_heat_matrix_1D.plt");

 }


 BOOST_AUTO_TEST_CASE( Sparsity2DQuads )

 {

   Core::instance().environment().options().set("log_level", 4u);


   // Parameters

   Real length            = 5.;

   const Uint nb_segments = 5 ;

   const Uint nb_nodes = (nb_segments+1) * (nb_segments+1);


   // Setup a model

   Model& model = *root.create_component<Model>("Model");

   Domain& domain = model.create_domain("Domain");


   LSS::System& lss = *model.create_component<LSS::System>("LSS");

   lss.options().option("matrix_builder").change_value(std::string("cf3.math.LSS.TrilinosFEVbrMatrix"));


   // Setup mesh

   Mesh& mesh = *domain.create_component<Mesh>("Mesh");

   Tools::MeshGeneration::create_rectangle(mesh, length, length, nb_segments, nb_segments);


   // Setup sparsity

   std::vector<Uint> node_connectivity, starting_indices;

   Handle< List<Uint> > gids = domain.create_component< List<Uint> >("GIDs");

   Handle< List<Uint> > ranks = domain.create_component< List<Uint> >("Ranks");

   Handle< List<int> > used_node_map = domain.create_component< List<int> >("used_node_map");

   UFEM::build_sparsity(std::vector< Handle<Region> >(1, mesh.topology().handle<Region>()), mesh.geometry_fields(), node_connectivity, starting_indices, *gids, *ranks, *used_node_map);


   PE::CommPattern& comm_pattern = *domain.create_component<PE::CommPattern>("CommPattern");

   comm_pattern.insert("gid",gids->array(),false);

   comm_pattern.setup(Handle<PE::CommWrapper>(comm_pattern.get_child("gid")),ranks->array());


   // Create the LSS

   lss.create(comm_pattern, 1u, node_connectivity, starting_indices);


   // Write the matrix

   lss.matrix()->print("utest-ufem-buildsparsity_heat_matrix_2DQuads.plt");

 }


 BOOST_AUTO_TEST_CASE( Sparsity2DTris )

 {

   Core::instance().environment().options().set("log_level", 4u);


   // Parameters

   Real length            = 5.;

   const Uint nb_segments = 5 ;

   const Uint nb_nodes = (nb_segments+1) * (nb_segments+1);


   // Setup a model

   Model& model = *root.create_component<Model>("Model");

   Domain& domain = model.create_domain("Domain");


   LSS::System& lss = *model.create_component<LSS::System>("LSS");

   lss.options().option("matrix_builder").change_value(std::string("cf3.math.LSS.TrilinosFEVbrMatrix"));


   // Setup mesh

   Mesh& mesh = *domain.create_component<Mesh>("Mesh");

   Tools::MeshGeneration::create_rectangle_tris(mesh, length, length, nb_segments, nb_segments);


   // Setup sparsity

   std::vector<Uint> node_connectivity, starting_indices;

   Handle< List<Uint> > gids = domain.create_component< List<Uint> >("GIDs");

   Handle< List<Uint> > ranks = domain.create_component< List<Uint> >("Ranks");

   Handle< List<int> > used_node_map = domain.create_component< List<int> >("used_node_map");

   UFEM::build_sparsity(std::vector< Handle<Region> >(1, mesh.topology().handle<Region>()), mesh.geometry_fields(), node_connectivity, starting_indices, *gids, *ranks, *used_node_map);


   PE::CommPattern& comm_pattern = *domain.create_component<PE::CommPattern>("CommPattern");

   comm_pattern.insert("gid",gids->array(),false);

   comm_pattern.setup(Handle<PE::CommWrapper>(comm_pattern.get_child("gid")),ranks->array());


   // Create the LSS

   lss.create(comm_pattern, 1u, node_connectivity, starting_indices);


   // Write the matrix

   lss.matrix()->print("utest-ufem-buildsparsity_heat_matrix_2DTris.plt");

 }


 // Single block, meshed with the blockmesher

 BOOST_AUTO_TEST_CASE( Sparsity3DHexaBlock )

 {

   Core::instance().environment().options().set("log_level", 4u);


   // Parameters

   Real length            = 5.;

   const Uint nb_segments = 10;

   const Uint nb_nodes = (nb_segments+1) * (nb_segments+1) * (nb_segments+1);


   // Setup a model

   Model& model = *root.create_component<Model>("Model");

   Domain& domain = model.create_domain("Domain");


   LSS::System& lss = *model.create_component<LSS::System>("LSS");

   lss.options().option("matrix_builder").change_value(std::string("cf3.math.LSS.TrilinosFEVbrMatrix"));


   // Setup mesh

   Mesh& mesh = *domain.create_component<Mesh>("Mesh");


   BlockMesh::BlockArrays& blocks = *domain.create_component<BlockMesh::BlockArrays>("blocks");


   *blocks.create_points(3, 8) << 0.     << 0.     << 0.

                               << length << 0.     << 0.

                               << 0.     << length << 0.

                               << length << length << 0.

                               << 0.     << 0.     << length

                               << length << 0.     << length

                               << 0.     << length << length

                               << length << length << length;


   *blocks.create_blocks(1) << 0 << 1 << 3 << 2 << 4 << 5 << 7 << 6;

   *blocks.create_block_subdivisions() << nb_segments << nb_segments << nb_segments;

   *blocks.create_block_gradings() << 1. << 1. << 1. << 1. << 1. << 1. << 1. << 1. << 1. << 1. << 1. << 1.;


   *blocks.create_patch("bottomWall", 1) << 0 << 2 << 3 << 1;

   *blocks.create_patch("topWall", 1) << 4 << 5 << 7 << 6;

   *blocks.create_patch("side1", 1) << 1 << 3 << 7 << 5;

   *blocks.create_patch("side2", 1) << 0 << 1 << 5 << 4;

   *blocks.create_patch("side3", 1) << 0 << 4 << 6 << 2;

   *blocks.create_patch("side4", 1) << 2 << 6 << 7 << 3;


   blocks.create_mesh(mesh);


   BOOST_CHECK_EQUAL(nb_nodes, mesh.geometry_fields().coordinates().size());


   // Setup sparsity

   std::vector<Uint> node_connectivity, starting_indices;

   Handle< List<Uint> > gids = domain.create_component< List<Uint> >("GIDs");

   Handle< List<Uint> > ranks = domain.create_component< List<Uint> >("Ranks");

   Handle< List<int> > used_node_map = domain.create_component< List<int> >("used_node_map");

   UFEM::build_sparsity(std::vector< Handle<Region> >(1, mesh.topology().handle<Region>()), mesh.geometry_fields(), node_connectivity, starting_indices, *gids, *ranks, *used_node_map);


   PE::CommPattern& comm_pattern = *domain.create_component<PE::CommPattern>("CommPattern");

   comm_pattern.insert("gid",gids->array(),false);

   comm_pattern.setup(Handle<PE::CommWrapper>(comm_pattern.get_child("gid")),ranks->array());


   // Create the LSS

   lss.create(comm_pattern, 1u, node_connectivity, starting_indices);


   // Write the matrix

   lss.matrix()->print("utest-ufem-buildsparsity_heat_matrix_3DHexaBlock.plt");

 }


 BOOST_AUTO_TEST_CASE( Sparsity3DHexaChannel )

 {

   Core::instance().environment().options().set("log_level", 4u);


   // Parameters

   Real length            = 5.;

   const Uint nb_segments = 4;

   const Uint nb_nodes = (nb_segments+1) * (nb_segments+1) * (nb_segments+1);


   // Setup a model

   Model& model = *root.create_component<Model>("Model");

   Domain& domain = model.create_domain("Domain");


   LSS::System& lss = *model.create_component<LSS::System>("LSS");

   lss.options().option("matrix_builder").change_value(std::string("cf3.math.LSS.TrilinosFEVbrMatrix"));


   // Setup mesh

   Mesh& mesh = *domain.create_component<Mesh>("Mesh");

   BlockMesh::BlockArrays& blocks = *domain.create_component<BlockMesh::BlockArrays>("blocks");

   Tools::MeshGeneration::create_channel_3d(blocks, length, length/8., length, nb_segments, nb_segments/2, nb_segments, 1.);

   blocks.create_mesh(mesh);


   BOOST_CHECK_EQUAL(nb_nodes, mesh.geometry_fields().coordinates().size());


   // Setup sparsity

   std::vector<Uint> node_connectivity, starting_indices;

   Handle< List<Uint> > gids = domain.create_component< List<Uint> >("GIDs");

   Handle< List<Uint> > ranks = domain.create_component< List<Uint> >("Ranks");

   Handle< List<int> > used_node_map = domain.create_component< List<int> >("used_node_map");

   UFEM::build_sparsity(std::vector< Handle<Region> >(1, mesh.topology().handle<Region>()), mesh.geometry_fields(), node_connectivity, starting_indices, *gids, *ranks, *used_node_map);


   PE::CommPattern& comm_pattern = *domain.create_component<PE::CommPattern>("CommPattern");

   comm_pattern.insert("gid",gids->array(),false);

   comm_pattern.setup(Handle<PE::CommWrapper>(comm_pattern.get_child("gid")),ranks->array());


   // Create the LSS

   lss.create(comm_pattern, 1u, node_connectivity, starting_indices);


   // Write the matrix

   lss.matrix()->print("utest-ufem-buildsparsity_heat_matrix_3DHexaChannel.plt");

 }


 BOOST_AUTO_TEST_CASE( Heat1DComponent )

 {

   Core::instance().environment().options().set("log_level", 4u);


   // Parameters

   Real length            = 5.;

   const Uint nb_segments = 5 ;

   const Uint nb_nodes = nb_segments + 1;


   // Setup a model

   Model& model = *root.create_component<Model>("Model");

   Domain& domain = model.create_domain("Domain");

   UFEM::Solver& solver = *model.create_component<UFEM::Solver>("Solver");


   Handle<UFEM::LSSAction> lss_action(solver.add_direct_solver("cf3.UFEM.LSSAction"));


   // Proto placeholders

   FieldVariable<0, ScalarField> temperature("Temperature", UFEM::Tags::solution());


   // Allowed elements (reducing this list improves compile times)

   boost::mpl::vector1<mesh::LagrangeP1::Line1D> allowed_elements;


   // add the top-level actions (assembly, BC and solve)

   *lss_action

     << create_proto_action

     (

       "Assembly",

       elements_expression

       (

         allowed_elements,

         group

         (

           _A = _0,

           element_quadrature( _A(temperature) += transpose(nabla(temperature)) * nabla(temperature) ),

           lss_action->system_matrix += _A

         )

       )

     )

     << allocate_component<UFEM::BoundaryConditions>("BoundaryConditions")

     << allocate_component<math::LSS::SolveLSS>("SolveLSS")

     << create_proto_action("Increment", nodes_expression(temperature += lss_action->solution(temperature)))

     << create_proto_action("Output", nodes_expression(_cout << "T(" << coordinates(0,0) << ") = " << temperature << "\n"));


   // Setup physics

   model.create_physics("cf3.physics.DynamicModel");


   // Setup mesh

   Mesh& mesh = *domain.create_component<Mesh>("Mesh");

   Tools::MeshGeneration::create_line(mesh, length, nb_segments);


   lss_action->options().set("regions", std::vector<URI>(1, mesh.topology().uri()));


   LSS::System& lss = lss_action->create_lss();


   // Write the matrix

   lss.matrix()->print("utest-ufem-buildsparsity_heat_matrix_1DHeat.plt");

 }


 BOOST_AUTO_TEST_SUITE_END()


 MeshGenerator.hpp

Line1D.hpp

cf3::math::LSS::System::create
void create(cf3::common::PE::CommPattern &cp, Uint neq, std::vector< Uint > &node_connectivity, std::vector< Uint > &starting_indices, const std::vector< Uint > &periodic_links_nodes=std::vector< Uint >(), const std::vector< bool > &periodic_links_active=std::vector< bool >())
Definition: System.cpp:82

BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(InitMPI)
Definition: utest-ufem-buildsparsity.cpp:60

cf3::solver::actions::Proto::_0
static boost::proto::terminal< ZeroTag >::type _0
Placeholder for the zero matrix.
Definition: Terminals.hpp:209

cf3::Tools::MeshGeneration::create_line
void create_line(Mesh &mesh, const Real x_len, const Uint x_segments)
Create a 1D line mesh.
Definition: MeshGeneration.cpp:61

cf3::solver::Model::create_domain
virtual mesh::Domain & create_domain(const std::string &name)
creates a domain in this model
Definition: Model.cpp:201

cf3::common::Core
Definition: Core.hpp:37

cf3::Handle
Safe pointer to an object. This is the supported method for referring to components.
Definition: Handle.hpp:39

cf3::solver::Model::create_physics
virtual physics::PhysModel & create_physics(const std::string &builder)
Definition: Model.cpp:182

cf3::solver::actions::Proto::_A
static boost::proto::terminal< ElementSystemMatrix< boost::mpl::int_< 0 > > >::type const _A
Some predefined element matrices (more can be user-defined, but you have to change the number in the ...
Definition: ElementMatrix.hpp:63

cf3::UFEM::Solver::add_direct_solver
Handle< common::Action > add_direct_solver(const std::string &builder_name)
Definition: Solver.cpp:128

UFEMBuildSparsityFixture::UFEMBuildSparsityFixture
UFEMBuildSparsityFixture()
Definition: utest-ufem-buildsparsity.cpp:50

System.hpp
This header collects all the headers needed for the linear system solver, also including configure-ti...

utest-zoltan-phg-periodic.ranks
ranks
Definition: utest-zoltan-phg-periodic.py:52

SolveLSS.hpp

cf3::math
Basic Classes for Mathematical applications used by COOLFluiD.
Definition: AnalyticalFunction.cpp:24

Environment.hpp

ProtoAction.hpp

atest-boussinesq.solver
tuple solver
Definition: atest-boussinesq.py:21

CommPattern.hpp
Parallel Communication Pattern. This class provides functionality to collect communication. For efficiency it works such a way that you submit your request via the constructor or the add/remove/move magic triangle and then call setup to modify the commpattern. The data needed to be kept synchronous can be registered via the insert function. The word node here means any kind of "point of storage", in this context it is not directly related with the computational mesh.

cf3::mesh::Domain
Definition: Domain.hpp:27

cf3::common::PE::CommPattern::setup
void setup(const Handle< CommWrapper > &gid, std::vector< Uint > &rank)

Domain.hpp

utest-cgal-tetrahedralize.blocks
tuple blocks
Definition: utest-cgal-tetrahedralize.py:9

cf3::DIM_1D
Definition: Defs.hpp:15

cf3::solver
Basic Classes for Solver applications used by CF.
Definition: Action.cpp:29

cf3::common::Component::uri
URI uri() const
Construct the full path.
Definition: Component.cpp:248

cf3::math::LSS::System::matrix
Handle< LSS::Matrix > matrix()
Accessor to matrix.
Definition: System.hpp:145

cf3::solver::actions::Proto::element_quadrature
static boost::proto::terminal< ElementQuadratureTag >::type element_quadrature
Use element_quadrature(expr1, expr2, ..., exprN) to evaluate a group of expressions.
Definition: ElementIntegration.hpp:263

cf3::mesh::Dictionary::coordinates
const Field & coordinates() const
Definition: Dictionary.cpp:481

atest-boussinesq.mesh
tuple mesh
Definition: atest-boussinesq.py:64

cf3::common::PE::CommPattern
Definition: CommPattern.hpp:41

cf3::Tools::MeshGeneration::create_rectangle_tris
void create_rectangle_tris(Mesh &mesh, const Real x_len, const Real y_len, const Uint x_segments, const Uint y_segments)
Create a triangulated version of a 2D rectangular grid.
Definition: MeshGeneration.cpp:209

UFEMBuildSparsityFixture::root
Component & root
Definition: utest-ufem-buildsparsity.cpp:55

coolfluid.root
tuple root
Definition: coolfluid.py:24

cf3::solver::actions::Proto::elements_expression
boost::shared_ptr< ElementsExpression< ExprT, ElementTypes > > elements_expression(ElementTypes, const ExprT &expr)
Definition: Expression.hpp:292

cf3::Tools::MeshGeneration::create_rectangle
void create_rectangle(Mesh &mesh, const Real x_len, const Real y_len, const Uint x_segments, const Uint y_segments)
Create a rectangular, 2D, quad-only mesh. No buffer for creation.
Definition: MeshGeneration.cpp:102

cf3::UFEM::Solver
Manage a collection of UFEM solvers.
Definition: Solver.hpp:31

cf3::common::PE::CommPattern::insert
void insert(const std::string &name, T *&data, const int size, const unsigned int stride=1, const bool needs_update=true)
Definition: CommPattern.hpp:139

cf3::solver::actions::Proto::_cout
static boost::proto::terminal< std::ostream & >::type _cout
Wrap std::cout.
Definition: Terminals.hpp:219

cf3::UFEM::build_sparsity
boost::shared_ptr< List< Uint > > build_sparsity(const std::vector< Handle< Region > > &regions, const Dictionary &dictionary, std::vector< Uint > &node_connectivity, std::vector< Uint > &start_indices, List< Uint > &gids, List< Uint > &ranks, List< int > &used_node_map)
Definition: SparsityBuilder.cpp:31

cf3::math::Consts
Static functions for mathematical constants.
Definition: Consts.hpp:25

cf3::common::Table::size
Uint size() const
Definition: Table.hpp:127

cf3::mesh::Region
Definition: Region.hpp:33

cf3::solver::actions::Proto::transpose
boost::proto::terminal< TransposeFunction >::type const transpose
Definition: EigenTransforms.hpp:258

MeshGeneration.hpp

cf3::solver::actions::Proto::nabla
boost::proto::terminal< SFOp< NablaOp > >::type const nabla
Definition: ElementOperations.hpp:813

atest-quadtriag.temperature
tuple temperature
Definition: atest-quadtriag.py:31

cf3::common::Option::change_value
virtual void change_value(const boost::any &value)
change the value of this option
Definition: Option.cpp:89

assign

cf3::mesh
Basic Classes for Mesh applications used by COOLFluiD.
Definition: AddPointRegion.cpp:33

cf3::solver::actions::Proto::FieldVariable< 0, ScalarField >

atest-boussinesq.model
tuple model
Global confifuration.
Definition: atest-boussinesq.py:18

cf3::solver::actions::Proto
Definition: BlockAccumulator.hpp:31

cf3::common::Component::get_child
Handle< Component > get_child(const std::string &name)
Definition: Component.cpp:441

cf3::common::PE::Comm::init
void init(int argc=0, char **args=0)
Definition: Comm.cpp:80

cf3
Top-level namespace for coolfluid.
Definition: Action.cpp:18

cf3::common::List< Uint >

LSSAction.hpp

Solver.hpp

Model.hpp

cf3::Tools::MeshGeneration::create_channel_3d
void create_channel_3d(BlockArrays &blocks, const Real length, const Real half_height, const Real width, const Uint x_segs, const Uint y_segs_half, const Uint z_segs, const Real ratio)
Definition: MeshGeneration.cpp:406

atest-ufem-navier-stokes-periodic-channel-2d.lss
lss
Definition: atest-ufem-navier-stokes-periodic-channel-2d.py:118

cf3::solver::actions::Proto::coordinates
boost::proto::terminal< SFOp< CoordinatesOp > >::type const coordinates
Definition: ElementOperations.hpp:809

UFEMBuildSparsityFixture
Definition: utest-ufem-buildsparsity.cpp:48

atest-boussinesq.domain
tuple domain
Definition: atest-boussinesq.py:19

cf3::math::LSS::System
Definition: System.hpp:59

cf3::solver::actions::Proto::group
static boost::proto::terminal< ExpressionGroupTag >::type group
Use group(expr1, expr2, ..., exprN) to evaluate a group of expressions.
Definition: ExpressionGroup.hpp:68

atest-quadtriag.length
int length
Definition: atest-quadtriag.py:32

cf3::common::Core::environment
common::Environment & environment() const
Definition: Core.cpp:168

cf3::Uint
unsigned int Uint
typedef for unsigned int
Definition: CF.hpp:90

Core.hpp

cf3::solver::Model
Definition: Model.hpp:34

Tags.hpp

cf3::solver::actions::Proto::create_proto_action
boost::shared_ptr< ProtoAction > create_proto_action(const std::string &name, const boost::shared_ptr< Expression > &expression)
Create a new ProtoAction, immediatly setting the expression.
Definition: ProtoAction.cpp:155

cf3::mesh::Mesh::topology
Region & topology() const
Definition: Mesh.hpp:51

cf3::common::Core::instance
static Core & instance()
Definition: Core.cpp:37

cf3::mesh::Mesh
Definition: Mesh.hpp:34

cf3::common::Component::handle
Handle< Component > handle()
Get a handle to the component.
Definition: Component.hpp:179

cf3::solver::actions::Proto::nodes_expression
boost::shared_ptr< NodesExpression< ExprT, boost::mpl::range_c< Uint, 1, 4 > > > nodes_expression(const ExprT &expr)
Definition: Expression.hpp:308

cf3::common::Component::options
OptionList & options()
Definition: Component.cpp:856

cf3::mesh::Mesh::geometry_fields
Dictionary & geometry_fields() const
Definition: Mesh.cpp:339

cf3::common::PE::Comm::instance
static Comm & instance()
Return a reference to the current PE.
Definition: Comm.cpp:44

Expression.hpp

cf3::common::Component
Base class for defining CF components.
Definition: Component.hpp:82

cf3::common::OptionList::set
void set(const std::string &pname, const boost::any &val)
Definition: OptionList.cpp:132

cf3::common::Component::create_component
Handle< Component > create_component(const std::string &name, const std::string &builder)
Build a (sub)component of this component using the extended type_name of the component.
Definition: Component.cpp:568

cf3::common::OptionList::option
const Option & option(const std::string &pname) const
get a constant option from the list
Definition: OptionList.cpp:52

cf3::mesh::BlockMesh::BlockArrays
Definition: BlockData.hpp:34

cf3::common
Most basic kernel library.
Definition: Action.cpp:19

cf3::solver::actions
Definition: AdvanceTime.cpp:24

SparsityBuilder.hpp

cf3::mesh::BlockMesh::BlockArrays::create_points
Handle< common::Table< Real > > create_points(const Uint dimensions, const Uint nb_points)
Create the table that holds the points for the blocks.
Definition: BlockData.cpp:1287