DASolvers.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v4
 
    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()
    {
        return DASolverPtr_->solvePrimal();
    }
 
    label getInputSize(
        const word inputName,
        const word inputType)
    {
        return DASolverPtr_->getInputSize(inputName, inputType);
    }
 
    label getOutputSize(
        const word outputName,
        const word outputType)
    {
        return DASolverPtr_->getOutputSize(outputName, outputType);
    }
 
    void calcOutput(
        const word outputName,
        const word outputType,
        double* output)
    {
        DASolverPtr_->calcOutput(outputName, outputType, output);
    }
 
    label getInputDistributed(
        const word inputName,
        const word inputType)
    {
        return DASolverPtr_->getInputDistributed(inputName, inputType);
    }
 
    label getOutputDistributed(
        const word outputName,
        const word outputType)
    {
        return DASolverPtr_->getOutputDistributed(outputName, outputType);
    }
 
    void calcJacTVecProduct(
        const word inputName,
        const word inputType,
        const double* input,
        const word outputName,
        const word outputType,
        const double* seed,
        double* product)
    {
        DASolverPtr_->calcJacTVecProduct(
            inputName,
            inputType,
            input,
            outputName,
            outputType,
            seed,
            product);
    }
 
    void setSolverInput(
        const word inputName,
        const word inputType,
        const int inputSize,
        const double* input,
        const double* seed)
    {
        DASolverPtr_->setSolverInput(
            inputName,
            inputType,
            inputSize,
            input,
            seed);
    }
 
    void runColoring()
    {
        DASolverPtr_->runColoring();
    }
 
    void calcdRdWT(
        const label isPC,
        Mat dRdWT)
    {
        DASolverPtr_->calcdRdWT(isPC, dRdWT);
    }
 
    void updateKSPPCMat(
        Mat PCMat,
        KSP ksp)
    {
        DASolverPtr_->updateKSPPCMat(PCMat, ksp);
    }
 
    void createMLRKSPMatrixFree(
        const Mat jacPCMat,
        KSP ksp)
    {
        DASolverPtr_->createMLRKSPMatrixFree(jacPCMat, ksp);
    }
 
    void initializedRdWTMatrixFree()
    {
        DASolverPtr_->initializedRdWTMatrixFree();
    }
 
    void destroydRdWTMatrixFree()
    {
        DASolverPtr_->destroydRdWTMatrixFree();
    }
 
    label solveLinearEqn(
        const KSP ksp,
        const Vec rhsVec,
        Vec solVec)
    {
        return DASolverPtr_->solveLinearEqn(ksp, rhsVec, solVec);
    }
 
    void calcdRdWOldTPsiAD(
        const label oldTimeLevel,
        const double* psi,
        double* dRdWOldTPsi)
    {
        DASolverPtr_->calcdRdWOldTPsiAD(oldTimeLevel, psi, dRdWOldTPsi);
    }
 
    void updateOFFields(const double* states)
    {
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        DASolverPtr_->updateOFFields(states);
#else
        label localSize = this->getNLocalAdjointStates();
        scalar* statesArray = new scalar[localSize];
        for (label i = 0; i < localSize; i++)
        {
            statesArray[i] = states[i];
        }
        DASolverPtr_->updateOFFields(statesArray);
        delete[] statesArray;
#endif
    }
 
    void getOFMeshPoints(double* points)
    {
        DASolverPtr_->getOFMeshPoints(points);
    }
 
    void getOFFields(double* states)
    {
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        DASolverPtr_->getOFFields(states);
#else
        label localSize = this->getNLocalAdjointStates();
        scalar* statesArray = new scalar[localSize];
        DASolverPtr_->getOFFields(statesArray);
        for (label i = 0; i < localSize; i++)
        {
            states[i] = statesArray[i].value();
        }
        delete[] statesArray;
#endif
    }
 
    void getOFField(
        const word fieldName,
        const word fieldType,
        double* field)
    {
        DASolverPtr_->getOFField(fieldName, fieldType, field);
    }
 
    void updateOFMesh(const double* volCoords)
    {
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        DASolverPtr_->updateOFMesh(volCoords);
#else
        label localSize = this->getNLocalPoints() * 3;
        scalar* volCoordsArray = new scalar[localSize];
        for (label i = 0; i < localSize; i++)
        {
            volCoordsArray[i] = volCoords[i];
        }
        DASolverPtr_->updateOFMesh(volCoordsArray);
        delete[] volCoordsArray;
#endif
    }
 
    label getGlobalXvIndex(
        const label idxPoint,
        const label idxCoord) const
    {
        return DASolverPtr_->getGlobalXvIndex(idxPoint, idxCoord);
    }
 
    label checkMesh() const
    {
        return DASolverPtr_->checkMesh();
    }
 
    // 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();
    }
 
    double getTimeOpFuncVal(const word functionName)
    {
        return DASolverPtr_->getTimeOpFuncVal(functionName);
    }
 
    double getdFScaling(const word functionName, const label timeIdx)
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getdFScaling(functionName, timeIdx));
        return returnVal;
    }
 
    void calcCouplingFaceCoords(
        const double* volCoords,
        double* surfCoords)
    {
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        DASolverPtr_->calcCouplingFaceCoords(volCoords, surfCoords);
        return;
#endif
        FatalErrorIn("calcCouplingFaceCoords") << "should not call this func in AD mode!"
                                               << abort(FatalError);
    }
 
    double getElapsedClockTime()
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getElapsedClockTime());
        return returnVal;
    }
 
    double getElapsedCpuTime()
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getElapsedCpuTime());
        return returnVal;
    }
 
    label getNRegressionParameters(word modelName)
    {
        return DASolverPtr_->getNRegressionParameters(modelName);
    }
 
    void printAllOptions()
    {
        DASolverPtr_->printAllOptions();
    }
 
    label hasVolCoordInput()
    {
        return DASolverPtr_->hasVolCoordInput();
    }
 
    void updateDAOption(PyObject* pyOptions)
    {
        DASolverPtr_->updateDAOption(pyOptions);
    }
 
    double getPrevPrimalSolTime()
    {
        double returnVal = 0.0;
        assignValueCheckAD(returnVal, DASolverPtr_->getPrevPrimalSolTime());
        return returnVal;
    }
 
    void writeFailedMesh()
    {
        DASolverPtr_->writeFailedMesh();
    }
 
    void readStateVars(
        scalar timeVal,
        label timeLevel = 0)
    {
        DASolverPtr_->readStateVars(timeVal, timeLevel);
    }
 
    void readMeshPoints(const scalar timeVal)
    {
        DASolverPtr_->readMeshPoints(timeVal);
    }
 
    void writeMeshPoints(const double* points, const scalar timeVal)
    {
        DASolverPtr_->writeMeshPoints(points, timeVal);
    }
 
    void calcPCMatWithFvMatrix(Mat PCMat, const label turbOnly)
    {
        DASolverPtr_->calcPCMatWithFvMatrix(PCMat, turbOnly);
    }
 
    void setTime(scalar time, label timeIndex)
    {
        DASolverPtr_->setTime(time, timeIndex);
    }
 
    label getDdtSchemeOrder()
    {
        return DASolverPtr_->getDdtSchemeOrder();
    }
 
    double getEndTime()
    {
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        return DASolverPtr_->getRunTime().endTime().value();
#endif
        FatalErrorIn("getEndTime") << "should not call this func in AD mode!"
                                   << abort(FatalError);
    }
 
    double getDeltaT()
    {
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        return DASolverPtr_->getRunTime().deltaT().value();
#endif
        FatalErrorIn("getDeltaT") << "should not call this func in AD mode!"
                                  << abort(FatalError);
    }
 
    void updateBoundaryConditions(
        const word fieldName,
        const word fieldType)
    {
        DASolverPtr_->updateBoundaryConditions(fieldName, fieldType);
    }
 
    void updateStateBoundaryConditions()
    {
        DASolverPtr_->updateStateBoundaryConditions();
    }
 
    void calcPrimalResidualStatistics(const word mode)
    {
        DASolverPtr_->calcPrimalResidualStatistics(mode, 0);
    }
 
    void setPrimalBoundaryConditions(const label printInfo = 1)
    {
        DASolverPtr_->setPrimalBoundaryConditions(printInfo);
    }
 
    label runFPAdj(
        Vec dFdW,
        Vec psi)
    {
        return DASolverPtr_->runFPAdj(dFdW, psi);
    }
 
    label solveAdjointFP(
        Vec dFdW,
        Vec psi)
    {
        return DASolverPtr_->solveAdjointFP(dFdW, psi);
    }
 
    void initTensorFlowFuncs(
        pyComputeInterface computeInterface,
        void* compute,
        pyJacVecProdInterface jacVecProdInterface,
        void* jacVecProd,
        pySetCharInterface setModelNameInterface,
        void* setModelName)
    {
        DASolverPtr_->initTensorFlowFuncs(
            computeInterface, compute, jacVecProdInterface, jacVecProd, setModelNameInterface, setModelName);
    }
 
    void writeAdjointFields(
        const word function,
        const double writeTime,
        const double* psi)
    {
        DASolverPtr_->writeAdjointFields(function, writeTime, psi);
    }
 
    void writeSensMapSurface(
        const word name,
        const double* dFdXs,
        const double* Xs,
        const label size,
        const double timeName)
    {
        DASolverPtr_->writeSensMapSurface(name, dFdXs, Xs, size, timeName);
    }
 
    void writeSensMapField(
        const word name,
        const double* dFdField,
        const word fieldType,
        const double timeName)
    {
        DASolverPtr_->writeSensMapField(name, dFdField, fieldType, timeName);
    }
 
    double getLatestTime()
    {
        double latestTime = 0.0;
#if !defined(CODI_ADR) && !defined(CODI_ADF)
        latestTime = DASolverPtr_->getLatestTime();
#else
        scalar tmp = DASolverPtr_->getLatestTime();
        latestTime = tmp.getValue();
#endif
        return latestTime;
    };
 
    void meanStatesToStates()
    {
        DASolverPtr_->meanStatesToStates();
    }
 
    void updateInputFieldUnsteady()
    {
        DASolverPtr_->updateInputFieldUnsteady();
    }
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif