getdp.l

cfd求解器使用与gmsh网格的求解

%{
/* $Id: GetDP.l,v 1.44 2006/03/10 18:09:23 geuzaine Exp $ */
/*
 * Copyright (C) 1997-2006 P. Dular, C. Geuzaine
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA.
 *
 * Please report all bugs and problems to <[e-mail]>.
 *
 * Contributor(s):
 *   Ruth Sabariego
 *   Johan Gyselinck
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "Data_Passive.h"
#include "Malloc.h"
#include "Parser.h"
#include "GetDP.tab.h"

extern long int  yylinenum ;
extern int       yycolnum, yyincludenum ;

/* 
   Redefinition of YY_INPUT to allow input character count. 
   This is slower than fread(), but the .pro files are
   never that big...
 */

#ifdef YY_INPUT
#undef YY_INPUT
#endif
#define YY_INPUT(buf,result,max_size) {			\
  int c = getc(yyin);					\
  yycolnum++;						\
  result = (c == EOF) ? YY_NULL : (buf[0] = c, 1);	\
}

%}

alpha      [a-zA-Z\_\.]
digit      [0-9]
exp        [Ee][-+]?{digit}+
string     {alpha}({alpha}|{digit})*

%e      2000
%p      6000
%n      1000
%k       150
%a      3000
%o      2500
%%

[\ \t\r\f]                   /* nothing to do */ ;
[\n]                         { yycolnum = 0 ; yylinenum++ ; }
<<EOF>>                      { yyincludenum = 0 ; return(0); }

";"                          return tEND ; 
"/*"                         C_comments() ;
"//"                         CC_comments() ;
"\""                         { parsestring('\"'); return tBIGSTR; }

"="                          return tDEF ;
"*^"                         return tCROSSPRODUCT ;
"/\\"                        return tCROSSPRODUCT ;
"||"                         return tOR ;
"&&"                         return tAND ;
"=="                         return tEQUAL ;
"!="                         return tNOTEQUAL ;
"~="                         return tAPPROXEQUAL ;
"<="                         return tLESSOREQUAL ;
">="                         return tGREATEROREQUAL ;
">>"                         return tGREATERGREATER ;
"<<"                         return tLESSLESS ;
"..."                        return tDOTS ;
":"                          return tDOTS ;
"##"                         return tSHOW ;

StrCat                       return tStrCat ;
Sprintf                      return tSprintf ;
Printf                       return tPrintf ;
Read                         return tRead ;

Pi                           return tPi ;
0D                           return t0D ;
1D                           return t1D ;
2D                           return t2D ;
3D                           return t3D ;

Include                      return tInclude;
#include                     return tInclude;

Constant                     return tConstant ;
Const                        return tConstant ;

Group                        return tGroup ;
DefineGroup                  return tDefineGroup ;
All                          return tAll ;
InSupport                    return tInSupport ;
MovingBand2D                 return tMovingBand2D ;
SaveMesh                     return tSaveMesh ;
DeformeMesh                  return tDeformeMesh ;

DefineFunction               return tDefineFunction ;
DefineVariable               return tDefineConstant ;
DefineConstant               return tDefineConstant ;

List                         return tList ;
ListAlt                      return tListAlt ;
ListFromFile                 return tListFromFile ;

Exp                          return tExp ;
Log                          return tLog ;
Log10                        return tLog10 ;
Sqrt                         return tSqrt ;
Sin                          return tSin ;
ASin                         return tAsin ;
Cos                          return tCos ;
ACos                         return tAcos ;
Tan                          return tTan ; 
Atan                         return tAtan ;
Atan2                        return tAtan2 ;
Sinh                         return tSinh ;
Cosh                         return tCosh ;
Tanh                         return tTanh ;
Fabs                         return tFabs ;
Floor                        return tFloor ;
Ceil                         return tCeil ;
Fmod                         return tFmod ;
Modulo                       return tModulo ;
Hypot                        return tHypot ;
Cross                        return tCrossProduct ;
CrossProduct                 return tCrossProduct ;
SolidAngle                   return tSolidAngle ;
Order                        return tOrder ;
Trace                        return tTrace ;
DofValue                     return tDofValue ;
LinSpace                     return tLinSpace ;
LogSpace                     return tLogSpace ;

MHTransform                  return tMHTransform;
MHJacNL                      return tMHJacNL;

Constraint                   return tConstraint ;
Region                       return tRegion ;
SubRegion                    return tSubRegion ;
RegionRef                    return tRegionRef ;
SubRegionRef                 return tSubRegionRef ;
Coefficient                  return tCoefficient ;
Filter                       return tFilter ;
Value                        return tValue ;
TimeFunction                 return tTimeFunction ;
Branch                       return tBranch ;
Loop                         return tLoop ;
Node                         return tNode ;
NameOfResolution             return tNameOfResolution ;

Jacobian                     return tJacobian ;
Case                         return tCase ;

Integration                  return tIntegration ;
FMMIntegration               return tFMMIntegration ;
Matrix                       return tMatrix ;
Criterion                    return tCriterion ;
GeoElement                   return tGeoElement ;
NumberOfPoints               return tNumberOfPoints ;
MaxNumberOfPoints            return tMaxNumberOfPoints ;
NumberOfDivisions            return tNumberOfDivisions ;
MaxNumberOfDivisions         return tMaxNumberOfDivisions ;
StoppingCriterion            return tStoppingCriterion ;

FunctionSpace                return tFunctionSpace ;
Name                         return tName ;
Type                         return tType ;
SubType                      return tSubType ;
BasisFunction                return tBasisFunction ;
NameOfCoef                   return tNameOfCoef ;
Function                     return tFunction ;
dFunction                    return tdFunction ;
SubFunction                  return tSubFunction ;
SubdFunction                 return tSubdFunction ;
Support                      return tSupport ;
Entity                       return tEntity ;
SubSpace                     return tSubSpace ;
NameOfBasisFunction          return tNameOfBasisFunction ;
GlobalQuantity               return tGlobalQuantity ;
EntityType                   return tEntityType ;
EntitySubType                return tEntitySubType ;
NameOfConstraint             return tNameOfConstraint ;

Formulation                  return tFormulation ;
Quantity                     return tQuantity ;
NameOfSpace                  return tNameOfSpace ;
IndexOfSystem                return tIndexOfSystem ;
Symmetry                     return tSymmetry ;
Equation                     return tEquation ;
Galerkin                     return tGalerkin ;
deRham                       return tdeRham ;
DiscreteGeometry             return tDiscreteGeometry ;

Dt                           return tDt ;
DtDof                        return tDtDof ;
DtDt                         return tDtDt ;
DtDtDof                      return tDtDtDof ;
JacNL                        return tJacNL ;
NeverDt                      return tNeverDt ;
DtNL                         return tDtNL ;
AtAnteriorTimeStep           return tAtAnteriorTimeStep ;

In                           return tIn ;
Full_Matrix                  return tFull_Matrix ;
GlobalTerm                   return tGlobalTerm ;
GlobalEquation               return tGlobalEquation ;

Resolution                   return tResolution ;
System                       return tDefineSystem ;
NameOfFormulation            return tNameOfFormulation ;
NameOfMesh                   return tNameOfMesh ;
Frequency                    return tFrequency ;
DummyFrequency               return tDummyFrequency ;
Solver                       return tSolver ;
OriginSystem                 return tOriginSystem ;
DestinationSystem            return tDestinationSystem ;

Operation                    return tOperation ;
OperationEnd                 return tOperationEnd ;
SetTime                      return tSetTime ;
SetFrequency                 return tSetFrequency ;
Update                       return tUpdate ;
UpdateConstraint             return tUpdateConstraint ;
Generate_FMMGroups           return tGenerateFMMGroups ;
GenerateOnly                 return tGenerateOnly ;
GenerateOnlyJac              return tGenerateOnlyJac ;
FourierTransform             return tFourierTransform ;
FourierTransformJ            return tFourierTransformJ ;
Lanczos                      return tLanczos ;
EigenSolve                   return tEigenSolve ;
EigenSolveJac                return tEigenSolveJac ;
Evaluate                     return tEvaluate ;
Test                         return tIf ;
TimeLoopTheta                return tTimeLoopTheta ;
TimeLoopNewmark              return tTimeLoopNewmark ;
Time0                        return tTime0 ;
TimeMax                      return tTimeMax ;
DTime                        return tDTime ;
Theta                        return tTheta ;