NURBS3DVolume.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2007-2023 PCOpt/NTUA
    Copyright (C) 2013-2023 FOSS GP
    Copyright (C) 2019-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM 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, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM 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 OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Class
    Foam::NURBS3DVolume

Description
    NURBS3DVolume morpher. Includes support functions for gradient computations
    Base class providing support for different coordinate systems

    Reference:
    \verbatim
        For a short introduction to a volumetric B-Splines morpher and its use
        in shape optimisation

            Papoutsis-Kiachagias, E., Magoulas, N., Mueller, J.,
            Othmer, C., & Giannakoglou, K. (2015).
            Noise reduction in car aerodynamics using a surrogate objective
            function and the continuous adjoint method with wall functions.
            Computers & Fluids, 122, 223-232.
            http://doi.org/10.1016/j.compfluid.2015.09.002
    \endverbatim

SourceFiles
    NURBS3DVolume.C
    NURBS3DVolumeI.H

\*---------------------------------------------------------------------------*/

#ifndef NURBS3DVolume_H
#define NURBS3DVolume_H

#include "NURBSbasis.H"
#include "boolVector.H"
#include "localIOdictionary.H"
#include "pointMesh.H"
#include "pointPatchField.H"
#include "pointPatchFieldsFwd.H"
#include "boundaryFieldsFwd.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
                        Class NURBS3DVolume Declaration
\*---------------------------------------------------------------------------*/

class NURBS3DVolume
:
    public localIOdictionary
{
protected:

    // Protected Data

        typedef List<boolVector> boolVectorList;

        const fvMesh& mesh_;
        dictionary dict_;
        word name_;
        //- NURBS basis functions
        NURBSbasis basisU_;
        NURBSbasis basisV_;
        NURBSbasis basisW_;

        //- Max iterations for Newton-Raphson
        label maxIter_;

        //- Tolerance for Newton-Raphson
        scalar tolerance_;

        //- How many times to bound parametric coordinates until deciding it is
        //- outside the box
        label nMaxBound_;

        //- The volumetric B-Splines control points
        vectorField cps_;

        //- Map of points-in-box to mesh points
        autoPtr<labelList> mapPtr_;

        //- Map of mesh points to points-in-box
        //  Return -1 if point not within the box
        autoPtr<labelList> reverseMapPtr_;

        //- Parametric coordinates of pointsInBox
        autoPtr<pointVectorField> parametricCoordinatesPtr_;

        //- Coordinates in the local system for which CPs are defined
        vectorField localSystemCoordinates_;

        //- Confine movement in certain directions and control points. Refers
        //- to the local system
        label confineUMovement_;

        label confineVMovement_;

        label confineWMovement_;

        label confineBoundaryControlPoints_;

        //- Which movement components to freeze in each plane
        boolVectorList confineUMinCPs_;

        boolVectorList confineUMaxCPs_;

        boolVectorList confineVMinCPs_;

        boolVectorList confineVMaxCPs_;

        boolVectorList confineWMinCPs_;

        boolVectorList confineWMaxCPs_;

        //- Which of the cps are moved in an optimisation
        boolList activeControlPoints_;

        //- Which design variables are changed in an optimisation
        boolList activeDesignVariables_;

        //- Folder to store control points
        string cpsFolder_;

        //- Read parametric coordinates from file if present in the folder
        bool readStoredData_;


    // Protected Member Functions

        //- Find points within control points box
        void findPointsInBox(const vectorField& meshPoints);

        //- Compute parametric coordinates in order to match a given set
        //- of coordinates, based on the cps of the class
        // Uses a Newton-Raphson loop.
        // Argument is the points residing in the box
        void computeParametricCoordinates(const vectorField& points);

        void computeParametricCoordinates(tmp<vectorField> tPoints);

        //- Bound components to certain limits
        bool bound
        (
            vector& vec,
            scalar minValue = 1e-7,
            scalar maxValue = 0.999999
        ) const;

        //- Create lists with active design variables and control points
        void determineActiveDesignVariablesAndPoints();

        //- Confine movement in boundary control points if necessary
        void confineBoundaryControlPoints();

        //- Confine control point movement to maintain user-defined continuity
        void continuityRealatedConfinement();

        //- Confine movement in all control points for user-defined directions
        void confineControlPointsDirections();

        //- Deactivate control points if they affect no mesh point
        void confineInertControlPoints();

        //- Confine all three movements for a prescribed control point
        void confineControlPoint(const label cpI);

        //- Confine specific movements for a prescribed control point
        void confineControlPoint(const label cpI, const boolVector&);

        //- Create folders to store cps and derivatives
        void makeFolders();

        //- Transform a point from its coordinate system to a cartesian system
        virtual vector transformPointToCartesian
        (
            const vector& localCoordinates
        ) const = 0;

        //- Transformation tensor for dxdb, from local coordinate system to
        //- cartesian
        virtual tensor transformationTensorDxDb(label globalPointIndex) = 0;

        //- Update coordinates in the local system based on the cartesian points
        virtual void updateLocalCoordinateSystem
        (
            const vectorField& cartesianPoints
        ) = 0;


public:

    //- Runtime type information
    TypeName("NURBS3DVolume");


    // Declare run-time constructor selection table

        declareRunTimeSelectionTable
        (
            autoPtr,
            NURBS3DVolume,
            dictionary,
            (
                const dictionary& dict,
                const fvMesh& mesh,
                bool computeParamCoors
            ),
            (dict, mesh, computeParamCoors)
        );

    // Constructors

        //- Construct from dictionary
        NURBS3DVolume
        (
            const dictionary& dict,
            const fvMesh& mesh,
            bool computeParamCoors = true
        );

        //- Construct as copy
        NURBS3DVolume(const NURBS3DVolume&);


    // Selectors

        //- Return a reference to the selected NURBS model
        static autoPtr<NURBS3DVolume> New
        (
            const dictionary& dict,
            const fvMesh& mesh,
            bool computeParamCoors = true
        );


    //- Destructor
    virtual ~NURBS3DVolume() = default;


    // Member Functions

        //- Compute parametric coordinates for a given set of points
        //  (not necessarily the mesh ones)
        tmp<vectorField> computeParametricCoordinates
        (
            const vectorField& points
        ) const;

        // Derivatives wrt parametric coordinates

            //- Volume point derivative wrt u at point u,v,w
            vector volumeDerivativeU
            (
                const scalar u,
                const scalar v,
                const scalar w
            ) const;

            //- Volume point derivative wrt v at point u,v,w
            vector volumeDerivativeV
            (
                const scalar u,
                const scalar v,
                const scalar w
            ) const;

            //- Volume point derivative wrt w at point u,v,w
            vector volumeDerivativeW
            (
                const scalar u,
                const scalar v,
                const scalar w
            ) const;

            //- Jacobian matrix wrt to the volume parametric coordinates
            tensor JacobianUVW(const vector& u) const;


        // Derivatives wrt to control points

            //- Volume point derivative wrt to control point cpI at point u,v,w
            //  Scalar since in the local system!
            scalar volumeDerivativeCP(const vector& u, const label cpI) const;

            //- Control point sensitivities computed using point-based surface
            //- sensitivities
            vectorField computeControlPointSensitivities
            (
                const pointVectorField& pointSens,
                const labelList& sensitivityPatchIDs
            );

            //- Control point sensitivities computed using face-based surface
            //- sensitivities
            vectorField computeControlPointSensitivities
            (
                const volVectorField& faceSens,
                const labelList& sensitivityPatchIDs
            );

            //- Control point sensitivities computed using face-based surface
            //- sensitivities
            vectorField computeControlPointSensitivities
            (
                const boundaryVectorField& faceSens,
                const labelList& sensitivityPatchIDs
            );

            //- Control point sensitivities computed using face-based surface
            //- sensitivities
            vector computeControlPointSensitivities
            (
                const vectorField& faceSens,
                const label patchI,
                const label cpI
            );

            //- Part of control point sensitivities related to the face normal
            //- variations
            tmp<tensorField> dndbBasedSensitivities
            (
                const label patchI,
                const label cpI,
                bool DimensionedNormalSens = true
            );

            //- Get patch dx/db
            tmp<tensorField> patchDxDb
            (
                const label patchI,
                const label cpI
            );

            //- Get patch dx/db
            tmp<tensorField> patchDxDbFace
            (
                const label patchI,
                const label cpI
            );


        // Cartesian coordinates

            //- Compute cartesian coordinates based on control points
            //- and parametric coordinates
            tmp<vectorField> coordinates(const vectorField& uVector) const;

            //- The same, for a specific point
            vector coordinates(const vector& uVector) const;

            //- Mesh movement based on given control point movement
            tmp<vectorField> computeNewPoints
            (
                const vectorField& controlPointsMovement
            );

            //- Boundary mesh movement based on given control point movement
            tmp<vectorField> computeNewBoundaryPoints
            (
                const vectorField& controlPointsMovement,
                const labelList& patchesToBeMoved,
                const bool moveCPs = true
            );


        // Control points management

            //- Get control point ID from its I-J-K coordinates
            label getCPID(const label i, const label j, const label k) const;

            //- Get I-J-K coordinates from control point ID
            void getIJK(label& i, label& j, label& k, const label cpID) const;

            //- Set new control points
            //  New values should be on the coordinates system original CPs
            //  were defined
            void setControlPoints(const vectorField& newCps);


            //- Bound control points movement in the boundary control points
            //- and in certain directions if needed
            void boundControlPointMovement
            (
                vectorField& controlPointsMovement
            ) const;

            //- Compute max. displacement at the boundary
            scalar computeMaxBoundaryDisplacement
            (
                const vectorField& controlPointsMovement,
                const labelList& patchesToBeMoved
            );


        // Access Functions

            // Functions triggering calculations

                //- Get mesh points that reside within the control points box
                tmp<vectorField> getPointsInBox();

                //- Get map of points in box to mesh points
                const labelList& getMap();

                //- Get map of mesh points to points in box.
                //- Return -1 if point is outside the box
                const labelList& getReverseMap();

                //- Get parametric coordinates
                const pointVectorField& getParametricCoordinates();

                //- Get dxCartesiandb for a certain control point
                tmp<pointTensorField> getDxDb(const label cpI);

                //- Get dxCartesiandb for a certain control point on cells
                tmp<volTensorField> getDxCellsDb(const label cpI);

                //- Get number of variables if CPs are moved symmetrically in U
                label nUSymmetry() const;

                //- Get number of variables if CPs are moved symmetrically in V
                label nVSymmetry() const;

                //- Get number of variables if CPs are moved symmetrically in W
                label nWSymmetry() const;

                //- Get number of variables per direction,
                //- if CPs are moved symmetrically
                Vector<label> nSymmetry() const;


            // Inline access functions

                //- Get box name
                inline const word& name() const;

                //- Which control points are active?
                //  A control point is active if at least one component can move
                inline const boolList& getActiveCPs() const;

                //- Which design variables are active?
                //  Numbering is (X1,Y1,Z1), (X2,Y2,Z2) ...
                inline const boolList& getActiveDesignVariables() const;

                //- Get control points
                inline const vectorField& getControlPoints() const;

                inline vectorField& getControlPoints();

                //- Get confine movements
                inline bool confineUMovement() const;

                inline bool confineVMovement() const;

                inline bool confineWMovement() const;

                //- Get basis functions
                inline const NURBSbasis& basisU() const;

                inline const NURBSbasis& basisV() const;

                inline const NURBSbasis& basisW() const;

                //- Get number of control points per direction
                inline Vector<label> nCPsPerDirection() const;

                //- Get mesh
                inline const fvMesh& mesh() const;

                //- Get dictionary
                inline const dictionary& dict() const;


        // Write Functions

            //- Write control points on a cartesian coordinates system for
            //- visualization
            void writeCps
            (
                const fileName& = "cpsFile",
                const bool transform = true
            ) const;

            //- Write parametric coordinates
            void writeParamCoordinates() const;

            //- Write the control points to support restart
            virtual bool writeData(Ostream& os) const;
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "NURBS3DVolumeI.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //