Cartesian.C File Reference

Go to the source code of this file.

Functions
	TEST (FunctionalExpansionsTest, legendreConstructor)
	TEST (FunctionalExpansionsTest, legendreSeriesOrthonormalEvaluation)
	TEST (FunctionalExpansionsTest, legendreSeriesSqrtMuEvaluation)
	TEST (FunctionalExpansionsTest, legendreSeriesStandardEvaluation)
	TEST (FunctionalExpansionsTest, CartesianConstructor)
	TEST (FunctionalExpansionsTest, Cartesian3D)
	TEST (FunctionalExpansionsTest, functionalBasisInterfaceCartesian)

Function Documentation

TEST() [1/7]

TEST	(	FunctionalExpansionsTest	,
		Cartesian3D
	)

Definition at line 149 of file Cartesian.C.

{
  const std::vector<MooseEnum> domains = {FunctionalBasisInterface::_domain_options = "x",
                                          FunctionalBasisInterface::_domain_options = "y",
                                          FunctionalBasisInterface::_domain_options = "z"};
  const std::vector<std::size_t> orders = {14, 21, 22};
  const std::vector<MooseEnum> series = {single_series_types_1D = "Legendre",
                                         single_series_types_1D = "Legendre",
                                         single_series_types_1D = "Legendre"};
 
  Cartesian legendre3D(
      domains, orders, series, name, expansion_type = "standard", generation_type = "orthonormal");
 
  const std::vector<Point> locations = {
      Point(-0.14854612627465, 0.60364074055275, 0.76978431165674),
      Point(0.93801805187856, 0.74175118177279, 0.74211345600994),
      Point(0.35423736896098, -0.83921049062126, -0.02231845586669)};
  const std::vector<Real> standard_truth = {1.32257143058688, 3.68047786932034, 0.17515811557416};
  const std::vector<Real> orthogonal_truth = {
      -2.33043696271172, 74.48747654183713, -14.48091828923379};
 
  for (std::size_t i = 0; i < locations.size(); ++i)
  {
    legendre3D.setLocation(locations[i]);
    // loose tolerances due to diffs with -march=x86-64-v3
    EXPECT_NEAR(legendre3D.getExpansionSeriesSum(), standard_truth[i], 5.e-12);
    EXPECT_NEAR(legendre3D.getGenerationSeriesSum(), orthogonal_truth[i], 5.e-10);
  }
}

TEST() [2/7]

TEST	(	FunctionalExpansionsTest	,
		CartesianConstructor
	)

Definition at line 122 of file Cartesian.C.

{
  std::vector<MooseEnum> domains;
  std::vector<std::size_t> orders;
  std::vector<MooseEnum> series;
  expansion_type = "standard";
  generation_type = "orthonormal";
 
  domains.push_back(FunctionalBasisInterface::_domain_options = "x");
  orders = {19};
  series.push_back(single_series_types_1D = "Legendre");
  Cartesian legendreOne(domains, orders, series, name, expansion_type, generation_type);
  EXPECT_EQ(legendreOne.getNumberOfTerms(), orders[0] + 1);
 
  domains.push_back(FunctionalBasisInterface::_domain_options = "y");
  orders = {{13, 15}};
  series.push_back(single_series_types_1D = "Legendre");
  Cartesian legendreTwo(domains, orders, series, name, expansion_type, generation_type);
  EXPECT_EQ(legendreTwo.getNumberOfTerms(), (orders[0] + 1) * (orders[1] + 1));
 
  domains.push_back(FunctionalBasisInterface::_domain_options = "z");
  orders = {{14, 21, 22}};
  series.push_back(single_series_types_1D = "Legendre");
  Cartesian legendreThree(domains, orders, series, name, expansion_type, generation_type);
  EXPECT_EQ(legendreThree.getNumberOfTerms(), (orders[0] + 1) * (orders[1] + 1) * (orders[2] + 1));
}

TEST() [3/7]

TEST	(	FunctionalExpansionsTest	,
		functionalBasisInterfaceCartesian
	)

Definition at line 179 of file Cartesian.C.

{
  const std::vector<MooseEnum> domains = {FunctionalBasisInterface::_domain_options = "x",
                                          FunctionalBasisInterface::_domain_options = "y",
                                          FunctionalBasisInterface::_domain_options = "z"};
  const std::vector<std::size_t> orders = {4, 5, 3};
  const std::vector<MooseEnum> series = {single_series_types_1D = "Legendre",
                                         single_series_types_1D = "Legendre",
                                         single_series_types_1D = "Legendre"};
 
  Cartesian legendre3D(
      domains, orders, series, name, expansion_type = "standard", generation_type = "orthonormal");
 
  const Point location(-0.38541903411291, 0.61369802505416, -0.04539307255549);
  const Real truth = 0.26458908225718;
  FunctionalBasisInterface & interface = (FunctionalBasisInterface &)legendre3D;
 
  interface.setLocation(location);
  EXPECT_NEAR(interface.getExpansionSeriesSum(), truth, tol);
}

TEST() [4/7]

TEST	(	FunctionalExpansionsTest	,
		legendreConstructor
	)

Definition at line 16 of file Cartesian.C.

{
  const unsigned int order = 5;
 
  Legendre legendre({FunctionalBasisInterface::_domain_options = "x"},
                    {order},
                    expansion_type = "orthonormal",
                    generation_type = "standard");
  EXPECT_EQ(legendre.getOrder(0), order);
}

TEST() [5/7]

TEST	(	FunctionalExpansionsTest	,
		legendreSeriesOrthonormalEvaluation
	)

Definition at line 27 of file Cartesian.C.

{
  const unsigned int order = 15;
  Real location = -0.90922108754014;
  const std::array<Real, order> truth = {{0.50000000000000,
                                          -1.36383163131021,
                                          1.85006119760378,
                                          -1.80341832197563,
                                          1.19175581122701,
                                          -0.11669847057321,
                                          -1.20462734483853,
                                          2.48341349094950,
                                          -3.41981864606651,
                                          3.76808851494207,
                                          -3.39261995754146,
                                          2.30300489952095,
                                          -0.66011244776270,
                                          -1.24901920248131,
                                          3.06342136027001}};
 
  Legendre legendre({FunctionalBasisInterface::_domain_options = "x"},
                    {order},
                    expansion_type = "standard",
                    generation_type = "orthonormal");
 
  legendre.setLocation(Point(location));
  auto & answer = legendre.getAllGeneration();
  for (std::size_t i = 0; i < order; ++i)
    // loose tolerances due to diffs with -march=x86-64-v3
    EXPECT_NEAR(answer[i], truth[i], 1.e-12);
}

TEST() [6/7]

TEST	(	FunctionalExpansionsTest	,
		legendreSeriesSqrtMuEvaluation
	)

Definition at line 59 of file Cartesian.C.

{
  const unsigned int order = 15;
  Real location = -0.90922108754014;
  const std::array<Real, order> truth = {{0.50000000000000,
                                          -1.36383163131021,
                                          1.85006119760378,
                                          -1.80341832197563,
                                          1.19175581122701,
                                          -0.11669847057321,
                                          -1.20462734483853,
                                          2.48341349094950,
                                          -3.41981864606651,
                                          3.76808851494207,
                                          -3.39261995754146,
                                          2.30300489952095,
                                          -0.66011244776270,
                                          -1.24901920248131,
                                          3.06342136027001}};
 
  Legendre legendre({FunctionalBasisInterface::_domain_options = "x"},
                    {order},
                    expansion_type = "standard",
                    generation_type = "sqrt_mu");
 
  legendre.setLocation(Point(location));
  auto & answer = legendre.getAllGeneration();
  for (std::size_t i = 0; i < order; ++i)
    // loose tolerances due to diffs with -march=x86-64-v3
    EXPECT_NEAR(answer[i], truth[i] / std::sqrt(i + 0.5), 5.e-12);
}

TEST() [7/7]

TEST	(	FunctionalExpansionsTest	,
		legendreSeriesStandardEvaluation
	)

Definition at line 91 of file Cartesian.C.

{
  const unsigned int order = 15;
  Real location = -0.90922108754014;
  const std::array<Real, order> truth = {{0.50000000000000,
                                          -1.36383163131021,
                                          1.85006119760378,
                                          -1.80341832197563,
                                          1.19175581122701,
                                          -0.11669847057321,
                                          -1.20462734483853,
                                          2.48341349094950,
                                          -3.41981864606651,
                                          3.76808851494207,
                                          -3.39261995754146,
                                          2.30300489952095,
                                          -0.66011244776270,
                                          -1.24901920248131,
                                          3.06342136027001}};
 
  Legendre legendre({FunctionalBasisInterface::_domain_options = "x"},
                    {order},
                    expansion_type = "standard",
                    generation_type = "standard");
 
  legendre.setLocation(Point(location));
  auto & answer = legendre.getAllGeneration();
  for (std::size_t i = 0; i < order; ++i)
    EXPECT_NEAR(answer[i], truth[i] / (i + 0.5), tol);
}