DASolvers.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v3
 
    Description:
        Python wrapper library for DASolver
 
\*---------------------------------------------------------------------------*/
 
#ifndef DASolvers_H
#define DASolvers_H
 
#include <petscksp.h>
#include "Python.h"
#include "DASolver.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                       Class DASolvers Declaration
\*---------------------------------------------------------------------------*/
 
class DASolvers
{
 
private:
    DASolvers(const DASolvers&);
 
    void operator=(const DASolvers&);
 
    char* argsAll_;
 
    PyObject* pyOptions_;
 
    autoPtr<DASolver> DASolverPtr_;
 
public:
    // Constructors
 
    DASolvers(
        char* argsAll,
        PyObject* pyOptions);
 
    virtual ~DASolvers();
 
    void initSolver()
    {
        DASolverPtr_->initSolver();
    }
 
    label solvePrimal(
        const Vec xvVec,
        Vec wVec)
    {
        return DASolverPtr_->solvePrimal(xvVec, wVec);
    }
 
    void calcdRdWT(
        const Vec xvVec,
        const Vec wVec,
        const label isPC,
        Mat dRdWT)
    {
        DASolverPtr_->calcdRdWT(xvVec, wVec, isPC, dRdWT);
    }
 
    void calcdFdW(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        Vec dFdW)
    {
        DASolverPtr_->calcdFdW(xvVec, wVec, objFuncName, dFdW);
    }
 
    void calcdFdWAD(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        Vec dFdW)
    {
        DASolverPtr_->calcdFdWAD(xvVec, wVec, objFuncName, dFdW);
    }
 
    void calcdFdXvAD(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdXv)
    {
        DASolverPtr_->calcdFdXvAD(xvVec, wVec, objFuncName, designVarName, dFdXv);
    }
 
    void calcdRdXvTPsiAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec psi,
        Vec dRdXvTPsi)
    {
        DASolverPtr_->calcdRdXvTPsiAD(xvVec, wVec, psi, dRdXvTPsi);
    }
 
    void calcdForcedXvAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec fBarVec,
        Vec dForcedW)
    {
        DASolverPtr_->calcdForcedXvAD(xvVec, wVec, fBarVec, dForcedW);
    }
 
    void calcdAcousticsdXvAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec fBarVec,
        Vec dAcoudW,
        word varName,
        word groupName)
    {
        DASolverPtr_->calcdAcousticsdXvAD(xvVec, wVec, fBarVec, dAcoudW, varName, groupName);
    }
 
    void calcdRdActTPsiAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec psi,
        const word designVarName,
        Vec dRdActTPsi)
    {
        DASolverPtr_->calcdRdActTPsiAD(xvVec, wVec, psi, designVarName, dRdActTPsi);
    }
 
    void calcdForcedWAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec fBarVec,
        Vec dForcedW)
    {
        DASolverPtr_->calcdForcedWAD(xvVec, wVec, fBarVec, dForcedW);
    }
 
    void calcdAcousticsdWAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec fBarVec,
        Vec dAcoudW,
        word varName,
        word groupName)
    {
        DASolverPtr_->calcdAcousticsdWAD(xvVec, wVec, fBarVec, dAcoudW, varName, groupName);
    }
 
    void calcdRdAOATPsiAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec psi,
        const word designVarName,
        Vec dRdAOATPsi)
    {
        DASolverPtr_->calcdRdAOATPsiAD(xvVec, wVec, psi, designVarName, dRdAOATPsi);
    }
 
    void createMLRKSP(
        const Mat jacMat,
        const Mat jacPCMat,
        KSP ksp)
    {
        DASolverPtr_->createMLRKSP(jacMat, jacPCMat, ksp);
    }
 
    void createMLRKSPMatrixFree(
        const Mat jacPCMat,
        KSP ksp)
    {
        DASolverPtr_->createMLRKSPMatrixFree(jacPCMat, ksp);
    }
 
    void initializedRdWTMatrixFree(
        const Vec xvVec,
        const Vec wVec)
    {
        DASolverPtr_->initializedRdWTMatrixFree(xvVec, wVec);
    }
 
    void destroydRdWTMatrixFree()
    {
        DASolverPtr_->destroydRdWTMatrixFree();
    }
 
    void solveLinearEqn(
        const KSP ksp,
        const Vec rhsVec,
        Vec solVec)
    {
        DASolverPtr_->solveLinearEqn(ksp, rhsVec, solVec);
    }
 
    void convertMPIVec2SeqVec(
        const Vec mpiVec,
        Vec seqVec)
    {
        DASolverPtr_->convertMPIVec2SeqVec(mpiVec, seqVec);
    }
 
    void calcdRdBC(
        const Vec xvVec,
        const Vec wVec,
        const word designVarName,
        Mat dRdBC)
    {
        DASolverPtr_->calcdRdBC(xvVec, wVec, designVarName, dRdBC);
    }
 
    void calcdFdBC(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdBC)
    {
        DASolverPtr_->calcdFdBC(xvVec, wVec, objFuncName, designVarName, dFdBC);
    }
 
    void calcdFdBCAD(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdBC)
    {
        DASolverPtr_->calcdFdBCAD(xvVec, wVec, objFuncName, designVarName, dFdBC);
    }
 
    void calcdRdBCTPsiAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec psi,
        const word designVarName,
        Vec dRdBCTPsi)
    {
        DASolverPtr_->calcdRdBCTPsiAD(xvVec, wVec, psi, designVarName, dRdBCTPsi);
    }
 
    void calcdRdAOA(
        const Vec xvVec,
        const Vec wVec,
        const word designVarName,
        Mat dRdAOA)
    {
        DASolverPtr_->calcdRdAOA(xvVec, wVec, designVarName, dRdAOA);
    }
 
    void calcdFdAOA(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdAOA)
    {
        DASolverPtr_->calcdFdAOA(xvVec, wVec, objFuncName, designVarName, dFdAOA);
    }
 
    void calcdRdFFD(
        const Vec xvVec,
        const Vec wVec,
        const word designVarName,
        Mat dRdFFD)
    {
        DASolverPtr_->calcdRdFFD(xvVec, wVec, designVarName, dRdFFD);
    }
 
    void calcdFdFFD(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdFFD)
    {
        DASolverPtr_->calcdFdFFD(xvVec, wVec, objFuncName, designVarName, dFdFFD);
    }
 
    void calcdRdACT(
        const Vec xvVec,
        const Vec wVec,
        const word designVarName,
        const word designVarType,
        Mat dRdACT)
    {
        DASolverPtr_->calcdRdACT(xvVec, wVec, designVarName, designVarType, dRdACT);
    }
 
    void calcdFdACTAD(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdACT)
    {
        DASolverPtr_->calcdFdACTAD(xvVec, wVec, objFuncName, designVarName, dFdACT);
    }
 
    void calcdFdACT(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        const word designVarType,
        Vec dFdACT)
    {
        DASolverPtr_->calcdFdACT(xvVec, wVec, objFuncName, designVarName, designVarType, dFdACT);
    }
 
    void calcdRdFieldTPsiAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec psi,
        const word designVarName,
        Vec dRdFieldTPsi)
    {
        DASolverPtr_->calcdRdFieldTPsiAD(xvVec, wVec, psi, designVarName, dRdFieldTPsi);
    }
 
    void calcdFdFieldAD(
        const Vec xvVec,
        const Vec wVec,
        const word objFuncName,
        const word designVarName,
        Vec dFdField)
    {
        DASolverPtr_->calcdFdFieldAD(xvVec, wVec, objFuncName, designVarName, dFdField);
    }
 
    void calcdRdWOldTPsiAD(
        const label oldTimeLevel,
        const Vec psi,
        Vec dRdWOldTPsi)
    {
        DASolverPtr_->calcdRdWOldTPsiAD(oldTimeLevel, psi, dRdWOldTPsi);
    }
 
    void calcdRdWTPsiAD(
        const Vec xvVec,
        const Vec wVec,
        const Vec psi,
        Vec dRdWTPsi)
    {
        DASolverPtr_->calcdRdWTPsiAD(xvVec, wVec, psi, dRdWTPsi);
    }
 
    void updateOFField(const Vec wVec)
    {
        DASolverPtr_->updateOFField(wVec);
    }
 
    void updateOFMesh(const Vec xvVec)
    {
        DASolverPtr_->updateOFMesh(xvVec);
    }
 
    label getGlobalXvIndex(
        const label idxPoint,
        const label idxCoord) const
    {
        return DASolverPtr_->getGlobalXvIndex(idxPoint, idxCoord);
    }
 
    void ofField2StateVec(Vec stateVec) const
    {
        DASolverPtr_->ofField2StateVec(stateVec);
    }
 
    void stateVec2OFField(const Vec stateVec) const
    {
        DASolverPtr_->stateVec2OFField(stateVec);
    }
 
    label checkMesh() const
    {
        return DASolverPtr_->checkMesh();
    }
 
    label getNCouplingFaces()
    {
        return DASolverPtr_->getNCouplingFaces();
    }
 
    label getNCouplingPoints()
    {
        return DASolverPtr_->getNCouplingPoints();
    }
 
    // return the number of local mesh points
    label getNLocalPoints() const
    {
        return DASolverPtr_->getNLocalPoints();
    }
 
    label getNLocalAdjointStates() const
    {
        return DASolverPtr_->getNLocalAdjointStates();
    }
 
    label getNLocalAdjointBoundaryStates() const
    {
        return DASolverPtr_->getNLocalAdjointBoundaryStates();
    }
 
    label getNLocalCells() const
    {
        return DASolverPtr_->getNLocalCells();
    }
 
    void syncDAOptionToActuatorDVs()
    {
        DASolverPtr_->syncDAOptionToActuatorDVs();
    }
 
    double getObjFuncValue(const word objFuncName)
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getObjFuncValue(objFuncName));
        return returnVal;
    }
 
    void calcCouplingFaceCoords(
        const double* volCoords,
        double* surfCoords)
    {
#if !defined(CODI_AD_REVERSE) && !defined(CODI_AD_FORWARD)
        DASolverPtr_->calcCouplingFaceCoords(volCoords, surfCoords);
        return;
#endif
        FatalErrorIn("calcCouplingFaceCoords") << "should not call this func in AD mode!"
                                               << abort(FatalError);
    }
 
    void calcCouplingFaceCoordsAD(
        const double* volCoords,
        const double* seeds,
        double* product)
    {
        DASolverPtr_->calcCouplingFaceCoordsAD(volCoords, seeds, product);
    }
 
    void getForces(Vec fX, Vec fY, Vec fZ)
    {
        DASolverPtr_->getForces(fX, fY, fZ);
    }
 
    void getThermal(
        const double* volCoords,
        const double* states,
        double* thermal)
    {
#if !defined(CODI_AD_REVERSE) && !defined(CODI_AD_FORWARD)
        DASolverPtr_->getThermal(volCoords, states, thermal);
        return;
#endif
        FatalErrorIn("getThermal") << "should not call this func in AD mode!"
                                   << abort(FatalError);
    }
 
    void getThermalAD(
        const word inputName,
        const double* volCoords,
        const double* states,
        const double* seeds,
        double* product)
    {
        DASolverPtr_->getThermalAD(inputName, volCoords, states, seeds, product);
    }
 
    void setThermal(double* thermal)
    {
#if !defined(CODI_AD_REVERSE) && !defined(CODI_AD_FORWARD)
        DASolverPtr_->setThermal(thermal);
        return;
#endif
        FatalErrorIn("setThermal") << "should not call this func in AD mode!"
                                   << abort(FatalError);
    }
 
    void calcdRdThermalTPsiAD(
        const double* volCoords,
        const double* states,
        const double* thermal,
        const double* seeds,
        double* product)
    {
        DASolverPtr_->calcdRdThermalTPsiAD(volCoords, states, thermal, seeds, product);
    }
 
    void getAcousticData(Vec x, Vec y, Vec z, Vec nX, Vec nY, Vec nZ, Vec a, Vec fX, Vec fY, Vec fZ, word groupName)
    {
        DASolverPtr_->getAcousticData(x, y, z, nX, nY, nZ, a, fX, fY, fZ, groupName);
    }
 
    void printAllOptions()
    {
        DASolverPtr_->printAllOptions();
    }
 
    void setdXvdFFDMat(const Mat dXvdFFDMat)
    {
        DASolverPtr_->setdXvdFFDMat(dXvdFFDMat);
    }
 
    void setFFD2XvSeedVec(Vec vecIn)
    {
        DASolverPtr_->setFFD2XvSeedVec(vecIn);
    }
 
    void updateDAOption(PyObject* pyOptions)
    {
        DASolverPtr_->updateDAOption(pyOptions);
    }
 
    double getPrevPrimalSolTime()
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getPrevPrimalSolTime());
        return returnVal;
    }
 
    void pointVec2OFMesh(const Vec xvVec) const
    {
        DASolverPtr_->pointVec2OFMesh(xvVec);
    }
 
    void ofMesh2PointVec(Vec xvVec) const
    {
        DASolverPtr_->ofMesh2PointVec(xvVec);
    }
 
    void resVec2OFResField(const Vec resVec) const
    {
        DASolverPtr_->resVec2OFResField(resVec);
    }
 
    void ofResField2ResVec(Vec resVec) const
    {
        DASolverPtr_->resVec2OFResField(resVec);
    }
 
    void writeMatrixBinary(
        const Mat matIn,
        const word prefix)
    {
        DASolverPtr_->writeMatrixBinary(matIn, prefix);
    }
 
    void writeMatrixASCII(
        const Mat matIn,
        const word prefix)
    {
        DASolverPtr_->writeMatrixASCII(matIn, prefix);
    }
 
    void readMatrixBinary(
        Mat matIn,
        const word prefix)
    {
        DASolverPtr_->readMatrixBinary(matIn, prefix);
    }
 
    void writeVectorASCII(
        const Vec vecIn,
        const word prefix)
    {
        DASolverPtr_->writeVectorASCII(vecIn, prefix);
    }
 
    void readVectorBinary(
        Vec vecIn,
        const word prefix)
    {
        DASolverPtr_->readVectorBinary(vecIn, prefix);
    }
 
    void writeVectorBinary(
        const Vec vecIn,
        const word prefix)
    {
        DASolverPtr_->writeVectorBinary(vecIn, prefix);
    }
 
    void setTimeInstanceField(const label instanceI)
    {
        DASolverPtr_->setTimeInstanceField(instanceI);
    }
 
    void setTimeInstanceVar(
        const word mode,
        Mat stateMat,
        Mat stateBCMat,
        Vec timeVec,
        Vec timeIdxVec)
    {
        DASolverPtr_->setTimeInstanceVar(mode, stateMat, stateBCMat, timeVec, timeIdxVec);
    }
 
    double getTimeInstanceObjFunc(
        const label instanceI,
        const word objFuncName)
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getTimeInstanceObjFunc(instanceI, objFuncName));
        return returnVal;
    }
 
    void setFieldValue4GlobalCellI(
        const word fieldName,
        const scalar val,
        const label globalCellI,
        const label compI = 0)
    {
        DASolverPtr_->setFieldValue4GlobalCellI(fieldName, val, globalCellI, compI);
    }
 
    void setFieldValue4LocalCellI(
        const word fieldName,
        const scalar val,
        const label localCellI,
        const label compI = 0)
    {
        DASolverPtr_->setFieldValue4LocalCellI(fieldName, val, localCellI, compI);
    }
 
    void updateBoundaryConditions(
        const word fieldName,
        const word fieldType)
    {
        DASolverPtr_->updateBoundaryConditions(fieldName, fieldType);
    }
 
    void calcPrimalResidualStatistics(const word mode)
    {
        DASolverPtr_->calcPrimalResidualStatistics(mode, 0);
    }
 
    PetscScalar getForwardADDerivVal(const word objFuncName)
    {
        return DASolverPtr_->getForwardADDerivVal(objFuncName);
    }
 
    void calcResidualVec(Vec resVec)
    {
        DASolverPtr_->calcResidualVec(resVec);
    }
 
    void setPrimalBoundaryConditions(const label printInfo = 1)
    {
        DASolverPtr_->setPrimalBoundaryConditions(printInfo);
    }
 
    void calcFvSource(
        const word propName,
        Vec aForce,
        Vec tForce,
        Vec rDist,
        Vec targetForce,
        Vec center,
        Vec fvSource)
    {
        DASolverPtr_->calcFvSource(propName, aForce, tForce, rDist, targetForce, center, fvSource);
    }
 
    void calcdFvSourcedInputsTPsiAD(
        const word propName,
        const word mode,
        Vec aForce,
        Vec tForce,
        Vec rDist,
        Vec targetForce,
        Vec center,
        Vec psi,
        Vec dFvSource)
    {
        DASolverPtr_->calcdFvSourcedInputsTPsiAD(propName, mode, aForce, tForce, rDist, targetForce, center, psi, dFvSource);
    }
 
    void calcForceProfile(
        Vec center,
        Vec aForceL,
        Vec tForceL,
        Vec rDistL)
    {
        DASolverPtr_->calcForceProfile(center, aForceL, tForceL, rDistL);
    }
 
    void calcdForcedStateTPsiAD(
        const word mode,
        Vec xvVec,
        Vec stateVec,
        Vec psiVec,
        Vec prodVec)
    {
        DASolverPtr_->calcdForcedStateTPsiAD(mode, xvVec, stateVec, psiVec, prodVec);
    }
 
    label runFPAdj(
        const Vec xvVec,
        const Vec wVec,
        Vec dFdW,
        Vec psi)
    {
        return DASolverPtr_->runFPAdj(xvVec, wVec, dFdW, psi);
    }
 
    void initTensorFlowFuncs(
        pyComputeInterface computeInterface, 
        void* compute,
        pyJacVecProdInterface jacVecProdInterface,
        void* jacVecProd)
    {
        DASolverPtr_->initTensorFlowFuncs(computeInterface, compute, jacVecProdInterface, jacVecProd);
    }
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif