#include "RifVtkReader.h" #include "RiaTestDataDirectory.h" #include "RigFemPartCollection.h" #include #include #include #include static std::filesystem::path testDataDir() { return std::filesystem::path( TEST_DATA_DIR ) / "RifVtkReader"; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, OpenValidFile ) { RifVtkReader reader; EXPECT_FALSE( reader.isOpen() ); std::string errorMessage; bool opened = reader.openFile( ( testDataDir() / "model.pvd" ).string(), &errorMessage ); EXPECT_TRUE( opened ); EXPECT_TRUE( reader.isOpen() ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, OpenInvalidFile ) { RifVtkReader reader; std::string errorMessage; bool opened = reader.openFile( ( testDataDir() / "nonexistent.pvd" ).string(), &errorMessage ); EXPECT_FALSE( opened ); EXPECT_FALSE( reader.isOpen() ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, StepNames ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); auto stepNames = reader.allStepNames(); ASSERT_EQ( stepNames.size(), 2u ); EXPECT_EQ( reader.frameCount( 0 ), 1 ); EXPECT_EQ( reader.frameCount( 1 ), 1 ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadFemParts ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); bool result = reader.readFemParts( femParts.p() ); ASSERT_TRUE( result ); ASSERT_EQ( femParts->partCount(), 1 ); const RigFemPart* part = femParts->part( 0 ); EXPECT_EQ( part->nodeCount(), 12 ); EXPECT_EQ( part->elementCount(), 2 ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadDisplacements ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); // Step 0: all displacements are zero { std::vector displacements; reader.readDisplacements( 0, 0, 0, &displacements ); ASSERT_EQ( displacements.size(), 12u ); for ( const auto& d : displacements ) { EXPECT_FLOAT_EQ( d.x(), 0.0f ); EXPECT_FLOAT_EQ( d.y(), 0.0f ); EXPECT_FLOAT_EQ( d.z(), 0.0f ); } } // Step 1: displacements are (0.1, 0.2, 0.3) in file, z is negated on read { std::vector displacements; reader.readDisplacements( 0, 1, 0, &displacements ); ASSERT_EQ( displacements.size(), 12u ); for ( const auto& d : displacements ) { EXPECT_NEAR( d.x(), 0.1f, 1e-5f ); EXPECT_NEAR( d.y(), 0.2f, 1e-5f ); EXPECT_NEAR( d.z(), -0.3f, 1e-5f ); } } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ScalarFieldNames ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); auto nodeFields = reader.scalarNodeFieldAndComponentNames(); ASSERT_TRUE( nodeFields.count( "U" ) > 0 ); auto& uComponents = nodeFields["U"]; EXPECT_EQ( uComponents.size(), 3u ); EXPECT_EQ( uComponents[0], "U1" ); EXPECT_EQ( uComponents[1], "U2" ); EXPECT_EQ( uComponents[2], "U3" ); auto elementFields = reader.scalarElementFieldAndComponentNames(); EXPECT_TRUE( elementFields.count( "Stress" ) > 0 ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadNodeFieldDisplacement ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); std::vector u1( 12 ), u2( 12 ), u3( 12 ); std::vector* components[3] = { &u1, &u2, &u3 }; std::vector*> resultValues( components, components + 3 ); reader.readNodeField( "U", 0, 1, 0, &resultValues ); ASSERT_EQ( u1.size(), 12u ); for ( size_t i = 0; i < 12; i++ ) { EXPECT_NEAR( u1[i], 0.1f, 1e-5f ); EXPECT_NEAR( u2[i], 0.2f, 1e-5f ); EXPECT_NEAR( u3[i], -0.3f, 1e-5f ); } } //-------------------------------------------------------------------------------------------------- /// stress[0..2] are the rows of a symmetric tensor; xz and yz change sign with the negated z //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadElementFieldStressTensorRows ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); auto elementFields = reader.scalarElementFieldAndComponentNames(); ASSERT_TRUE( elementFields.count( "S_VTK" ) > 0 ); const std::vector expectedComponents = { "S11", "S22", "S33", "S12", "S13", "S23" }; EXPECT_EQ( elementFields["S_VTK"], expectedComponents ); std::vector> values( 6 ); std::vector*> resultValues; for ( auto& v : values ) resultValues.push_back( &v ); reader.readElementField( "S_VTK", 0, 1, 0, &resultValues ); const std::vector expectedCell0 = { 11, 22, 33, 12, -13, -23 }; const std::vector expectedCell1 = { 111, 122, 133, 112, -113, -123 }; for ( size_t c = 0; c < 6; c++ ) { ASSERT_EQ( values[c].size(), 2u ); EXPECT_FLOAT_EQ( values[c][0], expectedCell0[c] ); EXPECT_FLOAT_EQ( values[c][1], expectedCell1[c] ); } } //-------------------------------------------------------------------------------------------------- /// Point data "pressure" is POR; S and E are the cell values at every element corner, S = POR * I - stress //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadElementNodalStressFromCellsAndPor ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); EXPECT_TRUE( reader.populateDerivedResultNames() ); EXPECT_TRUE( reader.scalarNodeFieldAndComponentNames().count( "POR" ) > 0 ); EXPECT_TRUE( reader.scalarElementNodeFieldAndComponentNames().count( "S" ) > 0 ); EXPECT_TRUE( reader.scalarElementNodeFieldAndComponentNames().count( "E" ) > 0 ); std::vector por; std::vector*> porValues = { &por }; reader.readNodeField( "POR", 0, 1, 0, &porValues ); ASSERT_EQ( por.size(), 12u ); EXPECT_FLOAT_EQ( por[5], 50.0f ); std::vector> s( 6 ), e( 6 ); std::vector*> sValues, eValues; for ( int c = 0; c < 6; c++ ) { sValues.push_back( &s[c] ); eValues.push_back( &e[c] ); } reader.readElementNodeField( "S", 0, 1, 0, &sValues ); reader.readElementNodeField( "E", 0, 1, 0, &eValues ); // Element 1, local node 2 is node 5 (POR 50). Cell stress rows (111 112 113), (112 122 123), (113 123 133); // z is negated, so xz and yz change sign. const size_t idx = 8 + 2; const std::vector expectedS = { 50 - 111, 50 - 122, 50 - 133, -112, 113, 123 }; const std::vector expectedE = { 1.1f, 1.4f, 1.6f, 1.2f, -1.3f, -1.5f }; for ( int c = 0; c < 6; c++ ) { ASSERT_EQ( s[c].size(), 16u ); EXPECT_FLOAT_EQ( s[c][idx], expectedS[c] ); EXPECT_FLOAT_EQ( e[c][idx], expectedE[c] ); } } //-------------------------------------------------------------------------------------------------- /// strain[0..2] are the rows of a symmetric tensor; xz and yz change sign with the negated z //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadElementFieldStrainTensorRows ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); auto elementFields = reader.scalarElementFieldAndComponentNames(); ASSERT_TRUE( elementFields.count( "E_VTK" ) > 0 ); const std::vector expectedComponents = { "E11", "E22", "E33", "E12", "E13", "E23" }; EXPECT_EQ( elementFields["E_VTK"], expectedComponents ); std::vector> values( 6 ); std::vector*> resultValues; for ( auto& v : values ) resultValues.push_back( &v ); reader.readElementField( "E_VTK", 0, 1, 0, &resultValues ); const std::vector expectedCell0 = { 0.1f, 0.4f, 0.6f, 0.2f, -0.3f, -0.5f }; const std::vector expectedCell1 = { 1.1f, 1.4f, 1.6f, 1.2f, -1.3f, -1.5f }; for ( size_t c = 0; c < 6; c++ ) { ASSERT_EQ( values[c].size(), 2u ); EXPECT_FLOAT_EQ( values[c][0], expectedCell0[c] ); EXPECT_FLOAT_EQ( values[c][1], expectedCell1[c] ); } } //-------------------------------------------------------------------------------------------------- /// Only stress[0] and strain[1..2]: list only the components with data, and no derived results //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadElementFieldPartialTensorRows ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "partial.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); auto elementFields = reader.scalarElementFieldAndComponentNames(); const std::vector expectedS = { "S11", "S12", "S13" }; const std::vector expectedE = { "E22", "E33", "E23" }; EXPECT_EQ( elementFields["S_VTK"], expectedS ); EXPECT_EQ( elementFields["E_VTK"], expectedE ); EXPECT_TRUE( reader.scalarElementNodeFieldAndComponentNames().empty() ); std::vector> s( 3 ), e( 3 ); std::vector*> sValues = { &s[0], &s[1], &s[2] }; std::vector*> eValues = { &e[0], &e[1], &e[2] }; reader.readElementField( "S_VTK", 0, 0, 0, &sValues ); reader.readElementField( "E_VTK", 0, 0, 0, &eValues ); const std::vector expectedSCell1 = { 111, 112, -113 }; const std::vector expectedECell1 = { 1.22f, 1.33f, -1.23f }; for ( size_t c = 0; c < 3; c++ ) { ASSERT_EQ( s[c].size(), 2u ); ASSERT_EQ( e[c].size(), 2u ); EXPECT_FLOAT_EQ( s[c][1], expectedSCell1[c] ); EXPECT_FLOAT_EQ( e[c][1], expectedECell1[c] ); } } //-------------------------------------------------------------------------------------------------- /// Complete stress and strain but no node "pressure": E is available, S and the derived results are not, /// also after reading E //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadElementNodalStrainWithoutPor ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "nopor.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); EXPECT_FALSE( reader.populateDerivedResultNames() ); EXPECT_EQ( reader.scalarElementNodeFieldAndComponentNames().count( "S" ), 0u ); ASSERT_EQ( reader.scalarElementNodeFieldAndComponentNames().count( "E" ), 1u ); std::vector> e( 6 ); std::vector*> eValues; for ( auto& v : e ) eValues.push_back( &v ); reader.readElementNodeField( "E", 0, 0, 0, &eValues ); ASSERT_EQ( e[0].size(), 16u ); EXPECT_FLOAT_EQ( e[0][8], 1.1f ); EXPECT_FALSE( reader.populateDerivedResultNames() ); EXPECT_EQ( reader.scalarElementNodeFieldAndComponentNames().count( "S" ), 0u ); EXPECT_EQ( reader.scalarNodeFieldAndComponentNames().count( "POR" ), 0u ); } //-------------------------------------------------------------------------------------------------- /// Step 0 has neither tensor nor POR data: S and E give no values, and reading them adds no fields //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadElementNodalStressAtStepWithoutData ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); const auto elementFieldsBefore = reader.scalarElementFieldAndComponentNames(); const auto nodeFieldsBefore = reader.scalarNodeFieldAndComponentNames(); for ( const std::string fieldName : { "S", "E" } ) { std::vector> values( 6 ); std::vector*> resultValues; for ( auto& v : values ) resultValues.push_back( &v ); reader.readElementNodeField( fieldName, 0, 0, 0, &resultValues ); for ( const auto& v : values ) EXPECT_TRUE( v.empty() ); } EXPECT_EQ( reader.scalarElementFieldAndComponentNames(), elementFieldsBefore ); EXPECT_EQ( reader.scalarNodeFieldAndComponentNames(), nodeFieldsBefore ); } //-------------------------------------------------------------------------------------------------- /// Reading the parts twice gives the same element node results //-------------------------------------------------------------------------------------------------- TEST( RifVtkReaderTest, ReadFemPartsTwice ) { RifVtkReader reader; reader.openFile( ( testDataDir() / "model.pvd" ).string(), nullptr ); cvf::ref femParts = new RigFemPartCollection(); reader.readFemParts( femParts.p() ); cvf::ref femPartsAgain = new RigFemPartCollection(); reader.readFemParts( femPartsAgain.p() ); std::vector e11; std::vector*> eValues = { &e11 }; reader.readElementNodeField( "E", 0, 1, 0, &eValues ); EXPECT_EQ( e11.size(), 16u ); }