Commit ccbfa353 authored by Kenneth Leiter's avatar Kenneth Leiter
Browse files

ENH: Modify how XdmfMap stores data internally. It now follows a form

used in other FEM codes, in a manner that makes it easy to assemble nodal
forces.

Get test compiling and running again.
parent 52708d7f
......@@ -22,11 +22,11 @@
/*****************************************************************************/
#include "XdmfAttribute.hpp"
#include "XdmfError.hpp"
#include "XdmfGridCollection.hpp"
#include "XdmfGridCollectionType.hpp"
#include "XdmfHeavyDataController.hpp"
#include "XdmfMap.hpp"
#include "XdmfError.hpp"
boost::shared_ptr<XdmfMap>
XdmfMap::New()
......@@ -38,60 +38,46 @@ XdmfMap::New()
std::vector<boost::shared_ptr<XdmfMap> >
XdmfMap::New(const std::vector<boost::shared_ptr<XdmfAttribute> > & globalNodeIds)
{
unsigned int maxGlobalNodeId = 0;
for(unsigned int i=0; i<globalNodeIds.size(); ++i) {
const boost::shared_ptr<XdmfAttribute> currGlobalNodeIds =
globalNodeIds[i];
for(unsigned int j=0; j<currGlobalNodeIds->getSize(); ++j) {
unsigned int currGlobalNodeId =
currGlobalNodeIds->getValue<unsigned int>(j);
if(currGlobalNodeId > maxGlobalNodeId) {
maxGlobalNodeId = currGlobalNodeId;
}
}
}
// globalNodeId | taskId | localNodeId at taskId
std::vector<std::map<unsigned int, unsigned int> >
globalNodeIdMap(maxGlobalNodeId + 1,
std::map<unsigned int, unsigned int>());
std::map<node_id, std::map<task_id, node_id> > globalNodeIdMap;
// Fill globalNodeIdMap
// fill globalNodeIdMap using globalNodeIds
for(unsigned int i=0; i<globalNodeIds.size(); ++i) {
const boost::shared_ptr<XdmfAttribute> currGlobalNodeIds =
const boost::shared_ptr<XdmfAttribute> currGlobalNodeIds =
globalNodeIds[i];
for(unsigned int j=0; j<currGlobalNodeIds->getSize(); ++j) {
unsigned int currGlobalNodeId =
currGlobalNodeIds->getValue<unsigned int>(j);
const node_id currGlobalNodeId = currGlobalNodeIds->getValue<node_id>(j);
globalNodeIdMap[currGlobalNodeId][i] = j;
}
}
std::vector<boost::shared_ptr<XdmfMap> > toReturn;
toReturn.reserve(globalNodeIds.size());
// Fill maps for each partition
std::vector<boost::shared_ptr<XdmfMap> > returnValue;
returnValue.resize(globalNodeIds.size());
// fill maps for each partition
for(unsigned int i=0; i<globalNodeIds.size(); ++i) {
boost::shared_ptr<XdmfMap> map = XdmfMap::New();
toReturn.push_back(map);
const boost::shared_ptr<XdmfAttribute> currGlobalNodeIds =
returnValue[i] = map;
const boost::shared_ptr<XdmfAttribute> currGlobalNodeIds =
globalNodeIds[i];
for(unsigned int j=0; j<currGlobalNodeIds->getSize(); ++j) {
unsigned int currGlobalNodeId =
currGlobalNodeIds->getValue<unsigned int>(j);
if(globalNodeIdMap[currGlobalNodeId].size() > 1) {
for(std::map<unsigned int, unsigned int>::const_iterator iter =
globalNodeIdMap[currGlobalNodeId].begin();
iter != globalNodeIdMap[currGlobalNodeId].end();
const node_id currGlobalNodeId = currGlobalNodeIds->getValue<node_id>(j);
const std::map<task_id, node_id> & currMap =
globalNodeIdMap[currGlobalNodeId];
if(currMap.size() > 1) {
for(std::map<task_id, node_id>::const_iterator iter = currMap.begin();
iter != currMap.end();
++iter) {
if(iter->first != i) {
map->insert(j, iter->first, iter->second);
map->insert(iter->first, j, iter->second);
}
}
}
}
}
return toReturn;
return returnValue;
}
XdmfMap::XdmfMap()
......@@ -117,33 +103,30 @@ XdmfMap::getItemTag() const
return ItemTag;
}
std::map<unsigned int, unsigned int>
XdmfMap::getRemoteNodeIds(const unsigned int localNodeId)
std::map<XdmfMap::task_id, XdmfMap::node_id_map>
XdmfMap::getMap() const
{
std::map<unsigned int, std::map<unsigned int, unsigned int> >::const_iterator
iter = mMap.find(localNodeId);
return mMap;
}
XdmfMap::node_id_map
XdmfMap::getRemoteNodeIds(const task_id remoteTaskId)
{
std::map<task_id, node_id_map>::const_iterator iter =
mMap.find(remoteTaskId);
if(iter != mMap.end()) {
return iter->second;
}
// No entry, return empty map.
return std::map<unsigned int, unsigned int>();
return node_id_map();
}
void
XdmfMap::insert(const unsigned int localNodeId,
const unsigned int remoteTaskId,
const unsigned int remoteLocalNodeId)
XdmfMap::insert(const task_id remoteTaskId,
const node_id localNodeId,
const node_id remoteLocalNodeId)
{
std::map<unsigned int, std::map<unsigned int, unsigned int> >::iterator
iter = mMap.find(localNodeId);
if(iter != mMap.end()) {
iter->second[remoteTaskId] = remoteLocalNodeId;
}
else {
std::map<unsigned int, unsigned int> newMap;
newMap[remoteTaskId] = remoteLocalNodeId;
mMap[localNodeId] = newMap;
}
mMap[remoteTaskId][localNodeId].insert(remoteLocalNodeId);
}
bool XdmfMap::isInitialized() const
......@@ -157,6 +140,7 @@ XdmfMap::populateItem(const std::map<std::string, std::string> & itemProperties,
const XdmfCoreReader * const reader)
{
XdmfItem::populateItem(itemProperties, childItems, reader);
std::vector<boost::shared_ptr<XdmfArray> > arrayVector;
arrayVector.reserve(3);
for(std::vector<boost::shared_ptr<XdmfItem> >::const_iterator iter =
......@@ -168,13 +152,21 @@ XdmfMap::populateItem(const std::map<std::string, std::string> & itemProperties,
arrayVector.push_back(array);
}
}
if(arrayVector.size() != 3)
XdmfError::message(XdmfError::FATAL, "Length of array vector not equal to 3 in XdmfMap::populateItem");
XdmfError::message(XdmfError::FATAL,
"Expected 3 arrays attached to XdmfMap::populateItem");
if(!(arrayVector[0]->getSize() == arrayVector[1]->getSize() &&
arrayVector[0]->getSize() == arrayVector[2]->getSize()))
XdmfError::message(XdmfError::FATAL, "Length of individual array vectors not equal in XdmfMap::populateItem");
arrayVector[0]->getSize() == arrayVector[2]->getSize())) {
XdmfError::message(XdmfError::FATAL,
"Arrays must be of equal size in "
"XdmfMap:: populateItem");
}
// check if any arrays have values in memory - if so, they need to be
// read into map
bool needToRead = false;
for(std::vector<boost::shared_ptr<XdmfArray> >::const_iterator iter =
for(std::vector<boost::shared_ptr<XdmfArray> >::const_iterator iter =
arrayVector.begin();
iter != arrayVector.end();
++iter) {
......@@ -183,22 +175,25 @@ XdmfMap::populateItem(const std::map<std::string, std::string> & itemProperties,
break;
}
}
if(needToRead) {
for(std::vector<boost::shared_ptr<XdmfArray> >::const_iterator iter =
arrayVector.begin();
iter != arrayVector.end();
++iter) {
(*iter)->read();
if(!(*iter)->isInitialized()) {
(*iter)->read();
}
}
for(unsigned int i=0; i<arrayVector[0]->getSize(); ++i) {
this->insert(arrayVector[0]->getValue<unsigned int>(i),
arrayVector[1]->getValue<unsigned int>(i),
arrayVector[2]->getValue<unsigned int>(i));
this->insert(arrayVector[0]->getValue<task_id>(i),
arrayVector[1]->getValue<node_id>(i),
arrayVector[2]->getValue<node_id>(i));
}
}
else {
mLocalNodeIdsController = arrayVector[0]->getHeavyDataController();
mRemoteTaskIdsController = arrayVector[1]->getHeavyDataController();
mRemoteTaskIdsController = arrayVector[0]->getHeavyDataController();
mLocalNodeIdsController = arrayVector[1]->getHeavyDataController();
mRemoteLocalNodeIdsController = arrayVector[2]->getHeavyDataController();
}
}
......@@ -209,31 +204,29 @@ XdmfMap::read()
if(mLocalNodeIdsController &&
mRemoteTaskIdsController &&
mRemoteLocalNodeIdsController) {
if(!(mLocalNodeIdsController->getSize() ==
mRemoteTaskIdsController->getSize() &&
mLocalNodeIdsController->getSize() ==
mRemoteLocalNodeIdsController->getSize()))
XdmfError::message(XdmfError::FATAL, "Number of local nodes not equal to number of remote tasks or nodes in XdmfMap::read");
boost::shared_ptr<XdmfArray> globalNodeIds = XdmfArray::New();
boost::shared_ptr<XdmfArray> taskIds = XdmfArray::New();
if(!(mLocalNodeIdsController->getSize() ==
mRemoteTaskIdsController->getSize() &&
mLocalNodeIdsController->getSize() ==
mRemoteLocalNodeIdsController->getSize())) {
XdmfError::message(XdmfError::FATAL,
"Arrays must be of equal size in XdmfMap::read");
}
boost::shared_ptr<XdmfArray> remoteTaskIds = XdmfArray::New();
boost::shared_ptr<XdmfArray> localNodeIds = XdmfArray::New();
mLocalNodeIdsController->read(globalNodeIds.get());
mRemoteTaskIdsController->read(taskIds.get());
mRemoteLocalNodeIdsController->read(localNodeIds.get());
boost::shared_ptr<XdmfArray> remoteLocalNodeIds = XdmfArray::New();
for(unsigned int i=0; i<globalNodeIds->getSize(); ++i) {
std::map<unsigned int, std::map<unsigned int, unsigned int> >::iterator
iter = mMap.find(globalNodeIds->getValue<unsigned int>(i));
if(iter != mMap.end()) {
iter->second[taskIds->getValue<unsigned int>(i)] =
localNodeIds->getValue<unsigned int>(i);
}
else {
std::map<unsigned int, unsigned int> newMap;
newMap[taskIds->getValue<unsigned int>(i)] =
localNodeIds->getValue<unsigned int>(i);
mMap[globalNodeIds->getValue<unsigned int>(i)] = newMap;
}
mRemoteTaskIdsController->read(remoteTaskIds.get());
mLocalNodeIdsController->read(localNodeIds.get());
mRemoteLocalNodeIdsController->read(remoteLocalNodeIds.get());
for(unsigned int i=0; i<remoteTaskIds->getSize(); ++i) {
const unsigned int remoteTaskId = remoteTaskIds->getValue<task_id>(i);
const unsigned int localNodeId = localNodeIds->getValue<node_id>(i);
const unsigned int remoteLocalNodeId =
remoteLocalNodeIds->getValue<node_id>(i);
mMap[remoteTaskId][localNodeId].insert(remoteLocalNodeId);
}
}
}
......@@ -245,17 +238,19 @@ XdmfMap::release()
}
void
XdmfMap::setHeavyDataControllers(boost::shared_ptr<XdmfHeavyDataController> localNodeIdsController,
boost::shared_ptr<XdmfHeavyDataController> remoteTaskIdsController,
XdmfMap::setHeavyDataControllers(boost::shared_ptr<XdmfHeavyDataController> remoteTaskIdsController,
boost::shared_ptr<XdmfHeavyDataController> localNodeIdsController,
boost::shared_ptr<XdmfHeavyDataController> remoteLocalNodeIdsController)
{
if(!(localNodeIdsController->getSize() ==
remoteTaskIdsController->getSize() &&
localNodeIdsController->getSize() ==
remoteLocalNodeIdsController->getSize()))
XdmfError::message(XdmfError::FATAL, "Number of local nodes not equal to number of remote tasks or nodes in XdmfMap::read");
mLocalNodeIdsController = localNodeIdsController;
remoteTaskIdsController->getSize() &&
localNodeIdsController->getSize() ==
remoteLocalNodeIdsController->getSize()))
XdmfError::message(XdmfError::FATAL,
"Arrays must be of equal size in "
"XdmfMap::setHeavyDataControllers");
mRemoteTaskIdsController = remoteTaskIdsController;
mLocalNodeIdsController = localNodeIdsController;
mRemoteLocalNodeIdsController = remoteLocalNodeIdsController;
}
......@@ -264,28 +259,38 @@ void
XdmfMap::traverse(const boost::shared_ptr<XdmfBaseVisitor> visitor)
{
XdmfItem::traverse(visitor);
boost::shared_ptr<XdmfArray> localNodeIds = XdmfArray::New();
boost::shared_ptr<XdmfArray> remoteTaskIds = XdmfArray::New();
boost::shared_ptr<XdmfArray> localNodeIds = XdmfArray::New();
boost::shared_ptr<XdmfArray> remoteLocalNodeIds = XdmfArray::New();
for(std::map<unsigned int, std::map<unsigned int, unsigned int> >::const_iterator
for(std::map<task_id, node_id_map>::const_iterator
iter = mMap.begin();
iter != mMap.end();
++iter) {
for(std::map<unsigned int, unsigned int>::const_iterator iter2 =
iter->second.begin();
for(node_id_map::const_iterator
iter2 = iter->second.begin();
iter2 != iter->second.end();
++iter2) {
localNodeIds->pushBack(iter->first);
remoteTaskIds->pushBack(iter2->first);
remoteLocalNodeIds->pushBack(iter2->second);
for(node_id_map::mapped_type::const_iterator iter3 =
iter2->second.begin();
iter3 != iter2->second.end();
++iter3) {
remoteTaskIds->pushBack(iter->first);
localNodeIds->pushBack(iter2->first);
remoteLocalNodeIds->pushBack(*iter3);
}
}
}
localNodeIds->setHeavyDataController(mLocalNodeIdsController);
remoteTaskIds->setHeavyDataController(mRemoteTaskIdsController);
localNodeIds->setHeavyDataController(mLocalNodeIdsController);
remoteLocalNodeIds->setHeavyDataController(mRemoteLocalNodeIdsController);
remoteTaskIds->accept(visitor);
localNodeIds->accept(visitor);
remoteTaskIds->accept(visitor);
remoteLocalNodeIds->accept(visitor);
mLocalNodeIdsController = localNodeIds->getHeavyDataController();
mRemoteTaskIdsController = remoteTaskIds->getHeavyDataController();
mRemoteLocalNodeIdsController = remoteLocalNodeIds->getHeavyDataController();
......
......@@ -26,13 +26,15 @@
// Forward Declarations
class XdmfArray;
class XdmfGridCollection;
class XdmfAttribute;
class XdmfHeavyDataController;
// Includes
#include "XdmfMap.hpp"
#include "Xdmf.hpp"
#include "XdmfItem.hpp"
#include <set>
/**
* @brief Boundary communicator map for partitioned spatial
* collections.
......@@ -56,6 +58,10 @@ class XDMF_EXPORT XdmfMap : public XdmfItem {
public:
typedef int node_id;
typedef int task_id;
typedef std::map<node_id, std::set<node_id> > node_id_map;
/**
* Create a new XdmfMap.
*
......@@ -70,6 +76,7 @@ class XDMF_EXPORT XdmfMap : public XdmfItem {
*
* @param globalNodeIds a vector of attributes containing globalNodeId
* values for each partition to be mapped.
*
* @return constructed XdmfMaps for each partition. The size of the vector
* will be the same as the globalNodeIds vector.
*/
......@@ -84,23 +91,44 @@ class XDMF_EXPORT XdmfMap : public XdmfItem {
std::map<std::string, std::string> getItemProperties() const;
/**
* Given a local node id return a map containing equivalent remote
* Get stored boundary communicator map.
*
* @return stored boundary communicator map.
*/
std::map<task_id, node_id_map> getMap() const;
/**
* Given a remote task id return a map of local node ids to remote
* node ids
*
* @param remoteTaskId a task id to retrieve mapping for.
*
* @return a map of local node ids to a vector of remote node ids on
* remoteTaskId.
*/
std::map<unsigned int, unsigned int>
getRemoteNodeIds(const unsigned int localNodeId);
node_id_map getRemoteNodeIds(const task_id remoteTaskId);
std::string getItemTag() const;
using XdmfItem::insert;
void insert(const unsigned int localNodeId,
const unsigned int remoteTaskId,
const unsigned int remoteLocalNodeId);
/**
* Insert a new entry in map.
*
* @param remoteTaskId task id where the remoteLoalNodeId is located.
* @param localNodeId the node id of the node being mapped.
* @param remoteLocalNodeId a node id on the remoteTaskId that the
* localNodeId is mapped to.
*/
void insert(const task_id remoteTaskId,
const node_id localNodeId,
const node_id remoteLocalNodeId);
/**
* Returns whether the map is initialized (contains values in
* memory).
*
* @return bool true if map contains values in memory.
*/
bool isInitialized() const;
......@@ -117,16 +145,16 @@ class XDMF_EXPORT XdmfMap : public XdmfItem {
/**
* Set the heavy data controllers for this map.
*
* @param localNodeIdsController an XdmfHeavyDataController to the local
* node ids dataset.
* @param remoteTaskIdsController an XdmfHeavyDataController to the remote
* task ids dataset.
* @param localNodeIdsController an XdmfHeavyDataController to the local
* node ids dataset.
* @param remoteLocalNodeIdsController an XdmfHeavyDataController to the
* remote local node ids dataset.
*/
void
setHeavyDataControllers(boost::shared_ptr<XdmfHeavyDataController> localNodeIdsController,
boost::shared_ptr<XdmfHeavyDataController> remoteTaskIdsController,
setHeavyDataControllers(boost::shared_ptr<XdmfHeavyDataController> remoteTaskIdsController,
boost::shared_ptr<XdmfHeavyDataController> localNodeIdsController,
boost::shared_ptr<XdmfHeavyDataController> remoteLocalNodeIdsController);
void traverse(const boost::shared_ptr<XdmfBaseVisitor> visitor);
......@@ -146,8 +174,8 @@ class XDMF_EXPORT XdmfMap : public XdmfItem {
void operator=(const XdmfMap & map); // Not implemented.
boost::shared_ptr<XdmfHeavyDataController> mLocalNodeIdsController;
// localNodeId | remoteTaskId | remoteLocalNodeId
std::map<unsigned int, std::map<unsigned int, unsigned int> > mMap;
// remoteTaskId | localNodeId | remoteLocalNodeId
std::map<task_id, node_id_map > mMap;
boost::shared_ptr<XdmfHeavyDataController> mRemoteLocalNodeIdsController;
boost::shared_ptr<XdmfHeavyDataController> mRemoteTaskIdsController;
......
......@@ -15,6 +15,7 @@ ADD_TEST_CXX(TestXdmfCurvilinearGrid)
ADD_TEST_CXX(TestXdmfGeometry)
ADD_TEST_CXX(TestXdmfGridCollection)
ADD_TEST_CXX(TestXdmfHDF5Hyperslab)
ADD_TEST_CXX(TestXdmfMap)
ADD_TEST_CXX(TestXdmfReader)
ADD_TEST_CXX(TestXdmfRegularGrid)
ADD_TEST_CXX(TestXdmfRectilinearGrid)
......@@ -48,6 +49,12 @@ CLEAN_TEST_CXX(TestXdmfHDF5Hyperslab
TestXdmfHDF5Hyperslab.xmf
TestXdmfHDF5Hyperslab.h5
TestXdmfHDF5Hyperslab2.xmf)
CLEAN_TEST_CXX(TestXdmfMap
TestXdmfMap1.xmf
TestXdmfMap2.xmf
TestXdmfMapHDF1.xmf
TestXdmfMapHDF1.h5
TestXdmfMapHDF2.xmf)
CLEAN_TEST_CXX(TestXdmfReader
TestXdmfReader1.h5
TestXdmfReader1.xmf
......
......@@ -3,7 +3,6 @@
#include "XdmfAttributeType.hpp"
#include "XdmfGeometry.hpp"
#include "XdmfGeometryType.hpp"
#include "XdmfGrid.hpp"
#include "XdmfGridCollection.hpp"
#include "XdmfGridCollectionType.hpp"
#include "XdmfHDF5Writer.hpp"
......@@ -12,21 +11,28 @@
#include "XdmfTestCompareFiles.hpp"
#include "XdmfTopology.hpp"
#include "XdmfTopologyType.hpp"
#include "XdmfUnstructuredGrid.hpp"
#include "XdmfWriter.hpp"
#include <iostream>
void performTests(std::vector<boost::shared_ptr<XdmfMap> > & boundaryMaps)
{
boundaryMaps[0]->read();
boundaryMaps[1]->read();
std::map<unsigned int, unsigned int> mapping;
mapping = boundaryMaps[0]->getRemoteNodeIds(0);
assert(mapping.size() == 0);
// localNodeId || remoteLocalNodeId
XdmfMap::node_id_map mapping;
mapping = boundaryMaps[0]->getRemoteNodeIds(1);
assert(mapping.size() == 1);
assert(mapping[1] == 0);
assert(mapping[1].size() == 1);
assert(*(mapping[1].begin()) == 0);
mapping = boundaryMaps[1]->getRemoteNodeIds(0);
assert(mapping.size() == 1);
assert(mapping[0] == 1);
assert(mapping[0].size() == 1);
assert(*(mapping[0].begin()) == 1);
}
/*
......@@ -45,7 +51,7 @@ void performTests(std::vector<boost::shared_ptr<XdmfMap> > & boundaryMaps)
int main(int, char **)
{
// Grid 0
boost::shared_ptr<XdmfGrid> grid0 = XdmfGrid::New();
boost::shared_ptr<XdmfUnstructuredGrid> grid0 = XdmfUnstructuredGrid::New();
grid0->getGeometry()->setType(XdmfGeometryType::XYZ());
double points0[] = {-1, 0, 0, 0, 0, 0};
grid0->getGeometry()->insert(0, &points0[0], 6);
......@@ -60,7 +66,7 @@ int main(int, char **)
globalNodeIds0->insert(0, &globalVals0[0], 2);
// Grid 1
boost::shared_ptr<XdmfGrid> grid1 = XdmfGrid::New();
boost::shared_ptr<XdmfUnstructuredGrid> grid1 = XdmfUnstructuredGrid::New();
grid1->getGeometry()->setType(XdmfGeometryType::XYZ());
double points1[] = {0, 0, 0, 1, 0, 0};
grid1->getGeometry()->insert(0, &points1[0], 6);
......@@ -78,7 +84,7 @@ int main(int, char **)
globalNodeIds.push_back(globalNodeIds0);
globalNodeIds.push_back(globalNodeIds1);
std::vector<boost::shared_ptr<XdmfMap> > boundaryMaps =
std::vector<boost::shared_ptr<XdmfMap> > boundaryMaps =
XdmfMap::New(globalNodeIds);
performTests(boundaryMaps);
......@@ -101,8 +107,8 @@ int main(int, char **)
boost::shared_dynamic_cast<XdmfDomain>(reader->read("TestXdmfMap1.xmf"));
boundaryMaps.clear();
boundaryMaps.push_back(domain2->getGridCollection(0)->getGrid(0)->getMap());
boundaryMaps.push_back(domain2->getGridCollection(0)->getGrid(1)->getMap());
boundaryMaps.push_back(domain2->getGridCollection(0)->getUnstructuredGrid(0)->getMap());
boundaryMaps.push_back(domain2->getGridCollection(0)->getUnstructuredGrid(1)->getMap());
performTests(boundaryMaps);
boost::shared_ptr<XdmfWriter> writer2 = XdmfWriter::New("TestXdmfMap2.xmf");
......@@ -121,13 +127,13 @@ int main(int, char **)
(reader->read("TestXdmfMapHDF1.xmf"));
boundaryMaps.clear();
boundaryMaps.push_back(domainHDF->getGridCollection(0)->getGrid(0)->getMap());
boundaryMaps.push_back(domainHDF->getGridCollection(0)->getGrid(1)->getMap());
boundaryMaps.push_back(domainHDF->getGridCollection(0)->getUnstructuredGrid(0)->getMap());
boundaryMaps.push_back(domainHDF->getGridCollection(0)->getUnstructuredGrid(1)->getMap());
performTests(boundaryMaps);
boost::shared_ptr<XdmfWriter> writerHDF2 =
XdmfWriter::New("TestXdmfMapHDF2.xmf");
writerHDF2->getHDF5Writer()->setMode(XdmfHDF5Writer::Overwrite);
writerHDF2->getHeavyDataWriter()->setMode(XdmfHeavyDataWriter::Overwrite);
writerHDF2->setLightDataLimit(0);
domainHDF->accept(writerHDF2);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment