Advanced Example
A more complex example demonstrating different ways of populating the blocks. For
instance a node block (NodeBlock) can be populated with
either setting all nodes at once with setNodes()
or setting them one at a time using addNode().
This example contains two parts, two states, a scalar result, a vector result and a displacement result.
It also uses properties for the following features:
Show Part 1 as lines
Show scalar result as fringes. Set legend range 1.0 to 5.0.
Show vector result. Color vector arrows by fringes.
Set initial camera position
This example can be overwhelming to start with, but is a very good reference for more practiced users.
Source file
const bool allAtOnce = 0;
//--------------------------------------------------------------------------------------------------
// Writes the given nodes to the VTFx file
//--------------------------------------------------------------------------------------------------
bool writeNodes(int blockId, cee::vtfx::Database* database, const std::vector<float> nodes, const std::vector<int> nodeIds)
{
// Create the node block
cee::PtrRef<cee::vtfx::NodeBlock> nodeBlock = new cee::vtfx::NodeBlock(blockId, !nodeIds.empty());
// Set the node data (Note: Express Writer expects interleaved node coordinates (xyzxyzxyz...))
// -------------------------------------------------------------------------
if (allAtOnce)
{
// Alt 1: Supply all nodes at once
if (!nodeBlock->setNodes(nodes, nodeIds))
{
return false;
}
}
else
{
// Alt 2: Add each node individually, using pre-allocation
if (!nodeBlock->allocateNodes(nodes.size()))
{
return false;
}
for (size_t i = 0; i < nodes.size() / 3; i++)
{
if (!nodeIds.empty())
{
nodeBlock->addNode(nodes[i * 3], nodes[i * 3 + 1], nodes[i * 3 + 2], nodeIds[i]);
}
else
{
nodeBlock->addNode(nodes[i * 3], nodes[i * 3 + 1], nodes[i * 3 + 2]);
}
}
}
// Write the block
// -------------------------------------------------------------------------
if (!database->writeBlock(nodeBlock.get()))
{
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
// Writes the given elements to the VTFx file
//--------------------------------------------------------------------------------------------------
bool writeElements(int blockId, cee::vtfx::Database* database, std::vector<int> elementNodes, cee::vtfx::ElementBlock::ElementType elementType, int nodeBlockId, std::vector<int> elementIds)
{
// Create the element block, using index mapping for the nodes
cee::PtrRef<cee::vtfx::ElementBlock> elementBlock = new cee::vtfx::ElementBlock(blockId, !elementIds.empty(), false);
// Set the element data
// -------------------------------------------------------------------------
if (allAtOnce)
{
// Set all elements at once (most efficient)
if (!elementBlock->addElements(elementType, elementNodes, elementIds))
{
return false;
}
}
else
{
// Add elements individually (requires frequent re-allocations)
int numElementNodes = static_cast<int>(cee::vtfx::ElementBlock::nodesPerElement(elementType));
int numElements = static_cast<int>(elementNodes.size()) / numElementNodes;
for (int i = 0; i < numElements; i++)
{
std::vector<int> currentElementNodes;
currentElementNodes.assign(elementNodes.begin() + (i*numElementNodes), elementNodes.begin() + ((i + 1)*numElementNodes));
if (!elementBlock->addElement(elementType, currentElementNodes, elementIds.empty() ? -1 : elementIds[i]))
{
return false;
}
}
}
elementBlock->setNodeBlockId(nodeBlockId);
// Write the block
// -------------------------------------------------------------------------
if (!database->writeBlock(elementBlock.get()))
{
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
// Writes the given geometry to the VTFx file
//--------------------------------------------------------------------------------------------------
bool writeGeometry(cee::vtfx::Database* database, const std::vector<int>& elementParts)
{
cee::PtrRef<cee::vtfx::GeometryBlock> geoBlock = new cee::vtfx::GeometryBlock(1); // Only one geometry per state
size_t geoIndex = 0;
// Set the element data
// -------------------------------------------------------------------------
if (!geoBlock->setElementBlocks(geoIndex, elementParts, elementParts)) // There's one part for each element block. Use same id array for simplicity.
{
return false;
}
// Write the block
// -------------------------------------------------------------------------
if (!database->writeBlock(geoBlock.get()))
{
return false;
}
// Set info
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::GeometryInfoBlock> infoBlock = new cee::vtfx::GeometryInfoBlock(1); // Only one geometry per state
for (size_t i = 0; i < elementParts.size(); i++)
{
infoBlock->addPartInfo(geoIndex, elementParts[i], cee::Str("Part %1").arg((int)i));
}
if (!database->writeBlock(infoBlock.get()))
{
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
// Writes 1D/3D result values for one part to the file
//--------------------------------------------------------------------------------------------------
bool writeResult(int blockId, cee::vtfx::Database* database, const std::vector<float>& resultValues, int mapToBlock, cee::vtfx::Block::BlockType mapToBlockType, cee::vtfx::ResultValuesBlock::ResultValueDimension dimension)
{
// Create the result values block
cee::PtrRef<cee::vtfx::ResultValuesBlock> resultValuesBlock = new cee::vtfx::ResultValuesBlock(blockId, dimension, false);
resultValuesBlock->setMapToBlockId(mapToBlock, mapToBlockType);
// Set the result values
// -------------------------------------------------------------------------
if (allAtOnce)
{
// Alt 1: Set data directly
if (!resultValuesBlock->setResultValues(resultValues))
{
return false;
}
}
else
{
// Alt 2: Add each result value individually (using pre-allocation)
if (dimension == cee::vtfx::ResultValuesBlock::SCALAR1D)
{
if (!resultValuesBlock->allocateResultValues(static_cast<int>(resultValues.size())))
{
return false;
}
for (size_t i = 0; i < resultValues.size(); i++)
{
resultValuesBlock->addResultValue1d(resultValues[i]);
}
}
else // assuming dimension VECTOR3D
{
if (!resultValuesBlock->allocateResultValues(static_cast<int>(resultValues.size()) / 3))
{
return false;
}
for (size_t i = 0; i < resultValues.size() / 3; i++)
{
resultValuesBlock->addResultValue3d(resultValues[3 * i], resultValues[3 * i + 1], resultValues[3 * i + 2]);
}
}
}
// Write the block
// -------------------------------------------------------------------------
if (!database->writeBlock(resultValuesBlock.get()))
{
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
// Creates case properties
//--------------------------------------------------------------------------------------------------
bool createProperties(cee::vtfx::Case* currentCase)
{
cee::PtrRef<cee::PropertySetCollection> vtfxProps = new cee::PropertySetCollection;
cee::PtrRef<cee::PropertySet> partSettings = new cee::PropertySet("part_settings");
partSettings->setValue("context_geometry_index", static_cast<unsigned int>(0));
partSettings->setValue("context_part_id", 1);
partSettings->setValue("draw_style", "line");
vtfxProps->addPropertySet(partSettings.get());
cee::PtrRef<cee::PropertySet> scalarSelection = new cee::PropertySet("result_selection");
scalarSelection->setValue("fringes_result_id", 1);
vtfxProps->addPropertySet(scalarSelection.get());
cee::PtrRef<cee::PropertySet> colorMapper = new cee::PropertySet("color_mapper_filled_contours_uniform");
colorMapper->setValue("context_result_id", 1);
colorMapper->setValue("range_min", 1.0);
colorMapper->setValue("range_max", 5.0);
vtfxProps->addPropertySet(colorMapper.get());
cee::PtrRef<cee::PropertySet> vectorSelection = new cee::PropertySet("result_selection");
std::vector<cee::Variant> vectorIds;
vectorIds.push_back(1);
vectorSelection->setValue("vector_result_ids", vectorIds);
vtfxProps->addPropertySet(vectorSelection.get());
cee::PtrRef<cee::PropertySet> vectorSettings = new cee::PropertySet("vector_settings");
vectorSettings->setValue("context_result_id", 1);
vectorSettings->setValue("color_mode", "color_by_fringes");
vtfxProps->addPropertySet(vectorSettings.get());
cee::PtrRef<cee::PropertySet> camera = new cee::PropertySet("camera");
camera->setValue("eye", cee::Vec3d(2.0, -7.5, 1-0));
camera->setValue("vrp", cee::Vec3d(2.0, -5.5, 1.0));
camera->setValue("vup", cee::Vec3d(0.0, 0.0, 1.0));
vtfxProps->addPropertySet(camera.get());
// Write the block
if (!currentCase->setProperties(vtfxProps.get()))
{
return false;
}
return true;
}
cee::PtrRef<cee::Instance> g_componentInstance;
//--------------------------------------------------------------------------------------------------
// Main function, program entry point
//--------------------------------------------------------------------------------------------------
int main()
{
// Initialize components and set up logging to console
// -------------------------------------------------------------------------
g_componentInstance = cee::CoreComponent::initialize(HOOPS_LICENSE);
cee::vtfx::VTFxComponent::initialize(g_componentInstance.get());
cee::PtrRef<cee::LogDestinationConsole> log = new cee::LogDestinationConsole();
cee::CoreComponent::logManager()->setDestination(log.get());
cee::CoreComponent::logManager()->setLevel("", 3); // Log errors, warnings and info
const cee::Str fileName = "Example1.vtfx";
// Create the VTFx file
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::File> file = new cee::vtfx::File;
// Create VTFx file settings struct
// -------------------------------------------------------------------------
cee::vtfx::FileSettings fileSettings;
fileSettings.binary = true;
fileSettings.compressionLevel = 5; // 0 to 9
fileSettings.applicationName = "VTFx: VTFxExample";
fileSettings.vendorName = "My Company AS";
fileSettings.createDigitalSignature = false;
// Let the API create the VTFx file
if (!file->create(fileName, fileSettings))
{
return EXIT_FAILURE;
}
// Create a single database (could have many)
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::Database> singleDatabase = new cee::vtfx::Database(file.get(), "Single Database", 1); // database id 1
// Create a single case (could have many)
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::Case> singleCase = new cee::vtfx::Case(file.get(), "Single Case", 1, 1); // case ID 1 using database with id 1
// Part 1
// -------------------------------------------------------------------------
// Write nodes
std::vector<float> nodesPart1(NODES_PART_1, NODES_PART_1 + sizeof(NODES_PART_1) / sizeof(float));
std::vector<int> nodesPart1Ids(NODES_PART_1_IDS, NODES_PART_1_IDS + sizeof(NODES_PART_1_IDS) / sizeof(int));
if (!writeNodes(1, singleDatabase.get(), nodesPart1, nodesPart1Ids))
{
return EXIT_FAILURE;
}
// Write elements
std::vector<int> connectsPart1(CONNECTS_PART_1, CONNECTS_PART_1 + sizeof(CONNECTS_PART_1) / sizeof(int));
std::vector<int> elementPart1(ELEMENTS_PART_1_IDS, ELEMENTS_PART_1_IDS + sizeof(ELEMENTS_PART_1_IDS) / sizeof(int));
if (!writeElements(1, singleDatabase.get(), connectsPart1, elementTypePart1, 1, elementPart1))
{
return EXIT_FAILURE;
}
// Part 2
// -------------------------------------------------------------------------
// Write nodes
std::vector<float> nodesPart2(NODES_PART_2, NODES_PART_2 + sizeof(NODES_PART_2) / sizeof(float));
std::vector<int> nodesPart2Ids(NODES_PART_2_IDS, NODES_PART_2_IDS + sizeof(NODES_PART_2_IDS) / sizeof(int));
if (!writeNodes(2, singleDatabase.get(), nodesPart2, nodesPart2Ids))
{
return EXIT_FAILURE;
}
// Write elements
std::vector<int> connectsPart2(CONNECTS_PART_2, CONNECTS_PART_2 + sizeof(CONNECTS_PART_2) / sizeof(int));
std::vector<int> elementPart2(ELEMENTS_PART_2_IDS, ELEMENTS_PART_2_IDS + sizeof(ELEMENTS_PART_2_IDS) / sizeof(int));
if (!writeElements(2, singleDatabase.get(), connectsPart2, elementTypePart2, 2, elementPart2))
{
return EXIT_FAILURE;
}
// Write Geometry definition
// -------------------------------------------------------------------------
std::vector<int> elementParts(ELEMENT_PARTS, ELEMENT_PARTS + sizeof(ELEMENT_PARTS) / sizeof(int));
if (!writeGeometry(singleDatabase.get(), elementParts))
{
return EXIT_FAILURE;
}
// Write the scalar result values
// -------------------------------------------------------------------------
// Write result values for each part for each step (here 2 parts, 2 steps)
std::vector<float> result1P1S1(RESULT1_P1_S1, RESULT1_P1_S1 + sizeof(RESULT1_P1_S1) / sizeof(int));
if (!writeResult(1, singleDatabase.get(), result1P1S1, 1, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::SCALAR1D))
{
return EXIT_FAILURE;
}
std::vector<float> result1P1S2(RESULT1_P1_S2, RESULT1_P1_S2 + sizeof(RESULT1_P1_S2) / sizeof(int));
if (!writeResult(11, singleDatabase.get(), result1P1S2, 1, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::SCALAR1D))
{
return EXIT_FAILURE;
}
std::vector<float> result1P2S1(RESULT1_P2_S1, RESULT1_P2_S1 + sizeof(RESULT1_P2_S1) / sizeof(int));
if (!writeResult(2, singleDatabase.get(), result1P2S1, 2, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::SCALAR1D))
{
return EXIT_FAILURE;
}
std::vector<float> result1P2S2(RESULT1_P2_S2, RESULT1_P2_S2 + sizeof(RESULT1_P2_S2) / sizeof(int));
if (!writeResult(12, singleDatabase.get(), result1P2S2, 2, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::SCALAR1D))
{
return EXIT_FAILURE;
}
// Write the scalar result definition
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::ResultBlock> scalarResult = new cee::vtfx::ResultBlock(1, cee::vtfx::ResultBlock::SCALAR, cee::vtfx::ResultBlock::NODE_MAPPING);
if (!scalarResult->addResultValuesBlock(1, 1) || // Assign the result values blocks to state IDs. Order is not significant.
!scalarResult->addResultValuesBlock(11, 2) ||
!scalarResult->addResultValuesBlock(2, 1) ||
!scalarResult->addResultValuesBlock(12, 2))
{
return EXIT_FAILURE;
}
scalarResult->setResultId(1);
scalarResult->setName("My scalar result");
scalarResult->setUnit("m^2");
if (!singleDatabase->writeBlock(scalarResult.get()))
{
return EXIT_FAILURE;
}
// Write the vector result values
// -------------------------------------------------------------------------
// Write result values for each part for each step (here 2 parts, 2 steps)
std::vector<float> result2P1S1(RESULT2_P1_S1, RESULT2_P1_S1 + sizeof(RESULT2_P1_S1) / sizeof(float));
if (!writeResult(101, singleDatabase.get(), result2P1S1, 1, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
std::vector<float> result2P1S2(RESULT2_P1_S2, RESULT2_P1_S2 + sizeof(RESULT2_P1_S2) / sizeof(float));
if (!writeResult(111, singleDatabase.get(), result2P1S2, 1, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
std::vector<float> result2P2S1(RESULT2_P2_S1, RESULT2_P2_S1 + sizeof(RESULT2_P2_S1) / sizeof(float));
if (!writeResult(102, singleDatabase.get(), result2P2S1, 2, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
std::vector<float> result2P2S2(RESULT2_P2_S2, RESULT2_P2_S2 + sizeof(RESULT2_P2_S2) / sizeof(float));
if (!writeResult(112, singleDatabase.get(), result2P2S2, 2, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
// Write the vector result definition
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::ResultBlock> vectorResult = new cee::vtfx::ResultBlock(2, cee::vtfx::ResultBlock::VECTOR, cee::vtfx::ResultBlock::NODE_MAPPING);
if (!vectorResult->addResultValuesBlock(101, 1) || // Assign the result values blocks to state IDs. Order is not significant.
!vectorResult->addResultValuesBlock(111, 2) ||
!vectorResult->addResultValuesBlock(102, 1) ||
!vectorResult->addResultValuesBlock(112, 2))
{
return EXIT_FAILURE;
}
vectorResult->setResultId(1);
vectorResult->setName("My vector result");
if (!singleDatabase->writeBlock(vectorResult.get()))
{
return EXIT_FAILURE;
}
// Write the Displacement result values
// -------------------------------------------------------------------------
// Write result values for each part for each step (here 2 parts, 2 steps)
std::vector<float> result3P1S1(RESULT3_P1_S1, RESULT3_P1_S1 + sizeof(RESULT3_P1_S1) / sizeof(float));
if (!writeResult(201, singleDatabase.get(), result3P1S1, 1, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
std::vector<float> result3P1S2(RESULT3_P1_S2, RESULT3_P1_S2 + sizeof(RESULT3_P1_S2) / sizeof(float));
if (!writeResult(211, singleDatabase.get(), result3P1S2, 1, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
std::vector<float> result3P2S1(RESULT3_P2_S1, RESULT3_P2_S1 + sizeof(RESULT3_P2_S1) / sizeof(float));
if (!writeResult(202, singleDatabase.get(), result3P2S1, 2, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
std::vector<float> result3P2S2(RESULT3_P2_S2, RESULT3_P2_S2 + sizeof(RESULT3_P2_S2) / sizeof(float));
if (!writeResult(212, singleDatabase.get(), result3P2S2, 2, cee::vtfx::Block::NODES, cee::vtfx::ResultValuesBlock::VECTOR3D))
{
return EXIT_FAILURE;
}
// Write the displacement result definition
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::ResultBlock> displacementResult = new cee::vtfx::ResultBlock(3, cee::vtfx::ResultBlock::DISPLACEMENT, cee::vtfx::ResultBlock::NODE_MAPPING);
if (!displacementResult->addResultValuesBlock(201, 1) || // Assign the result values blocks to state ids. Order is not significant.
!displacementResult->addResultValuesBlock(211, 2) ||
!displacementResult->addResultValuesBlock(202, 1) ||
!displacementResult->addResultValuesBlock(212, 2))
{
return EXIT_FAILURE;
}
displacementResult->setResultId(1);
displacementResult->setName("My displacement result");
if (!singleDatabase->writeBlock(displacementResult.get()))
{
return EXIT_FAILURE;
}
// Write state information info (here we have two "steps" of a time series)
// -------------------------------------------------------------------------
cee::PtrRef<cee::vtfx::StateInfoBlock> stepInfo = new cee::vtfx::StateInfoBlock;
if (!stepInfo->addStateInfo(1, "First step", 1.0f, cee::vtfx::StateInfoBlock::TIME) ||
!stepInfo->addStateInfo(2, "Second and last step", 5.0f, cee::vtfx::StateInfoBlock::TIME))
{
return EXIT_FAILURE;
}
if (!singleDatabase->writeBlock(stepInfo.get()))
{
return EXIT_FAILURE;
}
// Create properties
// -------------------------------------------------------------------------
if (!createProperties(singleCase.get()))
{
return EXIT_FAILURE;
}
// Finally close the file
// -------------------------------------------------------------------------
if (!file->close())
{
return EXIT_FAILURE;
}
std::cout << "Exported successfully to file: " << fileName.toStdString() << std::endl;
std::cout << std::endl << "Press enter to exit..." << std::endl;
std::cin.ignore();
return EXIT_SUCCESS;
}
Header file
// Part 1
// -----------------------------------------------------------------------------
// Nodes for part 1
const float NODES_PART_1[] =
{
0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 1.0f,
0.0f, 0.0f, 2.0f,
1.0f, 0.0f, 2.0f,
1.0f, 1.0f, 2.0f,
0.0f, 1.0f, 2.0f
};
const int NODES_PART_1_IDS[] =
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
};
// Elements for part 1
const int CONNECTS_PART_1[] =
{
0, 1, 2, 3, 4, 5, 6, 7,
4, 5, 6, 7, 8, 9, 10, 11
};
const cee::vtfx::ElementBlock::ElementType elementTypePart1 = cee::vtfx::ElementBlock::HEXAHEDRONS;
const int ELEMENTS_PART_1_IDS[] =
{
1, 2
};
// Part 2
// -----------------------------------------------------------------------------
// Nodes for part 2
const float NODES_PART_2[] =
{
2.0f, 0.0f, 0.0f,
3.0f, 0.0f, 0.0f,
3.0f, 1.0f, 0.0f,
2.0f, 1.0f, 0.0f,
4.0f, 0.0f, 0.0f,
4.0f, 1.0f, 0.0f
};
const int NODES_PART_2_IDS[] =
{
101, 102, 103, 104, 105, 106
};
// Elements for part 2
const int CONNECTS_PART_2[] =
{
0, 1, 2, 3,
1, 4, 5, 2
};
const cee::vtfx::ElementBlock::ElementType elementTypePart2 = cee::vtfx::ElementBlock::QUADS;
const int ELEMENTS_PART_2_IDS[] =
{
3, 4
};
// Geometry definition
// -----------------------------------------------------------------------------
const int ELEMENT_PARTS[] =
{
1, 2
};
// Time step 1 - Scalar Result 1
// -----------------------------------------------------------------------------
const float RESULT1_P1_S1[] =
{
0.0,
0.5,
1.5,
2.0,
3.0,
4.0,
5.0,
6.0,
6.5,
7.0,
7.5,
8.0
};
const float RESULT1_P2_S1[] =
{
1.0,
5.0,
3.0,
2.0,
5.0,
1.0
};
// Time step 2 - Scalar Result 1
// -----------------------------------------------------------------------------
const float RESULT1_P1_S2[] =
{
8.1f,
9.6f,
5.8f,
3.5f,
7.4f,
9.7f,
2.7f,
6.5f,
3.2f,
4.6f,
3.7f,
2.2f
};
const float RESULT1_P2_S2[] =
{
1.5f,
2.1f,
4.5f,
5.5f,
2.1f,
1.1f
};
// Time step 1 - Vector Result 1
// -----------------------------------------------------------------------------
const float RESULT2_P1_S1[] =
{
0.0, 0.0, 0.0,
1.0, 0.0, 0.0,
1.0, 1.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 0.0, 1.0,
1.0, 1.0, 1.0,
0.0, 1.0, 1.0,
0.0, 0.0, 2.0,
1.0, 0.0, 2.0,
1.0, 1.0, 2.0,
0.0, 1.0, 2.0
};
const float RESULT2_P2_S1[] =
{
2.0, 0.0, 0.0,
3.0, 0.0, 0.0,
3.0, 1.0, 0.0,
2.0, 1.0, 0.0,
4.0, 0.0, 0.0,
4.0, 1.0, 0.0,
};
// Time step 2 - Vector Result 2
// -----------------------------------------------------------------------------
const float RESULT2_P1_S2[] =
{
1.0, 8.0, 1.0,
3.0, 2.0, 5.0,
5.0, 8.0, 7.0,
3.0, 4.0, 9.0,
5.0, 2.0, 3.0,
7.0, 1.0, 2.0,
2.0, 7.0, 1.0,
5.0, 6.0, 5.0,
7.0, 5.0, 8.0,
6.0, 4.0, 0.0,
4.0, 2.0, 0.0,
1.0, 2.0, 2.0
};
const float RESULT2_P2_S2[] =
{
1.0, 4.0, 2.0,
6.0, 8.0, 5.0,
8.0, 7.0, 7.0,
3.0, 3.0, 8.0,
7.0, 5.0, 2.0,
3.0, 3.0, 1.0,
};
// Time step 1 - Displacement Result 1
// -----------------------------------------------------------------------------
const float RESULT3_P1_S1[] =
{
0.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 1.0f,
0.0f, 0.0f, 2.0f,
1.0f, 0.0f, 2.0f,
1.0f, 1.0f, 2.0f,
0.0f, 1.0f, 2.0f
};
const float RESULT3_P2_S1[] =
{
2.0, 0.0, 0.0,
3.0, 0.0, 0.0,
3.0, 1.0, 0.0,
2.0, 1.0, 0.0,
4.0, 0.0, 0.0,
4.0, 1.0, 0.0,
};
// Time step 2 - Displacement Result 1
// -----------------------------------------------------------------------------
const float RESULT3_P1_S2[] =
{
0.0f, 0.0f, 0.0f,
1.5f, 0.0f, 0.0f,
1.5f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
1.5f, 0.0f, 1.0f,
1.5f, 1.0f, 1.0f,
0.0f, 1.0f, 1.0f,
0.0f, 0.0f, 2.0f,
1.5f, 0.0f, 2.0f,
1.5f, 1.0f, 2.0f,
0.0f, 1.0f, 2.0f
};
const float RESULT3_P2_S2[] =
{
2.0, 0.0, 0.0,
3.0, 0.0, 0.0,
3.0, 1.0, 0.0,
2.0, 1.0, 0.0,
4.0, 0.0, 0.5,
4.0, 1.0, 0.5,
};
