Homec4science
Diffusion µSpectre prototype implementation (add_eigenstrain) Browse

muSpectre_proto/tests/test_voigt_conversion.cc
cf176e930f6cadd_eigenstrain

Last Change
Raw File

test_voigt_conversion.cc
View Options

/**
* file test_voigt_conversion.cc
*
* @author Till Junge <till.junge@epfl.ch>
*
* @date 04 May 2017
*
* @brief Test the conversion between voigt and regular notation
*
* @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 <Eigen/Dense>
#include <unsupported/Eigen/CXX11/Tensor>
#include "common/common.hh"
#include "common/voigt_conversion.hh"
#include <iostream>
namespace muSpectre {
BOOST_AUTO_TEST_SUITE(voigt)
BOOST_AUTO_TEST_CASE(index_test) {
const Dim_t dim{3};
using C_t= Eigen::Tensor<size_t, 4>;
C_t C1(dim, dim, dim, dim);
C_t C2(dim, dim, dim, dim);
using V_t = Eigen::Matrix<size_t, vsize(dim), vsize(dim)>;
V_t Cv1;
V_t Cv2;
for (Dim_t i = 0; i < dim; ++i) {
for (Dim_t j = 0; j < dim; ++j) {
for (Dim_t k = 0; k < dim; ++k) {
for (Dim_t l = 0; l < dim; ++l) {
C1(i, j, k, l) = 10*(10*(10*(i+1) + j+1)+k+1)+l+1;
C2(i, j, k, l) = 10*(10*(10*(i+1) + j+1)+k+1)+l+1;
}
}
}
}
VoigtConversion<dim>::fourth_to_voigt(C1, Cv1);
VoigtConversion<dim>::fourth_to_voigt(C2, Cv2);
//std::cout << Cv1 <<std::endl;
}
BOOST_AUTO_TEST_CASE(basic_test_2d) {
const Dim_t dim{3};
auto delta = [](Dim_t i, Dim_t j) { return (i==j) ? 1 : 0;};
Eigen::Tensor<Real, 4> C(dim, dim, dim, dim);
Eigen::Matrix<Real, vsize(dim), vsize(dim)> Cv;
//Cv = Cv.Zero();
Eigen::Matrix<Dim_t, dim, dim> I;
for (Dim_t i = 0; i < dim; ++i) {
for (Dim_t j = 0; j < dim; ++j) {
I(i, j) = delta(i, j);
}
}
//std::cout << "I:" << std::endl << I << std::endl;
Real E = 10, nu = .3;
const Real lambda = E*nu/(1+nu)/(1-2*nu), mu = E/2/(1+nu);
for (Dim_t i = 0; i < dim; ++i) {
for (Dim_t j = 0; j < dim; ++j) {
for (Dim_t k = 0; k < dim; ++k) {
for (Dim_t l = 0; l < dim; ++l) {
C(i, j, k, l) = lambda*delta(i,j)*delta(k,l) + 2*mu * (delta(i,l)*delta(j,k) + delta(i,k)*delta(j,l))*.5;
}
}
}
}
VoigtConversion<dim>::fourth_to_voigt(C, Cv);
auto prefactor = E/(1+nu)/(1-2*nu);
for (Dim_t i = 0; i < dim; ++i) {
BOOST_CHECK_CLOSE(Cv(i, i ), prefactor*(1-nu), 1e-12);
BOOST_CHECK_CLOSE(Cv(i+dim, i+dim), prefactor*(1-2*nu)/2, 1e-12);
for (Dim_t j = i + 1; j < dim; ++j ) {
BOOST_CHECK_CLOSE(Cv(i, j), prefactor*nu, 1e-12);
BOOST_CHECK_CLOSE(Cv(j, i), prefactor*nu, 1e-12);
BOOST_CHECK_CLOSE(Cv(i+dim, j+dim), 0, 1e-12);
}
for (Dim_t j = 0; j < dim; ++j) {
BOOST_CHECK_CLOSE(Cv(i+dim, j ), 0, 1e-12);
BOOST_CHECK_CLOSE(Cv(i, j+dim), 0, 1e-12);
}
}
//cstd::cout << Cv << std::endl;
}
BOOST_AUTO_TEST_SUITE_END()
} // muSpectre
c4science · Help