fieldsDistributorTemplates.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) 2022 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/>.

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

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

template<class GeoField>
void Foam::fieldsDistributor::readField
(
    const IOobject& io,
    const typename GeoField::Mesh& mesh,
    const label i,
    PtrList<GeoField>& fields
)
{
    fields.set(i, new GeoField(io, mesh));
}

template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::fieldsDistributor::readField
(
    const IOobject& io,
    const typename GeoMesh::Mesh& mesh,
    const label i,
    PtrList<GeometricField<Type, PatchField, GeoMesh>>& fields
)
{
    fields.set
    (
        i,
        new GeometricField<Type, PatchField, GeoMesh>(io, mesh, false)
    );
}


template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::fieldsDistributor::readFields
(
    const typename GeoMesh::Mesh& mesh,
    const IOobjectList& objects,
    PtrList<GeometricField<Type, PatchField, GeoMesh>>& fields,
    const bool readOldTime
)
{
    typedef GeometricField<Type, PatchField, GeoMesh> GeoField;

    // GeoField fields - sorted for consistent order on all processors
    UPtrList<const IOobject> fieldObjects(objects.sorted<GeoField>());

    // Construct the fields
    fields.resize(fieldObjects.size());

    forAll(fieldObjects, i)
    {
        fields.set(i, new GeoField(fieldObjects[i], mesh, readOldTime));
    }
}


template<class Mesh, class GeoField>
void Foam::fieldsDistributor::readFields
(
    const Mesh& mesh,
    const IOobjectList& objects,
    PtrList<GeoField>& fields
)
{
    // GeoField fields - sorted for consistent order on all processors
    UPtrList<const IOobject> fieldObjects(objects.sorted<GeoField>());

    // Construct the fields
    fields.resize(fieldObjects.size());

    forAll(fieldObjects, i)
    {
        fields.set(i, new GeoField(fieldObjects[i], mesh));
    }
}


