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

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

@ -11,15 +11,14 @@
//==============================================================================
#include "ASMu3D.h"
#include "GaussQuadrature.h"
#include "SIM3D.h"
#include "GaussQuadrature.h"
#include "LRSpline/LRSplineVolume.h"
#include "gtest/gtest.h"
#include <numeric>
class TestASMu3D :
public testing::Test,
class TestASMu3D : public testing::Test,
public testing::WithParamInterface<int>
{
};
@ -33,7 +32,7 @@ TEST_P(TestASMu3D, BoundaryNodes)
SIM3D sim(1);
sim.opt.discretization = ASM::LRSpline;
ASSERT_TRUE(sim.read("src/ASM/LR/Test/refdata/boundary_nodes_3d.xinp"));
sim.preprocess();
ASSERT_TRUE(sim.createFEMmodel());
std::stringstream str;
str << "Face" << GetParam();
@ -42,22 +41,20 @@ TEST_P(TestASMu3D, BoundaryNodes)
sim.getBoundaryNodes(bcode,vec);
ASSERT_EQ(vec.size(), 16U);
auto it = vec.begin();
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
if (GetParam() == 1)
ASSERT_EQ(*it++, 1+4*(4*i+j));
EXPECT_EQ(*it++, 1+4*(4*i+j));
else if (GetParam() == 2)
ASSERT_EQ(*it++, 2+4*(4*i+j));
EXPECT_EQ(*it++, 2+4*(4*i+j));
else if (GetParam() == 3)
ASSERT_EQ(*it++, 16*i+j+1);
EXPECT_EQ(*it++, 16*i+j+1);
else if (GetParam() == 4)
ASSERT_EQ(*it++, 5+16*i+j);
EXPECT_EQ(*it++, 5+16*i+j);
else if (GetParam() == 5)
ASSERT_EQ(*it++, 4*i+j+1);
EXPECT_EQ(*it++, 4*i+j+1);
else if (GetParam() == 6)
ASSERT_EQ(*it++, 17+4*i+j);
}
}
EXPECT_EQ(*it++, 17+4*i+j);
}

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

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

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

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