libmesh5.c

FreeFem++可以生成高质量的有限元网格。可以用于流体力学

        for(i=0;i<kwd->NmbTyp;i++)
            TypTab[i] = kwd->TypTab[i];

        va_end(par);
    }

    return(kwd->NmbLin);
}


/*----------------------------------------------------------*/
/* Set the current file position to a given kwd                */
/*----------------------------------------------------------*/

int GmfGotoKwd(int MshIdx, int KwdCod)
{
    GmfMshSct *msh;
    KwdSct *kwd;

    if( (MshIdx < 1) || (MshIdx > MaxMsh) )
        return(0);

    msh = MshTab[ MshIdx ];

    if( (KwdCod < 1) || (KwdCod > GmfMaxKwd) )
        return(0);

    kwd = &msh->KwdTab[ KwdCod ];

    if(!kwd->NmbLin)
        return(0);

    fseek(msh->hdl, kwd->pos, SEEK_SET);
    return 0;
}


/*----------------------------------------------------------*/
/* Write the kwd and set the number of lines                */
/*----------------------------------------------------------*/

int GmfSetKwd(int MshIdx, int KwdCod, ...)
{
    int i, CurPos, NmbLin=0, NulPos=0,  *TypTab;
    va_list par;
    GmfMshSct *msh;
    KwdSct *kwd;

    if( (MshIdx < 1) || (MshIdx > MaxMsh) )
        return(0);

    msh = MshTab[ MshIdx ];

    if( (KwdCod < 1) || (KwdCod > GmfMaxKwd) )
        return(0);

    kwd = &msh->KwdTab[ KwdCod ];

    /* Read further arguments if this kw has a header */

    if(strlen(KwdFmt[ KwdCod ][1]))
    {
        va_start(par, KwdCod);
        NmbLin = va_arg(par, int);

        if(!strcmp(KwdFmt[ KwdCod ][2], "sr"))
        {
            kwd->NmbTyp = va_arg(par, int);
            TypTab = va_arg(par, int *);

            for(i=0;i<kwd->NmbTyp;i++)
                kwd->TypTab[i] = TypTab[i];
        }

        va_end(par);
    }

    /* Setup the kwd info */

    ExpFmt(msh, KwdCod);

    if(!kwd->typ)
        return(0);
    else if(kwd->typ == InfKwd)
        kwd->NmbLin = 1;
    else
        kwd->NmbLin = NmbLin;

    /* Store the next kwd position in binary file */

    if( (msh->typ & Bin) && msh->NexKwdPos )
    {
        CurPos = ftell(msh->hdl);
        fseek(msh->hdl, msh->NexKwdPos, SEEK_SET);
        RecWrd(msh, (unsigned char *)&CurPos);
        fseek(msh->hdl, CurPos, SEEK_SET);
    }

    /* Write the header */

    if(msh->typ & Asc)
    {
        fprintf(msh->hdl, "\n%s\n", KwdFmt[ KwdCod ][0]);

        if(kwd->typ != InfKwd)
            fprintf(msh->hdl, "%d\n", kwd->NmbLin);

        /* In case of solution field, write the extended header */

        if(kwd->typ == SolKwd)
        {
            fprintf(msh->hdl, "%d ", kwd->NmbTyp);

            for(i=0;i<kwd->NmbTyp;i++)
                fprintf(msh->hdl, "%d ", kwd->TypTab[i]);

            fprintf(msh->hdl, "\n\n");
        }
    }
    else
    {
        RecWrd(msh, (unsigned char *)&KwdCod);
        msh->NexKwdPos = ftell(msh->hdl);
        RecWrd(msh, (unsigned char *)&NulPos);

        if(kwd->typ != InfKwd)
            RecWrd(msh, (unsigned char *)&kwd->NmbLin);

        /* In case of solution field, write the extended header at once */

        if(kwd->typ == SolKwd)
        {
            RecWrd(msh, (unsigned char *)&kwd->NmbTyp);

            for(i=0;i<kwd->NmbTyp;i++)
                RecWrd(msh, (unsigned char *)&kwd->TypTab[i]);
        }
    }

    return(kwd->NmbLin);
}


/*----------------------------------------------------------*/
/* Read a full line from the current kwd                    */
/*----------------------------------------------------------*/

int GmfGetLin(int MshIdx, int KwdCod, ...)
{
    double *DblPtr, *DblSolTab;
    float *FltPtr, *FltSolTab;
    int i, j, *IntPtr;
    va_list par;
    GmfMshSct *msh = MshTab[ MshIdx ];
    KwdSct *kwd = &msh->KwdTab[ KwdCod ];

    /* Start decoding the arguments */

    va_start(par, KwdCod);

    if(kwd->typ != SolKwd)
    {
        if(msh->ver == 1)
        {
            if(msh->typ & Asc)
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        FltPtr = va_arg(par, float *);
                        fscanf(msh->hdl, "%f", FltPtr);
                    }
                    else
                    {
                        IntPtr = va_arg(par, int *);
                        fscanf(msh->hdl, "%d", IntPtr);
                    }
                }
            }
            else
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        FltPtr = va_arg(par, float *);
                        ScaWrd(msh, (unsigned char *)FltPtr);
                    }
                    else
                    {
                        IntPtr = va_arg(par, int *);
                        ScaWrd(msh, (unsigned char *)IntPtr);
                    }
                }
            }
        }
        else
        {
            if(msh->typ & Asc)
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        DblPtr = va_arg(par, double *);
                        fscanf(msh->hdl, "%lf", DblPtr);
                    }
                    else
                    {
                        IntPtr = va_arg(par, int *);
                        fscanf(msh->hdl, "%d", IntPtr);
                    }
                }
            }
            else
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        DblPtr = va_arg(par, double *);
                        ScaDblWrd(msh, (unsigned char *)DblPtr);
                    }
                    else
                    {
                        IntPtr = va_arg(par, int *);
                        ScaWrd(msh, (unsigned char *)IntPtr);
                    }
                }
            }
        }
    }
    else
    {
        if(msh->ver == 1)
        {
            FltSolTab = va_arg(par, float *);

            if(msh->typ & Asc)
                for(j=0;j<kwd->SolSiz;j++)
                    fscanf(msh->hdl, "%f", &FltSolTab[j]);
            else
                for(j=0;j<kwd->SolSiz;j++)
                    ScaWrd(msh, (unsigned char *)&FltSolTab[j]);
        }
        else if(msh->ver == 2)
        {
            DblSolTab = va_arg(par, double *);

            if(msh->typ & Asc)
                for(j=0;j<kwd->SolSiz;j++)
                    fscanf(msh->hdl, "%lf", &DblSolTab[j]);
            else
                for(j=0;j<kwd->SolSiz;j++)
                    ScaDblWrd(msh, (unsigned char *)&DblSolTab[j]);
        }
    }

    va_end(par);

    /* return the number of arguments filled */

    return(kwd->SolSiz);
}


/*----------------------------------------------------------*/
/* Write a full line from the current kwd                    */
/*----------------------------------------------------------*/

int GmfSetLin(int MshIdx, int KwdCod, ...)
{
    double d, *DblSolTab;
    float f, *FltSolTab;
    int i, j;
    va_list par;
    GmfMshSct *msh = MshTab[ MshIdx ];
    KwdSct *kwd = &msh->KwdTab[ KwdCod ];

    /* Start decoding the arguments */

    va_start(par, KwdCod);

    if(kwd->typ != SolKwd)
    {
        if(msh->ver == 1)
        {
            if(msh->typ & Asc)
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        d = va_arg(par, double);
                        fprintf(msh->hdl, "%g ", (float)d);
                    }
                    else
                    {
                        j = va_arg(par, int);
                        fprintf(msh->hdl, "%d ", j);
                    }
                }
            }
            else
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        d = va_arg(par, double);
                        f = d;
                        RecWrd(msh, (unsigned char *)&f);
                    }
                    else
                    {
                        j = va_arg(par, int);
                        RecWrd(msh, (unsigned char *)&j);
                    }
                }
            }
        }
        else
        {
            if(msh->typ & Asc)
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        d = va_arg(par, double);
                        fprintf(msh->hdl, "%.15lg ", d);
                    }
                    else
                    {
                        j = va_arg(par, int);
                        fprintf(msh->hdl, "%d ", j);
                    }
                }
            }
            else
            {
                for(i=0;i<kwd->SolSiz;i++)
                {
                    if(kwd->fmt[i] == 'r')
                    {
                        d = va_arg(par, double);
                        RecDblWrd(msh, (unsigned char *)&d);
                    }
                    else
                    {
                        j = va_arg(par, int);
                        RecWrd(msh, (unsigned char *)&j);
                    }
                }
            }
        }
    }
    else
    {
        if(msh->ver == 1)
        {
            FltSolTab = va_arg(par, float *);

            if(msh->typ & Asc)
                for(j=0;j<kwd->SolSiz;j++)
                    fprintf(msh->hdl, "%g ", FltSolTab[j]);
            else
                for(j=0;j<kwd->SolSiz;j++)
                    RecWrd(msh, (unsigned char *)&FltSolTab[j]);
        }
        else if(msh->ver == 2)
        {
            DblSolTab = va_arg(par, double *);

            if(msh->typ & Asc)
                for(j=0;j<kwd->SolSiz;j++)
                    fprintf(msh->hdl, "%.15lg ", DblSolTab[j]);
            else
                for(j=0;j<kwd->SolSiz;j++)
                    RecDblWrd(msh, (unsigned char *)&DblSolTab[j]);
        }
    }

    va_end(par);

    if(msh->typ & Asc)
        fprintf(msh->hdl, "\n");

    /* return the number of arguments filled */

    return(kwd->SolSiz);
}


/*----------------------------------------------------------*/
/*----------------------------------------------------------*/

int GmfCpyLin(int InpIdx, int OutIdx, int KwdCod)
{
    double d;
    float f;
    int i, a;
    GmfMshSct *InpMsh = MshTab[ InpIdx ], *OutMsh = MshTab[ OutIdx ];
    KwdSct *kwd = &InpMsh->KwdTab[ KwdCod ];

    for(i=0;i<kwd->SolSiz;i++)
    {