Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[GeoMechanicsApplication] Moved logic of ApplyScalarConstraintsTableProcess to C++ #11669

Merged
merged 2 commits into from
Oct 9, 2023
Merged

[GeoMechanicsApplication] Moved logic of ApplyScalarConstraintsTableProcess to C++ #11669

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
d284259
Moved logic of `ApplyScalarConstraintsTableProcess` to C++
indigocoral Oct 2, 2023
82bad65
Started to process Wijtze Pieter's review comments
avdg81 Oct 9, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
219 changes: 219 additions & 0 deletions ...tions/GeoMechanicsApplication/custom_processes/apply_scalar_constraints_table_process.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,219 @@
// KRATOS___
// // ) )
// // ___ ___
// // ____ //___) ) // ) )
// // / / // // / /
// ((____/ / ((____ ((___/ / MECHANICS
//
// License: geo_mechanics_application/license.txt
//
// Main authors: Anne van de Graaf,
// Marjan Fathian
//
#include "apply_scalar_constraints_table_process.h"
#include "includes/model_part.h"
#include "includes/kratos_parameters.h"
#include "apply_component_table_process.hpp"
#include "processes/apply_constant_scalarvalue_process.h"
#include "apply_hydrostatic_pressure_table_process.hpp"
#include "apply_constant_phreatic_line_pressure_process.hpp"
#include "apply_phreatic_line_pressure_table_process.hpp"
#include "apply_constant_interpolate_line_pressure_process.hpp"
#include "apply_constant_phreatic_surface_pressure_process.hpp"
#include "apply_phreatic_surface_pressure_table_process.hpp"

namespace
{

using namespace Kratos;

Parameters ExtractParameters(const Parameters& rSourceParameters,
const std::vector<std::string>& rNamesOfParametersToCopy)
{
auto result = Parameters{};
result.CopyValuesFromExistingParameters(rSourceParameters, rNamesOfParametersToCopy);
return result;
}

void AppendParameterNameIfExists(const std::string& rParameterName,
const Parameters& rSourceParameters,
std::vector<std::string>& rResult)
{
if (rSourceParameters.Has(rParameterName)) {
rResult.emplace_back(rParameterName);
}
}

bool HasTableAttached(const Parameters& rSettings)
{
if (rSettings["table"].IsNumber()) {
return rSettings["table"].GetInt() != 0;
}

KRATOS_ERROR_IF_NOT(rSettings["table"].IsArray()) << "'table' is neither a single number nor an array of numbers";

const auto& table = rSettings["table"];
return std::any_of(table.begin(), table.end(),
[](const auto& value){return value.GetInt() != 0;});
}

}

namespace Kratos
{

ApplyScalarConstraintsTableProcess::ApplyScalarConstraintsTableProcess(ModelPart& rModelPart,
const Parameters& rProcessSettings)
: Process(Flags()),
mrModelPart{rModelPart}
{
MakeInternalProcess(rProcessSettings);
}

ApplyScalarConstraintsTableProcess::~ApplyScalarConstraintsTableProcess() = default;

void ApplyScalarConstraintsTableProcess::MakeInternalProcess(const Parameters& rProcessSettings)
{
auto names_of_settings_to_copy = std::vector<std::string>{"model_part_name",
"variable_name"};
AppendParameterNameIfExists("is_fixed", rProcessSettings, names_of_settings_to_copy);

if (rProcessSettings.Has("fluid_pressure_type")) {
MakeProcessForFluidPressureType(rProcessSettings, std::move(names_of_settings_to_copy));
avdg81 marked this conversation as resolved.
Show resolved Hide resolved
}
else {
MakeScalarConstraintsProcess(rProcessSettings, std::move(names_of_settings_to_copy));
}
}

void ApplyScalarConstraintsTableProcess::MakeProcessForFluidPressureType(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy)
{
const auto fluid_pressure_type = rProcessSettings["fluid_pressure_type"].GetString();
if (fluid_pressure_type == "Uniform") {
MakeScalarConstraintsProcess(rProcessSettings, std::move(NamesOfSettingsToCopy));
} else if (fluid_pressure_type == "Hydrostatic") {
MakeProcessForHydrostaticFluidPressure(rProcessSettings, std::move(NamesOfSettingsToCopy));
} else if (fluid_pressure_type == "Phreatic_Line") {
MakeProcessForPhreaticLine(rProcessSettings, std::move(NamesOfSettingsToCopy));
} else if (fluid_pressure_type == "Interpolate_Line") {
MakeProcessForInterpolatedLine(rProcessSettings, std::move(NamesOfSettingsToCopy));
} else if (fluid_pressure_type == "Phreatic_Surface") {
MakeProcessForPhreaticSurface(rProcessSettings, std::move(NamesOfSettingsToCopy));
} else {
KRATOS_ERROR << "Unknown fluid_pressure_type: " << fluid_pressure_type << std::endl;
}
}

void ApplyScalarConstraintsTableProcess::MakeScalarConstraintsProcess(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy)
{
NamesOfSettingsToCopy.emplace_back("value");

if (HasTableAttached(rProcessSettings)) {
NamesOfSettingsToCopy.emplace_back("table");
mProcess = std::make_unique<ApplyComponentTableProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
} else {
mProcess = std::make_unique<ApplyConstantScalarValueProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
}
}

void ApplyScalarConstraintsTableProcess::MakeProcessForHydrostaticFluidPressure(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy)
{
NamesOfSettingsToCopy.insert(NamesOfSettingsToCopy.end(), {"gravity_direction",
"reference_coordinate",
"specific_weight"});
AppendParameterNameIfExists("pressure_tension_cut_off", rProcessSettings, NamesOfSettingsToCopy);
AppendParameterNameIfExists("is_seepage", rProcessSettings, NamesOfSettingsToCopy);

if (HasTableAttached(rProcessSettings)) {
NamesOfSettingsToCopy.emplace_back("table");
mProcess = std::make_unique<ApplyHydrostaticPressureTableProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
} else {
mProcess = std::make_unique<ApplyConstantHydrostaticPressureProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
}
}

void ApplyScalarConstraintsTableProcess::MakeProcessForPhreaticLine(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy)
{
NamesOfSettingsToCopy.insert(NamesOfSettingsToCopy.end(), {"gravity_direction",
"out_of_plane_direction",
"first_reference_coordinate",
"second_reference_coordinate",
"specific_weight"});
AppendParameterNameIfExists("pressure_tension_cut_off", rProcessSettings, NamesOfSettingsToCopy);
AppendParameterNameIfExists("is_seepage", rProcessSettings, NamesOfSettingsToCopy);

if (HasTableAttached(rProcessSettings)) {
NamesOfSettingsToCopy.emplace_back("table");
mProcess = std::make_unique<ApplyPhreaticLinePressureTableProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
} else {
mProcess = std::make_unique<ApplyConstantPhreaticLinePressureProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
}
}

void ApplyScalarConstraintsTableProcess::MakeProcessForPhreaticSurface(const Parameters& rProcessSettings,
avdg81 marked this conversation as resolved.
Show resolved Hide resolved
std::vector<std::string> NamesOfSettingsToCopy)
{
NamesOfSettingsToCopy.insert(NamesOfSettingsToCopy.end(), {"gravity_direction",
"first_reference_coordinate",
"second_reference_coordinate",
"third_reference_coordinate",
"specific_weight"});
AppendParameterNameIfExists("pressure_tension_cut_off", rProcessSettings, NamesOfSettingsToCopy);
AppendParameterNameIfExists("is_seepage", rProcessSettings, NamesOfSettingsToCopy);

if (HasTableAttached(rProcessSettings)) {
NamesOfSettingsToCopy.emplace_back("table");
mProcess = std::make_unique<ApplyPhreaticSurfacePressureTableProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
}
else {
mProcess = std::make_unique<ApplyConstantPhreaticSurfacePressureProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));
}
}

void ApplyScalarConstraintsTableProcess::MakeProcessForInterpolatedLine(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy)
{
KRATOS_ERROR_IF(HasTableAttached(rProcessSettings)) << "No time dependent interpolate line pressure process available" << std::endl;

NamesOfSettingsToCopy.insert(NamesOfSettingsToCopy.end(), {"gravity_direction",
"out_of_plane_direction"});
AppendParameterNameIfExists("pressure_tension_cut_off", rProcessSettings, NamesOfSettingsToCopy);
AppendParameterNameIfExists("is_seepage", rProcessSettings, NamesOfSettingsToCopy);

mProcess = std::make_unique<ApplyConstantInterpolateLinePressureProcess>(mrModelPart,
ExtractParameters(rProcessSettings,
NamesOfSettingsToCopy));

}

void ApplyScalarConstraintsTableProcess::ExecuteInitialize()
{
mProcess->ExecuteInitialize();
}

void ApplyScalarConstraintsTableProcess::ExecuteInitializeSolutionStep()
{
mProcess->ExecuteInitializeSolutionStep();
}

}
61 changes: 61 additions & 0 deletions ...cations/GeoMechanicsApplication/custom_processes/apply_scalar_constraints_table_process.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,61 @@
// KRATOS___
// // ) )
// // ___ ___
// // ____ //___) ) // ) )
// // / / // // / /
// ((____/ / ((____ ((___/ / MECHANICS
//
// License: geo_mechanics_application/license.txt
//
// Main authors: Anne van de Graaf,
// Marjan Fathian
//
#pragma once

#include "processes/process.h"
avdg81 marked this conversation as resolved.
Show resolved Hide resolved

namespace Kratos
{

class ModelPart;
class Parameters;


class KRATOS_API(GEO_MECHANICS_APPLICATION) ApplyScalarConstraintsTableProcess : public Process
{
public:
KRATOS_CLASS_POINTER_DEFINITION(ApplyScalarConstraintsTableProcess);

ApplyScalarConstraintsTableProcess(ModelPart& rModelPart,
const Parameters& rProcessSettings);

~ApplyScalarConstraintsTableProcess() override;

ApplyScalarConstraintsTableProcess(const ApplyScalarConstraintsTableProcess&) = delete;
ApplyScalarConstraintsTableProcess& operator=(const ApplyScalarConstraintsTableProcess&) = delete;

using ProcessUniquePointer = std::unique_ptr<Process>;

void ExecuteInitialize() override;
void ExecuteInitializeSolutionStep() override;

private:
void MakeInternalProcess(const Parameters& rProcessSettings);
void MakeProcessForFluidPressureType(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy);
void MakeScalarConstraintsProcess(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy);
void MakeProcessForHydrostaticFluidPressure(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy);
void MakeProcessForPhreaticLine(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy);
void MakeProcessForPhreaticSurface(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy);
void MakeProcessForInterpolatedLine(const Parameters& rProcessSettings,
std::vector<std::string> NamesOfSettingsToCopy);

ModelPart& mrModelPart;
ProcessUniquePointer mProcess;
};

}
5 changes: 5 additions & 0 deletions applications/GeoMechanicsApplication/custom_python/add_custom_processes_to_python.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -42,6 +42,7 @@
#include "custom_processes/set_parameter_field_process.hpp"
#include "custom_processes/set_multiple_moving_loads.h"
#include "custom_processes/apply_vector_constraints_table_process.hpp"
#include "custom_processes/apply_scalar_constraints_table_process.h"

namespace Kratos {
namespace Python {
Expand Down Expand Up @@ -141,6 +142,10 @@ void AddCustomProcessesToPython(pybind11::module& m)
py::class_<ApplyVectorConstraintsTableProcess, ApplyVectorConstraintsTableProcess::Pointer, Process>
(m, "ApplyVectorConstraintsTableProcess")
.def(py::init<ModelPart&, const Parameters&>());

py::class_<ApplyScalarConstraintsTableProcess, ApplyScalarConstraintsTableProcess::Pointer, Process>
(m, "ApplyScalarConstraintsTableProcess")
.def(py::init<ModelPart&, const Parameters&>());
}

} // Namespace Python.
Expand Down
11 changes: 10 additions & 1 deletion applications/GeoMechanicsApplication/custom_workflows/dgeosettlement.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,7 @@

#include "utilities/variable_utils.h"

#include "custom_processes/apply_scalar_constraints_table_process.h"
#include "custom_processes/apply_vector_constraints_table_process.hpp"
#include "custom_processes/set_parameter_field_process.hpp"
#include "custom_processes/apply_k0_procedure_process.hpp"
Expand Down Expand Up @@ -47,7 +48,15 @@ KratosGeoSettlement::KratosGeoSettlement(std::unique_ptr<InputUtility> pInputUti
InitializeProcessFactory();
}

void KratosGeoSettlement::InitializeProcessFactory() {
void KratosGeoSettlement::InitializeProcessFactory()
{
mProcessFactory->AddCreator("ApplyScalarConstraintsTableProcess",
[this](const Parameters& rParameters)
{
return std::make_unique<ApplyScalarConstraintsTableProcess>(mModel.GetModelPart(mModelPartName),
rParameters);
});

mProcessFactory->AddCreator("ApplyVectorConstraintsTableProcess",
[this](const Parameters& rParameters)
{
Expand Down
Loading
Loading