Homec4science
Diffusion µSpectre prototype implementation (master) Browse

muSpectre_proto/tests/test_system_base.cc
659912251d62master

Last Change
Raw File

test_system_base.cc
View Options

/**
* file test_system_base.cc
*
* @author Till Junge <till.junge@epfl.ch>
*
* @date 10 May 2017
*
* @brief test SystemBase class
*
* @section LICENCE
*
* Copyright (C) 2017 Till Junge
*
* µSpectre is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3, or (at
* your option) any later version.
*
* µSpectre is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Emacs; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <boost/test/unit_test.hpp>
#include <boost/mpl/list.hpp>
#include <Eigen/Dense>
#include <iostream>
#include "common/voigt_conversion.hh"
#include "vector"
#include "memory"
#include "system/system_base.hh"
#include "tests.hh"
#include "system/fftw_engine_r2c.hh"
#include "materials/material_hyper_elastic.hh"
namespace muSpectre {
template <Dim_t DimS, Dim_t DimM>
struct sys_fixture:public SystemBase<DimS, DimM> {
sys_fixture()
:SystemBase<DimS, DimM>(std_size,
std_nb_pix){}
const static std::array<Real, DimS> std_size;
const static Index_t<DimS> std_nb_pix;
const static Dim_t dim_s=DimS, dim_m=DimM;
};
template<> const std::array<Real, 2> sys_fixture<2, 2>::std_size{5, 3};
template<> const std::array<Real, 2> sys_fixture<2, 3>::std_size{5, 3};
template<> const std::array<Real, 3> sys_fixture<3, 3>::std_size{7, 5, 3};
template<> const Index_t<2> sys_fixture<2, 2>::std_nb_pix{5, 3};
template<> const Index_t<2> sys_fixture<2, 3>::std_nb_pix{5, 3};
template<> const Index_t<3> sys_fixture<3, 3>::std_nb_pix{7, 5, 3};
#include "testdata_system_base.hh"
//----------------------------------------------------------------------------//
using test_systems = boost::mpl::list<sys_fixture<2, 2>,
sys_fixture<2, 3>,
sys_fixture<3, 3>>;
using dim_test_systems = boost::mpl::list<sys_fixture<2, 2>,
sys_fixture<3, 3>>;
//----------------------------------------------------------------------------//
BOOST_AUTO_TEST_CASE(fftfreq_test) {
auto length = 15.2;
auto n1{8}, n2{9};
Eigen::RowVectorXd ref1(n1);
ref1 << 0.0, 0.06578947368421052, 0.13157894736842105, 0.19736842105263158,
-0.2631578947368421, -0.19736842105263158, -0.13157894736842105,
-0.06578947368421052;
Eigen::RowVectorXd ref2(n2);
ref2 << 0.0, 0.06578947368421052, 0.13157894736842105, 0.19736842105263158,
0.2631578947368421, -0.2631578947368421, -0.19736842105263158,
-0.13157894736842105, -0.06578947368421052;
auto challenge1(Projection::fft_freqs(n1, length));
auto challenge2(Projection::fft_freqs(n2, length));
Eigen::RowVectorXd er1 = ref1-challenge1;
Real error1 = (ref1 - challenge1).norm();
Real error2 = (ref2 - challenge2).norm();
BOOST_CHECK_LT(error1, tol);
BOOST_CHECK_LT(error2, tol);
}
//----------------------------------------------------------------------------//
BOOST_FIXTURE_TEST_CASE_TEMPLATE(constructor_test, F, test_systems, F) {
}
//----------------------------------------------------------------------------//
BOOST_FIXTURE_TEST_CASE_TEMPLATE(Ghat_test, F, test_systems, F) {
const int dim_s = F::dim_s;
const int dim_m = F::dim_m;
auto ghat_ref = Ghats<dim_s, dim_m>();
//TODO; for unknown reason, the python ref gives different results when material and spatial dimension dffer. not sure who's wrong
if(dim_s == dim_m) {
for (size_t pix_id = 0; pix_id < F::nb_pixel; ++pix_id) {
using Tshape = Eigen::Sizes<F::dim_m,F::dim_m,F::dim_m,F::dim_m>;
using Ttype = Eigen::TensorFixedSize<Real, Tshape>;
Ttype ghat_i = F::Ghats.template chip<4>(pix_id);
Real error = (VoigtConversion<F::dim_m>::fourth_to_2d(ghat_i)
-(*ghat_ref[pix_id])).norm();
if (error >= tol) {
std::cout <<"For dim_m = " << dim_m << ", dim_s = " << dim_s
<< " reference is:\n"
<< VoigtConversion<dim_m>::fourth_to_2d(ghat_i)
<< "\nbut I got:\n" << *ghat_ref[pix_id] << std::endl;
}
BOOST_CHECK_LT(error, tol);
}
}
}
//----------------------------------------------------------------------------//
BOOST_FIXTURE_TEST_CASE_TEMPLATE(dumb_uniform_patchtest_hyperelastic, F, dim_test_systems, F) {
const int dim_s = F::dim_s;
const int dim_m = F::dim_m;
typename F::FFT_Ptr fft_eng =
std::make_shared<FFTW_EngineR2C<dim_s, dim_m>>
(F::std_nb_pix, FFT_PlanFlags::estimate);
const Real E = 1.0030648180242636;
const Real nu = 0.29930675909878679;
typename F::mat_Ptr hyperelastic =
std::make_shared<MaterialHyperElastic<dim_s, dim_m>>
(E, nu);
F::set_fft_engine(fft_eng);
F::add_material(hyperelastic);
Real newton_tol = 1e-4;
Real cg_tol = 1e-4;
size_t maxiter = 12;
auto it = F::begin();
auto end = F::end();
for (; it != end; ++it) {
hyperelastic->add_pixel(*it);
}
typename F::T2 DeltaF;
DeltaF.setZero();
DeltaF(0, 1) = 1e-2;
F::solve(DeltaF, newton_tol, cg_tol, maxiter);
}
//----------------------------------------------------------------------------//
BOOST_AUTO_TEST_CASE(non_uniform_test_hyperelastic) {
const Int dim = 3;
const Int N = 5;
const std::array<Real, dim> sizes{N, N, N};
const std::array<Dim_t, dim> nb_pixels{N, N, N};
using Sys_t = SystemBase<dim, dim>;
SystemBase<dim, dim> system(sizes, nb_pixels);
typename Sys_t::FFT_Ptr fft_eng =
std::make_shared<FFTW_EngineR2C<dim, dim>>
(nb_pixels, FFT_PlanFlags::estimate);
const Real E = 1.0030648180242636;
const Real nu = 0.29930675909878679;
typename Sys_t::mat_Ptr hyperelastic_soft =
std::make_shared<MaterialHyperElastic<dim, dim>>
(E, nu);
typename Sys_t::mat_Ptr hyperelastic_hard =
std::make_shared<MaterialHyperElastic<dim, dim>>
(10*E, nu);
system.set_fft_engine(fft_eng);
system.add_material(hyperelastic_soft);
system.add_material(hyperelastic_hard);
Real newton_tol = 1e-5;
Real cg_tol = 1e-8;
size_t maxiter = 35;
bool first = true;
for (const auto && pixel:system) {
if (first) {
first = false;
hyperelastic_hard->add_pixel(pixel);
} else {
hyperelastic_soft->add_pixel(pixel);
}
}
typename Sys_t::T2 DeltaF;
DeltaF.setZero();
DeltaF(0, 1) = 1.;
BOOST_CHECK_THROW(system.solve(DeltaF, newton_tol, cg_tol, maxiter),
std::runtime_error);
}
} // muSpectre
c4science · Help