// Creates a PropertyVector<unsigned> and maps it into a vtkDataArray-equivalent
TEST(MeshLibMappedPropertyVector, Unsigned)
{
const std::size_t mesh_size = 5;
const double length = 1.0;
MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
ASSERT_TRUE(mesh != nullptr);
const std::size_t number_of_tuples(mesh_size*mesh_size*mesh_size);
std::string const prop_name("TestProperty");
auto* const properties =
mesh->getProperties().createNewPropertyVector<unsigned>(
prop_name, MeshLib::MeshItemType::Cell);
properties->resize(number_of_tuples);
std::iota(properties->begin(), properties->end(), 0);
vtkNew<MeshLib::VtkMappedPropertyVectorTemplate<unsigned> > dataArray;
dataArray->SetPropertyVector(*properties);
ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
ASSERT_EQ(dataArray->GetNumberOfTuples(), number_of_tuples);
ASSERT_EQ(dataArray->GetValueReference(0), 0);
double* range = dataArray->GetRange(0);
ASSERT_EQ(range[0], 0);
ASSERT_EQ(range[1], 0 + mesh->getNumberOfElements() - 1);
delete mesh;
}
std::size_t ElementValueModification::setByElementType(MeshLib::Mesh &mesh, MeshElemType ele_type, int const new_value)
{
MeshLib::PropertyVector<int>* property_value_vector = nullptr;
try
{
property_value_vector = mesh.getProperties().getPropertyVector<int>(
"MaterialIDs", MeshLib::MeshItemType::Cell, 1);
}
catch (std::runtime_error const& e)
{
ERR("%s", e.what());
return 0;
}
std::vector<MeshLib::Element*> const& elements(mesh.getElements());
std::size_t cnt(0);
for (std::size_t k(0); k < elements.size(); k++)
{
if (elements[k]->getGeomType() != ele_type)
{
continue;
}
(*property_value_vector)[k] = new_value;
cnt++;
}
return cnt;
}
std::unique_ptr<PythonBoundaryCondition> createPythonBoundaryCondition(
BaseLib::ConfigTree const& config, MeshLib::Mesh const& boundary_mesh,
NumLib::LocalToGlobalIndexMap const& dof_table, std::size_t bulk_mesh_id,
int const variable_id, int const component_id,
unsigned const integration_order, unsigned const shapefunction_order,
unsigned const global_dim)
{
//! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__type}
config.checkConfigParameter("type", "Python");
//! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__Python__bc_object}
auto const bc_object = config.getConfigParameter<std::string>("bc_object");
//! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__Python__flush_stdout}
auto const flush_stdout = config.getConfigParameter("flush_stdout", false);
// Evaluate Python code in scope of main module
pybind11::object scope =
pybind11::module::import("__main__").attr("__dict__");
if (!scope.contains(bc_object))
OGS_FATAL(
"Function `%s' is not defined in the python script file, or there "
"was no python script file specified.",
bc_object.c_str());
auto* bc = scope[bc_object.c_str()]
.cast<PythonBoundaryConditionPythonSideInterface*>();
if (variable_id >= static_cast<int>(dof_table.getNumberOfVariables()) ||
component_id >= dof_table.getNumberOfVariableComponents(variable_id))
{
OGS_FATAL(
"Variable id or component id too high. Actual values: (%d, %d), "
"maximum values: (%d, %d).",
variable_id, component_id, dof_table.getNumberOfVariables(),
dof_table.getNumberOfVariableComponents(variable_id));
}
// In case of partitioned mesh the boundary could be empty, i.e. there is no
// boundary condition.
#ifdef USE_PETSC
// This can be extracted to createBoundaryCondition() but then the config
// parameters are not read and will cause an error.
// TODO (naumov): Add a function to ConfigTree for skipping the tags of the
// subtree and move the code up in createBoundaryCondition().
if (boundary_mesh.getDimension() == 0 &&
boundary_mesh.getNumberOfNodes() == 0 &&
boundary_mesh.getNumberOfElements() == 0)
{
return nullptr;
}
#endif // USE_PETSC
return std::make_unique<PythonBoundaryCondition>(
PythonBoundaryConditionData{
bc, dof_table, bulk_mesh_id,
dof_table.getGlobalComponent(variable_id, component_id),
boundary_mesh},
integration_order, shapefunction_order, global_dim, flush_stdout);
}
IntegrationPointMetaData getIntegrationPointMetaData(MeshLib::Mesh const& mesh,
std::string const& name)
{
if (!mesh.getProperties().existsPropertyVector<char>(
"IntegrationPointMetaData"))
{
OGS_FATAL(
"Integration point data '%s' is present in the vtk field "
"data but the required 'IntegrationPointMetaData' array "
"is not available.",
name.c_str());
}
auto const& mesh_property_ip_meta_data =
*mesh.getProperties().template getPropertyVector<char>(
"IntegrationPointMetaData");
if (mesh_property_ip_meta_data.getMeshItemType() !=
MeshLib::MeshItemType::IntegrationPoint)
{
OGS_FATAL("IntegrationPointMetaData array must be field data.");
}
// Find the current integration point data entry and extract the
// meta data.
auto const ip_meta_data = extractIntegrationPointMetaData(
json::parse(mesh_property_ip_meta_data.begin(),
mesh_property_ip_meta_data.end()),
name);
return ip_meta_data;
}
void MeshSurfaceExtraction::getSurfaceAreaForNodes(const MeshLib::Mesh &mesh, std::vector<double> &node_area_vec)
{
if (mesh.getDimension() == 2)
{
double total_area (0);
// for each node, a vector containing all the element idget every element
const std::vector<MeshLib::Node*> &nodes = mesh.getNodes();
const size_t nNodes ( mesh.getNNodes() );
node_area_vec.reserve(nNodes);
for (size_t n=0; n<nNodes; ++n)
{
double node_area (0);
std::vector<MeshLib::Element*> conn_elems = nodes[n]->getElements();
const size_t nConnElems (conn_elems.size());
for (size_t i=0; i<nConnElems; ++i)
{
const MeshLib::Element* elem (conn_elems[i]);
const unsigned nElemParts = (elem->getGeomType() == MeshElemType::TRIANGLE) ? 3 : 4;
const double area = conn_elems[i]->getContent() / nElemParts;
node_area += area;
total_area += area;
}
node_area_vec.push_back(node_area);
}
INFO ("Total surface Area: %f", total_area);
}
else
ERR ("Error in MeshSurfaceExtraction::getSurfaceAreaForNodes() - Given mesh is no surface mesh (dimension != 2).");
}
void LayeredVolume::addLayerBoundaries(const MeshLib::Mesh &layer, std::size_t nLayers)
{
const unsigned nLayerBoundaries (nLayers-1);
const std::size_t nNodes (layer.getNNodes());
const std::vector<MeshLib::Element*> &layer_elements (layer.getElements());
for (MeshLib::Element* elem : layer_elements)
{
const std::size_t nElemNodes (elem->getNBaseNodes());
for (unsigned i=0; i<nElemNodes; ++i)
if (elem->getNeighbor(i) == nullptr)
for (unsigned j=0; j<nLayerBoundaries; ++j)
{
const std::size_t offset (j*nNodes);
MeshLib::Node* n0 = _nodes[offset + elem->getNodeIndex(i)];
MeshLib::Node* n1 = _nodes[offset + elem->getNodeIndex((i+1)%nElemNodes)];
MeshLib::Node* n2 = _nodes[offset + nNodes + elem->getNodeIndex((i+1)%nElemNodes)];
MeshLib::Node* n3 = _nodes[offset + nNodes + elem->getNodeIndex(i)];
if (MathLib::Vector3(*n1, *n2).getLength() > std::numeric_limits<double>::epsilon())
{
const std::array<MeshLib::Node*,3> tri_nodes = {{ n0, n2, n1 }};
_elements.push_back(new MeshLib::Tri(tri_nodes, nLayers+1+j));
}
if (MathLib::Vector3(*n0, *n3).getLength() > std::numeric_limits<double>::epsilon())
{
const std::array<MeshLib::Node*,3> tri_nodes = {{ n0, n3, n2 }};
_elements.push_back(new MeshLib::Tri(tri_nodes, nLayers+1+j));
}
}
}
}
void HeatTransportBHEProcess::initializeConcreteProcess(
NumLib::LocalToGlobalIndexMap const& dof_table,
MeshLib::Mesh const& mesh,
unsigned const integration_order)
{
// Quick access map to BHE's through element ids.
std::unordered_map<std::size_t, BHE::BHETypes*> element_to_bhe_map;
int const n_BHEs = _process_data._vec_BHE_property.size();
for (int i = 0; i < n_BHEs; i++)
{
auto const& bhe_elements = _bheMeshData.BHE_elements[i];
for (auto const& e : bhe_elements)
{
element_to_bhe_map[e->getID()] =
&_process_data._vec_BHE_property[i];
}
}
assert(mesh.getDimension() == 3);
ProcessLib::HeatTransportBHE::createLocalAssemblers<
HeatTransportBHELocalAssemblerSoil, HeatTransportBHELocalAssemblerBHE>(
mesh.getElements(), dof_table, _local_assemblers, element_to_bhe_map,
mesh.isAxiallySymmetric(), integration_order, _process_data);
// Create BHE boundary conditions for each of the BHEs
createBHEBoundaryConditionTopBottom(_bheMeshData.BHE_nodes);
}
// Creates a PropertyVector<double> and maps it into a vtkDataArray-equivalent
TEST(InSituLibMappedPropertyVector, Int)
{
const size_t mesh_size = 5;
const double length = 1.0;
MeshLib::Mesh* mesh = MeshLib::MeshGenerator::generateRegularHexMesh(length, mesh_size);
ASSERT_TRUE(mesh != nullptr);
const std::size_t size(mesh_size*mesh_size*mesh_size);
std::string const prop_name("TestProperty");
boost::optional<MeshLib::PropertyVector<int> &> properties(
mesh->getProperties().createNewPropertyVector<int>(prop_name,
MeshLib::MeshItemType::Cell));
(*properties).resize(size);
std::iota((*properties).begin(), (*properties).end(), 1);
vtkNew<InSituLib::VtkMappedPropertyVectorTemplate<int> > dataArray;
dataArray->SetPropertyVector(*properties);
ASSERT_EQ(dataArray->GetNumberOfComponents(), 1);
ASSERT_EQ(dataArray->GetNumberOfTuples(), size);
ASSERT_EQ(dataArray->GetValueReference(0), 1);
double* range = dataArray->GetRange(0);
ASSERT_EQ(range[0], 1);
ASSERT_EQ(range[1], 1 + mesh->getNElements() - 1);
delete mesh;
}
void LiquidFlowProcess::initializeConcreteProcess(
NumLib::LocalToGlobalIndexMap const& dof_table,
MeshLib::Mesh const& mesh,
unsigned const integration_order)
{
ProcessLib::ProcessVariable const& pv = getProcessVariables()[0];
ProcessLib::createLocalAssemblers<LiquidFlowLocalAssembler>(
mesh.getDimension(), mesh.getElements(), dof_table,
pv.getShapeFunctionOrder(), _local_assemblers,
mesh.isAxiallySymmetric(), integration_order, _gravitational_axis_id,
_gravitational_acceleration, _material_properties);
_secondary_variables.addSecondaryVariable(
"darcy_velocity_x", 1,
makeExtrapolator(
getExtrapolator(), _local_assemblers,
&LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocityX));
if (mesh.getDimension() > 1)
{
_secondary_variables.addSecondaryVariable(
"darcy_velocity_y", 1,
makeExtrapolator(
getExtrapolator(), _local_assemblers,
&LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocityY));
}
if (mesh.getDimension() > 2)
{
_secondary_variables.addSecondaryVariable(
"darcy_velocity_z", 1,
makeExtrapolator(
getExtrapolator(), _local_assemblers,
&LiquidFlowLocalAssemblerInterface::getIntPtDarcyVelocityZ));
}
}
std::size_t ElementValueModification::setByElementType(MeshLib::Mesh &mesh, MeshElemType ele_type, int const new_value)
{
boost::optional<MeshLib::PropertyVector<int> &>
optional_property_value_vec(
mesh.getProperties().getPropertyVector<int>("MaterialIDs")
);
if (!optional_property_value_vec) {
return 0;
}
MeshLib::PropertyVector<int> & property_value_vector(
optional_property_value_vec.get()
);
std::vector<MeshLib::Element*> const& elements(mesh.getElements());
std::size_t cnt(0);
for (std::size_t k(0); k<elements.size(); k++) {
if (elements[k]->getGeomType()!=ele_type)
continue;
property_value_vector[k] = new_value;
cnt++;
}
return cnt;
}
void RichardsComponentTransportProcess::initializeConcreteProcess(
NumLib::LocalToGlobalIndexMap const& dof_table,
MeshLib::Mesh const& mesh,
unsigned const integration_order)
{
const int monolithic_process_id = 0;
ProcessLib::ProcessVariable const& pv =
getProcessVariables(monolithic_process_id)[0];
ProcessLib::createLocalAssemblers<LocalAssemblerData>(
mesh.getDimension(), mesh.getElements(), dof_table,
pv.getShapeFunctionOrder(), _local_assemblers,
mesh.isAxiallySymmetric(), integration_order, _process_data);
_secondary_variables.addSecondaryVariable(
"darcy_velocity",
makeExtrapolator(mesh.getDimension(), getExtrapolator(),
_local_assemblers,
&RichardsComponentTransportLocalAssemblerInterface::
getIntPtDarcyVelocity));
_secondary_variables.addSecondaryVariable(
"saturation",
makeExtrapolator(1, getExtrapolator(), _local_assemblers,
&RichardsComponentTransportLocalAssemblerInterface::
getIntPtSaturation));
}
std::unique_ptr<InitialCondition> createMeshPropertyInitialCondition(
BaseLib::ConfigTree const& config,
MeshLib::Mesh const& mesh,
int const n_components)
{
auto field_name = config.getConfParam<std::string>("field_name");
DBUG("Using field_name %s", field_name.c_str());
if (!mesh.getProperties().hasPropertyVector(field_name))
{
ERR("The required property %s does not exists in the mesh.",
field_name.c_str());
std::abort();
}
auto const& property =
mesh.getProperties().template getPropertyVector<double>(field_name);
if (!property)
{
ERR("The required property %s is not of the requested type.",
field_name.c_str());
std::abort();
}
if (property->getNumberOfComponents() !=
static_cast<std::size_t>(n_components))
{
ERR("The required property %s has different number of components %d, "
"expected %d.",
field_name.c_str(), property->getNumberOfComponents(), n_components);
std::abort();
}
return std::unique_ptr<InitialCondition>(
new MeshPropertyInitialCondition(*property));
}
std::unique_ptr<ParameterBase> createMeshPropertyParameter(
BaseLib::ConfigTree const config, MeshLib::Mesh const& mesh)
{
auto field_name = config.get_optional<std::string>("field_name");
if (!field_name)
{
ERR("Could not find required parameter field_name.");
std::abort();
}
DBUG("Using field_name %s", field_name->c_str());
if (!mesh.getProperties().hasPropertyVector(*field_name))
{
ERR("The required property %s does not exists in the mesh.",
field_name->c_str());
std::abort();
}
auto const& property =
mesh.getProperties().template getPropertyVector<double>(*field_name);
if (!property)
{
ERR("The required property %s is not of the requested type.",
field_name->c_str());
std::abort();
}
return std::unique_ptr<ParameterBase>(
new MeshPropertyParameter<double>(*property));
}
bool MeshLayerMapper::layerMapping(MeshLib::Mesh &new_mesh, GeoLib::Raster const& raster, double noDataReplacementValue = 0.0)
{
if (new_mesh.getDimension() != 2)
{
ERR("MshLayerMapper::layerMapping() - requires 2D mesh");
return false;
}
GeoLib::RasterHeader const& header (raster.getHeader());
const double x0(header.origin[0]);
const double y0(header.origin[1]);
const double delta(header.cell_size);
const std::pair<double, double> xDim(x0, x0 + header.n_cols * delta); // extension in x-dimension
const std::pair<double, double> yDim(y0, y0 + header.n_rows * delta); // extension in y-dimension
const std::size_t nNodes (new_mesh.getNumberOfNodes());
const std::vector<MeshLib::Node*> &nodes = new_mesh.getNodes();
for (unsigned i = 0; i < nNodes; ++i)
{
if (!raster.isPntOnRaster(*nodes[i]))
{
// use either default value or elevation from layer above
nodes[i]->updateCoordinates((*nodes[i])[0], (*nodes[i])[1], noDataReplacementValue);
continue;
}
double elevation (raster.interpolateValueAtPoint(*nodes[i]));
if (std::abs(elevation - header.no_data) < std::numeric_limits<double>::epsilon())
elevation = noDataReplacementValue;
nodes[i]->updateCoordinates((*nodes[i])[0], (*nodes[i])[1], elevation);
}
return true;
}
void LayeredVolume::addLayerToMesh(const MeshLib::Mesh &dem_mesh, unsigned layer_id, GeoLib::Raster const& raster)
{
const std::size_t nNodes (dem_mesh.getNNodes());
const std::vector<MeshLib::Node*> &nodes (dem_mesh.getNodes());
const std::size_t node_id_offset (_nodes.size());
const std::size_t last_layer_node_offset (node_id_offset-nNodes);
for (std::size_t i=0; i<nNodes; ++i)
_nodes.push_back(getNewLayerNode(*nodes[i], *_nodes[last_layer_node_offset + i], raster, _nodes.size()));
const std::vector<MeshLib::Element*> &layer_elements (dem_mesh.getElements());
for (MeshLib::Element* elem : layer_elements)
{
if (elem->getGeomType() == MeshLib::MeshElemType::TRIANGLE)
{
std::array<MeshLib::Node*,3> tri_nodes = {{ _nodes[node_id_offset+elem->getNodeIndex(0)],
_nodes[node_id_offset+elem->getNodeIndex(1)],
_nodes[node_id_offset+elem->getNodeIndex(2)] }};
_elements.push_back(new MeshLib::Tri(tri_nodes, layer_id));
}
else if (elem->getGeomType() == MeshLib::MeshElemType::QUAD)
{
std::array<MeshLib::Node*,4> quad_nodes = {{ _nodes[node_id_offset+elem->getNodeIndex(0)],
_nodes[node_id_offset+elem->getNodeIndex(1)],
_nodes[node_id_offset+elem->getNodeIndex(2)],
_nodes[node_id_offset+elem->getNodeIndex(3)] }};
_elements.push_back(new MeshLib::Quad(quad_nodes, layer_id));
}
}
}
std::unique_ptr<DirichletBoundaryCondition> createDirichletBoundaryCondition(
BaseLib::ConfigTree const& config, MeshLib::Mesh const& bc_mesh,
NumLib::LocalToGlobalIndexMap const& dof_table_bulk, int const variable_id,
int const component_id,
const std::vector<std::unique_ptr<ProcessLib::ParameterBase>>& parameters)
{
DBUG("Constructing DirichletBoundaryCondition from config.");
//! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__type}
config.checkConfigParameter("type", "Dirichlet");
//! \ogs_file_param{prj__process_variables__process_variable__boundary_conditions__boundary_condition__Dirichlet__parameter}
auto const param_name = config.getConfigParameter<std::string>("parameter");
DBUG("Using parameter %s", param_name.c_str());
auto& param = findParameter<double>(param_name, parameters, 1);
// In case of partitioned mesh the boundary could be empty, i.e. there is no
// boundary condition.
#ifdef USE_PETSC
// This can be extracted to createBoundaryCondition() but then the config
// parameters are not read and will cause an error.
// TODO (naumov): Add a function to ConfigTree for skipping the tags of the
// subtree and move the code up in createBoundaryCondition().
if (bc_mesh.getDimension() == 0 && bc_mesh.getNumberOfNodes() == 0 &&
bc_mesh.getNumberOfElements() == 0)
{
return nullptr;
}
#endif // USE_PETSC
return std::make_unique<DirichletBoundaryCondition>(
param, bc_mesh, dof_table_bulk, variable_id, component_id);
}
GlobalSparsityPattern computeSparsityPatternNonPETSc(
NumLib::LocalToGlobalIndexMap const& dof_table, MeshLib::Mesh const& mesh)
{
MeshLib::NodeAdjacencyTable node_adjacency_table;
node_adjacency_table.createTable(mesh.getNodes());
// A mapping mesh node id -> global indices
// It acts as a cache for dof table queries.
std::vector<std::vector<GlobalIndexType>> global_idcs;
global_idcs.reserve(mesh.getNumberOfNodes());
for (std::size_t n = 0; n < mesh.getNumberOfNodes(); ++n)
{
MeshLib::Location l(mesh.getID(), MeshLib::MeshItemType::Node, n);
global_idcs.push_back(dof_table.getGlobalIndices(l));
}
GlobalSparsityPattern sparsity_pattern(dof_table.dofSizeWithGhosts());
// Map adjacent mesh nodes to "adjacent global indices".
for (std::size_t n = 0; n < mesh.getNumberOfNodes(); ++n)
{
unsigned n_connected_dof = 0;
for (auto an : node_adjacency_table.getAdjacentNodes(n))
n_connected_dof += global_idcs[an].size();
for (auto global_index : global_idcs[n])
sparsity_pattern[global_index] = n_connected_dof;
}
return sparsity_pattern;
}
std::unique_ptr<ParameterBase> createMeshElementParameter(
BaseLib::ConfigTree const& config, MeshLib::Mesh const& mesh)
{
//! \ogs_file_param{parameter__type}
config.checkConfigParameter("type", "MeshElement");
//! \ogs_file_param{parameter__MeshElement__field_name}
auto const field_name = config.getConfigParameter<std::string>("field_name");
DBUG("Using field_name %s", field_name.c_str());
if (!mesh.getProperties().hasPropertyVector(field_name)) {
OGS_FATAL("The required property %s does not exists in the mesh.",
field_name.c_str());
}
// TODO other data types than only double
auto const& property =
mesh.getProperties().getPropertyVector<double>(field_name);
if (!property) {
OGS_FATAL("The mesh property `%s' is not of the requested type.",
field_name.c_str());
}
if (property->getMeshItemType() != MeshLib::MeshItemType::Cell) {
OGS_FATAL("The mesh property `%s' is not an element property.",
field_name.c_str());
}
return std::unique_ptr<ParameterBase>(
new MeshElementParameter<double>(*property));
}
std::vector<GeoLib::PointWithID*> MshEditor::getSurfaceNodes(const MeshLib::Mesh &mesh, const double *dir)
{
INFO ("Extracting surface nodes...");
const std::vector<MeshLib::Element*> all_elements (mesh.getElements());
const std::vector<MeshLib::Node*> all_nodes (mesh.getNodes());
std::vector<MeshLib::Element*> sfc_elements;
get2DSurfaceElements(all_elements, sfc_elements, dir, mesh.getDimension());
std::vector<MeshLib::Node*> sfc_nodes;
std::vector<unsigned> node_id_map(mesh.getNNodes());
get2DSurfaceNodes(all_nodes, sfc_nodes, sfc_elements, node_id_map);
const unsigned nElements (sfc_elements.size());
for (unsigned i=0; i<nElements; ++i)
delete sfc_elements[i];
const size_t nNodes (sfc_nodes.size());
std::vector<GeoLib::PointWithID*> surface_pnts(nNodes);
for (unsigned i=0; i<nNodes; ++i)
{
surface_pnts[i] = new GeoLib::PointWithID(sfc_nodes[i]->getCoords(), sfc_nodes[i]->getID());
delete sfc_nodes[i];
}
return surface_pnts;
}
int main (int argc, char* argv[])
{
LOGOG_INITIALIZE();
logog::Cout* logog_cout (new logog::Cout);
BaseLib::LogogSimpleFormatter *custom_format (new BaseLib::LogogSimpleFormatter);
logog_cout->SetFormatter(*custom_format);
TCLAP::CmdLine cmd("Converts VTK mesh into OGS mesh.", ' ', "0.1");
TCLAP::ValueArg<std::string> mesh_in("i", "mesh-input-file",
"the name of the file containing the input mesh", true,
"", "file name of input mesh");
cmd.add(mesh_in);
TCLAP::ValueArg<std::string> mesh_out("o", "mesh-output-file",
"the name of the file the mesh will be written to", true,
"", "file name of output mesh");
cmd.add(mesh_out);
cmd.parse(argc, argv);
MeshLib::Mesh* mesh (FileIO::BoostVtuInterface::readVTUFile(mesh_in.getValue()));
INFO("Mesh read: %d nodes, %d elements.", mesh->getNNodes(), mesh->getNElements());
FileIO::Legacy::MeshIO meshIO;
meshIO.setMesh(mesh);
meshIO.writeToFile(mesh_out.getValue());
delete custom_format;
delete logog_cout;
LOGOG_SHUTDOWN();
return 0;
}
void VtkMeshConverter::convertScalarArrays(vtkUnstructuredGrid& grid,
MeshLib::Mesh& mesh)
{
vtkPointData* point_data = grid.GetPointData();
auto const n_point_arrays =
static_cast<unsigned>(point_data->GetNumberOfArrays());
for (unsigned i = 0; i < n_point_arrays; ++i)
convertArray(*point_data->GetArray(i),
mesh.getProperties(),
MeshLib::MeshItemType::Node);
vtkCellData* cell_data = grid.GetCellData();
auto const n_cell_arrays =
static_cast<unsigned>(cell_data->GetNumberOfArrays());
for (unsigned i = 0; i < n_cell_arrays; ++i)
convertArray(*cell_data->GetArray(i),
mesh.getProperties(),
MeshLib::MeshItemType::Cell);
vtkFieldData* field_data = grid.GetFieldData();
auto const n_field_arrays =
static_cast<unsigned>(field_data->GetNumberOfArrays());
for (unsigned i = 0; i < n_field_arrays; ++i)
convertArray(
*vtkDataArray::SafeDownCast(field_data->GetAbstractArray(i)),
mesh.getProperties(),
MeshLib::MeshItemType::IntegrationPoint);
}
void VtkVisPipelineView::convertVTKToOGSMesh()
{
VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(
static_cast<VtkVisPipeline*>(this->model())->getItem(this->selectionModel()->currentIndex()));
vtkSmartPointer<vtkAlgorithm> algorithm = item->algorithm();
vtkUnstructuredGrid* grid(NULL);
vtkUnstructuredGridAlgorithm* ugAlg = vtkUnstructuredGridAlgorithm::SafeDownCast(algorithm);
if (ugAlg)
grid = ugAlg->GetOutput();
else
{
// for old filetypes
vtkGenericDataObjectReader* dataReader = vtkGenericDataObjectReader::SafeDownCast(algorithm);
if (dataReader)
grid = vtkUnstructuredGrid::SafeDownCast(dataReader->GetOutput());
else
{
// for new filetypes
vtkXMLUnstructuredGridReader* xmlReader = vtkXMLUnstructuredGridReader::SafeDownCast(algorithm);
grid = vtkUnstructuredGrid::SafeDownCast(xmlReader->GetOutput());
}
}
MeshLib::Mesh* mesh = MeshLib::VtkMeshConverter::convertUnstructuredGrid(grid);
mesh->setName(item->data(0).toString().toStdString());
emit meshAdded(mesh);
}
MeshLib::Mesh* MeshSurfaceExtraction::getMeshSurface(
const MeshLib::Mesh& mesh, const MathLib::Vector3& dir, double angle,
std::string const& subsfc_node_id_backup_prop_name)
{
if (angle < 0 || angle > 90)
{
ERR ("Supported angle between 0 and 90 degrees only.");
return nullptr;
}
INFO ("Extracting mesh surface...");
std::vector<MeshLib::Element*> sfc_elements;
get2DSurfaceElements(mesh.getElements(), sfc_elements, dir, angle, mesh.getDimension());
if (sfc_elements.empty())
return nullptr;
std::vector<MeshLib::Node*> sfc_nodes;
std::vector<std::size_t> node_id_map(mesh.getNNodes());
get2DSurfaceNodes(sfc_nodes, mesh.getNNodes(), sfc_elements, node_id_map);
// create new elements vector with newly created nodes
std::vector<MeshLib::Element*> new_elements;
new_elements.reserve(sfc_elements.size());
for (auto elem = sfc_elements.cbegin(); elem != sfc_elements.cend(); ++elem)
{
unsigned const n_elem_nodes ((*elem)->getNBaseNodes());
MeshLib::Node** new_nodes = new MeshLib::Node*[n_elem_nodes];
for (unsigned k(0); k<n_elem_nodes; k++)
new_nodes[k] = sfc_nodes[node_id_map[(*elem)->getNode(k)->getID()]];
if ((*elem)->getGeomType() == MeshElemType::TRIANGLE)
new_elements.push_back(new MeshLib::Tri(new_nodes));
else {
assert((*elem)->getGeomType() == MeshElemType::QUAD);
new_elements.push_back(new MeshLib::Quad(new_nodes));
}
delete *elem;
}
std::vector<std::size_t> id_map;
if (!subsfc_node_id_backup_prop_name.empty())
{
id_map.reserve(sfc_nodes.size());
for (auto node = sfc_nodes.cbegin(); node != sfc_nodes.cend(); ++node)
id_map.push_back((*node)->getID());
}
MeshLib::Mesh* result (new Mesh(mesh.getName()+"-Surface", sfc_nodes, new_elements));
// transmit the original node ids of the subsurface mesh as a property
if (!subsfc_node_id_backup_prop_name.empty()) {
boost::optional<MeshLib::PropertyVector<std::size_t>&> orig_node_ids(
result->getProperties().createNewPropertyVector<std::size_t>(
subsfc_node_id_backup_prop_name , MeshLib::MeshItemType::Node, 1));
if (orig_node_ids) {
orig_node_ids->resize(id_map.size());
std::copy(id_map.cbegin(), id_map.cend(), orig_node_ids->begin());
}
}
return result;
}
void testZCoords2D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height)
{
std::size_t const nNodes (input.getNumberOfNodes());
for (std::size_t i=0; i<nNodes; ++i)
{
ASSERT_EQ((*input.getNode(i))[2], (*output.getNode(i))[2]);
ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(nNodes+i))[2]);
}
}
void TESProcess::initializeConcreteProcess(
NumLib::LocalToGlobalIndexMap const& dof_table,
MeshLib::Mesh const& mesh, unsigned const integration_order)
{
ProcessLib::createLocalAssemblers<TESLocalAssembler>(
mesh.getDimension(), mesh.getElements(), dof_table, _local_assemblers,
mesh.isAxiallySymmetric(), integration_order, _assembly_params);
initializeSecondaryVariables();
}
void VtkMeshConverter::convertScalarArrays(vtkUnstructuredGrid &grid, MeshLib::Mesh &mesh)
{
vtkPointData* point_data = grid.GetPointData();
unsigned const n_point_arrays = static_cast<unsigned>(point_data->GetNumberOfArrays());
for (unsigned i=0; i<n_point_arrays; ++i)
convertArray(*point_data->GetArray(i), mesh.getProperties(), MeshLib::MeshItemType::Node);
vtkCellData* cell_data = grid.GetCellData();
unsigned const n_cell_arrays = static_cast<unsigned>(cell_data->GetNumberOfArrays());
for (unsigned i=0; i<n_cell_arrays; ++i)
convertArray(*cell_data->GetArray(i), mesh.getProperties(), MeshLib::MeshItemType::Cell);
}
int main(int argc, char *argv[])
{
LOGOG_INITIALIZE();
logog::Cout* logogCout = new logog::Cout;
TCLAP::CmdLine cmd("Simple mesh loading test", ' ', "0.1");
// Define a value argument and add it to the command line.
// A value arg defines a flag and a type of value that it expects,
// such as "-m meshfile".
TCLAP::ValueArg<std::string> mesh_arg("m","mesh","input mesh file",true,"homer","string");
// Add the argument mesh_arg to the CmdLine object. The CmdLine object
// uses this Arg to parse the command line.
cmd.add( mesh_arg );
cmd.parse( argc, argv );
std::string fname (mesh_arg.getValue());
FileIO::MeshIO mesh_io;
#ifndef WIN32
BaseLib::MemWatch mem_watch;
unsigned long mem_without_mesh (mem_watch.getVirtMemUsage());
#endif
BaseLib::RunTime run_time;
run_time.start();
MeshLib::Mesh* mesh = mesh_io.loadMeshFromFile(fname);
#ifndef WIN32
unsigned long mem_with_mesh (mem_watch.getVirtMemUsage());
// std::cout << "mem for mesh: " << (mem_with_mesh - mem_without_mesh)/(1024*1024) << " MB" << std::endl;
INFO ("mem for mesh: %i MB", (mem_with_mesh - mem_without_mesh)/(1024*1024));
#endif
run_time.stop();
// std::cout << "time for reading: " << run_time.elapsed() << " s" << std::endl;
INFO ("time for reading: %f s", run_time.elapsed());
unsigned elem_id = 25000;
const MeshLib::Element* e = mesh->getElement(elem_id);
const size_t nElems = mesh->getNElements();
for (unsigned i=0; i< e->getNNeighbors(); i++)
{
for (unsigned j=0; j< nElems; j++)
if (mesh->getElement(j) == e->getNeighbor(i))
std::cout << "neighbour of element " << elem_id << elem_id << " : " << j << std::endl;
}
delete mesh;
delete logogCout;
LOGOG_SHUTDOWN();
}
bool MeshLayerMapper::mapToStaticValue(MeshLib::Mesh &mesh, double value)
{
if (mesh.getDimension() != 2)
{
ERR("MshLayerMapper::mapToStaticValue() - requires 2D mesh");
return false;
}
std::vector<MeshLib::Node*> const& nodes (mesh.getNodes());
for (MeshLib::Node* node : nodes)
node->updateCoordinates((*node)[0], (*node)[1], value);
return true;
}
// Project to parallels of YZ plane
TEST_F(ProjectionTest, ProjectToYZ)
{
MathLib::Vector3 normal (1,0,0);
std::size_t const n_nodes (_mesh->getNumberOfNodes());
for (std::size_t p=0; p<10; p++)
{
MathLib::Point3d origin (std::array<double,3>{{static_cast<double>(p),0,0}});
MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
for (std::size_t i=0; i<n_nodes; i++)
ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[0], std::numeric_limits<double>::epsilon());
delete result;
}
}
bool convertMeshToGeo(const MeshLib::Mesh &mesh, GeoLib::GEOObjects &geo_objects, double eps)
{
if (mesh.getDimension() != 2)
{
ERR ("Mesh to geometry conversion is only working for 2D meshes.");
return false;
}
// nodes to points conversion
std::string mesh_name(mesh.getName());
{
auto points = std::make_unique<std::vector<GeoLib::Point*>>();
points->reserve(mesh.getNumberOfNodes());
for (auto node_ptr : mesh.getNodes())
points->push_back(new GeoLib::Point(*node_ptr, node_ptr->getID()));
geo_objects.addPointVec(std::move(points), mesh_name, nullptr, eps);
}
const std::vector<std::size_t> id_map (geo_objects.getPointVecObj(mesh_name)->getIDMap());
// elements to surface triangles conversion
std::string const mat_name ("MaterialIDs");
auto bounds (MeshInformation::getValueBounds<int>(mesh, mat_name));
const unsigned nMatGroups(bounds.second-bounds.first+1);
auto sfcs = std::make_unique<std::vector<GeoLib::Surface*>>();
sfcs->reserve(nMatGroups);
auto const& points = *geo_objects.getPointVec(mesh_name);
for (unsigned i=0; i<nMatGroups; ++i)
sfcs->push_back(new GeoLib::Surface(points));
const std::vector<MeshLib::Element*> &elements = mesh.getElements();
const std::size_t nElems (mesh.getNumberOfElements());
MeshLib::PropertyVector<int> const*const materialIds =
mesh.getProperties().existsPropertyVector<int>("MaterialIDs")
? mesh.getProperties().getPropertyVector<int>("MaterialIDs")
: nullptr;
for (unsigned i=0; i<nElems; ++i)
{
auto surfaceId = !materialIds ? 0 : ((*materialIds)[i] - bounds.first);
MeshLib::Element* e (elements[i]);
if (e->getGeomType() == MeshElemType::TRIANGLE)
(*sfcs)[surfaceId]->addTriangle(id_map[e->getNodeIndex(0)], id_map[e->getNodeIndex(1)], id_map[e->getNodeIndex(2)]);
if (e->getGeomType() == MeshElemType::QUAD)
{
(*sfcs)[surfaceId]->addTriangle(id_map[e->getNodeIndex(0)], id_map[e->getNodeIndex(1)], id_map[e->getNodeIndex(2)]);
(*sfcs)[surfaceId]->addTriangle(id_map[e->getNodeIndex(0)], id_map[e->getNodeIndex(2)], id_map[e->getNodeIndex(3)]);
}
// all other element types are ignored (i.e. lines)
}
std::for_each(sfcs->begin(), sfcs->end(), [](GeoLib::Surface* sfc){ if (sfc->getNumberOfTriangles()==0) delete sfc; sfc = nullptr;});
auto sfcs_end = std::remove(sfcs->begin(), sfcs->end(), nullptr);
sfcs->erase(sfcs_end, sfcs->end());
geo_objects.addSurfaceVec(std::move(sfcs), mesh_name);
return true;
}
