sensitivity_builder.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors: Martin Fusseder, https://github.com/MFusseder
//                Michael Andre, https://github.com/msandre
//                Suneth Warnakulasuriya, https://github.com/sunethwarna
//
 
#pragma once
 
// System includes
#include <string>
#include <vector>
#include <unordered_map>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/model_part.h"
#include "response_functions/adjoint_response_function.h"
#include "solving_strategies/schemes/sensitivity_builder_scheme.h"
 
namespace Kratos
{
 
class KRATOS_API(KRATOS_CORE) SensitivityBuilder
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(SensitivityBuilder);
 
    template <class TDataType>
    struct SensitivityVariables
    {
        const Variable<TDataType>* pDesignVariable = nullptr;
        const Variable<TDataType>* pOutputVariable = nullptr;
 
        explicit SensitivityVariables(const std::string& rName)
        {
            KRATOS_TRY;
            const std::string output_suffix = "_SENSITIVITY";
            pDesignVariable = &KratosComponents<Variable<TDataType>>::Get(rName);
            if (rName.size() > output_suffix.size() &&
                std::equal(output_suffix.rbegin(), output_suffix.rend(), rName.rbegin()))
            {
                pOutputVariable = pDesignVariable;
            }
            else
            {
                pOutputVariable =
                    &KratosComponents<Variable<TDataType>>::Get(rName + output_suffix);
            }
            KRATOS_CATCH("");
        }
    };
 
 
    template <class TDataType>
    using THomogeneousSensitivityVariables = std::vector<SensitivityVariables<TDataType>>;
 
    using TSensitivityVariables = std::tuple<
                                        THomogeneousSensitivityVariables<double>,
                                        THomogeneousSensitivityVariables<array_1d<double, 3>>
                                        >;
 
 
    SensitivityBuilder(Parameters Settings,
                       ModelPart& rModelPart,
                       AdjointResponseFunction::Pointer pResponseFunction);
 
    SensitivityBuilder(Parameters Settings,
                       ModelPart& rModelPart,
                       AdjointResponseFunction::Pointer pResponseFunction,
                       SensitivityBuilderScheme::Pointer pSensitivityBuilderScheme);
 
 
    void SetResponseFunction(AdjointResponseFunction::Pointer pResponseFunction);
 
    void Initialize();
 
    void InitializeSolutionStep();
 
    void UpdateSensitivities();
 
    void FinalizeSolutionStep();
 
    void Finalize();
 
    void Clear();
 
    void ClearFlags();
 
    void ClearSensitivities();
 
 
    static void CalculateNodalSolutionStepSensitivities(
        const std::vector<std::string>& rVariables,
        ModelPart& rModelPart,
        AdjointResponseFunction& rResponseFunction,
        double ScalingFactor);
 
    static void CalculateNodalSolutionStepSensitivities(
        const TSensitivityVariables& rVariables,
        ModelPart& rModelPart,
        AdjointResponseFunction& rResponseFunction,
        SensitivityBuilderScheme& rSensitivityBuilderScheme,
        double ScalingFactor);
 
    static void CalculateNonHistoricalSensitivities(
        const std::vector<std::string>& rVariables,
        ModelPart::ElementsContainerType& rElements,
        AdjointResponseFunction& rResponseFunction,
        const ProcessInfo& rProcessInfo,
        double ScalingFactor);
 
    static void CalculateNonHistoricalSensitivities(
        const TSensitivityVariables& rVariables,
        ModelPart::ElementsContainerType& rElements,
        AdjointResponseFunction& rResponseFunction,
        SensitivityBuilderScheme& rSensitivityBuilderScheme,
        const ProcessInfo& rProcessInfo,
        double ScalingFactor);
 
    static void CalculateNonHistoricalSensitivities(
        const std::vector<std::string>& rVariables,
        ModelPart::ConditionsContainerType& rConditions,
        AdjointResponseFunction& rResponseFunction,
        const ProcessInfo& rProcessInfo,
        double ScalingFactor);
 
    static void CalculateNonHistoricalSensitivities(
        const TSensitivityVariables& rVariables,
        ModelPart::ConditionsContainerType& rConditions,
        AdjointResponseFunction& rResponseFunction,
        SensitivityBuilderScheme& rSensitivityBuilderScheme,
        const ProcessInfo& rProcessInfo,
        double ScalingFactor);
 
private:
 
    ModelPart* mpModelPart = nullptr;
    ModelPart* mpSensitivityModelPart = nullptr;
    AdjointResponseFunction::Pointer mpResponseFunction;
    SensitivityBuilderScheme::Pointer mpSensitivityBuilderScheme;
 
    TSensitivityVariables mNodalSolutionStepSensitivityVariablesList;
    TSensitivityVariables mElementDataValueSensitivityVariablesList;
    TSensitivityVariables mConditionDataValueSensitivityVariablesList;
 
    std::string mBuildMode = "static";
    bool mNodalSolutionStepSensitivityCalculationIsThreadSafe = false;
 
 
    static TSensitivityVariables GetVariableLists(const std::vector<std::string>& rVariableNames);
 
};
 
 
} /* namespace Kratos.*/