Beispiel #1
0
double gradSolver(double *A, double *b, double *x, int n, double e,
        int it, double *timeGrad, double *timeError){
    int i = 0;
    double prev_norm, norm;
    double *r = (double *) malloc(n*sizeof(double));


    memset(x, 0, n*sizeof(double));
    *timeGrad = *timeError = 0.0;

    *timeError -= timestamp();
    residue(A, b, x, r, n);
    *timeError += timestamp();
    prev_norm = residualNorm(r, n);

    double absErr = e + 1.0;
    while ((fabs(absErr) > e) && (i++<it)){
        *timeGrad -= timestamp();
        calcGrad(A, x, r, n);
        *timeGrad += timestamp();
        *timeError -= timestamp();
        residue(A, b, x, r, n);
        *timeError += timestamp();
        norm = residualNorm(r, n);
        absErr = norm - prev_norm;
        prev_norm = norm;
    }

    //*timeGrad /= i;

    free(r);
    return norm;
}
Beispiel #2
0
Foam::tmp
<
    Foam::GeometricField
    <
        typename Foam::outerProduct<Foam::vector, Type>::type,
        Foam::fvPatchField,
        Foam::volMesh
    >
>
Foam::fv::gradScheme<Type>::grad
(
    const GeometricField<Type, fvPatchField, volMesh>& vsf,
    const word& name
) const
{
    typedef typename outerProduct<vector, Type>::type GradType;
    typedef GeometricField<GradType, fvPatchField, volMesh> GradFieldType;

    if (!this->mesh().changing() && this->mesh().cache(name))
    {
        if (!mesh().objectRegistry::template foundObject<GradFieldType>(name))
        {
            cachePrintMessage("Calculating and caching", name, vsf);
            tmp<GradFieldType> tgGrad = calcGrad(vsf, name);
            regIOobject::store(tgGrad.ptr());
        }

        cachePrintMessage("Retreiving", name, vsf);
        GradFieldType& gGrad = const_cast<GradFieldType&>
        (
            mesh().objectRegistry::template lookupObject<GradFieldType>(name)
        );

        if (gGrad.upToDate(vsf))
        {
            return gGrad;
        }
        else
        {
            cachePrintMessage("Deleting", name, vsf);
            gGrad.release();
            delete &gGrad;

            cachePrintMessage("Recalculating", name, vsf);
            tmp<GradFieldType> tgGrad = calcGrad(vsf, name);

            cachePrintMessage("Storing", name, vsf);
            regIOobject::store(tgGrad.ptr());
            GradFieldType& gGrad = const_cast<GradFieldType&>
            (
                mesh().objectRegistry::template lookupObject<GradFieldType>
                (
                    name
                )
            );

            return gGrad;
        }
    }
    else
    {
        if (mesh().objectRegistry::template foundObject<GradFieldType>(name))
        {
            GradFieldType& gGrad = const_cast<GradFieldType&>
            (
                mesh().objectRegistry::template lookupObject<GradFieldType>
                (
                    name
                )
            );

            if (gGrad.ownedByRegistry())
            {
                cachePrintMessage("Deleting", name, vsf);
                gGrad.release();
                delete &gGrad;
            }
        }

        cachePrintMessage("Calculating", name, vsf);
        return calcGrad(vsf, name);
    }
}
Foam::tmp
<
Foam::GeometricField
<
typename Foam::outerProduct<Foam::vector, Type>::type,
         Foam::fvPatchField,
         Foam::volMesh
         >
         >
         Foam::fv::gradScheme<Type>::grad
         (
             const GeometricField<Type, fvPatchField, volMesh>& vsf,
             const word& name
         ) const
{
    typedef typename outerProduct<vector, Type>::type GradType;
    typedef GeometricField<GradType, fvPatchField, volMesh> GradFieldType;

    if (!this->mesh().changing() && this->mesh().schemesDict().cache(name))
    {
        if (!mesh().objectRegistry::template foundObject<GradFieldType>(name))
        {
            if (fvSchemes::debug)
            {
                Info << "Cache: Calculating and caching " << name
                     << " originating from " << vsf.name()
                     << " event No. " << vsf.eventNo()
                     << endl;
            }
            tmp<GradFieldType> tgGrad = calcGrad(vsf, name);
            regIOobject::store(tgGrad.ptr());
        }

        if (fvSchemes::debug)
        {
            Info << "Cache: Retrieving " << name
                 << " originating from " << vsf.name()
                 << " event No. " << vsf.eventNo()
                 << endl;
        }
        GradFieldType& gGrad = const_cast<GradFieldType&>
                               (
                                   mesh().objectRegistry::template lookupObject<GradFieldType>(name)
                                                                               );

        if (gGrad.upToDate(vsf.name()))
        {
            return gGrad;
        }
        else
        {
            if (fvSchemes::debug)
            {
                Info << "Cache: Deleting " << name
                     << " originating from " << vsf.name()
                     << " event No. " << vsf.eventNo()
                     << endl;
            }
            gGrad.release();
            delete &gGrad;

            if (fvSchemes::debug)
            {
                Info << "Cache: Recalculating " << name
                     << " originating from " << vsf.name()
                     << " event No. " << vsf.eventNo()
                     << endl;
            }
            tmp<GradFieldType> tgGrad = calcGrad(vsf, name);

            if (fvSchemes::debug)
            {
                Info << "Cache: Storing " << name
                     << " originating from " << vsf.name()
                     << " event No. " << vsf.eventNo()
                     << endl;
            }
            regIOobject::store(tgGrad.ptr());
            GradFieldType& gGrad = const_cast<GradFieldType&>
                                   (
                                       mesh().objectRegistry::template lookupObject<GradFieldType>
                                       (
                                           name
                                       )
                                                                                   );

            return gGrad;
        }
    }
    else
    {
        if (mesh().objectRegistry::template foundObject<GradFieldType>(name))
        {
            GradFieldType& gGrad = const_cast<GradFieldType&>
                                   (
                                       mesh().objectRegistry::template lookupObject<GradFieldType>
                                       (
                                           name
                                       )
                                                                                   );

            if (gGrad.ownedByRegistry())
            {
                if (fvSchemes::debug)
                {
                    Info << "Cache: Deleting " << name
                         << " originating from " << vsf.name()
                         << " event No. " << vsf.eventNo()
                         << endl;
                }
                gGrad.release();
                delete &gGrad;
            }
        }

        if (fvSchemes::debug)
        {
            Info << "Cache: Calculating " << name
                 << " originating from " << vsf.name()
                 << " event No. " << vsf.eventNo()
                 << endl;
        }
        return calcGrad(vsf, name);
    }
}
Beispiel #4
0
void SubSystem::calcGrad(Eigen::VectorXd &grad)
{
    calcGrad(plist, grad);
}