template<class BoolListType, class GeoField, class MeshSubsetter>
void Foam::fieldsDistributor::readFieldsImpl
(
    const BoolListType& haveMeshOnProc,
    const MeshSubsetter* subsetter,
    const typename GeoField::Mesh& mesh,
    IOobjectList& allObjects,
    PtrList<GeoField>& fields,
    const bool deregister
)
{
    // Get my objects of type
    IOobjectList objects(allObjects.lookupClass<GeoField>());

    // Check that we all have all objects
    wordList objectNames = objects.sortedNames();

    // Get master names
    wordList masterNames(objectNames);
    Pstream::broadcast(masterNames);

    if (haveMeshOnProc.test(Pstream::myProcNo()) && objectNames != masterNames)
    {
        FatalErrorInFunction
            << "Objects not synchronised across processors." << nl
            << "Master has " << flatOutput(masterNames) << nl
            << "Processor " << Pstream::myProcNo()
            << " has " << flatOutput(objectNames)
            << exit(FatalError);
    }

    fields.clear();
    fields.resize(masterNames.size());

    if (fields.empty())
    {
        if (deregister)
        {
            // Extra safety - remove all such types
            HashTable<const GeoField*> other
            (
                mesh.thisDb().objectRegistry::template lookupClass<GeoField>()
            );

            forAllConstIters(other, iter)
            {
                GeoField& fld = const_cast<GeoField&>(*iter.val());

                if (!fld.ownedByRegistry())
                {
                    fld.checkOut();
                }
            }
        }

        // Early exit
        return;
    }


    // Have master send all fields to processors that don't have a mesh. The
    // issue is if a patchField does any parallel operations inside its
    // construct-from-dictionary. This will not work when going to more
    // processors (e.g. decompose = 1 -> many) ! We could make a special
    // exception for decomposePar but nicer would be to have read-communicator
    // ... For now detect if decomposing & disable parRun
    if (Pstream::master())
    {
        // Work out if we're decomposing - none of the subprocs has a mesh
        bool decompose = true;
        for (const int proci : Pstream::subProcs())
        {
            if (haveMeshOnProc.test(proci))
            {
                decompose = false;
                break;
            }
        }

        const bool oldParRun = Pstream::parRun();
        if (decompose)
        {
            Pstream::parRun(false);
        }

        forAll(masterNames, i)
        {
            const word& name = masterNames[i];
            IOobject& io = *objects[name];
            io.writeOpt(IOobject::AUTO_WRITE);

            // Load field (but not oldTime)
            readField(io, mesh, i, fields);
        }

        Pstream::parRun(oldParRun);  // Restore any changes
    }
    else if (haveMeshOnProc.test(Pstream::myProcNo()))
    {
        // Have mesh so just try to load
        forAll(masterNames, i)
        {
            const word& name = masterNames[i];
            IOobject& io = *objects[name];
            io.writeOpt(IOobject::AUTO_WRITE);


            // Load field (but not oldTime)
            readField(io, mesh, i, fields);
        }
    }


    // Missing fields on any processors?
    // - construct from dictionary

    PtrList<dictionary> fieldDicts;

    if (Pstream::master())
    {
        // Broadcast zero sized fields everywhere (if needed)
        // Send like a list of dictionaries

        OPBstream toProcs(UPstream::masterNo());  // worldComm

        const label nDicts = (subsetter ? fields.size() : label(0));

        toProcs << nDicts << token::BEGIN_LIST;  // Begin list

        if (nDicts && subsetter)
        {
            // Disable communication for interpolate() method
            const bool oldParRun = Pstream::parRun(false);

            for (const auto& fld : fields)
            {
                tmp<GeoField> tsubfld = subsetter->interpolate(fld);

                // Surround each with {} as dictionary entry
                toProcs.beginBlock();
                toProcs << tsubfld();
                toProcs.endBlock();
            }

            Pstream::parRun(oldParRun);  // Restore state
        }

        toProcs << token::END_LIST << token::NL;  // End list
    }
    else
    {
        // Receive the broadcast...
        IPBstream fromMaster(UPstream::masterNo());  // worldComm

        // But only consume where needed...
        if (!haveMeshOnProc.test(Pstream::myProcNo()))
        {
            fromMaster >> fieldDicts;
        }
    }


    // Use the received dictionaries (if any) to create missing fields.

    // Disable communication when constructing from dictionary
    const bool oldParRun = Pstream::parRun(false);

    forAll(fieldDicts, i)
    {
        fields.set
        (
            i,
            new GeoField
            (
                IOobject
                (
                    masterNames[i],
                    mesh.time().timeName(),
                    mesh.thisDb(),
                    IOobject::NO_READ,
                    IOobject::AUTO_WRITE
                ),
                mesh,
                fieldDicts[i]
            )
        );
    }

    Pstream::parRun(oldParRun);  // Restore any changes


    // Finally. Can checkOut of registry as required
    if (deregister)
    {
        for (auto& fld : fields)
        {

            // Ensure it is not destroyed by polyMesh deletion
            fld.checkOut();
        }

        // Extra safety - remove all such types
        HashTable<const GeoField*> other
        (
            mesh.thisDb().objectRegistry::template lookupClass<GeoField>()
        );

        forAllConstIters(other, iter)
        {
            GeoField& fld = const_cast<GeoField&>(*iter.val());

            if (!fld.ownedByRegistry())
            {
                fld.checkOut();
            }
        }
    }
}


template<class GeoField, class MeshSubsetter>
void Foam::fieldsDistributor::readFields
(
    const bitSet& haveMeshOnProc,
    const MeshSubsetter* subsetter,
    const typename GeoField::Mesh& mesh,
    IOobjectList& allObjects,
    PtrList<GeoField>& fields,
    const bool deregister
)
{
    readFieldsImpl
    (
        haveMeshOnProc,
        subsetter,

        mesh,
        allObjects,
        fields,
        deregister
    );
}


template<class GeoField, class MeshSubsetter>
void Foam::fieldsDistributor::readFields
(
    const boolList& haveMeshOnProc,
    const MeshSubsetter* subsetter,
    const typename GeoField::Mesh& mesh,
    IOobjectList& allObjects,
    PtrList<GeoField>& fields,
    const bool deregister
)
{
    readFieldsImpl
    (
        haveMeshOnProc,
        subsetter,

        mesh,
        allObjects,
        fields,
        deregister
    );
}


template<class GeoField, class MeshSubsetter>
void Foam::fieldsDistributor::readFields
(
    const boolList& haveMeshOnProc,
    const typename GeoField::Mesh& mesh,
    const autoPtr<MeshSubsetter>& subsetter,
    IOobjectList& allObjects,
    PtrList<GeoField>& fields,
    const bool deregister
)
{
    readFieldsImpl
    (
        haveMeshOnProc,
        subsetter.get(),

        mesh,
        allObjects,
        fields,
        deregister
    );
}


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