template<> void StructuredMesh<ElementShape::QUAD>::getNodeCoordinates(size_t id, GeoLib::Point* p) const
{
double *pt = const_cast<double*>(p->getData());
const size_t nnodes1 = getNumberOfNodes(1);
if (id < nnodes1) {
size_t k_x = id % _number_of_nodes_per_dimension[0];
size_t j_y = id / _number_of_nodes_per_dimension[1];
pt[0] = _spacing[0]*k_x + _origin[0];
pt[1] = _spacing[1]*j_y + _origin[1];
} else {
const size_t nnodes2 = getNumberOfNodes(2);
if (id < nnodes2 - _n_ele) {
const size_t id1 = id - nnodes1;
const size_t n_row_block = _number_of_nodes_per_dimension[0] + _number_of_elements_per_dimension[0];
size_t block_id = id1 / n_row_block;
size_t local_id = id1 % n_row_block;
bool isRow1 = (0==local_id / _number_of_elements_per_dimension[0]);
if (isRow1) {
pt[0] = _spacing[0]*local_id + 0.5*_spacing[0] + _origin[0];
pt[1] = _spacing[1]*block_id + _origin[1];
} else {
pt[0] = _spacing[0]*(local_id-_number_of_elements_per_dimension[0]) + _origin[0];
pt[1] = _spacing[1]*block_id + 0.5*_spacing[1] + _origin[1];
}
} else {
const size_t e_id = id - (nnodes2 - _n_ele);
const size_t j_y = e_id / _number_of_elements_per_dimension[0];
const size_t k_x = e_id % _number_of_elements_per_dimension[0];
pt[0] = _spacing[0]*k_x + 0.5*_spacing[0] + _origin[0];
pt[1] = _spacing[1]*j_y + 0.5*_spacing[1] + _origin[1];
}
}
pt[2] = _origin[2];
}
void ClusterWithSurface::retrieveAtomsInCluster( const unsigned& clust, std::vector<unsigned>& myatoms ) const {
std::vector<unsigned> tmpat; myclusters->retrieveAtomsInCluster( clust, tmpat );
// Prevent double counting
std::vector<bool> incluster( getNumberOfNodes(), false );
for(unsigned i=0;i<tmpat.size();++i) incluster[tmpat[i]]=true;
// Find the atoms in the the clusters
std::vector<bool> surface_atom( getNumberOfNodes(), false );
for(unsigned i=0;i<tmpat.size();++i){
for(unsigned j=0;j<getNumberOfNodes();++j){
if( incluster[j] ) continue;
double dist2=getSeparation( getPosition(tmpat[i]), getPosition(j) ).modulo2();
if( dist2<rcut_surf2 ){ surface_atom[j]=true; }
}
}
unsigned nsurf_at=0;
for(unsigned j=0;j<getNumberOfNodes();++j){
if( surface_atom[j] ) nsurf_at++;
}
myatoms.resize( nsurf_at + tmpat.size() );
for(unsigned i=0;i<tmpat.size();++i) myatoms[i]=tmpat[i];
unsigned nn=tmpat.size();
for(unsigned j=0;j<getNumberOfNodes();++j){
if( surface_atom[j] ){ myatoms[nn]=j; nn++; }
}
plumed_assert( nn==myatoms.size() );
}
template<> IElement* StructuredMesh<ElementShape::QUAD>::getElement( size_t element_id ) const
{
//set e
_e->reset();
_e->setID(element_id);
_e->setMaximumOrder(getMaxiumOrder());
_e->setCurrentOrder(_order);
const size_t x_j = element_id / _number_of_elements_per_dimension[0];
const size_t offset_y1 = x_j*_number_of_nodes_per_dimension[0];
const size_t offset_y2 = (x_j+1)*_number_of_nodes_per_dimension[0];
const size_t k = element_id % _number_of_elements_per_dimension[0];
for (size_t i=0; i<4; i++) {
_e->setNodeID(0, offset_y1+k);
_e->setNodeID(1, offset_y1+k+1);
_e->setNodeID(2, offset_y2+k+1);
_e->setNodeID(3, offset_y2+k);
}
if (getMaxiumOrder()==2) {
const size_t nnodes1 = getNumberOfNodes(1);
const size_t nnodes2 = getNumberOfNodes(2);
const size_t offset2_y1 = nnodes1 + x_j*(_number_of_elements_per_dimension[0] + _number_of_nodes_per_dimension[0]);
const size_t offset2_y2 = offset2_y1 + _number_of_elements_per_dimension[0];
const size_t offset2_y3 = offset2_y2 + _number_of_nodes_per_dimension[0];
_e->setNodeID(4, offset2_y1+k);
_e->setNodeID(5, offset2_y2+k+1);
_e->setNodeID(6, offset2_y3+k);
_e->setNodeID(7, offset2_y2+k);
_e->setNodeID(8, nnodes2-_n_ele+element_id);
}
return _e;
};
ClusteringBase::ClusteringBase(const ActionOptions&ao):
Action(ao),
ActionWithInputMatrix(ao),
number_of_cluster(-1)
{
if( getAdjacencyVessel() ) {
cluster_sizes.resize(getNumberOfNodes()); which_cluster.resize(getNumberOfNodes());
if( getNumberOfNodeTypes()!=1 ) error("should only be running clustering with one base multicolvar in function");
if( !getAdjacencyVessel()->undirectedGraph() ) error("input contact matrix is incompatible with clustering");
}
if( keywords.exists("MATRIX") ) {
std::vector<AtomNumber> fake_atoms; setupMultiColvarBase( fake_atoms );
}
}
void Element::setNode(unsigned idx, Node* node)
{
#ifndef NDEBUG
if (idx < getNumberOfNodes())
#endif
_nodes[idx] = node;
}
void DFSClusterDiameter::performTask( const unsigned& task_index, const unsigned& current, MultiValue& myvals ) const {
unsigned iatom=current/getNumberOfNodes(), jatom = current - iatom*getNumberOfNodes();
Vector distance=getSeparation( getPosition(iatom), getPosition(jatom) );
double dd = distance.modulo(), inv = 1.0/dd ; myvals.setValue( 1, dd );
if( !doNotCalculateDerivatives() ){
myvals.addDerivative( 1, 3*iatom + 0, -inv*distance[0] );
myvals.addDerivative( 1, 3*iatom + 1, -inv*distance[1] );
myvals.addDerivative( 1, 3*iatom + 2, -inv*distance[2] );
myvals.addDerivative( 1, 3*jatom + 0, +inv*distance[0] );
myvals.addDerivative( 1, 3*jatom + 1, +inv*distance[1] );
myvals.addDerivative( 1, 3*jatom + 2, +inv*distance[2] );
Tensor vir = -inv*Tensor(distance,distance);
unsigned vbase = myvals.getNumberOfDerivatives() - 9;
for(unsigned i=0;i<3;++i){
for(unsigned j=0;j<3;++j) myvals.addDerivative( 1, vbase+3*i+j, vir(i,j) );
}
}
}
const Node* Element::getNode(unsigned i) const
{
#ifndef NDEBUG
if (i < getNumberOfNodes())
#endif
return _nodes[i];
#ifndef NDEBUG
ERR("Error in MeshLib::Element::getNode() - Index %d in %s", i, MeshElemType2String(getGeomType()).c_str());
return nullptr;
#endif
}
unsigned Element::getNodeIndex(unsigned i) const
{
#ifndef NDEBUG
if (i<getNumberOfNodes())
#endif
return _nodes[i]->getID();
#ifndef NDEBUG
ERR("Error in MeshLib::Element::getNodeIndex() - Index does not exist.");
return std::numeric_limits<unsigned>::max();
#endif
}
signed getNodeForCore(unsigned core) {
hwloc_topology_t topology = getHWTopology();
unsigned nodes = getNumberOfNodes(topology);
hwloc_obj_t core_obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, core);
for (unsigned i = 0; i < nodes; i++) {
hwloc_obj_t obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, i);
if (hwloc_obj_is_in_subtree(topology, core_obj, obj)) {
return i;
}
}
return -1;
}
void ClusterDiameter::calculate(){
// Retrieve the atoms in the largest cluster
std::vector<unsigned> myatoms; retrieveAtomsInCluster( clustr, myatoms );
// Activate the relevant tasks
deactivateAllTasks();
for(unsigned i=1;i<myatoms.size();++i){
for(unsigned j=0;j<i;++j) taskFlags[ myatoms[i]*getNumberOfNodes() + myatoms[j] ] = 1;
}
lockContributors();
// Now do the calculation
runAllTasks();
}
unsigned getNodeForCore(unsigned core){
hwloc_topology_t topology = getHWTopology();
unsigned nodes = getNumberOfNodes(topology);
hwloc_obj_t obj;
hwloc_obj_t core_obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, core);
for(unsigned i = 0; i < nodes; i++){
obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NODE, i);
if (hwloc_obj_is_in_subtree(topology, core_obj, obj)){
return i;
}
}
throw std::runtime_error("expected to find node for core");
}
void DFSClusterDiameter::calculate(){
// Do the clustring
performClustering();
// Retrieve the atoms in the largest cluster
std::vector<unsigned> myatoms; retrieveAtomsInCluster( clustr, myatoms );
// Activate the relevant tasks
deactivateAllTasks(); std::vector<unsigned> active_tasks( getFullNumberOfTasks(), 0 );
for(unsigned i=1;i<myatoms.size();++i){
for(unsigned j=0;j<i;++j) active_tasks[ myatoms[i]*getNumberOfNodes() + myatoms[j] ] = 1;
}
activateTheseTasks( active_tasks );
// Now do the calculation
runAllTasks();
}
TEST(MeshLib, ElementStatus)
{
const unsigned width (100);
const unsigned elements_per_side (20);
auto const mesh = std::unique_ptr<MeshLib::Mesh>{
MeshLib::MeshGenerator::generateRegularQuadMesh(width, elements_per_side)};
auto* const material_id_properties =
mesh->getProperties().createNewPropertyVector<int>(
"MaterialIDs", MeshLib::MeshItemType::Cell);
ASSERT_NE(nullptr, material_id_properties);
material_id_properties->resize(mesh->getNumberOfElements());
const std::vector<MeshLib::Element*> elements (mesh->getElements());
for (unsigned i=0; i<elements_per_side; ++i)
{
for (unsigned j=0; j<elements_per_side; ++j)
(*material_id_properties)[elements[i*elements_per_side + j]->getID()] = i;
}
{
// all elements and nodes active
MeshLib::ElementStatus status(mesh.get());
ASSERT_EQ (elements.size(), status.getNumberOfActiveElements());
ASSERT_EQ (mesh->getNumberOfNodes(), status.getNumberOfActiveNodes());
}
{
// set material 1 to false
std::vector<int> inactiveMat{1};
MeshLib::ElementStatus status(mesh.get(), inactiveMat);
ASSERT_EQ (elements.size()-elements_per_side, status.getNumberOfActiveElements());
}
{
// set material 0 and 1 to false
std::vector<int> inactiveMat{0, 1};
MeshLib::ElementStatus status(mesh.get(), inactiveMat);
ASSERT_EQ (elements.size()-(2*elements_per_side), status.getNumberOfActiveElements());
// active elements
auto &active_elements (status.getActiveElements());
ASSERT_EQ (active_elements.size(), status.getNumberOfActiveElements());
// active nodes
auto& active_nodes (status.getActiveNodes());
ASSERT_EQ (active_nodes.size(), status.getNumberOfActiveNodes());
}
}
int Settings::getNodeId(Node type, int intDeviceIndex) const {
if (intDeviceIndex >= getNumberOfNodes(type)) { // Out of bounds
return -1;
}
TelldusCore::MutexLocker locker(&mutex);
cfg_t *cfg_node;
if (type == Device) {
cfg_node = cfg_getnsec(d->cfg, "device", intDeviceIndex);
} else if (type == Controller) {
cfg_node = cfg_getnsec(d->cfg, "controller", intDeviceIndex);
}
int id = cfg_getint(cfg_node, "id");
return id;
}
void Element::computeSqrNodeDistanceRange(double &min, double &max, bool check_allnodes) const
{
min = std::numeric_limits<double>::max();
max = 0;
const unsigned nnodes = check_allnodes ? getNumberOfNodes() : getNumberOfBaseNodes();
for (unsigned i=0; i<nnodes; i++)
{
for (unsigned j=i+1; j<nnodes; j++)
{
const double dist (MathLib::sqrDist(*getNode(i), *getNode(j)));
min = std::min(dist, min);
max = std::max(dist, max);
}
}
}
void tarch::parallel::Node::plotMessageQueues() {
MPI_Status status;
int flag;
MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, _communicator, &flag, &status);
if (flag==0) {
_log.error("plotMessageQueues()", "there are no messages from any sender in MPI queue");
}
else {
for (int i=0; i<getNumberOfNodes(); i++) {
if (i!=getRank()) {
plotMessagesInQueueToError(i);
}
}
}
}
TEST(MeshLib, CoordinatesMappingLocalLowerDimLineZ)
{
auto ele = TestLine2::createZ();
MeshLib::ElementCoordinatesMappingLocal mapping(*ele,
MeshLib::CoordinateSystem(MeshLib::CoordinateSystemType::Z));
auto matR(mapping.getRotationMatrixToGlobal());
//debugOutput(ele, mapping);
double exp_R[3*3] = {0, 0, -1, 0, 1, 0, 1, 0, 0};
const double eps(std::numeric_limits<double>::epsilon());
ASSERT_ARRAY_NEAR(exp_R, matR.data(), matR.size(), eps);
CHECK_COORDS(ele,mapping);
for (std::size_t n = 0; n < ele->getNumberOfNodes(); ++n)
delete ele->getNode(n);
}
void aco::Graph::evaporatePheromone( float evaporationRate )
{
int nNodes = getNumberOfNodes();
for (int i = 0; i < nNodes; ++i)
{
std::vector<int> adjacent;
getAdjacentNodes( i, adjacent );
int nAdjacent = adjacent.size();
for (int j = 0; j < nAdjacent; ++j)
{
float oldPheromone = getPheromone( i, j );
float newPheromone = oldPheromone * ( 1.0f - evaporationRate );
addPheromone( i, j, newPheromone - oldPheromone );
}
}
}
TEST(MeshLib, CoordinatesMappingLocalLowerDimLineXYZ)
{
auto ele = TestLine2::createXYZ();
MeshLib::ElementCoordinatesMappingLocal mapping(*ele, MeshLib::CoordinateSystem(*ele));
auto matR(mapping.getRotationMatrixToGlobal());
//debugOutput(ele, mapping);
double exp_R[3*3] = {0.57735026918962584, -0.81649658092772626, 0,
0.57735026918962584, 0.40824829046386313, -0.70710678118654757,
0.57735026918962584, 0.40824829046386313, 0.70710678118654757};
const double eps(std::numeric_limits<double>::epsilon());
ASSERT_ARRAY_NEAR(exp_R, matR.data(), matR.size(), eps);
CHECK_COORDS(ele,mapping);
for (std::size_t n = 0; n < ele->getNumberOfNodes(); ++n)
delete ele->getNode(n);
}
TEST_F(TestVtkMeshConverter, Conversion)
{
auto mesh = std::unique_ptr<MeshLib::Mesh>(
MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtu));
ASSERT_EQ(mesh->getNumberOfNodes(), vtu->GetNumberOfPoints());
ASSERT_EQ(mesh->getNumberOfElements(), vtu->GetNumberOfCells());
ASSERT_EQ(mesh->getElement(0)->getCellType(), MeshLib::CellType::HEX8);
auto meshProperties = mesh->getProperties();
// MaterialIDs are converted to an int property
auto const* const materialIds =
meshProperties.getPropertyVector<int>("MaterialIDs");
ASSERT_NE(nullptr, materialIds);
auto vtkMaterialIds = vtu->GetCellData()->GetArray("MaterialIDs");
ASSERT_EQ(materialIds->size(), vtkMaterialIds->GetNumberOfTuples());
for(std::size_t i = 0; i < materialIds->size(); i++)
ASSERT_EQ((*materialIds)[i], vtkMaterialIds->GetTuple1(i));
}
TEST(MeshLib, CoordinatesMappingLocalLowerDimQuadXYZ)
{
auto ele = TestQuad4::createXYZ();
MeshLib::ElementCoordinatesMappingLocal mapping(*ele, MeshLib::CoordinateSystem(*ele));
auto matR(mapping.getRotationMatrixToGlobal());
//debugOutput(ele, mapping);
// results when using GeoLib::ComputeRotationMatrixToXY()
double exp_R[3*3] = { 1, 0, 0,
0, 0.70710678118654757, -0.70710678118654757,
0, 0.70710678118654757, 0.70710678118654757};
const double eps(std::numeric_limits<double>::epsilon());
ASSERT_ARRAY_NEAR(exp_R, matR.data(), matR.size(), eps);
CHECK_COORDS(ele,mapping);
for (std::size_t n = 0; n < ele->getNumberOfNodes(); ++n)
delete ele->getNode(n);
}
/** Check if a new DB measurement is available for any node and return the Node ID for that node **/
uint8_t LithneClass::newDBForNode( )
{
uint8_t nodeID = UNKNOWN_NODE_ID;
for(int i = 0; i < getNumberOfNodes(); i++)
{
Node * currentNode = getNode( i );
if (currentNode != NULL)
{
if( currentNode->isNewMeasurement() )
{
/*
Serial.print("NEW BD INCOMING on node : ");
Serial.println(_id);*/
nodeID = currentNode->getID();
break;
}
}
}
return nodeID;
}
/**
* {@inheritDoc}
*/
void showQuadPointTree(DATA_QUADTREE *param, int n_args, va_list opt_par)
{
int k=0;
DATA_QUADTREE* vetor_node[n_args];
for(k = 0; k < n_args; k++)
vetor_node[k] = va_arg(opt_par,DATA_QUADTREE*);
va_end(opt_par);
setTitle($QTREE_NAME);
aux_red_qtree = getNodeRedColor() == -1 ? $NODE_TREE_RED : getNodeRedColor();
aux_green_qtree = getNodeGreenColor() == -1 ? $NODE_TREE_GREEN : getNodeGreenColor();
aux_blue_qtree = getNodeBlueColor() == -1 ? $NODE_TREE_BLUE : getNodeBlueColor();
int height = 1 + getHeightQTree(param);
int numberOfNodes = getNumberOfNodes(4,height -1);
malloc_qvector(numberOfNodes);
initVector(qVector,numberOfNodes);
setArrayValueQTree(param, numberOfNodes,n_args,vetor_node);
setQTreeVectorPosition(numberOfNodes, height);
plotElementsOnScreen(&box_qtree,qVector,numberOfNodes);
waitToContinue();
free(qVector);
}
void SparseBipartiteGraph::cardmax_matching(std::vector<int>& mates) const {
int n = getNumberOfNodes();
mates.clear();
mates.resize(n);
std::vector < boost::graph_traits < undirected_graph > ::vertex_descriptor
> mateys(n);
bool success = checked_edmonds_maximum_cardinality_matching(g, &mateys[0]);
assert(success);
boost::graph_traits<undirected_graph>::vertex_iterator vi, vi_end;
for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
if (mateys[*vi]
!= boost::graph_traits < undirected_graph > ::null_vertex()) {
//std::cout << "{" << *vi << ", " << mateys[*vi] << "}" << std::endl;
mates[*vi] = mateys[*vi];
mates[mateys[*vi]] = *vi;
} else
mates[*vi] = n;
}
}
void SparseBipartiteGraph::convert_to_bitset(
boost::dynamic_bitset<>& bits) const {
std::vector < int > adj;
unsigned int n = getNumberOfNodes() / 2;
bits.resize(n * n);
for (int u = 0; u < n; u++) {
getNeighbors(u, adj);
for (std::vector<int>::iterator it = adj.begin(); it != adj.end();
++it) {
int v = *it;
unsigned int i = n * u + v - n;
bits[n * n - i - 1] = 1;
}
}
}
TEST_F(InSituMesh, DISABLED_MappedMeshSourceRoundtrip)
#endif
{
// TODO Add more comparison criteria
ASSERT_TRUE(mesh != nullptr);
std::string test_data_file(BaseLib::BuildInfo::tests_tmp_path + "/MappedMeshSourceRoundtrip.vtu");
// -- Test VtkMappedMeshSource, i.e. OGS mesh to VTK mesh
vtkNew<MeshLib::VtkMappedMeshSource> vtkSource;
vtkSource->SetMesh(mesh);
vtkSource->Update();
vtkUnstructuredGrid* output = vtkSource->GetOutput();
// Point and cell numbers
ASSERT_EQ((subdivisions+1)*(subdivisions+1)*(subdivisions+1), output->GetNumberOfPoints());
ASSERT_EQ(subdivisions*subdivisions*subdivisions, output->GetNumberOfCells());
// Point data arrays
vtkDataArray* pointDoubleArray = output->GetPointData()->GetScalars("PointDoubleProperty");
ASSERT_EQ(pointDoubleArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointDoubleArray->GetComponent(0, 0), 1.0);
double* range = pointDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1.0 + mesh->getNumberOfNodes() - 1.0);
vtkDataArray* pointIntArray = output->GetPointData()->GetScalars("PointIntProperty");
ASSERT_EQ(pointIntArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointIntArray->GetComponent(0, 0), 1.0);
range = pointIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfNodes() - 1);
vtkDataArray* pointUnsignedArray = output->GetPointData()->GetScalars("PointUnsignedProperty");
ASSERT_EQ(pointUnsignedArray->GetSize(), mesh->getNumberOfNodes());
ASSERT_EQ(pointUnsignedArray->GetComponent(0, 0), 1.0);
range = pointUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfNodes() - 1);
// Cell data arrays
vtkDataArray* cellDoubleArray = output->GetCellData()->GetScalars("CellDoubleProperty");
ASSERT_EQ(cellDoubleArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellDoubleArray->GetComponent(0, 0), 1.0);
range = cellDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1.0 + mesh->getNumberOfElements() - 1.0);
vtkDataArray* cellIntArray = output->GetCellData()->GetScalars("CellIntProperty");
ASSERT_EQ(cellIntArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellIntArray->GetComponent(0, 0), 1.0);
range = cellIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfElements() - 1);
vtkDataArray* cellUnsignedArray = output->GetCellData()->GetScalars("CellUnsignedProperty");
ASSERT_EQ(cellUnsignedArray->GetSize(), mesh->getNumberOfElements());
ASSERT_EQ(cellUnsignedArray->GetComponent(0, 0), 1.0);
range = cellUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], 1 + mesh->getNumberOfElements() - 1);
// Field data arrays
vtkDataArray* fieldDoubleArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldDoubleProperty"));
ASSERT_EQ(fieldDoubleArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldDoubleArray->GetComponent(0, 0), 1.0);
range = fieldDoubleArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
vtkDataArray* fieldIntArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldIntProperty"));
ASSERT_EQ(fieldIntArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldIntArray->GetComponent(0, 0), 1.0);
range = fieldIntArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
vtkDataArray* fieldUnsignedArray = vtkDataArray::SafeDownCast(
output->GetFieldData()->GetAbstractArray("FieldUnsignedProperty"));
ASSERT_EQ(fieldUnsignedArray->GetSize(), mesh->getNumberOfElements() * 2);
ASSERT_EQ(fieldUnsignedArray->GetComponent(0, 0), 1.0);
range = fieldUnsignedArray->GetRange(0);
ASSERT_EQ(range[0], 1.0);
ASSERT_EQ(range[1], mesh->getNumberOfElements() * 2);
// -- Write VTK mesh to file (in all combinations of binary, appended and compressed)
// TODO: atm vtkXMLWriter::Ascii fails
for(int dataMode : { vtkXMLWriter::Appended, vtkXMLWriter::Binary })
{
for(bool compressed : { true, false })
{
if(dataMode == vtkXMLWriter::Ascii && compressed)
continue;
MeshLib::IO::VtuInterface vtuInterface(mesh, dataMode, compressed);
ASSERT_TRUE(vtuInterface.writeToFile(test_data_file));
// -- Read back VTK mesh
vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
reader->SetFileName(test_data_file.c_str());
reader->Update();
vtkUnstructuredGrid *vtkMesh = reader->GetOutput();
// Both VTK meshes should be identical
ASSERT_EQ(vtkMesh->GetNumberOfPoints(), output->GetNumberOfPoints());
ASSERT_EQ(vtkMesh->GetNumberOfCells(), output->GetNumberOfCells());
ASSERT_EQ(vtkMesh->GetFieldData()->GetNumberOfArrays(), output->GetFieldData()->GetNumberOfArrays());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointDoubleProperty")->GetNumberOfTuples(),
pointDoubleArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointIntProperty")->GetNumberOfTuples(),
pointIntArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetPointData()->GetScalars("PointUnsignedProperty")->GetNumberOfTuples(),
pointUnsignedArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellDoubleProperty")->GetNumberOfTuples(),
cellDoubleArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellIntProperty")->GetNumberOfTuples(),
cellIntArray->GetNumberOfTuples());
ASSERT_EQ(vtkMesh->GetCellData()->GetScalars("CellUnsignedProperty")->GetNumberOfTuples(),
cellUnsignedArray->GetNumberOfTuples());
auto get_field_data =
[&vtkMesh](std::string const array_name) -> vtkDataArray* {
return vtkDataArray::SafeDownCast(
vtkMesh->GetFieldData()->GetAbstractArray(
array_name.c_str()));
};
ASSERT_EQ(
get_field_data("FieldDoubleProperty")->GetNumberOfTuples(),
fieldDoubleArray->GetNumberOfTuples());
ASSERT_EQ(get_field_data("FieldIntProperty")->GetNumberOfTuples(),
fieldIntArray->GetNumberOfTuples());
ASSERT_EQ(
get_field_data("FieldUnsignedProperty")->GetNumberOfTuples(),
fieldUnsignedArray->GetNumberOfTuples());
// Both OGS meshes should be identical
auto newMesh = std::unique_ptr<MeshLib::Mesh>{MeshLib::VtkMeshConverter::convertUnstructuredGrid(vtkMesh)};
ASSERT_EQ(mesh->getNumberOfNodes(), newMesh->getNumberOfNodes());
ASSERT_EQ(mesh->getNumberOfElements(), newMesh->getNumberOfElements());
// Both properties should be identical
auto meshProperties = mesh->getProperties();
auto newMeshProperties = newMesh->getProperties();
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointDoubleProperty"),
meshProperties.hasPropertyVector("PointDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointIntProperty"),
meshProperties.hasPropertyVector("PointIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("PointUnsignedProperty"),
meshProperties.hasPropertyVector("PointUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellDoubleProperty"),
meshProperties.hasPropertyVector("CellDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellIntProperty"),
meshProperties.hasPropertyVector("CellIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("CellUnsignedProperty"),
meshProperties.hasPropertyVector("CellUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldDoubleProperty"),
meshProperties.hasPropertyVector("FieldDoubleProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldIntProperty"),
meshProperties.hasPropertyVector("FieldIntProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("FieldUnsignedProperty"),
meshProperties.hasPropertyVector("FieldUnsignedProperty"));
ASSERT_EQ(newMeshProperties.hasPropertyVector("MaterialIDs"),
meshProperties.hasPropertyVector("MaterialIDs"));
// Check some properties on equality
auto const* const doubleProps =
meshProperties.getPropertyVector<double>("PointDoubleProperty");
auto const* const newDoubleProps =
newMeshProperties.getPropertyVector<double>(
"PointDoubleProperty");
ASSERT_EQ(newDoubleProps->getNumberOfComponents(),
doubleProps->getNumberOfComponents());
ASSERT_EQ(newDoubleProps->getNumberOfTuples(),
doubleProps->getNumberOfTuples());
ASSERT_EQ(newDoubleProps->size(), doubleProps->size());
for (std::size_t i = 0; i < doubleProps->size(); i++)
ASSERT_EQ((*newDoubleProps)[i], (*doubleProps)[i]);
auto unsignedProps = meshProperties.getPropertyVector<unsigned>(
"CellUnsignedProperty");
auto newUnsignedIds = newMeshProperties.getPropertyVector<unsigned>(
"CellUnsignedProperty");
ASSERT_EQ(newUnsignedIds->getNumberOfComponents(),
unsignedProps->getNumberOfComponents());
ASSERT_EQ(newUnsignedIds->getNumberOfTuples(),
unsignedProps->getNumberOfTuples());
ASSERT_EQ(newUnsignedIds->size(), unsignedProps->size());
for (std::size_t i = 0; i < unsignedProps->size(); i++)
ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
{ // Field data
auto p =
meshProperties.getPropertyVector<int>("FieldIntProperty");
auto new_p = newMeshProperties.getPropertyVector<int>(
"FieldIntProperty");
ASSERT_EQ(new_p->getNumberOfComponents(),
p->getNumberOfComponents());
ASSERT_EQ(new_p->getNumberOfTuples(), p->getNumberOfTuples());
ASSERT_EQ(new_p->size(), p->size());
for (std::size_t i = 0; i < unsignedProps->size(); i++)
ASSERT_EQ((*newUnsignedIds)[i], (*unsignedProps)[i]);
}
auto const* const materialIds =
meshProperties.getPropertyVector<int>("MaterialIDs");
auto const* const newMaterialIds =
newMeshProperties.getPropertyVector<int>("MaterialIDs");
ASSERT_EQ(newMaterialIds->getNumberOfComponents(),
materialIds->getNumberOfComponents());
ASSERT_EQ(newMaterialIds->getNumberOfTuples(),
materialIds->getNumberOfTuples());
ASSERT_EQ(newMaterialIds->size(), materialIds->size());
for (std::size_t i = 0; i < materialIds->size(); i++)
ASSERT_EQ((*newMaterialIds)[i], (*materialIds)[i]);
}
}
}
void ClusterDiameter::performTask( const unsigned& task_index, const unsigned& current, MultiValue& myvals ) const {
unsigned iatom=std::floor(current/getNumberOfNodes()), jatom = current - iatom*getNumberOfNodes();
Vector distance=getSeparation( getPosition(iatom), getPosition(jatom) );
double dd = distance.modulo();
myvals.setValue( 0, 1.0 ); myvals.setValue( 1, dd );
}
void ClusteringBase::retrieveAtomsInCluster( const unsigned& clust, std::vector<unsigned>& myatoms ) const {
unsigned n=0; myatoms.resize( cluster_sizes[cluster_sizes.size() - clust].first );
for(unsigned i=0; i<getNumberOfNodes(); ++i) {
if( which_cluster[i]==cluster_sizes[cluster_sizes.size() - clust].second ) { myatoms[n]=i; n++; }
}
}
std::unique_ptr<MeshLib::Mesh> convertToLinearMesh(MeshLib::Mesh const& org_mesh, std::string const& new_mesh_name)
{
std::vector<MeshLib::Node*> vec_new_nodes = MeshLib::copyNodeVector(MeshLib::getBaseNodes(org_mesh.getElements()));
// create new elements with the quadratic nodes
std::vector<MeshLib::Element*> vec_new_eles;
for (MeshLib::Element const* e : org_mesh.getElements())
{
if (e->getCellType() == MeshLib::CellType::LINE3)
{
vec_new_eles.push_back(createLinearElement<MeshLib::Line>(
e, vec_new_nodes));
}
else if (e->getCellType() == MeshLib::CellType::QUAD8)
{
vec_new_eles.push_back(createLinearElement<MeshLib::Quad>(
e, vec_new_nodes));
}
else if (e->getCellType() == MeshLib::CellType::TRI6)
{
vec_new_eles.push_back(createLinearElement<MeshLib::Tri>(
e, vec_new_nodes));
}
else if (e->getCellType() == MeshLib::CellType::HEX20)
{
vec_new_eles.push_back(createLinearElement<MeshLib::Hex>(
e, vec_new_nodes));
}
else if (e->getCellType() == MeshLib::CellType::TET10)
{
vec_new_eles.push_back(createLinearElement<MeshLib::Tet>(
e, vec_new_nodes));
}
else
{
OGS_FATAL("Mesh element type %s is not supported", MeshLib::CellType2String(e->getCellType()).c_str());
}
}
auto new_mesh = std::make_unique<MeshLib::Mesh>(
new_mesh_name, vec_new_nodes, vec_new_eles,
org_mesh.getProperties().excludeCopyProperties(
std::vector<MeshLib::MeshItemType>(1,
MeshLib::MeshItemType::Node)));
// copy property vectors for nodes
MeshLib::Properties const& src_properties = org_mesh.getProperties();
for (auto name : src_properties.getPropertyVectorNames())
{
if (!src_properties.existsPropertyVector<double>(name))
{
continue;
}
auto const* src_prop = src_properties.getPropertyVector<double>(name);
if (src_prop->getMeshItemType() != MeshLib::MeshItemType::Node)
{
continue;
}
auto const n_src_comp = src_prop->getNumberOfComponents();
auto new_prop =
new_mesh->getProperties().createNewPropertyVector<double>(
name, MeshLib::MeshItemType::Node, n_src_comp);
new_prop->resize(new_mesh->getNumberOfNodes() * n_src_comp);
// copy only base node values
for (unsigned i=0; i<org_mesh.getNumberOfBaseNodes(); i++)
{
for (int j = 0; j < n_src_comp; j++)
{
(*new_prop)[i * n_src_comp + j] =
(*src_prop)[i * n_src_comp + j];
}
}
}
return new_mesh;
}
