generateInterfacialModels.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2025-2026 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
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/>.
 
Namespace
    Foam
 
Description
    Functions for generating tables of interfacial models
 
\*---------------------------------------------------------------------------*/
 
#ifndef generateInterfacialModels_H
#define generateInterfacialModels_H
 
#include "phaseSystem.H"
#include "TypeSet.H"
#include "dispersedPhaseInterface.H"
#include "segregatedPhaseInterface.H"
#include "displacedPhaseInterface.H"
#include "sidedPhaseInterface.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
template<class ModelType>
word modelName()
{
    word name = ModelType::typeName;
 
    // Extract the innermost part of the template
    const word::size_type i0 = name.find_last_of('<');
    if (i0 != word::npos)
    {
        const word::size_type i1 = name.find_first_of('>', i0 + 1);
        if (i1 != word::npos)
        {
            name = name(i0 + 1, i1 - i0 - 1);
        }
    }
 
    // Strip "Model" off the end of the name
    if (name(name.size() - 5, 5) == "Model")
    {
        name = name(name.size() - 5);
    }
 
    return name;
}
 
 
inline UPtrList<const dictionary> modelSubDicts
(
    const dictionary& dict,
    const wordHashSet& ignoreKeys = wordHashSet()
)
{
    UPtrList<const dictionary> result(dict.size());
 
    label n = 0;
 
    forAllConstIter(dictionary, dict, iter)
    {
        if (ignoreKeys.found(iter().keyword())) continue;
 
        result.set(n ++, &iter().dict());
    }
 
    result.resize(n);
 
    return result;
}
 
 
template<class ModelType>
const dictionary& modelSubDict(const UPtrList<const dictionary>& subDicts)
{
    if (subDicts.empty())
    {
        FatalErrorInFunction
            << "No many matching entries for construction of a "
            << ModelType::typeName
            << exit(FatalError);
    }
 
    if (subDicts.size() > 1)
    {
        wordList toc;
        forAll(subDicts, i)
        {
            toc.append(subDicts[i].dictName());
        }
 
        FatalErrorInFunction
            << "Too many matching entries for construction of a "
            << ModelType::typeName << nl << toc
            << exit(FatalError);
    }
 
    return subDicts.first();
}
 
 
template<class ModelType, typename = void>
struct ModelPhaseInterfaceTypes
:
    public std::false_type
{
    typedef TypeSet<> required;
 
    typedef TypeSet<> allowed;
 
    typedef TypeSet
    <
        dispersedPhaseInterface,
        segregatedPhaseInterface,
        displacedPhaseInterface,
        sidedPhaseInterface
    > prohibited;
};
 
template<class ModelType>
struct ModelPhaseInterfaceTypes<ModelType, VoidT<typename ModelType::modelType>>
:
    public std::true_type
{
    typedef typename
        TypeSetConcatenate
        <
            typename ModelPhaseInterfaceTypes
            <
                typename ModelType::modelType
            >::required,
            typename ModelType::requiredPhaseInterfaces
        >::type required;
 
    typedef typename
        TypeSetConcatenate
        <
            typename ModelPhaseInterfaceTypes
            <
                typename ModelType::modelType
            >::allowed,
            typename ModelType::allowedPhaseInterfaces
        >::type allowed;
 
    typedef typename
        TypeSetRemove
        <
            typename ModelPhaseInterfaceTypes<void>::prohibited,
            allowed
        >::type prohibited;
};
 
 
template<class ModelType>
bool isModelPhaseInterfaceType(const phaseInterface& interface)
{
    return
        ModelPhaseInterfaceTypes<ModelType>::required::isAll(interface)
     && !ModelPhaseInterfaceTypes<ModelType>::prohibited::isAny(interface);
}
 
 
template<class InterfaceTypeSet>
struct PhaseInterfaceInfo;
 
template<class InterfaceType, class ... InterfaceTypes>
struct PhaseInterfaceInfo<TypeSet<InterfaceType, InterfaceTypes ...>>
{
    string operator()(const char* andOr) const
    {
        const string subS =
            PhaseInterfaceInfo<TypeSet<InterfaceTypes ...>>()(andOr);
 
        string type(InterfaceType::typeName_());
        type.removeTrailing("PhaseInterface");
 
        const string s =
            type + " (i.e., contains '_" + InterfaceType::separator() + "_')";
 
        return
            sizeof ... (InterfaceTypes) == 0
          ? s.c_str()
          : sizeof ... (InterfaceTypes) == 1
          ? s + ' ' + andOr + ' ' + subS
          : s + ", " + subS;
    }
};
 
