DARegression.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 
    DAFoam  : Discrete Adjoint with OpenFOAM
    Version : v4
 
    Description:
        Regression model
 
\*---------------------------------------------------------------------------*/
 
#ifndef DARegression_H
#define DARegression_H
 
#include "fvOptions.H"
#include "surfaceFields.H"
#include "DAOption.H"
#include "DAUtility.H"
#include "DAModel.H"
#include "globalIndex.H"
#include "DAMacroFunctions.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                       Class DARegression Declaration
\*---------------------------------------------------------------------------*/
 
class DARegression
    : public regIOobject
{
 
private:
    DARegression(const DARegression&);
 
    void operator=(const DARegression&);
 
protected:
    const fvMesh& mesh_;
 
    const DAOption& daOption_;
 
    const DAModel& daModel_;
 
    label active_;
 
    wordList modelNames_;
 
    HashTable<word> modelType_;
 
    HashTable<wordList> inputNames_;
 
    HashTable<word> outputName_;
 
    HashTable<labelList> hiddenLayerNeurons_;
 
    HashTable<scalarList> inputShift_;
 
    HashTable<scalarList> inputScale_;
 
    HashTable<scalar> outputShift_;
 
    HashTable<scalar> outputScale_;
 
    HashTable<scalarList> parameters_;
 
    HashTable<word> activationFunction_;
 
    HashTable<scalar> leakyCoeff_;
 
    HashTable<scalar> outputUpperBound_;
 
    HashTable<scalar> outputLowerBound_;
 
    HashTable<label> printInputInfo_;
 
    HashTable<scalar> defaultOutputValue_;
 
    HashTable<label> nRBFs_;
 
    HashTable<PtrList<volScalarField>> features_;
 
#if defined(CODI_ADF)
    double* featuresFlattenArrayDouble_;
 
    double* outputFieldArrayDouble_;
#else
    scalar* featuresFlattenArray_;
 
    scalar* outputFieldArray_;
#endif
    label useExternalModel_ = 0;
 
    label featuresFlattenArraySize_ = -100;
 
    HashTable<label> writeFeatures_;
 
public:
    DARegression(
        const fvMesh& mesh,
        const DAOption& daOption,
        const DAModel& daModel);
 
    virtual ~DARegression()
    {
        if (useExternalModel_)
        {
#if defined(CODI_ADF)
            delete[] featuresFlattenArrayDouble_;
            delete[] outputFieldArrayDouble_;
#else
            delete[] featuresFlattenArray_;
            delete[] outputFieldArray_;
#endif
        }
    }
 
    // Members
 
    label compute();
 
    void calcInputFeatures(word modelName);
 
    label nParameters(word modelName);
 
    scalar getParameter(word modelName, label idxI)
    {
        return parameters_[modelName][idxI];
    }
 
    void setParameter(word modelName, label idxI, scalar val)
    {
        parameters_[modelName][idxI] = val;
    }
 
    label checkOutput(word modelName, volScalarField& outputField);
 
    void printInputInfo(const label printToScreen)
    {
        if (!active_ || !printToScreen)
        {
            return;
        }
        forAll(modelNames_, idxI)
        {
            word modelName = modelNames_[idxI];
            if (printInputInfo_[modelName])
            {
                Info << "RegModel input info for " << modelName << endl;
                forAll(inputNames_[modelName], idxI)
                {
                    word name = inputNames_[modelName][idxI];
                    Info << name << " Min: " << gMin(features_[modelName][idxI]) << " Max: " << gMax(features_[modelName][idxI])
                         << " Avg: " << gAverage(features_[modelName][idxI]) << " Std: " << sqrt(gSumSqr(features_[modelName][idxI]) / features_[modelName][idxI].size()) << endl;
                }
            }
        }
    }
 
    void writeFeatures()
    {
        if (!active_)
        {
            return;
        }
        forAll(modelNames_, idxI)
        {
            word modelName = modelNames_[idxI];
            if (writeFeatures_[modelName])
            {
                forAll(features_[modelName], idxI)
                {
                    features_[modelName][idxI].write();
                }
            }
        }
    }
 
#ifdef CODI_ADR
/*
    static void betaCompute(
        const double* x,
        size_t n,
        double* y,
        size_t m,
        codi::ExternalFunctionUserData* d)
    {
        DAUtility::pyCalcBetaInterface(x, n, y, m, DAUtility::pyCalcBeta);
    }
 
    static void betaJacVecProd(
        const double* x,
        double* x_b,
        size_t n,
        const double* y,
        const double* y_b,
        size_t m,
        codi::ExternalFunctionUserData* d)
    {
        DAUtility::pyCalcBetaJacVecProdInterface(x, x_b, n, y, y_b, m, DAUtility::pyCalcBetaJacVecProd);
    }
*/
#endif
 
    bool writeData(Ostream& os) const
    {
        return true;
    }
};
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //