Skip to main content

DPF C++ client library 2023 R2

ResultTest

Last update: 10.07.2023

Examples showing how to access results data in an RST file.

//
// COPYRIGHT ANSYS. ALL RIGHTS RESERVED.
//
#ifdef EXAMPLE
#include "Example.h"
#else
#include <gtest/gtest.h>
#endif
#include <math.h>
#include "helpers/dpf_result.h"
#include "helpers/dpf_model.h"
using namespace ansys::dpf;
TEST(result_info, DimensionalityNature_Homogeneity_AnalysisType_PhysicsType_unitSystem)
{
std::string fileName("../../../testfiles/mapdl_files/TwoSolids.rst");
ds.addResultFile(fileName);
ansys::dpf::Operator provider("ResultInfoProvider");
provider.connect(4, ds);
std::string analysis_type_name = res_info.analysisTypeName();
EXPECT_EQ(analysis_type_name, std::string("static"));
std::string physics_type_name = res_info.physicsTypeName();
EXPECT_EQ(physics_type_name, std::string("mechanical"));
std::string unit_sys_name = res_info.unitSystemName();
EXPECT_EQ(unit_sys_name, std::string("MKS: m, kg, N, s, V, A, degC"));
std::set<std::string> res = res_info.availableResults();
auto iter = res.begin();
iter++;
std::string res_name = *iter;
ansys::dpf::Dimensionality::ENature nat = res_info.nature(res_name);
EXPECT_EQ(nat, ansys::dpf::Dimensionality::eScalar);
ansys::dpf::Unit unit_res = res_info.unit(res_name);
EXPECT_EQ(std::string(unit_res.homogeneity().c_str()), std::string("Energy"));
// disp
res_name = "Displacement";
unit_res = res_info.unit(res_name);
EXPECT_EQ(std::string(unit_res.homogeneity().c_str()), std::string("Displacement"));
// Force
res_name = "Force";
unit_res = res_info.unit(res_name);
EXPECT_EQ(std::string(unit_res.homogeneity().c_str()), std::string("Force"));
// Strain
res_name = "Strain";
unit_res = res_info.unit(res_name);
EXPECT_EQ(std::string(unit_res.homogeneity().c_str()), std::string("DimensionLess"));
}
TEST(Results, readSEQV)
{
std::string fileName("../../../testfiles/mapdl_files/TwoSolids.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv");
FieldsContainer fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_EQ(fieldsContainer.size(), 1);
Field field = fieldsContainer[0];
Location location = field.fieldDefinition().location();
EXPECT_EQ(field.dataSize(), 344);
dp_int size;
Operator minmax = Operator("min_max");
minmax.connect(0, field);
Field fieldMin = minmax.getOutputField(0);
Field fieldMax = minmax.getOutputField(1);
auto dataMax = fieldMax.data(size);
auto dataMin = fieldMin.data(size);
auto ids_max = fieldMax.scoping().ids(size);
auto ids_min = fieldMin.scoping().ids(size);
EXPECT_DOUBLE_EQ(dataMax[0], 6314.9823137518824);
EXPECT_DOUBLE_EQ(dataMin[0], 62.022552581514269);
EXPECT_EQ(ids_max[0], 85);
EXPECT_EQ(ids_min[0], 141);
}
TEST(Results, readSEQVAtGivenNode)
{
std::string fileName("../../../testfiles/mapdl_files/TwoSolids.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
FieldsContainer fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_EQ(fieldsContainer.size(), 1);
Field field = fieldsContainer[0];
EXPECT_EQ(field.dataSize(), 1);
EXPECT_STREQ(field.fieldDefinition().location().c_str(), locations::nodal.c_str());
EXPECT_EQ(field.scoping().size(), 1);
EXPECT_EQ(field.scoping().at(0), 1);
dp_int size;
EXPECT_DOUBLE_EQ(field.data(size)[0], 987.40109280968454);
}
TEST(Results, readSEQVAtGivenNodes)
{
std::string fileName("../../../testfiles/mapdl_files/TwoSolids.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1,2 }, ansys::dpf::locations::nodal));
FieldsContainer fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_EQ(fieldsContainer.size(), 1);
Field field = fieldsContainer[0];
EXPECT_EQ(field.dataSize(), 2);
EXPECT_STREQ(field.fieldDefinition().location().c_str(), locations::nodal.c_str());
EXPECT_EQ(field.scoping().size(), 2);
dp_int size;
EXPECT_DOUBLE_EQ(field.entityDataById(1, size)[0], 987.40109280968454);
EXPECT_DOUBLE_EQ(field.entityDataById(2, size)[0], 1005.4123172685187);
}
TEST(Results, readTemperatures)
{
std::string fileName("../../../testfiles/mapdl_files/file.rth");
ansys::dpf::Model model(fileName);
TimeFreqSupport timeFreq = model.getTimeFreqSupport();
auto numSets = timeFreq.numberOfSets();
EXPECT_EQ(numSets, 4);
Result res = model.CreateResultEvaluationWorkflow("TEMP");
FieldsContainer fieldsContainer = res.EvaluateAtGivenTimeIndex(3, error);
EXPECT_EQ(fieldsContainer.size(), 1);
Field field = fieldsContainer[0];
EXPECT_EQ(field.dataSize(), 2159);
dp_int size;
Operator minmax = Operator("min_max");
minmax.connect(0, field);
Field fieldMin = minmax.getOutputField(0);
Field fieldMax = minmax.getOutputField(1);
auto dataMax = fieldMax.data(size);
auto dataMin = fieldMin.data(size);
auto ids_max = fieldMax.scoping().ids(size);
auto ids_min = fieldMin.scoping().ids(size);
EXPECT_DOUBLE_EQ(dataMax[0], 56.576226358561549);
EXPECT_DOUBLE_EQ(dataMin[0], 21.999572871657019);
EXPECT_EQ(ids_max[0], 32);
EXPECT_EQ(ids_min[0], 978);
}
TEST(Results, readSXAtGivenNamedSelection)
{
std::string fileName("../../../testfiles/mapdl_files/TwoSolids.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("SX", "not_exist");
FieldsContainer fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_FALSE(error.isOk());
EXPECT_EQ(fieldsContainer.size(), 0);
res = model.CreateResultEvaluationWorkflow("SX", "_FIXEDSU");
fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_TRUE(error.isOk());
Field field = fieldsContainer[0];
EXPECT_EQ(field.dataSize(), 30);
dp_int size;
Operator minmax = Operator("min_max");
minmax.connect(0, field);
Field fieldMin = minmax.getOutputField(0);
Field fieldMax = minmax.getOutputField(1);
auto dataMax = fieldMax.data(size);
auto dataMin = fieldMin.data(size);
auto ids_max = fieldMax.scoping().ids(size);
auto ids_min = fieldMin.scoping().ids(size);
EXPECT_DOUBLE_EQ(dataMax[0], 1292.4295654296875);
EXPECT_DOUBLE_EQ(dataMin[0], -2806.3163364955358);
EXPECT_EQ(ids_max[0], 100);
EXPECT_EQ(ids_min[0], 109);
}
TEST(Results, readSXAtGivenStepIndexAndSubStep)
{
std::string fileName("../../../testfiles/mapdl_files/TwoSolids.rst");
ansys::dpf::Model model(fileName);
TimeFreqSupport timeFreq = model.getTimeFreqSupport();
auto numSets = timeFreq.numberOfSets();
EXPECT_EQ(numSets, 1);
auto numSteps = timeFreq.numberOfSteps();
EXPECT_EQ(numSteps, 1);
auto numSubSteps = timeFreq.numberOfSubStepsByStepIndex(0);
EXPECT_EQ(numSubSteps, 1);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
FieldsContainer fieldsContainer = res.EvaluateAtGivenStepIndexAndSubStep(0, 0, error);
EXPECT_EQ(fieldsContainer.size(), 1);
Field field = fieldsContainer.at(0);
EXPECT_EQ(field.dataSize(), 1);
EXPECT_DOUBLE_EQ(field.data(size)[0], 987.40109280968454);
}
TEST(Results, readSEQVAmplitudeAtGivenTime)
{
std::string fileName("../../../testfiles/complex/filetheo.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
FieldsContainer amplitudeFieldsContainer = res.EvaluateAmplitudeAtGivenTime(0.0, error);
EXPECT_EQ(amplitudeFieldsContainer.size(), 1);
Field amplitudeField = amplitudeFieldsContainer.at(0);
EXPECT_EQ(amplitudeField.dataSize(), 3);
dp_double amplitudeValue = amplitudeField.data(size)[0];
EXPECT_DOUBLE_EQ(amplitudeValue, 15953.036468929646);
// now get the real and imaginary separately
FieldsContainer fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_EQ(fieldsContainer.size(), 2);
EXPECT_TRUE(fieldsContainer.hasLabel("complex"));
EXPECT_TRUE(fieldsContainer.hasLabel("time"));
std::vector<Field> realFields = fieldsContainer.getFieldsForTimeId(1, 0);
EXPECT_EQ(realFields.size(), 1);
Field realField = realFields.at(0);
EXPECT_EQ(realField.dataSize(), 3);
dp_double realValue = realField.data(size)[0];
EXPECT_DOUBLE_EQ(realValue, 15953.030385790376);
std::vector<Field> imaginaryFields = fieldsContainer.getFieldsForTimeId(1, 1);
EXPECT_EQ(imaginaryFields.size(), 1);
Field imaginaryField = imaginaryFields[0];
EXPECT_EQ(imaginaryField.dataSize(), 3);
dp_double imaginaryValue = imaginaryField.data(size)[0];
EXPECT_DOUBLE_EQ(imaginaryValue, 13.931584555079384);
// and compare them
EXPECT_DOUBLE_EQ(amplitudeValue, sqrt(realValue * realValue + imaginaryValue * imaginaryValue));
}
TEST(Results, readSEQVAmplitudeAtGivenTimeIndex)
{
std::string fileName("../../../testfiles/complex/filetheo.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
FieldsContainer amplitudeFieldsContainer = res.EvaluateAmplitudeAtGivenTimeIndex(0, error);
EXPECT_EQ(amplitudeFieldsContainer.size(), 1);
Field amplitudeField = amplitudeFieldsContainer.at(0);
EXPECT_EQ(amplitudeField.dataSize(), 3);
dp_double amplitudeValue = amplitudeField.data(size)[1];
EXPECT_DOUBLE_EQ(amplitudeValue, 15953.015373859611);
// now get the real and imaginary separately
FieldsContainer fieldsContainer = res.EvaluateAtGivenTimeIndex(0, error);
EXPECT_EQ(fieldsContainer.size(), 2);
EXPECT_TRUE(fieldsContainer.hasLabel("complex"));
EXPECT_TRUE(fieldsContainer.hasLabel("time"));
std::vector<Field> realFields = fieldsContainer.getFieldsForTimeId(1, 0);
EXPECT_EQ(realFields.size(), 1);
Field realField = realFields.at(0);
EXPECT_EQ(realField.dataSize(), 3);
dp_double realValue = realField.data(size)[1];
EXPECT_DOUBLE_EQ(realValue, 15953.009290308262);
std::vector<Field> imaginaryFields = fieldsContainer.getFieldsForTimeId(1, 1);
EXPECT_EQ(imaginaryFields.size(), 1);
Field imaginaryField = imaginaryFields[0];
EXPECT_EQ(imaginaryField.dataSize(), 3);
dp_double imaginaryValue = imaginaryField.data(size)[1];
EXPECT_DOUBLE_EQ(imaginaryValue, 13.932047206695039);
// and compare them
EXPECT_DOUBLE_EQ(amplitudeValue, sqrt(realValue * realValue + imaginaryValue * imaginaryValue));
}
TEST(Results, readSEQVAmplitudeAtGivenStepAndSubStep)
{
std::string fileName("../../../testfiles/complex/filetheo.rst");
ansys::dpf::Model model(fileName);
TimeFreqSupport timeFreq = model.getTimeFreqSupport();
auto numSets = timeFreq.numberOfSets();
EXPECT_EQ(numSets, 10);
auto numSteps = timeFreq.numberOfSteps();
EXPECT_EQ(numSteps, 1);
auto numSubSteps = timeFreq.numberOfSubStepsByStepIndex(0);
EXPECT_EQ(numSubSteps, 10);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
FieldsContainer amplitudeFieldsContainer = res.EvaluateAmplitudeAtGivenStepIndexAndSubStep(0, 9, error);
EXPECT_EQ(amplitudeFieldsContainer.size(), 1);
Field amplitudeField = amplitudeFieldsContainer[0];
EXPECT_EQ(amplitudeField.dataSize(), 3);
dp_double amplitudeValue = amplitudeField.data(size)[0];
EXPECT_DOUBLE_EQ(amplitudeValue, 4823.449633735253);
// now get the real and imaginary separately idx0,idx9=id10
FieldsContainer fieldsContainer = res.EvaluateAtGivenStepIndexAndSubStep(0, 9, error);
EXPECT_EQ(fieldsContainer.size(), 2);
EXPECT_TRUE(fieldsContainer.hasLabel("complex"));
EXPECT_TRUE(fieldsContainer.hasLabel("time"));
std::vector<Field> realFields = fieldsContainer.getFieldsForTimeId(10, 0);
EXPECT_EQ(realFields.size(), 1);
Field realField = realFields.at(0);
EXPECT_EQ(realField.dataSize(), 3);
dp_double realValue = realField.data(size)[0];
EXPECT_DOUBLE_EQ(realValue, 4823.4491029746168);
std::vector<Field> imaginaryFields = fieldsContainer.getFieldsForTimeId(10, 1);
EXPECT_EQ(imaginaryFields.size(), 1);
Field imaginaryField = imaginaryFields[0];
EXPECT_EQ(imaginaryField.dataSize(), 3);
dp_double imaginaryValue = imaginaryField.data(size)[0];
EXPECT_DOUBLE_EQ(imaginaryValue, 2.262784593315458);
// and compare them
EXPECT_DOUBLE_EQ(amplitudeValue, (dp_double)sqrt(realValue * realValue + imaginaryValue * imaginaryValue));
}
TEST(Results, readSEQVWithPhaseAtGivenTime)
{
std::string fileName("../../../testfiles/complex/filetheo.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
// theta is in degrees
const dp_double theta = 45.0;
FieldsContainer amplitudeFieldsContainer = res.EvaluateWithPhaseAtGivenTime(0.0, theta, error);
EXPECT_EQ(amplitudeFieldsContainer.size(), 1);
Field amplitudeField = amplitudeFieldsContainer.at(0);
EXPECT_EQ(amplitudeField.dataSize(), 3);
dp_double amplitudeValue = amplitudeField.data(size)[0];
EXPECT_DOUBLE_EQ(amplitudeValue, 11270.644848355851);
// now get the real and imaginary separately
FieldsContainer fieldsContainer = res.EvaluateAtGivenTime(0.0, error);
EXPECT_EQ(fieldsContainer.size(), 2);
EXPECT_TRUE(fieldsContainer.hasLabel("complex"));
EXPECT_TRUE(fieldsContainer.hasLabel("time"));
std::vector<Field> realFields = fieldsContainer.getFieldsForTimeId(1, 0);
EXPECT_EQ(realFields.size(), 1);
Field realField = realFields.at(0);
EXPECT_EQ(realField.dataSize(), 3);
dp_double realValue = realField.data(size)[0];
EXPECT_DOUBLE_EQ(realValue, 15953.030385790376);
std::vector<Field> imaginaryFields = fieldsContainer.getFieldsForTimeId(1, 1);
EXPECT_EQ(imaginaryFields.size(), 1);
Field imaginaryField = imaginaryFields[0];
EXPECT_EQ(imaginaryField.dataSize(), 3);
dp_double imaginaryValue = imaginaryField.data(size)[0];
EXPECT_DOUBLE_EQ(imaginaryValue, 13.931584555079384);
double thetaR = theta / 180.0 * 3.14159265358979323846;
// and compare them
dp_double expectedValue = realValue * cos(thetaR) - imaginaryValue * sin(thetaR);
EXPECT_DOUBLE_EQ(amplitudeValue, expectedValue);
}
TEST(Results, readSEQVWithPhaseAtGivenTimeIndex)
{
std::string fileName("../../../testfiles/complex/filetheo.rst");
ansys::dpf::Model model(fileName);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
// theta is in degrees
const dp_double theta = 22.5;
FieldsContainer amplitudeFieldsContainer = res.EvaluateWithPhaseAtGivenTimeIndex(0, theta, error);
EXPECT_EQ(amplitudeFieldsContainer.size(), 1);
Field amplitudeField = amplitudeFieldsContainer.at(0);
EXPECT_EQ(amplitudeField.dataSize(), 3);
dp_double amplitudeValue = amplitudeField.data(size)[1];
EXPECT_DOUBLE_EQ(amplitudeValue, 14733.327201633281);
// now get the real and imaginary separately
FieldsContainer fieldsContainer = res.EvaluateAtGivenTimeIndex(0, error);
EXPECT_EQ(fieldsContainer.size(), 2);
EXPECT_TRUE(fieldsContainer.hasLabel("complex"));
EXPECT_TRUE(fieldsContainer.hasLabel("time"));
std::vector<Field> realFields = fieldsContainer.getFieldsForTimeId(1, 0);
EXPECT_EQ(realFields.size(), 1);
Field realField = realFields.at(0);
EXPECT_EQ(realField.dataSize(), 3);
dp_double realValue = realField.data(size)[1];
EXPECT_DOUBLE_EQ(realValue, 15953.009290308262);
std::vector<Field> imaginaryFields = fieldsContainer.getFieldsForTimeId(1, 1);
EXPECT_EQ(imaginaryFields.size(), 1);
Field imaginaryField = imaginaryFields[0];
EXPECT_EQ(imaginaryField.dataSize(), 3);
dp_double imaginaryValue = imaginaryField.data(size)[1];
EXPECT_DOUBLE_EQ(imaginaryValue, 13.932047206695039);
double thetaR = theta / 180.0 * 3.14159265358979323846;
// and compare them
dp_double expectedValue = realValue * cos(thetaR) - imaginaryValue * sin(thetaR);
EXPECT_DOUBLE_EQ(amplitudeValue, expectedValue);
}
TEST(Results, readSEQVWithPhaseAtGivenStepIndexAndSubStep)
{
std::string fileName("../../../testfiles/complex/filetheo.rst");
ansys::dpf::Model model(fileName);
TimeFreqSupport timeFreq = model.getTimeFreqSupport();
auto numSets = timeFreq.numberOfSets();
EXPECT_EQ(numSets, 10);
auto numSteps = timeFreq.numberOfSteps();
EXPECT_EQ(numSteps, 1);
auto numSubSteps = timeFreq.numberOfSubStepsByStepIndex(0);
EXPECT_EQ(numSubSteps, 10);
Result res = model.CreateResultEvaluationWorkflow("S_eqv", Scoping({ 1 }, ansys::dpf::locations::nodal));
dp_int size;
// theta is in degrees
const dp_double theta = 67.5;
FieldsContainer amplitudeFieldsContainer = res.EvaluateWithPhaseAtGivenStepIndexAndSubStep(0, 9, theta, error);
EXPECT_EQ(amplitudeFieldsContainer.size(), 1);
Field amplitudeField = amplitudeFieldsContainer[0];
EXPECT_EQ(amplitudeField.dataSize(), 3);
dp_double amplitudeValue = amplitudeField.data(size)[0];
EXPECT_DOUBLE_EQ(amplitudeValue, 1843.7635181923936);
// now get the real and imaginary separately idx0,idx9=id10
FieldsContainer fieldsContainer = res.EvaluateAtGivenStepIndexAndSubStep(0, 9, error);
EXPECT_EQ(fieldsContainer.size(), 2);
EXPECT_TRUE(fieldsContainer.hasLabel("complex"));
EXPECT_TRUE(fieldsContainer.hasLabel("time"));
std::vector<Field> realFields = fieldsContainer.getFieldsForTimeId(10, 0);
EXPECT_EQ(realFields.size(), 1);
Field realField = realFields.at(0);
EXPECT_EQ(realField.dataSize(), 3);
dp_double realValue = realField.data(size)[0];
EXPECT_DOUBLE_EQ(realValue, 4823.4491029746168);
std::vector<Field> imaginaryFields = fieldsContainer.getFieldsForTimeId(10, 1);
EXPECT_EQ(imaginaryFields.size(), 1);
Field imaginaryField = imaginaryFields[0];
EXPECT_EQ(imaginaryField.dataSize(), 3);
dp_double imaginaryValue = imaginaryField.data(size)[0];
EXPECT_DOUBLE_EQ(imaginaryValue, 2.262784593315458);
double thetaR = theta / 180.0 * 3.14159265358979323846;
// and compare them
dp_double expectedValue = realValue * cos(thetaR) - imaginaryValue * sin(thetaR);
EXPECT_DOUBLE_EQ(amplitudeValue, expectedValue);
}
Definition: dpf_api.h:1954
void addResultFile(std::string const &file_path, std::string const &key)
Definition: dpf_api_base.h:1060
bool isOk() const noexcept
const char * c_str() const
Definition: dpf_model.h:14
Wrap an elementary operation.
Definition: dpf_api.h:2216
ResultInfo getOutputResultInfo(dp_index pin_index)
Definition: dpf_api.h:260
std::string physicsTypeName() const
std::set< std::string > availableResults() const
Dimensionality::ENature nature(std::string const &res_name) const
std::string analysisTypeName() const
std::string unitSystemName() const
Definition: dpf_api.h:226
ansys::dpf::Homogeneity const & homogeneity() const
This is the main namespace of the HGP API.
Definition: dpf_model.h:11
int dp_int
Definition: dpf_api_base.h:48
double dp_double
Definition: dpf_api_base.h:54
ENature
Definition: dpf_api_base.h:810
static const Location nodal
Definition: dpf_api_base.h:166