template<>
struct PhaseInterfaceInfo<TypeSet<>>
{
    inline string operator()(const char* andOr) const
    {
        return string();
    }
};
 
 
template<class ModelType>
void checkInterfacialModelsDict
(
    const phaseSystem& fluid,
    const dictionary& dict,
    const wordHashSet& ignoreKeys = wordHashSet()
)
{
    forAllConstIter(dictionary, dict, iter)
    {
        // Get the keyword name and skip if it is ignored
        const word& modelName = iter().keyword();
        if (ignoreKeys.found(modelName)) continue;
 
        // Construct the associated interface
        autoPtr<phaseInterface> modelInterfacePtr =
            phaseInterface::New(fluid, modelName);
 
        // Check the interface against the model's permitted interface types
        if (!isModelPhaseInterfaceType<ModelType>(modelInterfacePtr()))
        {
            FatalIOErrorInFunction(dict)
                << "The interface " << modelName
                << " is not of suitable type for construction of a "
                << ModelType::typeName << '.';
 
            const string requiredInfo =
                PhaseInterfaceInfo
                <
                    typename ModelPhaseInterfaceTypes<ModelType>::required
                >()("and");
 
            if (requiredInfo.size())
            {
                FatalIOError
                    << " The interface must be of type "
                    << requiredInfo.c_str() << '.';
            }
 
            const string prohibitedInfo =
                PhaseInterfaceInfo
                <
                    typename ModelPhaseInterfaceTypes<ModelType>::prohibited
                >()("or");
 
            if (prohibitedInfo.size())
            {
                FatalIOError
                    << " The interface must NOT be of type "
                    << prohibitedInfo.c_str() << '.';
            }
 
            FatalIOError
                << exit(FatalIOError);
        }
    }
}
 
 
template<class ModelType, class ... InterfaceTypes, class ... Args>
void generateInterfacialModels
(
    PtrList<phaseInterface>& interfaces,
    PtrList<ModelType>& models,
    const phaseSystem& fluid,
    const UPtrList<const dictionary>& subDicts,
    const wordHashSet& ignoreKeys,
    const phaseInterface& interface,
    const Args& ... args
)
{
    // Construct sub-dictionaries and associated interfaces
    hashedWordList names;
    List<UPtrList<const dictionary>> subDictss;
    forAll(subDicts, subDicti)
    {
        // Get the model sub dictionary and name
        const dictionary& modelDict = subDicts[subDicti];
        const word& modelName = modelDict.dictName();
        if (ignoreKeys.found(modelName)) continue;
 
        // Construct the interface
        autoPtr<phaseInterface> modelInterfacePtr =
            phaseInterface::New(fluid, modelName);
 
        // Check the interface against the model's permitted interface types
        if
        (
            isNull(interface)
         && !isModelPhaseInterfaceType<ModelType>(modelInterfacePtr())
        ) continue;
 
        // Convert the interface to the first specified type possible
        autoPtr<phaseInterface> interfacePtr =
            TypeSet<InterfaceTypes ...>::clone(modelInterfacePtr());
        if (!interfacePtr.valid())
        {
            FatalIOErrorInFunction(modelDict)
                << "The interface " << modelName
                << " is not of suitable type for construction of a "
                << ModelType::typeName
                << exit(FatalIOError);
        }
 
        // If constructing for a specific interface then combine with this
        // interface. This ensures interface information propagates through
        // hierarchical model generation.
        if (notNull(interface))
        {
            interfacePtr = phaseInterface::New(interface, interfacePtr());
        }
 
        // Find an existing dictionary to add to or create a new one
        const word name = interfacePtr->name();
        if (!names.found(name))
        {
            names.append(name);
            subDictss.append(UPtrList<const dictionary>());
            interfaces.append(interfacePtr.ptr());
            models.append(nullptr);
        }
 
        // Add the model dictionary
        subDictss[names[name]].append(&modelDict);
    }
 
    // Construct the models
    forAll(interfaces, i)
    {
        models.set(i, ModelType::New(subDictss[i], interfaces[i], args ...));
    }
}
 
 
template<class ModelType, class ... Args>
Foam::HashPtrTable
<
    ModelType,
    Foam::phaseInterfaceKey,
    Foam::phaseInterfaceKey::hash
> generateInterfacialModels
(
    const phaseSystem& fluid,
    const dictionary& dict,
    const wordHashSet& ignoreKeys,
    const bool ignoreNonModelPhaseInterfaceTypes,
    const Args& ... args
)
{
    // Check that the dictionary has the correct interface types in it
    if (!ignoreNonModelPhaseInterfaceTypes)
    {
        checkInterfacialModelsDict<ModelType>(fluid, dict, ignoreKeys);
    }
 
    // Construct lists of interfaces and models
    PtrList<phaseInterface> listInterfaces;
    PtrList<ModelType> listModels;
    generateInterfacialModels<ModelType, phaseInterface>
    (
        listInterfaces,
        listModels,
        fluid,
        modelSubDicts(dict, ignoreKeys),
        wordHashSet(),
        NullObjectRef<phaseInterface>(),
        args ...
    );
 
    // Transfer to a keyed table
    HashPtrTable<ModelType, phaseInterfaceKey, phaseInterfaceKey::hash> models;
    forAll(listInterfaces, i)
    {
        models.insert(listInterfaces[i], listModels.set(i, nullptr).ptr());
    }
 
    return models;
}
 
 
template<class ModelType>
Foam::HashPtrTable
<
    ModelType,
    Foam::phaseInterfaceKey,
    Foam::phaseInterfaceKey::hash
> generateInterfacialModels
(
    const phaseSystem& fluid,
    const dictionary& dict
)
{
    return
        generateInterfacialModels<ModelType>
        (
            fluid,
            dict,
            wordHashSet(),
            false
        );
}
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //