DAUtility.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v3
 
    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*);
 
/*---------------------------------------------------------------------------*\
                       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 isInList(
        const classType value,
        const List<classType>& list);
 
    template<class classType>
    static label listReplaceVal(
        List<classType>& listIn,
        const classType valOrig,
        const classType valNew);
 
    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;
};
 
template<class classType>
label DAUtility::isInList(
    const classType value,
    const List<classType>& list)
{
    /*
    Description:
        Check whether a value is in the list
 
    Input:
        value: a value to check with type: classType
        list: list to check the value
 
    Example:
        If the list reads
        list1={"test","run","compare"};
        label val=isInList<word>("run",list1);
        Here the return value: val==1 (value found in the list)
    */
 
    forAll(list, idxI)
    {
        if (list[idxI] == value)
        {
            return 1;
        }
    }
    return 0;
}
 
template<class classType>
label DAUtility::listReplaceVal(
    List<classType>& listIn,
    const classType valOrig,
    const classType valNew)
{
    /*
    Description:
        Replace a value in hte list, the list sequence is preserved
 
    Input:
        listIn: the list to replace
        valOrig: original value in the list
        valNew: new value to replace
 
    Example:
        List<word> listIn={"apple","orange"};
        listReplaceVal<word>(listIn,"apple","banana");
        Now listIn will be {"banana","orange"}
        NOTE: if list has multiple valOrig, they will be all replaced
    */
 
    label foundVal = 0;
    forAll(listIn, idxI)
    {
        const classType& val = listIn[idxI];
        if (val == valOrig)
        {
            listIn[idxI] = valNew;
            foundVal = 1;
        }
    }
 
    return foundVal;
}
 
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;
}
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //