[t.oliveira]

Dear Foamers,

I need to:
(1) solve for the velocity field
and then
(2) use this velocity field for the transport of a scalar.

I would like to do that in just one code, so that the mesh and velocity field don't need to be reloaded from step (1) to (2). A sketch of the idea is below:

        // as in simpleFoam.C
        while (simple.loop())
        {
        // --- Pressure-velocity SIMPLE corrector
            {
                #include "UEqn.H"
                #include "pEqn.H"
            }
            turbulence->correct();
            runTime.write();
        }

    // as in scalarTransportFoam.C
        while (simple.loop())
        {
            while (simple.correctNonOrthogonal())
            {
                solve(fvm::ddt(T) + fvm::div(phi, T) - fvm::laplacian(DT, T)  == fvOptions(T));
            }
            runTime.write();
        }

However, I still have no clue on how to deal with the timesteps so that step 2 writes its output to its own series of time directories. One acceptable solution would be to write the time directories of step 1 in a folder, restart the time, and write the time directories of step 2 in another folder.

Would you have any idea on how to achieve this or other solution?

Any insight, references to documentation or examples, or threads in the forum I may have missed are welcome.

Thank for your attention,

[wouter]

hello t.oliveira,

I do not think this is gonna work, because simple foam is not a time dependent solver, time is more or less the name of the iteration steps variables and have nothing to to with the clock time. (steady state solver)
In scalar transport you need this 'clocktime' so the two do not mix.

The best way is to solve with simplefoam and use the converged velocity to calculate the transport of the scalar.

hope this helps,
Wouter

[t.oliveira]

Hi Wouter,

Thanks for your reply. I am aware that the "time" in simpleFoam represents iteration steps, and that's why I want to separate the "time" of simpleFoam from the real time of scalarTransportFoam.

I do intend to solve with simplefoam and use the converged velocity to calculate the transport of the scalar. However, I am looking for a way of doing that withing the same program, so that I save the time that it takes to reconstruct the mesh and reading the velocity field from a file.

Regards,
Thomas

[t.oliveira]

At this moment, I am considering exploring one of these tracks:

i) use subCycling
ii) create a new Foam::Time object
iii) reset time using Foam::Time::setTime

Any thoughts?

[t.oliveira]

I got a satisfactory solution, but I am almost sure that there must be neater a way of doing it.

My solution involved:

- creating another Foam::argList beside the standard args. The "case" in this other argList is a subdirectory of the original case directory. This allows the "time" directories of the velocity field solver to be written to a separate subdirectory:

Foam::argList args(argc, argv);
if (!args.checkRootCase())
{
    Foam::FatalError.exit();
}

HashTable<string> directoryVel;
directoryVel.set("case", "flowSolver");
Foam::argList argsVel(args, directoryVel);
if (!argsVel.checkRootCase())
{
    Foam::FatalError.exit();
}

- creating another Foam::Time:

// Runtime for the solution of velocity and pressure fields
Foam::Time runTimeVel(Foam::word("controlDictVel"), argsVel);
// Runtime for the solution of reactive transport
Foam::Time runTime(Foam::Time::controlDictName, args);

- creating another Foam::fvMesh, fv::IOoptionList and simpleControl

- running the first solver

- mapping the velocity field obtained by the first solver into the velocity field used by the second solver. More tests are needed to verify if this is doing what I expect it to do and that I didn't mess up with pointers and references:

// U = UVel would work just if U.mesh() == UVel.mesh()
// U.dimensionedInternalField() = UVel.dimensionedInternalField() would work just if U.mesh() == UVel.mesh()
U.dimensionedInternalField().dimensions() = UVel.dimensionedInternalField().dimensions();
U.dimensionedInternalField().Field<vector>::operator=(UVel.dimensionedInternalField());

// U.boundaryField() = UVel.boundaryField() would work if they had same patches      
forAll(UVel.boundaryField(), i)
{
   Field<vector> source = UVel.boundaryField()[i];
   Field<vector> target = U.boundaryField()[i];
   target = source;
}

Before running, I created a subdirectory called "flowSolver". Inside it, I created symbolic links to the folders "0", "constant" and "system".

Best wishes,
Thomas

[marupio]

Good use case for multiSolver.

https://github.com/Marupio/multiSolver/wiki