faMeshSubsetTemplates.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/>.
 
\*---------------------------------------------------------------------------*/
 
#include "faMeshSubset.H"
#include "areaFaMesh.H"
#include "edgeFaMesh.H"
#include "areaFields.H"
#include "edgeFields.H"
#include "emptyFaPatchFields.H"
#include "directFaPatchFieldMapper.H"
#include "flipOp.H"
 
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
 
template<class Type>
Foam::tmp
<
    Foam::GeometricField<Type, Foam::faPatchField, Foam::areaMesh>
>
Foam::faMeshSubset::interpolate
(
    const GeometricField<Type, faPatchField, areaMesh>& vf,
    const faMesh& sMesh,
    const bool allowUnmapped
)
{
    // 1. Create the complete field with dummy patch fields
    PtrList<faPatchField<Type>> patchFields(sMesh.boundary().size());
 
    forAll(patchFields, patchi)
    {
        patchFields.set
        (
            patchi,
            faPatchField<Type>::New
            (
                calculatedFaPatchField<Type>::typeName,
                sMesh.boundary()[patchi],
                DimensionedField<Type, areaMesh>::null()
            )
        );
    }
 
    auto tresult = tmp<GeometricField<Type, faPatchField, areaMesh>>::New
    (
        IOobject
        (
            "subset"+vf.name(),
            sMesh.time().timeName(),
            sMesh.thisDb(),
            IOobject::NO_READ,
            IOobject::NO_WRITE
        ),
        sMesh,
        vf.dimensions(),
        Field<Type>(),
        // Field<Type>(vf.primitiveField(), cellMap),
        patchFields
    );
    auto& result = tresult.ref();
    result.oriented() = vf.oriented();
 
 
    // 2. Change the faPatchFields to the correct type using a mapper
    //  constructor (with reference to the now correct internal field)
 
    auto& bf = result.boundaryFieldRef();
 
    forAll(bf, patchi)
    {
        // Construct addressing
        const faPatch& subPatch = sMesh.boundary()[patchi];
 
        labelList directAddressing;
        directFaPatchFieldMapper mapper(directAddressing);
 
        // allowUnmapped : special mode for if we do not want to be
        // warned for unmapped faces (e.g. from faMeshDistribute).
        const bool hasUnmapped = mapper.hasUnmapped();
        if (allowUnmapped)
        {
            mapper.hasUnmapped() = false;
        }
 
        bf.set
        (
            patchi,
            faPatchField<Type>::New
            (
                vf.boundaryField()[patchi],
                subPatch,
                result(),
                mapper
            )
        );
 
        if (allowUnmapped && hasUnmapped)
        {
            // Set unmapped values to zeroGradient. This is the default
            // action for unmapped faPatchFields. Note that this bypasses
            // any special logic for handling unmapped faPatchFields but
            // since this is only used inside faMeshDistribute ...
 
            tmp<Field<Type>> tfld(bf[patchi].patchInternalField());
            const Field<Type>& fld = tfld();
 
            Field<Type> value(bf[patchi]);
            forAll(directAddressing, i)
            {
                if (directAddressing[i] == -1)
                {
                    value[i] = fld[i];
                }
            }
            bf[patchi].faPatchField<Type>::operator=(value);
        }
    }
 
    return tresult;
}
 
 
template<class Type>
Foam::tmp
<
    Foam::GeometricField<Type, Foam::faePatchField, Foam::edgeMesh>
>
Foam::faMeshSubset::interpolate
(
    const GeometricField<Type, faePatchField, edgeMesh>& vf,
    const faMesh& sMesh
)
{
    // 1. Create the complete field with dummy patch fields
    PtrList<faePatchField<Type>> patchFields(sMesh.boundary().size());
 
    forAll(patchFields, patchi)
    {
        patchFields.set
        (
            patchi,
            faePatchField<Type>::New
            (
                calculatedFaePatchField<Type>::typeName,
                sMesh.boundary()[patchi],
                DimensionedField<Type, edgeMesh>::null()
            )
        );
    }
 
    auto tresult = tmp<GeometricField<Type, faePatchField, edgeMesh>>::New
    (
        IOobject
        (
            "subset"+vf.name(),
            sMesh.time().timeName(),
            sMesh.thisDb(),
            IOobject::NO_READ,
            IOobject::NO_WRITE
        ),
        sMesh,
        vf.dimensions(),
        Field<Type>(),
        // Field<Type>
        // (
        //     vf.primitiveField(),
        //     SubList<label>(edgeMap, sMesh.nInternalEdges())
        // ),
        patchFields
    );
    auto& result = tresult.ref();
    result.oriented() = vf.oriented();
 
 
    // 2. Change the faePatchFields to the correct type using a mapper
    //  constructor (with reference to the now correct internal field)
 
    auto& bf = result.boundaryFieldRef();
 
    forAll(bf, patchi)
    {
        // Construct addressing
        const faPatch& subPatch = sMesh.boundary()[patchi];
 
        labelList directAddressing;
        directFaPatchFieldMapper mapper(directAddressing);
 
        bf.set
        (
            patchi,
            faePatchField<Type>::New
            (
                vf.boundaryField()[patchi],
                subPatch,
                result(),
                mapper
            )
        );
    }
 
    return tresult;
}
 
 
// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
template<class Type>
Foam::tmp
<
    Foam::GeometricField<Type, Foam::faPatchField, Foam::areaMesh>
>
Foam::faMeshSubset::interpolate
(
    const GeometricField<Type, faPatchField, areaMesh>& vf,
    const bool allowUnmapped
) const
{
    if (subMeshPtr_)
    {
        return interpolate(vf, *subMeshPtr_);
    }
 
    return vf;
}
 
 
template<class Type>
Foam::tmp
<
    Foam::GeometricField<Type, Foam::faePatchField, Foam::edgeMesh>
>
Foam::faMeshSubset::interpolate
(
    const GeometricField<Type, faePatchField, edgeMesh>& vf,
    const bool allowUnmapped
) const
{
    if (subMeshPtr_)
    {
        return interpolate(vf, *subMeshPtr_);
    }
 
    return vf;
}
 
 
// ************************************************************************* //