getdp.l

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

Beta                         return tBeta ;
Gamma                        return tGamma ;
IterativeLoop                return tIterativeLoop ;
NbrMaxIteration              return tNbrMaxIteration ;
RelaxationFactor             return tRelaxationFactor ;
IterativeTimeReduction       return tIterativeTimeReduction ;
DivisionCoefficient          return tDivisionCoefficient ;
ChangeOfState                return tChangeOfState ;
ChangeOfCoordinates          return tChangeOfCoordinates ;
ChangeOfCoordinates2         return tChangeOfCoordinates2 ;
ChangeOfValues               return tChangeOfValues ;
SystemCommand                return tSystemCommand ;
Break                        return tBreak ;
SolveJac_AdaptRelax          return tSolveJac_AdaptRelax ;
SaveSolutionExtendedMH       return tSaveSolutionExtendedMH ;
SaveSolutionMHtoTime         return tSaveSolutionMHtoTime ;
Init_MovingBand2D            return tInit_MovingBand2D ;
Mesh_MovingBand2D            return tMesh_MovingBand2D ;
Generate_MH_Moving           return tGenerate_MH_Moving ;
Generate_MH_Moving_Separate  return tGenerate_MH_Moving_Separate ;
Add_MH_Moving                return tAdd_MH_Moving ;
GenerateGroup                return tGenerateGroup ;
GenerateJacGroup             return tGenerateJacGroup ;

PostProcessing               return tPostProcessing ;
NameOfSystem                 return tNameOfSystem ;

PostOperation                return tPostOperation ;
NameOfPostProcessing         return tNameOfPostProcessing ;
UsingPost                    return tUsingPost ;
Append                       return tAppend ;
Plot                         return tPlot ;
Print                        return tPrint ;
PrintGroup                   return tPrintGroup ;
Echo                         return tEcho ;
Adapt                        return tAdapt ;
Write                        return tWrite ;
OnGlobal                     return tOnGlobal ;
OnRegion                     return tOnRegion ;
OnElementsOf                 return tOnElementsOf ;
OnGrid                       return tOnGrid ;
OnCut                        return tOnSection ;
OnSection                    return tOnSection ;
OnPoint                      return tOnPoint ;
OnLine                       return tOnLine ;
OnPlane                      return tOnPlane ;
OnBox                        return tOnBox ;
WithArgument                 return tWithArgument ;
Smoothing                    return tSmoothing ;
Skin                         return tSkin ;
Format                       return tFormat ;
Footer                       return tFooter ;
Header                       return tHeader ;
Depth                        return tDepth ;
Dimension                    return tDimension ;
Comma                        return tComma ;
HarmonicToTime               return tHarmonicToTime ;
TimeStep                     return tTimeStep ;
Target                       return tTarget ;
File                         return tFile ;
Sort                         return tSort ;
Iso                          return tIso ;
NoNewLine                    return tNoNewLine ;
TimeLegend                   return tTimeLegend ;
FrequencyLegend              return tFrequencyLegend ;
EigenvalueLegend             return tEigenvalueLegend ;
EvaluationPoints             return tEvaluationPoints ;
Store                        return tStore ;
LastTimeStepOnly             return tLastTimeStepOnly ;

If                           return tIf ;
Else                         return tElse ;
EndIf                        return tEndIf ;
For                          return tFor ;
EndFor                       return tEndFor ;

DecomposeInSimplex           return tDecomposeInSimplex ;
Str                          return tStr ;
Date                         return tDate ;

Flag                         return tFlag ;

Help                         return tHelp ;
Check                        return tCheck ;
Cpu                          return tCpu ;

EquationTerm                 return tEquation ;
PostQuantity                 return tQuantity ;
Integral                     return tGalerkin ;

{digit}+                     { yylval.i = atoi(yytext) ; return tINT ; }

{digit}+"."{digit}*({exp})? |
{digit}*"."{digit}+({exp})? |
{digit}+{exp}                { yylval.d = atof(yytext) ; return tFLOAT ; }

{string}                     { yylval.c = strsave((char*)yytext) ; return tSTRING ; }

