Skip to content
Snippets Groups Projects
Commit 8e970553 authored by Tom Fischer's avatar Tom Fischer
Browse files

[PL/LiquidFlow] Rm. unused material data structures.

parent 4baba5f1
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
ProcessLib/LiquidFlow/CreateLiquidFlowMaterialProperties.cpp deleted 100644 → 0
+ 0
− 106
View file @ 4baba5f1
/**
* \copyright
* Copyright (c) 2012-2020, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
* \file
*
* Created on December 14, 2016, 1:20 PM
*/
#include "CreateLiquidFlowMaterialProperties.h"
#include "BaseLib/Algorithm.h"
#include "BaseLib/ConfigTree.h"
#include "MaterialLib/Fluid/FluidProperties/CreateFluidProperties.h"
#include "MaterialLib/Fluid/FluidProperty.h"
#include "MaterialLib/Fluid/FluidPropertyHeaders.h"
#include "MaterialLib/PorousMedium/Permeability/Permeability.h"
#include "MaterialLib/PorousMedium/Porosity/Porosity.h"
#include "MaterialLib/PorousMedium/PorousPropertyHeaders.h"
#include "MaterialLib/PorousMedium/Storage/Storage.h"
#include "MeshLib/PropertyVector.h"
#include "LiquidFlowMaterialProperties.h"
namespace ParameterLib
{
struct ParameterBase;
}
namespace ProcessLib
{
namespace LiquidFlow
{
class LiquidFlowMaterialProperties;
std::unique_ptr<LiquidFlowMaterialProperties>
createLiquidFlowMaterialProperties(
BaseLib::ConfigTree const& config,
std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
MeshLib::PropertyVector<int> const* const material_ids)
{
DBUG("Reading material properties of liquid flow process.");
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__fluid}
// auto const& fluid_config = config.getConfigSubtree("fluid");
// auto fluid_properties =
// MaterialLib::Fluid::createFluidProperties(fluid_config);
// Get porous properties
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>
intrinsic_permeability_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>
porosity_models;
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
storage_models;
std::vector<int> mat_ids;
auto const& porous_medium_configs =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium}
config.getConfigSubtree("porous_medium");
for (
auto const& porous_medium_config :
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium}
porous_medium_configs.getConfigSubtreeList("porous_medium"))
{
//! \ogs_file_attr{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__id}
auto const id = porous_medium_config.getConfigAttribute<int>("id");
mat_ids.push_back(id);
auto const& permeability_config =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__permeability}
porous_medium_config.getConfigSubtree("permeability");
intrinsic_permeability_models.emplace_back(
MaterialLib::PorousMedium::createPermeabilityModel(
permeability_config, parameters));
auto const& porosity_config =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__porosity}
porous_medium_config.getConfigSubtree("porosity");
auto n = MaterialLib::PorousMedium::createPorosityModel(porosity_config,
parameters);
porosity_models.emplace_back(std::move(n));
auto const& storage_config =
//! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property__porous_medium__porous_medium__storage}
porous_medium_config.getConfigSubtree("storage");
auto beta =
MaterialLib::PorousMedium::createStorageModel(storage_config);
storage_models.emplace_back(std::move(beta));
}
BaseLib::reorderVector(intrinsic_permeability_models, mat_ids);
BaseLib::reorderVector(porosity_models, mat_ids);
BaseLib::reorderVector(storage_models, mat_ids);
return std::make_unique<LiquidFlowMaterialProperties>(
//std::move(fluid_properties),
std::move(intrinsic_permeability_models),
std::move(porosity_models), std::move(storage_models), material_ids);
}
} // namespace LiquidFlow
} // namespace ProcessLib
ProcessLib/LiquidFlow/CreateLiquidFlowMaterialProperties.h deleted 100644 → 0
+ 0
− 51
View file @ 4baba5f1
/**
* \copyright
* Copyright (c) 2012-2020, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
* \file
*
* Created on December 14, 2016, 1:20 PM
*/
#pragma once
#include <memory>
#include <vector>
namespace BaseLib
{
class ConfigTree;
}
namespace MeshLib
{
template <typename PROP_VAL_TYPE>
class PropertyVector;
}
namespace ParameterLib
{
struct ParameterBase;
}
namespace ProcessLib::LiquidFlow
{
class LiquidFlowMaterialProperties;
/**
* Parse the XML input for fluid properties of a single phase and create an
* instance of class LiquidFlowMaterialProperties.
*
* The XML syntax example is given in an unit test in
* Tests/Process/LiquidFlow/TestLiquidFlowMaterialProperties.cpp
*/
std::unique_ptr<LiquidFlowMaterialProperties>
createLiquidFlowMaterialProperties(
BaseLib::ConfigTree const& config,
std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
MeshLib::PropertyVector<int> const* const material_ids);
} // namespace ProcessLib::LiquidFlow
ProcessLib/LiquidFlow/LiquidFlowMaterialProperties.cpp deleted 100644 → 0
+ 0
− 104
View file @ 4baba5f1
/**
* \copyright
* Copyright (c) 2012-2020, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
* \file
*
* Created on August 18, 2016, 11:49 AM
*/
#include "LiquidFlowMaterialProperties.h"
#include <logog/include/logog.hpp>
#include "MeshLib/PropertyVector.h"
#include "ParameterLib/SpatialPosition.h"
#include "MaterialLib/PorousMedium/Permeability/Permeability.h"
#include "MaterialLib/PorousMedium/Porosity/Porosity.h"
#include "MaterialLib/PorousMedium/Storage/Storage.h"
#include "MaterialLib/Fluid/FluidPropertyHeaders.h"
#include "MaterialLib/PorousMedium/PorousPropertyHeaders.h"
namespace ProcessLib
{
namespace LiquidFlow
{
int LiquidFlowMaterialProperties::getMaterialID(
const ParameterLib::SpatialPosition& pos) const
{
if (!_material_ids)
{
return 0;
}
assert(pos.getElementID().get() < _material_ids->size());
return (*_material_ids)[pos.getElementID().get()];
}
/*
double LiquidFlowMaterialProperties::getLiquidDensity(const double p,
const double T) const
{
ArrayType vars;
vars[static_cast<int>(MaterialLib::Fluid::PropertyVariableType::T)] = T;
vars[static_cast<int>(MaterialLib::Fluid::PropertyVariableType::p)] = p;
return _fluid_properties->getValue(
MaterialLib::Fluid::FluidPropertyType::Density, vars);
}
double LiquidFlowMaterialProperties::getViscosity(const double p,
const double T) const
{
ArrayType vars;
vars[static_cast<int>(MaterialLib::Fluid::PropertyVariableType::T)] = T;
vars[static_cast<int>(MaterialLib::Fluid::PropertyVariableType::p)] = p;
return _fluid_properties->getValue(
MaterialLib::Fluid::FluidPropertyType::Viscosity, vars);
}
*/
double LiquidFlowMaterialProperties::getPorosity(
const int material_id,
const double t,
const ParameterLib::SpatialPosition& pos,
const double porosity_variable,
const double T) const
{
return _porosity_models[material_id]->getValue(t, pos, porosity_variable,
T);
}
double LiquidFlowMaterialProperties::getMassCoefficient(
const int material_id, const double t,
const ParameterLib::SpatialPosition& pos, const double p, const double T,
const double porosity_variable, const double storage_variable,
double const density, double const ddensity_dpressure) const
{
ArrayType vars;
vars[static_cast<int>(MaterialLib::Fluid::PropertyVariableType::T)] = T;
vars[static_cast<int>(MaterialLib::Fluid::PropertyVariableType::p)] = p;
const double porosity =
_porosity_models[material_id]->getValue(t, pos, porosity_variable, T);
const double storage =
_storage_models[material_id]->getValue(storage_variable);
return porosity * ddensity_dpressure / density + storage;
}
Eigen::MatrixXd LiquidFlowMaterialProperties::getPermeability(
const int material_id, const double t,
const ParameterLib::SpatialPosition& pos, const int /*dim*/, double const p,
double const T) const
{
return _intrinsic_permeability_models[material_id]->getValue(t, pos, p, T);
}
} // namespace LiquidFlow
} // namespace ProcessLib
ProcessLib/LiquidFlow/LiquidFlowMaterialProperties.h deleted 100644 → 0
+ 0
− 126
View file @ 4baba5f1
/**
* \copyright
* Copyright (c) 2012-2020, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
* \file
*
* Created on August 18, 2016, 11:03 AM
*/
#pragma once
#include <memory>
#include <Eigen/Dense>
#include <vector>
#include "MaterialLib/Fluid/FluidProperty.h"
#include "MaterialLib/Fluid/FluidProperties/FluidProperties.h"
#include "MaterialLib/PorousMedium/Permeability/Permeability.h"
#include "MaterialLib/PorousMedium/Porosity/Porosity.h"
#include "MaterialLib/PorousMedium/Storage/Storage.h"
namespace BaseLib
{
class ConfigTree;
}
namespace MeshLib
{
template <typename PROP_VAL_TYPE>
class PropertyVector;
}
namespace ProcessLib::LiquidFlow
{
/** This class has a collection of material properties of liquid flow process
* and it provides the computation of the coefficients of the PDE of liquid
* flow process.
*/
class LiquidFlowMaterialProperties
{
public:
using ArrayType = MaterialLib::Fluid::FluidProperty::ArrayType;
LiquidFlowMaterialProperties(
// std::unique_ptr<MaterialLib::Fluid::FluidProperties>&& fluid_properties,
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>&&
intrinsic_permeability_models,
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>&&
porosity_models,
std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>&&
storage_models,
MeshLib::PropertyVector<int> const* const material_ids)
: _material_ids(material_ids),
// _fluid_properties(std::move(fluid_properties)),
_intrinsic_permeability_models(
std::move(intrinsic_permeability_models)),
_porosity_models(std::move(porosity_models)),
_storage_models(std::move(storage_models))
{
}
int getMaterialID(const ParameterLib::SpatialPosition& pos) const;
/**
* \brief Compute the coefficient of the mass term by
* \f[
* n \frac{partial \rho_l}{\partial p} + \beta_s
* \f]
* where \f$n\f$ is the porosity, \f$rho_l\f$ is the liquid density,
* \f$bata_s\f$ is the storage.
* \param material_id Material index.
* \param t Time.
* \param pos Position of element.
* \param p Pressure value.
* \param T Temperature value.
* \param porosity_variable The first variable for porosity model, and it
* passes a double type value that could be
* saturation, and invariant of stress or strain.
* \param storage_variable Variable for storage model.
*/
double getMassCoefficient(const int material_id, const double t,
const ParameterLib::SpatialPosition& pos,
const double p, const double T,
const double porosity_variable,
const double storage_variable,
double const density,
double const ddensity_dpressure) const;
Eigen::MatrixXd getPermeability(const int material_id, const double t,
const ParameterLib::SpatialPosition& pos,
const int dim, const double p,
const double T) const;
// double getLiquidDensity(const double p, const double T) const;
// double getViscosity(const double p, const double T) const;
double getPorosity(const int material_id, const double t,
const ParameterLib::SpatialPosition& pos,
const double porosity_variable, const double T) const;
private:
/** Use porous medium models for different material zones.
* Material IDs must be given as mesh element properties.
*/
MeshLib::PropertyVector<int> const* const _material_ids;
// const std::unique_ptr<MaterialLib::Fluid::FluidProperties>
// _fluid_properties;
const std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>
_intrinsic_permeability_models;
const std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>
_porosity_models;
const std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
_storage_models;
// Note: For the statistical data of porous media, they could be read from
// vtu files directly. This can be done by using property vectors directly.
// Such property vectors will be added here if they are needed.
};
} // namespace ProcessLib::LiquidFlow
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment