doxygen/utest-mesh-construction_8cpp_source.html

 // Copyright (C) 2010-2013 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 "Tests mesh construction"


 #include <iostream>

 #include <boost/test/unit_test.hpp>

 #include <boost/foreach.hpp>


 #include "common/Log.hpp"

 #include "common/Core.hpp"

 #include "common/FindComponents.hpp"

 #include "common/Group.hpp"

 #include "common/List.hpp"


 #include "mesh/Connectivity.hpp"

 #include "mesh/Mesh.hpp"

 #include "mesh/Region.hpp"

 #include "mesh/Elements.hpp"

 #include "mesh/Dictionary.hpp"

 #include "mesh/Space.hpp"

 #include "mesh/Field.hpp"

 #include "mesh/ElementData.hpp"

 #include "mesh/ElementType.hpp"

 #include "mesh/ElementConnectivity.hpp"


 #include "mesh/MeshWriter.hpp"


 using namespace std;

 using namespace boost;

 using namespace cf3;

 using namespace cf3::mesh;

 using namespace cf3::common;


 class ElementIterator :

     public boost::iterator_facade<ElementIterator,  // iterator

                                   Entity,                     // Value

                                   boost::random_access_traversal_tag, // search direction

                                   Entity                     // return type of dereference

                                  >

 {

   typedef boost::iterator_facade<ElementIterator,

                                  Entity,

                                  boost::random_access_traversal_tag,

                                  Entity

                                 > BaseT;

 public:


   typedef BaseT::difference_type difference_type;


   explicit ElementIterator(Entities& entities,

                            const Uint element_idx=0)

     : element(entities,element_idx) {}


 private:

   friend class boost::iterator_core_access;


   bool equal(ElementIterator const& other) const { return (element == other.element); }


   void increment()

   {

     ++element.idx;

   }


   void decrement()

   {

     --element.idx;

   }


   void advance(const difference_type n) { element.idx += n; }


   template <typename T2>

   difference_type distance_to(ElementIterator const& other) const

   {

     return other.element.idx - element.idx;

   }


 public:


   const Entity& dereference() const { return element; }


 private:


   Entity element;

 };


 boost::iterator_range<ElementIterator> make_range(Entities& entities)

 {

   ElementIterator begin(entities);

   return boost::make_iterator_range(begin,begin+static_cast<ElementIterator::difference_type>(entities.size()));

 }


 struct Mesh_API SpaceElement

 {


   SpaceElement(Space& component, const Uint index=0) :

     comp( &component ),

     idx(index)

   {

     cf3_assert(idx<comp->support().size());

   }


   Space* comp;

   Uint idx;


   const ShapeFunction& element_type() const { return comp->shape_function(); }


   Dictionary& dict() const { return comp->dict(); }


   Entity support() const { return Entity(comp->support(),idx); }


   Connectivity::ConstRow field_indices() const { return comp->connectivity()[idx]; }

   Uint glb_idx() const { return comp->support().glb_idx()[idx]; }

   Uint rank() const { return comp->support().rank()[idx]; }

   bool is_ghost() const { return comp->support().is_ghost(idx); }

   RealMatrix get_coordinates() const { return comp->get_coordinates(idx); }

   void put_coordinates(RealMatrix& coordinates) const { return comp->put_coordinates(coordinates,idx); }

   void allocate_coordinates(RealMatrix& coordinates) const { return comp->allocate_coordinates(coordinates); }

 };


 struct MeshConstruction_Fixture

 {

   MeshConstruction_Fixture()

   {

      // uncomment if you want to use arguments to the test executable

      //int*    argc = &boost::unit_test::framework::master_test_suite().argc;

      //char*** argv = &boost::unit_test::framework::master_test_suite().argv;

   }


   ~MeshConstruction_Fixture()

   {

   }


   RealVector create_coord(const Real& x, const Real& y) {

     RealVector coordVec(2);

     coordVec[XX]=x;

     coordVec[YY]=y;

     return coordVec;

   }


   std::vector<Uint> create_quad(const Uint& A, const Uint& B, const Uint& C, const Uint& D) {

     Uint quad[] = {A,B,C,D};

     std::vector<Uint> quadVec;

     quadVec.assign(quad,quad+4);

     return quadVec;

   }


   std::vector<Uint> create_triag(const Uint& A, const Uint& B, const Uint& C) {

     Uint triag[] = {A,B,C};

     std::vector<Uint> triagVec;

     triagVec.assign(triag,triag+3);

     return triagVec;

   }


   std::vector<Uint> create_quad_p2(const Uint A, const Uint B, const Uint C, const Uint D,

                                    const Uint E, const Uint F, const Uint G, const Uint H, const Uint I)

   {

     Uint quad[] = {A,B,C,D,E,F,G,H,I};

     std::vector<Uint> quadVec;

     quadVec.assign(quad,quad+9);

     return quadVec;

   }


   std::vector<Uint> create_triag_p2(const Uint A, const Uint B, const Uint C,

                                     const Uint D, const Uint E, const Uint F)

   {

     Uint triag[] = {A,B,C,D,E,F};

     std::vector<Uint> triagVec;

     triagVec.assign(triag,triag+6);

     return triagVec;

   }


 };


 BOOST_FIXTURE_TEST_SUITE( MeshConstruction_TestSuite, MeshConstruction_Fixture )


 BOOST_AUTO_TEST_CASE( P1_2D_MeshConstruction )

 {

   AssertionManager::instance().AssertionThrows = true;


   const Uint dim=2;


   // Create root and mesh component

   Component& root = Core::instance().root();


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


   // create regions

   Region& superRegion = mesh.topology().create_region("superRegion");

   Dictionary& nodes = mesh.geometry_fields();

   mesh.initialize_nodes(0,dim);

   BOOST_CHECK_EQUAL(nodes.coordinates().row_size() , dim);


   Elements& quadRegion = superRegion.create_elements("cf3.mesh.LagrangeP1.Quad2D",nodes);

   Elements& triagRegion = superRegion.create_elements("cf3.mesh.LagrangeP1.Triag2D",nodes);


   Table<Uint>::Buffer qTableBuffer = quadRegion.geometry_space().connectivity().create_buffer();

   Table<Uint>::Buffer tTableBuffer = triagRegion.geometry_space().connectivity().create_buffer();

   Table<Real>::Buffer coordinatesBuffer = nodes.coordinates().create_buffer();


   //  Mesh of quads and triangles with node and element numbering:

   //

   //    5----4----6

   //    |    |\ 3 |

   //    |    | \  |

   //    | 1  |  \ |

   //    |    | 2 \|

   //    3----2----7

   //    |    |\ 1 |

   //    |    | \  |

   //    | 0  |  \ |

   //    |    | 0 \|

   //    0----1----8


   // fill coordinates in the buffer

   coordinatesBuffer.add_row(create_coord( 0.0 , 0.0 ));  // 0

   coordinatesBuffer.add_row(create_coord( 1.0 , 0.0 ));  // 1

   coordinatesBuffer.add_row(create_coord( 1.0 , 1.0 ));  // 2

   coordinatesBuffer.add_row(create_coord( 0.0 , 1.0 ));  // 3

   coordinatesBuffer.add_row(create_coord( 1.0 , 2.0 ));  // 4

   coordinatesBuffer.add_row(create_coord( 0.0 , 2.0 ));  // 5

   coordinatesBuffer.add_row(create_coord( 2.0 , 2.0 ));  // 6

   coordinatesBuffer.add_row(create_coord( 2.0 , 1.0 ));  // 7

   coordinatesBuffer.add_row(create_coord( 2.0 , 0.0 ));  // 8


   // fill connectivity in the buffer

   qTableBuffer.add_row(create_quad( 0 , 1 , 2 , 3 ));

   qTableBuffer.add_row(create_quad( 3 , 2 , 4 , 5 ));


   tTableBuffer.add_row(create_triag( 1 , 8 , 2 ));

   tTableBuffer.add_row(create_triag( 8 , 7 , 2 ));

   tTableBuffer.add_row(create_triag( 2 , 7 , 4 ));

   tTableBuffer.add_row(create_triag( 7 , 6 , 4 ));


   // flush buffers into the table.

   // This causes the table and array to be resized and filled.

   coordinatesBuffer.flush();

   qTableBuffer.flush();

   tTableBuffer.flush();


   nodes.resize(nodes.coordinates().size());

   quadRegion.resize(quadRegion.size());

   triagRegion.resize(triagRegion.size());


   mesh.raise_mesh_loaded();

   BOOST_CHECK(true);


   // check if coordinates match

   Uint elem=1;

   Uint node=2;


   Table<Uint>::ConstRow nodesRef = triagRegion.geometry_space().connectivity()[elem];

   Table<Real>::Row coordRef = triagRegion.geometry_fields().coordinates()[nodesRef[node]];

   BOOST_CHECK_EQUAL(coordRef[0],1.0);

   BOOST_CHECK_EQUAL(coordRef[1],1.0);


   // calculate all volumes of a region

   BOOST_FOREACH( Elements& region, find_components_recursively<Elements>(superRegion))

   {

     const ElementType& elementType = region.element_type();

     const Uint nbRows = region.geometry_space().connectivity().size();

     std::vector<Real> volumes(nbRows);

     const Table<Real>& region_coordinates = region.geometry_fields().coordinates();

     const Table<Uint>& region_connTable = region.geometry_space().connectivity();


     // the loop

     RealMatrix elementCoordinates(elementType.nb_nodes(), elementType.dimension());

     for (Uint iElem=0; iElem<nbRows; ++iElem)

     {

       fill(elementCoordinates, region_coordinates, region_connTable[iElem]);


       volumes[iElem]=elementType.volume(elementCoordinates);


       // check

       if(elementType.shape() == GeoShape::QUAD)

         BOOST_CHECK_EQUAL(volumes[iElem],1.0);

       if(elementType.shape() == GeoShape::TRIAG)

         BOOST_CHECK_EQUAL(volumes[iElem],0.5);

     }

   }


 //  BOOST_FOREACH(Table<Real>::Row node , elem_coord)

 //  {

 //    CFinfo << "node = ";

 //    for (Uint j=0; j<node.size(); j++) {

 //      CFinfo << node[j] << " ";

 //    }

 //    CFinfo << "\n" << CFflush;

 //  }


   boost::shared_ptr< MeshWriter > meshwriter = build_component_abstract_type<MeshWriter>("cf3.mesh.gmsh.Writer","meshwriter");

   meshwriter->write_from_to(mesh,"p1-mesh.msh");


   Entity entity(quadRegion,0);


   SpaceElement space_elem(quadRegion.space(nodes),0);

   BOOST_CHECK_EQUAL( space_elem.field_indices()[0] , 0 );


   RealMatrix geom_coords  = space_elem.support().get_coordinates();

   RealMatrix space_coords = space_elem.get_coordinates();


   BOOST_CHECK( geom_coords == space_coords );


   for(SpaceElement elem(quadRegion.space(nodes)); elem.idx<quadRegion.size(); ++elem.idx)

   {

     CFinfo << "indices = ";

     boost_foreach(Uint field_idx, elem.field_indices())

       CFinfo << field_idx << " ";

     CFinfo << CFendl;

   }

   ElementIterator it(quadRegion);

   boost_foreach( const Entity& entity, make_range(quadRegion) )

   {

     std::cout << entity << std::endl;

   }


 }


 BOOST_AUTO_TEST_CASE( P2_2D_MeshConstruction )

 {

   AssertionManager::instance().AssertionThrows = true;


   const Uint dim=2;


   // Create root and mesh component

   boost::shared_ptr<Component> root = boost::static_pointer_cast<Component>(allocate_component<Group>("root"));


   Mesh& mesh = *root->create_component<Mesh>( "mesh" );


   // create regions

   Region& superRegion = mesh.topology().create_region("superRegion");

   Dictionary& nodes = mesh.geometry_fields();

   mesh.initialize_nodes(0,dim);

   BOOST_CHECK_EQUAL(nodes.coordinates().row_size() , dim);

   Elements& quadRegion = superRegion.create_elements("cf3.mesh.LagrangeP2.Quad2D",nodes);

   Elements& triagRegion = superRegion.create_elements("cf3.mesh.LagrangeP2.Triag2D",nodes);


   Table<Uint>::Buffer qTableBuffer = quadRegion.geometry_space().connectivity().create_buffer();

   Table<Uint>::Buffer tTableBuffer = triagRegion.geometry_space().connectivity().create_buffer();

   Table<Real>::Buffer coordinatesBuffer = nodes.coordinates().create_buffer();


   //  Mesh of quads and triangles with node numbering and element numbering in brackets:

   //

   //  Y ^

   //    |

   //  2 -  5--15---4--24--6

   //    |  |       |\     |

   //    |  |       | \ (3)|

   // 1.5-  16 17  14  22 23

   //    |  |       |   \  |

   //    |  |  (1)  |(2) \ |

   //    |  |       |     \|

   //  1 -  3--11---2--21--7

   //    |  |       |\     |

   //    |  |       | \ (1)|

   // 0.5-  12 13  10  19 20

   //    |  |       |   \  |

   //    |  |  (0)  | (0)\ |

   //    |  |       |     \|

   //  0 -  0---9---1--18--8

   //    |

   //    o--|---|---|--|--|------> X

   //       0  0.5  1 1.5  2


   // fill coordinates in the buffer of the P1 mesh

   coordinatesBuffer.add_row(create_coord( 0.0 , 0.0 ));  // 0

   coordinatesBuffer.add_row(create_coord( 1.0 , 0.0 ));  // 1

   coordinatesBuffer.add_row(create_coord( 1.0 , 1.0 ));  // 2

   coordinatesBuffer.add_row(create_coord( 0.0 , 1.0 ));  // 3

   coordinatesBuffer.add_row(create_coord( 1.0 , 2.0 ));  // 4

   coordinatesBuffer.add_row(create_coord( 0.0 , 2.0 ));  // 5

   coordinatesBuffer.add_row(create_coord( 2.0 , 2.0 ));  // 6

   coordinatesBuffer.add_row(create_coord( 2.0 , 1.0 ));  // 7

   coordinatesBuffer.add_row(create_coord( 2.0 , 0.0 ));  // 8


   // enrich

   coordinatesBuffer.add_row(create_coord( 0.5 , 0.0 ));  // 9

   coordinatesBuffer.add_row(create_coord( 1.0 , 0.5 ));  // 10

   coordinatesBuffer.add_row(create_coord( 0.5 , 1.0 ));  // 11

   coordinatesBuffer.add_row(create_coord( 0.0 , 0.5 ));  // 12

   coordinatesBuffer.add_row(create_coord( 0.5 , 0.5 ));  // 13

   coordinatesBuffer.add_row(create_coord( 1.0 , 1.5 ));  // 14

   coordinatesBuffer.add_row(create_coord( 0.5 , 2.0 ));  // 15

   coordinatesBuffer.add_row(create_coord( 0.0 , 1.5 ));  // 16

   coordinatesBuffer.add_row(create_coord( 0.5 , 1.5 ));  // 17

   coordinatesBuffer.add_row(create_coord( 1.5 , 0.0 ));  // 18

   coordinatesBuffer.add_row(create_coord( 1.5 , 0.5 ));  // 19

   coordinatesBuffer.add_row(create_coord( 2.0 , 0.5 ));  // 20

   coordinatesBuffer.add_row(create_coord( 1.5 , 1.0 ));  // 21

   coordinatesBuffer.add_row(create_coord( 1.5 , 1.5 ));  // 22

   coordinatesBuffer.add_row(create_coord( 2.0 , 1.5 ));  // 23

   coordinatesBuffer.add_row(create_coord( 1.5 , 2.0 ));  // 24


   // enrich


   // fill connectivity in the buffer

   qTableBuffer.add_row(create_quad_p2( 0 , 1 , 2 , 3 , 9 , 10, 11, 12, 13 ));

   qTableBuffer.add_row(create_quad_p2( 3 , 2 , 4 , 5 , 11, 14, 15, 16, 17 ));


   tTableBuffer.add_row(create_triag_p2( 1 , 8 , 2 , 18 , 19 , 10 ));

   tTableBuffer.add_row(create_triag_p2( 8 , 7 , 2 , 20 , 21 , 19 ));

   tTableBuffer.add_row(create_triag_p2( 2 , 7 , 4 , 21 , 22 , 14 ));

   tTableBuffer.add_row(create_triag_p2( 7 , 6 , 4 , 23 , 24 , 22 ));


   // flush buffers into the table.

   // This causes the table and array to be resized and filled.

   coordinatesBuffer.flush();

   qTableBuffer.flush();

   tTableBuffer.flush();


   nodes.resize(nodes.coordinates().size());

   quadRegion.resize(quadRegion.size());

   triagRegion.resize(triagRegion.size());


   mesh.raise_mesh_loaded();

   BOOST_CHECK(true);


   // check if coordinates match

   Uint elem=1;

   Uint node=2;


   Table<Uint>::ConstRow nodesRef = triagRegion.geometry_space().connectivity()[elem];

   Table<Real>::Row coordRef = triagRegion.geometry_fields().coordinates()[nodesRef[node]];

   BOOST_CHECK_EQUAL(coordRef[0],1.0);

   BOOST_CHECK_EQUAL(coordRef[1],1.0);


 //  // calculate all volumes of a region

 //  BOOST_FOREACH( Elements& region, find_components_recursively<Elements>(superRegion))

 //  {

 //    const ElementType& elementType = region.element_type();

 //    const Uint nbRows = region.geometry_space().connectivity().size();

 //    std::vector<Real> volumes(nbRows);

 //    const Table<Real>& region_coordinates = region.coordinates();

 //    const Table<Uint>& region_connTable = region.geometry_space().connectivity();

 //    // the loop

 //    ElementType::NodesT elementCoordinates(elementType.nb_nodes(), elementType.dimension());

 //    for (Uint iElem=0; iElem<nbRows; ++iElem)

 //    {

 //      elementCoordinates.fill(region_coordinates, region_connTable[iElem]);

 //

 //      volumes[iElem]=elementType.compute_volume(elementCoordinates);

 //

 //      // check

 //      if(elementType.shape() == GeoShape::QUAD)

 //        BOOST_CHECK_EQUAL(volumes[iElem],1.0);

 //      if(elementType.shape() == GeoShape::TRIAG)

 //        BOOST_CHECK_EQUAL(volumes[iElem],0.5);

 //    }

 //  }

 //

 //  //  BOOST_FOREACH(Table<Real>::Row node , elem_coord)

 //  //  {

 //  //    CFinfo << "node = ";

 //  //    for (Uint j=0; j<node.size(); j++) {

 //  //      CFinfo << node[j] << " ";

 //  //    }

 //  //    CFinfo << "\n" << CFflush;

 //  //  }


   boost::shared_ptr< MeshWriter > meshwriter = build_component_abstract_type<MeshWriter>("cf3.mesh.gmsh.Writer","meshwriter");

   meshwriter->write_from_to(mesh,"p2-mesh.msh");


 }


 BOOST_AUTO_TEST_SUITE_END()


F
#define F(x, y, z)

CFinfo
#define CFinfo
these are always defined
Definition: Log.hpp:104

cf3::mesh::Space::shape_function
const ShapeFunction & shape_function() const
Definition: Space.cpp:102

cf3::mesh::Entity::get_coordinates
RealMatrix get_coordinates() const
Definition: Entities.cpp:213

test-mpi-scalability.idx
tuple idx
Definition: test-mpi-scalability.py:49

SpaceElement::rank
Uint rank() const
Definition: utest-mesh-construction.cpp:126

cf3::mesh::ShapeFunction
Definition: ShapeFunction.hpp:31

ElementIterator::decrement
void decrement()
Definition: utest-mesh-construction.cpp:72

ElementIterator::increment
void increment()
Definition: utest-mesh-construction.cpp:67

boost
external boost library namespace
Definition: BoostAssertions.cpp:12

cf3::mesh::Entities::geometry_space
Space & geometry_space() const
Definition: Entities.hpp:94

cf3::mesh::Mesh::initialize_nodes
void initialize_nodes(const Uint nb_nodes, const Uint dimension)
will among others set the coordinate dimension for the nodes
Definition: Mesh.cpp:127

ElementIterator::distance_to
difference_type distance_to(ElementIterator const &other) const
Definition: utest-mesh-construction.cpp:80

SpaceElement::comp
Space * comp
Definition: utest-mesh-construction.cpp:113

SpaceElement::field_indices
Connectivity::ConstRow field_indices() const
Definition: utest-mesh-construction.cpp:124

cf3::mesh::ElementType
Definition: ElementType.hpp:34

cf3::mesh::Entities
Definition: Entities.hpp:35

cf3::mesh::Entity::idx
Uint idx
Definition: Entities.hpp:161

MeshConstruction_Fixture::create_triag_p2
std::vector< Uint > create_triag_p2(const Uint A, const Uint B, const Uint C, const Uint D, const Uint E, const Uint F)
create a Uint vector with 3 node ID's
Definition: utest-mesh-construction.cpp:189

List.hpp

cf3_assert
#define cf3_assert(a)
Definition: Assertions.hpp:93

cf3::mesh::Entities::element_type
ElementType & element_type() const
return the elementType
Definition: Entities.cpp:116

cf3::mesh::Region::create_region
Region & create_region(const std::string &name)
Definition: Region.cpp:50

SpaceElement::idx
Uint idx
Definition: utest-mesh-construction.cpp:114

std
STL namespace.

Mesh_API
#define Mesh_API
Definition: LibMesh.hpp:24

cf3::common::Table::create_buffer
Buffer create_buffer(const size_t buffersize=16384)
Definition: Table.hpp:102

cf3::mesh::Entities::is_ghost
bool is_ghost(const Uint idx) const
Definition: Entities.cpp:197

boost::iterator_range
Definition: Component.hpp:32

boost_foreach
#define boost_foreach
lowercase version of BOOST_FOREACH
Definition: Foreach.hpp:16

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

cf3::mesh::Entities::rank
common::List< Uint > & rank()
Definition: Entities.hpp:71

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

ElementIterator::advance
void advance(const difference_type n)
Definition: utest-mesh-construction.cpp:77

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

MeshConstruction_Fixture
Definition: utest-mesh-construction.cpp:136

cf3::mesh::Space::support
Entities & support() const
Access the geometric support.
Definition: Space.hpp:102

CFendl
#define CFendl
Definition: Log.hpp:109

ElementIterator
Definition: utest-mesh-construction.cpp:39

ElementIterator::element
Entity element
Definition: utest-mesh-construction.cpp:92

cf3::solver::actions::Proto::nodes
boost::proto::terminal< SFOp< NodesOp > >::type const nodes
Definition: ElementOperations.hpp:807

MeshConstruction_Fixture::~MeshConstruction_Fixture
~MeshConstruction_Fixture()
common tear-down for each test case
Definition: utest-mesh-construction.cpp:147

cf3::mesh::Entities::geometry_fields
Dictionary & geometry_fields() const
Const access to the coordinates.
Definition: Entities.hpp:63

cf3::XX
Definition: Defs.hpp:17

ElementType.hpp

cf3::RealMatrix
Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic > RealMatrix
Dynamic sized matrix of Real scalars.
Definition: MatrixTypes.hpp:22

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

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

SpaceElement::SpaceElement
SpaceElement(Space &component, const Uint index=0)
Definition: utest-mesh-construction.cpp:106

atest-quadtriag.x
list x
Definition: atest-quadtriag.py:34

ElementIterator::ElementIterator
ElementIterator(Entities &entities, const Uint element_idx=0)
Definition: utest-mesh-construction.cpp:58

ElementConnectivity.hpp

cf3::mesh::Entities::size
Uint size() const
return the number of elements
Definition: Entities.cpp:161

SpaceElement::get_coordinates
RealMatrix get_coordinates() const
Definition: utest-mesh-construction.cpp:128

SpaceElement::support
Entity support() const
Definition: utest-mesh-construction.cpp:122

SpaceElement::element_type
const ShapeFunction & element_type() const
return the elementType
Definition: utest-mesh-construction.cpp:117

cf3::mesh::Elements
Definition: Elements.hpp:30

FindComponents.hpp

SpaceElement
Definition: utest-mesh-construction.cpp:103

Space.hpp

Elements.hpp

atest-ufem-demo-all.n
int n
Definition: atest-ufem-demo-all.py:12

SpaceElement::is_ghost
bool is_ghost() const
Definition: utest-mesh-construction.cpp:127

Group.hpp

cf3::mesh::Entities::glb_idx
common::List< Uint > & glb_idx()
Mutable access to the list of nodes.
Definition: Entities.hpp:66

Region.hpp

Dictionary.hpp

SpaceElement::dict
Dictionary & dict() const
Const access to the coordinates.
Definition: utest-mesh-construction.cpp:120

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

cf3::mesh::ElementType::volume
virtual Real volume(const RealMatrix &nodes) const =0

ElementIterator::dereference
const Entity & dereference() const
dereferencing
Definition: utest-mesh-construction.cpp:88

cf3::RealVector
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealVector
Dynamic sized column vector.
Definition: MatrixTypes.hpp:25

ElementIterator::difference_type
BaseT::difference_type difference_type
Definition: utest-mesh-construction.cpp:53

cf3::mesh::ElementType::shape
GeoShape::Type shape() const
Definition: ElementType.hpp:64

ElementIterator::equal
bool equal(ElementIterator const &other) const
Definition: utest-mesh-construction.cpp:65

ElementIterator::BaseT
boost::iterator_facade< ElementIterator, Entity, boost::random_access_traversal_tag, Entity > BaseT
Definition: utest-mesh-construction.cpp:50

cf3::mesh::Space::allocate_coordinates
void allocate_coordinates(RealMatrix &coordinates) const
Allocate element coordinates.
Definition: Space.cpp:172

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

MeshConstruction_Fixture::create_quad
std::vector< Uint > create_quad(const Uint &A, const Uint &B, const Uint &C, const Uint &D)
create a Uint vector with 4 node ID's
Definition: utest-mesh-construction.cpp:164

cf3::mesh::Entities::resize
void resize(const Uint nb_elem)
Definition: Entities.cpp:246

BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(P1_2D_MeshConstruction)
Definition: utest-mesh-construction.cpp:208

Connectivity.hpp

atest-ufem-particles-taylor-green-polydisperse.D
float D
Definition: atest-ufem-particles-taylor-green-polydisperse.py:17

utest-solver-actions-randomize.y
list y
Definition: utest-solver-actions-randomize.py:56

cf3::mesh::fill
void fill(NodeValuesT &to_fill, const common::Table< Real > &data_array, const RowT &element_row, const Uint start=0)
Fill STL-vector like per-node data storage.
Definition: ElementData.hpp:28

ElementData.hpp

cf3::common::Table
Component holding a 2 dimensional array of a templated type.
Definition: Table.hpp:45

cf3::mesh::Space::get_coordinates
RealMatrix get_coordinates(const Uint elem_idx) const
Lookup element coordinates.
Definition: Space.cpp:179

MeshConstruction_Fixture::create_coord
RealVector create_coord(const Real &x, const Real &y)
possibly common functions used on the tests below
Definition: utest-mesh-construction.cpp:156

cf3::mesh::Mesh::raise_mesh_loaded
void raise_mesh_loaded()
Definition: Mesh.cpp:479

cf3::common::Table::row_size
Uint row_size(Uint i=0) const
Definition: Table.hpp:133

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

make_range
boost::iterator_range< ElementIterator > make_range(Entities &entities)
Definition: utest-mesh-construction.cpp:95

cf3::mesh::Entity
Low storage struct to uniquely identify one element.
Definition: Entities.hpp:141

atest-ufem-navier-stokes-restart.elem
string elem
Definition: atest-ufem-navier-stokes-restart.py:237

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

Field.hpp

MeshConstruction_Fixture::MeshConstruction_Fixture
MeshConstruction_Fixture()
common setup for each test case
Definition: utest-mesh-construction.cpp:139

Core.hpp

Log.hpp

SpaceElement::allocate_coordinates
void allocate_coordinates(RealMatrix &coordinates) const
Definition: utest-mesh-construction.cpp:130

cf3::mesh::Dictionary::resize
void resize(const Uint size)
Resize the contained fields.
Definition: Dictionary.cpp:106

cf3::mesh::ElementType::nb_nodes
Uint nb_nodes() const
Definition: ElementType.hpp:73

atest-ufem-particles-burgers.volumes
list volumes
Definition: atest-ufem-particles-burgers.py:29

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

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

MeshConstruction_Fixture::create_triag
std::vector< Uint > create_triag(const Uint &A, const Uint &B, const Uint &C)
create a Uint vector with 3 node ID's
Definition: utest-mesh-construction.cpp:172

cf3::mesh::Dictionary
Definition: Dictionary.hpp:38

Mesh.hpp

cf3::YY
Definition: Defs.hpp:17

cf3::mesh::Space::dict
Dictionary & dict() const
Dictionary this space belongs to.
Definition: Space.hpp:92

MeshWriter.hpp

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

SpaceElement::glb_idx
Uint glb_idx() const
Definition: utest-mesh-construction.cpp:125

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

cf3::mesh::Space
Space component class.
Definition: Space.hpp:59

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
Most basic kernel library.
Definition: Action.cpp:19

MeshConstruction_Fixture::create_quad_p2
std::vector< Uint > create_quad_p2(const Uint A, const Uint B, const Uint C, const Uint D, const Uint E, const Uint F, const Uint G, const Uint H, const Uint I)
Definition: utest-mesh-construction.cpp:179

cf3::mesh::Space::put_coordinates
void put_coordinates(RealMatrix &coordinates, const Uint elem_idx) const
Lookup element coordinates.
Definition: Space.cpp:153

cf3::mesh::ElementType::dimension
Uint dimension() const
Definition: ElementType.hpp:82

cf3::mesh::Space::connectivity
Connectivity & connectivity()
connectivity table to dictionary entries
Definition: Space.hpp:110

SpaceElement::put_coordinates
void put_coordinates(RealMatrix &coordinates) const
Definition: utest-mesh-construction.cpp:129