[mary mor]

Hi dear all
Can anybody explain for me what's the difference between boundary condition 'fixedValue' and 'movingWallVelocity' for velocity please?


Regards
Maryam

[fumiya]

Hi,

If a wall moves at a constant velocity, you can assign the 'fixedValue' condition on it.

On the other hand, if the wall's velocity changes with time, the 'movingWallVelocity' condition
is able to impose a non-slip boundary condition on it.

You might want to take a look at the tutorial:
incompressible/pimpleDyMFoam/oscillatingInletACMI2D

Hope this helps,
Fumiya

[student666]

Hi,

I have another question about it, and that's it:

for a rotating case (like a fan), sometimes I see applied on rotating frame's patches two different BCs.

rotating_wall
(
type fixedValue
value uniform (0 0 0)
)

while sometimes I see someone using:

rotating_wall
(
type movingWallVelocity
value uniform (0 0 0)
)

What's the reason? which is the difference?

Thanks

[obiscolly50]

Originally Posted by student666

Hi,

I have another question about it, and that's it:

for a rotating case (like a fan), sometimes I see applied on rotating frame's patches two different BCs.

rotating_wall
(
type fixedValue
value uniform (0 0 0)
)

while sometimes I see someone using:

rotating_wall
(
type movingWallVelocity
value uniform (0 0 0)
)

What's the reason? which is the difference?

Thanks

I guess this is a bit late, but might help someone. fixedValue is used when simulating using an MRF (frozen rotor) approach. However, movingWallVelocity is used when simulating the actual dynamic movement of the rotor in transient mode.

[Krao]

Hi Obi, I have actually tried both the BCs on MRF and I didn't find any difference between the simulation results. They were exactly the same. However we should use movingWallVelocity in transient simulations.

[studente]

Hi all, I have done a simulation of a Darrieus wind turbine, where I imposed those BCs on the airfoil, just to compare the results. All other parameters and conditions were set the same. Have a look at my attachments, there you can see a big difference in calculation of the Tangential force and Normal force between those two. The one with BC type movingWallVelocity shows a better agreement in comparison to experimental data. Apparently, the type no_slip overpredict the forces.

In another image, we could also see the difference between those two, what you see there is, the vortical structures behind the airfoil. The one with movingWallVelocity type (right) shows a more realistic vortices wake than the one of no slip (left)

[Bloerb]

movingWallVelocity and fixedValue are both fixedValue conditions. For fixedValue the wall velocity is obviously set to the value you are imposing. movingWallVelocity however looks up the velocity from the movement of the wall itself.
Hence

type fixedValue;
value (1 0 0);

will set your wall velocity to 1 m/s in x direction.

type movingWallVelocity;
value (1 0 0);

won't set it to 1m/s in x. It will only use that value in the first time step and calculate the real velocity from the speed at which the mesh moves:

In other words, if your mesh is not fixed, but moving it applies this:

    if (mesh.moving())
    {
        const fvPatch& p = patch();
        const polyPatch& pp = p.patch();
        const pointField& oldPoints = mesh.oldPoints();

        vectorField oldFc(pp.size());

        forAll(oldFc, i)
        {
            oldFc[i] = pp[i].centre(oldPoints);
        }

        const scalar deltaT = mesh.time().deltaTValue();

        const vectorField Up((pp.faceCentres() - oldFc)/deltaT);

        const volVectorField& U =
            static_cast<const volVectorField&>(internalField());

        scalarField phip
        (
            p.patchField<surfaceScalarField, scalar>(fvc::meshPhi(U))
        );

        const vectorField n(p.nf());
        const scalarField& magSf = p.magSf();
        tmp<scalarField> Un = phip/(magSf + VSMALL);


        vectorField::operator=(Up + n*(Un - (n & Up)));
    }

Hence it is basically a non slip wall condition for rotating or moving meshes. But if my mesh is moving at 1m/s in x shouldn't it be identical you might ask! Now it does this: Up + n*(Un - (n & Up)). And you might notice that n & Up is identical to Un. Hence the second part is Un-Un=0. And you could simply write the boundary condition as Up (U at the patch which is exactly what fixedValue would do). But in reality this is not the case. This difference is for numerical reasons. Since Un is calculated using the flux field phi and Up is calculated from U. Hence there is a small difference between this and a pure fixedValue condition.The second part is hence purely for numerical stability.

[Oliver Meng]

So if I have a fixed mesh, do you know the difference between these two definitions?

type fixedValue;
value (1 0 0);

and

type movingWallVelocity;
value (1 0 0);

Originally Posted by Bloerb

movingWallVelocity and fixedValue are both fixedValue conditions. For fixedValue the wall velocity is obviously set to the value you are imposing. movingWallVelocity however looks up the velocity from the movement of the wall itself.
Hence

type fixedValue;
value (1 0 0);

will set your wall velocity to 1 m/s in x direction.

type movingWallVelocity;
value (1 0 0);

won't set it to 1m/s in x. It will only use that value in the first time step and calculate the real velocity from the speed at which the mesh moves:

In other words, if your mesh is not fixed, but moving it applies this:

    if (mesh.moving())
    {
        const fvPatch& p = patch();
        const polyPatch& pp = p.patch();
        const pointField& oldPoints = mesh.oldPoints();

        vectorField oldFc(pp.size());

        forAll(oldFc, i)
        {
            oldFc[i] = pp[i].centre(oldPoints);
        }

        const scalar deltaT = mesh.time().deltaTValue();

        const vectorField Up((pp.faceCentres() - oldFc)/deltaT);

        const volVectorField& U =
            static_cast<const volVectorField&>(internalField());

        scalarField phip
        (
            p.patchField<surfaceScalarField, scalar>(fvc::meshPhi(U))
        );

        const vectorField n(p.nf());
        const scalarField& magSf = p.magSf();
        tmp<scalarField> Un = phip/(magSf + VSMALL);


        vectorField::operator=(Up + n*(Un - (n & Up)));
    }

Hence it is basically a non slip wall condition for rotating or moving meshes. But if my mesh is moving at 1m/s in x shouldn't it be identical you might ask! Now it does this: Up + n*(Un - (n & Up)). And you might notice that n & Up is identical to Un. Hence the second part is Un-Un=0. And you could simply write the boundary condition as Up (U at the patch which is exactly what fixedValue would do). But in reality this is not the case. This difference is for numerical reasons. Since Un is calculated using the flux field phi and Up is calculated from U. Hence there is a small difference between this and a pure fixedValue condition.The second part is hence purely for numerical stability.