/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  v2506                                 |
|   \\  /    A nd           | Website:  www.openfoam.com                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    object      controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

application     scalarTransportFoam;

startFrom       startTime;

startTime       0;

stopAt          endTime;

endTime         100;

deltaT          0.005;

writeControl    timeStep;

writeInterval   100;

purgeWrite      0;

writeFormat     ascii;

writePrecision  6;

writeCompression off;

timeFormat      general;

timePrecision   6;

runTimeModifiable true;

functions
{
    coded1
    {
        name                calcGrad;
        type                coded;
        libs                (utilityFunctionObjects);
        writeControl        timeStep;

        codeInclude
        #{
            #include        "emptyFvPatchField.H"
        #};

        codeExecute
        #{
            const volVectorField& Cc = mesh().C();
            volVectorField Cc2
            (
                IOobject
                (
                    "Cc",
                    mesh().time().timeName(),
                    mesh(),
                    IOobject::NO_READ
                ),
                mesh(),
                dimensionedVector(dimless/dimLength, Zero)
            );

            Cc2.primitiveFieldRef() = Cc.primitiveField();
            auto& bf = Cc2.boundaryFieldRef();

            forAll(bf, patchi)
            {
                fvPatchVectorField& pf = bf[patchi];

                if (!isA<emptyFvPatchField<vector>>(pf))
                {
                    pf == Cc.boundaryField()[patchi];
                }
            }

            tmp<volTensorField> gradC = fvc::grad(Cc2);
            const word gradCName(gradC.cref().name());
            gradC->write();

            volScalarField error
            (
                IOobject
                (
                    "error",
                    mesh().time().timeName(),
                    mesh(),
                    IOobject::NO_READ
                ),
                mesh(),
                dimensionedScalar(dimless, Zero)
            );

            volScalarField magError
            (
                IOobject
                (
                    "magError",
                    mesh().time().timeName(),
                    mesh(),
                    IOobject::NO_READ
                ),
                mesh(),
                dimensionedScalar(dimless, Zero)
            );

            const dimensionedScalar root2(dimless/sqr(dimLength), Foam::sqrt(2.0));

            error = scalar(100)*(mag(gradC) - root2)/root2;
            error.write();

            magError = mag(error);
            magError.write();
        #};
    }

    readFields1
    {
        type            readFields;
        libs            (fieldFunctionObjects);
        fields          ( error magError );
    }

    minMax1
    {
        type                fieldMinMax;
        libs                (fieldFunctionObjects);
        fields              ( error magError );
    }

    volFieldAverage
    {
        type            volFieldValue;
        libs            (fieldFunctionObjects);
        fields          ( error magError );
        operation       average;
        regionType      all;
        writeFields     false;
    }

    volFieldCoV
    {
        type            volFieldValue;
        libs            (fieldFunctionObjects);
        fields          ( error magError );
        operation       CoV;
        regionType      all;
        writeFields     false;
    }

    #include "cuttingPlane"
    // #include "runtimePostProcessing"
}


// ************************************************************************* //