[linch]

Hi foamers,

I want to use upwind and downwind interpolation schemes in my code.

A simple way could be e.g. using

AfUpstream = fvc::interpolate(A)

in the code and

interpolationSchemes
{
    interpolate(A)                upwind      fluxIndicator;
}

in the fvSchemes dictionary. But this is not an option, cause:
1) I want to apply both upwind and downwind on the same field A:

AfUpstream = fvc::interpolate(A)
AfDownstream = fvc::interpolate(A)

and this wouldn't work with fvSchemes dict, because only one interpolation method can be prescribed there for the field A.

2) I want to "protect" the interpolation scheme by making it unchangeable, so it shouldn't appear in the fvSchemes dict.

So I need something like that

AfUpstream = fvc::interpolate(A,"upwind",fluxIndicator)

or

AfUpstream = fvc::upwindInterpolate(A,fluxIndicator)

, but I can not find the wright syntax.

[kmooney]

I know that for most of the other fvc and fvm operators you can name a particular operation like this:

fvm::div(phi,U,"velocityDivergenceUpwind")

and perhaps later in the code

fvm::div(phi,U,"velocityDivergenceDownwind")

Where the solver will force you to set each "velocityDivergence" scheme in fvSchemes even though they are both a div(phi,U) operation. I didn't check to see if this option is available for fvc::interpolation but its worth a shot!

[linch]

Thanks a lot, it works.

Still, if there is a possibility to use it without fvSchemes, I would appreciate if someone share it

[akidess]

This snippet from interFoam might be useful for you:

fv::gaussConvectionScheme<scalar>
            (
                mesh,
                phi,
                upwind<scalar>(mesh, phi)
            ).fvmDiv(phi, alpha1)

Again it's a divergence scheme and not an interpolation scheme, but maybe it gives you a hint on how to get it done.

[tomislav_maric]

Hi everyone. Long time no see

This was an interesting question, so here's the working example:

#include "fvCFD.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:

int main(int argc, char *argv[])
{
    #include "setRootCase.H"
    #include "createTime.H"
    #include "createMesh.H"
    #include "createFields.H"

    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    typedef fv::convectionScheme<vector> schemeType;  

    // Uncomment this line to see that the choice of the interpolation scheme 
    // is actually active.
    //IStringStream schemeData("Gauss something"); 
    
    IStringStream schemeData("Gauss upwind"); 

    tmp<schemeType> schemeTmp = schemeType::New(
        mesh, 
        phi, 
        schemeData // Constructor requires a ref to Istream.
    );

    const schemeType& scheme = schemeTmp(); 

    // Give us your name. 
    Info << "Chosen scheme type: " << scheme.type() << endl; 

    // Assemble the matrix. 
    fvVectorMatrix UEqn = scheme.fvmDiv(phi, U);  

    Info<< "\nEnd\n" << endl;
    return 0;
}

Explanation

Selecting anything at run-time will depend on the 'New' static factory function (selector, as it is confusingly named in OF). So all we need is to take a look at the arguments of the selector:

 
        //- Return a pointer to a new convectionScheme created on freestore
        static tmp<convectionScheme<Type> > New
        (
            const fvMesh& mesh,
            const surfaceScalarField& faceFlux,
            Istream& schemeData
        );

Here, 'Istream& schemeData' obviously defines the parameters used for the type selection. Therefore, in the example above, 'Istream' object (of concrete type IStringStream) is constructed as passed as a reference to the 'New' selector.

As for the direct call using the operators in "fvc" or "fvm", I would need to take a look at it.

In any case, @illya, if you are writing client code, that uses those classes, you can use the classes directly, without dispatching the call from a "fvc/m" operator.

Uncomment the "Gauss something" line to see that both parameters are taken and the interpolation scheme of the gaussConvectionScheme really does get selected from the second parameter.

T.

[Pfiffikus]

Hi Tomislav,

many thanks for your interesting code snippet, but imho it doesn't fully answer the initial question:
How to code the interpolation of a volScalarField X (defined on cell centres) to a surfaceScalarField Y (defined on cell faces) while controling the scheme _without_ any controldict entry for interpolationSchemes?

Or is it possible to implement something like

surfaceScalarField Y = scheme.fvmInterpolate(Y,fluxIndicator);

?