VMAP API Reference Manual

Tutorial 1 – Create a simulation result with geometry, one part, and one nodal variable

This tutorial follows the same API sequence used by the existing geometry examples in test/write_read_pointsblock.cxx, test/write_read_elementsblock.cxx, and the state-variable setup visible in swig/Interfacetest/C++/example.cxx.

1. Open the VMAP file and create the simulation branch hierarchy.
2. Create a geometry group for the part and write its point block.
3. Create the integration type and element type referenced by the mesh.
4. Write the element block using the previously defined element type identifier.
5. Create a result group for STATE-1 and attach state metadata.
6. Create a scalar nodal sStateVariable and write it into the state/part result path.

#include "VMAP.h"
#include "VMAPFile.h"
#include "VMAPElementTypeFactory.h"
#include "VMAPIntegrationTypeFactory.h"

#include <vector>

int main() {
  using namespace VMAP;

  VMAPFile file("plate_result.vmap", VMAPFile::CREATEORREPLACE);
  file.createSimulationGroups();

  const int partId = 1;
  const int stateId = 1;

  std::string partPath = file.createGeometryGroup(partId, "Plate");

  sPointsBlock points(4);
  points.setPoint(0, 1, 0.0, 0.0, 0.0);
  points.setPoint(1, 2, 1.0, 0.0, 0.0);
  points.setPoint(2, 3, 1.0, 1.0, 0.0);
  points.setPoint(3, 4, 0.0, 1.0, 0.0);
  file.writePointsBlock(partPath, points);

  sIntegrationType quadRule =
      VMAPIntegrationTypeFactory::createVMAPIntegrationType(
          VMAPIntegrationTypeFactory::GAUSS_QUAD_4);
  quadRule.setIdentifier(1);
  file.writeIntegrationTypes(std::vector<sIntegrationType>{quadRule});

  sElementType quadType =
      VMAPElementTypeFactory::createVMAPElementType(
          sElementType::ELEM_3D,
          sElementType::QUAD_4,
          sElementType::CONSTANT,
          quadRule.getIdentifier());
  quadType.setIdentifier(1);
  quadType.setTypeDescription("Four-node quad shell");
  quadType.setNumberOfNormalComponents(3);
  quadType.setNumberOfShearComponents(1);
  file.writeElementTypes(std::vector<sElementType>{quadType});

  sElement element;
  element.setIdentifier(1);
  element.setElementType(quadType.getIdentifier());
  element.setCoordinateSystem(-1);
  element.setMaterialType(-1);
  element.setSectionType(-1);
  element.setConnectivity(std::vector<int>{1, 2, 3, 4});

  sElementBlock elements(1);
  elements.setElement(0, element);
  file.writeElementsBlock(partPath, elements);

  std::string resultPath = file.createVariablesGroup(stateId, partId);
  file.setVariableStateInformation(stateId, "LOADSTEP-1", 1.0, 1.0, 1);

  sStateVariable temperature;
  temperature.setIdentifier(1);
  temperature.setVariableName("TEMPERATURE");
  temperature.setVariableDescription("Nodal temperature in degree Celsius");
  temperature.setIncrementValue(1);
  temperature.setTimeValue(1.0);
  temperature.setModalFrequency(-1.0);
  temperature.setUnit(-1);
  temperature.setCoordinateSystem(-1);
  temperature.setDimension(sStateVariable::DIMENSION_SCALAR);
  temperature.setLocation(sStateVariable::LOCATION_NODE);
  temperature.setMultiplicity(1);
  temperature.setEntity(sStateVariable::ENTITY_REAL);
  temperature.setValues(std::vector<double>{20.0, 35.0, 42.0, 28.0});
  file.writeVariable(resultPath, temperature);

  file.closeFile();
  return 0;
}

Tutorial 2 – Read the written simulation result back for validation

After writing, reopen the file in read-only mode and confirm the part geometry, state metadata, and variable block.

#include "VMAP.h"
#include "VMAPFile.h"

#include <string>
#include <vector>

int main() {
  using namespace VMAP;

  VMAPFile file("plate_result.vmap", VMAPFile::OPENREADONLY);

  sPointsBlock points;
  file.readPointsBlock("/VMAP/SIMULATION/GEOMETRY/1", points);

  sElementBlock elements;
  file.readElementsBlock("/VMAP/SIMULATION/GEOMETRY/1", elements);

  std::string stateName;
  double totalTime = 0.0;
  double stepTime = 0.0;
  double modalFrequency = -1.0;
  int increment = 0;
  file.getVariableStateInformation(1, stateName, totalTime, stepTime, increment, modalFrequency);

  std::vector<sStateVariable> variables;
  file.readVariablesBlock("/VMAP/SIMULATION/VARIABLES/STATE-1/1", variables);

  file.closeFile();
  return 0;
}