lumpedPointMovementWriter.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2016-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

\*---------------------------------------------------------------------------*/

#include "lumpedPointMovement.H"
#include "polyMesh.H"
#include "pointMesh.H"
#include "OFstream.H"
#include "foamVtkOutput.H"
#include "foamVtkSurfaceWriter.H"

// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //

void Foam::lumpedPointMovement::writeStateVTP
(
    const lumpedPointState& state,
    const fileName& file
) const
{
    if (!Pstream::master())
    {
        // No extra information available from slaves, write on master only.
        return;
    }

    labelListList lines;

    label nLines = controllers_.size();

    if (nLines)
    {
        lines.resize(nLines);
        nLines = 0;

        for (const word& ctrlName : controllers_.sortedToc())
        {
            lines[nLines] = controllers_[ctrlName]->pointLabels();
            ++nLines;
        }
    }
    else
    {
        // Default - global with all points as a single line
        lines.resize(1);
        lines.first() = identity(state.size());
    }

    state.writeVTP(file, lines, originalIds_);
}


void Foam::lumpedPointMovement::writeStateVTP(const fileName& file) const
{
    writeStateVTP(state(), file);
}


void Foam::lumpedPointMovement::writeForcesAndMomentsVTP
(
    const fileName& file,
    const UList<vector>& forces,
    const UList<vector>& moments
) const
{
    if (!Pstream::master())
    {
        // Force, moments already reduced
        return;
    }

    OFstream fos(file);
    std::ostream& os = fos.stdStream();

    autoPtr<vtk::formatter> format = vtk::newFormatter
    (
        os,
        vtk::formatType::INLINE_ASCII
    );

    format().xmlHeader()
        .beginVTKFile<vtk::fileTag::POLY_DATA>();

    //
    // The 'backbone' of lumped mass points
    //
    const label nPoints = state().points().size();

    {
        format()
            .tag
            (
                vtk::fileTag::PIECE,
                vtk::fileAttr::NUMBER_OF_POINTS, nPoints,
                vtk::fileAttr::NUMBER_OF_VERTS,  nPoints
            );

        // 'points'
        {
            const uint64_t payLoad = vtk::sizeofData<float, 3>(nPoints);

            format()
                .tag(vtk::fileTag::POINTS)
                .beginDataArray<float, 3>(vtk::dataArrayAttr::POINTS);

            format().writeSize(payLoad);
            vtk::writeList(format(), state().points());
            format().flush();

            format()
                .endDataArray()
                .endTag(vtk::fileTag::POINTS);
        }

        // <Verts>
        format().tag(vtk::fileTag::VERTS);

        //
        // 'connectivity'
        //
        {
            const uint64_t payLoad = vtk::sizeofData<label>(nPoints);

            format().beginDataArray<label>(vtk::dataArrayAttr::CONNECTIVITY);
            format().writeSize(payLoad);

            vtk::writeIdentity(format(), nPoints);

            format().flush();

            format().endDataArray();
        }

        //
        // 'offsets'  (connectivity offsets)
        // = linear mapping onto points (with 1 offset)
        //
        {
            const uint64_t payLoad = vtk::sizeofData<label>(nPoints);

            format().beginDataArray<label>(vtk::dataArrayAttr::OFFSETS);
            format().writeSize(payLoad);

            vtk::writeIdentity(format(), nPoints, 1);

            format().flush();

            format().endDataArray();
        }

        format().endTag(vtk::fileTag::VERTS);
        // </Verts>
    }

    format().beginPointData();

    // forces
    if (forces.size() == nPoints)
    {
        const uint64_t payLoad = vtk::sizeofData<float, 3>(nPoints);

        format().beginDataArray<float, 3>("forces");
        format().writeSize(payLoad);

        vtk::writeList(format(), forces);
        format().flush();

        format().endDataArray();
    }

    // moments
    if (moments.size() == nPoints)
    {
        const uint64_t payLoad = vtk::sizeofData<float, 3>(nPoints);

        format().beginDataArray<float, 3>("moments");
        format().writeSize(payLoad);

        vtk::writeList(format(), moments);
        format().flush();

        format().endDataArray();
    }

    format().endPointData();

    format().endPiece();

    format().endTag(vtk::fileTag::POLY_DATA)
        .endVTKFile();
}


void Foam::lumpedPointMovement::writeZonesVTP
(
    const fileName& file,
    const polyMesh& mesh,
    const pointField& points0
) const
{
    const polyBoundaryMesh& patches = mesh.boundaryMesh();
    const labelList patchIds(patchControls_.sortedToc());

    vtk::surfaceWriter writer
    (
        pointField::null(),
        faceList::null(),
        vtk::formatType::INLINE_ASCII,
        file
    );

    for (const label patchi : patchIds)
    {
        const labelList& faceToPoint = patchControls_[patchi].faceToPoint_;

        primitivePatch pp(patches[patchi].faces(), points0);

        writer.piece(pp.localPoints(), pp.localFaces());

        writer.writeGeometry();

        writer.beginCellData(2);

        writer.writeUniform("patchId", patchi);
        writer.write("lumpedId", faceToPoint);

        writer.endCellData();
    }
}


void Foam::lumpedPointMovement::writeVTP
(
    const fileName& file,
    const polyMesh& mesh,
    const pointField& points0
) const
{
    writeVTP(file, state(), mesh, points0);
}


void Foam::lumpedPointMovement::writeVTP
(
    const fileName& file,
    const lumpedPointState& state,
    const polyMesh& mesh,
    const pointField& points0
) const
{
    const polyBoundaryMesh& patches = mesh.boundaryMesh();
    const labelList patchIds(patchControls_.sortedToc());

    pointMesh ptMesh(mesh);

    vtk::surfaceWriter writer
    (
        pointField::null(),
        faceList::null(),
        vtk::formatType::INLINE_ASCII,
        file
    );

    for (const label patchi : patchIds)
    {
        const polyPatch& pp = patches[patchi];

        const pointPatch& ptPatch = ptMesh.boundary()[patchi];

        // Current position (not displacement)
        tmp<pointField> tpts = pointsPosition(state, ptPatch, points0);

        writer.piece(tpts(), pp.localFaces());

        writer.writeGeometry();

        // Face mapping
        const labelList& faceToPoint = patchControls_[patchi].faceToPoint_;

        writer.beginCellData(2);

        writer.writeUniform("patchId", patchi);
        writer.write("lumpedId", faceToPoint);

        writer.endCellData();

        // The interpolator
        const List<lumpedPointInterpolator>& interpList
            = patchControls_[patchi].interp_;

        writer.beginPointData(3);

        // Nearest, Next
        {
            labelList intData(interpList.size());

            forAll(interpList, i)
            {
                intData[i] = interpList[i].nearest();
            }
            writer.write("nearest", intData);

            forAll(interpList, i)
            {
                intData[i] = interpList[i].next1();
            }
            writer.write("next1", intData);


            forAll(interpList, i)
            {
                intData[i] = interpList[i].next2();
            }
            writer.write("next2", intData);
        }

        // Weights
        {
            scalarList floatData(interpList.size());

            forAll(interpList, i)
            {
                floatData[i] = interpList[i].weight0();
            }
            writer.write("weight", floatData);

            forAll(interpList, i)
            {
                floatData[i] = interpList[i].weight1();
            }
            writer.write("weight1", floatData);

            forAll(interpList, i)
            {
                floatData[i] = interpList[i].weight2();
            }
            writer.write("weight2", floatData);
        }

        writer.endPointData();
    }
}


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