DAJacCon.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v4
 
    Description:
        Compute Jacobian connectivity and coloring
 
\*---------------------------------------------------------------------------*/
 
#ifndef DAJacCon_H
#define DAJacCon_H
 
#include "runTimeSelectionTables.H"
#include "fvOptions.H"
#include "DAUtility.H"
#include "DAOption.H"
#include "DAIndex.H"
#include "DAModel.H"
#include "DAStateInfo.H"
#include "syncTools.H"
#include "DAFunction.H"
#include "DAColoring.H"
#include "DAField.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                    Class DAJacCon Declaration
\*---------------------------------------------------------------------------*/
 
class DAJacCon
{
 
private:
    DAJacCon(const DAJacCon&);
 
    void operator=(const DAJacCon&);
 
protected:
    const word modelType_;
 
    const fvMesh& mesh_;
 
    const DAOption& daOption_;
 
    const DAModel& daModel_;
 
    const DAIndex& daIndex_;
 
    DAColoring daColoring_;
 
    DAField daField_;
 
    HashTable<wordList> stateInfo_;
 
    Mat stateBoundaryCon_;
 
    Mat stateBoundaryConID_;
 
    labelList neiBFaceGlobalCompact_;
 
    Mat jacCon_;
 
    Vec jacConColors_;
 
    label nJacConColors_;
 
 
    Vec dRdWTPreallocOn_;
    Vec dRdWTPreallocOff_;
    Vec dRdWPreallocOn_;
    Vec dRdWPreallocOff_;
 
    void initializeStateBoundaryCon();
 
    void calcNeiBFaceGlobalCompact(labelList& neiBFaceGlobalCompact);
 
    label getLocalCoupledBFaceIndex(const label localFaceI) const;
 
    void setupStateBoundaryCon(Mat* stateBoundaryCon);
 
    void setupStateBoundaryConID(Mat* stateBoundaryConID);
 
    void createConnectionMat(Mat* connectedStates);
 
    void addStateConnections(
        Mat connections,
        const label cellI,
        const label connectedLevelLocal,
        const wordList connectedStatesLocal,
        const List<List<word>> connectedStateInterProc,
        const label addFace);
 
    void setConnections(
        Mat conMat,
        const label idx) const;
 
    void setupJacobianConnections(
        Mat conMat,
        Mat connections,
        const label idxI);
 
    void combineStateBndCon(
        Mat* stateBoundaryCon,
        Mat* stateBoundaryConTmp);
 
    void addConMatCell(
        Mat conMat,
        const label gRow,
        const label cellI,
        const word stateName,
        const PetscScalar val);
 
    void addConMatNeighbourCells(
        Mat conMat,
        const label gRow,
        const label cellI,
        const word stateName,
        const PetscScalar val);
 
    void addConMatCellFaces(
        Mat conMat,
        const label gRow,
        const label cellI,
        const word stateName,
        const PetscScalar val);
 
    void addBoundaryFaceConnections(
        Mat conMat,
        const label gRow,
        const label cellI,
        const labelList v,
        const List<List<word>> connectedStates,
        const label addFaces);
 
    void clearDAJacConMembers()
    {
        // Need to clean up all the matrices
        MatDestroy(&jacCon_);
        MatDestroy(&stateBoundaryCon_);
        MatDestroy(&stateBoundaryConID_);
        VecDestroy(&jacConColors_);
        stateInfo_.clear();
        neiBFaceGlobalCompact_.clear();
    }
 
    void checkSpecialBCs();
 
    Vec isPIVBCState_;
 
    void setPIVVec(
        Vec iSPIV,
        const label idxI);
 
    label addPhi4PIV(
        const word stateName,
        const label idxI,
        const label comp = -1);
 
    void initializePetscVecs();
 
    void allocateJacobianConnections(
        Vec preallocOnProc,
        Vec preallocOffProc,
        Vec preallocOnProcT,
        Vec preallocOffProcT,
        Mat connections,
        const label row);
 
    void preallocateJacobianMatrix(
        Mat dRMat,
        const Vec preallocOnProc,
        const Vec preallocOffProc) const;
 
    void setupdRdWCon(
        const HashTable<List<List<word>>>& stateResConInfo,
        const label isPrealloc);
 
public:
    // Constructors
    DAJacCon(
        const word modelType,
        const fvMesh& mesh,
        const DAOption& daOption,
        const DAModel& daModel,
        const DAIndex& daIndex);
 
    //- Destructor
    virtual ~DAJacCon()
    {
    }
 
    // Member functions
 
    void clear();
 
    void setupJacConPreallocation(const dictionary& options);
 
    void initializeJacCon(const dictionary& options);
 
    void setupJacCon(const dictionary& options);
 
    label getNJacConColors() const
    {
        return nJacConColors_;
    }
 
    void preallocatedRdW(
        Mat dRMat,
        const label transposed) const;
 
    void calcJacConColoring(const word postFix = "");
 
    void readJacConColoring(const word postFix = "");
 
    label coloringExists(const word postFix = "") const;
 
    Vec getJacConColor() const
    {
        return jacConColors_;
    }
 
    void calcColoredColumns(
        const label colorI,
        Vec coloredColumn) const;
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //