bool Foam::simpleControl::criteriaSatisfied()
{
    if (residualControl_.empty())
    {
        return false;
    }

    bool achieved = true;
    const dictionary& solverDict = mesh_.solverPerformanceDict();

    forAllConstIter(dictionary, solverDict, iter)
    {
        const word& variableName = iter().keyword();
        label fieldI = applyToField(variableName);
        if (fieldI != -1)
        {
            const List<lduMatrix::solverPerformance> sp(iter().stream());
            const scalar residual = sp.first().initialResidual();

            bool absCheck = residual < residualControl_[fieldI].absTol;
            achieved = achieved && absCheck;

            if (debug)
            {
                Info<< algorithmName_ << " solution statistics:" << endl;

                Info<< "    " << variableName << ": tolerance = " << residual
                    << " (" << residualControl_[fieldI].absTol << ")"
                    << endl;
            }
        }
    }

    return achieved;
}
Example #2
0
bool Foam::steadyStateControl::criteriaSatisfied()
{
    if (residualControl_.empty())
    {
        return false;
    }

    Time& time = const_cast<Time&>(mesh_.time());
    if (debug)
    {
        Info<<"Time: "<< time.timeName() <<"    Iteration: "<<iter_counter<<nl;
    }

    bool achieved = true;
    bool checked = false;    // safety that some checks were indeed performed

    const dictionary& solverDict = mesh_.solverPerformanceDict();
    forAllConstIter(dictionary, solverDict, iter)
    {
        const word& variableName = iter().keyword();
        const label fieldI = applyToField(variableName);
        if (fieldI != -1)
        {
            scalar lastResidual = 0;
            const scalar residual =
                this->maxResidual(variableName, iter().stream(), lastResidual);

            //const List<solverPerformance> sp(iter().stream());
            //const scalar residual = sp.first().initialResidual();

            checked = true;

            bool absCheck = residual < residualControl_[fieldI].absTol;
            achieved = achieved && absCheck;

            if (debug)
            {
                Info<< algorithmName_ << " solution statistics:";

                Info<< "    " << variableName << ": tolerance = " << residual
                    << " (" << residualControl_[fieldI].absTol << ")"
                    << endl;
            }
        }
    }
    mesh_.clearSolverPerformanceDict();
    initialised_ = false;


    return checked && achieved;
}
Example #3
0
bool Foam::pimpleControl::criteriaSatisfied()
{
    // no checks on first iteration - nothing has been calculated yet
    if ((corr_ == 1) || residualControl_.empty() || finalIter())
    {
        return false;
    }


    bool storeIni = this->storeInitialResiduals();

    bool achieved = true;
    bool checked = false;    // safety that some checks were indeed performed

    const dictionary& solverDict = mesh_.solverPerformanceDict();
    forAllConstIter(dictionary, solverDict, iter)
    {
        const word& variableName = iter().keyword();
        const label fieldi = applyToField(variableName);
        if (fieldi != -1)
        {
            scalar residual = 0;
            const scalar firstResidual =
                maxResidual(variableName, iter().stream(), residual);

            checked = true;

            if (storeIni)
            {
                residualControl_[fieldi].initialResidual = firstResidual;
            }

            const bool absCheck = residual < residualControl_[fieldi].absTol;
            bool relCheck = false;

            scalar relative = 0.0;
            if (!storeIni)
            {
                const scalar iniRes =
                    residualControl_[fieldi].initialResidual
                  + ROOTVSMALL;

                relative = residual/iniRes;
                relCheck = relative < residualControl_[fieldi].relTol;
            }

            achieved = achieved && (absCheck || relCheck);

            if (debug)
            {
                Info<< algorithmName_ << " loop:" << endl;

                Info<< "    " << variableName
                    << " PIMPLE iter " << corr_
                    << ": ini res = "
                    << residualControl_[fieldi].initialResidual
                    << ", abs tol = " << residual
                    << " (" << residualControl_[fieldi].absTol << ")"
                    << ", rel tol = " << relative
                    << " (" << residualControl_[fieldi].relTol << ")"
                    << endl;
            }
        }
    }

    return checked && achieved;
}
bool Foam::pimpleControl::criteriaSatisfied()
{
    if ((corr_ == 0) || residualControl_.empty() || finalIter())
    {
        return false;
    }

    bool firstIter = corr_ == 1;

    bool achieved = true;
    const dictionary& solverDict = mesh_.solverPerformanceDict();

    forAllConstIter(dictionary, solverDict, iter)
    {
        const word& variableName = iter().keyword();
        label fieldI = applyToField(variableName);
        if (fieldI != -1)
        {
            const List<lduMatrix::solverPerformance> sp(iter().stream());
            const scalar residual = sp.last().initialResidual();

            if (firstIter)
            {
                residualControl_[fieldI].initialResidual =
                    sp.first().initialResidual();
            }

            bool absCheck = residual < residualControl_[fieldI].absTol;

            bool relCheck = false;

            scalar relative = 0.0;
            if (!firstIter)
            {
                scalar iniRes =
                    residualControl_[fieldI].initialResidual
                  + ROOTVSMALL;

                relative = residual/iniRes;

                relCheck = relative < residualControl_[fieldI].relTol;
            }

            achieved = achieved && (absCheck || relCheck);

            if (debug)
            {
                Info<< algorithmName_ << "loop statistics:" << endl;

                Info<< "    " << variableName << " iter " << corr_
                    << ": ini res = "
                    << residualControl_[fieldI].initialResidual
                    << ", abs tol = " << residual
                    << " (" << residualControl_[fieldI].absTol << ")"
                    << ", rel tol = " << relative
                    << " (" << residualControl_[fieldI].relTol << ")"
                    << endl;
            }
        }
    }

    return achieved;
}