C++ cstrIter函数代码示例

Foam::autoPtr<Foam::radiation::absorptionEmissionModel>
Foam::radiation::absorptionEmissionModel::New
(
    const dictionary& dict,
    const fvMesh& mesh
)
{
    word absorptionEmissionModelType(dict.lookup("absorptionEmissionModel"));

    Info<< "Selecting absorptionEmissionModel "
        << absorptionEmissionModelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(absorptionEmissionModelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "absorptionEmissionModel::New(const dictionary&, const fvMesh&)"
        )   << "Unknown absorptionEmissionModelType type "
            << absorptionEmissionModelType
            << ", constructor not in hash table" << nl << nl
            << "    Valid absorptionEmissionModel types are :" << nl
            << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError);
    }

    return autoPtr<absorptionEmissionModel>(cstrIter()(dict, mesh));
}

Foam::autoPtr<Foam::kineticTheoryModels::packingLimitModel>
Foam::kineticTheoryModels::packingLimitModel::New
(
    const dictionary& dict,
    const kineticTheorySystem& kt
)
{
    word packingLimitModelType
    (
        dict.lookupOrDefault<word>("packingLimitModel", "constant")
    );

    Info<< "Selecting packingLimitModel "
        << packingLimitModelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(packingLimitModelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalError
            << "packingLimitModel::New(const dictionary&) : " << endl
            << "    unknown packingLimitModelType type "
            << packingLimitModelType
            << ", constructor not in hash table" << endl << endl
            << "    Valid packingLimitModelType types are :" << endl;
        Info<< dictionaryConstructorTablePtr_->sortedToc()
            << abort(FatalError);
    }

    return autoPtr<packingLimitModel>(cstrIter()(dict, kt));
}

Foam::autoPtr<Foam::extrudeModel> Foam::extrudeModel::New
(
    const dictionary& dict
)
{
    const word modelType(dict.lookup("extrudeModel"));

    Info<< "Selecting extrudeModel " << modelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(modelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "extrudeModel::New(const dictionary&)"
        )   << "Unknown extrudeModel type "
            << modelType << nl << nl
            << "Valid extrudeModel types are :" << nl
            << dictionaryConstructorTablePtr_->sortedToc() << nl
            << exit(FatalError);
    }

    return autoPtr<extrudeModel>(cstrIter()(dict));
}

autoPtr<thermalBaffleModel> thermalBaffleModel::New
(
    const fvMesh& mesh,
    const dictionary& dict
)
{
    word modelType =
        dict.lookupOrDefault<word>("thermalBaffleModel", "thermalBaffle");

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(modelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {

        FatalErrorIn
        (
            "thermalBaffleModel::New(const fvMesh&, const dictionary&)"
        )   << "Unknown thermalBaffleModel type " << modelType
            << nl << nl
            <<  "Valid thermalBaffleModel types are:" << nl
            << dictionaryConstructorTablePtr_->sortedToc()
            << exit(FatalError);
    }

    return autoPtr<thermalBaffleModel>(cstrIter()(modelType, mesh, dict));
}

Foam::autoPtr<Foam::phaseModel> Foam::phaseModel::New
(
    const phaseSystem& fluid,
    const word& phaseName
)
{
    word phaseModelType(fluid.subDict(phaseName).lookup("type"));

    Info<< "Selecting phaseModel for "
        << phaseName << ": " << phaseModelType << endl;

    phaseSystemConstructorTable::iterator cstrIter =
        phaseSystemConstructorTablePtr_->find(phaseModelType);

    if (cstrIter == phaseSystemConstructorTablePtr_->end())
    {
        FatalErrorIn("phaseModel::New")
            << "Unknown phaseModelType type "
            << phaseModelType << endl << endl
            << "Valid phaseModel types are : " << endl
            << phaseSystemConstructorTablePtr_->sortedToc()
            << exit(FatalError);
    }

    return cstrIter()(fluid, phaseName);
}

Foam::autoPtr<Foam::wallBoilingModels::nucleationSiteModel>
Foam::wallBoilingModels::nucleationSiteModel::New
(
    const dictionary& dict
)
{
    word nucleationSiteModelType(dict.lookup("type"));

    Info<< "Selecting nucleationSiteModel: "
        << nucleationSiteModelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(nucleationSiteModelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorInFunction
            << "Unknown nucleationSiteModelType type "
            << nucleationSiteModelType << endl << endl
            << "Valid nucleationSiteModel types are : " << endl
            << dictionaryConstructorTablePtr_->sortedToc()
            << exit(FatalError);
    }

    return cstrIter()(dict);
}

Foam::autoPtr<Foam::granularPressureModel> Foam::granularPressureModel::New
(
    const dictionary& dict
)
{
    word granularPressureModelType(dict.lookup("granularPressureModel"));

    Info<< "Selecting granularPressureModel "
        << granularPressureModelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(granularPressureModelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalError
            << "granularPressureModel::New(const dictionary&) : " << endl
            << "    unknown granularPressureModelType type "
            << granularPressureModelType
            << ", constructor not in hash table" << endl << endl
            << "    Valid granularPressureModelType types are :" << endl;
        Info<< dictionaryConstructorTablePtr_->toc() << abort(FatalError);
    }

    return autoPtr<granularPressureModel>(cstrIter()(dict));
}

Foam::autoPtr<Foam::barotropicCompressibilityModel>
Foam::barotropicCompressibilityModel::New
(
    const dictionary& compressibilityProperties,
    const volScalarField& gamma
)
{
    word bcModelTypeName
    (
        compressibilityProperties.lookup("barotropicCompressibilityModel")
    );

    Info<< "Selecting compressibility model "
        << bcModelTypeName << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(bcModelTypeName);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "barotropicCompressibilityModel::New(const volScalarField&)"
        )   << "Unknown barotropicCompressibilityModel type "
            << bcModelTypeName << endl << endl
            << "Valid  barotropicCompressibilityModels are : " << endl
            << dictionaryConstructorTablePtr_->toc()
            << exit(FatalError);
    }

    return autoPtr<barotropicCompressibilityModel>
    (
        cstrIter()(compressibilityProperties, gamma)
    );
}

Foam::autoPtr<Foam::topoSetSource> Foam::topoSetSource::New
(
    const word& topoSetSourceType,
    const polyMesh& mesh,
    const dictionary& dict
)
{
    wordConstructorTable::iterator cstrIter =
        wordConstructorTablePtr_->find(topoSetSourceType);

    if (cstrIter == wordConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "topoSetSource::New(const word&, "
            "const polyMesh&, const dictionary&)"
        )   << "Unknown topoSetSource type " << topoSetSourceType
            << endl << endl
            << "Valid topoSetSource types : " << endl
            << wordConstructorTablePtr_->sortedToc()
            << exit(FatalError);
    }

    return autoPtr<topoSetSource>(cstrIter()(mesh, dict));
}

autoPtr<pointDistributions> pointDistributions::New
(
    const fvMesh& mesh,
    const dictionary& dict
)
{
    word pd( dict.lookup("pointDistribution") );

    pointDistributionsConstructorTable::iterator cstrIter =
            pointDistributionsConstructorTablePtr_->find( pd );

    if (cstrIter == pointDistributionsConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "pointDistributions::New(const dictionary&)"
        )   << "Unknown point distribution: " << pd
            << endl << endl
            << "Valid methods are :" << endl
            << pointDistributionsConstructorTablePtr_->toc()
            << exit(FatalError);
    }

    return autoPtr<pointDistributions>(cstrIter()( mesh, dict));
}

Foam::autoPtr<Foam::thermophysicalFunction> Foam::thermophysicalFunction::New
(
    const dictionary& dict
)
{
    if (debug)
    {
        InfoInFunction
            << "Constructing thermophysicalFunction"
            << endl;
    }

    const word thermophysicalFunctionType(dict.lookup("functionType"));

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(thermophysicalFunctionType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorInFunction
            << "Unknown thermophysicalFunction type "
            << thermophysicalFunctionType
            << nl << nl
            << "Valid thermophysicalFunction types are :" << endl
            << dictionaryConstructorTablePtr_->sortedToc()
            << abort(FatalError);
    }

    return autoPtr<thermophysicalFunction>(cstrIter()(dict));
}

Foam::autoPtr<Foam::solidBodyMotionFunction> Foam::solidBodyMotionFunction::New
(
    const dictionary& SBMFCoeffs,
    const Time& runTime
)
{
    const word motionType(SBMFCoeffs.lookup("solidBodyMotionFunction"));

    Info<< "Selecting solid-body motion function " << motionType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(motionType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorInFunction
            << "Unknown solidBodyMotionFunction type "
            << motionType << nl << nl
            << "Valid solidBodyMotionFunctions are : " << endl
            << dictionaryConstructorTablePtr_->sortedToc()
            << exit(FatalError);
    }

    return autoPtr<solidBodyMotionFunction>(cstrIter()(SBMFCoeffs, runTime));
}

Foam::autoPtr<Foam::heatTransferModel> Foam::heatTransferModel::New
(
    const dictionary& interfaceDict,
    const volScalarField& alpha,
    const phaseModel& phase1,
    const phaseModel& phase2
)
{
    word heatTransferModelType
    (
        interfaceDict.lookup("heatTransferModel" + phase1.name())
    );

    Info<< "Selecting heatTransferModel for phase "
        << phase1.name()
        << ": "
        << heatTransferModelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(heatTransferModelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorIn("heatTransferModel::New")
            << "Unknown heatTransferModelType type "
            << heatTransferModelType << endl << endl
            << "Valid heatTransferModel types are : " << endl
            << dictionaryConstructorTablePtr_->sortedToc()
            << exit(FatalError);
    }

    return cstrIter()(interfaceDict, alpha, phase1, phase2);
}

autoPtr<filmTurbulenceModel> filmTurbulenceModel::New
(
    surfaceFilmModel& model,
    const dictionary& dict
)
{
    const word modelType(dict.lookup("turbulence"));

    Info<< "    Selecting filmTurbulenceModel " << modelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(modelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "filmTurbulenceModel::New"
            "("
                "surfaceFilmModel&, "
                "const dictionary&"
            ")"
        )   << "Unknown filmTurbulenceModel type " << modelType
            << nl << nl << "Valid filmTurbulenceModel types are:" << nl
            << dictionaryConstructorTablePtr_->toc()
            << exit(FatalError);
    }

    return autoPtr<filmTurbulenceModel>(cstrIter()(model, dict));
}

autoPtr<injectionModel> injectionModel::New
(
    const surfaceFilmModel& model,
    const dictionary& dict,
    const word& modelType
)
{
    Info<< "        " << modelType << endl;

    dictionaryConstructorTable::iterator cstrIter =
        dictionaryConstructorTablePtr_->find(modelType);

    if (cstrIter == dictionaryConstructorTablePtr_->end())
    {
        FatalErrorIn
        (
            "injectionModel::New(const surfaceFilmModel&, const dictionary&)"
        )   << "Unknown injectionModel type " << modelType
            << nl << nl << "Valid injectionModel types are:" << nl
            << dictionaryConstructorTablePtr_->toc()
            << exit(FatalError);
    }

    return autoPtr<injectionModel>(cstrIter()(model, dict));
}