decomposeFaFields.H

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) 2021-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
 
Description
    Write proc addressing and decompose area fields (parallel only).
 
\*---------------------------------------------------------------------------*/
 
// Embed do-while to support early termination
if (doDecompose && UPstream::parRun())
do
{
    faMeshReconstructor reconstructor(aMesh, IOobjectOption::LAZY_READ);
 
    if (!reconstructor.good())
    {
        Info<< "Missing volume proc-addressing, "
               "cannot generate area proc-addressing." << nl
            << "Also skip decomposing area fields...."
            << endl;
        break;
    }
 
    reconstructor.writeMesh();          // Writes on master only
    reconstructor.writeAddressing();    // Writes per-proc
 
    Info<< "Wrote proc-addressing and serial mesh" << nl << endl;
 
    // Handle area fields
    // ------------------
 
    faFieldDecomposer::fieldsCache areaFieldsCache;
 
    const faMesh& serialMesh = reconstructor.mesh();
 
    if (doDecompFields)
    {
        // The serial finite-area mesh exists and is identical on all
        // processors, but its fields can only reliably be read on the
        // master (eg, running with distributed roots).
        //
        // - mark mesh fields as readable on master only (haveMeshOnProc)
        // - 'subset' entire serial mesh so that a full copy will be
        //   broadcast to other ranks (subsetterPtr)
        // - scan available IOobjects on the master only
 
        bitSet haveMeshOnProc;
        std::unique_ptr<faMeshSubset> subsetter;
        IOobjectList objects;
 
        refPtr<fileOperation> newHandler(fileOperation::NewUncollated());
 
        const bool oldDistributed = fileHandler().distributed();
        auto oldHandler = fileOperation::fileHandler(newHandler);
        fileHandler().distributed(true);
 
        if (UPstream::master())
        {
            haveMeshOnProc.set(UPstream::myProcNo());
            subsetter.reset(new faMeshSubset(serialMesh));
 
            const bool oldParRun = UPstream::parRun(false);
 
            objects = IOobjectList
            (
                serialMesh.time(),
                runTime.timeName(),
                serialMesh.dbDir(),
                IOobjectOption::NO_REGISTER
            );
 
            UPstream::parRun(oldParRun);
        }
 
        // Restore settings
        (void) fileOperation::fileHandler(oldHandler);
        fileHandler().distributed(oldDistributed);
 
        areaFieldsCache.readAllFields
        (
            haveMeshOnProc,
            subsetter.get(),
            serialMesh,
            objects
        );
    }
 
    const label nAreaFields = areaFieldsCache.size();
 
    if (nAreaFields)
    {
        Info<< "Decomposing " << nAreaFields << " area fields" << nl;
 
        faFieldDecomposer fieldDecomposer
        (
            serialMesh,
            aMesh,
            reconstructor.edgeProcAddressing(),
            reconstructor.faceProcAddressing(),
            reconstructor.boundaryProcAddressing()
        );
 
        // Report
        areaFieldsCache.decomposeAllFields(fieldDecomposer, true);
        Info<< endl;
    }
} while (false);
 
 
// ************************************************************************* //