openfoam/applications/utilities/postProcessing/lumped/lumpedPointZones/lumpedPointZones.C

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  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/>.

Application
    lumpedPointZones

Description
    Produce a VTK PolyData file \c lumpedPointZones.vtp in which the
    segmentation of the pressure integration zones can be visualized
    for diagnostic purposes. Does not use external coupling.

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

#include "argList.H"
#include "Time.H"
#include "timeSelector.H"

#include "lumpedPointTools.H"
#include "lumpedPointIOMovement.H"
#include "fvMesh.H"

using namespace Foam;

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

int main(int argc, char *argv[])
{
    argList::addNote
    (
        "Create lumpedPointZones.vtp to verify the segmentation of"
        " pressure integration zones used by lumpedPoint BC."
    );

    argList::noFunctionObjects();  // Never use function objects

    argList::addBoolOption
    (
        "dry-run",
        "Test initial lumped points state without a mesh"
    );
    argList::addOption
    (
        "visual-length",
        "len",
        "Visualization length for planes (visualized as triangles)"
    );

    argList::addBoolOption
    (
        "no-interpolate",
        "Suppress calculation/display of point interpolators"
    );

    argList::addBoolOption
    (
        "verbose",
        "Additional verbosity"
    );

    #include "addRegionOption.H"

    #include "setRootCase.H"

    const bool noInterpolate = args.found("no-interpolate");

    const bool dryrun = args.found("dry-run");

    // const bool verbose = args.found("verbose");

    args.readIfPresent("visual-length", lumpedPointState::visLength);

    #include "createTime.H"

    if (dryrun)
    {
        // Create without a mesh
        autoPtr<lumpedPointIOMovement> movement =
            lumpedPointIOMovement::New(runTime);

        if (!movement.valid())
        {
            Info<< "No valid movement found" << endl;
            return 1;
        }

        const word outputName("state.vtp");

        Info<< "dry-run: writing " << outputName << nl;

        movement().writeStateVTP(movement().state0(), outputName);

        Info<< "\nEnd\n" << endl;

        return 0;
    }


    runTime.setTime(instant(runTime.constant()), 0);

    #include "createNamedMesh.H"

    autoPtr<lumpedPointIOMovement> movement = lumpedPointIOMovement::New(mesh);

    if (!movement.valid())
    {
        Info<< "No valid movement found" << endl;
        return 1;
    }

    // Initial positions/rotations
    movement().writeStateVTP("state.vtp");

    pointIOField points0(lumpedPointTools::points0Field(mesh));

    const label nPatches = lumpedPointTools::setPatchControls(mesh, points0);
    if (!nPatches)
    {
        Info<< "No point patches with lumped movement found" << endl;
        return 2;
    }

    Info<<"Lumped point patch controls set on "
        << nPatches << " patches" << nl;

    Info<<"Areas per point: " << flatOutput(movement().areas(mesh)) << nl;

    if (noInterpolate)
    {
        // Initial geometry, with zones
        movement().writeZonesVTP("lumpedPointZones.vtp", mesh, points0);
    }
    else
    {
        lumpedPointTools::setInterpolators(mesh, points0);

        // Initial geometry, with zones and interpolations
        movement().writeVTP("lumpedPointZones.vtp", mesh, points0);
    }

    Info<< nl
        << "wrote 'state.vtp' (reference state)" << nl
        << "wrote 'lumpedPointZones.vtp'" << nl
        << "\nEnd\n" << endl;

    return 0;
}

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