.                            return yytext[0] ;

%%

#undef yywrap

int yywrap() {
  return(1);
}

#ifdef __cplusplus
#define input yyinput
#endif

void  C_comments(void) {
  int c;

  while(1) {
    while((c = input()) != '*'){ 
      if(c == '\n') yylinenum++ ; 
      if(c == EOF) {
        fprintf(stderr, "Error: End of file in commented region\n") ;
        exit(1);
      }
    } 
    if((c = input()) == '/') return ;
    unput(c) ;
  }
}

void  CC_comments(void) {
  int c;
  while(1){ 	 
    c = input(); 	 
    if(c == '\n' || c == EOF) break; 	 
  }
  yylinenum++ ; 
}

void  parsestring(char endchar) {
  int c, i;
  char tmp[2048];

  c = input();  
  i = 0;
  while(c != endchar){ 
    if(c == EOF) { 
      Msg(GERROR, "End of file in string") ;
      yycolnum=0 ; 
      break;
    }
    else if(c == '\n') { 
      yycolnum=0 ; 
    }
    else if(i >= (int)sizeof(tmp)-1) {
      Msg(GERROR, "String too long") ;
      break;
    }
    else { 
      tmp[i++] = c; 
    }
    c = input(); 
  }
  tmp[i] = '\0';
  yylval.c = strsave(tmp);
}

char *strsave(char *string) {
  return ((char *)strcpy((char *)Malloc(strlen(string)+1), string));
}

void skip_until(char *skip, char *until){
  int i, nb_skip;
  int l, l_skip, l_until;
  char chars[256];
  int c_next, c_next_skip, c_next_until;

  nb_skip = 0 ;

  if(skip)
    l_skip = strlen(skip);
  else
    l_skip = 0 ;

  l_until = strlen(until);

  while(1){
    while (1){
      chars[0] = input();
      if(chars[0] == '\n') yylinenum++ ; 
      if(chars[0] == (char)EOF){
        Msg(GERROR, "Unexpected end of file") ;
	return;
      }
      if(chars[0] == '/'){
        c_next = input();
        if     (c_next ==  '*') C_comments();
        else if(c_next ==  '/') CC_comments();
        else unput(c_next);
      }
      if(chars[0] == until[0]) break;
      if(skip && chars[0] == skip[0]) break;
    }

    l = (l_skip > l_until) ? l_skip : l_until ;
    if(l >= (int)sizeof(chars)){
      Msg(GERROR, "Search pattern too long in skip_until");
      return;
    }
    for(i = 1 ; i < l ; i++){
      chars[i] = input();
      if(chars[i] == '\n') yylinenum++ ; 
      if(chars[i] == (char)EOF){
	l = i;
	break;
      }
    }

    c_next = input(); unput(c_next);
    c_next_skip = (l_skip<l)? chars[l_skip] : c_next;
    c_next_until = (l_until<l)? chars[l_until] : c_next;

    if(!strncmp(chars,until,l_until)
       && (!(c_next_until>='a' && c_next_until<='z')
           && !(c_next_until>='A' && c_next_until<='Z')
           && c_next_until!='_' )
      ){
      if(!nb_skip){
	return;
      }
      else{
	nb_skip--;
      }
    }
    else if(skip && !strncmp(chars,skip,l_skip)
       && (!(c_next_skip>='a' && c_next_skip<='z')
           && !(c_next_skip>='A' && c_next_skip<='Z')
           && c_next_skip!='_' )
    ){
      nb_skip++;
    }
    else{
      for(i = 1; i < l - 1; i++){
	unput(chars[l-i]);
        if(chars[l-i] == '\n') yylinenum-- ;
      }
    }

  }
}

void hack_fsetpos_printf(void) {
  char chars[5];
  int c = input(), c2 = input(), c3 = input();
  unput(c3); unput(c2); unput(c);
  chars[0] = c; chars[1] = c2; chars[2] = c3; chars[3] = 0;
  printf("++++++ c: %d %d %d /%s/\n", (int)c, (int)c2, (int)c3, chars);
}

void hack_fsetpos(void) {
  int c = input();
}