OilfieldToolsNet/IFEM
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Changed: Use createFEMmodel() instead of preprocess() when sufficient,

Browse Source 
and also use EXPECT_* instead of ASSERT_* when possible, to check all
This commit is contained in:
Knut Morten Okstad 2018-02-17 08:22:26 +01:00
parent ac6c1c3a6b
commit f578ac69ef
3 changed files with 69 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/ASM/LR/Test/TestASMu3D.C
View File

@ -11,16 +11,15 @@
//============================================================================== //==============================================================================
#include "ASMu3D.h" #include "ASMu3D.h"
#include "GaussQuadrature.h"
#include "SIM3D.h" #include "SIM3D.h"
#include "GaussQuadrature.h"
#include "LRSpline/LRSplineVolume.h" #include "LRSpline/LRSplineVolume.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <numeric> #include <numeric>
class TestASMu3D : class TestASMu3D : public testing::Test,
public testing::Test, public testing::WithParamInterface<int>
public testing::WithParamInterface<int>
{ {
}; };
@ -33,7 +32,7 @@ TEST_P(TestASMu3D, BoundaryNodes)
SIM3D sim(1); SIM3D sim(1);
sim.opt.discretization = ASM::LRSpline; sim.opt.discretization = ASM::LRSpline;
ASSERT_TRUE(sim.read("src/ASM/LR/Test/refdata/boundary_nodes_3d.xinp")); ASSERT_TRUE(sim.read("src/ASM/LR/Test/refdata/boundary_nodes_3d.xinp"));
sim.preprocess(); ASSERT_TRUE(sim.createFEMmodel());
std::stringstream str; std::stringstream str;
str << "Face" << GetParam(); str << "Face" << GetParam();
@ -42,22 +41,20 @@ TEST_P(TestASMu3D, BoundaryNodes)
sim.getBoundaryNodes(bcode,vec); sim.getBoundaryNodes(bcode,vec);
ASSERT_EQ(vec.size(), 16U); ASSERT_EQ(vec.size(), 16U);
auto it = vec.begin(); auto it = vec.begin();
for (int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j) { for (int j = 0; j < 4; ++j)
if (GetParam() == 1) if (GetParam() == 1)
ASSERT_EQ(*it++, 1+4*(4*i+j)); EXPECT_EQ(*it++, 1+4*(4*i+j));
else if (GetParam() == 2) else if (GetParam() == 2)
ASSERT_EQ(*it++, 2+4*(4*i+j)); EXPECT_EQ(*it++, 2+4*(4*i+j));
else if (GetParam() == 3) else if (GetParam() == 3)
ASSERT_EQ(*it++, 16*i+j+1); EXPECT_EQ(*it++, 16*i+j+1);
else if (GetParam() == 4) else if (GetParam() == 4)
ASSERT_EQ(*it++, 5+16*i+j); EXPECT_EQ(*it++, 5+16*i+j);
else if (GetParam() == 5) else if (GetParam() == 5)
ASSERT_EQ(*it++, 4*i+j+1); EXPECT_EQ(*it++, 4*i+j+1);
else if (GetParam() == 6) else if (GetParam() == 6)
ASSERT_EQ(*it++, 17+4*i+j); EXPECT_EQ(*it++, 17+4*i+j);
}
}
} }
@ -120,9 +117,9 @@ TEST(TestASMu3D, TransferGaussPtVars)
pchNew->transferGaussPtVars(pch->getVolume(), oldAr, newAr, 3); pchNew->transferGaussPtVars(pch->getVolume(), oldAr, newAr, 3);
size_t k = 0; size_t k = 0;
for (size_t iEl = 0; iEl < 2; ++iEl) for (size_t iEl = 0; iEl < 2; ++iEl)
for (id[2] = 0; id[2] < 3; ++id[2]) for (id[2] = 0; id[2] < 3; ++id[2])
for (id[1] = 0; id[1] < 3; ++id[1]) for (id[1] = 0; id[1] < 3; ++id[1])
for (id[0] = 0; id[0] < 3; ++id[0], ++k) for (id[0] = 0; id[0] < 3; ++id[0], ++k)
EXPECT_FLOAT_EQ(newAr[k], 0.5*iEl + 0.5*(xi[id[idx]] + 1.0) / 2.0); EXPECT_FLOAT_EQ(newAr[k], 0.5*iEl + 0.5*(xi[id[idx]] + 1.0) / 2.0);
} }
} }

54
src/ASM/LR/Test/TestLRSplineFields.C
View File

@ -27,7 +27,7 @@ TEST(TestLRSplineFields, Value2D)
{ {
IFEM::getOptions().discretization = ASM::LRSpline; IFEM::getOptions().discretization = ASM::LRSpline;
SIM2D sim(2); SIM2D sim(2);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+x*y, x-y+x*y} // {x+y+x*y, x-y+x*y}
std::vector<double> vc = {0.0, 0.0, std::vector<double> vc = {0.0, 0.0,
@ -47,9 +47,9 @@ TEST(TestLRSplineFields, Value2D)
fe.v = it[1]; fe.v = it[1];
Vector v(2); Vector v(2);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[2]); EXPECT_FLOAT_EQ(v(1), it[2]);
ASSERT_FLOAT_EQ(v(2), it[3]); EXPECT_FLOAT_EQ(v(2), it[3]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[3]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[3]);
} }
} }
@ -59,8 +59,8 @@ TEST(TestLRSplineFields, Value2Dmx)
ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE; ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE;
IFEM::getOptions().discretization = ASM::LRSpline; IFEM::getOptions().discretization = ASM::LRSpline;
SIM2D sim({1,1,1}); SIM2D sim({1,1,1});
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
sim.preprocess(); ASSERT_TRUE(sim.createFEMmodel());
// {x+y+x*y, x-y+x*y} // {x+y+x*y, x-y+x*y}
std::vector<double> vc = {0.0, std::vector<double> vc = {0.0,
@ -91,9 +91,9 @@ TEST(TestLRSplineFields, Value2Dmx)
fe.v = it[1]; fe.v = it[1];
Vector v(2); Vector v(2);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[2]); EXPECT_FLOAT_EQ(v(1), it[2]);
ASSERT_FLOAT_EQ(v(2), it[3]); EXPECT_FLOAT_EQ(v(2), it[3]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[4]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[4]);
} }
} }
@ -102,7 +102,7 @@ TEST(TestLRSplineFields, Grad2D)
{ {
IFEM::getOptions().discretization = ASM::LRSpline; IFEM::getOptions().discretization = ASM::LRSpline;
SIM2D sim(2); SIM2D sim(2);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+x*y, x-y+x*y} // {x+y+x*y, x-y+x*y}
std::vector<double> vc = {0.0, 0.0, 1.0, 1.0, 1.0, -1.0, 3.0, 1.0}; std::vector<double> vc = {0.0, 0.0, 1.0, 1.0, 1.0, -1.0, 3.0, 1.0};
@ -118,10 +118,10 @@ TEST(TestLRSplineFields, Grad2D)
fe.v = it[1]; fe.v = it[1];
Matrix gradu(2,2); Matrix gradu(2,2);
fvector->gradFE(fe, gradu); fvector->gradFE(fe, gradu);
ASSERT_FLOAT_EQ(gradu(1,1), it[2]); EXPECT_FLOAT_EQ(gradu(1,1), it[2]);
ASSERT_FLOAT_EQ(gradu(1,2), it[3]); EXPECT_FLOAT_EQ(gradu(1,2), it[3]);
ASSERT_FLOAT_EQ(gradu(2,1), it[4]); EXPECT_FLOAT_EQ(gradu(2,1), it[4]);
ASSERT_FLOAT_EQ(gradu(2,2), it[5]); EXPECT_FLOAT_EQ(gradu(2,2), it[5]);
} }
} }
@ -130,7 +130,7 @@ TEST(TestLRSplineFields, Value3D)
{ {
IFEM::getOptions().discretization = ASM::LRSpline; IFEM::getOptions().discretization = ASM::LRSpline;
SIM3D sim(3); SIM3D sim(3);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+z, x+y-z, x-y+z} // {x+y+z, x+y-z, x-y+z}
std::vector<double> vc = {0.0, 0.0, 0.0, std::vector<double> vc = {0.0, 0.0, 0.0,
@ -160,10 +160,10 @@ TEST(TestLRSplineFields, Value3D)
fe.w = it[2]; fe.w = it[2];
Vector v(3); Vector v(3);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[3]); EXPECT_FLOAT_EQ(v(1), it[3]);
ASSERT_FLOAT_EQ(v(2), it[4]); EXPECT_FLOAT_EQ(v(2), it[4]);
ASSERT_FLOAT_EQ(v(3), it[5]); EXPECT_FLOAT_EQ(v(3), it[5]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[4]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[4]);
} }
} }
@ -172,7 +172,7 @@ TEST(TestLRSplineFields, Grad3D)
{ {
IFEM::getOptions().discretization = ASM::LRSpline; IFEM::getOptions().discretization = ASM::LRSpline;
SIM3D sim(3); SIM3D sim(3);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z} // {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z}
std::vector<double> vc = {0.0, 0.0, 0.0, std::vector<double> vc = {0.0, 0.0, 0.0,
@ -222,7 +222,7 @@ TEST(TestLRSplineFields, Grad3D)
fvector->gradFE(fe, gradu); fvector->gradFE(fe, gradu);
for (size_t i = 0; i < 3; ++i) for (size_t i = 0; i < 3; ++i)
for (size_t j = 0; j <3; ++j) for (size_t j = 0; j <3; ++j)
ASSERT_FLOAT_EQ(gradu(i+1,j+1), it.second[i*3+j]); EXPECT_FLOAT_EQ(gradu(i+1,j+1), it.second[i*3+j]);
} }
} }
@ -231,8 +231,8 @@ TEST(TestLRSplineFields, Value3Dmx)
{ {
ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE; ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE;
SIM3D sim({1,1,1,1}); SIM3D sim({1,1,1,1});
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
sim.preprocess(); ASSERT_TRUE(sim.createFEMmodel());
// {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z} // {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z}
std::vector<double> vc = {0.0, 0.5, 1.0, std::vector<double> vc = {0.0, 0.5, 1.0,
@ -274,9 +274,9 @@ TEST(TestLRSplineFields, Value3Dmx)
fe.w = it[2]; fe.w = it[2];
Vector v(3); Vector v(3);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[3]); EXPECT_FLOAT_EQ(v(1), it[3]);
ASSERT_FLOAT_EQ(v(2), it[4]); EXPECT_FLOAT_EQ(v(2), it[4]);
ASSERT_FLOAT_EQ(v(3), it[5]); EXPECT_FLOAT_EQ(v(3), it[5]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[6]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[6]);
} }
} }

54
src/ASM/Test/TestSplineFields.C
View File

@ -25,7 +25,7 @@
TEST(TestSplineFields, Value2D) TEST(TestSplineFields, Value2D)
{ {
SIM2D sim(2); SIM2D sim(2);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+x*y, x-y+x*y} // {x+y+x*y, x-y+x*y}
std::vector<double> vc = {0.0, 0.0, std::vector<double> vc = {0.0, 0.0,
@ -45,9 +45,9 @@ TEST(TestSplineFields, Value2D)
fe.v = it[1]; fe.v = it[1];
Vector v(2); Vector v(2);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[2]); EXPECT_FLOAT_EQ(v(1), it[2]);
ASSERT_FLOAT_EQ(v(2), it[3]); EXPECT_FLOAT_EQ(v(2), it[3]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[3]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[3]);
} }
} }
@ -56,8 +56,8 @@ TEST(TestSplineFields, Value2Dmx)
{ {
ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE; ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE;
SIM2D sim({1,1,1}); SIM2D sim({1,1,1});
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
sim.preprocess(); ASSERT_TRUE(sim.createFEMmodel());
// {x+y+x*y, x-y+x*y} // {x+y+x*y, x-y+x*y}
std::vector<double> vc = {0.0, std::vector<double> vc = {0.0,
@ -88,9 +88,9 @@ TEST(TestSplineFields, Value2Dmx)
fe.v = it[1]; fe.v = it[1];
Vector v(2); Vector v(2);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[2]); EXPECT_FLOAT_EQ(v(1), it[2]);
ASSERT_FLOAT_EQ(v(2), it[3]); EXPECT_FLOAT_EQ(v(2), it[3]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[4]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[4]);
} }
} }
@ -98,7 +98,7 @@ TEST(TestSplineFields, Value2Dmx)
TEST(TestSplineFields, Grad2D) TEST(TestSplineFields, Grad2D)
{ {
SIM2D sim(2); SIM2D sim(2);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+x*y, x-y+x*y} // {x+y+x*y, x-y+x*y}
std::vector<double> vc = {0.0, 0.0, 1.0, 1.0, 1.0, -1.0, 3.0, 1.0}; std::vector<double> vc = {0.0, 0.0, 1.0, 1.0, 1.0, -1.0, 3.0, 1.0};
@ -114,10 +114,10 @@ TEST(TestSplineFields, Grad2D)
fe.v = it[1]; fe.v = it[1];
Matrix gradu(2,2); Matrix gradu(2,2);
fvector->gradFE(fe, gradu); fvector->gradFE(fe, gradu);
ASSERT_FLOAT_EQ(gradu(1,1), it[2]); EXPECT_FLOAT_EQ(gradu(1,1), it[2]);
ASSERT_FLOAT_EQ(gradu(1,2), it[3]); EXPECT_FLOAT_EQ(gradu(1,2), it[3]);
ASSERT_FLOAT_EQ(gradu(2,1), it[4]); EXPECT_FLOAT_EQ(gradu(2,1), it[4]);
ASSERT_FLOAT_EQ(gradu(2,2), it[5]); EXPECT_FLOAT_EQ(gradu(2,2), it[5]);
} }
} }
@ -125,7 +125,7 @@ TEST(TestSplineFields, Grad2D)
TEST(TestSplineFields, Value3D) TEST(TestSplineFields, Value3D)
{ {
SIM3D sim(3); SIM3D sim(3);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+z, x+y-z, x-y+z} // {x+y+z, x+y-z, x-y+z}
std::vector<double> vc = {0.0, 0.0, 0.0, std::vector<double> vc = {0.0, 0.0, 0.0,
@ -155,10 +155,10 @@ TEST(TestSplineFields, Value3D)
fe.w = it[2]; fe.w = it[2];
Vector v(3); Vector v(3);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[3]); EXPECT_FLOAT_EQ(v(1), it[3]);
ASSERT_FLOAT_EQ(v(2), it[4]); EXPECT_FLOAT_EQ(v(2), it[4]);
ASSERT_FLOAT_EQ(v(3), it[5]); EXPECT_FLOAT_EQ(v(3), it[5]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[4]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[4]);
} }
} }
@ -166,7 +166,7 @@ TEST(TestSplineFields, Value3D)
TEST(TestSplineFields, Grad3D) TEST(TestSplineFields, Grad3D)
{ {
SIM3D sim(3); SIM3D sim(3);
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
// {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z} // {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z}
std::vector<double> vc = {0.0, 0.0, 0.0, std::vector<double> vc = {0.0, 0.0, 0.0,
@ -216,7 +216,7 @@ TEST(TestSplineFields, Grad3D)
fvector->gradFE(fe, gradu); fvector->gradFE(fe, gradu);
for (size_t i = 0; i < 3; ++i) for (size_t i = 0; i < 3; ++i)
for (size_t j = 0; j <3; ++j) for (size_t j = 0; j <3; ++j)
ASSERT_FLOAT_EQ(gradu(i+1,j+1), it.second[i*3+j]); EXPECT_FLOAT_EQ(gradu(i+1,j+1), it.second[i*3+j]);
} }
} }
@ -225,8 +225,8 @@ TEST(TestSplineFields, Value3Dmx)
{ {
ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE; ASMmxBase::Type = ASMmxBase::DIV_COMPATIBLE;
SIM3D sim({1,1,1,1}); SIM3D sim({1,1,1,1});
sim.createDefaultModel(); ASSERT_TRUE(sim.createDefaultModel());
sim.preprocess(); ASSERT_TRUE(sim.createFEMmodel());
// {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z} // {x+y+z+x*y*z, x+y-z+x*y*z, x-y+z+x*y*z}
std::vector<double> vc = {0.0, 0.5, 1.0, std::vector<double> vc = {0.0, 0.5, 1.0,
@ -268,9 +268,9 @@ TEST(TestSplineFields, Value3Dmx)
fe.w = it[2]; fe.w = it[2];
Vector v(3); Vector v(3);
fvector->valueFE(fe, v); fvector->valueFE(fe, v);
ASSERT_FLOAT_EQ(v(1), it[3]); EXPECT_FLOAT_EQ(v(1), it[3]);
ASSERT_FLOAT_EQ(v(2), it[4]); EXPECT_FLOAT_EQ(v(2), it[4]);
ASSERT_FLOAT_EQ(v(3), it[5]); EXPECT_FLOAT_EQ(v(3), it[5]);
ASSERT_FLOAT_EQ(fscalar->valueFE(fe), it[6]); EXPECT_FLOAT_EQ(fscalar->valueFE(fe), it[6]);
} }
} }