DAUtility.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v4
 
    Description:
        DAUtility contains basic functions such as matrix file IO, and
        it is independent of fvMesh. All the functions in DAUtility are static,
        so they can be directly called, e.g., DAUtility::boundVar(...)
 
\*---------------------------------------------------------------------------*/
 
#ifndef DAUtility_H
#define DAUtility_H
 
#include <petscksp.h>
#include "Python.h"
#include "fvOptions.H"
#include "globalIndex.H"
#include "IOMRFZoneListDF.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
typedef void (*pyComputeInterface)(const double*, int, double*, int, void*);
typedef void (*pyJacVecProdInterface)(const double*, double*, int, const double*, const double*, int, void*);
typedef void (*pySetCharInterface)(const char*, void*);
 
/*---------------------------------------------------------------------------*\
                       Class DAUtility Declaration
\*---------------------------------------------------------------------------*/
class DAUtility
{
 
private:
    DAUtility(const DAUtility&);
 
    void operator=(const DAUtility&);
 
public:
    DAUtility();
 
    virtual ~DAUtility();
 
    static void pyDict2OFDict(
        PyObject* pyDict,
        dictionary& ofDict);
 
    template<class classType>
    static label listDeleteVal(
        List<classType>& listIn,
        const classType valDel);
 
    static void writeMatrixBinary(
        const Mat matIn,
        const word prefix);
 
    static void writeMatrixASCII(
        const Mat matIn,
        const word prefix);
 
    static void readMatrixBinary(
        Mat matIn,
        const word prefix);
 
    static void writeVectorASCII(
        const Vec vecIn,
        const word prefix);
 
    static void readVectorBinary(
        Vec vecIn,
        const word prefix);
 
    static void writeVectorBinary(
        const Vec vecIn,
        const word prefix);
 
    static void boundVar(
        const dictionary& allOptions,
        volScalarField& var,
        const label printToScreen);
 
    static void boundVar(
        const dictionary& allOptions,
        volVectorField& var,
        const label printToScreen);
 
    static label isValueCloseToRef(
        const scalar val,
        const scalar refVal,
        const scalar tol = 1.0e-6);
 
    static globalIndex genGlobalIndex(const label localIndexSize);
 
    static scalar angleOfAttackRadForwardAD;
 
    static void* pyCalcBeta;
    static pyComputeInterface pyCalcBetaInterface;
 
    static void* pyCalcBetaJacVecProd;
    static pyJacVecProdInterface pyCalcBetaJacVecProdInterface;
 
    static void* pySetModelName;
    static pySetCharInterface pySetModelNameInterface;
 
    static void primalResidualControl(
        const SolverPerformance<scalar>& solverP,
        const label printToScreen,
        const word varName,
        scalar& primalMaxRes);
 
    static void primalResidualControl(
        const SolverPerformance<vector>& solverP,
        const label printToScreen,
        const word varName,
        scalar& primalMaxRes);
 
    static label myFindCell(
        const primitiveMesh& mesh,
        const point& point);
 
    static label isFieldReadable(
        const fvMesh& mesh,
        const word fieldName,
        const word fieldType);
 
    template<class classType>
    static void swapLists(List<classType>& a, List<classType>& b);
};
 
template<class classType>
label DAUtility::listDeleteVal(
    List<classType>& listIn,
    const classType valDel)
{
    /*
    Description:
        Delete a value in the list, the sequence of other
        elements will be preserved
 
    Input:
        listIn: the list to delete value
        valDel: value to delete
    
    Output:
        foundVal: 1 means the requested value is found and deleted
 
    Example:
        List<word> listIn={"apple","orange"};
        listDeleteVal<word>(listIn,"apple");
        Now listIn will be {orange"}
        NOTE: if list has multiple val, they will be all deleted
    */
 
    // we will create a new list and delete the value
    List<classType> listNew;
 
    label foundVal = 0;
    forAll(listIn, idxI)
    {
        const classType& val = listIn[idxI];
        if (val == valDel)
        {
            foundVal = 1;
            // do not append
        }
        else
        {
            listNew.append(val);
        }
    }
 
    listIn.clear();
    listIn = listNew;
 
    return foundVal;
}
 
template<class classType>
void DAUtility::swapLists(List<classType>& a, List<classType>& b)
{
    List<classType> temp = a;
    a = b;
    b = temp;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //