adjoint_response_function.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:
//
 
#ifndef ADJOINT_RESPONSE_FUNCTION_H
#define ADJOINT_RESPONSE_FUNCTION_H
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/element.h"
#include "includes/condition.h"
#include "includes/process_info.h"
#include "includes/ublas_interface.h"
#include "containers/array_1d.h"
#include "containers/variable.h"
 
 
// Application includes
 
namespace Kratos
{
 
class AdjointResponseFunction
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(AdjointResponseFunction);
 
 
    AdjointResponseFunction()
    {
    }
 
    virtual ~AdjointResponseFunction()
    {
    }
 
 
 
    virtual void Initialize()
    {
    }
 
    virtual void InitializeSolutionStep()
    {
    }
 
    virtual void FinalizeSolutionStep()
    {
    }
 
 
    virtual void CalculateGradient(const Element& rAdjointElement,
                                   const Matrix& rResidualGradient,
                                   Vector& rResponseGradient,
                                   const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculateGradient(const Condition& rAdjointCondition,
                                   const Matrix& rResidualGradient,
                                   Vector& rResponseGradient,
                                   const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculateFirstDerivativesGradient(const Element& rAdjointElement,
                                                   const Matrix& rResidualGradient,
                                                   Vector& rResponseGradient,
                                                   const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculateFirstDerivativesGradient(const Condition& rAdjointCondition,
                                                   const Matrix& rResidualGradient,
                                                   Vector& rResponseGradient,
                                                   const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculateSecondDerivativesGradient(const Element& rAdjointElement,
                                                    const Matrix& rResidualGradient,
                                                    Vector& rResponseGradient,
                                                    const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculateSecondDerivativesGradient(const Condition& rAdjointCondition,
                                                    const Matrix& rResidualGradient,
                                                    Vector& rResponseGradient,
                                                    const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculatePartialSensitivity(Element& rAdjointElement,
                                             const Variable<double>& rVariable,
                                             const Matrix& rSensitivityMatrix,
                                             Vector& rSensitivityGradient,
                                             const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculatePartialSensitivity(Condition& rAdjointCondition,
                                             const Variable<double>& rVariable,
                                             const Matrix& rSensitivityMatrix,
                                             Vector& rSensitivityGradient,
                                             const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculatePartialSensitivity(Element& rAdjointElement,
                                             const Variable<array_1d<double, 3>>& rVariable,
                                             const Matrix& rSensitivityMatrix,
                                             Vector& rSensitivityGradient,
                                             const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
 
    virtual void CalculatePartialSensitivity(Condition& rAdjointCondition,
                                             const Variable<array_1d<double, 3>>& rVariable,
                                             const Matrix& rSensitivityMatrix,
                                             Vector& rSensitivityGradient,
                                             const ProcessInfo& rProcessInfo)
    {
        KRATOS_ERROR << "Calling base class response function method.\n";
    }
 
    virtual double CalculateValue(ModelPart& rModelPart) = 0;
 
 
protected:
 
 
 
 
private:
 
 
 
};
 
 
} /* namespace Kratos.*/
 
#endif /* ADJOINT_RESPONSE_FUNCTION_H defined */