fluid_adjoint_slip_utilities.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Suneth Warnakulasuriya
//
 
#if !defined(KRATOS_FLUID_ADJOINT_SLIP_UTILITIES_H)
#define KRATOS_FLUID_ADJOINT_SLIP_UTILITIES_H
 
// System includes
 
// External includes
 
// Project includes
#include "geometries/geometry.h"
#include "includes/node.h"
#include "includes/ublas_interface.h"
#include "utilities/coordinate_transformation_utilities.h"
 
// Application includes
#include "custom_utilities/fluid_calculation_utilities.h"
 
 
namespace Kratos
{
 
 
class KRATOS_API(FLUID_DYNAMICS_APPLICATION) FluidAdjointSlipUtilities
{
public:
 
    using NodeType = Node;
 
    using IndexType = std::size_t;
 
    using GeometryType = Geometry<NodeType>;
 
    using CoordinateTransformationUtilities = CoordinateTransformationUtils<Matrix, Vector, double>;
 
 
    FluidAdjointSlipUtilities(
        const IndexType Dimension,
        const IndexType BlockSize);
 
 
    void CalculateRotatedSlipConditionAppliedSlipVariableDerivatives(
        Matrix& rOutput,
        const Matrix& rResidualDerivatives,
        const GeometryType& rGeometry) const;
 
    void CalculateRotatedSlipConditionAppliedNonSlipVariableDerivatives(
        Matrix& rOutput,
        const Matrix& rResidualDerivatives,
        const GeometryType& rGeometry) const;
 
    void AddNodalRotationDerivatives(
        Matrix& rOutput,
        const Matrix& rResidualDerivatives,
        const IndexType NodeStartIndex,
        const NodeType& rNode) const
    {
        (this->*(this->mAddNodalRotationDerivativesMethod))(rOutput, rResidualDerivatives, NodeStartIndex, rNode);
    }
 
    void AddNodalApplySlipConditionDerivatives(
        Matrix& rOutput,
        const IndexType NodeStartIndex,
        const NodeType& rNode) const;
 
    void AddNodalResidualDerivatives(
        Matrix& rOutput,
        const Matrix& rResidualDerivatives,
        const IndexType NodeStartIndex) const;
 
    void ClearNodalResidualDerivatives(
        Matrix& rOutput,
        const IndexType ResidualIndex) const;
 
private:
 
    const IndexType mDimension;
    const IndexType mBlockSize;
 
    const CoordinateTransformationUtilities mRotationTool;
 
    void (FluidAdjointSlipUtilities::*mAddNodalRotationDerivativesMethod)(
        Matrix&,
        const Matrix&,
        const IndexType,
        const NodeType&) const;
 
 
    template<unsigned int TDim>
    void TemplatedAddNodalRotationDerivatives(
        Matrix& rOutput,
        const Matrix& rResidualDerivatives,
        const IndexType NodeStartIndex,
        const NodeType& rNode) const
    {
        KRATOS_TRY
 
        BoundedVector<double, TDim> residual_derivative, aux_vector;
        BoundedMatrix<double, TDim, TDim> rotation_matrix;
        mRotationTool.LocalRotationOperatorPure(rotation_matrix, rNode);
 
        // add rotated residual derivative contributions
        for (IndexType c = 0; c < rResidualDerivatives.size1(); ++c) {
            // get the residual derivative relevant for node
            FluidCalculationUtilities::ReadSubVector<TDim>(
                residual_derivative, row(rResidualDerivatives, c), NodeStartIndex);
 
            // rotate residual derivative
            noalias(aux_vector) = prod(rotation_matrix, residual_derivative);
 
            // add rotated residual derivative to local matrix
            FluidCalculationUtilities::AddSubVector<TDim>(rOutput, aux_vector, c, NodeStartIndex);
 
            // add rest of the equation derivatives
            for (IndexType a = TDim; a < mBlockSize; ++a) {
                rOutput(c, NodeStartIndex + a) += rResidualDerivatives(c, NodeStartIndex + a);
            }
        }
 
        KRATOS_CATCH("");
    }
 
};
 
 
 
} // namespace Kratos
 
#endif // KRATOS_FLUID_ADJOINT_SLIP_UTILITIES_H