From eae4821639bec166f7ca9dba608f7486839af317 Mon Sep 17 00:00:00 2001 From: "Andrew J. Burns (Cont" Date: Mon, 13 Jun 2016 10:59:02 -0400 Subject: [PATCH 01/11] Changes from ARL's Repo (C Wrappers, DSM rework, Custom Types, Templates, GridControllers, TIFF integration, XdmfAggregate) --- CMake/TestingSuite/TestDriverC.cmake.in | 9 +- CMake/TestingSuite/TestDriverCxx.cmake.in | 9 +- CMake/TestingSuite/TestDriverFortran.cmake.in | 9 +- CMake/TestingSuite/TestDriverPython.cmake.in | 8 +- .../TestDriverPythonScript.cmake.in | 11 +- CMake/TestingSuite/TestingSetup.cmake | 5 + CMake/VersionSuite/ProjectVersion.hpp | 114 +- CMake/VersionSuite/SetUpVersion.cmake | 20 +- CMakeLists.txt | 84 +- Xdmf.dtd | 85 + Xdmf.hpp | 12 + Xdmf.i | 863 ++++- XdmfAggregate.cpp | 272 ++ XdmfAggregate.hpp | 214 ++ XdmfAttribute.cpp | 140 + XdmfAttribute.hpp | 41 +- XdmfAttributeCenter.cpp | 66 +- XdmfAttributeCenter.hpp | 32 +- XdmfAttributeType.cpp | 89 +- XdmfAttributeType.hpp | 37 +- XdmfCurvilinearGrid.cpp | 214 +- XdmfCurvilinearGrid.hpp | 58 +- XdmfDomain.cpp | 379 +- XdmfDomain.hpp | 341 +- XdmfGeometry.cpp | 180 +- XdmfGeometry.hpp | 101 +- XdmfGeometryType.cpp | 153 +- XdmfGeometryType.hpp | 48 +- XdmfGraph.cpp | 75 +- XdmfGraph.hpp | 44 +- XdmfGrid.cpp | 361 +- XdmfGrid.hpp | 400 ++- XdmfGridCollection.cpp | 302 +- XdmfGridCollection.hpp | 51 +- XdmfGridCollectionType.cpp | 49 +- XdmfGridCollectionType.hpp | 32 +- XdmfGridController.cpp | 195 + XdmfGridController.hpp | 226 ++ XdmfItemFactory.cpp | 153 +- XdmfItemFactory.hpp | 20 + XdmfMap.cpp | 288 ++ XdmfMap.hpp | 65 +- XdmfReader.cpp | 26 + XdmfReader.hpp | 37 +- XdmfRectilinearGrid.cpp | 376 +- XdmfRectilinearGrid.hpp | 56 +- XdmfRegularGrid.cpp | 336 +- XdmfRegularGrid.hpp | 73 +- XdmfSet.cpp | 124 +- XdmfSet.hpp | 53 +- XdmfSetType.cpp | 65 +- XdmfSetType.hpp | 34 +- XdmfTime.cpp | 33 + XdmfTime.hpp | 29 +- XdmfTopology.cpp | 435 ++- XdmfTopology.hpp | 52 +- XdmfTopologyType.cpp | 695 +++- XdmfTopologyType.hpp | 134 +- XdmfUnstructuredGrid.cpp | 158 + XdmfUnstructuredGrid.hpp | 55 +- core/CMakeLists.txt | 62 +- core/XdmfArray.cpp | 1522 +++++++- core/XdmfArray.hpp | 517 ++- core/XdmfArray.tpp | 11 +- core/XdmfArrayReference.cpp | 87 + core/XdmfArrayReference.hpp | 68 +- core/XdmfArrayType.cpp | 282 +- core/XdmfArrayType.hpp | 103 +- core/XdmfBinaryController.cpp | 237 +- core/XdmfBinaryController.hpp | 167 +- core/XdmfConfig.hpp.in | 1 + core/XdmfCore.i | 854 ++++- core/XdmfCoreItemFactory.cpp | 528 +++ core/XdmfCoreItemFactory.hpp | 34 +- core/XdmfCoreReader.cpp | 85 +- core/XdmfCoreReader.hpp | 56 +- core/XdmfError.cpp | 102 + core/XdmfError.hpp | 82 +- core/XdmfFunction.cpp | 471 ++- core/XdmfFunction.hpp | 72 +- core/XdmfHDF5Controller.cpp | 182 +- core/XdmfHDF5Controller.hpp | 172 +- core/XdmfHDF5Writer.cpp | 363 +- core/XdmfHDF5Writer.hpp | 240 +- core/XdmfHeavyDataController.cpp | 318 +- core/XdmfHeavyDataController.hpp | 257 +- core/XdmfHeavyDataDescription.cpp | 88 + core/XdmfHeavyDataDescription.hpp | 112 + core/XdmfHeavyDataWriter.cpp | 113 + core/XdmfHeavyDataWriter.hpp | 154 +- core/XdmfInformation.cpp | 135 +- core/XdmfInformation.hpp | 59 +- core/XdmfItem.cpp | 105 +- core/XdmfItem.hpp | 127 +- core/XdmfItemProperty.cpp | 51 + core/XdmfItemProperty.hpp | 8 + core/XdmfPlaceholder.cpp | 224 ++ core/XdmfPlaceholder.hpp | 156 + core/XdmfSharedPtr.hpp | 13 + core/XdmfSparseMatrix.cpp | 145 +- core/XdmfSparseMatrix.hpp | 120 +- core/XdmfSubset.cpp | 211 +- core/XdmfSubset.hpp | 54 +- core/XdmfSystemUtils.cpp | 18 +- core/XdmfSystemUtils.hpp | 19 +- core/XdmfTIFFController.cpp | 617 ++++ core/XdmfTIFFController.hpp | 187 + core/XdmfVisitor.hpp | 21 +- core/XdmfWriter.cpp | 480 ++- core/XdmfWriter.hpp | 117 +- core/dsm/CMakeLists.txt | 69 +- core/dsm/XdmfDSM.i | 265 +- core/dsm/XdmfDSMBuffer.cpp | 2632 ++++++++++++-- core/dsm/XdmfDSMBuffer.hpp | 1501 ++++++-- core/dsm/XdmfDSMCommMPI.cpp | 892 ++++- core/dsm/XdmfDSMCommMPI.hpp | 663 +++- core/dsm/XdmfDSMDescription.cpp | 115 + core/dsm/XdmfDSMDescription.hpp | 113 + core/dsm/XdmfDSMDriver.cpp | 634 ++-- core/dsm/XdmfDSMDriver.hpp | 27 +- core/dsm/XdmfDSMItemFactory.cpp | 391 ++ core/dsm/XdmfDSMItemFactory.hpp | 114 + core/dsm/XdmfHDF5ControllerDSM.cpp | 877 +++-- core/dsm/XdmfHDF5ControllerDSM.hpp | 586 +-- core/dsm/XdmfHDF5WriterDSM.cpp | 1108 +++++- core/dsm/XdmfHDF5WriterDSM.hpp | 617 ++-- core/dsm/tests/C/CConnectTest.sh | 7 + core/dsm/tests/C/CDSMLoopTest.c | 310 ++ core/dsm/tests/C/CDSMLoopTest.sh | 1 + core/dsm/tests/C/CMakeLists.txt | 37 + core/dsm/tests/C/CXdmfAcceptTest.c | 56 + core/dsm/tests/C/CXdmfConnectTest.c | 234 ++ core/dsm/tests/C/CXdmfConnectTest2.c | 229 ++ core/dsm/tests/CMakeLists.txt | 1 + core/dsm/tests/Cxx/CMakeLists.txt | 42 +- core/dsm/tests/Cxx/ConnectTestPaged.sh | 7 + core/dsm/tests/Cxx/CrayConnectTest.sh | 3 + core/dsm/tests/Cxx/DSMLoopTest.cpp | 95 +- core/dsm/tests/Cxx/DSMLoopTestPaged.cpp | 376 ++ core/dsm/tests/Cxx/DSMLoopTestPaged.sh | 1 + .../tests/Cxx/DSMLoopTestPagedSingleCore.cpp | 162 + .../tests/Cxx/DSMLoopTestPagedSingleCore.sh | 1 + core/dsm/tests/Cxx/TestXdmfHDF5WriterDSM.cpp | 4 +- core/dsm/tests/Cxx/XdmfAcceptTest.cpp | 6 +- core/dsm/tests/Cxx/XdmfAcceptTestPaged.cpp | 117 + core/dsm/tests/Cxx/XdmfConnectTest.cpp | 52 +- core/dsm/tests/Cxx/XdmfConnectTest2.cpp | 53 +- core/dsm/tests/Cxx/XdmfConnectTest2Paged.cpp | 236 ++ core/dsm/tests/Cxx/XdmfConnectTestPaged.cpp | 315 ++ core/dsm/tests/Python/CMakeLists.txt | 28 +- core/dsm/tests/Python/CrayPythonConnect.sh | 5 + .../dsm/tests/Python/XdmfExampleAcceptTest.py | 4 +- .../tests/Python/XdmfExampleConnectTest.py | 22 +- .../tests/Python/XdmfExampleConnectTest2.py | 16 +- core/dsm/tests/Python/XdmfExampleDsmTest.py | 161 +- core/tests/C/CMakeLists.txt | 47 + core/tests/C/CTestXdmfArray.c | 343 ++ core/tests/C/CTestXdmfArrayType.c | 160 + core/tests/C/CTestXdmfError.c | 100 + core/tests/C/CTestXdmfFunction.c | 393 ++ core/tests/C/CTestXdmfHDF5Controller.c | 194 + core/tests/C/CTestXdmfInformation.c | 71 + core/tests/C/CTestXdmfSparseMatrix.c | 170 + core/tests/C/CTestXdmfSubset.c | 174 + core/tests/C/CTestXdmfWriter.c | 21 + core/tests/CMakeLists.txt | 1 + core/tests/Cxx/CMakeLists.txt | 4 +- core/tests/Cxx/TestXdmfHDF5Writer.cpp | 34 + core/tests/Python/TestXdmfArray.py | 25 + doc/Doxyfile.in | 2 +- examples/Cxx/ExampleXdmfAggregate.cpp | 53 + examples/Cxx/ExampleXdmfArray.cpp | 22 + examples/Cxx/ExampleXdmfBinaryController.cpp | 76 + examples/Cxx/ExampleXdmfDSMNoThread.cpp | 308 +- examples/Cxx/ExampleXdmfGeometry.cpp | 16 + examples/Cxx/ExampleXdmfGrid.cpp | 27 + examples/Cxx/ExampleXdmfHDF5Writer.cpp | 28 + .../Cxx/ExampleXdmfHeavyDataController.cpp | 6 + examples/Cxx/ExampleXdmfPlaceholder.cpp | 40 + examples/Cxx/ExampleXdmfTIFFController.cpp | 56 + examples/Cxx/ExampleXdmfWriter.cpp | 13 + examples/Cxx/XdmfAcceptTest.cpp | 8 + examples/Cxx/XdmfConnectTest.cpp | 46 +- examples/Cxx/XdmfConnectTest2.cpp | 58 +- examples/Python/XdmfExampleAcceptTest.py | 8 + examples/Python/XdmfExampleAggregate.py | 40 + examples/Python/XdmfExampleArray.py | 19 + .../Python/XdmfExampleBinaryController.py | 72 + examples/Python/XdmfExampleConnectTest.py | 34 + examples/Python/XdmfExampleConnectTest2.py | 44 +- examples/Python/XdmfExampleDSMNoThread.py | 167 +- examples/Python/XdmfExampleGrid.py | 27 + examples/Python/XdmfExampleHDF5Writer.py | 28 + .../Python/XdmfExampleHeavyDataController.py | 6 + examples/Python/XdmfExamplePlaceholder.py | 36 + examples/Python/XdmfExampleTIFFController.py | 52 + examples/Python/XdmfExampleWriter.py | 14 + tests/C/CMakeLists.txt | 98 + tests/C/CTestXdmfAggregate.c | 98 + tests/C/CTestXdmfAttribute.c | 88 + tests/C/CTestXdmfBinaryController.c | 92 + tests/C/CTestXdmfCurvilinearGrid.c | 133 + tests/C/CTestXdmfDomain.c | 817 +++++ tests/C/CTestXdmfGeometry.c | 91 + tests/C/CTestXdmfGraph.c | 279 ++ tests/C/CTestXdmfGridCollection.c | 1204 +++++++ tests/C/CTestXdmfGridController.c | 377 ++ tests/C/CTestXdmfMap.c | 307 ++ tests/C/CTestXdmfRectilinearGrid.c | 144 + tests/C/CTestXdmfRegularGrid.c | 138 + tests/C/CTestXdmfSet.c | 73 + tests/C/CTestXdmfTIFFReadWriteCompressed.c | 83 + tests/C/CTestXdmfTopology.c | 101 + tests/C/CTestXdmfUnstructuredGrid.c | 124 + tests/C/CTestXdmfWriter.c | 303 ++ tests/CMakeLists.txt | 1 + tests/Cxx/CMakeLists.txt | 25 + tests/Cxx/DSMFileTest.sh | 6 + tests/Cxx/TestXdmfAggregate.cpp | 88 + tests/Cxx/TestXdmfBinaryController.cpp | 14 +- tests/Cxx/TestXdmfFunction.cpp | 191 +- tests/Cxx/TestXdmfGridController.cpp | 411 +++ tests/Cxx/TestXdmfHDF5Visit.cpp | 42 + tests/Cxx/TestXdmfRectilinearGrid.cpp | 21 + tests/Cxx/TestXdmfRegularGrid.cpp | 21 + tests/Cxx/TestXdmfSubset.cpp | 32 + tests/Cxx/TestXdmfTIFFReadWriteCompressed.cpp | 359 ++ tests/Cxx/XdmfFileAcceptTest.cpp | 166 + tests/Cxx/XdmfFileConnectTest.cpp | 118 + tests/Python/CMakeLists.txt | 4 + tests/Python/ReadTypeTest.py | 28 + utils/CMakeLists.txt | 24 +- utils/Xdmf.f | 27 +- utils/XdmfDiff.cpp | 48 +- utils/XdmfDiff.hpp | 33 +- utils/XdmfExodusReader.cpp | 25 + utils/XdmfExodusReader.hpp | 23 + utils/XdmfExodusWriter.cpp | 50 +- utils/XdmfExodusWriter.hpp | 31 + utils/XdmfFortran.cpp | 3150 ++++++++++++++++- utils/XdmfFortran.hpp | 798 ++++- utils/XdmfGeometryConverter.cpp | 357 ++ utils/XdmfGeometryConverter.hpp | 155 + utils/XdmfPartitioner.cpp | 86 +- utils/XdmfPartitioner.hpp | 47 +- utils/XdmfTopologyConverter.cpp | 170 + utils/XdmfTopologyConverter.hpp | 42 +- utils/XdmfUtils.i | 92 +- utils/tests/C/CMakeLists.txt | 40 + utils/tests/C/CTestXdmfDiff.c | 140 + utils/tests/C/CTestXdmfExodusIO.c | 126 + utils/tests/C/CTestXdmfGeometryConverter.c | 129 + utils/tests/C/CTestXdmfTopologyConverter.c | 178 + utils/tests/CMakeLists.txt | 10 +- utils/tests/Cxx/CMakeLists.txt | 4 + utils/tests/Cxx/TestXdmfDiff.cpp | 149 + utils/tests/Cxx/TestXdmfGeometryConverter.cpp | 110 + utils/tests/Fortran/CMakeLists.txt | 33 +- utils/tests/Fortran/ConnectDSMFortran.f90 | 5 - utils/tests/Fortran/ConnectDSMFortran2.f90 | 6 - .../tests/Fortran/FunctionTestXdmfFortran.f90 | 144 + utils/tests/Fortran/OutputTestXdmfFortran.f90 | 14 +- utils/tests/Fortran/SubsetTestXdmfFortran.f90 | 169 + utils/tests/Python/CMakeLists.txt | 31 + utils/tests/Python/XdmfTestDiff.py | 122 + .../tests/Python/XdmfTestGeometryConverter.py | 84 + .../tests/Python/XdmfTestTopologyConverter.py | 142 + 267 files changed, 43629 insertions(+), 4303 deletions(-) create mode 100644 Xdmf.dtd create mode 100644 XdmfAggregate.cpp create mode 100644 XdmfAggregate.hpp create mode 100644 XdmfGridController.cpp create mode 100644 XdmfGridController.hpp create mode 100644 core/XdmfHeavyDataDescription.cpp create mode 100644 core/XdmfHeavyDataDescription.hpp create mode 100644 core/XdmfPlaceholder.cpp create mode 100644 core/XdmfPlaceholder.hpp create mode 100644 core/XdmfTIFFController.cpp create mode 100644 core/XdmfTIFFController.hpp create mode 100644 core/dsm/XdmfDSMDescription.cpp create mode 100644 core/dsm/XdmfDSMDescription.hpp create mode 100644 core/dsm/XdmfDSMItemFactory.cpp create mode 100644 core/dsm/XdmfDSMItemFactory.hpp create mode 100755 core/dsm/tests/C/CConnectTest.sh create mode 100644 core/dsm/tests/C/CDSMLoopTest.c create mode 100755 core/dsm/tests/C/CDSMLoopTest.sh create mode 100644 core/dsm/tests/C/CMakeLists.txt create mode 100644 core/dsm/tests/C/CXdmfAcceptTest.c create mode 100644 core/dsm/tests/C/CXdmfConnectTest.c create mode 100644 core/dsm/tests/C/CXdmfConnectTest2.c create mode 100755 core/dsm/tests/Cxx/ConnectTestPaged.sh create mode 100755 core/dsm/tests/Cxx/CrayConnectTest.sh create mode 100644 core/dsm/tests/Cxx/DSMLoopTestPaged.cpp create mode 100755 core/dsm/tests/Cxx/DSMLoopTestPaged.sh create mode 100644 core/dsm/tests/Cxx/DSMLoopTestPagedSingleCore.cpp create mode 100755 core/dsm/tests/Cxx/DSMLoopTestPagedSingleCore.sh create mode 100644 core/dsm/tests/Cxx/XdmfAcceptTestPaged.cpp create mode 100644 core/dsm/tests/Cxx/XdmfConnectTest2Paged.cpp create mode 100644 core/dsm/tests/Cxx/XdmfConnectTestPaged.cpp create mode 100755 core/dsm/tests/Python/CrayPythonConnect.sh create mode 100644 core/tests/C/CMakeLists.txt create mode 100644 core/tests/C/CTestXdmfArray.c create mode 100644 core/tests/C/CTestXdmfArrayType.c create mode 100644 core/tests/C/CTestXdmfError.c create mode 100644 core/tests/C/CTestXdmfFunction.c create mode 100644 core/tests/C/CTestXdmfHDF5Controller.c create mode 100644 core/tests/C/CTestXdmfInformation.c create mode 100644 core/tests/C/CTestXdmfSparseMatrix.c create mode 100644 core/tests/C/CTestXdmfSubset.c create mode 100644 core/tests/C/CTestXdmfWriter.c create mode 100644 examples/Cxx/ExampleXdmfAggregate.cpp create mode 100644 examples/Cxx/ExampleXdmfBinaryController.cpp create mode 100644 examples/Cxx/ExampleXdmfPlaceholder.cpp create mode 100644 examples/Cxx/ExampleXdmfTIFFController.cpp create mode 100644 examples/Python/XdmfExampleAggregate.py create mode 100644 examples/Python/XdmfExampleBinaryController.py create mode 100644 examples/Python/XdmfExamplePlaceholder.py create mode 100644 examples/Python/XdmfExampleTIFFController.py create mode 100644 tests/C/CMakeLists.txt create mode 100644 tests/C/CTestXdmfAggregate.c create mode 100644 tests/C/CTestXdmfAttribute.c create mode 100644 tests/C/CTestXdmfBinaryController.c create mode 100644 tests/C/CTestXdmfCurvilinearGrid.c create mode 100644 tests/C/CTestXdmfDomain.c create mode 100644 tests/C/CTestXdmfGeometry.c create mode 100644 tests/C/CTestXdmfGraph.c create mode 100644 tests/C/CTestXdmfGridCollection.c create mode 100644 tests/C/CTestXdmfGridController.c create mode 100644 tests/C/CTestXdmfMap.c create mode 100644 tests/C/CTestXdmfRectilinearGrid.c create mode 100644 tests/C/CTestXdmfRegularGrid.c create mode 100644 tests/C/CTestXdmfSet.c create mode 100644 tests/C/CTestXdmfTIFFReadWriteCompressed.c create mode 100644 tests/C/CTestXdmfTopology.c create mode 100644 tests/C/CTestXdmfUnstructuredGrid.c create mode 100644 tests/C/CTestXdmfWriter.c create mode 100755 tests/Cxx/DSMFileTest.sh create mode 100644 tests/Cxx/TestXdmfAggregate.cpp create mode 100644 tests/Cxx/TestXdmfGridController.cpp create mode 100644 tests/Cxx/TestXdmfTIFFReadWriteCompressed.cpp create mode 100644 tests/Cxx/XdmfFileAcceptTest.cpp create mode 100644 tests/Cxx/XdmfFileConnectTest.cpp create mode 100644 tests/Python/ReadTypeTest.py create mode 100644 utils/XdmfGeometryConverter.cpp create mode 100644 utils/XdmfGeometryConverter.hpp create mode 100644 utils/tests/C/CMakeLists.txt create mode 100644 utils/tests/C/CTestXdmfDiff.c create mode 100644 utils/tests/C/CTestXdmfExodusIO.c create mode 100644 utils/tests/C/CTestXdmfGeometryConverter.c create mode 100644 utils/tests/C/CTestXdmfTopologyConverter.c create mode 100644 utils/tests/Cxx/TestXdmfDiff.cpp create mode 100644 utils/tests/Cxx/TestXdmfGeometryConverter.cpp create mode 100644 utils/tests/Fortran/FunctionTestXdmfFortran.f90 create mode 100644 utils/tests/Fortran/SubsetTestXdmfFortran.f90 create mode 100644 utils/tests/Python/CMakeLists.txt create mode 100644 utils/tests/Python/XdmfTestDiff.py create mode 100644 utils/tests/Python/XdmfTestGeometryConverter.py create mode 100644 utils/tests/Python/XdmfTestTopologyConverter.py diff --git a/CMake/TestingSuite/TestDriverC.cmake.in b/CMake/TestingSuite/TestDriverC.cmake.in index 6be8f6bc..326f1d96 100644 --- a/CMake/TestingSuite/TestDriverC.cmake.in +++ b/CMake/TestingSuite/TestDriverC.cmake.in @@ -1,5 +1,12 @@ SET(ENV{PATH} "${PATH}${SEPARATOR}$ENV{PATH}") -SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") + +set(XDMF_DSM_IS_CRAY "@XDMF_DSM_IS_CRAY@") +if (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "$ENV{LD_LIBRARY_PATH}${SEPARATOR}${LDPATH}") +else (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") +endif (XDMF_DSM_IS_CRAY) + SET(ENV{MPIEXEC} "@MPIEXEC@") MESSAGE("| Calling:\t${EXECUTABLE} ${ARGUMENTS}") diff --git a/CMake/TestingSuite/TestDriverCxx.cmake.in b/CMake/TestingSuite/TestDriverCxx.cmake.in index 35e7b3af..4f92ec42 100644 --- a/CMake/TestingSuite/TestDriverCxx.cmake.in +++ b/CMake/TestingSuite/TestDriverCxx.cmake.in @@ -1,5 +1,12 @@ SET(ENV{PATH} "${PATH}${SEPARATOR}$ENV{PATH}") -SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") + +set(XDMF_DSM_IS_CRAY "@XDMF_DSM_IS_CRAY@") +if (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "$ENV{LD_LIBRARY_PATH}${SEPARATOR}${LDPATH}") +else (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") +endif (XDMF_DSM_IS_CRAY) + SET(ENV{MPIEXEC} "@MPIEXEC@") MESSAGE("| Calling:\t${EXECUTABLE} ${ARGUMENTS}") diff --git a/CMake/TestingSuite/TestDriverFortran.cmake.in b/CMake/TestingSuite/TestDriverFortran.cmake.in index 86da052e..20b9df7c 100644 --- a/CMake/TestingSuite/TestDriverFortran.cmake.in +++ b/CMake/TestingSuite/TestDriverFortran.cmake.in @@ -1,5 +1,12 @@ SET(ENV{PATH} "${PATH}${SEPARATOR}$ENV{PATH}") -SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") + +set(XDMF_DSM_IS_CRAY "@XDMF_DSM_IS_CRAY@") +if (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "$ENV{LD_LIBRARY_PATH}${SEPARATOR}${LDPATH}") +else (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") +endif (XDMF_DSM_IS_CRAY) + SET(ENV{MPIEXEC} "@MPIEXEC@") MESSAGE("| Calling:\t${EXECUTABLE} ${ARGUMENTS}") diff --git a/CMake/TestingSuite/TestDriverPython.cmake.in b/CMake/TestingSuite/TestDriverPython.cmake.in index 17fbcae8..4938cb06 100644 --- a/CMake/TestingSuite/TestDriverPython.cmake.in +++ b/CMake/TestingSuite/TestDriverPython.cmake.in @@ -3,7 +3,13 @@ SET(python_binary_dir "@CMAKE_CURRENT_BINARY_DIR@") SET(ENV{PYTHONPATH} "${PYTHONPATH}${SEPARATOR}$ENV{PYTHONPATH}") SET(ENV{PATH} "${PATH}${SEPARATOR}$ENV{PATH}") -SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") + +set(XDMF_DSM_IS_CRAY "@XDMF_DSM_IS_CRAY@") +if (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "$ENV{LD_LIBRARY_PATH}${SEPARATOR}${LDPATH}") +else (XDMF_DSM_IS_CRAY) + SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") +endif (XDMF_DSM_IS_CRAY) MESSAGE("| Calling:\t${python_runtime} ${EXECUTABLE} ${ARGUMENTS}") EXECUTE_PROCESS( diff --git a/CMake/TestingSuite/TestDriverPythonScript.cmake.in b/CMake/TestingSuite/TestDriverPythonScript.cmake.in index 828ed523..2a3ef2a1 100644 --- a/CMake/TestingSuite/TestDriverPythonScript.cmake.in +++ b/CMake/TestingSuite/TestDriverPythonScript.cmake.in @@ -3,7 +3,16 @@ SET(python_binary_dir "@CMAKE_CURRENT_BINARY_DIR@") SET(ENV{PYTHONPATH} "${PYTHONPATH}${SEPARATOR}$ENV{PYTHONPATH}") SET(ENV{PATH} "${PATH}${SEPARATOR}$ENV{PATH}") -SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") + +set(XDMF_DSM_IS_CRAY "@XDMF_DSM_IS_CRAY@") +if (XDMF_DSM_IS_CRAY) +# message("Cray Style") + SET(ENV{LD_LIBRARY_PATH} "$ENV{LD_LIBRARY_PATH}${SEPARATOR}${LDPATH}") +else (XDMF_DSM_IS_CRAY) +# message("Normal Style") + SET(ENV{LD_LIBRARY_PATH} "${LDPATH}${SEPARATOR}$ENV{LD_LIBRARY_PATH}") +endif (XDMF_DSM_IS_CRAY) + SET(ENV{PYTHON_EXECUTABLE} "${python_runtime}") SET(ENV{MPIEXEC} "@MPIEXEC@") diff --git a/CMake/TestingSuite/TestingSetup.cmake b/CMake/TestingSuite/TestingSetup.cmake index feaeef63..e793e095 100644 --- a/CMake/TestingSuite/TestingSetup.cmake +++ b/CMake/TestingSuite/TestingSetup.cmake @@ -82,5 +82,10 @@ MACRO(SET_CORE dir) STRING(REGEX MATCH "core" is_core "${dir}") IF(EXISTS ${is_core}) SET(is_core "Core") + ELSE(EXISTS ${is_core}) + STRING(REGEX MATCH "utils" is_core "${dir}") + IF(EXISTS ${is_core}) + SET(is_core "Util") + ENDIF(EXISTS ${is_core}) ENDIF(EXISTS ${is_core}) ENDMACRO(SET_CORE dir) diff --git a/CMake/VersionSuite/ProjectVersion.hpp b/CMake/VersionSuite/ProjectVersion.hpp index 6015a6e5..4458e109 100644 --- a/CMake/VersionSuite/ProjectVersion.hpp +++ b/CMake/VersionSuite/ProjectVersion.hpp @@ -19,27 +19,31 @@ class ProjectVersion { * * @param name of the project */ - ProjectVersion(std::string iProjectName, int iMajor, int iMinor) { - setProjectName(iProjectName); - setMajor(iMajor); - setMinor(iMinor); - } + ProjectVersion(std::string iProjectName, int iMajor, int iMinor, int iPatch) { + setProjectName(iProjectName); + setMajor(iMajor); + setMinor(iMinor); + setPatch(iPatch); + } ProjectVersion(std::string iProjectName, - std::string iMajor, std::string iMinor) { - setProjectName(iProjectName); - setMajorStr(iMajor); - setMinorStr(iMinor); - } - /** - * Get the version string - * - * @return the Version in "ProjectName Major.Minor" string format - */ + std::string iMajor, std::string iMinor, std::string iPatch) { + setProjectName(iProjectName); + setMajorStr(iMajor); + setMinorStr(iMinor); + setPatchStr(iPatch); + } + + /** + * Get the version string + * + * @return the Version in "ProjectName Major.Minor.Patch" string format + */ std::string getFull() { - return getProjectName()+std::string(" ")+ - getMajorStr()+std::string(".")+ - getMinorStr(); + return getProjectName()+std::string(" ")+ + getMajorStr()+std::string(".")+ + getMinorStr()+std::string(".")+ + getPatchStr(); } /** @@ -47,79 +51,101 @@ class ProjectVersion { * * @return the Version in "Major.Minor" string format */ - std::string getShort() { - return getMajorStr()+std::string(".")+ - getMinorStr(); - } + std::string getShort() { + return getMajorStr()+std::string(".")+ + getMinorStr(); + } - /** + /** * Get the version objects project name * * @return the project name in string format */ std::string getProjectName() { return ProjectName; } - /** + /** * Get the Version Major * * @return the Version Major in string format */ - std::string getMajorStr() - { + std::string getMajorStr() + { if(Major != -1) return IntToStr(Major); return("X"); } - /** + /** * Get the Version Minor * * @return the Version Minor in string format */ std::string getMinorStr() - { + { if(Minor != -1) return IntToStr(Minor); return("X"); } - - /** + + /** + * Get the Version Patch + * + * @return the Version Patch in string format + */ + std::string getPatchStr() + { + if(Patch != -1) return IntToStr(Patch); + return("X"); + } + + /** * Get the Version Major * * @return the Version Major in int format */ int getMajor() { return Major; } - /** + /** * Get the Version Minor * * @return the Version Minor in int format */ int getMinor() { return Minor; } + /** + * Get the Version Patch + * + * @return the Version Patch in int format + */ + int getPatch() { return Patch; } + private: std::string ProjectName; - int Major, Minor; + int Major, Minor, Patch; - std::string IntToStr(int number) { - std::stringstream s; - s << number; - return s.str(); - } + std::string IntToStr(int number) { + std::stringstream s; + s << number; + return s.str(); + } int StrToInt(std::string string) { - int i = 0; - std::stringstream s(string); - if(!(s >> i)) return -1; - return i; + int i = 0; + std::stringstream s(string); + if(!(s >> i)) return -1; + return i; } void setProjectName(std::string iProjectName) - { ProjectName = iProjectName; } + { ProjectName = iProjectName; } void setMajor(int iMajor) { Major = iMajor; } void setMajorStr(std::string iMajor) { - Major = StrToInt(iMajor); + Major = StrToInt(iMajor); } void setMinor(int iMinor) { Minor = iMinor; } void setMinorStr(std::string iMinor) { - Minor = StrToInt(iMinor); + Minor = StrToInt(iMinor); + } + void setPatch(int iPatch) { Patch = iPatch; } + void setPatchStr(std::string iPatch) { + Patch = StrToInt(iPatch); } }; diff --git a/CMake/VersionSuite/SetUpVersion.cmake b/CMake/VersionSuite/SetUpVersion.cmake index 7c137ee9..7e1066d3 100644 --- a/CMake/VersionSuite/SetUpVersion.cmake +++ b/CMake/VersionSuite/SetUpVersion.cmake @@ -14,11 +14,16 @@ INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/CMake/VersionSuite) # Default incase CalculateVerison is not called SET(vMajor "0") SET(vMinor "0") +SET(vPatch "0") # This Macro allows you to set up the Version in a one liner -MACRO(VersionCreate versionName versionMajor export_name) +MACRO(VersionCreate versionName versionMajor versionMinor versionPatch export_name) VersionMajorSet(${versionMajor}) - VersionCalculate() + VersionMinorSet(${versionMinor}) + VersionPatchSet(${versionPatch}) + +# Manually generating minor version +# VersionCalculate() VersionWrite(${versionName} ${export_name} "${ARGN}") ENDMACRO(VersionCreate versionName versionMajor export_name) @@ -27,6 +32,14 @@ MACRO(VersionMajorSet versionMajor) SET(vMajor ${versionMajor}) ENDMACRO(VersionMajorSet) +MACRO(VersionMinorSet versionMinor) + SET(vMinor ${versionMinor}) +ENDMACRO(VersionMinorSet) + +MACRO(VersionPatchSet versionPatch) + SET(vPatch ${versionPatch}) +ENDMACRO(VersionPatchSet) + # This Macro calculates the number of tags from your git repo MACRO(VersionCalculate) FIND_PACKAGE(Git) @@ -53,6 +66,7 @@ MACRO(VersionWrite vProjectName export_name) "/* Current Version of ${vProjectName} * Major is: ${vMajor} * Minor is: ${vMinor} + * Patch is: ${vPatch} */ ${includes} \#include \"ProjectVersion.hpp\" @@ -64,6 +78,6 @@ extern ${export_name} ProjectVersion ${vProjectName}Version;\n" * Make sure to include this file in your built sources */ \#include \"${vProjectName}Version.hpp\" -ProjectVersion ${vProjectName}Version = ProjectVersion(\"${vProjectName}\", \"${vMajor}\", \"${vMinor}\");\n" +ProjectVersion ${vProjectName}Version = ProjectVersion(\"${vProjectName}\", \"${vMajor}\", \"${vMinor}\", \"${vPatch}\");\n" ) ENDMACRO(VersionWrite vProjectName export_name) diff --git a/CMakeLists.txt b/CMakeLists.txt index cef59097..c3f12ea1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,16 @@ if(MSVC10) SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}) endif(MSVC10) -set(BUILD_SHARED_LIBS true) +option(BUILD_SHARED_LIBS ON PARENT_SCOPE) + +if (BUILD_SHARED_LIBS) + STRING(REGEX MATCH "-fPIC" IS_FPIC "${CMAKE_CXX_FLAGS}") + if ("${IS_FPIC}" STREQUAL "") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + endif ("${IS_FPIC}" STREQUAL "") + add_definitions(-DXDMFSTATIC) +endif (BUILD_SHARED_LIBS) + include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) @@ -49,6 +58,19 @@ endif(BUILD_TESTING) option(XDMF_WRAP_PYTHON OFF) option(XDMF_WRAP_JAVA OFF) +#check for TIFF +find_package(TIFF) +if (TIFF_FOUND) + add_definitions(-DXDMF_BUILD_TIFF) + mark_as_advanced(FORCE TIFF_INCLUDE_DIR) + mark_as_advanced(FORCE TIFF_LIBRARIES) + mark_as_advanced(FORCE TIFF_LIBRARY) + include_directories(${TIFF_INCLUDE_DIR}) + get_filename_component(TIFF_LIBRARY_DIR "${TIFF_LIBRARY}" PATH) + set(XDMF_LIBRARY_DIRS ${XDMF_LIBRARY_DIRS} ${TIFF_LIBRARY_DIR}) + set(XDMF_LIBRARIES ${XDMF_LIBRARIES} ${TIFF_LIBRARIES}) +endif (TIFF_FOUND) + # Test for DSM option(XDMF_BUILD_DSM OFF) @@ -70,6 +92,7 @@ if(XDMF_BUILD_DSM) mark_as_advanced(FORCE PYTHON_INCLUDE_MPI4PY_DIR) set(PYTHON_INCLUDE_MPI4PY_DIR "" CACHE STRING "Directory containing mpi4py/mpi4py.i") endif (XDMF_WRAP_PYTHON) + add_definitions(-DXDMF_BUILD_DSM) endif(XDMF_BUILD_DSM) # If we are wrapping either, we need swig @@ -146,7 +169,6 @@ if(XDMF_WRAP_PYTHON) PROPERTIES OUTPUT_NAME "_${python_name}") - string(TOUPPER ${python_name} python_name_upper) set(${python_name_upper}_PYTHON ${CMAKE_INSTALL_PREFIX}/lib/python/${python_name}.py) @@ -257,6 +279,7 @@ link_directories(${XDMF_LIBRARY_DIRS}) option(XDMF_BUILD_CORE_ONLY OFF) if(NOT XDMF_BUILD_CORE_ONLY) set(XdmfSources + XdmfAggregate XdmfAttribute XdmfAttributeCenter XdmfAttributeType @@ -268,6 +291,7 @@ if(NOT XDMF_BUILD_CORE_ONLY) XdmfGrid XdmfGridCollection XdmfGridCollectionType + XdmfGridController XdmfItemFactory XdmfMap XdmfReader @@ -280,24 +304,50 @@ if(NOT XDMF_BUILD_CORE_ONLY) XdmfTopologyType XdmfUnstructuredGrid) - add_library(Xdmf ${XdmfSources}) + add_library(XdmfObjects OBJECT ${XdmfSources}) + add_library(Xdmf $) + if (BUILD_SHARED_LIBS) + add_library(Xdmf_Static STATIC $) + if (UNIX) + set_target_properties(Xdmf_Static PROPERTIES + OUTPUT_NAME "Xdmf") + endif (UNIX) + endif (BUILD_SHARED_LIBS) if(XDMF_BUILD_DSM) target_link_libraries(Xdmf XdmfCore XdmfDSM) + if (BUILD_SHARED_LIBS) + target_link_libraries(Xdmf_Static XdmfCore_Static XdmfDSM_Static) + endif (BUILD_SHARED_LIBS) else(XDMF_BUILD_DSM) target_link_libraries(Xdmf XdmfCore) + if (BUILD_SHARED_LIBS) + target_link_libraries(Xdmf_Static XdmfCore_Static) + endif (BUILD_SHARED_LIBS) endif(XDMF_BUILD_DSM) if(WIN32) - set_target_properties(Xdmf PROPERTIES + set_target_properties(Xdmf PROPERTIES DEFINE_SYMBOL Xdmf_EXPORTS) + if (BUILD_SHARED_LIBS) + set_target_properties(Xdmf_Static PROPERTIES + DEFINE_SYMBOL Xdmf_EXPORTS) + endif (BUILD_SHARED_LIBS) if(NOT MSVC10) - set_target_properties(Xdmf PROPERTIES + set_target_properties(Xdmf PROPERTIES PREFIX ../ IMPORT_PREFIX ../ RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) - endif(NOT MSVC10) + if (BUILD_SHARED_LIBS) + set_target_properties(Xdmf_Static PROPERTIES + PREFIX ../ + IMPORT_PREFIX ../ + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) + endif (BUILD_SHARED_LIBS) + endif(NOT MSVC10) endif(WIN32) if(XDMF_WRAP_JAVA) @@ -305,7 +355,15 @@ if(NOT XDMF_BUILD_CORE_ONLY) endif(XDMF_WRAP_JAVA) if(XDMF_WRAP_PYTHON) - XDMF_SWIG_PYTHON(Xdmf XdmfCore XdmfDSM) + if (NOT BUILD_SHARED_LIBS) + message(FATAL_ERROR "Python Wrappers do not function" + " properly without shared libraries") + endif (NOT BUILD_SHARED_LIBS) + if (XDMF_BUILD_DSM) + XDMF_SWIG_PYTHON(Xdmf XdmfCore XdmfDSM) + else (XDMF_BUILD_DSM) + XDMF_SWIG_PYTHON(Xdmf XdmfCore) + endif (XDMF_BUILD_DSM) set(XDMF_PYTHON_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib/python/) endif(XDMF_WRAP_PYTHON) @@ -323,7 +381,11 @@ if(NOT XDMF_BUILD_CORE_ONLY) endif(WIN32) if(UNIX) - set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmf.so) + if (BUILD_SHARED_LIBS) + set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmf.so) + else (BUILD_SHARED_LIBS) + set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmf.a) + endif (BUILD_SHARED_LIBS) endif(UNIX) if(APPLE) @@ -342,6 +404,12 @@ if(NOT XDMF_BUILD_CORE_ONLY) RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib) + if (BUILD_SHARED_LIBS) + install(TARGETS Xdmf_Static + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib) + endif (BUILD_SHARED_LIBS) endif(NOT XDMF_BUILD_CORE_ONLY) xdmf_create_config_file(${PROJECT_NAME}) diff --git a/Xdmf.dtd b/Xdmf.dtd new file mode 100644 index 00000000..3e39e64b --- /dev/null +++ b/Xdmf.dtd @@ -0,0 +1,85 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Xdmf.hpp b/Xdmf.hpp index bf0cf818..b09c4d7e 100644 --- a/Xdmf.hpp +++ b/Xdmf.hpp @@ -76,6 +76,9 @@ * a topology could be shared across multiple grids or a grid * could be included in multiple grid collections and/or the domain. * +* Comparing objects is done by comparing pointer addresses, +* a deep copy will not produce an equivalent object. +* * * C++ Examples: * @@ -129,6 +132,14 @@ /* Keep all our Win32 Conversions here */ #ifdef _WIN32 +#ifdef XDMFSTATIC +#define XDMFCORE_EXPORT +#define XDMFDSM_EXPORT +#define XDMF_EXPORT +#define XDMFCORE_TEMPLATE +#define XDMFDSM_TEMPLATE +#define XDMF_TEMPLATE +#else /* Used to export/import from the dlls */ #undef XDMFCORE_EXPORT #define XDMFCORE_EXPORT __declspec(dllimport) @@ -147,6 +158,7 @@ #define XDMF_EXPORT __declspec(dllimport) #define XDMF_TEMPLATE extern #endif /* Xdmf_EXPORTS */ +#endif /* Compiler Warnings */ #ifndef XDMF_DEBUG diff --git a/Xdmf.i b/Xdmf.i index 9ab4344e..b86fb7c2 100644 --- a/Xdmf.i +++ b/Xdmf.i @@ -27,9 +27,9 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i #include #include #include - #include #include #include + #include #include #include #include @@ -45,10 +45,12 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i #include #include #include + #include #include #include // Xdmf Includes + #include #include #include #include @@ -74,8 +76,6 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i %} -%import XdmfDSM.i - #else %module Xdmf %{ @@ -99,10 +99,12 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i #include #include #include + #include #include #include // Xdmf Includes + #include #include #include #include @@ -131,6 +133,847 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i %import XdmfCore.i +// Ignoring C Wrappers + +// XdmfAggregate + +%ignore XdmfAggregateNew(); +%ignore XdmfAggregateGetArray(XDMFAGGREGATE * aggregate, unsigned int index); +%ignore XdmfAggregateGetArrayByName(XDMFAGGREGATE * aggregate, char * name); +%ignore XdmfAggregateGetNumberArrays(XDMFAGGREGATE * aggregate); +%ignore XdmfAggregateInsertArray(XDMFAGGREGATE * aggregate, XDMFARRAY * array, int transferOwnership); +%ignore XdmfAggregateRemoveArray(XDMFAGGREGATE * aggregate, unsigned int index); +%ignore XdmfAggregateRemoveArrayByName(XDMFAGGREGATE * aggregate, char * name); + +// XdmfAttributeCenter + +%ignore XdmfAttributeCenterGrid(); +%ignore XdmfAttributeCenterCell(); +%ignore XdmfAttributeCenterFace(); +%ignore XdmfAttributeCenterEdge(); +%ignore XdmfAttributeCenterNode(); + +// XdmfAttribute + +%ignore XdmfAttributeNew(); +%ignore XdmfAttributeGetCenter(XDMFATTRIBUTE * attribute); +%ignore XdmfAttributeGetType(XDMFATTRIBUTE * attribute); +%ignore XdmfAttributeSetCenter(XDMFATTRIBUTE * attribute, int center, int * status); +%ignore XdmfAttributeSetType(XDMFATTRIBUTE * attribute, int type, int * status); +// XdmfAttribute inherited from XdmfArray +%ignore XdmfAttributeNew(); +%ignore XdmfAttributeClear(XDMFATTRIBUTE * array); +%ignore XdmfAttributeErase(XDMFATTRIBUTE * array, unsigned int index); +%ignore XdmfAttributeGetArrayType(XDMFATTRIBUTE * array, int * status); +%ignore XdmfAttributeGetCapacity(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetDimensions(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetDimensionsString(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetHeavyDataController(XDMFATTRIBUTE * array, unsigned int index); +%ignore XdmfAttributeGetReadMode(XDMFATTRIBUTE * array, int * status); +%ignore XdmfAttributeGetName(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetNumberDimensions(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetNumberHeavyDataControllers(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetSize(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetReference(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetValue(XDMFATTRIBUTE * array, unsigned int index, int arrayType, int * status); +%ignore XdmfAttributeGetValues(XDMFATTRIBUTE * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfAttributeGetValuesInternal(XDMFATTRIBUTE * array); +%ignore XdmfAttributeGetValuesString(XDMFATTRIBUTE * array); +%ignore XdmfAttributeInitialize(XDMFATTRIBUTE * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfAttributeInsertDataFromPointer(XDMFATTRIBUTE * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfAttributeInsertDataFromXdmfArray(XDMFATTRIBUTE * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status); +%ignore XdmfAttributeInsertHeavyDataController(XDMFATTRIBUTE * array, XDMFHEAVYDATACONTROLLER * controller, int passControl); +%ignore XdmfAttributeInsertValue(XDMFATTRIBUTE * array, unsigned int index, void * value, int arrayType, int * status); +%ignore XdmfAttributeIsInitialized(XDMFATTRIBUTE * array); +%ignore XdmfAttributePushBack(XDMFATTRIBUTE * array, void * value, int arrayType, int * status); +%ignore XdmfAttributeRead(XDMFATTRIBUTE * array, int * status); +%ignore XdmfAttributeReadController(XDMFATTRIBUTE * array, int * status); +%ignore XdmfAttributeReadReference(XDMFATTRIBUTE * array, int * status); +%ignore XdmfAttributeRelease(XDMFATTRIBUTE * array); +%ignore XdmfAttributeRemoveHeavyDataController(XDMFATTRIBUTE * array, unsigned int index); +%ignore XdmfAttributeReserve(XDMFATTRIBUTE * array, int size); +%ignore XdmfAttributeResize(XDMFATTRIBUTE * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfAttributeSetReadMode(XDMFATTRIBUTE * array, int readMode, int * status); +%ignore XdmfAttributeSetReference(XDMFATTRIBUTE * array, XDMFARRAYREFERENCE * reference, int passControl); +%ignore XdmfAttributeSetName(XDMFATTRIBUTE * array, char * name, int * status); +%ignore XdmfAttributeSetValuesInternal(XDMFATTRIBUTE * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status); +%ignore XdmfAttributeSwapWithXdmfArray(XDMFATTRIBUTE * array, XDMFARRAY * swapArray); +%ignore XdmfAttributeSwapWithArray(XDMFATTRIBUTE * array, void ** pointer, int numValues, int arrayType, int * status); +// XdmfAttribute inherited from XdmfItem +%ignore XdmfAttributeAccept(XDMFATTRIBUTE * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfAttributeFree(void * item); +%ignore XdmfAttributeGetInformation(XDMFATTRIBUTE * item, unsigned int index); +%ignore XdmfAttributeGetInformationByKey(XDMFATTRIBUTE * item, char * key); +%ignore XdmfAttributeGetNumberInformations(XDMFATTRIBUTE * item); +%ignore XdmfAttributeInsertInformation(XDMFATTRIBUTE * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfAttributeRemoveInformation(XDMFATTRIBUTE * item, unsigned int index); +%ignore XdmfAttributeRemoveInformationByKey(XDMFATTRIBUTE * item, char * key); +%ignore XdmfAttributeGetItemTag(XDMFATTRIBUTE * item); + +// XdmfAttributeType + +%ignore XdmfAttributeTypeScalar(); +%ignore XdmfAttributeTypeVector(); +%ignore XdmfAttributeTypeTensor(); +%ignore XdmfAttributeTypeMatrix(); +%ignore XdmfAttributeTypeTensor6(); +%ignore XdmfAttributeTypeGlobalId(); +%ignore XdmfAttributeTypeNoAttributeType(); + +// XdmfCurvilinearGrid + +%ignore XdmfCurvilinearGridNew2D(unsigned int xNumPoints, + unsigned int yNumPoints); +%ignore XdmfCurvilinearGridNew3D(unsigned int xNumPoints, + unsigned int yNumPoints, + unsigned int zNumPoints); +%ignore XdmfCurvilinearGridNew(XDMFARRAY * numPoints, int * status); +%ignore XdmfCurvilinearGridGetDimensions(XDMFCURVILINEARGRID * grid, int * status); +%ignore XdmfCurvilinearGridGetGeometry(XDMFCURVILINEARGRID * grid); +%ignore XdmfCurvilinearGridSetDimensions(XDMFCURVILINEARGRID * grid, + XDMFARRAY * dimensions, + int passControl, + int * status); +%ignore XdmfCurvilinearGridSetGeometry(XDMFCURVILINEARGRID * grid, + XDMFGEOMETRY * geometry, + int passControl); +// XdmfCurvilinearGrid inherited from XdmfItem +%ignore XdmfCurvilinearGridAccept(XDMFCURVILINEARGRID * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfCurvilinearGridFree(void * item); +%ignore XdmfCurvilinearGridGetInformation(XDMFCURVILINEARGRID * item, unsigned int index); +%ignore XdmfCurvilinearGridGetInformationByKey(XDMFCURVILINEARGRID * item, char * key); +%ignore XdmfCurvilinearGridGetNumberInformations(XDMFCURVILINEARGRID * item); +%ignore XdmfCurvilinearGridInsertInformation(XDMFCURVILINEARGRID * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfCurvilinearGridRemoveInformation(XDMFCURVILINEARGRID * item, unsigned int index); +%ignore XdmfCurvilinearGridRemoveInformationByKey(XDMFCURVILINEARGRID * item, char * key); +%ignore XdmfCurvilinearGridGetItemTag(XDMFCURVILINEARGRID * item); +// XdmfCurvilinearGrid inherited from XdmfGrid +%ignore XdmfCurvilinearGridGetAttribute(XDMFCURVILINEARGRID * grid, unsigned int index); +%ignore XdmfCurvilinearGridGetAttributeByName(XDMFCURVILINEARGRID * grid, char * Name); +%ignore XdmfCurvilinearGridGetNumberAttributes(XDMFCURVILINEARGRID * grid); +%ignore XdmfCurvilinearGridInsertAttribute(XDMFCURVILINEARGRID * grid, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfCurvilinearGridRemoveAttribute(XDMFCURVILINEARGRID * grid, unsigned int index); +%ignore XdmfCurvilinearGridRemoveAttributeByName(XDMFCURVILINEARGRID * grid, char * Name); +%ignore XdmfCurvilinearGridGetSet(XDMFCURVILINEARGRID * grid, unsigned int index); +%ignore XdmfCurvilinearGridGetSetByName(XDMFCURVILINEARGRID * grid, char * Name); +%ignore XdmfCurvilinearGridGetNumberSets(XDMFCURVILINEARGRID * grid); +%ignore XdmfCurvilinearGridInsertSet(XDMFCURVILINEARGRID * grid, XDMFSET * Set, int passControl); +%ignore XdmfCurvilinearGridRemoveSet(XDMFCURVILINEARGRID * grid, unsigned int index); +%ignore XdmfCurvilinearGridRemoveSetByName(XDMFCURVILINEARGRID * grid, char * Name); +%ignore XdmfCurvilinearGridGetMap(XDMFCURVILINEARGRID * grid, unsigned int index); +%ignore XdmfCurvilinearGridGetMapByName(XDMFCURVILINEARGRID * grid, char * Name); +%ignore XdmfCurvilinearGridGetNumberMaps(XDMFCURVILINEARGRID * grid); +%ignore XdmfCurvilinearGridInsertMap(XDMFCURVILINEARGRID * grid, XDMFMAP * Map, int passControl); +%ignore XdmfCurvilinearGridRemoveMap(XDMFCURVILINEARGRID * grid, unsigned int index); +%ignore XdmfCurvilinearGridRemoveMapByName(XDMFCURVILINEARGRID * grid, char * Name); +%ignore XdmfCurvilinearGridGetName(XDMFCURVILINEARGRID * grid); +%ignore XdmfCurvilinearGridGetTime(XDMFCURVILINEARGRID * grid); +%ignore XdmfCurvilinearGridSetName(XDMFCURVILINEARGRID * grid, char * name, int * status); +%ignore XdmfCurvilinearGridSetTime(XDMFCURVILINEARGRID * grid, XDMFTIME * time, int passControl); + +// XdmfDomain + +%ignore XdmfDomainNew(); +%ignore XdmfDomainGetGridCollection(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainGetGridCollectionByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetNumberGridCollections(XDMFDOMAIN * domain); +%ignore XdmfDomainInsertGridCollection(XDMFDOMAIN * domain, + XDMFGRIDCOLLECTION * GridCollection, + int passControl); +%ignore XdmfDomainRemoveGridCollection(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainRemoveGridCollectionByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetGraph(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainGetGraphByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetNumberGraphs(XDMFDOMAIN * domain); +%ignore XdmfDomainInsertGraph(XDMFDOMAIN * domain, XDMFGRAPH * graph, int passControl); +%ignore XdmfDomainRemoveGraph(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainRemoveGraphByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetCurvilinearGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainGetCurvilinearGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetNumberCurvilinearGrids(XDMFDOMAIN * domain); +%ignore XdmfDomainInsertCurvilinearGrid(XDMFDOMAIN * domain, + XDMFCURVILINEARGRID * CurvilinearGrid, + int passControl); +%ignore XdmfDomainRemoveCurvilinearGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainRemoveCurvilinearGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetRectilinearGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainGetRectilinearGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetNumberRectilinearGrids(XDMFDOMAIN * domain); +%ignore XdmfDomainInsertRectilinearGrid(XDMFDOMAIN * domain, + XDMFRECTILINEARGRID * RectilinearGrid, + int passControl); +%ignore XdmfDomainRemoveRectilinearGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainRemoveRectilinearGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetRegularGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainGetRegularGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetNumberRegularGrids(XDMFDOMAIN * domain); +%ignore XdmfDomainInsertRegularGrid(XDMFDOMAIN * domain, + XDMFREGULARGRID * RegularGrid, + int passControl); +%ignore XdmfDomainRemoveRegularGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainRemoveRegularGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetUnstructuredGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainGetUnstructuredGridByName(XDMFDOMAIN * domain, char * Name); +%ignore XdmfDomainGetNumberUnstructuredGrids(XDMFDOMAIN * domain); +%ignore XdmfDomainInsertUnstructuredGrid(XDMFDOMAIN * domain, + XDMFUNSTRUCTUREDGRID * UnstructuredGrid, + int passControl); +%ignore XdmfDomainRemoveUnstructuredGrid(XDMFDOMAIN * domain, unsigned int index); +%ignore XdmfDomainRemoveUnstructuredGridByName(XDMFDOMAIN * domain, char * Name); +// XdmfDomain inherited from XdmfItem +%ignore XdmfDomainAccept(XDMFDOMAIN * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfDomainFree(void * item); +%ignore XdmfDomainGetInformation(XDMFDOMAIN * item, unsigned int index); +%ignore XdmfDomainGetInformationByKey(XDMFDOMAIN * item, char * key); +%ignore XdmfDomainGetNumberInformations(XDMFDOMAIN * item); +%ignore XdmfDomainInsertInformation(XDMFDOMAIN * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfDomainRemoveInformation(XDMFDOMAIN * item, unsigned int index); +%ignore XdmfDomainRemoveInformationByKey(XDMFDOMAIN * item, char * key); +%ignore XdmfDomainGetItemTag(XDMFDOMAIN * item); + +// XdmfGeometry + +%ignore XdmfGeometryNew(); +%ignore XdmfGeometryGetNumberPoints(XDMFGEOMETRY * geometry); +%ignore XdmfGeometryGetOrigin(XDMFGEOMETRY * geometry); +%ignore XdmfGeometryGetOriginSize(XDMFGEOMETRY * geometry); +%ignore XdmfGeometryGetType(XDMFGEOMETRY * geometry); +%ignore XdmfGeometrySetOrigin(XDMFGEOMETRY * geometry, double newX, double newY, double newZ); +%ignore XdmfGeometrySetOriginArray(XDMFGEOMETRY * geometry, double * originVals, unsigned int numDims); +%ignore XdmfGeometrySetType(XDMFGEOMETRY * geometry, int type, int * status); +// XdmfGeometry inherited from XdmfArray +%ignore XdmfGeometryNew(); +%ignore XdmfGeometryClear(XDMFGEOMETRY * array); +%ignore XdmfGeometryErase(XDMFGEOMETRY * array, unsigned int index); +%ignore XdmfGeometryGetArrayType(XDMFGEOMETRY * array, int * status); +%ignore XdmfGeometryGetCapacity(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetDimensions(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetDimensionsString(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetHeavyDataController(XDMFGEOMETRY * array, unsigned int index); +%ignore XdmfGeometryGetReadMode(XDMFGEOMETRY * array, int * status); +%ignore XdmfGeometryGetName(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetNumberDimensions(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetNumberHeavyDataControllers(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetSize(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetReference(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetValue(XDMFGEOMETRY * array, unsigned int index, int arrayType, int * status); +%ignore XdmfGeometryGetValues(XDMFGEOMETRY * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfGeometryGetValuesInternal(XDMFGEOMETRY * array); +%ignore XdmfGeometryGetValuesString(XDMFGEOMETRY * array); +%ignore XdmfGeometryInitialize(XDMFGEOMETRY * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfGeometryInsertDataFromPointer(XDMFGEOMETRY * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfGeometryInsertDataFromXdmfArray(XDMFGEOMETRY * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status); +%ignore XdmfGeometryInsertHeavyDataController(XDMFGEOMETRY * array, XDMFHEAVYDATACONTROLLER * controller, int passControl); +%ignore XdmfGeometryInsertValue(XDMFGEOMETRY * array, unsigned int index, void * value, int arrayType, int * status); +%ignore XdmfGeometryIsInitialized(XDMFGEOMETRY * array); +%ignore XdmfGeometryPushBack(XDMFGEOMETRY * array, void * value, int arrayType, int * status); +%ignore XdmfGeometryRead(XDMFGEOMETRY * array, int * status); +%ignore XdmfGeometryReadController(XDMFGEOMETRY * array, int * status); +%ignore XdmfGeometryReadReference(XDMFGEOMETRY * array, int * status); +%ignore XdmfGeometryRelease(XDMFGEOMETRY * array); +%ignore XdmfGeometryRemoveHeavyDataController(XDMFGEOMETRY * array, unsigned int index); +%ignore XdmfGeometryReserve(XDMFGEOMETRY * array, int size); +%ignore XdmfGeometryResize(XDMFGEOMETRY * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfGeometrySetReadMode(XDMFGEOMETRY * array, int readMode, int * status); +%ignore XdmfGeometrySetReference(XDMFGEOMETRY * array, XDMFARRAYREFERENCE * reference, int passControl); +%ignore XdmfGeometrySetName(XDMFGEOMETRY * array, char * name, int * status); +%ignore XdmfGeometrySetValuesInternal(XDMFGEOMETRY * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status); +%ignore XdmfGeometrySwapWithXdmfArray(XDMFGEOMETRY * array, XDMFARRAY * swapArray); +%ignore XdmfGeometrySwapWithArray(XDMFGEOMETRY * array, void ** pointer, int numValues, int arrayType, int * status); +// XdmfGeometry inherited from XdmfItem +%ignore XdmfGeometryAccept(XDMFGEOMETRY * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfGeometryFree(void * item); +%ignore XdmfGeometryGetInformation(XDMFGEOMETRY * item, unsigned int index); +%ignore XdmfGeometryGetInformationByKey(XDMFGEOMETRY * item, char * key); +%ignore XdmfGeometryGetNumberInformations(XDMFGEOMETRY * item); +%ignore XdmfGeometryInsertInformation(XDMFGEOMETRY * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfGeometryRemoveInformation(XDMFGEOMETRY * item, unsigned int index); +%ignore XdmfGeometryRemoveInformationByKey(XDMFGEOMETRY * item, char * key); +%ignore XdmfGeometryGetItemTag(XDMFGEOMETRY * item); + +// XdmfGeometryType + +%ignore XdmfGeometryTypeNoGeometryType(); +%ignore XdmfGeometryTypeXYZ(); +%ignore XdmfGeometryTypeXY(); +%ignore XdmfGeometryTypeGetDimensions(int type, int * status); +%ignore XdmfGeometryTypeGetName(int type); + +// XdmfGraph + +%ignore XdmfGraphNew(unsigned int numberNodes); +%ignore XdmfGraphGetAttribute(XDMFGRAPH * graph, unsigned int index); +%ignore XdmfGraphGetAttributeByName(XDMFGRAPH * graph, char * Name); +%ignore XdmfGraphGetNumberAttributes(XDMFGRAPH * graph); +%ignore XdmfGraphInsertAttribute(XDMFGRAPH * graph, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfGraphRemoveAttribute(XDMFGRAPH * graph, unsigned int index); +%ignore XdmfGraphRemoveAttributeByName(XDMFGRAPH * graph, char * Name); +%ignore XdmfGraphGetNumberNodes(XDMFGRAPH * graph); +// XdmfGraph inherited from XdmfSparseMatrix +%ignore XdmfGraphNew(unsigned int numberRows, unsigned int numberColumns); +%ignore XdmfGraphGetColumnIndex(XDMFGRAPH * matrix, int * status); +%ignore XdmfGraphGetName(XDMFGRAPH * matrix); +%ignore XdmfGraphGetNumberColumns(XDMFGRAPH * matrix); +%ignore XdmfGraphGetNumberRows(XDMFGRAPH * matrix); +%ignore XdmfGraphGetRowPointer(XDMFGRAPH * matrix, int * status); +%ignore XdmfGraphGetValues(XDMFGRAPH * matrix, int * status); +%ignore XdmfGraphGetValuesString(XDMFGRAPH * matrix, int * status); +%ignore XdmfGraphSetColumnIndex(XDMFGRAPH * matrix, + XDMFARRAY * columnIndex, + int passControl, + int * status); +%ignore XdmfGraphSetName(XDMFGRAPH * matrix, char * name, int * status); +%ignore XdmfGraphSetRowPointer(XDMFGRAPH * matrix, + XDMFARRAY * rowPointer, + int passControl, + int * status); +%ignore XdmfGraphSetValues(XDMFGRAPH * matrix, + XDMFARRAY * values, + int passControl, + int * status); +// XdmfGraph inherited from XdmfItem +%ignore XdmfGraphAccept(XDMFGRAPH * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfGraphFree(void * item); +%ignore XdmfGraphGetInformation(XDMFGRAPH * item, unsigned int index); +%ignore XdmfGraphGetInformationByKey(XDMFGRAPH * item, char * key); +%ignore XdmfGraphGetNumberInformations(XDMFGRAPH * item); +%ignore XdmfGraphInsertInformation(XDMFGRAPH * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfGraphRemoveInformation(XDMFGRAPH * item, unsigned int index); +%ignore XdmfGraphRemoveInformationByKey(XDMFGRAPH * item, char * key); +%ignore XdmfGraphGetItemTag(XDMFGRAPH * item); + +// XdmfGridCollection + +%ignore XdmfGridCollectionNew(); +%ignore XdmfGridCollectionGetType(XDMFGRIDCOLLECTION * collection, int * status); +%ignore XdmfGridCollectionSetType(XDMFGRIDCOLLECTION * collection, int type, int * status); +// XdmfGridCollection inherited from XdmfDomain +%ignore XdmfGridCollectionGetGridCollection(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionGetGridCollectionByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetNumberGridCollections(XDMFGRIDCOLLECTION * domain); +%ignore XdmfGridCollectionInsertGridCollection(XDMFGRIDCOLLECTION * domain, + XDMFGRIDCOLLECTION * GridCollection, + int passControl); +%ignore XdmfGridCollectionRemoveGridCollection(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionRemoveGridCollectionByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetGraph(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionGetGraphByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetNumberGraphs(XDMFGRIDCOLLECTION * domain); +%ignore XdmfGridCollectionInsertGraph(XDMFGRIDCOLLECTION * domain, XDMFGRAPH * graph, int passControl); +%ignore XdmfGridCollectionRemoveGraph(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionRemoveGraphByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetCurvilinearGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionGetCurvilinearGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetNumberCurvilinearGrids(XDMFGRIDCOLLECTION * domain); +%ignore XdmfGridCollectionInsertCurvilinearGrid(XDMFGRIDCOLLECTION * domain, + XDMFCURVILINEARGRID * CurvilinearGrid, + int passControl); +%ignore XdmfGridCollectionRemoveCurvilinearGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionRemoveCurvilinearGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetRectilinearGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionGetRectilinearGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetNumberRectilinearGrids(XDMFGRIDCOLLECTION * domain); +%ignore XdmfGridCollectionInsertRectilinearGrid(XDMFGRIDCOLLECTION * domain, + XDMFRECTILINEARGRID * RectilinearGrid, + int passControl); +%ignore XdmfGridCollectionRemoveRectilinearGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionRemoveRectilinearGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetRegularGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionGetRegularGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetNumberRegularGrids(XDMFGRIDCOLLECTION * domain); +%ignore XdmfGridCollectionInsertRegularGrid(XDMFGRIDCOLLECTION * domain, + XDMFREGULARGRID * RegularGrid, + int passControl); +%ignore XdmfGridCollectionRemoveRegularGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionRemoveRegularGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetUnstructuredGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionGetUnstructuredGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +%ignore XdmfGridCollectionGetNumberUnstructuredGrids(XDMFGRIDCOLLECTION * domain); +%ignore XdmfGridCollectionInsertUnstructuredGrid(XDMFGRIDCOLLECTION * domain, + XDMFUNSTRUCTUREDGRID * UnstructuredGrid, + int passControl); +%ignore XdmfGridCollectionRemoveUnstructuredGrid(XDMFGRIDCOLLECTION * domain, unsigned int index); +%ignore XdmfGridCollectionRemoveUnstructuredGridByName(XDMFGRIDCOLLECTION * domain, char * Name); +// XdmfGridCollection inherited from XdmfGrid +%ignore XdmfGridCollectionGetAttribute(XDMFGRIDCOLLECTION * grid, unsigned int index); +%ignore XdmfGridCollectionGetAttributeByName(XDMFGRIDCOLLECTION * grid, char * Name); +%ignore XdmfGridCollectionGetNumberAttributes(XDMFGRIDCOLLECTION * grid); +%ignore XdmfGridCollectionInsertAttribute(XDMFGRIDCOLLECTION * grid, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfGridCollectionRemoveAttribute(XDMFGRIDCOLLECTION * grid, unsigned int index); +%ignore XdmfGridCollectionRemoveAttributeByName(XDMFGRIDCOLLECTION * grid, char * Name); +%ignore XdmfGridCollectionGetSet(XDMFGRIDCOLLECTION * grid, unsigned int index); +%ignore XdmfGridCollectionGetSetByName(XDMFGRIDCOLLECTION * grid, char * Name); +%ignore XdmfGridCollectionGetNumberSets(XDMFGRIDCOLLECTION * grid); +%ignore XdmfGridCollectionInsertSet(XDMFGRIDCOLLECTION * grid, XDMFSET * Set, int passControl); +%ignore XdmfGridCollectionRemoveSet(XDMFGRIDCOLLECTION * grid, unsigned int index); +%ignore XdmfGridCollectionRemoveSetByName(XDMFGRIDCOLLECTION * grid, char * Name); +%ignore XdmfGridCollectionGetMap(XDMFGRIDCOLLECTION * grid, unsigned int index); +%ignore XdmfGridCollectionGetMapByName(XDMFGRIDCOLLECTION * grid, char * Name); +%ignore XdmfGridCollectionGetNumberMaps(XDMFGRIDCOLLECTION * grid); +%ignore XdmfGridCollectionInsertMap(XDMFGRIDCOLLECTION * grid, XDMFMAP * Map, int passControl); +%ignore XdmfGridCollectionRemoveMap(XDMFGRIDCOLLECTION * grid, unsigned int index); +%ignore XdmfGridCollectionRemoveMapByName(XDMFGRIDCOLLECTION * grid, char * Name); +%ignore XdmfGridCollectionGetName(XDMFGRIDCOLLECTION * grid); +%ignore XdmfGridCollectionGetTime(XDMFGRIDCOLLECTION * grid); +%ignore XdmfGridCollectionSetName(XDMFGRIDCOLLECTION * grid, char * name, int * status); +%ignore XdmfGridCollectionSetTime(XDMFGRIDCOLLECTION * grid, XDMFTIME * time, int passControl); +// XdmfGridCollection inherited from XdmfItem +%ignore XdmfGridCollectionAccept(XDMFGRIDCOLLECTION * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfGridCollectionFree(void * item); +%ignore XdmfGridCollectionGetInformation(XDMFGRIDCOLLECTION * item, unsigned int index); +%ignore XdmfGridCollectionGetInformationByKey(XDMFGRIDCOLLECTION * item, char * key); +%ignore XdmfGridCollectionGetNumberInformations(XDMFGRIDCOLLECTION * item); +%ignore XdmfGridCollectionInsertInformation(XDMFGRIDCOLLECTION * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfGridCollectionRemoveInformation(XDMFGRIDCOLLECTION * item, unsigned int index); +%ignore XdmfGridCollectionRemoveInformationByKey(XDMFGRIDCOLLECTION * item, char * key); +%ignore XdmfGridCollectionGetItemTag(XDMFGRIDCOLLECTION * item); + +// XdmfGrid + +// XdmfGrid inherited from XdmfGrid +%ignore XdmfGridGetAttribute(XDMFGRID * grid, unsigned int index); +%ignore XdmfGridGetAttributeByName(XDMFGRID * grid, char * Name); +%ignore XdmfGridGetNumberAttributes(XDMFGRID * grid); +%ignore XdmfGridInsertAttribute(XDMFGRID * grid, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfGridRemoveAttribute(XDMFGRID * grid, unsigned int index); +%ignore XdmfGridRemoveAttributeByName(XDMFGRID * grid, char * Name); +%ignore XdmfGridGetSet(XDMFGRID * grid, unsigned int index); +%ignore XdmfGridGetSetByName(XDMFGRID * grid, char * Name); +%ignore XdmfGridGetNumberSets(XDMFGRID * grid); +%ignore XdmfGridInsertSet(XDMFGRID * grid, XDMFSET * Set, int passControl); +%ignore XdmfGridRemoveSet(XDMFGRID * grid, unsigned int index); +%ignore XdmfGridRemoveSetByName(XDMFGRID * grid, char * Name); +%ignore XdmfGridGetMap(XDMFGRID * grid, unsigned int index); +%ignore XdmfGridGetMapByName(XDMFGRID * grid, char * Name); +%ignore XdmfGridGetNumberMaps(XDMFGRID * grid); +%ignore XdmfGridInsertMap(XDMFGRID * grid, XDMFMAP * Map, int passControl); +%ignore XdmfGridRemoveMap(XDMFGRID * grid, unsigned int index); +%ignore XdmfGridRemoveMapByName(XDMFGRID * grid, char * Name); +%ignore XdmfGridGetName(XDMFGRID * grid); +%ignore XdmfGridGetTime(XDMFGRID * grid); +%ignore XdmfGridSetName(XDMFGRID * grid, char * name, int * status); +%ignore XdmfGridSetTime(XDMFGRID * grid, XDMFTIME * time, int passControl); +// XdmfGrid inherited from XdmfItem +%ignore XdmfGridAccept(XDMFGRID * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfGridFree(void * item); +%ignore XdmfGridGetInformation(XDMFGRID * item, unsigned int index); +%ignore XdmfGridGetInformationByKey(XDMFGRID * item, char * key); +%ignore XdmfGridGetNumberInformations(XDMFGRID * item); +%ignore XdmfGridInsertInformation(XDMFGRID * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfGridRemoveInformation(XDMFGRID * item, unsigned int index); +%ignore XdmfGridRemoveInformationByKey(XDMFGRID * item, char * key); +%ignore XdmfGridGetItemTag(XDMFGRID * item); + +// XdmfMap + +%ignore XdmfMapNew(); +%ignore XdmfMapNewFromIdVector(int ** globalNodeIds, int * numIdsOnNode, int numIds); +%ignore XdmfMapGetName(XDMFMAP * map); +%ignore XdmfMapInsert(XDMFMAP * map, int remoteTaskId, int localNodeId, int remoteLocalNodeId); +%ignore XdmfMapIsInitialized(XDMFMAP * map); +%ignore XdmfMapRead(XDMFMAP * map, int * status); +%ignore XdmfMapRelease(XDMFMAP * map); +%ignore XdmfMapRetrieveLocalNodeIds(XDMFMAP * map, int remoteTaskId); +%ignore XdmfMapRetrieveNumberLocalNodeIds(XDMFMAP * map, int remoteTaskId); +%ignore XdmfMapRetrieveNumberRemoteTaskIds(XDMFMAP * map); +%ignore XdmfMapRetrieveNumberRemoteNodeIds(XDMFMAP * map, int remoteTaskId, int localNodeId); +%ignore XdmfMapRetrieveRemoteTaskIds(XDMFMAP * map); +%ignore XdmfMapRetrieveRemoteNodeIds(XDMFMAP * map, int remoteTaskId, int localNodeId); +%ignore XdmfMapSetHeavyDataControllers(XDMFMAP * map, + XDMFHEAVYDATACONTROLLER ** remoteTaskControllers, + int numRemoteTaskControllers, + XDMFHEAVYDATACONTROLLER ** localNodeControllers, + int numberLocalNodeControllers, + XDMFHEAVYDATACONTROLLER ** remoteLocalNodeControllers, + int numRemoteLocalNodeControllers, + int passControl, + int * status); +%ignore XdmfMapSetName(XDMFMAP * map, char * newName); +// XdmfMap inherited from XdmfItem +%ignore XdmfMapAccept(XDMFMAP * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfMapFree(void * item); +%ignore XdmfMapGetInformation(XDMFMAP * item, unsigned int index); +%ignore XdmfMapGetInformationByKey(XDMFMAP * item, char * key); +%ignore XdmfMapGetNumberInformations(XDMFMAP * item); +%ignore XdmfMapInsertInformation(XDMFMAP * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfMapRemoveInformation(XDMFMAP * item, unsigned int index); +%ignore XdmfMapRemoveInformationByKey(XDMFMAP * item, char * key); +%ignore XdmfMapGetItemTag(XDMFMAP * item); + +// XdmfReader + +%ignore XdmfReaderNew(); +%ignore XdmfReaderFree(XDMFREADER * item); +// XdmfReader inherited from XdmfCoreReader +%ignore XdmfReaderRead(XDMFREADER * reader, char * filePath, int * status); + +// XdmfRectilinearGrid + +%ignore XdmfRectilinearGridNew(XDMFARRAY ** axesCoordinates, + unsigned int numCoordinates, + int passControl); +%ignore XdmfRectilinearGridNew2D(XDMFARRAY * xCoordinates, + XDMFARRAY * yCoordinates, + int passControl); +%ignore XdmfRectilinearGridNew3D(XDMFARRAY * xCoordinates, + XDMFARRAY * yCoordinates, + XDMFARRAY * zCoordinates, + int passControl); +%ignore XdmfRectilinearGridGetCoordinatesByIndex(XDMFRECTILINEARGRID * grid, + unsigned int axisIndex, + int * status); +%ignore XdmfRectilinearGridGetCoordinates(XDMFRECTILINEARGRID * grid, int * status); +%ignore XdmfRectilinearGridGetNumberCoordinates(XDMFRECTILINEARGRID * grid, int * status); +%ignore XdmfRectilinearGridGetDimensions(XDMFRECTILINEARGRID * grid, int * status); +%ignore XdmfRectilinearGridSetCoordinates(XDMFRECTILINEARGRID * grid, + XDMFARRAY ** axesCoordinates, + unsigned int numCoordinates, + int passControl, + int * status); +%ignore XdmfRectilinearGridSetCoordinatesByIndex(XDMFRECTILINEARGRID * grid, + unsigned int index, + XDMFARRAY * coordinates, + int passControl, + int * status); +// XdmfRectilinearGrid inherited from XdmfItem +%ignore XdmfRectilinearGridAccept(XDMFRECTILINEARGRID * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfRectilinearGridFree(void * item); +%ignore XdmfRectilinearGridGetInformation(XDMFRECTILINEARGRID * item, unsigned int index); +%ignore XdmfRectilinearGridGetInformationByKey(XDMFRECTILINEARGRID * item, char * key); +%ignore XdmfRectilinearGridGetNumberInformations(XDMFRECTILINEARGRID * item); +%ignore XdmfRectilinearGridInsertInformation(XDMFRECTILINEARGRID * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfRectilinearGridRemoveInformation(XDMFRECTILINEARGRID * item, unsigned int index); +%ignore XdmfRectilinearGridRemoveInformationByKey(XDMFRECTILINEARGRID * item, char * key); +%ignore XdmfRectilinearGridGetItemTag(XDMFRECTILINEARGRID * item); +// XdmfRectilinearGrid inherited from XdmfGrid +%ignore XdmfRectilinearGridGetAttribute(XDMFRECTILINEARGRID * grid, unsigned int index); +%ignore XdmfRectilinearGridGetAttributeByName(XDMFRECTILINEARGRID * grid, char * Name); +%ignore XdmfRectilinearGridGetNumberAttributes(XDMFRECTILINEARGRID * grid); +%ignore XdmfRectilinearGridInsertAttribute(XDMFRECTILINEARGRID * grid, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfRectilinearGridRemoveAttribute(XDMFRECTILINEARGRID * grid, unsigned int index); +%ignore XdmfRectilinearGridRemoveAttributeByName(XDMFRECTILINEARGRID * grid, char * Name); +%ignore XdmfRectilinearGridGetSet(XDMFRECTILINEARGRID * grid, unsigned int index); +%ignore XdmfRectilinearGridGetSetByName(XDMFRECTILINEARGRID * grid, char * Name); +%ignore XdmfRectilinearGridGetNumberSets(XDMFRECTILINEARGRID * grid); +%ignore XdmfRectilinearGridInsertSet(XDMFRECTILINEARGRID * grid, XDMFSET * Set, int passControl); +%ignore XdmfRectilinearGridRemoveSet(XDMFRECTILINEARGRID * grid, unsigned int index); +%ignore XdmfRectilinearGridRemoveSetByName(XDMFRECTILINEARGRID * grid, char * Name); +%ignore XdmfRectilinearGridGetMap(XDMFRECTILINEARGRID * grid, unsigned int index); +%ignore XdmfRectilinearGridGetMapByName(XDMFRECTILINEARGRID * grid, char * Name); +%ignore XdmfRectilinearGridGetNumberMaps(XDMFRECTILINEARGRID * grid); +%ignore XdmfRectilinearGridInsertMap(XDMFRECTILINEARGRID * grid, XDMFMAP * Map, int passControl); +%ignore XdmfRectilinearGridRemoveMap(XDMFRECTILINEARGRID * grid, unsigned int index); +%ignore XdmfRectilinearGridRemoveMapByName(XDMFRECTILINEARGRID * grid, char * Name); +%ignore XdmfRectilinearGridGetName(XDMFRECTILINEARGRID * grid); +%ignore XdmfRectilinearGridGetTime(XDMFRECTILINEARGRID * grid); +%ignore XdmfRectilinearGridSetName(XDMFRECTILINEARGRID * grid, char * name, int * status); +%ignore XdmfRectilinearGridSetTime(XDMFRECTILINEARGRID * grid, XDMFTIME * time, int passControl); + +// XdmfRegularGrid + +%ignore XdmfRegularGridNew2D(double xBrickSize, + double yBrickSize, + unsigned int xNumPoints, + unsigned int yNumPoints, + double xOrigin, + double yOrigin); +%ignore XdmfRegularGridNew3D(double xBrickSize, + double yBrickSize, + double zBrickSize, + unsigned int xNumPoints, + unsigned int yNumPoints, + unsigned int zNumPoints, + double xOrigin, + double yOrigin, + double zOrigin); +%ignore XdmfRegularGridNew(XDMFARRAY * brickSize, + XDMFARRAY * numPoints, + XDMFARRAY * origin, + int passControl); +%ignore XdmfRegularGridGetBrickSize(XDMFREGULARGRID * grid, int * status); +%ignore XdmfRegularGridGetDimensions(XDMFREGULARGRID * grid, int * status); +%ignore XdmfRegularGridGetOrigin(XDMFREGULARGRID * grid, int * status); +%ignore XdmfRegularGridSetBrickSize(XDMFREGULARGRID * grid, + XDMFARRAY * brickSize, + int passControl, + int * status); +%ignore XdmfRegularGridSetDimensions(XDMFREGULARGRID * grid, + XDMFARRAY * dimensions, + int passControl, + int * status); +%ignore XdmfRegularGridSetOrigin(XDMFREGULARGRID * grid, + XDMFARRAY * origin, + int passControl, + int * status); +// XdmfRegularGrid inherited from XdmfItem +%ignore XdmfRegularGridAccept(XDMFREGULARGRID * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfRegularGridFree(void * item); +%ignore XdmfRegularGridGetInformation(XDMFREGULARGRID * item, unsigned int index); +%ignore XdmfRegularGridGetInformationByKey(XDMFREGULARGRID * item, char * key); +%ignore XdmfRegularGridGetNumberInformations(XDMFREGULARGRID * item); +%ignore XdmfRegularGridInsertInformation(XDMFREGULARGRID * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfRegularGridRemoveInformation(XDMFREGULARGRID * item, unsigned int index); +%ignore XdmfRegularGridRemoveInformationByKey(XDMFREGULARGRID * item, char * key); +%ignore XdmfRegularGridGetItemTag(XDMFREGULARGRID * item); +// XdmfRegularGrid inherited from XdmfGrid +%ignore XdmfRegularGridGetAttribute(XDMFREGULARGRID * grid, unsigned int index); +%ignore XdmfRegularGridGetAttributeByName(XDMFREGULARGRID * grid, char * Name); +%ignore XdmfRegularGridGetNumberAttributes(XDMFREGULARGRID * grid); +%ignore XdmfRegularGridInsertAttribute(XDMFREGULARGRID * grid, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfRegularGridRemoveAttribute(XDMFREGULARGRID * grid, unsigned int index); +%ignore XdmfRegularGridRemoveAttributeByName(XDMFREGULARGRID * grid, char * Name); +%ignore XdmfRegularGridGetSet(XDMFREGULARGRID * grid, unsigned int index); +%ignore XdmfRegularGridGetSetByName(XDMFREGULARGRID * grid, char * Name); +%ignore XdmfRegularGridGetNumberSets(XDMFREGULARGRID * grid); +%ignore XdmfRegularGridInsertSet(XDMFREGULARGRID * grid, XDMFSET * Set, int passControl); +%ignore XdmfRegularGridRemoveSet(XDMFREGULARGRID * grid, unsigned int index); +%ignore XdmfRegularGridRemoveSetByName(XDMFREGULARGRID * grid, char * Name); +%ignore XdmfRegularGridGetMap(XDMFREGULARGRID * grid, unsigned int index); +%ignore XdmfRegularGridGetMapByName(XDMFREGULARGRID * grid, char * Name); +%ignore XdmfRegularGridGetNumberMaps(XDMFREGULARGRID * grid); +%ignore XdmfRegularGridInsertMap(XDMFREGULARGRID * grid, XDMFMAP * Map, int passControl); +%ignore XdmfRegularGridRemoveMap(XDMFREGULARGRID * grid, unsigned int index); +%ignore XdmfRegularGridRemoveMapByName(XDMFREGULARGRID * grid, char * Name); +%ignore XdmfRegularGridGetName(XDMFREGULARGRID * grid); +%ignore XdmfRegularGridGetTime(XDMFREGULARGRID * grid); +%ignore XdmfRegularGridSetName(XDMFREGULARGRID * grid, char * name, int * status); +%ignore XdmfRegularGridSetTime(XDMFREGULARGRID * grid, XDMFTIME * time, int passControl); + +// XdmfSet + +%ignore XdmfSetNew(); +%ignore XdmfSetGetAttribute(XDMFSET * set, unsigned int index); +%ignore XdmfSetGetAttributeByName(XDMFSET * set, char * Name); +%ignore XdmfSetGetNumberAttributes(XDMFSET * set); +%ignore XdmfSetGetType(XDMFSET * set); +%ignore XdmfSetInsertAttribute(XDMFSET * set, XDMFATTRIBUTE * Attribute, int passControl); +vXdmfSetRemoveAttribute(XDMFSET * set, unsigned int index); +%ignore XdmfSetRemoveAttributeByName(XDMFSET * set, char * Name); +%ignore XdmfSetSetType(XDMFSET * set, int type, int * status); +// XdmfSet inherited from XdmfArray +%ignore XdmfSetNew(); +%ignore XdmfSetClear(XDMFSET * array); +%ignore XdmfSetErase(XDMFSET * array, unsigned int index); +%ignore XdmfSetGetArrayType(XDMFSET * array, int * status); +%ignore XdmfSetGetCapacity(XDMFSET * array); +%ignore XdmfSetGetDimensions(XDMFSET * array); +%ignore XdmfSetGetDimensionsString(XDMFSET * array); +%ignore XdmfSetGetHeavyDataController(XDMFSET * array, unsigned int index); +%ignore XdmfSetGetReadMode(XDMFSET * array, int * status); +%ignore XdmfSetGetName(XDMFSET * array); +%ignore XdmfSetGetNumberDimensions(XDMFSET * array); +%ignore XdmfSetGetNumberHeavyDataControllers(XDMFSET * array); +%ignore XdmfSetGetSize(XDMFSET * array); +%ignore XdmfSetGetReference(XDMFSET * array); +%ignore XdmfSetGetValue(XDMFSET * array, unsigned int index, int arrayType, int * status); +%ignore XdmfSetGetValues(XDMFSET * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfSetGetValuesInternal(XDMFSET * array); +%ignore XdmfSetGetValuesString(XDMFSET * array); +%ignore XdmfSetInitialize(XDMFSET * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfSetInsertDataFromPointer(XDMFSET * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfSetInsertDataFromXdmfArray(XDMFSET * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status); +%ignore XdmfSetInsertHeavyDataController(XDMFSET * array, XDMFHEAVYDATACONTROLLER * controller, int passControl); +%ignore XdmfSetInsertValue(XDMFSET * array, unsigned int index, void * value, int arrayType, int * status); +%ignore XdmfSetIsInitialized(XDMFSET * array); +%ignore XdmfSetPushBack(XDMFSET * array, void * value, int arrayType, int * status); +%ignore XdmfSetRead(XDMFSET * array, int * status); +%ignore XdmfSetReadController(XDMFSET * array, int * status); +%ignore XdmfSetReadReference(XDMFSET * array, int * status); +%ignore XdmfSetRelease(XDMFSET * array); +%ignore XdmfSetRemoveHeavyDataController(XDMFSET * array, unsigned int index); +%ignore XdmfSetReserve(XDMFSET * array, int size); +%ignore XdmfSetResize(XDMFSET * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfSetSetReadMode(XDMFSET * array, int readMode, int * status); +%ignore XdmfSetSetReference(XDMFSET * array, XDMFARRAYREFERENCE * reference, int passControl); +%ignore XdmfSetSetName(XDMFSET * array, char * name, int * status); +%ignore XdmfSetSetValuesInternal(XDMFSET * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status); +%ignore XdmfSetSwapWithXdmfArray(XDMFSET * array, XDMFARRAY * swapArray); +%ignore XdmfSetSwapWithArray(XDMFSET * array, void ** pointer, int numValues, int arrayType, int * status); +// XdmfSet inherited from XdmfItem +%ignore XdmfSetAccept(XDMFSET * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfSetFree(void * item); +%ignore XdmfSetGetInformation(XDMFSET * item, unsigned int index); +%ignore XdmfSetGetInformationByKey(XDMFSET * item, char * key); +%ignore XdmfSetGetNumberInformations(XDMFSET * item); +%ignore XdmfSetInsertInformation(XDMFSET * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfSetRemoveInformation(XDMFSET * item, unsigned int index); +%ignore XdmfSetRemoveInformationByKey(XDMFSET * item, char * key); +%ignore XdmfSetGetItemTag(XDMFSET * item); + +// XdmfSetType + +%ignore XdmfSetTypeNoSetType(); +%ignore XdmfSetTypeNode(); +%ignore XdmfSetTypeCell(); +%ignore XdmfSetTypeFace(); +%ignore XdmfSetTypeEdge(); + +// XdmfTime + +%ignore XdmfTimeNew(double value); +%ignore XdmfTimeGetValue(XDMFTIME * timePointer); +%ignore XdmfTimeSetValue(XDMFTIME * timePointer, double time); +// XdmfTime inherited from XdmfItem +%ignore XdmfTimeAccept(XDMFTIME * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfTimeFree(void * item); +%ignore XdmfTimeGetInformation(XDMFTIME * item, unsigned int index); +%ignore XdmfTimeGetInformationByKey(XDMFTIME * item, char * key); +%ignore XdmfTimeGetNumberInformations(XDMFTIME * item); +%ignore XdmfTimeInsertInformation(XDMFTIME * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfTimeRemoveInformation(XDMFTIME * item, unsigned int index); +%ignore XdmfTimeRemoveInformationByKey(XDMFTIME * item, char * key); +%ignore XdmfTimeGetItemTag(XDMFTIME * item); + +// XdmfTopology + +%ignore XdmfTopologyNew(); +%ignore XdmfTopologyGetNumberElements(XDMFTOPOLOGY * topology, int * status); +%ignore XdmfTopologyGetType(XDMFTOPOLOGY * topology); +%ignore XdmfTopologySetType(XDMFTOPOLOGY * topology, int type, int * status); +%ignore XdmfTopologySetPolyType(XDMFTOPOLOGY * topology, int type, int nodes, int * status); +// XdmfTopology inherited from XdmfArray +%ignore XdmfTopologyNew(); +%ignore XdmfTopologyClear(XDMFTOPOLOGY * array); +%ignore XdmfTopologyErase(XDMFTOPOLOGY * array, unsigned int index); +%ignore XdmfTopologyGetArrayType(XDMFTOPOLOGY * array, int * status); +%ignore XdmfTopologyGetCapacity(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetDimensions(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetDimensionsString(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetHeavyDataController(XDMFTOPOLOGY * array, unsigned int index); +%ignore XdmfTopologyGetReadMode(XDMFTOPOLOGY * array, int * status); +%ignore XdmfTopologyGetName(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetNumberDimensions(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetNumberHeavyDataControllers(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetSize(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetReference(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetValue(XDMFTOPOLOGY * array, unsigned int index, int arrayType, int * status); +%ignore XdmfTopologyGetValues(XDMFTOPOLOGY * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfTopologyGetValuesInternal(XDMFTOPOLOGY * array); +%ignore XdmfTopologyGetValuesString(XDMFTOPOLOGY * array); +%ignore XdmfTopologyInitialize(XDMFTOPOLOGY * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfTopologyInsertDataFromPointer(XDMFTOPOLOGY * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfTopologyInsertDataFromXdmfArray(XDMFTOPOLOGY * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status); +%ignore XdmfTopologyInsertHeavyDataController(XDMFTOPOLOGY * array, XDMFHEAVYDATACONTROLLER * controller, int passControl); +%ignore XdmfTopologyInsertValue(XDMFTOPOLOGY * array, unsigned int index, void * value, int arrayType, int * status); +%ignore XdmfTopologyIsInitialized(XDMFTOPOLOGY * array); +%ignore XdmfTopologyPushBack(XDMFTOPOLOGY * array, void * value, int arrayType, int * status); +%ignore XdmfTopologyRead(XDMFTOPOLOGY * array, int * status); +%ignore XdmfTopologyReadController(XDMFTOPOLOGY * array, int * status); +%ignore XdmfTopologyReadReference(XDMFTOPOLOGY * array, int * status); +%ignore XdmfTopologyRelease(XDMFTOPOLOGY * array); +%ignore XdmfTopologyRemoveHeavyDataController(XDMFTOPOLOGY * array, unsigned int index); +%ignore XdmfTopologyReserve(XDMFTOPOLOGY * array, int size); +%ignore XdmfTopologyResize(XDMFTOPOLOGY * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfTopologySetReadMode(XDMFTOPOLOGY * array, int readMode, int * status); +%ignore XdmfTopologySetReference(XDMFTOPOLOGY * array, XDMFARRAYREFERENCE * reference, int passControl); +%ignore XdmfTopologySetName(XDMFTOPOLOGY * array, char * name, int * status); +%ignore XdmfTopologySetValuesInternal(XDMFTOPOLOGY * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status); +%ignore XdmfTopologySwapWithXdmfArray(XDMFTOPOLOGY * array, XDMFARRAY * swapArray); +%ignore XdmfTopologySwapWithArray(XDMFTOPOLOGY * array, void ** pointer, int numValues, int arrayType, int * status); +// XdmfTopology inherited from XdmfItem +%ignore XdmfTopologyAccept(XDMFTOPOLOGY * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfTopologyFree(void * item); +%ignore XdmfTopologyGetInformation(XDMFTOPOLOGY * item, unsigned int index); +%ignore XdmfTopologyGetInformationByKey(XDMFTOPOLOGY * item, char * key); +%ignore XdmfTopologyGetNumberInformations(XDMFTOPOLOGY * item); +%ignore XdmfTopologyInsertInformation(XDMFTOPOLOGY * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfTopologyRemoveInformation(XDMFTOPOLOGY * item, unsigned int index); +%ignore XdmfTopologyRemoveInformationByKey(XDMFTOPOLOGY * item, char * key); +%ignore XdmfTopologyGetItemTag(XDMFTOPOLOGY * item); + +// XdmfTopologyType + +%ignore XdmfTopologyTypePolyvertex(); +%ignore XdmfTopologyTypePolyline(); +%ignore XdmfTopologyTypePolygon(); +%ignore XdmfTopologyTypeTriangle(); +%ignore XdmfTopologyTypeQuadrilateral(); +%ignore XdmfTopologyTypeTetrahedron(); +%ignore XdmfTopologyTypePyramid(); +%ignore XdmfTopologyTypeWedge(); +%ignore XdmfTopologyTypeHexahedron(); +%ignore XdmfTopologyTypeEdge_3(); +%ignore XdmfTopologyTypeTriangle_6(); +%ignore XdmfTopologyTypeQuadrilateral_8(); +%ignore XdmfTopologyTypeQuadrilateral_9(); +%ignore XdmfTopologyTypeTetrahedron_10(); +%ignore XdmfTopologyTypePyramid_13(); +%ignore XdmfTopologyTypeWedge_15(); +%ignore XdmfTopologyTypeWedge_18(); +%ignore XdmfTopologyTypeHexahedron_20(); +%ignore XdmfTopologyTypeHexahedron_24(); +%ignore XdmfTopologyTypeHexahedron_27(); +%ignore XdmfTopologyTypeHexahedron_64(); +%ignore XdmfTopologyTypeHexahedron_125(); +%ignore XdmfTopologyTypeHexahedron_216(); +%ignore XdmfTopologyTypeHexahedron_343(); +%ignore XdmfTopologyTypeHexahedron_512(); +%ignore XdmfTopologyTypeHexahedron_729(); +%ignore XdmfTopologyTypeHexahedron_1000(); +%ignore XdmfTopologyTypeHexahedron_1331(); +%ignore XdmfTopologyTypeHexahedron_Spectral_64(); +%ignore XdmfTopologyTypeHexahedron_Spectral_125(); +%ignore XdmfTopologyTypeHexahedron_Spectral_216(); +%ignore XdmfTopologyTypeHexahedron_Spectral_343(); +%ignore XdmfTopologyTypeHexahedron_Spectral_512(); +%ignore XdmfTopologyTypeHexahedron_Spectral_729(); +%ignore XdmfTopologyTypeHexahedron_Spectral_1000(); +%ignore XdmfTopologyTypeHexahedron_Spectral_1331(); +%ignore XdmfTopologyTypeMixed(); +%ignore XdmfTopologyTypeGetCellType(int type); +%ignore XdmfTopologyTypeGetEdgesPerElement(int type, int * status); +%ignore XdmfTopologyTypeGetFacesPerElement(int type, int * status); +%ignore XdmfTopologyTypeGetFaceType(int type); +%ignore XdmfTopologyTypeGetID(int type); +%ignore XdmfTopologyTypeGetName(int type); +%ignore XdmfTopologyTypeGetNodesPerElement(int type); + +// XdmfUnstructuredGrid + +%ignore XdmfUnstructuredGridNew(); +%ignore XdmfUnstructuredGridNewFromRegularGrid(XDMFREGULARGRID * regularGrid, int * status); +%ignore XdmfUnstructuredGridGetGeometry(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridGetTopology(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridSetGeometry(XDMFUNSTRUCTUREDGRID * grid, + XDMFGEOMETRY * geometry, + int passControl); +%ignore XdmfUnstructuredGridSetTopology(XDMFUNSTRUCTUREDGRID * grid, + XDMFTOPOLOGY * topology, + int passControl); +// XdmfUnstructuredGrid inherited from XdmfItem +%ignore XdmfUnstructuredGridAccept(XDMFUNSTRUCTUREDGRID * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfUnstructuredGridFree(void * item); +%ignore XdmfUnstructuredGridGetInformation(XDMFUNSTRUCTUREDGRID * item, unsigned int index); +%ignore XdmfUnstructuredGridGetInformationByKey(XDMFUNSTRUCTUREDGRID * item, char * key); +%ignore XdmfUnstructuredGridGetNumberInformations(XDMFUNSTRUCTUREDGRID * item); +%ignore XdmfUnstructuredGridInsertInformation(XDMFUNSTRUCTUREDGRID * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfUnstructuredGridRemoveInformation(XDMFUNSTRUCTUREDGRID * item, unsigned int index); +%ignore XdmfUnstructuredGridRemoveInformationByKey(XDMFUNSTRUCTUREDGRID * item, char * key); +%ignore XdmfUnstructuredGridGetItemTag(XDMFUNSTRUCTUREDGRID * item); +// XdmfUnstructuredGrid inherited from XdmfGrid +%ignore XdmfUnstructuredGridGetAttribute(XDMFUNSTRUCTUREDGRID * grid, unsigned int index); +%ignore XdmfUnstructuredGridGetAttributeByName(XDMFUNSTRUCTUREDGRID * grid, char * Name); +%ignore XdmfUnstructuredGridGetNumberAttributes(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridInsertAttribute(XDMFUNSTRUCTUREDGRID * grid, XDMFATTRIBUTE * Attribute, int passControl); +%ignore XdmfUnstructuredGridRemoveAttribute(XDMFUNSTRUCTUREDGRID * grid, unsigned int index); +%ignore XdmfUnstructuredGridRemoveAttributeByName(XDMFUNSTRUCTUREDGRID * grid, char * Name); +%ignore XdmfUnstructuredGridGetSet(XDMFUNSTRUCTUREDGRID * grid, unsigned int index); +%ignore XdmfUnstructuredGridGetSetByName(XDMFUNSTRUCTUREDGRID * grid, char * Name); +%ignore XdmfUnstructuredGridGetNumberSets(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridInsertSet(XDMFUNSTRUCTUREDGRID * grid, XDMFSET * Set, int passControl); +%ignore XdmfUnstructuredGridRemoveSet(XDMFUNSTRUCTUREDGRID * grid, unsigned int index); +%ignore XdmfUnstructuredGridRemoveSetByName(XDMFUNSTRUCTUREDGRID * grid, char * Name); +%ignore XdmfUnstructuredGridGetMap(XDMFUNSTRUCTUREDGRID * grid, unsigned int index); +%ignore XdmfUnstructuredGridGetMapByName(XDMFUNSTRUCTUREDGRID * grid, char * Name); +%ignore XdmfUnstructuredGridGetNumberMaps(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridInsertMap(XDMFUNSTRUCTUREDGRID * grid, XDMFMAP * Map, int passControl); +%ignore XdmfUnstructuredGridRemoveMap(XDMFUNSTRUCTUREDGRID * grid, unsigned int index); +%ignore XdmfUnstructuredGridRemoveMapByName(XDMFUNSTRUCTUREDGRID * grid, char * Name); +%ignore XdmfUnstructuredGridGetName(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridGetTime(XDMFUNSTRUCTUREDGRID * grid); +%ignore XdmfUnstructuredGridSetName(XDMFUNSTRUCTUREDGRID * grid, char * name, int * status); +%ignore XdmfUnstructuredGridSetTime(XDMFUNSTRUCTUREDGRID * grid, XDMFTIME * time, int passControl); + #ifdef SWIGJAVA // Typemaps that work for Java @@ -247,14 +1090,6 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i %include std_map.i %include std_vector.i -#ifdef XDMF_BUILD_DSM - -%include mpi4py/mpi4py.i - -%mpi4py_typemap(Comm, MPI_Comm); - -#endif /* XDMF_BUILD_DSM */ - %template(XdmfMapNodeIdSet) std::set; %template(XdmfMapNodeIdMap) std::map >; %template(XdmfMapMap) std::map > >; @@ -265,8 +1100,10 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i #ifdef XDMF_BUILD_DSM %pythoncode { + import sys from XdmfCore import * - from XdmfDSM import * + if 'mpi4py' in sys.modules.keys(): + from XdmfDSM import * } #else @@ -381,6 +1218,7 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i #endif /* SWIGPYTHON */ // Shared Pointer Templates +%shared_ptr(XdmfAggregate) %shared_ptr(XdmfAttribute) %shared_ptr(XdmfAttributeCenter) %shared_ptr(XdmfAttributeType) @@ -407,6 +1245,7 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i %include Xdmf.hpp %include XdmfGrid.hpp +%include XdmfAggregate.hpp %include XdmfAttribute.hpp %include XdmfAttributeCenter.hpp %include XdmfAttributeType.hpp diff --git a/XdmfAggregate.cpp b/XdmfAggregate.cpp new file mode 100644 index 00000000..c5cfdd91 --- /dev/null +++ b/XdmfAggregate.cpp @@ -0,0 +1,272 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfAggregate.cpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@us.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2013 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#include +#include +#include +#include "XdmfArray.hpp" +#include "XdmfError.hpp" +#include "XdmfAggregate.hpp" +#include "XdmfVisitor.hpp" +#include "XdmfWriter.hpp" +#include "string.h" + +XDMF_CHILDREN_IMPLEMENTATION(XdmfAggregate, XdmfArray, Array, Name) + +XdmfAggregate::XdmfAggregate() +{ +} + +XdmfAggregate::XdmfAggregate(XdmfAggregate & refAggregate) : + XdmfArrayReference(refAggregate) +{ +} + +XdmfAggregate::~XdmfAggregate() +{ +} + +const std::string XdmfAggregate::ItemTag = "Aggregate"; + +shared_ptr +XdmfAggregate::New() +{ + shared_ptr p(new XdmfAggregate()); + return p; +} + +std::vector XdmfAggregate::getDimensions() const +{ + std::vector testDims = mArrays[0]->getDimensions(); + + bool isSame = true; + + for(std::vector >::const_iterator iter = + mArrays.begin(); + iter != mArrays.end() && isSame; + ++iter) { + std::vector compareDims = (*iter)->getDimensions(); + if (compareDims.size() == testDims.size()) + { + for (unsigned int i = 0; i < testDims.size(); ++i) + { + if (compareDims[i] != testDims[i]) + { + isSame = false; + break; + } + } + } + else + { + isSame = false; + break; + } + } + + if (isSame) + { + testDims.push_back(mArrays.size()); + return testDims; + } + else + { + std::vector returnDims; + returnDims.push_back(this->getSize()); + return returnDims; + } +} + +std::map +XdmfAggregate::getItemProperties() const +{ + std::map aggregateMap = XdmfArrayReference::getItemProperties(); + + return aggregateMap; +} + +std::string +XdmfAggregate::getItemTag() const +{ + return ItemTag; +} + +unsigned int +XdmfAggregate::getSize() const +{ + unsigned int total = 0; + for(std::vector >::const_iterator iter = + mArrays.begin(); + iter != mArrays.end(); + ++iter) { + total += (*iter)->getSize(); + } + return total; +} + +void +XdmfAggregate::populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader) +{ + bool placeholderFound = false; + for(std::vector >::const_iterator iter = + childItems.begin(); + iter != childItems.end(); + ++iter) { + if(shared_ptr array = shared_dynamic_cast(*iter)) { + if (!placeholderFound) { + placeholderFound = true; + } + else { + this->insert(array); + } +/* + this->swap(array); + if (array->getReference()) { + this->setReference(array->getReference()); + this->setReadMode(XdmfArray::Reference); + } + break; +*/ + } + } +} + +shared_ptr +XdmfAggregate::read() const +{ + shared_ptr returnArray = XdmfArray::New(); + + if (mArrays.size() > 0) + { + if (!mArrays[0]->isInitialized()) { + mArrays[0]->read(); + } + returnArray->insert(0, mArrays[0], 0, mArrays[0]->getSize(), 1, 1); + if (mArrays.size() > 1) + { + unsigned int offset = mArrays[0]->getSize(); + for (unsigned int i = 1; i < mArrays.size(); ++i) + { + if (!mArrays[i]->isInitialized()) { + mArrays[i]->read(); + } + returnArray->insert(offset, mArrays[i], 0, mArrays[i]->getSize(), 1, 1); + offset += mArrays[i]->getSize(); + } + } + } + + return returnArray; +} + +void +XdmfAggregate::traverse(const shared_ptr visitor) +{ + XdmfItem::traverse(visitor); + + bool originalXPath; + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + originalXPath = writer->getWriteXPaths(); + writer->setWriteXPaths(false); + } + + shared_ptr spacerarray = XdmfArray::New(); + spacerarray->pushBack((int)0); + spacerarray->accept(visitor); + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + writer->setWriteXPaths(originalXPath); + } + + for (unsigned int i = 0; i < mArrays.size(); ++i) + { + mArrays[i]->accept(visitor); + } +} + +// C Wrappers + +XDMFAGGREGATE * XdmfAggregateNew() +{ + try + { + shared_ptr generatedAggregate = XdmfAggregate::New(); + return (XDMFAGGREGATE *)((void *)(new XdmfAggregate(*generatedAggregate.get()))); + } + catch (...) + { + shared_ptr generatedAggregate = XdmfAggregate::New(); + return (XDMFAGGREGATE *)((void *)(new XdmfAggregate(*generatedAggregate.get()))); + } +} + +XDMFARRAY * +XdmfAggregateGetArray(XDMFAGGREGATE * aggregate, unsigned int index) +{ + return (XDMFARRAY *)((void *)(((XdmfAggregate *)(aggregate))->getArray(index).get())); +} + +XDMFARRAY * +XdmfAggregateGetArrayByName(XDMFAGGREGATE * aggregate, char * name) +{ + return (XDMFARRAY *)((void *)(((XdmfAggregate *)(aggregate))->getArray(name).get())); +} + +unsigned int +XdmfAggregateGetNumberArrays(XDMFAGGREGATE * aggregate) +{ + return ((XdmfAggregate *)(aggregate))->getNumberArrays(); +} + +void +XdmfAggregateInsertArray(XDMFAGGREGATE * aggregate, XDMFARRAY * array, int transferOwnership) +{ + if (transferOwnership) { + ((XdmfAggregate *)(aggregate))->insert(shared_ptr((XdmfArray *)array)); + } + else { + ((XdmfAggregate *)(aggregate))->insert(shared_ptr((XdmfArray *)array, XdmfNullDeleter())); + } +} + +void +XdmfAggregateRemoveArray(XDMFAGGREGATE * aggregate, unsigned int index) +{ + ((XdmfAggregate *)(aggregate))->removeArray(index); +} + +void +XdmfAggregateRemoveArrayByName(XDMFAGGREGATE * aggregate, char * name) +{ + ((XdmfAggregate *)(aggregate))->removeArray(name); +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfAggregate, XDMFAGGREGATE) +XDMF_ARRAYREFERENCE_C_CHILD_WRAPPER(XdmfAggregate, XDMFAGGREGATE) diff --git a/XdmfAggregate.hpp b/XdmfAggregate.hpp new file mode 100644 index 00000000..e422bff0 --- /dev/null +++ b/XdmfAggregate.hpp @@ -0,0 +1,214 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfAggregate.hpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@us.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2013 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#ifndef XDMFAGGREGATE_HPP_ +#define XDMFAGGREGATE_HPP_ + +// C Compatible Includes +#include "Xdmf.hpp" +#include "XdmfArrayReference.hpp" + +#ifdef __cplusplus + +// Forward Declarations +class XdmfArray; + +// Includes +#include +#include "XdmfItem.hpp" +#include "XdmfSharedPtr.hpp" + +/** + * @brief Couples an XdmfArray with heavy data stored in another XdmfArray. + * + * This class serves to allow an array to retrieve data that is a subsection + * of an already existing array. + */ +class XDMF_EXPORT XdmfAggregate: public XdmfArrayReference { + +public: + + /** + * Generates an XdmfAggregate object. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfAggregate.cpp + * @skipline //#initialization + * @until //#initialization + * + * Python + * + * @dontinclude XdmfExampleAggregate.py + * @skipline #//initialization + * @until #//initialization + * + * @return A constructed XdmfAggregate object. + */ + static shared_ptr + New(); + + virtual ~XdmfAggregate(); + + LOKI_DEFINE_VISITABLE(XdmfAggregate, XdmfItem) + XDMF_CHILDREN(XdmfAggregate, XdmfArray, Array, Name) + + static const std::string ItemTag; + + /** + * Get the dimensions of the set referenced by this subset. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfAggregate.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getDimensions + * @until //#getDimensions + * + * Python + * + * @dontinclude XdmfExampleAggregate.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getDimensions + * @until #//getDimensions + * + * @return A vector containing the size in each dimension of the + * set referenced by this subset. + */ + std::vector getDimensions() const; + + std::map getItemProperties() const; + + std::string getItemTag() const; + + /** + * Get the size of the set referenced by this subset. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfAggregate.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getSize + * @until //#getSize + * + * Python + * + * @dontinclude XdmfExampleAggregate.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getSize + * @until #//getSize + * + * @return An int containing the size of the subset. + */ + unsigned int getSize() const; + + /** + * Read data reference by this subset and return as an XdmfArray. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfAggregate.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#read + * @until //#read + * + * Python + * + * @dontinclude XdmfExampleAggregate.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//read + * @until #//read + * + * @return An array filled with data based on the subset's parameters. + */ + virtual shared_ptr read() const; + + void traverse(const shared_ptr visitor); + + XdmfAggregate(XdmfAggregate&); + +protected: + + XdmfAggregate(); + + void + populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader); + +private: + + XdmfAggregate(const XdmfAggregate&); // Not implemented. + void operator=(const XdmfAggregate&); // Not implemented. + +}; + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFAGGREGATE; // Simply as a typedef to ensure correct typing +typedef struct XDMFAGGREGATE XDMFAGGREGATE; + +XDMF_EXPORT XDMFAGGREGATE * XdmfAggregateNew(); + +XDMF_EXPORT XDMFARRAY * XdmfAggregateGetArray(XDMFAGGREGATE * aggregate, unsigned int index); + +XDMF_EXPORT XDMFARRAY * XdmfAggregateGetArrayByName(XDMFAGGREGATE * aggregate, char * name); + +XDMF_EXPORT unsigned int XdmfAggregateGetNumberArrays(XDMFAGGREGATE * aggregate); + +XDMF_EXPORT void XdmfAggregateInsertArray(XDMFAGGREGATE * aggregate, XDMFARRAY * array, int transferOwnership); + +XDMF_EXPORT void XdmfAggregateRemoveArray(XDMFAGGREGATE * aggregate, unsigned int index); + +XDMF_EXPORT void XdmfAggregateRemoveArrayByName(XDMFAGGREGATE * aggregate, char * name); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfAggregate, XDMFAGGREGATE, XDMF) +XDMF_ARRAYREFERENCE_C_CHILD_DECLARE(XdmfAggregate, XDMFAGGREGATE, XDMF) + +#ifdef __cplusplus +} +#endif + +#endif /* XDMFAGGREGATE_HPP_ */ diff --git a/XdmfAttribute.cpp b/XdmfAttribute.cpp index b984adb5..0c86abbf 100644 --- a/XdmfAttribute.cpp +++ b/XdmfAttribute.cpp @@ -41,6 +41,14 @@ XdmfAttribute::XdmfAttribute() : { } +XdmfAttribute::XdmfAttribute(XdmfAttribute & refAttribute) : + XdmfArray(refAttribute), + mCenter(refAttribute.mCenter), + mName(refAttribute.mName), + mType(refAttribute.mType) +{ +} + XdmfAttribute::~XdmfAttribute() { } @@ -120,16 +128,148 @@ void XdmfAttribute::setCenter(const shared_ptr center) { mCenter = center; + this->setIsChanged(true); } void XdmfAttribute::setName(const std::string & name) { mName = name; + this->setIsChanged(true); } void XdmfAttribute::setType(const shared_ptr type) { mType = type; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFATTRIBUTE * XdmfAttributeNew() +{ + try + { + shared_ptr generatedAttribute = XdmfAttribute::New(); + return (XDMFATTRIBUTE *)((void *)(new XdmfAttribute(*generatedAttribute.get()))); + } + catch (...) + { + shared_ptr generatedAttribute = XdmfAttribute::New(); + return (XDMFATTRIBUTE *)((void *)(new XdmfAttribute(*generatedAttribute.get()))); + } +} + +int XdmfAttributeGetCenter(XDMFATTRIBUTE * attribute) +{ + if (((XdmfAttribute *)attribute)->getCenter() == XdmfAttributeCenter::Grid()) { + return XDMF_ATTRIBUTE_CENTER_GRID; + } + else if (((XdmfAttribute *)attribute)->getCenter() == XdmfAttributeCenter::Cell()) { + return XDMF_ATTRIBUTE_CENTER_CELL; + } + else if (((XdmfAttribute *)attribute)->getCenter() == XdmfAttributeCenter::Face()) { + return XDMF_ATTRIBUTE_CENTER_FACE; + } + else if (((XdmfAttribute *)attribute)->getCenter() == XdmfAttributeCenter::Edge()) { + return XDMF_ATTRIBUTE_CENTER_EDGE; + } + else if (((XdmfAttribute *)attribute)->getCenter() == XdmfAttributeCenter::Node()) { + return XDMF_ATTRIBUTE_CENTER_NODE; + } + else { + return -1; + } +} + +int XdmfAttributeGetType(XDMFATTRIBUTE * attribute) +{ + if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::Scalar()) { + return XDMF_ATTRIBUTE_TYPE_SCALAR; + } + else if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::Vector()) { + return XDMF_ATTRIBUTE_TYPE_VECTOR; + } + else if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::Tensor()) { + return XDMF_ATTRIBUTE_TYPE_TENSOR; + } + else if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::Matrix()) { + return XDMF_ATTRIBUTE_TYPE_MATRIX; + } + else if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::Tensor6()) { + return XDMF_ATTRIBUTE_TYPE_TENSOR6; + } + else if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::GlobalId()) { + return XDMF_ATTRIBUTE_TYPE_GLOBALID; + } + else if (((XdmfAttribute *)attribute)->getType() == XdmfAttributeType::NoAttributeType()) { + return XDMF_ATTRIBUTE_TYPE_NOTYPE; + } + else { + return -1; + } +} + +void XdmfAttributeSetCenter(XDMFATTRIBUTE * attribute, int center, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch(center) { + case XDMF_ATTRIBUTE_CENTER_GRID: + ((XdmfAttribute *)attribute)->setCenter(XdmfAttributeCenter::Grid()); + break; + case XDMF_ATTRIBUTE_CENTER_CELL: + ((XdmfAttribute *)attribute)->setCenter(XdmfAttributeCenter::Cell()); + break; + case XDMF_ATTRIBUTE_CENTER_FACE: + ((XdmfAttribute *)attribute)->setCenter(XdmfAttributeCenter::Face()); + break; + case XDMF_ATTRIBUTE_CENTER_EDGE: + ((XdmfAttribute *)attribute)->setCenter(XdmfAttributeCenter::Edge()); + break; + case XDMF_ATTRIBUTE_CENTER_NODE: + ((XdmfAttribute *)attribute)->setCenter(XdmfAttributeCenter::Node()); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Attribute Center: Code " + center); + break; + } + XDMF_ERROR_WRAP_END(status) } + +void XdmfAttributeSetType(XDMFATTRIBUTE * attribute, int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch(type) { + case XDMF_ATTRIBUTE_TYPE_SCALAR: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::Scalar()); + break; + case XDMF_ATTRIBUTE_TYPE_VECTOR: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::Vector()); + break; + case XDMF_ATTRIBUTE_TYPE_TENSOR: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::Tensor()); + break; + case XDMF_ATTRIBUTE_TYPE_MATRIX: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::Matrix()); + break; + case XDMF_ATTRIBUTE_TYPE_TENSOR6: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::Tensor6()); + break; + case XDMF_ATTRIBUTE_TYPE_GLOBALID: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::GlobalId()); + break; + case XDMF_ATTRIBUTE_TYPE_NOTYPE: + ((XdmfAttribute *)attribute)->setType(XdmfAttributeType::NoAttributeType()); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Attribute Type: Code " + type); + break; + } + XDMF_ERROR_WRAP_END(status) +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfAttribute, XDMFATTRIBUTE) +XDMF_ARRAY_C_CHILD_WRAPPER(XdmfAttribute, XDMFATTRIBUTE) diff --git a/XdmfAttribute.hpp b/XdmfAttribute.hpp index 0dc13811..bf024105 100644 --- a/XdmfAttribute.hpp +++ b/XdmfAttribute.hpp @@ -24,13 +24,14 @@ #ifndef XDMFATTRIBUTE_HPP_ #define XDMFATTRIBUTE_HPP_ -// Forward Declarations -class XdmfAttributeCenter; -class XdmfAttributeType; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfArray.hpp" +#include "XdmfAttributeCenter.hpp" +#include "XdmfAttributeType.hpp" +#include "XdmfTime.hpp" + +#ifdef __cplusplus /** * @brief Holds values located at specific parts of an XdmfGrid. @@ -237,6 +238,8 @@ public: */ void setType(const shared_ptr type); + XdmfAttribute(XdmfAttribute &); + protected: XdmfAttribute(); @@ -263,4 +266,32 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFATTRIBUTE; // Simply as a typedef to ensure correct typing +typedef struct XDMFATTRIBUTE XDMFATTRIBUTE; + +XDMF_EXPORT XDMFATTRIBUTE * XdmfAttributeNew(); + +XDMF_EXPORT int XdmfAttributeGetCenter(XDMFATTRIBUTE * attribute); + +XDMF_EXPORT int XdmfAttributeGetType(XDMFATTRIBUTE * attribute); + +XDMF_EXPORT void XdmfAttributeSetCenter(XDMFATTRIBUTE * attribute, int center, int * status); + +XDMF_EXPORT void XdmfAttributeSetType(XDMFATTRIBUTE * attribute, int type, int * status); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfAttribute, XDMFATTRIBUTE, XDMF) +XDMF_ARRAY_C_CHILD_DECLARE(XdmfAttribute, XDMFATTRIBUTE, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFATTRIBUTE_HPP_ */ diff --git a/XdmfAttributeCenter.cpp b/XdmfAttributeCenter.cpp index a580b311..0b7691ea 100644 --- a/XdmfAttributeCenter.cpp +++ b/XdmfAttributeCenter.cpp @@ -25,6 +25,8 @@ #include "XdmfAttributeCenter.hpp" #include "XdmfError.hpp" +std::map(*)()> XdmfAttributeCenter::mAttributeCenterDefinitions; + // Supported XdmfAttributeCenters shared_ptr XdmfAttributeCenter::Grid() @@ -66,6 +68,16 @@ XdmfAttributeCenter::Node() return p; } +void +XdmfAttributeCenter::InitTypes() +{ + mAttributeCenterDefinitions["GRID"] = Grid; + mAttributeCenterDefinitions["CELL"] = Cell; + mAttributeCenterDefinitions["FACE"] = Face; + mAttributeCenterDefinitions["EDGE"] = Edge; + mAttributeCenterDefinitions["NODE"] = Node; +} + XdmfAttributeCenter::XdmfAttributeCenter(const std::string & name) : mName(name) { @@ -78,6 +90,7 @@ XdmfAttributeCenter::~XdmfAttributeCenter() shared_ptr XdmfAttributeCenter::New(const std::map & itemProperties) { + InitTypes(); std::map::const_iterator center = itemProperties.find("Center"); if(center == itemProperties.end()) { @@ -85,22 +98,18 @@ XdmfAttributeCenter::New(const std::map & itemProperti "'Center' not found in itemProperties in " "XdmfAttributeCenter::New"); } - const std::string & centerVal = center->second; - - if(centerVal.compare("Node") == 0) { - return Node(); - } - else if(centerVal.compare("Cell") == 0) { - return Cell(); - } - else if(centerVal.compare("Grid") == 0) { - return Grid(); - } - else if(centerVal.compare("Face") == 0) { - return Face(); + + const std::string & centerVal = ConvertToUpper(center->second); + + std::map(*)()>::const_iterator returnType = mAttributeCenterDefinitions.find(centerVal); + + if (returnType == mAttributeCenterDefinitions.end()) { + XdmfError::message(XdmfError::FATAL, + "Center not of 'Grid','Cell','Face','Edge','Node' " + "in XdmfAttributeCenter::New"); } - else if(centerVal.compare("Edge") == 0) { - return Edge(); + else { + return (*(returnType->second))(); } XdmfError::message(XdmfError::FATAL, @@ -116,3 +125,30 @@ XdmfAttributeCenter::getProperties(std::map & collecte { collectedProperties.insert(std::make_pair("Center", mName)); } + +// C Wrappers + +int XdmfAttributeCenterGrid() +{ + return XDMF_ATTRIBUTE_CENTER_GRID; +} + +int XdmfAttributeCenterCell() +{ + return XDMF_ATTRIBUTE_CENTER_CELL; +} + +int XdmfAttributeCenterFace() +{ + return XDMF_ATTRIBUTE_CENTER_FACE; +} + +int XdmfAttributeCenterEdge() +{ + return XDMF_ATTRIBUTE_CENTER_EDGE; +} + +int XdmfAttributeCenterNode() +{ + return XDMF_ATTRIBUTE_CENTER_NODE; +} diff --git a/XdmfAttributeCenter.hpp b/XdmfAttributeCenter.hpp index 71b00b88..a0b76167 100644 --- a/XdmfAttributeCenter.hpp +++ b/XdmfAttributeCenter.hpp @@ -24,10 +24,12 @@ #ifndef XDMFATTRIBUTECENTER_HPP_ #define XDMFATTRIBUTECENTER_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfItemProperty.hpp" +#ifdef __cplusplus + /** * @brief Property describing where XdmfAttribute values are centered. * @@ -97,6 +99,10 @@ protected: */ XdmfAttributeCenter(const std::string & name); + static std::map(*)()> mAttributeCenterDefinitions; + + static void InitTypes(); + private: XdmfAttributeCenter(const XdmfAttributeCenter &); // Not implemented. @@ -108,4 +114,28 @@ private: std::string mName; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_ATTRIBUTE_CENTER_GRID 100 +#define XDMF_ATTRIBUTE_CENTER_CELL 101 +#define XDMF_ATTRIBUTE_CENTER_FACE 102 +#define XDMF_ATTRIBUTE_CENTER_EDGE 103 +#define XDMF_ATTRIBUTE_CENTER_NODE 104 + +XDMF_EXPORT int XdmfAttributeCenterGrid(); +XDMF_EXPORT int XdmfAttributeCenterCell(); +XDMF_EXPORT int XdmfAttributeCenterFace(); +XDMF_EXPORT int XdmfAttributeCenterEdge(); +XDMF_EXPORT int XdmfAttributeCenterNode(); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFATTRIBUTECENTER_HPP_ */ diff --git a/XdmfAttributeType.cpp b/XdmfAttributeType.cpp index b2c0607e..c0729ab0 100644 --- a/XdmfAttributeType.cpp +++ b/XdmfAttributeType.cpp @@ -25,6 +25,8 @@ #include "XdmfAttributeType.hpp" #include "XdmfError.hpp" +std::map(*)()> XdmfAttributeType::mAttributeDefinitions; + // Supported XdmfAttributeTypes shared_ptr XdmfAttributeType::NoAttributeType() @@ -82,6 +84,18 @@ XdmfAttributeType::GlobalId() return p; } +void +XdmfAttributeType::InitTypes() +{ + mAttributeDefinitions["NONE"] = NoAttributeType; + mAttributeDefinitions["SCALAR"] = Scalar; + mAttributeDefinitions["VECTOR"] = Vector; + mAttributeDefinitions["TENSOR"] = Tensor; + mAttributeDefinitions["MATRIX"] = Matrix; + mAttributeDefinitions["TENSOR6"] = Tensor6; + mAttributeDefinitions["GLOBALID"] = GlobalId; +} + XdmfAttributeType::XdmfAttributeType(const std::string & name) : mName(name) { @@ -94,6 +108,7 @@ XdmfAttributeType::~XdmfAttributeType() shared_ptr XdmfAttributeType::New(const std::map & itemProperties) { + InitTypes(); std::map::const_iterator type = itemProperties.find("Type"); if(type == itemProperties.end()) { @@ -103,35 +118,22 @@ XdmfAttributeType::New(const std::map & itemProperties // to support old xdmf defaults, return Scalar() return Scalar(); } - const std::string & typeVal = type->second; - if(typeVal.compare("Scalar") == 0) { - return Scalar(); - } - else if(typeVal.compare("Vector") == 0) { - return Vector(); - } - else if(typeVal.compare("Tensor") == 0) { - return Tensor(); - } - else if(typeVal.compare("Matrix") == 0) { - return Matrix(); - } - else if(typeVal.compare("Tensor6") == 0) { - return Tensor6(); - } - else if(typeVal.compare("GlobalId") == 0) { - return GlobalId(); + + const std::string & typeVal = ConvertToUpper(type->second); + + std::map(*)()>::const_iterator returnType = mAttributeDefinitions.find(typeVal); + + if (returnType == mAttributeDefinitions.end()) { + XdmfError::message(XdmfError::FATAL, + "Type not of 'None','Scalar','Vector','Tensor', " + "'Matrix','Tensor6', or 'GlobalId' in " + "XdmfAttributeType::New"); } - else if(typeVal.compare("None") == 0) { - return NoAttributeType(); + else { + return (*(returnType->second))(); } - XdmfError::message(XdmfError::FATAL, - "Type not of 'None','Scalar','Vector','Tensor', " - "'Matrix','Tensor6', or 'GlobalId' in " - "XdmfAttributeType::New"); - // unreachable return shared_ptr(); } @@ -141,3 +143,40 @@ XdmfAttributeType::getProperties(std::map & collectedP { collectedProperties.insert(std::make_pair("Type", mName)); } + +// C Wrappers + +int XdmfAttributeTypeScalar() +{ + return XDMF_ATTRIBUTE_TYPE_SCALAR; +} + +int XdmfAttributeTypeVector() +{ + return XDMF_ATTRIBUTE_TYPE_VECTOR; +} + +int XdmfAttributeTypeTensor() +{ + return XDMF_ATTRIBUTE_TYPE_TENSOR; +} + +int XdmfAttributeTypeMatrix() +{ + return XDMF_ATTRIBUTE_TYPE_MATRIX; +} + +int XdmfAttributeTypeTensor6() +{ + return XDMF_ATTRIBUTE_TYPE_TENSOR6; +} + +int XdmfAttributeTypeGlobalId() +{ + return XDMF_ATTRIBUTE_TYPE_GLOBALID; +} + +int XdmfAttributeTypeNoAttributeType() +{ + return XDMF_ATTRIBUTE_TYPE_NOTYPE; +} diff --git a/XdmfAttributeType.hpp b/XdmfAttributeType.hpp index d7275928..4ffa6ed5 100644 --- a/XdmfAttributeType.hpp +++ b/XdmfAttributeType.hpp @@ -24,8 +24,11 @@ #ifndef XDMFATTRIBUTETYPE_HPP_ #define XDMFATTRIBUTETYPE_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" + +#ifdef __cplusplus + #include "XdmfItemProperty.hpp" /** @@ -100,6 +103,10 @@ protected: */ XdmfAttributeType(const std::string & name); + static std::map(*)()> mAttributeDefinitions; + + static void InitTypes(); + private: XdmfAttributeType(const XdmfAttributeType &); // Not implemented. @@ -111,4 +118,32 @@ private: std::string mName; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_ATTRIBUTE_TYPE_SCALAR 200 +#define XDMF_ATTRIBUTE_TYPE_VECTOR 201 +#define XDMF_ATTRIBUTE_TYPE_TENSOR 202 +#define XDMF_ATTRIBUTE_TYPE_MATRIX 203 +#define XDMF_ATTRIBUTE_TYPE_TENSOR6 204 +#define XDMF_ATTRIBUTE_TYPE_GLOBALID 205 +#define XDMF_ATTRIBUTE_TYPE_NOTYPE 206 + +XDMF_EXPORT int XdmfAttributeTypeScalar(); +XDMF_EXPORT int XdmfAttributeTypeVector(); +XDMF_EXPORT int XdmfAttributeTypeTensor(); +XDMF_EXPORT int XdmfAttributeTypeMatrix(); +XDMF_EXPORT int XdmfAttributeTypeTensor6(); +XDMF_EXPORT int XdmfAttributeTypeGlobalId(); +XDMF_EXPORT int XdmfAttributeTypeNoAttributeType(); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFATTRIBUTETYPE_HPP_ */ diff --git a/XdmfCurvilinearGrid.cpp b/XdmfCurvilinearGrid.cpp index cf307f92..1fb42122 100644 --- a/XdmfCurvilinearGrid.cpp +++ b/XdmfCurvilinearGrid.cpp @@ -32,7 +32,7 @@ /** * PIMPL */ -class XdmfCurvilinearGrid::XdmfCurvilinearGridImpl { +class XdmfCurvilinearGrid::XdmfCurvilinearGridImpl : public XdmfGridImpl { public: @@ -49,6 +49,11 @@ public: return p; } + bool isInitialized() const + { + return true; + } + unsigned int getNumberElements() const { @@ -91,12 +96,17 @@ public: unsigned int getEdgesPerElement() const { + return calculateHypercubeNumElements(mCurvilinearGrid->getDimensions()->getSize(), 1); +/* const unsigned int dimensions = mCurvilinearGrid->getDimensions()->getSize(); + if (dimensions == 1) { + return 1; + } if(dimensions == 2) { return 4; } - else if(dimensions == 3) { + else if(dimensions >= 3) { return 12; } else { @@ -105,14 +115,20 @@ public: "XdmfTopologyTypeCurvilinear::getEdgesPerElement"); } return 0; +*/ } unsigned int getFacesPerElement() const { + return calculateHypercubeNumElements(mCurvilinearGrid->getDimensions()->getSize(), 2); +/* const unsigned int dimensions = mCurvilinearGrid->getDimensions()->getSize(); - if(dimensions == 2) { + if (dimensions == 1) { + return 0; + } + else if(dimensions == 2) { return 1; } else if(dimensions == 3) { @@ -124,15 +140,17 @@ public: "XdmfTopologyTypeCurvilinear::getFacesPerElement"); } return 0; +*/ } unsigned int getNodesPerElement() const { + return calculateHypercubeNumElements(mCurvilinearGrid->getDimensions()->getSize(), 0); // 2^Dimensions // e.g. 1D = 2 nodes per element and 2D = 4 nodes per element. - return (unsigned int) - std::pow(2, (double)mCurvilinearGrid->getDimensions()->getSize()); +// return (unsigned int) +// std::pow(2, (double)mCurvilinearGrid->getDimensions()->getSize()); } void @@ -147,9 +165,10 @@ public: collectedProperties["Type"] = "2DSMesh"; } else { - XdmfError::message(XdmfError::FATAL, - "Grid dimensions not 2 or 3 in " - "XdmfTopologyTypeCurvilinear::getProperties"); + collectedProperties["Type"] = "SMesh"; +// XdmfError::message(XdmfError::FATAL, +// "Grid dimensions not 2 or 3 in " +// "XdmfTopologyTypeCurvilinear::getProperties"); } collectedProperties["Dimensions"] = dimensions->getValuesString(); } @@ -175,10 +194,15 @@ public: XdmfCurvilinearGridImpl(const shared_ptr numPoints) : mDimensions(numPoints) { + mGridType ="Curvilinear"; } - shared_ptr mDimensions; + XdmfGridImpl * duplicate() + { + return new XdmfCurvilinearGridImpl(mDimensions); + } + shared_ptr mDimensions; }; shared_ptr @@ -186,7 +210,7 @@ XdmfCurvilinearGrid::New(const unsigned int xNumPoints, const unsigned int yNumPoints) { shared_ptr numPoints = XdmfArray::New(); - numPoints->resize(2); + numPoints->resize(2, (unsigned int)0); numPoints->insert(0, xNumPoints); numPoints->insert(1, yNumPoints); shared_ptr p(new XdmfCurvilinearGrid(numPoints)); @@ -199,7 +223,7 @@ XdmfCurvilinearGrid::New(const unsigned int xNumPoints, const unsigned int zNumPoints) { shared_ptr numPoints = XdmfArray::New(); - numPoints->resize(3); + numPoints->resize(3, (unsigned int)0); numPoints->insert(0, xNumPoints); numPoints->insert(1, yNumPoints); numPoints->insert(2, zNumPoints); @@ -216,9 +240,15 @@ XdmfCurvilinearGrid::New(const shared_ptr numPoints) XdmfCurvilinearGrid::XdmfCurvilinearGrid(const shared_ptr numPoints) : XdmfGrid(XdmfGeometry::New(), - XdmfCurvilinearGridImpl::XdmfTopologyCurvilinear::New(this)), - mImpl(new XdmfCurvilinearGridImpl(numPoints)) + XdmfCurvilinearGridImpl::XdmfTopologyCurvilinear::New(this)) +{ + mImpl = new XdmfCurvilinearGridImpl(numPoints); +} + +XdmfCurvilinearGrid::XdmfCurvilinearGrid(XdmfCurvilinearGrid & refGrid) : + XdmfGrid(refGrid) { + mTopology = XdmfCurvilinearGridImpl::XdmfTopologyCurvilinear::New(this); } XdmfCurvilinearGrid::~XdmfCurvilinearGrid() @@ -231,6 +261,18 @@ XdmfCurvilinearGrid::~XdmfCurvilinearGrid() const std::string XdmfCurvilinearGrid::ItemTag = "Grid"; +void +XdmfCurvilinearGrid::copyGrid(shared_ptr sourceGrid) +{ + XdmfGrid::copyGrid(sourceGrid); + if (shared_ptr classedGrid = shared_dynamic_cast(sourceGrid)) + { + // Copy stucture from read grid to this grid + this->setGeometry(classedGrid->getGeometry()); + this->setDimensions(classedGrid->getDimensions()); + } +} + shared_ptr XdmfCurvilinearGrid::getDimensions() { @@ -241,7 +283,7 @@ XdmfCurvilinearGrid::getDimensions() shared_ptr XdmfCurvilinearGrid::getDimensions() const { - return mImpl->mDimensions; + return ((XdmfCurvilinearGridImpl *)mImpl)->mDimensions; } shared_ptr @@ -264,20 +306,160 @@ XdmfCurvilinearGrid::populateItem(const std::map & ite ++iter) { if(shared_ptr curvilinearGrid = shared_dynamic_cast(*iter)) { - mImpl->mDimensions = curvilinearGrid->getDimensions(); + ((XdmfCurvilinearGridImpl *)mImpl)->mDimensions = curvilinearGrid->getDimensions(); + } + } +} + +void +XdmfCurvilinearGrid::read() +{ + if (mGridController) + { + if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + // Copy stucture from read grid to this grid + copyGrid(grid); + } + else if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + XdmfError::message(XdmfError::FATAL, "Error: Grid Type Mismatch"); + } + else + { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Grid Reference"); } } } +void +XdmfCurvilinearGrid::release() +{ + XdmfGrid::release(); + this->setGeometry(shared_ptr()); + this->setDimensions(shared_ptr()); +} + void XdmfCurvilinearGrid::setDimensions(const shared_ptr dimensions) { - mImpl->mDimensions = dimensions; + ((XdmfCurvilinearGridImpl *)mImpl)->mDimensions = dimensions; + this->setIsChanged(true); } void XdmfCurvilinearGrid::setGeometry(const shared_ptr geometry) { mGeometry = geometry; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFCURVILINEARGRID * XdmfCurvilinearGridNew2D(unsigned int xNumPoints, + unsigned int yNumPoints) +{ + try + { + shared_ptr generatedGrid = XdmfCurvilinearGrid::New(xNumPoints, yNumPoints); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*generatedGrid.get())))); + } + catch (...) + { + shared_ptr generatedGrid = XdmfCurvilinearGrid::New(xNumPoints, yNumPoints); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*generatedGrid.get())))); + } +} + +XDMFCURVILINEARGRID * XdmfCurvilinearGridNew3D(unsigned int xNumPoints, + unsigned int yNumPoints, + unsigned int zNumPoints) +{ + try + { + shared_ptr generatedGrid = XdmfCurvilinearGrid::New(xNumPoints, yNumPoints, zNumPoints); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*generatedGrid.get())))); + } + catch (...) + { + shared_ptr generatedGrid = XdmfCurvilinearGrid::New(xNumPoints, yNumPoints, zNumPoints); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*generatedGrid.get())))); + } +} + +XDMFCURVILINEARGRID * XdmfCurvilinearGridNew(XDMFARRAY * numPoints, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + shared_ptr tempArray = shared_ptr((XdmfArray *)numPoints, XdmfNullDeleter()); + shared_ptr generatedGrid = XdmfCurvilinearGrid::New(tempArray); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*generatedGrid.get())))); + } + catch (...) + { + shared_ptr tempArray = shared_ptr((XdmfArray *)numPoints, XdmfNullDeleter()); + shared_ptr generatedGrid = XdmfCurvilinearGrid::New(tempArray); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*generatedGrid.get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfCurvilinearGridGetDimensions(XDMFCURVILINEARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfCurvilinearGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedArray = gridPointer->getDimensions(); + return (XDMFARRAY *)((void *)generatedArray.get()); + } + catch (...) + { + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfCurvilinearGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedArray = gridPointer->getDimensions(); + return (XDMFARRAY *)((void *)generatedArray.get()); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFGEOMETRY * XdmfCurvilinearGridGetGeometry(XDMFCURVILINEARGRID * grid) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfCurvilinearGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedGeometry = gridPointer->getGeometry(); + return (XDMFGEOMETRY *)((void *)generatedGeometry.get()); +} + +void XdmfCurvilinearGridSetDimensions(XDMFCURVILINEARGRID * grid, XDMFARRAY * dimensions, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfCurvilinearGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setDimensions(shared_ptr((XdmfArray *)dimensions)); + } + else { + gridPointer->setDimensions(shared_ptr((XdmfArray *)dimensions, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfCurvilinearGridSetGeometry(XDMFCURVILINEARGRID * grid, XDMFGEOMETRY * geometry, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfCurvilinearGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setGeometry(shared_ptr((XdmfGeometry *)geometry)); + } + else { + gridPointer->setGeometry(shared_ptr((XdmfGeometry *)geometry, XdmfNullDeleter())); + } } +XDMF_ITEM_C_CHILD_WRAPPER(XdmfCurvilinearGrid, XDMFCURVILINEARGRID) +XDMF_GRID_C_CHILD_WRAPPER(XdmfCurvilinearGrid, XDMFCURVILINEARGRID) diff --git a/XdmfCurvilinearGrid.hpp b/XdmfCurvilinearGrid.hpp index 2dd03a2e..5b3dd32a 100644 --- a/XdmfCurvilinearGrid.hpp +++ b/XdmfCurvilinearGrid.hpp @@ -24,13 +24,15 @@ #ifndef XDMFCURVILINEARGRID_HPP_ #define XDMFCURVILINEARGRID_HPP_ -// Forward Declarations -class XdmfArray; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfGrid.hpp" +#ifdef __cplusplus + +// Forward Declarations +class XdmfArray; + /** * @brief A curvilinear (or structured) grid consisting of cells and * points arranged on a regular lattice in space. @@ -220,6 +222,10 @@ public: */ shared_ptr getGeometry(); + virtual void read(); + + virtual void release(); + /** * Set the dimensions of the grid, the number of points in each * direction. @@ -275,6 +281,8 @@ public: */ void setGeometry(const shared_ptr geometry); + XdmfCurvilinearGrid(XdmfCurvilinearGrid &); + protected: XdmfCurvilinearGrid(const shared_ptr numPoints); @@ -290,12 +298,11 @@ private: * PIMPL */ class XdmfCurvilinearGridImpl; - - XdmfCurvilinearGrid(const XdmfCurvilinearGrid &); // Not implemented. + XdmfCurvilinearGrid(const XdmfCurvilinearGrid &); // Not implemented. void operator=(const XdmfCurvilinearGrid &); // Not implemented. - XdmfCurvilinearGridImpl * mImpl; - + void + copyGrid(shared_ptr sourceGrid); }; #ifdef _WIN32 @@ -307,4 +314,39 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFCURVILINEARGRID; // Simply as a typedef to ensure correct typing +typedef struct XDMFCURVILINEARGRID XDMFCURVILINEARGRID; + +XDMF_EXPORT XDMFCURVILINEARGRID * XdmfCurvilinearGridNew2D(unsigned int xNumPoints, + unsigned int yNumPoints); + +XDMF_EXPORT XDMFCURVILINEARGRID * XdmfCurvilinearGridNew3D(unsigned int xNumPoints, + unsigned int yNumPoints, + unsigned int zNumPoints); + +XDMF_EXPORT XDMFCURVILINEARGRID * XdmfCurvilinearGridNew(XDMFARRAY * numPoints, int * status); + +XDMF_EXPORT XDMFARRAY * XdmfCurvilinearGridGetDimensions(XDMFCURVILINEARGRID * grid, int * status); + +XDMF_EXPORT XDMFGEOMETRY * XdmfCurvilinearGridGetGeometry(XDMFCURVILINEARGRID * grid); + +XDMF_EXPORT void XdmfCurvilinearGridSetDimensions(XDMFCURVILINEARGRID * grid, XDMFARRAY * dimensions, int passControl, int * status); + +XDMF_EXPORT void XdmfCurvilinearGridSetGeometry(XDMFCURVILINEARGRID * grid, XDMFGEOMETRY * geometry, int passControl); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfCurvilinearGrid, XDMFCURVILINEARGRID, XDMF) +XDMF_GRID_C_CHILD_DECLARE(XdmfCurvilinearGrid, XDMFCURVILINEARGRID, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFCURVILINEARGRID_HPP_ */ diff --git a/XdmfDomain.cpp b/XdmfDomain.cpp index c68550fa..a2ba9ff0 100644 --- a/XdmfDomain.cpp +++ b/XdmfDomain.cpp @@ -29,6 +29,12 @@ #include "XdmfRegularGrid.hpp" #include "XdmfUnstructuredGrid.hpp" +#ifdef XDMF_BUILD_DSM + #include "XdmfDSMBuffer.hpp" + #include "XdmfDSMDriver.hpp" + #include "XdmfDSMDescription.hpp" +#endif + XDMF_CHILDREN_IMPLEMENTATION(XdmfDomain, XdmfGridCollection, GridCollection, @@ -65,6 +71,17 @@ XdmfDomain::XdmfDomain() { } +XdmfDomain::XdmfDomain(XdmfDomain & refDomain) : + XdmfItem(refDomain), + mGridCollections(refDomain.mGridCollections), + mGraphs(refDomain.mGraphs), + mCurvilinearGrids(refDomain.mCurvilinearGrids), + mRectilinearGrids(refDomain.mRectilinearGrids), + mRegularGrids(refDomain.mRegularGrids), + mUnstructuredGrids(refDomain.mUnstructuredGrids) +{ +} + XdmfDomain::~XdmfDomain() { } @@ -124,41 +141,343 @@ XdmfDomain::populateItem(const std::map & itemProperti void XdmfDomain::traverse(const shared_ptr visitor) { +#ifdef XDMF_BUILD_DSM + // Traverse Data Descriptions before anything + XdmfDSMBuffer * dsmBuffer = (XdmfDSMBuffer *)xdmf_dsm_get_manager(); + + if (dsmBuffer) + { + shared_ptr dsmDescription; + dsmDescription = XdmfDSMDescription::New(); + dsmDescription->setPortDescription(dsmBuffer->GetComm()->GetDsmPortName()); + + dsmDescription->accept(visitor); + } +#endif + XdmfItem::traverse(visitor); - for(std::vector >::const_iterator iter = - mGridCollections.begin(); - iter != mGridCollections.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mGridCollections.size(); ++i) + { + mGridCollections[i]->accept(visitor); } - for(std::vector >::const_iterator iter = - mCurvilinearGrids.begin(); - iter != mCurvilinearGrids.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mCurvilinearGrids.size(); ++i) + { + mCurvilinearGrids[i]->accept(visitor); } - for(std::vector >::const_iterator iter = - mGraphs.begin(); - iter != mGraphs.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mGraphs.size(); ++i) + { + mGraphs[i]->accept(visitor); } - for(std::vector >::const_iterator iter = - mRectilinearGrids.begin(); - iter != mRectilinearGrids.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mRectilinearGrids.size(); ++i) + { + mRectilinearGrids[i]->accept(visitor); } - for(std::vector >::const_iterator iter = - mRegularGrids.begin(); - iter != mRegularGrids.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mRegularGrids.size(); ++i) + { + mRegularGrids[i]->accept(visitor); } - for(std::vector >::const_iterator iter = - mUnstructuredGrids.begin(); - iter != mUnstructuredGrids.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mUnstructuredGrids.size(); ++i) + { + mUnstructuredGrids[i]->accept(visitor); + } +} + +// C Wrappers + +XDMFDOMAIN * XdmfDomainNew() +{ + try + { + shared_ptr generatedDomain = XdmfDomain::New(); + return (XDMFDOMAIN *)((void *)((XdmfItem *)(new XdmfDomain(*generatedDomain.get())))); + } + catch (...) + { + shared_ptr generatedDomain = XdmfDomain::New(); + return (XDMFDOMAIN *)((void *)((XdmfItem *)(new XdmfDomain(*generatedDomain.get())))); + } +} + +XDMFGRIDCOLLECTION * XdmfDomainGetGridCollection(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFGRIDCOLLECTION *)((void *)((XdmfItem *)(domainPointer->getGridCollection(index).get()))); +} + +XDMFGRIDCOLLECTION * XdmfDomainGetGridCollectionByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFGRIDCOLLECTION *)((void *)((XdmfItem *)(domainPointer->getGridCollection(Name).get()))); +} + +unsigned int XdmfDomainGetNumberGridCollections(XDMFDOMAIN * domain) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return domainPointer->getNumberGridCollections(); +} + +void XdmfDomainInsertGridCollection(XDMFDOMAIN * domain, XDMFGRIDCOLLECTION * GridCollection, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + if (passControl) { + domainPointer->insert(shared_ptr((XdmfGridCollection *)GridCollection)); + } + else { + domainPointer->insert(shared_ptr((XdmfGridCollection *)GridCollection, XdmfNullDeleter())); } } + +void XdmfDomainRemoveGridCollection(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeGridCollection(index); +} + +void XdmfDomainRemoveGridCollectionByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeGridCollection(Name); +} + +XDMFGRAPH * XdmfDomainGetGraph(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFGRAPH *)((void *)(domainPointer->getGraph(index).get())); +} + +XDMFGRAPH * XdmfDomainGetGraphByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFGRAPH *)((void *)(domainPointer->getGraph(Name).get())); +} + +unsigned int XdmfDomainGetNumberGraphs(XDMFDOMAIN * domain) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return domainPointer->getNumberGraphs(); +} + +void XdmfDomainInsertGraph(XDMFDOMAIN * domain, XDMFGRAPH * Graph, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + if (passControl) { + domainPointer->insert(shared_ptr((XdmfGraph *)Graph)); + } + else { + domainPointer->insert(shared_ptr((XdmfGraph *)Graph, XdmfNullDeleter())); + } +} + +void XdmfDomainRemoveGraph(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeGraph(index); +} + +void XdmfDomainRemoveGraphByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeGraph(Name); +} + +XDMFCURVILINEARGRID * XdmfDomainGetCurvilinearGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(domainPointer->getCurvilinearGrid(index).get()))); +} + +XDMFCURVILINEARGRID * XdmfDomainGetCurvilinearGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFCURVILINEARGRID *)((void *)((XdmfItem *)(domainPointer->getCurvilinearGrid(Name).get()))); +} + +unsigned int XdmfDomainGetNumberCurvilinearGrids(XDMFDOMAIN * domain) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return domainPointer->getNumberCurvilinearGrids(); +} + +void XdmfDomainInsertCurvilinearGrid(XDMFDOMAIN * domain, XDMFCURVILINEARGRID * CurvilinearGrid, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + if (passControl) { + domainPointer->insert(shared_ptr((XdmfCurvilinearGrid *)CurvilinearGrid)); + } + else { + domainPointer->insert(shared_ptr((XdmfCurvilinearGrid *)CurvilinearGrid, XdmfNullDeleter())); + } +} + +void XdmfDomainRemoveCurvilinearGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeCurvilinearGrid(index); +} + +void XdmfDomainRemoveCurvilinearGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeCurvilinearGrid(Name); +} + +XDMFRECTILINEARGRID * XdmfDomainGetRectilinearGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(domainPointer->getRectilinearGrid(index).get()))); +} + +XDMFRECTILINEARGRID * XdmfDomainGetRectilinearGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(domainPointer->getRectilinearGrid(Name).get()))); +} + +unsigned int XdmfDomainGetNumberRectilinearGrids(XDMFDOMAIN * domain) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return domainPointer->getNumberRectilinearGrids(); +} + +void XdmfDomainInsertRectilinearGrid(XDMFDOMAIN * domain, XDMFRECTILINEARGRID * RectilinearGrid, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + if (passControl) { + domainPointer->insert(shared_ptr((XdmfRectilinearGrid *)RectilinearGrid)); + } + else { + domainPointer->insert(shared_ptr((XdmfRectilinearGrid *)RectilinearGrid, XdmfNullDeleter())); + } +} + +void XdmfDomainRemoveRectilinearGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeRectilinearGrid(index); +} + +void XdmfDomainRemoveRectilinearGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeRectilinearGrid(Name); +} + +XDMFREGULARGRID * XdmfDomainGetRegularGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(domainPointer->getRegularGrid(index).get()))); +} + +XDMFREGULARGRID * XdmfDomainGetRegularGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(domainPointer->getRegularGrid(Name).get()))); +} + +unsigned int XdmfDomainGetNumberRegularGrids(XDMFDOMAIN * domain) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return domainPointer->getNumberRegularGrids(); +} + +void XdmfDomainInsertRegularGrid(XDMFDOMAIN * domain, XDMFREGULARGRID * RegularGrid, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + if (passControl) { + domainPointer->insert(shared_ptr((XdmfRegularGrid *)RegularGrid)); + } + else { + domainPointer->insert(shared_ptr((XdmfRegularGrid *)RegularGrid, XdmfNullDeleter())); + } +} + +void XdmfDomainRemoveRegularGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeRegularGrid(index); +} + +void XdmfDomainRemoveRegularGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeRegularGrid(Name); +} + +XDMFUNSTRUCTUREDGRID * XdmfDomainGetUnstructuredGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFUNSTRUCTUREDGRID *)((void *)((XdmfItem *)(domainPointer->getUnstructuredGrid(index).get()))); +} + +XDMFUNSTRUCTUREDGRID * XdmfDomainGetUnstructuredGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return (XDMFUNSTRUCTUREDGRID *)((void *)((XdmfItem *)(domainPointer->getUnstructuredGrid(Name).get()))); +} + +unsigned int XdmfDomainGetNumberUnstructuredGrids(XDMFDOMAIN * domain) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + return domainPointer->getNumberUnstructuredGrids(); +} + +void XdmfDomainInsertUnstructuredGrid(XDMFDOMAIN * domain, XDMFUNSTRUCTUREDGRID * UnstructuredGrid, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + if (passControl) { + domainPointer->insert(shared_ptr((XdmfUnstructuredGrid *)UnstructuredGrid)); + } + else { + domainPointer->insert(shared_ptr((XdmfUnstructuredGrid *)UnstructuredGrid, XdmfNullDeleter())); + } +} + +void XdmfDomainRemoveUnstructuredGrid(XDMFDOMAIN * domain, unsigned int index) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeUnstructuredGrid(index); +} + +void XdmfDomainRemoveUnstructuredGridByName(XDMFDOMAIN * domain, char * Name) +{ + XdmfItem * classedPointer = (XdmfItem *)domain; + XdmfDomain * domainPointer = dynamic_cast(classedPointer); + domainPointer->removeUnstructuredGrid(Name); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfDomain, XDMFDOMAIN) diff --git a/XdmfDomain.hpp b/XdmfDomain.hpp index c336c77a..2e79281c 100644 --- a/XdmfDomain.hpp +++ b/XdmfDomain.hpp @@ -24,17 +24,19 @@ #ifndef XDMFDOMAIN_HPP_ #define XDMFDOMAIN_HPP_ -// Forward Declarations -class XdmfCurvilinearGrid; -class XdmfGraph; -class XdmfGridCollection; -class XdmfRectilinearGrid; -class XdmfRegularGrid; -class XdmfUnstructuredGrid; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfItem.hpp" +#include "XdmfCurvilinearGrid.hpp" +#include "XdmfGraph.hpp" +#include "XdmfRectilinearGrid.hpp" +#include "XdmfRegularGrid.hpp" +#include "XdmfUnstructuredGrid.hpp" + +#ifdef __cplusplus + +// Forward Declarations +class XdmfGridCollection; /** * @brief The root XdmfItem that holds XdmfGrids. @@ -87,6 +89,8 @@ public: virtual void traverse(const shared_ptr visitor); + XdmfDomain(XdmfDomain &); + protected: XdmfDomain(); @@ -130,4 +134,323 @@ std::vector, std::allocator > >; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFDOMAIN; // Simply as a typedef to ensure correct typing +typedef struct XDMFDOMAIN XDMFDOMAIN; + +#ifndef XDMFGRIDCOLLECTIONCDEFINE +#define XDMFGRIDCOLLECTIONCDEFINE +struct XDMFGRIDCOLLECTION; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRIDCOLLECTION XDMFGRIDCOLLECTION; +#endif + +XDMF_EXPORT XDMFDOMAIN * XdmfDomainNew(); + +XDMF_EXPORT XDMFGRIDCOLLECTION * XdmfDomainGetGridCollection(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT XDMFGRIDCOLLECTION * XdmfDomainGetGridCollectionByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT unsigned int XdmfDomainGetNumberGridCollections(XDMFDOMAIN * domain); + +XDMF_EXPORT void XdmfDomainInsertGridCollection(XDMFDOMAIN * domain, XDMFGRIDCOLLECTION * GridCollection, int passControl); + +XDMF_EXPORT void XdmfDomainRemoveGridCollection(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT void XdmfDomainRemoveGridCollectionByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT XDMFGRAPH * XdmfDomainGetGraph(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT XDMFGRAPH * XdmfDomainGetGraphByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT unsigned int XdmfDomainGetNumberGraphs(XDMFDOMAIN * domain); + +XDMF_EXPORT void XdmfDomainInsertGraph(XDMFDOMAIN * domain, XDMFGRAPH * graph, int passControl); + +XDMF_EXPORT void XdmfDomainRemoveGraph(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT void XdmfDomainRemoveGraphByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT XDMFCURVILINEARGRID * XdmfDomainGetCurvilinearGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT XDMFCURVILINEARGRID * XdmfDomainGetCurvilinearGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT unsigned int XdmfDomainGetNumberCurvilinearGrids(XDMFDOMAIN * domain); + +XDMF_EXPORT void XdmfDomainInsertCurvilinearGrid(XDMFDOMAIN * domain, XDMFCURVILINEARGRID * CurvilinearGrid, int passControl); + +XDMF_EXPORT void XdmfDomainRemoveCurvilinearGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT void XdmfDomainRemoveCurvilinearGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT XDMFRECTILINEARGRID * XdmfDomainGetRectilinearGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT XDMFRECTILINEARGRID * XdmfDomainGetRectilinearGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT unsigned int XdmfDomainGetNumberRectilinearGrids(XDMFDOMAIN * domain); + +XDMF_EXPORT void XdmfDomainInsertRectilinearGrid(XDMFDOMAIN * domain, XDMFRECTILINEARGRID * RectilinearGrid, int passControl); + +XDMF_EXPORT void XdmfDomainRemoveRectilinearGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT void XdmfDomainRemoveRectilinearGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT XDMFREGULARGRID * XdmfDomainGetRegularGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT XDMFREGULARGRID * XdmfDomainGetRegularGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT unsigned int XdmfDomainGetNumberRegularGrids(XDMFDOMAIN * domain); + +XDMF_EXPORT void XdmfDomainInsertRegularGrid(XDMFDOMAIN * domain, XDMFREGULARGRID * RegularGrid, int passControl); + +XDMF_EXPORT void XdmfDomainRemoveRegularGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT void XdmfDomainRemoveRegularGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT XDMFUNSTRUCTUREDGRID * XdmfDomainGetUnstructuredGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT XDMFUNSTRUCTUREDGRID * XdmfDomainGetUnstructuredGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_EXPORT unsigned int XdmfDomainGetNumberUnstructuredGrids(XDMFDOMAIN * domain); + +XDMF_EXPORT void XdmfDomainInsertUnstructuredGrid(XDMFDOMAIN * domain, XDMFUNSTRUCTUREDGRID * UnstructuredGrid, int passControl); + +XDMF_EXPORT void XdmfDomainRemoveUnstructuredGrid(XDMFDOMAIN * domain, unsigned int index); + +XDMF_EXPORT void XdmfDomainRemoveUnstructuredGridByName(XDMFDOMAIN * domain, char * Name); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfDomain, XDMFDOMAIN, XDMF) + +#define XDMF_DOMAIN_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT XDMFGRIDCOLLECTION * ClassName##GetGridCollection(CClassName * domain, unsigned int index); \ +Level##_EXPORT XDMFGRIDCOLLECTION * ClassName##GetGridCollectionByName(CClassName * domain, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberGridCollections(CClassName * domain); \ +Level##_EXPORT void ClassName##InsertGridCollection(CClassName * domain, XDMFGRIDCOLLECTION * GridCollection, int passControl); \ +Level##_EXPORT void ClassName##RemoveGridCollection(CClassName * domain, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveGridCollectionByName(CClassName * domain, char * Name); \ +Level##_EXPORT XDMFGRAPH * ClassName##GetGraph(CClassName * domain, unsigned int index); \ +Level##_EXPORT XDMFGRAPH * ClassName##GetGraphByName(CClassName * domain, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberGraphs(CClassName * domain); \ +Level##_EXPORT void ClassName##InsertGraph(CClassName * domain, XDMFGRAPH * Graph, int passControl); \ +Level##_EXPORT void ClassName##RemoveGraph(CClassName * domain, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveGraphByName(CClassName * domain, char * Name); \ +Level##_EXPORT XDMFCURVILINEARGRID * ClassName##GetCurvilinearGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT XDMFCURVILINEARGRID * ClassName##GetCurvilinearGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberCurvilinearGrids(CClassName * domain); \ +Level##_EXPORT void ClassName##InsertCurvilinearGrid(CClassName * domain, XDMFCURVILINEARGRID * CurvilinearGrid, int passControl); \ +Level##_EXPORT void ClassName##RemoveCurvilinearGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveCurvilinearGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT XDMFRECTILINEARGRID * ClassName##GetRectilinearGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT XDMFRECTILINEARGRID * ClassName##GetRectilinearGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberRectilinearGrids(CClassName * domain); \ +Level##_EXPORT void ClassName##InsertRectilinearGrid(CClassName * domain, XDMFRECTILINEARGRID * RectilinearGrid, int passControl); \ +Level##_EXPORT void ClassName##RemoveRectilinearGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveRectilinearGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT XDMFREGULARGRID * ClassName##GetRegularGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT XDMFREGULARGRID * ClassName##GetRegularGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberRegularGrids(CClassName * domain); \ +Level##_EXPORT void ClassName##InsertRegularGrid(CClassName * domain, XDMFREGULARGRID * RegularGrid, int passControl); \ +Level##_EXPORT void ClassName##RemoveRegularGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveRegularGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT XDMFUNSTRUCTUREDGRID * ClassName##GetUnstructuredGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT XDMFUNSTRUCTUREDGRID * ClassName##GetUnstructuredGridByName(CClassName * domain, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberUnstructuredGrids(CClassName * domain); \ +Level##_EXPORT void ClassName##InsertUnstructuredGrid(CClassName * domain, XDMFUNSTRUCTUREDGRID * UnstructuredGrid, int passControl); \ +Level##_EXPORT void ClassName##RemoveUnstructuredGrid(CClassName * domain, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveUnstructuredGridByName(CClassName * domain, char * Name); + + +#define XDMF_DOMAIN_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +XDMFGRIDCOLLECTION * ClassName##GetGridCollection(CClassName * domain, unsigned int index) \ +{ \ + return XdmfDomainGetGridCollection((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +XDMFGRIDCOLLECTION * ClassName##GetGridCollectionByName(CClassName * domain, char * Name) \ +{ \ + return XdmfDomainGetGridCollectionByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +unsigned int ClassName##GetNumberGridCollections(CClassName * domain) \ +{ \ + return XdmfDomainGetNumberGridCollections((XDMFDOMAIN *)((void *)domain)); \ +} \ + \ +void ClassName##InsertGridCollection(CClassName * domain, XDMFGRIDCOLLECTION * GridCollection, int passControl) \ +{ \ + XdmfDomainInsertGridCollection((XDMFDOMAIN *)((void *)domain), GridCollection, passControl); \ +} \ + \ +void ClassName##RemoveGridCollection(CClassName * domain, unsigned int index) \ +{ \ + XdmfDomainRemoveGridCollection((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +void ClassName##RemoveGridCollectionByName(CClassName * domain, char * Name) \ +{ \ + XdmfDomainRemoveGridCollectionByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +XDMFGRAPH * ClassName##GetGraph(CClassName * domain, unsigned int index) \ +{ \ + return XdmfDomainGetGraph((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +XDMFGRAPH * ClassName##GetGraphByName(CClassName * domain, char * Name) \ +{ \ + return XdmfDomainGetGraphByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +unsigned int ClassName##GetNumberGraphs(CClassName * domain) \ +{ \ + return XdmfDomainGetNumberGraphs((XDMFDOMAIN *)((void *)domain)); \ +} \ + \ +void ClassName##InsertGraph(CClassName * domain, XDMFGRAPH * Graph, int passControl) \ +{ \ + XdmfDomainInsertGraph((XDMFDOMAIN *)((void *)domain), Graph, passControl); \ +} \ + \ +void ClassName##RemoveGraph(CClassName * domain, unsigned int index) \ +{ \ + XdmfDomainRemoveGraph((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +void ClassName##RemoveGraphByName(CClassName * domain, char * Name) \ +{ \ + XdmfDomainRemoveGraphByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +XDMFCURVILINEARGRID * ClassName##GetCurvilinearGrid(CClassName * domain, unsigned int index) \ +{ \ + return XdmfDomainGetCurvilinearGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +XDMFCURVILINEARGRID * ClassName##GetCurvilinearGridByName(CClassName * domain, char * Name) \ +{ \ + return XdmfDomainGetCurvilinearGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +unsigned int ClassName##GetNumberCurvilinearGrids(CClassName * domain) \ +{ \ + return XdmfDomainGetNumberCurvilinearGrids((XDMFDOMAIN *)((void *)domain)); \ +} \ + \ +void ClassName##InsertCurvilinearGrid(CClassName * domain, XDMFCURVILINEARGRID * CurvilinearGrid, int passControl) \ +{ \ + XdmfDomainInsertCurvilinearGrid((XDMFDOMAIN *)((void *)domain), CurvilinearGrid, passControl); \ +} \ + \ +void ClassName##RemoveCurvilinearGrid(CClassName * domain, unsigned int index) \ +{ \ + XdmfDomainRemoveCurvilinearGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +void ClassName##RemoveCurvilinearGridByName(CClassName * domain, char * Name) \ +{ \ + XdmfDomainRemoveCurvilinearGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +XDMFRECTILINEARGRID * ClassName##GetRectilinearGrid(CClassName * domain, unsigned int index) \ +{ \ + return XdmfDomainGetRectilinearGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +XDMFRECTILINEARGRID * ClassName##GetRectilinearGridByName(CClassName * domain, char * Name) \ +{ \ + return XdmfDomainGetRectilinearGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +unsigned int ClassName##GetNumberRectilinearGrids(CClassName * domain) \ +{ \ + return XdmfDomainGetNumberRectilinearGrids((XDMFDOMAIN *)((void *)domain)); \ +} \ + \ +void ClassName##InsertRectilinearGrid(CClassName * domain, XDMFRECTILINEARGRID * RectilinearGrid, int passControl) \ +{ \ + XdmfDomainInsertRectilinearGrid((XDMFDOMAIN *)((void *)domain), RectilinearGrid, passControl); \ +} \ + \ +void ClassName##RemoveRectilinearGrid(CClassName * domain, unsigned int index) \ +{ \ + XdmfDomainRemoveRectilinearGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +void ClassName##RemoveRectilinearGridByName(CClassName * domain, char * Name) \ +{ \ + XdmfDomainRemoveRectilinearGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +XDMFREGULARGRID * ClassName##GetRegularGrid(CClassName * domain, unsigned int index) \ +{ \ + return XdmfDomainGetRegularGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +XDMFREGULARGRID * ClassName##GetRegularGridByName(CClassName * domain, char * Name) \ +{ \ + return XdmfDomainGetRegularGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +unsigned int ClassName##GetNumberRegularGrids(CClassName * domain) \ +{ \ + return XdmfDomainGetNumberRegularGrids((XDMFDOMAIN *)((void *)domain)); \ +} \ + \ +void ClassName##InsertRegularGrid(CClassName * domain, XDMFREGULARGRID * RegularGrid, int passControl) \ +{ \ + XdmfDomainInsertRegularGrid((XDMFDOMAIN *)((void *)domain), RegularGrid, passControl); \ +} \ + \ +void ClassName##RemoveRegularGrid(CClassName * domain, unsigned int index) \ +{ \ + XdmfDomainRemoveRegularGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +void ClassName##RemoveRegularGridByName(CClassName * domain, char * Name) \ +{ \ + XdmfDomainRemoveRegularGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +XDMFUNSTRUCTUREDGRID * ClassName##GetUnstructuredGrid(CClassName * domain, unsigned int index) \ +{ \ + return XdmfDomainGetUnstructuredGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +XDMFUNSTRUCTUREDGRID * ClassName##GetUnstructuredGridByName(CClassName * domain, char * Name) \ +{ \ + return XdmfDomainGetUnstructuredGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} \ + \ +unsigned int ClassName##GetNumberUnstructuredGrids(CClassName * domain) \ +{ \ + return XdmfDomainGetNumberUnstructuredGrids((XDMFDOMAIN *)((void *)domain)); \ +} \ + \ +void ClassName##InsertUnstructuredGrid(CClassName * domain, XDMFUNSTRUCTUREDGRID * UnstructuredGrid, int passControl) \ +{ \ + XdmfDomainInsertUnstructuredGrid((XDMFDOMAIN *)((void *)domain), UnstructuredGrid, passControl); \ +} \ + \ +void ClassName##RemoveUnstructuredGrid(CClassName * domain, unsigned int index) \ +{ \ + XdmfDomainRemoveUnstructuredGrid((XDMFDOMAIN *)((void *)domain), index); \ +} \ + \ +void ClassName##RemoveUnstructuredGridByName(CClassName * domain, char * Name) \ +{ \ + XdmfDomainRemoveUnstructuredGridByName((XDMFDOMAIN *)((void *)domain), Name); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFDOMAIN_HPP_ */ diff --git a/XdmfGeometry.cpp b/XdmfGeometry.cpp index 72902efe..44fcfd45 100644 --- a/XdmfGeometry.cpp +++ b/XdmfGeometry.cpp @@ -25,6 +25,7 @@ #include "XdmfGeometryType.hpp" #include "XdmfError.hpp" #include "XdmfFunction.hpp" +#include shared_ptr XdmfGeometry::New() { @@ -39,6 +40,13 @@ XdmfGeometry::XdmfGeometry() : { } +XdmfGeometry::XdmfGeometry(XdmfGeometry & refGeometry) : + XdmfArray(refGeometry), + mType(refGeometry.mType), + mOrigin(refGeometry.mOrigin) +{ +} + XdmfGeometry::~XdmfGeometry() { } @@ -50,6 +58,14 @@ XdmfGeometry::getItemProperties() const { std::map geometryProperties; mType->getProperties(geometryProperties); + std::stringstream originstream; + for (unsigned int i = 0; i < mOrigin.size(); ++i) { + originstream << mOrigin[i]; + if (i + 1 < mOrigin.size()) { + originstream << " "; + } + } + geometryProperties["Origin"] = originstream.str(); return geometryProperties; } @@ -65,7 +81,16 @@ XdmfGeometry::getNumberPoints() const if(mType->getDimensions() == 0) { return 0; } - return this->getSize() / mType->getDimensions(); + else { + return this->getSize() / mType->getDimensions(); + } +} + +std::vector +XdmfGeometry::getOrigin() const +{ + std::vector returnVector(mOrigin); + return returnVector; } shared_ptr @@ -166,10 +191,163 @@ XdmfGeometry::populateItem(const std::map & itemProper "Neither 'Type' nor 'GeometryType' in itemProperties " "in XdmfGeometry::populateItem"); } + + std::map::const_iterator origin = + itemProperties.find("Origin"); + if (origin != itemProperties.end()) { + boost::tokenizer<> tokens(origin->second); + for(boost::tokenizer<>::const_iterator iter = tokens.begin(); + iter != tokens.end(); + ++iter) { + mOrigin.push_back(atof((*iter).c_str())); + } + } +} + +void +XdmfGeometry::setOrigin(double newX, double newY, double newZ) +{ + mOrigin.clear(); + mOrigin.push_back(newX); + mOrigin.push_back(newY); + mOrigin.push_back(newZ); + this->setIsChanged(true); +} + +void +XdmfGeometry::setOrigin(std::vector newOrigin) +{ + mOrigin.clear(); + for (unsigned int i = 0; i < newOrigin.size(); ++i) { + mOrigin.push_back(newOrigin[i]); + } + this->setIsChanged(true); } void XdmfGeometry::setType(const shared_ptr type) { mType = type; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFGEOMETRY * XdmfGeometryNew() +{ + try + { + shared_ptr generatedGeometry = XdmfGeometry::New(); + return (XDMFGEOMETRY *)((void *)(new XdmfGeometry(*generatedGeometry.get()))); + } + catch (...) + { + shared_ptr generatedGeometry = XdmfGeometry::New(); + return (XDMFGEOMETRY *)((void *)(new XdmfGeometry(*generatedGeometry.get()))); + } +} + +unsigned int XdmfGeometryGetNumberPoints(XDMFGEOMETRY * geometry) +{ + return ((XdmfGeometry *) geometry)->getNumberPoints(); } + +double * +XdmfGeometryGetOrigin(XDMFGEOMETRY * geometry) +{ + try + { + std::vector tempVector = ((XdmfGeometry *)(geometry))->getOrigin(); + unsigned int returnSize = tempVector.size(); + double * returnArray = new double[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfGeometry *)(geometry))->getOrigin(); + unsigned int returnSize = tempVector.size(); + double * returnArray = new double[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +int +XdmfGeometryGetOriginSize(XDMFGEOMETRY * geometry) +{ + return ((XdmfGeometry *) geometry)->getOrigin().size(); +} + +int XdmfGeometryGetType(XDMFGEOMETRY * geometry) +{ + if (((XdmfGeometry *) geometry)->getType() == XdmfGeometryType::NoGeometryType()) { + return XDMF_GEOMETRY_TYPE_NO_GEOMETRY_TYPE; + } + else if (((XdmfGeometry *) geometry)->getType() == XdmfGeometryType::XYZ()) { + return XDMF_GEOMETRY_TYPE_XYZ; + } + else if (((XdmfGeometry *) geometry)->getType() == XdmfGeometryType::XY()) { + return XDMF_GEOMETRY_TYPE_XY; + } + else if (((XdmfGeometry *) geometry)->getType() == XdmfGeometryType::Polar()) { + return XDMF_GEOMETRY_TYPE_POLAR; + } + else if (((XdmfGeometry *) geometry)->getType() == XdmfGeometryType::Spherical()) { + return XDMF_GEOMETRY_TYPE_SPHERICAL; + } + else { + return -1; + } +} + +void +XdmfGeometrySetOrigin(XDMFGEOMETRY * geometry, double newX, double newY, double newZ) +{ + ((XdmfGeometry *) geometry)->setOrigin(newX, newY, newZ); +} + +void +XdmfGeometrySetOriginArray(XDMFGEOMETRY * geometry, double * originVals, unsigned int numDims) +{ + std::vector originVector; + for (unsigned int i = 0; i < numDims; ++i) + { + originVector.push_back(originVals[i]); + } + ((XdmfGeometry *) geometry)->setOrigin(originVector); +} + +void XdmfGeometrySetType(XDMFGEOMETRY * geometry, int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (type) { + case XDMF_GEOMETRY_TYPE_NO_GEOMETRY_TYPE: + ((XdmfGeometry *) geometry)->setType(XdmfGeometryType::NoGeometryType()); + break; + case XDMF_GEOMETRY_TYPE_XYZ: + ((XdmfGeometry *) geometry)->setType(XdmfGeometryType::XYZ()); + break; + case XDMF_GEOMETRY_TYPE_XY: + ((XdmfGeometry *) geometry)->setType(XdmfGeometryType::XY()); + break; + case XDMF_GEOMETRY_TYPE_POLAR: + ((XdmfGeometry *) geometry)->setType(XdmfGeometryType::Polar()); + break; + case XDMF_GEOMETRY_TYPE_SPHERICAL: + ((XdmfGeometry *) geometry)->setType(XdmfGeometryType::Spherical()); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Geometry Type: Code " + type); + break; + } + XDMF_ERROR_WRAP_END(status) +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfGeometry, XDMFGEOMETRY) +XDMF_ARRAY_C_CHILD_WRAPPER(XdmfGeometry, XDMFGEOMETRY) diff --git a/XdmfGeometry.hpp b/XdmfGeometry.hpp index ccf3ed8d..d1cbf48d 100644 --- a/XdmfGeometry.hpp +++ b/XdmfGeometry.hpp @@ -24,12 +24,12 @@ #ifndef XDMFGEOMETRY_HPP_ #define XDMFGEOMETRY_HPP_ -// Forward Declarations -class XdmfGeometryType; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfArray.hpp" +#include "XdmfGeometryType.hpp" + +#ifdef __cplusplus /** * @brief Handles the coordinate positions of points in an XdmfGrid. @@ -96,6 +96,32 @@ public: */ virtual unsigned int getNumberPoints() const; + /** + * Gets the origin of the geometry. This value defaults to (0, 0, 0) + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGeometry.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getOrigin + * @until //#getOrigin + * + * Python + * + * @dontinclude XdmfExampleGeometry.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getOrigin + * @until #//getOrigin + * + * @return A vector containing the current location + * of the origin of this geometry + */ + std::vector getOrigin() const; + /** * Get the XdmfGeometryType associated with this geometry. * @@ -121,6 +147,35 @@ public: */ shared_ptr getType() const; + /** + * Sets the origin of the geometry. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGeometry.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setOrigin + * @until //#setOrigin + * + * Python + * + * @dontinclude XdmfExampleGeometry.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setOrigin + * @until #//setOrigin + * + * @param newX The new X value of the origin. + * @param newY The new Y value of the origin. + * @param newZ The new Z value of the origin. + */ + void setOrigin(double newX, double newY, double newZ = 0.0); + + void setOrigin(std::vector newOrigin); + /** * Set the XdmfGeometryType associated with this geometry. * @@ -146,6 +201,8 @@ public: */ void setType(const shared_ptr type); + XdmfGeometry(XdmfGeometry &); + protected: XdmfGeometry(); @@ -162,6 +219,8 @@ private: int mNumberPoints; shared_ptr mType; + + std::vector mOrigin; }; #ifdef _WIN32 @@ -169,4 +228,38 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFGEOMETRY; // Simply as a typedef to ensure correct typing +typedef struct XDMFGEOMETRY XDMFGEOMETRY; + +XDMF_EXPORT XDMFGEOMETRY * XdmfGeometryNew(); + +XDMF_EXPORT unsigned int XdmfGeometryGetNumberPoints(XDMFGEOMETRY * geometry); + +XDMF_EXPORT double * XdmfGeometryGetOrigin(XDMFGEOMETRY * geometry); + +XDMF_EXPORT int XdmfGeometryGetOriginSize(XDMFGEOMETRY * geometry); + +XDMF_EXPORT int XdmfGeometryGetType(XDMFGEOMETRY * geometry); + +XDMF_EXPORT void XdmfGeometrySetOrigin(XDMFGEOMETRY * geometry, double newX, double newY, double newZ); + +XDMF_EXPORT void XdmfGeometrySetOriginArray(XDMFGEOMETRY * geometry, double * originVals, unsigned int numDims); + +XDMF_EXPORT void XdmfGeometrySetType(XDMFGEOMETRY * geometry, int type, int * status); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfGeometry, XDMFGEOMETRY, XDMF) +XDMF_ARRAY_C_CHILD_DECLARE(XdmfGeometry, XDMFGEOMETRY, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFGEOMETRY_HPP_ */ diff --git a/XdmfGeometryType.cpp b/XdmfGeometryType.cpp index df4677a2..f6a8c54f 100644 --- a/XdmfGeometryType.cpp +++ b/XdmfGeometryType.cpp @@ -24,6 +24,9 @@ #include #include "XdmfGeometryType.hpp" #include "XdmfError.hpp" +#include "string.h" + +std::map(*)()> XdmfGeometryType::mGeometryDefinitions; // Supported XdmfGeometryTypes shared_ptr @@ -47,6 +50,30 @@ XdmfGeometryType::XY() return p; } +shared_ptr +XdmfGeometryType::Polar() +{ + static shared_ptr p(new XdmfGeometryType("Polar", 2)); + return p; +} + +shared_ptr +XdmfGeometryType::Spherical() +{ + static shared_ptr p(new XdmfGeometryType("Spherical", 3)); + return p; +} + +void +XdmfGeometryType::InitTypes() +{ + mGeometryDefinitions["NONE"] = NoGeometryType; + mGeometryDefinitions["XYZ"] = XYZ; + mGeometryDefinitions["XY"] = XY; + mGeometryDefinitions["POLAR"] = Polar; + mGeometryDefinitions["SPHERICAL"] = Spherical; +} + XdmfGeometryType::XdmfGeometryType(const std::string& name, const int& dimensions) : mDimensions(dimensions), @@ -61,6 +88,8 @@ XdmfGeometryType::~XdmfGeometryType() shared_ptr XdmfGeometryType::New(const std::map & itemProperties) { + InitTypes(); + std::map::const_iterator type = itemProperties.find("Type"); if(type == itemProperties.end()) { @@ -71,20 +100,20 @@ XdmfGeometryType::New(const std::map & itemProperties) "Neither 'Type' nor 'GeometryType' in itemProperties " "in XdmfGeometryType::New"); } - const std::string & typeVal = type->second; - if(typeVal.compare("None") == 0) { - return NoGeometryType(); - } - else if(typeVal.compare("XYZ") == 0) { - return XYZ(); - } - else if(typeVal.compare("XY") == 0) { - return XY(); - } + const std::string & typeVal = ConvertToUpper(type->second); + + std::map(*)()>::const_iterator returnType + = mGeometryDefinitions.find(typeVal); - XdmfError::message(XdmfError::FATAL, "Type not 'None', 'XYZ', or 'XY' " + if (returnType == mGeometryDefinitions.end()) { + XdmfError::message(XdmfError::FATAL, "Type " + + typeVal + " not Supported " "in XdmfGeometryType::New"); + } + else { + return (*(returnType->second))(); + } return shared_ptr(); } @@ -106,3 +135,105 @@ XdmfGeometryType::getProperties(std::map & collectedPr { collectedProperties.insert(std::make_pair("Type", mName)); } + +// C Wrappers + +int XdmfGeometryTypeNoGeometryType() +{ + return XDMF_GEOMETRY_TYPE_NO_GEOMETRY_TYPE; +} + +int XdmfGeometryTypeXYZ() +{ + return XDMF_GEOMETRY_TYPE_XYZ; +} + +int XdmfGeometryTypeXY() +{ + return XDMF_GEOMETRY_TYPE_XY; +} + +int XdmfGeometryTypePolar() +{ + return XDMF_GEOMETRY_TYPE_POLAR; +} + +int XdmfGeometryTypeSpherical() +{ + return XDMF_GEOMETRY_TYPE_SPHERICAL; +} + +unsigned int XdmfGeometryTypeGetDimensions(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (type) { + case XDMF_GEOMETRY_TYPE_NO_GEOMETRY_TYPE: + return XdmfGeometryType::NoGeometryType()->getDimensions(); + break; + case XDMF_GEOMETRY_TYPE_XYZ: + return XdmfGeometryType::XYZ()->getDimensions(); + break; + case XDMF_GEOMETRY_TYPE_XY: + return XdmfGeometryType::XY()->getDimensions(); + break; + case XDMF_GEOMETRY_TYPE_POLAR: + return XdmfGeometryType::Polar()->getDimensions(); + break; + case XDMF_GEOMETRY_TYPE_SPHERICAL: + return XdmfGeometryType::Spherical()->getDimensions(); + break; + default: + try { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Geometry Type: Code " + type); + } + catch (XdmfError & e) { + throw e; + } + break; + } + XDMF_ERROR_WRAP_END(status) + return 0; +} + +char * XdmfGeometryTypeGetName(int type) +{ + switch (type) { + case XDMF_GEOMETRY_TYPE_NO_GEOMETRY_TYPE: + { + char * returnPointer = strdup(XdmfGeometryType::NoGeometryType()->getName().c_str()); + return returnPointer; + break; + } + case XDMF_GEOMETRY_TYPE_XYZ: + { + char * returnPointer = strdup(XdmfGeometryType::XYZ()->getName().c_str()); + return returnPointer; + break; + } + case XDMF_GEOMETRY_TYPE_XY: + { + char * returnPointer = strdup(XdmfGeometryType::XY()->getName().c_str()); + return returnPointer; + break; + } + case XDMF_GEOMETRY_TYPE_POLAR: + { + char * returnPointer = strdup(XdmfGeometryType::Polar()->getName().c_str()); + return returnPointer; + break; + } + case XDMF_GEOMETRY_TYPE_SPHERICAL: + { + char * returnPointer = strdup(XdmfGeometryType::Spherical()->getName().c_str()); + return returnPointer; + break; + } + default: + { + char * returnPointer = NULL; + return returnPointer; + break; + } + } +} diff --git a/XdmfGeometryType.hpp b/XdmfGeometryType.hpp index df4ff317..fa6e429f 100644 --- a/XdmfGeometryType.hpp +++ b/XdmfGeometryType.hpp @@ -24,9 +24,14 @@ #ifndef XDMFGEOMETRYTYPE_HPP_ #define XDMFGEOMETRYTYPE_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" + +#ifdef __cplusplus + +// Includes #include "XdmfItemProperty.hpp" +#include /** * @brief Property describing the types of coordinate values stored in @@ -57,6 +62,13 @@ * NoGeometryType * XYZ * XY + * Polar + * Spherical + * + * The Polar and Spherical types consist of a series of coordinates. + * These coordinates are in order of: radius, polar, azimuthal. + * In accordance with the ISO standard. + * */ class XDMF_EXPORT XdmfGeometryType : public XdmfItemProperty { @@ -70,6 +82,8 @@ public: static shared_ptr NoGeometryType(); static shared_ptr XYZ(); static shared_ptr XY(); + static shared_ptr Polar(); + static shared_ptr Spherical(); /** * Get the dimensions of this geometry type - i.e. XYZ = 3. @@ -129,6 +143,10 @@ protected: */ XdmfGeometryType(const std::string & name, const int & dimensions); + static std::map(*)()> mGeometryDefinitions; + + static void InitTypes(); + private: XdmfGeometryType(const XdmfGeometryType &); // Not implemented. @@ -141,4 +159,32 @@ private: std::string mName; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_GEOMETRY_TYPE_NO_GEOMETRY_TYPE 300 +#define XDMF_GEOMETRY_TYPE_XYZ 301 +#define XDMF_GEOMETRY_TYPE_XY 302 +#define XDMF_GEOMETRY_TYPE_POLAR 303 +#define XDMF_GEOMETRY_TYPE_SPHERICAL 304 + +XDMF_EXPORT int XdmfGeometryTypeNoGeometryType(); +XDMF_EXPORT int XdmfGeometryTypeXYZ(); +XDMF_EXPORT int XdmfGeometryTypeXY(); +XDMF_EXPORT int XdmfGeometryTypePolar(); +XDMF_EXPORT int XdmfGeometryTypeSpherical(); + +XDMF_EXPORT unsigned int XdmfGeometryTypeGetDimensions(int type, int * status); + +XDMF_EXPORT char * XdmfGeometryTypeGetName(int type); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFGEOMETRYTYPE_HPP_ */ diff --git a/XdmfGraph.cpp b/XdmfGraph.cpp index c102c2b6..fc3ae232 100644 --- a/XdmfGraph.cpp +++ b/XdmfGraph.cpp @@ -40,6 +40,13 @@ XdmfGraph::XdmfGraph(const unsigned int numberNodes) : { } +XdmfGraph::XdmfGraph(XdmfGraph & refGraph) : + XdmfSparseMatrix(refGraph), + mAttributes(refGraph.mAttributes), + mTime(refGraph.mTime) +{ +} + XdmfGraph::~XdmfGraph() { } @@ -95,16 +102,74 @@ void XdmfGraph::setTime(const shared_ptr time) { mTime = time; + this->setIsChanged(true); } void XdmfGraph::traverse(const shared_ptr visitor) { XdmfSparseMatrix::traverse(visitor); - for(std::vector >::const_iterator iter = - mAttributes.begin(); - iter != mAttributes.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mAttributes.size(); ++i) + { + mAttributes[i]->accept(visitor); + } +} + +// C Wrappers + +XDMFGRAPH * XdmfGraphNew(unsigned int numberNodes) +{ + try + { + shared_ptr generatedGraph = XdmfGraph::New(numberNodes); + return (XDMFGRAPH *)((void *)(new XdmfGraph(*generatedGraph.get()))); + } + catch (...) + { + shared_ptr generatedGraph = XdmfGraph::New(numberNodes); + return (XDMFGRAPH *)((void *)(new XdmfGraph(*generatedGraph.get()))); + } +} + +XDMFATTRIBUTE * XdmfGraphGetAttribute(XDMFGRAPH * graph, unsigned int index) +{ + return (XDMFATTRIBUTE *)((void *)(((XdmfGraph *)(graph))->getAttribute(index).get())); +} + +XDMFATTRIBUTE * XdmfGraphGetAttributeByName(XDMFGRAPH * graph, char * Name) +{ + return (XDMFATTRIBUTE *)((void *)(((XdmfGraph *)(graph))->getAttribute(std::string(Name)).get())); +} + +unsigned int XdmfGraphGetNumberAttributes(XDMFGRAPH * graph) +{ + return ((XdmfGraph *)graph)->getNumberAttributes(); +} + +void XdmfGraphInsertAttribute(XDMFGRAPH * graph, XDMFATTRIBUTE * Attribute, int passControl) +{ + if (passControl) { + ((XdmfGraph *)(graph))->insert(shared_ptr((XdmfAttribute *)Attribute)); + } + else { + ((XdmfGraph *)(graph))->insert(shared_ptr((XdmfAttribute *)Attribute, XdmfNullDeleter())); } } + +void XdmfGraphRemoveAttribute(XDMFGRAPH * graph, unsigned int index) +{ + ((XdmfGraph *)graph)->removeAttribute(index); +} + +void XdmfGraphRemoveAttributeByName(XDMFGRAPH * graph, char * Name) +{ + ((XdmfGraph *)graph)->removeAttribute(std::string(Name)); +} + +unsigned int XdmfGraphGetNumberNodes(XDMFGRAPH * graph) +{ + return ((XdmfGraph *)graph)->getNumberNodes(); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfGraph, XDMFGRAPH) +XDMF_SPARSEMATRIX_C_CHILD_WRAPPER(XdmfGraph, XDMFGRAPH) diff --git a/XdmfGraph.hpp b/XdmfGraph.hpp index 1aac65cf..f310bbd2 100644 --- a/XdmfGraph.hpp +++ b/XdmfGraph.hpp @@ -24,14 +24,14 @@ #ifndef XDMFGRAPH_HPP_ #define XDMFGRAPH_HPP_ -// Forward Declarations -class XdmfAttribute; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" +#include "XdmfAttribute.hpp" #include "XdmfTime.hpp" #include "XdmfSparseMatrix.hpp" +#ifdef __cplusplus + /** * @brief Graph stored in sparse matrix form. * @@ -85,6 +85,8 @@ public: void traverse(const shared_ptr visitor); + XdmfGraph(XdmfGraph &); + protected: XdmfGraph(const unsigned int numberNodes); @@ -105,4 +107,38 @@ private: #ifdef _WIN32 #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFGRAPH; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRAPH XDMFGRAPH; + +XDMF_EXPORT XDMFGRAPH * XdmfGraphNew(unsigned int numberNodes); + +XDMF_EXPORT XDMFATTRIBUTE * XdmfGraphGetAttribute(XDMFGRAPH * graph, unsigned int index); + +XDMF_EXPORT XDMFATTRIBUTE * XdmfGraphGetAttributeByName(XDMFGRAPH * graph, char * Name); + +XDMF_EXPORT unsigned int XdmfGraphGetNumberAttributes(XDMFGRAPH * graph); + +XDMF_EXPORT void XdmfGraphInsertAttribute(XDMFGRAPH * graph, XDMFATTRIBUTE * Attribute, int passControl); + +XDMF_EXPORT void XdmfGraphRemoveAttribute(XDMFGRAPH * graph, unsigned int index); + +XDMF_EXPORT void XdmfGraphRemoveAttributeByName(XDMFGRAPH * graph, char * Name); + +XDMF_EXPORT unsigned int XdmfGraphGetNumberNodes(XDMFGRAPH * graph); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfGraph, XDMFGRAPH, XDMF) +XDMF_SPARSEMATRIX_C_CHILD_DECLARE(XdmfGraph, XDMFGRAPH, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFGRAPH_HPP_ */ diff --git a/XdmfGrid.cpp b/XdmfGrid.cpp index 0f80fbc4..1b992d80 100644 --- a/XdmfGrid.cpp +++ b/XdmfGrid.cpp @@ -22,7 +22,9 @@ /*****************************************************************************/ #include +#include #include "XdmfAttribute.hpp" +#include "XdmfError.hpp" #include "XdmfGeometry.hpp" #include "XdmfGrid.hpp" #include "XdmfMap.hpp" @@ -44,12 +46,72 @@ XdmfGrid::XdmfGrid(const shared_ptr geometry, { } +XdmfGrid::XdmfGrid(XdmfGrid &refGrid): + XdmfItem(refGrid), + mAttributes(refGrid.mAttributes), + mSets(refGrid.mSets), + mMaps(refGrid.mMaps), + mGeometry(refGrid.mGeometry), + mTopology(refGrid.mTopology), + mName(refGrid.mName), + mTime(refGrid.mTime) +{ + XdmfGridImpl * holder = refGrid.mImpl; + XdmfGridImpl * duplicateImpl = holder->duplicate(); + mImpl = duplicateImpl; +} + XdmfGrid::~XdmfGrid() { } const std::string XdmfGrid::ItemTag = "Grid"; +shared_ptr +XdmfGrid::getGridController() +{ + return mGridController; +} + +void +XdmfGrid::copyGrid(shared_ptr sourceGrid) +{ + this->setName(sourceGrid->getName()); + this->setTime(sourceGrid->getTime()); + while(this->getNumberAttributes() > 0) + { + this->removeAttribute(0); + } + for (unsigned int i = 0; i < sourceGrid->getNumberAttributes(); ++i) + { + this->insert(sourceGrid->getAttribute(i)); + } + while(this->getNumberInformations() > 0) + { + this->removeInformation(0); + } + for (unsigned int i = 0; i < sourceGrid->getNumberInformations(); ++i) + { + this->insert(sourceGrid->getInformation(i)); + } + while(this->getNumberSets() > 0) + { + this->removeSet(0); + } + for (unsigned int i = 0; i < sourceGrid->getNumberSets(); ++i) + { + this->insert(sourceGrid->getSet(i)); + } + while(this->getNumberMaps() > 0) + { + this->removeMap(0); + } + for (unsigned int i = 0; i < sourceGrid->getNumberMaps(); ++i) + { + this->insert(sourceGrid->getMap(i)); + } +} + shared_ptr XdmfGrid::getGeometry() const { @@ -137,25 +199,70 @@ XdmfGrid::populateItem(const std::map & itemProperties shared_dynamic_cast(*iter)) { mTopology = topology; } + else if(shared_ptr gridController = + shared_dynamic_cast(*iter)) { + this->setGridController(gridController); + } + } +} + +void +XdmfGrid::read() +{ + +} + +void +XdmfGrid::release() +{ + this->setName(""); + this->setTime(shared_ptr()); + while(this->getNumberAttributes() > 0) + { + this->removeAttribute(0); + } + while(this->getNumberInformations() > 0) + { + this->removeInformation(0); + } + while(this->getNumberSets() > 0) + { + this->removeSet(0); + } + while(this->getNumberMaps() > 0) + { + this->removeMap(0); } } +void +XdmfGrid::setGridController(shared_ptr newController) +{ + mGridController = newController; +} + + void XdmfGrid::setName(const std::string & name) { mName = name; + this->setIsChanged(true); } void XdmfGrid::setTime(const shared_ptr time) { mTime = time; + this->setIsChanged(true); } void XdmfGrid::traverse(const shared_ptr visitor) { XdmfItem::traverse(visitor); + if (mGridController) { + mGridController->accept(visitor); + } if(mTime) { mTime->accept(visitor); } @@ -165,21 +272,247 @@ XdmfGrid::traverse(const shared_ptr visitor) if(mTopology) { mTopology->accept(visitor); } - for(std::vector >::const_iterator iter = - mAttributes.begin(); - iter != mAttributes.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mAttributes.size(); ++i) + { + mAttributes[i]->accept(visitor); } - for(std::vector >::const_iterator iter = - mMaps.begin(); - iter != mMaps.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mMaps.size(); ++i) + { + mMaps[i]->accept(visitor); } - for(std::vector >::const_iterator iter = mSets.begin(); - iter != mSets.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mSets.size(); ++i) + { + mSets[i]->accept(visitor); } } + +// C Wrappers + +XDMFATTRIBUTE * XdmfGridGetAttribute(XDMFGRID * grid, unsigned int index) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return (XDMFATTRIBUTE *)((void *)(gridPointer->getAttribute(index).get())); +} + +XDMFATTRIBUTE * XdmfGridGetAttributeByName(XDMFGRID * grid, char * Name) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return (XDMFATTRIBUTE *)((void *)(gridPointer->getAttribute(Name).get())); +} + +unsigned int XdmfGridGetNumberAttributes(XDMFGRID * grid) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return gridPointer->getNumberAttributes(); +} + +void XdmfGridInsertAttribute(XDMFGRID * grid, XDMFATTRIBUTE * Attribute, int passControl) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + if (passControl) { + gridPointer->insert(shared_ptr((XdmfAttribute *)Attribute)); + } + else { + gridPointer->insert(shared_ptr((XdmfAttribute *)Attribute, XdmfNullDeleter())); + } +} + +void XdmfGridRemoveAttribute(XDMFGRID * grid, unsigned int index) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->removeAttribute(index); +} + +void XdmfGridRemoveAttributeByName(XDMFGRID * grid, char * Name) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->removeAttribute(Name); +} + +XDMFSET * XdmfGridGetSet(XDMFGRID * grid, unsigned int index) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return (XDMFSET *)((void *)(gridPointer->getSet(index).get())); +} + +XDMFSET * XdmfGridGetSetByName(XDMFGRID * grid, char * Name) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return (XDMFSET *)((void *)(gridPointer->getSet(Name).get())); +} + +unsigned int XdmfGridGetNumberSets(XDMFGRID * grid) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return gridPointer->getNumberSets(); +} + +void XdmfGridInsertSet(XDMFGRID * grid, XDMFSET * Set, int passControl) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + if (passControl) { + gridPointer->insert(shared_ptr((XdmfSet *)Set)); + } + else { + gridPointer->insert(shared_ptr((XdmfSet *)Set, XdmfNullDeleter())); + } +} + +void XdmfGridRemoveSet(XDMFGRID * grid, unsigned int index) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->removeSet(index); +} + +void XdmfGridRemoveSetByName(XDMFGRID * grid, char * Name) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->removeSet(Name); +} + +XDMFMAP * XdmfGridGetMap(XDMFGRID * grid, unsigned int index) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return (XDMFMAP *)((void *)(gridPointer->getMap(index).get())); +} + +XDMFMAP * XdmfGridGetMapByName(XDMFGRID * grid, char * Name) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return (XDMFMAP *)((void *)(gridPointer->getMap(Name).get())); +} + +unsigned int XdmfGridGetNumberMaps(XDMFGRID * grid) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return gridPointer->getNumberMaps(); +} + +void XdmfGridInsertMap(XDMFGRID * grid, XDMFMAP * Map, int passControl) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + if (passControl) { + gridPointer->insert(shared_ptr((XdmfMap *)Map)); + } + else { + gridPointer->insert(shared_ptr((XdmfMap *)Map, XdmfNullDeleter())); + } +} + +void XdmfGridRemoveMap(XDMFGRID * grid, unsigned int index) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->removeMap(index); +} + +void XdmfGridRemoveMapByName(XDMFGRID * grid, char * Name) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->removeMap(Name); +} + +XDMFGRIDCONTROLLER * XdmfGridGetGridController(XDMFGRID * grid) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedController = gridPointer->getGridController(); + return (XDMFGRIDCONTROLLER *)((void *)(generatedController.get())); + +} + +char * XdmfGridGetName(XDMFGRID * grid) +{ + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + return strdup(gridPointer->getName().c_str()); +} + +XDMFTIME * XdmfGridGetTime(XDMFGRID * grid) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedTime = gridPointer->getTime(); + return (XDMFTIME *)((void *)(generatedTime.get())); +} + +void +XdmfGridRead(XDMFGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + gridPointer->read(); + } + catch (...) + { + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + gridPointer->read(); + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfGridRelease(XDMFGRID * grid) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + gridPointer->release(); +} + +void XdmfGridSetGridController(XDMFGRID * grid, XDMFGRIDCONTROLLER * controller, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + XdmfItem * controllerPointer = (XdmfItem *) controller; + XdmfGridController * classedController = dynamic_cast(controllerPointer); + if (passControl) { + gridPointer->setGridController(shared_ptr(classedController)); + } + else { + gridPointer->setGridController(shared_ptr(classedController, XdmfNullDeleter())); + } +} + +void XdmfGridSetName(XDMFGRID * grid, char * name, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * tempPointer = (XdmfItem *)(grid); + XdmfGrid * gridPointer = dynamic_cast(tempPointer); + gridPointer->setName(name); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfGridSetTime(XDMFGRID * grid, XDMFTIME * time, int passControl) +{ + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setTime(shared_ptr((XdmfTime *)time)); + } + else { + gridPointer->setTime(shared_ptr((XdmfTime *)time, XdmfNullDeleter())); + } +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfGrid, XDMFGRID) diff --git a/XdmfGrid.hpp b/XdmfGrid.hpp index c14c58fb..0113acb3 100644 --- a/XdmfGrid.hpp +++ b/XdmfGrid.hpp @@ -24,17 +24,21 @@ #ifndef XDMFGRID_HPP_ #define XDMFGRID_HPP_ -// Forward Declarations -class XdmfAttribute; -class XdmfGeometry; -class XdmfMap; -class XdmfSet; -class XdmfTime; -class XdmfTopology; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfItem.hpp" +#include "XdmfAttribute.hpp" +#include "XdmfGeometry.hpp" +#include "XdmfGridController.hpp" +#include "XdmfTopology.hpp" +#include "XdmfMap.hpp" +#include "XdmfSet.hpp" + +#ifdef __cplusplus + +// Forward Declarations +class XdmfSubGrid; +class XdmfTime; /** * @brief A mesh containing elements, points, and fields attached to @@ -55,7 +59,7 @@ class XDMF_EXPORT XdmfGrid : public virtual XdmfItem { public: - virtual ~XdmfGrid() = 0; + virtual ~XdmfGrid(); LOKI_DEFINE_VISITABLE(XdmfGrid, XdmfItem) XDMF_CHILDREN(XdmfGrid, XdmfAttribute, Attribute, Name) @@ -86,7 +90,36 @@ public: * * @return The geometry associated with this grid. */ - shared_ptr getGeometry() const; + virtual shared_ptr getGeometry() const; + + /** + * Gets the current external reference for this grid. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setGridController + * @until //#setGridController + * @skipline //#getGridController + * @until //#getGridController + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setGridController + * @until #//setGridController + * @skipline #//getGridController + * @until #//getGridController + * + * @return The current reference. + */ + shared_ptr getGridController(); std::map getItemProperties() const; @@ -149,7 +182,7 @@ public: * @return Pointer to the XdmfTime attached to this grid. If no * XdmfTime is attached, return a NULL pointer. */ - shared_ptr getTime(); + virtual shared_ptr getTime(); /** * Get the time associated with this grid (const version). @@ -171,7 +204,7 @@ public: * @return Pointer to the XdmfTime attached to this grid. If no * XdmfTime is attached, return a NULL pointer. */ - shared_ptr getTime() const; + virtual shared_ptr getTime() const; /** * Get the topology associated with this grid. @@ -196,10 +229,81 @@ public: * * @return The topology associated with this grid. */ - shared_ptr getTopology() const; + virtual shared_ptr getTopology() const; using XdmfItem::insert; + /** + * Reads the tree structure fromt he grid controller set to this grid + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#read + * @until //#read + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//read + * @until #//read + */ + virtual void read(); + + /** + * Releases the grid structure that this grid contains. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#release + * @until //#release + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//release + * @until #//release + */ + virtual void release(); + + /** + * Sets the reference to an external xdmf tree from which to populate the grid. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setGridController + * @until //#setGridController + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setGridController + * @until #//setGridController + * + * @param newController A reference to the external tree. + */ + void setGridController(shared_ptr newController); + /** * Set the name of the grid. * @@ -248,16 +352,21 @@ public: * * @param time An XdmfTime to associate with this grid. */ - void setTime(const shared_ptr time); + virtual void setTime(const shared_ptr time); virtual void traverse(const shared_ptr visitor); + XdmfGrid(XdmfGrid &); + protected: XdmfGrid(const shared_ptr geometry, const shared_ptr topology, const std::string & name = "Grid"); + virtual void + copyGrid(shared_ptr sourceGrid); + virtual void populateItem(const std::map & itemProperties, const std::vector > & childItems, @@ -266,6 +375,31 @@ protected: shared_ptr mGeometry; shared_ptr mTopology; + class XdmfGridImpl + { + public: + XdmfGridImpl() + { + } + + ~XdmfGridImpl() + { + } + + virtual XdmfGridImpl * duplicate() = 0; + + std::string getGridType() const + { + return mGridType; + } + + std::string mGridType; + }; + + XdmfGridImpl * mImpl; + + shared_ptr mGridController; + private: XdmfGrid(const XdmfGrid &); // Not implemented. @@ -305,4 +439,240 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#ifndef XDMFGRIDCDEFINE +#define XDMFGRIDCDEFINE +struct XDMFGRID; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRID XDMFGRID; +#endif + +XDMF_EXPORT XDMFATTRIBUTE * XdmfGridGetAttribute(XDMFGRID * grid, unsigned int index); + +XDMF_EXPORT XDMFATTRIBUTE * XdmfGridGetAttributeByName(XDMFGRID * grid, char * Name); + +XDMF_EXPORT unsigned int XdmfGridGetNumberAttributes(XDMFGRID * grid); + +XDMF_EXPORT void XdmfGridInsertAttribute(XDMFGRID * grid, XDMFATTRIBUTE * Attribute, int passControl); + +XDMF_EXPORT void XdmfGridRemoveAttribute(XDMFGRID * grid, unsigned int index); + +XDMF_EXPORT void XdmfGridRemoveAttributeByName(XDMFGRID * grid, char * Name); + +XDMF_EXPORT XDMFSET * XdmfGridGetSet(XDMFGRID * grid, unsigned int index); + +XDMF_EXPORT XDMFSET * XdmfGridGetSetByName(XDMFGRID * grid, char * Name); + +XDMF_EXPORT unsigned int XdmfGridGetNumberSets(XDMFGRID * grid); + +XDMF_EXPORT void XdmfGridInsertSet(XDMFGRID * grid, XDMFSET * Set, int passControl); + +XDMF_EXPORT void XdmfGridRemoveSet(XDMFGRID * grid, unsigned int index); + +XDMF_EXPORT void XdmfGridRemoveSetByName(XDMFGRID * grid, char * Name); + +XDMF_EXPORT XDMFMAP * XdmfGridGetMap(XDMFGRID * grid, unsigned int index); + +XDMF_EXPORT XDMFMAP * XdmfGridGetMapByName(XDMFGRID * grid, char * Name); + +XDMF_EXPORT unsigned int XdmfGridGetNumberMaps(XDMFGRID * grid); + +XDMF_EXPORT void XdmfGridInsertMap(XDMFGRID * grid, XDMFMAP * Map, int passControl); + +XDMF_EXPORT void XdmfGridRemoveMap(XDMFGRID * grid, unsigned int index); + +XDMF_EXPORT void XdmfGridRemoveMapByName(XDMFGRID * grid, char * Name); + +XDMF_EXPORT XDMFGRIDCONTROLLER * XdmfGridGetGridController(XDMFGRID * grid); + +XDMF_EXPORT char * XdmfGridGetName(XDMFGRID * grid); + +XDMF_EXPORT XDMFTIME * XdmfGridGetTime(XDMFGRID * grid); + +XDMF_EXPORT void XdmfGridRead(XDMFGRID * grid, int * status); + +XDMF_EXPORT void XdmfGridRelease(XDMFGRID * grid); + +XDMF_EXPORT void XdmfGridSetGridController(XDMFGRID * grid, XDMFGRIDCONTROLLER * controller, int passControl); + +XDMF_EXPORT void XdmfGridSetName(XDMFGRID * grid, char * name, int * status); + +XDMF_EXPORT void XdmfGridSetTime(XDMFGRID * grid, XDMFTIME * time, int passControl); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfGrid, XDMFGRID, XDMF) + +#define XDMF_GRID_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT XDMFATTRIBUTE * ClassName##GetAttribute(CClassName * grid, unsigned int index); \ +Level##_EXPORT XDMFATTRIBUTE * ClassName##GetAttributeByName(CClassName * grid, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberAttributes(CClassName * grid); \ +Level##_EXPORT void ClassName##InsertAttribute(CClassName * grid, XDMFATTRIBUTE * Attribute, int passControl); \ +Level##_EXPORT void ClassName##RemoveAttribute(CClassName * grid, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveAttributeByName(CClassName * grid, char * Name); \ +Level##_EXPORT XDMFSET * ClassName##GetSet(CClassName * grid, unsigned int index); \ +Level##_EXPORT XDMFSET * ClassName##GetSetByName(CClassName * grid, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberSets(CClassName * grid); \ +Level##_EXPORT void ClassName##InsertSet(CClassName * grid, XDMFSET * Set, int passControl); \ +Level##_EXPORT void ClassName##RemoveSet(CClassName * grid, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveSetByName(CClassName * grid, char * Name); \ +Level##_EXPORT XDMFMAP * ClassName##GetMap(CClassName * grid, unsigned int index); \ +Level##_EXPORT XDMFMAP * ClassName##GetMapByName(CClassName * grid, char * Name); \ +Level##_EXPORT unsigned int ClassName##GetNumberMaps(CClassName * grid); \ +Level##_EXPORT void ClassName##InsertMap(CClassName * grid, XDMFMAP * Map, int passControl); \ +Level##_EXPORT void ClassName##RemoveMap(CClassName * grid, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveMapByName(CClassName * grid, char * Name); \ +Level##_EXPORT XDMFGRIDCONTROLLER * ClassName##GetGridController(CClassName * grid); \ +Level##_EXPORT char * ClassName##GetName(CClassName * grid); \ +Level##_EXPORT XDMFTIME * ClassName##GetTime(CClassName * grid); \ +Level##_EXPORT void ClassName##Read( CClassName * grid, int * status); \ +Level##_EXPORT void ClassName##Release( CClassName * grid); \ +Level##_EXPORT void ClassName##SetGridController(CClassName * grid, XDMFGRIDCONTROLLER * controller, int passControl); \ +Level##_EXPORT void ClassName##SetName(CClassName * grid, char * name, int * status); \ +Level##_EXPORT void ClassName##SetTime(CClassName * grid, XDMFTIME * time, int passControl); + + + +#define XDMF_GRID_C_CHILD_WRAPPER(ClassName, CClassName) \ +XDMFATTRIBUTE * ClassName##GetAttribute(CClassName * grid, unsigned int index) \ +{ \ + return XdmfGridGetAttribute((XDMFGRID *)((void *)grid), index); \ +} \ + \ +XDMFATTRIBUTE * ClassName##GetAttributeByName(CClassName * grid, char * Name) \ +{ \ + return XdmfGridGetAttributeByName((XDMFGRID *)((void *)grid), Name); \ +} \ + \ +unsigned int ClassName##GetNumberAttributes(CClassName * grid) \ +{ \ + return XdmfGridGetNumberAttributes((XDMFGRID *)((void *)grid)); \ +} \ + \ +void ClassName##InsertAttribute(CClassName * grid, XDMFATTRIBUTE * Attribute, int passControl) \ +{ \ + XdmfGridInsertAttribute((XDMFGRID *)((void *)grid), Attribute, passControl); \ +} \ + \ +void ClassName##RemoveAttribute(CClassName * grid, unsigned int index) \ +{ \ + XdmfGridRemoveAttribute((XDMFGRID *)((void *)grid), index); \ +} \ + \ +void ClassName##RemoveAttributeByName(CClassName * grid, char * Name) \ +{ \ + XdmfGridRemoveAttributeByName((XDMFGRID *)((void *)grid), Name); \ +} \ + \ +XDMFSET * ClassName##GetSet(CClassName * grid, unsigned int index) \ +{ \ + return XdmfGridGetSet((XDMFGRID *)((void *)grid), index); \ +} \ + \ +XDMFSET * ClassName##GetSetByName(CClassName * grid, char * Name) \ +{ \ + return XdmfGridGetSetByName((XDMFGRID *)((void *)grid), Name); \ +} \ + \ +unsigned int ClassName##GetNumberSets(CClassName * grid) \ +{ \ + return XdmfGridGetNumberSets((XDMFGRID *)((void *)grid)); \ +} \ + \ +void ClassName##InsertSet(CClassName * grid, XDMFSET * Set, int passControl) \ +{ \ + XdmfGridInsertSet((XDMFGRID *)((void *)grid), Set, passControl); \ +} \ + \ +void ClassName##RemoveSet(CClassName * grid, unsigned int index) \ +{ \ + XdmfGridRemoveSet((XDMFGRID *)((void *)grid), index); \ +} \ + \ +void ClassName##RemoveSetByName(CClassName * grid, char * Name) \ +{ \ + XdmfGridRemoveSetByName((XDMFGRID *)((void *)grid), Name); \ +} \ + \ +XDMFMAP * ClassName##GetMap(CClassName * grid, unsigned int index) \ +{ \ + return XdmfGridGetMap((XDMFGRID *)((void *)grid), index); \ +} \ + \ +XDMFMAP * ClassName##GetMapByName(CClassName * grid, char * Name) \ +{ \ + return XdmfGridGetMapByName((XDMFGRID *)((void *)grid), Name); \ +} \ + \ +unsigned int ClassName##GetNumberMaps(CClassName * grid) \ +{ \ + return XdmfGridGetNumberMaps((XDMFGRID *)((void *)grid)); \ +} \ + \ +void ClassName##InsertMap(CClassName * grid, XDMFMAP * Map, int passControl) \ +{ \ + XdmfGridInsertMap((XDMFGRID *)((void *)grid), Map, passControl); \ +} \ + \ +void ClassName##RemoveMap(CClassName * grid, unsigned int index) \ +{ \ + XdmfGridRemoveMap((XDMFGRID *)((void *)grid), index); \ +} \ + \ +void ClassName##RemoveMapByName(CClassName * grid, char * Name) \ +{ \ + XdmfGridRemoveMapByName((XDMFGRID *)((void *)grid), Name); \ +} \ + \ +XDMFGRIDCONTROLLER * ClassName##GetGridController(CClassName * grid) \ +{ \ + return XdmfGridGetGridController((XDMFGRID *)((void *)grid)); \ +} \ + \ +char * ClassName##GetName(CClassName * grid) \ +{ \ + return XdmfGridGetName((XDMFGRID *)((void *)grid)); \ +} \ + \ +XDMFTIME * ClassName##GetTime(CClassName * grid) \ +{ \ + return XdmfGridGetTime((XDMFGRID *)((void *)grid)); \ +} \ + \ +void \ +ClassName##Read( CClassName * grid, int * status) \ +{ \ + XdmfGridRead((XDMFGRID *)((void *)grid), status); \ +} \ + \ +void \ +ClassName##Release( CClassName * grid) \ +{ \ + XdmfGridRelease((XDMFGRID *)((void *)grid)); \ +} \ + \ +void ClassName##SetGridController(CClassName * grid, XDMFGRIDCONTROLLER * controller, int passControl) \ +{ \ + XdmfGridSetGridController((XDMFGRID *)((void *)grid), controller, passControl); \ +} \ + \ +void ClassName##SetName(CClassName * grid, char * name, int * status) \ +{ \ + XdmfGridSetName((XDMFGRID *)((void *)grid), name, status); \ +} \ + \ +void ClassName##SetTime(CClassName * grid, XDMFTIME * time, int passControl) \ +{ \ + XdmfGridSetTime((XDMFGRID *)((void *)grid), time, passControl); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFGRID_HPP_ */ diff --git a/XdmfGridCollection.cpp b/XdmfGridCollection.cpp index d3a2604c..e4eef6b4 100644 --- a/XdmfGridCollection.cpp +++ b/XdmfGridCollection.cpp @@ -22,11 +22,35 @@ /*****************************************************************************/ #include +#include "XdmfError.hpp" #include "XdmfGeometry.hpp" #include "XdmfTopology.hpp" #include "XdmfGridCollection.hpp" #include "XdmfGridCollectionType.hpp" +class XdmfGridCollection::XdmfGridCollectionImpl : public XdmfGridImpl +{ + public: + XdmfGridCollectionImpl() + { + mGridType = "Collection"; + } + + ~XdmfGridCollectionImpl() + { + } + + XdmfGridImpl * duplicate() + { + return new XdmfGridCollectionImpl(); + } + + std::string getGridType() const + { + return mGridType; + } +}; + shared_ptr XdmfGridCollection::New() { @@ -36,17 +60,87 @@ XdmfGridCollection::New() XdmfGridCollection::XdmfGridCollection() : XdmfDomain(), - XdmfGrid(XdmfGeometry::New(), XdmfTopology::New(), "Collection"), + XdmfGrid(shared_ptr(), shared_ptr(), "Collection"), mType(XdmfGridCollectionType::NoCollectionType()) +{ + mImpl = new XdmfGridCollectionImpl(); +} + +XdmfGridCollection::XdmfGridCollection(XdmfGridCollection & refCollection) : + XdmfDomain(refCollection), + XdmfGrid(refCollection), + mType(refCollection.mType) { } XdmfGridCollection::~XdmfGridCollection() { + if (mImpl) { + delete mImpl; + } + mImpl = NULL; } const std::string XdmfGridCollection::ItemTag = "Grid"; +void +XdmfGridCollection::copyGrid(shared_ptr sourceGrid) +{ + XdmfGrid::copyGrid(sourceGrid); + if (shared_ptr classedGrid = shared_dynamic_cast(sourceGrid)) + { + // Copy stucture from read grid to this grid + while (this->getNumberGridCollections() > 0) + { + this->removeGridCollection(0); + } + for (unsigned int i = 0; i < classedGrid->getNumberGridCollections(); ++i) + { + this->insert(classedGrid->getGridCollection(i)); + } + while (this->getNumberCurvilinearGrids() > 0) + { + this->removeCurvilinearGrid(0); + } + for (unsigned int i = 0; i < classedGrid->getNumberCurvilinearGrids(); ++i) + { + this->insert(classedGrid->getCurvilinearGrid(i)); + } + while (this->getNumberGraphs() > 0) + { + this->removeGraph(0); + } + for (unsigned int i = 0; i < classedGrid->getNumberGraphs(); ++i) + { + this->insert(classedGrid->getGraph(i)); + } + while (this->getNumberRectilinearGrids() > 0) + { + this->removeRectilinearGrid(0); + } + for (unsigned int i = 0; i < classedGrid->getNumberRectilinearGrids(); ++i) + { + this->insert(classedGrid->getRectilinearGrid(i)); + } + while (this->getNumberRegularGrids() > 0) + { + this->removeRegularGrid(0); + } + for (unsigned int i = 0; i < classedGrid->getNumberRegularGrids(); ++i) + { + this->insert(classedGrid->getRegularGrid(i)); + } + while (this->getNumberUnstructuredGrids() > 0) + { + this->removeUnstructuredGrid(0); + } + for (unsigned int i = 0; i < classedGrid->getNumberUnstructuredGrids(); ++i) + { + this->insert(classedGrid->getUnstructuredGrid(i)); + } + } +} + std::map XdmfGridCollection::getItemProperties() const { @@ -86,10 +180,144 @@ XdmfGridCollection::populateItem(const std::map & item XdmfGrid::populateItem(itemProperties, childItems, reader); } +void +XdmfGridCollection::read() +{ + if (mGridController) + { + if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + // Copy stucture from read grid to this grid + while(this->getNumberGridCollections() > 0) + { + this->removeGridCollection(0); + } + for (unsigned int i = 0; i < grid->getNumberGridCollections(); ++i) + { + this->insert(grid->getGridCollection(i)); + } + while(this->getNumberUnstructuredGrids() > 0) + { + this->removeUnstructuredGrid(0); + } + for (unsigned int i = 0; i < grid->getNumberUnstructuredGrids(); ++i) + { + this->insert(grid->getUnstructuredGrid(i)); + } + while(this->getNumberCurvilinearGrids() > 0) + { + this->removeCurvilinearGrid(0); + } + for (unsigned int i = 0; i < grid->getNumberCurvilinearGrids(); ++i) + { + this->insert(grid->getCurvilinearGrid(i)); + } + while(this->getNumberRectilinearGrids() > 0) + { + this->removeRectilinearGrid(0); + } + for (unsigned int i = 0; i < grid->getNumberRectilinearGrids(); ++i) + { + this->insert(grid->getRectilinearGrid(i)); + } + while(this->getNumberRegularGrids() > 0) + { + this->removeRegularGrid(0); + } + for (unsigned int i = 0; i < grid->getNumberRegularGrids(); ++i) + { + this->insert(grid->getRegularGrid(i)); + } + while(this->getNumberAttributes() > 0) + { + this->removeAttribute(0); + } + for (unsigned int i = 0; i < grid->getNumberAttributes(); ++i) + { + this->insert(grid->getAttribute(i)); + } + while(this->getNumberInformations() > 0) + { + this->removeInformation(0); + } + for (unsigned int i = 0; i < grid->getNumberInformations(); ++i) + { + this->insert(grid->getInformation(i)); + } + while(this->getNumberSets() > 0) + { + this->removeSet(0); + } + for (unsigned int i = 0; i < grid->getNumberSets(); ++i) + { + this->insert(grid->getSet(i)); + } + while(this->getNumberMaps() > 0) + { + this->removeMap(0); + } + for (unsigned int i = 0; i < grid->getNumberMaps(); ++i) + { + this->insert(grid->getMap(i)); + } + } + else if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + XdmfError::message(XdmfError::FATAL, "Error: Grid Type Mismatch"); + } + else + { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Grid Reference"); + } + } +} + +void +XdmfGridCollection::release() +{ + while(this->getNumberGridCollections() > 0) + { + this->removeGridCollection(0); + } + while(this->getNumberUnstructuredGrids() > 0) + { + this->removeUnstructuredGrid(0); + } + while(this->getNumberCurvilinearGrids() > 0) + { + this->removeCurvilinearGrid(0); + } + while(this->getNumberRectilinearGrids() > 0) + { + this->removeRectilinearGrid(0); + } + while(this->getNumberRegularGrids() > 0) + { + this->removeRegularGrid(0); + } + while(this->getNumberAttributes() > 0) + { + this->removeAttribute(0); + } + while(this->getNumberInformations() > 0) + { + this->removeInformation(0); + } + while(this->getNumberSets() > 0) + { + this->removeSet(0); + } + while(this->getNumberMaps() > 0) + { + this->removeMap(0); + } +} + void XdmfGridCollection::setType(const shared_ptr type) { mType = type; + this->setIsChanged(true); } void @@ -103,3 +331,75 @@ XdmfGridCollection::traverse(const shared_ptr visitor) XdmfDomain::traverse(visitor); informations.swap(mInformations); } + +// C Wrappers + +XDMFGRIDCOLLECTION * XdmfGridCollectionNew() +{ + try + { + XDMFGRIDCOLLECTION * returnCollection = NULL; + shared_ptr generatedCollection = XdmfGridCollection::New(); + returnCollection = (XDMFGRIDCOLLECTION *)((void *)((XdmfItem *)(new XdmfGridCollection(*generatedCollection.get())))); + generatedCollection.reset(); + return returnCollection; + } + catch (...) + { + XDMFGRIDCOLLECTION * returnCollection = NULL; + shared_ptr generatedCollection = XdmfGridCollection::New(); + returnCollection = (XDMFGRIDCOLLECTION *)((void *)((XdmfItem *)(new XdmfGridCollection(*generatedCollection.get())))); + generatedCollection.reset(); + return returnCollection; + } +} + +int XdmfGridCollectionGetType(XDMFGRIDCOLLECTION * collection, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * tempPointer = (XdmfItem *)collection; + XdmfGridCollection * tempCollection = dynamic_cast(tempPointer); + shared_ptr checkType = tempCollection->getType(); + if (checkType == XdmfGridCollectionType::NoCollectionType()) { + return XDMF_GRID_COLLECTION_TYPE_NO_COLLECTION_TYPE; + } + else if (checkType == XdmfGridCollectionType::Spatial()) { + return XDMF_GRID_COLLECTION_TYPE_SPATIAL; + } + else if (checkType == XdmfGridCollectionType::Temporal()) { + return XDMF_GRID_COLLECTION_TYPE_TEMPORAL; + } + else { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +void XdmfGridCollectionSetType(XDMFGRIDCOLLECTION * collection, int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * tempPointer = (XdmfItem *)collection; + XdmfGridCollection * tempCollection = dynamic_cast(tempPointer); + switch (type) { + case XDMF_GRID_COLLECTION_TYPE_NO_COLLECTION_TYPE: + tempCollection->setType(XdmfGridCollectionType::NoCollectionType()); + break; + case XDMF_GRID_COLLECTION_TYPE_SPATIAL: + tempCollection->setType(XdmfGridCollectionType::Spatial()); + break; + case XDMF_GRID_COLLECTION_TYPE_TEMPORAL: + tempCollection->setType(XdmfGridCollectionType::Temporal()); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + XDMF_ERROR_WRAP_END(status) +} + +XDMF_DOMAIN_C_CHILD_WRAPPER(XdmfGridCollection, XDMFGRIDCOLLECTION) +XDMF_GRID_C_CHILD_WRAPPER(XdmfGridCollection, XDMFGRIDCOLLECTION) +XDMF_ITEM_C_CHILD_WRAPPER(XdmfGridCollection, XDMFGRIDCOLLECTION) diff --git a/XdmfGridCollection.hpp b/XdmfGridCollection.hpp index ae938f13..ccbf020a 100644 --- a/XdmfGridCollection.hpp +++ b/XdmfGridCollection.hpp @@ -24,13 +24,13 @@ #ifndef XDMFGRIDCOLLECTION_HPP_ #define XDMFGRIDCOLLECTION_HPP_ -// Forward Declarations -class XdmfGridCollectionType; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfDomain.hpp" #include "XdmfGrid.hpp" +#include "XdmfGridCollectionType.hpp" + +#ifdef __cplusplus /** * @brief A spatial or temporal collection of XdmfGrids. @@ -43,7 +43,7 @@ class XdmfGridCollectionType; * It is valid to nest collections. A spatial collection inside a * temporal collection is commonly used. */ -class XDMF_EXPORT XdmfGridCollection : public XdmfDomain, +class XDMF_EXPORT XdmfGridCollection : public virtual XdmfDomain, public XdmfGrid { public: @@ -131,6 +131,10 @@ public: */ void insert(const shared_ptr information); + void read(); + + void release(); + /** * Set the XdmfGridCollectionType associated with this grid * collection. @@ -159,6 +163,8 @@ public: void traverse(const shared_ptr visitor); + XdmfGridCollection(XdmfGridCollection &); + protected: XdmfGridCollection(); @@ -168,8 +174,15 @@ protected: const std::vector > & childItems, const XdmfCoreReader * const reader); + void copyGrid(shared_ptr sourceGrid); + private: + /** + * PIMPL + */ + class XdmfGridCollectionImpl; + XdmfGridCollection(const XdmfGridCollection &); // Not implemented. void operator=(const XdmfGridCollection &); // Not implemented. @@ -181,4 +194,32 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#ifndef XDMFGRIDCOLLECTIONCDEFINE +#define XDMFGRIDCOLLECTIONCDEFINE +struct XDMFGRIDCOLLECTION; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRIDCOLLECTION XDMFGRIDCOLLECTION; +#endif + +XDMF_EXPORT XDMFGRIDCOLLECTION * XdmfGridCollectionNew(); + +XDMF_EXPORT int XdmfGridCollectionGetType(XDMFGRIDCOLLECTION * collection, int * status); + +XDMF_EXPORT void XdmfGridCollectionSetType(XDMFGRIDCOLLECTION * collection, int type, int * status); + +XDMF_DOMAIN_C_CHILD_DECLARE(XdmfGridCollection, XDMFGRIDCOLLECTION, XDMF) +XDMF_GRID_C_CHILD_DECLARE(XdmfGridCollection, XDMFGRIDCOLLECTION, XDMF) +XDMF_ITEM_C_CHILD_DECLARE(XdmfGridCollection, XDMFGRIDCOLLECTION, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFGRID_HPP_ */ diff --git a/XdmfGridCollectionType.cpp b/XdmfGridCollectionType.cpp index f032f1c9..793f217a 100644 --- a/XdmfGridCollectionType.cpp +++ b/XdmfGridCollectionType.cpp @@ -25,6 +25,9 @@ #include "XdmfError.hpp" #include "XdmfGridCollectionType.hpp" +std::map(*)()> + XdmfGridCollectionType::mGridCollectionDefinitions; + // Supported XdmfGridCollectionTypes shared_ptr XdmfGridCollectionType::NoCollectionType() @@ -50,6 +53,14 @@ XdmfGridCollectionType::Temporal() return p; } +void +XdmfGridCollectionType::InitTypes() +{ + mGridCollectionDefinitions["NONE"] = NoCollectionType; + mGridCollectionDefinitions["SPATIAL"] = Spatial; + mGridCollectionDefinitions["TEMPORAL"] = Temporal; +} + XdmfGridCollectionType::XdmfGridCollectionType(const std::string & name) : mName(name) { @@ -62,6 +73,8 @@ XdmfGridCollectionType::~XdmfGridCollectionType() shared_ptr XdmfGridCollectionType::New(const std::map & itemProperties) { + InitTypes(); + std::map::const_iterator type = itemProperties.find("CollectionType"); if(type == itemProperties.end()) { @@ -70,15 +83,18 @@ XdmfGridCollectionType::New(const std::map & itemPrope "XdmfGridCollectionType::New"); } - const std::string & typeVal = type->second; - if(typeVal.compare("None") == 0) { - return NoCollectionType(); - } - else if(typeVal.compare("Spatial") == 0) { - return Spatial(); + const std::string & typeVal = ConvertToUpper(type->second); + + std::map(*)()>::const_iterator returnType + = mGridCollectionDefinitions.find(typeVal); + + if (returnType == mGridCollectionDefinitions.end()) { + XdmfError::message(XdmfError::FATAL, + "'CollectionType' not of 'None', 'Spatial', or " + "'Temporal' in XdmfGridCollectionType::New"); } - else if(typeVal.compare("Temporal") == 0) { - return Temporal(); + else { + return (*(returnType->second))(); } XdmfError::message(XdmfError::FATAL, @@ -94,3 +110,20 @@ XdmfGridCollectionType::getProperties(std::map & colle { collectedProperties.insert(std::make_pair("CollectionType", mName)); } + +// C Wrappers + +int XdmfGridCollectionTypeNoCollectionType() +{ + return XDMF_GRID_COLLECTION_TYPE_NO_COLLECTION_TYPE; +} + +int XdmfGridCollectionTypeSpatial() +{ + return XDMF_GRID_COLLECTION_TYPE_SPATIAL; +} + +int XdmfGridCollectionTypeTemporal() +{ + return XDMF_GRID_COLLECTION_TYPE_TEMPORAL; +} diff --git a/XdmfGridCollectionType.hpp b/XdmfGridCollectionType.hpp index bb53835b..fabfed18 100644 --- a/XdmfGridCollectionType.hpp +++ b/XdmfGridCollectionType.hpp @@ -24,8 +24,12 @@ #ifndef XDMFGRIDCOLLECTIONTYPE_HPP_ #define XDMFGRIDCOLLECTIONTYPE_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" + +#ifdef __cplusplus + +// Includes #include "XdmfItemProperty.hpp" /** @@ -67,6 +71,7 @@ public: virtual ~XdmfGridCollectionType(); friend class XdmfGridCollection; + friend class XdmfGridTemplate; // Supported XdmfGridCollectionTypes static shared_ptr NoCollectionType(); @@ -89,6 +94,10 @@ protected: */ XdmfGridCollectionType(const std::string & name); + static std::map(*)()> mGridCollectionDefinitions; + + static void InitTypes(); + private: XdmfGridCollectionType(const XdmfGridCollectionType &); // Not implemented. @@ -100,4 +109,25 @@ private: std::string mName; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_GRID_COLLECTION_TYPE_SPATIAL 400 +#define XDMF_GRID_COLLECTION_TYPE_TEMPORAL 401 +#define XDMF_GRID_COLLECTION_TYPE_NO_COLLECTION_TYPE 402 + +XDMF_EXPORT int XdmfGridCollectionTypeNoCollectionType(); +XDMF_EXPORT int XdmfGridCollectionTypeSpatial(); +XDMF_EXPORT int XdmfGridCollectionTypeTemporal(); + +#ifdef __cplusplus +} +#endif + + #endif /* XDMFGRIDCOLLECTIONTYPE_HPP_ */ diff --git a/XdmfGridController.cpp b/XdmfGridController.cpp new file mode 100644 index 00000000..3d9a3964 --- /dev/null +++ b/XdmfGridController.cpp @@ -0,0 +1,195 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfGridController.cpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@arl.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2015 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#include "XdmfCurvilinearGrid.hpp" +#include "XdmfError.hpp" +#include "XdmfGrid.hpp" +#include "XdmfGridCollection.hpp" +#include "XdmfGridController.hpp" +#include "XdmfReader.hpp" +#include "XdmfRectilinearGrid.hpp" +#include "XdmfRegularGrid.hpp" +#include "XdmfUnstructuredGrid.hpp" +#include "string.h" +#include + +shared_ptr +XdmfGridController::New(const std::string & filePath, + const std::string & xmlPath) +{ + shared_ptr p(new XdmfGridController(filePath, + xmlPath)); + return p; +} + +XdmfGridController::XdmfGridController(const std::string & filePath, + const std::string & xmlPath) : + mFilePath(filePath), + mXMLPath(xmlPath) +{ +} + +XdmfGridController::XdmfGridController(const XdmfGridController& refController): + mFilePath(refController.getFilePath()), + mXMLPath(refController.getXMLPath()) +{ +} + +XdmfGridController::~XdmfGridController() +{ +} + +const std::string XdmfGridController::ItemTag = "XGrid"; + +std::string +XdmfGridController::getFilePath() const +{ + return mFilePath; +} + +std::string +XdmfGridController::getItemTag() const +{ + return ItemTag; +} + +std::map +XdmfGridController::getItemProperties() const +{ + std::map gridProperties; + gridProperties.insert(std::make_pair("File", mFilePath)); + gridProperties.insert(std::make_pair("XPath", mXMLPath)); + return gridProperties; +} + +std::string +XdmfGridController::getXMLPath() const +{ + return mXMLPath; +} + +shared_ptr +XdmfGridController::read() +{ + shared_ptr gridReader = XdmfReader::New(); + return shared_dynamic_cast(gridReader->read(mFilePath, mXMLPath)[0]); +} + +// C Wrappers + +XDMFGRIDCONTROLLER * +XdmfGridControllerNew(char * filePath, char * xmlPath) +{ + try + { + XDMFGRIDCONTROLLER * returnController = NULL; + shared_ptr generatedController = XdmfGridController::New(std::string(filePath), std::string(xmlPath)); + returnController = (XDMFGRIDCONTROLLER *)((void *)((XdmfItem *)(new XdmfGridController(*generatedController.get())))); + generatedController.reset(); + return returnController; + } + catch (...) + { + XDMFGRIDCONTROLLER * returnController = NULL; + shared_ptr generatedController = XdmfGridController::New(std::string(filePath), std::string(xmlPath)); + returnController = (XDMFGRIDCONTROLLER *)((void *)((XdmfItem *)(new XdmfGridController(*generatedController.get())))); + generatedController.reset(); + return returnController; + } +} + +char * +XdmfGridControllerGetFilePath(XDMFGRIDCONTROLLER * controller) +{ + try + { + XdmfGridController referenceController = *(XdmfGridController *)(controller); + char * returnPointer = strdup(referenceController.getFilePath().c_str()); + return returnPointer; + } + catch (...) + { + XdmfGridController referenceController = *(XdmfGridController *)(controller); + char * returnPointer = strdup(referenceController.getFilePath().c_str()); + return returnPointer; + } +} + +char * +XdmfGridControllerGetXMLPath(XDMFGRIDCONTROLLER * controller) +{ + try + { + XdmfGridController referenceController = *(XdmfGridController *)(controller); + char * returnPointer = strdup(referenceController.getXMLPath().c_str()); + return returnPointer; + } + catch (...) + { + XdmfGridController referenceController = *(XdmfGridController *)(controller); + char * returnPointer = strdup(referenceController.getXMLPath().c_str()); + return returnPointer; + } +} + +XDMFGRID * +XdmfGridControllerRead(XDMFGRIDCONTROLLER * controller) +{ + try + { + XdmfGridController referenceController = *(XdmfGridController *)(controller); + shared_ptr returnGrid = referenceController.read(); + XDMFGRID * returnPointer; + if (shared_ptr curvilinearGrid = + shared_dynamic_cast(returnGrid)) + { + returnPointer = (XDMFGRID *)((void *)((XdmfItem *)(new XdmfCurvilinearGrid(*curvilinearGrid.get())))); + } + else if (shared_ptr rectilinearGrid = + shared_dynamic_cast(returnGrid)) + { + returnPointer = (XDMFGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*rectilinearGrid.get())))); + } + else if (shared_ptr regularGrid = + shared_dynamic_cast(returnGrid)) + { + returnPointer = (XDMFGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*regularGrid.get())))); + } + else if (shared_ptr collectionGrid = + shared_dynamic_cast(returnGrid)) + { + returnPointer = (XDMFGRID *)((void *)((XdmfItem *)(new XdmfGridCollection(*collectionGrid.get())))); + } + else if (shared_ptr unstructuredGrid = + shared_dynamic_cast(returnGrid)) + { + returnPointer = (XDMFGRID *)((void *)((XdmfItem *)(new XdmfUnstructuredGrid(*unstructuredGrid.get())))); + } + return returnPointer; + } + catch (...) + { + } +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfGridController, XDMFGRIDCONTROLLER) diff --git a/XdmfGridController.hpp b/XdmfGridController.hpp new file mode 100644 index 00000000..5a84dffa --- /dev/null +++ b/XdmfGridController.hpp @@ -0,0 +1,226 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfGridController.hpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@arl.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2015 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#ifndef XDMFGRIDCONTROLLER_HPP_ +#define XDMFGRIDCONTROLLER_HPP_ + +// C Compatible Includes +#include "Xdmf.hpp" + +#ifdef __cplusplus + +// Forward Declarations +class XdmfGrid; + +// Includes +#include +#include "XdmfSharedPtr.hpp" + +/** + * @brief Couples an XdmfGrid with a grid on a different XML file. + * + * Serves as an method to reduce memory usage by leaving part of + * the xdmf tree in file. + */ +class XDMF_EXPORT XdmfGridController : public virtual XdmfItem { + +public: + + /** + * Creates a link to an xdmf tree in another file. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setGridController + * @until //#setGridController + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setGridController + * @until #//setGridController + * + * @param filePath + * @param xmlPath + * + * @return A reference to the external xdmf tree + */ + static shared_ptr + New(const std::string & filePath, + const std::string & xmlPath); + + friend class XdmfWriter; + friend class XdmfGrid; + + virtual ~XdmfGridController(); + + static const std::string ItemTag; + + /** + * Gets the file path of the grid that this reference reads from. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setGridController + * @until //#setGridController + * @skipline //#getFilePath + * @until //#getFilePath + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setGridController + * @until #//setGridController + * @skipline #//getFilePath + * @until #//getFilePath + * + * @return The file path. + */ + std::string getFilePath() const; + + std::map getItemProperties() const; + + virtual std::string getItemTag() const; + + /** + * Gets the XML path that refers to the base node in the reference file. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setGridController + * @until //#setGridController + * @skipline //#getXMLPath + * @until //#getXMLPath + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setGridController + * @until #//setGridController + * @skipline #//getXMLPath + * @until #//getXMLPath + * + * @return The XML path. + */ + std::string getXMLPath() const; + + /** + * Reads the grid that his controller references. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfGrid.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setGridController + * @until //#setGridController + * @skipline //#controllerRead + * @until //#controllerRead + * + * Python + * + * @dontinclude XdmfExampleGrid.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setGridController + * @until #//setGridController + * @skipline #//controllerRead + * @until #//controllerRead + * + * @return The grid read from the controller's stored location + */ + virtual shared_ptr read(); + + XdmfGridController(const XdmfGridController&); + +protected: + + XdmfGridController(const std::string & filePath, + const std::string & xmlPath); + + const std::string mFilePath; + const std::string mXMLPath; + +private: + +// XdmfGridController(const XdmfGridController&); // Not implemented. + void operator=(const XdmfGridController &); // Not implemented. + +}; + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#ifndef XDMFGRIDCDEFINE +#define XDMFGRIDCDEFINE +struct XDMFGRID; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRID XDMFGRID; +#endif + +struct XDMFGRIDCONTROLLER; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRIDCONTROLLER XDMFGRIDCONTROLLER; + +XDMF_EXPORT XDMFGRIDCONTROLLER * XdmfGridControllerNew(char * filePath, + char * xmlPath); + +XDMF_EXPORT char * XdmfGridControllerGetFilePath(XDMFGRIDCONTROLLER * controller); + +XDMF_EXPORT char * XdmfGridControllerGetXMLPath(XDMFGRIDCONTROLLER * controller); + +XDMF_EXPORT XDMFGRID * XdmfGridControllerRead(XDMFGRIDCONTROLLER * controller); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfGridController, XDMFGRIDCONTROLLER, XDMF) + +#ifdef __cplusplus +} +#endif + +#endif /* XDMFGRIDCONTROLLER_HPP_ */ diff --git a/XdmfItemFactory.cpp b/XdmfItemFactory.cpp index 133981c7..6ac32588 100644 --- a/XdmfItemFactory.cpp +++ b/XdmfItemFactory.cpp @@ -34,6 +34,7 @@ #include "XdmfGridCollection.hpp" #include "XdmfInformation.hpp" #include "XdmfItemFactory.hpp" +#include "XdmfAggregate.hpp" #include "XdmfMap.hpp" #include "XdmfRectilinearGrid.hpp" #include "XdmfRegularGrid.hpp" @@ -63,8 +64,13 @@ XdmfItemFactory::createItem(const std::string & itemTag, const std::map & itemProperties, const std::vector > & childItems) const { +#ifdef XDMF_BUILD_DSM + shared_ptr newItem = + XdmfDSMItemFactory::createItem(itemTag, itemProperties, childItems); +#else shared_ptr newItem = XdmfCoreItemFactory::createItem(itemTag, itemProperties, childItems); +#endif if(newItem) { return newItem; @@ -73,6 +79,46 @@ XdmfItemFactory::createItem(const std::string & itemTag, if(itemTag.compare(XdmfAttribute::ItemTag) == 0) { return XdmfAttribute::New(); } + else if(itemTag.compare(XdmfAggregate::ItemTag) == 0) { + std::map::const_iterator type = + itemProperties.find("ConstructedType"); + std::string arraySubType; + if(type == itemProperties.end()) { + // If no type is specified an array is generated + arraySubType = XdmfArray::ItemTag; + } + else { + arraySubType = type->second; + } + std::vector > newArrayChildren; + shared_ptr createdItem = createItem(arraySubType, + itemProperties, + newArrayChildren); + + shared_ptr returnArray = shared_dynamic_cast(createdItem); + + shared_ptr returnAggregate = XdmfAggregate::New(); + + bool placeholderFound = false; + for(std::vector >::const_iterator iter = + childItems.begin(); + iter != childItems.end(); + ++iter) { + if(shared_ptr array = shared_dynamic_cast(*iter)) { + if (!placeholderFound) { + placeholderFound = true; + } + else { + returnAggregate->insert(array); + } + } + } + + returnArray->setReference(returnAggregate); + returnArray->setReadMode(XdmfArray::Reference); + + return returnArray; + } else if(itemTag.compare(XdmfDomain::ItemTag) == 0) { return XdmfDomain::New(); } @@ -86,7 +132,8 @@ XdmfItemFactory::createItem(const std::string & itemTag, if(type != itemProperties.end()) { const std::string & typeVal = type->second; if(typeVal.compare("ORIGIN_DXDY") == 0 || - typeVal.compare("ORIGIN_DXDYDZ") == 0) { + typeVal.compare("ORIGIN_DXDYDZ") == 0 || + typeVal.compare("ORIGIN_DISPLACEMENT") == 0) { shared_ptr origin = shared_ptr(); shared_ptr brickSize = shared_ptr(); for(std::vector >::const_iterator iter = @@ -112,7 +159,8 @@ XdmfItemFactory::createItem(const std::string & itemTag, return shared_ptr(); } else if(typeVal.compare("VXVY") == 0 || - typeVal.compare("VXVYVZ") == 0) { + typeVal.compare("VXVYVZ") == 0 || + typeVal.compare("VECTORED") == 0) { std::vector > coordinateValues; for(std::vector >::const_iterator iter = childItems.begin(); @@ -123,7 +171,7 @@ XdmfItemFactory::createItem(const std::string & itemTag, coordinateValues.push_back(array); } } - return XdmfRectilinearGrid::New(coordinateValues); + return shared_dynamic_cast(XdmfRectilinearGrid::New(coordinateValues)); } } return XdmfGeometry::New(); @@ -163,6 +211,13 @@ XdmfItemFactory::createItem(const std::string & itemTag, return XdmfUnstructuredGrid::New(); } } + else if(itemTag.compare(XdmfGridController::ItemTag) == 0) { + std::map::const_iterator filename = + itemProperties.find("File"); + std::map::const_iterator xpath = + itemProperties.find("XPath"); + return XdmfGridController::New(filename->second, xpath->second); + } else if(itemTag.compare(XdmfInformation::ItemTag) == 0) { return XdmfInformation::New(); } @@ -193,8 +248,10 @@ XdmfItemFactory::createItem(const std::string & itemTag, (int(*)(int))toupper); if(typeVal.compare("2DCORECTMESH") == 0 || typeVal.compare("3DCORECTMESH") == 0 || + typeVal.compare("CORECTMESH") == 0 || typeVal.compare("2DSMESH") == 0 || - typeVal.compare("3DSMESH") == 0) { + typeVal.compare("3DSMESH") == 0 || + typeVal.compare("SMESH") == 0) { shared_ptr dimensionsArray = XdmfArray::New(); std::string dimensionsString = ""; std::map::const_iterator dimensions = @@ -209,7 +266,8 @@ XdmfItemFactory::createItem(const std::string & itemTag, dimensionsArray->pushBack(atoi((*iter).c_str())); } if(typeVal.compare("2DCORECTMESH") == 0 || - typeVal.compare("3DCORECTMESH") == 0) { + typeVal.compare("3DCORECTMESH") == 0 || + typeVal.compare("CORECTMESH") == 0) { return XdmfRegularGrid::New(shared_ptr(), dimensionsArray, shared_ptr()); @@ -219,7 +277,8 @@ XdmfItemFactory::createItem(const std::string & itemTag, } } else if(typeVal.compare("2DRECTMESH") == 0 || - typeVal.compare("3DRECTMESH") == 0) { + typeVal.compare("3DRECTMESH") == 0 || + typeVal.compare("RECTMESH") == 0) { std::vector > coordinateValues; return XdmfRectilinearGrid::New(coordinateValues); } @@ -229,3 +288,85 @@ XdmfItemFactory::createItem(const std::string & itemTag, } return shared_ptr(); } + +bool +XdmfItemFactory::isArrayTag(char * tag) const +{ +#ifdef XDMF_BUILD_DSM + if (XdmfDSMItemFactory::isArrayTag(tag)) + { + return true; + } +#else + if (XdmfCoreItemFactory::isArrayTag(tag)) + { + return true; + } +#endif + else if (XdmfAggregate::ItemTag.compare(tag) == 0) { + return true; + } + else { + return false; + } +} + +XdmfItem * +XdmfItemFactory::DuplicatePointer(shared_ptr original) const +{ +#ifdef XDMF_BUILD_DSM + XdmfItem * returnPointer = XdmfDSMItemFactory::DuplicatePointer(original); +#else + XdmfItem * returnPointer = XdmfCoreItemFactory::DuplicatePointer(original); +#endif + + if (returnPointer) { + return returnPointer; + } + else { + if (original->getItemTag().compare(XdmfTime::ItemTag) == 0) { + return (XdmfItem *)(new XdmfTime(*((XdmfTime *)original.get()))); + } + else if (original->getItemTag().compare(XdmfAttribute::ItemTag) == 0) { + return (XdmfItem *)(new XdmfAttribute(*((XdmfAttribute *)original.get()))); + } + else if (original->getItemTag().compare(XdmfDomain::ItemTag) == 0) { + return (XdmfItem *)(new XdmfDomain(*(shared_dynamic_cast(original).get()))); + } + else if (original->getItemTag().compare(XdmfTopology::ItemTag) == 0) { + return (XdmfItem *)(new XdmfTopology(*((XdmfTopology *)original.get()))); + } + else if (original->getItemTag().compare(XdmfGeometry::ItemTag) == 0) { + return (XdmfItem *)(new XdmfGeometry(*((XdmfGeometry *)original.get()))); + } + else if (original->getItemTag().compare(XdmfGraph::ItemTag) == 0) { + return (XdmfItem *)(new XdmfGraph(*((XdmfGraph *)original.get()))); + } + else if (original->getItemTag().compare(XdmfSet::ItemTag) == 0) { + return (XdmfItem *)(new XdmfSet(*((XdmfSet *)original.get()))); + } + else if (original->getItemTag().compare(XdmfMap::ItemTag) == 0) { + return (XdmfItem *)(new XdmfMap(*((XdmfMap *)original.get()))); + } + else if (original->getItemTag().compare(XdmfGrid::ItemTag) == 0) { + if (shared_ptr collection = + shared_dynamic_cast(original)) { + return (XdmfItem *)(new XdmfGridCollection(*(shared_dynamic_cast(original).get()))); + } + else if (shared_ptr curvilinear = + shared_dynamic_cast(original)) { + return (XdmfItem *)(new XdmfCurvilinearGrid(*(shared_dynamic_cast(original).get()))); + } + else if(shared_ptr regularGrid = + shared_dynamic_cast(original)) { + return (XdmfItem *)(new XdmfRegularGrid(*(shared_dynamic_cast(original).get()))); + } + else if(shared_ptr rectilinearGrid = + shared_dynamic_cast(original)) { + return (XdmfItem *)(new XdmfRectilinearGrid(*(shared_dynamic_cast(original).get()))); + } + return (XdmfItem *)(new XdmfUnstructuredGrid(*(shared_dynamic_cast(original).get()))); + } + } + return NULL; +} diff --git a/XdmfItemFactory.hpp b/XdmfItemFactory.hpp index 2931d999..cdda30cf 100644 --- a/XdmfItemFactory.hpp +++ b/XdmfItemFactory.hpp @@ -24,6 +24,15 @@ #ifndef XDMFITEMFACTORY_HPP_ #define XDMFITEMFACTORY_HPP_ +// C Compatible Includes +#include "Xdmf.hpp" +#include "XdmfCoreItemFactory.hpp" +#ifdef XDMF_BUILD_DSM + #include "XdmfDSMItemFactory.hpp" +#endif + +#ifdef __cplusplus + // Forward Declarations class XdmfItem; @@ -35,7 +44,11 @@ class XdmfItem; * @brief Factory for constructing XdmfItems from their ItemTag and * ItemProperties. */ +#ifdef XDMF_BUILD_DSM +class XDMF_EXPORT XdmfItemFactory : public XdmfDSMItemFactory { +#else class XDMF_EXPORT XdmfItemFactory : public XdmfCoreItemFactory { +#endif public: @@ -67,6 +80,11 @@ public: const std::map & itemProperties, const std::vector > & childItems) const; + virtual bool isArrayTag(char * tag) const; + + virtual XdmfItem * + DuplicatePointer(shared_ptr original) const; + protected: XdmfItemFactory(); @@ -82,4 +100,6 @@ private: XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + #endif /* XDMFITEMFACTORY_HPP_ */ diff --git a/XdmfMap.cpp b/XdmfMap.cpp index d4999e70..46bbecfb 100644 --- a/XdmfMap.cpp +++ b/XdmfMap.cpp @@ -22,12 +22,14 @@ /*****************************************************************************/ #include +#include #include "XdmfAttribute.hpp" #include "XdmfError.hpp" #include "XdmfGridCollection.hpp" #include "XdmfGridCollectionType.hpp" #include "XdmfHeavyDataController.hpp" #include "XdmfMap.hpp" +#include "XdmfWriter.hpp" shared_ptr XdmfMap::New() @@ -92,6 +94,15 @@ XdmfMap::XdmfMap() : { } +XdmfMap::XdmfMap(XdmfMap & refMap): + mLocalNodeIdsControllers(refMap.mLocalNodeIdsControllers), + mMap(refMap.mMap), + mName(refMap.mName), + mRemoteLocalNodeIdsControllers(refMap.mRemoteLocalNodeIdsControllers), + mRemoteTaskIdsControllers(refMap.mRemoteTaskIdsControllers) +{ +} + XdmfMap::~XdmfMap() { } @@ -142,6 +153,7 @@ XdmfMap::insert(const task_id remoteTaskId, const node_id remoteLocalNodeId) { mMap[remoteTaskId][localNodeId].insert(remoteLocalNodeId); + this->setIsChanged(true); } bool XdmfMap::isInitialized() const @@ -341,18 +353,21 @@ XdmfMap::setHeavyDataControllers(std::vector mRemoteTaskIdsControllers = remoteTaskIdsControllers; mLocalNodeIdsControllers = localNodeIdsControllers; mRemoteLocalNodeIdsControllers = remoteLocalNodeIdsControllers; + this->setIsChanged(true); } void XdmfMap::setMap(std::map map) { mMap = map; + this->setIsChanged(true); } void XdmfMap::setName(const std::string & name) { mName = name; + this->setIsChanged(true); } void @@ -396,10 +411,23 @@ XdmfMap::traverse(const shared_ptr visitor) remoteLocalNodeIds->insert(mRemoteLocalNodeIdsControllers[i]); } + bool originalXPath; + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + originalXPath = writer->getWriteXPaths(); + writer->setWriteXPaths(false); + } + remoteTaskIds->accept(visitor); localNodeIds->accept(visitor); remoteLocalNodeIds->accept(visitor); + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + writer->setWriteXPaths(originalXPath); + } + mLocalNodeIdsControllers.clear(); mRemoteTaskIdsControllers.clear(); mRemoteLocalNodeIdsControllers.clear(); @@ -416,4 +444,264 @@ XdmfMap::traverse(const shared_ptr visitor) { mRemoteLocalNodeIdsControllers.push_back(remoteLocalNodeIds->getHeavyDataController(i)); } + + remoteTaskIds.reset(); + localNodeIds.reset(); + remoteLocalNodeIds.reset(); +} + +// C Wrappers + +XDMFMAP * XdmfMapNew() +{ + try + { + shared_ptr generatedMap = XdmfMap::New(); + return (XDMFMAP *)((void *)(new XdmfMap(*generatedMap.get()))); + } + catch (...) + { + shared_ptr generatedMap = XdmfMap::New(); + return (XDMFMAP *)((void *)(new XdmfMap(*generatedMap.get()))); + } +} + +XDMFMAP ** XdmfMapNewFromIdVector(int ** globalNodeIds, int * numIdsOnNode, int numIds) +{ + try + { + std::vector > insertedAttributeVector; + for (int i = 0; i < numIds; ++i) { + shared_ptr insertedAttribute = XdmfAttribute::New(); + insertedAttribute->insert(0, globalNodeIds[i], numIdsOnNode[i], 1, 1); + insertedAttributeVector.push_back(insertedAttribute); + } + std::vector > generatedMaps = XdmfMap::New(insertedAttributeVector); + unsigned int returnSize = generatedMaps.size(); + XDMFMAP ** returnArray = new XDMFMAP *[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = (XDMFMAP *)((void *)(new XdmfMap(*generatedMaps[i].get()))); + } + return returnArray; + } + catch (...) + { + std::vector > insertedAttributeVector; + for (int i = 0; i < numIds; ++i) { + shared_ptr insertedAttribute = XdmfAttribute::New(); + insertedAttribute->insert(0, globalNodeIds[i], numIdsOnNode[i], 1, 1); + insertedAttributeVector.push_back(insertedAttribute); + } + std::vector > generatedMaps = XdmfMap::New(insertedAttributeVector); + unsigned int returnSize = generatedMaps.size(); + XDMFMAP ** returnArray = new XDMFMAP *[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = (XDMFMAP *)((void *)(new XdmfMap(*generatedMaps[i].get()))); + } + return returnArray; + } +} + +char * XdmfMapGetName(XDMFMAP * map) +{ + try + { + char * returnPointer = strdup(((XdmfMap *)(map))->getName().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfMap *)(map))->getName().c_str()); + return returnPointer; + } +} + +void XdmfMapInsert(XDMFMAP * map, int remoteTaskId, int localNodeId, int remoteLocalNodeId) +{ + ((XdmfMap *)(map))->insert(remoteTaskId, localNodeId, remoteLocalNodeId); +} + +int XdmfMapIsInitialized(XDMFMAP * map) +{ + return ((XdmfMap *)(map))->isInitialized(); +} + +void XdmfMapRead(XDMFMAP * map, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfMap *)(map))->read(); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfMapRelease(XDMFMAP * map) +{ + ((XdmfMap *)(map))->release(); +} + +int * XdmfMapRetrieveLocalNodeIds(XDMFMAP * map, int remoteTaskId) +{ + try + { + int * returnPointer = new int[XdmfMapRetrieveNumberLocalNodeIds(map, remoteTaskId)](); + std::map > > testMap = ((XdmfMap *)(map))->getMap(); + std::map > >::const_iterator iter = testMap.find(remoteTaskId); + unsigned int i = 0; + for(std::map >::const_iterator + iter2 = iter->second.begin(); + iter2 != iter->second.end(); + ++iter2) { + returnPointer[i] = iter2->first; + ++i; + } + return returnPointer; + } + catch (...) + { + int * returnPointer = new int[XdmfMapRetrieveNumberLocalNodeIds(map, remoteTaskId)](); + std::map > > testMap = ((XdmfMap *)(map))->getMap(); + std::map > >::const_iterator iter = testMap.find(remoteTaskId); + unsigned int i = 0; + for(std::map >::const_iterator + iter2 = iter->second.begin(); + iter2 != iter->second.end(); + ++iter2) { + returnPointer[i] = iter2->first; + ++i; + } + return returnPointer; + } +} + +int XdmfMapRetrieveNumberLocalNodeIds(XDMFMAP * map, int remoteTaskId) +{ + return ((XdmfMap *)(map))->getMap()[remoteTaskId].size(); +} + +int XdmfMapRetrieveNumberRemoteTaskIds(XDMFMAP * map) +{ + return ((XdmfMap *)(map))->getMap().size(); +} + +int XdmfMapRetrieveNumberRemoteNodeIds(XDMFMAP * map, int remoteTaskId, int localNodeId) +{ + return ((XdmfMap *)(map))->getMap()[remoteTaskId][localNodeId].size(); +} + +int * XdmfMapRetrieveRemoteTaskIds(XDMFMAP * map) +{ + try + { + int * returnPointer = new int[((XdmfMap *)(map))->getMap().size()](); + std::map > > testMap = ((XdmfMap *)(map))->getMap(); + unsigned int i = 0; + for(std::map > >::const_iterator + iter = testMap.begin(); + iter != testMap.end(); + ++iter) { + returnPointer[i] = iter->first; + ++i; + } + return returnPointer; + } + catch (...) + { + int * returnPointer = new int[((XdmfMap *)(map))->getMap().size()](); + std::map > > testMap = ((XdmfMap *)(map))->getMap(); + unsigned int i = 0; + for(std::map > >::const_iterator + iter = testMap.begin(); + iter != testMap.end(); + ++iter) { + returnPointer[i] = iter->first; + ++i; + } + return returnPointer; + } +} + +int * XdmfMapRetrieveRemoteNodeIds(XDMFMAP * map, int remoteTaskId, int localNodeId) +{ + try + { + int * returnPointer = new int[XdmfMapRetrieveNumberRemoteNodeIds(map, remoteTaskId, localNodeId)](); + std::map > > testMap = ((XdmfMap *)(map))->getMap(); + std::map > >::const_iterator iter = testMap.find(remoteTaskId); + std::map >::const_iterator iter2 = iter->second.find(localNodeId); + unsigned int i = 0; + for(std::map >::mapped_type::const_iterator iter3 = + iter2->second.begin(); + iter3 != iter2->second.end(); + ++iter3) { + returnPointer[i] = *iter3; + i++; + } + return returnPointer; + } + catch (...) + { + int * returnPointer = new int[XdmfMapRetrieveNumberRemoteNodeIds(map, remoteTaskId, localNodeId)](); + std::map > > testMap = ((XdmfMap *)(map))->getMap(); + std::map > >::const_iterator iter = testMap.find(remoteTaskId); + std::map >::const_iterator iter2 = iter->second.find(localNodeId); + unsigned int i = 0; + for(std::map >::mapped_type::const_iterator iter3 = + iter2->second.begin(); + iter3 != iter2->second.end(); + ++iter3) { + returnPointer[i] = *iter3; + i++; + } + return returnPointer; + } +} + +void XdmfMapSetHeavyDataControllers(XDMFMAP * map, + XDMFHEAVYDATACONTROLLER ** remoteTaskControllers, + int numRemoteTaskControllers, + XDMFHEAVYDATACONTROLLER ** localNodeControllers, + int numLocalNodeControllers, + XDMFHEAVYDATACONTROLLER ** remoteLocalNodeControllers, + int numRemoteLocalNodeControllers, + int passControl, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector > insertRemoteTaskControllers; + for (int i = 0; i < numRemoteTaskControllers; ++i) { + if (passControl) { + insertRemoteTaskControllers.push_back(shared_ptr(((XdmfHeavyDataController *)remoteTaskControllers[i]))); + } + else { + insertRemoteTaskControllers.push_back(shared_ptr(((XdmfHeavyDataController *)remoteTaskControllers[i]), XdmfNullDeleter())); + } + } + + std::vector > insertLocalNodeControllers; + for (int i = 0; i < numLocalNodeControllers; ++i) { + if (passControl) { + insertLocalNodeControllers.push_back(shared_ptr(((XdmfHeavyDataController *)localNodeControllers[i]))); + } + else { + insertLocalNodeControllers.push_back(shared_ptr(((XdmfHeavyDataController *)localNodeControllers[i]), XdmfNullDeleter())); + } + } + + std::vector > insertRemoteLocalNodeControllers; + for (int i = 0; i < numRemoteLocalNodeControllers; ++i) { + if (passControl) { + insertRemoteLocalNodeControllers.push_back(shared_ptr(((XdmfHeavyDataController *)remoteLocalNodeControllers[i]))); + } + else { + insertRemoteLocalNodeControllers.push_back(shared_ptr(((XdmfHeavyDataController *)remoteLocalNodeControllers[i]), XdmfNullDeleter())); + } + } + ((XdmfMap *)(map))->setHeavyDataControllers(insertRemoteTaskControllers, insertLocalNodeControllers, insertRemoteLocalNodeControllers); + XDMF_ERROR_WRAP_END(status) } + +void XdmfMapSetName(XDMFMAP * map, char * newName) +{ + ((XdmfMap *)(map))->setName(std::string(newName)); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfMap, XDMFMAP) diff --git a/XdmfMap.hpp b/XdmfMap.hpp index b62c84b3..aca1ae57 100644 --- a/XdmfMap.hpp +++ b/XdmfMap.hpp @@ -24,14 +24,18 @@ #ifndef XDMFMAP_HPP_ #define XDMFMAP_HPP_ +// C Compatible Includes +#include "Xdmf.hpp" +#include "XdmfItem.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfArray; class XdmfAttribute; class XdmfHeavyDataController; // Includes -#include "Xdmf.hpp" -#include "XdmfItem.hpp" #include @@ -394,6 +398,8 @@ public: void traverse(const shared_ptr visitor); + XdmfMap(XdmfMap & map); + protected: XdmfMap(); @@ -417,4 +423,59 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFMAP; // Simply as a typedef to ensure correct typing +typedef struct XDMFMAP XDMFMAP; + +XDMF_EXPORT XDMFMAP * XdmfMapNew(); + +XDMF_EXPORT XDMFMAP ** XdmfMapNewFromIdVector(int ** globalNodeIds, int * numIdsOnNode, int numIds); + +XDMF_EXPORT char * XdmfMapGetName(XDMFMAP * map); + +XDMF_EXPORT void XdmfMapInsert(XDMFMAP * map, int remoteTaskId, int localNodeId, int remoteLocalNodeId); + +XDMF_EXPORT int XdmfMapIsInitialized(XDMFMAP * map); + +XDMF_EXPORT void XdmfMapRead(XDMFMAP * map, int * status); + +XDMF_EXPORT void XdmfMapRelease(XDMFMAP * map); + +XDMF_EXPORT int * XdmfMapRetrieveLocalNodeIds(XDMFMAP * map, int remoteTaskId); + +XDMF_EXPORT int XdmfMapRetrieveNumberLocalNodeIds(XDMFMAP * map, int remoteTaskId); + +XDMF_EXPORT int XdmfMapRetrieveNumberRemoteTaskIds(XDMFMAP * map); + +XDMF_EXPORT int XdmfMapRetrieveNumberRemoteNodeIds(XDMFMAP * map, int remoteTaskId, int localNodeId); + +XDMF_EXPORT int * XdmfMapRetrieveRemoteTaskIds(XDMFMAP * map); + +XDMF_EXPORT int * XdmfMapRetrieveRemoteNodeIds(XDMFMAP * map, int remoteTaskId, int localNodeId); + +XDMF_EXPORT void XdmfMapSetHeavyDataControllers(XDMFMAP * map, + XDMFHEAVYDATACONTROLLER ** remoteTaskControllers, + int numRemoteTaskControllers, + XDMFHEAVYDATACONTROLLER ** localNodeControllers, + int numberLocalNodeControllers, + XDMFHEAVYDATACONTROLLER ** remoteLocalNodeControllers, + int numRemoteLocalNodeControllers, + int passControl, + int * status); + +XDMF_EXPORT void XdmfMapSetName(XDMFMAP * map, char * newName); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfMap, XDMFMAP, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFMAP_HPP_ */ diff --git a/XdmfReader.cpp b/XdmfReader.cpp index 323161da..8af91fdc 100644 --- a/XdmfReader.cpp +++ b/XdmfReader.cpp @@ -37,10 +37,21 @@ XdmfReader::XdmfReader() : { } +XdmfReader::XdmfReader(const XdmfReader &) : + XdmfCoreReader(XdmfItemFactory::New()) +{ +} + XdmfReader::~XdmfReader() { } +XdmfItem * +XdmfReader::DuplicatePointer(shared_ptr original) const +{ + return XdmfCoreReader::DuplicatePointer(original); +} + // Implemented to make SWIG wrapping work correctly // (typemaps to return specific subclass instances of XdmfItems) shared_ptr @@ -55,3 +66,18 @@ XdmfReader::read(const std::string & filePath, { return XdmfCoreReader::read(filePath, xPath); } + +// C Wrappers + +XDMFREADER * XdmfReaderNew() +{ + shared_ptr returnReader = XdmfReader::New(); + return (XDMFREADER *)((void *)(new XdmfReader(*returnReader.get()))); +} + +void XdmfReaderFree(XDMFREADER * item) +{ + delete ((XdmfReader *)item); +} + +XDMF_CORE_READER_C_CHILD_WRAPPER(XdmfReader, XDMFREADER) diff --git a/XdmfReader.hpp b/XdmfReader.hpp index 6ee6a1db..8e4fec24 100644 --- a/XdmfReader.hpp +++ b/XdmfReader.hpp @@ -24,10 +24,12 @@ #ifndef XDMFREADER_HPP_ #define XDMFREADER_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfCoreReader.hpp" +#ifdef __cplusplus + /** * @brief Reads an Xdmf file stored on disk into memory. * @@ -63,19 +65,29 @@ public: virtual ~XdmfReader(); + /** + * Uses the internal item factory to create a copy of the internal pointer + * of the provided shared pointer. Primarily used for C wrapping. + * + * @param original The source shared pointer that the pointer will be pulled from. + * @return A duplicate of the object contained in the pointer. + */ + virtual XdmfItem * DuplicatePointer(shared_ptr original) const; + shared_ptr read(const std::string & filePath) const; std::vector > read(const std::string & filePath, const std::string & xPath) const; + XdmfReader(const XdmfReader &); + protected: XdmfReader(); private: - XdmfReader(const XdmfReader &); // Not implemented. void operator=(const XdmfReader &); // Not implemented. }; @@ -84,4 +96,25 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFREADER; // Simply as a typedef to ensure correct typing +typedef struct XDMFREADER XDMFREADER; + +XDMF_EXPORT XDMFREADER * XdmfReaderNew(); + +XDMF_EXPORT void XdmfReaderFree(XDMFREADER * item); + +XDMF_CORE_READER_C_CHILD_DECLARE(XdmfReader, XDMFREADER, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFREADER_HPP_ */ diff --git a/XdmfRectilinearGrid.cpp b/XdmfRectilinearGrid.cpp index 2ffcb118..8ec1a002 100644 --- a/XdmfRectilinearGrid.cpp +++ b/XdmfRectilinearGrid.cpp @@ -33,7 +33,7 @@ /** * PIMPL */ -class XdmfRectilinearGrid::XdmfRectilinearGridImpl { +class XdmfRectilinearGrid::XdmfRectilinearGridImpl : public XdmfGridImpl { public: @@ -65,16 +65,19 @@ public: return toReturn; } + bool isInitialized() const + { + return true; + } + void traverse(const shared_ptr visitor) { const std::vector > & coordinates = mRectilinearGrid->getCoordinates(); - for(std::vector >::const_iterator iter = - coordinates.begin(); - iter != coordinates.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < coordinates.size(); ++i) + { + coordinates[i]->accept(visitor); } } @@ -119,9 +122,7 @@ public: collectedProperties["Type"] = "VXVY"; } else { - XdmfError::message(XdmfError::FATAL, - "Number of dimensions not 2 or 3 in" - " XdmfGeometryTypeRectilinear::getProperties"); + collectedProperties["Type"] = "VECTORED"; } } @@ -150,6 +151,11 @@ public: return p; } + bool isInitialized() const + { + return true; + } + unsigned int getNumberElements() const { @@ -192,48 +198,19 @@ public: unsigned int getEdgesPerElement() const { - const unsigned int dimensions = - mRectilinearGrid->getDimensions()->getSize(); - if(dimensions == 2) { - return 4; - } - else if(dimensions == 3) { - return 12; - } - else { - XdmfError::message(XdmfError::FATAL, - "Grid dimensions not 2 or 3 in " - "XdmfTopologyTypeRectilinear::getEdgesPerElement"); - } - return 0; + return calculateHypercubeNumElements(mRectilinearGrid->getDimensions()->getSize(), 1); } unsigned int getFacesPerElement() const { - const unsigned int dimensions = - mRectilinearGrid->getDimensions()->getSize(); - if(dimensions == 2) { - return 1; - } - else if(dimensions == 3) { - return 6; - } - else { - XdmfError::message(XdmfError::FATAL, - "Grid dimensions not 2 or 3 in " - "XdmfTopologyTypeRectilinear::getFacesPerElement"); - } - return 0; + return calculateHypercubeNumElements(mRectilinearGrid->getDimensions()->getSize(), 2); } unsigned int getNodesPerElement() const { - // 2^Dimensions - // e.g. 1D = 2 nodes per element and 2D = 4 nodes per element. - return (unsigned int) - std::pow(2, (double)mRectilinearGrid->getDimensions()->getSize()); + return calculateHypercubeNumElements(mRectilinearGrid->getDimensions()->getSize(), 0); } void @@ -248,9 +225,7 @@ public: collectedProperties["Type"] = "2DRectMesh"; } else { - XdmfError::message(XdmfError::FATAL, - "Number of dimensions not 2 or 3 in " - "XdmfTopologyTypeRectilinear::getProperties"); + collectedProperties["Type"] = "RectMesh"; } collectedProperties["Dimensions"] = dimensions->getValuesString(); } @@ -276,10 +251,15 @@ public: XdmfRectilinearGridImpl(const std::vector > & coordinates) : mCoordinates(coordinates.begin(), coordinates.end()) { + mGridType = "Rectilinear"; } - std::vector > mCoordinates; + XdmfGridImpl * duplicate() + { + return new XdmfRectilinearGridImpl(mCoordinates); + } + std::vector > mCoordinates; }; shared_ptr @@ -317,9 +297,16 @@ XdmfRectilinearGrid::New(const std::vector > & axesCoordin XdmfRectilinearGrid::XdmfRectilinearGrid(const std::vector > & axesCoordinates) : XdmfGrid(XdmfRectilinearGridImpl::XdmfGeometryRectilinear::New(this), - XdmfRectilinearGridImpl::XdmfTopologyRectilinear::New(this)), - mImpl(new XdmfRectilinearGridImpl(axesCoordinates)) + XdmfRectilinearGridImpl::XdmfTopologyRectilinear::New(this)) { + mImpl = new XdmfRectilinearGridImpl(axesCoordinates); +} + +XdmfRectilinearGrid::XdmfRectilinearGrid(XdmfRectilinearGrid & refGrid): + XdmfGrid(refGrid) +{ + mTopology = XdmfRectilinearGridImpl::XdmfTopologyRectilinear::New(this); + mGeometry = XdmfRectilinearGridImpl::XdmfGeometryRectilinear::New(this); } XdmfRectilinearGrid::~XdmfRectilinearGrid() @@ -332,6 +319,17 @@ XdmfRectilinearGrid::~XdmfRectilinearGrid() const std::string XdmfRectilinearGrid::ItemTag = "Grid"; +void +XdmfRectilinearGrid::copyGrid(shared_ptr sourceGrid) +{ + XdmfGrid::copyGrid(sourceGrid); + if (shared_ptr classedGrid = shared_dynamic_cast(sourceGrid)) + { + // Copy stucture from read grid to this grid + this->setCoordinates(classedGrid->getCoordinates()); + } +} + shared_ptr XdmfRectilinearGrid::getCoordinates(const unsigned int axisIndex) { @@ -343,8 +341,8 @@ XdmfRectilinearGrid::getCoordinates(const unsigned int axisIndex) shared_ptr XdmfRectilinearGrid::getCoordinates(const unsigned int axisIndex) const { - if(axisIndex < mImpl->mCoordinates.size()) { - return mImpl->mCoordinates[axisIndex]; + if(axisIndex < ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates.size()) { + return ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates[axisIndex]; } return shared_ptr(); } @@ -358,7 +356,7 @@ XdmfRectilinearGrid::getCoordinates() const std::vector > XdmfRectilinearGrid::getCoordinates() const { - return mImpl->mCoordinates; + return ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates; } shared_ptr @@ -372,12 +370,12 @@ shared_ptr XdmfRectilinearGrid::getDimensions() const { shared_ptr dimensions = XdmfArray::New(); - dimensions->reserve(mImpl->mCoordinates.size()); - for(std::vector >::const_iterator iter = - mImpl->mCoordinates.begin(); - iter != mImpl->mCoordinates.end(); - ++iter) { - dimensions->pushBack((*iter)->getSize()); + std::vector > heldCoordinates = + ((XdmfRectilinearGridImpl*)mImpl)->mCoordinates; + dimensions->reserve(heldCoordinates.size()); + for (unsigned int i = 0; i < heldCoordinates.size(); ++i) + { + dimensions->pushBack(heldCoordinates[i]->getSize()); } return dimensions; } @@ -403,23 +401,277 @@ XdmfRectilinearGrid::populateItem(const std::map & ite } } +void +XdmfRectilinearGrid::read() +{ + if (mGridController) + { + if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + // Copy stucture from read grid to this grid + copyGrid(grid); + } + else if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + XdmfError::message(XdmfError::FATAL, "Error: Grid Type Mismatch"); + } + else + { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Grid Reference"); + } + } +} + +void +XdmfRectilinearGrid::release() +{ + XdmfGrid::release(); + ((XdmfRectilinearGridImpl*)mImpl)->mCoordinates.clear(); +} + void XdmfRectilinearGrid::setCoordinates(const unsigned int axisIndex, const shared_ptr axisCoordinates) { - if(mImpl->mCoordinates.size() <= axisIndex) { - mImpl->mCoordinates.reserve(axisIndex + 1); + if(((XdmfRectilinearGridImpl *)mImpl)->mCoordinates.size() <= axisIndex) { + ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates.reserve(axisIndex + 1); unsigned int numArraysToInsert = - axisIndex - mImpl->mCoordinates.size() + 1; + axisIndex - ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates.size() + 1; for(unsigned int i=0; imCoordinates.push_back(XdmfArray::New()); + ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates.push_back(XdmfArray::New()); } } - mImpl->mCoordinates[axisIndex] = axisCoordinates; + ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates[axisIndex] = axisCoordinates; + this->setIsChanged(true); } void XdmfRectilinearGrid::setCoordinates(const std::vector > axesCoordinates) { - mImpl->mCoordinates = axesCoordinates; + ((XdmfRectilinearGridImpl *)mImpl)->mCoordinates = axesCoordinates; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFRECTILINEARGRID * XdmfRectilinearGridNew(XDMFARRAY ** axesCoordinates, unsigned int numCoordinates, int passControl) +{ + try + { + std::vector > holderVector; + for (unsigned int i = 0; i < numCoordinates; ++i) { + if (passControl) { + holderVector.push_back(shared_ptr((XdmfArray *)axesCoordinates[i])); + } + else { + holderVector.push_back(shared_ptr((XdmfArray *)axesCoordinates[i], XdmfNullDeleter())); + } + } + shared_ptr generatedGrid = XdmfRectilinearGrid::New(holderVector); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + catch (...) + { + std::vector > holderVector; + for (unsigned int i = 0; i < numCoordinates; ++i) { + if (passControl) { + holderVector.push_back(shared_ptr((XdmfArray *)axesCoordinates[i])); + } + else { + holderVector.push_back(shared_ptr((XdmfArray *)axesCoordinates[i], XdmfNullDeleter())); + } + } + shared_ptr generatedGrid = XdmfRectilinearGrid::New(holderVector); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } +} + +XDMFRECTILINEARGRID * XdmfRectilinearGridNew2D(XDMFARRAY * xCoordinates, XDMFARRAY * yCoordinates, int passControl) +{ + try + { + if (passControl) { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates), + shared_ptr((XdmfArray *)yCoordinates)); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + else { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates, XdmfNullDeleter()), + shared_ptr((XdmfArray *)yCoordinates, XdmfNullDeleter())); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + } + catch (...) + { + if (passControl) { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates), + shared_ptr((XdmfArray *)yCoordinates)); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + else { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates, XdmfNullDeleter()), + shared_ptr((XdmfArray *)yCoordinates, XdmfNullDeleter())); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + } +} + +XDMFRECTILINEARGRID * XdmfRectilinearGridNew3D(XDMFARRAY * xCoordinates, XDMFARRAY * yCoordinates, XDMFARRAY * zCoordinates, int passControl) +{ + try + { + if (passControl) { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates), + shared_ptr((XdmfArray *)yCoordinates), + shared_ptr((XdmfArray *)zCoordinates)); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + else { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates, XdmfNullDeleter()), + shared_ptr((XdmfArray *)yCoordinates, XdmfNullDeleter()), + shared_ptr((XdmfArray *)zCoordinates, XdmfNullDeleter())); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + } + catch (...) + { + if (passControl) { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates), + shared_ptr((XdmfArray *)yCoordinates), + shared_ptr((XdmfArray *)zCoordinates)); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + else { + shared_ptr generatedGrid = XdmfRectilinearGrid::New(shared_ptr((XdmfArray *)xCoordinates, XdmfNullDeleter()), + shared_ptr((XdmfArray *)yCoordinates, XdmfNullDeleter()), + shared_ptr((XdmfArray *)zCoordinates, XdmfNullDeleter())); + return (XDMFRECTILINEARGRID *)((void *)((XdmfItem *)(new XdmfRectilinearGrid(*generatedGrid.get())))); + } + } +} + +XDMFARRAY * XdmfRectilinearGridGetCoordinatesByIndex(XDMFRECTILINEARGRID * grid, unsigned int axisIndex, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedPointer); + return (XDMFARRAY *)((void *)(gridPointer->getCoordinates(axisIndex).get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY ** XdmfRectilinearGridGetCoordinates(XDMFRECTILINEARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + XDMFARRAY ** returnPointer; + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedPointer); + std::vector > heldCoordinates = gridPointer->getCoordinates(); + returnPointer = new XDMFARRAY *[heldCoordinates.size()](); + for (unsigned int i = 0; i < heldCoordinates.size(); ++i) { + XDMFARRAY * insertArray = (XDMFARRAY *)((void *)(new XdmfArray(*(heldCoordinates[i].get())))); + returnPointer[i] = insertArray; + } + return returnPointer; + } + catch (...) + { + XDMFARRAY ** returnPointer; + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedPointer); + std::vector > heldCoordinates = gridPointer->getCoordinates(); + returnPointer = new XDMFARRAY *[heldCoordinates.size()](); + for (unsigned int i = 0; i < heldCoordinates.size(); ++i) { + XDMFARRAY * insertArray = (XDMFARRAY *)((void *)(new XdmfArray(*(heldCoordinates[i].get())))); + returnPointer[i] = insertArray; + } + return returnPointer; + } + XDMF_ERROR_WRAP_END(status) + return NULL; } + +int XdmfRectilinearGridGetNumberCoordinates(XDMFRECTILINEARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedPointer); + std::vector > heldCoordinates = gridPointer->getCoordinates(); + return heldCoordinates.size(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +XDMFARRAY * XdmfRectilinearGridGetDimensions(XDMFRECTILINEARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + XdmfArray * copyArray; + shared_ptr returnDimensions; + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * classedGrid = dynamic_cast(classedPointer); + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedGrid); + XDMFARRAY * returnArray; + returnDimensions = gridPointer->getDimensions(); + copyArray = new XdmfArray(*(returnDimensions.get())); + void * copyVoid = (void *)copyArray; + returnArray = (XDMFARRAY *) copyVoid; + returnDimensions.reset(); + return returnArray; + } + catch (...) + { + XdmfArray * copyArray; + shared_ptr returnDimensions; + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfGrid * classedGrid = dynamic_cast(classedPointer); + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedGrid); + XDMFARRAY * returnArray; + returnDimensions = gridPointer->getDimensions(); + copyArray = new XdmfArray(*(returnDimensions.get())); + void * copyVoid = (void *)copyArray; + returnArray = (XDMFARRAY *) copyVoid; + returnDimensions.reset(); + return returnArray; + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +void XdmfRectilinearGridSetCoordinates(XDMFRECTILINEARGRID * grid, XDMFARRAY ** axesCoordinates, unsigned int numCoordinates, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedPointer); + std::vector > holderVector; + for (unsigned int i = 0; i < numCoordinates; ++i) { + if (passControl) { + holderVector.push_back(shared_ptr((XdmfArray *)axesCoordinates[i])); + } + else { + holderVector.push_back(shared_ptr((XdmfArray *)axesCoordinates[i], XdmfNullDeleter())); + } + } + gridPointer->setCoordinates(holderVector); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfRectilinearGridSetCoordinatesByIndex(XDMFRECTILINEARGRID * grid, unsigned int index, XDMFARRAY * coordinates, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRectilinearGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setCoordinates(index, shared_ptr((XdmfArray *)coordinates)); + } + else { + gridPointer->setCoordinates(index, shared_ptr((XdmfArray *)coordinates, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfRectilinearGrid, XDMFRECTILINEARGRID) +XDMF_GRID_C_CHILD_WRAPPER(XdmfRectilinearGrid, XDMFRECTILINEARGRID) diff --git a/XdmfRectilinearGrid.hpp b/XdmfRectilinearGrid.hpp index 05d44269..d5062e07 100644 --- a/XdmfRectilinearGrid.hpp +++ b/XdmfRectilinearGrid.hpp @@ -24,13 +24,15 @@ #ifndef XDMFRECTILINEARGRID_HPP_ #define XDMFRECTILINEARGRID_HPP_ -// Forward Declarations -class XdmfArray; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfGrid.hpp" +#ifdef __cplusplus + +// Forward Declarations +class XdmfArray; + /** * @brief A rectilinear grid consists of cells and points arranged on * a regular lattice in space. @@ -306,6 +308,10 @@ public: */ shared_ptr getDimensions() const; + virtual void read(); + + virtual void release(); + /** * Set the coordinates of the grid along a single axis. * @@ -370,10 +376,14 @@ public: void setCoordinates(const std::vector > axesCoordinates); + XdmfRectilinearGrid(XdmfRectilinearGrid &); + protected: XdmfRectilinearGrid(const std::vector > & axesCoordinates); + void copyGrid(shared_ptr sourceGrid); + void populateItem(const std::map & itemProperties, const std::vector > & childItems, const XdmfCoreReader * const reader); @@ -388,8 +398,6 @@ private: XdmfRectilinearGrid(const XdmfRectilinearGrid &); // Not implemented. void operator=(const XdmfRectilinearGrid &); // Not implemented. - XdmfRectilinearGridImpl * mImpl; - }; #ifdef _WIN32 @@ -399,4 +407,40 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFRECTILINEARGRID; // Simply as a typedef to ensure correct typing +typedef struct XDMFRECTILINEARGRID XDMFRECTILINEARGRID; + +XDMF_EXPORT XDMFRECTILINEARGRID * XdmfRectilinearGridNew(XDMFARRAY ** axesCoordinates, unsigned int numCoordinates, int passControl); + +XDMF_EXPORT XDMFRECTILINEARGRID * XdmfRectilinearGridNew2D(XDMFARRAY * xCoordinates, XDMFARRAY * yCoordinates, int passControl); + +XDMF_EXPORT XDMFRECTILINEARGRID * XdmfRectilinearGridNew3D(XDMFARRAY * xCoordinates, XDMFARRAY * yCoordinates, XDMFARRAY * zCoordinates, int passControl); + +XDMF_EXPORT XDMFARRAY * XdmfRectilinearGridGetCoordinatesByIndex(XDMFRECTILINEARGRID * grid, unsigned int axisIndex, int * status); + +XDMF_EXPORT XDMFARRAY ** XdmfRectilinearGridGetCoordinates(XDMFRECTILINEARGRID * grid, int * status); + +XDMF_EXPORT int XdmfRectilinearGridGetNumberCoordinates(XDMFRECTILINEARGRID * grid, int * status); + +XDMF_EXPORT XDMFARRAY * XdmfRectilinearGridGetDimensions(XDMFRECTILINEARGRID * grid, int * status); + +XDMF_EXPORT void XdmfRectilinearGridSetCoordinates(XDMFRECTILINEARGRID * grid, XDMFARRAY ** axesCoordinates, unsigned int numCoordinates, int passControl, int * status); + +XDMF_EXPORT void XdmfRectilinearGridSetCoordinatesByIndex(XDMFRECTILINEARGRID * grid, unsigned int index, XDMFARRAY * coordinates, int passControl, int * status); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfRectilinearGrid, XDMFRECTILINEARGRID, XDMF) +XDMF_GRID_C_CHILD_DECLARE(XdmfRectilinearGrid, XDMFRECTILINEARGRID, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFRECTILINEARGRID_HPP_ */ diff --git a/XdmfRegularGrid.cpp b/XdmfRegularGrid.cpp index 3020d597..ebfa6cf1 100644 --- a/XdmfRegularGrid.cpp +++ b/XdmfRegularGrid.cpp @@ -33,7 +33,7 @@ /** * PIMPL */ -class XdmfRegularGrid::XdmfRegularGridImpl { +class XdmfRegularGrid::XdmfRegularGridImpl : public XdmfGridImpl { public: @@ -64,6 +64,11 @@ public: return toReturn; } + bool isInitialized() const + { + return true; + } + void traverse(const shared_ptr visitor) { @@ -114,9 +119,8 @@ public: collectedProperties["Type"] = "ORIGIN_DXDY"; } else { - XdmfError::message(XdmfError::FATAL, - "Dimensions not 2 or 3 in " - "XdmfGeometryTypeRegular::getProperties"); + collectedProperties["Type"] = "ORIGIN_DISPLACEMENT"; +// XdmfError::message(XdmfError::FATAL, "Dimensions not 2 or 3 in XdmfGeometryTypeRegular::getProperties"); } } @@ -144,6 +148,11 @@ public: return p; } + bool isInitialized() const + { + return true; + } + unsigned int getNumberElements() const { @@ -186,46 +195,19 @@ public: unsigned int getEdgesPerElement() const { - const unsigned int dimensions = mRegularGrid->getDimensions()->getSize(); - if(dimensions == 2) { - return 4; - } - else if(dimensions == 3) { - return 12; - } - else { - XdmfError::message(XdmfError::FATAL, - "Grid dimensions not 2 or 3 in " - "XdmfTopologyTypeRegular::getEdgesPerElement"); - } - return 0; + return calculateHypercubeNumElements(mRegularGrid->getDimensions()->getSize(), 1); } unsigned int getFacesPerElement() const { - const unsigned int dimensions = mRegularGrid->getDimensions()->getSize(); - if(dimensions == 2) { - return 1; - } - else if(dimensions == 3) { - return 6; - } - else { - XdmfError::message(XdmfError::FATAL, - "Grid dimensions not 2 or 3 in " - "XdmfTopologyTypeRegular::getFacesPerElement"); - } - return 0; + return calculateHypercubeNumElements(mRegularGrid->getDimensions()->getSize(), 2); } unsigned int getNodesPerElement() const { - // 2^Dimensions - // e.g. 1D = 2 nodes per element and 2D = 4 nodes per element. - return (unsigned int) - std::pow(2, (double)mRegularGrid->getDimensions()->getSize()); + return calculateHypercubeNumElements(mRegularGrid->getDimensions()->getSize(), 0); } void @@ -239,9 +221,11 @@ public: collectedProperties["Type"] = "2DCoRectMesh"; } else { - XdmfError::message(XdmfError::FATAL, - "Dimensions not 2 or 3 in " - "XdmfTopologyTypeRegular::getProperties"); + // If not 2 or 3 just mark it as a mesh of unknown dims + collectedProperties["Type"] = "CoRectMesh"; +// XdmfError::message(XdmfError::FATAL, +// "Dimensions not 2 or 3 in " +// "XdmfTopologyTypeRegular::getProperties"); } collectedProperties["Dimensions"] = dimensions->getValuesString(); } @@ -265,12 +249,17 @@ public: mDimensions(numPoints), mOrigin(origin) { + mGridType = "Regular"; + } + + XdmfGridImpl * duplicate() + { + return new XdmfRegularGridImpl(mBrickSize, mDimensions, mOrigin); } shared_ptr mBrickSize; shared_ptr mDimensions; shared_ptr mOrigin; - }; shared_ptr @@ -282,15 +271,15 @@ XdmfRegularGrid::New(const double xBrickSize, const double yOrigin) { shared_ptr brickSize = XdmfArray::New(); - brickSize->resize(2); + brickSize->resize(2, (double)0); brickSize->insert(0, xBrickSize); brickSize->insert(1, yBrickSize); shared_ptr numPoints = XdmfArray::New(); - numPoints->resize(2); + numPoints->resize(2, (unsigned int)0); numPoints->insert(0, xNumPoints); numPoints->insert(1, yNumPoints); shared_ptr origin = XdmfArray::New(); - origin->resize(2); + origin->resize(2, (double)0); origin->insert(0, xOrigin); origin->insert(1, yOrigin); shared_ptr p(new XdmfRegularGrid(brickSize, @@ -311,17 +300,17 @@ XdmfRegularGrid::New(const double xBrickSize, const double zOrigin) { shared_ptr brickSize = XdmfArray::New(); - brickSize->resize(3); + brickSize->resize(3, (double)0); brickSize->insert(0, xBrickSize); brickSize->insert(1, yBrickSize); brickSize->insert(2, zBrickSize); shared_ptr numPoints = XdmfArray::New(); - numPoints->resize(3); + numPoints->resize(3, (unsigned int)0); numPoints->insert(0, xNumPoints); numPoints->insert(1, yNumPoints); numPoints->insert(2, zNumPoints); shared_ptr origin = XdmfArray::New(); - origin->resize(3); + origin->resize(3, (double)0); origin->insert(0, xOrigin); origin->insert(1, yOrigin); origin->insert(2, zOrigin); @@ -346,9 +335,16 @@ XdmfRegularGrid::XdmfRegularGrid(const shared_ptr brickSize, const shared_ptr numPoints, const shared_ptr origin) : XdmfGrid(XdmfRegularGridImpl::XdmfGeometryRegular::New(this), - XdmfRegularGridImpl::XdmfTopologyRegular::New(this)), - mImpl(new XdmfRegularGridImpl(brickSize, numPoints, origin)) + XdmfRegularGridImpl::XdmfTopologyRegular::New(this)) { + mImpl = new XdmfRegularGridImpl(brickSize, numPoints, origin); +} + +XdmfRegularGrid::XdmfRegularGrid(XdmfRegularGrid & refGrid) : + XdmfGrid(refGrid) +{ + mGeometry = XdmfRegularGridImpl::XdmfGeometryRegular::New(this); + mTopology = XdmfRegularGridImpl::XdmfTopologyRegular::New(this); } XdmfRegularGrid::~XdmfRegularGrid() @@ -361,6 +357,19 @@ XdmfRegularGrid::~XdmfRegularGrid() const std::string XdmfRegularGrid::ItemTag = "Grid"; +void +XdmfRegularGrid::copyGrid(shared_ptr sourceGrid) +{ + XdmfGrid::copyGrid(sourceGrid); + if (shared_ptr classedGrid = shared_dynamic_cast(sourceGrid)) + { + // Copy stucture from read grid to this grid + this->setOrigin(classedGrid->getOrigin()); + this->setDimensions(classedGrid->getDimensions()); + this->setBrickSize(classedGrid->getBrickSize()); + } +} + shared_ptr XdmfRegularGrid::getBrickSize() { @@ -371,7 +380,7 @@ XdmfRegularGrid::getBrickSize() shared_ptr XdmfRegularGrid::getBrickSize() const { - return mImpl->mBrickSize; + return ((XdmfRegularGridImpl *)mImpl)->mBrickSize; } shared_ptr @@ -384,7 +393,7 @@ XdmfRegularGrid::getDimensions() shared_ptr XdmfRegularGrid::getDimensions() const { - return mImpl->mDimensions; + return ((XdmfRegularGridImpl *)mImpl)->mDimensions; } shared_ptr @@ -397,7 +406,7 @@ XdmfRegularGrid::getOrigin() shared_ptr XdmfRegularGrid::getOrigin() const { - return mImpl->mOrigin; + return ((XdmfRegularGridImpl *)mImpl)->mOrigin; } void @@ -414,34 +423,251 @@ XdmfRegularGrid::populateItem(const std::map & itemPro if(shared_ptr regularGrid = shared_dynamic_cast(*iter)) { if(regularGrid->getBrickSize()) { - mImpl->mBrickSize = regularGrid->getBrickSize(); + ((XdmfRegularGridImpl *)mImpl)->mBrickSize = regularGrid->getBrickSize(); } if(regularGrid->getDimensions()) { - mImpl->mDimensions = regularGrid->getDimensions(); + ((XdmfRegularGridImpl *)mImpl)->mDimensions = regularGrid->getDimensions(); } if(regularGrid->getOrigin()) { - mImpl->mOrigin = regularGrid->getOrigin(); + ((XdmfRegularGridImpl *)mImpl)->mOrigin = regularGrid->getOrigin(); } } } } +void +XdmfRegularGrid::read() +{ + if (mGridController) + { + if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + // Copy stucture from read grid to this grid + copyGrid(grid); + } + else if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + XdmfError::message(XdmfError::FATAL, "Error: Grid Type Mismatch"); + } + else + { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Grid Reference"); + } + } +} + +void +XdmfRegularGrid::release() +{ + XdmfGrid::release(); + this->setOrigin(shared_ptr()); + this->setDimensions(shared_ptr()); + this->setBrickSize(shared_ptr()); +} + void XdmfRegularGrid::setBrickSize(const shared_ptr brickSize) { - mImpl->mBrickSize = brickSize; + ((XdmfRegularGridImpl *)mImpl)->mBrickSize = brickSize; + this->setIsChanged(true); } void XdmfRegularGrid::setDimensions(const shared_ptr dimensions) { - mImpl->mDimensions = dimensions; + ((XdmfRegularGridImpl *)mImpl)->mDimensions = dimensions; + this->setIsChanged(true); } void XdmfRegularGrid::setOrigin(const shared_ptr origin) { - mImpl->mOrigin = origin; + ((XdmfRegularGridImpl *)mImpl)->mOrigin = origin; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFREGULARGRID * XdmfRegularGridNew2D(double xBrickSize, + double yBrickSize, + unsigned int xNumPoints, + unsigned int yNumPoints, + double xOrigin, + double yOrigin) +{ + try + { + shared_ptr generatedGrid = XdmfRegularGrid::New(xBrickSize, + yBrickSize, + xNumPoints, + yNumPoints, + xOrigin, + yOrigin); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } + catch (...) + { + shared_ptr generatedGrid = XdmfRegularGrid::New(xBrickSize, + yBrickSize, + xNumPoints, + yNumPoints, + xOrigin, + yOrigin); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } +} + +XDMFREGULARGRID * XdmfRegularGridNew3D(double xBrickSize, + double yBrickSize, + double zBrickSize, + unsigned int xNumPoints, + unsigned int yNumPoints, + unsigned int zNumPoints, + double xOrigin, + double yOrigin, + double zOrigin) +{ + try + { + shared_ptr generatedGrid = XdmfRegularGrid::New(xBrickSize, + yBrickSize, + zBrickSize, + xNumPoints, + yNumPoints, + zNumPoints, + xOrigin, + yOrigin, + zOrigin); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } + catch (...) + { + shared_ptr generatedGrid = XdmfRegularGrid::New(xBrickSize, + yBrickSize, + zBrickSize, + xNumPoints, + yNumPoints, + zNumPoints, + xOrigin, + yOrigin, + zOrigin); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } +} + +XDMFREGULARGRID * XdmfRegularGridNew(XDMFARRAY * brickSize, + XDMFARRAY * numPoints, + XDMFARRAY * origin, + int passControl) +{ + try + { + if (passControl) { + shared_ptr generatedGrid = XdmfRegularGrid::New(shared_ptr((XdmfArray *)brickSize), + shared_ptr((XdmfArray *)numPoints), + shared_ptr((XdmfArray *)origin)); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } + else { + shared_ptr generatedGrid = XdmfRegularGrid::New(shared_ptr((XdmfArray *)brickSize, XdmfNullDeleter()), + shared_ptr((XdmfArray *)numPoints, XdmfNullDeleter()), + shared_ptr((XdmfArray *)origin, XdmfNullDeleter())); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } + } + catch (...) + { + if (passControl) { + shared_ptr generatedGrid = XdmfRegularGrid::New(shared_ptr((XdmfArray *)brickSize), + shared_ptr((XdmfArray *)numPoints), + shared_ptr((XdmfArray *)origin)); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } + else { + shared_ptr generatedGrid = XdmfRegularGrid::New(shared_ptr((XdmfArray *)brickSize, XdmfNullDeleter()), + shared_ptr((XdmfArray *)numPoints, XdmfNullDeleter()), + shared_ptr((XdmfArray *)origin, XdmfNullDeleter())); + return (XDMFREGULARGRID *)((void *)((XdmfItem *)(new XdmfRegularGrid(*generatedGrid.get())))); + } + } +} + +XDMFARRAY * XdmfRegularGridGetBrickSize(XDMFREGULARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRegularGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedBrick = gridPointer->getBrickSize(); + return (XDMFARRAY *)((void *)(generatedBrick.get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfRegularGridGetDimensions(XDMFREGULARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRegularGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedDimensions = gridPointer->getDimensions(); + return (XDMFARRAY *)((void *)(generatedDimensions.get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfRegularGridGetOrigin(XDMFREGULARGRID * grid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRegularGrid * gridPointer = dynamic_cast(classedPointer); + shared_ptr generatedOrigin = gridPointer->getOrigin(); + return (XDMFARRAY *)((void *)(generatedOrigin.get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +void XdmfRegularGridSetBrickSize(XDMFREGULARGRID * grid, XDMFARRAY * brickSize, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRegularGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setBrickSize(shared_ptr((XdmfArray *)brickSize)); + } + else { + gridPointer->setBrickSize(shared_ptr((XdmfArray *)brickSize, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) } + +void XdmfRegularGridSetDimensions(XDMFREGULARGRID * grid, XDMFARRAY * dimensions, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRegularGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setDimensions(shared_ptr((XdmfArray *)dimensions)); + } + else { + gridPointer->setDimensions(shared_ptr((XdmfArray *)dimensions, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfRegularGridSetOrigin(XDMFREGULARGRID * grid, XDMFARRAY * origin, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfItem * classedPointer = (XdmfItem *)grid; + XdmfRegularGrid * gridPointer = dynamic_cast(classedPointer); + if (passControl) { + gridPointer->setOrigin(shared_ptr((XdmfArray *)origin)); + } + else { + gridPointer->setOrigin(shared_ptr((XdmfArray *)origin, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfRegularGrid, XDMFREGULARGRID) +XDMF_GRID_C_CHILD_WRAPPER(XdmfRegularGrid, XDMFREGULARGRID) diff --git a/XdmfRegularGrid.hpp b/XdmfRegularGrid.hpp index 4d09e795..a4cd194c 100644 --- a/XdmfRegularGrid.hpp +++ b/XdmfRegularGrid.hpp @@ -24,13 +24,15 @@ #ifndef XDMFREGULARGRID_HPP_ #define XDMFREGULARGRID_HPP_ -// Forward Declarations -class XdmfArray; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfGrid.hpp" +#ifdef __cplusplus + +// Forward Declarations +class XdmfArray; + /** * @brief A regular grid consists of congruent points arranged * regularly in space. @@ -314,6 +316,10 @@ public: */ shared_ptr getOrigin() const; + virtual void read(); + + virtual void release(); + /** * Set the size of the points composing the grid. * @@ -394,12 +400,17 @@ public: */ void setOrigin(const shared_ptr origin); + XdmfRegularGrid(XdmfRegularGrid &); + protected: XdmfRegularGrid(const shared_ptr brickSize, const shared_ptr numPoints, const shared_ptr origin); + virtual void + copyGrid(shared_ptr sourceGrid); + void populateItem(const std::map & itemProperties, const std::vector > & childItems, const XdmfCoreReader * const reader); @@ -414,8 +425,6 @@ private: XdmfRegularGrid(const XdmfRegularGrid &); // Not implemented. void operator=(const XdmfRegularGrid &); // Not implemented. - XdmfRegularGridImpl * mImpl; - }; #ifdef _WIN32 @@ -425,4 +434,56 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFREGULARGRID; // Simply as a typedef to ensure correct typing +typedef struct XDMFREGULARGRID XDMFREGULARGRID; + +XDMF_EXPORT XDMFREGULARGRID * XdmfRegularGridNew2D(double xBrickSize, + double yBrickSize, + unsigned int xNumPoints, + unsigned int yNumPoints, + double xOrigin, + double yOrigin); + +XDMF_EXPORT XDMFREGULARGRID * XdmfRegularGridNew3D(double xBrickSize, + double yBrickSize, + double zBrickSize, + unsigned int xNumPoints, + unsigned int yNumPoints, + unsigned int zNumPoints, + double xOrigin, + double yOrigin, + double zOrigin); + +XDMF_EXPORT XDMFREGULARGRID * XdmfRegularGridNew(XDMFARRAY * brickSize, + XDMFARRAY * numPoints, + XDMFARRAY * origin, + int passControl); + +XDMF_EXPORT XDMFARRAY * XdmfRegularGridGetBrickSize(XDMFREGULARGRID * grid, int * status); + +XDMF_EXPORT XDMFARRAY * XdmfRegularGridGetDimensions(XDMFREGULARGRID * grid, int * status); + +XDMF_EXPORT XDMFARRAY * XdmfRegularGridGetOrigin(XDMFREGULARGRID * grid, int * status); + +XDMF_EXPORT void XdmfRegularGridSetBrickSize(XDMFREGULARGRID * grid, XDMFARRAY * brickSize, int passControl, int * status); + +XDMF_EXPORT void XdmfRegularGridSetDimensions(XDMFREGULARGRID * grid, XDMFARRAY * dimensions, int passControl, int * status); + +XDMF_EXPORT void XdmfRegularGridSetOrigin(XDMFREGULARGRID * grid, XDMFARRAY * origin, int passControl, int * status); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfRegularGrid, XDMFREGULARGRID, XDMF) +XDMF_GRID_C_CHILD_DECLARE(XdmfRegularGrid, XDMFREGULARGRID, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFREGULARGRID_HPP_ */ diff --git a/XdmfSet.cpp b/XdmfSet.cpp index 99b61903..93c9bfd8 100644 --- a/XdmfSet.cpp +++ b/XdmfSet.cpp @@ -43,6 +43,13 @@ XdmfSet::XdmfSet() : { } +XdmfSet::XdmfSet(XdmfSet & refSet) : + XdmfArray(refSet), + mName(refSet.mName), + mType(refSet.mType) +{ +} + XdmfSet::~XdmfSet() { } @@ -116,22 +123,129 @@ void XdmfSet::setName(const std::string & name) { mName = name; + this->setIsChanged(true); } void XdmfSet::setType(const shared_ptr type) { mType = type; + this->setIsChanged(true); } void XdmfSet::traverse(const shared_ptr visitor) { XdmfItem::traverse(visitor); - for(std::vector >::const_iterator iter = - mAttributes.begin(); - iter != mAttributes.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mAttributes.size(); ++i) + { + mAttributes[i]->accept(visitor); + } +} + +// C Wrappers + +XDMFSET * XdmfSetNew() +{ + try + { + shared_ptr generatedSet = XdmfSet::New(); + return (XDMFSET*)((void *)(new XdmfSet(*generatedSet.get()))); + } + catch (...) + { + shared_ptr generatedSet = XdmfSet::New(); + return (XDMFSET*)((void *)(new XdmfSet(*generatedSet.get()))); } } + +XDMFATTRIBUTE * XdmfSetGetAttribute(XDMFSET * set, unsigned int index) +{ + return (XDMFATTRIBUTE *)((void *)(((XdmfSet *)(set))->getAttribute(index).get())); +} + +XDMFATTRIBUTE * XdmfSetGetAttributeByName(XDMFSET * set, char * Name) +{ + return (XDMFATTRIBUTE *)((void *)(((XdmfSet *)(set))->getAttribute(Name).get())); +} + +unsigned int XdmfSetGetNumberAttributes(XDMFSET * set) +{ + return ((XdmfSet *)(set))->getNumberAttributes(); +} + +int XdmfSetGetType(XDMFSET * set) +{ + shared_ptr checkType = ((XdmfSet *)set)->getType(); + + if (checkType == XdmfSetType::NoSetType()) { + return XDMF_SET_TYPE_NO_SET_TYPE; + } + else if (checkType == XdmfSetType::Node()) { + return XDMF_SET_TYPE_NODE; + } + else if (checkType == XdmfSetType::Cell()) { + return XDMF_SET_TYPE_CELL; + } + else if (checkType == XdmfSetType::Face()) { + return XDMF_SET_TYPE_FACE; + } + else if (checkType == XdmfSetType::Edge()) { + return XDMF_SET_TYPE_EDGE; + } + else { + return -1; + } +} + +void XdmfSetInsertAttribute(XDMFSET * set, XDMFATTRIBUTE * Attribute, int passControl) +{ + if (passControl) { + ((XdmfSet *)(set))->insert(shared_ptr((XdmfAttribute *)Attribute)); + } + else { + ((XdmfSet *)(set))->insert(shared_ptr((XdmfAttribute *)Attribute, XdmfNullDeleter())); + } +} + +void XdmfSetRemoveAttribute(XDMFSET * set, unsigned int index) +{ + ((XdmfSet *)(set))->removeAttribute(index); +} + +void XdmfSetRemoveAttributeByName(XDMFSET * set, char * Name) +{ + ((XdmfSet *)(set))->removeAttribute(Name); +} + +void XdmfSetSetType(XDMFSET * set, int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr newType = shared_ptr(); + switch (type) { + case XDMF_SET_TYPE_NO_SET_TYPE: + newType = XdmfSetType::NoSetType(); + break; + case XDMF_SET_TYPE_NODE: + newType = XdmfSetType::Node(); + break; + case XDMF_SET_TYPE_CELL: + newType = XdmfSetType::Cell(); + break; + case XDMF_SET_TYPE_FACE: + newType = XdmfSetType::Face(); + break; + case XDMF_SET_TYPE_EDGE: + newType = XdmfSetType::Edge(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Set Type: Code " + type); + break; + } + ((XdmfSet *)set)->setType(newType); + XDMF_ERROR_WRAP_END(status) +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfSet, XDMFSET) +XDMF_ARRAY_C_CHILD_WRAPPER(XdmfSet, XDMFSET) diff --git a/XdmfSet.hpp b/XdmfSet.hpp index 33e0a7eb..3a7f3abc 100644 --- a/XdmfSet.hpp +++ b/XdmfSet.hpp @@ -24,14 +24,17 @@ #ifndef XDMFSET_HPP_ #define XDMFSET_HPP_ +// C Compatible Includes +#include "Xdmf.hpp" +#include "XdmfArray.hpp" +#include "XdmfAttribute.hpp" +#include "XdmfSetType.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfAttribute; class XdmfHDF5Controller; -class XdmfSetType; - -// Includes -#include "Xdmf.hpp" -#include "XdmfArray.hpp" /** * @brief Holds a collection of individual nodes, cells, faces, or @@ -195,6 +198,8 @@ public: void traverse(const shared_ptr visitor); + XdmfSet(XdmfSet &); + protected: XdmfSet(); @@ -206,7 +211,7 @@ protected: private: - XdmfSet(const XdmfSet &); // Not implemented. + XdmfSet(const XdmfSet &); void operator=(const XdmfSet &); // Not implemented. std::string mName; @@ -223,4 +228,40 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFSET; // Simply as a typedef to ensure correct typing +typedef struct XDMFSET XDMFSET; + +XDMF_EXPORT XDMFSET * XdmfSetNew(); + +XDMF_EXPORT XDMFATTRIBUTE * XdmfSetGetAttribute(XDMFSET * set, unsigned int index); + +XDMF_EXPORT XDMFATTRIBUTE * XdmfSetGetAttributeByName(XDMFSET * set, char * Name); + +XDMF_EXPORT unsigned int XdmfSetGetNumberAttributes(XDMFSET * set); + +XDMF_EXPORT int XdmfSetGetType(XDMFSET * set); + +XDMF_EXPORT void XdmfSetInsertAttribute(XDMFSET * set, XDMFATTRIBUTE * Attribute, int passControl); + +XDMF_EXPORT void XdmfSetRemoveAttribute(XDMFSET * set, unsigned int index); + +XDMF_EXPORT void XdmfSetRemoveAttributeByName(XDMFSET * set, char * Name); + +XDMF_EXPORT void XdmfSetSetType(XDMFSET * set, int type, int * status); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfSet, XDMFSET, XDMF) +XDMF_ARRAY_C_CHILD_DECLARE(XdmfSet, XDMFSET, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFSET_HPP_ */ diff --git a/XdmfSetType.cpp b/XdmfSetType.cpp index f100c049..5e808969 100644 --- a/XdmfSetType.cpp +++ b/XdmfSetType.cpp @@ -25,6 +25,8 @@ #include "XdmfSetType.hpp" #include "XdmfError.hpp" +std::map(*)()> XdmfSetType::mSetDefinitions; + // Supported XdmfSetTypes shared_ptr XdmfSetType::NoSetType() @@ -61,6 +63,16 @@ XdmfSetType::Edge() return p; } +void +XdmfSetType::InitTypes() +{ + mSetDefinitions["NONE"] = NoSetType; + mSetDefinitions["NODE"] = Node; + mSetDefinitions["CELL"] = Cell; + mSetDefinitions["FACE"] = Face; + mSetDefinitions["EDGE"] = Edge; +} + XdmfSetType::XdmfSetType(const std::string & name) : mName(name) { @@ -73,6 +85,8 @@ XdmfSetType::~XdmfSetType() shared_ptr XdmfSetType::New(const std::map & itemProperties) { + InitTypes(); + std::map::const_iterator type = itemProperties.find("Type"); if(type == itemProperties.end()) { @@ -83,22 +97,18 @@ XdmfSetType::New(const std::map & itemProperties) "Neither 'Type' nor 'SetType' found in itemProperties " "in XdmfSetType::New"); } - const std::string & typeVal = type->second; + const std::string & typeVal = ConvertToUpper(type->second); - if(typeVal.compare("Node") == 0) { - return Node(); - } - else if(typeVal.compare("Cell") == 0) { - return Cell(); - } - else if(typeVal.compare("Face") == 0) { - return Face(); - } - else if(typeVal.compare("Edge") == 0) { - return Edge(); + std::map(*)()>::const_iterator returnType + = mSetDefinitions.find(typeVal); + + if (returnType == mSetDefinitions.end()) { + XdmfError::message(XdmfError::FATAL, + "Type not of 'None', 'Node', 'Cell', 'Face', or " + "'Edge' in XdmfSetType::New"); } - else if(typeVal.compare("None") == 0) { - return NoSetType(); + else { + return (*(returnType->second))(); } XdmfError::message(XdmfError::FATAL, @@ -114,3 +124,30 @@ XdmfSetType::getProperties(std::map & collectedPropert { collectedProperties.insert(std::make_pair("Type", mName)); } + +// C Wrappers + +int XdmfSetTypeNoSetType() +{ + return XDMF_SET_TYPE_NO_SET_TYPE; +} + +int XdmfSetTypeNode() +{ + return XDMF_SET_TYPE_NODE; +} + +int XdmfSetTypeCell() +{ + return XDMF_SET_TYPE_CELL; +} + +int XdmfSetTypeFace() +{ + return XDMF_SET_TYPE_FACE; +} + +int XdmfSetTypeEdge() +{ + return XDMF_SET_TYPE_EDGE; +} diff --git a/XdmfSetType.hpp b/XdmfSetType.hpp index 6ae470d9..4ffa3af9 100644 --- a/XdmfSetType.hpp +++ b/XdmfSetType.hpp @@ -1,8 +1,12 @@ #ifndef XDMFSETTYPE_HPP_ #define XDMFSETTYPE_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" + +#ifdef __cplusplus + +// Includes #include "XdmfItemProperty.hpp" /** @@ -71,6 +75,10 @@ protected: */ XdmfSetType(const std::string & name); + static std::map(*)()> mSetDefinitions; + + static void InitTypes(); + private: XdmfSetType(const XdmfSetType &); // Not implemented. @@ -82,4 +90,28 @@ private: std::string mName; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_SET_TYPE_NO_SET_TYPE 600 +#define XDMF_SET_TYPE_NODE 601 +#define XDMF_SET_TYPE_CELL 602 +#define XDMF_SET_TYPE_FACE 603 +#define XDMF_SET_TYPE_EDGE 604 + +XDMF_EXPORT int XdmfSetTypeNoSetType(); +XDMF_EXPORT int XdmfSetTypeNode(); +XDMF_EXPORT int XdmfSetTypeCell(); +XDMF_EXPORT int XdmfSetTypeFace(); +XDMF_EXPORT int XdmfSetTypeEdge(); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFSETTYPE_HPP_ */ diff --git a/XdmfTime.cpp b/XdmfTime.cpp index 3a3da402..028bd299 100644 --- a/XdmfTime.cpp +++ b/XdmfTime.cpp @@ -38,6 +38,12 @@ XdmfTime::XdmfTime(const double & value) : { } +XdmfTime::XdmfTime(XdmfTime & refTime) : + XdmfItem(refTime), + mValue(refTime.getValue()) +{ +} + XdmfTime::~XdmfTime() { } @@ -88,4 +94,31 @@ void XdmfTime::setValue(const double & value) { mValue = value; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFTIME * XdmfTimeNew(double value) +{ + try + { + return (XDMFTIME *)((void *)(new XdmfTime(*(XdmfTime::New(value).get())))); + } + catch (...) + { + return (XDMFTIME *)((void *)(new XdmfTime(*(XdmfTime::New(value).get())))); + } +} + +double XdmfTimeGetValue(XDMFTIME * timePointer) +{ + return ((XdmfTime *)timePointer)->getValue(); } + +void XdmfTimeSetValue(XDMFTIME * timePointer, double time) +{ + ((XdmfTime *)timePointer)->setValue(time); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfTime, XDMFTIME) diff --git a/XdmfTime.hpp b/XdmfTime.hpp index 5ac600e6..44fe81cc 100644 --- a/XdmfTime.hpp +++ b/XdmfTime.hpp @@ -24,10 +24,12 @@ #ifndef XDMFTIME_HPP_ #define XDMFTIME_HPP_ -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfItem.hpp" +#ifdef __cplusplus + /** * @brief Time specification for an XdmfGrid. * @@ -118,6 +120,8 @@ public: */ void setValue(const double & time); + XdmfTime(XdmfTime &); + protected: XdmfTime(const double & value); @@ -135,4 +139,27 @@ private: double mValue; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFTIME; // Simply as a typedef to ensure correct typing +typedef struct XDMFTIME XDMFTIME; + +XDMF_EXPORT XDMFTIME * XdmfTimeNew(double value); + +XDMF_EXPORT double XdmfTimeGetValue(XDMFTIME * timePointer); + +XDMF_EXPORT void XdmfTimeSetValue(XDMFTIME * timePointer, double time); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfTime, XDMFTIME, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFTIME_HPP_ */ diff --git a/XdmfTopology.cpp b/XdmfTopology.cpp index 6dbb61f5..0a2bee45 100644 --- a/XdmfTopology.cpp +++ b/XdmfTopology.cpp @@ -36,7 +36,14 @@ XdmfTopology::New() } XdmfTopology::XdmfTopology() : - mType(XdmfTopologyType::NoTopologyType()) + mType(XdmfTopologyType::NoTopologyType()), + mBaseOffset(0) +{ +} + +XdmfTopology::XdmfTopology(XdmfTopology & refTopo) : + XdmfArray(refTopo), + mType(refTopo.mType) { } @@ -46,6 +53,12 @@ XdmfTopology::~XdmfTopology() const std::string XdmfTopology::ItemTag = "Topology"; +int +XdmfTopology::getBaseOffset() const +{ + return mBaseOffset; +} + std::string XdmfTopology::getItemTag() const { @@ -62,6 +75,12 @@ XdmfTopology::getItemProperties() const numElements << this->getNumberElements(); topologyProperties.insert(std::make_pair("Dimensions", numElements.str())); } + if (mBaseOffset != 0) + { + std::stringstream offsetString; + offsetString << mBaseOffset; + topologyProperties.insert(std::make_pair("BaseOffset", offsetString.str())); + } return topologyProperties; } @@ -138,6 +157,10 @@ XdmfTopology::populateItem(const std::map & itemProper std::map::const_iterator type = itemProperties.find("Offset"); + if (type != itemProperties.end()) { + std::map::const_iterator type = + itemProperties.find("BaseOffset"); + } if (type != itemProperties.end()) { // Convert to double double offset = atof(type->second.c_str()); @@ -153,8 +176,418 @@ XdmfTopology::populateItem(const std::map & itemProper } } +void +XdmfTopology::setBaseOffset(int offset) +{ + mBaseOffset = offset; +} + void XdmfTopology::setType(const shared_ptr type) { mType = type; + this->setIsChanged(true); +} + +// C Wrappers + +XDMFTOPOLOGY * XdmfTopologyNew() +{ + try + { + shared_ptr generatedTopology = XdmfTopology::New(); + return (XDMFTOPOLOGY *)((void *)(new XdmfTopology(*generatedTopology.get()))); + } + catch (...) + { + shared_ptr generatedTopology = XdmfTopology::New(); + return (XDMFTOPOLOGY *)((void *)(new XdmfTopology(*generatedTopology.get()))); + } } + +unsigned int XdmfTopologyGetNumberElements(XDMFTOPOLOGY * topology, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return ((XdmfTopology *)topology)->getNumberElements(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +int XdmfTopologyGetType(XDMFTOPOLOGY * topology) +{ + shared_ptr type = ((XdmfTopology *)topology)->getType(); + int returnType = -1; + + if (type->getID() == XdmfTopologyType::Polyvertex()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_POLYVERTEX; + } + else if (type->getID() == XdmfTopologyType::Polyline(0)->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_POLYLINE; + } + else if (type->getID() == XdmfTopologyType::Polygon(0)->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_POLYGON; + } + else if (type->getID() == XdmfTopologyType::Triangle()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_TRIANGLE; + } + else if (type->getID() == XdmfTopologyType::Quadrilateral()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_QUADRILATERAL; + } + else if (type->getID() == XdmfTopologyType::Tetrahedron()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_TETRAHEDRON; + } + else if (type->getID() == XdmfTopologyType::Pyramid()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_PYRAMID; + } + else if (type->getID() == XdmfTopologyType::Wedge()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_WEDGE; + } + else if (type->getID() == XdmfTopologyType::Hexahedron()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON; + } + else if (type->getID() == XdmfTopologyType::Edge_3()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_EDGE_3; + } + else if (type->getID() == XdmfTopologyType::Triangle_6()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_TRIANGLE_6; + } + else if (type->getID() == XdmfTopologyType::Quadrilateral_8()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8; + } + else if (type->getID() == XdmfTopologyType::Quadrilateral_9()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9; + } + else if (type->getID() == XdmfTopologyType::Tetrahedron_10()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10; + } + else if (type->getID() == XdmfTopologyType::Pyramid_13()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_PYRAMID_13; + } + else if (type->getID() == XdmfTopologyType::Wedge_15()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_WEDGE_15; + } + else if (type->getID() == XdmfTopologyType::Wedge_18()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_WEDGE_18; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_20()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_24()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_27()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_64()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_125()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_216()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_343()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_512()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_729()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_1000()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_1331()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_64()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_125()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_216()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_343()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_512()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_729()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_1000()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_1331()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331; + } + else if (type->getID() == XdmfTopologyType::Mixed()->getID()) { + returnType = XDMF_TOPOLOGY_TYPE_MIXED; + } + else { + returnType = -1; + } + + return returnType; +} + +void XdmfTopologySetType(XDMFTOPOLOGY * topology, int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr newType = shared_ptr(); + + switch (type) { + case XDMF_TOPOLOGY_TYPE_POLYVERTEX: + newType = XdmfTopologyType::Polyvertex(); + break; + case XDMF_TOPOLOGY_TYPE_POLYLINE: + newType = XdmfTopologyType::Polyline(0); + break; + case XDMF_TOPOLOGY_TYPE_POLYGON: + newType = XdmfTopologyType::Polygon(0); + break; + case XDMF_TOPOLOGY_TYPE_TRIANGLE: + newType = XdmfTopologyType::Triangle(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL: + newType = XdmfTopologyType::Quadrilateral(); + break; + case XDMF_TOPOLOGY_TYPE_TETRAHEDRON: + newType = XdmfTopologyType::Tetrahedron(); + break; + case XDMF_TOPOLOGY_TYPE_PYRAMID: + newType = XdmfTopologyType::Pyramid(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE: + newType = XdmfTopologyType::Wedge(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON: + newType = XdmfTopologyType::Hexahedron(); + break; + case XDMF_TOPOLOGY_TYPE_EDGE_3: + newType = XdmfTopologyType::Edge_3(); + break; + case XDMF_TOPOLOGY_TYPE_TRIANGLE_6: + newType = XdmfTopologyType::Triangle_6(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8: + newType = XdmfTopologyType::Quadrilateral_8(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9: + newType = XdmfTopologyType::Quadrilateral_9(); + break; + case XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10: + newType = XdmfTopologyType::Tetrahedron_10(); + break; + case XDMF_TOPOLOGY_TYPE_PYRAMID_13: + newType = XdmfTopologyType::Pyramid_13(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE_15: + newType = XdmfTopologyType::Wedge_15(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE_18: + newType = XdmfTopologyType::Wedge_18(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20: + newType = XdmfTopologyType::Hexahedron_20(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24: + newType = XdmfTopologyType::Hexahedron_24(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27: + newType = XdmfTopologyType::Hexahedron_27(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64: + newType = XdmfTopologyType::Hexahedron_64(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125: + newType = XdmfTopologyType::Hexahedron_125(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216: + newType = XdmfTopologyType::Hexahedron_216(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343: + newType = XdmfTopologyType::Hexahedron_343(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512: + newType = XdmfTopologyType::Hexahedron_512(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729: + newType = XdmfTopologyType::Hexahedron_729(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000: + newType = XdmfTopologyType::Hexahedron_1000(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331: + newType = XdmfTopologyType::Hexahedron_1331(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64: + newType = XdmfTopologyType::Hexahedron_Spectral_64(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125: + newType = XdmfTopologyType::Hexahedron_Spectral_125(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216: + newType = XdmfTopologyType::Hexahedron_Spectral_216(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343: + newType = XdmfTopologyType::Hexahedron_Spectral_343(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512: + newType = XdmfTopologyType::Hexahedron_Spectral_512(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729: + newType = XdmfTopologyType::Hexahedron_Spectral_729(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000: + newType = XdmfTopologyType::Hexahedron_Spectral_1000(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331: + newType = XdmfTopologyType::Hexahedron_Spectral_1331(); + break; + case XDMF_TOPOLOGY_TYPE_MIXED: + newType = XdmfTopologyType::Mixed(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Topology Type: Code " + type); + break; + } + + ((XdmfTopology *)topology)->setType(newType); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfTopologySetPolyType(XDMFTOPOLOGY * topology, int type, int nodes, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr newType = shared_ptr(); + + switch (type) { + case XDMF_TOPOLOGY_TYPE_POLYVERTEX: + newType = XdmfTopologyType::Polyvertex(); + break; + case XDMF_TOPOLOGY_TYPE_POLYLINE: + newType = XdmfTopologyType::Polyline(nodes); + break; + case XDMF_TOPOLOGY_TYPE_POLYGON: + newType = XdmfTopologyType::Polygon(nodes); + break; + case XDMF_TOPOLOGY_TYPE_TRIANGLE: + newType = XdmfTopologyType::Triangle(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL: + newType = XdmfTopologyType::Quadrilateral(); + break; + case XDMF_TOPOLOGY_TYPE_TETRAHEDRON: + newType = XdmfTopologyType::Tetrahedron(); + break; + case XDMF_TOPOLOGY_TYPE_PYRAMID: + newType = XdmfTopologyType::Pyramid(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE: + newType = XdmfTopologyType::Wedge(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON: + newType = XdmfTopologyType::Hexahedron(); + break; + case XDMF_TOPOLOGY_TYPE_EDGE_3: + newType = XdmfTopologyType::Edge_3(); + break; + case XDMF_TOPOLOGY_TYPE_TRIANGLE_6: + newType = XdmfTopologyType::Triangle_6(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8: + newType = XdmfTopologyType::Quadrilateral_8(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9: + newType = XdmfTopologyType::Quadrilateral_9(); + break; + case XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10: + newType = XdmfTopologyType::Tetrahedron_10(); + break; + case XDMF_TOPOLOGY_TYPE_PYRAMID_13: + newType = XdmfTopologyType::Pyramid_13(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE_15: + newType = XdmfTopologyType::Wedge_15(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE_18: + newType = XdmfTopologyType::Wedge_18(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20: + newType = XdmfTopologyType::Hexahedron_20(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24: + newType = XdmfTopologyType::Hexahedron_24(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27: + newType = XdmfTopologyType::Hexahedron_27(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64: + newType = XdmfTopologyType::Hexahedron_64(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125: + newType = XdmfTopologyType::Hexahedron_125(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216: + newType = XdmfTopologyType::Hexahedron_216(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343: + newType = XdmfTopologyType::Hexahedron_343(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512: + newType = XdmfTopologyType::Hexahedron_512(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729: + newType = XdmfTopologyType::Hexahedron_729(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000: + newType = XdmfTopologyType::Hexahedron_1000(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331: + newType = XdmfTopologyType::Hexahedron_1331(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64: + newType = XdmfTopologyType::Hexahedron_Spectral_64(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125: + newType = XdmfTopologyType::Hexahedron_Spectral_125(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216: + newType = XdmfTopologyType::Hexahedron_Spectral_216(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343: + newType = XdmfTopologyType::Hexahedron_Spectral_343(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512: + newType = XdmfTopologyType::Hexahedron_Spectral_512(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729: + newType = XdmfTopologyType::Hexahedron_Spectral_729(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000: + newType = XdmfTopologyType::Hexahedron_Spectral_1000(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331: + newType = XdmfTopologyType::Hexahedron_Spectral_1331(); + break; + case XDMF_TOPOLOGY_TYPE_MIXED: + newType = XdmfTopologyType::Mixed(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Topology Type: Code " + type); + break; + } + ((XdmfTopology *)topology)->setType(newType); + XDMF_ERROR_WRAP_END(status) +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfTopology, XDMFTOPOLOGY) +XDMF_ARRAY_C_CHILD_WRAPPER(XdmfTopology, XDMFTOPOLOGY) diff --git a/XdmfTopology.hpp b/XdmfTopology.hpp index 6683fea5..9bbdccc9 100644 --- a/XdmfTopology.hpp +++ b/XdmfTopology.hpp @@ -24,12 +24,12 @@ #ifndef XDMFTOPOLOGY_HPP_ #define XDMFTOPOLOGY_HPP_ -// Forward Declarations -class XdmfTopologyType; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfArray.hpp" +#include "XdmfTopologyType.hpp" + +#ifdef __cplusplus /** * @brief Holds the connectivity information in an XdmfGrid. @@ -82,6 +82,11 @@ public: LOKI_DEFINE_VISITABLE(XdmfTopology, XdmfArray) static const std::string ItemTag; + /** + * + */ + int getBaseOffset() const; + std::map getItemProperties() const; std::string getItemTag() const; @@ -140,6 +145,11 @@ public: */ shared_ptr getType() const; + /** + * + */ + void setBaseOffset(int offset); + /** * Set the XdmfTopologyType associated with this topology. * @@ -165,6 +175,8 @@ public: */ void setType(const shared_ptr type); + XdmfTopology(XdmfTopology &); + protected: XdmfTopology(); @@ -176,10 +188,12 @@ protected: private: - XdmfTopology(const XdmfTopology &); // Not implemented. + XdmfTopology(const XdmfTopology &); void operator=(const XdmfTopology &); // Not implemented. shared_ptr mType; + + int mBaseOffset; }; #ifdef _WIN32 @@ -187,4 +201,32 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFTOPOLOGY; // Simply as a typedef to ensure correct typing +typedef struct XDMFTOPOLOGY XDMFTOPOLOGY; + +XDMF_EXPORT XDMFTOPOLOGY * XdmfTopologyNew(); + +XDMF_EXPORT unsigned int XdmfTopologyGetNumberElements(XDMFTOPOLOGY * topology, int * status); + +XDMF_EXPORT int XdmfTopologyGetType(XDMFTOPOLOGY * topology); + +XDMF_EXPORT void XdmfTopologySetType(XDMFTOPOLOGY * topology, int type, int * status); + +XDMF_EXPORT void XdmfTopologySetPolyType(XDMFTOPOLOGY * topology, int type, int nodes, int * status); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfTopology, XDMFTOPOLOGY, XDMF) +XDMF_ARRAY_C_CHILD_DECLARE(XdmfTopology, XDMFTOPOLOGY, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFTOPOLOGY_HPP_ */ diff --git a/XdmfTopologyType.cpp b/XdmfTopologyType.cpp index 7c71b9f1..71126d43 100644 --- a/XdmfTopologyType.cpp +++ b/XdmfTopologyType.cpp @@ -22,11 +22,16 @@ /*****************************************************************************/ #include +#include #include #include +#include +#include "string.h" #include "XdmfError.hpp" #include "XdmfTopologyType.hpp" +std::map(*)()> XdmfTopologyType::mTopologyDefinitions; + // Supported XdmfTopologyTypes shared_ptr XdmfTopologyType::NoTopologyType() @@ -440,6 +445,78 @@ XdmfTopologyType::Mixed() return p; } +void +XdmfTopologyType::InitTypes() +{ + mTopologyDefinitions["NOTOPOLOGY"] = NoTopologyType; + mTopologyDefinitions["POLYVERTEX"] = Polyvertex; + mTopologyDefinitions["TRIANGLE"] = Triangle; + mTopologyDefinitions["QUADRILATERAL"] = Quadrilateral; + mTopologyDefinitions["TETRAHEDRON"] = Tetrahedron; + mTopologyDefinitions["PYRAMID"] = Pyramid; + mTopologyDefinitions["WEDGE"] = Wedge; + mTopologyDefinitions["HEXAHEDRON"] = Hexahedron; + mTopologyDefinitions["EDGE_3"] = Edge_3; + mTopologyDefinitions["TRIANGLE_6"] = Triangle_6; + mTopologyDefinitions["QUADRILATERAL_8"] = Quadrilateral_8; + mTopologyDefinitions["QUADRILATERAL_9"] = Quadrilateral_9; + mTopologyDefinitions["TETRAHEDRON_10"] = Tetrahedron_10; + mTopologyDefinitions["PYRAMID_13"] = Pyramid_13; + mTopologyDefinitions["WEDGE_15"] = Wedge_15; + mTopologyDefinitions["WEDGE_18"] = Wedge_18; + mTopologyDefinitions["HEXAHEDRON_20"] = Hexahedron_20; + mTopologyDefinitions["HEXAHEDRON_24"] = Hexahedron_24; + mTopologyDefinitions["HEXAHEDRON_27"] = Hexahedron_27; + mTopologyDefinitions["HEXAHEDRON_64"] = Hexahedron_64; + mTopologyDefinitions["HEXAHEDRON_125"] = Hexahedron_125; + mTopologyDefinitions["HEXAHEDRON_216"] = Hexahedron_216; + mTopologyDefinitions["HEXAHEDRON_343"] = Hexahedron_343; + mTopologyDefinitions["HEXAHEDRON_512"] = Hexahedron_512; + mTopologyDefinitions["HEXAHEDRON_729"] = Hexahedron_729; + mTopologyDefinitions["HEXAHEDRON_1000"] = Hexahedron_1000; + mTopologyDefinitions["HEXAHEDRON_1331"] = Hexahedron_1331; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_64"] = Hexahedron_Spectral_64; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_125"] = Hexahedron_Spectral_125; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_216"] = Hexahedron_Spectral_216; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_343"] = Hexahedron_Spectral_343; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_512"] = Hexahedron_Spectral_512; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_729"] = Hexahedron_Spectral_729; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_1000"] = Hexahedron_Spectral_1000; + mTopologyDefinitions["HEXAHEDRON_SPECTRAL_1331"] = Hexahedron_Spectral_1331; + mTopologyDefinitions["MIXED"] = Mixed; +} + +unsigned int +XdmfTopologyType::calculateHypercubeNumElements(unsigned int numDims, + unsigned int elementNumDims) const +{ + if (elementNumDims > numDims) { + return 0; + } + else if (elementNumDims == numDims) { + return 1; + } + else { + // The calculation has 3 parts + // First is the 2 taken to the power of + // the object's dimensionality minus the element's dimensionality. + unsigned int part1 = std::pow((double)2, (double)(numDims - elementNumDims)); + // The second part is numDims!/(numDims-elementdims)! + unsigned int part2 = 1; + for (unsigned int i = numDims; i > (numDims - elementNumDims); --i) + { + part2 *= i; + } + // The third part is elementDims! + unsigned int part3 = 1; + for (unsigned int i = 1; i <= elementNumDims; ++i) + { + part3 *= i; + } + return part1 * (part2 / part3); + } +} + shared_ptr XdmfTopologyType::New(const unsigned int id) { @@ -584,6 +661,8 @@ XdmfTopologyType::~XdmfTopologyType() shared_ptr XdmfTopologyType::New(const std::map & itemProperties) { + InitTypes(); + std::map::const_iterator type = itemProperties.find("Type"); if(type == itemProperties.end()) { @@ -594,134 +673,41 @@ XdmfTopologyType::New(const std::map & itemProperties) "Neither 'Type' nor 'TopologyType' found in " "itemProperties in XdmfTopologyType::New"); } - std::string typeVal = type->second; - std::transform(typeVal.begin(), - typeVal.end(), - typeVal.begin(), - (int(*)(int))toupper); + std::string typeVal = ConvertToUpper(type->second); std::map::const_iterator nodesPerElement = itemProperties.find("NodesPerElement"); - if(typeVal.compare("NOTOPOLOGY") == 0) { - return NoTopologyType(); - } - else if(typeVal.compare("POLYVERTEX") == 0) { - return Polyvertex(); - } - else if(typeVal.compare("POLYLINE") == 0) { - if(nodesPerElement != itemProperties.end()) { - return Polyline(atoi(nodesPerElement->second.c_str())); + std::map(*)()>::const_iterator returnType + = mTopologyDefinitions.find(typeVal); + + if (returnType == mTopologyDefinitions.end()) { + if(typeVal.compare("POLYLINE") == 0) { + if(nodesPerElement != itemProperties.end()) { + return Polyline(atoi(nodesPerElement->second.c_str())); + } + XdmfError::message(XdmfError::FATAL, + "'NodesPerElement' not in itemProperties and type " + "'POLYLINE' selected in XdmfTopologyType::New"); } - XdmfError::message(XdmfError::FATAL, - "'NodesPerElement' not in itemProperties and type " - "'POLYLINE' selected in XdmfTopologyType::New"); - } - else if(typeVal.compare("POLYGON") == 0) { - if(nodesPerElement != itemProperties.end()) { - return Polygon(atoi(nodesPerElement->second.c_str())); + else if(typeVal.compare("POLYGON") == 0) { + if(nodesPerElement != itemProperties.end()) { + return Polygon(atoi(nodesPerElement->second.c_str())); + } + XdmfError::message(XdmfError::FATAL, + "'NodesPerElement' not in itemProperties and type " + "'POLYGON' selected in XdmfTopologyType::New"); + } + else { + XdmfError::message(XdmfError::FATAL, + "Invalid Type selected in XdmfTopologyType::New"); + } - XdmfError::message(XdmfError::FATAL, - "'NodesPerElement' not in itemProperties and type " - "'POLYGON' selected in XdmfTopologyType::New"); - } - else if(typeVal.compare("TRIANGLE") == 0) { - return Triangle(); - } - else if(typeVal.compare("QUADRILATERAL") == 0) { - return Quadrilateral(); - } - else if(typeVal.compare("TETRAHEDRON") == 0) { - return Tetrahedron(); - } - else if(typeVal.compare("PYRAMID") == 0) { - return Pyramid(); - } - else if(typeVal.compare("WEDGE") == 0) { - return Wedge(); - } - else if(typeVal.compare("HEXAHEDRON") == 0) { - return Hexahedron(); - } - else if(typeVal.compare("EDGE_3") == 0) { - return Edge_3(); - } - else if(typeVal.compare("TRIANGLE_6") == 0) { - return Triangle_6(); - } - else if(typeVal.compare("QUADRILATERAL_8") == 0) { - return Quadrilateral_8(); - } - else if(typeVal.compare("TETRAHEDRON_10") == 0) { - return Tetrahedron_10(); - } - else if(typeVal.compare("PYRAMID_13") == 0) { - return Pyramid_13(); - } - else if(typeVal.compare("WEDGE_15") == 0) { - return Wedge_15(); - } - else if(typeVal.compare("HEXAHEDRON_20") == 0) { - return Hexahedron_20(); - } - else if(typeVal.compare("HEXAHEDRON_24") == 0) { - return Hexahedron_24(); - } - else if(typeVal.compare("HEXAHEDRON_27") == 0) { - return Hexahedron_27(); - } - else if(typeVal.compare("HEXAHEDRON_64") == 0) { - return Hexahedron_64(); - } - else if(typeVal.compare("HEXAHEDRON_125") == 0) { - return Hexahedron_125(); - } - else if(typeVal.compare("HEXAHEDRON_216") == 0) { - return Hexahedron_216(); - } - else if(typeVal.compare("HEXAHEDRON_343") == 0) { - return Hexahedron_343(); - } - else if(typeVal.compare("HEXAHEDRON_512") == 0) { - return Hexahedron_512(); - } - else if(typeVal.compare("HEXAHEDRON_729") == 0) { - return Hexahedron_729(); - } - else if(typeVal.compare("HEXAHEDRON_1000") == 0) { - return Hexahedron_1000(); - } - else if(typeVal.compare("HEXAHEDRON_1331") == 0) { - return Hexahedron_1331(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_64") == 0) { - return Hexahedron_Spectral_64(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_125") == 0) { - return Hexahedron_Spectral_125(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_216") == 0) { - return Hexahedron_Spectral_216(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_343") == 0) { - return Hexahedron_Spectral_343(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_512") == 0) { - return Hexahedron_Spectral_512(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_729") == 0) { - return Hexahedron_Spectral_729(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_1000") == 0) { - return Hexahedron_Spectral_1000(); - } - else if(typeVal.compare("HEXAHEDRON_SPECTRAL_1331") == 0) { - return Hexahedron_Spectral_1331(); } - else if(typeVal.compare("MIXED") == 0) { - return Mixed(); + else { + return (*(returnType->second))(); } - + XdmfError::message(XdmfError::FATAL, "Invalid Type selected in XdmfTopologyType::New"); @@ -742,7 +728,7 @@ XdmfTopologyType::getEdgesPerElement() const } shared_ptr -XdmfTopologyType::getFaceType() +XdmfTopologyType::getFaceType() const { if (mFaces.size() == 0) { return XdmfTopologyType::NoTopologyType(); @@ -787,3 +773,470 @@ XdmfTopologyType::getProperties(std::map & collectedPr nodesPerElement.str())); } } + +// C Wrappers + +int XdmfTopologyTypePolyvertex() +{ + return XDMF_TOPOLOGY_TYPE_POLYVERTEX; +} + +int XdmfTopologyTypePolyline() +{ + return XDMF_TOPOLOGY_TYPE_POLYLINE; +} + +int XdmfTopologyTypePolygon() +{ + return XDMF_TOPOLOGY_TYPE_POLYGON; +} + +int XdmfTopologyTypeTriangle() +{ + return XDMF_TOPOLOGY_TYPE_TRIANGLE; +} + +int XdmfTopologyTypeQuadrilateral() +{ + return XDMF_TOPOLOGY_TYPE_QUADRILATERAL; +} + +int XdmfTopologyTypeTetrahedron() +{ + return XDMF_TOPOLOGY_TYPE_TETRAHEDRON; +} + +int XdmfTopologyTypePyramid() +{ + return XDMF_TOPOLOGY_TYPE_PYRAMID; +} + +int XdmfTopologyTypeWedge() +{ + return XDMF_TOPOLOGY_TYPE_WEDGE; +} + +int XdmfTopologyTypeHexahedron() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON; +} + +int XdmfTopologyTypeEdge_3() +{ + return XDMF_TOPOLOGY_TYPE_EDGE_3; +} + +int XdmfTopologyTypeTriangle_6() +{ + return XDMF_TOPOLOGY_TYPE_TRIANGLE_6; +} + +int XdmfTopologyTypeQuadrilateral_8() +{ + return XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8; +} + +int XdmfTopologyTypeQuadrilateral_9() +{ + return XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9; +} + +int XdmfTopologyTypeTetrahedron_10() +{ + return XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10; +} + +int XdmfTopologyTypePyramid_13() +{ + return XDMF_TOPOLOGY_TYPE_PYRAMID_13; +} + +int XdmfTopologyTypeWedge_15() +{ + return XDMF_TOPOLOGY_TYPE_WEDGE_15; +} + +int XdmfTopologyTypeWedge_18() +{ + return XDMF_TOPOLOGY_TYPE_WEDGE_18; +} + +int XdmfTopologyTypeHexahedron_20() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20; +} + +int XdmfTopologyTypeHexahedron_24() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24; +} + +int XdmfTopologyTypeHexahedron_27() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27; +} + +int XdmfTopologyTypeHexahedron_64() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64; +} + +int XdmfTopologyTypeHexahedron_125() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125; +} + +int XdmfTopologyTypeHexahedron_216() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216; +} + +int XdmfTopologyTypeHexahedron_343() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343; +} + +int XdmfTopologyTypeHexahedron_512() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512; +} + +int XdmfTopologyTypeHexahedron_729() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729; +} + +int XdmfTopologyTypeHexahedron_1000() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000; +} + +int XdmfTopologyTypeHexahedron_1331() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331; +} + +int XdmfTopologyTypeHexahedron_Spectral_64() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64; +} + +int XdmfTopologyTypeHexahedron_Spectral_125() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125; +} + +int XdmfTopologyTypeHexahedron_Spectral_216() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216; +} + +int XdmfTopologyTypeHexahedron_Spectral_343() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343; +} + +int XdmfTopologyTypeHexahedron_Spectral_512() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512; +} + +int XdmfTopologyTypeHexahedron_Spectral_729() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729; +} + +int XdmfTopologyTypeHexahedron_Spectral_1000() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000; +} + +int XdmfTopologyTypeHexahedron_Spectral_1331() +{ + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331; +} + +int XdmfTopologyTypeMixed() +{ + return XDMF_TOPOLOGY_TYPE_MIXED; +} + +shared_ptr intToType(int type, int nodes = 0) +{ + switch (type) { + case XDMF_TOPOLOGY_TYPE_POLYVERTEX: + return XdmfTopologyType::Polyvertex(); + break; + case XDMF_TOPOLOGY_TYPE_POLYLINE: + return XdmfTopologyType::Polyline(nodes); + break; + case XDMF_TOPOLOGY_TYPE_POLYGON: + return XdmfTopologyType::Polygon(nodes); + break; + case XDMF_TOPOLOGY_TYPE_TRIANGLE: + return XdmfTopologyType::Triangle(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL: + return XdmfTopologyType::Quadrilateral(); + break; + case XDMF_TOPOLOGY_TYPE_TETRAHEDRON: + return XdmfTopologyType::Tetrahedron(); + break; + case XDMF_TOPOLOGY_TYPE_PYRAMID: + return XdmfTopologyType::Pyramid(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE: + return XdmfTopologyType::Wedge(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON: + return XdmfTopologyType::Hexahedron(); + break; + case XDMF_TOPOLOGY_TYPE_EDGE_3: + return XdmfTopologyType::Edge_3(); + break; + case XDMF_TOPOLOGY_TYPE_TRIANGLE_6: + return XdmfTopologyType::Triangle_6(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8: + return XdmfTopologyType::Quadrilateral_8(); + break; + case XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9: + return XdmfTopologyType::Quadrilateral_9(); + break; + case XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10: + return XdmfTopologyType::Tetrahedron_10(); + break; + case XDMF_TOPOLOGY_TYPE_PYRAMID_13: + return XdmfTopologyType::Pyramid_13(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE_15: + return XdmfTopologyType::Wedge_15(); + break; + case XDMF_TOPOLOGY_TYPE_WEDGE_18: + return XdmfTopologyType::Wedge_18(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20: + return XdmfTopologyType::Hexahedron_20(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24: + return XdmfTopologyType::Hexahedron_24(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27: + return XdmfTopologyType::Hexahedron_27(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64: + return XdmfTopologyType::Hexahedron_64(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125: + return XdmfTopologyType::Hexahedron_125(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216: + return XdmfTopologyType::Hexahedron_216(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343: + return XdmfTopologyType::Hexahedron_343(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512: + return XdmfTopologyType::Hexahedron_512(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729: + return XdmfTopologyType::Hexahedron_729(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000: + return XdmfTopologyType::Hexahedron_1000(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331: + return XdmfTopologyType::Hexahedron_1331(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64: + return XdmfTopologyType::Hexahedron_Spectral_64(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125: + return XdmfTopologyType::Hexahedron_Spectral_125(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216: + return XdmfTopologyType::Hexahedron_Spectral_216(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343: + return XdmfTopologyType::Hexahedron_Spectral_343(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512: + return XdmfTopologyType::Hexahedron_Spectral_512(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729: + return XdmfTopologyType::Hexahedron_Spectral_729(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000: + return XdmfTopologyType::Hexahedron_Spectral_1000(); + break; + case XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331: + return XdmfTopologyType::Hexahedron_Spectral_1331(); + break; + case XDMF_TOPOLOGY_TYPE_MIXED: + return XdmfTopologyType::Mixed(); + break; + default: + return shared_ptr(); + break; + } +} + +int typeToInt(shared_ptr type) +{ + if (type->getID() == XdmfTopologyType::Polyvertex()->getID()) { + return XDMF_TOPOLOGY_TYPE_POLYVERTEX; + } + else if (type->getID() == XdmfTopologyType::Polyline(0)->getID()) { + return XDMF_TOPOLOGY_TYPE_POLYLINE; + } + else if (type->getID() == XdmfTopologyType::Polygon(0)->getID()) { + return XDMF_TOPOLOGY_TYPE_POLYGON; + } + else if (type->getID() == XdmfTopologyType::Triangle()->getID()) { + return XDMF_TOPOLOGY_TYPE_TRIANGLE; + } + else if (type->getID() == XdmfTopologyType::Quadrilateral()->getID()) { + return XDMF_TOPOLOGY_TYPE_QUADRILATERAL; + } + else if (type->getID() == XdmfTopologyType::Tetrahedron()->getID()) { + return XDMF_TOPOLOGY_TYPE_TETRAHEDRON; + } + else if (type->getID() == XdmfTopologyType::Pyramid()->getID()) { + return XDMF_TOPOLOGY_TYPE_PYRAMID; + } + else if (type->getID() == XdmfTopologyType::Wedge()->getID()) { + return XDMF_TOPOLOGY_TYPE_WEDGE; + } + else if (type->getID() == XdmfTopologyType::Hexahedron()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON; + } + else if (type->getID() == XdmfTopologyType::Edge_3()->getID()) { + return XDMF_TOPOLOGY_TYPE_EDGE_3; + } + else if (type->getID() == XdmfTopologyType::Triangle_6()->getID()) { + return XDMF_TOPOLOGY_TYPE_TRIANGLE_6; + } + else if (type->getID() == XdmfTopologyType::Quadrilateral_8()->getID()) { + return XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8; + } + else if (type->getID() == XdmfTopologyType::Quadrilateral_9()->getID()) { + return XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9; + } + else if (type->getID() == XdmfTopologyType::Tetrahedron_10()->getID()) { + return XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10; + } + else if (type->getID() == XdmfTopologyType::Pyramid_13()->getID()) { + return XDMF_TOPOLOGY_TYPE_PYRAMID_13; + } + else if (type->getID() == XdmfTopologyType::Wedge_15()->getID()) { + return XDMF_TOPOLOGY_TYPE_WEDGE_15; + } + else if (type->getID() == XdmfTopologyType::Wedge_18()->getID()) { + return XDMF_TOPOLOGY_TYPE_WEDGE_18; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_20()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_24()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_27()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_64()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_125()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_216()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_343()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_512()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_729()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_1000()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_1331()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_64()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_125()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_216()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_343()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_512()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_729()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_1000()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000; + } + else if (type->getID() == XdmfTopologyType::Hexahedron_Spectral_1331()->getID()) { + return XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331; + } + else if (type->getID() == XdmfTopologyType::Mixed()->getID()) { + return XDMF_TOPOLOGY_TYPE_MIXED; + } + else { + return -1; + } +} + +int XdmfTopologyTypeGetCellType(int type) +{ + return intToType(type)->getCellType(); +} + +unsigned int XdmfTopologyTypeGetEdgesPerElement(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return intToType(type)->getEdgesPerElement(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +unsigned int XdmfTopologyTypeGetFacesPerElement(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return intToType(type)->getFacesPerElement(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +int XdmfTopologyTypeGetFaceType(int type) +{ + return typeToInt(intToType(type)->getFaceType()); +} + +unsigned int XdmfTopologyTypeGetID(int type) +{ + return intToType(type)->getID(); +} + +char * XdmfTopologyTypeGetName(int type) +{ + char * returnPointer = strdup(intToType(type)->getName().c_str()); + return returnPointer; +} + +unsigned int XdmfTopologyTypeGetNodesPerElement(int type) +{ + return intToType(type)->getNodesPerElement(); +} diff --git a/XdmfTopologyType.hpp b/XdmfTopologyType.hpp index 758b4bcf..741a6007 100644 --- a/XdmfTopologyType.hpp +++ b/XdmfTopologyType.hpp @@ -24,10 +24,15 @@ #ifndef XDMFTOPOLOGYTYPE_HPP_ #define XDMFTOPOLOGYTYPE_HPP_ -// Includes -#include +// C Compatible Includes #include "Xdmf.hpp" + +#ifdef __cplusplus + +// Includes #include "XdmfItemProperty.hpp" +#include +#include /** * @brief Property describing the types of elements stored in an @@ -265,7 +270,7 @@ public: * * @return The face's topology type */ - shared_ptr getFaceType(); + shared_ptr getFaceType() const; /** * Get the id of this cell type, necessary in order to create grids @@ -351,6 +356,12 @@ protected: const CellType cellType, const unsigned int id); + unsigned int calculateHypercubeNumElements(unsigned int numDims, unsigned int elementNumDims) const; + + static std::map(*)()> mTopologyDefinitions; + + static void InitTypes(); + private: XdmfTopologyType(const XdmfTopologyType &); // Not implemented. @@ -369,4 +380,121 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_TOPOLOGY_TYPE_POLYVERTEX 500 +#define XDMF_TOPOLOGY_TYPE_POLYLINE 501 +#define XDMF_TOPOLOGY_TYPE_POLYGON 502 +#define XDMF_TOPOLOGY_TYPE_TRIANGLE 503 +#define XDMF_TOPOLOGY_TYPE_QUADRILATERAL 504 +#define XDMF_TOPOLOGY_TYPE_TETRAHEDRON 505 +#define XDMF_TOPOLOGY_TYPE_PYRAMID 506 +#define XDMF_TOPOLOGY_TYPE_WEDGE 507 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON 508 +#define XDMF_TOPOLOGY_TYPE_EDGE_3 509 +#define XDMF_TOPOLOGY_TYPE_TRIANGLE_6 510 +#define XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8 511 +#define XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9 512 +#define XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10 513 +#define XDMF_TOPOLOGY_TYPE_PYRAMID_13 514 +#define XDMF_TOPOLOGY_TYPE_WEDGE_15 515 +#define XDMF_TOPOLOGY_TYPE_WEDGE_18 516 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20 517 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24 518 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27 519 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64 520 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125 521 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216 522 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343 523 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512 524 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729 525 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000 526 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331 527 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64 528 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125 529 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216 530 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343 531 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512 532 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729 533 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000 534 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331 535 +#define XDMF_TOPOLOGY_TYPE_MIXED 536 + +#define XDMF_TOPOLOGY_CELL_TYPE_NO_CELL_TYPE 0 +#define XDMF_TOPOLOGY_CELL_TYPE_LINEAR 1 +#define XDMF_TOPOLOGY_CELL_TYPE_QUADRATIC 2 +#define XDMF_TOPOLOGY_CELL_TYPE_CUBIC 3 +#define XDMF_TOPOLOGY_CELL_TYPE_QUARTIC 4 +#define XDMF_TOPOLOGY_CELL_TYPE_QUINTIC 5 +#define XDMF_TOPOLOGY_CELL_TYPE_SEXTIC 6 +#define XDMF_TOPOLOGY_CELL_TYPE_SEPTIC 7 +#define XDMF_TOPOLOGY_CELL_TYPE_OCTIC 8 +#define XDMF_TOPOLOGY_CELL_TYPE_NONIC 9 +#define XDMF_TOPOLOGY_CELL_TYPE_DECIC 10 +#define XDMF_TOPOLOGY_CELL_TYPE_ARBITRARY 100 +#define XDMF_TOPOLOGY_CELL_TYPE_STRUCTURED 101 + +XDMF_EXPORT int XdmfTopologyTypePolyvertex(); +XDMF_EXPORT int XdmfTopologyTypePolyline(); +XDMF_EXPORT int XdmfTopologyTypePolygon(); +XDMF_EXPORT int XdmfTopologyTypeTriangle(); +XDMF_EXPORT int XdmfTopologyTypeQuadrilateral(); +XDMF_EXPORT int XdmfTopologyTypeTetrahedron(); +XDMF_EXPORT int XdmfTopologyTypePyramid(); +XDMF_EXPORT int XdmfTopologyTypeWedge(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron(); +XDMF_EXPORT int XdmfTopologyTypeEdge_3(); +XDMF_EXPORT int XdmfTopologyTypeTriangle_6(); +XDMF_EXPORT int XdmfTopologyTypeQuadrilateral_8(); +XDMF_EXPORT int XdmfTopologyTypeQuadrilateral_9(); +XDMF_EXPORT int XdmfTopologyTypeTetrahedron_10(); +XDMF_EXPORT int XdmfTopologyTypePyramid_13(); +XDMF_EXPORT int XdmfTopologyTypeWedge_15(); +XDMF_EXPORT int XdmfTopologyTypeWedge_18(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_20(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_24(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_27(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_64(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_125(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_216(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_343(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_512(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_729(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_1000(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_1331(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_64(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_125(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_216(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_343(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_512(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_729(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_1000(); +XDMF_EXPORT int XdmfTopologyTypeHexahedron_Spectral_1331(); +XDMF_EXPORT int XdmfTopologyTypeMixed(); + + +XDMF_EXPORT int XdmfTopologyTypeGetCellType(int type); + +XDMF_EXPORT unsigned int XdmfTopologyTypeGetEdgesPerElement(int type, int * status); + +XDMF_EXPORT unsigned int XdmfTopologyTypeGetFacesPerElement(int type, int * status); + +XDMF_EXPORT int XdmfTopologyTypeGetFaceType(int type); + +XDMF_EXPORT unsigned int XdmfTopologyTypeGetID(int type); + +XDMF_EXPORT char * XdmfTopologyTypeGetName(int type); + +XDMF_EXPORT unsigned int XdmfTopologyTypeGetNodesPerElement(int type); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFTOPOLOGYTYPE_HPP_ */ diff --git a/XdmfUnstructuredGrid.cpp b/XdmfUnstructuredGrid.cpp index 224ddc57..4d12ff99 100644 --- a/XdmfUnstructuredGrid.cpp +++ b/XdmfUnstructuredGrid.cpp @@ -113,6 +113,29 @@ namespace { } } +class XdmfUnstructuredGrid::XdmfUnstructuredGridImpl : public XdmfGridImpl +{ + public: + XdmfUnstructuredGridImpl() + { + mGridType = "Unstructured"; + } + + ~XdmfUnstructuredGridImpl() + { + } + + XdmfGridImpl * duplicate() + { + return new XdmfUnstructuredGridImpl(); + } + + std::string getGridType() const + { + return mGridType; + } +}; + shared_ptr XdmfUnstructuredGrid::New() { @@ -130,11 +153,14 @@ XdmfUnstructuredGrid::New(const shared_ptr regularGrid) XdmfUnstructuredGrid::XdmfUnstructuredGrid() : XdmfGrid(XdmfGeometry::New(), XdmfTopology::New()) { + mImpl = new XdmfUnstructuredGridImpl(); } XdmfUnstructuredGrid::XdmfUnstructuredGrid(const shared_ptr regularGrid) : XdmfGrid(XdmfGeometry::New(), XdmfTopology::New()) { + mImpl = new XdmfUnstructuredGridImpl(); + const shared_ptr origin = regularGrid->getOrigin(); shared_ptr brickSize = regularGrid->getBrickSize(); @@ -204,12 +230,32 @@ XdmfUnstructuredGrid::XdmfUnstructuredGrid(const shared_ptr reg } } +XdmfUnstructuredGrid::XdmfUnstructuredGrid(XdmfUnstructuredGrid & refGrid) : + XdmfGrid(refGrid) +{ +} + XdmfUnstructuredGrid::~XdmfUnstructuredGrid() { + if (mImpl) { + delete mImpl; + } + mImpl = NULL; } const std::string XdmfUnstructuredGrid::ItemTag = "Grid"; +void +XdmfUnstructuredGrid::copyGrid(shared_ptr sourceGrid) +{ + XdmfGrid::copyGrid(sourceGrid); + if (shared_ptr classedGrid = shared_dynamic_cast(sourceGrid)) + { + this->setGeometry(classedGrid->getGeometry()); + this->setTopology(classedGrid->getTopology()); + } +} + shared_ptr XdmfUnstructuredGrid::getGeometry() { @@ -230,6 +276,34 @@ XdmfUnstructuredGrid::getTopology() (static_cast(*this).getTopology()); } +void +XdmfUnstructuredGrid::read() +{ + if (mGridController) + { + if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + copyGrid(grid); + } + else if (shared_ptr grid = shared_dynamic_cast(mGridController->read())) + { + XdmfError::message(XdmfError::FATAL, "Error: Grid Type Mismatch"); + } + else + { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Grid Reference"); + } + } +} + +void +XdmfUnstructuredGrid::release() +{ + XdmfGrid::release(); + this->setGeometry(shared_ptr()); + this->setTopology(shared_ptr()); +} + void XdmfUnstructuredGrid::setGeometry(const shared_ptr geometry) { @@ -241,3 +315,87 @@ XdmfUnstructuredGrid::setTopology(const shared_ptr topology) { mTopology = topology; } + +// C Wrappers + +XDMFUNSTRUCTUREDGRID * XdmfUnstructuredGridNew() +{ + try + { + shared_ptr generatedGrid = XdmfUnstructuredGrid::New(); + return (XDMFUNSTRUCTUREDGRID *)((void *)((XdmfItem *)(new XdmfUnstructuredGrid(*generatedGrid.get())))); + } + catch (...) + { + shared_ptr generatedGrid = XdmfUnstructuredGrid::New(); + return (XDMFUNSTRUCTUREDGRID *)((void *)((XdmfItem *)(new XdmfUnstructuredGrid(*generatedGrid.get())))); + } +} + +XDMFUNSTRUCTUREDGRID * XdmfUnstructuredGridNewFromRegularGrid(XDMFREGULARGRID * regularGrid, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + // Here it works when classed directly to the grid type, + // in other cases this may not work. + XdmfItem * tempPointer = (XdmfItem *)regularGrid; + XdmfRegularGrid * classedPointer = dynamic_cast(tempPointer); + shared_ptr originGrid = shared_ptr(classedPointer, XdmfNullDeleter()); + shared_ptr generatedGrid = XdmfUnstructuredGrid::New(originGrid); + return (XDMFUNSTRUCTUREDGRID *)((void *)((XdmfItem *)(new XdmfUnstructuredGrid(*generatedGrid.get())))); + } + catch (...) + { + // Here it works when classed directly to the grid type, + // in other cases this may not work. + XdmfItem * tempPointer = (XdmfItem *)regularGrid; + XdmfRegularGrid * classedPointer = dynamic_cast(tempPointer); + shared_ptr originGrid = shared_ptr(classedPointer, XdmfNullDeleter()); + shared_ptr generatedGrid = XdmfUnstructuredGrid::New(originGrid); + return (XDMFUNSTRUCTUREDGRID *)((void *)((XdmfItem *)(new XdmfUnstructuredGrid(*generatedGrid.get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFGEOMETRY * XdmfUnstructuredGridGetGeometry(XDMFUNSTRUCTUREDGRID * grid) +{ + XdmfItem * tempPointer = (XdmfItem *)grid; + XdmfUnstructuredGrid * classedPointer = dynamic_cast(tempPointer); + return (XDMFGEOMETRY *)((void *)(classedPointer->getGeometry().get())); +} + +XDMFTOPOLOGY * XdmfUnstructuredGridGetTopology(XDMFUNSTRUCTUREDGRID * grid) +{ + XdmfItem * tempPointer = (XdmfItem *)grid; + XdmfUnstructuredGrid * classedPointer = dynamic_cast(tempPointer); + return (XDMFTOPOLOGY *)((void *)(classedPointer->getTopology().get())); +} + +void XdmfUnstructuredGridSetGeometry(XDMFUNSTRUCTUREDGRID * grid, XDMFGEOMETRY * geometry, int passControl) +{ + XdmfItem * tempPointer = (XdmfItem *)grid; + XdmfUnstructuredGrid * classedPointer = dynamic_cast(tempPointer); + if (passControl) { + classedPointer->setGeometry(shared_ptr((XdmfGeometry *)geometry)); + } + else { + classedPointer->setGeometry(shared_ptr((XdmfGeometry *)geometry, XdmfNullDeleter())); + } +} + +void XdmfUnstructuredGridSetTopology(XDMFUNSTRUCTUREDGRID * grid, XDMFTOPOLOGY * topology, int passControl) +{ + XdmfItem * tempPointer = (XdmfItem *)grid; + XdmfUnstructuredGrid * classedPointer = dynamic_cast(tempPointer); + if (passControl) { + classedPointer->setTopology(shared_ptr((XdmfTopology *)topology)); + } + else { + classedPointer->setTopology(shared_ptr((XdmfTopology *)topology, XdmfNullDeleter())); + } +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfUnstructuredGrid, XDMFUNSTRUCTUREDGRID) +XDMF_GRID_C_CHILD_WRAPPER(XdmfUnstructuredGrid, XDMFUNSTRUCTUREDGRID) diff --git a/XdmfUnstructuredGrid.hpp b/XdmfUnstructuredGrid.hpp index d27603a8..3e00b7ba 100644 --- a/XdmfUnstructuredGrid.hpp +++ b/XdmfUnstructuredGrid.hpp @@ -24,12 +24,15 @@ #ifndef XDMFUNSTRUCTUREDGRID_HPP_ #define XDMFUNSTRUCTUREDGRID_HPP_ -// Forward Declarations -class XdmfRegularGrid; - -// Includes +// C Compatible Includes #include "Xdmf.hpp" #include "XdmfGrid.hpp" +#include "XdmfRegularGrid.hpp" + +#ifdef __cplusplus + +// Forward Declarations +class XdmfRegularGrid; /** * @brief An unstructured grid that consists of elements, points, and @@ -153,6 +156,10 @@ public: */ shared_ptr getTopology(); + virtual void read(); + + virtual void release(); + /** * Set the geometry associated with this grid. * @@ -203,13 +210,23 @@ public: */ void setTopology(const shared_ptr topology); + XdmfUnstructuredGrid(XdmfUnstructuredGrid &); + protected: XdmfUnstructuredGrid(); XdmfUnstructuredGrid(const shared_ptr regularGrid); + virtual void + copyGrid(shared_ptr sourceGrid); + private: + /** + * PIMPL + */ + class XdmfUnstructuredGridImpl; + XdmfUnstructuredGrid(const XdmfUnstructuredGrid &); // Not implemented. void operator=(const XdmfUnstructuredGrid &); // Not implemented. @@ -222,4 +239,34 @@ XDMF_TEMPLATE template class XDMF_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFUNSTRUCTUREDGRID; // Simply as a typedef to ensure correct typing +typedef struct XDMFUNSTRUCTUREDGRID XDMFUNSTRUCTUREDGRID; + +XDMF_EXPORT XDMFUNSTRUCTUREDGRID * XdmfUnstructuredGridNew(); + +XDMF_EXPORT XDMFUNSTRUCTUREDGRID * XdmfUnstructuredGridNewFromRegularGrid(XDMFREGULARGRID * regularGrid, int * status); + +XDMF_EXPORT XDMFGEOMETRY * XdmfUnstructuredGridGetGeometry(XDMFUNSTRUCTUREDGRID * grid); + +XDMF_EXPORT XDMFTOPOLOGY * XdmfUnstructuredGridGetTopology(XDMFUNSTRUCTUREDGRID * grid); + +XDMF_EXPORT void XdmfUnstructuredGridSetGeometry(XDMFUNSTRUCTUREDGRID * grid, XDMFGEOMETRY * geometry, int passControl); + +XDMF_EXPORT void XdmfUnstructuredGridSetTopology(XDMFUNSTRUCTUREDGRID * grid, XDMFTOPOLOGY * topology, int passControl); + +XDMF_ITEM_C_CHILD_DECLARE(XdmfUnstructuredGrid, XDMFUNSTRUCTUREDGRID, XDMF) +XDMF_GRID_C_CHILD_DECLARE(XdmfUnstructuredGrid, XDMFUNSTRUCTUREDGRID, XDMF) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFUNSTRUCTUREDGRID_HPP_ */ diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt index 7f2a9678..ffe326f6 100644 --- a/core/CMakeLists.txt +++ b/core/CMakeLists.txt @@ -8,13 +8,12 @@ include(CheckCXXSourceCompiles) include(SetUpVersion) include(TestBigEndian) -if(VERSION_CONTROL_AUTOUPDATE OR +if(VERSION_CONTROL_AUTOUPDATE OR NOT EXISTS ${CMAKE_BINARY_DIR}/XdmfVersion.hpp) - VersionCreate("Xdmf" "2" "XDMFCORE_EXPORT" "XdmfCore.hpp") -endif(VERSION_CONTROL_AUTOUPDATE OR + VersionCreate("Xdmf" "3" "3" "0" "XDMFCORE_EXPORT" "XdmfCore.hpp") +endif(VERSION_CONTROL_AUTOUPDATE OR NOT EXISTS ${CMAKE_BINARY_DIR}/XdmfVersion.hpp) -set(BUILD_SHARED_LIBS true) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_BINARY_DIR}) set(CMAKE_SKIP_BUILD_RPATH FALSE) @@ -125,10 +124,12 @@ set(XdmfCoreSources XdmfHDF5Controller XdmfHDF5Writer XdmfHeavyDataController + XdmfHeavyDataDescription XdmfHeavyDataWriter XdmfInformation XdmfItem XdmfItemProperty + XdmfPlaceholder XdmfSparseMatrix XdmfSubset XdmfSystemUtils @@ -136,21 +137,50 @@ set(XdmfCoreSources XdmfVisitor XdmfWriter) -add_library(XdmfCore ${XdmfCoreSources}) +if (TIFF_FOUND) + set(XdmfCoreSources + ${XdmfCoreSources} + XdmfTIFFController) +endif (TIFF_FOUND) + +add_library(XdmfCoreObjects OBJECT ${XdmfCoreSources}) +add_library(XdmfCore $) +if (BUILD_SHARED_LIBS) + add_library(XdmfCore_Static STATIC $) + if (UNIX) + set_target_properties(XdmfCore_Static PROPERTIES + OUTPUT_NAME "XdmfCore") + endif (UNIX) +endif (BUILD_SHARED_LIBS) link_directories(${XDMF_LIBRARY_DIRS}) target_link_libraries(XdmfCore ${XDMF_LIBRARIES}) +if (BUILD_SHARED_LIBS) + target_link_libraries(XdmfCore_Static ${XDMF_LIBRARIES}) +endif (BUILD_SHARED_LIBS) if(WIN32) add_definitions(-D_HDF5USEDLL_ -D_HDF5USEHLDLL_) set_target_properties(XdmfCore PROPERTIES DEFINE_SYMBOL XdmfCore_EXPORTS) + if (BUILD_SHARED_LIBS) + set_target_properties(XdmfCore_Static PROPERTIES + DEFINE_SYMBOL XdmfCore_EXPORTS) + endif (BUILD_SHARED_LIBS) if(NOT MSVC10) - set_target_properties(XdmfCore PROPERTIES + set_target_properties(XdmfCore PROPERTIES PREFIX ../ IMPORT_PREFIX ../ RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) + if (BUILD_SHARED_LIBS) + set_target_properties(XdmfCore_Static PROPERTIES + PREFIX ../ + IMPORT_PREFIX ../ + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) + endif (BUILD_SHARED_LIBS) endif(NOT MSVC10) endif(WIN32) @@ -159,6 +189,10 @@ if(XDMF_WRAP_JAVA) endif(XDMF_WRAP_JAVA) if(XDMF_WRAP_PYTHON) + if (NOT BUILD_SHARED_LIBS) + message(FATAL_ERROR "Python Wrappers do not function" + " properly without shared libraries") + endif (NOT BUILD_SHARED_LIBS) XDMF_SWIG_PYTHON(XdmfCore) endif(XDMF_WRAP_PYTHON) @@ -168,8 +202,13 @@ if(WIN32) endif(WIN32) if(UNIX) - set(XDMFCORE_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfCore.so - PARENT_SCOPE) + if (BUILD_SHARED_LIBS) + set(XDMFCORE_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfCore.so + PARENT_SCOPE) + else (BUILD_SHARED_LIBS) + set(XDMFCORE_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfCore.a + PARENT_SCOPE) + endif (BUILD_SHARED_LIBS) endif(UNIX) if(APPLE) @@ -188,6 +227,12 @@ install(TARGETS XdmfCore RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib) +if (BUILD_SHARED_LIBS) + install(TARGETS XdmfCore_Static + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib) +endif (BUILD_SHARED_LIBS) set(XdmfCore_INCLUDE_DIRS ${Boost_INCLUDE_DIRS} @@ -204,6 +249,7 @@ set(XDMF_BINARIES ${XDMF_BINARIES} ${CMAKE_INSTALL_PREFIX}/bin) if(XDMF_BUILD_DSM) add_subdirectory(dsm) + set(XDMF_DSM_IS_CRAY "${XDMF_DSM_IS_CRAY}" PARENT_SCOPE) endif(XDMF_BUILD_DSM) if(BUILD_TESTING) diff --git a/core/XdmfArray.cpp b/core/XdmfArray.cpp index fcccb4af..18762299 100644 --- a/core/XdmfArray.cpp +++ b/core/XdmfArray.cpp @@ -27,41 +27,18 @@ #include #include #include +#include #include "XdmfArray.hpp" #include "XdmfArrayType.hpp" #include "XdmfArrayReference.hpp" #include "XdmfBinaryController.hpp" +#include "XdmfCoreReader.hpp" #include "XdmfFunction.hpp" -#include "XdmfHDF5Controller.hpp" +#include "XdmfSubset.hpp" #include "XdmfHeavyDataController.hpp" #include "XdmfVisitor.hpp" #include "XdmfError.hpp" -namespace { - - std::string - getFullHeavyDataPath(const std::string & filePath, - const std::map & itemProperties) - { - // FIXME: for other OS (e.g. windows) - if(filePath.size() > 0 && filePath[0] != '/') { - // Dealing with a relative path for heavyData location - std::map::const_iterator xmlDir = - itemProperties.find("XMLDir"); - if(xmlDir == itemProperties.end()) { - XdmfError::message(XdmfError::FATAL, - "'XMLDir' not found in itemProperties when " - "building full heavy data path"); - } - std::stringstream newHeavyDataPath; - newHeavyDataPath << xmlDir->second << filePath; - return newHeavyDataPath.str(); - } - return filePath; - } - -} - XDMF_CHILDREN_IMPLEMENTATION(XdmfArray, XdmfHeavyDataController, HeavyDataController, @@ -393,7 +370,12 @@ public: void operator()(const boost::blank & array) const { - mArray->initialize(mArrayToCopy->getArrayType()); + const shared_ptr copyType = + mArrayToCopy->getArrayType(); + if(copyType == XdmfArrayType::Uninitialized()) { + return; + } + mArray->initialize(copyType); boost::apply_visitor(*this, mArray->mArray); } @@ -590,6 +572,29 @@ XdmfArray::XdmfArray() : { } +XdmfArray::XdmfArray(XdmfArray & refArray): + XdmfItem(refArray), + mDimensions(refArray.getDimensions()), + mName(refArray.getName()), + mReadMode(refArray.getReadMode()) +{ + if (refArray.getArrayType() != XdmfArrayType::Uninitialized()) { + this->initialize(refArray.getArrayType(), 0); + if (refArray.getSize() > 0) { + shared_ptr tempPointer = shared_ptr(&refArray, XdmfNullDeleter()); + this->insert(0, tempPointer, 0, tempPointer->getSize()); + } + } + if (refArray.getNumberHeavyDataControllers() > 0) { + for (unsigned int i = 0; i < refArray.getNumberHeavyDataControllers(); ++i) { + this->insert(refArray.getHeavyDataController(i)); + } + } + if (refArray.mReference) { + this->setReference(refArray.getReference()); + } +} + XdmfArray::~XdmfArray() { } @@ -602,6 +607,7 @@ XdmfArray::clear() boost::apply_visitor(Clear(this), mArray); mDimensions.clear(); + this->setIsChanged(true); } void @@ -611,6 +617,7 @@ XdmfArray::erase(const unsigned int index) index), mArray); mDimensions.clear(); + this->setIsChanged(true); } shared_ptr @@ -621,7 +628,7 @@ XdmfArray::getArrayType() const mArray); } else { - return boost::apply_visitor(GetArrayType(shared_ptr()), + return boost::apply_visitor(GetArrayType(shared_ptr()), mArray); } } @@ -814,6 +821,7 @@ XdmfArray::initialize(const shared_ptr & arrayType, XdmfError::message(XdmfError::FATAL, "Array of unsupported type in XdmfArray::initialize"); } + this->setIsChanged(true); } void @@ -845,6 +853,7 @@ XdmfArray::insert(const unsigned int startIndex, mDimensions, values), mArray); + this->setIsChanged(true); } @@ -959,6 +968,7 @@ XdmfArray::insert(const std::vector startIndex, } } } + this->setIsChanged(true); } else { // Throw an error @@ -1000,7 +1010,6 @@ XdmfArray::populateItem(const std::map & itemPropertie const std::vector > & childItems, const XdmfCoreReader * const reader) { - // This inserts any XdmfInformation in childItems into the object. XdmfItem::populateItem(itemProperties, childItems, reader); @@ -1053,9 +1062,96 @@ XdmfArray::populateItem(const std::map & itemPropertie this->setReadMode(XdmfArray::Reference); filled = true; } + else if (itemType->second.compare("HyperSlab") == 0) { + + shared_ptr dimArray; + shared_ptr valArray; + + unsigned int foundArrayIndex = 0; + + for(std::vector >::const_iterator iter = + childItems.begin(); + iter != childItems.end(); + ++iter) { + if(shared_ptr array = shared_dynamic_cast(*iter)) { + if (foundArrayIndex == 0) + { + dimArray = array; + foundArrayIndex++; + } + else if (foundArrayIndex == 1) + { + valArray = array; + foundArrayIndex++; + } + } + } + + if (!(dimArray)) + { + XdmfError::message(XdmfError::FATAL, + "Error: Hyperslab description missing"); + } + if (!(valArray)) + { + XdmfError::message(XdmfError::FATAL, + "Error: Hyperslab values missing"); + } + + if (dimArray->getSize() % 3 != 0) + { + XdmfError::message(XdmfError::FATAL, + "Error: Hyperslab description structured improperly"); + } + + // A start, stride, and dimension need to be + // specified for each dimension + unsigned int numDims = dimArray->getSize() / 3; + + // Start, stride, and dims are set via the first array provided + std::vector start; + std::vector stride; + std::vector dimensions; + + unsigned int i = 0; + + while (i < dimArray->getSize() / 3) + { + start.push_back(dimArray->getValue(i)); + ++i; + } + + while (i < 2 * (dimArray->getSize() / 3)) + { + stride.push_back(dimArray->getValue(i)); + ++i; + } + + while (i < dimArray->getSize()) + { + dimensions.push_back(dimArray->getValue(i)); + ++i; + } + + shared_ptr subset = + XdmfSubset::New(valArray, + start, + stride, + dimensions); + this->setReference(subset); + this->setReadMode(XdmfArray::Reference); + filled = true; + } } if (!filled) { + std::vector > readControllers = reader->generateHeavyDataControllers(itemProperties); + + mHeavyDataControllers.clear(); + + for (unsigned int i = 0; i < readControllers.size(); ++i) { + mHeavyDataControllers.push_back(readControllers[i]); + } const shared_ptr arrayType = XdmfArrayType::New(itemProperties); @@ -1116,129 +1212,40 @@ XdmfArray::populateItem(const std::map & itemPropertie } const std::string & formatVal = format->second; - if(formatVal.compare("HDF") == 0) { - contentIndex = 0; - int contentStep = 2; - while (contentIndex < contentVals.size()) { - size_t colonLocation = contentVals[contentIndex].find(":"); - if(colonLocation == std::string::npos) { - XdmfError::message(XdmfError::FATAL, - "':' not found in content in " - "XdmfArray::populateItem -- double check an HDF5 " - "data set is specified for the file"); - } - - std::string hdf5Path = - contentVals[contentIndex].substr(0, colonLocation); - std::string dataSetPath = - contentVals[contentIndex].substr(colonLocation+1); - - hdf5Path = getFullHeavyDataPath(hdf5Path, - itemProperties); - - // Parse dimensions from the content - std::vector contentDims; - if (contentVals.size() > contentIndex+1) { - // This is the string that contains the dimensions - boost::tokenizer<> dimtokens(contentVals[contentIndex+1]); - for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); - iter != dimtokens.end(); - ++iter) { - contentDims.push_back(atoi((*iter).c_str())); + if (readControllers.size() == 0) { + if(formatVal.compare("XML") == 0) { + this->initialize(arrayType, + mDimensions); + unsigned int index = 0; + boost::char_separator sep(" \t\n"); + for (contentIndex = 0; contentIndex < contentVals.size(); ++contentIndex) + { + boost::tokenizer > tokens(contentVals[contentIndex], sep); + if(arrayType == XdmfArrayType::String()) { + for(boost::tokenizer >::const_iterator + iter = tokens.begin(); + iter != tokens.end(); + ++iter, ++index) { + this->insert(index, *iter); + } } - contentStep = 2; - // If this works then the dimension content should be skipped over - } - else { - // If it fails then it means that the next content is not a dimension string - // In this case it is assumed that the controller will have - // dimensions equal to the array - for (unsigned int j = 0; j < mDimensions.size(); ++j) { - contentDims.push_back(mDimensions[j]); + else { + for(boost::tokenizer >::const_iterator + iter = tokens.begin(); + iter != tokens.end(); + ++iter, ++index) { + this->insert(index, atof((*iter).c_str())); + } } - contentStep = 1; - } - - mHeavyDataControllers.push_back( - XdmfHDF5Controller::New(hdf5Path, - dataSetPath, - arrayType, - std::vector(contentDims.size(), - 0), - std::vector(contentDims.size(), - 1), - contentDims, - contentDims) - ); - contentIndex += contentStep; - } - } - else if(formatVal.compare("XML") == 0) { - this->initialize(arrayType, - mDimensions); - unsigned int index = 0; - boost::char_separator sep(" \t\n"); - boost::tokenizer > tokens(contentVals[0], sep); - if(arrayType == XdmfArrayType::String()) { - for(boost::tokenizer >::const_iterator - iter = tokens.begin(); - iter != tokens.end(); - ++iter, ++index) { - this->insert(index, *iter); - } - } - else { - for(boost::tokenizer >::const_iterator - iter = tokens.begin(); - iter != tokens.end(); - ++iter, ++index) { - this->insert(index, atof((*iter).c_str())); } } - } - else if(formatVal.compare("Binary") == 0) { - - XdmfBinaryController::Endian endian = XdmfBinaryController::NATIVE; - std::map::const_iterator endianIter = - itemProperties.find("Endian"); - if(endianIter != itemProperties.end()) { - if(endianIter->second.compare("Big") == 0) { - endian = XdmfBinaryController::BIG; - } - else if(endianIter->second.compare("Little") == 0) { - endian = XdmfBinaryController::LITTLE; - } - else if(endianIter->second.compare("Native") == 0) { - endian = XdmfBinaryController::NATIVE; - } - else { - XdmfError(XdmfError::FATAL, - "Invalid endianness type: " + endianIter->second); - } - } - - unsigned int seek = 0; - std::map::const_iterator seekIter = - itemProperties.find("Seek"); - if(seekIter != itemProperties.end()) { - seek = std::atoi(seekIter->second.c_str()); + else + { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Data Format " + "in XdmfArray::populateItem"); } - - const std::string binaryPath = getFullHeavyDataPath(contentVals[0], - itemProperties); - - mHeavyDataControllers.push_back(XdmfBinaryController::New(binaryPath, - arrayType, - endian, - seek, - mDimensions)); - } - else { - XdmfError::message(XdmfError::FATAL, - "Neither 'HDF' nor 'XML' specified as 'Format' " - "in XdmfArray::populateItem"); } - } std::map::const_iterator name = @@ -1249,6 +1256,7 @@ XdmfArray::populateItem(const std::map & itemPropertie else { mName = ""; } + this->setIsChanged(true); } void @@ -1319,6 +1327,7 @@ XdmfArray::readController() this->insert(mHeavyDataControllers[0]->getArrayOffset(), tempArray, 0, mHeavyDataControllers[0]->getSize(), 1, 1); mDimensions = mHeavyDataControllers[0]->getDimensions(); } + this->setIsChanged(true); } void @@ -1326,6 +1335,7 @@ XdmfArray::readReference() { shared_ptr tempArray = mReference->read(); this->swap(tempArray); + this->setIsChanged(true); } void @@ -1342,6 +1352,7 @@ XdmfArray::reserve(const unsigned int size) boost::apply_visitor(Reserve(this, size), mArray); + this->setIsChanged(true); } void @@ -1352,24 +1363,41 @@ XdmfArray::setHeavyDataController(shared_ptr newControl // It will clear the current controllers before adding the new one in mHeavyDataControllers.clear(); mHeavyDataControllers.push_back(newController); + this->setIsChanged(true); +} + +void +XdmfArray::setHeavyDataController(std::vector > & newControllers) +{ + if (mHeavyDataControllers.size() != newControllers.size()) { + mHeavyDataControllers.resize(newControllers.size()); + } + for (unsigned int i = 0; i < newControllers.size(); ++i) { + mHeavyDataControllers[i] = newControllers[i]; + } + this->setIsChanged(true); } + void XdmfArray::setName(const std::string & name) { mName = name; + this->setIsChanged(true); } void XdmfArray::setReadMode(XdmfArray::ReadMode newStatus) { mReadMode = newStatus; + this->setIsChanged(true); } void XdmfArray::setReference(shared_ptr newReference) { mReference = newReference; + this->setIsChanged(true); } void @@ -1379,4 +1407,1206 @@ XdmfArray::swap(const shared_ptr array) std::swap(mArrayPointerNumValues, array->mArrayPointerNumValues); std::swap(mDimensions, array->mDimensions); std::swap(mHeavyDataControllers, array->mHeavyDataControllers); + this->setIsChanged(true); +} + +void +XdmfArray::traverse(const shared_ptr visitor) +{ + XdmfItem::traverse(visitor); + if (mReference) { + mReference->accept(visitor); + } +} + +// C wrappers + +XDMFARRAY * +XdmfArrayNew() +{ + try + { + XDMFARRAY * returnPointer; + shared_ptr generatedArray = XdmfArray::New(); + returnPointer = (XDMFARRAY *)((void *)(new XdmfArray(*generatedArray.get()))); + generatedArray.reset(); + return returnPointer; + } + catch (...) + { + XDMFARRAY * returnPointer; + shared_ptr generatedArray = XdmfArray::New(); + returnPointer = (XDMFARRAY *)((void *)(new XdmfArray(*generatedArray.get()))); + generatedArray.reset(); + return returnPointer; + } +} + +void XdmfArrayClear(XDMFARRAY * array) +{ + ((XdmfArray *)(array))->clear(); +} + +void XdmfArrayErase(XDMFARRAY * array, unsigned int index) +{ + ((XdmfArray *)(array))->erase(index); +} + +int XdmfArrayGetArrayType(XDMFARRAY * array, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr compareType = ((XdmfArray *)(array))->getArrayType(); + std::string typeName = compareType->getName(); + unsigned int typePrecision = compareType->getElementSize(); + if (typeName == XdmfArrayType::UInt8()->getName()) + { + return XDMF_ARRAY_TYPE_UINT8; + } + else if (typeName == XdmfArrayType::UInt16()->getName()) + { + return XDMF_ARRAY_TYPE_UINT16; + } + else if (typeName == XdmfArrayType::UInt32()->getName()) + { + return XDMF_ARRAY_TYPE_UINT32; + } + else if (typeName == XdmfArrayType::Int8()->getName()) + { + return XDMF_ARRAY_TYPE_INT8; + } + else if (typeName == XdmfArrayType::Int16()->getName()) + { + return XDMF_ARRAY_TYPE_INT16; + } + else if (typeName == XdmfArrayType::Int32()->getName() || typeName == XdmfArrayType::Int64()->getName()) + { + if (typePrecision == 4) + { + return XDMF_ARRAY_TYPE_INT32; + } + else if (typePrecision == 8) + { + return XDMF_ARRAY_TYPE_INT64; + } + else + { + } + } + else if (typeName == XdmfArrayType::Float32()->getName() || typeName == XdmfArrayType::Float64()->getName()) + { + if (typePrecision == 4) + { + return XDMF_ARRAY_TYPE_FLOAT32; + } + else if (typePrecision == 8) + { + return XDMF_ARRAY_TYPE_FLOAT64; + } + else + { + } + } + else if (typeName == XdmfArrayType::String()->getName()) + { + //This shouldn't be used from C bindings + XdmfError::message(XdmfError::FATAL, + "Error: String type not usable from C."); + } + else + { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +unsigned int XdmfArrayGetCapacity(XDMFARRAY * array) +{ + return ((XdmfArray *)(array))->getCapacity(); +} + +unsigned int * +XdmfArrayGetDimensions(XDMFARRAY * array) +{ + try + { + std::vector tempVector = ((XdmfArray *)(array))->getDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfArray *)(array))->getDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +char * +XdmfArrayGetDimensionsString(XDMFARRAY * array) +{ + try + { + char * returnPointer = strdup(((XdmfArray *)(array))->getDimensionsString().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfArray *)(array))->getDimensionsString().c_str()); + return returnPointer; + } +} + +XDMFHEAVYDATACONTROLLER * +XdmfArrayGetHeavyDataController(XDMFARRAY * array, unsigned int index) +{ + return (XDMFHEAVYDATACONTROLLER *)((void *)(((XdmfArray *)(array))->getHeavyDataController(index).get())); +} + +char * +XdmfArrayGetName(XDMFARRAY * array) +{ + try + { + char * returnPointer = strdup(((XdmfArray *)(array))->getName().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfArray *)(array))->getName().c_str()); + return returnPointer; + } +} + +unsigned int +XdmfArrayGetNumberDimensions(XDMFARRAY * array) +{ + return ((XdmfArray *)(array))->getDimensions().size(); +} + +unsigned int +XdmfArrayGetNumberHeavyDataControllers(XDMFARRAY * array) +{ + return ((XdmfArray *)(array))->getNumberHeavyDataControllers(); +} + +unsigned int +XdmfArrayGetSize(XDMFARRAY * array) +{ + return ((XdmfArray *)(array))->getSize(); +} + +int +XdmfArrayGetReadMode(XDMFARRAY * array, int * status) +{ + XDMF_ERROR_WRAP_START(status) + int readMode = ((XdmfArray *)(array))->getReadMode(); + switch (readMode) { + case XdmfArray::Controller: + return XDMF_ARRAY_READ_MODE_CONTROLLER; + break; + case XdmfArray::Reference: + return XDMF_ARRAY_READ_MODE_REFERENCE; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ReadMode."); + break; + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +XDMFARRAYREFERENCE * +XdmfArrayGetReference(XDMFARRAY * array) +{ + return (XDMFARRAYREFERENCE *)((void *)(((XdmfArray *)(array))->getReference().get())); +} + +void * +XdmfArrayGetValue(XDMFARRAY * array, unsigned int index, int arrayType, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + void * returnVal; + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + returnVal = new unsigned char(); + *((unsigned char *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT16: + returnVal = new unsigned short(); + *((unsigned short *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT32: + returnVal = new unsigned int(); + *((unsigned int *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT8: + returnVal = new char(); + *((char *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT16: + returnVal = new short(); + *((short *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT32: + returnVal = new int(); + *((int *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT64: + returnVal = new long(); + *((long *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT32: + returnVal = new float(); + *((float *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT64: + returnVal = new double(); + *((double *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + catch (...) + { + void * returnVal; + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + returnVal = new unsigned char(); + *((unsigned char *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT16: + returnVal = new unsigned short(); + *((unsigned short *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT32: + returnVal = new unsigned int(); + *((unsigned int *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT8: + returnVal = new char(); + *((char *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT16: + returnVal = new short(); + *((short *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT32: + returnVal = new int(); + *((int *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT64: + returnVal = new long(); + *((long *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT32: + returnVal = new float(); + *((float *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT64: + returnVal = new double(); + *((double *)returnVal) = ((XdmfArray *)(array))->getValue(index); + return returnVal; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +void * +XdmfArrayGetValues(XDMFARRAY * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + void * returnVal; + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + returnVal = new unsigned char[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (unsigned char *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT16: + returnVal = new unsigned short[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (unsigned short *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT32: + returnVal = new unsigned int[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (unsigned int *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT8: + returnVal = new char[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (char *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT16: + returnVal = new short[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (short *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT32: + returnVal = new int[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (int *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT64: + returnVal = new long[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (long *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT32: + returnVal = new float[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (float *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT64: + returnVal = new double[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (double *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + catch (...) + { + void * returnVal; + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + returnVal = new unsigned char[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (unsigned char *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT16: + returnVal = new unsigned short[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (unsigned short *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_UINT32: + returnVal = new unsigned int[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (unsigned int *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT8: + returnVal = new char[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (char *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT16: + returnVal = new short[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (short *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT32: + returnVal = new int[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (int *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_INT64: + returnVal = new long[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (long *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT32: + returnVal = new float[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (float *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + case XDMF_ARRAY_TYPE_FLOAT64: + returnVal = new double[numValues](); + ((XdmfArray *)(array))->getValues(startIndex, (double *)returnVal, numValues, arrayStride, valueStride); + return returnVal; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +void * +XdmfArrayGetValuesInternal(XDMFARRAY * array) +{ + return ((XdmfArray *)(array))->getValuesInternal(); +} + +char * +XdmfArrayGetValuesString(XDMFARRAY * array) +{ + try + { + char * returnPointer = strdup(((XdmfArray *)(array))->getValuesString().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfArray *)(array))->getValuesString().c_str()); + return returnPointer; + } +} + +void +XdmfArrayInitialize(XDMFARRAY * array, int * dims, int numDims, int arrayType, int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector dimVector((int *)dims, (int *)dims + numDims); + shared_ptr tempPointer = XdmfArrayType::Uninitialized(); + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + tempPointer = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + tempPointer = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + tempPointer = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + tempPointer = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + tempPointer = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + tempPointer = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + tempPointer = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + tempPointer = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + tempPointer = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + ((XdmfArray *)(array))->initialize(tempPointer, dimVector); + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArrayInsertDataFromPointer(XDMFARRAY * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)(array))->insert(startIndex, (unsigned char *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)(array))->insert(startIndex, (unsigned short *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)(array))->insert(startIndex, (unsigned int *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)(array))->insert(startIndex, (char *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)(array))->insert(startIndex, (short *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)(array))->insert(startIndex, (int *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)(array))->insert(startIndex, (long *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)(array))->insert(startIndex, (float *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)(array))->insert(startIndex, (double *)values, numVals, arrayStride, valueStride); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + catch (...) + { + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)(array))->insert(startIndex, (unsigned char *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)(array))->insert(startIndex, (unsigned short *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)(array))->insert(startIndex, (unsigned int *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)(array))->insert(startIndex, (char *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)(array))->insert(startIndex, (short *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)(array))->insert(startIndex, (int *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)(array))->insert(startIndex, (long *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)(array))->insert(startIndex, (float *)values, numVals, arrayStride, valueStride); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)(array))->insert(startIndex, (double *)values, numVals, arrayStride, valueStride); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfArrayInsertDataFromXdmfArray(XDMFARRAY * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + shared_ptr tempPointer((XdmfArray *)valArray, XdmfNullDeleter()); + std::vector arrayStartVector((int *)arrayStarts, (int *)arrayStarts + ((XdmfArray *)(array))->getDimensions().size()); + std::vector valueStartVector((int *)valueStarts, (int *)valueStarts + tempPointer->getDimensions().size()); + std::vector arrayCountVector((int *)arrayCounts, (int *)arrayCounts + ((XdmfArray *)(array))->getDimensions().size()); + std::vector valueCountVector((int *)valueCounts, (int *)valueCounts + tempPointer->getDimensions().size()); + std::vector arrayStrideVector((int *)arrayStrides, (int *)arrayStrides + ((XdmfArray *)(array))->getDimensions().size()); + std::vector valueStrideVector((int *)valueStrides, (int *)valueStrides + tempPointer->getDimensions().size()); + ((XdmfArray *)(array))->insert(arrayStartVector, tempPointer, valueStartVector, arrayCountVector, valueCountVector, arrayStrideVector, valueStrideVector); + } + catch (...) + { + shared_ptr tempPointer((XdmfArray *)valArray, XdmfNullDeleter()); + std::vector arrayStartVector((int *)arrayStarts, (int *)arrayStarts + ((XdmfArray *)(array))->getDimensions().size()); + std::vector valueStartVector((int *)valueStarts, (int *)valueStarts + tempPointer->getDimensions().size()); + std::vector arrayCountVector((int *)arrayCounts, (int *)arrayCounts + ((XdmfArray *)(array))->getDimensions().size()); + std::vector valueCountVector((int *)valueCounts, (int *)valueCounts + tempPointer->getDimensions().size()); + std::vector arrayStrideVector((int *)arrayStrides, (int *)arrayStrides + ((XdmfArray *)(array))->getDimensions().size()); + std::vector valueStrideVector((int *)valueStrides, (int *)valueStrides + tempPointer->getDimensions().size()); + ((XdmfArray *)(array))->insert(arrayStartVector, tempPointer, valueStartVector, arrayCountVector, valueCountVector, arrayStrideVector, valueStrideVector); + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArrayInsertHeavyDataController(XDMFARRAY * array, XDMFHEAVYDATACONTROLLER * controller, int passControl) +{ + if (passControl == 0) { + ((XdmfArray *)(array))->insert(shared_ptr((XdmfHeavyDataController *) controller, XdmfNullDeleter())); + } + else { + ((XdmfArray *)(array))->insert(shared_ptr((XdmfHeavyDataController *) controller)); + } +} + +void +XdmfArrayInsertValue(XDMFARRAY * array, unsigned int index, void * value, int arrayType, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)(array))->insert(index, *((unsigned char *)value)); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)(array))->insert(index, *((unsigned short *)value)); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)(array))->insert(index, *((unsigned int *)value)); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)(array))->insert(index, *((char *)value)); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)(array))->insert(index, *((short *)value)); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)(array))->insert(index, *((int *)value)); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)(array))->insert(index, *((long *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)(array))->insert(index, *((float *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)(array))->insert(index, *((double *)value)); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + catch (...) + { + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)(array))->insert(index, *((unsigned char *)value)); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)(array))->insert(index, *((unsigned short *)value)); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)(array))->insert(index, *((unsigned int *)value)); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)(array))->insert(index, *((char *)value)); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)(array))->insert(index, *((short *)value)); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)(array))->insert(index, *((int *)value)); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)(array))->insert(index, *((long *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)(array))->insert(index, *((float *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)(array))->insert(index, *((double *)value)); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + XDMF_ERROR_WRAP_END(status) +} + +int +XdmfArrayIsInitialized(XDMFARRAY * array) +{ + return ((XdmfArray *)(array))->isInitialized(); +} + +void +XdmfArrayPushBack(XDMFARRAY * array, void * value, int arrayType, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)(array))->pushBack(*((unsigned char *)value)); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)(array))->pushBack(*((unsigned short *)value)); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)(array))->pushBack(*((unsigned int *)value)); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)(array))->pushBack(*((char *)value)); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)(array))->pushBack(*((short *)value)); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)(array))->pushBack(*((int *)value)); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)(array))->pushBack(*((long *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)(array))->pushBack(*((float *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)(array))->pushBack(*((double *)value)); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + catch (...) + { + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)(array))->pushBack(*((unsigned char *)value)); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)(array))->pushBack(*((unsigned short *)value)); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)(array))->pushBack(*((unsigned int *)value)); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)(array))->pushBack(*((char *)value)); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)(array))->pushBack(*((short *)value)); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)(array))->pushBack(*((int *)value)); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)(array))->pushBack(*((long *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)(array))->pushBack(*((float *)value)); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)(array))->pushBack(*((double *)value)); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArrayRead(XDMFARRAY * array, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + ((XdmfArray *)(array))->read(); + } + catch (...) + { + ((XdmfArray *)(array))->read(); + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArrayReadController(XDMFARRAY * array, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + ((XdmfArray *)(array))->readController(); + } + catch (...) + { + ((XdmfArray *)(array))->readController(); + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArrayReadReference(XDMFARRAY * array, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + ((XdmfArray *)(array))->readReference(); + } + catch (...) + { + ((XdmfArray *)(array))->readReference(); + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArrayRelease(XDMFARRAY * array) +{ + ((XdmfArray *)(array))->release(); +} + +void +XdmfArrayRemoveHeavyDataController(XDMFARRAY * array, unsigned int index) +{ + ((XdmfArray *)(array))->removeHeavyDataController(index); +} + +void +XdmfArrayReserve(XDMFARRAY * array, int size) +{ + ((XdmfArray *)(array))->reserve(size); +} + +void +XdmfArrayResize(XDMFARRAY * array, int * dims, int numDims, int arrayType, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector dimVector((int *)dims, (int *)dims + numDims); + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (unsigned char) 0); + break; + } + case XDMF_ARRAY_TYPE_UINT16: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (unsigned short) 0); + break; + } + case XDMF_ARRAY_TYPE_UINT32: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (unsigned int) 0); + break; + } + case XDMF_ARRAY_TYPE_INT8: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (char) 0); + break; + } + case XDMF_ARRAY_TYPE_INT16: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (short) 0); + break; + } + case XDMF_ARRAY_TYPE_INT32: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (int) 0); + break; + } + case XDMF_ARRAY_TYPE_INT64: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (long) 0); + break; + } + case XDMF_ARRAY_TYPE_FLOAT32: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (float) 0); + break; + } + case XDMF_ARRAY_TYPE_FLOAT64: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (double) 0); + break; + } + default: + { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + dimVector.clear(); + } + catch (...) + { + std::vector dimVector((int *)dims, (int *)dims + numDims); + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (unsigned char) 0); + break; + } + case XDMF_ARRAY_TYPE_UINT16: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (unsigned short) 0); + break; + } + case XDMF_ARRAY_TYPE_UINT32: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (unsigned int) 0); + break; + } + case XDMF_ARRAY_TYPE_INT8: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (char) 0); + break; + } + case XDMF_ARRAY_TYPE_INT16: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (short) 0); + break; + } + case XDMF_ARRAY_TYPE_INT32: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (int) 0); + break; + } + case XDMF_ARRAY_TYPE_INT64: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (long) 0); + break; + } + case XDMF_ARRAY_TYPE_FLOAT32: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (float) 0); + break; + } + + case XDMF_ARRAY_TYPE_FLOAT64: + { + XdmfArray * classedArray = (XdmfArray *)((void *) array); + classedArray->resize(dimVector, (double) 0); + break; + } + default: + { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + } + dimVector.clear(); + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArraySetReadMode(XDMFARRAY * array, int readMode, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (readMode) { + case XDMF_ARRAY_READ_MODE_CONTROLLER: + ((XdmfArray *)(array))->setReadMode(XdmfArray::Controller); + break; + case XDMF_ARRAY_READ_MODE_REFERENCE: + ((XdmfArray *)(array))->setReadMode(XdmfArray::Reference); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ReadMode."); + break; + } + XDMF_ERROR_WRAP_END(status) } + +void +XdmfArraySetReference(XDMFARRAY * array, XDMFARRAYREFERENCE * reference, int passControl) +{ + if (passControl) { + ((XdmfArray *)(array))->setReference(shared_ptr((XdmfArrayReference *)reference)); + } + else { + ((XdmfArray *)(array))->setReference(shared_ptr((XdmfArrayReference *)reference, XdmfNullDeleter())); + } +} + +void +XdmfArraySetName(XDMFARRAY * array, char * name, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfArray *)(array))->setName(name); + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArraySetValuesInternal(XDMFARRAY * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: + ((XdmfArray *)array)->setValuesInternal((unsigned char *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_UINT16: + ((XdmfArray *)array)->setValuesInternal((unsigned short *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_UINT32: + ((XdmfArray *)array)->setValuesInternal((unsigned int *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_INT8: + ((XdmfArray *)array)->setValuesInternal((char *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_INT16: + ((XdmfArray *)array)->setValuesInternal((short *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_INT32: + ((XdmfArray *)array)->setValuesInternal((int *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_INT64: + ((XdmfArray *)array)->setValuesInternal((long *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + ((XdmfArray *)array)->setValuesInternal((float *)pointer, numValues, transferOwnership); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + ((XdmfArray *)array)->setValuesInternal((double *)pointer, numValues, transferOwnership); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfArraySwapWithXdmfArray(XDMFARRAY * array, XDMFARRAY * swapArray) +{ + shared_ptr pointerToSwap((XdmfArray *) swapArray, XdmfNullDeleter()); + ((XdmfArray *)array)->swap(pointerToSwap); +} + +void +XdmfArraySwapWithArray(XDMFARRAY * array, void ** pointer, int numValues, int arrayType, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (arrayType) { + case XDMF_ARRAY_TYPE_UINT8: { + std::vector swapVector((unsigned char *)(*pointer), (unsigned char *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new unsigned char[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((unsigned char *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_UINT16: { + std::vector swapVector((unsigned short *)(*pointer), (unsigned short *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new unsigned short[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((unsigned short *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_UINT32: { + std::vector swapVector((unsigned int *)(*pointer), (unsigned int *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new unsigned int[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((unsigned int *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_INT8: { + std::vector swapVector((char *)(*pointer), (char *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new char[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((char *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_INT16: { + std::vector swapVector((short *)(*pointer), (short *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new short[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((short *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_INT32: { + std::vector swapVector((int *)(*pointer), (int *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new int[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((int *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_INT64: { + std::vector swapVector((long *)(*pointer), (long *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new long[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((long *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_FLOAT32: { + std::vector swapVector((float *)(*pointer), (float *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new float[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((float *) (*pointer))[i] = swapVector[i]; + } + break; + } + case XDMF_ARRAY_TYPE_FLOAT64: { + std::vector swapVector((double *)(*pointer), (double *)(*pointer) + numValues); + ((XdmfArray *)array)->swap(swapVector); + *pointer = new double[swapVector.size()]; + for (unsigned int i = 0; i < swapVector.size(); ++i) + { + ((double *) (*pointer))[i] = swapVector[i]; + } + break; + } + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + XDMF_ERROR_WRAP_END(status) +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfArray, XDMFARRAY) diff --git a/core/XdmfArray.hpp b/core/XdmfArray.hpp index f1b59e45..a0490acb 100644 --- a/core/XdmfArray.hpp +++ b/core/XdmfArray.hpp @@ -24,14 +24,19 @@ #ifndef XDMFARRAY_HPP_ #define XDMFARRAY_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfArrayReference.hpp" +#include "XdmfHeavyDataController.hpp" +#include "XdmfItem.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfArrayType; class XdmfHeavyDataController; // Includes -#include "XdmfCore.hpp" -#include "XdmfItem.hpp" -#include "XdmfArrayReference.hpp" #include #include @@ -859,7 +864,7 @@ public: * @skipline #//isInitialized * @until #//isInitialized */ - bool isInitialized() const; + virtual bool isInitialized() const; /** * Copy a value to the back of this array @@ -965,6 +970,34 @@ public: void setHeavyDataController(shared_ptr newController); + /** + * Sets the controllers attached to this array to the ones contained + * in the provided vector. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfArray.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setHeavyDataControllerVector + * @until //#setHeavyDataControllerVector + * + * Python + * + * @dontinclude XdmfExampleArray.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setHeavyDataControllerVector + * @until #//setHeavyDataControllerVector + * + * @param newControllers The controllers to be set to the array. + */ + void + setHeavyDataController(std::vector > & newControllers); + + /** * Read data from disk into memory. * @@ -1423,6 +1456,10 @@ public: */ void swap(const shared_ptr array); + virtual void traverse(const shared_ptr visitor); + + XdmfArray(XdmfArray &); + protected: XdmfArray(); @@ -1488,14 +1525,13 @@ private: boost::shared_array, boost::shared_array > ArrayVariant; - ArrayVariant mArray; unsigned int mArrayPointerNumValues; std::vector mDimensions; std::string mName; unsigned int mTmpReserveSize; ReadMode mReadMode; shared_ptr mReference; - + ArrayVariant mArray; }; #include "XdmfArray.tpp" @@ -1513,4 +1549,473 @@ XDMFCORE_TEMPLATE template class XDMFCORE_EXPORT Loki::Visitor, shared_ptr >; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define XDMF_ARRAY_READ_MODE_CONTROLLER 10 +#define XDMF_ARRAY_READ_MODE_REFERENCE 11 + +// C wrappers go here + +struct XDMFARRAY; // Simply as a typedef to ensure correct typing +typedef struct XDMFARRAY XDMFARRAY; + +XDMFCORE_EXPORT XDMFARRAY * XdmfArrayNew(); + +XDMFCORE_EXPORT void XdmfArrayClear(XDMFARRAY * array); + +XDMFCORE_EXPORT void XdmfArrayErase(XDMFARRAY * array, unsigned int index); + +XDMFCORE_EXPORT int XdmfArrayGetArrayType(XDMFARRAY * array, int * status); + +XDMFCORE_EXPORT unsigned int XdmfArrayGetCapacity(XDMFARRAY * array); + +XDMFCORE_EXPORT unsigned int * XdmfArrayGetDimensions(XDMFARRAY * array); + +XDMFCORE_EXPORT char * XdmfArrayGetDimensionsString(XDMFARRAY * array); + +XDMFCORE_EXPORT XDMFHEAVYDATACONTROLLER * XdmfArrayGetHeavyDataController(XDMFARRAY * array, unsigned int index); + +XDMFCORE_EXPORT int XdmfArrayGetReadMode(XDMFARRAY * array, int * status); + +XDMFCORE_EXPORT char * XdmfArrayGetName(XDMFARRAY * array); + +XDMFCORE_EXPORT unsigned int XdmfArrayGetNumberDimensions(XDMFARRAY * array); + +XDMFCORE_EXPORT unsigned int XdmfArrayGetNumberHeavyDataControllers(XDMFARRAY * array); + +XDMFCORE_EXPORT unsigned int XdmfArrayGetSize(XDMFARRAY * array); + +XDMFCORE_EXPORT XDMFARRAYREFERENCE * XdmfArrayGetReference(XDMFARRAY * array); + +XDMFCORE_EXPORT void * XdmfArrayGetValue(XDMFARRAY * array, unsigned int index, int arrayType, int * status); + +XDMFCORE_EXPORT void * XdmfArrayGetValues(XDMFARRAY * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status); + +XDMFCORE_EXPORT void * XdmfArrayGetValuesInternal(XDMFARRAY * array); + +XDMFCORE_EXPORT char * XdmfArrayGetValuesString(XDMFARRAY * array); + +XDMFCORE_EXPORT void XdmfArrayInitialize(XDMFARRAY * array, int * dims, int numDims, int arrayType, int * status); + +XDMFCORE_EXPORT void XdmfArrayInsertDataFromPointer(XDMFARRAY * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status); + +XDMFCORE_EXPORT void XdmfArrayInsertDataFromXdmfArray(XDMFARRAY * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status); + +XDMFCORE_EXPORT void XdmfArrayInsertHeavyDataController(XDMFARRAY * array, XDMFHEAVYDATACONTROLLER * controller, int passControl); + +XDMFCORE_EXPORT void XdmfArrayInsertValue(XDMFARRAY * array, unsigned int index, void * value, int arrayType, int * status); + +XDMFCORE_EXPORT int XdmfArrayIsInitialized(XDMFARRAY * array); + +XDMFCORE_EXPORT void XdmfArrayPushBack(XDMFARRAY * array, void * value, int arrayType, int * status); + +XDMFCORE_EXPORT void XdmfArrayRead(XDMFARRAY * array, int * status); + +XDMFCORE_EXPORT void XdmfArrayReadController(XDMFARRAY * array, int * status); + +XDMFCORE_EXPORT void XdmfArrayReadReference(XDMFARRAY * array, int * status); + +XDMFCORE_EXPORT void XdmfArrayRelease(XDMFARRAY * array); + +XDMFCORE_EXPORT void XdmfArrayRemoveHeavyDataController(XDMFARRAY * array, unsigned int index); + +XDMFCORE_EXPORT void XdmfArrayReserve(XDMFARRAY * array, int size); + +XDMFCORE_EXPORT void XdmfArrayResize(XDMFARRAY * array, int * dims, int numDims, int arrayType, int * status); + +XDMFCORE_EXPORT void XdmfArraySetReadMode(XDMFARRAY * array, int readMode, int * status); + +XDMFCORE_EXPORT void XdmfArraySetReference(XDMFARRAY * array, XDMFARRAYREFERENCE * reference, int passControl); + +XDMFCORE_EXPORT void XdmfArraySetName(XDMFARRAY * array, char * name, int * status); + +XDMFCORE_EXPORT void XdmfArraySetValuesInternal(XDMFARRAY * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status); + +XDMFCORE_EXPORT void XdmfArraySwapWithXdmfArray(XDMFARRAY * array, XDMFARRAY * swapArray); + +XDMFCORE_EXPORT void XdmfArraySwapWithArray(XDMFARRAY * array, void ** pointer, int numValues, int arrayType, int * status); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfArray, XDMFARRAY, XDMFCORE) + + +#define XDMF_ARRAY_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT void ClassName##Clear( CClassName * array); \ +Level##_EXPORT void ClassName##Erase( CClassName * array, unsigned int index); \ +Level##_EXPORT int ClassName##GetArrayType( CClassName * array, int * status); \ +Level##_EXPORT unsigned int ClassName##GetCapacity( CClassName * array); \ +Level##_EXPORT unsigned int * ClassName##GetDimensions( CClassName * array); \ +Level##_EXPORT char * ClassName##GetDimensionsString( CClassName * array); \ +Level##_EXPORT XDMFHEAVYDATACONTROLLER * ClassName##GetHeavyDataController( CClassName * array, unsigned int index); \ +Level##_EXPORT int ClassName##GetReadMode( CClassName * array, int * status); \ +Level##_EXPORT char * ClassName##GetName( CClassName * array); \ +Level##_EXPORT unsigned int ClassName##GetNumberDimensions( CClassName * array); \ +Level##_EXPORT unsigned int ClassName##GetNumberHeavyDataControllers( CClassName * array); \ +Level##_EXPORT unsigned int ClassName##GetSize( CClassName * array); \ +Level##_EXPORT XDMFARRAYREFERENCE * ClassName##GetReference( CClassName * array); \ +Level##_EXPORT void * ClassName##GetValue( CClassName * array, \ + unsigned int index, \ + int arrayType, \ + int * status); \ +Level##_EXPORT void * ClassName##GetValues( CClassName * array, \ + unsigned int startIndex, \ + int arrayType, \ + unsigned int numValues, \ + unsigned int arrayStride, \ + unsigned int valueStride, \ + int * status); \ +Level##_EXPORT void * ClassName##GetValuesInternal( CClassName * array); \ +Level##_EXPORT char * ClassName##GetValuesString( CClassName * array); \ +Level##_EXPORT void ClassName##Initialize( CClassName * array, \ + int * dims, \ + int numDims, \ + int arrayType, \ + int * status); \ +Level##_EXPORT void ClassName##InsertDataFromPointer( CClassName * array, \ + void * values, \ + int arrayType, \ + unsigned int startIndex, \ + unsigned int numVals, \ + unsigned int arrayStride, \ + unsigned int valueStride, \ + int * status); \ +Level##_EXPORT void ClassName##InsertDataFromXdmfArray( CClassName * array, \ + XDMFARRAY * valArray, \ + int * arrayStarts, \ + int * valueStarts, \ + int * arrayCounts, \ + int * valueCounts, \ + int * arrayStrides, \ + int * valueStrides, \ + int * status); \ +Level##_EXPORT void ClassName##InsertHeavyDataController( CClassName * array, \ + XDMFHEAVYDATACONTROLLER * controller, \ + int passControl); \ +Level##_EXPORT void ClassName##InsertValue( CClassName * array, \ + unsigned int index, \ + void * value, \ + int arrayType, \ + int * status); \ +Level##_EXPORT int ClassName##IsInitialized( CClassName * array); \ +Level##_EXPORT void ClassName##PushBack( CClassName * array, \ + void * value, \ + int arrayType, \ + int * status); \ +Level##_EXPORT void ClassName##Read( CClassName * array, int * status); \ +Level##_EXPORT void ClassName##ReadController( CClassName * array, int * status); \ +Level##_EXPORT void ClassName##ReadReference( CClassName * array, int * status); \ +Level##_EXPORT void ClassName##Release( CClassName * array); \ +Level##_EXPORT void ClassName##RemoveHeavyDataController( CClassName * array, unsigned int index); \ +Level##_EXPORT void ClassName##Reserve( CClassName * array, int size); \ +Level##_EXPORT void ClassName##Resize( CClassName * array, \ + int * dims, \ + int numDims, \ + int arrayType, \ + int * status); \ +Level##_EXPORT void ClassName##SetReadMode( CClassName * array, int readMode, int * status); \ +Level##_EXPORT void ClassName##SetReference( CClassName * array, XDMFARRAYREFERENCE * reference, int passControl); \ +Level##_EXPORT void ClassName##SetName( CClassName * array, char * name, int * status); \ +Level##_EXPORT void ClassName##SetValuesInternal( CClassName * array, \ + void * pointer, \ + unsigned int numValues, \ + int arrayType, \ + int transferOwnership, \ + int * status); \ +Level##_EXPORT void ClassName##SwapWithXdmfArray( CClassName * array, XDMFARRAY * swapArray); \ +Level##_EXPORT void ClassName##SwapWithArray( CClassName * array, \ + void ** pointer, \ + int numValues, \ + int arrayType, \ + int * status); + + +#define XDMF_ARRAY_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +void ClassName##Clear( CClassName * array) \ +{ \ + XdmfArrayClear((XDMFARRAY *)((void *)array)); \ +} \ + \ +void ClassName##Erase( CClassName * array, unsigned int index) \ +{ \ + XdmfArrayErase((XDMFARRAY *)((void *)array), index); \ +} \ + \ +int ClassName##GetArrayType( CClassName * array, int * status) \ +{ \ + return XdmfArrayGetArrayType((XDMFARRAY *)((void *)array), status); \ +} \ + \ +unsigned int ClassName##GetCapacity( CClassName * array) \ +{ \ + return XdmfArrayGetCapacity((XDMFARRAY *)((void *)array)); \ +} \ + \ +unsigned int * \ +ClassName##GetDimensions( CClassName * array) \ +{ \ + return XdmfArrayGetDimensions((XDMFARRAY *)((void *)array)); \ +} \ + \ +char * \ +ClassName##GetDimensionsString( CClassName * array) \ +{ \ + return XdmfArrayGetDimensionsString((XDMFARRAY *)((void *)array)); \ +} \ + \ +XDMFHEAVYDATACONTROLLER * \ +ClassName##GetHeavyDataController( CClassName * array, unsigned int index) \ +{ \ + return XdmfArrayGetHeavyDataController((XDMFARRAY *)((void *)array), index); \ +} \ + \ +char * \ +ClassName##GetName( CClassName * array) \ +{ \ + return XdmfArrayGetName((XDMFARRAY *)((void *)array)); \ +} \ + \ +unsigned int \ +ClassName##GetNumberDimensions( CClassName * array) \ +{ \ + return XdmfArrayGetNumberDimensions((XDMFARRAY *)((void *)array)); \ +} \ + \ +unsigned int \ +ClassName##GetNumberHeavyDataControllers( CClassName * array) \ +{ \ + return XdmfArrayGetNumberHeavyDataControllers((XDMFARRAY *)((void *)array)); \ +} \ + \ +unsigned int \ +ClassName##GetSize( CClassName * array) \ +{ \ + return XdmfArrayGetSize((XDMFARRAY *)((void *)array)); \ +} \ + \ +int \ +ClassName##GetReadMode( CClassName * array, int * status) \ +{ \ + return XdmfArrayGetReadMode((XDMFARRAY *)((void *)array), status); \ +} \ + \ +XDMFARRAYREFERENCE * \ +ClassName##GetReference( CClassName * array) \ +{ \ + return XdmfArrayGetReference((XDMFARRAY *)((void *)array)); \ +} \ + \ +void * \ +ClassName##GetValue( CClassName * array, unsigned int index, int arrayType, int * status) \ +{ \ + return XdmfArrayGetValue((XDMFARRAY *)((void *)array), index, arrayType, status); \ +} \ + \ +void * \ +ClassName##GetValues( CClassName * array, \ + unsigned int startIndex, \ + int arrayType, \ + unsigned int numValues, \ + unsigned int arrayStride, \ + unsigned int valueStride, \ + int * status) \ +{ \ + return XdmfArrayGetValues((XDMFARRAY *)((void *)array), \ + startIndex, \ + arrayType, \ + numValues, \ + arrayStride, \ + valueStride, \ + status); \ +} \ + \ +void * \ +ClassName##GetValuesInternal( CClassName * array) \ +{ \ + return XdmfArrayGetValuesInternal((XDMFARRAY *)((void *)array)); \ +} \ + \ +char * \ +ClassName##GetValuesString( CClassName * array) \ +{ \ + return XdmfArrayGetValuesString((XDMFARRAY *)((void *)array)); \ +} \ + \ +void \ +ClassName##Initialize( CClassName * array, int * dims, int numDims, int arrayType, int * status) \ +{ \ + XdmfArrayInitialize((XDMFARRAY *)((void *)array), dims, numDims, arrayType, status); \ +} \ + \ +void \ +ClassName##InsertDataFromPointer( CClassName * array, \ + void * values, \ + int arrayType, \ + unsigned int startIndex, \ + unsigned int numVals, \ + unsigned int arrayStride, \ + unsigned int valueStride, \ + int * status) \ +{ \ + XdmfArrayInsertDataFromPointer((XDMFARRAY *)((void *)array), \ + values, \ + arrayType, \ + startIndex, \ + numVals, \ + arrayStride, \ + valueStride, \ + status); \ +} \ + \ +void ClassName##InsertDataFromXdmfArray( CClassName * array, \ + XDMFARRAY * valArray, \ + int * arrayStarts, \ + int * valueStarts, \ + int * arrayCounts, \ + int * valueCounts, \ + int * arrayStrides, \ + int * valueStrides, \ + int * status) \ +{ \ + XdmfArrayInsertDataFromXdmfArray((XDMFARRAY *)((void *)array), \ + valArray, \ + arrayStarts, \ + valueStarts, \ + arrayCounts, \ + valueCounts, \ + arrayStrides, \ + valueStrides, \ + status); \ +} \ + \ +void \ +ClassName##InsertHeavyDataController( CClassName * array, XDMFHEAVYDATACONTROLLER * controller, int passControl) \ +{ \ + XdmfArrayInsertHeavyDataController((XDMFARRAY *)((void *)array), controller, passControl); \ +} \ + \ +void \ +ClassName##InsertValue( CClassName * array, \ + unsigned int index, \ + void * value, \ + int arrayType, \ + int * status) \ +{ \ + XdmfArrayInsertValue((XDMFARRAY *)((void *)array), index, value, arrayType, status); \ +} \ + \ +int \ +ClassName##IsInitialized( CClassName * array) \ +{ \ + return XdmfArrayIsInitialized((XDMFARRAY *)((void *)array)); \ +} \ + \ +void \ +ClassName##PushBack( CClassName * array, void * value, int arrayType, int * status) \ +{ \ + XdmfArrayPushBack((XDMFARRAY *)((void *)array), value, arrayType, status); \ +} \ + \ +void \ +ClassName##Read( CClassName * array, int * status) \ +{ \ + XdmfArrayRead((XDMFARRAY *)((void *)array), status); \ +} \ + \ +void \ +ClassName##ReadController( CClassName * array, int * status) \ +{ \ + XdmfArrayReadController((XDMFARRAY *)((void *)array), status); \ +} \ + \ +void \ +ClassName##ReadReference( CClassName * array, int * status) \ +{ \ + XdmfArrayReadReference((XDMFARRAY *)((void *)array), status); \ +} \ + \ +void \ +ClassName##Release( CClassName * array) \ +{ \ + XdmfArrayRelease((XDMFARRAY *)((void *)array)); \ +} \ + \ +void \ +ClassName##RemoveHeavyDataController( CClassName * array, unsigned int index) \ +{ \ + XdmfArrayRemoveHeavyDataController((XDMFARRAY *)((void *)array), index); \ +} \ + \ +void \ +ClassName##Reserve( CClassName * array, int size) \ +{ \ + XdmfArrayReserve((XDMFARRAY *)((void *)array), size); \ +} \ + \ +void \ +ClassName##Resize( CClassName * array, int * dims, int numDims, int arrayType, int * status) \ +{ \ + XdmfArrayResize((XDMFARRAY *)((void *)array), dims, numDims, arrayType, status); \ +} \ + \ +void \ +ClassName##SetReadMode( CClassName * array, int readMode, int * status) \ +{ \ + XdmfArraySetReadMode((XDMFARRAY *)((void *)array), readMode, status); \ +} \ + \ +void \ +ClassName##SetReference( CClassName * array, XDMFARRAYREFERENCE * reference, int passControl) \ +{ \ + XdmfArraySetReference((XDMFARRAY *)((void *)array), reference, passControl); \ +} \ + \ +void \ +ClassName##SetName( CClassName * array, char * name, int * status) \ +{ \ + XdmfArraySetName((XDMFARRAY *)((void *)array), name, status); \ +} \ + \ +void \ +ClassName##SetValuesInternal( CClassName * array, \ + void * pointer, \ + unsigned int numValues, \ + int arrayType, \ + int transferOwnership, \ + int * status) \ +{ \ + XdmfArraySetValuesInternal((XDMFARRAY *)((void *)array), \ + pointer, \ + numValues, \ + arrayType, \ + transferOwnership, \ + status); \ +} \ + \ +void \ +ClassName##SwapWithXdmfArray( CClassName * array, XDMFARRAY * swapArray) \ +{ \ + XdmfArraySwapWithXdmfArray((XDMFARRAY *)((void *)array), swapArray); \ +} \ + \ +void \ +ClassName##SwapWithArray( CClassName * array, \ + void ** pointer, \ + int numValues, \ + int arrayType, \ + int * status) \ +{ \ + XdmfArraySwapWithArray((XDMFARRAY *)((void *)array), pointer, numValues, arrayType, status); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFARRAY_HPP_ */ diff --git a/core/XdmfArray.tpp b/core/XdmfArray.tpp index ef206e83..70fa22ea 100644 --- a/core/XdmfArray.tpp +++ b/core/XdmfArray.tpp @@ -652,6 +652,7 @@ XdmfArray::initialize(const unsigned int size) mTmpReserveSize = 0; } mArray = newArray; + this->setIsChanged(true); return newArray; } @@ -698,6 +699,7 @@ XdmfArray::insert(const unsigned int startIndex, valuesStride, mDimensions), mArray); + this->setIsChanged(true); } template @@ -707,6 +709,7 @@ XdmfArray::pushBack(const T & value) return boost::apply_visitor(PushBack(value, this), mArray); + this->setIsChanged(true); } template @@ -718,8 +721,7 @@ XdmfArray::resize(const unsigned int numValues, numValues, value), mArray); - std::vector newDimensions; - newDimensions.push_back(numValues); + this->setIsChanged(true); } template @@ -733,6 +735,7 @@ XdmfArray::resize(const std::vector & dimensions, std::multiplies()); this->resize(size, value); mDimensions = dimensions; + this->setIsChanged(true); } template @@ -752,6 +755,7 @@ XdmfArray::setValuesInternal(const T * const arrayPointer, mArray = newArrayPointer; } mArrayPointerNumValues = numValues; + this->setIsChanged(true); } template @@ -767,6 +771,7 @@ XdmfArray::setValuesInternal(std::vector & array, shared_ptr > newArray(&array, NullDeleter()); mArray = newArray; } + this->setIsChanged(true); } template @@ -774,6 +779,7 @@ void XdmfArray::setValuesInternal(const shared_ptr > array) { mArray = array; + this->setIsChanged(true); } template @@ -793,6 +799,7 @@ XdmfArray::swap(std::vector & array) catch(const boost::bad_get & exception) { return false; } + this->setIsChanged(true); } template diff --git a/core/XdmfArrayReference.cpp b/core/XdmfArrayReference.cpp index 7d8a155f..7b277740 100644 --- a/core/XdmfArrayReference.cpp +++ b/core/XdmfArrayReference.cpp @@ -35,6 +35,13 @@ XdmfArrayReference::XdmfArrayReference(): { } +XdmfArrayReference::XdmfArrayReference(XdmfArrayReference & refReference) : + XdmfItem(refReference), + mConstructedType(refReference.mConstructedType), + mConstructedProperties(refReference.mConstructedProperties) +{ +} + XdmfArrayReference::~XdmfArrayReference() { } @@ -56,14 +63,94 @@ XdmfArrayReference::getConstructedType() const } } +std::map +XdmfArrayReference::getItemProperties() const +{ + std::map referenceProperties; + + referenceProperties["ConstructedType"] = mConstructedType; + + for (std::map::const_iterator constructedIt = mConstructedProperties.begin(); + constructedIt != mConstructedProperties.end(); + ++constructedIt) { + referenceProperties[constructedIt->first] = constructedIt->second; + } + + // An array is missing a lot of data if not read first + if (mConstructedType.compare(XdmfArray::ItemTag) == 0) { + shared_ptr resultArray = this->read(); + shared_ptr resultArrayType = resultArray->getArrayType(); + std::map arrayTypeProperties; + resultArrayType->getProperties(arrayTypeProperties); + for (std::map::const_iterator arrayTypeIt = arrayTypeProperties.begin(); + arrayTypeIt != arrayTypeProperties.end(); + ++arrayTypeIt) { + referenceProperties[arrayTypeIt->first] = arrayTypeIt->second; + } + referenceProperties["Format"] = "XML"; + referenceProperties["Dimensions"] = resultArray->getDimensionsString(); + } + + return referenceProperties; +} + void XdmfArrayReference::setConstructedProperties(std::map newProperties) { mConstructedProperties = newProperties; + this->setIsChanged(true); } void XdmfArrayReference::setConstructedType(std::string newType) { mConstructedType = newType; + this->setIsChanged(true); +} + +// C Wrappers + +char * XdmfArrayReferenceGetConstructedType(XDMFARRAYREFERENCE * arrayReference) +{ + try + { + char * returnPointer = strdup((*((XdmfArrayReference *)arrayReference)).getConstructedType().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup((*((XdmfArrayReference *)arrayReference)).getConstructedType().c_str()); + return returnPointer; + } +} + +void * XdmfArrayReferenceRead(XDMFARRAYREFERENCE * arrayReference, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + shared_ptr returnItem = ((XdmfArrayReference *)arrayReference)->read(); + return new XdmfArray(*returnItem.get()); + } + catch (...) + { + shared_ptr returnItem = ((XdmfArrayReference *)arrayReference)->read(); + return new XdmfArray(*returnItem.get()); + } + XDMF_ERROR_WRAP_END(status) + return NULL; } + +void XdmfArrayReferenceSetConstructedProperties(XDMFARRAYREFERENCE * arrayReference, void * referenceobject) +{ + ((XdmfArrayReference *)arrayReference)->setConstructedProperties(((XdmfItem *)referenceobject)->getItemProperties()); +} + +void XdmfArrayReferenceSetConstructedType(XDMFARRAYREFERENCE * arrayReference, char * newType) +{ + ((XdmfArrayReference *)arrayReference)->setConstructedType(newType); +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfArrayReference, XDMFARRAYREFERENCE) diff --git a/core/XdmfArrayReference.hpp b/core/XdmfArrayReference.hpp index 1acfd3be..b2d05e96 100644 --- a/core/XdmfArrayReference.hpp +++ b/core/XdmfArrayReference.hpp @@ -24,9 +24,12 @@ #ifndef XDMFARRAYREFERENCE_HPP_ #define XDMFARRAYREFERENCE_HPP_ -// Includes +// C Compatible Includes #include "XdmfCore.hpp" #include "XdmfArray.hpp" +#include "XdmfItem.hpp" + +#ifdef __cplusplus class XdmfArray; @@ -103,6 +106,8 @@ public: */ std::string getConstructedType() const; + virtual std::map getItemProperties() const; + /** * Parses the reference and generates an array containing the values that * the reference produces. @@ -180,6 +185,8 @@ public: */ void setConstructedType(std::string newType); + XdmfArrayReference(XdmfArrayReference &); + protected: XdmfArrayReference(); @@ -193,4 +200,63 @@ private: void operator=(const XdmfArrayReference &); // Not implemented. }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFARRAYREFERENCE; // Simply as a typedef to ensure correct typing +typedef struct XDMFARRAYREFERENCE XDMFARRAYREFERENCE; + +XDMFCORE_EXPORT char * XdmfArrayReferenceGetConstructedType(XDMFARRAYREFERENCE * arrayReference); + +XDMFCORE_EXPORT void * XdmfArrayReferenceRead(XDMFARRAYREFERENCE * arrayReference, int * status); + +XDMFCORE_EXPORT void XdmfArrayReferenceSetConstructedProperties(XDMFARRAYREFERENCE * arrayReference, void * referenceobject); + +XDMFCORE_EXPORT void XdmfArrayReferenceSetConstructedType(XDMFARRAYREFERENCE * arrayReference, char * newType); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfArrayReference, XDMFARRAYREFERENCE, XDMFCORE) + +#define XDMF_ARRAYREFERENCE_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT char * ClassName##GetConstructedType( CClassName * arrayReference); \ +Level##_EXPORT void * ClassName##Read( CClassName * arrayReference, int * status); \ +Level##_EXPORT void ClassName##SetConstructedProperties( CClassName * arrayReference, void * referenceobject); \ +Level##_EXPORT void ClassName##SetConstructedType( CClassName * arrayReference, char * newType); + + + +#define XDMF_ARRAYREFERENCE_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ + \ +char * ClassName##GetConstructedType(CClassName * arrayReference) \ +{ \ + return XdmfArrayReferenceGetConstructedType((XDMFARRAYREFERENCE *)((void *)arrayReference)); \ +} \ + \ +void * ClassName##Read(CClassName * arrayReference, int * status) \ +{ \ + return XdmfArrayReferenceRead((XDMFARRAYREFERENCE *)((void *)arrayReference), status); \ +} \ + \ +void ClassName##SetConstructedProperties(CClassName * arrayReference, void * referenceobject) \ +{ \ + XdmfArrayReferenceSetConstructedProperties((XDMFARRAYREFERENCE *)((void *)arrayReference), referenceobject); \ +} \ + \ +void ClassName##SetConstructedType(CClassName * arrayReference, char * newType) \ +{ \ + XdmfArrayReferenceSetConstructedType((XDMFARRAYREFERENCE *)((void *)arrayReference), newType); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFARRAYREFERENCE_HPP_ */ diff --git a/core/XdmfArrayType.cpp b/core/XdmfArrayType.cpp index f1952ee6..5a8ef010 100644 --- a/core/XdmfArrayType.cpp +++ b/core/XdmfArrayType.cpp @@ -23,9 +23,14 @@ #include #include +#include +#include "string.h" #include "XdmfArrayType.hpp" #include "XdmfError.hpp" +std::map(*)()> > + XdmfArrayType::mArrayDefinitions; + // Supported XdmfArrayTypes shared_ptr XdmfArrayType::Uninitialized() @@ -104,6 +109,22 @@ XdmfArrayType::String() return p; } +void +XdmfArrayType::InitTypes() +{ + mArrayDefinitions["NONE"][0] = Uninitialized; + mArrayDefinitions["CHAR"][1] = Int8; + mArrayDefinitions["SHORT"][2] = Int16; + mArrayDefinitions["INT"][4] = Int32; + mArrayDefinitions["INT"][8] = Int64; + mArrayDefinitions["FLOAT"][4] = Float32; + mArrayDefinitions["FLOAT"][8] = Float64; + mArrayDefinitions["UCHAR"][1] = UInt8; + mArrayDefinitions["USHORT"][2] = UInt16; + mArrayDefinitions["UINT"][4] = UInt32; + mArrayDefinitions["STRING"][0] = String; +} + XdmfArrayType::XdmfArrayType(const std::string & name, const unsigned int precision, const Format typeFormat) : @@ -123,6 +144,7 @@ XdmfArrayType::~XdmfArrayType() shared_ptr XdmfArrayType::New(const std::map & itemProperties) { + InitTypes(); std::map::const_iterator type = itemProperties.find("DataType"); if(type == itemProperties.end()) { @@ -132,45 +154,40 @@ XdmfArrayType::New(const std::map & itemProperties) // to support old xdmf defaults, return Float32() return Float32(); } - const std::string & typeVal = type->second; - + const std::string & typeVal = ConvertToUpper(type->second); std::map::const_iterator precision = itemProperties.find("Precision"); - const unsigned int precisionVal = - (precision == itemProperties.end()) ? 0 : atoi(precision->second.c_str()); + const unsigned int precisionVal = + (precision == itemProperties.end()) ? 0 : atoi(precision->second.c_str()); + std::map(*)()> >::const_iterator returnType = mArrayDefinitions.find(typeVal); + if (returnType == mArrayDefinitions.end()) { + XdmfError::message(XdmfError::FATAL, + "Type not one of accepted values: " + typeVal + + " in XdmfArrayType::New"); + } + else { + std::map(*)()>::const_iterator returnPrecision = returnType->second.find(precisionVal); - if(typeVal.compare("Float") == 0) { - if(precisionVal == 8) { - return Float64(); + if (returnPrecision == returnType->second.end()) { + // Default to 32bit types if not specified otherwise + returnPrecision = returnType->second.find(4); } - return Float32(); - } - else if(typeVal.compare("Int") == 0) { - if(precisionVal == 8) { - return Int64(); + + if (returnPrecision == returnType->second.end()) { + std::string errorVal = ""; + if (precision == itemProperties.end()) { + errorVal = "0"; + } + else { + errorVal = precision->second; + } + XdmfError::message(XdmfError::FATAL, + "Type not one of accepted precision: " + errorVal + + " in XdmfArrayType::New"); + } + else { + return (*(returnPrecision->second))(); } - return Int32(); - } - else if(typeVal.compare("String") == 0) { - return String(); - } - else if(typeVal.compare("Char") == 0) { - return Int8(); - } - else if(typeVal.compare("Short") == 0) { - return Int16(); - } - else if(typeVal.compare("UChar") == 0) { - return UInt8(); - } - else if(typeVal.compare("UShort") == 0) { - return UInt16(); - } - else if(typeVal.compare("UInt") == 0) { - return UInt32(); - } - else if(typeVal.compare("None") == 0) { - return Uninitialized(); } XdmfError::message(XdmfError::FATAL, @@ -393,3 +410,200 @@ XdmfArrayType::getProperties(std::map & collectedPrope collectedProperties.insert(std::make_pair("DataType", mName)); collectedProperties.insert(std::make_pair("Precision", mPrecisionString)); } + +// C Wrappers + +shared_ptr +intToType(int type) +{ + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + return XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + return XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + return XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + return XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + return XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + return XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + return XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + return XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + return XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + return shared_ptr(); +} + +int +typeToInt(shared_ptr type) +{ + std::string typeName = type->getName(); + unsigned int typePrecision = type->getElementSize(); + if (typeName == XdmfArrayType::UInt8()->getName()) + { + return XDMF_ARRAY_TYPE_UINT8; + } + else if (typeName == XdmfArrayType::UInt16()->getName()) + { + return XDMF_ARRAY_TYPE_UINT16; + } + else if (typeName == XdmfArrayType::UInt32()->getName()) + { + return XDMF_ARRAY_TYPE_UINT32; + } + else if (typeName == XdmfArrayType::Int8()->getName()) + { + return XDMF_ARRAY_TYPE_INT8; + } + else if (typeName == XdmfArrayType::Int16()->getName()) + { + return XDMF_ARRAY_TYPE_INT16; + } + else if (typeName == XdmfArrayType::Int32()->getName() || typeName == XdmfArrayType::Int64()->getName()) + { + if (typePrecision == 4) + { + return XDMF_ARRAY_TYPE_INT32; + } + else if (typePrecision == 8) + { + return XDMF_ARRAY_TYPE_INT64; + } + else + { + } + } + else if (typeName == XdmfArrayType::Float32()->getName() || typeName == XdmfArrayType::Float64()->getName()) + { + if (typePrecision == 4) + { + return XDMF_ARRAY_TYPE_FLOAT32; + } + else if (typePrecision == 8) + { + return XDMF_ARRAY_TYPE_FLOAT64; + } + else + { + } + } + else if (typeName == XdmfArrayType::String()->getName()) + { + //This shouldn't be used from C bindings + XdmfError::message(XdmfError::FATAL, + "Error: String type not usable from C."); + } + else + { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + } + return -1; +} + +int XdmfArrayTypeInt8() +{ + return XDMF_ARRAY_TYPE_INT8; +} + +int XdmfArrayTypeInt16() +{ + return XDMF_ARRAY_TYPE_INT16; +} + +int XdmfArrayTypeInt32() +{ + return XDMF_ARRAY_TYPE_INT32; +} + +int XdmfArrayTypeInt64() +{ + return XDMF_ARRAY_TYPE_INT64; +} + +int XdmfArrayTypeFloat32() +{ + return XDMF_ARRAY_TYPE_FLOAT32; +} + +int XdmfArrayTypeFloat64() +{ + return XDMF_ARRAY_TYPE_FLOAT64; +} + +int XdmfArrayTypeUInt8() +{ + return XDMF_ARRAY_TYPE_UINT8; +} + +int XdmfArrayTypeUInt16() +{ + return XDMF_ARRAY_TYPE_UINT16; +} + +int XdmfArrayTypeUInt32() +{ + return XDMF_ARRAY_TYPE_UINT32; +} + +int XdmfArrayTypeComparePrecision(int type1, int type2, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr tempType1 = intToType(type1); + shared_ptr tempType2 = intToType(type2); + shared_ptr returnType = XdmfArrayType::comparePrecision(tempType1, tempType2); + return typeToInt(returnType); + XDMF_ERROR_WRAP_END(status) + return -1; +} + +int XdmfArrayTypeGetElementSize(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return intToType(type)->getElementSize(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +int XdmfArrayTypeGetIsFloat(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return intToType(type)->getIsFloat(); + XDMF_ERROR_WRAP_END(status) + return false; +} + +int XdmfArrayTypeGetIsSigned(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return intToType(type)->getIsSigned(); + XDMF_ERROR_WRAP_END(status) + return false; +} + +char * XdmfArrayTypeGetName(int type, int * status) +{ + XDMF_ERROR_WRAP_START(status) + char * returnPointer = strdup(intToType(type)->getName().c_str()); + return returnPointer; + XDMF_ERROR_WRAP_END(status) + return NULL; +} diff --git a/core/XdmfArrayType.hpp b/core/XdmfArrayType.hpp index 4bdc2e9e..1409a9e9 100644 --- a/core/XdmfArrayType.hpp +++ b/core/XdmfArrayType.hpp @@ -24,9 +24,14 @@ #ifndef XDMFARRAYTYPE_HPP_ #define XDMFARRAYTYPE_HPP_ -// Includes +// C Compatible Includes #include "XdmfCore.hpp" + +#ifdef __cplusplus + +// Includes #include "XdmfItemProperty.hpp" +#include /** * @brief Property describing what types of values an XdmfArray @@ -70,6 +75,7 @@ public: virtual ~XdmfArrayType(); friend class XdmfArray; + friend class XdmfCoreItemFactory; enum Format { Unsigned, @@ -134,67 +140,67 @@ public: unsigned int getElementSize() const; /** - * Get the name of the data type. + * Gets whether the data type is floating point or not. * * Example of use: * * C++ * * @dontinclude ExampleXdmfArrayType.cpp - * @skipline //#getName - * @until //#getName + * @skipline //#getIsFloat + * @until //#getIsFloat * * Python * * @dontinclude XdmfExampleArrayType.py - * @skipline #//getName - * @until #//getName + * @skipline #//getIsFloat + * @until #//getIsFloat * - * @return The name of the data type. + * @return Whether the data type is signed. */ - std::string getName() const; + bool getIsFloat() const; /** - * Gets whether the data type is floating point or not. + * Gets whether the data type is signed or not. * * Example of use: * * C++ * * @dontinclude ExampleXdmfArrayType.cpp - * @skipline //#getIsFloat - * @until //#getIsFloat + * @skipline //#getIsSigned + * @until //#getIsSigned * * Python * * @dontinclude XdmfExampleArrayType.py - * @skipline #//getIsFloat - * @until #//getIsFloat + * @skipline #//getIsSigned + * @until #//getIsSigned * * @return Whether the data type is signed. */ - bool getIsFloat() const; + bool getIsSigned() const; /** - * Gets whether the data type is signed or not. + * Get the name of the data type. * * Example of use: * * C++ * * @dontinclude ExampleXdmfArrayType.cpp - * @skipline //#getIsSigned - * @until //#getIsSigned + * @skipline //#getName + * @until //#getName * * Python * * @dontinclude XdmfExampleArrayType.py - * @skipline #//getIsSigned - * @until #//getIsSigned + * @skipline #//getName + * @until #//getName * - * @return Whether the data type is signed. + * @return The name of the data type. */ - bool getIsSigned() const; + std::string getName() const; void getProperties(std::map & collectedProperties) const; @@ -210,11 +216,16 @@ protected: * @param name the name of the XdmfArrayType to construct. * @param precision the precision, in bytes, of the XdmfArrayType to * construct. + * @param typeFormat The format description of the XdmfArrayType. */ XdmfArrayType(const std::string & name, const unsigned int precision, const Format typeFormat); + static std::map(*)()> > mArrayDefinitions; + + static void InitTypes(); + private: XdmfArrayType(const XdmfArrayType &); // Not implemented. @@ -227,6 +238,56 @@ private: const unsigned int mPrecision; std::string mPrecisionString; Format mTypeFormat; + const char * mTypeId; + + // Allows for up to 16 byte sizes for unsigned, signed, and floating point types + // The vector is actually larger than that to allow for the string and uninitialized types + static std::vector > mTypes; + // Due to uninitialized taking position 0 the size of the array is actually one over the max size + static unsigned int mCurrentMaxSize; + // Map of typeid to index in mTypes + static std::map > mTypeIdMap; }; +#endif + +#define XDMF_ARRAY_TYPE_INT8 0 +#define XDMF_ARRAY_TYPE_INT16 1 +#define XDMF_ARRAY_TYPE_INT32 2 +#define XDMF_ARRAY_TYPE_INT64 3 +#define XDMF_ARRAY_TYPE_UINT8 4 +#define XDMF_ARRAY_TYPE_UINT16 5 +#define XDMF_ARRAY_TYPE_UINT32 6 +#define XDMF_ARRAY_TYPE_FLOAT32 7 +#define XDMF_ARRAY_TYPE_FLOAT64 8 + +#ifdef __cplusplus +extern "C" { +#endif + +// These simply return the values defined above +XDMFCORE_EXPORT int XdmfArrayTypeInt8(); +XDMFCORE_EXPORT int XdmfArrayTypeInt16(); +XDMFCORE_EXPORT int XdmfArrayTypeInt32(); +XDMFCORE_EXPORT int XdmfArrayTypeInt64(); +XDMFCORE_EXPORT int XdmfArrayTypeFloat32(); +XDMFCORE_EXPORT int XdmfArrayTypeFloat64(); +XDMFCORE_EXPORT int XdmfArrayTypeUInt8(); +XDMFCORE_EXPORT int XdmfArrayTypeUInt16(); +XDMFCORE_EXPORT int XdmfArrayTypeUInt32(); + +XDMFCORE_EXPORT int XdmfArrayTypeComparePrecision(int type1, int type2, int * status); + +XDMFCORE_EXPORT int XdmfArrayTypeGetElementSize(int type, int * status); + +XDMFCORE_EXPORT int XdmfArrayTypeGetIsFloat(int type, int * status); + +XDMFCORE_EXPORT int XdmfArrayTypeGetIsSigned(int type, int * status); + +XDMFCORE_EXPORT char * XdmfArrayTypeGetName(int type, int * status); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFARRAYTYPE_HPP_ */ diff --git a/core/XdmfBinaryController.cpp b/core/XdmfBinaryController.cpp index e70a70ca..75f887b4 100644 --- a/core/XdmfBinaryController.cpp +++ b/core/XdmfBinaryController.cpp @@ -2,7 +2,7 @@ /* Xdmf */ /* eXtensible Data Model and Format */ /* */ -/* Id : XdmfBinaryController.cpp */ +/* Id : XdmfBinaryController.cpp */ /* */ /* Author: */ /* Kenneth Leiter */ @@ -82,31 +82,70 @@ XdmfBinaryController::New(const std::string & filePath, type, endian, seek, + std::vector(dimensions.size(), 0), + std::vector(dimensions.size(), 1), + dimensions, dimensions)); return p; } +shared_ptr +XdmfBinaryController::New(const std::string & filePath, + const shared_ptr & type, + const Endian & endian, + const unsigned int seek, + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces) +{ + shared_ptr p(new XdmfBinaryController(filePath, + type, + endian, + seek, + starts, + strides, + dimensions, + dataspaces)); + return p; +} + XdmfBinaryController::XdmfBinaryController(const std::string & filePath, const shared_ptr & type, const Endian & endian, const unsigned int seek, - const std::vector & dimensions) : + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces) : XdmfHeavyDataController(filePath, type, - dimensions), + starts, + strides, + dimensions, + dataspaces), mEndian(endian), mSeek(seek) { } +XdmfBinaryController::XdmfBinaryController(const XdmfBinaryController & refController): + XdmfHeavyDataController(refController), + mEndian(refController.mEndian), + mSeek(refController.mSeek) +{ +} + XdmfBinaryController::~XdmfBinaryController() { } std::string -XdmfBinaryController::getDescriptor() const +XdmfBinaryController::getDataspaceDescription() const { - return ""; + std::stringstream descstream; + descstream << mSeek << ":" << XdmfHeavyDataController::getDataspaceDescription(); + return descstream.str(); } XdmfBinaryController::Endian @@ -125,9 +164,7 @@ void XdmfBinaryController::getProperties(std::map & collectedProperties) const { collectedProperties["Format"] = this->getName(); - std::stringstream seekStream; - seekStream << mSeek; - collectedProperties["Seek"] = seekStream.str(); + if(mEndian == BIG) { collectedProperties["Endian"] = "Big"; } @@ -147,6 +184,10 @@ XdmfBinaryController::read(XdmfArray * const array) { array->initialize(mType, mDimensions); + shared_ptr dataspaceArray = XdmfArray::New(); + + dataspaceArray->initialize(mType, mDataspaceDimensions); + std::ifstream fileStream(mFilePath.c_str(), std::ifstream::binary); @@ -164,8 +205,8 @@ XdmfBinaryController::read(XdmfArray * const array) " in XdmfBinaryController::read"); } - fileStream.read(static_cast(array->getValuesInternal()), - array->getSize() * mType->getElementSize()); + fileStream.read(static_cast(dataspaceArray->getValuesInternal()), + dataspaceArray->getSize() * mType->getElementSize()); #if defined(XDMF_BIG_ENDIAN) const bool needByteSwap = mEndian == LITTLE; @@ -178,16 +219,16 @@ XdmfBinaryController::read(XdmfArray * const array) case 1: break; case 2: - ByteSwaper<2>::swap(array->getValuesInternal(), - array->getSize()); + ByteSwaper<2>::swap(dataspaceArray->getValuesInternal(), + dataspaceArray->getSize()); break; case 4: - ByteSwaper<4>::swap(array->getValuesInternal(), - array->getSize()); + ByteSwaper<4>::swap(dataspaceArray->getValuesInternal(), + dataspaceArray->getSize()); break; case 8: - ByteSwaper<8>::swap(array->getValuesInternal(), - array->getSize()); + ByteSwaper<8>::swap(dataspaceArray->getValuesInternal(), + dataspaceArray->getSize()); break; default: XdmfError::message(XdmfError::FATAL, @@ -195,5 +236,169 @@ XdmfBinaryController::read(XdmfArray * const array) break; } } + array->insert(std::vector(mDimensions.size(), 0), + dataspaceArray, + mStart, + mDataspaceDimensions, + mDimensions, + std::vector(mDimensions.size(), 1), + mStride); +} + +// C Wrappers +XDMFBINARYCONTROLLER * +XdmfBinaryControllerNew(char * filePath, + int type, + int endian, + unsigned int seek, + unsigned int * dimensions, + unsigned int numDims, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector dimVector(dimensions, dimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + XdmfBinaryController::Endian buildEndian = XdmfBinaryController::NATIVE; + printf("switch endian = %u\n", endian); + switch (endian) { + case XDMF_BINARY_CONTROLLER_ENDIAN_BIG: + buildEndian = XdmfBinaryController::BIG; + break; + case XDMF_BINARY_CONTROLLER_ENDIAN_LITTLE: + buildEndian = XdmfBinaryController::LITTLE; + break; + case XDMF_BINARY_CONTROLLER_ENDIAN_NATIVE: + buildEndian = XdmfBinaryController::NATIVE; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Endian."); + break; + } + shared_ptr generatedController = XdmfBinaryController::New(std::string(filePath), buildType, buildEndian, seek, dimVector); + return (XDMFBINARYCONTROLLER *)((void *)(new XdmfBinaryController(*generatedController.get()))); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFBINARYCONTROLLER * +XdmfBinaryControllerNewHyperslab(char * filePath, + int type, + int endian, + unsigned int seek, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + XdmfBinaryController::Endian buildEndian = XdmfBinaryController::NATIVE; + switch (endian) { + case XDMF_BINARY_CONTROLLER_ENDIAN_BIG: + buildEndian = XdmfBinaryController::BIG; + break; + case XDMF_BINARY_CONTROLLER_ENDIAN_LITTLE: + buildEndian = XdmfBinaryController::LITTLE; + break; + case XDMF_BINARY_CONTROLLER_ENDIAN_NATIVE: + buildEndian = XdmfBinaryController::NATIVE; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid Endian."); + break; + } + shared_ptr generatedController = XdmfBinaryController::New(std::string(filePath), buildType, buildEndian, seek, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFBINARYCONTROLLER *)((void *)(new XdmfBinaryController(*generatedController.get()))); + XDMF_ERROR_WRAP_END(status) + return NULL; } + +int +XdmfBinaryControllerGetEndian(XDMFBINARYCONTROLLER * controller) +{ + return ((XdmfBinaryController *)(controller))->getEndian(); +} + +unsigned int +XdmfBinaryControllerGetSeek(XDMFBINARYCONTROLLER * controller) +{ + return ((XdmfBinaryController *)(controller))->getSeek(); +} + +// C Wrappers for parent classes are generated by macros +XDMF_HEAVYCONTROLLER_C_CHILD_WRAPPER(XdmfBinaryController, XDMFBINARYCONTROLLER) diff --git a/core/XdmfBinaryController.hpp b/core/XdmfBinaryController.hpp index 217f8644..0d411044 100644 --- a/core/XdmfBinaryController.hpp +++ b/core/XdmfBinaryController.hpp @@ -2,7 +2,7 @@ /* XDMF */ /* eXtensible Data Model and Format */ /* */ -/* Id : XdmfBinaryController.hpp */ +/* Id : XdmfBinaryController.hpp */ /* */ /* Author: */ /* Kenneth Leiter */ @@ -24,10 +24,12 @@ #ifndef XDMFBinaryCONTROLLER_HPP_ #define XDMFBinaryCONTROLLER_HPP_ -// Includes +// C Compatible Includes #include "XdmfCore.hpp" #include "XdmfHeavyDataController.hpp" +#ifdef __cplusplus + /** * @brief Couples an XdmfArray with Binary data stored on disk. * @@ -52,12 +54,25 @@ public: /** * Create a new controller for an binary data set on disk. * - * @param filePath the location of the binary file. - * @param type the data type of the dataset to read. - * @param endian the endianness of the data. - * @param seek in bytes to begin reading in file. - * @param dimensions the number of elements to select in each - * dimension from the hdf5 data set. (size in each dimension) + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfBinaryController.cpp + * @skipline //#initializationsimplified + * @until //#initializationsimplified + * + * Python + * + * @dontinclude XdmfExampleBinaryController.py + * @skipline #//initializationsimplified + * @until #//initializationsimplified + * + * @param filePath Location of the binary file. + * @param type Data type of the dataset to read. + * @param endian Endianness of the data. + * @param seek Distance in bytes to begin reading in file. + * @param dimensions Number of elements to select in each from the total * * @return New Binary Controller. */ @@ -68,8 +83,69 @@ public: const unsigned int seek, const std::vector & dimensions); - virtual std::string getDescriptor() const; + /** + * Create a new controller for an binary data set on disk. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfBinaryController.cpp + * @skipline //#initialization + * @until //#initialization + * + * Python + * + * @dontinclude XdmfExampleBinaryController.py + * @skipline #//initialization + * @until #//initialization + * + * @param filePath Location of the binary file. + * @param type Data type of the dataset to read. + * @param endian Endianness of the data. + * @param seek Distance in bytes to begin reading in file. + * @param starts Starting index for each dimension + * @param strides Distance between read values across the dataspace + * @param dimensions Number of elements to select in each from the total + * @param dataspaces Total number of elements to select in each + * + * @return New Binary Controller. + */ + static shared_ptr + New(const std::string & filePath, + const shared_ptr & type, + const Endian & endian, + const unsigned int seek, + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces); + virtual std::string getDataspaceDescription() const; + + /** + * Gets the endianness of the dataset that the controller points to. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfBinaryController.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getEndian + * @until //#getEndian + * + * Python + * + * @dontinclude XdmfExampleBinaryController.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getEndian + * @until #//getEndian + * + * @return The endianness of the dataset. + */ virtual Endian getEndian() const; virtual std::string getName() const; @@ -77,21 +153,48 @@ public: virtual void getProperties(std::map & collectedProperties) const; + /** + * Gets the offset in bytes of the dataset that the controller points to in the file. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfBinaryController.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getSeek + * @until //#getSeek + * + * Python + * + * @dontinclude XdmfExampleBinaryController.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getSeek + * @until #//getSeek + * + * @return The offset in bytes. + */ virtual unsigned int getSeek() const; virtual void read(XdmfArray * const array); + XdmfBinaryController(const XdmfBinaryController &); + protected: XdmfBinaryController(const std::string & filePath, const shared_ptr & type, const Endian & endian, const unsigned int seek, - const std::vector & dimensions); + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces); private: - XdmfBinaryController(const XdmfBinaryController &); // Not implemented. void operator=(const XdmfBinaryController &); // Not implemented. const Endian mEndian; @@ -99,4 +202,46 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define XDMF_BINARY_CONTROLLER_ENDIAN_BIG 50 +#define XDMF_BINARY_CONTROLLER_ENDIAN_LITTLE 51 +#define XDMF_BINARY_CONTROLLER_ENDIAN_NATIVE 52 + +struct XDMFBINARYCONTROLLER; // Simply as a typedef to ensure correct typing +typedef struct XDMFBINARYCONTROLLER XDMFBINARYCONTROLLER; + +XDMFCORE_EXPORT XDMFBINARYCONTROLLER * XdmfBinaryControllerNew(char * filePath, + int type, + int endian, + unsigned int seek, + unsigned int * dimensions, + unsigned int numDims, + int * status); + +XDMFCORE_EXPORT XDMFBINARYCONTROLLER * XdmfBinaryControllerNewHyperslab(char * filePath, + int type, + int endian, + unsigned int seek, + unsigned int * starts, + unsigned int * strides, + unsigned int * dimensions, + unsigned int * dataspaces, + unsigned int numDims, + int * status); + +XDMFCORE_EXPORT int XdmfBinaryControllerGetEndian(XDMFBINARYCONTROLLER * controller); + +XDMFCORE_EXPORT unsigned int XdmfBinaryControllerGetSeek(XDMFBINARYCONTROLLER * controller); + +XDMF_HEAVYCONTROLLER_C_CHILD_DECLARE(XdmfBinaryController, XDMFBINARYCONTROLLER, XDMFCORE) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFBinaryCONTROLLER_HPP_ */ diff --git a/core/XdmfConfig.hpp.in b/core/XdmfConfig.hpp.in index 1b5a9bc1..67cf82f5 100644 --- a/core/XdmfConfig.hpp.in +++ b/core/XdmfConfig.hpp.in @@ -25,6 +25,7 @@ #define XDMFCONFIG_HPP_ #cmakedefine HAVE_BOOST_SHARED_DYNAMIC_CAST +#cmakedefine HAVE_CXX11_ENABLE_IF #cmakedefine XDMF_BIG_ENDIAN #endif /* XDMFSHAREDPTR_HPP_ */ diff --git a/core/XdmfCore.i b/core/XdmfCore.i index a1c82d94..00f6401f 100644 --- a/core/XdmfCore.i +++ b/core/XdmfCore.i @@ -25,6 +25,7 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i #include #include #include + #include #include #include #include @@ -32,6 +33,356 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i #include %} +// Ignoring C Wrappers + +// XdmfItem + +%ignore XdmfItemAccept(XDMFITEM * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfItemFree(void * item); +%ignore XdmfItemGetInformation(XDMFITEM * item, unsigned int index); +%ignore XdmfItemGetInformationByKey(XDMFITEM * item, char * key); +%ignore XdmfItemGetNumberInformations(XDMFITEM * item); +%ignore XdmfItemInsertInformation(XDMFITEM * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfItemRemoveInformation(XDMFITEM * item, unsigned int index); +%ignore XdmfItemRemoveInformationByKey(XDMFITEM * item, char * key); +%ignore XdmfItemGetItemTag(XDMFITEM * item); + +// XdmfArray + +%ignore XdmfArrayNew(); +%ignore XdmfArrayClear(XDMFARRAY * array); +%ignore XdmfArrayErase(XDMFARRAY * array, unsigned int index); +%ignore XdmfArrayGetArrayType(XDMFARRAY * array, int * status); +%ignore XdmfArrayGetCapacity(XDMFARRAY * array); +%ignore XdmfArrayGetDimensions(XDMFARRAY * array); +%ignore XdmfArrayGetDimensionsString(XDMFARRAY * array); +%ignore XdmfArrayGetHeavyDataController(XDMFARRAY * array, unsigned int index); +%ignore XdmfArrayGetReadMode(XDMFARRAY * array, int * status); +%ignore XdmfArrayGetName(XDMFARRAY * array); +%ignore XdmfArrayGetNumberDimensions(XDMFARRAY * array); +%ignore XdmfArrayGetNumberHeavyDataControllers(XDMFARRAY * array); +%ignore XdmfArrayGetSize(XDMFARRAY * array); +%ignore XdmfArrayGetReference(XDMFARRAY * array); +%ignore XdmfArrayGetValue(XDMFARRAY * array, unsigned int index, int arrayType, int * status); +%ignore XdmfArrayGetValues(XDMFARRAY * array, unsigned int startIndex, int arrayType, unsigned int numValues, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfArrayGetValuesInternal(XDMFARRAY * array); +%ignore XdmfArrayGetValuesString(XDMFARRAY * array); +%ignore XdmfArrayInitialize(XDMFARRAY * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfArrayInsertDataFromPointer(XDMFARRAY * array, void * values, int arrayType, unsigned int startIndex, unsigned int numVals, unsigned int arrayStride, unsigned int valueStride, int * status); +%ignore XdmfArrayInsertDataFromXdmfArray(XDMFARRAY * array, XDMFARRAY * valArray, int * arrayStarts, int * valueStarts, int * arrayCounts, int * valueCounts, int * arrayStrides, int * valueStrides, int * status); +%ignore XdmfArrayInsertHeavyDataController(XDMFARRAY * array, XDMFHEAVYDATACONTROLLER * controller, int passControl); +%ignore XdmfArrayInsertValue(XDMFARRAY * array, unsigned int index, void * value, int arrayType, int * status); +%ignore XdmfArrayIsInitialized(XDMFARRAY * array); +%ignore XdmfArrayPushBack(XDMFARRAY * array, void * value, int arrayType, int * status); +%ignore XdmfArrayRead(XDMFARRAY * array, int * status); +%ignore XdmfArrayReadController(XDMFARRAY * array, int * status); +%ignore XdmfArrayReadReference(XDMFARRAY * array, int * status); +%ignore XdmfArrayRelease(XDMFARRAY * array); +%ignore XdmfArrayRemoveHeavyDataController(XDMFARRAY * array, unsigned int index); +%ignore XdmfArrayReserve(XDMFARRAY * array, int size); +%ignore XdmfArrayResize(XDMFARRAY * array, int * dims, int numDims, int arrayType, int * status); +%ignore XdmfArraySetReadMode(XDMFARRAY * array, int readMode, int * status); +%ignore XdmfArraySetReference(XDMFARRAY * array, XDMFARRAYREFERENCE * reference, int passControl); +%ignore XdmfArraySetName(XDMFARRAY * array, char * name, int * status); +%ignore XdmfArraySetValuesInternal(XDMFARRAY * array, void * pointer, unsigned int numValues, int arrayType, int transferOwnership, int * status); +%ignore XdmfArraySwapWithXdmfArray(XDMFARRAY * array, XDMFARRAY * swapArray); +%ignore XdmfArraySwapWithArray(XDMFARRAY * array, void ** pointer, int numValues, int arrayType, int * status); +// XdmfArray inherited from XdmfItem +%ignore XdmfArrayAccept(XDMFARRAY * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfArrayFree(void * item); +%ignore XdmfArrayGetInformation(XDMFARRAY * item, unsigned int index); +%ignore XdmfArrayGetInformationByKey(XDMFARRAY * item, char * key); +%ignore XdmfArrayGetNumberInformations(XDMFARRAY * item); +%ignore XdmfArrayInsertInformation(XDMFARRAY * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfArrayRemoveInformation(XDMFARRAY * item, unsigned int index); +%ignore XdmfArrayRemoveInformationByKey(XDMFARRAY * item, char * key); +%ignore XdmfArrayGetItemTag(XDMFARRAY * item); + +// XdmfArrayReference + +%ignore XdmfArrayReferenceGetConstructedType(XDMFARRAYREFERENCE * arrayReference); +%ignore XdmfArrayReferenceRead(XDMFARRAYREFERENCE * arrayReference, int * status); +%ignore XdmfArrayReferenceSetConstructedProperties(XDMFARRAYREFERENCE * arrayReference, void * referenceobject); +%ignore XdmfArrayReferenceSetConstructedType(XDMFARRAYREFERENCE * arrayReference, char * newType); +// XdmfArrayReference inherited from XdmfItem +%ignore XdmfArrayReferenceAccept(XDMFARRAYREFERENCE * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfArrayReferenceFree(void * item); +%ignore XdmfArrayReferenceGetInformation(XDMFARRAYREFERENCE * item, unsigned int index); +%ignore XdmfArrayReferenceGetInformationByKey(XDMFARRAYREFERENCE * item, char * key); +%ignore XdmfArrayReferenceGetNumberInformations(XDMFARRAYREFERENCE * item); +%ignore XdmfArrayReferenceInsertInformation(XDMFARRAYREFERENCE * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfArrayReferenceRemoveInformation(XDMFARRAYREFERENCE * item, unsigned int index); +%ignore XdmfArrayReferenceRemoveInformationByKey(XDMFARRAYREFERENCE * item, char * key); +%ignore XdmfArrayReferenceGetItemTag(XDMFARRAYREFERENCE * item); + +// XdmfArrayType + +%ignore XdmfArrayTypeInt8(); +%ignore XdmfArrayTypeInt16(); +%ignore XdmfArrayTypeInt32(); +%ignore XdmfArrayTypeInt64(); +%ignore XdmfArrayTypeFloat32(); +%ignore XdmfArrayTypeFloat64(); +%ignore XdmfArrayTypeUInt8(); +%ignore XdmfArrayTypeUInt16(); +%ignore XdmfArrayTypeUInt32(); +%ignore XdmfArrayTypeComparePrecision(int type1, int type2, oint * status); +%ignore XdmfArrayTypeGetElementSize(int type, int * status); +%ignore XdmfArrayTypeGetIsSigned(int type, int * status); +%ignore XdmfArrayTypeGetName(int type, int * status); + +// XdmfCoreReader + +%ignore XdmfCoreReaderRead(XDMFCOREREADER * reader, char * filePath, int * status); + +// XdmfError + +%ignore XdmfErrorSetCErrorsAreFatal(int status); +%ignore XdmfErrorSetLevelLimit(int level, int * status); +%ignore XdmfErrorSetSuppressionLevel(int level, int * status); +%ignore XdmfErrorGetCErrorsAreFatal(); +%ignore XdmfErrorGetLevelLimit(); +%ignore XdmfErrorGetSuppressionLevel(); + +// XdmfFunction + +%ignore XdmfFunctionNew(); +%ignore XdmfFunctionNewInit(char * newExpression, char ** keys, XDMFARRAY ** values, int numVariables); +%ignore XdmfFunctionAddFunction(char * name, XDMFARRAY *(*functionref)(XDMFARRAY **, unsigned int), int * status); +%ignore XdmfFunctionAddOperation(char newoperator, XDMFARRAY *(*operationref)(XDMFARRAY *, XDMFARRAY *), int priority, int * status); +%ignore XdmfFunctionAverage(XDMFARRAY ** values, int numValues); +%ignore XdmfFunctionChunk(XDMFARRAY * val1, XDMFARRAY * val2, int * status); +%ignore XdmfFunctionEvaluateExpression(char * expression, char ** keys, XDMFARRAY ** values, int numVariables, int * status); +%ignore XdmfFunctionEvaluateOperation(XDMFARRAY * val1, XDMFARRAY * val2, char operation, int * status); +%ignore XdmfFunctionEvaluateFunction(XDMFARRAY ** valueVector, int numValues, char * functionName, int * status); +%ignore XdmfFunctionGetExpression(XDMFFUNCTION * function); +%ignore XdmfFunctionGetNumberVariables(XDMFFUNCTION * function); +%ignore XdmfFunctionGetOperationPriority(char operation); +%ignore XdmfFunctionGetSupportedOperations(); +%ignore XdmfFunctionGetSupportedFunctions(); +%ignore XdmfFunctionGetNumberSupportedFunctions(); +%ignore XdmfFunctionGetValidDigitChars(); +%ignore XdmfFunctionGetValidVariableChars(); +%ignore XdmfFunctionGetVariable(XDMFFUNCTION * function, char * key); +%ignore XdmfFunctionGetVariableList(XDMFFUNCTION * function); +%ignore XdmfFunctionInterlace(XDMFARRAY * val1, XDMFARRAY * val2, int * status); +%ignore XdmfFunctionInsertVariable(XDMFFUNCTION * function, char * key, XDMFARRAY * value, int passControl); +%ignore XdmfFunctionRemoveVariable(XDMFFUNCTION * function, char * key); +%ignore XdmfFunctionSetExpression(XDMFFUNCTION * function, char * newExpression, int * status); +%ignore XdmfFunctionSum(XDMFARRAY ** values, int numValues); +// XdmfFunction inherited from XdmfItem +%ignore XdmfFunctionAccept(XDMFFUNCTION * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfFunctionFree(void * item); +%ignore XdmfFunctionGetInformation(XDMFFUNCTION * item, unsigned int index); +%ignore XdmfFunctionGetInformationByKey(XDMFFUNCTION * item, char * key); +%ignore XdmfFunctionGetNumberInformations(XDMFFUNCTION * item); +%ignore XdmfFunctionInsertInformation(XDMFFUNCTION * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfFunctionRemoveInformation(XDMFFUNCTION * item, unsigned int index); +%ignore XdmfFunctionRemoveInformationByKey(XDMFFUNCTION * item, char * key); +%ignore XdmfFunctionGetItemTag(XDMFFUNCTION * item); +// XdmfFunction inherited from XdmfArrayReference +%ignore XdmfFunctionGetConstructedType(XDMFFUNCTION * arrayReference); +%ignore XdmfFunctionRead(XDMFFUNCTION * arrayReference, int * status); +%ignore XdmfFunctionSetConstructedProperties(XDMFFUNCTION * arrayReference, void * referenceobject); +%ignore XdmfFunctionSetConstructedType(XDMFFUNCTION * arrayReference, char * newType); + +// XdmfHDF5Controller + +%ignore XdmfHDF5ControllerNew(char * hdf5FilePath, char * dataSetPath, int type, unsigned int * start, unsigned int * stride, unsigned int * dimensions, unsigned int * dataspaceDimensions, unsigned int numDims, int * status); +%ignore XdmfHDF5ControllerGetDataSetPath(XDMFHDF5CONTROLLER * controller); +// XdmfHDF5Controller inherited from XdmfHeavyDataController +%ignore XdmfHDF5ControllerFree(XDMFHDF5CONTROLLER * item); +%ignore XdmfHDF5ControllerGetDataspaceDimensions(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetDimensions(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetFilePath(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetName(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetNumberDimensions(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetSize(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetStart(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetStride(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerSetArrayOffset(XDMFHDF5CONTROLLER * controller, unsigned int newOffset); +%ignore XdmfHDF5ControllerGetArrayOffset(XDMFHDF5CONTROLLER * controller); +%ignore XdmfHDF5ControllerGetType(XDMFHDF5CONTROLLER * controller, int * status); +%ignore XdmfHDF5ControllerRead(XDMFHDF5CONTROLLER * controller, void * array, int * status); + +// XdmfHDF5Writer + +%ignore XdmfHDF5WriterNew(char * fileName, int clobberFile); +%ignore XdmfHDF5WriterCloseFile(XDMFHDF5WRITER * writer, int * status); +%ignore XdmfHDF5WriterGetChunkSize(XDMFHDF5WRITER * writer, int * status); +%ignore XdmfHDF5WriterOpenFile(XDMFHDF5WRITER * writer, int * status); +%ignore XdmfHDF5WriterSetChunkSize(XDMFHDF5WRITER * writer, unsigned int chunkSize, int * status); +// XdmfHDF5Writer inherited from XdmfHeavyDataWriter +%ignore XdmfHDF5WriterFree(XDMFHDF5WRITER * item); +%ignore XdmfHDF5WriterGetAllowSetSplitting(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterGetFileIndex(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterGetFileOverhead(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterGetFilePath(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterGetFileSizeLimit(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterGetMode(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterGetReleaseData(XDMFHDF5WRITER * writer); +%ignore XdmfHDF5WriterSetAllowSetSplitting(XDMFHDF5WRITER * writer, int newAllow); +%ignore XdmfHDF5WriterSetFileIndex(XDMFHDF5WRITER * writer, int newIndex); +%ignore XdmfHDF5WriterSetFileSizeLimit(XDMFHDF5WRITER * writer, int newSize); +%ignore XdmfHDF5WriterSetMode(XDMFHDF5WRITER * writer, int mode, int * status); +%ignore XdmfHDF5WriterSetReleaseData(XDMFHDF5WRITER * writer, int releaseData); + +// XdmfHeavyDataController + +%ignore XdmfHeavyDataControllerFree(XDMFHEAVYDATACONTROLLER * item); +%ignore XdmfHeavyDataControllerGetDataspaceDimensions(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetDimensions(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetFilePath(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetName(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetNumberDimensions(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetSize(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetStart(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetStride(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerSetArrayOffset(XDMFHEAVYDATACONTROLLER * controller, unsigned int newOffset); +%ignore XdmfHeavyDataControllerGetArrayOffset(XDMFHEAVYDATACONTROLLER * controller); +%ignore XdmfHeavyDataControllerGetType(XDMFHEAVYDATACONTROLLER * controller, int * status); +%ignore XdmfHeavyDataControllerRead(XDMFHEAVYDATACONTROLLER * controller, void * array, int * status); + +// XdmfHeavyDataWriter + +%ignore XdmfHeavyDataWriterFree(XDMFHEAVYDATAWRITER * item); +%ignore XdmfHeavyDataWriterGetAllowSetSplitting(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterGetFileIndex(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterGetFileOverhead(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterGetFilePath(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterGetFileSizeLimit(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterGetMode(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterGetReleaseData(XDMFHEAVYDATAWRITER * writer); +%ignore XdmfHeavyDataWriterSetAllowSetSplitting(XDMFHEAVYDATAWRITER * writer, int newAllow); +%ignore XdmfHeavyDataWriterSetFileIndex(XDMFHEAVYDATAWRITER * writer, int newIndex); +%ignore XdmfHeavyDataWriterSetFileSizeLimit(XDMFHEAVYDATAWRITER * writer, int newSize); +%ignore XdmfHeavyDataWriterSetMode(XDMFHEAVYDATAWRITER * writer, int mode, int * status); +%ignore XdmfHeavyDataWriterSetReleaseData(XDMFHEAVYDATAWRITER * writer, int releaseData); + +// XdmfInformation + +%ignore XdmfInformationNew(char * key, char * value); +%ignore XdmfInformationGetArray(XDMFINFORMATION * information, unsigned int index); +%ignore XdmfInformationGetArrayByName(XDMFINFORMATION * information, char * name); +%ignore XdmfInformationGetKey(XDMFINFORMATION * information); +%ignore XdmfInformationGetNumberArrays(XDMFINFORMATION * information); +%ignore XdmfInformationGetValue(XDMFINFORMATION * information); +%ignore XdmfInformationInsertArray(XDMFINFORMATION * information, XDMFARRAY * array, int transferOwnership); +%ignore XdmfInformationRemoveArray(XDMFINFORMATION * information, unsigned int index); +%ignore XdmfInformationRemoveArrayByName(XDMFINFORMATION * information, char * name); +%ignore XdmfInformationSetKey(XDMFINFORMATION * information, char * key, int * status); +%ignore XdmfInformationSetValue(XDMFINFORMATION * information, char * value, int * status); +// XdmfInformation inherited from XdmfItem +%ignore XdmfInformationAccept(XDMFINFORMATION * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfInformationFree(void * item); +%ignore XdmfInformationGetInformation(XDMFINFORMATION * item, unsigned int index); +%ignore XdmfInformationGetInformationByKey(XDMFINFORMATION * item, char * key); +%ignore XdmfInformationGetNumberInformations(XDMFINFORMATION * item); +%ignore XdmfInformationInsertInformation(XDMFINFORMATION * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfInformationRemoveInformation(XDMFINFORMATION * item, unsigned int index); +%ignore XdmfInformationRemoveInformationByKey(XDMFINFORMATION * item, char * key); +%ignore XdmfInformationGetItemTag(XDMFINFORMATION * item); + +// XdmfSparseMatrix + +%ignore XdmfSparseMatrixNew(unsigned int numberRows, unsigned int numberColumns); +%ignore XdmfSparseMatrixGetColumnIndex(XDMFSPARSEMATRIX * matrix, int * status); +%ignore XdmfSparseMatrixGetName(XDMFSPARSEMATRIX * matrix); +%ignore XdmfSparseMatrixGetNumberColumns(XDMFSPARSEMATRIX * matrix); +%ignore XdmfSparseMatrixGetNumberRows(XDMFSPARSEMATRIX * matrix); +%ignore XdmfSparseMatrixGetRowPointer(XDMFSPARSEMATRIX * matrix, int * status); +%ignore XdmfSparseMatrixGetValues(XDMFSPARSEMATRIX * matrix, int * status); +%ignore XdmfSparseMatrixGetValuesString(XDMFSPARSEMATRIX * matrix, int * status); +%ignore XdmfSparseMatrixSetColumnIndex(XDMFSPARSEMATRIX * matrix, + XDMFARRAY * columnIndex, + int passControl, + int * status); +%ignore XdmfSparseMatrixSetName(XDMFSPARSEMATRIX * matrix, char * name, int * status); +%ignore XdmfSparseMatrixSetRowPointer(XDMFSPARSEMATRIX * matrix, + XDMFARRAY * rowPointer, + int passControl, + int * status); +%ignore XdmfSparseMatrixSetValues(XDMFSPARSEMATRIX * matrix, + XDMFARRAY * values, + int passControl, + int * status); +// XdmfSparseMatrix inherited from XdmfItem +%ignore XdmfSparseMatrixAccept(XDMFSPARSEMATRIX * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfSparseMatrixFree(void * item); +%ignore XdmfSparseMatrixGetInformation(XDMFSPARSEMATRIX * item, unsigned int index); +%ignore XdmfSparseMatrixGetInformationByKey(XDMFSPARSEMATRIX * item, char * key); +%ignore XdmfSparseMatrixGetNumberInformations(XDMFSPARSEMATRIX * item); +%ignore XdmfSparseMatrixInsertInformation(XDMFSPARSEMATRIX * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfSparseMatrixRemoveInformation(XDMFSPARSEMATRIX * item, unsigned int index); +%ignore XdmfSparseMatrixRemoveInformationByKey(XDMFSPARSEMATRIX * item, char * key); +%ignore XdmfSparseMatrixGetItemTag(XDMFSPARSEMATRIX * item); + +// XdmfSubset + +%ignore XdmfSubsetNew(void * referenceArray, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int numDims, + int passControl, + int * status); +%ignore XdmfSubsetGetDimensions(XDMFSUBSET * subset); +%ignore XdmfSubsetGetNumberDimensions(XDMFSUBSET * subset); +%ignore XdmfSubsetGetReferenceArray(XDMFSUBSET * subset); +%ignore XdmfSubsetGetSize(XDMFSUBSET * subset); +%ignore XdmfSubsetGetStart(XDMFSUBSET * subset); +%ignore XdmfSubsetGetStride(XDMFSUBSET * subset); +%ignore XdmfSubsetSetDimensions(XDMFSUBSET * subset, + unsigned int * newDimensions, + unsigned int numDims, + int * status); +%ignore XdmfSubsetSetReferenceArray(XDMFSUBSET * subset, + XDMFARRAY * referenceArray, + int passControl); +%ignore XdmfSubsetSetStart(XDMFSUBSET * subset, + unsigned int * newStarts, + unsigned int numDims, + int * status); +%ignore XdmfSubsetSetStride(XDMFSUBSET * subset, + unsigned int * newStrides, + unsigned int numDims, + int * status); +// XdmfSubset inherited from XdmfItem +%ignore XdmfSubsetAccept(XDMFSUBSET * item, XDMFVISITOR * visitor, int * status); +%ignore XdmfSubsetFree(void * item); +%ignore XdmfSubsetGetInformation(XDMFSUBSET * item, unsigned int index); +%ignore XdmfSubsetGetInformationByKey(XDMFSUBSET * item, char * key); +%ignore XdmfSubsetGetNumberInformations(XDMFSUBSET * item); +%ignore XdmfSubsetInsertInformation(XDMFSUBSET * item, XDMFINFORMATION * information, int passControl); +%ignore XdmfSubsetRemoveInformation(XDMFSUBSET * item, unsigned int index); +%ignore XdmfSubsetRemoveInformationByKey(XDMFSUBSET * item, char * key); +%ignore XdmfSubsetGetItemTag(XDMFSUBSET * item); +// XdmfSubset inherited from XdmfArrayReference +%ignore XdmfSubsetGetConstructedType(XDMFSUBSET * arrayReference); +%ignore XdmfSubsetRead(XDMFSUBSET * arrayReference, int * status); +%ignore XdmfSubsetSetConstructedProperties(XDMFSUBSET * arrayReference, void * referenceobject); +%ignore XdmfSubsetSetConstructedType(XDMFSUBSET * arrayReference, char * newType); + +// XdmfWriter + +%ignore XdmfWriterNew(char * fileName); +%ignore XdmfWriterNewSpecifyHeavyDataWriter(char * fileName, XDMFHEAVYDATAWRITER * heavyDataWriter); +%ignore XdmfWriterFree(XDMFWRITER * item); +%ignore XdmfWriterGetFilePath(XDMFWRITER * writer, int * status); +%ignore XdmfWriterGetHeavyDataWriter(XDMFWRITER * writer, int * status); +%ignore XdmfWriterGetLightDataLimit(XDMFWRITER * writer, int * status); +%ignore XdmfWriterGetMode(XDMFWRITER * writer, int * status); +%ignore XdmfWriterGetWriteXPaths(XDMFWRITER * writer, int * status); +%ignore XdmfWriterGetXPathParse(XDMFWRITER * writer, int * status); +%ignore XdmfWriterSetHeavyDataWriter(XDMFWRITER * writer, + XDMFHEAVYDATAWRITER * heavyDataWriter, + int transferOwnership, + int * status); +%ignore XdmfWriterSetLightDataLimit(XDMFWRITER * writer, unsigned int numValues, int * status); +%ignore XdmfWriterSetMode(XDMFWRITER * writer, int mode, int * status); +%ignore XdmfWriterSetWriteXPaths(XDMFWRITER * writer, int writeXPaths, int * status); +%ignore XdmfWriterSetXPathParse(XDMFWRITER * writer, int xPathParse, int * status); + #ifdef SWIGJAVA // Ignore const overloaded methods @@ -127,6 +478,9 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i #ifdef SWIGPYTHON +%ignore XdmfArray::insert(const unsigned int startIndex, const T * const valuesPointer, const unsigned int numValues, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1); +%ignore XdmfArray::pushBack(const T & value); + /*This converts XdmfErrors to Python RuntimeErrors*/ %exception { @@ -245,88 +599,312 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i return(___frombuffer(buf, 'uint32')) return None else : - h5FileName = h5ctl.getFilePath() - h5DataSetName = h5ctl.getDataSetPath() - if (h5FileName == None) | (h5DataSetName == None) : - return None - try : - from h5py import File as ___File - from numpy import array as ___array - f = ___File(h5FileName, 'r') - if h5DataSetName in f.keys() : - return(___array(f[h5DataSetName])) - except : - pass - return None + if h5ctl.getName() == "HDF": + controller = XdmfHeavyDataController.XdmfHDF5ControllerCast(h5ctl) + h5FileName = controller.getFilePath() + h5DataSetName = controller.getDataSetPath() + if (h5FileName == None) | (h5DataSetName == None) : + return None + try : + from h5py import File as ___File + from numpy import array as ___array + f = ___File(h5FileName, 'r') + if h5DataSetName in f.keys() : + return(___array(f[h5DataSetName])) + except : + pass + return None + else: + return None + }; - void insertAsInt8(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void getValues(unsigned int startIndex, PyObject * list, unsigned int numValues = 1, unsigned int arrayStride = 1, unsigned int valuesStride = 1) + { + Py_ssize_t size = PyList_Size(list); + PyObject * placeholderVal; + if (valuesStride * numValues > size) + { + if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int8()) + { + placeholderVal = PyLong_FromLong((char)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int16()) + { + placeholderVal = PyLong_FromLong((short)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int32()) + { + placeholderVal = PyLong_FromLong((int)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int64()) + { + placeholderVal = PyLong_FromLong((long)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Float32()) + { + placeholderVal = PyFloat_FromDouble((float)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Float64()) + { + placeholderVal = PyFloat_FromDouble((double)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::UInt8()) + { + placeholderVal = PyLong_FromUnsignedLong((unsigned char)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::UInt16()) + { + placeholderVal = PyLong_FromUnsignedLong((unsigned short)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::UInt32()) + { + placeholderVal = PyLong_FromUnsignedLong((unsigned int)0); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::String()) + { + placeholderVal = PyString_FromString(""); + } + } + for (unsigned int i = 0; i < numValues; ++i) + { + unsigned int index = startIndex + (i * arrayStride); + unsigned int insertIndex = i * valuesStride; + PyObject * insertedVal; + if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int8()) + { + insertedVal = PyLong_FromLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int16()) + { + insertedVal = PyLong_FromLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int32()) + { + insertedVal = PyLong_FromLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Int64()) + { + insertedVal = PyLong_FromLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Float32()) + { + insertedVal = PyFloat_FromDouble($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::Float64()) + { + insertedVal = PyFloat_FromDouble($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::UInt8()) + { + insertedVal = PyLong_FromUnsignedLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::UInt16()) + { + insertedVal = PyLong_FromUnsignedLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::UInt32()) + { + insertedVal = PyLong_FromUnsignedLong($self->XdmfArray::getValue(index)); + } + else if ($self->XdmfArray::getArrayType() == XdmfArrayType::String()) + { + insertedVal = PyString_FromString($self->XdmfArray::getValue(index).c_str()); + } + if (insertIndex < size) + { + PyList_SetItem(list, insertIndex, insertedVal); + } + else + { + for (unsigned int padding = size; padding < insertIndex; ++padding) + { + PyList_Append(list, placeholderVal); + ++size; + } + PyList_Append(list, insertedVal); + ++size; + } + } + } + + void insertAsInt8(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (char)(PyLong_AsLong(PyList_GetItem(list, i)))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (char) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (char)PyLong_AsLong(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } - void insertAsInt16(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsInt16(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (short)(PyLong_AsLong(PyList_GetItem(list, i)))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (short) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (short)PyLong_AsLong(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } - void insertAsInt32(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsInt32(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (int)(PyLong_AsLong(PyList_GetItem(list, i)))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (int) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (int)PyLong_AsLong(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } - void insertAsInt64(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsInt64(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, PyLong_AsLong(PyList_GetItem(list, i))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (long) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, PyLong_AsLong(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } - void insertAsFloat32(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsFloat32(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (float)PyFloat_AsDouble(PyList_GetItem(list, i))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (float) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (float)PyFloat_AsDouble(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } - void insertAsFloat64(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsFloat64(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, PyFloat_AsDouble(PyList_GetItem(list, i))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (double) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, PyFloat_AsDouble(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } - void insertAsUInt8(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsUInt8(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (unsigned char)(PyLong_AsUnsignedLong(PyList_GetItem(list, i)))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (unsigned char) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (unsigned char)(PyLong_AsUnsignedLong(PyList_GetItem(list, listStartIndex + (i * listStride))))); + } } } - void insertAsUInt16(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsUInt16(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (unsigned short)(PyLong_AsUnsignedLong(PyList_GetItem(list, i)))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (unsigned short) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (unsigned short)(PyLong_AsUnsignedLong(PyList_GetItem(list, listStartIndex + (i * listStride))))); + } } } - void insertAsUInt32(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsUInt32(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, (unsigned int)(PyLong_AsUnsignedLong(PyList_GetItem(list, i)))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, (unsigned int) 0); + } + else { + $self->insert((i * arrayStride) + startIndex, (unsigned int)(PyLong_AsUnsignedLong(PyList_GetItem(list, listStartIndex + (i * listStride))))); + } } } - void insertAsString(int startIndex, PyObject * list) { - Py_ssize_t size = PyList_Size(list); + void insertAsString(int startIndex, PyObject * list, int listStartIndex = 0, int numValues = -1, int arrayStride = 1, int listStride = 1) { + Py_ssize_t size; + if (numValues <= 0) { + size = PyList_Size(list); + } + else { + size = numValues; + } for(Py_ssize_t i = 0; i < size; ++i) { - $self->insert(i+startIndex, PyString_AsString(PyList_GetItem(list, i))); + if (listStartIndex + (i * listStride) >= PyList_Size(list)) { + $self->insert(i+startIndex, ""); + } + else { + $self->insert((i * arrayStride) + startIndex, PyString_AsString(PyList_GetItem(list, listStartIndex + (i * listStride)))); + } } } @@ -339,6 +917,191 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i shared_ptr returnArray = returnArrayPointer[0]; return returnArray; } + + void + pushBackAsInt8(const char & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsInt16(const short & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsInt32(const int & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsInt64(const long & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsUInt8(const unsigned char & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsUInt16(const unsigned short & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsUInt32(const unsigned int & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsFloat32(const float & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsFloat64(const double & value) + { + $self->XdmfArray::pushBack(value); + } + + void + pushBackAsString(const std::string & value) + { + $self->XdmfArray::pushBack(value); + } + + void + insertValueAsInt8(const unsigned int startIndex, const char * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, valuesPointer, numValues, arrayStride, valuesStride); + } + + void + insertValueAsInt8(const unsigned int startIndex, const char value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsInt16(const unsigned int startIndex, const short * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, valuesPointer, numValues, arrayStride, valuesStride); + } + + void + insertValueAsInt16(const unsigned int startIndex, const short value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsInt32(const unsigned int startIndex, const int * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, valuesPointer, numValues, arrayStride, valuesStride); + } + + void + insertValueAsInt32(const unsigned int startIndex, const int value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsInt64(const unsigned int startIndex, const long * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, valuesPointer, numValues, arrayStride, valuesStride); + } + + void + insertValueAsInt64(const unsigned int startIndex, const long value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsUInt8(const unsigned int startIndex, const unsigned char * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, valuesPointer, numValues, arrayStride, valuesStride); + } + + void + insertValueAsUInt8(const unsigned int startIndex, const unsigned char value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsUInt16(const unsigned int startIndex, const unsigned short * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, valuesPointer, numValues, arrayStride, valuesStride); + } + + void + insertValueAsUInt16(const unsigned int startIndex, const unsigned short value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsUInt32(const unsigned int startIndex, const unsigned int * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, (unsigned int *)(valuesPointer), numValues, arrayStride, valuesStride); + } + + void + insertValueAsUInt32(const unsigned int startIndex, const unsigned int value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsFloat32(const unsigned int startIndex, const float * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, (float *)(&valuesPointer), numValues, arrayStride, valuesStride); + } + + void + insertValueAsFloat32(const unsigned int startIndex, const float value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsFloat64(const unsigned int startIndex, const double * const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + $self->XdmfArray::insert(startIndex, (double *)(valuesPointer), numValues, arrayStride, valuesStride); + } + + void + insertValueAsFloat64(const unsigned int startIndex, const double value) + { + $self->XdmfArray::insert(startIndex, value); + } + + void + insertValueAsString(const unsigned int startIndex, const char ** const valuesPointer, const unsigned int numValues = 1, const unsigned int arrayStride = 1, const unsigned int valuesStride = 1) + { + std::string * tempPointer = new std::string[numValues](); + for (unsigned int i = 0; i < numValues; ++i) + { + tempPointer[i] = std::string(valuesPointer[i]); + } + $self->XdmfArray::insert(startIndex, (std::string *)(tempPointer), numValues, arrayStride, valuesStride); + } + + void + insertValueAsString(const unsigned int startIndex, const char * value) + { + $self->XdmfArray::insert(startIndex, std::string(value)); + } }; /*This causes it to avoid throwing a warning for redefining fuctions that are defined for XdmfArray. @@ -500,6 +1263,7 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i %shared_ptr(XdmfItemProperty) %shared_ptr(XdmfSparseMatrix) %shared_ptr(XdmfSubset) +%shared_ptr(XdmfTIFFController) %shared_ptr(XdmfVisitor) %shared_ptr(XdmfWriter) @@ -528,6 +1292,7 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i %include XdmfInformation.hpp %include XdmfHDF5Controller.hpp %include XdmfHDF5Writer.hpp +%include XdmfTIFFController.hpp %include XdmfWriter.hpp %include CMake/VersionSuite/ProjectVersion.hpp @@ -610,5 +1375,8 @@ swig -v -c++ -python -o XdmfCorePython.cpp XdmfCore.i %template(Float64Vector) std::vector; %template(StringVector) std::vector; %template(ItemVector) std::vector >; +%template(HeavyControllerVector) std::vector >; %template(ArrayMap) std::map >; %template(StringMap) std::map; +%template(DSMStructreVector) std::vector >; +%template(DSMApplicationPair) std::pair; diff --git a/core/XdmfCoreItemFactory.cpp b/core/XdmfCoreItemFactory.cpp index 998c19f4..88387815 100644 --- a/core/XdmfCoreItemFactory.cpp +++ b/core/XdmfCoreItemFactory.cpp @@ -22,13 +22,45 @@ /*****************************************************************************/ #include "XdmfArray.hpp" +#include "XdmfBinaryController.hpp" #include "XdmfCoreItemFactory.hpp" #include "XdmfError.hpp" #include "XdmfFunction.hpp" +#include "XdmfHDF5Controller.hpp" +#include "XdmfHDF5Writer.hpp" #include "XdmfSubset.hpp" +#include "XdmfTIFFController.hpp" #include "XdmfInformation.hpp" #include "XdmfSparseMatrix.hpp" #include +#include + +std::string +XdmfCoreItemFactory::getFullHeavyDataPath(const std::string & filePath, + const std::map & itemProperties) const +{ + // FIXME: for other OS (e.g. windows) + if(filePath.size() > 0 && filePath[0] != '/') { + // Dealing with a relative path for heavyData location + std::map::const_iterator xmlDir = + itemProperties.find("XMLDir"); + if(xmlDir == itemProperties.end()) { + XdmfError::message(XdmfError::FATAL, + "'XMLDir' not found in itemProperties when " + "building full heavy data path"); + } + std::stringstream newHeavyDataPath; + newHeavyDataPath << xmlDir->second << filePath; + return newHeavyDataPath.str(); + } + return filePath; +} + +shared_ptr +XdmfCoreItemFactory::getArrayType(const std::map & itemProperties) const +{ + return XdmfArrayType::New(itemProperties); +} XdmfCoreItemFactory::XdmfCoreItemFactory() { @@ -226,3 +258,499 @@ XdmfCoreItemFactory::createItem(const std::string & itemTag, } return shared_ptr(); } + +std::vector > +XdmfCoreItemFactory::generateHeavyDataControllers(const std::map & itemProperties, + const std::vector & passedDimensions, + shared_ptr passedArrayType, + const std::string & passedFormat) const +{ + std::vector > returnControllers; + + std::string formatVal; + + if (passedFormat.size() > 0) + { + formatVal = passedFormat; + } + else + { + // create a version that passes these in directly + std::map::const_iterator format = + itemProperties.find("Format"); + if(format == itemProperties.end()) { + XdmfError::message(XdmfError::FATAL, + "'Format' not found in generateHeavyControllers in " + "XdmfCoreItemFactory"); + } + formatVal = format->second; + } + + + std::map::const_iterator content = + itemProperties.find("Content"); + if(content == itemProperties.end()) { + XdmfError::message(XdmfError::FATAL, + "'Content' not found in generateHeavyControllers in " + "XdmfCoreItemFactory"); + } + + unsigned int contentIndex; + + const std::string & contentVal = content->second; + + std::vector contentVals; + + // Split the content based on "|" characters + size_t barSplit = 0; + std::string splitString(contentVal); + std::string subcontent; + while (barSplit != std::string::npos) { + barSplit = 0; + barSplit = splitString.find_first_of("|", barSplit); + if (barSplit == std::string::npos) { + subcontent = splitString; + } + else { + subcontent = splitString.substr(0, barSplit); + splitString = splitString.substr(barSplit+1); + barSplit++; + } + contentVals.push_back(subcontent); + } + + std::vector dimVector; + + if (passedDimensions.size() > 0) + { + dimVector = passedDimensions; + } + else + { + std::map::const_iterator dimensions = + itemProperties.find("Dimensions"); + if(dimensions == itemProperties.end()) { + XdmfError::message(XdmfError::FATAL, + "'Dimensions' not found in generateHeavyControllers in " + "XdmfCoreItemFactory"); + } + + boost::tokenizer<> tokens(dimensions->second); + for(boost::tokenizer<>::const_iterator iter = tokens.begin(); + iter != tokens.end(); + ++iter) { + dimVector.push_back(atoi((*iter).c_str())); + } + } + + shared_ptr arrayType; + if (passedArrayType) + { + arrayType = passedArrayType; + } + else + { + arrayType = XdmfArrayType::New(itemProperties); + } + + if (contentVals.size() == 0) { + return returnControllers; + } + + if(formatVal.compare("Binary") == 0) { + contentIndex = 0; + int contentStep = 2; + while (contentIndex < contentVals.size()) { + XdmfBinaryController::Endian endian = XdmfBinaryController::NATIVE; + std::map::const_iterator endianIter = + itemProperties.find("Endian"); + if(endianIter != itemProperties.end()) { + if(endianIter->second.compare("Big") == 0) { + endian = XdmfBinaryController::BIG; + } + else if(endianIter->second.compare("Little") == 0) { + endian = XdmfBinaryController::LITTLE; + } + else if(endianIter->second.compare("Native") == 0) { + endian = XdmfBinaryController::NATIVE; + } + else { + XdmfError(XdmfError::FATAL, + "Invalid endianness type: " + endianIter->second); + } + } + + unsigned int seek = 0; + std::map::const_iterator seekIter = + itemProperties.find("Seek"); + if(seekIter != itemProperties.end()) { + seek = std::atoi(seekIter->second.c_str()); + } + + const std::string binaryPath = getFullHeavyDataPath(contentVals[contentIndex], + itemProperties); + + // Parse dimensions from the content + std::vector contentStarts; + std::vector contentStrides; + std::vector contentDims; + std::vector contentDataspaces; + if (contentVals.size() > contentIndex+1) { + // This is the string that contains the dimensions + std::string dataspaceDescription = contentVals[contentIndex+1]; + std::vector dataspaceVector; + size_t colonSplit = 0; + while (colonSplit != std::string::npos) { + colonSplit = 0; + colonSplit = dataspaceDescription.find_first_of(":", colonSplit); + if (colonSplit == std::string::npos) { + subcontent = dataspaceDescription; + } + else { + subcontent = dataspaceDescription.substr(0, colonSplit); + dataspaceDescription = dataspaceDescription.substr(colonSplit+1); + colonSplit++; + } + dataspaceVector.push_back(subcontent); + } + + // split the description based on tokens + boost::tokenizer<> dimtokens(std::string("")); + if (dataspaceVector.size() == 1) { + dimtokens = boost::tokenizer<>(dataspaceDescription); + } + else if (dataspaceVector.size() == 5) { + dimtokens = boost::tokenizer<>(dataspaceVector[3]); + } + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentDims.push_back(atoi((*iter).c_str())); + } + + if (dataspaceVector.size() == 5) { + seek = atoi(dataspaceVector[0].c_str()); + dimtokens = boost::tokenizer<>(dataspaceVector[1]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentStarts.push_back(atoi((*iter).c_str())); + } + dimtokens = boost::tokenizer<>(dataspaceVector[2]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentStrides.push_back(atoi((*iter).c_str())); + } + dimtokens = boost::tokenizer<>(dataspaceVector[4]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentDataspaces.push_back(atoi((*iter).c_str())); + } + } + + contentStep = 2; + // If this works then the dimension content should be skipped over + } + else { + // If it fails then it means that the next content is not a dimension string + // In this case it is assumed that the controller will have + // dimensions equal to the array + for (unsigned int j = 0; j < dimVector.size(); ++j) { + contentDims.push_back(dimVector[j]); + } + contentStep = 1; + } + if (contentDataspaces.size() == 0) { + returnControllers.push_back(XdmfBinaryController::New(binaryPath, + arrayType, + endian, + seek, + contentDims)); + } + else { + returnControllers.push_back( + XdmfBinaryController::New(binaryPath, + arrayType, + endian, + seek, + contentStarts, + contentStrides, + contentDims, + contentDataspaces) + ); + } + contentIndex+=contentStep; + } + } + else if(formatVal.compare("HDF") == 0) { + contentIndex = 0; + int contentStep = 2; + while (contentIndex < contentVals.size()) { + size_t colonLocation = contentVals[contentIndex].find(":"); + if(colonLocation == std::string::npos) { + XdmfError::message(XdmfError::FATAL, + "':' not found in content generateHeavyControllers in " + "XdmfCoreItemFactory -- double check an HDF5 " + "data set is specified for the file"); + } + + std::string hdf5Path = + contentVals[contentIndex].substr(0, colonLocation); + std::string dataSetPath = + contentVals[contentIndex].substr(colonLocation+1); + + hdf5Path = getFullHeavyDataPath(hdf5Path, + itemProperties); + + // Parse dimensions from the content + std::vector contentStarts; + std::vector contentStrides; + std::vector contentDims; + std::vector contentDataspaces; + if (contentVals.size() > contentIndex+1) { + // This is the string that contains the dimensions + std::string dataspaceDescription = contentVals[contentIndex+1]; + std::vector dataspaceVector; + size_t colonSplit = 0; + while (colonSplit != std::string::npos) { + colonSplit = 0; + colonSplit = dataspaceDescription.find_first_of(":", colonSplit); + if (colonSplit == std::string::npos) { + subcontent = dataspaceDescription; + } + else { + subcontent = dataspaceDescription.substr(0, colonSplit); + dataspaceDescription = dataspaceDescription.substr(colonSplit+1); + colonSplit++; + } + dataspaceVector.push_back(subcontent); + } + + // split the description based on tokens + boost::tokenizer<> dimtokens(std::string("")); + if (dataspaceVector.size() == 1) { + dimtokens = boost::tokenizer<>(dataspaceDescription); + } + else if (dataspaceVector.size() == 4) { + dimtokens = boost::tokenizer<>(dataspaceVector[2]); + } + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentDims.push_back(atoi((*iter).c_str())); + } + + if (dataspaceVector.size() == 4) { + dimtokens = boost::tokenizer<>(dataspaceVector[0]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentStarts.push_back(atoi((*iter).c_str())); + } + dimtokens = boost::tokenizer<>(dataspaceVector[1]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentStrides.push_back(atoi((*iter).c_str())); + } + dimtokens = boost::tokenizer<>(dataspaceVector[3]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentDataspaces.push_back(atoi((*iter).c_str())); + } + } + + contentStep = 2; + // If this works then the dimension content should be skipped over + } + else { + // If it fails then it means that the next content is not a dimension string + // In this case it is assumed that the controller will have + // dimensions equal to the array + for (unsigned int j = 0; j < dimVector.size(); ++j) { + contentDims.push_back(dimVector[j]); + } + contentStep = 1; + } + if (contentDataspaces.size() == 0) { + returnControllers.push_back( + XdmfHDF5Controller::New(hdf5Path, + dataSetPath, + arrayType, + std::vector(contentDims.size(), + 0), + std::vector(contentDims.size(), + 1), + contentDims, + contentDims) + ); + } + else { + returnControllers.push_back( + XdmfHDF5Controller::New(hdf5Path, + dataSetPath, + arrayType, + contentStarts, + contentStrides, + contentDims, + contentDataspaces) + ); + } + contentIndex+=contentStep; + } + } +#ifdef XDMF_BUILD_TIFF + else if(formatVal.compare("TIFF") == 0) { + contentIndex = 0; + int contentStep = 2; + while (contentIndex < contentVals.size()) { + const std::string tiffPath = getFullHeavyDataPath(contentVals[contentIndex], + itemProperties); + + // Parse dimensions from the content + std::vector contentStarts; + std::vector contentStrides; + std::vector contentDims; + std::vector contentDataspaces; + if (contentVals.size() > contentIndex+1) { + // This is the string that contains the dimensions + std::string dataspaceDescription = contentVals[contentIndex+1]; + std::vector dataspaceVector; + size_t colonSplit = 0; + while (colonSplit != std::string::npos) { + colonSplit = 0; + colonSplit = dataspaceDescription.find_first_of(":", colonSplit); + if (colonSplit == std::string::npos) { + subcontent = dataspaceDescription; + } + else { + subcontent = dataspaceDescription.substr(0, colonSplit); + dataspaceDescription = dataspaceDescription.substr(colonSplit+1); + colonSplit++; + } + dataspaceVector.push_back(subcontent); + } + + // split the description based on tokens + boost::tokenizer<> dimtokens(std::string("")); + if (dataspaceVector.size() == 1) { + dimtokens = boost::tokenizer<>(dataspaceDescription); + } + else if (dataspaceVector.size() == 4) { + dimtokens = boost::tokenizer<>(dataspaceVector[2]); + } + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentDims.push_back(atoi((*iter).c_str())); + } + + if (dataspaceVector.size() == 4) { + dimtokens = boost::tokenizer<>(dataspaceVector[0]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentStarts.push_back(atoi((*iter).c_str())); + } + dimtokens = boost::tokenizer<>(dataspaceVector[1]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentStrides.push_back(atoi((*iter).c_str())); + } + dimtokens = boost::tokenizer<>(dataspaceVector[3]); + for(boost::tokenizer<>::const_iterator iter = dimtokens.begin(); + iter != dimtokens.end(); + ++iter) { + contentDataspaces.push_back(atoi((*iter).c_str())); + } + } + + contentStep = 2; + // If this works then the dimension content should be skipped over + } + else { + // If it fails then it means that the next content is not a dimension string + // In this case it is assumed that the controller will have + // dimensions equal to the array + for (unsigned int j = 0; j < dimVector.size(); ++j) { + contentDims.push_back(dimVector[j]); + } + contentStep = 1; + } + if (contentDataspaces.size() == 0) { + returnControllers.push_back( + XdmfTIFFController::New(tiffPath, + arrayType, + std::vector(contentDims.size(), + 0), + std::vector(contentDims.size(), + 1), + contentDims, + contentDims) + ); + } + else { + returnControllers.push_back( + XdmfTIFFController::New(tiffPath, + arrayType, + contentStarts, + contentStrides, + contentDims, + contentDataspaces) + ); + } + contentIndex+=contentStep; + } + } +#endif /* XDMF_BUILD_TIFF */ + + return returnControllers; +} + +shared_ptr +XdmfCoreItemFactory::generateHeavyDataWriter(std::string typeName, std::string path) const +{ + if (typeName.compare("HDF") == 0) { + return XdmfHDF5Writer::New(path); + } + return shared_ptr(); +} + +bool +XdmfCoreItemFactory::isArrayTag(char * tag) const +{ + if (XdmfArray::ItemTag.compare(tag) == 0 || + strcmp("DataStructure", tag) == 0 || + XdmfFunction::ItemTag.compare(tag) == 0 || + XdmfSubset::ItemTag.compare(tag) == 0) { + return true; + } + return false; +} + +XdmfItem * +XdmfCoreItemFactory::DuplicatePointer(shared_ptr original) const +{ + if (original->getItemTag() == XdmfArray::ItemTag) { + return (XdmfItem *)(new XdmfArray(*((XdmfArray *)original.get()))); + } + else if (original->getItemTag() == XdmfInformation::ItemTag) { + return (XdmfItem *)(new XdmfInformation(*((XdmfInformation *)original.get()))); + } + else if (original->getItemTag() == XdmfFunction::ItemTag) { + return (XdmfItem *)(new XdmfFunction(*((XdmfFunction *)original.get()))); + } + else if (original->getItemTag() == XdmfSubset::ItemTag) { + return (XdmfItem *)(new XdmfSubset(*((XdmfSubset *)original.get()))); + } + else if (original->getItemTag() == XdmfSparseMatrix::ItemTag) { + return (XdmfItem *)(new XdmfSparseMatrix(*((XdmfSparseMatrix *)original.get()))); + } + else { + return NULL; + } +} diff --git a/core/XdmfCoreItemFactory.hpp b/core/XdmfCoreItemFactory.hpp index d68761d5..f8096cf8 100644 --- a/core/XdmfCoreItemFactory.hpp +++ b/core/XdmfCoreItemFactory.hpp @@ -24,14 +24,17 @@ #ifndef XDMFCOREITEMFACTORY_HPP_ #define XDMFCOREITEMFACTORY_HPP_ +#ifdef __cplusplus + // Forward Declarations class XdmfItem; // Includes #include #include -#include #include "XdmfCore.hpp" +#include "XdmfHeavyDataController.hpp" +#include "XdmfHeavyDataWriter.hpp" #include "XdmfSharedPtr.hpp" /** @@ -72,8 +75,35 @@ public: const std::map & itemProperties, const std::vector > & childItems) const; + virtual std::vector > + generateHeavyDataControllers(const std::map & itemProperties, + const std::vector & passedDimensions = std::vector(), + shared_ptr passedArrayType = shared_ptr(), + const std::string & passedFormat = std::string()) const; + + virtual shared_ptr + generateHeavyDataWriter(std::string typeName, std::string path) const; + + virtual bool isArrayTag(char * tag) const; + + /** + * Extracts the pointer from the provided shared pointer. Primarily used for C interface. + * + * @param original The source shared pointer that the pointer will be pulled from. + * @return A duplicate of the object contained in the pointer. + */ + virtual XdmfItem * + DuplicatePointer(shared_ptr original) const; + protected: + shared_ptr + getArrayType(const std::map & itemProperties) const; + + std::string + getFullHeavyDataPath(const std::string & filePath, + const std::map & itemProperties) const; + XdmfCoreItemFactory(); private: @@ -83,4 +113,6 @@ private: }; +#endif + #endif /* XDMFCOREITEMFACTORY_HPP_ */ diff --git a/core/XdmfCoreReader.cpp b/core/XdmfCoreReader.cpp index 26ae1843..a0344b43 100644 --- a/core/XdmfCoreReader.cpp +++ b/core/XdmfCoreReader.cpp @@ -32,7 +32,6 @@ #include #include "XdmfArray.hpp" #include "XdmfArrayType.hpp" -#include "XdmfHDF5Controller.hpp" #include "XdmfCoreItemFactory.hpp" #include "XdmfCoreReader.hpp" #include "XdmfError.hpp" @@ -141,7 +140,6 @@ public: readSingleNode(const xmlNodePtr currNode, std::vector > & myItems) { - // Deal with proper resolution of XIncludes if(xmlStrcmp(currNode->name, (xmlChar*)"include") == 0) { @@ -214,44 +212,29 @@ public: xmlNodePtr childNode = currNode->children; // generate content if an array or arrayReference - if (XdmfArray::ItemTag.compare((char *)currNode->name) == 0 || - strcmp("DataStructure", (char *)currNode->name) == 0 || - XdmfFunction::ItemTag.compare((char *)currNode->name) == 0 || - XdmfSubset::ItemTag.compare((char *)currNode->name) == 0) { + if (mItemFactory->isArrayTag((char *)currNode->name)) { while(childNode != NULL) { if(childNode->type == XML_TEXT_NODE && childNode->content) { -///* - const char * content = (char*)childNode->content; - - // Determine if content is whitespace - bool whitespace = true; - - const char * contentPtr = content; - // Step through to end of pointer - while(contentPtr != NULL) { - // If not a whitespace character, break - if(!isspace(*contentPtr++)) { - whitespace = false; - break; + const char * content = (char*)childNode->content; + + // Determine if content is whitespace + bool whitespace = true; + + const char * contentPtr = content; + // Step through to end of pointer + while(contentPtr != NULL) { + // If not a whitespace character, break + if(!isspace(*contentPtr++)) { + whitespace = false; + break; + } } - } - if(!whitespace) { - itemProperties.insert(std::make_pair("Content", content)); - itemProperties.insert(std::make_pair("XMLDir", mXMLDir)); - break; - } -//*/ -/* - std::string content((char *)childNode->content); - boost::algorithm::trim(content); - - if(content.size() != 0) { + if(!whitespace) { itemProperties.insert(std::make_pair("Content", content)); itemProperties.insert(std::make_pair("XMLDir", mXMLDir)); break; } -*/ } childNode = childNode->next; } @@ -324,6 +307,33 @@ XdmfCoreReader::~XdmfCoreReader() delete mImpl; } +XdmfItem * +XdmfCoreReader::DuplicatePointer(shared_ptr original) const +{ + if (mImpl == NULL) { + XdmfError::message(XdmfError::FATAL, "Error: Reader Internal Object is NULL"); + } + return mImpl->mItemFactory->DuplicatePointer(original); +} + +std::vector > +XdmfCoreReader::generateHeavyDataControllers(std::map controllerProperties, + const std::vector & passedDimensions, + shared_ptr passedArrayType, + const std::string & passedFormat) const +{ + return mImpl->mItemFactory->generateHeavyDataControllers(controllerProperties, + passedDimensions, + passedArrayType, + passedFormat); +} + +shared_ptr +XdmfCoreReader::generateHeavyDataWriter(std::string typeName, std::string path) const +{ + return mImpl->mItemFactory->generateHeavyDataWriter(typeName, path); +} + shared_ptr XdmfCoreReader::parse(const std::string & lightData) const { @@ -381,3 +391,14 @@ XdmfCoreReader::readPathObjects(const std::string & xPath) const return toReturn; } +// C Wrappers + +XDMFITEM * +XdmfCoreReaderRead(XDMFCOREREADER * reader, char * filePath, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr returnItem = ((XdmfCoreReader *)reader)->read(filePath); + return (XDMFITEM *)((void *)((XdmfItem *)((XdmfCoreReader *)reader)->DuplicatePointer(returnItem))); + XDMF_ERROR_WRAP_END(status) + return NULL; +} diff --git a/core/XdmfCoreReader.hpp b/core/XdmfCoreReader.hpp index b407d22c..e45c3646 100644 --- a/core/XdmfCoreReader.hpp +++ b/core/XdmfCoreReader.hpp @@ -24,14 +24,20 @@ #ifndef XDMFCOREREADER_HPP_ #define XDMFCOREREADER_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfHeavyDataController.hpp" +#include "XdmfHeavyDataWriter.hpp" +#include "XdmfItem.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfCoreItemFactory; -class XdmfItem; // Includes #include #include -#include "XdmfCore.hpp" #include "XdmfSharedPtr.hpp" /** @@ -50,6 +56,24 @@ public: virtual ~XdmfCoreReader() = 0; + /** + * Uses the internal item factory to create a copy of the internal pointer + * of the provided shared pointer. Primarily used for C wrapping. + * + * @param original The source shared pointer that the pointer will be pulled from. + * @return A duplicate of the object contained in the pointer. + */ + virtual XdmfItem * DuplicatePointer(shared_ptr original) const; + + virtual std::vector > + generateHeavyDataControllers(std::map controllerProperties, + const std::vector & passedDimensions = std::vector(), + shared_ptr passedArrayType = shared_ptr(), + const std::string & passedFormat = std::string()) const; + + virtual shared_ptr + generateHeavyDataWriter(std::string typeName, std::string path) const; + /** * Parse a string containing light data into an Xdmf structure in * memory. @@ -222,4 +246,32 @@ std::vector, std::allocator > >; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFCOREREADER; // Simply as a typedef to ensure correct typing +typedef struct XDMFCOREREADER XDMFCOREREADER; + +XDMFCORE_EXPORT XDMFITEM * XdmfCoreReaderRead(XDMFCOREREADER * reader, char * filePath, int * status); + +#define XDMF_CORE_READER_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT XDMFITEM * ClassName##Read( CClassName * reader, char * filePath, int * status); + +#define XDMF_CORE_READER_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +XDMFITEM * ClassName##Read( CClassName * reader, char * filePath, int * status) \ +{ \ + return XdmfCoreReaderRead((XDMFCOREREADER *)((void *)reader), filePath, status); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFCOREREADER_HPP_ */ diff --git a/core/XdmfError.cpp b/core/XdmfError.cpp index 8f828658..72a37f2b 100644 --- a/core/XdmfError.cpp +++ b/core/XdmfError.cpp @@ -38,6 +38,12 @@ XdmfError::what() const throw() *** Public Static Functions *** *******************************/ +bool +XdmfError::getCErrorsAreFatal() +{ + return XdmfError::mCErrorsAreFatal; +} + XdmfError::Level XdmfError::getLevelLimit() { @@ -50,6 +56,12 @@ XdmfError::getSuppressionLevel() return XdmfError::mSuppressLevel; } +void +XdmfError::setCErrorsAreFatal(bool status) +{ + XdmfError::mCErrorsAreFatal = status; +} + void XdmfError::setLevelLimit(Level l) { @@ -103,3 +115,93 @@ XdmfError::WriteToStream(std::string msg) XdmfError::Level XdmfError::mLevelLimit = XdmfError::FATAL; XdmfError::Level XdmfError::mSuppressLevel = XdmfError::WARNING; std::streambuf* XdmfError::mBuf=std::cout.rdbuf(); +bool XdmfError::mCErrorsAreFatal = false; + +// C Wrappers + +void XdmfErrorSetCErrorsAreFatal(int status) +{ + XdmfError::setCErrorsAreFatal(status); +} + +void XdmfErrorSetLevelLimit(int level, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (level) { + case XDMF_ERROR_FATAL: + XdmfError::setLevelLimit(XdmfError::FATAL); + break; + case XDMF_ERROR_WARNING: + XdmfError::setLevelLimit(XdmfError::WARNING); + break; + case XDMF_ERROR_DEBUG: + XdmfError::setLevelLimit(XdmfError::DEBUG); + break; + default: + try { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Error Level"); + } + catch (XdmfError & e) { + throw e; + } + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfErrorSetSuppressionLevel(int level, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (level) { + case XDMF_ERROR_FATAL: + XdmfError::setSuppressionLevel(XdmfError::FATAL); + break; + case XDMF_ERROR_WARNING: + XdmfError::setSuppressionLevel(XdmfError::WARNING); + break; + case XDMF_ERROR_DEBUG: + XdmfError::setSuppressionLevel(XdmfError::DEBUG); + break; + default: + XdmfError::message(XdmfError::FATAL, "Error: Invalid Error Level"); + } + XDMF_ERROR_WRAP_END(status) +} + +int XdmfErrorGetCErrorsAreFatal() +{ + return XdmfError::getCErrorsAreFatal(); +} + +int XdmfErrorGetLevelLimit() +{ + if (XdmfError::getLevelLimit() == XdmfError::FATAL) { + return XDMF_ERROR_FATAL; + } + else if (XdmfError::getLevelLimit() == XdmfError::WARNING) { + return XDMF_ERROR_WARNING; + } + else if (XdmfError::getLevelLimit() == XdmfError::DEBUG) { + return XDMF_ERROR_DEBUG; + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Error Level"); + } + return -1; +} + +int XdmfErrorGetSuppressionLevel() +{ + if (XdmfError::getSuppressionLevel() == XdmfError::FATAL) { + return XDMF_ERROR_FATAL; + } + else if (XdmfError::getSuppressionLevel() == XdmfError::WARNING) { + return XDMF_ERROR_WARNING; + } + else if (XdmfError::getSuppressionLevel() == XdmfError::DEBUG) { + return XDMF_ERROR_DEBUG; + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Invalid Error Level"); + } + return -1; +} diff --git a/core/XdmfError.hpp b/core/XdmfError.hpp index fecc025a..6f900c7a 100644 --- a/core/XdmfError.hpp +++ b/core/XdmfError.hpp @@ -1,12 +1,16 @@ #ifndef XDMFERROR_HPP_ #define XDMFERROR_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" + +#ifdef __cplusplus + +// Includes #include #include #include -#include "XdmfCore.hpp" - class XDMFCORE_EXPORT XdmfError : public std::exception { public: @@ -82,6 +86,16 @@ public: */ Level getLevel() const; + /** + * Gets whether C errors are Fatal. If set to false a status will be returned + * to C when an error is thrown. Otherwise there will be no handling and the + * program will exit since C cannot handle exceptions. + * + * @param status Whether the C wrappers are to pass an integer value to + * C on failure instead of exiting. + */ + static void setCErrorsAreFatal(bool status); + /** * Sets the level limit for Errors. This determines what level of errors will be thrown with message. * @@ -126,6 +140,16 @@ public: */ static void setSuppressionLevel(Level l); + /** + * Gets whether C errors are Fatal. If set to false a status will be returned + * to C when an error is thrown. Otherwise there will be no handling and the + * program will exit since C cannot handle exceptions. + * + * @return Whether the C wrappers with pass an integer value to C + * instead of stopping the program + */ + static bool getCErrorsAreFatal(); + /** * Gets the level limit for Errors. * @@ -240,9 +264,63 @@ private: static Level mLevelLimit; static Level mSuppressLevel; static std::streambuf* mBuf; + static bool mCErrorsAreFatal; std::string mMessage; static void WriteToStream(std::string msg); }; #endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#define XDMF_SUCCESS 1 +#define XDMF_FAIL -1 + +#define XDMF_ERROR_FATAL 40 +#define XDMF_ERROR_WARNING 41 +#define XDMF_ERROR_DEBUG 42 + +XDMFCORE_EXPORT void XdmfErrorSetCErrorsAreFatal(int status); + +XDMFCORE_EXPORT void XdmfErrorSetLevelLimit(int level, int * status); + +XDMFCORE_EXPORT void XdmfErrorSetSuppressionLevel(int level, int * status); + +XDMFCORE_EXPORT int XdmfErrorGetCErrorsAreFatal(); + +XDMFCORE_EXPORT int XdmfErrorGetLevelLimit(); + +XDMFCORE_EXPORT int XdmfErrorGetSuppressionLevel(); + +#ifdef __cplusplus + +//Use these macros to catch Exceptions for C code + +#define XDMF_ERROR_WRAP_START(status) \ +if (status) { \ + *status = XDMF_SUCCESS; \ +} \ +try { + +#define XDMF_ERROR_WRAP_END(status) \ +} \ +catch (XdmfError & e) { \ + if (XdmfError::getCErrorsAreFatal()) { \ + throw e; \ + } \ + else { \ + if (status) { \ + *status = XDMF_FAIL; \ + } \ + } \ +} + +} +#endif + +#endif diff --git a/core/XdmfFunction.cpp b/core/XdmfFunction.cpp index 261edca1..a9429b45 100644 --- a/core/XdmfFunction.cpp +++ b/core/XdmfFunction.cpp @@ -25,6 +25,7 @@ #include "XdmfArray.hpp" #include "XdmfArrayType.hpp" #include "XdmfFunction.hpp" +#include "XdmfWriter.hpp" #include #include #include @@ -176,6 +177,16 @@ XdmfFunction::XdmfFunction(std::string newExpression, { } +XdmfFunction::XdmfFunction(XdmfFunction & refFunction) : + XdmfArrayReference(refFunction), + mExpression(refFunction.getExpression()) +{ + std::vector copyVariables = refFunction.getVariableList(); + for (unsigned int i = 0; i < copyVariables.size(); ++i) { + mVariableList[copyVariables[i]] = refFunction.getVariable(copyVariables[i]); + } +} + XdmfFunction::~XdmfFunction() { } @@ -399,9 +410,18 @@ XdmfFunction::average(std::vector > values) { double total = sum(values)->getValue(0);; int totalSize = 0; + bool release = false; for (unsigned int i = 0; i < values.size(); ++i) { + release = false; + if (!values[i]->isInitialized()) { + values[i]->read(); + release = true; + } totalSize += values[i]->getSize(); + if (release) { + values[i]->release(); + } } shared_ptr returnArray = XdmfArray::New(); returnArray->insert(0, total/totalSize); @@ -863,16 +883,9 @@ XdmfFunction::getItemTag() const std::map XdmfFunction::getItemProperties() const { - std::map functionProperties; + std::map functionProperties = XdmfArrayReference::getItemProperties(); functionProperties["Expression"] = mExpression; - functionProperties["ConstructedType"] = mConstructedType; - - for (std::map::const_iterator constructedIt = mConstructedProperties.begin(); - constructedIt != mConstructedProperties.end(); - ++constructedIt) { - functionProperties[constructedIt->first] = constructedIt->second; - } std::stringstream variableStream; @@ -1091,6 +1104,7 @@ void XdmfFunction::insertVariable(std::string key, shared_ptr value) { mVariableList[key] = value; + this->setIsChanged(true); } shared_ptr @@ -1217,12 +1231,14 @@ XdmfFunction::removeVariable(std::string key) if (removeWalker != mVariableList.end()) { mVariableList.erase(removeWalker); } + this->setIsChanged(true); } void XdmfFunction::setExpression(std::string newExpression) { mExpression = newExpression; + this->setIsChanged(true); } shared_ptr @@ -1360,13 +1376,452 @@ XdmfFunction::traverse(const shared_ptr visitor) { XdmfItem::traverse(visitor); + bool originalXPath; + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + originalXPath = writer->getWriteXPaths(); + writer->setWriteXPaths(false); + } + shared_ptr spacerarray = XdmfArray::New(); spacerarray->pushBack((int)0); spacerarray->accept(visitor); + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + writer->setWriteXPaths(originalXPath); + } + for (std::map >::iterator it = mVariableList.begin(); it != mVariableList.end(); ++it) { it->second->accept(visitor); } } + +// C Wrappers + +class XdmfCFunctionInternalImpl : public XdmfFunction::XdmfFunctionInternal { + public: + static shared_ptr + New(XDMFARRAY * (*newInternal)(XDMFARRAY **, unsigned int)) + { + shared_ptr p (new XdmfCFunctionInternalImpl(newInternal)); + return p; + } + + ~XdmfCFunctionInternalImpl() + { + } + + virtual shared_ptr execute(std::vector > valueVector) + { + XDMFARRAY ** valueArray = new XDMFARRAY *[valueVector.size()](); + for (unsigned int i = 0; i < valueVector.size(); ++i) { + valueArray[i] = (XDMFARRAY *)((void *)(valueVector[i].get())); + } + return shared_ptr((XdmfArray *)((*mInternalFunction)(valueArray, valueVector.size()))); + } + private: + XdmfCFunctionInternalImpl(XDMFARRAY * (*newInternal)(XDMFARRAY **, unsigned int)) + { + mInternalFunction = newInternal; + } + + XDMFARRAY * (*mInternalFunction)(XDMFARRAY **, unsigned int); +}; + +class XdmfCOperationInternalImpl : public XdmfFunction::XdmfOperationInternal { + public: + static shared_ptr + New(XDMFARRAY * (*newInternal)(XDMFARRAY *, XDMFARRAY *)) + { + shared_ptr p (new XdmfCOperationInternalImpl(newInternal)); + return p; + } + + ~XdmfCOperationInternalImpl() + { + } + + virtual shared_ptr execute(shared_ptr val1, + shared_ptr val2) + { + return shared_ptr((XdmfArray *)((*mInternalOperation)((XDMFARRAY *)((void *)(val1.get())), (XDMFARRAY *)((void *)(val2.get()))))); + } + private: + XdmfCOperationInternalImpl(XDMFARRAY * (*newInternal)(XDMFARRAY *, XDMFARRAY *)) + { + mInternalOperation = newInternal; + } + + XDMFARRAY * (*mInternalOperation)(XDMFARRAY *, XDMFARRAY *); +}; + +XDMFFUNCTION * XdmfFunctionNew() +{ + try + { + shared_ptr generatedFunction = XdmfFunction::New(); + return (XDMFFUNCTION *)((void *)(new XdmfFunction(*generatedFunction.get()))); + } + catch (...) + { + shared_ptr generatedFunction = XdmfFunction::New(); + return (XDMFFUNCTION *)((void *)(new XdmfFunction(*generatedFunction.get()))); + } +} + +XDMFFUNCTION * XdmfFunctionNewInit(char * newExpression, char ** keys, XDMFARRAY ** values, int numVariables) +{ + try + { + std::map > variableMap; + for (int i = 0; i < numVariables; ++i) { + variableMap[keys[i]] = shared_ptr((XdmfArray *)(values[i]), XdmfNullDeleter()); + } + shared_ptr generatedFunction = XdmfFunction::New(std::string(newExpression), variableMap); + return (XDMFFUNCTION *)((void *)(new XdmfFunction(*generatedFunction.get()))); + } + catch (...) + { + std::map > variableMap; + for (int i = 0; i < numVariables; ++i) { + variableMap[keys[i]] = shared_ptr((XdmfArray *)(values[i]), XdmfNullDeleter()); + } + shared_ptr generatedFunction = XdmfFunction::New(std::string(newExpression), variableMap); + return (XDMFFUNCTION *)((void *)(new XdmfFunction(*generatedFunction.get()))); + } +} + +int XdmfFunctionAddFunction(char * name, XDMFARRAY *(*functionref)(XDMFARRAY **, unsigned int), int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + shared_ptr newFunction = + XdmfCFunctionInternalImpl::New(functionref); + return XdmfFunction::addFunction(name, newFunction); + } + catch (...) + { + shared_ptr newFunction = + XdmfCFunctionInternalImpl::New(functionref); + return XdmfFunction::addFunction(name, newFunction); + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +int XdmfFunctionAddOperation(char newoperator, XDMFARRAY *(*operationref)(XDMFARRAY *, XDMFARRAY *), int priority, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + shared_ptr newOperation = + XdmfCOperationInternalImpl::New(operationref); + return XdmfFunction::addOperation(newoperator, + newOperation, + priority); + } + catch (...) + { + shared_ptr newOperation = + XdmfCOperationInternalImpl::New(operationref); + return XdmfFunction::addOperation(newoperator, + newOperation, + priority); + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +XDMFARRAY * XdmfFunctionAverage(XDMFARRAY ** values, int numValues) +{ + try + { + std::vector > valueVector; + for (int i = 0; i < numValues; ++i) { + valueVector.push_back(shared_ptr((XdmfArray *)values[i], XdmfNullDeleter())); + } + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::average(valueVector).get())))); + } + catch (...) + { + std::vector > valueVector; + for (int i = 0; i < numValues; ++i) { + valueVector.push_back(shared_ptr((XdmfArray *)values[i], XdmfNullDeleter())); + } + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::average(valueVector).get())))); + } +} + +XDMFARRAY * XdmfFunctionChunk(XDMFARRAY * val1, XDMFARRAY * val2, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::chunk(shared_ptr((XdmfArray *)val1, XdmfNullDeleter()), shared_ptr((XdmfArray *)val2, XdmfNullDeleter())).get())))); + } + catch (...) + { + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::chunk(shared_ptr((XdmfArray *)val1, XdmfNullDeleter()), shared_ptr((XdmfArray *)val2, XdmfNullDeleter())).get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfFunctionEvaluateExpression(char * expression, char ** keys, XDMFARRAY ** values, int numVariables, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::map > variableMap; + for (int i = 0; i < numVariables; ++i) { + variableMap[keys[i]] = shared_ptr((XdmfArray *)(values[i]), XdmfNullDeleter()); + } + shared_ptr generatedArray = XdmfFunction::evaluateExpression(std::string(expression), variableMap); + return (XDMFARRAY *)((void *)(new XdmfArray(*(generatedArray.get())))); + } + catch (...) + { + std::map > variableMap; + for (int i = 0; i < numVariables; ++i) { + variableMap[keys[i]] = shared_ptr((XdmfArray *)(values[i]), XdmfNullDeleter()); + } + shared_ptr generatedArray = XdmfFunction::evaluateExpression(std::string(expression), variableMap); + return (XDMFARRAY *)((void *)(new XdmfArray(*(generatedArray.get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfFunctionEvaluateOperation(XDMFARRAY * val1, XDMFARRAY * val2, char operation, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + shared_ptr generatedArray = XdmfFunction::evaluateOperation(shared_ptr((XdmfArray *)(val1), XdmfNullDeleter()), shared_ptr((XdmfArray *)(val2), XdmfNullDeleter()), operation); + return (XDMFARRAY *)((void *)(new XdmfArray(*(generatedArray.get())))); + } + catch (...) + { + shared_ptr generatedArray = XdmfFunction::evaluateOperation(shared_ptr((XdmfArray *)(val1), XdmfNullDeleter()), shared_ptr((XdmfArray *)(val2), XdmfNullDeleter()), operation); + return (XDMFARRAY *)((void *)(new XdmfArray(*(generatedArray.get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfFunctionEvaluateFunction(XDMFARRAY ** valueVector, int numValues, char * functionName, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector > evaluatedVector; + for (int i = 0; i < numValues; ++i) { + evaluatedVector.push_back(shared_ptr((XdmfArray *)valueVector[i], XdmfNullDeleter())); + } + shared_ptr generatedArray = XdmfFunction::evaluateFunction(evaluatedVector, std::string(functionName)); + return (XDMFARRAY *)((void *)(new XdmfArray(*(generatedArray.get())))); + } + catch (...) + { + std::vector > evaluatedVector; + for (int i = 0; i < numValues; ++i) { + evaluatedVector.push_back(shared_ptr((XdmfArray *)valueVector[i], XdmfNullDeleter())); + } + shared_ptr generatedArray = XdmfFunction::evaluateFunction(evaluatedVector, std::string(functionName)); + return (XDMFARRAY *)((void *)(new XdmfArray(*(generatedArray.get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +char * XdmfFunctionGetExpression(XDMFFUNCTION * function) +{ + try + { + char * returnPointer = strdup(((XdmfFunction *)(function))->getExpression().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfFunction *)(function))->getExpression().c_str()); + return returnPointer; + } +} + +unsigned int XdmfFunctionGetNumberVariables(XDMFFUNCTION * function) +{ + return ((XdmfFunction *)(function))->getVariableList().size(); +} + +int XdmfFunctionGetOperationPriority(char operation) +{ + return XdmfFunction::getOperationPriority(operation); +} + +char * XdmfFunctionGetSupportedOperations() +{ + try + { + return strdup(XdmfFunction::getSupportedOperations().c_str()); + } + catch (...) + { + return strdup(XdmfFunction::getSupportedOperations().c_str()); + } +} + +char ** XdmfFunctionGetSupportedFunctions() +{ + try + { + std::vector supportedFunctions = XdmfFunction::getSupportedFunctions(); + char ** returnPointer = new char *[supportedFunctions.size()](); + for (unsigned int i = 0; i < supportedFunctions.size(); ++i) { + returnPointer[i] = strdup(supportedFunctions[i].c_str()); + } + return returnPointer; + } + catch (...) + { + std::vector supportedFunctions = XdmfFunction::getSupportedFunctions(); + char ** returnPointer = new char *[supportedFunctions.size()](); + for (unsigned int i = 0; i < supportedFunctions.size(); ++i) { + returnPointer[i] = strdup(supportedFunctions[i].c_str()); + } + return returnPointer; + } +} + +unsigned int XdmfFunctionGetNumberSupportedFunctions() +{ + return XdmfFunction::getSupportedFunctions().size(); +} + +char * XdmfFunctionGetValidDigitChars() +{ + try + { + return strdup(XdmfFunction::getValidDigitChars().c_str()); + } + catch (...) + { + return strdup(XdmfFunction::getValidDigitChars().c_str()); + } +} + +char * XdmfFunctionGetValidVariableChars() +{ + try + { + return strdup(XdmfFunction::getValidVariableChars().c_str()); + } + catch (...) + { + return strdup(XdmfFunction::getValidVariableChars().c_str()); + } +} + +XDMFARRAY * XdmfFunctionGetVariable(XDMFFUNCTION * function, char * key) +{ + try + { + shared_ptr returnArray = ((XdmfFunction *)function)->getVariable(std::string(key)); + return (XDMFARRAY *)((void *)(new XdmfArray(*returnArray.get()))); + } + catch (...) + { + shared_ptr returnArray = ((XdmfFunction *)function)->getVariable(std::string(key)); + return (XDMFARRAY *)((void *)(new XdmfArray(*returnArray.get()))); + } +} + +char ** XdmfFunctionGetVariableList(XDMFFUNCTION * function) +{ + try + { + std::vector variablelist = ((XdmfFunction *)(function))->getVariableList(); + char ** returnpointer = new char *[variablelist.size()](); + for (unsigned int i = 0; i < variablelist.size(); ++i) { + returnpointer[i] = strdup(variablelist[i].c_str()); + } + return returnpointer; + } + catch (...) + { + std::vector variablelist = ((XdmfFunction *)(function))->getVariableList(); + char ** returnpointer = new char *[variablelist.size()](); + for (unsigned int i = 0; i < variablelist.size(); ++i) { + returnpointer[i] = strdup(variablelist[i].c_str()); + } + return returnpointer; + } +} + +XDMFARRAY * XdmfFunctionInterlace(XDMFARRAY * val1, XDMFARRAY * val2, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::interlace(shared_ptr((XdmfArray *)val1, XdmfNullDeleter()), shared_ptr((XdmfArray *)val2, XdmfNullDeleter())).get())))); + } + catch (...) + { + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::interlace(shared_ptr((XdmfArray *)val1, XdmfNullDeleter()), shared_ptr((XdmfArray *)val2, XdmfNullDeleter())).get())))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +void XdmfFunctionInsertVariable(XDMFFUNCTION * function, char * key, XDMFARRAY * value, int passControl) +{ + shared_ptr insertedValue; + if (passControl == 0) { + insertedValue = shared_ptr((XdmfArray *)value, XdmfNullDeleter()); + } + else { + insertedValue = shared_ptr((XdmfArray *)value); + } + ((XdmfFunction *)function)->insertVariable(std::string(key), insertedValue); +} + +void XdmfFunctionRemoveVariable(XDMFFUNCTION * function, char * key) +{ + ((XdmfFunction *)(function))->removeVariable(std::string(key)); +} + +void XdmfFunctionSetExpression(XDMFFUNCTION * function, char * newExpression, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfFunction *)(function))->setExpression(std::string(newExpression)); + XDMF_ERROR_WRAP_END(status) +} + +XDMFARRAY * XdmfFunctionSum(XDMFARRAY ** values, int numValues) +{ + try + { + std::vector > valueVector; + for (int i = 0; i < numValues; ++i) { + valueVector.push_back(shared_ptr((XdmfArray *)values[i], XdmfNullDeleter())); + } + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::sum(valueVector).get())))); + } + catch (...) + { + std::vector > valueVector; + for (int i = 0; i < numValues; ++i) { + valueVector.push_back(shared_ptr((XdmfArray *)values[i], XdmfNullDeleter())); + } + return (XDMFARRAY *)((void *)(new XdmfArray(*(XdmfFunction::sum(valueVector).get())))); + } +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfFunction, XDMFFUNCTION) +XDMF_ARRAYREFERENCE_C_CHILD_WRAPPER(XdmfFunction, XDMFFUNCTION) diff --git a/core/XdmfFunction.hpp b/core/XdmfFunction.hpp index b3d7efec..e63d66db 100644 --- a/core/XdmfFunction.hpp +++ b/core/XdmfFunction.hpp @@ -24,11 +24,13 @@ #ifndef XDMFFUNCTION_HPP_ #define XDMFFUNCTION_HPP_ -// Includes +// C Compatible Includes #include "XdmfCore.hpp" #include "XdmfArray.hpp" #include "XdmfArrayReference.hpp" +#ifdef __cplusplus + class XdmfArray; /** @@ -1299,6 +1301,8 @@ public: void traverse(const shared_ptr visitor); + XdmfFunction(XdmfFunction &); + protected: XdmfFunction(); @@ -1325,4 +1329,70 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct XDMFFUNCTION; // Simply as a typedef to ensure correct typing +typedef struct XDMFFUNCTION XDMFFUNCTION; + +XDMFCORE_EXPORT XDMFFUNCTION * XdmfFunctionNew(); + +XDMFCORE_EXPORT XDMFFUNCTION * XdmfFunctionNewInit(char * newExpression, char ** keys, XDMFARRAY ** values, int numVariables); + +XDMFCORE_EXPORT int XdmfFunctionAddFunction(char * name, XDMFARRAY *(*functionref)(XDMFARRAY **, unsigned int), int * status); + +XDMFCORE_EXPORT int XdmfFunctionAddOperation(char newoperator, XDMFARRAY *(*operationref)(XDMFARRAY *, XDMFARRAY *), int priority, int * status); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionAverage(XDMFARRAY ** values, int numValues); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionChunk(XDMFARRAY * val1, XDMFARRAY * val2, int * status); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionEvaluateExpression(char * expression, char ** keys, XDMFARRAY ** values, int numVariables, int * status); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionEvaluateOperation(XDMFARRAY * val1, XDMFARRAY * val2, char operation, int * status); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionEvaluateFunction(XDMFARRAY ** valueVector, int numValues, char * functionName, int * status); + +XDMFCORE_EXPORT char * XdmfFunctionGetExpression(XDMFFUNCTION * function); + +XDMFCORE_EXPORT unsigned int XdmfFunctionGetNumberVariables(XDMFFUNCTION * function); + +XDMFCORE_EXPORT int XdmfFunctionGetOperationPriority(char operation); + +XDMFCORE_EXPORT char * XdmfFunctionGetSupportedOperations(); + +XDMFCORE_EXPORT char ** XdmfFunctionGetSupportedFunctions(); + +XDMFCORE_EXPORT unsigned int XdmfFunctionGetNumberSupportedFunctions(); + +XDMFCORE_EXPORT char * XdmfFunctionGetValidDigitChars(); + +XDMFCORE_EXPORT char * XdmfFunctionGetValidVariableChars(); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionGetVariable(XDMFFUNCTION * function, char * key); + +XDMFCORE_EXPORT char ** XdmfFunctionGetVariableList(XDMFFUNCTION * function); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionInterlace(XDMFARRAY * val1, XDMFARRAY * val2, int * status); + +XDMFCORE_EXPORT void XdmfFunctionInsertVariable(XDMFFUNCTION * function, char * key, XDMFARRAY * value, int passControl); + +XDMFCORE_EXPORT void XdmfFunctionRemoveVariable(XDMFFUNCTION * function, char * key); + +XDMFCORE_EXPORT void XdmfFunctionSetExpression(XDMFFUNCTION * function, char * newExpression, int * status); + +XDMFCORE_EXPORT XDMFARRAY * XdmfFunctionSum(XDMFARRAY ** values, int numValues); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfFunction, XDMFFUNCTION, XDMFCORE) +XDMF_ARRAYREFERENCE_C_CHILD_DECLARE(XdmfFunction, XDMFFUNCTION, XDMFCORE) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFFUNCTION_HPP_ */ diff --git a/core/XdmfHDF5Controller.cpp b/core/XdmfHDF5Controller.cpp index eea8a293..2338d1b7 100644 --- a/core/XdmfHDF5Controller.cpp +++ b/core/XdmfHDF5Controller.cpp @@ -24,6 +24,7 @@ #include #include #include +#include "string.h" #include "XdmfArray.hpp" #include "XdmfArrayType.hpp" #include "XdmfError.hpp" @@ -63,11 +64,41 @@ XdmfHDF5Controller::XdmfHDF5Controller(const std::string & hdf5FilePath, const std::vector & dataspaceDimensions) : XdmfHeavyDataController(hdf5FilePath, type, - dimensions), + start, + stride, + dimensions, + dataspaceDimensions), mDataSetPath(dataSetPath), - mDataspaceDimensions(dataspaceDimensions), - mStart(start), - mStride(stride) + mDataSetPrefix(""), + mDataSetId(-1) +{ + unsigned int i = 0; + for (; i < mDataSetPath.size(); ++i) { + if (mDataSetPath[(mDataSetPath.size() - 1) - i] != '0' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '1' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '2' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '3' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '4' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '5' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '6' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '7' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '8' && + mDataSetPath[(mDataSetPath.size() - 1) - i] != '9') { + break; + } + } + unsigned int endOfPrefix = (mDataSetPath.size()) - i; + mDataSetPrefix = mDataSetPath.substr(0, endOfPrefix); + if (mDataSetPrefix.compare(mDataSetPath) != 0) { + mDataSetId = atoi(mDataSetPath.substr(endOfPrefix).c_str()); + } +} + +XdmfHDF5Controller::XdmfHDF5Controller(const XdmfHDF5Controller& refController): + XdmfHeavyDataController(refController), + mDataSetPath(refController.getDataSetPath()), + mDataSetPrefix(refController.mDataSetPrefix), + mDataSetId(refController.mDataSetId) { } @@ -93,16 +124,22 @@ XdmfHDF5Controller::getDataSetPath() const return mDataSetPath; } -std::string -XdmfHDF5Controller::getDescriptor() const +const std::string +XdmfHDF5Controller::getDataSetPrefix() const { - return ":" + mDataSetPath; + return mDataSetPrefix; } -std::vector -XdmfHDF5Controller::getDataspaceDimensions() const +int +XdmfHDF5Controller::getDataSetId() const { - return mDataspaceDimensions; + return mDataSetId; +} + +std::string +XdmfHDF5Controller::getDescriptor() const +{ + return ":" + mDataSetPath; } std::string @@ -123,18 +160,6 @@ XdmfHDF5Controller::getProperties(std::map & collected collectedProperties["Format"] = this->getName(); } -std::vector -XdmfHDF5Controller::getStart() const -{ - return mStart; -} - -std::vector -XdmfHDF5Controller::getStride() const -{ - return mStride; -} - void XdmfHDF5Controller::read(XdmfArray * const array) { @@ -319,3 +344,116 @@ XdmfHDF5Controller::setMaxOpenedFiles(unsigned int newMax) { XdmfHDF5Controller::mMaxOpenedFiles = newMax; } + +// C Wrappers + +XDMFHDF5CONTROLLER * XdmfHDF5ControllerNew(char * hdf5FilePath, + char * dataSetPath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfHDF5Controller::New(std::string(hdf5FilePath), std::string(dataSetPath), buildType, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFHDF5CONTROLLER *)((void *)(new XdmfHDF5Controller(*generatedController.get()))); + } + catch (...) + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfHDF5Controller::New(std::string(hdf5FilePath), std::string(dataSetPath), buildType, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFHDF5CONTROLLER *)((void *)(new XdmfHDF5Controller(*generatedController.get()))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +char * XdmfHDF5ControllerGetDataSetPath(XDMFHDF5CONTROLLER * controller) +{ + char * returnPointer = strdup(((XdmfHDF5Controller *)(controller))->getDataSetPath().c_str()); + return returnPointer; +} + +// C Wrappers for parent classes are generated by macros + +XDMF_HEAVYCONTROLLER_C_CHILD_WRAPPER(XdmfHDF5Controller, XDMFHDF5CONTROLLER) diff --git a/core/XdmfHDF5Controller.hpp b/core/XdmfHDF5Controller.hpp index d15097e1..c5c15d0a 100644 --- a/core/XdmfHDF5Controller.hpp +++ b/core/XdmfHDF5Controller.hpp @@ -24,9 +24,21 @@ #ifndef XDMFHDF5CONTROLLER_HPP_ #define XDMFHDF5CONTROLLER_HPP_ -// Includes +// C Compatible Includes #include "XdmfCore.hpp" #include "XdmfHeavyDataController.hpp" + +// So that hdf5 does not need to be included in the header files +// It would add a dependancy to programs that use Xdmf +#ifndef _H5Ipublic_H + #ifndef XDMF_HID_T + #define XDMF_HID_T + typedef int hid_t; + #endif +#endif + +#ifdef __cplusplus + #include /** @@ -42,6 +54,8 @@ class XDMFCORE_EXPORT XdmfHDF5Controller : public XdmfHeavyDataController { public: + friend class XdmfHDF5Writer; + virtual ~XdmfHDF5Controller(); /** @@ -131,58 +145,6 @@ public: */ std::string getDataSetPath() const; - /** - * Get the dimensions of the dataspace owned by this - * controller. This is the dimension of the entire heavy dataset, - * which may be larger than the dimensions of the array (if reading - * a piece of a larger dataset). - * - * Example of use: - * - * C++ - * - * @dontinclude ExampleXdmfHDF5Controller.cpp - * @skipline //#initialization - * @until //#initialization - * @skipline //#getDataspaceDimensions - * @until //#getDataspaceDimensions - * - * Python - * - * @dontinclude XdmfExampleHDF5Controller.py - * @skipline #//initialization - * @until #//initialization - * @skipline #//getDataspaceDimensions - * @until #//getDataspaceDimensions - * - * @return A vector containing the size in each dimension of the dataspace - * owned by this controller. - */ - std::vector getDataspaceDimensions() const; - - /** - * Gets the controller in string form. For writing to file. - * - * Example of use: - * - * C++ - * - * @dontinclude ExampleXdmfHeavyDataController.cpp - * @skipline //#initialization - * @until //#initialization - * @skipline //#getDescriptor - * @until //#getDescriptor - * - * Python - * - * @dontinclude XdmfExampleHeavyDataController.py - * @skipline #//initialization - * @until #//initialization - * @skipline #//getDescriptor - * @until #//getDescriptor - * - * @return A string that contains relevant information for the controller - */ virtual std::string getDescriptor() const; virtual std::string getName() const; @@ -211,54 +173,6 @@ public: virtual void getProperties(std::map & collectedProperties) const; - /** - * Get the start index of the heavy data set owned by this controller. - * - * C++ - * - * @dontinclude ExampleXdmfHDF5Controller.cpp - * @skipline //#initialization - * @until //#initialization - * @skipline //#getStart - * @until //#getStart - * - * Python - * - * @dontinclude XdmfExampleHDF5Controller.py - * @skipline #//initialization - * @until #//initialization - * @skipline #//getStart - * @until #//getStart - * - * @return A vector containing the start index in each dimension of - * the heavy data set owned by this controller. - */ - std::vector getStart() const; - - /** - * Get the stride of the heavy data set owned by this controller. - * - * C++ - * - * @dontinclude ExampleXdmfHDF5Controller.cpp - * @skipline //#initialization - * @until //#initialization - * @skipline //#getStride - * @until //#getStride - * - * Python - * - * @dontinclude XdmfExampleHDF5Controller.py - * @skipline #//initialization - * @until #//initialization - * @skipline #//getStride - * @until #//getStride - * - * @return A vector containing the stride in each dimension of the - * heavy data set owned by this controller. - */ - std::vector getStride() const; - virtual void read(XdmfArray * const array); /** @@ -282,6 +196,8 @@ public: */ static void setMaxOpenedFiles(unsigned int newMax); + XdmfHDF5Controller(const XdmfHDF5Controller &); + protected: XdmfHDF5Controller(const std::string & hdf5FilePath, @@ -292,21 +208,63 @@ protected: const std::vector & dimensions, const std::vector & dataspaceDimensions); + const std::string getDataSetPrefix() const; + int getDataSetId() const; + void read(XdmfArray * const array, const int fapl); private: - XdmfHDF5Controller(const XdmfHDF5Controller &); // Not implemented. void operator=(const XdmfHDF5Controller &); // Not implemented. + const std::string mDataSetPath; + + std::string mDataSetPrefix; + int mDataSetId; + static std::map mOpenFileUsage; // When set to 0 there will be no files that stay open after a read static unsigned int mMaxOpenedFiles; - - const std::string mDataSetPath; - const std::vector mDataspaceDimensions; - const std::vector mStart; - const std::vector mStride; }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct XDMFHDF5CONTROLLER; // Simply as a typedef to ensure correct typing +typedef struct XDMFHDF5CONTROLLER XDMFHDF5CONTROLLER; + +XDMFCORE_EXPORT XDMFHDF5CONTROLLER * XdmfHDF5ControllerNew(char * hdf5FilePath, + char * dataSetPath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + int * status); + +// C Wrappers for parent classes are generated by macros + +XDMFCORE_EXPORT char * XdmfHDF5ControllerGetDataSetPath(XDMFHDF5CONTROLLER * controller); + +XDMF_HEAVYCONTROLLER_C_CHILD_DECLARE(XdmfHDF5Controller, XDMFHDF5CONTROLLER, XDMFCORE) + +#define XDMF_HDF5CONTROLLER_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT char * ClassName##GetDataSetPath( CClassName * controller); + +#define XDMF_HDF5CONTROLLER_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +char * ClassName##GetDataSetPath( CClassName * controller) \ +{ \ + return XdmfHDF5ControllerGetDataSetPath((XDMFHDF5CONTROLLER *)((void *)controller)); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFHDF5CONTROLLER_HPP_ */ diff --git a/core/XdmfHDF5Writer.cpp b/core/XdmfHDF5Writer.cpp index c1d96148..e975e8d5 100644 --- a/core/XdmfHDF5Writer.cpp +++ b/core/XdmfHDF5Writer.cpp @@ -27,12 +27,14 @@ #include #include #include +#include #include "XdmfItem.hpp" #include "XdmfArray.hpp" #include "XdmfArrayType.hpp" #include "XdmfError.hpp" #include "XdmfHDF5Controller.hpp" #include "XdmfHDF5Writer.hpp" +#include "XdmfSystemUtils.hpp" namespace { @@ -40,91 +42,74 @@ namespace { } -/** - * PIMPL - */ -class XdmfHDF5Writer::XdmfHDF5WriterImpl { +XdmfHDF5Writer::XdmfHDF5WriterImpl::XdmfHDF5WriterImpl(): + mHDF5Handle(-1), + mFapl(H5P_DEFAULT), + mChunkSize(DEFAULT_CHUNK_SIZE), + mOpenFile(""), + mDepth(0) +{ +}; -public: +XdmfHDF5Writer::XdmfHDF5WriterImpl::~XdmfHDF5WriterImpl() +{ + closeFile(); +}; - XdmfHDF5WriterImpl(): - mHDF5Handle(-1), - mChunkSize(DEFAULT_CHUNK_SIZE), - mOpenFile(""), - mDepth(0) - { - }; +void +XdmfHDF5Writer::XdmfHDF5WriterImpl::closeFile() +{ + if(mHDF5Handle >= 0) { + H5Fclose(mHDF5Handle); + mHDF5Handle = -1; + } + mOpenFile = ""; +}; - ~XdmfHDF5WriterImpl() - { +int +XdmfHDF5Writer::XdmfHDF5WriterImpl::openFile(const std::string & filePath, + const int mDataSetId) +{ + if(mHDF5Handle >= 0) { + // Perhaps we should throw a warning. closeFile(); - }; + } + // Save old error handler and turn off error handling for now + H5E_auto_t old_func; + void * old_client_data; + H5Eget_auto(0, &old_func, &old_client_data); + H5Eset_auto2(0, NULL, NULL); - void - closeFile() - { - if(mHDF5Handle >= 0) { - /*herr_t status =*/H5Fclose(mHDF5Handle); - mHDF5Handle = -1; - } - mOpenFile = ""; - }; + int toReturn = 0; - int - openFile(const std::string & filePath, - const int fapl, - const int mDataSetId) - { - if(mHDF5Handle >= 0) { - // Perhaps we should throw a warning. - closeFile(); - } - // Save old error handler and turn off error handling for now - H5E_auto_t old_func; - void * old_client_data; - H5Eget_auto(0, &old_func, &old_client_data); - H5Eset_auto2(0, NULL, NULL); - - int toReturn = 0; - - mOpenFile.assign(filePath); - - - if(H5Fis_hdf5(filePath.c_str()) > 0) { - mHDF5Handle = H5Fopen(filePath.c_str(), - H5F_ACC_RDWR, - fapl); - if(mDataSetId == 0) { - hsize_t numObjects; - /*herr_t status = */H5Gget_num_objs(mHDF5Handle, - &numObjects); - toReturn = numObjects; - } - else { - toReturn = mDataSetId; - } + mOpenFile.assign(filePath); + + if(H5Fis_hdf5(filePath.c_str()) > 0) { + mHDF5Handle = H5Fopen(filePath.c_str(), + H5F_ACC_RDWR, + mFapl); + if(mDataSetId == 0) { + hsize_t numObjects; + /*herr_t status = */H5Gget_num_objs(mHDF5Handle, + &numObjects); + toReturn = numObjects; } else { - // This is where it currently fails - mHDF5Handle = H5Fcreate(filePath.c_str(), - H5F_ACC_TRUNC, - H5P_DEFAULT, - fapl); + toReturn = mDataSetId; } - - // Restore previous error handler - H5Eset_auto2(0, old_func, old_client_data); - - return toReturn; - + } + else { + mHDF5Handle = H5Fcreate(filePath.c_str(), + H5F_ACC_TRUNC, + H5P_DEFAULT, + mFapl); } - hid_t mHDF5Handle; - unsigned int mChunkSize; - std::string mOpenFile; - int mDepth; - std::set mWrittenItems; -}; + // Restore previous error handler + H5Eset_auto2(0, old_func, old_client_data); + + return toReturn; +} shared_ptr XdmfHDF5Writer::New(const std::string & filePath, @@ -139,7 +124,17 @@ XdmfHDF5Writer::New(const std::string & filePath, XdmfHDF5Writer::XdmfHDF5Writer(const std::string & filePath) : XdmfHeavyDataWriter(filePath, 1, 800), - mImpl(new XdmfHDF5WriterImpl()) + mImpl(new XdmfHDF5WriterImpl()), + mUseDeflate(false), + mDeflateFactor(0) +{ +} + +XdmfHDF5Writer::XdmfHDF5Writer(const XdmfHDF5Writer & writerRef) : + XdmfHeavyDataWriter(writerRef.getFilePath(), 1, 800), + mImpl(new XdmfHDF5WriterImpl()), + mUseDeflate(false), + mDeflateFactor(0) { } @@ -150,17 +145,19 @@ XdmfHDF5Writer::~XdmfHDF5Writer() void XdmfHDF5Writer::controllerSplitting(XdmfArray & array, - const int & fapl, int & controllerIndexOffset, shared_ptr heavyDataController, const std::string & checkFileName, const std::string & checkFileExt, const std::string & dataSetPath, + int dataSetId, const std::vector & dimensions, const std::vector & dataspaceDimensions, const std::vector & start, const std::vector & stride, std::list & filesWritten, + std::list & datasetsWritten, + std::list & datasetIdsWritten, std::list & arraysWritten, std::list > & startsWritten, std::list > & stridesWritten, @@ -219,7 +216,13 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, // If overwrite subtract previous data size. if (mMode == Overwrite || mMode == Hyperslab) { // Find previous data size - int checkfilesize = getDataSetSize(testFile.str(), dataSetPath, fapl); + std::stringstream currentDataSetPath; + currentDataSetPath << dataSetPath; + if (dataSetId >= 0) + { + currentDataSetPath << dataSetId; + } + int checkfilesize = getDataSetSize(testFile.str(), currentDataSetPath.str()); if (checkfilesize < 0) { checkfilesize = 0; } @@ -248,7 +251,9 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, else if (previousDataSize == 0) { fileSize += getFileOverhead(); } - + if (fileSize > (unsigned int)getFileSizeLimit()*(1024*1024)) { + fileSize = (unsigned int)getFileSizeLimit()*(1024*1024); + } //Start of splitting section // If needed split the written array @@ -324,8 +329,8 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, // If remaining size is less than available space, just write all of what's left remainingSize = remainingValues * dataItemSize; } - if (remainingSize + previousDataSize + fileSize - < (unsigned int)getFileSizeLimit()*(1024*1024)) { + if (remainingSize + previousDataSize + fileSize - (hyperslabSize * dataItemSize) + <= (unsigned int)getFileSizeLimit()*(1024*1024)) { // If the array hasn't been split if (amountAlreadyWritten == 0) { // Just pass all data to the partial vectors @@ -412,11 +417,11 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, // then take a fraction of the dimension // Calculate the number of values of the data type you're using will fit unsigned int usableSpace = (getFileSizeLimit()*(1024*1024) - - fileSize) / dataItemSize; + (fileSize + previousDataSize)) / dataItemSize; if ((unsigned int)getFileSizeLimit()*(1024*1024) < previousDataSize + fileSize) { usableSpace = 0; } - usableSpace += hyperslabSize-previousDataSize; + usableSpace += hyperslabSize; // If the array hasn't been split if (amountAlreadyWritten == 0) { // See if it will fit in the next file @@ -727,6 +732,8 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, } arraysWritten.push_back(partialArray); filesWritten.push_back(testFile.str()); + datasetsWritten.push_back(dataSetPath); + datasetIdsWritten.push_back(dataSetId); startsWritten.push_back(partialStarts); stridesWritten.push_back(partialStrides); dimensionsWritten.push_back(partialDimensions); @@ -809,6 +816,7 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, } } } + ++dataSetId; } if (mMode == Append) { @@ -893,6 +901,8 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, arraysWritten.push_back(partialArray); filesWritten.push_back(writtenFileName); + datasetsWritten.push_back(dataSetPath); + datasetIdsWritten.push_back(dataSetId); // Also need to push the starts and strides loaded from the HeavyDataController startsWritten.push_back(start); stridesWritten.push_back(stride); @@ -919,24 +929,6 @@ XdmfHDF5Writer::createController(const std::string & hdf5FilePath, dataspaceDimensions); } -shared_ptr -XdmfHDF5Writer::createController(const shared_ptr & refController) -{ - if (shared_ptr controller = shared_dynamic_cast(refController)) { - return createController(controller->getFilePath(), - controller->getDataSetPath(), - controller->getType(), - controller->getStart(), - controller->getStride(), - controller->getDimensions(), - controller->getDataspaceDimensions()); - } - else { - XdmfError::message(XdmfError::FATAL, "Error: Invalid Controller Conversion"); - return shared_ptr(); - } -} - unsigned int XdmfHDF5Writer::getChunkSize() const { @@ -944,27 +936,34 @@ XdmfHDF5Writer::getChunkSize() const } int -XdmfHDF5Writer::getDataSetSize(const std::string & fileName, const std::string & dataSetName, const int fapl) +XdmfHDF5Writer::getDataSetSize(shared_ptr descriptionController) +{ + return getDataSetSize(descriptionController->getFilePath(), + shared_dynamic_cast(descriptionController)->getDataSetPath()); +} + +int +XdmfHDF5Writer::getDataSetSize(const std::string & fileName, const std::string & dataSetName) { hid_t handle = -1; H5E_auto_t old_func; void * old_client_data; H5Eget_auto(0, &old_func, &old_client_data); H5Eset_auto2(0, NULL, NULL); - if (fileName != mImpl->mOpenFile) { + if (XdmfSystemUtils::getRealPath(fileName) != mImpl->mOpenFile) { // Save old error handler and turn off error handling for now if(H5Fis_hdf5(fileName.c_str()) > 0) { handle = H5Fopen(fileName.c_str(), H5F_ACC_RDWR, - fapl); + mImpl->mFapl); } else { // This is where it currently fails handle = H5Fcreate(fileName.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, - fapl); + mImpl->mFapl); } } else { @@ -974,6 +973,13 @@ XdmfHDF5Writer::getDataSetSize(const std::string & fileName, const std::string & // Restore previous error handler H5Eset_auto2(0, old_func, old_client_data); + if (!H5Lexists(mImpl->mHDF5Handle, + dataSetName.c_str(), + H5P_DEFAULT)) + { + return 0; + } + hid_t checkset = H5Dopen(handle, dataSetName.c_str(), H5P_DEFAULT); @@ -990,23 +996,28 @@ XdmfHDF5Writer::getDataSetSize(const std::string & fileName, const std::string & return checksize; } -void -XdmfHDF5Writer::closeFile() +int +XdmfHDF5Writer::getDeflateFactor() const { - mImpl->closeFile(); + return mDeflateFactor; +} + +bool +XdmfHDF5Writer::getUseDeflate() const +{ + return mUseDeflate; } void -XdmfHDF5Writer::openFile() +XdmfHDF5Writer::closeFile() { - this->openFile(H5P_DEFAULT); + mImpl->closeFile(); } void -XdmfHDF5Writer::openFile(const int fapl) +XdmfHDF5Writer::openFile() { mDataSetId = mImpl->openFile(mFilePath, - fapl, mDataSetId); } @@ -1016,18 +1027,30 @@ XdmfHDF5Writer::setChunkSize(const unsigned int chunkSize) mImpl->mChunkSize = chunkSize; } +void +XdmfHDF5Writer::setDeflateFactor(int factor) +{ + mDeflateFactor = factor; +} + +void +XdmfHDF5Writer::setUseDeflate(bool status) +{ + mUseDeflate = status; +} + void XdmfHDF5Writer::visit(XdmfArray & array, const shared_ptr visitor) { mImpl->mDepth++; std::set::iterator checkWritten = mImpl->mWrittenItems.find(&array); - if (checkWritten == mImpl->mWrittenItems.end() || array.getItemTag() == "DataItem") { + if (checkWritten == mImpl->mWrittenItems.end()) { // If it has children send the writer to them too. array.traverse(visitor); - if (array.isInitialized()) { + if (array.isInitialized() && array.getSize() > 0) { // Only do this if the object has not already been written - this->write(array, H5P_DEFAULT); + this->write(array); mImpl->mWrittenItems.insert(&array); } } @@ -1060,8 +1083,7 @@ XdmfHDF5Writer::visit(XdmfItem & item, void -XdmfHDF5Writer::write(XdmfArray & array, - const int fapl) +XdmfHDF5Writer::write(XdmfArray & array) { hid_t datatype = -1; bool closeDatatype = false; @@ -1132,7 +1154,12 @@ XdmfHDF5Writer::write(XdmfArray & array, // Hold the controllers in order to base the new controllers on them for(unsigned int i = 0; i < array.getNumberHeavyDataControllers(); ++i) { - previousControllers.push_back(array.getHeavyDataController(i)); + // discard controllers of the wrong type + if (shared_ptr controller = + shared_dynamic_cast(array.getHeavyDataController(i)) ) + { + previousControllers.push_back(array.getHeavyDataController(i)); + } } // Remove controllers from the array @@ -1141,10 +1168,11 @@ XdmfHDF5Writer::write(XdmfArray & array, array.removeHeavyDataController(array.getNumberHeavyDataControllers() -1); } - + bool hasControllers = true; if (previousControllers.size() == 0) { // Create a temporary controller if the array doesn't have one + hasControllers = false; shared_ptr tempDataController = this->createController(hdf5FilePath, "Data", @@ -1170,6 +1198,8 @@ XdmfHDF5Writer::write(XdmfArray & array, } std::list filesWritten; + std::list datasetsWritten; + std::list datasetIdsWritten; std::list arraysWritten; std::list > startsWritten; std::list > stridesWritten; @@ -1237,17 +1267,19 @@ XdmfHDF5Writer::write(XdmfArray & array, // Then check subsequent files for the same limitation std::string passPath = dataSetPath.str(); controllerSplitting(array, - fapl, controllerIndexOffset, heavyDataController, checkFileName, checkFileExt, - dataSetPath.str(), + heavyDataController->getDataSetPrefix(), + heavyDataController->getDataSetId(), dimensions, dataspaceDimensions, start, stride, filesWritten, + datasetsWritten, + datasetIdsWritten, arraysWritten, startsWritten, stridesWritten, @@ -1265,6 +1297,8 @@ XdmfHDF5Writer::write(XdmfArray & array, } std::list::iterator fileNameWalker = filesWritten.begin(); + std::list::iterator datasetWalker = datasetsWritten.begin(); + std::list::iterator datasetIdWalker = datasetIdsWritten.begin(); std::list::iterator arrayWalker = arraysWritten.begin(); std::list >::iterator startWalker = startsWritten.begin(); std::list >::iterator strideWalker = stridesWritten.begin(); @@ -1274,11 +1308,12 @@ XdmfHDF5Writer::write(XdmfArray & array, // Loop based on the amount of blocks split from the array. for (unsigned int writeIndex = 0; writeIndex < arraysWritten.size(); ++writeIndex) { - // This is the section where the data is written to hdf5 // If you want to change the writer to write to a different data format, do it here std::string curFileName = *fileNameWalker; + std::string currDataset = *datasetWalker; + int currDatasetId = *datasetIdWalker; void * curArray = *arrayWalker; std::vector curStart = *startWalker; std::vector curStride = *strideWalker; @@ -1295,7 +1330,14 @@ XdmfHDF5Writer::write(XdmfArray & array, closeFile = true; } mImpl->openFile(curFileName, - fapl, mDataSetId); + mDataSetId); + } + + if (currDatasetId >= 0) + { + mDataSetId = currDatasetId; + dataSetPath.str(std::string()); + dataSetPath << currDataset << mDataSetId; } htri_t testingSet = H5Lexists(mImpl->mHDF5Handle, @@ -1315,13 +1357,17 @@ XdmfHDF5Writer::write(XdmfArray & array, // If default mode find a new data set to write to (keep // incrementing dataSetId) - if(dataset >=0 && mMode == Default) { + if(dataset >=0 && + (mMode == Default || + (mMode == Hyperslab && !hasControllers))) { while(true) { dataSetPath.str(std::string()); - dataSetPath << "Data" << ++mDataSetId; + dataSetPath << currDataset << ++mDataSetId; if(!H5Lexists(mImpl->mHDF5Handle, dataSetPath.str().c_str(), H5P_DEFAULT)) { + //Close previous dataset + status = H5Dclose(dataset); dataset = H5Dopen(mImpl->mHDF5Handle, dataSetPath.str().c_str(), H5P_DEFAULT); @@ -1372,6 +1418,12 @@ XdmfHDF5Writer::write(XdmfArray & array, } } + // Set ZLIB / DEFLATE Compression + if (mUseDeflate) + { + status = H5Pset_deflate(property, mDeflateFactor); + } + status = H5Pset_chunk(property, current_dims.size(), &chunk_size[0]); // Use that dataspace to create a new dataset dataset = H5Dcreate(mImpl->mHDF5Handle, @@ -1506,15 +1558,13 @@ XdmfHDF5Writer::write(XdmfArray & array, status = H5Dclose(dataset); + H5Fflush(mImpl->mHDF5Handle, H5F_SCOPE_GLOBAL); + // This is causing a lot of overhead if(closeFile) { mImpl->closeFile(); } - if(mMode == Default) { - ++mDataSetId; - } - // Attach a new controller to the array shared_ptr newDataController = shared_ptr(); @@ -1524,7 +1574,7 @@ XdmfHDF5Writer::write(XdmfArray & array, if(mMode == Append) { // Find data size mImpl->openFile(curFileName, - fapl, mDataSetId); + mDataSetId); hid_t checkset = H5Dopen(mImpl->mHDF5Handle, dataSetPath.str().c_str(), H5P_DEFAULT); @@ -1572,6 +1622,8 @@ XdmfHDF5Writer::write(XdmfArray & array, array.insert(newDataController); fileNameWalker++; + datasetWalker++; + datasetIdWalker++; arrayWalker++; startWalker++; strideWalker++; @@ -1579,6 +1631,10 @@ XdmfHDF5Writer::write(XdmfArray & array, dataSizeWalker++; arrayOffsetWalker++; + if (mMode == Default) { + dataSetPath.str(std::string()); + dataSetPath << "Data" << ++mDataSetId; + } } @@ -1593,3 +1649,52 @@ XdmfHDF5Writer::write(XdmfArray & array, } } } + +// C Wrappers + +XDMFHDF5WRITER * XdmfHDF5WriterNew(char * fileName, int clobberFile) +{ + try + { + shared_ptr generatedWriter = XdmfHDF5Writer::New(std::string(fileName), clobberFile); + return (XDMFHDF5WRITER *)((void *)(new XdmfHDF5Writer(*generatedWriter.get()))); + } + catch (...) + { + shared_ptr generatedWriter = XdmfHDF5Writer::New(std::string(fileName), clobberFile); + return (XDMFHDF5WRITER *)((void *)(new XdmfHDF5Writer(*generatedWriter.get()))); + } +} + +void XdmfHDF5WriterCloseFile(XDMFHDF5WRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfHDF5Writer *)writer)->closeFile(); + XDMF_ERROR_WRAP_END(status) +} + +unsigned int XdmfHDF5WriterGetChunkSize(XDMFHDF5WRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return ((XdmfHDF5Writer *)writer)->getChunkSize(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +void XdmfHDF5WriterOpenFile(XDMFHDF5WRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfHDF5Writer *)writer)->openFile(); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfHDF5WriterSetChunkSize(XDMFHDF5WRITER * writer, unsigned int chunkSize, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfHDF5Writer *)writer)->setChunkSize(chunkSize); + XDMF_ERROR_WRAP_END(status) +} + +// C Wrappers for parent classes are generated by macros + +XDMF_HEAVYWRITER_C_CHILD_WRAPPER(XdmfHDF5Writer, XDMFHDF5WRITER) diff --git a/core/XdmfHDF5Writer.hpp b/core/XdmfHDF5Writer.hpp index 8850fb1d..cfbec6f4 100644 --- a/core/XdmfHDF5Writer.hpp +++ b/core/XdmfHDF5Writer.hpp @@ -24,16 +24,30 @@ #ifndef XDMFHDF5WRITER_HPP_ #define XDMFHDF5WRITER_HPP_ +// C Compatible includes +#include "XdmfCore.hpp" +#include "XdmfHeavyDataWriter.hpp" +#include "XdmfHeavyDataController.hpp" + +// So that hdf5 does not need to be included in the header files +// It would add a dependancy to programs that use Xdmf +#ifndef _H5Ipublic_H + #ifndef XDMF_HID_T + #define XDMF_HID_T + typedef int hid_t; + #endif +#endif + +#ifdef __cplusplus + // Forward Declarations class XdmfArray; class XdmfArrayType; class XdmfHDF5Controller; // Includes -#include "XdmfCore.hpp" -#include "XdmfHeavyDataWriter.hpp" -#include "XdmfHeavyDataController.hpp" #include +#include /** * @brief Traverse the Xdmf graph and write heavy data stored in @@ -106,6 +120,59 @@ public: */ unsigned int getChunkSize() const; + virtual int getDataSetSize(const std::string & fileName, + const std::string & dataSetName); + + /** + * Gets the factor that Deflate uses to compress data. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Writer.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getDeflateFactor + * @until //#getDeflateFactor + * + * Python + * + * @dontinclude XdmfExampleHDF5Writer.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getDeflateFactor + * @until #//getDeflateFactor + * + * @return The factor Deflate uses. + */ + int getDeflateFactor() const; + + /** + * Gets whether Deflate is enabled. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Writer.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getUseDeflate + * @until //#getUseDeflate + * + * Python + * + * @dontinclude XdmfExampleHDF5Writer.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getUseDeflate + * @until #//getUseDeflate + * + * @return Whether Deflate is in use. + */ + bool getUseDeflate() const; + virtual void openFile(); /** @@ -133,6 +200,56 @@ public: */ void setChunkSize(const unsigned int chunkSize); + /** + * Sets the factor that Deflate will use to compress data. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Writer.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setDeflateFactor + * @until //#setDeflateFactor + * + * Python + * + * @dontinclude XdmfExampleHDF5Writer.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setDeflateFactor + * @until #//setDeflateFactor + * + * @param factor The factor Deflate will use. + */ + void setDeflateFactor(int factor); + + /** + * Sets whether HDF5 will use Deflate compression + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Writer.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#setUseDeflate + * @until //#setUseDeflate + * + * Python + * + * @dontinclude XdmfExampleHDF5Writer.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//setUseDeflate + * @until #//setUseDeflate + * + * @param status Whether Deflate will be used. + */ + void setUseDeflate(bool status); + using XdmfHeavyDataWriter::visit; virtual void visit(XdmfArray & array, const shared_ptr visitor); @@ -140,6 +257,8 @@ public: virtual void visit(XdmfItem & item, const shared_ptr visitor); + XdmfHDF5Writer(const XdmfHDF5Writer &); + protected: XdmfHDF5Writer(const std::string & filePath); @@ -165,55 +284,71 @@ protected: */ virtual shared_ptr createController(const std::string & hdf5FilePath, - const std::string & dataSetPath, + const std::string & descriptor, const shared_ptr type, const std::vector & start, const std::vector & stride, const std::vector & dimensions, const std::vector & dataspaceDimensions); - virtual shared_ptr - createController(const shared_ptr & refController); - - virtual int getDataSetSize(const std::string & fileName, const std::string & dataSetName, const int fapl); - - /** - * Open hdf5 file with a fapl. - * - * @param fapl The file access property list for the hdf5 file. - */ - void openFile(const int fapl); + virtual int getDataSetSize(shared_ptr descriptionController); /** * Write the XdmfArray to a hdf5 file. * * @param array An XdmfArray to write to hdf5. - * @param fapl The file access property list for the hdf5 file on disk. */ - void write(XdmfArray & array, const int fapl); - -private: + virtual void write(XdmfArray & array); /** * PIMPL */ - class XdmfHDF5WriterImpl; + class XdmfHDF5WriterImpl + { + public: + + XdmfHDF5WriterImpl(); + + virtual ~XdmfHDF5WriterImpl(); + + virtual void + closeFile(); + + virtual int + openFile(const std::string & filePath, + const int mDataSetId); + + hid_t mHDF5Handle; + int mFapl; + unsigned int mChunkSize; + std::string mOpenFile; + int mDepth; + std::set mWrittenItems; + }; + + XdmfHDF5WriterImpl * mImpl; + + bool mUseDeflate; + int mDeflateFactor; + +private: - XdmfHDF5Writer(const XdmfHDF5Writer &); // Not implemented. void operator=(const XdmfHDF5Writer &); // Not implemented. virtual void controllerSplitting(XdmfArray & array, - const int & fapl, int & controllerIndexOffset, shared_ptr heavyDataController, const std::string & checkFileName, const std::string & checkFileExt, const std::string & dataSetPath, + int dataSetId, const std::vector & dimensions, const std::vector & dataspaceDimensions, const std::vector & start, const std::vector & stride, std::list & filesWritten, + std::list & datasetsWritten, + std::list & datasetIdsWritten, std::list & arraysWritten, std::list > & startsWritten, std::list > & stridesWritten, @@ -221,8 +356,65 @@ private: std::list > & dataSizesWritten, std::list & arrayOffsetsWritten); - XdmfHDF5WriterImpl * mImpl; - }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFHDF5WRITER; // Simply as a typedef to ensure correct typing +typedef struct XDMFHDF5WRITER XDMFHDF5WRITER; + +XDMFCORE_EXPORT XDMFHDF5WRITER * XdmfHDF5WriterNew(char * fileName, int clobberFile); + +XDMFCORE_EXPORT void XdmfHDF5WriterCloseFile(XDMFHDF5WRITER * writer, int * status); + +XDMFCORE_EXPORT unsigned int XdmfHDF5WriterGetChunkSize(XDMFHDF5WRITER * writer, int * status); + +XDMFCORE_EXPORT void XdmfHDF5WriterOpenFile(XDMFHDF5WRITER * writer, int * status); + +XDMFCORE_EXPORT void XdmfHDF5WriterSetChunkSize(XDMFHDF5WRITER * writer, unsigned int chunkSize, int * status); + +#define XDMF_HDF5WRITER_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT void ClassName##CloseFile( CClassName * writer, int * status); \ +Level##_EXPORT unsigned int ClassName##GetChunkSize( CClassName * writer, int * status); \ +Level##_EXPORT void ClassName##OpenFile( CClassName * writer, int * status); \ +Level##_EXPORT void ClassName##SetChunkSize( CClassName * writer, unsigned int chunkSize, int * status); + +#define XDMF_HDF5WRITER_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +void ClassName##CloseFile( CClassName * writer, int * status) \ +{ \ + XdmfHDF5WriterCloseFile((XDMFHDF5WRITER *)((void *)writer), status); \ +} \ + \ +unsigned int ClassName##GetChunkSize( CClassName * writer, int * status) \ +{ \ + return XdmfHDF5WriterGetChunkSize((XDMFHDF5WRITER *)((void *)writer), status); \ +} \ + \ +void ClassName##OpenFile( CClassName * writer, int * status) \ +{ \ + XdmfHDF5WriterOpenFile((XDMFHDF5WRITER *)((void *)writer), status); \ +} \ + \ +void ClassName##SetChunkSize( CClassName * writer, unsigned int chunkSize, int * status) \ +{ \ + XdmfHDF5WriterSetChunkSize((XDMFHDF5WRITER *)((void *)writer), chunkSize, status); \ +} + + +// C Wrappers for parent classes are generated by macros + +XDMF_HEAVYWRITER_C_CHILD_DECLARE(XdmfHDF5Writer, XDMFHDF5WRITER, XDMFCORE) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFHDF5WRITER_HPP_ */ diff --git a/core/XdmfHeavyDataController.cpp b/core/XdmfHeavyDataController.cpp index 4b5bb013..0486fcc6 100644 --- a/core/XdmfHeavyDataController.cpp +++ b/core/XdmfHeavyDataController.cpp @@ -23,6 +23,7 @@ #include #include +#include "string.h" #include "XdmfArrayType.hpp" #include "XdmfError.hpp" #include "XdmfHeavyDataController.hpp" @@ -30,14 +31,31 @@ XdmfHeavyDataController::XdmfHeavyDataController(const std::string & filePath, const shared_ptr & type, - const std::vector & dimensions) : + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces) : + mStart(starts), + mStride(strides), mDimensions(dimensions), + mDataspaceDimensions(dataspaces), mFilePath(filePath), mArrayStartOffset(0), mType(type) { } +XdmfHeavyDataController::XdmfHeavyDataController(const XdmfHeavyDataController& refController): + mStart(refController.getStart()), + mStride(refController.getStride()), + mDimensions(refController.getDimensions()), + mDataspaceDimensions(refController.getDataspaceDimensions()), + mFilePath(refController.getFilePath()), + mArrayStartOffset(refController.getArrayOffset()), + mType(refController.getType()) +{ +} + XdmfHeavyDataController::~XdmfHeavyDataController() { } @@ -48,6 +66,62 @@ XdmfHeavyDataController::getArrayOffset() const return mArrayStartOffset; } +std::string +XdmfHeavyDataController::getDataspaceDescription() const +{ + std::stringstream dimensionStream; + + for (unsigned int j = 0; j < this->getStart().size(); ++j) { + dimensionStream << this->getStart()[j]; + if (j < this->getStart().size() - 1) { + dimensionStream << " "; + } + } + dimensionStream << ":"; + for (unsigned int j = 0; j < this->getStride().size(); ++j) { + dimensionStream << this->getStride()[j]; + if (j < this->getStride().size() - 1) { + dimensionStream << " "; + } + } + dimensionStream << ":"; + for (unsigned int j = 0; j < this->getDimensions().size(); ++j) { + dimensionStream << this->getDimensions()[j]; + if (j < this->getDimensions().size() - 1) { + dimensionStream << " "; + } + } + dimensionStream << ":"; + for (unsigned int j = 0; j < this->getDataspaceDimensions().size(); ++j) { + dimensionStream << this->getDataspaceDimensions()[j]; + if (j < this->getDataspaceDimensions().size() - 1) { + dimensionStream << " "; + } + } + return dimensionStream.str(); +} + +std::vector +XdmfHeavyDataController::getDataspaceDimensions() const +{ + return mDataspaceDimensions; +} + +unsigned int +XdmfHeavyDataController::getDataspaceSize() const +{ + return std::accumulate(mDataspaceDimensions.begin(), + mDataspaceDimensions.end(), + 1, + std::multiplies()); +} + +std::string +XdmfHeavyDataController::getDescriptor() const +{ + return ""; +} + std::vector XdmfHeavyDataController::getDimensions() const { @@ -60,6 +134,18 @@ XdmfHeavyDataController::getFilePath() const return mFilePath; } +std::vector +XdmfHeavyDataController::getStart() const +{ + return mStart; +} + +std::vector +XdmfHeavyDataController::getStride() const +{ + return mStride; +} + unsigned int XdmfHeavyDataController::getSize() const { @@ -80,3 +166,233 @@ XdmfHeavyDataController::setArrayOffset(unsigned int newOffset) { mArrayStartOffset = newOffset; } + +// C Wrappers + +void XdmfHeavyDataControllerFree(XDMFHEAVYDATACONTROLLER * item) +{ + if (item != NULL) { + delete ((XdmfHeavyDataController *)item); + item = NULL; + } +} + +unsigned int * XdmfHeavyDataControllerGetDataspaceDimensions(XDMFHEAVYDATACONTROLLER * controller) +{ + try + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getDataspaceDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getDataspaceDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +unsigned int * XdmfHeavyDataControllerGetDimensions(XDMFHEAVYDATACONTROLLER * controller) +{ + try + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +char * XdmfHeavyDataControllerGetFilePath(XDMFHEAVYDATACONTROLLER * controller) +{ + try + { + char * returnPointer = strdup(((XdmfHeavyDataController *)(controller))->getFilePath().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfHeavyDataController *)(controller))->getFilePath().c_str()); + return returnPointer; + } +} + +char * XdmfHeavyDataControllerGetName(XDMFHEAVYDATACONTROLLER * controller) +{ + try + { + char * returnPointer = strdup(((XdmfHeavyDataController *)(controller))->getName().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfHeavyDataController *)(controller))->getName().c_str()); + return returnPointer; + } +} + +unsigned int XdmfHeavyDataControllerGetNumberDimensions(XDMFHEAVYDATACONTROLLER * controller) +{ + return ((XdmfHeavyDataController *)(controller))->getDimensions().size(); +} + +unsigned int XdmfHeavyDataControllerGetSize(XDMFHEAVYDATACONTROLLER * controller) +{ + return ((XdmfHeavyDataController *)(controller))->getSize(); +} + +unsigned int * XdmfHeavyDataControllerGetStart(XDMFHEAVYDATACONTROLLER * controller) +{ + try + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getStart(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getStart(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +unsigned int * XdmfHeavyDataControllerGetStride(XDMFHEAVYDATACONTROLLER * controller) +{ + try + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getStride(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfHeavyDataController *)(controller))->getStride(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +void XdmfHeavyDataControllerSetArrayOffset(XDMFHEAVYDATACONTROLLER * controller, unsigned int newOffset) +{ + ((XdmfHeavyDataController *)(controller))->setArrayOffset(newOffset); +} + +unsigned int XdmfHeavyDataControllerGetArrayOffset(XDMFHEAVYDATACONTROLLER * controller) +{ + return ((XdmfHeavyDataController *)(controller))->getArrayOffset(); +} + +int XdmfHeavyDataControllerGetType(XDMFHEAVYDATACONTROLLER * controller, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr compareType = ((XdmfHeavyDataController *)(controller))->getType(); + std::string typeName = compareType->getName(); + unsigned int typePrecision = compareType->getElementSize(); + if (typeName == XdmfArrayType::UInt8()->getName()) + { + return XDMF_ARRAY_TYPE_UINT8; + } + else if (typeName == XdmfArrayType::UInt16()->getName()) + { + return XDMF_ARRAY_TYPE_UINT16; + } + else if (typeName == XdmfArrayType::UInt32()->getName()) + { + return XDMF_ARRAY_TYPE_UINT32; + } + else if (typeName == XdmfArrayType::Int8()->getName()) + { + return XDMF_ARRAY_TYPE_INT8; + } + else if (typeName == XdmfArrayType::Int16()->getName()) + { + return XDMF_ARRAY_TYPE_INT16; + } + else if (typeName == XdmfArrayType::Int32()->getName() || typeName == XdmfArrayType::Int64()->getName()) + { + if (typePrecision == 4) + { + return XDMF_ARRAY_TYPE_INT32; + } + else if (typePrecision == 8) + { + return XDMF_ARRAY_TYPE_INT64; + } + else + { + } + } + else if (typeName == XdmfArrayType::Float32()->getName() || typeName == XdmfArrayType::Float64()->getName()) + { + if (typePrecision == 4) + { + return XDMF_ARRAY_TYPE_FLOAT32; + } + else if (typePrecision == 8) + { + return XDMF_ARRAY_TYPE_FLOAT64; + } + else + { + } + } + else if (typeName == XdmfArrayType::String()->getName()) + { + //This shouldn't be used from C bindings + XdmfError::message(XdmfError::FATAL, + "Error: String type not usable from C."); + } + else + { + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +void XdmfHeavyDataControllerRead(XDMFHEAVYDATACONTROLLER * controller, void * array, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfHeavyDataController *)(controller))->read((XdmfArray *)array); + XDMF_ERROR_WRAP_END(status) +} diff --git a/core/XdmfHeavyDataController.hpp b/core/XdmfHeavyDataController.hpp index fc2c0e1c..f7e6eebb 100644 --- a/core/XdmfHeavyDataController.hpp +++ b/core/XdmfHeavyDataController.hpp @@ -24,12 +24,16 @@ #ifndef XDMFHEAVYDATACONTROLLER_HPP_ #define XDMFHEAVYDATACONTROLLER_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfArrayType.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfArray; -class XdmfArrayType; // Includes -#include "XdmfCore.hpp" #include #include #include @@ -53,6 +57,68 @@ public: virtual ~XdmfHeavyDataController() = 0; + /** + * Gets a string containing data on the starts, + * strides, dimensions, and dataspaces for this controller. + * + * @return The string description + */ + std::string getDataspaceDescription() const; + + /** + * Get the dimensions of the dataspace owned by this + * controller. This is the dimension of the entire heavy dataset, + * which may be larger than the dimensions of the array (if reading + * a piece of a larger dataset). + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Controller.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getDataspaceDimensions + * @until //#getDataspaceDimensions + * + * Python + * + * @dontinclude XdmfExampleHDF5Controller.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getDataspaceDimensions + * @until #//getDataspaceDimensions + * + * @return A vector containing the size in each dimension of the dataspace + * owned by this controller. + */ + std::vector getDataspaceDimensions() const; + + /** + * Get the size of dataspace of the heavy data set owned by this controller. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Controller.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getDataspaceSize + * @until //#getDataspaceSize + * + * Python + * + * @dontinclude XdmfExampleHDF5Controller.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getDataspaceSize + * @until #//getDataspaceSize + * + * @return An int containing the size of the heavy data set. + */ + unsigned int getDataspaceSize() const; + /** * Gets the controller in string form. For writing to file. * @@ -76,7 +142,7 @@ public: * * @return A string that contains relevant information for the controller */ - virtual std::string getDescriptor() const = 0; + virtual std::string getDescriptor() const; /** * Get the dimensions of the heavy data set owned by this controller. @@ -182,6 +248,54 @@ public: */ unsigned int getSize() const; + /** + * Get the start index of the heavy data set owned by this controller. + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Controller.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getStart + * @until //#getStart + * + * Python + * + * @dontinclude XdmfExampleHDF5Controller.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getStart + * @until #//getStart + * + * @return A vector containing the start index in each dimension of + * the heavy data set owned by this controller. + */ + std::vector getStart() const; + + /** + * Get the stride of the heavy data set owned by this controller. + * + * C++ + * + * @dontinclude ExampleXdmfHDF5Controller.cpp + * @skipline //#initialization + * @until //#initialization + * @skipline //#getStride + * @until //#getStride + * + * Python + * + * @dontinclude XdmfExampleHDF5Controller.py + * @skipline #//initialization + * @until #//initialization + * @skipline #//getStride + * @until #//getStride + * + * @return A vector containing the stride in each dimension of the + * heavy data set owned by this controller. + */ + std::vector getStride() const; + /** * For use in conjunction with heavy data controllers set to arrays * the offset within the array from which the controller will be inserted @@ -290,20 +404,27 @@ public: */ virtual void read(XdmfArray * const array) = 0; + XdmfHeavyDataController(const XdmfHeavyDataController&); + protected: XdmfHeavyDataController(const std::string & filePath, const shared_ptr & type, - const std::vector & dimensions); + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces); + const std::vector mStart; + const std::vector mStride; const std::vector mDimensions; + const std::vector mDataspaceDimensions; const std::string mFilePath; unsigned int mArrayStartOffset; const shared_ptr mType; private: - XdmfHeavyDataController(const XdmfHeavyDataController&); // Not implemented. void operator=(const XdmfHeavyDataController &); // Not implemented. }; @@ -313,4 +434,130 @@ XDMFCORE_TEMPLATE template class XDMFCORE_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFHEAVYDATACONTROLLER; // Simply as a typedef to ensure correct typing +typedef struct XDMFHEAVYDATACONTROLLER XDMFHEAVYDATACONTROLLER; + +XDMFCORE_EXPORT void XdmfHeavyDataControllerFree(XDMFHEAVYDATACONTROLLER * item); + +XDMFCORE_EXPORT unsigned int * XdmfHeavyDataControllerGetDataspaceDimensions(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT unsigned int * XdmfHeavyDataControllerGetDimensions(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT char * XdmfHeavyDataControllerGetFilePath(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT char * XdmfHeavyDataControllerGetName(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT unsigned int XdmfHeavyDataControllerGetNumberDimensions(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT unsigned int XdmfHeavyDataControllerGetSize(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT unsigned int * XdmfHeavyDataControllerGetStart(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT unsigned int * XdmfHeavyDataControllerGetStride(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT void XdmfHeavyDataControllerSetArrayOffset(XDMFHEAVYDATACONTROLLER * controller, unsigned int newOffset); + +XDMFCORE_EXPORT unsigned int XdmfHeavyDataControllerGetArrayOffset(XDMFHEAVYDATACONTROLLER * controller); + +XDMFCORE_EXPORT int XdmfHeavyDataControllerGetType(XDMFHEAVYDATACONTROLLER * controller, int * status); + +XDMFCORE_EXPORT void XdmfHeavyDataControllerRead(XDMFHEAVYDATACONTROLLER * controller, void * array, int * status); + +#define XDMF_HEAVYCONTROLLER_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT void ClassName##Free( CClassName * item); \ +Level##_EXPORT unsigned int * ClassName##GetDataspaceDimensions( CClassName * controller); \ +Level##_EXPORT unsigned int * ClassName##GetDimensions( CClassName * controller); \ +Level##_EXPORT char * ClassName##GetFilePath( CClassName * controller); \ +Level##_EXPORT char * ClassName##GetName( CClassName * controller); \ +Level##_EXPORT unsigned int ClassName##GetNumberDimensions( CClassName * controller); \ +Level##_EXPORT unsigned int ClassName##GetSize( CClassName * controller); \ +Level##_EXPORT unsigned int * ClassName##GetStart( CClassName * controller); \ +Level##_EXPORT unsigned int * ClassName##GetStride( CClassName * controller); \ +Level##_EXPORT void ClassName##SetArrayOffset( CClassName * controller, unsigned int newOffset); \ +Level##_EXPORT unsigned int ClassName##GetArrayOffset( CClassName * controller); \ +Level##_EXPORT int ClassName##GetType( CClassName * controller, int * status); \ +Level##_EXPORT void ClassName##Read( CClassName * controller, void * array, int * status); + + + +#define XDMF_HEAVYCONTROLLER_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +void ClassName##Free( CClassName * item) \ +{ \ + XdmfHeavyDataControllerFree((XDMFHEAVYDATACONTROLLER *)((void *)item)); \ +} \ + \ +unsigned int * ClassName##GetDataspaceDimensions( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetDataspaceDimensions((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +unsigned int * ClassName##GetDimensions( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetDimensions((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +char * ClassName##GetFilePath( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetFilePath((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +char * ClassName##GetName( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetName((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +unsigned int ClassName##GetNumberDimensions( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetNumberDimensions((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +unsigned int ClassName##GetSize( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetSize((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +unsigned int * ClassName##GetStart( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetStart((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +unsigned int * ClassName##GetStride( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetStride((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +void ClassName##SetArrayOffset( CClassName * controller, unsigned int newOffset) \ +{ \ + XdmfHeavyDataControllerSetArrayOffset((XDMFHEAVYDATACONTROLLER *)((void *)controller), newOffset); \ +} \ + \ +unsigned int ClassName##GetArrayOffset( CClassName * controller) \ +{ \ + return XdmfHeavyDataControllerGetArrayOffset((XDMFHEAVYDATACONTROLLER *)((void *)controller)); \ +} \ + \ +int ClassName##GetType( CClassName * controller, int * status) \ +{ \ + return XdmfHeavyDataControllerGetType((XDMFHEAVYDATACONTROLLER *)((void *)controller), status); \ +} \ + \ +void ClassName##Read( CClassName * controller, void * array, int * status) \ +{ \ + XdmfHeavyDataControllerRead((XDMFHEAVYDATACONTROLLER *)((void *)controller), array, status); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFHEAVYDATACONTROLLER_HPP_ */ diff --git a/core/XdmfHeavyDataDescription.cpp b/core/XdmfHeavyDataDescription.cpp new file mode 100644 index 00000000..37e652ff --- /dev/null +++ b/core/XdmfHeavyDataDescription.cpp @@ -0,0 +1,88 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfHeavyDataDescription.hpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@us.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2013 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ +#include +#include "XdmfError.hpp" +#include "XdmfHeavyDataDescription.hpp" +#include "XdmfSharedPtr.hpp" +#include "XdmfVisitor.hpp" +#include "string.h" + +shared_ptr +XdmfHeavyDataDescription::New() +{ + shared_ptr p(new XdmfHeavyDataDescription()); + return p; +} + +XdmfHeavyDataDescription::XdmfHeavyDataDescription() +{ +} + +XdmfHeavyDataDescription::XdmfHeavyDataDescription(XdmfHeavyDataDescription & refDescription) : + XdmfItem(refDescription) +{ +} + +XdmfHeavyDataDescription::~XdmfHeavyDataDescription() +{ +} + +const std::string XdmfHeavyDataDescription::ItemTag = "HeavyData"; + +std::map +XdmfHeavyDataDescription::getItemProperties() const +{ + std::map descriptionProperties; + return descriptionProperties; +} + +std::string +XdmfHeavyDataDescription::getItemTag() const +{ + return ItemTag; +} + +void +XdmfHeavyDataDescription::populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader) +{ + XdmfItem::populateItem(itemProperties, childItems, reader); +} + +void +XdmfHeavyDataDescription::traverse(const shared_ptr visitor) +{ + +} + +XDMFHEAVYDATADESCRIPTION * +XdmfHeavyDataDescriptionNew(char * key, char * value) +{ + std::string createKey(key); + std::string createValue(value); + shared_ptr generatedDesc = XdmfHeavyDataDescription::New(); + return (XDMFHEAVYDATADESCRIPTION *)((void *)(new XdmfHeavyDataDescription(*generatedDesc.get()))); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfHeavyDataDescription, XDMFHEAVYDATADESCRIPTION) diff --git a/core/XdmfHeavyDataDescription.hpp b/core/XdmfHeavyDataDescription.hpp new file mode 100644 index 00000000..34935099 --- /dev/null +++ b/core/XdmfHeavyDataDescription.hpp @@ -0,0 +1,112 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfHeavyDataDescription.hpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@us.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2013 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ +#ifndef XDMFHEAVYDATADESCRIPTION_HPP_ +#define XDMFHEAVYDATADESCRIPTION_HPP_ + +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfItem.hpp" + +#ifdef __cplusplus + +/** + * @brief Holds information about a dsm buffer so that a process can connect. + * + * XdmfDescription stores the information required to process + * to a data format + */ +class XDMFCORE_EXPORT XdmfHeavyDataDescription : public XdmfItem { + +public: + + /** + * + */ + static shared_ptr New(); + + virtual ~XdmfHeavyDataDescription(); + + LOKI_DEFINE_VISITABLE(XdmfHeavyDataDescription, XdmfItem) + static const std::string ItemTag; + + std::map getItemProperties() const; + + virtual std::string getItemTag() const; + + std::string getPortDescription() const; + + using XdmfItem::insert; + + void setPortDescription(std::string portDesc); + + virtual void traverse(const shared_ptr visitor); + + XdmfHeavyDataDescription(XdmfHeavyDataDescription &); + +protected: + + XdmfHeavyDataDescription(); + + virtual void + populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader); + +private: + + XdmfHeavyDataDescription(const XdmfHeavyDataDescription &); // Not implemented. + void operator=(const XdmfHeavyDataDescription &); // Not implemented. + + std::string mPortDescription; +}; + +#ifdef _WIN32 +XDMFCORE_TEMPLATE template class XDMFCORE_EXPORT +shared_ptr; +XDMFCORE_TEMPLATE template class XDMFCORE_EXPORT +Loki::Visitor, + shared_ptr >; +#endif + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFHEAVYDATADESCRIPTION; // Simply as a typedef to ensure correct typing +typedef struct XDMFHEAVYDATADESCRIPTION XDMFHEAVYDATADESCRIPTION; + +XDMFCORE_EXPORT XDMFHEAVYDATADESCRIPTION * XdmfHeavyDataDescriptionNew(); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfHeavyDataDescription, XDMFHEAVYDATADESCRIPTION, XDMFCORE) + +#ifdef __cplusplus +} +#endif + +#endif /* XDMFHeavyDataDESCRIPTION_HPP_ */ diff --git a/core/XdmfHeavyDataWriter.cpp b/core/XdmfHeavyDataWriter.cpp index 3f9c013c..09e08a8c 100644 --- a/core/XdmfHeavyDataWriter.cpp +++ b/core/XdmfHeavyDataWriter.cpp @@ -30,6 +30,7 @@ #include #include #include +#include "string.h" XdmfHeavyDataWriter::XdmfHeavyDataWriter(const double compression, const unsigned int overhead) : @@ -139,3 +140,115 @@ XdmfHeavyDataWriter::setReleaseData(const bool releaseData) { mReleaseData = releaseData; } + +// C Wrappers + +void XdmfHeavyDataWriterFree(XDMFHEAVYDATAWRITER * item) +{ + if (item != NULL) { + delete ((XdmfHeavyDataWriter *)item); + item = NULL; + } +} + +int XdmfHeavyDataWriterGetAllowSetSplitting(XDMFHEAVYDATAWRITER * writer) +{ + return ((XdmfHeavyDataWriter *)writer)->getAllowSetSplitting(); +} + +int XdmfHeavyDataWriterGetFileIndex(XDMFHEAVYDATAWRITER * writer) +{ + return ((XdmfHeavyDataWriter *)writer)->getFileIndex(); +} + +unsigned int XdmfHeavyDataWriterGetFileOverhead(XDMFHEAVYDATAWRITER * writer) +{ + return ((XdmfHeavyDataWriter *)writer)->getFileOverhead(); +} + +char * XdmfHeavyDataWriterGetFilePath(XDMFHEAVYDATAWRITER * writer) +{ + try + { + char * returnPointer = strdup(((XdmfHeavyDataWriter *)writer)->getFilePath().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfHeavyDataWriter *)writer)->getFilePath().c_str()); + return returnPointer; + } +} + +int XdmfHeavyDataWriterGetFileSizeLimit(XDMFHEAVYDATAWRITER * writer) +{ + return ((XdmfHeavyDataWriter *)writer)->getFileSizeLimit(); +} + +int XdmfHeavyDataWriterGetMode(XDMFHEAVYDATAWRITER * writer) +{ + XdmfHeavyDataWriter::Mode checkMode = ((XdmfHeavyDataWriter *)writer)->getMode(); + if (checkMode == XdmfHeavyDataWriter::Default) { + return XDMF_HEAVY_WRITER_MODE_DEFAULT; + } + else if (checkMode == XdmfHeavyDataWriter::Overwrite) { + return XDMF_HEAVY_WRITER_MODE_OVERWRITE; + } + else if (checkMode == XdmfHeavyDataWriter::Append) { + return XDMF_HEAVY_WRITER_MODE_APPEND; + } + else if (checkMode == XdmfHeavyDataWriter::Hyperslab) { + return XDMF_HEAVY_WRITER_MODE_HYPERSLAB; + } + return -1; +} + +int XdmfHeavyDataWriterGetReleaseData(XDMFHEAVYDATAWRITER * writer) +{ + return ((XdmfHeavyDataWriter *)writer)->getReleaseData(); +} + +void XdmfHeavyDataWriterSetAllowSetSplitting(XDMFHEAVYDATAWRITER * writer, int newAllow) +{ + ((XdmfHeavyDataWriter *)writer)->setAllowSetSplitting(newAllow); +} + +void XdmfHeavyDataWriterSetFileIndex(XDMFHEAVYDATAWRITER * writer, int newIndex) +{ + ((XdmfHeavyDataWriter *)writer)->setFileIndex(newIndex); +} + +void XdmfHeavyDataWriterSetFileSizeLimit(XDMFHEAVYDATAWRITER * writer, int newSize) +{ + ((XdmfHeavyDataWriter *)writer)->setFileSizeLimit(newSize); +} + +void XdmfHeavyDataWriterSetMode(XDMFHEAVYDATAWRITER * writer, int mode, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfHeavyDataWriter::Mode newMode; + switch (mode) { + case XDMF_HEAVY_WRITER_MODE_DEFAULT: + newMode = XdmfHeavyDataWriter::Default; + break; + case XDMF_HEAVY_WRITER_MODE_OVERWRITE: + newMode = XdmfHeavyDataWriter::Overwrite; + break; + case XDMF_HEAVY_WRITER_MODE_APPEND: + newMode = XdmfHeavyDataWriter::Append; + break; + case XDMF_HEAVY_WRITER_MODE_HYPERSLAB: + newMode = XdmfHeavyDataWriter::Hyperslab; + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid heavy writer mode."); + } + ((XdmfHeavyDataWriter *)writer)->setMode(newMode); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfHeavyDataWriterSetReleaseData(XDMFHEAVYDATAWRITER * writer, int releaseData) +{ + ((XdmfHeavyDataWriter *)writer)->setReleaseData(releaseData); +} diff --git a/core/XdmfHeavyDataWriter.hpp b/core/XdmfHeavyDataWriter.hpp index 8f6e57be..389ebd1b 100644 --- a/core/XdmfHeavyDataWriter.hpp +++ b/core/XdmfHeavyDataWriter.hpp @@ -24,15 +24,18 @@ #ifndef XDMFHEAVYDATAWRITER_HPP_ #define XDMFHEAVYDATAWRITER_HPP_ +#include "XdmfCore.hpp" +#include "XdmfArrayType.hpp" +#include "XdmfHeavyDataController.hpp" +#include "XdmfVisitor.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfArray; // Includes #include -#include "XdmfCore.hpp" -#include "XdmfArrayType.hpp" -#include "XdmfHeavyDataController.hpp" -#include "XdmfVisitor.hpp" #include /** @@ -476,9 +479,15 @@ protected: XdmfHeavyDataWriter(const std::string & filePath, const double compression = 1, const unsigned int overhead = 0); virtual shared_ptr - createController(const shared_ptr & refController) = 0; + createController(const std::string & filePath, + const std::string & descriptor, + const shared_ptr type, + const std::vector & start, + const std::vector & stride, + const std::vector & dimensions, + const std::vector & dataspaceDimensions) = 0; - virtual int getDataSetSize(const std::string & fileName, const std::string & dataSetName, const int fapl) = 0; + virtual int getDataSetSize(shared_ptr descriptionController) = 0; bool mAllowSplitDataSets; int mDataSetId; @@ -492,9 +501,140 @@ protected: private: - XdmfHeavyDataWriter(const XdmfHeavyDataWriter &); // Not implemented. + XdmfHeavyDataWriter(const XdmfHeavyDataWriter &); // Not implemented. void operator=(const XdmfHeavyDataWriter &); // Not implemented. }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct XDMFHEAVYDATAWRITER; // Simply as a typedef to ensure correct typing +typedef struct XDMFHEAVYDATAWRITER XDMFHEAVYDATAWRITER; + +#define XDMF_HEAVY_WRITER_MODE_DEFAULT 20 +#define XDMF_HEAVY_WRITER_MODE_OVERWRITE 21 +#define XDMF_HEAVY_WRITER_MODE_APPEND 22 +#define XDMF_HEAVY_WRITER_MODE_HYPERSLAB 23 + +// C wrappers go here + +XDMFCORE_EXPORT void XdmfHeavyDataWriterFree(XDMFHEAVYDATAWRITER * item); + +XDMFCORE_EXPORT int XdmfHeavyDataWriterGetAllowSetSplitting(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT int XdmfHeavyDataWriterGetFileIndex(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT unsigned int XdmfHeavyDataWriterGetFileOverhead(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT char * XdmfHeavyDataWriterGetFilePath(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT int XdmfHeavyDataWriterGetFileSizeLimit(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT int XdmfHeavyDataWriterGetMode(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT int XdmfHeavyDataWriterGetReleaseData(XDMFHEAVYDATAWRITER * writer); + +XDMFCORE_EXPORT void XdmfHeavyDataWriterSetAllowSetSplitting(XDMFHEAVYDATAWRITER * writer, int newAllow); + +XDMFCORE_EXPORT void XdmfHeavyDataWriterSetFileIndex(XDMFHEAVYDATAWRITER * writer, int newIndex); + +XDMFCORE_EXPORT void XdmfHeavyDataWriterSetFileSizeLimit(XDMFHEAVYDATAWRITER * writer, int newSize); + +XDMFCORE_EXPORT void XdmfHeavyDataWriterSetMode(XDMFHEAVYDATAWRITER * writer, int mode, int * status); + +XDMFCORE_EXPORT void XdmfHeavyDataWriterSetReleaseData(XDMFHEAVYDATAWRITER * writer, int releaseData); + +#define XDMF_HEAVYWRITER_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT void ClassName##Free( CClassName * item); \ +Level##_EXPORT int ClassName##GetAllowSetSplitting( CClassName * writer); \ +Level##_EXPORT int ClassName##GetFileIndex( CClassName * writer); \ +Level##_EXPORT unsigned int ClassName##GetFileOverhead( CClassName * writer); \ +Level##_EXPORT char * ClassName##GetFilePath( CClassName * writer); \ +Level##_EXPORT int ClassName##GetFileSizeLimit( CClassName * writer); \ +Level##_EXPORT int ClassName##GetMode( CClassName * writer); \ +Level##_EXPORT int ClassName##GetReleaseData( CClassName * writer); \ +Level##_EXPORT void ClassName##SetAllowSetSplitting( CClassName * writer, int newAllow); \ +Level##_EXPORT void ClassName##SetFileIndex( CClassName * writer, int newIndex); \ +Level##_EXPORT void ClassName##SetFileSizeLimit( CClassName * writer, int newSize); \ +Level##_EXPORT void ClassName##SetMode( CClassName * writer, int mode, int * status); \ +Level##_EXPORT void ClassName##SetReleaseData( CClassName * writer, int releaseData); + + + +#define XDMF_HEAVYWRITER_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +void ClassName##Free( CClassName * item) \ +{ \ + XdmfHeavyDataWriterFree((XDMFHEAVYDATAWRITER *)((void *)item)); \ +} \ + \ +int ClassName##GetAllowSetSplitting( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetAllowSetSplitting((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +int ClassName##GetFileIndex( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetFileIndex((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +unsigned int ClassName##GetFileOverhead( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetFileOverhead((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +char * ClassName##GetFilePath( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetFilePath((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +int ClassName##GetFileSizeLimit( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetFileSizeLimit((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +int ClassName##GetMode( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetMode((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +int ClassName##GetReleaseData( CClassName * writer) \ +{ \ + return XdmfHeavyDataWriterGetReleaseData((XDMFHEAVYDATAWRITER *)((void *)writer)); \ +} \ + \ +void ClassName##SetAllowSetSplitting( CClassName * writer, int newAllow) \ +{ \ + XdmfHeavyDataWriterSetAllowSetSplitting((XDMFHEAVYDATAWRITER *)((void *)writer), newAllow); \ +} \ + \ +void ClassName##SetFileIndex( CClassName * writer, int newIndex) \ +{ \ + XdmfHeavyDataWriterSetFileIndex((XDMFHEAVYDATAWRITER *)((void *)writer), newIndex); \ +} \ + \ +void ClassName##SetFileSizeLimit( CClassName * writer, int newSize) \ +{ \ + XdmfHeavyDataWriterSetFileSizeLimit((XDMFHEAVYDATAWRITER *)((void *)writer), newSize); \ +} \ + \ +void ClassName##SetMode( CClassName * writer, int mode, int * status) \ +{ \ + XdmfHeavyDataWriterSetMode((XDMFHEAVYDATAWRITER *)((void *)writer), mode, status); \ +} \ + \ +void ClassName##SetReleaseData( CClassName * writer, int releaseData) \ +{ \ + XdmfHeavyDataWriterSetReleaseData((XDMFHEAVYDATAWRITER *)((void *)writer), releaseData); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFHEAVYDATAWRITER_HPP_ */ diff --git a/core/XdmfInformation.cpp b/core/XdmfInformation.cpp index d0d4b71e..050ac5f0 100644 --- a/core/XdmfInformation.cpp +++ b/core/XdmfInformation.cpp @@ -22,6 +22,7 @@ /*****************************************************************************/ #include +#include "string.h" #include "XdmfArray.hpp" #include "XdmfError.hpp" #include "XdmfInformation.hpp" @@ -50,6 +51,14 @@ XdmfInformation::XdmfInformation(const std::string & key, { } +XdmfInformation::XdmfInformation(XdmfInformation & refInfo) : + XdmfItem(refInfo), + mArrays(refInfo.mArrays) +{ + mKey = refInfo.getKey(); + mValue = refInfo.getValue(); +} + XdmfInformation::~XdmfInformation() { } @@ -131,22 +140,138 @@ void XdmfInformation::setKey(const std::string & key) { mKey = key; + this->setIsChanged(true); } void XdmfInformation::setValue(const std::string & value) { mValue = value; + this->setIsChanged(true); } void XdmfInformation::traverse(const shared_ptr visitor) { XdmfItem::traverse(visitor); - for(std::vector >::const_iterator iter = - mArrays.begin(); - iter != mArrays.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mArrays.size(); ++i) + { + mArrays[i]->accept(visitor); + } +} + +// C Wrappers + +XDMFINFORMATION * +XdmfInformationNew(char * key, char * value) +{ + try + { + std::string createKey(key); + std::string createValue(value); + shared_ptr generatedInfo = XdmfInformation::New(createKey, createValue); + return (XDMFINFORMATION *)((void *)(new XdmfInformation(*generatedInfo.get()))); + } + catch (...) + { + std::string createKey(key); + std::string createValue(value); + shared_ptr generatedInfo = XdmfInformation::New(createKey, createValue); + return (XDMFINFORMATION *)((void *)(new XdmfInformation(*generatedInfo.get()))); + } +} + +XDMFARRAY * +XdmfInformationGetArray(XDMFINFORMATION * information, unsigned int index) +{ + return (XDMFARRAY *)((void *)(((XdmfInformation *)(information))->getArray(index).get())); +} + +XDMFARRAY * +XdmfInformationGetArrayByName(XDMFINFORMATION * information, char * name) +{ + return (XDMFARRAY *)((void *)(((XdmfInformation *)(information))->getArray(name).get())); +} + +char * +XdmfInformationGetKey(XDMFINFORMATION * information) +{ + try + { + XdmfInformation referenceInfo = *(XdmfInformation *)(information); + char * returnPointer = strdup(referenceInfo.getKey().c_str()); + return returnPointer; + } + catch (...) + { + XdmfInformation referenceInfo = *(XdmfInformation *)(information); + char * returnPointer = strdup(referenceInfo.getKey().c_str()); + return returnPointer; + } +} + +unsigned int +XdmfInformationGetNumberArrays(XDMFINFORMATION * information) +{ + return ((XdmfInformation *)(information))->getNumberArrays(); +} + +char * +XdmfInformationGetValue(XDMFINFORMATION * information) +{ + try + { + XdmfInformation referenceInfo = *(XdmfInformation *)(information); + char * returnPointer = strdup(referenceInfo.getValue().c_str()); + return returnPointer; + } + catch (...) + { + XdmfInformation referenceInfo = *(XdmfInformation *)(information); + char * returnPointer = strdup(referenceInfo.getValue().c_str()); + return returnPointer; + } +} + +void +XdmfInformationInsertArray(XDMFINFORMATION * information, XDMFARRAY * array, int transferOwnership) +{ + if (transferOwnership) { + ((XdmfInformation *)(information))->insert(shared_ptr((XdmfArray *)array)); + } + else { + ((XdmfInformation *)(information))->insert(shared_ptr((XdmfArray *)array, XdmfNullDeleter())); } } + +void +XdmfInformationRemoveArray(XDMFINFORMATION * information, unsigned int index) +{ + ((XdmfInformation *)(information))->removeArray(index); +} + +void +XdmfInformationRemoveArrayByName(XDMFINFORMATION * information, char * name) +{ + ((XdmfInformation *)(information))->removeArray(name); +} + +void +XdmfInformationSetKey(XDMFINFORMATION * information, char * key, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfInformation *)(information))->setKey(key); + XDMF_ERROR_WRAP_END(status) +} + +void +XdmfInformationSetValue(XDMFINFORMATION * information, char * value, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfInformation *)(information))->setValue(value); + XDMF_ERROR_WRAP_END(status) +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfInformation, XDMFINFORMATION) diff --git a/core/XdmfInformation.hpp b/core/XdmfInformation.hpp index 16be73d2..1631fe9f 100644 --- a/core/XdmfInformation.hpp +++ b/core/XdmfInformation.hpp @@ -24,12 +24,15 @@ #ifndef XDMFINFORMATION_HPP_ #define XDMFINFORMATION_HPP_ -// Forward declarations -class XdmfArray; - -// Includes +// C Compatible Includes #include "XdmfCore.hpp" #include "XdmfItem.hpp" +#include "XdmfArray.hpp" + +#ifdef __cplusplus + +// Forward declarations +class XdmfArray; /** * @brief Holds a key/value pair that can be attached to an Xdmf @@ -204,6 +207,8 @@ public: virtual void traverse(const shared_ptr visitor); + XdmfInformation(XdmfInformation &); + protected: XdmfInformation(const std::string & key = "", @@ -216,7 +221,7 @@ protected: private: - XdmfInformation(const XdmfInformation &); // Not implemented. + XdmfInformation(const XdmfInformation &); void operator=(const XdmfInformation &); // Not implemented. std::string mKey; @@ -231,4 +236,48 @@ Loki::Visitor, shared_ptr >; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#ifndef XDMFINFORMATIONCDEFINE +#define XDMFINFORMATIONCDEFINE +struct XDMFINFORMATION; // Simply as a typedef to ensure correct typing +typedef struct XDMFINFORMATION XDMFINFORMATION; +#endif + +XDMFCORE_EXPORT XDMFINFORMATION * XdmfInformationNew(char * key, char * value); + +XDMFCORE_EXPORT XDMFARRAY * XdmfInformationGetArray(XDMFINFORMATION * information, unsigned int index); + +XDMFCORE_EXPORT XDMFARRAY * XdmfInformationGetArrayByName(XDMFINFORMATION * information, char * name); + +XDMFCORE_EXPORT char * XdmfInformationGetKey(XDMFINFORMATION * information); + +XDMFCORE_EXPORT unsigned int XdmfInformationGetNumberArrays(XDMFINFORMATION * information); + +XDMFCORE_EXPORT char * XdmfInformationGetValue(XDMFINFORMATION * information); + +XDMFCORE_EXPORT void XdmfInformationInsertArray(XDMFINFORMATION * information, XDMFARRAY * array, int transferOwnership); + +XDMFCORE_EXPORT void XdmfInformationRemoveArray(XDMFINFORMATION * information, unsigned int index); + +XDMFCORE_EXPORT void XdmfInformationRemoveArrayByName(XDMFINFORMATION * information, char * name); + +XDMFCORE_EXPORT void XdmfInformationSetKey(XDMFINFORMATION * information, char * key, int * status); + +XDMFCORE_EXPORT void XdmfInformationSetValue(XDMFINFORMATION * information, char * value, int * status); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfInformation, XDMFINFORMATION, XDMFCORE) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFINFORMATION_HPP_ */ diff --git a/core/XdmfItem.cpp b/core/XdmfItem.cpp index 6cba7d5d..38c0dfd5 100644 --- a/core/XdmfItem.cpp +++ b/core/XdmfItem.cpp @@ -23,10 +23,20 @@ #include "XdmfInformation.hpp" #include "XdmfItem.hpp" +#include "XdmfVisitor.hpp" +#include "XdmfError.hpp" +#include "string.h" XDMF_CHILDREN_IMPLEMENTATION(XdmfItem, XdmfInformation, Information, Key) -XdmfItem::XdmfItem() +XdmfItem::XdmfItem() : + mIsChanged(true) +{ +} + +XdmfItem::XdmfItem(XdmfItem &refItem) : + mInformations(refItem.mInformations), + mIsChanged(true) { } @@ -34,6 +44,32 @@ XdmfItem::~XdmfItem() { } +bool +XdmfItem::getIsChanged() +{ + return mIsChanged; +} + +void +XdmfItem::setIsChanged(bool status) +{ + // No change if status is the same + if (mIsChanged != status) + { + mIsChanged = status; + // If it was changed all parents should be alerted + if (status) + { + for (std::set::iterator iter = mParents.begin(); + iter != mParents.end(); + ++iter) + { + (*iter)->setIsChanged(status); + } + } + } +} + void XdmfItem::populateItem(const std::map &, const std::vector > & childItems, @@ -53,10 +89,67 @@ XdmfItem::populateItem(const std::map &, void XdmfItem::traverse(const shared_ptr visitor) { - for(std::vector >::const_iterator iter = - mInformations.begin(); - iter != mInformations.end(); - ++iter) { - (*iter)->accept(visitor); + for (unsigned int i = 0; i < mInformations.size(); ++i) + { + mInformations[i]->accept(visitor); + } +} + +// C Wrappers + +void XdmfItemAccept(XDMFITEM * item, XDMFVISITOR * visitor, int * status) +{ + XDMF_ERROR_WRAP_START(status) + shared_ptr visitPointer((XdmfVisitor *)visitor, XdmfNullDeleter()); + ((XdmfItem *)(item))->accept(visitPointer); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfItemFree(void * item) +{ + if (item != NULL) { + delete ((XdmfItem *)item); + item = NULL; + } +} + +XDMFINFORMATION * XdmfItemGetInformation(XDMFITEM * item, unsigned int index) +{ + return (XDMFINFORMATION *)((void *)(((XdmfItem *)(item))->getInformation(index).get())); +} + +XDMFINFORMATION * XdmfItemGetInformationByKey(XDMFITEM * item, char * key) +{ + return (XDMFINFORMATION *)((void *)(((XdmfItem *)(item))->getInformation(key).get())); +} + +unsigned int XdmfItemGetNumberInformations(XDMFITEM * item) +{ + return ((XdmfItem *)(item))->getNumberInformations(); +} + +void XdmfItemInsertInformation(XDMFITEM * item, XDMFINFORMATION * information, int passControl) +{ + if (passControl == 0) { + ((XdmfItem *)(item))->insert(shared_ptr((XdmfInformation *)information, XdmfNullDeleter())); + } + else { + ((XdmfItem *)(item))->insert(shared_ptr((XdmfInformation *)information)); } } + +void XdmfItemRemoveInformation(XDMFITEM * item, unsigned int index) +{ + ((XdmfItem *)(item))->removeInformation(index); +} + +void XdmfItemRemoveInformationByKey(XDMFITEM * item, char * key) +{ + ((XdmfItem *)(item))->removeInformation(std::string(key)); +} + +char * XdmfItemGetItemTag(XDMFITEM * item) +{ + char * returnPointer = strdup(((XdmfItem *)(item))->getItemTag().c_str()); + return returnPointer; +} diff --git a/core/XdmfItem.hpp b/core/XdmfItem.hpp index 4167531e..c9b01aeb 100644 --- a/core/XdmfItem.hpp +++ b/core/XdmfItem.hpp @@ -24,6 +24,12 @@ #ifndef XDMFITEM_HPP_ #define XDMFITEM_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfVisitor.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfCoreReader; class XdmfInformation; @@ -31,10 +37,13 @@ class XdmfVisitor; // Includes #include +#define vtk_libxml2_reference reference // Reversing VTK name mangling +#include +#include #include +#include #include #include -#include "XdmfCore.hpp" #include "XdmfSharedPtr.hpp" // Macro that allows children XdmfItems to be attached to a parent XdmfItem. @@ -242,6 +251,7 @@ public : ParentClass::insert(const shared_ptr ChildName) \ { \ m##ChildName##s.push_back(ChildName); \ + this->setIsChanged(true); \ } \ \ void \ @@ -250,6 +260,7 @@ public : if(index < m##ChildName##s.size()) { \ m##ChildName##s.erase(m##ChildName##s.begin() + index); \ } \ + this->setIsChanged(true); \ } \ \ void \ @@ -264,6 +275,7 @@ public : return; \ } \ } \ + this->setIsChanged(true); \ } /** @@ -283,6 +295,9 @@ public: LOKI_DEFINE_VISITABLE_BASE() XDMF_CHILDREN(XdmfItem, XdmfInformation, Information, Key) friend class XdmfCoreReader; + friend class XdmfWriter; + friend class XdmfHeavyDataWriter; + friend class XdmfHDF5Writer; /** * Get the tag for this item. This is equivalent to tags in XML @@ -361,6 +376,8 @@ public: */ virtual void traverse(const shared_ptr visitor); + XdmfItem(XdmfItem &); + protected: XdmfItem(); @@ -381,6 +398,16 @@ protected: const std::vector > & childItems, const XdmfCoreReader * const reader); + bool + getIsChanged(); + + void + setIsChanged(bool status); + + std::set mParents; + + bool mIsChanged; + private: XdmfItem(const XdmfItem &); // Not implemented. @@ -406,4 +433,102 @@ XDMFCORE_TEMPLATE template class XDMFCORE_EXPORT Loki::BaseVisitable; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFITEM; // Simply as a typedef to ensure correct typing +typedef struct XDMFITEM XDMFITEM; + +#ifndef XDMFINFORMATIONCDEFINE +#define XDMFINFORMATIONCDEFINE +struct XDMFINFORMATION; // Simply as a typedef to ensure correct typing +typedef struct XDMFINFORMATION XDMFINFORMATION; +#endif + +XDMFCORE_EXPORT void XdmfItemAccept(XDMFITEM * item, XDMFVISITOR * visitor, int * status); + +XDMFCORE_EXPORT void XdmfItemFree(void * item); + +XDMFCORE_EXPORT XDMFINFORMATION * XdmfItemGetInformation(XDMFITEM * item, unsigned int index); + +XDMFCORE_EXPORT XDMFINFORMATION * XdmfItemGetInformationByKey(XDMFITEM * item, char * key); + +XDMFCORE_EXPORT unsigned int XdmfItemGetNumberInformations(XDMFITEM * item); + +XDMFCORE_EXPORT void XdmfItemInsertInformation(XDMFITEM * item, XDMFINFORMATION * information, int passControl); + +XDMFCORE_EXPORT void XdmfItemRemoveInformation(XDMFITEM * item, unsigned int index); + +XDMFCORE_EXPORT void XdmfItemRemoveInformationByKey(XDMFITEM * item, char * key); + +XDMFCORE_EXPORT char * XdmfItemGetItemTag(XDMFITEM * item); + +#define XDMF_ITEM_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT void ClassName##Accept ( CClassName * item, XDMFVISITOR * visitor, int * status); \ +XDMFCORE_EXPORT void ClassName##Free(void * item); \ +Level##_EXPORT XDMFINFORMATION * ClassName##GetInformation( CClassName * item, unsigned int index); \ +Level##_EXPORT XDMFINFORMATION * ClassName##GetInformationByKey( CClassName * item, char * key); \ +Level##_EXPORT unsigned int ClassName##GetNumberInformations( CClassName * item); \ +Level##_EXPORT void ClassName##InsertInformation( CClassName * item, XDMFINFORMATION * information, int passControl); \ +Level##_EXPORT void ClassName##RemoveInformation( CClassName * item, unsigned int index); \ +Level##_EXPORT void ClassName##RemoveInformationByKey( CClassName * item, char * key); \ +Level##_EXPORT char * ClassName##GetItemTag( CClassName * item); + + +#define XDMF_ITEM_C_CHILD_WRAPPER(ClassName, CClassName) \ +void ClassName##Accept( CClassName * item, XDMFVISITOR * visitor, int * status) \ +{ \ + XdmfItemAccept(((XDMFITEM *)item), visitor, status); \ +} \ + \ +void ClassName##Free(void * item) \ +{ \ + XdmfItemFree(item); \ +} \ + \ +XDMFINFORMATION * ClassName##GetInformation( CClassName * item, unsigned int index) \ +{ \ + return XdmfItemGetInformation(((XDMFITEM *)item), index); \ +} \ + \ +XDMFINFORMATION * ClassName##GetInformationByKey( CClassName * item, char * key) \ +{ \ + return XdmfItemGetInformationByKey(((XDMFITEM *)item), key); \ +} \ + \ +unsigned int ClassName##GetNumberInformations( CClassName * item) \ +{ \ + return XdmfItemGetNumberInformations(((XDMFITEM *)item)); \ +} \ + \ +void ClassName##InsertInformation( CClassName * item, XDMFINFORMATION * information, int passControl) \ +{ \ + XdmfItemInsertInformation(((XDMFITEM *)item), information, passControl); \ +} \ + \ +void ClassName##RemoveInformation( CClassName * item, unsigned int index) \ +{ \ + XdmfItemRemoveInformation(((XDMFITEM *)item), index); \ +} \ + \ +void ClassName##RemoveInformationByKey( CClassName * item, char * key) \ +{ \ + XdmfItemRemoveInformationByKey(((XDMFITEM *)item), key); \ +} \ + \ +char * ClassName##GetItemTag( CClassName * item) \ +{ \ + return XdmfItemGetItemTag(((XDMFITEM *)item)); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFITEM_HPP_ */ diff --git a/core/XdmfItemProperty.cpp b/core/XdmfItemProperty.cpp index b6091c54..d3d46bd6 100644 --- a/core/XdmfItemProperty.cpp +++ b/core/XdmfItemProperty.cpp @@ -22,6 +22,57 @@ /*****************************************************************************/ #include "XdmfItemProperty.hpp" +#include + +const std::map XdmfItemProperty::UpperConversionMap = + boost::assign::map_list_of ('a', 'A') + ('b', 'B') + ('c', 'C') + ('d', 'D') + ('e', 'E') + ('f', 'F') + ('g', 'G') + ('h', 'H') + ('i', 'I') + ('j', 'J') + ('k', 'K') + ('l', 'L') + ('m', 'M') + ('n', 'N') + ('o', 'O') + ('p', 'P') + ('q', 'Q') + ('r', 'R') + ('s', 'S') + ('t', 'T') + ('u', 'U') + ('v', 'V') + ('w', 'W') + ('x', 'X') + ('y', 'Y') + ('z', 'Z'); + +// Using this method because ANSI and std transform aren't guarenteed +std::string +XdmfItemProperty::ConvertToUpper(const std::string & converted) +{ + std::string returnstring; + returnstring.resize(converted.size()); + std::map::const_iterator characterConversion; + for (unsigned int i = 0; i < converted.size(); ++i) + { + characterConversion = UpperConversionMap.find(converted[i]); + if (characterConversion != UpperConversionMap.end()) + { + returnstring[i] = characterConversion->second; + } + else + { + returnstring[i] = converted[i]; + } + } + return returnstring; +} XdmfItemProperty::XdmfItemProperty() { diff --git a/core/XdmfItemProperty.hpp b/core/XdmfItemProperty.hpp index e9a054dc..9a1bd86e 100644 --- a/core/XdmfItemProperty.hpp +++ b/core/XdmfItemProperty.hpp @@ -24,6 +24,8 @@ #ifndef XDMFITEMPROPERTY_HPP_ #define XDMFITEMPROPERTY_HPP_ +#ifdef __cplusplus + // Includes #include #include @@ -74,6 +76,10 @@ protected: XdmfItemProperty(); + static std::string ConvertToUpper(const std::string & converted); + + static const std::map UpperConversionMap; + private: XdmfItemProperty(const XdmfItemProperty &); // Not implemented. @@ -81,4 +87,6 @@ private: }; +#endif + #endif /* XDMFITEMPROPERTY_HPP_ */ diff --git a/core/XdmfPlaceholder.cpp b/core/XdmfPlaceholder.cpp new file mode 100644 index 00000000..0ee885a8 --- /dev/null +++ b/core/XdmfPlaceholder.cpp @@ -0,0 +1,224 @@ +/*****************************************************************************/ +/* Xdmf */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfPlaceholder.cpp */ +/* */ +/* Author: */ +/* Andrew Burns */ +/* andrew.j.burns2@us.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2014 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#include +#include +#include "XdmfArray.hpp" +#include "XdmfArrayType.hpp" +#include "XdmfError.hpp" +#include "XdmfHeavyDataDescription.hpp" +#include "XdmfPlaceholder.hpp" +#include "XdmfSystemUtils.hpp" +#include "string.h" + +shared_ptr +XdmfPlaceholder::New(const std::string & filePath, + const shared_ptr type, + const std::vector & start, + const std::vector & stride, + const std::vector & dimensions, + const std::vector & dataspaceDimensions) +{ + shared_ptr + p(new XdmfPlaceholder(filePath, + type, + start, + stride, + dimensions, + dataspaceDimensions)); + return p; +} + +XdmfPlaceholder::XdmfPlaceholder(const std::string & filePath, + const shared_ptr type, + const std::vector & start, + const std::vector & stride, + const std::vector & dimensions, + const std::vector & dataspaceDimensions) : + XdmfHeavyDataController(filePath, + type, + start, + stride, + dimensions, + dataspaceDimensions) +{ +} + +XdmfPlaceholder::XdmfPlaceholder(const XdmfPlaceholder & refController): + XdmfHeavyDataController(refController) +{ +} + +XdmfPlaceholder::~XdmfPlaceholder() +{ +} + +shared_ptr +XdmfPlaceholder::createSubController(const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions) +{ + return XdmfPlaceholder::New(mFilePath, + mType, + starts, + strides, + dimensions, + mDataspaceDimensions); +} + +std::string +XdmfPlaceholder::getDescriptor() const +{ + return ""; +} + +shared_ptr +XdmfPlaceholder::getHeavyDataDescription() +{ + static shared_ptr p = shared_ptr(); + return p; +} + +std::string +XdmfPlaceholder::getName() const +{ + return "Placeholder"; +} + +void +XdmfPlaceholder::getProperties(std::map & collectedProperties) const +{ + collectedProperties["Format"] = this->getName(); +} + +void +XdmfPlaceholder::read(XdmfArray * const array) +{ + array->initialize(this->getType(), this->getDimensions()); +} + +// C Wrappers + +XDMFPLACEHOLDER * XdmfPlaceholderNew(char * hdf5FilePath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfPlaceholder::New(std::string(hdf5FilePath), buildType, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFPLACEHOLDER *)((void *)(new XdmfPlaceholder(*generatedController.get()))); + } + catch (...) + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfPlaceholder::New(std::string(hdf5FilePath), buildType, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFPLACEHOLDER *)((void *)(new XdmfPlaceholder(*generatedController.get()))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +// C Wrappers for parent classes are generated by macros + +XDMF_HEAVYCONTROLLER_C_CHILD_WRAPPER(XdmfPlaceholder, XDMFPLACEHOLDER) diff --git a/core/XdmfPlaceholder.hpp b/core/XdmfPlaceholder.hpp new file mode 100644 index 00000000..4988dca5 --- /dev/null +++ b/core/XdmfPlaceholder.hpp @@ -0,0 +1,156 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfPlaceholder.hpp */ +/* */ +/* Author: */ +/* Kenneth Leiter */ +/* kenneth.leiter@arl.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2011 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#ifndef XDMFPLACEHOLDER_HPP_ +#define XDMFPLACEHOLDER_HPP_ + +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfHeavyDataController.hpp" + +#ifdef __cplusplus + +#include + +/** + * @brief Couples an XdmfArray with an array structure. + * + * Takes the place of a heavy data set. Allows an array to define + * its structure without having to have an associated dataset. + */ +class XDMFCORE_EXPORT XdmfPlaceholder : public XdmfHeavyDataController { + +public: + + virtual ~XdmfPlaceholder(); + + /** + * Create a new placeholder to define array structure. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfPlaceholder.cpp + * @skipline //#initialization + * @until //#initialization + * + * Python + * + * @dontinclude XdmfExamplePlaceholder.py + * @skipline #//initialization + * @until #//initialization + * + * @param filePath The location of the file the data set resides in. + * @param type The data type of the dataset to read. + * @param start The offset of the starting element in each + * dimension in the data set. + * @param stride The number of elements to move in each + * dimension from the data set. + * @param dimensions The number of elements to select in each + * dimension from the data set. + * (size in each dimension) + * @param dataspaceDimensions The number of elements in the entire + * data set (may be larger than + * dimensions if using hyperslabs). + * + * @return New Placeholder. + */ + static shared_ptr + New(const std::string & FilePath, + const shared_ptr type, + const std::vector & start, + const std::vector & stride, + const std::vector & dimensions, + const std::vector & dataspaceDimensions); + + virtual std::string getDescriptor() const; + + virtual std::string getName() const; + + virtual void + getProperties(std::map & collectedProperties) const; + + virtual void read(XdmfArray * const array); + + XdmfPlaceholder(const XdmfPlaceholder &); + +protected: + + XdmfPlaceholder(const std::string & filePath, + const shared_ptr type, + const std::vector & start, + const std::vector & stride, + const std::vector & dimensions, + const std::vector & dataspaceDimensions); + + shared_ptr + createSubController(const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions); + + virtual shared_ptr + getHeavyDataDescription(); + + void read(XdmfArray * const array, const int fapl); + +private: + + void operator=(const XdmfPlaceholder &); // Not implemented. +}; + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct XDMFPLACEHOLDER; // Simply as a typedef to ensure correct typing +typedef struct XDMFPLACEHOLDER XDMFPLACEHOLDER; + +XDMFCORE_EXPORT XDMFPLACEHOLDER * XdmfPlaceholderNew(char * hdf5FilePath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + int * status); + +// C Wrappers for parent classes are generated by macros + +/* +XDMFCORE_EXPORT unsigned int * XdmfPlaceholderGetDataspaceDimensions(XDMFPLACEHOLDER * controller); + +XDMFCORE_EXPORT unsigned int * XdmfPlaceholderGetStart(XDMFPLACEHOLDER * controller); + +XDMFCORE_EXPORT unsigned int * XdmfPlaceholderGetStride(XDMFPLACEHOLDER * controller); +*/ + +XDMF_HEAVYCONTROLLER_C_CHILD_DECLARE(XdmfPlaceholder, XDMFPLACEHOLDER, XDMFCORE) + +#ifdef __cplusplus +} +#endif + +#endif /* XDMFPLACEHOLDER_HPP_ */ diff --git a/core/XdmfSharedPtr.hpp b/core/XdmfSharedPtr.hpp index b5934e2f..a499f8a3 100644 --- a/core/XdmfSharedPtr.hpp +++ b/core/XdmfSharedPtr.hpp @@ -24,6 +24,8 @@ #ifndef XDMFSHAREDPTR_HPP_ #define XDMFSHAREDPTR_HPP_ +#ifdef __cplusplus + #include "XdmfConfig.hpp" #include @@ -45,4 +47,15 @@ shared_ptr shared_dynamic_cast(shared_ptr const & r) #endif /* HAVE_BOOST_SHARED_DYNAMIC_CAST */ +// Used by C wrappers to prevent shared pointers from prematurely deleting objects +// Normally this would be completely against the point of shared pointers, +// but the C wrapping requires that objects be seperated from the shared pointers. +struct XdmfNullDeleter +{ +template +void operator()(T*) {} +}; + +#endif + #endif /* XDMFSHAREDPTR_HPP_ */ diff --git a/core/XdmfSparseMatrix.cpp b/core/XdmfSparseMatrix.cpp index 4f057d1b..8276cc66 100644 --- a/core/XdmfSparseMatrix.cpp +++ b/core/XdmfSparseMatrix.cpp @@ -22,8 +22,8 @@ /*****************************************************************************/ #include - #include +#include "string.h" #include "XdmfSparseMatrix.hpp" #include "XdmfError.hpp" @@ -48,6 +48,17 @@ XdmfSparseMatrix::XdmfSparseMatrix(const unsigned int numberRows, mRowPointer->resize(mNumberRows + 1, 0); } +XdmfSparseMatrix::XdmfSparseMatrix(XdmfSparseMatrix & matrixRef) : + XdmfItem(matrixRef), + mColumnIndex(matrixRef.getColumnIndex()), + mName(matrixRef.getName()), + mNumberColumns(matrixRef.getNumberColumns()), + mNumberRows(matrixRef.getNumberRows()), + mRowPointer(matrixRef.getRowPointer()), + mValues(matrixRef.getValues()) +{ +} + XdmfSparseMatrix::~XdmfSparseMatrix() { } @@ -214,24 +225,28 @@ void XdmfSparseMatrix::setColumnIndex(const shared_ptr columnIndex) { mColumnIndex = columnIndex; + this->setIsChanged(true); } void XdmfSparseMatrix::setName(const std::string & name) { mName = name; + this->setIsChanged(true); } void XdmfSparseMatrix::setRowPointer(const shared_ptr rowPointer) { mRowPointer = rowPointer; + this->setIsChanged(true); } void XdmfSparseMatrix::setValues(const shared_ptr values) { mValues = values; + this->setIsChanged(true); } void @@ -242,3 +257,131 @@ XdmfSparseMatrix::traverse(const shared_ptr visitor) mColumnIndex->accept(visitor); mValues->accept(visitor); } + +// C Wrappers + +XDMFSPARSEMATRIX * XdmfSparseMatrixNew(unsigned int numberRows, unsigned int numberColumns) +{ + try + { + shared_ptr generatedMatrix = XdmfSparseMatrix::New(numberRows, numberColumns); + return (XDMFSPARSEMATRIX *)((void *)(new XdmfSparseMatrix(*generatedMatrix.get()))); + } + catch (...) + { + shared_ptr generatedMatrix = XdmfSparseMatrix::New(numberRows, numberColumns); + return (XDMFSPARSEMATRIX *)((void *)(new XdmfSparseMatrix(*generatedMatrix.get()))); + } +} + +XDMFARRAY * XdmfSparseMatrixGetColumnIndex(XDMFSPARSEMATRIX * matrix, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return (XDMFARRAY *)((void *)(((XdmfSparseMatrix *)(matrix))->getColumnIndex().get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +char * XdmfSparseMatrixGetName(XDMFSPARSEMATRIX * matrix) +{ + try + { + char * returnPointer= strdup(((XdmfSparseMatrix *)(matrix))->getName().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer= strdup(((XdmfSparseMatrix *)(matrix))->getName().c_str()); + return returnPointer; + } +} + +unsigned int XdmfSparseMatrixGetNumberColumns(XDMFSPARSEMATRIX * matrix) +{ + return ((XdmfSparseMatrix *)matrix)->getNumberColumns(); +} + +unsigned int XdmfSparseMatrixGetNumberRows(XDMFSPARSEMATRIX * matrix) +{ + return ((XdmfSparseMatrix *)matrix)->getNumberRows(); +} + +XDMFARRAY * XdmfSparseMatrixGetRowPointer(XDMFSPARSEMATRIX * matrix, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return (XDMFARRAY *)((void *)(((XdmfSparseMatrix *)(matrix))->getRowPointer().get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFARRAY * XdmfSparseMatrixGetValues(XDMFSPARSEMATRIX * matrix, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return (XDMFARRAY *)((void *)(((XdmfSparseMatrix *)(matrix))->getValues().get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +char * XdmfSparseMatrixGetValuesString(XDMFSPARSEMATRIX * matrix, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + char * returnPointer = strdup(((XdmfSparseMatrix *)(matrix))->getValuesString().c_str()); + return returnPointer; + } + catch (...) + { + char * returnPointer = strdup(((XdmfSparseMatrix *)(matrix))->getValuesString().c_str()); + return returnPointer; + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +void XdmfSparseMatrixSetColumnIndex(XDMFSPARSEMATRIX * matrix, XDMFARRAY * columnIndex, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + if (passControl) { + ((XdmfSparseMatrix *)(matrix))->setColumnIndex(shared_ptr((XdmfArray *)columnIndex)); + } + else { + ((XdmfSparseMatrix *)(matrix))->setColumnIndex(shared_ptr((XdmfArray *)columnIndex, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfSparseMatrixSetName(XDMFSPARSEMATRIX * matrix, char * name, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfSparseMatrix *)matrix)->setName(std::string(name)); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfSparseMatrixSetRowPointer(XDMFSPARSEMATRIX * matrix, XDMFARRAY * rowPointer, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + if (passControl) { + ((XdmfSparseMatrix *)(matrix))->setRowPointer(shared_ptr((XdmfArray *)rowPointer)); + } + else { + ((XdmfSparseMatrix *)(matrix))->setRowPointer(shared_ptr((XdmfArray *)rowPointer, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfSparseMatrixSetValues(XDMFSPARSEMATRIX * matrix, XDMFARRAY * values, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + if (passControl) { + ((XdmfSparseMatrix *)(matrix))->setValues(shared_ptr((XdmfArray *)values)); + } + else { + ((XdmfSparseMatrix *)(matrix))->setValues(shared_ptr((XdmfArray *)values, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfSparseMatrix, XDMFSPARSEMATRIX) diff --git a/core/XdmfSparseMatrix.hpp b/core/XdmfSparseMatrix.hpp index 2448d427..496f13ab 100644 --- a/core/XdmfSparseMatrix.hpp +++ b/core/XdmfSparseMatrix.hpp @@ -24,10 +24,12 @@ #ifndef XDMFSPARSEMATRIX_HPP_ #define XDMFSPARSEMATRIX_HPP_ -// Includes +// C Compatible Includes #include "XdmfCore.hpp" #include "XdmfArray.hpp" +#ifdef __cplusplus + /** * @brief Sparse matrix implemented as compressed row storage. * @@ -408,6 +410,8 @@ public: virtual void traverse(const shared_ptr visitor); + XdmfSparseMatrix(XdmfSparseMatrix &); + protected: XdmfSparseMatrix(const unsigned int numberRows, @@ -434,4 +438,118 @@ private: #ifdef _WIN32 #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFSPARSEMATRIX; // Simply as a typedef to ensure correct typing +typedef struct XDMFSPARSEMATRIX XDMFSPARSEMATRIX; + +XDMFCORE_EXPORT XDMFSPARSEMATRIX * XdmfSparseMatrixNew(unsigned int numberRows, unsigned int numberColumns); + +XDMFCORE_EXPORT XDMFARRAY * XdmfSparseMatrixGetColumnIndex(XDMFSPARSEMATRIX * matrix, int * status); + +XDMFCORE_EXPORT char * XdmfSparseMatrixGetName(XDMFSPARSEMATRIX * matrix); + +XDMFCORE_EXPORT unsigned int XdmfSparseMatrixGetNumberColumns(XDMFSPARSEMATRIX * matrix); + +XDMFCORE_EXPORT unsigned int XdmfSparseMatrixGetNumberRows(XDMFSPARSEMATRIX * matrix); + +XDMFCORE_EXPORT XDMFARRAY * XdmfSparseMatrixGetRowPointer(XDMFSPARSEMATRIX * matrix, int * status); + +XDMFCORE_EXPORT XDMFARRAY * XdmfSparseMatrixGetValues(XDMFSPARSEMATRIX * matrix, int * status); + +XDMFCORE_EXPORT char * XdmfSparseMatrixGetValuesString(XDMFSPARSEMATRIX * matrix, int * status); + +XDMFCORE_EXPORT void XdmfSparseMatrixSetColumnIndex(XDMFSPARSEMATRIX * matrix, XDMFARRAY * columnIndex, int passControl, int * status); + +XDMFCORE_EXPORT void XdmfSparseMatrixSetName(XDMFSPARSEMATRIX * matrix, char * name, int * status); + +XDMFCORE_EXPORT void XdmfSparseMatrixSetRowPointer(XDMFSPARSEMATRIX * matrix, XDMFARRAY * rowPointer, int passControl, int * status); + +XDMFCORE_EXPORT void XdmfSparseMatrixSetValues(XDMFSPARSEMATRIX * matrix, XDMFARRAY * values, int passControl, int * status); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfSparseMatrix, XDMFSPARSEMATRIX, XDMFCORE) + +#define XDMF_SPARSEMATRIX_C_CHILD_DECLARE(ClassName, CClassName, Level) \ + \ +Level##_EXPORT XDMFARRAY * ClassName##GetColumnIndex( CClassName * matrix, int * status); \ +Level##_EXPORT char * ClassName##GetName( CClassName * matrix); \ +Level##_EXPORT unsigned int ClassName##GetNumberColumns( CClassName * matrix); \ +Level##_EXPORT unsigned int ClassName##GetNumberRows( CClassName * matrix); \ +Level##_EXPORT XDMFARRAY * ClassName##GetRowPointer( CClassName * matrix, int * status); \ +Level##_EXPORT XDMFARRAY * ClassName##GetValues( CClassName * matrix, int * status); \ +Level##_EXPORT char * ClassName##GetValuesString( CClassName * matrix, int * status); \ +Level##_EXPORT void ClassName##SetColumnIndex( CClassName * matrix, XDMFARRAY * columnIndex, int passControl, int * status); \ +Level##_EXPORT void ClassName##SetName( CClassName * matrix, char * name, int * status); \ +Level##_EXPORT void ClassName##SetRowPointer( CClassName * matrix, XDMFARRAY * rowPointer, int passControl, int * status); \ +Level##_EXPORT void ClassName##SetValues( CClassName * matrix, XDMFARRAY * values, int passControl, int * status); + +#define XDMF_SPARSEMATRIX_C_CHILD_WRAPPER(ClassName, CClassName) \ + \ +XDMFARRAY * ClassName##GetColumnIndex( CClassName * matrix, int * status) \ +{ \ + return XdmfSparseMatrixGetColumnIndex((XDMFSPARSEMATRIX *)((void *)matrix), status); \ +} \ + \ +char * ClassName##GetName( CClassName * matrix) \ +{ \ + return XdmfSparseMatrixGetName((XDMFSPARSEMATRIX *)((void *)matrix)); \ +} \ + \ +unsigned int ClassName##GetNumberColumns( CClassName * matrix) \ +{ \ + return XdmfSparseMatrixGetNumberColumns((XDMFSPARSEMATRIX *)((void *)matrix)); \ +} \ + \ +unsigned int ClassName##GetNumberRows( CClassName * matrix) \ +{ \ + return XdmfSparseMatrixGetNumberRows((XDMFSPARSEMATRIX *)((void *)matrix)); \ +} \ + \ +XDMFARRAY * ClassName##GetRowPointer( CClassName * matrix, int * status) \ +{ \ + return XdmfSparseMatrixGetRowPointer((XDMFSPARSEMATRIX *)((void *)matrix), status); \ +} \ + \ +XDMFARRAY * ClassName##GetValues( CClassName * matrix, int * status) \ +{ \ + return XdmfSparseMatrixGetValues((XDMFSPARSEMATRIX *)((void *)matrix), status); \ +} \ + \ +char * ClassName##GetValuesString( CClassName * matrix, int * status) \ +{ \ + return XdmfSparseMatrixGetValuesString((XDMFSPARSEMATRIX *)((void *)matrix), status); \ +} \ + \ +void ClassName##SetColumnIndex( CClassName * matrix, XDMFARRAY * columnIndex, int passControl, int * status) \ +{ \ + XdmfSparseMatrixSetColumnIndex((XDMFSPARSEMATRIX *)((void *)matrix), columnIndex, passControl, status); \ +} \ + \ +void ClassName##SetName( CClassName * matrix, char * name, int * status) \ +{ \ + XdmfSparseMatrixSetName((XDMFSPARSEMATRIX *)((void *)matrix), name, status); \ +} \ + \ +void ClassName##SetRowPointer( CClassName * matrix, XDMFARRAY * rowPointer, int passControl, int * status) \ +{ \ + XdmfSparseMatrixSetRowPointer((XDMFSPARSEMATRIX *)((void *)matrix), rowPointer, passControl, status); \ +} \ + \ +void ClassName##SetValues( CClassName * matrix, XDMFARRAY * values, int passControl, int * status) \ +{ \ + XdmfSparseMatrixSetValues((XDMFSPARSEMATRIX *)((void *)matrix), values, passControl, status); \ +} + +#ifdef __cplusplus +} +#endif + #endif /* XDMFSPARSEMATRIX_HPP_ */ diff --git a/core/XdmfSubset.cpp b/core/XdmfSubset.cpp index 4fe80cd7..04236a93 100644 --- a/core/XdmfSubset.cpp +++ b/core/XdmfSubset.cpp @@ -24,9 +24,11 @@ #include #include #include +#include "string.h" #include "XdmfArray.hpp" #include "XdmfError.hpp" #include "XdmfSubset.hpp" +#include "XdmfWriter.hpp" XdmfSubset::XdmfSubset(shared_ptr referenceArray, std::vector & start, @@ -45,6 +47,15 @@ XdmfSubset::XdmfSubset(shared_ptr referenceArray, } } +XdmfSubset::XdmfSubset(XdmfSubset & refSubset) : + XdmfArrayReference(refSubset), + mParent(refSubset.getReferenceArray()), + mDimensions(refSubset.getDimensions()), + mStart(refSubset.getStart()), + mStride(refSubset.getStride()) +{ +} + XdmfSubset::~XdmfSubset() { } @@ -86,9 +97,7 @@ XdmfSubset::getItemProperties() const "one value contained within"); } - std::map subsetMap; - - subsetMap["ConstructedType"] = mConstructedType; + std::map subsetMap = XdmfArrayReference::getItemProperties(); std::stringstream vectorStream; @@ -120,13 +129,6 @@ XdmfSubset::getItemProperties() const subsetMap["SubsetDimensions"] = vectorStream.str(); - // merge with the properties of the generated class - for (std::map::const_iterator constructedIt = mConstructedProperties.begin(); - constructedIt != mConstructedProperties.end(); - ++constructedIt) { - subsetMap[constructedIt->first] = constructedIt->second; - } - return subsetMap; } @@ -217,6 +219,10 @@ XdmfSubset::read() const "one value contained within"); } + if (!mParent->isInitialized()) { + mParent->read(); + } + shared_ptr tempArray = XdmfArray::New(); tempArray->initialize(mParent->getArrayType()); tempArray->resize(this->getSize(), 0); @@ -249,12 +255,14 @@ XdmfSubset::setDimensions(std::vector newDimensions) "mStart, mStride, mDimensions now have different sizes." "The sizes should be equal before use."); } + this->setIsChanged(true); } void XdmfSubset::setReferenceArray(shared_ptr newReference) { mParent = newReference; + this->setIsChanged(true); } void @@ -269,6 +277,7 @@ XdmfSubset::setStart(std::vector newStarts) "mStart, mStride, mDimensions now have different sizes." "The sizes should be equal before use."); } + this->setIsChanged(true); } void @@ -283,6 +292,7 @@ XdmfSubset::setStride(std::vector newStrides) "mStart, mStride, mDimensions now have different sizes." "The sizes should be equal before use."); } + this->setIsChanged(true); } void @@ -290,9 +300,190 @@ XdmfSubset::traverse(const shared_ptr visitor) { XdmfItem::traverse(visitor); + bool originalXPath; + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + originalXPath = writer->getWriteXPaths(); + writer->setWriteXPaths(false); + } + shared_ptr spacerarray = XdmfArray::New(); spacerarray->pushBack((int)0); spacerarray->accept(visitor); + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + writer->setWriteXPaths(originalXPath); + } + mParent->accept(visitor); } + +// C Wrappers + +XDMFSUBSET * XdmfSubsetNew(void * referenceArray, unsigned int * start, unsigned int * stride, unsigned int * dimensions, unsigned int numDims, int passControl, int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + shared_ptr referencePointer; + if (passControl) { + referencePointer = shared_ptr((XdmfArray *)referenceArray); + } + else { + referencePointer = shared_ptr((XdmfArray *)referenceArray, XdmfNullDeleter()); + } + shared_ptr generatedSubset = XdmfSubset::New(referencePointer, startVector, strideVector, dimVector); + return (XDMFSUBSET *)((void *)(new XdmfSubset(*generatedSubset.get()))); + } + catch (...) + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + shared_ptr referencePointer; + if (passControl) { + referencePointer = shared_ptr((XdmfArray *)referenceArray); + } + else { + referencePointer = shared_ptr((XdmfArray *)referenceArray, XdmfNullDeleter()); + } + shared_ptr generatedSubset = XdmfSubset::New(referencePointer, startVector, strideVector, dimVector); + return (XDMFSUBSET *)((void *)(new XdmfSubset(*generatedSubset.get()))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +unsigned int * XdmfSubsetGetDimensions(XDMFSUBSET * subset) +{ + try + { + std::vector tempVector = ((XdmfSubset *)(subset))->getDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfSubset *)(subset))->getDimensions(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +unsigned int XdmfSubsetGetNumberDimensions(XDMFSUBSET * subset) +{ + return ((XdmfSubset *)(subset))->getDimensions().size(); +} + +void * XdmfSubsetGetReferenceArray(XDMFSUBSET * subset) +{ + shared_ptr returnItem = ((XdmfSubset *)subset)->getReferenceArray(); + return returnItem.get(); +} + +unsigned int XdmfSubsetGetSize(XDMFSUBSET * subset) +{ + return ((XdmfSubset *)(subset))->getSize(); +} + +unsigned int * XdmfSubsetGetStart(XDMFSUBSET * subset) +{ + try + { + std::vector tempVector = ((XdmfSubset *)(subset))->getStart(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfSubset *)(subset))->getStart(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +unsigned int * XdmfSubsetGetStride(XDMFSUBSET * subset) +{ + try + { + std::vector tempVector = ((XdmfSubset *)(subset))->getStride(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } + catch (...) + { + std::vector tempVector = ((XdmfSubset *)(subset))->getStride(); + unsigned int returnSize = tempVector.size(); + unsigned int * returnArray = new unsigned int[returnSize](); + for (unsigned int i = 0; i < returnSize; ++i) { + returnArray[i] = tempVector[i]; + } + return returnArray; + } +} + +void XdmfSubsetSetDimensions(XDMFSUBSET * subset, unsigned int * newDimensions, unsigned int numDims, int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector dimVector(newDimensions, newDimensions + numDims); + ((XdmfSubset *)(subset))->setDimensions(dimVector); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfSubsetSetReferenceArray(XDMFSUBSET * subset, XDMFARRAY * referenceArray, int passControl) +{ + shared_ptr referencePointer; + if (passControl) { + referencePointer = shared_ptr((XdmfArray *)referenceArray); + } + else { + referencePointer = shared_ptr((XdmfArray *)referenceArray, XdmfNullDeleter()); + } + ((XdmfSubset *)subset)->setReferenceArray(referencePointer); +} + +void XdmfSubsetSetStart(XDMFSUBSET * subset, unsigned int * newStarts, unsigned int numDims, int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector startVector(newStarts, newStarts + numDims); + ((XdmfSubset *)(subset))->setStart(startVector); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfSubsetSetStride(XDMFSUBSET * subset, unsigned int * newStrides, unsigned int numDims, int * status) +{ + XDMF_ERROR_WRAP_START(status) + std::vector strideVector(newStrides, newStrides + numDims); + ((XdmfSubset *)(subset))->setStride(strideVector); + XDMF_ERROR_WRAP_END(status) +} + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfSubset, XDMFSUBSET) +XDMF_ARRAYREFERENCE_C_CHILD_WRAPPER(XdmfSubset, XDMFSUBSET) diff --git a/core/XdmfSubset.hpp b/core/XdmfSubset.hpp index 5c04a0d9..b4b0657f 100644 --- a/core/XdmfSubset.hpp +++ b/core/XdmfSubset.hpp @@ -24,14 +24,18 @@ #ifndef XDMFSUBSET_HPP_ #define XDMFSUBSET_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfArrayReference.hpp" +#include "XdmfItem.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfArray; // Includes #include -#include "XdmfCore.hpp" -#include "XdmfItem.hpp" -#include "XdmfArrayReference.hpp" #include "XdmfSharedPtr.hpp" /** @@ -362,6 +366,8 @@ public: void traverse(const shared_ptr visitor); + XdmfSubset(XdmfSubset&); + protected: XdmfSubset(shared_ptr referenceArray, @@ -386,4 +392,46 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFSUBSET; // Simply as a typedef to ensure correct typing +typedef struct XDMFSUBSET XDMFSUBSET; + +XDMFCORE_EXPORT XDMFSUBSET * XdmfSubsetNew(void * referenceArray, unsigned int * start, unsigned int * stride, unsigned int * dimensions, unsigned int numDims, int passControl, int * status); + +XDMFCORE_EXPORT unsigned int * XdmfSubsetGetDimensions(XDMFSUBSET * subset); + +XDMFCORE_EXPORT unsigned int XdmfSubsetGetNumberDimensions(XDMFSUBSET * subset); + +XDMFCORE_EXPORT void * XdmfSubsetGetReferenceArray(XDMFSUBSET * subset); + +XDMFCORE_EXPORT unsigned int XdmfSubsetGetSize(XDMFSUBSET * subset); + +XDMFCORE_EXPORT unsigned int * XdmfSubsetGetStart(XDMFSUBSET * subset); + +XDMFCORE_EXPORT unsigned int * XdmfSubsetGetStride(XDMFSUBSET * subset); + +XDMFCORE_EXPORT void XdmfSubsetSetDimensions(XDMFSUBSET * subset, unsigned int * newDimensions, unsigned int numDims, int * status); + +XDMFCORE_EXPORT void XdmfSubsetSetReferenceArray(XDMFSUBSET * subset, XDMFARRAY * referenceArray, int passControl); + +XDMFCORE_EXPORT void XdmfSubsetSetStart(XDMFSUBSET * subset, unsigned int * newStarts, unsigned int numDims, int * status); + +XDMFCORE_EXPORT void XdmfSubsetSetStride(XDMFSUBSET * subset, unsigned int * newStrides, unsigned int numDims, int * status); + +// C Wrappers for parent classes are generated by macros + +XDMF_ITEM_C_CHILD_DECLARE(XdmfSubset, XDMFSUBSET, XDMFCORE) +XDMF_ARRAYREFERENCE_C_CHILD_DECLARE(XdmfSubset, XDMFSUBSET, XDMFCORE) + +#ifdef __cplusplus +} +#endif + #endif /* XDMFSUBSET_HPP_ */ diff --git a/core/XdmfSystemUtils.cpp b/core/XdmfSystemUtils.cpp index 0f73ea2c..505880b8 100644 --- a/core/XdmfSystemUtils.cpp +++ b/core/XdmfSystemUtils.cpp @@ -25,6 +25,7 @@ #include #include #include "XdmfSystemUtils.hpp" +#include "string.h" XdmfSystemUtils::XdmfSystemUtils() { @@ -40,10 +41,23 @@ XdmfSystemUtils::getRealPath(const std::string & path) xmlURIPtr ref = NULL; ref = xmlCreateURI(); xmlParseURIReference(ref, path.c_str()); - + +#ifdef WIN32 + char realPath[_MAX_PATH]; + _fullpath(realPath, path.c_str(), _MAX_PATH); + xmlFreeURI(ref); + return realPath; +#else char realPath[PATH_MAX]; realpath(ref->path, realPath); - xmlFreeURI(ref); return realPath; +#endif +} + +char * XdmfSystemUtilsGetRealPath(char * path) +{ + std::string returnstring = XdmfSystemUtils::getRealPath(std::string(path)); + char * returnPointer = strdup(returnstring.c_str()); + return returnPointer; } diff --git a/core/XdmfSystemUtils.hpp b/core/XdmfSystemUtils.hpp index 3910ee73..d8e5329f 100644 --- a/core/XdmfSystemUtils.hpp +++ b/core/XdmfSystemUtils.hpp @@ -24,9 +24,13 @@ #ifndef XDMFSYSTEMUTILS_HPP_ #define XDMFSYSTEMUTILS_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" + +#ifdef __cplusplus + // Includes #include -#include "XdmfCore.hpp" /** * @brief System specific functions. @@ -73,4 +77,17 @@ class XDMFCORE_EXPORT XdmfSystemUtils { }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +XDMFCORE_EXPORT char * XdmfSystemUtilsGetRealPath(char * path); + +#ifdef __cplusplus +} +#endif + + #endif /* XDMFSYSTEMUTILS_HPP_ */ diff --git a/core/XdmfTIFFController.cpp b/core/XdmfTIFFController.cpp new file mode 100644 index 00000000..08411b6a --- /dev/null +++ b/core/XdmfTIFFController.cpp @@ -0,0 +1,617 @@ +/*****************************************************************************/ +/* Xdmf */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfTIFFController.cpp */ +/* */ +/* Author: */ +/* Kenneth Leiter */ +/* kenneth.leiter@arl.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2011 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#include +#include +#include "XdmfArray.hpp" +#include "XdmfArrayType.hpp" +#include "XdmfTIFFController.hpp" +#include "XdmfError.hpp" + +#include "tiff.h" +#include "tiffio.h" + +shared_ptr +XdmfTIFFController::New(const std::string & filePath, + const shared_ptr & type, + const std::vector & dimensions) +{ + shared_ptr p(new XdmfTIFFController(filePath, + type, + std::vector(dimensions.size(), 0), + std::vector(dimensions.size(), 1), + dimensions, + dimensions)); + return p; +} + +shared_ptr +XdmfTIFFController::New(const std::string & filePath, + const shared_ptr & type, + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces) +{ + shared_ptr p(new XdmfTIFFController(filePath, + type, + starts, + strides, + dimensions, + dataspaces)); + return p; +} + +XdmfTIFFController::XdmfTIFFController(const std::string & filePath, + const shared_ptr & type, + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces) : + XdmfHeavyDataController(filePath, + type, + starts, + strides, + dimensions, + dataspaces) +{ +} + +XdmfTIFFController::XdmfTIFFController(const XdmfTIFFController& refController): + XdmfHeavyDataController(refController) +{ +} + +XdmfTIFFController::~XdmfTIFFController() +{ +} + +shared_ptr +XdmfTIFFController::createSubController(const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions) +{ + return XdmfTIFFController::New(mFilePath, + mType, + starts, + strides, + dimensions, + mDataspaceDimensions); +} + +void +XdmfTIFFController::readToArray(XdmfArray * const array, + void * pointer, + unsigned int offset, + unsigned int start, + unsigned int stride, + unsigned int amount, + shared_ptr type) +{ + if (type == XdmfArrayType::UInt32()) + { + unsigned int * offsetpointer = &(((unsigned int *)pointer)[start]); + array->insert(offset, + offsetpointer, + amount, + 1, + stride); + } + else if (type == XdmfArrayType::UInt16()) + { + unsigned short * offsetpointer = &(((unsigned short *)pointer)[start]); + array->insert(offset, + offsetpointer, + amount, + 1, + stride); + } + else if (type == XdmfArrayType::UInt8()) + { + unsigned char * offsetpointer = &(((unsigned char *)pointer)[start]); + array->insert(offset, + offsetpointer, + amount, + 1, + stride); + } +} + +std::string +XdmfTIFFController::getName() const +{ + return "TIFF"; +} + +unsigned int +XdmfTIFFController::getNumberDirectories() const +{ + TIFF* tif = TIFFOpen(mFilePath.c_str(), "r"); + unsigned int count = 0; + if (tif) { + do { + count++; + } while (TIFFReadDirectory(tif)); + TIFFClose(tif); + } + return count; +} + +void +XdmfTIFFController::getProperties(std::map & collectedProperties) const +{ + collectedProperties["Format"] = this->getName(); + std::stringstream seekStream; +} + +void +XdmfTIFFController::read(XdmfArray * const array) +{ + TIFF* tif = TIFFOpen(mFilePath.c_str(), "r"); + + unsigned int compression = 0; + + TIFFGetField(tif, TIFFTAG_COMPRESSION, &compression); + + unsigned int currentDirectory = 0; + + if (tif && mStart.size() >= 3) { + // setting the start for the first directory + TIFFSetDirectory(tif, mStart[2]); + currentDirectory = mStart[2]; + } + + unsigned int amountWritten = 0; + // Only used for 1d controllers + unsigned int sizeLeft = this->getSize(); + if (!array->isInitialized()) { + array->initialize(this->getType()); + } + if (array->getSize() != this->getSize()) { + array->resize(mDimensions, 0); + } + + // For single dimension version only + unsigned int currentRowStart = mStart[0]; + unsigned int scanlineIndex = 0; + + if (mDimensions.size() > 1) + { + scanlineIndex = mStart[1]; + } + + if (tif) { + bool validDir = true; + while (validDir) { + // Directories are handled by the third dimension + // If no directories are specified, progress as far + // as needed to fill the dimensions provided. + unsigned int imagelength, bitsPerSample; + tdata_t buf; + unsigned int row; + unsigned int scanlinesize = TIFFScanlineSize(tif); + + shared_ptr tiffDataType = array->getArrayType(); + + TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bitsPerSample); + + TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &imagelength); + + if (compression == 1) { + // Specific to non-compressed read + + if (bitsPerSample / 8 == 1) { + tiffDataType = XdmfArrayType::UInt8(); + } + else if (bitsPerSample / 8 == 2) { + tiffDataType = XdmfArrayType::UInt16(); + } + else if (bitsPerSample / 8 == 4) { + tiffDataType = XdmfArrayType::UInt32(); + } + + // the buffer is a number of bytes equal to the scan line size + buf = _TIFFmalloc(scanlinesize ); + + scanlinesize /= array->getArrayType()->getElementSize(); + + if (mDimensions.size() == 1) + { + if (sizeLeft == 0) { + break; + } + // If there is one dimensions then we treat the entire entry as a single dataset. + // We need to adjust the starting point accordingly. + for (row = 0; row < imagelength; ++row) + { + TIFFReadScanline(tif, buf, row); + unsigned int amountRead = sizeLeft; + if ((scanlinesize - currentRowStart) / mStride[0] <= sizeLeft) { + amountRead = (scanlinesize - currentRowStart) / mStride[0]; + if (scanlinesize % mStride[0] != 0 && + currentRowStart % mStride[0] <= scanlinesize - (amountRead * mStride[0] + currentRowStart)) + { + amountRead++; + } + } + readToArray(array, + buf, + amountWritten, + currentRowStart, + mStride[0], + amountRead, + tiffDataType); + // check to see how the start matches up with the scanline size + amountWritten += amountRead; + if (sizeLeft == 0) { + break; + } + + if (amountRead < sizeLeft) { + sizeLeft = sizeLeft - amountRead; + } + else { + sizeLeft = 0; + } + if (((int)((amountRead * mStride[0]) + currentRowStart)) - scanlinesize >= 0) + { + currentRowStart = ((amountRead * mStride[0]) + currentRowStart) - scanlinesize; + } + else + { + currentRowStart = ((amountRead * (mStride[0] + 1)) + currentRowStart) - scanlinesize; + } + } + } + else { + // Dimensions correspond to scanline size and number of scanlines + unsigned int rowstride = mStride[1]; + unsigned int currentRowStart = mStart[0]; + for (row = mStart[1]; row < imagelength && row < mDataspaceDimensions[1]; row+=rowstride) + { + TIFFReadScanline(tif, buf, row); + readToArray(array, + buf, + amountWritten, + currentRowStart, + mStride[0], + mDimensions[0], + tiffDataType); + amountWritten += mDimensions[0]; + } + } + _TIFFfree(buf); + + } + else if (compression == 5) + { + // In this case we need to use strips instead of scanlines + // scanline size is in bytes when dealing with compression + if (bitsPerSample == 1) { + tiffDataType = XdmfArrayType::UInt8(); + } + else if (bitsPerSample == 2) { + tiffDataType = XdmfArrayType::UInt16(); + } + else if (bitsPerSample == 4) { + tiffDataType = XdmfArrayType::UInt32(); + } + + // the buffer is a number of bytes equal to the scan line size + buf = _TIFFmalloc(TIFFStripSize(tif)); + + scanlinesize /= array->getArrayType()->getElementSize(); + + // For each strip in the directory + for (unsigned int strip = 0; strip < TIFFNumberOfStrips(tif); strip++) + { + if (sizeLeft == 0) { + break; + } + + unsigned int currentStripSize = TIFFReadEncodedStrip(tif, strip, buf, -1); + currentStripSize = currentStripSize / array->getArrayType()->getElementSize(); + // Size is in bits, and is not necessarily the same per strip + unsigned int numberScanlines = currentStripSize / scanlinesize; + // For the case of a partial scanline + if (currentStripSize % scanlinesize != 0) { + ++numberScanlines; + } + // If singledimensional + // then write out the strip as if it was a scanline + + if (mDimensions.size() == 1) + { + unsigned int amountRead = sizeLeft; + if ((currentStripSize - currentRowStart) / mStride[0] <= sizeLeft) { + amountRead = (currentStripSize - currentRowStart) / mStride[0]; + if (currentStripSize % mStride[0] != 0 && + currentRowStart % mStride[0] <= currentStripSize - (amountRead * mStride[0] + currentRowStart)) + { + amountRead++; + } + } + readToArray(array, + buf, + amountWritten, + currentRowStart, + mStride[0], + amountRead, + tiffDataType); + amountWritten += amountRead; + if (sizeLeft == 0) { + break; + } + + if (amountRead < sizeLeft) { + sizeLeft = sizeLeft - amountRead; + } + else { + sizeLeft = 0; + } + if (((int)((amountRead * mStride[0]) + currentRowStart)) - currentStripSize >= 0) + { + currentRowStart = ((amountRead * mStride[0]) + currentRowStart) - currentStripSize; + } + else + { + currentRowStart = ((amountRead * (mStride[0] + 1)) + currentRowStart) - currentStripSize; + } + } + else + { + currentRowStart = scanlineIndex; + // If multidimensional + // Loop through the scanlines in the strip + for (; scanlineIndex < numberScanlines; scanlineIndex += mStride[1]) + { + readToArray(array, + buf, + amountWritten, + currentRowStart, + mStride[0], + mDimensions[0], + tiffDataType); + amountWritten += mDimensions[0]; + currentRowStart = currentRowStart + scanlinesize * mStride[1]; + } + scanlineIndex = scanlineIndex % mStride[1]; + } + } + } + + if (mStride.size() >= 3) + { + currentDirectory += mStride[2]; + } + else + { + ++currentDirectory; + } + + validDir = TIFFSetDirectory(tif, currentDirectory); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Invalid TIFF file"); + } + + TIFFClose(tif); +} + +// C Wrappers + +XDMFTIFFCONTROLLER * XdmfTIFFControllerNew(char * filePath, + int type, + unsigned int * dimensions, + unsigned int numDims, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector dimVector(dimensions, dimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfTIFFController::New(std::string(filePath), buildType, dimVector); + return (XDMFTIFFCONTROLLER *)((void *)(new XdmfTIFFController(*generatedController.get()))); + } + catch (...) + { + std::vector dimVector(dimensions, dimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfTIFFController::New(std::string(filePath), buildType, dimVector); + return (XDMFTIFFCONTROLLER *)((void *)(new XdmfTIFFController(*generatedController.get()))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFTIFFCONTROLLER * XdmfTIFFControllerNewHyperslab(char * filePath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + try + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfTIFFController::New(std::string(filePath), buildType, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFTIFFCONTROLLER *)((void *)(new XdmfTIFFController(*generatedController.get()))); + } + catch (...) + { + std::vector startVector(start, start + numDims); + std::vector strideVector(stride, stride + numDims); + std::vector dimVector(dimensions, dimensions + numDims); + std::vector dataspaceVector(dataspaceDimensions, dataspaceDimensions + numDims); + shared_ptr buildType = shared_ptr(); + switch (type) { + case XDMF_ARRAY_TYPE_UINT8: + buildType = XdmfArrayType::UInt8(); + break; + case XDMF_ARRAY_TYPE_UINT16: + buildType = XdmfArrayType::UInt16(); + break; + case XDMF_ARRAY_TYPE_UINT32: + buildType = XdmfArrayType::UInt32(); + break; + case XDMF_ARRAY_TYPE_INT8: + buildType = XdmfArrayType::Int8(); + break; + case XDMF_ARRAY_TYPE_INT16: + buildType = XdmfArrayType::Int16(); + break; + case XDMF_ARRAY_TYPE_INT32: + buildType = XdmfArrayType::Int32(); + break; + case XDMF_ARRAY_TYPE_INT64: + buildType = XdmfArrayType::Int64(); + break; + case XDMF_ARRAY_TYPE_FLOAT32: + buildType = XdmfArrayType::Float32(); + break; + case XDMF_ARRAY_TYPE_FLOAT64: + buildType = XdmfArrayType::Float64(); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid ArrayType."); + break; + } + shared_ptr generatedController = XdmfTIFFController::New(std::string(filePath), buildType, startVector, strideVector, dimVector, dataspaceVector); + return (XDMFTIFFCONTROLLER *)((void *)(new XdmfTIFFController(*generatedController.get()))); + } + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +// C Wrappers for parent classes are generated by macros + +XDMF_HEAVYCONTROLLER_C_CHILD_WRAPPER(XdmfTIFFController, XDMFTIFFCONTROLLER) diff --git a/core/XdmfTIFFController.hpp b/core/XdmfTIFFController.hpp new file mode 100644 index 00000000..94daf5bc --- /dev/null +++ b/core/XdmfTIFFController.hpp @@ -0,0 +1,187 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfTIFFController.hpp */ +/* */ +/* Author: */ +/* Kenneth Leiter */ +/* kenneth.leiter@arl.army.mil */ +/* US Army Research Laboratory */ +/* Aberdeen Proving Ground, MD */ +/* */ +/* Copyright @ 2011 US Army Research Laboratory */ +/* All Rights Reserved */ +/* See Copyright.txt for details */ +/* */ +/* This software is distributed WITHOUT ANY WARRANTY; without */ +/* even the implied warranty of MERCHANTABILITY or FITNESS */ +/* FOR A PARTICULAR PURPOSE. See the above copyright notice */ +/* for more information. */ +/* */ +/*****************************************************************************/ + +#ifndef XDMFTIFFCONTROLLER_HPP_ +#define XDMFTIFFCONTROLLER_HPP_ + +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfHeavyDataController.hpp" + +#ifdef __cplusplus + +/** + * @brief Couples an XdmfArray with TIFF data stored on disk. + * + * Serves as an interface between data stored in XdmfArrays and data + * stored in tiff files on disk. When an Xdmf file is read from or + * written to disk an XdmfTIFFController is attached to + * XdmfArrays. This allows data to be released from memory but still + * be accessible or have its location written to light data. + */ +class XDMFCORE_EXPORT XdmfTIFFController : public XdmfHeavyDataController { + +public: + + virtual ~XdmfTIFFController(); + + /** + * Create a new controller for an TIFF file on disk. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfTIFFController.cpp + * @skipline //#initializationsimplified + * @until //#initializationsimplified + * + * Python + * + * @dontinclude XdmfExampleTIFFController.py + * @skipline #//initializationsimplified + * @until #//initializationsimplified + * + * @param filePath The location of the tiff file the data + * set resides in. + * @param type The data type of the dataset to read. + * @param dimensions The number of elements to select in each + * dimension from the data set. + * (size in each dimension) + * + * @return New TIFF Controller. + */ + static shared_ptr + New(const std::string & filePath, + const shared_ptr & type, + const std::vector & dimensions); + + /** + * Create a new controller for an TIFF file on disk. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfTIFFController.cpp + * @skipline //#initialization + * @until //#initialization + * + * Python + * + * @dontinclude XdmfExampleTIFFController.py + * @skipline #//initialization + * @until #//initialization + * + * @param filePath The location of the tiff file the data set resides in. + * @param type The data type of the dataset to read. + * @param starts The offset of the starting element in each + * dimension in the data set. + * @param strides The number of elements to move in each + * dimension from the data set. + * @param dimensions The number of elements to select in each + * dimension from the data set. + * (size in each dimension) + * @param dataspaces The number of elements in the entire + * data set (may be larger than + * dimensions if using hyperslabs). + * + * @return New TIFF Controller. + */ + static shared_ptr + New(const std::string & filePath, + const shared_ptr & type, + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces); + + virtual std::string getName() const; + + virtual void + getProperties(std::map & collectedProperties) const; + + virtual void read(XdmfArray * const array); + + XdmfTIFFController(const XdmfTIFFController &); + +protected: + + XdmfTIFFController(const std::string & filePath, + const shared_ptr & type, + const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions, + const std::vector & dataspaces); + + virtual shared_ptr + createSubController(const std::vector & starts, + const std::vector & strides, + const std::vector & dimensions); + + unsigned int getNumberDirectories() const; + + void readToArray(XdmfArray * const array, + void * pointer, + unsigned int offset, + unsigned int start, + unsigned int stride, + unsigned int amount, + shared_ptr type); + +private: + + void operator=(const XdmfTIFFController &); // Not implemented. +}; + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct XDMFTIFFCONTROLLER; // Simply as a typedef to ensure correct typing +typedef struct XDMFTIFFCONTROLLER XDMFTIFFCONTROLLER; + +XDMFCORE_EXPORT XDMFTIFFCONTROLLER * XdmfTIFFControllerNew(char * filePath, + int type, + unsigned int * dimensions, + unsigned int numDims, + int * status); + +XDMFCORE_EXPORT XDMFTIFFCONTROLLER * XdmfTIFFControllerNewHyperslab(char * filePath, + int type, + unsigned int * starts, + unsigned int * strides, + unsigned int * dimensions, + unsigned int * dataspaces, + unsigned int numDims, + int * status); + +XDMF_HEAVYCONTROLLER_C_CHILD_DECLARE(XdmfTIFFController, XDMFTIFFCONTROLLER, XDMFCORE) + +#ifdef __cplusplus +} +#endif + +#endif /* XDMFTIFFCONTROLLER_HPP_ */ diff --git a/core/XdmfVisitor.hpp b/core/XdmfVisitor.hpp index 92b0bc55..86bb40d8 100644 --- a/core/XdmfVisitor.hpp +++ b/core/XdmfVisitor.hpp @@ -24,12 +24,16 @@ #ifndef XDMFVISITOR_HPP_ #define XDMFVISITOR_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfItem; // Includes #include -#include "XdmfCore.hpp" /** * @brief Perform an operation on an Xdmf tree structure. @@ -59,4 +63,19 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFVISITOR; // Simply as a typedef to ensure correct typing +typedef struct XDMFVISITOR XDMFVISITOR; + +#ifdef __cplusplus +} +#endif + #endif /* XDMFVISITOR_HPP_ */ diff --git a/core/XdmfWriter.cpp b/core/XdmfWriter.cpp index 3580354e..227c6ced 100644 --- a/core/XdmfWriter.cpp +++ b/core/XdmfWriter.cpp @@ -50,6 +50,7 @@ public: mDepth(0), mDocumentTitle("Xdmf"), mHeavyDataWriter(heavyDataWriter), + mHeavyWriterIsOpen(false), mLastXPathed(false), mLightDataLimit(100), mMode(Default), @@ -73,6 +74,7 @@ public: closeFile() { mXPath.clear(); + mXPathCount = 0; // This section writes to file std::ofstream fileStream; @@ -96,11 +98,13 @@ public: mStream = NULL; } - xmlFreeDoc(mXMLDocument); +// xmlFreeDoc(mXMLDocument); xmlCleanupParser(); if(mHeavyDataWriter->getMode() == XdmfHeavyDataWriter::Default) { - mHeavyDataWriter->closeFile(); + if (mHeavyWriterIsOpen) { + mHeavyDataWriter->closeFile(); + } } }; @@ -116,14 +120,12 @@ public: (xmlChar*)"Version", (xmlChar*)mVersionString.c_str()); xmlDocSetRootElement(mXMLDocument, mXMLCurrentNode); - if(mHeavyDataWriter->getMode() == XdmfHeavyDataWriter::Default) { - mHeavyDataWriter->openFile(); - } } int mDepth; std::string mDocumentTitle; shared_ptr mHeavyDataWriter; + bool mHeavyWriterIsOpen; bool mLastXPathed; unsigned int mLightDataLimit; Mode mMode; @@ -179,13 +181,15 @@ XdmfWriter::New(std::ostream & stream, XdmfWriter::XdmfWriter(const std::string & xmlFilePath, shared_ptr heavyDataWriter, std::ostream * stream) : + mRebuildAlreadyVisited(true), mImpl(new XdmfWriterImpl(xmlFilePath, heavyDataWriter, stream)) { } -XdmfWriter::XdmfWriter(const XdmfWriter & writerRef) +XdmfWriter::XdmfWriter(const XdmfWriter & writerRef) : + mRebuildAlreadyVisited(writerRef.mRebuildAlreadyVisited) { char * transferPath = strdup(writerRef.getFilePath().c_str()); char * heavyTransferPath = strdup(writerRef.getHeavyDataWriter()->getFilePath().c_str()); @@ -194,6 +198,8 @@ XdmfWriter::XdmfWriter(const XdmfWriter & writerRef) XdmfWriter::~XdmfWriter() { + mXMLArchive.clear(); + xmlFreeDoc(mImpl->mXMLDocument); delete mImpl; } @@ -228,6 +234,43 @@ XdmfWriter::getMode() const return mImpl->mMode; } +bool +XdmfWriter::getRebuildXML() +{ + return mRebuildAlreadyVisited; +} + +xmlNodePtr +XdmfWriter::getXMLNode(XdmfItem * item, xmlDocPtr parentDoc, xmlNodePtr parentNode) +{ + std::map::iterator node = + mXMLArchive.find(item); + if (node != mXMLArchive.end()) + { + xmlAddChild(parentNode, mXMLArchive[item]); + return mXMLArchive[item]; + } + else + { + return xmlNewNode(NULL, (xmlChar*)"NULL"); + } +} + +bool +XdmfWriter::getHasXMLArchive(XdmfItem * item) +{ + std::map::iterator node = + mXMLArchive.find(item); + if (node != mXMLArchive.end()) + { + return true; + } + else + { + return false; + } +} + bool XdmfWriter::getWriteXPaths() const { @@ -264,12 +307,24 @@ XdmfWriter::setMode(const Mode mode) mImpl->mMode = mode; } +void +XdmfWriter::setRebuildXML(bool newStatus) +{ + mRebuildAlreadyVisited = newStatus; +} + void XdmfWriter::setVersionString(std::string version) { mImpl->mVersionString = version; } +void +XdmfWriter::setXMLNode(XdmfItem * item, xmlNodePtr & newNode) +{ + mXMLArchive[item] = xmlCopyNode(newNode, 1); +} + void XdmfWriter::setWriteXPaths(const bool writeXPaths) { @@ -329,6 +384,11 @@ XdmfWriter::visit(XdmfArray & array, // Write values to heavy data // This takes about half the time needed + if ((!mImpl->mHeavyWriterIsOpen) && + mImpl->mHeavyDataWriter->getMode() == XdmfHeavyDataWriter::Default) { + mImpl->mHeavyDataWriter->openFile(); + mImpl->mHeavyWriterIsOpen = true; + } mImpl->mHeavyDataWriter->visit(array, mImpl->mHeavyDataWriter); std::stringstream valuesStream; @@ -350,19 +410,13 @@ XdmfWriter::visit(XdmfArray & array, } // Otherwise the full path is required } - - std::stringstream dimensionStream; - for (unsigned int j = 0; j < array.getHeavyDataController(i)->getDimensions().size(); ++j) { - dimensionStream << array.getHeavyDataController(i)->getDimensions()[j]; - if (j < array.getHeavyDataController(i)->getDimensions().size() - 1) { - dimensionStream << " "; - } - } // Clear the stream valuesStream.str(std::string()); valuesStream << heavyDataPath << array.getHeavyDataController(i)->getDescriptor(); - if (array.getNumberHeavyDataControllers() > 1) { - valuesStream << "|" << dimensionStream.str(); + if (array.getNumberHeavyDataControllers() > 1 || + (array.getHeavyDataController(i)->getSize() != + array.getHeavyDataController(i)->getDataspaceSize())) { + valuesStream << "|" << array.getHeavyDataController(i)->getDataspaceDescription(); if (i + 1 < array.getNumberHeavyDataControllers()) { valuesStream << "|"; } @@ -376,10 +430,15 @@ XdmfWriter::visit(XdmfArray & array, } bool oldWriteXPaths = mImpl->mWriteXPaths; - mImpl->mWriteXPaths = false; // Write XML (metadata) description if(isSubclassed) { + // We don't want temporary items to be on the XPath List + // This is a one-of anyway, so it shouldn't be equivalent + // to anything written before now or after. + mImpl->mWriteXPaths = false; + const unsigned int parentCount = mImpl->mXPathCount; + mImpl->mXPathCount = 0; shared_ptr arrayToWrite = XdmfArray::New(); array.swap(arrayToWrite); mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->last; @@ -390,17 +449,22 @@ XdmfWriter::visit(XdmfArray & array, } mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->parent; array.swap(arrayToWrite); + mImpl->mXPathCount = parentCount; + mImpl->mLastXPathed = false; } else { + std::map::const_iterator iter = + mImpl->mXPath.find(&array); this->visit(dynamic_cast(array), visitor); - for(unsigned int i = 0; imXMLCurrentNode->last, - xmlNewText((xmlChar*)xmlTextValues[i].c_str())); + if(iter == mImpl->mXPath.end()) { + for(unsigned int i = 0; imXMLCurrentNode->last, + xmlNewText((xmlChar*)xmlTextValues[i].c_str())); + } } } mImpl->mWriteXPaths = oldWriteXPaths; } - } else { // These statements are reached when an unsupported read mode is used @@ -431,32 +495,89 @@ XdmfWriter::visit(XdmfItem & item, } mImpl->mDepth++; - std::string tag = item.getItemTag(); - if (tag.length() == 0) { - item.traverse(visitor); - } - else { - if(mImpl->mWriteXPaths) { - if (tag == "Information" && mImpl->mXPathParse) { - XdmfInformation & xpathinfo = dynamic_cast(item); - if (xpathinfo.getKey() == "XIncludes") { - shared_ptr outputinfo; - for (unsigned int i = 0; i < xpathinfo.getNumberInformations(); ++i) { + if ((item.getItemTag().compare("Grid") != 0) || // If not a grid + (item.getItemTag().compare("Grid") == 0 && item.getIsChanged()) || // If a Grid that is changed + (item.getItemTag().compare("Grid") == 0 && !getHasXMLArchive(&item)) || // If the grid doesn't have an XML Archive + mRebuildAlreadyVisited) // If Rebuild + { + std::string tag = item.getItemTag(); + if (tag.length() == 0) { + item.traverse(visitor); + } + else { + if(mImpl->mWriteXPaths) { + if (tag == "Information" && mImpl->mXPathParse) { + XdmfInformation & xpathinfo = dynamic_cast(item); + if (xpathinfo.getKey() == "XIncludes") { + shared_ptr outputinfo; + for (unsigned int i = 0; i < xpathinfo.getNumberInformations(); ++i) { + mImpl->mXPathCount++; + outputinfo = xpathinfo.getInformation(i); + mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, + NULL, + (xmlChar*)"xi:include", + NULL); + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)"href", + (xmlChar*)(outputinfo->getKey().c_str())); + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)"xpointer", + (xmlChar*)(outputinfo->getValue().c_str())); + if (i < xpathinfo.getNumberInformations()-1) { + mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->parent; + } + } + } + else { mImpl->mXPathCount++; - outputinfo = xpathinfo.getInformation(i); - mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, - NULL, - (xmlChar*)"xi:include", - NULL); - xmlNewProp(mImpl->mXMLCurrentNode, - (xmlChar*)"href", - (xmlChar*)(outputinfo->getKey().c_str())); - xmlNewProp(mImpl->mXMLCurrentNode, - (xmlChar*)"xpointer", - (xmlChar*)(outputinfo->getValue().c_str())); - if (i < xpathinfo.getNumberInformations()-1) { - mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->parent; + + const std::string parentXPathString = mImpl->mXPathString; + + std::stringstream newXPathString; + newXPathString << mImpl->mXPathString << "/" << mImpl->mXPathCount; + mImpl->mXPathString = newXPathString.str(); + + std::map::const_iterator iter = + mImpl->mXPath.find(&item); + if(iter != mImpl->mXPath.end()) { + // Inserted before --- just xpath location of previously written node + mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, + NULL, + (xmlChar*)"xi:include", + NULL); + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)"xpointer", + (xmlChar*)iter->second.c_str()); + mImpl->mLastXPathed = true; } + else { + // Not inserted before --- need to write all data and traverse. + mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, + NULL, + (xmlChar *)tag.c_str(), + NULL); + std::stringstream xPathProp; + xPathProp << "element(/1" << mImpl->mXPathString << ")"; + mImpl->mXPath.insert(std::make_pair(&item, xPathProp.str())); + const std::map & itemProperties = + item.getItemProperties(); + for(std::map::const_iterator iter = + itemProperties.begin(); + iter != itemProperties.end(); + ++iter) { + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)iter->first.c_str(), + (xmlChar*)iter->second.c_str()); + } + const unsigned int parentCount = mImpl->mXPathCount; + mImpl->mXPathCount = 0; + item.traverse(visitor); + mImpl->mXPathCount = parentCount; + mImpl->mLastXPathed = false; + } + + mImpl->mXPathString = parentXPathString; + } } else { @@ -469,20 +590,21 @@ XdmfWriter::visit(XdmfItem & item, mImpl->mXPathString = newXPathString.str(); std::map::const_iterator iter = - mImpl->mXPath.find(&item); + mImpl->mXPath.find(&item); if(iter != mImpl->mXPath.end()) { // Inserted before --- just xpath location of previously written node mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, NULL, (xmlChar*)"xi:include", NULL); - xmlNewProp(mImpl->mXMLCurrentNode, - (xmlChar*)"xpointer", - (xmlChar*)iter->second.c_str()); - mImpl->mLastXPathed = true; + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)"xpointer", + (xmlChar*)iter->second.c_str()); + mImpl->mLastXPathed = true; } else { // Not inserted before --- need to write all data and traverse. + mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, NULL, (xmlChar *)tag.c_str(), @@ -491,7 +613,7 @@ XdmfWriter::visit(XdmfItem & item, xPathProp << "element(/1" << mImpl->mXPathString << ")"; mImpl->mXPath.insert(std::make_pair(&item, xPathProp.str())); const std::map & itemProperties = - item.getItemProperties(); + item.getItemProperties(); for(std::map::const_iterator iter = itemProperties.begin(); iter != itemProperties.end(); @@ -506,83 +628,65 @@ XdmfWriter::visit(XdmfItem & item, mImpl->mXPathCount = parentCount; mImpl->mLastXPathed = false; } - mImpl->mXPathString = parentXPathString; - } } - else { + else + { + // Increment XPathCount, handling temporary arrays not written to XPath mImpl->mXPathCount++; - - const std::string parentXPathString = mImpl->mXPathString; - - std::stringstream newXPathString; - newXPathString << mImpl->mXPathString << "/" << mImpl->mXPathCount; - mImpl->mXPathString = newXPathString.str(); - - std::map::const_iterator iter = - mImpl->mXPath.find(&item); - if(iter != mImpl->mXPath.end()) { - // Inserted before --- just xpath location of previously written node - mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, - NULL, - (xmlChar*)"xi:include", - NULL); - xmlNewProp(mImpl->mXMLCurrentNode, - (xmlChar*)"xpointer", - (xmlChar*)iter->second.c_str()); - mImpl->mLastXPathed = true; - } - else { - // Not inserted before --- need to write all data and traverse. - - mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, - NULL, - (xmlChar *)tag.c_str(), - NULL); - std::stringstream xPathProp; - xPathProp << "element(/1" << mImpl->mXPathString << ")"; - mImpl->mXPath.insert(std::make_pair(&item, xPathProp.str())); - const std::map & itemProperties = + // Not inserted before --- need to write all data and traverse. + mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, + NULL, + (xmlChar*)tag.c_str(), + NULL); + const std::map itemProperties = item.getItemProperties(); - for(std::map::const_iterator iter = + for(std::map::const_iterator iter = itemProperties.begin(); - iter != itemProperties.end(); - ++iter) { - xmlNewProp(mImpl->mXMLCurrentNode, - (xmlChar*)iter->first.c_str(), - (xmlChar*)iter->second.c_str()); - } - const unsigned int parentCount = mImpl->mXPathCount; - mImpl->mXPathCount = 0; - item.traverse(visitor); - mImpl->mXPathCount = parentCount; - mImpl->mLastXPathed = false; + iter != itemProperties.end(); + ++iter) { + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)iter->first.c_str(), + (xmlChar*)iter->second.c_str()); } - mImpl->mXPathString = parentXPathString; + const unsigned int parentCount = mImpl->mXPathCount; + mImpl->mXPathCount = 0; + item.traverse(visitor); + mImpl->mXPathCount = parentCount; + mImpl->mLastXPathed = false; } + + if (!mRebuildAlreadyVisited) + { + if (item.getItemTag().compare("Grid") == 0) + { + setXMLNode(&item, mImpl->mXMLCurrentNode); + } + item.setIsChanged(false); + } + + mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->parent; } - else - { - // Not inserted before --- need to write all data and traverse. + } + else + { + std::map::const_iterator iter = + mImpl->mXPath.find(&item); + if(iter != mImpl->mXPath.end()) { + // Inserted before --- just xpath location of previously written node mImpl->mXMLCurrentNode = xmlNewChild(mImpl->mXMLCurrentNode, NULL, - (xmlChar*)tag.c_str(), + (xmlChar*)"xi:include", NULL); - const std::map itemProperties = - item.getItemProperties(); - for(std::map::const_iterator iter = - itemProperties.begin(); - iter != itemProperties.end(); - ++iter) { - xmlNewProp(mImpl->mXMLCurrentNode, - (xmlChar*)iter->first.c_str(), - (xmlChar*)iter->second.c_str()); - } - item.traverse(visitor); + xmlNewProp(mImpl->mXMLCurrentNode, + (xmlChar*)"xpointer", + (xmlChar*)iter->second.c_str()); + mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->parent; + } + else { + this->getXMLNode(&item, mImpl->mXMLDocument, mImpl->mXMLCurrentNode); } - - mImpl->mXMLCurrentNode = mImpl->mXMLCurrentNode->parent; } mImpl->mDepth--; @@ -590,3 +694,149 @@ XdmfWriter::visit(XdmfItem & item, mImpl->closeFile(); } } + +// C Wrappers + +XDMFWRITER * XdmfWriterNew(char * fileName) +{ + try + { + shared_ptr generatedWriter = XdmfWriter::New(std::string(fileName)); + return (XDMFWRITER *)((void *)(new XdmfWriter(*generatedWriter.get()))); + } + catch (...) + { + shared_ptr generatedWriter = XdmfWriter::New(std::string(fileName)); + return (XDMFWRITER *)((void *)(new XdmfWriter(*generatedWriter.get()))); + } +} + +XDMFWRITER * XdmfWriterNewSpecifyHeavyDataWriter(char * fileName, XDMFHEAVYDATAWRITER * heavyDataWriter) +{ + try + { + shared_ptr generatedWriter = XdmfWriter::New(std::string(fileName), shared_ptr((XdmfHeavyDataWriter *) heavyDataWriter)); + return (XDMFWRITER *)((void *)(new XdmfWriter(*generatedWriter.get()))); + } + catch (...) + { + shared_ptr generatedWriter = XdmfWriter::New(std::string(fileName), shared_ptr((XdmfHeavyDataWriter *) heavyDataWriter)); + return (XDMFWRITER *)((void *)(new XdmfWriter(*generatedWriter.get()))); + } +} + +void XdmfWriterFree(XDMFWRITER * item) +{ + if (item != NULL) { + delete ((XdmfWriter *)item); + item = NULL; + } +} + +char * XdmfWriterGetFilePath(XDMFWRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + char * returnPointer = strdup(((XdmfWriter *)writer)->getFilePath().c_str()); + return returnPointer; + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +XDMFHEAVYDATAWRITER * XdmfWriterGetHeavyDataWriter(XDMFWRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return (XDMFHEAVYDATAWRITER *)((void *)(((XdmfWriter *)writer)->getHeavyDataWriter().get())); + XDMF_ERROR_WRAP_END(status) + return NULL; +} + +unsigned int XdmfWriterGetLightDataLimit(XDMFWRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return ((XdmfWriter *)writer)->getLightDataLimit(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +int XdmfWriterGetMode(XDMFWRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + XdmfWriter::Mode testMode = ((XdmfWriter *)writer)->getMode(); + if (testMode == XdmfWriter::Default) { + return XDMF_WRITER_MODE_DEFAULT; + } + else if (testMode == XdmfWriter::DistributedHeavyData) { + return XDMF_WRITER_MODE_DISTRIBUTED_HEAVY_DATA; + } + else { + return -1; + } + XDMF_ERROR_WRAP_END(status) + return -1; +} + +int XdmfWriterGetWriteXPaths(XDMFWRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return ((XdmfWriter *)writer)->getWriteXPaths(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +int XdmfWriterGetXPathParse(XDMFWRITER * writer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return ((XdmfWriter *)writer)->getXPathParse(); + XDMF_ERROR_WRAP_END(status) + return 0; +} + +void XdmfWriterSetHeavyDataWriter(XDMFWRITER * writer, XDMFHEAVYDATAWRITER * heavyDataWriter, int transferOwnership, int * status) +{ + XDMF_ERROR_WRAP_START(status) + if (transferOwnership) { + ((XdmfWriter *)writer)->setHeavyDataWriter(shared_ptr((XdmfHeavyDataWriter *) heavyDataWriter)); + } + else { + ((XdmfWriter *)writer)->setHeavyDataWriter(shared_ptr((XdmfHeavyDataWriter *) heavyDataWriter, XdmfNullDeleter())); + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfWriterSetLightDataLimit(XDMFWRITER * writer, unsigned int numValues, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfWriter *)writer)->setLightDataLimit(numValues); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfWriterSetMode(XDMFWRITER * writer, int mode, int * status) +{ + XDMF_ERROR_WRAP_START(status) + switch (mode) { + case XDMF_WRITER_MODE_DEFAULT: + ((XdmfWriter *)writer)->setMode(XdmfWriter::Default); + break; + case XDMF_WRITER_MODE_DISTRIBUTED_HEAVY_DATA: + ((XdmfWriter *)writer)->setMode(XdmfWriter::DistributedHeavyData); + break; + default: + XdmfError::message(XdmfError::FATAL, + "Error: Invalid writer mode."); + } + XDMF_ERROR_WRAP_END(status) +} + +void XdmfWriterSetWriteXPaths(XDMFWRITER * writer, int writeXPaths, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfWriter *)writer)->setWriteXPaths(writeXPaths); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfWriterSetXPathParse(XDMFWRITER * writer, int xPathParse, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfWriter *)writer)->setXPathParse(xPathParse); + XDMF_ERROR_WRAP_END(status) +} diff --git a/core/XdmfWriter.hpp b/core/XdmfWriter.hpp index 5747ec56..63d29174 100644 --- a/core/XdmfWriter.hpp +++ b/core/XdmfWriter.hpp @@ -24,15 +24,18 @@ #ifndef XDMFWRITER_HPP_ #define XDMFWRITER_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfHeavyDataWriter.hpp" +#include "XdmfVisitor.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfArray; class XdmfInformation; class XdmfHeavyDataWriter; -// Includes -#include "XdmfCore.hpp" -#include "XdmfVisitor.hpp" - /** * @brief Traverse the Xdmf graph and write light and heavy data * stored to disk. @@ -268,6 +271,31 @@ public: */ Mode getMode() const; + /** + * Gets whether XML is rebuilt with each write. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfWriter.cpp + * @skipline //#heavyinitialization + * @until //#heavyinitialization + * @skipline //#getRebuildXML + * @until //#getRebuildXML + * + * Python + * + * @dontinclude XdmfExampleWriter.py + * @skipline #//heavyinitialization + * @until #//heavyinitialization + * @skipline #//getRebuildXML + * @until #//getRebuildXML + * + * @return Whether XML will be rebuilt. + */ + bool getRebuildXML(); + /** * Get whether this writer is set to write xpaths. * @@ -399,6 +427,31 @@ public: */ void setMode(const Mode mode); + /** + * Sets whether XML will be rebuilt with each write. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfWriter.cpp + * @skipline //#heavyinitialization + * @until //#heavyinitialization + * @skipline //#setRebuildXML + * @until //#setRebuildXML + * + * Python + * + * @dontinclude XdmfExampleWriter.py + * @skipline #//heavyinitialization + * @until #//heavyinitialization + * @skipline #//setRebuildXML + * @until #//setRebuildXML + * + * @param newStatus Whether to rebuild XML. + */ + void setRebuildXML(bool newStatus); + /** * Set whether to write xpaths for this writer. * @@ -495,6 +548,7 @@ public: virtual void visit(XdmfItem & item, const shared_ptr visitor); + XdmfWriter(const XdmfWriter &); protected: @@ -502,9 +556,17 @@ protected: shared_ptr heavyDataWriter, std::ostream * stream = NULL); + xmlNodePtr getXMLNode(XdmfItem * item, xmlDocPtr parentDoc, xmlNodePtr parentNode); + bool getHasXMLArchive(XdmfItem * item); + void setXMLNode(XdmfItem * item, xmlNodePtr & newNode); + void setDocumentTitle(std::string title); void setVersionString(std::string version); + bool mRebuildAlreadyVisited; + + std::map mXMLArchive; + private: /** @@ -512,7 +574,6 @@ private: */ class XdmfWriterImpl; - XdmfWriter(const XdmfWriter &); // Not implemented. void operator=(const XdmfWriter &); // Not implemented. XdmfWriterImpl * mImpl; @@ -526,4 +587,50 @@ XDMFCORE_TEMPLATE template class XDMFCORE_EXPORT shared_ptr; #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define XDMF_WRITER_MODE_DEFAULT 30 +#define XDMF_WRITER_MODE_DISTRIBUTED_HEAVY_DATA 31 + +// C wrappers go here + +struct XDMFWRITER; // Simply as a typedef to ensure correct typing +typedef struct XDMFWRITER XDMFWRITER; + +XDMFCORE_EXPORT XDMFWRITER * XdmfWriterNew(char * fileName); + +XDMFCORE_EXPORT XDMFWRITER * XdmfWriterNewSpecifyHeavyDataWriter(char * fileName, XDMFHEAVYDATAWRITER * heavyDataWriter); + +XDMFCORE_EXPORT void XdmfWriterFree(XDMFWRITER * item); + +XDMFCORE_EXPORT char * XdmfWriterGetFilePath(XDMFWRITER * writer, int * status); + +XDMFCORE_EXPORT XDMFHEAVYDATAWRITER * XdmfWriterGetHeavyDataWriter(XDMFWRITER * writer, int * status); + +XDMFCORE_EXPORT unsigned int XdmfWriterGetLightDataLimit(XDMFWRITER * writer, int * status); + +XDMFCORE_EXPORT int XdmfWriterGetMode(XDMFWRITER * writer, int * status); + +XDMFCORE_EXPORT int XdmfWriterGetWriteXPaths(XDMFWRITER * writer, int * status); + +XDMFCORE_EXPORT int XdmfWriterGetXPathParse(XDMFWRITER * writer, int * status); + +XDMFCORE_EXPORT void XdmfWriterSetHeavyDataWriter(XDMFWRITER * writer, XDMFHEAVYDATAWRITER * heavyDataWriter, int transferOwnership, int * status); + +XDMFCORE_EXPORT void XdmfWriterSetLightDataLimit(XDMFWRITER * writer, unsigned int numValues, int * status); + +XDMFCORE_EXPORT void XdmfWriterSetMode(XDMFWRITER * writer, int mode, int * status); + +XDMFCORE_EXPORT void XdmfWriterSetWriteXPaths(XDMFWRITER * writer, int writeXPaths, int * status); + +XDMFCORE_EXPORT void XdmfWriterSetXPathParse(XDMFWRITER * writer, int xPathParse, int * status); + +#ifdef __cplusplus +} +#endif + #endif /* XDMFWRITER_HPP_ */ diff --git a/core/dsm/CMakeLists.txt b/core/dsm/CMakeLists.txt index 2ad7f298..582ae5c6 100644 --- a/core/dsm/CMakeLists.txt +++ b/core/dsm/CMakeLists.txt @@ -31,7 +31,10 @@ if(HDF5_FOUND) # FIXME: Would like to get this info from HDF5 so we don't have conflicting # MPI versions if(HDF5_IS_PARALLEL) + # If MPI variables are already populated don't search again + if (NOT MPI_FOUND) find_package(MPI REQUIRED) + endif (NOT MPI_FOUND) if(MPI_FOUND) include_directories(${MPI_INCLUDE_PATH}) set(XdmfDSMLinkLibraries ${XdmfDSMLinkLibraries} ${MPI_LIBRARY} ${MPI_EXTRA_LIBRARY}) @@ -55,14 +58,14 @@ set(XdmfDSMSources XdmfHDF5WriterDSM XdmfDSMCommMPI XdmfDSMBuffer - XdmfDSMManager + XdmfDSMDescription + XdmfDSMItemFactory XdmfDSMDriver) if (XDMF_BUILD_DSM_THREADS) add_definitions(-DXDMF_BUILD_DSM_THREADS) endif (XDMF_BUILD_DSM_THREADS) - if (XDMF_BUILD_DSM_THREADS) find_package(H5FDdsm REQUIRED NO_MODULE) if(H5FDdsm_FOUND) @@ -76,14 +79,47 @@ if (XDMF_BUILD_DSM_THREADS) endif(H5FDdsm_FOUND) endif (XDMF_BUILD_DSM_THREADS) -add_library(XdmfDSM ${XdmfDSMSources}) +# Set a variable if cray is being used +STRING(REGEX MATCH "aprun" IS_CRAY "${MPIEXEC}") + +set(XDMF_DSM_IS_CRAY "${IS_CRAY}") +set(XDMF_DSM_IS_CRAY "${XDMF_DSM_IS_CRAY}" PARENT_SCOPE) + +if (XDMF_DSM_IS_CRAY) + add_definitions(-DXDMF_DSM_IS_CRAY) +endif (XDMF_DSM_IS_CRAY) + +add_library(XdmfDSMObjects OBJECT ${XdmfDSMSources}) +add_library(XdmfDSM $) +if (BUILD_SHARED_LIBS) + add_library(XdmfDSM_Static STATIC $) + if (UNIX) + set_target_properties(XdmfDSM_Static PROPERTIES + OUTPUT_NAME "XdmfDSM") + endif (UNIX) +endif (BUILD_SHARED_LIBS) +#add_library(XdmfDSM ${XdmfDSMSources}) +#if (BUILD_SHARED_LIBS) +# add_library(XdmfDSM_Static STATIC ${XdmfDSMSources}) +# if (UNIX) +# set_target_properties(XdmfDSM_Static PROPERTIES +# OUTPUT_NAME "XdmfDSM") +# endif (UNIX) +#endif (BUILD_SHARED_LIBS) link_directories(${XDMF_LIBRARY_DIRS} ${XdmfDSMLinkLibraryDir}) target_link_libraries(XdmfDSM ${XdmfDSMLinkLibraries}) +if (BUILD_SHARED_LIBS) + target_link_libraries(XdmfDSM_Static ${XdmfDSMLinkLibraries}) +endif (BUILD_SHARED_LIBS) if(WIN32) add_definitions(-D_HDF5USEDLL_ -D_HDF5USEHLDLL_) set_target_properties(XdmfDSM PROPERTIES DEFINE_SYMBOL XdmfDSM_EXPORTS) + if (BUILD_SHARED_LIBS) + set_target_properties(XdmfDSM_Static PROPERTIES + DEFINE_SYMBOL XdmfDSM_EXPORTS) + endif (BUILD_SHARED_LIBS) if(NOT MSVC10) set_target_properties(XdmfDSM PROPERTIES PREFIX ../ @@ -91,6 +127,14 @@ if(WIN32) RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) + if (BUILD_SHARED_LIBS) + set_target_properties(XdmfDSM_Static PROPERTIES + PREFIX ../ + IMPORT_PREFIX ../ + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) + endif (BUILD_SHARED_LIBS) endif(NOT MSVC10) endif(WIN32) @@ -99,6 +143,10 @@ if(XDMF_WRAP_JAVA) endif(XDMF_WRAP_JAVA) if(XDMF_WRAP_PYTHON) + if (NOT BUILD_SHARED_LIBS) + message(FATAL_ERROR "Python Wrappers do not function" + " properly without shared libraries") + endif (NOT BUILD_SHARED_LIBS) XDMF_SWIG_PYTHON(XdmfDSM XdmfCore) endif(XDMF_WRAP_PYTHON) @@ -110,8 +158,13 @@ if(WIN32) endif(WIN32) if(UNIX) - set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfDSM.so - PARENT_SCOPE) + if (BUILD_SHARED_LIBS) + set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfDSM.so + PARENT_SCOPE) + else (BUILD_SHARED_LIBS) + set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfDSM.a + PARENT_SCOPE) + endif (BUILD_SHARED_LIBS) endif(UNIX) if(APPLE) @@ -128,6 +181,12 @@ install(TARGETS XdmfDSM RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib) +if (BUILD_SHARED_LIBS) + install(TARGETS XdmfDSM_Static + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib) +endif (BUILD_SHARED_LIBS) if(XDMF_BUILD_DSM_THREADS) set(XdmfDSM_INCLUDE_DIRS diff --git a/core/dsm/XdmfDSM.i b/core/dsm/XdmfDSM.i index 615ed05e..cf1b0c17 100644 --- a/core/dsm/XdmfDSM.i +++ b/core/dsm/XdmfDSM.i @@ -16,9 +16,9 @@ swig -v -c++ -python -o XdmfDSMPython.cpp XdmfDSM.i #include #include #include - #include #include #include + #include #include #include #include @@ -33,6 +33,7 @@ swig -v -c++ -python -o XdmfDSMPython.cpp XdmfDSM.i #include #include #include + #include #include #include #include @@ -43,6 +44,257 @@ swig -v -c++ -python -o XdmfDSMPython.cpp XdmfDSM.i %import XdmfCore.i +// Ignore C Wrappers + +// XdmfHDF5ControllerDSM + +%ignore XdmfHDF5ControllerDSMNewFromServerBuffer(char * hdf5FilePath, + char * dataSetPath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + void * dsmBuffer, + int * status); +%ignore XdmfHDF5ControllerDSMNew(char * hdf5FilePath, + char * dataSetPath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + MPI_Comm comm, + unsigned int bufferSize, + int startCoreIndex, + int endCoreIndex, + char * applicationName, + int * status); +%ignore XdmfHDF5ControllerDSMNewPaged(char * hdf5FilePath, + char * dataSetPath, + int type, + unsigned int * start, + unsigned int * stride, + unsigned int * dimensions, + unsigned int * dataspaceDimensions, + unsigned int numDims, + MPI_Comm comm, + unsigned int bufferSize, + unsigned int blockSize, + int startCoreIndex, + int endCoreIndex, + char * applicationName, + int * status); +%ignore XdmfHDF5ControllerDSMGetServerBuffer(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControllerDSMGetServerMode(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControllerDSMGetWorkerComm(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControllerDSMSetServerBuffer(XDMFHDF5CONTROLLERDSM * controller, XDMFDSMBUFFER * newBuffer); +%ignore XdmfHDF5ControllerDSMSetServerMode(XDMFHDF5CONTROLLERDSM * controller, int newMode); +%ignore XdmfHDF5ControllerDSMSetWorkerComm(XDMFHDF5CONTROLLERDSM * controller, MPI_Comm comm, int * status); +%ignore XdmfHDF5ControllerDSMStopDSM(XDMFHDF5CONTROLLERDSM * controller, int * status); +%ignore XdmfHDF5ControllerDSMRestartDSM(XDMFHDF5CONTROLLERDSM * controller, int * status); +// XdmfHDF5ControlerDSM inherited from XdmfHDF5Controler +%ignore XdmfHDF5ControlerDSMGetDataSetPath(XDMFHDF5CONTROLLERDSM * controller); +// XdmfHDF5ControlerDSM inherited from XdmfHeavyDataController +%ignore XdmfHDF5ControlerDSMFree(XDMFHDF5CONTROLLERDSM * item); +%ignore XdmfHDF5ControlerDSMGetDataspaceDimensions(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetDimensions(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetFilePath(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetName(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetNumberDimensions(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetSize(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetStart(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetStride(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMSetArrayOffset(XDMFHDF5CONTROLLERDSM * controller, unsigned int newOffset); +%ignore XdmfHDF5ControlerDSMGetArrayOffset(XDMFHDF5CONTROLLERDSM * controller); +%ignore XdmfHDF5ControlerDSMGetType(XDMFHDF5CONTROLLERDSM * controller, int * status); +%ignore XdmfHDF5ControlerDSMRead(XDMFHDF5CONTROLLERDSM * controller, void * array, int * status); + +// XdmfHDF5WriterDSM + +%ignore XdmfHDF5WriterDSMNewFromServerBuffer(char * filePath, + void * dsmBuffer, + int * status); +%ignore XdmfHDF5WriterDSMNew(char * filePath, + MPI_Comm comm, + unsigned int bufferSize, + int startCoreIndex, + int endCoreIndex, + int * status); +%ignore XdmfHDF5WriterDSMNewPaged(char * filePath, + MPI_Comm comm, + unsigned int bufferSize, + unsigned int blockSize, + int startCoreIndex, + int endCoreIndex, + int * status); +%ignore XdmfHDF5WriterDSMNewConnectRequired(char * filePath, + MPI_Comm comm, + char * applicationName, + int * status); +%ignore XdmfHDF5WriterDSMGetDataSetSize(XDMFHDF5WRITERDSM * writer, char * fileName, char * dataSetName); +%ignore XdmfHDF5WriterDSMGetServerBuffer(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetServerMode(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetWorkerComm(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMSetServerBuffer(XDMFHDF5WRITERDSM * writer, XDMFDSMBUFFER * newBuffer); +%ignore XdmfHDF5WriterDSMSetServerMode(XDMFHDF5WRITERDSM * writer, int newMode); +%ignore XdmfHDF5WriterDSMSetWorkerComm(XDMFHDF5WRITERDSM * writer, MPI_Comm comm, int * status); +%ignore XdmfHDF5WriterDSMStopDSM(XDMFHDF5WRITERDSM * writer, int * status); +%ignore XdmfHDF5WriterDSMRestartDSM(XDMFHDF5WRITERDSM * writer, int * status); +%ignore XdmfHDF5WriterDSMWaitRelease(XDMFHDF5WRITERDSM * writer, char * fileName, char * datasetName, int code); +%ignore XdmfHDF5WriterDSMWaitOn(XDMFHDF5WRITERDSM * writer, char * fileName, char * datasetName); +// XdmfHDF5WriterDSM inherited from XdmfHDF5Writer +%ignore XdmfHDF5WriterCloseFile(XDMFHDF5WRITER * writer, int * status); +%ignore XdmfHDF5WriterGetChunkSize(XDMFHDF5WRITER * writer, int * status); +%ignore XdmfHDF5WriterOpenFile(XDMFHDF5WRITER * writer, int * status); +%ignore XdmfHDF5WriterSetChunkSize(XDMFHDF5WRITER * writer, unsigned int chunkSize, int * status); +// XdmfHDF5WriterDSM inherited from XdmfHeavyDataWriter +%ignore XdmfHDF5WriterDSMFree(XDMFHDF5WRITERDSM * item); +%ignore XdmfHDF5WriterDSMGetAllowSetSplitting(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetFileIndex(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetFileOverhead(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetFilePath(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetFileSizeLimit(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetMode(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMGetReleaseData(XDMFHDF5WRITERDSM * writer); +%ignore XdmfHDF5WriterDSMSetAllowSetSplitting(XDMFHDF5WRITERDSM * writer, int newAllow); +%ignore XdmfHDF5WriterDSMSetFileIndex(XDMFHDF5WRITERDSM * writer, int newIndex); +%ignore XdmfHDF5WriterDSMSetFileSizeLimit(XDMFHDF5WRITERDSM * writer, int newSize); +%ignore XdmfHDF5WriterDSMSetMode(XDMFHDF5WRITERDSM * writer, int mode, int * status); +%ignore XdmfHDF5WriterDSMSetReleaseData(XDMFHDF5WRITERDSM * writer, int releaseData); + +// XdmfDSMCommMPI + +%ignore XdmfDSMCommMPINew(); +%ignore XdmfDSMCommMPIFree(XDMFDSMCOMMMPI * item); +%ignore XdmfDSMCommMPIAccept(XDMFDSMCOMMMPI * dsmComm, unsigned int numConnections, int * status); +%ignore XdmfDSMCommMPIClosePort(XDMFDSMCOMMMPI * dsmComm, int * status); +%ignore XdmfDSMCommMPIConnect(XDMFDSMCOMMMPI * dsmComm, int * status); +%ignore XdmfDSMCommMPIDisconnect(XDMFDSMCOMMMPI * dsmComm, int * status); +%ignore XdmfDSMCommMPIDupComm(XDMFDSMCOMMMPI * dsmComm, MPI_Comm comm, int * status); +%ignore XdmfDSMCommMPIDupInterComm(XDMFDSMCOMMMPI * dsmComm, MPI_Comm comm, int * status); +%ignore XdmfDSMCommMPIGetApplicationName(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetDsmFileName(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetDsmPortName(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetDsmProcessStructure(XDMFDSMCOMMMPI * dsmComm, + char ** names, + unsigned int * coreCount, + int * numApplications); +%ignore XdmfDSMCommMPIGetId(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetInterComm(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetInterCommType(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetInterId(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetInterSize(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetIntraComm(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetIntraSize(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIGetUseEnvFileName(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPIInit(XDMFDSMCOMMMPI * dsmComm, int * status); +%ignore XdmfDSMCommMPIOpenPort(XDMFDSMCOMMMPI * dsmComm, int * status); +%ignore XdmfDSMCommMPIReadDsmPortName(XDMFDSMCOMMMPI * dsmComm); +%ignore XdmfDSMCommMPISetApplicationName(XDMFDSMCOMMMPI * dsmComm, char * newName); +%ignore XdmfDSMCommMPISetDsmFileName(XDMFDSMCOMMMPI * dsmComm, char * filename); +%ignore XdmfDSMCommMPISetDsmPortName(XDMFDSMCOMMMPI * dsmComm, char * hostName); +%ignore XdmfDSMCommMPISetUseEnvFileName(XDMFDSMCOMMMPI * dsmComm, int status); + +// XdmfDSMBuffer + +%ignore XdmfDSMBufferNew(); +%ignore XdmfDSMBufferFree(XDMFDSMBUFFER * item); +%ignore XdmfDSMBufferAddressToId(XDMFDSMBUFFER * buffer, int Address, int * status); +%ignore XdmfDSMBufferBroadcastComm(XDMFDSMBUFFER * buffer, int *comm, int root, int * status); +%ignore XdmfDSMBufferBufferService(XDMFDSMBUFFER * buffer, int *returnOpcode, int * status); +%ignore XdmfDSMBufferBufferServiceLoop(XDMFDSMBUFFER * buffer, int *returnOpcode, int * status); +%ignore XdmfDSMBufferConfigureUniform(XDMFDSMBUFFER * buffer, + XDMFDSMCOMMMPI * Comm, + long Length, + int StartId, + int EndId, + long aBlockLength, + int random, + int * status); +%ignore XdmfDSMBufferConnect(XDMFDSMBUFFER * buffer, int persist, int * status); +%ignore XdmfDSMBufferCreate(XDMFDSMBUFFER * buffer, int comm, int startId, int endId, int * status); +%ignore XdmfDSMBufferDisconnect(XDMFDSMBUFFER * buffer, int * status); +%ignore XdmfDSMBufferGet(XDMFDSMBUFFER * buffer, long Address, long aLength, void * Data, int * status); +%ignore XdmfDSMBufferGetAddressRangeForId(XDMFDSMBUFFER * buffer, int Id, int * Start, int * End, int * status); +%ignore XdmfDSMBufferGetBlockLength(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetComm(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetDataPointer(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetDsmType(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetEndAddress(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetEndServerId(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetInterCommType(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetIsConnected(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetIsServer(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetLength(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetLocalBufferSizeMBytes(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetResizeFactor(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetStartAddress(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetStartServerId(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferGetTotalLength(XDMFDSMBUFFER * buffer); +%ignore XdmfDSMBufferProbeCommandHeader(XDMFDSMBUFFER * buffer, int * comm, int * status); +%ignore XdmfDSMBufferPut(XDMFDSMBUFFER * buffer, long Address, long aLength, void * Data, int * status); +%ignore XdmfDSMBufferReceiveAcknowledgment(XDMFDSMBUFFER * buffer, + int source, + int * data, + int tag, + int comm, + int * status); +%ignore XdmfDSMBufferReceiveCommandHeader(XDMFDSMBUFFER * buffer, + int * opcode, + int * source, + int * address, + int * aLength, + int comm, + int remoteSource, + int * status); +%ignore XdmfDSMBufferReceiveData(XDMFDSMBUFFER * buffer, + int source, + char * data, + int aLength, + int tag, + int aAddress, + int comm, + int * status); +%ignore XdmfDSMBufferReceiveInfo(XDMFDSMBUFFER * buffer, + int * status); +%ignore XdmfDSMBufferSendAccept(XDMFDSMBUFFER * buffer, unsigned int numConnects); +%ignore XdmfDSMBufferSendAcknowledgment(XDMFDSMBUFFER * buffer, + int dest, + int data, + int tag, + int comm, + int * status); +%ignore XdmfDSMBufferSendCommandHeader(XDMFDSMBUFFER * buffer, + int opcode, + int dest, + int address, + int aLength, + int comm, + int * status); +%ignore XdmfDSMBufferSendData(XDMFDSMBUFFER * buffer, + int dest, + char * data, + int aLength, + int tag, + int aAddress, + int comm, + int * status); +%ignore XdmfDSMBufferSendDone(XDMFDSMBUFFER * buffer, int * status); +%ignore XdmfDSMBufferSendInfo(XDMFDSMBUFFER * buffer, int * status); +%ignore XdmfDSMBufferSetBlockLength(XDMFDSMBUFFER * buffer, long newBlock); +%ignore XdmfDSMBufferSetComm(XDMFDSMBUFFER * buffer, XDMFDSMCOMMMPI * newComm); +%ignore XdmfDSMBufferSetDsmType(XDMFDSMBUFFER * buffer, int newDsmType); +%ignore XdmfDSMBufferSetInterCommType(XDMFDSMBUFFER * buffer, int newType); +%ignore XdmfDSMBufferSetIsConnected(XDMFDSMBUFFER * buffer, int newStatus); +%ignore XdmfDSMBufferSetIsServer(XDMFDSMBUFFER * buffer, int newIsServer); +%ignore XdmfDSMBufferSetLocalBufferSizeMBytes(XDMFDSMBUFFER * buffer, unsigned int newSize); +%ignore XdmfDSMBufferSetResizeFactor(XDMFDSMBUFFER * buffer, double newFactor); +%ignore XdmfDSMBufferWaitRelease(XDMFDSMBUFFER * buffer, char * filename, char * datasetname, int code); +%ignore XdmfDSMBufferWaitOn(XDMFDSMBUFFER * buffer, char * filename, char * datasetname); + #ifdef SWIGJAVA %pragma(java) jniclasscode=%{ @@ -86,13 +338,6 @@ swig -v -c++ -python -o XdmfDSMPython.cpp XdmfDSM.i } }; - -%extend XdmfDSMManager { - bool __eq__(const XdmfDSMManager * item) { - return $self == item; - } -}; - %extend XdmfHeavyDataController { static shared_ptr XdmfHDF5ControllerDSMCast(PyObject * obj) { @@ -119,11 +364,11 @@ swig -v -c++ -python -o XdmfDSMPython.cpp XdmfDSM.i // Shared Pointer Templates %shared_ptr(XdmfHDF5ControllerDSM) %shared_ptr(XdmfHDF5WriterDSM) - +%shared_ptr(XdmfDSMItemFactory) %include XdmfDSM.hpp %include XdmfHDF5ControllerDSM.hpp %include XdmfHDF5WriterDSM.hpp -%include XdmfDSMManager.hpp %include XdmfDSMBuffer.hpp %include XdmfDSMCommMPI.hpp +%include XdmfDSMItemFactory.hpp diff --git a/core/dsm/XdmfDSMBuffer.cpp b/core/dsm/XdmfDSMBuffer.cpp index b59daf6d..e02ea7b3 100644 --- a/core/dsm/XdmfDSMBuffer.cpp +++ b/core/dsm/XdmfDSMBuffer.cpp @@ -66,15 +66,21 @@ XdmfDSMBuffer::XdmfDSMBuffer() { this->CommChannel = XDMF_DSM_INTER_COMM; + this->DsmType = XDMF_DSM_TYPE_UNIFORM; this->IsServer = true; this->StartAddress = this->EndAddress = 0; this->StartServerId = this->EndServerId = -1; + this->LocalBufferSizeMBytes = 128; this->Length = 0; this->TotalLength = 0; - this->BlockLength = 0; + this->BlockLength = XDMF_DSM_DEFAULT_BLOCK_LENGTH; + this->NumPages = 0; + this->PagesAssigned = 0; this->Comm = NULL; this->DataPointer = NULL; + this->InterCommType = XDMF_DSM_COMM_MPI; this->IsConnected = false; + this->ResizeFactor = 1; } XdmfDSMBuffer::~XdmfDSMBuffer() @@ -114,22 +120,33 @@ XdmfDSMBuffer::AddressToId(int Address) switch(this->DsmType) { case XDMF_DSM_TYPE_UNIFORM : case XDMF_DSM_TYPE_UNIFORM_RANGE : + // Block based allocation should use PageToId // All Servers have same length // This finds out which server the address provided starts on ServerId = this->StartServerId + (Address / this->Length); if(ServerId > this->EndServerId ){ - std::stringstream message; - message << "ServerId " << ServerId << " for Address " - << Address << " is larger than EndServerId " - << this->EndServerId; - XdmfError::message(XdmfError::FATAL, message.str()); + try { + std::stringstream message; + message << "ServerId " << ServerId << " for Address " + << Address << " is larger than EndServerId " + << this->EndServerId; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } } break; default : // Not Implemented - std::stringstream message; - message << "DsmType " << this->DsmType << " not yet implemented"; - XdmfError::message(XdmfError::FATAL, message.str()); + try { + std::stringstream message; + message << "DsmType " << this->DsmType << " not yet implemented or not uniform"; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } break; } return(ServerId); @@ -140,9 +157,17 @@ XdmfDSMBuffer::BroadcastComm(int *comm, int root) { int status; - status = MPI_Bcast(comm, sizeof(int), MPI_UNSIGNED_CHAR, root, this->Comm->GetIntraComm()); + this->Comm->Broadcast(comm, + sizeof(int), + root, + XDMF_DSM_INTRA_COMM); if (status != MPI_SUCCESS) { - XdmfError(XdmfError::FATAL, "Broadcast of Comm failed"); + try { + XdmfError(XdmfError::FATAL, "Broadcast of Comm failed"); + } + catch (XdmfError & e) { + throw e; + } } } @@ -157,17 +182,32 @@ XdmfDSMBuffer::BufferService(int *returnOpcode) if (this->CommChannel == XDMF_DSM_ANY_COMM) { if (this->Comm->GetId() == 0) { - this->ProbeCommandHeader(&this->CommChannel); + try { + this->Comm->Probe(&this->CommChannel); + } + catch (XdmfError & e) { + throw e; + } + } + try { + this->BroadcastComm(&this->CommChannel, 0); + } + catch (XdmfError & e) { + throw e; } - this->BroadcastComm(&this->CommChannel, 0); } - this->ReceiveCommandHeader(&opcode, - &who, - &address, - &aLength, - this->CommChannel, - syncId); + try { + this->ReceiveCommandHeader(&opcode, + &who, + &address, + &aLength, + this->CommChannel, + syncId); + } + catch (XdmfError & e) { + throw e; + } // Connection is an ID for client or server, // int communicatorId = this->CommChannel; @@ -177,48 +217,78 @@ XdmfDSMBuffer::BufferService(int *returnOpcode) // H5FD_DSM_OPCODE_PUT case XDMF_DSM_OPCODE_PUT: if (((unsigned int) aLength + address) > this->Length) { - std::stringstream message; - message << "Length " << aLength << " too long for Address " << address - << "\n" << "Server Start = " << this->StartAddress << " End = " - << this->EndAddress; - XdmfError::message(XdmfError::FATAL, message.str()); + try { + std::stringstream message; + message << "Length " << aLength << " too long for Address " << address + << "\n" << "Server Start = " << this->StartAddress << " End = " + << this->EndAddress; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } } if ((datap = this->DataPointer) == NULL) { - XdmfError::message(XdmfError::FATAL, - "Null Data Pointer when trying to put data"); + try { + XdmfError::message(XdmfError::FATAL, + "Null Data Pointer when trying to put data"); + } + catch (XdmfError & e) { + throw e; + } } datap += address; - this->ReceiveData(who, - datap, - aLength, - XDMF_DSM_PUT_DATA_TAG, - 0, - this->CommChannel); + try { + this->ReceiveData(who, + datap, + aLength, + XDMF_DSM_PUT_DATA_TAG, + 0, + this->CommChannel); + } + catch (XdmfError & e) { + throw e; + } break; // H5FD_DSM_OPCODE_GET case XDMF_DSM_OPCODE_GET: if (((unsigned int) aLength + address) > this->Length) { - std::stringstream message; - message << "Length " << aLength << " too long for Address " << address - << "\n" << "Server Start = " << this->StartAddress << " End = " - << this->EndAddress; - XdmfError::message(XdmfError::FATAL, message.str()); + try { + std::stringstream message; + message << "Length " << aLength << " too long for Address " << address + << "\n" << "Server Start = " << this->StartAddress << " End = " + << this->EndAddress; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } } if ((datap = this->DataPointer) == NULL) { - XdmfError::message(XdmfError::FATAL, - "Null Data Pointer when trying to put data"); + try { + XdmfError::message(XdmfError::FATAL, + "Null Data Pointer when trying to put data"); + } + catch (XdmfError & e) { + throw e; + } } datap += address; - this->SendData(who, - datap, - aLength, - XDMF_DSM_GET_DATA_TAG, - 0, - this->CommChannel); + try { + this->SendData(who, + datap, + aLength, + XDMF_DSM_GET_DATA_TAG, + 0, + this->CommChannel); + } + catch (XdmfError & e) { + throw e; + } break; -// H5FD_DSM_ACCEPT + // H5FD_DSM_ACCEPT // Comes from client case XDMF_DSM_ACCEPT: { @@ -231,8 +301,516 @@ XdmfDSMBuffer::BufferService(int *returnOpcode) this->SendInfo(); break; } - // H5FD_DSM_LOCK_ACQUIRE - // Comes from client or server depending on communicator + // Comes from client, requests a notifcation when a file is touched. + // The notification is sent out when clear is called. + case XDMF_DSM_SET_NOTIFY: + { + // Send the notify info to all cores. + int strlength = 0; + char * notifystring; + int waitingCore = 0; + if (this->Comm->GetId() == 0) + { + waitingCore = who; + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + notifystring = new char[strlength+1](); + this->ReceiveData(who, + notifystring, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + notifystring[strlength] = 0; + WaitingMap[std::string(notifystring)].push_back(who); + // Send XDMF_DSM_SET_NOTIFY to all server cores in order of increasing id + for (int i = this->GetStartServerId() + 1; // Since this is core 0 sending it + i <= this->GetEndServerId(); + ++i) { + if (i != this->Comm->GetInterId()) + { + this->SendCommandHeader(XDMF_DSM_SET_NOTIFY, i, 0, 0, XDMF_DSM_INTER_COMM); + } + } + } + // broadcast to the other server cores + // BCAST strlen + this->Comm->Broadcast(&strlength, + sizeof(int), + 0, + XDMF_DSM_INTRA_COMM); + // BCAST notifystring + if (this->Comm->GetId() != 0) + { + notifystring = new char[strlength + 1](); + } + this->Comm->Broadcast(¬ifystring, + strlength, + 0, + XDMF_DSM_INTRA_COMM); + notifystring[strlength] = 0; + // BCAST locked core + this->Comm->Broadcast(&waitingCore, + sizeof(int), + 0, + XDMF_DSM_INTRA_COMM); + + if (this->Comm->GetId() != 0) + { + WaitingMap[std::string(notifystring)].push_back(waitingCore); + } + + break; + } + // sends out and clears the notifcations that are stored for a specific file. + case XDMF_DSM_CLEAR_NOTIFY: + { + // send a command to other cores to clear this notification + int strlength = 0; + char * notifystring; + int clearCode = 0; + if (this->Comm->GetId() == 0) + { + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + notifystring = new char[strlength+1](); + this->ReceiveData(who, + notifystring, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + notifystring[strlength] = 0; + this->ReceiveAcknowledgment(who, + clearCode, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + } + // broad cast string to be notified + if (WaitingMap[std::string(notifystring)].size() > 0) + { + // Request the help of the rest of the server + // Send XDMF_DSM_SET_NOTIFY to all server cores in order of increasing id + for (int i = this->GetStartServerId() + 1; // Since this is core 0 sending it + i <= this->GetEndServerId(); + ++i) { + if (i != this->Comm->GetInterId()) + { + this->SendCommandHeader(XDMF_DSM_CLEAR_NOTIFY, i, 0, 0, XDMF_DSM_INTER_COMM); + } + } + + // BCAST strlen and code + this->Comm->Broadcast(&strlength, + sizeof(int), + 0, + XDMF_DSM_INTRA_COMM); + this->Comm->Broadcast(&clearCode, + sizeof(int), + 0, + XDMF_DSM_INTRA_COMM); + // BCAST notifystring + if (this->Comm->GetId() != 0) + { + notifystring = new char[strlength+1](); + } + this->Comm->Broadcast(¬ifystring, + strlength, + 0, + XDMF_DSM_INTRA_COMM); + notifystring[strlength] = 0; + // cores notify based on their index, in order to split up the work + std::vector notifiedCores = WaitingMap[std::string(notifystring)]; + for (unsigned int i = this->Comm->GetId(); i < notifiedCores.size(); i+=this->Comm->GetIntraSize()) + { + unsigned int recvCore = notifiedCores[i]; + this->SendAcknowledgment(recvCore, + clearCode, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + } + // Then all cores remove the string from the map of notifications + WaitingMap.erase(std::string(notifystring)); + } + break; + } + case XDMF_DSM_REGISTER_FILE: + { + // save file description + XdmfDSMBuffer::XDMF_file_desc * newfile = new XdmfDSMBuffer::XDMF_file_desc(); + + int strlength = 0; + + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + newfile->name = new char[strlength + 1]; + + this->ReceiveData(who, + newfile->name, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + newfile->name[strlength] = 0; + + this->ReceiveData(who, + (char *)&newfile->start, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + this->ReceiveData(who, + (char *)&newfile->end, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + int recvNumPages = 0; + + this->ReceiveAcknowledgment(who, + recvNumPages, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + newfile->numPages = recvNumPages; + + if (newfile->numPages > 0) + { + newfile->pages = new unsigned int[newfile->numPages](); + + this->ReceiveData(who, + (char *)newfile->pages, + newfile->numPages * sizeof(unsigned int), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + } + else + { + newfile->pages = NULL; + } + + // If old description exists, overwrite it. + + FileDefinitions[std::string(newfile->name)] = newfile; + + break; + } + case XDMF_DSM_REQUEST_PAGES: + { + // set aside pages to a file + char * requestfile; + int strlength = 0; + + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + requestfile = new char[strlength + 1]; + + this->ReceiveData(who, + requestfile, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + requestfile[strlength] = 0; + + // This file will have its pages appended to. + XdmfDSMBuffer::XDMF_file_desc * filedesc; + + if (FileDefinitions.count(std::string(requestfile)) > 0) + { + filedesc = FileDefinitions[std::string(requestfile)]; + } + else + { + filedesc = new XDMF_file_desc(); + filedesc->start = 0; + filedesc->end = 0; + filedesc->numPages = 0; + filedesc->pages = NULL; + } + + int datasize = 0; + + // Request size required for the file + this->ReceiveAcknowledgment(who, + datasize, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + // TODO Error handling block length must be greater than 0 + // If Block size = 0 then do nothing? + // Then return blank data? + + int requestedblocks = ((double)datasize) / this->BlockLength; + + // Round up + if (requestedblocks * this->BlockLength != datasize) + { + ++requestedblocks; + } + + while (requestedblocks + PagesAssigned >= this->NumPages * this->Comm->GetIntraSize()) + { + // If requested blocks are out of range, resize + for (int i = this->GetStartServerId() + 1; // Since this is core 0 sending it + i <= this->GetEndServerId(); + ++i) { + if (i != this->Comm->GetInterId()) + { + this->SendCommandHeader(XDMF_DSM_OPCODE_RESIZE, i, 0, 0, XDMF_DSM_INTER_COMM); + } + } + this->SetLength(this->Length + (this->Length * this->ResizeFactor)); + } + + unsigned int * newpagelist = new unsigned int[filedesc->numPages + requestedblocks](); + + unsigned int index = 0; + + for (unsigned int i = 0; i < filedesc->numPages; ++i) + { + newpagelist[index] = filedesc->pages[index]; + ++index; + } + + for (;index < filedesc->numPages + requestedblocks; ++index) + { + // The number of pages assigned is incremented after the page is added. + // The value added is simply an index + newpagelist[index] = PagesAssigned++; + } + + filedesc->numPages = filedesc->numPages + requestedblocks; + unsigned int * oldpointer = filedesc->pages; + filedesc->pages = newpagelist; + + if (oldpointer != NULL) + { + delete oldpointer; + } + + // Send back new page allocation pointer + + this->SendAcknowledgment(who, + filedesc->numPages, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + this->SendData(who, + (char *)filedesc->pages, + filedesc->numPages * sizeof(unsigned int), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + this->SendData(who, + (char*)&filedesc->start, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + filedesc->end = filedesc->start + (filedesc->numPages * this->BlockLength); + + this->SendData(who, + (char*)&(filedesc->end), + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + // Notify the current size of the buffer + int currentLength = this->Length; + this->SendAcknowledgment(who, + currentLength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + break; + } + case XDMF_DSM_REQUEST_FILE: + { + char * requestfile; + int strlength = 0; + + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + requestfile = new char[strlength + 1]; + + this->ReceiveData(who, + requestfile, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + requestfile[strlength] = 0; + + // This file will be returned. + XdmfDSMBuffer::XDMF_file_desc * filedesc; + + if (FileDefinitions.count(std::string(requestfile)) > 0) + { + this->SendAcknowledgment(who, + XDMF_DSM_SUCCESS, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + filedesc = FileDefinitions[std::string(requestfile)]; + + this->SendData(who, + (char*)&filedesc->start, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + this->SendData(who, + (char*)&filedesc->end, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + int sendNumPages = filedesc->numPages; + + this->SendAcknowledgment(who, + sendNumPages, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + this->SendData(who, + (char *)filedesc->pages, + filedesc->numPages * sizeof(unsigned int), + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + } + else + { + this->SendAcknowledgment(who, + XDMF_DSM_FAIL, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + } + + break; + } + case XDMF_DSM_OPCODE_RESIZE: + this->SetLength(this->Length + (this->Length * this->ResizeFactor)); + break; + case XDMF_DSM_REQUEST_ACCESS: + { + int isLocked = 0; + + char * requestfile; + int strlength = 0; + + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + requestfile = new char[strlength + 1]; + + this->ReceiveData(who, + requestfile, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + requestfile[strlength] = 0; + + // If the requesting core is the one who + // already locked the file then tell it that there is not lock. + std::map::iterator isOwner = FileOwners.find(std::string(requestfile)); + + if (LockedMap.count(std::string(requestfile)) > 0) + { + if (isOwner->second != who) + { + // If the file is locked notify the requesting core and add it to the queue. + isLocked = 1; + LockedMap[std::string(requestfile)].push(who); + } + } + else + { + LockedMap[std::string(requestfile)] = std::queue(); + FileOwners[std::string(requestfile)] = who; + } + + this->SendAcknowledgment(who, + isLocked, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + break; + } + case XDMF_DSM_UNLOCK_FILE: + { + char * requestfile; + int strlength = 0; + + this->ReceiveAcknowledgment(who, + strlength, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + + requestfile = new char[strlength + 1]; + + this->ReceiveData(who, + requestfile, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + this->CommChannel); + + requestfile[strlength] = 0; + + // If file isn't locked do nothing + if (LockedMap.count(std::string(requestfile)) > 0) + { + // Remove the queue if there are no more waiting + if (LockedMap[std::string(requestfile)].size() > 0) + { + // Pop the next process waiting off the queue + unsigned int nextCore = LockedMap[std::string(requestfile)].front(); + LockedMap[std::string(requestfile)].pop(); + FileOwners[std::string(requestfile)] = nextCore; + this->SendAcknowledgment(nextCore, + 1, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + } + if(LockedMap[std::string(requestfile)].size() == 0) + { + LockedMap.erase(std::string(requestfile)); + FileOwners.erase(std::string(requestfile)); + } + } + + break; + } case XDMF_DSM_LOCK_ACQUIRE: // Currently unsupported break; @@ -250,9 +828,14 @@ XdmfDSMBuffer::BufferService(int *returnOpcode) // DEFAULT default : - std::stringstream message; - message << "Error: Unknown Opcode " << opcode; - XdmfError::message(XdmfError::FATAL, message.str()); + try { + std::stringstream message; + message << "Error: Unknown Opcode " << opcode; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } } if (returnOpcode) *returnOpcode = opcode; @@ -264,7 +847,12 @@ XdmfDSMBuffer::BufferServiceLoop(int *returnOpcode) { int op, status = XDMF_DSM_SUCCESS; while (status == XDMF_DSM_SUCCESS) { - status = this->BufferService(&op); + try { + status = this->BufferService(&op); + } + catch (XdmfError & e) { + throw e; + } if (returnOpcode) *returnOpcode = op; if (op == XDMF_DSM_OPCODE_DONE) { break; @@ -272,6 +860,52 @@ XdmfDSMBuffer::BufferServiceLoop(int *returnOpcode) } } +void +XdmfDSMBuffer::Create(MPI_Comm newComm, int startId, int endId) +{ + // + // Create DSM communicator + // + switch (this->InterCommType) { + case XDMF_DSM_COMM_MPI: + this->Comm = new XdmfDSMCommMPI(); + break; + default: + try { + XdmfError::message(XdmfError::FATAL, "DSM communication type not supported"); + } + catch (XdmfError & e) { + throw e; + } + } + + this->Comm->DupComm(newComm); + this->Comm->Init(); + + // Uniform Dsm : every node has a buffer the same size. (Addresses are sequential) + // Block DSM : nodes are set up using paging + long length = (long) (this->LocalBufferSizeMBytes)*1024LU*1024LU; + switch (this->DsmType) { + case XDMF_DSM_TYPE_UNIFORM: + case XDMF_DSM_TYPE_UNIFORM_RANGE: + this->ConfigureUniform(this->Comm, length, startId, endId); + break; + case XDMF_DSM_TYPE_BLOCK_CYCLIC: + this->ConfigureUniform(this->Comm, length, startId, endId, this->BlockLength, false); + break; + case XDMF_DSM_TYPE_BLOCK_RANDOM: + this->ConfigureUniform(this->Comm, length, startId, endId, this->BlockLength, true); + break; + default: + try { + XdmfError(XdmfError::FATAL, "DSM configuration type not supported"); + } + catch (XdmfError & e) { + throw e; + } + } +} + void XdmfDSMBuffer::ConfigureUniform(XdmfDSMCommMPI *aComm, long aLength, int startId, int endId, long aBlockLength, @@ -302,12 +936,18 @@ XdmfDSMBuffer::ConfigureUniform(XdmfDSMCommMPI *aComm, long aLength, if ((aComm->GetId() >= startId) && (aComm->GetId() <= endId) && this->IsServer) { - if (aBlockLength) { - // For optimization we make the DSM length fit to a multiple of block size - this->SetLength(((long)(aLength / aBlockLength)) * aBlockLength); + try { + if (aBlockLength) { + // For optimization we make the DSM length fit to a multiple of block size + this->SetLength(((long)(aLength / aBlockLength)) * aBlockLength); + this->NumPages = ((long)(aLength / aBlockLength)); + } + else { + this->SetLength(aLength); + } } - else { - this->SetLength(aLength); + catch (XdmfError & e) { + throw e; } this->StartAddress = (aComm->GetId() - startId) * aLength; this->EndAddress = this->StartAddress + aLength - 1; @@ -321,7 +961,65 @@ XdmfDSMBuffer::ConfigureUniform(XdmfDSMCommMPI *aComm, long aLength, } } this->TotalLength = this->GetLength() * (endId - startId + 1); -} + // Set DSM structure + std::vector > newStructure; + // determine size of application before the server + if (startId > 0) + { + newStructure.push_back(std::pair(aComm->GetApplicationName(), startId)); + } + newStructure.push_back(std::pair("Server", (endId + 1) - startId)); + if(aComm->GetInterSize() - (startId +((endId + 1) - startId)) > 0) + { + newStructure.push_back(std::pair(aComm->GetApplicationName(), aComm->GetInterSize() - (startId +((endId + 1) - startId)))); + } + aComm->SetDsmProcessStructure(newStructure); +} + +void +XdmfDSMBuffer::Connect(bool persist) +{ + int status; + + do { + try { + status = this->GetComm()->Connect(); + } + catch (XdmfError & e) { + throw e; + } + if (status == MPI_SUCCESS) { + this->SetIsConnected(true); + try { + this->ReceiveInfo(); + } + catch (XdmfError & e) { + throw e; + } + } + else { +#ifdef _WIN32 + Sleep(1000); + // Since windows has a different sleep command +#else + sleep(1); +#endif + } + } while (persist && (status != MPI_SUCCESS)); +} + +void +XdmfDSMBuffer::Disconnect() +{ + // Disconnecting is done manually + try { + this->GetComm()->Disconnect(); + } + catch (XdmfError & e) { + throw e; + } + this->SetIsConnected(false); +} void XdmfDSMBuffer::Get(long Address, long aLength, void *Data) @@ -335,7 +1033,12 @@ XdmfDSMBuffer::Get(long Address, long aLength, void *Data) // Figure out what server core the address is located on who = this->AddressToId(Address); if(who == XDMF_DSM_FAIL){ - XdmfError::message(XdmfError::FATAL, "Address Error"); + try { + XdmfError::message(XdmfError::FATAL, "Address Error"); + } + catch (XdmfError & e) { + throw e; + } } // Get the start and end of the block listed this->GetAddressRangeForId(who, &astart, &aend); @@ -356,8 +1059,18 @@ XdmfDSMBuffer::Get(long Address, long aLength, void *Data) if (this->Comm->GetInterComm() != MPI_COMM_NULL) { dataComm = XDMF_DSM_INTER_COMM; } - this->SendCommandHeader(XDMF_DSM_OPCODE_GET, who, Address - astart, len, dataComm); - this->ReceiveData(who, datap, len, XDMF_DSM_GET_DATA_TAG, Address - astart, dataComm); + try { + this->SendCommandHeader(XDMF_DSM_OPCODE_GET, who, Address - astart, len, dataComm); + } + catch (XdmfError & e) { + throw e; + } + try { + this->ReceiveData(who, datap, len, XDMF_DSM_GET_DATA_TAG, Address - astart, dataComm); + } + catch (XdmfError & e) { + throw e; + } } // Shift all the numbers by the length of the data written // Until aLength = 0 @@ -367,6 +1080,103 @@ XdmfDSMBuffer::Get(long Address, long aLength, void *Data) } } +void +XdmfDSMBuffer::Get(unsigned int * pages, unsigned int numPages, long Address, long aLength, void *Data) +{ + char * currentStart; + unsigned int currentPageId = Address / this->BlockLength; + unsigned int dsmPage; + long startingAddress = Address % this->BlockLength; + unsigned int tranferedLength; + unsigned int dataPage = 0; + + long pointeroffset = 0; + + int serverCore; + int writeAddress; + + while (aLength) { + if (dataPage == 0) { + tranferedLength = this->BlockLength - startingAddress; + } + else { + tranferedLength = this->BlockLength; + } + if (tranferedLength > aLength) { + tranferedLength = aLength; + } + + dsmPage = pages[currentPageId]; + + currentStart = (char *)Data + pointeroffset;; + + // Write page to DSM + // page to DSM server Id + // page to address + // write to location + + serverCore = PageToId(dsmPage); + writeAddress = PageToAddress(dsmPage); + + if (serverCore == XDMF_DSM_FAIL) { + XdmfError::message(XdmfError::FATAL, + "Error: Unable to determine server core."); + } + + if (writeAddress == XDMF_DSM_FAIL) { + XdmfError::message(XdmfError::FATAL, + "Error: Unable to determine write address."); + } + + if (dataPage == 0) + { + writeAddress += startingAddress; + } + + // If the data is on the core running this code, then the put is simple + if(serverCore == this->Comm->GetInterId()){ + char *dp; + dp = this->DataPointer; + dp += writeAddress; + memcpy(currentStart, dp, tranferedLength); + } + else{ + // Otherwise send it to the appropriate core to deal with + int dataComm = XDMF_DSM_INTRA_COMM; + if (this->Comm->GetInterComm() != MPI_COMM_NULL) { + dataComm = XDMF_DSM_INTER_COMM; + } + try { + this->SendCommandHeader(XDMF_DSM_OPCODE_GET, + serverCore, + writeAddress, + tranferedLength, + dataComm); + } + catch (XdmfError & e) { + throw e; + } + try { + this->ReceiveData(serverCore, + currentStart, + tranferedLength, + XDMF_DSM_GET_DATA_TAG, + writeAddress, + dataComm); + } + catch (XdmfError & e) { + throw e; + } + } + + aLength -= tranferedLength; + pointeroffset += tranferedLength; + // move to the next page + ++currentPageId; + ++dataPage; + } +} + void XdmfDSMBuffer::GetAddressRangeForId(int Id, int *Start, int *End){ switch(this->DsmType) { @@ -385,9 +1195,14 @@ XdmfDSMBuffer::GetAddressRangeForId(int Id, int *Start, int *End){ break; default : // Not Implemented - std::stringstream message; - message << "DsmType " << this->DsmType << " not yet implemented"; - XdmfError::message(XdmfError::FATAL, message.str()); + try { + std::stringstream message; + message << "DsmType " << this->DsmType << " not yet implemented"; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } break; } } @@ -428,6 +1243,12 @@ XdmfDSMBuffer::GetEndServerId() return this->EndServerId; } +int +XdmfDSMBuffer::GetInterCommType() +{ + return this->InterCommType; +} + bool XdmfDSMBuffer::GetIsConnected() { @@ -443,9 +1264,25 @@ XdmfDSMBuffer::GetIsServer() long XdmfDSMBuffer::GetLength() { + // This is the length of the pointer on the current core. + // Different from local buffer size as that value is + // the starting size. return this->Length; } +unsigned int +XdmfDSMBuffer::GetLocalBufferSizeMBytes() +{ + // This is the starting value, so it is not updated as the pointer is expanded. + return this->LocalBufferSizeMBytes; +} + +double +XdmfDSMBuffer::GetResizeFactor() +{ + return this->ResizeFactor; +} + int XdmfDSMBuffer::GetStartAddress() { @@ -464,6 +1301,118 @@ XdmfDSMBuffer::GetTotalLength() return this->TotalLength; } +void +XdmfDSMBuffer::Lock(char * filename) +{ + int strlength = std::string(filename).size(); + // Request access to the file + this->SendCommandHeader(XDMF_DSM_REQUEST_ACCESS, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + + this->SendAcknowledgment(this->GetStartServerId(), + strlength, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + filename, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + int isLocked = 0; + + this->ReceiveAcknowledgment(this->GetStartServerId(), + isLocked, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + if (isLocked == 1) + { + // If locked wait for notification that the file is available. + this->ReceiveAcknowledgment(this->GetStartServerId(), + isLocked, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + } +} + +int +XdmfDSMBuffer::PageToId(int pageId) +{ + int ServerId = XDMF_DSM_FAIL; + + switch(this->DsmType) { + case XDMF_DSM_TYPE_BLOCK_CYCLIC : + case XDMF_DSM_TYPE_BLOCK_RANDOM : + { + // Block based allocation should use PageToId + // All Servers have same length + // This finds out which server the address provided starts on + int serversize = (this->EndServerId - this->StartServerId); + if (serversize < 1) + { + serversize = 1; + } + ServerId = pageId % serversize;// This should only be called by the server + ServerId += this->StartServerId; // Apply the offset of the server if required. + break; + } + default : + // Not Implemented + try { + std::stringstream message; + message << "DsmType " << this->DsmType << " not yet implemented or not paged"; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } + break; + } + return(ServerId); +} + +int +XdmfDSMBuffer::PageToAddress(int pageId) +{ + int resultAddress = XDMF_DSM_FAIL; + + switch(this->DsmType) { + case XDMF_DSM_TYPE_BLOCK_CYCLIC : + case XDMF_DSM_TYPE_BLOCK_RANDOM : + { + // Block based allocation should use PageToId + // All Servers have same length + // This finds out which server the address provided starts on + // Since this is integers being divided the result is truncated. + int serversize = (this->EndServerId - this->StartServerId); + if (serversize < 1) + { + serversize = 1; + } + resultAddress = this->BlockLength * (pageId / serversize); + break; + } + default : + // Not Implemented + try { + std::stringstream message; + message << "DsmType " << this->DsmType << " not yet implemented or not paged"; + XdmfError::message(XdmfError::FATAL, message.str()); + } + catch (XdmfError & e) { + throw e; + } + break; + } + return(resultAddress); +} + void XdmfDSMBuffer::ProbeCommandHeader(int *comm) { @@ -484,8 +1433,13 @@ XdmfDSMBuffer::ProbeCommandHeader(int *comm) &signalStatus); if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, - "Error: Failed to probe for command header"); + try { + XdmfError::message(XdmfError::FATAL, + "Error: Failed to probe for command header"); + } + catch (XdmfError & e) { + throw e; + } } if (flag) { status = XDMF_DSM_SUCCESS; @@ -494,10 +1448,10 @@ XdmfDSMBuffer::ProbeCommandHeader(int *comm) if (static_cast(this->Comm)->GetInterComm() != MPI_COMM_NULL) { if (probeComm == static_cast(this->Comm)->GetIntraComm()) { probeComm = static_cast(this->Comm)->GetInterComm(); - } - else { + } + else { probeComm = static_cast(this->Comm)->GetIntraComm(); - } + } } } } @@ -524,7 +1478,12 @@ XdmfDSMBuffer::Put(long Address, long aLength, const void *Data) // Figure out what server core the address is located on who = this->AddressToId(Address); if(who == XDMF_DSM_FAIL){ - XdmfError::message(XdmfError::FATAL, "Address Error"); + try { + XdmfError::message(XdmfError::FATAL, "Address Error"); + } + catch (XdmfError & e) { + throw e; + } } // Get the start and end of the block listed this->GetAddressRangeForId(who, &astart, &aend); @@ -541,22 +1500,31 @@ XdmfDSMBuffer::Put(long Address, long aLength, const void *Data) } else{ // Otherwise send it to the appropriate core to deal with - int status; int dataComm = XDMF_DSM_INTRA_COMM; if (this->Comm->GetInterComm() != MPI_COMM_NULL) { dataComm = XDMF_DSM_INTER_COMM; } - this->SendCommandHeader(XDMF_DSM_OPCODE_PUT, - who, - Address - astart, - len, - dataComm); - this->SendData(who, - datap, - len, - XDMF_DSM_PUT_DATA_TAG, - Address - astart, - dataComm); + try { + this->SendCommandHeader(XDMF_DSM_OPCODE_PUT, + who, + Address - astart, + len, + dataComm); + } + catch (XdmfError & e) { + throw e; + } + try { + this->SendData(who, + datap, + len, + XDMF_DSM_PUT_DATA_TAG, + Address - astart, + dataComm); + } + catch (XdmfError & e) { + throw e; + } } // Shift all the numbers by the length of the data written // Until aLength = 0 @@ -566,42 +1534,122 @@ XdmfDSMBuffer::Put(long Address, long aLength, const void *Data) } } +void +XdmfDSMBuffer::Put(unsigned int * pages, unsigned int numPages, haddr_t Address, haddr_t aLength, const void *Data) +{ + + char * currentStart; + unsigned int currentPageId = Address / this->BlockLength; + unsigned int dsmPage = 0; + long startingAddress = Address % this->BlockLength; + unsigned int tranferedLength; + + long pointeroffset = 0; + + unsigned int dataPage = 0; + + int serverCore = 0; + int writeAddress = 0; + + while (aLength) { + if (dataPage == 0) { + tranferedLength = this->BlockLength - startingAddress; + } + else { + tranferedLength = this->BlockLength; + } + if (tranferedLength > aLength) { + tranferedLength = aLength; + } + + dsmPage = pages[currentPageId]; + + currentStart = (char *)Data + pointeroffset; + + // Write page to DSM + // page to DSM server Id + // page to address + // write to location + serverCore = PageToId(dsmPage); + + writeAddress = PageToAddress(dsmPage); + + if (serverCore == XDMF_DSM_FAIL) { + XdmfError::message(XdmfError::FATAL, "Error: Unable to determine page server core."); + } + if (writeAddress == XDMF_DSM_FAIL) { + XdmfError::message(XdmfError::FATAL, "Error: Unable to determine page address."); + } + + if (dataPage == 0) + { + writeAddress += startingAddress; + } + + // If the data is on the core running this code, then the put is simple + if(serverCore == this->Comm->GetInterId()) { + char *dp; + dp = this->DataPointer; + dp += writeAddress; + memcpy(dp, currentStart, tranferedLength); + } + else{ + // Otherwise send it to the appropriate core to deal with + int dataComm = XDMF_DSM_INTRA_COMM; + if (this->Comm->GetInterComm() != MPI_COMM_NULL) { + dataComm = XDMF_DSM_INTER_COMM; + } + try { + this->SendCommandHeader(XDMF_DSM_OPCODE_PUT, + serverCore, + writeAddress, + tranferedLength, + dataComm); + } + catch (XdmfError & e) { + throw e; + } + try { + this->SendData(serverCore, + currentStart, + tranferedLength, + XDMF_DSM_PUT_DATA_TAG, + writeAddress, + dataComm); + } + catch (XdmfError & e) { + throw e; + } + } + + aLength -= tranferedLength; + pointeroffset += tranferedLength; + // move to the next page + ++currentPageId; + ++dataPage; + } +} + void XdmfDSMBuffer::ReceiveAcknowledgment(int source, int &data, int tag, int comm) { int status; MPI_Status signalStatus; - if (comm == XDMF_DSM_INTRA_COMM) { - status = MPI_Recv(&data, - sizeof(int), - MPI_UNSIGNED_CHAR, - source, - tag, - static_cast(this->Comm)->GetIntraComm(), - &signalStatus); - } - else if (comm == XDMF_DSM_INTER_COMM) { - status = MPI_Recv(&data, - sizeof(int), - MPI_UNSIGNED_CHAR, - source, - tag, - static_cast(this->Comm)->GetInterComm(), - &signalStatus); - } - else { - MPI_Comm tempComm = MPI_Comm_f2c(comm); - status = MPI_Recv(&data, + + this->Comm->Receive(&data, sizeof(int), - MPI_UNSIGNED_CHAR, source, - tag, - tempComm, - &signalStatus); - } + comm, + tag); + status = MPI_SUCCESS; if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to receive data"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to receive data"); + } + catch (XdmfError & e) { + throw e; + } } } @@ -617,42 +1665,25 @@ XdmfDSMBuffer::ReceiveCommandHeader(int *opcode, int *source, int *address, int remoteSource = MPI_ANY_SOURCE; } - if (comm == XDMF_DSM_INTRA_COMM) { - status = MPI_Recv(&cmd, - sizeof(CommandMsg), - MPI_UNSIGNED_CHAR, - remoteSource, - XDMF_DSM_COMMAND_TAG, - static_cast(this->Comm)->GetIntraComm(), - &signalStatus); - } - else if (comm == XDMF_DSM_INTER_COMM) { - status = MPI_Recv(&cmd, - sizeof(CommandMsg), - MPI_UNSIGNED_CHAR, - remoteSource, - XDMF_DSM_COMMAND_TAG, - static_cast(this->Comm)->GetInterComm(), - &signalStatus); - } - else { - // In this case the integer is probably a pointer to an MPI_Comm object - MPI_Comm tempComm = MPI_Comm_f2c(comm); - status = MPI_Recv(&cmd, + this->Comm->Receive(&cmd, sizeof(CommandMsg), - MPI_UNSIGNED_CHAR, remoteSource, - XDMF_DSM_COMMAND_TAG, - tempComm, - &signalStatus); - } + comm, + XDMF_DSM_COMMAND_TAG); + + status = MPI_SUCCESS; if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to receive command header"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to receive command header"); + } + catch (XdmfError & e) { + throw e; + } } else { *opcode = cmd.Opcode; - *source = cmd.Source; + *source = cmd.Source; *address = cmd.Address; *aLength = cmd.Length; } @@ -663,36 +1694,19 @@ XdmfDSMBuffer::ReceiveData(int source, char * data, int aLength, int tag, int aA { int status; MPI_Status signalStatus; - if (comm == XDMF_DSM_INTRA_COMM) { - status = MPI_Recv(data, - aLength, - MPI_UNSIGNED_CHAR, - source, - tag, - static_cast(this->Comm)->GetIntraComm(), - &signalStatus); - } - else if (comm == XDMF_DSM_INTER_COMM) { - status = MPI_Recv(data, - aLength, - MPI_UNSIGNED_CHAR, - source, - tag, - static_cast(this->Comm)->GetInterComm(), - &signalStatus); - } - else { - MPI_Comm tempComm = MPI_Comm_f2c(comm); - status = MPI_Recv(data, + this->Comm->Receive(data, aLength, - MPI_UNSIGNED_CHAR, source, - tag, - tempComm, - &signalStatus); - } + comm, + tag); + status = MPI_SUCCESS; if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to receive data"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to receive data"); + } + catch (XdmfError & e) { + throw e; + } } } @@ -712,7 +1726,11 @@ XdmfDSMBuffer::ReceiveInfo() int * groupInfoStatus = new int[this->Comm->GetInterSize()](); - MPI_Allgather(&infoStatus, 1, MPI_INT, &(groupInfoStatus[0]), 1, MPI_INT, this->Comm->GetInterComm()); + this->Comm->AllGather(&infoStatus, + sizeof(int), + &(groupInfoStatus[0]), + sizeof(int), + XDMF_DSM_INTER_COMM); int sendCore = 0; @@ -721,13 +1739,20 @@ XdmfDSMBuffer::ReceiveInfo() sendCore = i; } } - status = MPI_Bcast(&dsmInfo, - sizeof(InfoMsg), - MPI_UNSIGNED_CHAR, - sendCore, - static_cast(this->Comm)->GetInterComm()); + + status = MPI_SUCCESS; + + this->Comm->Broadcast(&dsmInfo, + sizeof(InfoMsg), + sendCore, + XDMF_DSM_INTER_COMM); if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to broadcast info"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to broadcast info"); + } + catch (XdmfError & e) { + throw e; + } } this->SetDsmType(dsmInfo.type); // We are a client so don't allocate anything but only set a virtual remote length @@ -736,150 +1761,424 @@ XdmfDSMBuffer::ReceiveInfo() this->SetBlockLength(dsmInfo.block_length); this->StartServerId = dsmInfo.start_server_id; this->EndServerId = dsmInfo.end_server_id; -} -void -XdmfDSMBuffer::SendAccept(unsigned int numConnections) -{ - for (int i = this->StartServerId; i <= this->EndServerId; ++i) { - if (i != this->Comm->GetInterId()){ - this->SendCommandHeader(XDMF_DSM_ACCEPT, i, 0, 0, XDMF_DSM_INTER_COMM); - this->SendAcknowledgment(i, numConnections, XDMF_DSM_EXCHANGE_TAG, XDMF_DSM_INTER_COMM); - } - } - this->Comm->Accept(numConnections); - this->SendInfo(); -} + MPI_Comm comm = this->Comm->GetInterComm(); -void -XdmfDSMBuffer::SendAcknowledgment(int dest, int data, int tag, int comm) -{ - int status; + // Cray needs to be launched via the colon notation so that it + // can properly create a merged communicator - if (comm == XDMF_DSM_INTRA_COMM) { - status = MPI_Send(&data, - sizeof(int), - MPI_UNSIGNED_CHAR, - dest, - tag, - static_cast(this->Comm)->GetIntraComm()); - } - else if (comm == XDMF_DSM_INTER_COMM) { - status = MPI_Send(&data, - sizeof(int), - MPI_UNSIGNED_CHAR, - dest, - tag, - static_cast(this->Comm)->GetInterComm()); - } - else { - MPI_Comm tempComm = MPI_Comm_f2c(comm); - status = MPI_Send(&data, - sizeof(int), - MPI_UNSIGNED_CHAR, - dest, - tag, - tempComm); - } - if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to receive data"); - } -} + int rank = this->Comm->GetInterId(); + int size = this->Comm->GetInterSize(); -void -XdmfDSMBuffer::SendCommandHeader(int opcode, int dest, int address, int aLength, int comm) -{ - int status; - CommandMsg cmd; - memset(&cmd, 0, sizeof(CommandMsg)); - cmd.Opcode = opcode; - cmd.Source = this->Comm->GetId(); - cmd.Target = dest; - cmd.Address = address; - cmd.Length = aLength; + int currentCore = 0; + int * checkstatus = new int[size](); + int localCheck = 0; + std::string applicationName = this->Comm->GetApplicationName(); - if (comm == XDMF_DSM_INTRA_COMM) { - status = MPI_Send(&cmd, - sizeof(CommandMsg), - MPI_UNSIGNED_CHAR, - dest, - XDMF_DSM_COMMAND_TAG, - static_cast(this->Comm)->GetIntraComm()); + char * coreTag; + int tagSize = 0; + + std::vector coreSplit; + unsigned int splitid = 0; + + std::vector > newStructure; + + int * splitIds; + unsigned int splitsize = 0; + + while (currentCore < size) + { + if (rank == currentCore) + { + tagSize = applicationName.size(); + } + MPI_Bcast(&tagSize, 1, MPI_INT, currentCore, comm); + coreTag = new char[tagSize+1](); + + if (rank == currentCore) + { + strcpy(coreTag, applicationName.c_str()); + } + MPI_Bcast(coreTag, tagSize, MPI_CHAR, currentCore, comm); + coreTag[tagSize] = 0; + + if (strcmp(coreTag, applicationName.c_str()) == 0) + { + localCheck = 1; + } + else + { + localCheck = 0; + } + + checkstatus[rank] = localCheck; + + MPI_Allgather(&localCheck, 1, MPI_INT, + checkstatus, 1, MPI_INT, + comm); + + bool insplit = false; + while (checkstatus[currentCore]) + { + if (rank == currentCore) + { + insplit = true; + } + coreSplit.push_back(currentCore); + ++currentCore; + if (currentCore >= size) + { + break; + } + } + if (insplit) + { + splitIds = (int *)calloc(coreSplit.size(), sizeof(int)); + memcpy(splitIds, &(coreSplit[0]), coreSplit.size() * sizeof(int)); + splitsize = coreSplit.size(); + } + newStructure.push_back(std::pair(std::string(coreTag), coreSplit.size())); + coreSplit.clear(); + ++splitid; } - else if (comm == XDMF_DSM_INTER_COMM) { - int interSource = 0; - MPI_Comm_rank(static_cast(this->Comm)->GetInterComm(), &interSource); - cmd.Source = interSource; - status = MPI_Send(&cmd, - sizeof(CommandMsg), - MPI_UNSIGNED_CHAR, - dest, - XDMF_DSM_COMMAND_TAG, - static_cast(this->Comm)->GetInterComm()); + this->Comm->SetDsmProcessStructure(newStructure); +} + +int +XdmfDSMBuffer::RegisterFile(char * name, unsigned int * pages, unsigned int numPages, haddr_t start, haddr_t end) +{ + this->SendCommandHeader(XDMF_DSM_REGISTER_FILE, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + + int strlength = std::string(name).size(); + + this->SendAcknowledgment(this->GetStartServerId(), + strlength, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + name, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + (char *)&start, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + (char *)&end, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + this->SendAcknowledgment(this->GetStartServerId(), + numPages, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + if (numPages > 0) + { + this->SendData(this->GetStartServerId(), + (char *)pages, + numPages * sizeof(unsigned int), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); } - else { - // In this case the comm should be a pointer to an MPI_Comm object - MPI_Comm tempComm = MPI_Comm_f2c(comm); - status = MPI_Send(&cmd, - sizeof(CommandMsg), - MPI_UNSIGNED_CHAR, - dest, - XDMF_DSM_COMMAND_TAG, - tempComm); + + return XDMF_DSM_SUCCESS; +} + +int +XdmfDSMBuffer::RequestFileDescription(char * name, std::vector & pages, unsigned int & numPages, haddr_t & start, haddr_t & end) +{ + this->SendCommandHeader(XDMF_DSM_REQUEST_FILE, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + + int strlength = std::string(name).size(); + + this->SendAcknowledgment(this->GetStartServerId(), + strlength, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + name, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + int fileExists = XDMF_DSM_SUCCESS; + + this->ReceiveAcknowledgment(this->GetStartServerId(), + fileExists, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + if (fileExists == XDMF_DSM_SUCCESS) + { + this->ReceiveData(this->GetStartServerId(), + (char*)&start, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + this->ReceiveData(this->GetStartServerId(), + (char*)&end, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + int recvNumPages = 0; + + this->ReceiveAcknowledgment(this->GetStartServerId(), + recvNumPages, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + numPages = recvNumPages; + + // Reallocate pointer + pages.clear(); + + unsigned int * pagelist = new unsigned int[numPages]; + + this->ReceiveData(this->GetStartServerId(), + (char *)pagelist, + numPages * sizeof(unsigned int), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + for (unsigned int i = 0; i < numPages; ++i) + { + pages.push_back(pagelist[i]); + } + + return XDMF_DSM_SUCCESS; } + else + { + return XDMF_DSM_FAIL; + } +} + + +void +XdmfDSMBuffer::RequestPages(char * name, + haddr_t spaceRequired, + std::vector & pages, + unsigned int & numPages, + haddr_t & start, + haddr_t & end) +{ + this->SendCommandHeader(XDMF_DSM_REQUEST_PAGES, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + + // set aside pages to a file + int strlength = std::string(name).size(); + + this->SendAcknowledgment(this->GetStartServerId(), + strlength, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + name, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + // Request size required for the file + this->SendAcknowledgment(this->GetStartServerId(), + spaceRequired, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + // Send back new page allocation pointer + + int newPageCount = 0; + + this->ReceiveAcknowledgment(this->GetStartServerId(), + newPageCount, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + numPages = newPageCount; + + unsigned int * pagelist = new unsigned int[numPages](); + pages.clear(); + + this->ReceiveData(this->GetStartServerId(), + (char *) pagelist, + numPages * sizeof(unsigned int), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + for (unsigned int i = 0; i < numPages; ++i) + { + pages.push_back(pagelist[i]); + } + + // Recieve the new start and end addresses + this->ReceiveData(this->GetStartServerId(), + (char*)&start, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + this->ReceiveData(this->GetStartServerId(), + (char*)&end, + sizeof(haddr_t), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + // If resized, set up the reset the total length. + int currentLength = 0; + this->ReceiveAcknowledgment(this->GetStartServerId(), + currentLength, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + this->UpdateLength(currentLength); +} + +void +XdmfDSMBuffer::SendAccept(unsigned int numConnections) +{ +#ifndef XDMF_DSM_IS_CRAY + for (int i = this->StartServerId; i <= this->EndServerId; ++i) { + if (i != this->Comm->GetInterId()){ + this->SendCommandHeader(XDMF_DSM_ACCEPT, i, 0, 0, XDMF_DSM_INTER_COMM); + this->SendAcknowledgment(i, numConnections, XDMF_DSM_EXCHANGE_TAG, XDMF_DSM_INTER_COMM); + } + } + this->Comm->Accept(numConnections); + this->SendInfo(); +#endif +} + +void +XdmfDSMBuffer::SendAcknowledgment(int dest, int data, int tag, int comm) +{ + int status; + this->Comm->Send(&data, + sizeof(int), + dest, + comm, + tag); + status = MPI_SUCCESS; if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to send command header"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to receive data"); + } + catch (XdmfError & e) { + throw e; + } } } void -XdmfDSMBuffer::SendData(int dest, char * data, int aLength, int tag, int aAddress, int comm) +XdmfDSMBuffer::SendCommandHeader(int opcode, int dest, int address, int aLength, int comm) { int status; + CommandMsg cmd; + memset(&cmd, 0, sizeof(CommandMsg)); + cmd.Opcode = opcode; if (comm == XDMF_DSM_INTRA_COMM) { - status = MPI_Send(data, - aLength, - MPI_UNSIGNED_CHAR, - dest, - tag, - static_cast(this->Comm)->GetIntraComm()); + cmd.Source = this->Comm->GetId(); } else if (comm == XDMF_DSM_INTER_COMM) { - status = MPI_Send(data, - aLength, - MPI_UNSIGNED_CHAR, - dest, - tag, - static_cast(this->Comm)->GetInterComm()); + cmd.Source = this->Comm->GetInterId(); } - else { - MPI_Comm tempComm = MPI_Comm_f2c(comm); - status = MPI_Send(data, aLength, MPI_UNSIGNED_CHAR, dest, tag, tempComm); + cmd.Target = dest; + cmd.Address = address; + cmd.Length = aLength; + + this->Comm->Send(&cmd, + sizeof(CommandMsg), + dest, + comm, + XDMF_DSM_COMMAND_TAG); + status = MPI_SUCCESS; + if (status != MPI_SUCCESS) { + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to send command header"); + } + catch (XdmfError & e) { + throw e; + } } +} + +void +XdmfDSMBuffer::SendData(int dest, char * data, int aLength, int tag, int aAddress, int comm) +{ + int status; + + this->Comm->Send(data, + aLength, + dest, + comm, + tag); + status = MPI_SUCCESS; if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to send data"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to send data"); + } + catch (XdmfError & e) { + throw e; + } } } void XdmfDSMBuffer::SendDone() { - if (static_cast(this->Comm)->GetInterComm() == MPI_COMM_NULL) - { - for (int i = this->StartServerId; i <= this->EndServerId; ++i) { - if (i != this->Comm->GetId()){ - this->SendCommandHeader(XDMF_DSM_OPCODE_DONE, i, 0, 0, XDMF_DSM_INTRA_COMM); + try { + if (static_cast(this->Comm)->GetInterComm() == MPI_COMM_NULL) + { + for (int i = this->StartServerId; i <= this->EndServerId; ++i) { + if (i != this->Comm->GetId()){ + this->SendCommandHeader(XDMF_DSM_OPCODE_DONE, i, 0, 0, XDMF_DSM_INTRA_COMM); + } } } - } - else - { - for (int i = this->StartServerId; i <= this->EndServerId; ++i) { - if (i != this->Comm->GetId()){ - this->SendCommandHeader(XDMF_DSM_OPCODE_DONE, i, 0, 0, XDMF_DSM_INTER_COMM); + else + { + for (int i = this->StartServerId; i <= this->EndServerId; ++i) { + if (i != this->Comm->GetId()){ + this->SendCommandHeader(XDMF_DSM_OPCODE_DONE, i, 0, 0, XDMF_DSM_INTER_COMM); + } } } } + catch (XdmfError & e) { + throw e; + } } void @@ -903,13 +2202,11 @@ XdmfDSMBuffer::SendInfo() int * groupInfoStatus = new int[this->Comm->GetInterSize()](); - MPI_Allgather(&infoStatus, - 1, - MPI_INT, - &(groupInfoStatus[0]), - 1, - MPI_INT, - this->Comm->GetInterComm()); + this->Comm->AllGather(&infoStatus, + sizeof(int), + &(groupInfoStatus[0]), + sizeof(int), + XDMF_DSM_INTER_COMM); int sendCore = 0; @@ -919,14 +2216,101 @@ XdmfDSMBuffer::SendInfo() } } - status = MPI_Bcast(&dsmInfo, - sizeof(InfoMsg), - MPI_UNSIGNED_CHAR, - sendCore, - static_cast(this->Comm)->GetInterComm()); + status = MPI_SUCCESS; + + this->Comm->Broadcast(&dsmInfo, + sizeof(InfoMsg), + sendCore, + XDMF_DSM_INTER_COMM); if (status != MPI_SUCCESS) { - XdmfError::message(XdmfError::FATAL, "Error: Failed to send info"); + try { + XdmfError::message(XdmfError::FATAL, "Error: Failed to send info"); + } + catch (XdmfError & e) { + throw e; + } } + + MPI_Comm comm = this->Comm->GetInterComm(); + + // Cray needs to be launched via the colon notation so that it + // can properly create a merged communicator + + int rank = this->Comm->GetInterId(); + int size = this->Comm->GetInterSize(); + + int currentCore = 0; + int * checkstatus = new int[size](); + int localCheck = 0; + std::string applicationName = this->Comm->GetApplicationName(); + + char * coreTag; + int tagSize = 0; + + std::vector coreSplit; + unsigned int splitid = 0; + + std::vector > newStructure; + + int * splitIds; + unsigned int splitsize = 0; + + while (currentCore < size) + { + if (rank == currentCore) + { + tagSize = applicationName.size(); + } + MPI_Bcast(&tagSize, 1, MPI_INT, currentCore, comm); + coreTag = new char[tagSize+1](); + + if (rank == currentCore) + { + strcpy(coreTag, applicationName.c_str()); + } + MPI_Bcast(coreTag, tagSize, MPI_CHAR, currentCore, comm); + coreTag[tagSize] = 0; + + if (strcmp(coreTag, applicationName.c_str()) == 0) + { + localCheck = 1; + } + else + { + localCheck = 0; + } + + checkstatus[rank] = localCheck; + + MPI_Allgather(&localCheck, 1, MPI_INT, + checkstatus, 1, MPI_INT, + comm); + + bool insplit = false; + while (checkstatus[currentCore]) + { + if (rank == currentCore) + { + insplit = true; + } + coreSplit.push_back(currentCore); + ++currentCore; + if (currentCore >= size) + { + break; + } + } + if (insplit) + { + splitIds = (int *)calloc(coreSplit.size(), sizeof(int)); + memcpy(splitIds, &(coreSplit[0]), coreSplit.size() * sizeof(int)); + splitsize = coreSplit.size(); + } + newStructure.push_back(std::pair(std::string(coreTag), coreSplit.size())); + coreSplit.clear(); + ++splitid; + } + this->Comm->SetDsmProcessStructure(newStructure); } void @@ -947,6 +2331,12 @@ XdmfDSMBuffer::SetDsmType(int newDsmType) this->DsmType = newDsmType; } +void +XdmfDSMBuffer::SetInterCommType(int newType) +{ + this->InterCommType = newType; +} + void XdmfDSMBuffer::SetIsConnected(bool newStatus) { @@ -959,6 +2349,19 @@ XdmfDSMBuffer::SetIsServer(bool newIsServer) this->IsServer = newIsServer; } +void +XdmfDSMBuffer::SetResizeFactor(double newFactor) +{ + if (newFactor >= 0) + { + this->ResizeFactor = newFactor; + } + else + { + this->ResizeFactor = newFactor * -1; + } +} + void XdmfDSMBuffer::SetLength(long aLength) { @@ -989,4 +2392,639 @@ XdmfDSMBuffer::SetLength(long aLength) message << "Allocation Failed, unable to allocate " << this->Length; XdmfError::message(XdmfError::FATAL, message.str()); } + + if (this->BlockLength > 0) + { + this->NumPages = this->Length / this->BlockLength; + } +} + +void +XdmfDSMBuffer::SetLocalBufferSizeMBytes(unsigned int newSize) +{ + this->LocalBufferSizeMBytes = newSize; +} + +void +XdmfDSMBuffer::Unlock(char * filename) +{ + int strlength = std::string(filename).size(); + this->SendCommandHeader(XDMF_DSM_UNLOCK_FILE, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + + this->SendAcknowledgment(this->GetStartServerId(), + strlength, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + + this->SendData(this->GetStartServerId(), + filename, + strlength, + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); +} + +void +XdmfDSMBuffer::UpdateLength(unsigned int newLength) +{ + this->Length = newLength; + this->TotalLength = this->Length * (this->EndServerId - this->StartServerId); +} + +void +XdmfDSMBuffer::WaitRelease(std::string filename, std::string datasetname, int code) +{ + // Send Command Header + this->SendCommandHeader(XDMF_DSM_CLEAR_NOTIFY, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + // Send string size + this->SendAcknowledgment(this->GetStartServerId(), + filename.size() + datasetname.size(), + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + // Send string + char * sendPointer = new char[filename.size() + datasetname.size()](); + unsigned int placementIndex = 0; + for (unsigned int i = 0; i < filename.size(); ++i) + { + sendPointer[placementIndex++] = filename[i]; + } + for (unsigned int i = 0; i < datasetname.size(); ++i) + { + sendPointer[placementIndex++] = datasetname[i]; + } + this->SendData(this->GetStartServerId(), + sendPointer, + filename.size() + datasetname.size(), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + delete sendPointer; + // Send Release Code + this->SendAcknowledgment(this->GetStartServerId(), + code, + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); +} + +int +XdmfDSMBuffer::WaitOn(std::string filename, std::string datasetname) +{ + // Send Command Header + this->SendCommandHeader(XDMF_DSM_SET_NOTIFY, + this->GetStartServerId(), + 0, + 0, + XDMF_DSM_INTER_COMM); + // Send string size + this->SendAcknowledgment(this->GetStartServerId(), + filename.size() + datasetname.size(), + XDMF_DSM_EXCHANGE_TAG, + XDMF_DSM_INTER_COMM); + // Send string + char * sendPointer = new char[filename.size() + datasetname.size()](); + unsigned int placementIndex = 0; + for (unsigned int i = 0; i < filename.size(); ++i) + { + sendPointer[placementIndex++] = filename[i]; + } + for (unsigned int i = 0; i < datasetname.size(); ++i) + { + sendPointer[placementIndex++] = datasetname[i]; + } + this->SendData(this->GetStartServerId(), + sendPointer, + filename.size() + datasetname.size(), + XDMF_DSM_EXCHANGE_TAG, + 0, + XDMF_DSM_INTER_COMM); + + // Wait for Release + int code = 0; + this->ReceiveAcknowledgment(MPI_ANY_SOURCE, + code, + XDMF_DSM_EXCHANGE_TAG, + this->CommChannel); + delete sendPointer; + // Return Code from Notification + return code; +} + +// C Wrappers + +XDMFDSMBUFFER * XdmfDSMBufferNew() +{ + try + { + return (XDMFDSMBUFFER *)((void *)(new XdmfDSMBuffer())); + } + catch (...) + { + return (XDMFDSMBUFFER *)((void *)(new XdmfDSMBuffer())); + } +} + +void XdmfDSMBufferFree(XDMFDSMBUFFER * item) +{ + if (item != NULL) { + delete ((XdmfDSMBuffer *)item); + } + item = NULL; +} + +void XdmfDSMBufferBroadcastComm(XDMFDSMBUFFER * buffer, int *comm, int root, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->BroadcastComm(comm, root); + XDMF_ERROR_WRAP_END(status) +} + +int XdmfDSMBufferBufferService(XDMFDSMBUFFER * buffer, int *returnOpcode, int * status) +{ + XDMF_ERROR_WRAP_START(status) + return ((XdmfDSMBuffer *)buffer)->BufferService(returnOpcode); + XDMF_ERROR_WRAP_END(status) + return -1; +} + +void XdmfDSMBufferBufferServiceLoop(XDMFDSMBUFFER * buffer, int *returnOpcode, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->BufferServiceLoop(returnOpcode); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferConfigureUniform(XDMFDSMBUFFER * buffer, + XDMFDSMCOMMMPI * Comm, + long Length, + int StartId, + int EndId, + long aBlockLength, + int random, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->ConfigureUniform((XdmfDSMCommMPI *)Comm, Length, StartId, EndId, aBlockLength, random); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferConnect(XDMFDSMBUFFER * buffer, int persist, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->Connect(persist); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferCreate(XDMFDSMBUFFER * buffer, MPI_Comm comm, int startId, int endId, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->Create(comm, startId, endId); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferDisconnect(XDMFDSMBUFFER * buffer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->Disconnect(); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferGet(XDMFDSMBUFFER * buffer, long Address, long aLength, void * Data, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->Get(Address, aLength, Data); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferGetAddressRangeForId(XDMFDSMBUFFER * buffer, int Id, int * Start, int * End, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->GetAddressRangeForId(Id, Start, End); + XDMF_ERROR_WRAP_END(status) +} + +long XdmfDSMBufferGetBlockLength(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetBlockLength(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetBlockLength(); + } +} + +XDMFDSMCOMMMPI * XdmfDSMBufferGetComm(XDMFDSMBUFFER * buffer) +{ + try + { + return (XDMFDSMCOMMMPI *)((void *)(((XdmfDSMBuffer *)buffer)->GetComm())); + } + catch (...) + { + return (XDMFDSMCOMMMPI *)((void *)(((XdmfDSMBuffer *)buffer)->GetComm())); + } +} + +char * XdmfDSMBufferGetDataPointer(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetDataPointer(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetDataPointer(); + } +} + +int XdmfDSMBufferGetDsmType(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetDsmType(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetDsmType(); + } +} + +int XdmfDSMBufferGetEndAddress(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetEndAddress(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetEndAddress(); + } +} + +int XdmfDSMBufferGetEndServerId(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetEndServerId(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetEndServerId(); + } +} + +int XdmfDSMBufferGetInterCommType(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetInterCommType(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetInterCommType(); + } +} + +int XdmfDSMBufferGetIsConnected(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetIsConnected(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetIsConnected(); + } +} + +int XdmfDSMBufferGetIsServer(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetIsServer(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetIsServer(); + } +} + +long XdmfDSMBufferGetLength(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetLength(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetLength(); + } +} + +unsigned int XdmfDSMBufferGetLocalBufferSizeMBytes(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetLocalBufferSizeMBytes(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetLocalBufferSizeMBytes(); + } +} + +double XdmfDSMBufferGetResizeFactor(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetResizeFactor(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetResizeFactor(); + } +} + +int XdmfDSMBufferGetStartAddress(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetStartAddress(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetStartAddress(); + } +} + +int XdmfDSMBufferGetStartServerId(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetStartServerId(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetStartServerId(); + } +} + +long XdmfDSMBufferGetTotalLength(XDMFDSMBUFFER * buffer) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->GetTotalLength(); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->GetTotalLength(); + } +} + +void XdmfDSMBufferProbeCommandHeader(XDMFDSMBUFFER * buffer, int * comm, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->ProbeCommandHeader(comm); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferPut(XDMFDSMBUFFER * buffer, long Address, long aLength, void * Data, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->Put(Address, aLength, Data); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferReceiveAcknowledgment(XDMFDSMBUFFER * buffer, + int source, + int * data, + int tag, + int comm, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->ReceiveAcknowledgment(source, *data, tag, comm); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferReceiveCommandHeader(XDMFDSMBUFFER * buffer, + int * opcode, + int * source, + int * address, + int * aLength, + int comm, + int remoteSource, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->ReceiveCommandHeader(opcode, source, address, aLength, comm, remoteSource); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferReceiveData(XDMFDSMBUFFER * buffer, + int source, + char * data, + int aLength, + int tag, + int aAddress, + int comm, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->ReceiveData(source, data, aLength, tag, aAddress, comm); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferReceiveInfo(XDMFDSMBUFFER * buffer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->ReceiveInfo(); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferSendAccept(XDMFDSMBUFFER * buffer, unsigned int numConnects) +{ + ((XdmfDSMBuffer *)buffer)->SendAccept(numConnects); +} + +void XdmfDSMBufferSendAcknowledgment(XDMFDSMBUFFER * buffer, + int dest, + int data, + int tag, + int comm, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->SendAcknowledgment(dest, data, tag, comm); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferSendCommandHeader(XDMFDSMBUFFER * buffer, + int opcode, + int dest, + int address, + int aLength, + int comm, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->SendCommandHeader(opcode, dest, address, aLength, comm); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferSendData(XDMFDSMBUFFER * buffer, + int dest, + char * data, + int aLength, + int tag, + int aAddress, + int comm, + int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->SendData(dest, data, aLength, tag, aAddress, comm); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferSendDone(XDMFDSMBUFFER * buffer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->SendDone(); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferSendInfo(XDMFDSMBUFFER * buffer, int * status) +{ + XDMF_ERROR_WRAP_START(status) + ((XdmfDSMBuffer *)buffer)->SendInfo(); + XDMF_ERROR_WRAP_END(status) +} + +void XdmfDSMBufferSetBlockLength(XDMFDSMBUFFER * buffer, long newBlock) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetBlockLength(newBlock); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetBlockLength(newBlock); + } +} + +void XdmfDSMBufferSetComm(XDMFDSMBUFFER * buffer, XDMFDSMCOMMMPI * newComm) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetComm((XdmfDSMCommMPI *)newComm); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetComm((XdmfDSMCommMPI *)newComm); + } +} + +void XdmfDSMBufferSetDsmType(XDMFDSMBUFFER * buffer, int newDsmType) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetDsmType(newDsmType); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetDsmType(newDsmType); + } +} + +void XdmfDSMBufferSetInterCommType(XDMFDSMBUFFER * buffer, int newType) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetInterCommType(newType); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetInterCommType(newType); + } +} + +void XdmfDSMBufferSetIsConnected(XDMFDSMBUFFER * buffer, int newStatus) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetIsConnected(newStatus); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetIsConnected(newStatus); + } +} + +void XdmfDSMBufferSetIsServer(XDMFDSMBUFFER * buffer, int newIsServer) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetIsServer(newIsServer); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetIsServer(newIsServer); + } +} + +void XdmfDSMBufferSetLocalBufferSizeMBytes(XDMFDSMBUFFER * buffer, unsigned int newSize) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetLocalBufferSizeMBytes(newSize); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetLocalBufferSizeMBytes(newSize); + } +} + +void XdmfDSMBufferSetResizeFactor(XDMFDSMBUFFER * buffer, double newFactor) +{ + try + { + ((XdmfDSMBuffer *)buffer)->SetResizeFactor(newFactor); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->SetResizeFactor(newFactor); + } +} + +void XdmfDSMBufferWaitRelease(XDMFDSMBUFFER * buffer, char * filename, char * datasetname, int code) +{ + try + { + ((XdmfDSMBuffer *)buffer)->WaitRelease(std::string(filename), std::string(datasetname), code); + } + catch (...) + { + ((XdmfDSMBuffer *)buffer)->WaitRelease(std::string(filename), std::string(datasetname), code); + } +} + +int XdmfDSMBufferWaitOn(XDMFDSMBUFFER * buffer, char * filename, char * datasetname) +{ + try + { + return ((XdmfDSMBuffer *)buffer)->WaitOn(std::string(filename), std::string(datasetname)); + } + catch (...) + { + return ((XdmfDSMBuffer *)buffer)->WaitOn(std::string(filename), std::string(datasetname)); + } } diff --git a/core/dsm/XdmfDSMBuffer.hpp b/core/dsm/XdmfDSMBuffer.hpp index 9d49563b..ec2d4cb1 100644 --- a/core/dsm/XdmfDSMBuffer.hpp +++ b/core/dsm/XdmfDSMBuffer.hpp @@ -53,13 +53,21 @@ #ifndef XDMFDSMBUFFER_HPP_ #define XDMFDSMBUFFER_HPP_ -// Forward Declarations - -// Includes +// C Compatible Includes #include -#include #include +#include + +#ifndef _H5public_H + #ifndef XDMF_HADDR_T + #define XDMF_HADDR_T + typedef unsigned long haddr_t; + #endif +#endif +// Definitions + +/* #define XDMF_DSM_DEFAULT_TAG 0x80 #define XDMF_DSM_COMMAND_TAG 0x81 #define XDMF_DSM_SERVER_ACK_TAG 0x82 @@ -70,6 +78,7 @@ #define XDMF_DSM_ANY_TAG -1 #define XDMF_DSM_ANY_SOURCE -2 +*/ #define XDMF_DSM_TYPE_UNIFORM 0 #define XDMF_DSM_TYPE_UNIFORM_RANGE 1 @@ -87,14 +96,34 @@ #define XDMF_DSM_LOCK_ACQUIRE 0x03 #define XDMF_DSM_LOCK_RELEASE 0x05 +#define XDMF_DSM_SET_NOTIFY 0x06 +#define XDMF_DSM_CLEAR_NOTIFY 0x07 + #define XDMF_DSM_ACCEPT 0x10 #define XDMF_DSM_DISCONNECT 0x11 +#define XDMF_DSM_REGISTER_FILE 0x12 +#define XDMF_DSM_REQUEST_PAGES 0x13 +#define XDMF_DSM_REQUEST_FILE 0x14 + +#define XDMF_DSM_OPCODE_RESIZE 0x15 + +#define XDMF_DSM_REQUEST_ACCESS 0x16 +#define XDMF_DSM_UNLOCK_FILE 0x17 + #define XDMF_DSM_OPCODE_DONE 0xFF #define XDMF_DSM_SUCCESS 1 #define XDMF_DSM_FAIL -1 +#ifdef __cplusplus + +// Forward Declarations +class XdmfHDF5WriterDSM; + +// Includes +#include +#include /** * @brief Controls the data buffer for DSM. @@ -107,69 +136,11 @@ class XDMFDSM_EXPORT XdmfDSMBuffer { public: + friend class XdmfHDF5WriterDSM; + XdmfDSMBuffer(); ~XdmfDSMBuffer(); - /** - * Find the Id of the core that the provided address resides on. - * - * Example of use: - * - * C++ - * - * @dontinclude ExampleXdmfDSMNoThread.cpp - * @skipline //#initMPI - * @until //#initMPI - * @skipline //#initwritevector - * @until //#initwritevector - * @skipline //#initwritergenerate - * @until //#initwritergenerate - * @skipline //#startworksection - * @until //#startworksection - * @skipline //#declaremanager - * @until //#declaremanager - * @skipline //#getServerManagerwriter - * @until //#getServerManagerwriter - * @skipline //#declarebuffer - * @until //#declarebuffer - * @skipline //#GetDsmBuffer - * @until //#GetDsmBuffer - * @skipline //#AddressToId - * @until //#AddressToId - * @skipline //#endworksection - * @until //#endworksection - * @skipline //#stopDSMwriter - * @until //#stopDSMwriter - * @skipline //#finalizeMPI - * @until //#finalizeMPI - * - * Python - * - * @dontinclude XdmfExampleDSMNoThread.py - * @skipline #//initMPI - * @until #//initMPI - * @skipline #//initwritevector - * @until #//initwritevector - * @skipline #//initwritergenerate - * @until #//initwritergenerate - * @skipline #//startworksection - * @until #//startworksection - * @skipline #//getServerManagerwriter - * @until #//getServerManagerwriter - * @skipline #//GetDsmBuffer - * @until #//GetDsmBuffer - * @skipline #//AddressToId - * @until #//AddressToId - * @skipline #//stopDSMwriter - * @until #//stopDSMwriter - * @skipline #//finalizeMPI - * @until #//finalizeMPI - * - * @param Address The address to be found - * @return The id of the core that the address resides on - */ - int AddressToId(int Address); - /** * Broadcasts the provided comm from the specified core to all other cores. * @@ -186,14 +157,10 @@ public: * @until //#initwritergenerate * @skipline //#startworksection * @until //#startworksection - * @skipline //#declaremanager - * @until //#declaremanager - * @skipline //#getServerManagerwriter - * @until //#getServerManagerwriter * @skipline //#declarebuffer * @until //#declarebuffer - * @skipline //#GetDsmBuffer - * @until //#GetDsmBuffer + * @skipline //#getServerBufferwriter + * @until //#getServerBufferwriter * @skipline //#BroadcastComm * @until //#BroadcastComm * @skipline //#endworksection @@ -231,14 +198,10 @@ public: * @until //#initwritergenerate * @skipline //#startworksection * @until //#startworksection - * @skipline //#declaremanager - * @until //#declaremanager - * @skipline //#getServerManagerwriter - * @until //#getServerManagerwriter * @skipline //#declarebuffer * @until //#declarebuffer - * @skipline //#GetDsmBuffer - * @until //#GetDsmBuffer + * @skipline //#getServerBufferwriter + * @until //#getServerBufferwriter * @skipline //#BufferService * @until //#BufferService * @skipline //#endworksection @@ -259,10 +222,8 @@ public: * @until #//initwritergenerate * @skipline #//startworksection * @until #//startworksection - * @skipline #//getServerManagerwriter - * @until #//getServerManagerwriter - * @skipline #//GetDsmBuffer - * @until #//GetDsmBuffer + * @skipline #//getServerBufferwriter + * @until #//getServerBufferwriter * @skipline #//BufferService * @until #//BufferService * @skipline #//stopDSMwriter @@ -294,14 +255,10 @@ public: * @until //#initwritergenerate * @skipline //#startworksection * @until //#startworksection - * @skipline //#declaremanager - * @until //#declaremanager - * @skipline //#getServerManagerwriter - * @until //#getServerManagerwriter * @skipline //#declarebuffer * @until //#declarebuffer - * @skipline //#GetDsmBuffer - * @until //#GetDsmBuffer + * @skipline //#getServerBufferwriter + * @until //#getServerBufferwriter * @skipline //#BufferServiceLoop * @until //#BufferServiceLoop * @skipline //#endworksection @@ -322,10 +279,8 @@ public: * @until #//initwritergenerate * @skipline #//startworksection * @until #//startworksection - * @skipline #//getServerManagerwriter - * @until #//getServerManagerwriter - * @skipline #//GetDsmBuffer - * @until #//GetDsmBuffer + * @skipline #//getServerBufferwriter + * @until #//getServerBufferwriter * @skipline #//BufferServiceLoop * @until #//BufferServiceLoop * @skipline #//stopDSMwriter @@ -338,6 +293,61 @@ public: */ void BufferServiceLoop(int *returnOpcode = 0); + /** + * Creates an internal buffer based on the information provided. + * + * Example of use: + * + * C++ + * + * @dontinclude ExampleXdmfDSMNoThread.cpp + * @skipline //#initMPI + * @until //#initMPI + * @skipline //#initwritevector + * @until //#initwritevector + * @skipline //#initwritergenerate + * @until //#initwritergenerate + * @skipline //#startworksection + * @until //#startworksection + * @skipline //#declarebuffer + * @until //#declarebuffer + * @skipline //#getServerBufferwriter + * @until //#getServerBufferwriter + * @skipline //#Create + * @until //#Create + * @skipline //#endworksection + * @until //#endworksection + * @skipline //#stopDSMwriter + * @until //#stopDSMwriter + * @skipline //#finalizeMPI + * @until //#finalizeMPI + * + * Python + * + * @dontinclude XdmfExampleDSMNoThread.py + * @skipline #//initMPI + * @until #//initMPI + * @skipline #//initwritevector + * @until #//initwritevector + * @skipline #//initwritergenerate + * @until #//initwritergenerate + * @skipline #//startworksection + * @until #//startworksection + * @skipline #//getServerBufferwriter + * @until #//getServerBufferwriter + * @skipline #//Create + * @until #//Create + * @skipline #//stopDSMwriter + * @until #//stopDSMwriter + * @skipline #//finalizeMPI + * @until #//finalizeMPI + * + * @param newComm The communicator that will be used. + * @param startId The index of the first server node + * @param endId The index of the last server node + */ + void Create(MPI_Comm newComm, int startId = -1, int endId = -1); + /** * Configures the Buffer to match the configuration details provided. * @@ -354,14 +364,10 @@ public: * @until //#initwritergenerate * @skipline //#startworksection * @until //#startworksection - * @skipline //#declaremanager - * @until //#declaremanager - * @skipline //#getServerManagerwriter - * @until //#getServerManagerwriter * @skipline //#declarebuffer * @until //#declarebuffer - * @skipline //#GetDsmBuffer - * @until //#GetDsmBuffer + * @skipline //#getServerBufferrwriter + * @until //#getServerBufferwriter * @skipline //#ConfigureUniform * @until //#ConfigureUniform * @skipline //#endworksection @@ -382,10 +388,8 @@ public: * @until #//initwritergenerate * @skipline #//startworksection * @until #//startworksection - * @skipline #//getServerManagerwriter - * @until #//getServerManagerwriter - * @skipline #//GetDsmBuffer - * @until #//GetDsmBuffer + * @skipline #//getServerBufferwriter + * @until #//getServerBufferwriter * @skipline #//ConfigureUniform * @until #//ConfigureUniform * @skipline #//stopDSMwriter @@ -410,6 +414,73 @@ public: int StartId = -1, int EndId = -1, long aBlockLength = 0, bool random = false); + /** + * Attempts to connect the buffer to the port that is currently set. + * + * Example of use: + * + * C++ + * + * @dontinclude XdmfConnectTest.cpp + * @skipline //#initMPI + * @until //#initMPI + * @skipline //#ReadDsmPortName + * @until //#ReadDsmPortName + * @skipline //#Connect + * @until //#Connect + * @skipline //#Disconnectmanager + * @until //#Disconnectmanager + * @skipline //#finalizeMPI + * @until //#finalizeMPI + * + * Python + * + * @dontinclude XdmfExampleConnectTest.py + * @skipline #//initMPI + * @until #//initMPI + * @skipline #//ReadDsmPortName + * @until #//ReadDsmPortName + * @skipline #//Connect + * @until #//Connect + * @skipline #//Disconnectmanager + * + * @param persist Whether to try to connect repeatedly + */ + void Connect(bool persist = false); + + /** + * Disconnects the buffer from the port it was connected to. + * + * Example of use: + * + * C++ + * + * @dontinclude XdmfConnectTest.cpp + * @skipline //#initMPI