diff --git a/CMake/TestingSuite/TestDriverC.cmake.in b/CMake/TestingSuite/TestDriverC.cmake.in index 84123896638e02aee7780a06c5258d309db53150..d2c9b4a12706b697fdddd0970a5dc765a4df73cb 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 d6ff9098e5640a6ddd331818f9ed5342ca0f7f11..10c19bd1656f77129a6df0ffd9dfbdc02fbbd3b5 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 86d8f0cedb1f599d6f54f78c02f504a2ccb276b1..30dfa6a18d799803bce33c5f831bd45804bbf4fb 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 5d7d64e7695e2140cf1b4bcf3823cae8320bec1c..1d7dd7bdc7cdc1ffcdde0454449318b5cd37d9f3 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 c636aeaab62f75f253883d0386bbfbcb3bbd109e..5996f0386fd7612089ecb0b1ea2b278375652779 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 d9a065375bb750c67fc63fbec4e94c3af307b77d..68977f5cd2f3e2d4b76f197397e6a47e2ab805ec 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") - ENDIF() -ENDMACRO() + 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 6015a6e5aaa38ca90c7610cd8cceab2e5e6d1ecb..4458e109cd10adac1916a6b138b139f616e93aa2 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 918512f7ab610baa679f4695d1e68d2fd5b727c6..67f46ddeb412bd580aa593bf69a89c60ef268d41 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() @@ -27,6 +32,14 @@ MACRO(VersionMajorSet versionMajor) SET(vMajor ${versionMajor}) ENDMACRO() +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() diff --git a/CMakeLists.txt b/CMakeLists.txt index 48c592f318443633a238e4e4b61f0e0a9e9f05e0..5973019e4a232b2e74f7c9632b81cdd7d59de237 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,6 +31,14 @@ if(XDMF_BUILD_TESTING) include(CTest) endif() +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_CURRENT_BINARY_DIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) @@ -63,6 +71,19 @@ endif() 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) mark_as_advanced(XDMF_BUILD_DSM) @@ -85,6 +106,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 () + add_definitions(-DXDMF_BUILD_DSM) endif() # If we are wrapping either, we need swig @@ -121,7 +143,7 @@ if(XDMF_WRAP_PYTHON) # Output: # Target Name = the output target name will have ${python_name} as its name macro(XDMF_SWIG_PYTHON python_name) - set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}) + set(CMAKE_SWIG_OUTDIR ${CMAKE_BINARY_DIR}) # optimize swig generation --- these are all flags corresponding to -O # except -fvirtual which breaks visitor operation set(CMAKE_SWIG_FLAGS ${XDMF_SWIG_FLAGS} -modern -fastdispatch -nosafecstrings -noproxydel -fastproxy -fastinit -fastunpack -fastquery -modernargs -nobuildnone) @@ -146,7 +168,7 @@ if(XDMF_WRAP_PYTHON) endif() if(WIN32) - if(NOT MSVC10) + if(NOT MSVC10) set_target_properties(${SWIG_MODULE_${python_name}Python_REAL_NAME} PROPERTIES PREFIX ../ @@ -154,14 +176,13 @@ if(XDMF_WRAP_PYTHON) RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - endif() + endif() endif() set_target_properties(${SWIG_MODULE_${python_name}Python_REAL_NAME} 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) @@ -196,9 +217,9 @@ if(XDMF_WRAP_JAVA) # Target Name = the output target name will have ${java_name}Java as its name # Target Jar = the output target jar will have ${java_name}Java.jar as its name macro(XDMF_SWIG_JAVA java_name) - set(${java_name}_JAVA_JAR ${CMAKE_CURRENT_BINARY_DIR}/${java_name}.jar) + set(${java_name}_JAVA_JAR ${CMAKE_BINARY_DIR}/${java_name}.jar) set(XDMF_JAVA_PACKAGE_DIR mil/army/arl/xdmf) - set(XDMF_JAVA_DIR ${CMAKE_CURRENT_BINARY_DIR}/${XDMF_JAVA_PACKAGE_DIR}) + set(XDMF_JAVA_DIR ${CMAKE_BINARY_DIR}/${XDMF_JAVA_PACKAGE_DIR}) set(CMAKE_SWIG_OUTDIR ${XDMF_JAVA_DIR}) set(CMAKE_SWIG_FLAGS ${XDMF_SWIG_FLAGS} -v -make_default -package mil.army.arl.xdmf) set_source_files_properties(${java_name}.i PROPERTIES CPLUSPLUS ON) @@ -272,6 +293,7 @@ link_directories(${XDMF_LIBRARY_DIRS}) option(XDMF_BUILD_CORE_ONLY OFF) if(NOT XDMF_BUILD_CORE_ONLY) set(XdmfSources + XdmfAggregate XdmfAttribute XdmfAttributeCenter XdmfAttributeType @@ -283,6 +305,8 @@ if(NOT XDMF_BUILD_CORE_ONLY) XdmfGrid XdmfGridCollection XdmfGridCollectionType + XdmfGridController + XdmfGridTemplate XdmfItemFactory XdmfMap XdmfReader @@ -290,17 +314,34 @@ if(NOT XDMF_BUILD_CORE_ONLY) XdmfRegularGrid XdmfSet XdmfSetType + XdmfTemplate XdmfTime XdmfTopology XdmfTopologyType XdmfUnstructuredGrid) - add_library(${XDMF_LIBNAME} ${LIBTYPE} ${XdmfSources}) + add_library(XdmfObjects OBJECT ${XdmfSources}) + set_target_properties(XdmfObjects PROPERTIES + POSITION_INDEPENDENT_CODE True) + add_library(${XDMF_LIBNAME} $) + 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_LIBNAME} XdmfCore XdmfDSM) - else() + 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_LIBNAME} XdmfCore) - endif() + if (BUILD_SHARED_LIBS) + target_link_libraries(Xdmf_Static XdmfCore_Static) + endif (BUILD_SHARED_LIBS) + endif(XDMF_BUILD_DSM) if (COMMAND vtk_target_install) vtk_target_install(${XDMF_LIBNAME}) endif() @@ -308,28 +349,41 @@ if(NOT XDMF_BUILD_CORE_ONLY) if(WIN32) if (BUILD_SHARED_LIBS) set_target_properties(${XDMF_LIBNAME} PROPERTIES - DEFINE_SYMBOL XDMF_EXPORTS) - endif() - + DEFINE_SYMBOL Xdmf_EXPORTS) + set_target_properties(Xdmf_Static PROPERTIES + DEFINE_SYMBOL Xdmf_EXPORTS) + endif () if(NOT MSVC10) - set_target_properties(${XDMF_LIBNAME} PROPERTIES + set_target_properties(${XDMF_LIBNAME} PROPERTIES PREFIX ../ IMPORT_PREFIX ../ - RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} - LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} - ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - endif() - endif() + 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(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 () + endif() + endif() if(XDMF_WRAP_JAVA) XDMF_SWIG_JAVA(${XDMF_LIBNAME} Compiled_XdmfCore_Jar) endif() 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) if (XDMF_BUILD_DSM) - XDMF_SWIG_PYTHON(${XDMF_LIBNAME} XdmfCore) - else() XDMF_SWIG_PYTHON(${XDMF_LIBNAME} XdmfCore XdmfDSM) + else() + XDMF_SWIG_PYTHON(${XDMF_LIBNAME} XdmfCore) endif() set(XDMF_PYTHON_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/lib/python/) endif() @@ -348,8 +402,12 @@ if(NOT XDMF_BUILD_CORE_ONLY) endif() if(UNIX) - set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/lib${XDMF_LIBNAME}.so) - endif() + if (BUILD_SHARED_LIBS) + set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/lib${XDMF_LIBNAME}.so) + else (BUILD_SHARED_LIBS) + set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/lib${XDMF_LIBNAME}.a) + endif (BUILD_SHARED_LIBS) + endif(UNIX) if(APPLE) set(XDMF_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/lib${XDMF_LIBNAME}.dylib) @@ -367,6 +425,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() xdmf_create_config_file(${PROJECT_NAME}) diff --git a/Xdmf.dtd b/Xdmf.dtd new file mode 100644 index 0000000000000000000000000000000000000000..3e39e64bdc797c2e7a234f6395d4ed5a1b2cc7a2 --- /dev/null +++ b/Xdmf.dtd @@ -0,0 +1,85 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Xdmf.hpp b/Xdmf.hpp index 331dda89131e1d8b97f8ab2d8cfebe196eb8797b..db71bfa4ce8d1069191e4869af7202ad52cfae69 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: * diff --git a/Xdmf.i b/Xdmf.i index 9ab4344e11858a4a5f86fb8232241c2181fdf7e0..b86fb7c2f1ef49ece220bf95fe64bb3768c6242b 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 0000000000000000000000000000000000000000..c5cfdd91e59edab2d9bf8d2b95ea835228a390f8 --- /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 0000000000000000000000000000000000000000..e422bff098b3ce3d61ac5c227a66a82991d6373f --- /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 b984adb57f59f16c7ff57bb644730bb5687ebe9d..0c86abbfb1a89131eeef657830c229d8197b2689 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 f28f9b435837686d532d9a87f5b2fef6d51df8a6..ab07fd06d0fe654cde0cb8904bec487bd1d7b1df 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(); @@ -256,4 +259,32 @@ private: shared_ptr mType; }; +#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 a580b3111a5e1d947bd53eeee2a240ebf9b2b60a..0b7691ea93e84f936b2b11f4342aca55a6ed8528 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 71b00b88a185c30e5015b0631577ac800950a7e3..a0b761678df78e347a10d3a89ab8f8cee6cf3686 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 b2c0607e503664dd7e34ec6063ce88d2fa732aba..c0729ab033db349b48745ec5c9c1b24edf902829 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 d727592862b4ef8b122ab2b6c6d4a6d375be1c5e..4ffa6ed5cb19ee3404b88c8702172f2f1c4c1787 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 5aea41ffc9a616db69d7bc1e6917fdb7c15343a1..82f12d4a19fdd8f6029a4d95dc6d3c6812db2b60 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 @@ -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 8bce840b1a68d43686a1a9414789b7da9bdfe4e8..f580a3258885c5f11e1d581165d82d88366ebe77 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,46 @@ 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); }; +#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 c68550fa0d8cd730cf59f6855c99e125843f269d..a2ba9ff0e6775f10206e0d5b8f27ca7123015fb7 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 27f5a8f597434d8cd481609ab67ddb82d384d7dd..cdcaecffea5cbfd06434d29a74295cac11e1d4e8 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(); @@ -102,4 +106,323 @@ private: }; +#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 72902efea0033671f4db2c0e32261cb2ee13cc56..44fcfd45df55763037c97d80aba31c6db865872e 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 2d755a1082cd62212d60cb4531ddcc9ecd9051b8..8cd97cd27cc83f36ac1ae89a341a005aee5e0cb4 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,42 @@ private: int mNumberPoints; shared_ptr mType; + + std::vector mOrigin; }; +#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 df4677a27396669300d830f900d63c0868fe3921..f6a8c54f4ba637ee08c1cb1967f35af05787e3e2 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 df4ff317aca75cb272656cf6e05795740b2b957b..fa6e429fb48f449ba5de14160224b2282c3eb6d4 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 c102c2b6a351084d620c64f1091de456b5d21403..fc3ae232d74f62474fc402641480c3b919a8f7ef 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 f12b5e7e65c66a25451636a01138757c57cc1839..f06dac1ec061094b4dffce84417cb28f43fdb296 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); @@ -102,4 +104,38 @@ private: shared_ptr mTime; }; +#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 0f80fbc4c4617b80cecebd66a9c5b69225916976..1b992d801c6f557c4ca67256c00015eb1734eb45 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 03bf04ce13ffbb70305f81a2af5d3cac9b4f5fe2..04c25fcb29611868615d38191b3ae3f1ac0a58b5 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. @@ -276,4 +410,240 @@ private: }; +#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 d3a2604cfe60af08c9d0c9485e05e1c0dcf7284f..e4eef6b4b0dd6ef3dc52f4282643f889adffa5e5 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 ce36c4d6c49f7a11f1829c7287b432f88f536576..63dcaeee0c7e5caff5826526d5532129e92f5c36 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,12 +174,47 @@ 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. shared_ptr mType; }; +#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 f032f1c93b343d5f6d086cca3840b51e91bedc56..793f217aa6b3c406c60546ff2f15d3d0af594612 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 bb53835bc5f5fac8b4c86d5aa4bb4a06aaaa79d5..fabfed18e74913271a47d7194475a6eacb572e7f 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 0000000000000000000000000000000000000000..3d9a396447313e9c08515d846e0f81cb23495623 --- /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 0000000000000000000000000000000000000000..5a84dffaa27cca51ba5f1b1a2b1a32b96a88b115 --- /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/XdmfGridTemplate.cpp b/XdmfGridTemplate.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5e67990b54e33f2e341d566506901808f700b149 --- /dev/null +++ b/XdmfGridTemplate.cpp @@ -0,0 +1,975 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfTemplate.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 "XdmfArray.hpp" +#include "XdmfCurvilinearGrid.hpp" +#include "XdmfItem.hpp" +#include "XdmfItemFactory.hpp" +#include "XdmfReader.hpp" +#include "XdmfGridCollection.hpp" +#include "XdmfGridCollectionType.hpp" +#include "XdmfGridTemplate.hpp" +#include "XdmfRectilinearGrid.hpp" +#include "XdmfRegularGrid.hpp" +#include "XdmfTemplate.hpp" +#include "XdmfTopology.hpp" +#include "XdmfError.hpp" +#include "XdmfUnstructuredGrid.hpp" +#include "XdmfVisitor.hpp" +#include "XdmfWriter.hpp" + +#include "XdmfSystemUtils.hpp" + +#include + +#include + +shared_ptr +XdmfGridTemplate::New() +{ + shared_ptr p(new XdmfGridTemplate()); + return p; +} + + +XdmfGridTemplate::XdmfGridTemplate() : + XdmfTemplate(), + XdmfGridCollection(), + mTimeCollection(XdmfArray::New()) +{ + mTimeCollection->setName("Time Collection"); +} + +XdmfGridTemplate::XdmfGridTemplate(XdmfGridTemplate & refTemplate) : + XdmfTemplate(refTemplate), + XdmfGridCollection(refTemplate), + mTimeCollection(refTemplate.mTimeCollection) +{ +} + +XdmfGridTemplate::~XdmfGridTemplate() +{ +} + +const std::string XdmfGridTemplate::ItemTag = "Template"; + +unsigned int +XdmfGridTemplate::addStep() +{ + XdmfTemplate::addStep(); + if (shared_dynamic_cast(mBase)->getTime()) { + if (!mTimeCollection->isInitialized()) { + mTimeCollection->read(); + } + mTimeCollection->pushBack(shared_dynamic_cast(mBase)->getTime()->getValue()); + } + return mCurrentStep; +} + +std::map +XdmfGridTemplate::getItemProperties() const +{ + std::map templateProperties = XdmfGridCollection::getItemProperties(); + + templateProperties["BaseType"] = "Grid"; + return templateProperties; +} + +std::string +XdmfGridTemplate::getItemTag() const +{ + return ItemTag; +} + +shared_ptr +XdmfGridTemplate::getTimes() +{ + return mTimeCollection; +} + +shared_ptr +XdmfGridTemplate::getGridCollection(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + this->clearStep(); + this->setStep(index); + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get GridCollection from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getGridCollection(const unsigned int index) const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (index != mCurrentStep) + { + XdmfError::message(XdmfError::FATAL, "Error: GridTemplates can not return a constant reference to its base on an index other than the currently loaded one."); + return shared_ptr(); + } + else + { + return grid; + } + } + else { + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getGridCollection(const std::string & Name) +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get GridCollection from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getGridCollection(const std::string & Name) const +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get GridCollection from template without a base"); + return shared_ptr(); + } +} + +unsigned int +XdmfGridTemplate::getNumberGridCollections() const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return this->getNumberSteps(); + } + else { + return 0; + } +} + +void +XdmfGridTemplate::insert(const shared_ptr GridCollection) +{ + XdmfError::message(XdmfError::FATAL, "Error: Attempting to use insert to add an XdmfGridCollection to an XdmfGridTemplate. " + "Use addStep instead of insert to add to an XdmfGridTemplate"); +} + +void +XdmfGridTemplate::removeGridCollection(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + this->removeStep(index); + } + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get GridCollection from template without a base"); + } +} + +void +XdmfGridTemplate::removeGridCollection(const std::string & Name) +{ + XdmfError::message(XdmfError::FATAL, "Error: Removing Grids by name from XdmfGridTemplate is not supported"); +} + +shared_ptr +XdmfGridTemplate::getCurvilinearGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + this->clearStep(); + this->setStep(index); + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get CurvilinearGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getCurvilinearGrid(const unsigned int index) const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (index != mCurrentStep) + { + XdmfError::message(XdmfError::FATAL, "Error: GridTemplates can not return a constant reference to its base on an index other than the currently loaded one."); + return shared_ptr(); + } + else + { + return grid; + } + } + else { + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getCurvilinearGrid(const std::string & Name) +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get CurvilinearGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getCurvilinearGrid(const std::string & Name) const +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get CurvilinearGrid from template without a base"); + return shared_ptr(); + } +} + +unsigned int +XdmfGridTemplate::getNumberCurvilinearGrids() const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return this->getNumberSteps(); + } + else { + return 0; + } +} + +void +XdmfGridTemplate::insert(const shared_ptr CurvilinearGrid) +{ + XdmfError::message(XdmfError::FATAL, "Error: Attempting to use insert to add an XdmfCurvilinearGrid to an XdmfGridTemplate. " + "Use addStep instead of insert to add to an XdmfGridTemplate"); +} + +void +XdmfGridTemplate::removeCurvilinearGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + this->removeStep(index); + } + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get CurvilinearGrid from template without a base"); + } +} + +void +XdmfGridTemplate::removeCurvilinearGrid(const std::string & Name) +{ + XdmfError::message(XdmfError::FATAL, "Error: Removing Grids by name from XdmfGridTemplate is not supported"); +} + +shared_ptr +XdmfGridTemplate::getRectilinearGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + this->clearStep(); + this->setStep(index); + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RectilinearGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getRectilinearGrid(const unsigned int index) const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (index != mCurrentStep) + { + XdmfError::message(XdmfError::FATAL, "Error: GridTemplates can not return a constant reference to its base on an index other than the currently loaded one."); + return shared_ptr(); + } + else + { + return grid; + } + } + else { + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getRectilinearGrid(const std::string & Name) +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RectilinearGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getRectilinearGrid(const std::string & Name) const +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RectilinearGrid from template without a base"); + return shared_ptr(); + } +} + +unsigned int +XdmfGridTemplate::getNumberRectilinearGrids() const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return this->getNumberSteps(); + } + else { + return 0; + } +} + +void +XdmfGridTemplate::insert(const shared_ptr RectilinearGrid) +{ + XdmfError::message(XdmfError::FATAL, "Error: Attempting to use insert to add a XdmfRectilinearGrid to an XdmfGridTemplate." + "Use addStep instead of insert to add to an XdmfGridTemplate"); +} + +void +XdmfGridTemplate::removeRectilinearGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + this->removeStep(index); + } + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RectilinearGrid from template without a base"); + } +} + +void +XdmfGridTemplate::removeRectilinearGrid(const std::string & Name) +{ + XdmfError::message(XdmfError::FATAL, "Error: Removing Grids by name from XdmfGridTemplate is not supported"); +} + +shared_ptr +XdmfGridTemplate::getRegularGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + this->clearStep(); + this->setStep(index); + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RegularGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getRegularGrid(const unsigned int index) const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (index != mCurrentStep) + { + XdmfError::message(XdmfError::FATAL, "Error: GridTemplates can not return a constant reference to its base on an index other than the currently loaded one."); + return shared_ptr(); + } + else + { + return grid; + } + } + else { + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getRegularGrid(const std::string & Name) +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RegularGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getRegularGrid(const std::string & Name) const +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RegularGrid from template without a base"); + return shared_ptr(); + } +} + +unsigned int +XdmfGridTemplate::getNumberRegularGrids() const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return this->getNumberSteps(); + } + else { + return 0; + } +} + +void +XdmfGridTemplate::insert(const shared_ptr RegularGrid) +{ + XdmfError::message(XdmfError::FATAL, "Error: Attempting to use insert to add an XdmfRegularGrid to an XdmfGridTemplate." + "Use addStep instead of insert to add to an XdmfGridTemplate"); +} + +void +XdmfGridTemplate::removeRegularGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + this->removeStep(index); + } + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get RegularGrid from template without a base"); + } +} + +void +XdmfGridTemplate::removeRegularGrid(const std::string & Name) +{ + XdmfError::message(XdmfError::FATAL, "Error: Removing Grids by name from XdmfGridTemplate is not supported"); +} + +shared_ptr +XdmfGridTemplate::getUnstructuredGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + this->clearStep(); + this->setStep(index); + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get UnstructuredGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getUnstructuredGrid(const unsigned int index) const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (index != mCurrentStep) + { + XdmfError::message(XdmfError::FATAL, "Error: GridTemplates can not return a constant reference to its base on an index other than the currently loaded one."); + return shared_ptr(); + } + else + { + return grid; + } + } + else { + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getUnstructuredGrid(const std::string & Name) +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get UnstructuredGrid from template without a base"); + return shared_ptr(); + } +} + +shared_ptr +XdmfGridTemplate::getUnstructuredGrid(const std::string & Name) const +{ + if (mBase) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + if (grid->getName().compare(Name) == 0) { + return grid; + } + else { + return shared_ptr(); + } + } + else { + return shared_ptr(); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get UnstructuredGrid from template without a base"); + return shared_ptr(); + } +} + +unsigned int +XdmfGridTemplate::getNumberUnstructuredGrids() const +{ + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + return this->getNumberSteps(); + } + else { + return 0; + } +} + + +void +XdmfGridTemplate::insert(const shared_ptr UnstructuredGrid) +{ + XdmfError::message(XdmfError::FATAL, "Error: Attempting to use insert to add an XdmfUnstructuredGrid to an XdmfGridTemplate." + "Use addStep instead of insert to add to an XdmfGridTemplate"); +} + +void +XdmfGridTemplate::removeUnstructuredGrid(const unsigned int index) +{ + if (mBase) { + if (index < getNumberSteps()) { + if (shared_ptr grid = + shared_dynamic_cast(mBase)) { + this->removeStep(index); + } + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Attempting to get UnstructuredGrid from template without a base"); + } +} + + +void +XdmfGridTemplate::removeUnstructuredGrid(const std::string & Name) +{ + XdmfError::message(XdmfError::FATAL, "Error: Removing Grids by name from XdmfGridTemplate is not supported"); +} + +void +XdmfGridTemplate::populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader) +{ + // We are overrriding the populate item of the template and grid collection here + // The template functions internally different from either. + + this->setType(XdmfGridCollectionType::New(itemProperties)); + + // The first child item is the base + mBase = childItems[0]; + mCurrentStep = 0; + + if (childItems.size() > 1) { + for(std::vector >::const_iterator iter = + childItems.begin() + 1; + iter != childItems.end(); + ++iter) { + if(shared_ptr array = shared_dynamic_cast(*iter)) { + if (array->getName().compare("Data Description") == 0) { + // Split description into substrings based on the " character + + if (array->getNumberHeavyDataControllers() > 0 & !mHeavyWriter) { + mHeavyWriter = reader->generateHeavyDataWriter(array->getHeavyDataController(0)->getName(), array->getHeavyDataController(0)->getFilePath()); + } + + array->read(); + + // If a character array, create std::string version? TODO + std::string descriptionString; + if (array->getArrayType() == XdmfArrayType::Int8()) + { + descriptionString = std::string((char *)array->getValuesInternal()); + } + else if (array->getArrayType() == XdmfArrayType::String()) + { + descriptionString = array->getValue(0); + } + + size_t index = descriptionString.find_first_of("\""); + size_t previousIndex = 0; + + if (index != std::string::npos) { + // Removing the prepended " + previousIndex = index + 1; + index = descriptionString.find_first_of("\"", previousIndex); + } + + while (index != std::string::npos) { + std::string type = descriptionString.substr(previousIndex, index - previousIndex); + mDataTypes.push_back(type); + previousIndex = index + 1; + index = descriptionString.find_first_of("\"", previousIndex); + if (index - previousIndex > 0) { + std::string description; + description = descriptionString.substr(previousIndex, index - previousIndex); + mDataDescriptions.push_back(description); + // create controllers here based on the type/description? + // Is array type already filled? + // Potentially call "fillControllers" after populating? + if (index != std::string::npos) { + previousIndex = index + 1; + index = descriptionString.find_first_of("\"", previousIndex); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Type without a description in XdmfTemplate::populateItem"); + } + } + } + else if (array->getName().compare("Time Collection") == 0) { + mTimeCollection = array; + } + else { + mTrackedArrays.push_back(array.get()); + mTrackedArrayDims.push_back(array->getDimensions()); + mTrackedArrayTypes.push_back(array->getArrayType()); + } + } + } + } + mDataControllers.resize(mDataTypes.size()); + if (!mItemFactory) { + mItemFactory = XdmfItemFactory::New(); + } + std::map populateProperties; + if (mHeavyWriter) { + // The heavy writer provides the XMLDir, which is used to get full paths for the controllers + // It is assumed that the files that the controllers reference are in the same directory + // as the file that the writer references + std::string filepath = XdmfSystemUtils::getRealPath(mHeavyWriter->getFilePath()); + size_t index = filepath.find_last_of("/\\"); + filepath = filepath.substr(0, index + 1); + populateProperties["XMLDir"] = filepath; + } + for (unsigned int i = 0; i < mDataDescriptions.size(); ++i) { + populateProperties["Content"] = mDataDescriptions[i]; + std::vector > readControllers = + reader->generateHeavyDataControllers(populateProperties, mTrackedArrayDims[i % mTrackedArrays.size()], mTrackedArrayTypes[i % mTrackedArrays.size()], mDataTypes[i]); + if (readControllers.size() > 0) { + // Heavy data controllers reference the data + for (unsigned int j = 0; j < readControllers.size(); ++j) { + mDataControllers[i].push_back(readControllers[j]); + } + } + } + // Compare the first set of controllers to the size of the first array + unsigned int controllerTotal = 0; + for (unsigned int i = 0; i < mDataControllers[0].size(); ++i) + { + controllerTotal += mDataControllers[0][i]->getSize(); + } + // If the array is smaller, set the writer to append. + if (controllerTotal > mTrackedArrays[0]->getSize()) + { + mHeavyWriter->setMode(XdmfHeavyDataWriter::Append); + mNumSteps = controllerTotal / mTrackedArrays[0]->getSize(); + } + else { + mNumSteps = mDataControllers.size() / mTrackedArrays.size(); + } +} + +void +XdmfGridTemplate::removeStep(unsigned int stepId) +{ + if (stepId < this->getNumberSteps()) { + XdmfTemplate::removeStep(stepId); + mTimeCollection->erase(stepId); + } + this->setIsChanged(true); +} + +void +XdmfGridTemplate::setBase(shared_ptr newBase) +{ + if (shared_ptr grid = shared_dynamic_cast(newBase)) { + XdmfTemplate::setBase(newBase); + } + else { + XdmfError::message(XdmfError::FATAL, "Error: XdmfGridTemplate::setBase," + " attempting to set a Base that is not grid type."); + } +} + +void +XdmfGridTemplate::setStep(unsigned int stepId) +{ + XdmfTemplate::setStep(stepId); + if (mTimeCollection->getSize() >= stepId) { + if (!mTimeCollection->isInitialized()) { + mTimeCollection->read(); + } + if (shared_dynamic_cast(mBase)->getTime()) { + shared_dynamic_cast(mBase)->getTime()->setValue(mTimeCollection->getValue(stepId)); + } + else { + shared_dynamic_cast(mBase)->setTime(XdmfTime::New(mTimeCollection->getValue(stepId))); + } + } +} + +void +XdmfGridTemplate::setStep(shared_ptr time) +{ + if (mTimeCollection->getSize() > 0) + { + if (!mTimeCollection->isInitialized()) { + mTimeCollection->read(); + } + unsigned int index = 0; + while (index < mTimeCollection->getSize() && + time->getValue() != mTimeCollection->getValue(index)) + { + ++index; + } + if (index < mTimeCollection->getSize()) + { + this->setStep(index); + } + } +} + +void +XdmfGridTemplate::traverse(const shared_ptr visitor) +{ + // We are only using the template traverse + // since the grid data is only held in the Base + if (mTimeCollection->getSize() > 0) + { + this->setType(XdmfGridCollectionType::Temporal()); + } + else + { + this->setType(XdmfGridCollectionType::Spatial()); + } + XdmfTemplate::traverse(visitor); + mTimeCollection->accept(visitor); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfGridTemplate, XDMFGRIDTEMPLATE) diff --git a/XdmfGridTemplate.hpp b/XdmfGridTemplate.hpp new file mode 100644 index 0000000000000000000000000000000000000000..b9b203a8178d1081bb1acfd100912545fd7dfb91 --- /dev/null +++ b/XdmfGridTemplate.hpp @@ -0,0 +1,224 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfTemplate.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 XDMFGRIDTEMPLATE_HPP_ +#define XDMFGRIDTEMPLATE_HPP_ + +// C Compatible Includes +#include "Xdmf.hpp" +#include "XdmfItem.hpp" +#include "XdmfGridCollection.hpp" +#include "XdmfItemFactory.hpp" +#include "XdmfTemplate.hpp" +#include "XdmfArray.hpp" +#include "XdmfHeavyDataWriter.hpp" + +#ifdef __cplusplus + +// Includes + +/** + * @brief Defines a template that can be filled with multiple sets of data. + * + * An XdmfTemplate defines a structure. The arrays within that structure + * are stored if they are not initialized when the structure is first set. + * Steps can then be added and references to heavy data are produced and + * stored for later retrieval. + * + * This effectively lets an object have several variations with different + * contained data. + */ +class XDMF_EXPORT XdmfGridTemplate : public XdmfTemplate, + public XdmfGridCollection { + +public: + + /** + * Creates a new instance of the XdmfTemplate object + * + * @return A constructed XdmfTemplate object. + */ + static shared_ptr New(); + + virtual ~XdmfGridTemplate(); + + LOKI_DEFINE_VISITABLE(XdmfGridTemplate, XdmfGrid); + static const std::string ItemTag; + + /** + * Writes all tracked arrays to heavy data via the provided + * heavy data writer then stores the heavy data descriptions. + * + * @return The ID of the step that was added + */ + virtual unsigned int addStep(); + + std::map getItemProperties() const; + + std::string getItemTag() const; + + using XdmfGrid::insert; + + // Overriding the parent versions so that all of these reference the Base item + // instead of the template + + virtual shared_ptr getTimes(); + + virtual shared_ptr getGridCollection(const unsigned int index); + + virtual shared_ptr getGridCollection(const unsigned int index) const; + + virtual shared_ptr getGridCollection(const std::string & Name); + + virtual shared_ptr getGridCollection(const std::string & Name) const; + + virtual unsigned int getNumberGridCollections() const; + + virtual void insert(const shared_ptr GridCollection); + + virtual void removeGridCollection(const unsigned int index); + + virtual void removeGridCollection(const std::string & Name); + + virtual shared_ptr getCurvilinearGrid(const unsigned int index); + + virtual shared_ptr getCurvilinearGrid(const unsigned int index) const; + + virtual shared_ptr getCurvilinearGrid(const std::string & Name); + + virtual shared_ptr getCurvilinearGrid(const std::string & Name) const; + + virtual unsigned int getNumberCurvilinearGrids() const; + + virtual void insert(const shared_ptr CurvilinearGrid); + + virtual void removeCurvilinearGrid(const unsigned int index); + + virtual void removeCurvilinearGrid(const std::string & Name); + + virtual shared_ptr getRectilinearGrid(const unsigned int index); + + virtual shared_ptr getRectilinearGrid(const unsigned int index) const; + + virtual shared_ptr getRectilinearGrid(const std::string & Name); + + virtual shared_ptr getRectilinearGrid(const std::string & Name) const; + + virtual unsigned int getNumberRectilinearGrids() const; + + virtual void insert(const shared_ptr RectilinearGrid); + + virtual void removeRectilinearGrid(const unsigned int index); + + virtual void removeRectilinearGrid(const std::string & Name); + + virtual shared_ptr getRegularGrid(const unsigned int index); + + virtual shared_ptr getRegularGrid(const unsigned int index) const; + + virtual shared_ptr getRegularGrid(const std::string & Name); + + virtual shared_ptr getRegularGrid(const std::string & Name) const; + + virtual unsigned int getNumberRegularGrids() const; + + virtual void insert(const shared_ptr RegularGrid); + + virtual void removeRegularGrid(const unsigned int index); + + virtual void removeRegularGrid(const std::string & Name); + + virtual shared_ptr getUnstructuredGrid(const unsigned int index); + + virtual shared_ptr getUnstructuredGrid(const unsigned int index) const; + + virtual shared_ptr getUnstructuredGrid(const std::string & Name); + + virtual shared_ptr getUnstructuredGrid(const std::string & Name) const; + + virtual unsigned int getNumberUnstructuredGrids() const; + + virtual void insert(const shared_ptr UnstructuredGrid); + + virtual void removeUnstructuredGrid(const unsigned int index); + + virtual void removeUnstructuredGrid(const std::string & Name); + + /** + * + */ + virtual void removeStep(unsigned int stepId); + + virtual void setBase(shared_ptr newBase); + + /** + * Reads in the heavy data associated with the provided step id. + * + * @param stepId The id of the step whose heavy data + * is to be read in from file + */ + void setStep(unsigned int stepId); + + void setStep(shared_ptr time); + + void traverse(const shared_ptr visitor); + + XdmfGridTemplate(XdmfGridTemplate &); + +protected: + + XdmfGridTemplate(); + + virtual void + populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader); + + shared_ptr mTimeCollection; + +private: + + XdmfGridTemplate(const XdmfGridTemplate &); // Not implemented. + void operator=(const XdmfGridTemplate &); // Not implemented. + +}; + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFGRIDTEMPLATE; // Simply as a typedef to ensure correct typing +typedef struct XDMFGRIDTEMPLATE XDMFGRIDTEMPLATE; + +XDMF_ITEM_C_CHILD_DECLARE(XdmfGridTemplate, XDMFGRIDTEMPLATE, XDMF) + +#ifdef __cplusplus +} +#endif + + +#endif /* XDMFGRIDTEMPLATE_HPP_ */ diff --git a/XdmfItemFactory.cpp b/XdmfItemFactory.cpp index 133981c7ad0046020d6ca064f2a917d99ea28f24..7642209690edbc096f2ef72bf5af09c1d4b72919 100644 --- a/XdmfItemFactory.cpp +++ b/XdmfItemFactory.cpp @@ -32,13 +32,16 @@ #include "XdmfGeometryType.hpp" #include "XdmfGraph.hpp" #include "XdmfGridCollection.hpp" +#include "XdmfGridTemplate.hpp" #include "XdmfInformation.hpp" #include "XdmfItemFactory.hpp" +#include "XdmfAggregate.hpp" #include "XdmfMap.hpp" #include "XdmfRectilinearGrid.hpp" #include "XdmfRegularGrid.hpp" #include "XdmfSet.hpp" #include "XdmfSparseMatrix.hpp" +#include "XdmfTemplate.hpp" #include "XdmfTime.hpp" #include "XdmfTopology.hpp" #include "XdmfUnstructuredGrid.hpp" @@ -63,8 +66,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 +81,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 +134,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 +161,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 +173,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 +213,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(); } @@ -175,6 +232,22 @@ XdmfItemFactory::createItem(const std::string & itemTag, else if(itemTag.compare(XdmfSparseMatrix::ItemTag) == 0) { return XdmfSparseMatrix::New(0, 0); } + else if (itemTag.compare(XdmfTemplate::ItemTag) == 0) { + std::map::const_iterator type = + itemProperties.find("BaseType"); + if(type == itemProperties.end()) { + return XdmfTemplate::New(); + } + else { + if (type->second.compare("Grid") == 0) { + return XdmfGridTemplate::New(); + } + else { + return XdmfTemplate::New(); + } + } + return XdmfTemplate::New(); + } else if(itemTag.compare(XdmfTime::ItemTag) == 0) { return XdmfTime::New(); } @@ -193,8 +266,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 +284,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 +295,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 +306,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 3cd144d4e03bbdafb4b86c115dda8fd8adf7fd92..8c85546345db20a398516c26dbff7c481dce8cfb 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(); @@ -78,4 +96,7 @@ private: }; + +#endif + #endif /* XDMFITEMFACTORY_HPP_ */ diff --git a/XdmfMap.cpp b/XdmfMap.cpp index d4999e70879824e1d8a9a4ac11b808310f1bfe0b..46bbecfb94f18dd6b2be348e19313b2cfb1feafc 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 b62c84b3a33eeb1ac241e7953b9a4e2efca4fd8d..aca1ae57d5b7c1d89e7fac6a0ce7921413d0f955 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 323161dac3bcc82305a6aac3091de02cb5680146..8af91fdc9573522f6b2f29b55f1e0e642c746d75 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 a56595132698ca9a39a4f82e071b349bc3c3498c..bc3301e769999323d388514aacf449788149e1c5 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,20 +65,51 @@ 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. }; +#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 2ffcb118fd90b7965a3e29ff02726a9c2ca74253..8ec1a0028a3cded28e23ad0155ce8ae351b90dc1 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 dcb41672a47a95daeeb3e042fe73bbfdb710df91..73f5bc147abc5f7dfdde477f623964dac6b16f90 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,42 @@ private: XdmfRectilinearGrid(const XdmfRectilinearGrid &); // Not implemented. void operator=(const XdmfRectilinearGrid &); // Not implemented. - XdmfRectilinearGridImpl * mImpl; - }; +#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 fdba0bab3f6905ab95801ee972caf410f690d07f..1aa91c0e6205c17c596694a82ab83bc60e1e1c83 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 @@ -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 615288b3e807535f8d733156fdf2feecf5d11a0c..6b8c3a614fbdac8e5afd5fcd81ed9ebb5ced4710 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,58 @@ private: XdmfRegularGrid(const XdmfRegularGrid &); // Not implemented. void operator=(const XdmfRegularGrid &); // Not implemented. - XdmfRegularGridImpl * mImpl; - }; +#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 99b619036705b217b3ab1ddf9b382dc12d03f0d3..93c9bfd8fe73d08dc52e3823f0145d814632d6b2 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 660b3dcc171c5435b9577ebbee38175d084736ae..5b239aa8b39ecbeb1f42e7c60d8e216aea8bd24f 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,11 +211,47 @@ protected: private: - XdmfSet(const XdmfSet &); // Not implemented. + XdmfSet(const XdmfSet &); void operator=(const XdmfSet &); // Not implemented. std::string mName; shared_ptr mType; }; +#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 f100c0492f3334082f9a5bfec55015caa64a64b0..5e8089695a718f4a5d3bd3ab0f8344af964718d2 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 6ae470d928a79a1665419c3350bc2e4e3e8a8664..4ffa3af93a89c4227da14adeefc7965fbc0a8a60 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/XdmfTemplate.cpp b/XdmfTemplate.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b9c19af52e9d6f92ba75fe154308f3d8a51cadf8 --- /dev/null +++ b/XdmfTemplate.cpp @@ -0,0 +1,1244 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfTemplate.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 +#include "XdmfArray.hpp" +#include "XdmfHDF5Controller.hpp" +#include "XdmfBinaryController.hpp" +#include "XdmfItem.hpp" +#include "XdmfItemFactory.hpp" +#include "XdmfReader.hpp" +#include "XdmfTemplate.hpp" +#include "XdmfError.hpp" +#include "XdmfVisitor.hpp" +#include "XdmfWriter.hpp" + +#include "XdmfSystemUtils.hpp" + +#include + +#include + +std::vector > +getStepControllers(unsigned int stepId, + std::vector stepDims, + std::vector > datasetControllers) +{ + std::vector > returnVector; + if (datasetControllers.size() > 0) + { + unsigned int sizePerStep = 1; + for (unsigned int i = 0; i < stepDims.size(); ++i) + { + sizePerStep *= stepDims[i]; + } +// unsigned int offset = (sizePerStep * stepId); +// unsigned int offsetStepsRemaining = 0; + unsigned int offset = 0; + unsigned int offsetStepsRemaining = stepId; + // grabbing the subset is a little different for each type + // Right now we assume controllers are of the same type + unsigned int controllerIndex = 0; + unsigned int sizeRemaining = sizePerStep; + unsigned int arrayoffset = 0; + while (sizeRemaining > 0) + { +//printf("sizeRemaining = %u\n", sizeRemaining); + // We don't reset the controller index between runs of the while loop + // On iterations after the first it should only execute the loop once + // because offset is set to 0 + while (controllerIndex < datasetControllers.size()) + { +//printf("offset = %u\n", offset); +//printf("%u >= %u\n", offset, datasetControllers[controllerIndex]->getSize()); + //Iterate until we find the controller that the step starts in + if (offset >= datasetControllers[controllerIndex]->getSize()) + { + offset -= datasetControllers[controllerIndex]->getSize(); + ++controllerIndex; + } + else + { + if (offsetStepsRemaining == 0) + { + // offset is within the current controller + break; + } + else + { + // There are steps left to offset +//printf("accounting for step %d\n", offsetStepsRemaining); + offset += sizePerStep; + --offsetStepsRemaining; + } + } + } +//printf("final offset = %u\n", offset); + std::vector newDimVector; + std::vector newStarts; +//printf("after creating dim vector but before filling it\n"); +//printf("%d < %d\n", controllerIndex, datasetControllers.size()); +//printf("size left %d\n", sizeRemaining); + if (offset + sizeRemaining <= datasetControllers[controllerIndex]->getSize()) + { +//printf("step is entirely in the controller\n"); + // step is entirely within this controller + newStarts.push_back(offset + datasetControllers[controllerIndex]->getStart()[0]); // TODO multidim version + newDimVector.push_back(sizeRemaining); + sizeRemaining = 0; + } + else + { +//printf("step is partially in the controller\n"); + if (controllerIndex + 1 >= datasetControllers.size()) { + // Error, step doesn't fit in the data set provided + XdmfError::message(XdmfError::FATAL, "Error: Step does not fit in data step provided"); + } + // step is partially in this controller + newDimVector.push_back(sizeRemaining - + (sizeRemaining - (datasetControllers[controllerIndex]->getSize() - offset))); + newStarts.push_back(offset+datasetControllers[controllerIndex]->getStart()[0]); // TODO multidim version + sizeRemaining -= newDimVector[0]; + } +//printf("size for other controllers %d\n", sizeRemaining); +//printf("before creating the new controller\n"); + // Using the remaining space in the controller + // Slightly differen creation method for each controller + if (datasetControllers[0]->getName().compare("Binary") == 0) { + shared_ptr createdController = + XdmfBinaryController::New(datasetControllers[0]->getFilePath(), + datasetControllers[0]->getType(), + shared_dynamic_cast( + datasetControllers[0])->getEndian(), + newStarts[0], + newDimVector); + returnVector.push_back(createdController); + } + else if (datasetControllers[0]->getName().compare("HDF") == 0) { + // TODO + // The writer should only write to contiguous sets when in this mode. + // A user would need to do something custom to foul this up. + std::vector newStrides; + newStrides.push_back(1); + shared_ptr createdController = + XdmfHDF5Controller::New(datasetControllers[controllerIndex]->getFilePath(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataSetPath(), + datasetControllers[0]->getType(), + newStarts, + newStrides, + newDimVector, + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataspaceDimensions()); + returnVector.push_back(createdController); + } +//printf("after creating the new controller\n"); + returnVector[returnVector.size()-1]->setArrayOffset(arrayoffset); + arrayoffset += returnVector[returnVector.size()-1]->getSize(); + offset = 0; + ++controllerIndex; + // Starts at the beggining of the next controller + } + } +/* +printf("size of return vector = %d\n", returnVector.size()); +for (unsigned int i = 0; i < returnVector.size(); ++i) +{ + shared_ptr currentController = shared_dynamic_cast(returnVector[i]); +assert(currentController); + printf("file = %s\n", currentController->getFilePath().c_str()); + printf("dataset = %s\n", currentController->getDataSetPath().c_str()); + printf("start = %u\n", currentController->getStart()[0]); + printf("dimension = %u\n", currentController->getDimensions()[0]); + printf("dataspace = %u\n", currentController->getDataspaceDimensions()[0]); +} +*/ + return returnVector; +} + +std::vector > +getControllersExcludingStep(unsigned int stepId, + std::vector stepDims, + std::vector > datasetControllers) +{ + std::vector > returnVector; + if (datasetControllers.size() > 0) + { + unsigned int sizePerStep = 1; + for (unsigned int i = 0; i < stepDims.size(); ++i) + { + sizePerStep *= stepDims[i]; + } + unsigned int offset = sizePerStep * stepId; + unsigned int sizeRemaining = sizePerStep; +//printf("base offset = %u\nstarting size remaining = %u\ncutting from %u controllers\n", offset, sizeRemaining, datasetControllers.size()); + // grabbing the subset is a little different for each type + // Right now we assume controllers are of the same type + for (unsigned int controllerIndex = 0; controllerIndex < datasetControllers.size(); ++controllerIndex) + { +//printf("offset = %u out of controller size %u\n", offset, datasetControllers[controllerIndex]->getSize()); + if (offset >= datasetControllers[controllerIndex]->getSize()) + { + // The removed step isn't in the controller provided + // Simply add it back into the return set + returnVector.push_back(datasetControllers[controllerIndex]); + // then subtract the size from the offset + offset -= datasetControllers[controllerIndex]->getSize(); + } + else + { + // The removed step is inside the controller provided + if (offset > 0) + { +//printf("removed step is inside this controller\n"); + // If offset is greater than zero the controller has a section chopped off the front + std::vector newDim; + newDim.push_back(offset); + // Dataspace is the same + // stride is the same + // start is the same + // TODO dims is reduced to just cover the offset size + if (datasetControllers[controllerIndex]->getName().compare("Binary") == 0) { + shared_ptr createdController = + XdmfBinaryController::New(datasetControllers[controllerIndex]->getFilePath(), + datasetControllers[controllerIndex]->getType(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getEndian(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getSeek(), + datasetControllers[controllerIndex]->getStart(), + datasetControllers[controllerIndex]->getStride(), + newDim, + datasetControllers[controllerIndex]->getDataspaceDimensions()); + returnVector.push_back(createdController); + } + else if (datasetControllers[controllerIndex]->getName().compare("HDF") == 0) { + // TODO + // The writer should only write to contiguous sets when in this mode. + // A user would need to do something custom to foul this up. + shared_ptr createdController = + XdmfHDF5Controller::New(datasetControllers[controllerIndex]->getFilePath(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataSetPath(), + datasetControllers[controllerIndex]->getType(), + datasetControllers[controllerIndex]->getStart(), + datasetControllers[controllerIndex]->getStride(), + newDim, + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataspaceDimensions()); + returnVector.push_back(createdController); + } + // These are the stats for the first half of the dataset + if (sizeRemaining <= datasetControllers[controllerIndex]->getSize() - offset) + { + // The controller is large enough to need to be split into two controllers + std::vector newStart; //TODO we're assuming one dim for now + newStart.push_back(datasetControllers[controllerIndex]->getStart()[0] +sizeRemaining + offset); + std::vector newDim; + newDim.push_back(datasetControllers[controllerIndex]->getSize() - (sizeRemaining + offset)); + // These are the stats of the second controller + sizeRemaining = 0; + if (datasetControllers[controllerIndex]->getName().compare("Binary") == 0) { + shared_ptr createdController = + XdmfBinaryController::New(datasetControllers[controllerIndex]->getFilePath(), + datasetControllers[controllerIndex]->getType(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getEndian(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getSeek(), + newStart, + datasetControllers[controllerIndex]->getStride(), + newDim, + datasetControllers[controllerIndex]->getDataspaceDimensions()); + returnVector.push_back(createdController); + } + else if (datasetControllers[controllerIndex]->getName().compare("HDF") == 0) { + // TODO + // The writer should only write to contiguous sets when in this mode. + // A user would need to do something custom to foul this up. + shared_ptr createdController = + XdmfHDF5Controller::New(datasetControllers[controllerIndex]->getFilePath(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataSetPath(), + datasetControllers[controllerIndex]->getType(), + newStart, + datasetControllers[controllerIndex]->getStride(), + newDim, + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataspaceDimensions()); + returnVector.push_back(createdController); + } + } + else { + // The controller only contains part of the dataset + sizeRemaining -= (datasetControllers[controllerIndex]->getSize() - offset); + } + offset = 0; + } + else + { + // in the case of 0 offset, we either need to trim from the front or just use the whole controller + if (sizeRemaining > 0) + { + if (sizeRemaining < datasetControllers[controllerIndex]->getSize()) + { + std::vector newStart; + newStart.push_back(sizeRemaining); + std::vector newDim; + newDim.push_back(datasetControllers[controllerIndex]->getSize() - sizeRemaining); + sizeRemaining = 0; + if (datasetControllers[controllerIndex]->getName().compare("Binary") == 0) { + shared_ptr createdController = + XdmfBinaryController::New(datasetControllers[controllerIndex]->getFilePath(), + datasetControllers[controllerIndex]->getType(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getEndian(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getSeek(), + newStart, + datasetControllers[controllerIndex]->getStride(), + newDim, + datasetControllers[controllerIndex]->getDataspaceDimensions()); + returnVector.push_back(createdController); + } + else if (datasetControllers[controllerIndex]->getName().compare("HDF") == 0) { + // TODO + // The writer should only write to contiguous sets when in this mode. + // A user would need to do something custom to foul this up. + shared_ptr createdController = + XdmfHDF5Controller::New(datasetControllers[controllerIndex]->getFilePath(), + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataSetPath(), + datasetControllers[controllerIndex]->getType(), + newStart, + datasetControllers[controllerIndex]->getStride(), + newDim, + shared_dynamic_cast( + datasetControllers[controllerIndex])->getDataspaceDimensions()); + returnVector.push_back(createdController); + } + } + else { + sizeRemaining -= datasetControllers[controllerIndex]->getSize(); + } + } + else + { + // Just use the current controller + returnVector.push_back(datasetControllers[controllerIndex]); + } + } + } + } + } + return returnVector; +} + +class XdmfArrayGatherer : public XdmfVisitor, public Loki::Visitor +{ + public: + + static shared_ptr + New(std::vector * storageVector) + { + shared_ptr p(new XdmfArrayGatherer(storageVector)); + return p; + } + + ~XdmfArrayGatherer() + { + } + + virtual void + visit(XdmfArray & array, + const shared_ptr visitor) + { + ++mDepth; + if (!array.isInitialized()) + { +// mStorage->push_back(&array); + mArrayCollection.insert(&array); + } + array.traverse(visitor); + --mDepth; + if (mDepth == 0) + { + moveToStorage(); + } + } + + virtual void + visit(XdmfItem & item, + const shared_ptr visitor) + { + ++mDepth; + item.traverse(visitor); + --mDepth; + if (mDepth == 0) + { + moveToStorage(); + } + } + + void + moveToStorage() + { + for (std::set::iterator iter = mArrayCollection.begin(); + iter != mArrayCollection.end(); + ++iter) + { + mStorage->push_back(*iter); + } + } + + private: + + XdmfArrayGatherer(std::vector * storageVector) : + mDepth(0), + mStorage(storageVector) + { + } + + unsigned int mDepth; + std::set mArrayCollection; + std::vector * mStorage; +}; + +shared_ptr +XdmfTemplate::New() +{ + shared_ptr p(new XdmfTemplate()); + return p; +} + + +XdmfTemplate::XdmfTemplate() : + mHeavyWriter(shared_ptr()), + mBase(shared_ptr()), + mCurrentStep(-1), + mNumSteps(0), + mItemFactory(shared_ptr()) +{ +} + +XdmfTemplate::XdmfTemplate(XdmfTemplate & refTemplate) : + XdmfItem(refTemplate), + mBase(refTemplate.mBase), + mCurrentStep(refTemplate.mCurrentStep), + mNumSteps(refTemplate.mNumSteps), + mItemFactory(refTemplate.mItemFactory) +{ +} + +XdmfTemplate::~XdmfTemplate() +{ +} + +const std::string XdmfTemplate::ItemTag = "Template"; + +unsigned int +XdmfTemplate::addStep() +{ + mCurrentStep = this->getNumberSteps(); + std::stringstream datastream; + if (mTrackedArrays.size() < 1) { + XdmfError::message(XdmfError::FATAL, + "Error: XdmfTemplate attempting to add a step when no arrays are tracked"); + } + for (unsigned int arrayIndex = 0; arrayIndex < mTrackedArrays.size(); ++arrayIndex) { + if (mTrackedArrayTypes.size() < mTrackedArrays.size()){ + mTrackedArrayTypes.resize(mTrackedArrays.size()); + } + if (mTrackedArrayDims.size() < mTrackedArrays.size()){ + mTrackedArrayDims.resize(mTrackedArrays.size()); + } + if (!mTrackedArrayTypes[arrayIndex]) { + mTrackedArrayTypes[arrayIndex] = mTrackedArrays[arrayIndex]->getArrayType(); + } + if (mTrackedArrayDims[arrayIndex].size() == 0) { + mTrackedArrayDims[arrayIndex] = mTrackedArrays[arrayIndex]->getDimensions(); + } + // Write the tracked arrays to heavy data if they aren't already + if (mHeavyWriter) { + bool revertToAppend = false; + if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Append) { + // Set to original heavy data controllers for append + if (mDataControllers.size() > arrayIndex) + { + if (mDataControllers[arrayIndex].size() > 0) + { + while (mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers() > 0) { + mTrackedArrays[arrayIndex]->removeHeavyDataController(0); + } + for (unsigned int i = 0; i < mDataControllers[arrayIndex].size(); ++i) + { + mTrackedArrays[arrayIndex]->insert(mDataControllers[arrayIndex][i]); + } + } + } + else + { + // Creating new Dataset + // Set to default mode so that it doesn't overlap + mHeavyWriter->setMode(XdmfHeavyDataWriter::Default); + revertToAppend = true; + } + } + else if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Hyperslab) { + // Use the controller that references the subset that will be overwritten + if (!(arrayIndex < mDataControllers.size())) + { + // When in overwrite mode the dataset must be preallocated + XdmfError::message(XdmfError::FATAL, "Error: Heavy Data dataset must be preallocated " + "to use Hyperslab mode Templates"); + } + std::vector > overwriteControllers = + getStepControllers(mCurrentStep, mTrackedArrayDims[arrayIndex], mDataControllers[arrayIndex]); + mTrackedArrays[arrayIndex]->setHeavyDataController(overwriteControllers); + } + mTrackedArrays[arrayIndex]->accept(mHeavyWriter); + if (revertToAppend) + { + mHeavyWriter->setMode(XdmfHeavyDataWriter::Append); + } + } + datastream.str(std::string()); + for (unsigned int controllerIndex = 0; controllerIndex < mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers(); ++controllerIndex) { + // TODO throw error if controller types don't match + // For each heavy data controller + std::string writerPath = XdmfSystemUtils::getRealPath(mHeavyWriter->getFilePath()); + std::string heavyDataPath = + mTrackedArrays[arrayIndex]->getHeavyDataController(controllerIndex)->getFilePath(); + size_t index = heavyDataPath.find_last_of("/\\"); + if(index != std::string::npos) { + // If path is not a folder + // put the directory path into this variable + const std::string heavyDataDir = heavyDataPath.substr(0, index + 1); + // If the directory is in the XML File Path + if(writerPath.find(heavyDataDir) == 0) { + heavyDataPath = + heavyDataPath.substr(heavyDataDir.size(), + heavyDataPath.size() - heavyDataDir.size()); + // Pull the file off of the end and place it in the DataPath + } + // Otherwise the full path is required + } + datastream << heavyDataPath; + datastream << mTrackedArrays[arrayIndex]->getHeavyDataController(controllerIndex)->getDescriptor(); + datastream << "|"; + for (unsigned int i = 0; i < mTrackedArrays[arrayIndex]->getHeavyDataController(controllerIndex)->getDimensions().size(); ++i) { + datastream << mTrackedArrays[arrayIndex]->getHeavyDataController(controllerIndex)->getDimensions()[i]; + if (i < mTrackedArrays[arrayIndex]->getHeavyDataController(controllerIndex)->getDimensions().size() - 1) { + datastream << " "; + } + } + if (controllerIndex + 1 < mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers()) { + datastream << "|"; + } + } + if (mHeavyWriter) { + if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Append) { + if (mDataControllers.size() > arrayIndex) + { + // If controllers already exist + // Store the overarching controllers again + mDataControllers[arrayIndex].clear(); + for (unsigned int i = 0; i < mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers(); ++i) + { + mDataControllers[arrayIndex].push_back(mTrackedArrays[arrayIndex]->getHeavyDataController(i)); + } + // Clear controllers from the array + while (mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers() > 0) { + mTrackedArrays[arrayIndex]->removeHeavyDataController(0); + } + // If append set controller to the correct subsection of the whole + std::vector > readControllers = getStepControllers(mCurrentStep, mTrackedArrayDims[arrayIndex], mDataControllers[arrayIndex]); + mTrackedArrays[arrayIndex]->setHeavyDataController(readControllers); + // Replace with updated description + mDataDescriptions[arrayIndex] = datastream.str(); + } + else + { + // If a new dataset, as normal + mDataControllers.push_back(std::vector >()); + for (unsigned int i = 0; i < mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers(); ++i) { + mDataControllers[mDataControllers.size()-1].push_back((mTrackedArrays[arrayIndex]->getHeavyDataController(i))); + } + if (mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers() > 0) { + mDataTypes.push_back(mTrackedArrays[arrayIndex]->getHeavyDataController(0)->getName()); + mDataDescriptions.push_back(datastream.str()); + } + } + } + else if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Hyperslab) { + // Hyperslab is already storing the base controller + // So nothing is done here, the controller should already be pointing to the correct location + // TODO, to what the file index was before the add, as opposed to 0 + mHeavyWriter->setFileIndex(0); + } + else { + mDataControllers.push_back(std::vector >()); + for (unsigned int i = 0; i < mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers(); ++i) { + mDataControllers[mDataControllers.size()-1].push_back((mTrackedArrays[arrayIndex]->getHeavyDataController(i))); + } + if (mTrackedArrays[arrayIndex]->getNumberHeavyDataControllers() > 0) { + mDataTypes.push_back(mTrackedArrays[arrayIndex]->getHeavyDataController(0)->getName()); + mDataDescriptions.push_back(datastream.str()); + } + } + } + else { + mDataControllers.push_back(std::vector >()); + mDataTypes.push_back("XML"); + mDataDescriptions.push_back(mTrackedArrays[arrayIndex]->getValuesString()); + } + } + ++mNumSteps; + this->setIsChanged(true); + return mCurrentStep; +} + +void +XdmfTemplate::clearStep() +{ + for (unsigned int i = 0; i < mTrackedArrays.size(); ++i) { + mTrackedArrays[i]->release(); + while (mTrackedArrays[i]->getNumberHeavyDataControllers() > 0) { + mTrackedArrays[i]->removeHeavyDataController(0); + } + } + mCurrentStep = -1; +} + +shared_ptr +XdmfTemplate::getBase() +{ + return mBase; +} + +shared_ptr +XdmfTemplate::getHeavyDataWriter() +{ + return mHeavyWriter; +} + +std::map +XdmfTemplate::getItemProperties() const +{ + std::map templateProperties; +/* + std::stringstream value; + value << mValue; + timeProperties.insert(std::make_pair("Value", value.str())); +*/ + return templateProperties; +} + +std::string +XdmfTemplate::getItemTag() const +{ + return ItemTag; +} + +unsigned int +XdmfTemplate::getNumberSteps() const +{ + return mNumSteps; +} + +unsigned int +XdmfTemplate::getNumberTrackedArrays() const +{ + return mTrackedArrays.size(); +} + +XdmfArray * +XdmfTemplate::getTrackedArray(unsigned int index) +{ + return mTrackedArrays[index]; +} + + +void +XdmfTemplate::populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader) +{ + XdmfItem::populateItem(itemProperties, childItems, reader); + + // The first child item is the base + mBase = childItems[0]; + mCurrentStep = 0; + + std::string referenceHDF5File = ""; + + if (childItems.size() > 1) { + for(std::vector >::const_iterator iter = + childItems.begin() + 1; + iter != childItems.end(); + ++iter) { + if(shared_ptr array = shared_dynamic_cast(*iter)) { + // Pull hdf5 reference data from the first provided array + if (array->getNumberHeavyDataControllers() > 0 & !mHeavyWriter) { + mHeavyWriter = reader->generateHeavyDataWriter(array->getHeavyDataController(0)->getName(), array->getHeavyDataController(0)->getFilePath()); + } + if (array->getName().compare("Data Description") == 0) { + // Split description into substrings based on the " character + array->read(); + + std::string descriptionString; + if (array->getArrayType() == XdmfArrayType::Int8()) + { + descriptionString = std::string((char *)array->getValuesInternal()); + } + else if (array->getArrayType() == XdmfArrayType::String()) + { + std::stringstream descriptionstream; + for (unsigned int i = 0; i < array->getSize(); ++i) + { + descriptionstream << array->getValue(i); + if (i < array->getSize() - 1) + { + descriptionstream << '|'; + } + } + descriptionString = descriptionstream.str(); + } + + size_t index = descriptionString.find_first_of("\""); + size_t previousIndex = 0; + + if (index != std::string::npos) { + // Removing the prepended " + previousIndex = index + 1; + index = descriptionString.find_first_of("\"", previousIndex); + } + + while (index != std::string::npos) { + std::string type = descriptionString.substr(previousIndex, index - previousIndex); + mDataTypes.push_back(type); + previousIndex = index + 1; + index = descriptionString.find_first_of("\"", previousIndex); + if (index - previousIndex > 0) { + std::string description; + description = descriptionString.substr(previousIndex, index - previousIndex); + mDataDescriptions.push_back(description); + // create controllers here based on the type/description? + // Is array type already filled? + // Potentially call "fillControllers" after populating? + if (index != std::string::npos) { + previousIndex = index + 1; + index = descriptionString.find_first_of("\"", previousIndex); + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Type without a description in XdmfTemplate::populateItem"); + } + } + } + else { + mTrackedArrays.push_back(array.get()); + mTrackedArrayDims.push_back(array->getDimensions()); + mTrackedArrayTypes.push_back(array->getArrayType()); + } + } + } + } + for (unsigned int i = 0; i < mDataTypes.size(); ++i) + { + mDataControllers.push_back(std::vector >()); + } + mDataControllers.resize(mDataTypes.size()); + if (!mItemFactory) { + mItemFactory = XdmfItemFactory::New(); + } + std::map populateProperties; + if (mHeavyWriter) { + // The heavy writer provides the XMLDir, which is used to get full paths for the controllers + // It is assumed that the files that the controllers reference are in the same directory + // as the file that the writer references + std::string filepath = XdmfSystemUtils::getRealPath(mHeavyWriter->getFilePath()); + size_t index = filepath.find_last_of("/\\"); + filepath = filepath.substr(0, index + 1); + populateProperties["XMLDir"] = filepath; + } + else + { + // Error because a writer is required? TODO + } + for (unsigned int i = 0; i < mDataDescriptions.size(); ++i) { + populateProperties["Content"] = mDataDescriptions[i]; + std::vector > readControllers = + reader->generateHeavyDataControllers(populateProperties, mTrackedArrayDims[i % mTrackedArrays.size()], mTrackedArrayTypes[i % mTrackedArrays.size()], mDataTypes[i]); + if (readControllers.size() > 0) { + // Heavy data controllers reference the data + for (unsigned int j = 0; j < readControllers.size(); ++j) { + mDataControllers[i].push_back(readControllers[j]); + } + } + } + // Compare the first set of controllers to the size of the first array + unsigned int controllerTotal = 0; + + for (unsigned int i = 0; i < mDataControllers[0].size(); ++i) + { + unsigned int previousTotal = controllerTotal; + controllerTotal += mDataControllers[0][i]->getSize(); + if (previousTotal != controllerTotal - mDataControllers[0][i]->getSize()) + { + controllerTotal = UINT_MAX; + break; + } + } + // If the array is smaller, set the writer to append. + if (controllerTotal > mTrackedArrays[0]->getSize()) + { + mHeavyWriter->setMode(XdmfHeavyDataWriter::Append); + mNumSteps = 0; + unsigned int currentTotal = 0; + for (unsigned int controllerIndex = 0; controllerIndex < mDataControllers[0].size(); ++controllerIndex) + { + currentTotal += mDataControllers[0][controllerIndex]->getSize(); + while (currentTotal >= mTrackedArrays[0]->getSize()) + { + currentTotal -= mTrackedArrays[0]->getSize(); + ++mNumSteps; + } + } +// mNumSteps = controllerTotal / mTrackedArrays[0]->getSize(); + } + else { + mNumSteps = mDataControllers.size() / mTrackedArrays.size(); + } + this->setStep(0); +} + +void +XdmfTemplate::preallocateSteps(unsigned int numSteps) +{ + // Preallocate steps based on the current size of the arrays + // Use a temporary array to write data to hdf5 + shared_ptr tempArray = XdmfArray::New(); + // Set to Default mode so that the new allocations are in new locations + mHeavyWriter->setMode(XdmfHeavyDataWriter::Default); + int preallocatedSize = 0; + int numberSetsPreallocated = 0; + std::stringstream datastream; + for (unsigned int i = 0; i < mTrackedArrays.size(); ++i) { + preallocatedSize = mTrackedArrays[i]->getSize() * numSteps; +///* + numberSetsPreallocated = 1; + + int adjustment = 1; + while (preallocatedSize / (numSteps/adjustment) != mTrackedArrays[i]->getSize() || 0 > (int)preallocatedSize) { +// XdmfError::message(XdmfError::WARNING, "Overflow error"); + ++adjustment; + while (numSteps % adjustment != 0) { +//printf("%d / %d remainder %d\n", numSteps, adjustment, (numSteps % adjustment)); + ++adjustment; + } + numberSetsPreallocated = numberSetsPreallocated * adjustment; + preallocatedSize = mTrackedArrays[i]->getSize() * (numSteps / adjustment); +//printf("%d / %d = %d ?= %d\n", preallocatedSize , (numSteps/adjustment), preallocatedSize / (numSteps/adjustment), mTrackedArrays[i]->getSize()); + } + + // If adjusted, split one more time, to ensure that the dataset fits. + if (adjustment > 1) { + ++adjustment; + while (numSteps % adjustment != 0) { + ++adjustment; + } + numberSetsPreallocated = numberSetsPreallocated * adjustment; + preallocatedSize = mTrackedArrays[i]->getSize() * (numSteps / adjustment); + } + + bool allocateSucceeded = false; + while (!allocateSucceeded) + { + try { + mHeavyWriter->openFile(); +//printf("now size %d allocated %d times\n", preallocatedSize, numberSetsPreallocated); + for (unsigned int allocateIteration = 0; + allocateIteration < numberSetsPreallocated; + ++allocateIteration) + { +//printf("allocating subsection %u\n", allocateIteration); +//*/ +//printf("initializing base array\n"); + tempArray->initialize(mTrackedArrays[i]->getArrayType(), preallocatedSize); +//printf("writing subsection"); + tempArray->accept(mHeavyWriter); +//printf("subsection written\n"); +// mHeavyWriter->clearCache(); +///* + if (mDataControllers.size() <= i) { + mDataControllers.push_back(std::vector >()); + } + // Clean Array for the next iteration + while (tempArray->getNumberHeavyDataControllers() > 0) { + mDataControllers[i].push_back(tempArray->getHeavyDataController(0)); + if (mDataTypes.size() <= i) { + mDataTypes.push_back(tempArray->getHeavyDataController(0)->getName()); + } + tempArray->removeHeavyDataController(0); + } + tempArray->release(); +//*/ +///* +//printf("moving to next allocation\n"); + } + mHeavyWriter->closeFile(); + allocateSucceeded = true; +//*/ +//TODO catch the controllers created by this. +///* + } + catch (...) + { + while (tempArray->getNumberHeavyDataControllers() > 0) { + tempArray->removeHeavyDataController(0); + } + tempArray->release(); +// XdmfError::message(XdmfError::WARNING, "Array Allocation failed"); + int factor = 2; + while (preallocatedSize % factor != 0) { +//printf("%d / %d remainder %d\n", preallocatedSize, factor, (preallocatedSize % factor)); + factor = factor + 1; + } +//printf("adjusted factor %d\n", factor); + numberSetsPreallocated = numberSetsPreallocated * factor; + preallocatedSize = (preallocatedSize) / factor; +//printf("now size %d allocated %d times\n", preallocatedSize, numberSetsPreallocated); + } + } +//printf("Done writing to hdf5\n"); +//*/ +/* + // Transfer controllers to the appropriate slot before clearing them + if (mDataControllers.size() <= i) { + mDataControllers.push_back(std::vector >()); + } + // Clean Array for the next iteration + while (tempArray->getNumberHeavyDataControllers() > 0) { + mDataControllers[i].push_back(tempArray->getHeavyDataController(0)); + if (mDataTypes.size() <= i) { + mDataTypes.push_back(tempArray->getHeavyDataController(0)->getName()); + } + tempArray->removeHeavyDataController(0); + } + tempArray->release(); +*/ + datastream.str(std::string()); + for (unsigned int controllerIndex = 0; controllerIndex < mDataControllers[i].size(); ++controllerIndex) { + // TODO throw error if controller types don't match + // For each heavy data controller + std::string writerPath = XdmfSystemUtils::getRealPath(mHeavyWriter->getFilePath()); + std::string heavyDataPath = + mDataControllers[i][controllerIndex]->getFilePath(); + size_t index = heavyDataPath.find_last_of("/\\"); + if(index != std::string::npos) { + // If path is not a folder + // put the directory path into this variable + const std::string heavyDataDir = heavyDataPath.substr(0, index + 1); + // If the directory is in the XML File Path + if(writerPath.find(heavyDataDir) == 0) { + heavyDataPath = + heavyDataPath.substr(heavyDataDir.size(), + heavyDataPath.size() - heavyDataDir.size()); + // Pull the file off of the end and place it in the DataPath + } + // Otherwise the full path is required + } + datastream << heavyDataPath; + datastream << mDataControllers[i][controllerIndex]->getDescriptor(); + datastream << "|"; + for (unsigned int j = 0; j < mDataControllers[i][controllerIndex]->getDimensions().size(); ++j) { + datastream << mDataControllers[i][controllerIndex]->getDimensions()[j]; + if (j < mDataControllers[i][controllerIndex]->getDimensions().size() - 1) { + datastream << " "; + } + } + if (controllerIndex + 1 < mDataControllers[i].size()) { + datastream << "|"; + } + } + mDataDescriptions.push_back(datastream.str()); + } + // To end set the heavy writer to overwrite mode + mHeavyWriter->setMode(XdmfHeavyDataWriter::Hyperslab); +} + + +void +XdmfTemplate::removeStep(unsigned int stepId) +{ + if (stepId < this->getNumberSteps()) { + for (unsigned int i = 0; i < mTrackedArrays.size(); ++i) { + if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Append || + mHeavyWriter->getMode() == XdmfHeavyDataWriter::Hyperslab) { + std::vector > replacementControllers = getControllersExcludingStep(stepId, mTrackedArrayDims[i], mDataControllers[i]); + for (unsigned int j = 0; j < replacementControllers.size(); ++j) + { + if (mDataControllers[i].size() > j) { + mDataControllers[i][j] = replacementControllers[j]; + } + else { + mDataControllers[i].push_back(replacementControllers[j]); + } + } + } + else { + mDataTypes.erase(mDataTypes.begin() + (stepId*mTrackedArrays.size())); + mDataDescriptions.erase(mDataDescriptions.begin() + (stepId*mTrackedArrays.size())); + mDataControllers.erase(mDataControllers.begin() + (stepId*mTrackedArrays.size())); + } + } + --mNumSteps; + } + mCurrentStep = -1; + this->setIsChanged(true); +} + +void +XdmfTemplate::setBase(shared_ptr newBase) +{ + shared_ptr accumulator = XdmfArrayGatherer::New(&mTrackedArrays); + newBase->accept(accumulator); + mBase = newBase; + this->setIsChanged(true); +} + +void +XdmfTemplate::setHeavyDataWriter(shared_ptr writer) +{ + mHeavyWriter = writer; +} + +void +XdmfTemplate::setStep(unsigned int stepId) +{ + if (stepId != mCurrentStep) { + if (!mItemFactory) { + mItemFactory = XdmfItemFactory::New(); + } + if (stepId < this->getNumberSteps()) { + for (unsigned int i = 0; i < mTrackedArrays.size(); ++i) { + unsigned int arrayIndex = 0; + if (mHeavyWriter) { + if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Append || + mHeavyWriter->getMode() == XdmfHeavyDataWriter::Hyperslab) { + arrayIndex = i; + } + else { + arrayIndex = i+(stepId*mTrackedArrays.size()); + } + } + else { + arrayIndex = i+(stepId*mTrackedArrays.size()); + } + if (mDataControllers[arrayIndex].size() > 0) { + if(mHeavyWriter) { + if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Append || + mHeavyWriter->getMode() == XdmfHeavyDataWriter::Hyperslab) { + std::vector > insertVector = + getStepControllers(stepId, mTrackedArrayDims[i], mDataControllers[i]); + mTrackedArrays[i]->setHeavyDataController(insertVector); + } + else { + mTrackedArrays[i]->setHeavyDataController(mDataControllers[i+(stepId*mTrackedArrays.size())]); + } + } + else { + mTrackedArrays[i]->setHeavyDataController(mDataControllers[i+(stepId*mTrackedArrays.size())]); + } + } + else { + std::map populateProperties; + if (mHeavyWriter) { + // The heavy writer provides the XMLDir, which is used to get full paths for the controllers + // It is assumed that the files that the controllers reference are in the same directory + // as the file that the writer references + std::string filepath = XdmfSystemUtils::getRealPath(mHeavyWriter->getFilePath()); + size_t index = filepath.find_last_of("/\\"); + filepath = filepath.substr(0, index + 1); + populateProperties["XMLDir"] = filepath; + } + populateProperties["Content"] = mDataDescriptions[arrayIndex]; + std::vector > readControllers; + if (mHeavyWriter) { + if (mHeavyWriter->getMode() == XdmfHeavyDataWriter::Append || + mHeavyWriter->getMode() == XdmfHeavyDataWriter::Hyperslab) { + std::vector > totalControllers = + mItemFactory->generateHeavyDataControllers(populateProperties, mTrackedArrayDims[i], mTrackedArrayTypes[i], mDataTypes[i+(stepId*mTrackedArrays.size())]); + readControllers = getStepControllers(stepId, mTrackedArrayDims[i], totalControllers); + } + else { + readControllers = mItemFactory->generateHeavyDataControllers(populateProperties, mTrackedArrayDims[i], mTrackedArrayTypes[i], mDataTypes[i+(stepId*mTrackedArrays.size())]); + } + } + else { + readControllers = mItemFactory->generateHeavyDataControllers(populateProperties, mTrackedArrayDims[i], mTrackedArrayTypes[i], mDataTypes[i+(stepId*mTrackedArrays.size())]); + } + if (readControllers.size() > 0) { + // Heavy data controllers reference the data + mTrackedArrays[i]->setHeavyDataController(readControllers); + mDataControllers[arrayIndex] = readControllers; + } + else { + // Data is contained in the content + std::string content = mDataDescriptions[i+(stepId*mTrackedArrays.size())]; + + mTrackedArrays[i]->initialize(mTrackedArrayTypes[i], mTrackedArrayDims[i]); + + unsigned int index = 0; + boost::char_separator sep(" \t\n"); + boost::tokenizer > valtokens(content, sep); + if(mTrackedArrayTypes[i] == XdmfArrayType::String()) { + for(boost::tokenizer >::const_iterator + iter = valtokens.begin(); + iter != valtokens.end(); + ++iter, ++index) { + mTrackedArrays[i]->insert(index, *iter); + } + } + else { + for(boost::tokenizer >::const_iterator + iter = valtokens.begin(); + iter != valtokens.end(); + ++iter, ++index) { + mTrackedArrays[i]->insert(index, atof((*iter).c_str())); + } + } + } + } + } + } + else { + XdmfError::message(XdmfError::FATAL, "Error: Template attempting to load invalid step"); + } + mCurrentStep = stepId; + } +} + +void +XdmfTemplate::trackArray(shared_ptr newArray) +{ + bool found = false; + + for (unsigned int i = 0; i < mTrackedArrays.size() && !found; ++i) { + if (mTrackedArrays[i] == newArray.get()) { + found = true; + } + } + + if (!found) { + mTrackedArrays.push_back(newArray.get()); + } + this->setIsChanged(true); +} + +void +XdmfTemplate::traverse(const shared_ptr visitor) +{ + // Set to the first step when writing, as the first step is the model for the rest of the template + // Will fail if there are no steps + if (this->getNumberSteps() == 0) { + XdmfError::message(XdmfError::FATAL, "Error: No steps in template in XdmfTemplate::traverse"); + } + this->clearStep(); + + unsigned int arraysize = 1; + for (unsigned int i = 0; i < mTrackedArrayDims[0].size(); ++i) + { + arraysize *= mTrackedArrayDims[0][i]; + } + + unsigned int controllersize = 0; + for (unsigned int i = 0; i < mDataControllers[0].size(); ++i) + { + controllersize += mDataControllers[0][i]->getSize(); + } + + XdmfHeavyDataWriter::Mode originalMode; + + if (mHeavyWriter) + { + originalMode = mHeavyWriter->getMode(); + if (controllersize > arraysize) { + mHeavyWriter->setMode(XdmfHeavyDataWriter::Append); + } + } + + this->setStep(0); + + if (mHeavyWriter) + { + mHeavyWriter->setMode(originalMode); + } + + // Sending visitor to the base first so that it appears first when reading. + mBase->accept(visitor); + + for (unsigned int i = 0; i < mTrackedArrays.size(); ++i) { + mTrackedArrays[i]->release(); + mTrackedArrays[i]->accept(visitor); + } + + // Create an array to hold all of the data information strings + + bool originalXPath; + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + originalXPath = writer->getWriteXPaths(); + writer->setWriteXPaths(false); + } + + shared_ptr dataInfoArray = XdmfArray::New(); + + dataInfoArray->setName("Data Description"); + + unsigned int i = 0; + + std::stringstream arrayInfo; + while (i < mDataTypes.size()) { + arrayInfo << "\"" << mDataTypes[i] << "\"" << mDataDescriptions[i]; + ++i; + } + dataInfoArray->insert(0, arrayInfo.str().c_str(), arrayInfo.str().length()); + dataInfoArray->insert(dataInfoArray->getSize(), 0); + + dataInfoArray->accept(visitor); + + if (shared_ptr writer = + shared_dynamic_cast(visitor)) { + writer->setWriteXPaths(originalXPath); + } + + XdmfItem::traverse(visitor); +} + +XDMF_ITEM_C_CHILD_WRAPPER(XdmfTemplate, XDMFTEMPLATE) diff --git a/XdmfTemplate.hpp b/XdmfTemplate.hpp new file mode 100644 index 0000000000000000000000000000000000000000..8ea7d4464377862eb3923270be8fe4a767b0f07a --- /dev/null +++ b/XdmfTemplate.hpp @@ -0,0 +1,218 @@ +/*****************************************************************************/ +/* XDMF */ +/* eXtensible Data Model and Format */ +/* */ +/* Id : XdmfTemplate.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 XDMFTEMPLATE_HPP_ +#define XDMFTEMPLATE_HPP_ + +// C Compatible Includes +#include "Xdmf.hpp" +#include "XdmfItem.hpp" +#include "XdmfItemFactory.hpp" +#include "XdmfArray.hpp" +#include "XdmfHeavyDataWriter.hpp" + +#ifdef __cplusplus + +// Includes + +/** + * @brief Defines a template that can be filled with multiple sets of data. + * + * An XdmfTemplate defines a structure. The arrays within that structure + * are stored if they are not initialized when the structure is first set. + * Steps can then be added and references to heavy data are produced and + * stored for later retrieval. + * + * This effectively lets an object have several variations with different + * contained data. + */ +class XDMF_EXPORT XdmfTemplate : public virtual XdmfItem { + +public: + + /** + * Creates a new instance of the XdmfTemplate object + * + * @return A constructed XdmfTemplate object. + */ + static shared_ptr New(); + + virtual ~XdmfTemplate(); + + LOKI_DEFINE_VISITABLE(XdmfTemplate, XdmfItem); + static const std::string ItemTag; + + /** + * Writes all tracked arrays to heavy data via the provided + * heavy data writer then stores the heavy data descriptions. + * + * @return The ID of the step that was added + */ + virtual unsigned int addStep(); + + /** + * Clears the current data from the tracked arrays. + */ + virtual void clearStep(); + + /** + * Gets the XdmfItem that serves as the structure for the template. + * + * @return The XdmfItem that serves as the structure for the template. + */ + virtual shared_ptr getBase(); + + /** + * Gets the heavy data writer that is used to write step data to heavy data. + * + * @return The heavy data writer + */ + shared_ptr getHeavyDataWriter(); + + std::map getItemProperties() const; + + std::string getItemTag() const; + + /** + * Gets the number of steps currently contained within the template. + * + * @return The number of steps contained within the template. + */ + unsigned int getNumberSteps() const; + + /** + * Gets the number of arrays tracked across timesteps. + * + * @return The numer of tracked arrays. + */ + unsigned int getNumberTrackedArrays() const; + + /** + * Gets the tracked array at the specified index. The index of the array + * depends on when the internal visitor encountered the array in question. + * + * @return The requested array. + */ + XdmfArray * getTrackedArray(unsigned int index); + + using XdmfItem::insert; + + /* + * + */ + virtual void preallocateSteps(unsigned int numSteps); + + /** + * + */ + virtual void removeStep(unsigned int stepId); + + /** + * Sets the item to define the structure for each step of the template. + * + * When the base is set all uninitialized arrays are added to + * the list of tracked arrays. + * + * @param newBase The item to serve as the structure. + */ + virtual void setBase(shared_ptr newBase); + + /** + * Sets the heavy data writer with which the template will write + * to heavy data when adding a step. + * + * @param writer The writer to be used to write to heavy data. + */ + void setHeavyDataWriter(shared_ptr writer); + + /** + * Reads in the heavy data associated with the provided step id. + * + * @param stepId The id of the step whose heavy data + * is to be read in from file + */ + virtual void setStep(unsigned int stepId); + + /** + * Adds an array to the list of tracked arrays if that array + * is not already there. + * + * The setBase method automatically sets uninitialized arrays + * to be tracked, this can be used to add any missed by setBase. + * + * @param newArray The array to be tracked. + */ + virtual void trackArray(shared_ptr newArray); + + virtual void traverse(const shared_ptr visitor); + + XdmfTemplate(XdmfTemplate &); + +protected: + + XdmfTemplate(); + + virtual void + populateItem(const std::map & itemProperties, + const std::vector > & childItems, + const XdmfCoreReader * const reader); + + shared_ptr mHeavyWriter; + + shared_ptr mBase; + std::vector mTrackedArrays; + std::vector mDataTypes; + std::vector mDataDescriptions; + std::vector > > mDataControllers; + std::vector > mTrackedArrayTypes; + std::vector > mTrackedArrayDims; + int mCurrentStep; + unsigned int mNumSteps; + shared_ptr mItemFactory; + +private: + + XdmfTemplate(const XdmfTemplate &); // Not implemented. + void operator=(const XdmfTemplate &); // Not implemented. + +}; + +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +struct XDMFTEMPLATE; // Simply as a typedef to ensure correct typing +typedef struct XDMFTEMPLATE XDMFTEMPLATE; + +XDMF_ITEM_C_CHILD_DECLARE(XdmfTemplate, XDMFTEMPLATE, XDMF) + +#ifdef __cplusplus +} +#endif + + +#endif /* XDMFTEMPLATE_HPP_ */ diff --git a/XdmfTime.cpp b/XdmfTime.cpp index 3a3da402d7b03a71f26f4e22ce3988637dc7bd61..028bd2997ec2faf13b9300715f51f65dedb2eb8e 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 5ac600e618187c313cf1e065e54b1eab4d8152e2..44fe81ccd8714163d830e44f05dede2ca7832873 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 4ea4cdcaf646a95b8b57dc55e5f3ba6ab8706bb7..2d0c27f4584f1bcd41eae5a0f77718940b727bb5 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; } @@ -150,6 +169,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()); @@ -165,8 +188,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 4b1221f63170d7afb1ae96a5a140554b09d00870..f76570c0f0bccbdaf8bf230d840e6f1239cf0c9a 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. @@ -86,6 +86,11 @@ public: LOKI_DEFINE_VISITABLE(XdmfTopology, XdmfArray) static const std::string ItemTag; + /** + * + */ + int getBaseOffset() const; + std::map getItemProperties() const; std::string getItemTag() const; @@ -144,6 +149,11 @@ public: */ shared_ptr getType() const; + /** + * + */ + void setBaseOffset(int offset); + /** * Set the XdmfTopologyType associated with this topology. * @@ -169,6 +179,8 @@ public: */ void setType(const shared_ptr type); + XdmfTopology(XdmfTopology &); + protected: XdmfTopology(); @@ -180,10 +192,40 @@ protected: private: - XdmfTopology(const XdmfTopology &); // Not implemented. + XdmfTopology(const XdmfTopology &); void operator=(const XdmfTopology &); // Not implemented. shared_ptr mType; + + int mBaseOffset; }; +#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 4e87e4ff2680c14cfacc2eccea9a3900b5ae7eb9..3e8efadcd8a15e64130a7769fab03133ddae516b 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() @@ -449,6 +454,79 @@ 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["POLYHEDRON"] = Polyhedron; + 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) { @@ -596,6 +674,8 @@ XdmfTopologyType::~XdmfTopologyType() shared_ptr XdmfTopologyType::New(const std::map & itemProperties) { + InitTypes(); + std::map::const_iterator type = itemProperties.find("Type"); if(type == itemProperties.end()) { @@ -606,138 +686,39 @@ 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("POLYHEDRON") == 0) { - return Polyhedron(); - } - 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("QUADRILATERAL_9") == 0) { - return Quadrilateral_9(); - } - 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, @@ -760,7 +741,7 @@ XdmfTopologyType::getEdgesPerElement() const } shared_ptr -XdmfTopologyType::getFaceType() +XdmfTopologyType::getFaceType() const { if (mFaces.size() == 0) { return XdmfTopologyType::NoTopologyType(); @@ -805,3 +786,481 @@ 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 XdmfTopologyTypePolyhedron() +{ + return XDMF_TOPOLOGY_TYPE_POLYHEDRON; +} + +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_POLYHEDRON: + return XdmfTopologyType::Polyhedron(); + 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::Polyhedron()->getID()) { + return XDMF_TOPOLOGY_TYPE_POLYHEDRON; + } + 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 d0d846a0d9ce5cab6b3aeed80d445020cf02b638..9c3154734e45d71874c38e9a6024ccfe02017938 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 @@ -267,7 +272,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 @@ -353,6 +358,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. @@ -371,4 +382,125 @@ private: }; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// C wrappers go here + +#ifndef XDMF_C_TOPOLOGY_TYPES +#define XDMF_C_TOPOLOGY_TYPES +#define XDMF_TOPOLOGY_TYPE_POLYVERTEX 500 +#define XDMF_TOPOLOGY_TYPE_POLYLINE 501 +#define XDMF_TOPOLOGY_TYPE_POLYGON 502 +#define XDMF_TOPOLOGY_TYPE_POLYHEDRON 503 +#define XDMF_TOPOLOGY_TYPE_TRIANGLE 504 +#define XDMF_TOPOLOGY_TYPE_QUADRILATERAL 505 +#define XDMF_TOPOLOGY_TYPE_TETRAHEDRON 506 +#define XDMF_TOPOLOGY_TYPE_PYRAMID 507 +#define XDMF_TOPOLOGY_TYPE_WEDGE 508 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON 509 +#define XDMF_TOPOLOGY_TYPE_EDGE_3 510 +#define XDMF_TOPOLOGY_TYPE_TRIANGLE_6 511 +#define XDMF_TOPOLOGY_TYPE_QUADRILATERAL_8 512 +#define XDMF_TOPOLOGY_TYPE_QUADRILATERAL_9 513 +#define XDMF_TOPOLOGY_TYPE_TETRAHEDRON_10 514 +#define XDMF_TOPOLOGY_TYPE_PYRAMID_13 515 +#define XDMF_TOPOLOGY_TYPE_WEDGE_15 516 +#define XDMF_TOPOLOGY_TYPE_WEDGE_18 517 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_20 518 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_24 519 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_27 520 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_64 521 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_125 522 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_216 523 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_343 524 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_512 525 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_729 526 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1000 527 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_1331 528 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_64 529 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_125 530 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_216 531 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_343 532 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_512 533 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_729 534 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1000 535 +#define XDMF_TOPOLOGY_TYPE_HEXAHEDRON_SPECTRAL_1331 536 +#define XDMF_TOPOLOGY_TYPE_MIXED 537 +#endif + +#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 224ddc572aef7ba3b2b93d7a9716bb6003446f42..4d12ff9921064b1725e78024fc7b4168ae29c82a 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 2d0d9e68f1826d882d21b7be74f37fe1924bd196..041ab54628edffcd3faf3b42a2f3b9e5f28e14ac 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,16 +210,56 @@ 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. }; +#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 118a6dee991d0d4661715fbcee79e6f57205160b..53ddbf91a0421b7930d701e4cdcb5eb22c694d81 100644 --- a/core/CMakeLists.txt +++ b/core/CMakeLists.txt @@ -8,9 +8,9 @@ include(CheckCXXSourceCompiles) include(SetUpVersion) include(TestBigEndian) -if(VERSION_CONTROL_AUTOUPDATE OR +if(VERSION_CONTROL_AUTOUPDATE OR NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/XdmfVersion.hpp) - VersionCreate("Xdmf" "2" "XDMFCORE_EXPORT" "XdmfCore.hpp") + VersionCreate("Xdmf" "3" "3" "0" "XDMFCORE_EXPORT" "XdmfCore.hpp") endif() if(BUILD_SHARED_LIBS) @@ -131,10 +131,12 @@ set(XdmfCoreSources XdmfHDF5Controller XdmfHDF5Writer XdmfHeavyDataController + XdmfHeavyDataDescription XdmfHeavyDataWriter XdmfInformation XdmfItem XdmfItemProperty + XdmfPlaceholder XdmfSparseMatrix XdmfSubset XdmfSystemUtils @@ -142,10 +144,31 @@ set(XdmfCoreSources XdmfVisitor XdmfWriter) -add_library(XdmfCore ${LIBTYPE} ${XdmfCoreSources}) +if (TIFF_FOUND) + set(XdmfCoreSources + ${XdmfCoreSources} + XdmfTIFFController) +endif() + +add_library(XdmfCoreObjects OBJECT ${XdmfCoreSources}) +set_target_properties(XdmfCoreObjects PROPERTIES + POSITION_INDEPENDENT_CODE True) +add_library(XdmfCore ${LIBTYPE} $) +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 (COMMAND vtk_target_install) vtk_target_install(XdmfCore) endif() @@ -155,14 +178,24 @@ if(WIN32) if (BUILD_SHARED_LIBS) set_target_properties(XdmfCore PROPERTIES DEFINE_SYMBOL XdmfCore_EXPORTS) + set_target_properties(XdmfCore_Static PROPERTIES + DEFINE_SYMBOL XdmfCore_EXPORTS) endif() if(NOT MSVC10) - set_target_properties(XdmfCore PROPERTIES + set_target_properties(XdmfCore PROPERTIES PREFIX ../ IMPORT_PREFIX ../ RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + if (BUILD_SHARED_LIBS) + set_target_properties(XdmfCore_Static PROPERTIES + PREFIX ../ + IMPORT_PREFIX ../ + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) + endif () endif() endif() @@ -171,6 +204,10 @@ if(XDMF_WRAP_JAVA) endif() 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() @@ -180,8 +217,13 @@ if(WIN32) endif() 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() + set(XDMFCORE_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfCore.a + PARENT_SCOPE) + endif() endif() if(APPLE) @@ -200,6 +242,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} @@ -217,7 +265,8 @@ set(XDMF_BINARIES ${XDMF_BINARIES} ${CMAKE_INSTALL_PREFIX}/bin) if(XDMF_BUILD_DSM) add_subdirectory(dsm) -endif() + set(XDMF_DSM_IS_CRAY "${XDMF_DSM_IS_CRAY}" PARENT_SCOPE) +endif(XDMF_BUILD_DSM) if(XDMF_BUILD_TESTING) add_subdirectory(tests) @@ -225,4 +274,3 @@ endif() set(XDMF_LIBRARIES ${XDMF_LIBRARIES} PARENT_SCOPE) set(XDMF_BINARIES ${XDMF_BINARIES} PARENT_SCOPE) - diff --git a/core/XdmfArray.cpp b/core/XdmfArray.cpp index fcccb4aff1c0ddbe6fa972148a4649abf9953ddb..18762299cdc8c6db6f40ff5de1d01d33ae39e318 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 ae5d11c682c84fb42fa7b364deb7e2e7f1c3ba8f..691d4d32e71538f3cdd79ced102f90af00464347 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,16 +1525,484 @@ 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" +#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 7c762f1c447b0a7170c14ec5d3f16558cc219c1b..e21798647cf2ef12169942d9ba5de011d46ddb71 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; } @@ -699,6 +700,7 @@ XdmfArray::insert(const unsigned int startIndex, valuesStride, mDimensions), mArray); + this->setIsChanged(true); } template @@ -708,6 +710,7 @@ XdmfArray::pushBack(const T & value) return boost::apply_visitor(PushBack(value, this), mArray); + this->setIsChanged(true); } template @@ -719,8 +722,7 @@ XdmfArray::resize(const unsigned int numValues, numValues, value), mArray); - std::vector newDimensions; - newDimensions.push_back(numValues); + this->setIsChanged(true); } template @@ -735,6 +737,7 @@ XdmfArray::resize(const std::vector & dimensions, std::multiplies())); this->resize(size, value); mDimensions = dimensions; + this->setIsChanged(true); } template @@ -754,6 +757,7 @@ XdmfArray::setValuesInternal(const T * const arrayPointer, mArray = newArrayPointer; } mArrayPointerNumValues = numValues; + this->setIsChanged(true); } template @@ -769,6 +773,7 @@ XdmfArray::setValuesInternal(std::vector & array, shared_ptr > newArray(&array, NullDeleter()); mArray = newArray; } + this->setIsChanged(true); } template @@ -776,6 +781,7 @@ void XdmfArray::setValuesInternal(const shared_ptr > array) { mArray = array; + this->setIsChanged(true); } template @@ -795,6 +801,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 7d8a155f9e81d78ced2671d63d82356bb99827d9..7b27774074cbb4340fba1d8a0b42a1f2b8ade4c5 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 1acfd3be6d5b063be3fe35c91626f367cdddbc06..b2d05e9649dc08b2e95731837cfe13ae2fdf0067 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 f1952ee652497a72556b2269604875e02b7c79f6..0c04fd8bb5ad18c806e44452aee8b05a9d764b98 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,46 @@ 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 only one precision is available, assume that if not specified. + if (returnType->second.size() == 1 && precisionVal == 0) + { + return (*((returnType->second.begin())->second))(); } - return Float32(); - } - else if(typeVal.compare("Int") == 0) { - if(precisionVal == 8) { - return Int64(); + + if (returnPrecision == returnType->second.end()) { + // Default to 32bit types if not specified otherwise + returnPrecision = returnType->second.find(4); + } + + 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 +416,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 4bdc2e9e2343c167f7dc8b4ede5259e9b5fc9b4d..1409a9e99207b2c0a5d521bd186ec63fb6100507 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 e70a70ca9f2007bb85e2d7c977a771c0902c43be..75f887b487b7a43c7cd855ff62f1814eeea171d5 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 217f8644e8679b33699afc269d933a8936c16e40..0d411044030fbcd526ef10dab071d3d837483465 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 1b5a9bc1b7c545b9eb3f3df51c1786841e16dc9c..67cf82f5b02a79737dc97b00fab6be9e5a54416f 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 a1c82d942c880f08cf5303d95d2a6f0a6c028b0f..00f6401f56729f2ba74f95d98a4e50c3d72d1966 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 998c19f4d45f3c72b5673420cdc4d1d5a3b8360a..88387815f073ae4760c27c97bcf2c9422d73549c 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 d68761d5933cf62f2fe81a840f2d1da83810ca03..f8096cf8608b641c9ba30d99b09310f383032f51 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 6c555adc431a74daf35af1ff567811b9bb615223..1e58968fc8db4f1413ebef93a5d4c1f927fb8a4d 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) { @@ -211,52 +209,47 @@ public: else { // Otherwise, generate a new XdmfItem from the node std::map itemProperties; - + 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; +#if 1 //ARL's side + 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; } - } - - if(!whitespace) { - itemProperties.insert(std::make_pair("Content", content)); - itemProperties.insert(std::make_pair("XMLDir", mXMLDir)); - break; - } -*/ -//* +#else //VTK's side, breaks XDMF's tests, revisit if problematic in VTK std::string content((char *)childNode->content); boost::algorithm::trim(content); - + if(content.size() != 0) { itemProperties.insert(std::make_pair("Content", content)); itemProperties.insert(std::make_pair("XMLDir", mXMLDir)); break; } -//*/ +#endif } childNode = childNode->next; } } - + // Pull attributes from node xmlAttrPtr currAttribute = currNode->properties; while(currAttribute != NULL) { @@ -264,21 +257,21 @@ public: (char *)currAttribute->children->content)); currAttribute = currAttribute->next; } - + // Build XdmfItem const std::vector > childItems = this->read(currNode->children); - shared_ptr newItem = + shared_ptr newItem = mItemFactory->createItem((const char *)currNode->name, itemProperties, childItems); - + if(newItem == NULL) { - XdmfError::message(XdmfError::FATAL, + XdmfError::message(XdmfError::FATAL, "mItemFactory failed to createItem in " "XdmfCoreReader::XdmfCoreReaderImpl::readSingleNode"); } - + // Populate built XdmfItem newItem->populateItem(itemProperties, @@ -324,6 +317,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 +401,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 b407d22ca43381da448fa99880e777d7da8241bf..e45c36462e1b5c46f23c14d81f957453e0b478e2 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 8f828658c86c7dea10110e9d3c2e40a26dbe6e53..72a37f2b1087f24d5b17311530f851189cbf72c1 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 fecc025a5b1cd70848b48a6b4c72f5d5c3436390..6f900c7a1c2458d5e8e561d084709406379ecd5e 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 261edca12bc9572e8226d52010f1840873324a42..a9429b459d70be114c7a9fa3b107259ce8344495 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 b3d7efec0e63c788ecf8bc6e22db201b27ce1bdd..e63d66db57581a575f9ea12552fa9029d4c0c09f 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 663cdecc77a992f40d4764775fa71917f6dfa05b..fe7eb606dd07893daae16648e4210e50f6adfe64 100644 --- a/core/XdmfHDF5Controller.cpp +++ b/core/XdmfHDF5Controller.cpp @@ -25,6 +25,7 @@ #include #include #include +#include "string.h" #include "XdmfArray.hpp" #include "XdmfArrayType.hpp" #include "XdmfError.hpp" @@ -64,11 +65,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) { } @@ -94,16 +125,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 @@ -124,18 +161,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) { @@ -320,3 +345,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 d15097e1cf8c589718f493171293062024d711a0..c5c15d0af3bdfcc40502aa3d6f5cd0757da0003c 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 62526484e6e8dacc8881afff42b506234ec15576..4f05cd384300b0f3f2d45548784c31d9ad61ef97 100644 --- a/core/XdmfHDF5Writer.cpp +++ b/core/XdmfHDF5Writer.cpp @@ -28,12 +28,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 { @@ -41,91 +43,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, @@ -140,7 +125,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) { } @@ -151,17 +146,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, @@ -220,7 +217,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; } @@ -249,7 +252,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 @@ -325,8 +330,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 @@ -413,11 +418,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 @@ -728,6 +733,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); @@ -810,6 +817,7 @@ XdmfHDF5Writer::controllerSplitting(XdmfArray & array, } } } + ++dataSetId; } if (mMode == Append) { @@ -894,6 +902,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); @@ -920,24 +930,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 { @@ -945,27 +937,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 { @@ -975,6 +974,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); @@ -991,23 +997,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); } @@ -1017,18 +1028,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); } } @@ -1061,8 +1084,7 @@ XdmfHDF5Writer::visit(XdmfItem & item, void -XdmfHDF5Writer::write(XdmfArray & array, - const int fapl) +XdmfHDF5Writer::write(XdmfArray & array) { hid_t datatype = -1; bool closeDatatype = false; @@ -1133,7 +1155,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 @@ -1142,10 +1169,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", @@ -1171,6 +1199,8 @@ XdmfHDF5Writer::write(XdmfArray & array, } std::list filesWritten; + std::list datasetsWritten; + std::list datasetIdsWritten; std::list arraysWritten; std::list > startsWritten; std::list > stridesWritten; @@ -1238,17 +1268,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, @@ -1266,6 +1298,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(); @@ -1275,11 +1309,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; @@ -1296,7 +1331,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, @@ -1316,13 +1358,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); @@ -1373,6 +1419,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, @@ -1507,15 +1559,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(); @@ -1525,7 +1575,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); @@ -1573,6 +1623,8 @@ XdmfHDF5Writer::write(XdmfArray & array, array.insert(newDataController); fileNameWalker++; + datasetWalker++; + datasetIdWalker++; arrayWalker++; startWalker++; strideWalker++; @@ -1580,6 +1632,10 @@ XdmfHDF5Writer::write(XdmfArray & array, dataSizeWalker++; arrayOffsetWalker++; + if (mMode == Default) { + dataSetPath.str(std::string()); + dataSetPath << "Data" << ++mDataSetId; + } } @@ -1594,3 +1650,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 8850fb1d0dc0a3a53d21a1da07ace2fdaa92c27a..cfbec6f454294ebee5b1f035a463d7c745c81848 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 4b5bb01353b75c6b0442ea935a9c514cd2f014b8..0486fcc6da6b8a423dbdcdcbeefaed55f61d77f5 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 329a18f4b4f4aa5e2a214eb6ffdf04ec1ce6b292..e0622f2bdd18fb34f1eaf9e1d6adb564962e5e64 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,23 +404,156 @@ 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. }; +#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 0000000000000000000000000000000000000000..37e652ff2c6872f16ec28f0ee4b738f6b300504d --- /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 0000000000000000000000000000000000000000..349350993d7689e816170d01cd23e9e6af9033ae --- /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 3f9c013c0182497ff7472e50f99777b372019474..09e08a8c1a5b0271f6e3a085f84590a40b66f10e 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 8f6e57be01933175959fc4f2c119f05862f4f926..389ebd1b2925ca50dddbcc279557698f3d80e67c 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 d0d4b71eff9a5d5ae4cd99e8e0e13fd74da14d1d..050ac5f0e7d8cc8650ff337c5ff526df099c4942 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 308bbdbcd448f87a1a1c8bec41ce2383b0917c45..ac50d96d05f32f63657f6f8b6a60837e37e3c63d 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,11 +221,55 @@ protected: private: - XdmfInformation(const XdmfInformation &); // Not implemented. + XdmfInformation(const XdmfInformation &); void operator=(const XdmfInformation &); // Not implemented. std::string mKey; std::string mValue; }; +#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 6cba7d5d1ba1521417bf20b23ef03f0284bc515f..38c0dfd5dfd178933098af7143deb3c2f0997a30 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 5626e717f3e28b5a8296c4194e319aa716a71c4b..ebdb7283ce9ba22add15e6ebece561f27bef234b 100644 --- a/core/XdmfItem.hpp +++ b/core/XdmfItem.hpp @@ -24,18 +24,25 @@ #ifndef XDMFITEM_HPP_ #define XDMFITEM_HPP_ +// C Compatible Includes +#include "XdmfCore.hpp" +#include "XdmfVisitor.hpp" + +#ifdef __cplusplus + // Forward Declarations class XdmfCoreReader; class XdmfInformation; class XdmfVisitor; // Includes -#undef reference //stop libXML2 mangle of "reference" from causing havoc #include +#include +#include #include +#include #include #include -#include "XdmfCore.hpp" #include "XdmfSharedPtr.hpp" // Macro that allows children XdmfItems to be attached to a parent XdmfItem. @@ -243,6 +250,7 @@ public : ParentClass::insert(const shared_ptr ChildName) \ { \ m##ChildName##s.push_back(ChildName); \ + this->setIsChanged(true); \ } \ \ void \ @@ -251,6 +259,7 @@ public : if(index < m##ChildName##s.size()) { \ m##ChildName##s.erase(m##ChildName##s.begin() + index); \ } \ + this->setIsChanged(true); \ } \ \ void \ @@ -265,6 +274,7 @@ public : return; \ } \ } \ + this->setIsChanged(true); \ } /** @@ -284,6 +294,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 @@ -362,6 +375,8 @@ public: */ virtual void traverse(const shared_ptr visitor); + XdmfItem(XdmfItem &); + protected: XdmfItem(); @@ -382,6 +397,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. @@ -389,4 +414,102 @@ private: }; +#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 b6091c54880568ed79ceb94fd7473b26bc7f2a40..d3d46bd60b4eccb720fa5f94372df33ca8f4a4fb 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 e9a054dc8eea2753226dc9889f74a740901bc1ab..9a1bd86efa8fdb7f51b1eca6341cad4d32db006f 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 0000000000000000000000000000000000000000..0ee885a88258fd8f2713a690b375e581d9232bdb --- /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 0000000000000000000000000000000000000000..4988dca5537087bc465c3583dd4f189bd873177a --- /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 afb0ff915a5947da7be9fe29b6f0f0c297a50366..cfa7b916826c82c79a8ca3d32cac2285f1b61001 100644 --- a/core/XdmfSharedPtr.hpp +++ b/core/XdmfSharedPtr.hpp @@ -24,6 +24,8 @@ #ifndef XDMFSHAREDPTR_HPP_ #define XDMFSHAREDPTR_HPP_ +#ifdef __cplusplus + #include "XdmfCoreConfig.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 4f057d1bc52622ab834a6e93361cc6214aae81fb..8276cc66c7929dbe71cb31c0a99a860e31a4b246 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 2448d427f96ab59ae2e9e12d22680108ef167288..496f13abda6c1f468a1b0b408151ab02c1011e3d 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 4fe80cd7085b173ded3abe7a77cb1f6e033eb8f1..04236a93ee63da084dc4e4ac86aa476a8dac9bb3 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 5c04a0d9e3cf20d25cb8c1777a1ce7a37b626e2e..b4b0657f04ff1d660278f4667ffca7d5c3d69d37 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 30c00d1237b9f37acfb832212e35610685e82888..3fe54b2ea2bbdb757e5424eff5fd26661a8b9d1c 100644 --- a/core/XdmfSystemUtils.cpp +++ b/core/XdmfSystemUtils.cpp @@ -27,6 +27,7 @@ #include "XdmfSystemUtils.hpp" #include "XdmfCoreConfig.hpp" #include +#include "string.h" XdmfSystemUtils::XdmfSystemUtils() { @@ -50,6 +51,12 @@ 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]; char *rp = realpath(ref->path, realPath); if (rp == 0) @@ -61,5 +68,13 @@ XdmfSystemUtils::getRealPath(const std::string & path) } xmlFreeURI(ref); return std::string(rp); +#endif } #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 3910ee73ae088630ec6fc02c7c1f47409e4c9b97..d8e5329f4d3720b969a5978599131eb38178f491 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 0000000000000000000000000000000000000000..08411b6ad1527d39bb2018e32f030bb94425996b --- /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 0000000000000000000000000000000000000000..94daf5bcff5cb9d30923f36fe3dbe379defe8a0a --- /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 92b0bc551d82df9004a1b7895810bf59309717e8..86bb40d80e31568c8bcc7678ec2fa33df37937df 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 3580354e673aa01d93c3b84631249970260d5d8d..227c6cedb926312c1643986629672948aa190406 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 7ab83231362f394b56ab2cc071f6758209943f3f..8f9f365ca3063021678bb0dea327e374e25781e6 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,12 +574,56 @@ private: */ class XdmfWriterImpl; - XdmfWriter(const XdmfWriter &); // Not implemented. void operator=(const XdmfWriter &); // Not implemented. XdmfWriterImpl * mImpl; }; +#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_ */ \ No newline at end of file +#endif /* XDMFWRITER_HPP_ */ diff --git a/core/dsm/CMakeLists.txt b/core/dsm/CMakeLists.txt index b69abf126d473847b750ceb7a0a3852e8d58e5a3..36d0ed6712211f95469237dc024c5e88d9f27216 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 () - if (XDMF_BUILD_DSM_THREADS) find_package(H5FDdsm REQUIRED NO_MODULE) if(H5FDdsm_FOUND) @@ -76,21 +79,64 @@ if (XDMF_BUILD_DSM_THREADS) endif() endif () -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}) +set_target_properties(XdmfDSMObjects PROPERTIES + POSITION_INDEPENDENT_CODE True) +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 + set_target_properties(XdmfDSM 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(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() endif() endif() @@ -99,6 +145,10 @@ if(XDMF_WRAP_JAVA) endif() 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() @@ -106,12 +156,17 @@ endif() set(XDMF_LIBRARY_DIRS ${XDMF_LIBRARY_DIRS} PARENT_SCOPE) if(WIN32) - set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/XdmfDSM.lib PARENT_SCOPE) + set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/XdmfDSM.lib PARENT_SCOPE) endif() if(UNIX) + if (BUILD_SHARED_LIBS) set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfDSM.so - PARENT_SCOPE) + PARENT_SCOPE) + else (BUILD_SHARED_LIBS) + set(XDMFDSM_LIBRARY ${CMAKE_INSTALL_PREFIX}/lib/libXdmfDSM.a + PARENT_SCOPE) + endif (BUILD_SHARED_LIBS) endif() if(APPLE) @@ -128,6 +183,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 615ed05e9989045b1d6734cdd07b24644732d841..cf1b0c1758930dbec2649539acb81a9da0d53330 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 b59daf6d16a19d5ea0783097ced513de1bd0e743..e02ea7b38f17b41e4086f120a6ec9d6688765568 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), +