Homec4science
Diffusion tamaas (features/declarative) Browse

tamaas/src/core/computes.hh
1fc7644bad52features/declarative

Last Change
Raw File

computes.hh
View Options

/*
* SPDX-License-Indentifier: AGPL-3.0-or-later
*
* Copyright (©) 2016-2021 EPFL (École Polytechnique Fédérale de Lausanne),
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
/* -------------------------------------------------------------------------- */
#ifndef EIGENVALUES_HH
#define EIGENVALUES_HH
/* -------------------------------------------------------------------------- */
#include "grid.hh"
#include "loop.hh"
#include "model_type.hh"
#include "ranges.hh"
#include "static_types.hh"
#include <boost/preprocessor/seq.hpp>
namespace tamaas {
namespace compute {
/// Compute eigenvalues of a symmetric matrix field
struct Eigenvalues {
template <UInt dim>
static void call(Grid<Real, dim>& eigs, const Grid<Real, dim>& field) {
Loop::loop([] CUDA_LAMBDA(
VectorProxy<Real, dim> eig,
SymMatrixProxy<const Real, dim> f) { eig = eigenvalues(f); },
range<VectorProxy<Real, dim>>(eigs),
range<SymMatrixProxy<const Real, dim>>(field));
}
};
/// Compute von Mises stress on a tensor field
struct VonMises {
template <UInt dim>
static void call(Grid<Real, dim>& vm, const Grid<Real, dim>& stress) {
Loop::loop(
[] CUDA_LAMBDA(Real & vm, SymMatrixProxy<const Real, dim> sigma) {
SymMatrix<Real, dim> dev;
dev.deviatoric(sigma, 3);
vm = std::sqrt(1.5) * dev.l2norm();
},
vm, range<SymMatrixProxy<const Real, dim>>(stress));
}
};
/// Compute deviatoric of tensor field
struct Deviatoric {
template <UInt dim>
static void call(Grid<Real, dim>& dev, const Grid<Real, dim>& field) {
Loop::loop(
[] CUDA_LAMBDA(SymMatrixProxy<Real, dim> s,
SymMatrixProxy<const Real, dim> sigma) {
s.deviatoric(sigma, 3);
},
range<SymMatrixProxy<Real, dim>>(dev),
range<SymMatrixProxy<const Real, dim>>(field));
}
};
} // namespace compute
template <typename Compute>
void applyCompute(model_type type, GridBase<Real>& result,
const GridBase<Real>& field) {
#define APPLY_CASE(_, __, type) \
case type: { \
constexpr UInt dim = model_type_traits<type>::dimension; \
const auto& f = dynamic_cast<const Grid<Real, dim>&>(field); \
auto& e = dynamic_cast<Grid<Real, dim>&>(result); \
Compute::template call<dim>(e, f); \
break; \
}
switch (type) {
BOOST_PP_SEQ_FOR_EACH(APPLY_CASE, ~, (model_type::volume_2d));
default:
TAMAAS_EXCEPTION("Model type "
<< type << " not yet suported for field computation");
}
#undef APPLY_CASE
}
void eigenvalues(model_type type, GridBase<Real>& eigs,
const GridBase<Real>& field);
void vonMises(model_type type, GridBase<Real>& eigs,
const GridBase<Real>& field);
void deviatoric(model_type type, GridBase<Real>& dev,
const GridBase<Real>& field);
} // namespace tamaas
#endif /* EIGENVALUES_HH */
c4science · Help