residual_based_adjoint_steady_scheme.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:
//
 
#if !defined(KRATOS_RESIDUAL_BASED_ADJOINT_STEADY_SCHEME_H_INCLUDED)
#define KRATOS_RESIDUAL_BASED_ADJOINT_STEADY_SCHEME_H_INCLUDED
 
// System includes
#include <vector>
#include <string>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "solving_strategies/schemes/residual_based_adjoint_static_scheme.h"
 
namespace Kratos
{
 
 
template <class TSparseSpace, class TDenseSpace>
class ResidualBasedAdjointSteadyScheme : public ResidualBasedAdjointStaticScheme<TSparseSpace, TDenseSpace>
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(ResidualBasedAdjointSteadyScheme);
 
    typedef ResidualBasedAdjointStaticScheme<TSparseSpace, TDenseSpace> BaseType;
 
    typedef typename BaseType::LocalSystemVectorType LocalSystemVectorType;
 
    typedef typename BaseType::LocalSystemMatrixType LocalSystemMatrixType;
 
 
    explicit ResidualBasedAdjointSteadyScheme(AdjointResponseFunction::Pointer pResponseFunction)
        : ResidualBasedAdjointStaticScheme<TSparseSpace, TDenseSpace>(pResponseFunction)
    {
    }
 
    ~ResidualBasedAdjointSteadyScheme() override
    {
    }
 
 
 
    void CalculateSystemContributions(Element& rCurrentElement,
                                      LocalSystemMatrixType& rLHS_Contribution,
                                      LocalSystemVectorType& rRHS_Contribution,
                                      Element::EquationIdVectorType& rEquationId,
                                      const ProcessInfo& rCurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        int thread_id = OpenMPUtils::ThisThread();
        const auto& r_const_elem_ref = rCurrentElement;
        rCurrentElement.CalculateFirstDerivativesLHS(rLHS_Contribution, rCurrentProcessInfo);
 
        if (rRHS_Contribution.size() != rLHS_Contribution.size1())
            rRHS_Contribution.resize(rLHS_Contribution.size1(), false);
 
        this->mpResponseFunction->CalculateFirstDerivativesGradient(
            rCurrentElement, rLHS_Contribution, rRHS_Contribution, rCurrentProcessInfo);
 
        noalias(rRHS_Contribution) = -rRHS_Contribution;
 
        // Calculate system contributions in residual form.
        r_const_elem_ref.GetFirstDerivativesVector(this->mAdjointValues[thread_id]);
        noalias(rRHS_Contribution) -= prod(rLHS_Contribution, this->mAdjointValues[thread_id]);
 
        r_const_elem_ref.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("");
    }
 
    void CalculateLHSContribution(Element& rCurrentElement,
                                  LocalSystemMatrixType& rLHS_Contribution,
                                  Element::EquationIdVectorType& rEquationId,
                                  const ProcessInfo& rCurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        rCurrentElement.CalculateFirstDerivativesLHS(rLHS_Contribution, rCurrentProcessInfo);
        rCurrentElement.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("");
    }
 
    void CalculateSystemContributions(Condition& rCurrentCondition,
                                      LocalSystemMatrixType& rLHS_Contribution,
                                      LocalSystemVectorType& rRHS_Contribution,
                                      Condition::EquationIdVectorType& rEquationId,
                                      const ProcessInfo& rCurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        int thread_id = OpenMPUtils::ThisThread();
        const auto& r_const_cond_ref = rCurrentCondition;
        rCurrentCondition.CalculateFirstDerivativesLHS(rLHS_Contribution, rCurrentProcessInfo);
 
        if (rRHS_Contribution.size() != rLHS_Contribution.size1())
            rRHS_Contribution.resize(rLHS_Contribution.size1(), false);
 
        this->mpResponseFunction->CalculateFirstDerivativesGradient(
            rCurrentCondition, rLHS_Contribution, rRHS_Contribution, rCurrentProcessInfo);
 
        noalias(rRHS_Contribution) = -rRHS_Contribution;
 
        // Calculate system contributions in residual form.
        r_const_cond_ref.GetFirstDerivativesVector(this->mAdjointValues[thread_id]);
        noalias(rRHS_Contribution) -= prod(rLHS_Contribution, this->mAdjointValues[thread_id]);
 
        r_const_cond_ref.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("");
    }
 
    void CalculateLHSContribution(Condition& rCurrentCondition,
                                  LocalSystemMatrixType& rLHS_Contribution,
                                  Condition::EquationIdVectorType& rEquationId,
                                  const ProcessInfo& rCurrentProcessInfo) override
    {
        KRATOS_TRY;
 
        rCurrentCondition.CalculateFirstDerivativesLHS(rLHS_Contribution, rCurrentProcessInfo);
        rCurrentCondition.EquationIdVector(rEquationId, rCurrentProcessInfo);
 
        KRATOS_CATCH("");
    }
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
private:
 
 
 
 
 
 
 
 
}; /* Class ResidualBasedAdjointSteadyScheme */
 
 
 
 
} /* namespace Kratos.*/
 
#endif /* KRATOS_RESIDUAL_BASED_ADJOINT_STEADY_SCHEME_H_INCLUDED defined */