vector_value_test.C

Go to the documentation of this file.

#include <libmesh/vector_value.h>
 
#include "type_vector_test.h"
 
#include <type_traits>
 
#ifdef LIBMESH_HAVE_METAPHYSICL
#include <metaphysicl/dualnumber.h>
#endif
 
 
using namespace libMesh;
 
#define VECTORVALUETEST                         \
  TYPEVECTORTEST                                \
  CPPUNIT_TEST( testScalarInit );               \
 
class RealVectorValueTest : public TypeVectorTestBase<VectorValue<Real>> {
public:
  RealVectorValueTest() :
    TypeVectorTestBase<VectorValue<Real>>() {
    if (unitlog->summarized_logs_enabled())
      this->libmesh_suite_name = "TypeVectorTest";
    else
      this->libmesh_suite_name = "RealVectorValueTest";
  }
 
  CPPUNIT_TEST_SUITE( RealVectorValueTest );
 
  VECTORVALUETEST
 
  CPPUNIT_TEST_SUITE_END();
};
 
class NumberVectorValueTest : public TypeVectorTestBase<VectorValue<Number>> {
public:
  NumberVectorValueTest() :
    TypeVectorTestBase<VectorValue<Number>>() {
    this->libmesh_suite_name = "NumberVectorValueTest";
  }
 
  CPPUNIT_TEST_SUITE( NumberVectorValueTest );
 
  VECTORVALUETEST
 
  CPPUNIT_TEST_SUITE_END();
};
 
class ComplexVectorValueTest : public TypeVectorTestBase<VectorValue<Complex>> {
public:
  ComplexVectorValueTest() :
    TypeVectorTestBase<VectorValue<Complex>>() {
    this->libmesh_suite_name = "ComplexVectorValueTest";
  }
 
  CPPUNIT_TEST_SUITE( ComplexVectorValueTest );
 
  VECTORVALUETEST
 
  CPPUNIT_TEST_SUITE_END();
};
 
class VectorCompareTypesTest : public CppUnit::TestCase {
public:
  LIBMESH_CPPUNIT_TEST_SUITE( VectorCompareTypesTest );
 
  CPPUNIT_TEST( testCompareTypes );
 
  CPPUNIT_TEST_SUITE_END();
 
private:
  template <typename T, typename T2>
  typename CompareTypes<T, T2>::supertype
  average(const T & val1, const T2 & val2)
    {
      return (val1 + val2) / 2;
    }
 
public:
  void
  testCompareTypes()
    {
    LOG_UNIT_TEST;
 
      VectorValue<float> fvec;
      VectorValue<double> dvec;
 
      [[maybe_unused]] auto ftype = fvec * 1;
      [[maybe_unused]] auto dtype = dvec * 1;
 
      {
        bool assertion = std::is_same<decltype(ftype), TypeVector<float>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(dtype), TypeVector<double>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(average(ftype, ftype)), TypeVector<float>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(average(ftype, dtype)), TypeVector<double>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(average(fvec, fvec)), VectorValue<float>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(average(fvec, dvec)), VectorValue<double>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(average(fvec, dtype)), VectorValue<double>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        bool assertion = std::is_same<decltype(average(ftype, dvec)), VectorValue<double>>::value;
        CPPUNIT_ASSERT(assertion);
      }
#ifdef LIBMESH_HAVE_METAPHYSICL
      {
        typedef typename MetaPhysicL::ReplaceAlgebraicType<
            std::vector<double>,
            typename TensorTools::IncrementRank<
                typename MetaPhysicL::ValueType<std::vector<double>>::type>::type>::type
            ReplacedType;
        constexpr bool assertion =
            std::is_same<ReplacedType, std::vector<VectorValue<double>>>::value;
        CPPUNIT_ASSERT(assertion);
      }
      {
        typedef typename MetaPhysicL::ReplaceAlgebraicType<
            std::vector<VectorValue<double>>,
            typename TensorTools::IncrementRank<
                typename MetaPhysicL::ValueType<std::vector<VectorValue<double>>>::type>::type>::type
            ReplacedType;
        constexpr bool assertion =
            std::is_same<ReplacedType, std::vector<TensorValue<double>>>::value;
        CPPUNIT_ASSERT(assertion);
      }
#endif
    }
};
 
 
#ifdef LIBMESH_HAVE_METAPHYSICL
class ADVectorValueTest : public CppUnit::TestCase {
public:
  LIBMESH_CPPUNIT_TEST_SUITE( ADVectorValueTest );
 
  CPPUNIT_TEST( testNormAtZeroDerivative );
  CPPUNIT_TEST( testNormDerivative );
 
  CPPUNIT_TEST_SUITE_END();
 
private:
  typedef MetaPhysicL::DualNumber<Real> ADReal;
 
public:
  void testNormAtZeroDerivative()
  {
    LOG_UNIT_TEST;
 
    VectorValue<ADReal> avector(ADReal(0, 1));
#if LIBMESH_DIM > 1
    avector(1) = ADReal(0, 1);
#endif
#if LIBMESH_DIM > 2
    avector(2) = ADReal(0, 1);
#endif
 
    const ADReal result = avector.norm();
 
    LIBMESH_ASSERT_FP_EQUAL( Real(0), result.value(), TOLERANCE*TOLERANCE );
    LIBMESH_ASSERT_FP_EQUAL( Real(0), result.derivatives(), TOLERANCE*TOLERANCE );
  }
 
  void testNormDerivative()
  {
    LOG_UNIT_TEST;
 
    VectorValue<ADReal> avector(ADReal(1, 1));
#if LIBMESH_DIM > 1
    avector(1) = ADReal(1, 1);
#endif
#if LIBMESH_DIM > 2
    avector(2) = ADReal(1, 1);
#endif
 
    const ADReal result = avector.norm();
 
    LIBMESH_ASSERT_FP_EQUAL( std::sqrt(Real(LIBMESH_DIM)), result.value(), TOLERANCE*TOLERANCE );
    LIBMESH_ASSERT_FP_EQUAL( std::sqrt(Real(LIBMESH_DIM)), result.derivatives(), TOLERANCE*TOLERANCE );
  }
};
#endif // LIBMESH_HAVE_METAPHYSICL
 
 
CPPUNIT_TEST_SUITE_REGISTRATION( RealVectorValueTest );
CPPUNIT_TEST_SUITE_REGISTRATION( NumberVectorValueTest );
CPPUNIT_TEST_SUITE_REGISTRATION( ComplexVectorValueTest );
CPPUNIT_TEST_SUITE_REGISTRATION( VectorCompareTypesTest );
#ifdef LIBMESH_HAVE_METAPHYSICL
CPPUNIT_TEST_SUITE_REGISTRATION( ADVectorValueTest );
#endif