getdp.y

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

    /* none */
    { 
      IntegrationCase_S.Type = GAUSS ; 
      IntegrationCase_S.SubType = STANDARD ; 
    }

  | IntegrationCase IntegrationCaseTerm
  ;


IntegrationCaseTerm :

    tType tSTRING tEND
    { IntegrationCase_S.Type =
	Get_DefineForString(Integration_Type, $2, &FlagError) ;
      if (FlagError){
	vyyerror("Unknown type of Integration method: %s", $2);
	Get_Valid_SXD(Integration_Type);
      }
      Free($2) ;
    }

  | tSubType tSTRING tEND
    { IntegrationCase_S.SubType =
	Get_DefineForString(Integration_SubType, $2, &FlagError) ;
      if (FlagError){
	vyyerror("Unknown subtype of Integration method: %s", $2);
	Get_Valid_SXD(Integration_Type);
      }
      Free($2) ;
    }

  | tCase '{' QuadratureCases '}'
    { IntegrationCase_S.Case = $3 ; }
  ;
		   

QuadratureCases :

    /* none */
    { $$ = List_Create(5, 5, sizeof (struct Quadrature)) ; }

  | QuadratureCases  '{' QuadratureCase '}'
    { List_Add($$ = $1, &QuadratureCase_S) ; }
  ;


QuadratureCase :

    /* none */
    { QuadratureCase_S.ElementType = TRIANGLE ; 
      QuadratureCase_S.NumberOfPoints = 4 ;
      QuadratureCase_S.MaxNumberOfPoints = 4 ;
      QuadratureCase_S.NumberOfDivisions = 1 ;
      QuadratureCase_S.MaxNumberOfDivisions = 1 ;
      QuadratureCase_S.StoppingCriterion = 1.E-4 ;
      QuadratureCase_S.Function = (void (*)())Gauss_Triangle ;
    }

  | QuadratureCase QuadratureCaseTerm
  ;


QuadratureCaseTerm :

    tGeoElement tSTRING tEND
    { QuadratureCase_S.ElementType = Get_DefineForString(Element_Type, $2, &FlagError) ;
      if (FlagError){
	vyyerror("Unknown type of Element: %s", $2);
	Get_Valid_SXD(Element_Type);
      }

      switch(IntegrationCase_S.SubType) {

      case STANDARD :
	switch (IntegrationCase_S.Type) {
	case GAUSS :
	  Get_FunctionForDefine
	    (FunctionForGauss, QuadratureCase_S.ElementType,
	     &FlagError, (void (**)())&QuadratureCase_S.Function) ;
	  break ;
	case GAUSSLEGENDRE :
	  Get_FunctionForDefine
	    (FunctionForGaussLegendre, QuadratureCase_S.ElementType,
	     &FlagError, (void (**)())&QuadratureCase_S.Function) ;
	  break ;
	default : 
	  vyyerror("Incompatible type of Integration method") ;
	  break ;
	}
	break ;

      case SINGULAR :
	switch (IntegrationCase_S.Type) {
	case GAUSS :
	  Get_FunctionForDefine
	    (FunctionForSingularGauss, QuadratureCase_S.ElementType,
	     &FlagError, (void (**)())&QuadratureCase_S.Function) ;
	  break ;
	default : 
	  vyyerror("Incompatible type of Integration method") ;
	  break ;
	}
	break ;
      default :
	vyyerror("Incompatible type of Integration method") ;
	break ;
      }

      if (FlagError)  vyyerror("Bad type of Integration method for Element: %s", $2) ;
      Free($2) ;
    }

  | tNumberOfPoints FExpr tEND
    { QuadratureCase_S.NumberOfPoints = (int)$2 ; }

  | tMaxNumberOfPoints FExpr tEND
    { QuadratureCase_S.MaxNumberOfPoints = (int)$2 ; }

  | tNumberOfDivisions FExpr tEND
    { QuadratureCase_S.NumberOfDivisions = (int)$2 ; }

  | tMaxNumberOfDivisions FExpr tEND
    { QuadratureCase_S.MaxNumberOfDivisions = (int)$2 ; }

  | tStoppingCriterion FExpr tEND
    { QuadratureCase_S.StoppingCriterion = $2 ; }
  ;


/* ------------------------------------------------------------------------ */
/*  C o n s t r a i n t                                                     */
/* ------------------------------------------------------------------------ */

Constraints :

    /* none */
    { if (!Problem_S.Constraint)
	Problem_S.Constraint = List_Create(20, 20, sizeof (struct Constraint) ) ;
    }

  | Constraints BracedConstraint 
  ;

BracedConstraint :

    '{' Constraint '}'
    {
      List_Add(Problem_S.Constraint, &Constraint_S) ;
    }

  | Affectation

  | Loop
  ;

Constraint :

    /* none */
    { Constraint_S.Name = NULL ;  
      Constraint_S.Type = ASSIGN ;
      Constraint_S.ConstraintPerRegion = NULL ;
      Constraint_S.MultiConstraintPerRegion = NULL ;
    }

  | Constraint  ConstraintTerm
  ;


ConstraintTerm :

    tName String__Index tEND
    {
      Check_NameOfStructNotExist("Constraint", Problem_S.Constraint, $2,
				 fcmp_Constraint_Name) ;
      Constraint_S.Name = $2 ;
    }

  | tName tSTRING DefineDimension tEND
    {
      yyerror("Multi-fields {#.} are not used anymore. Use Loops For ... EndFor");
      Check_NameOfStructNotExist("Constraint", Problem_S.Constraint, $2,
				 fcmp_Constraint_Name) ;
      Constraint_S.Name = $2 ;
    }

  | tType tSTRING tEND
    { Constraint_S.Type = Get_DefineForString(Constraint_Type, $2, &FlagError) ;
      if (FlagError){
	vyyerror("Unknown type of Constraint: %s", $2);
	Get_Valid_SXD(Constraint_Type);
      }
      Free($2) ;
    }

  | tCase '{' ConstraintCases '}'
    { Constraint_S.ConstraintPerRegion = $3 ; }

  | tCase tSTRING '{' ConstraintCases '}'
    {
      if (!Constraint_S.MultiConstraintPerRegion)
	Constraint_S.MultiConstraintPerRegion =
	  List_Create( 5, 5, sizeof(struct MultiConstraintPerRegion)) ;

      MultiConstraintPerRegion_S.Name = $2 ;
      MultiConstraintPerRegion_S.ConstraintPerRegion = $4 ;
      MultiConstraintPerRegion_S.Active = NULL ;

      List_Add(Constraint_S.MultiConstraintPerRegion, 
	       &MultiConstraintPerRegion_S) ;
    }
  ;


ConstraintCases :

    /* none */
    {
      $$ = List_Create(6, 6, sizeof (struct ConstraintPerRegion)) ;
    }

  | ConstraintCases  '{' ConstraintCase '}'
    {
      List_Add($$ = $1, &ConstraintPerRegion_S) ;
    }

  | ConstraintCases Loop
    { 
      $$ = $1 ;
    }
  ;


ConstraintCase :

    /* none */
    { 
      ConstraintPerRegion_S.Type = Constraint_S.Type ;
      ConstraintPerRegion_S.RegionIndex = -1 ;
      ConstraintPerRegion_S.SubRegionIndex = -1 ;
      ConstraintPerRegion_S.TimeFunctionIndex = -1 ;
    }

  | ConstraintCase ConstraintCaseTerm
  ;


ConstraintCaseTerm :

    tType tSTRING tEND
    { ConstraintPerRegion_S.Type = 
	Get_DefineForString(Constraint_Type, $2, &FlagError) ;
      if (FlagError){
	vyyerror("Unknown type of Constraint: %s", $2);
	Get_Valid_SXD(Constraint_Type);
      }
      Free($2) ;
    }

  | tRegion GroupRHS tEND
    { 
      ConstraintPerRegion_S.RegionIndex = Num_Group(&Group_S, "CO_Region", $2) ;
    }

  | tSubRegion GroupRHS tEND
    { 
      ConstraintPerRegion_S.SubRegionIndex =
	Num_Group(&Group_S, "CO_SubRegion", $2) ;
    }

  | tTimeFunction Expression tEND
    {
      ConstraintPerRegion_S.TimeFunctionIndex = $2 ;
    }

  | tValue Expression tEND
    { 
      if (ConstraintPerRegion_S.Type == ASSIGN ||
	  ConstraintPerRegion_S.Type == INIT)
	ConstraintPerRegion_S.Case.Fixed.ExpressionIndex = $2 ;
      else  vyyerror("Value incompatible with Type") ;
    }

  | tNameOfResolution String__Index tEND
    {
      if (ConstraintPerRegion_S.Type == ASSIGNFROMRESOLUTION ||
	  ConstraintPerRegion_S.Type == INITFROMRESOLUTION)
	ConstraintPerRegion_S.Case.Solve.ResolutionName = $2 ;
      else  vyyerror("NameOfResolution incompatible with Type") ;
    }

  | tBranch '{' OneFExpr Comma OneFExpr '}' tEND
    {
      if (ConstraintPerRegion_S.Type == NETWORK) {
	ConstraintPerRegion_S.Case.Network.Node1 = (int)$3 ;
	ConstraintPerRegion_S.Case.Network.Node2 = (int)$5 ;
      }
      else  vyyerror("Branch incompatible with Type") ;
    }

  | tRegionRef GroupRHS tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX) {
	ConstraintPerRegion_S.Case.Link.RegionRefIndex =
	  Num_Group(&Group_S, "CO_RegionRef", $2) ;
	ConstraintPerRegion_S.Case.Link.SubRegionRefIndex = -1 ;

	ConstraintPerRegion_S.Case.Link.FilterIndex = -1 ;
	ConstraintPerRegion_S.Case.Link.FunctionIndex = -1 ;
	ConstraintPerRegion_S.Case.Link.CoefIndex = -1 ;
	ConstraintPerRegion_S.Case.Link.FilterIndex2 = -1 ;
	ConstraintPerRegion_S.Case.Link.FunctionIndex2 = -1 ;
	ConstraintPerRegion_S.Case.Link.CoefIndex2 = -1 ;
      }
      else  vyyerror("RegionRef incompatible with Type") ;
    }

  | tSubRegionRef GroupRHS tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX)
	ConstraintPerRegion_S.Case.Link.SubRegionRefIndex =
	  Num_Group(&Group_S, "CO_RegionRef", $2) ;
      else  vyyerror("SubRegionRef incompatible with Type") ;
    }

  | tFunction Expression tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX)
	ConstraintPerRegion_S.Case.Link.FunctionIndex = $2 ;
      else  vyyerror("Function incompatible with Type") ;
    }

  | tCoefficient Expression tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX)
	ConstraintPerRegion_S.Case.Link.CoefIndex = $2 ;
      else  vyyerror("Coefficient incompatible with Type") ;
    }

  | tFilter Expression tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX) {
	ConstraintPerRegion_S.Case.Link.FilterIndex  = $2 ;
	ConstraintPerRegion_S.Case.Link.FilterIndex2 = -1 ;
      }
      else  vyyerror("Filter incompatible with Type") ;
    }

  | tFunction '[' Expression ',' Expression ']' tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX) {
	ConstraintPerRegion_S.Case.Link.FunctionIndex  = $3 ;
	ConstraintPerRegion_S.Case.Link.FunctionIndex2 = $5 ;
      }
      else  vyyerror("Function incompatible with Type") ;
    }

  | tCoefficient '[' Expression ',' Expression ']' tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX) {
	ConstraintPerRegion_S.Case.Link.CoefIndex  = $3 ;
	ConstraintPerRegion_S.Case.Link.CoefIndex2 = $5 ;
      }
      else  vyyerror("Coefficient incompatible with Type") ;
    }

  | tFilter '[' Expression ',' Expression ']' tEND
    {
      if (ConstraintPerRegion_S.Type == CST_LINK ||
	  ConstraintPerRegion_S.Type == CST_LINKCPLX) {
	ConstraintPerRegion_S.Case.Link.FilterIndex  = $3 ;
	ConstraintPerRegion_S.Case.Link.FilterIndex2 = $5 ;
      }
      else  vyyerror("Filter incompatible with Type") ;
    }

  ;


/* ------------------------------------------------------------------------ */
/*  F u n c t i o n   S p a c e                                             */
/* ------------------------------------------------------------------------ */


FunctionSpaces :

    /* none */
    { if (!Problem_S.FunctionSpace)
	Problem_S.FunctionSpace = 
	  List_Create(10, 5, sizeof (struct FunctionSpace) ) ;
    }

  | FunctionSpaces  BracedFunctionSpace 
  ;

BracedFunctionSpace :

    '{' FunctionSpace '}'
    {
      List_Add(Problem_S.FunctionSpace, &FunctionSpace_S) ;
    }

  | Affectation

  | Loop  
  ;


FunctionSpace :

    /* none */
    { FunctionSpace_S.Name = NULL ; FunctionSpace_S.Type = FORM0 ;
      FunctionSpace_S.BasisFunction = FunctionSpace_S.SubSpace =
	FunctionSpace_S.GlobalQuantity = FunctionSpace_S.Constraint = NULL ;
    }

  | F