Hessian.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2023.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include <array>
 
#include "MeshKernel/Definitions.hpp"
#include "MeshKernel/Utilities/LinearAlgebra.hpp"
 
namespace meshkernel
{
 
    using HessianDimension = std::array<UInt, 3>;
 
    using MatrixColMajor = lin_alg::Matrix<double, Eigen::ColMajor>;
 
    class Hessian
    {
    public:
        Hessian() = default;
 
        Hessian(const UInt dim1, const UInt dim2, const UInt dim3);
 
        void resize(const UInt dim1, const UInt dim2, const UInt dim3);
 
        UInt size(const UInt dim) const;
 
        const HessianDimension& size() const;
 
        UInt get1DIndex(const UInt dim2, const UInt dim3) const;
 
        double operator()(const UInt dim1, const UInt dim2, const UInt dim3) const;
 
        double& operator()(const UInt dim1, const UInt dim2, const UInt dim3);
 
        double operator()(const UInt dim1, const UInt dim2) const;
 
        const MatrixColMajor& getMatrix(const UInt dim) const;
 
        MatrixColMajor& getMatrix(const UInt dim);
 
        void zero();
 
    private:
        std::vector<MatrixColMajor> m_hessian;
 
        HessianDimension m_dimensions{0, 0, 0};
    };
    class Hessian {…};
 
} // namespace meshkernel
 
inline meshkernel::UInt meshkernel::Hessian::size(const UInt dim) const
{
    return m_dimensions[dim];
}
inline meshkernel::UInt meshkernel::Hessian::size(const UInt dim) const {…}
 
inline const meshkernel::HessianDimension& meshkernel::Hessian::size() const
{
    return m_dimensions;
}
inline const meshkernel::HessianDimension& meshkernel::Hessian::size() const {…}
 
inline meshkernel::UInt meshkernel::Hessian::get1DIndex(const UInt dim2, const UInt dim3) const
{
    return dim2 + m_dimensions[1] * dim3;
}
inline meshkernel::UInt meshkernel::Hessian::get1DIndex(const UInt dim2, const UInt dim3) const {…}
 
inline double meshkernel::Hessian::operator()(const UInt dim1, const UInt dim2, const UInt dim3) const
{
    return m_hessian[dim1](dim2, dim3);
}
inline double meshkernel::Hessian::operator()(const UInt dim1, const UInt dim2, const UInt dim3) const {…}
 
inline double& meshkernel::Hessian::operator()(const UInt dim1, const UInt dim2, const UInt dim3)
{
    return m_hessian[dim1](dim2, dim3);
}
inline double& meshkernel::Hessian::operator()(const UInt dim1, const UInt dim2, const UInt dim3) {…}
 
inline double meshkernel::Hessian::operator()(const UInt dim1, const UInt dim2) const
{
    return m_hessian[dim1](dim2);
}
inline double meshkernel::Hessian::operator()(const UInt dim1, const UInt dim2) const {…}
 
inline const meshkernel::MatrixColMajor& meshkernel::Hessian::getMatrix(const UInt dim) const
{
    return m_hessian[dim];
}
inline const meshkernel::MatrixColMajor& meshkernel::Hessian::getMatrix(const UInt dim) const {…}
 
inline meshkernel::MatrixColMajor& meshkernel::Hessian::getMatrix(const UInt dim)
{
    return m_hessian[dim];
}
inline meshkernel::MatrixColMajor& meshkernel::Hessian::getMatrix(const UInt dim) {…}