[mAlletto]

Hello all,


I'm trying to understand the source in the file interpolatedFaces.H located in pEqn.H of the solver overPimpleDyMFaom.


I understood that the code loops over of all faces. If a face is adjacent to a calculated and an interpolated cell if first look for the closest cell in the different mesh parts (the overlapping meshes in the overset approach). After that it uses all neighbors of the latter closest cell to interpolated the H/A field to the face.



After that it does some transformations before assigning the H/A field to the cell center of the interpolated cell.



What I do not understand is why transform the interpolated vectorField H/A before transferring it to the center of the interpolated cell?


The Part of the code I do not understand is the following:

    if (cellId != -1)
    {
        const vector& n = faceNormals[faceI];
        vector n1(Zero);

        // 2-D cases
        if (mesh.nSolutionD() == 2)
        {
            for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
            {
                if (mesh.geometricD()[cmpt] == -1)
                {
                    switch (cmpt)
                    {
                        case vector::X:
                        {
                            n1 = vector(0, n.z(), -n.y());
                            break;
                        }

                        case vector::Y:
                        {
                            n1 = vector(n.z(), 0, -n.x());
                            break;
                        }

                        case vector::Z:
                        {
                            n1 = vector(n.y(), -n.x(), 0);
                            break;
                        }
                    }
                }
            }
        }
        else if (mesh.nSolutionD() == 3)
        {
            //Determine which is the primary direction
            if (mag(n.x()) > mag(n.y()) && mag(n.x()) > mag(n.z()))
            {
                n1 = vector(n.y(), -n.x(), 0);
            }
            else if (mag(n.y()) > mag(n.z()))
            {
                n1 = vector(0, n.z(), -n.y());
            }
            else
            {
                n1 = vector(-n.z(), 0, n.x());
            }
        }
        n1.normalise();

        const vector n2 = normalised(n ^ n1);

        tensor rot =
            tensor
            (
               n.x() ,n.y(), n.z(),
               n1.x() ,n1.y(), n1.z(),
               n2.x() ,n2.y(), n2.z()
            );

//         tensor rot =
//             tensor
//             (
//                n  & x ,n  & y, n  & z,
//                n1 & x ,n1 & y, n1 & z,
//                n2 & x ,n2 & y, n2 & z
//             );

        U1Contrav[faceI].x() =
           2*transform(rot, UIntFaces[faceI]).x()
           - transform(rot, HbyA[receptorNeigCell[faceI]]).x();

        U1Contrav[faceI].y() = transform(rot, HbyA[cellId]).y();

        U1Contrav[faceI].z() = transform(rot, HbyA[cellId]).z();

        HbyA[cellId] = transform(inv(rot), U1Contrav[faceI]);

Any idea why the transformation is performed. Maybe one has to consider that an interpolated face can have more than one neighbor which cell is calculated?


Best


Michael

[mAlletto]

Hello all


I continued analyzing the code. Let's say we have a face normal vector pointing in x-direction. Then the vectors n, n1 and n2 look like this:




The rotation matrix looks like this:





For this case the application of the rotation matrix to a vector





we get

[mAlletto]

Let's analyze the code chunk

        U1Contrav[faceI].x() =
           2*transform(rot, UIntFaces[faceI]).x()
           - transform(rot, HbyA[receptorNeigCell[faceI]]).x();

        U1Contrav[faceI].y() = transform(rot, HbyA[cellId]).y();

        U1Contrav[faceI].z() = transform(rot, HbyA[cellId]).z();

        HbyA[cellId] = transform(inv(rot), U1Contrav[faceI]);

a bit further.


For a face normal pointing in x-direction we get:











and after applying the backward transformation:











It seem that for a face pointing in x-direction the twice the difference between Hbya and the interpolated velocity at the face is added.

[mAlletto]

Ok from the above equation it seems that the vector


a the calculated cells is set equal to the velocity resulting from the inverse distance interpolation at the face plus some correction which should correct the mass imbalance coming from the overset interpolation