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
Show whitespace changes
Inline Side-by-side
src/language/modules/SchemeModule.cpp
+ 0
− 78
View file @ f7bb98ce
...@@ -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>,
......
src/scheme/CMakeLists.txt
+ 1
− 2
View file @ f7bb98ce
...@@ -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)
src/scheme/PerfectGas.cpp deleted 100644 → 0
+ 0
− 248
View file @ 3f536824
#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
src/scheme/PerfectGas.hpp deleted 100644 → 0
+ 0
− 32
View file @ 3f536824
#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% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment