Skip to content
Snippets Groups Projects
Commit f7bb98ce authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Remove temporary perfect gas utilities

parent 3f536824
No related branches found
No related tags found
1 merge request!90Add access to cells' volume of a mesh in the script file
...@@ -25,8 +25,6 @@ ...@@ -25,8 +25,6 @@
#include <scheme/NumberedBoundaryDescriptor.hpp> #include <scheme/NumberedBoundaryDescriptor.hpp>
#include <scheme/SymmetryBoundaryConditionDescriptor.hpp> #include <scheme/SymmetryBoundaryConditionDescriptor.hpp>
#include <scheme/PerfectGas.hpp>
#include <memory> #include <memory>
SchemeModule::SchemeModule() SchemeModule::SchemeModule()
...@@ -150,82 +148,6 @@ SchemeModule::SchemeModule() ...@@ -150,82 +148,6 @@ SchemeModule::SchemeModule()
)); ));
this
->_addBuiltinFunction("perfect_gas_epsilon_from_rho_p_gamma",
std::make_shared<BuiltinFunctionEmbedder<
std::shared_ptr<const IDiscreteFunction>(const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&)>>(
[](const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& p,
const std::shared_ptr<const IDiscreteFunction>& gamma)
-> std::shared_ptr<const IDiscreteFunction> {
return perfect_gas::epsilonFromRhoPGamma(rho, p, gamma);
}
));
this
->_addBuiltinFunction("perfect_gas_p_from_rho_epsilon_gamma",
std::make_shared<BuiltinFunctionEmbedder<
std::shared_ptr<const IDiscreteFunction>(const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&)>>(
[](const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& epsilon,
const std::shared_ptr<const IDiscreteFunction>& gamma)
-> std::shared_ptr<const IDiscreteFunction> {
return perfect_gas::pFromRhoEpsilonGamma(rho, epsilon, gamma);
}
));
this
->_addBuiltinFunction("perfect_gas_sound_speed",
std::make_shared<BuiltinFunctionEmbedder<
std::shared_ptr<const IDiscreteFunction>(const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&)>>(
[](const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& p,
const std::shared_ptr<const IDiscreteFunction>& gamma)
-> std::shared_ptr<const IDiscreteFunction> {
return perfect_gas::soundSpeed(rho, p, gamma);
}
));
this
->_addBuiltinFunction("E_from_epsilon_u",
std::make_shared<BuiltinFunctionEmbedder<
std::shared_ptr<const IDiscreteFunction>(const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&)>>(
[](const std::shared_ptr<const IDiscreteFunction>& epsilon,
const std::shared_ptr<const IDiscreteFunction>& u)
-> std::shared_ptr<const IDiscreteFunction> {
return perfect_gas::totalEnergyFromEpsilonU(epsilon, u);
}
));
this
->_addBuiltinFunction("epsilon_from_E_u",
std::make_shared<BuiltinFunctionEmbedder<
std::shared_ptr<const IDiscreteFunction>(const std::shared_ptr<const IDiscreteFunction>&,
const std::shared_ptr<const IDiscreteFunction>&)>>(
[](const std::shared_ptr<const IDiscreteFunction>& E,
const std::shared_ptr<const IDiscreteFunction>& u)
-> std::shared_ptr<const IDiscreteFunction> {
return perfect_gas::epsilonFromTotalEnergyU(E, u);
}
));
this->_addBuiltinFunction("glace_solver", this->_addBuiltinFunction("glace_solver",
std::make_shared<BuiltinFunctionEmbedder<std::tuple< std::make_shared<BuiltinFunctionEmbedder<std::tuple<
std::shared_ptr<const IMesh>, std::shared_ptr<const IDiscreteFunction>, std::shared_ptr<const IMesh>, std::shared_ptr<const IDiscreteFunction>,
......
...@@ -5,5 +5,4 @@ add_library( ...@@ -5,5 +5,4 @@ add_library(
AcousticSolver.cpp AcousticSolver.cpp
DiscreteFunctionInterpoler.cpp DiscreteFunctionInterpoler.cpp
DiscreteFunctionUtils.cpp DiscreteFunctionUtils.cpp
DiscreteFunctionVectorInterpoler.cpp DiscreteFunctionVectorInterpoler.cpp)
PerfectGas.cpp)
#include <scheme/PerfectGas.hpp>
#include <scheme/DiscreteFunctionP0.hpp>
#include <scheme/DiscreteFunctionUtils.hpp>
namespace perfect_gas
{
template <size_t Dimension, typename DataType>
std::shared_ptr<IDiscreteFunction>
soundSpeed(const DiscreteFunctionP0<Dimension, DataType>& rho,
const DiscreteFunctionP0<Dimension, DataType>& p,
const DiscreteFunctionP0<Dimension, DataType>& gamma)
{
using MeshType = Mesh<Connectivity<Dimension>>;
std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(rho.mesh());
DiscreteFunctionP0<Dimension, DataType> sound_speed{mesh};
parallel_for(
mesh->numberOfCells(),
PUGS_LAMBDA(CellId cell_id) { sound_speed[cell_id] = std::sqrt(gamma[cell_id] * p[cell_id] / rho[cell_id]); });
return std::make_shared<DiscreteFunctionP0<Dimension, DataType>>(sound_speed);
}
std::shared_ptr<IDiscreteFunction>
soundSpeed(const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& p,
const std::shared_ptr<const IDiscreteFunction>& gamma)
{
std::shared_ptr<const IMesh> mesh = getCommonMesh({rho, p, gamma});
if (not mesh.use_count()) {
throw NormalError("rho, p and gamma are not defined on the same mesh");
}
switch (mesh->dimension()) {
case 1: {
return soundSpeed(dynamic_cast<const DiscreteFunctionP0<1, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<1, double>&>(*p),
dynamic_cast<const DiscreteFunctionP0<1, double>&>(*gamma));
}
case 2: {
return soundSpeed(dynamic_cast<const DiscreteFunctionP0<2, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<2, double>&>(*p),
dynamic_cast<const DiscreteFunctionP0<2, double>&>(*gamma));
}
case 3: {
return soundSpeed(dynamic_cast<const DiscreteFunctionP0<3, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<3, double>&>(*p),
dynamic_cast<const DiscreteFunctionP0<3, double>&>(*gamma));
}
default: {
throw UnexpectedError("invalid mesh dimension");
}
}
}
template <size_t Dimension, typename DataType>
std::shared_ptr<IDiscreteFunction>
epsilonFromRhoPGamma(const DiscreteFunctionP0<Dimension, DataType>& rho,
const DiscreteFunctionP0<Dimension, DataType>& p,
const DiscreteFunctionP0<Dimension, DataType>& gamma)
{
using MeshType = Mesh<Connectivity<Dimension>>;
std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(rho.mesh());
DiscreteFunctionP0<Dimension, DataType> epsilon{mesh};
parallel_for(
mesh->numberOfCells(),
PUGS_LAMBDA(CellId cell_id) { epsilon[cell_id] = p[cell_id] / ((gamma[cell_id] - 1) * rho[cell_id]); });
return std::make_shared<DiscreteFunctionP0<Dimension, DataType>>(epsilon);
}
std::shared_ptr<IDiscreteFunction>
epsilonFromRhoPGamma(const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& p,
const std::shared_ptr<const IDiscreteFunction>& gamma)
{
std::shared_ptr<const IMesh> mesh = getCommonMesh({rho, p, gamma});
if (not mesh.use_count()) {
throw NormalError("rho, p and gamma are not defined on the same mesh");
}
switch (mesh->dimension()) {
case 1: {
return epsilonFromRhoPGamma(dynamic_cast<const DiscreteFunctionP0<1, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<1, double>&>(*p),
dynamic_cast<const DiscreteFunctionP0<1, double>&>(*gamma));
}
case 2: {
return epsilonFromRhoPGamma(dynamic_cast<const DiscreteFunctionP0<2, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<2, double>&>(*p),
dynamic_cast<const DiscreteFunctionP0<2, double>&>(*gamma));
}
case 3: {
return epsilonFromRhoPGamma(dynamic_cast<const DiscreteFunctionP0<3, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<3, double>&>(*p),
dynamic_cast<const DiscreteFunctionP0<3, double>&>(*gamma));
}
default: {
throw UnexpectedError("invalid mesh dimension");
}
}
}
template <size_t Dimension, typename DataType>
std::shared_ptr<IDiscreteFunction>
pFromRhoEpsilonGamma(const DiscreteFunctionP0<Dimension, DataType>& rho,
const DiscreteFunctionP0<Dimension, DataType>& epsilon,
const DiscreteFunctionP0<Dimension, DataType>& gamma)
{
using MeshType = Mesh<Connectivity<Dimension>>;
std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(rho.mesh());
DiscreteFunctionP0<Dimension, DataType> p{mesh};
parallel_for(
mesh->numberOfCells(),
PUGS_LAMBDA(CellId cell_id) { p[cell_id] = ((gamma[cell_id] - 1) * rho[cell_id]) * epsilon[cell_id]; });
return std::make_shared<DiscreteFunctionP0<Dimension, DataType>>(p);
}
std::shared_ptr<IDiscreteFunction>
pFromRhoEpsilonGamma(const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& epsilon,
const std::shared_ptr<const IDiscreteFunction>& gamma)
{
std::shared_ptr<const IMesh> mesh = getCommonMesh({rho, epsilon, gamma});
if (not mesh.use_count()) {
throw NormalError("rho, epsilon and gamma are not defined on the same mesh");
}
switch (mesh->dimension()) {
case 1: {
return pFromRhoEpsilonGamma(dynamic_cast<const DiscreteFunctionP0<1, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<1, double>&>(*epsilon),
dynamic_cast<const DiscreteFunctionP0<1, double>&>(*gamma));
}
case 2: {
return pFromRhoEpsilonGamma(dynamic_cast<const DiscreteFunctionP0<2, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<2, double>&>(*epsilon),
dynamic_cast<const DiscreteFunctionP0<2, double>&>(*gamma));
}
case 3: {
return pFromRhoEpsilonGamma(dynamic_cast<const DiscreteFunctionP0<3, double>&>(*rho),
dynamic_cast<const DiscreteFunctionP0<3, double>&>(*epsilon),
dynamic_cast<const DiscreteFunctionP0<3, double>&>(*gamma));
}
default: {
throw UnexpectedError("invalid mesh dimension");
}
}
}
template <size_t Dimension, typename DataType>
std::shared_ptr<IDiscreteFunction>
totalEnergyFromEpsilonU(const DiscreteFunctionP0<Dimension, DataType>& epsilon,
const DiscreteFunctionP0<Dimension, TinyVector<Dimension, DataType>>& u)
{
using MeshType = Mesh<Connectivity<Dimension>>;
std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(epsilon.mesh());
DiscreteFunctionP0<Dimension, DataType> E{mesh};
parallel_for(
mesh->numberOfCells(),
PUGS_LAMBDA(CellId cell_id) { E[cell_id] = epsilon[cell_id] + 0.5 * dot(u[cell_id], u[cell_id]); });
return std::make_shared<DiscreteFunctionP0<Dimension, DataType>>(epsilon);
}
std::shared_ptr<IDiscreteFunction>
totalEnergyFromEpsilonU(const std::shared_ptr<const IDiscreteFunction>& epsilon,
const std::shared_ptr<const IDiscreteFunction>& u)
{
std::shared_ptr<const IMesh> mesh = getCommonMesh({epsilon, u});
if (not mesh.use_count()) {
throw NormalError("epsilon and u are not defined on the same mesh");
}
switch (mesh->dimension()) {
case 1: {
return totalEnergyFromEpsilonU(dynamic_cast<const DiscreteFunctionP0<1, double>&>(*epsilon),
dynamic_cast<const DiscreteFunctionP0<1, TinyVector<1, double>>&>(*u));
}
case 2: {
return totalEnergyFromEpsilonU(dynamic_cast<const DiscreteFunctionP0<2, double>&>(*epsilon),
dynamic_cast<const DiscreteFunctionP0<2, TinyVector<2, double>>&>(*u));
}
case 3: {
return totalEnergyFromEpsilonU(dynamic_cast<const DiscreteFunctionP0<3, double>&>(*epsilon),
dynamic_cast<const DiscreteFunctionP0<3, TinyVector<3, double>>&>(*u));
}
default: {
throw UnexpectedError("invalid mesh dimension");
}
}
}
template <size_t Dimension, typename DataType>
std::shared_ptr<IDiscreteFunction>
epsilonFromTotalEnergyU(const DiscreteFunctionP0<Dimension, DataType>& E,
const DiscreteFunctionP0<Dimension, TinyVector<Dimension, DataType>>& u)
{
using MeshType = Mesh<Connectivity<Dimension>>;
std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(u.mesh());
DiscreteFunctionP0<Dimension, DataType> epsilon{mesh};
parallel_for(
mesh->numberOfCells(),
PUGS_LAMBDA(CellId cell_id) { epsilon[cell_id] = E[cell_id] - 0.5 * dot(u[cell_id], u[cell_id]); });
return std::make_shared<DiscreteFunctionP0<Dimension, DataType>>(epsilon);
}
std::shared_ptr<IDiscreteFunction>
epsilonFromTotalEnergyU(const std::shared_ptr<const IDiscreteFunction>& E,
const std::shared_ptr<const IDiscreteFunction>& u)
{
std::shared_ptr<const IMesh> mesh = getCommonMesh({E, u});
if (not mesh.use_count()) {
throw NormalError("E and u are not defined on the same mesh");
}
switch (mesh->dimension()) {
case 1: {
return epsilonFromTotalEnergyU(dynamic_cast<const DiscreteFunctionP0<1, double>&>(*E),
dynamic_cast<const DiscreteFunctionP0<1, TinyVector<1, double>>&>(*u));
}
case 2: {
return epsilonFromTotalEnergyU(dynamic_cast<const DiscreteFunctionP0<2, double>&>(*E),
dynamic_cast<const DiscreteFunctionP0<2, TinyVector<2, double>>&>(*u));
}
case 3: {
return epsilonFromTotalEnergyU(dynamic_cast<const DiscreteFunctionP0<3, double>&>(*E),
dynamic_cast<const DiscreteFunctionP0<3, TinyVector<3, double>>&>(*u));
}
default: {
throw UnexpectedError("invalid mesh dimension");
}
}
}
} // namespace perfect_gas
#ifndef PERFECT_GAS_HPP
#define PERFECT_GAS_HPP
#include <scheme/IDiscreteFunction.hpp>
namespace perfect_gas
{
std::shared_ptr<IDiscreteFunction> soundSpeed(const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& p,
const std::shared_ptr<const IDiscreteFunction>& gamma);
std::shared_ptr<IDiscreteFunction> epsilonFromRhoPGamma(const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& p,
const std::shared_ptr<const IDiscreteFunction>& gamma);
std::shared_ptr<IDiscreteFunction> pFromRhoEpsilonGamma(const std::shared_ptr<const IDiscreteFunction>& rho,
const std::shared_ptr<const IDiscreteFunction>& epsilon,
const std::shared_ptr<const IDiscreteFunction>& gamma);
// This is a temporary function
// Todo: TO REMOVE
std::shared_ptr<IDiscreteFunction> totalEnergyFromEpsilonU(const std::shared_ptr<const IDiscreteFunction>& epsilon,
const std::shared_ptr<const IDiscreteFunction>& u);
// This is a temporary function
// Todo: TO REMOVE
std::shared_ptr<IDiscreteFunction> epsilonFromTotalEnergyU(const std::shared_ptr<const IDiscreteFunction>& E,
const std::shared_ptr<const IDiscreteFunction>& u);
} // namespace perfect_gas
#endif // PERFECT_GAS_HPP
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment