data_passive.h

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

  char  * Name ;
  int   Num,  Type, ReferenceIndex ;
} ;

/* GlobalQuantity.Type */
#define ALIASOF              1
#define ASSOCIATEDWITH       2

struct ConstraintInFS {
  int  QuantityType, ReferenceIndex, EntityIndex ;
  struct ConstraintPerRegion  * ConstraintPerRegion ;
  struct {
    int ResolutionIndex ;
    struct ConstraintActive  * Active ;
  } Active ;  /* a deplacer lorsque sera necessaire */
} ;

/* ConstraintInFS.QuantityType */
#define LOCALQUANTITY       1
#define GLOBALQUANTITY      2
#define INTEGRALQUANTITY    3
#define NODOF               4


/* ------------------------------------------------------------------------ */
/*  F u n c t i o n                                                         */
/* ------------------------------------------------------------------------ */

struct Function {
  void    (*Fct)() ; /* ANSI C++ forbids data member `Function' with 
			same name as enclosing class */
  int     TypeOfValue, NbrArguments, NbrParameters ;
  double  *Para ;
  struct FunctionActive  * Active ;
} ;


/* ------------------------------------------------------------------------ */
/*  F o r m u l a t i o n                                                   */
/* ------------------------------------------------------------------------ */

struct Formulation {
  char    * Name ;
  int     Type ;
  List_T  * DefineQuantity, * Equation ;
} ;

/* Formulation.Type */
#define FEMEQUATION       1
#define BEMEQUATION       2
#define GLOBALEQUATION    3

struct IntegralQuantity {
  List_T  *WholeQuantity;
  int      DofIndexInWholeQuantity ;

  int      TypeOperatorDof, DefineQuantityIndexDof ;
  int      DefineQuantityIndexNoDof ;

  int      NbrQuantityIndex, * QuantityIndexTable ;
  int    * QuantityTraceGroupIndexTable ;

  int      InIndex ;
  int      IntegrationMethodIndex, FMMIntegrationMethodIndex, JacobianMethodIndex;
  int      Symmetry ;

  int      CanonicalWholeQuantity, ExpressionIndexForCanonical ;
  struct   Function FunctionForCanonical, FunctionForFMM, AnyFunction ;
} ;

struct DefineQuantity {
  char    * Name ;
  int     Type ;
  int     FunctionSpaceIndex ;

  /* for subspaces */
  List_T  *IndexInFunctionSpace ;

  /* for MH calculation */
  List_T  *DummyFrequency ;

  /* for multiple DofData vs. one FunctionSpace */
  int      DofDataIndex ; 
  struct   DofData  * DofData ;

  /* for integral quantities */ 
  struct   IntegralQuantity  IntegralQuantity ;
} ;

/* DefineQuantity.Type */
/* LOCALQUANTITY
   GLOBALQUANTITY
   INTEGRALQUANTITY */

struct EquationTerm {
  int        Type ;

  union {

    struct FemLocalTerm {
      struct {
	int     TypeTimeDerivative ;

	List_T  * WholeQuantity ;
	int     DofIndexInWholeQuantity ;
	int     CanonicalWholeQuantity, ExpressionIndexForCanonical ;
	struct  Function  FunctionForCanonical ;
	int     CanonicalWholeQuantity_Equ, ExpressionIndexForCanonical_Equ, 
	          OperatorTypeForCanonical_Equ ;

	int     NbrQuantityIndex, * QuantityIndexTable, QuantityIndexPost ;
	int     * QuantityTraceGroupIndexTable ;

	int     TypeOperatorEqu, DefineQuantityIndexEqu ;
	int     TypeOperatorDof, DefineQuantityIndexDof ;
	int     DefineQuantityIndexNoDof, DofInTrace ;
      } Term ;

      int  InIndex ; 
      int  Full_Matrix ;
      int  IntegrationMethodIndex, FMMIntegrationMethodIndex, JacobianMethodIndex ;
    
      int  FMMObservation, FMMSource, iFMMEqu ;
      int  MatrixIndex ;
      struct FemLocalTermActive  * Active ;
    } LocalTerm ;


    struct FemGlobalTerm {
      int  TypeTimeDerivative ;
      int  DefineQuantityIndex ;

      struct {
	int  TypeTimeDerivative ;

	List_T  * WholeQuantity ;
	int     DofIndexInWholeQuantity ;
	int     CanonicalWholeQuantity, ExpressionIndexForCanonical ;

	int     NbrQuantityIndex, * QuantityIndexTable ;
	int     * QuantityTraceGroupIndexTable ;

	int     TypeOperatorEqu, DefineQuantityIndexEqu ;
	int     TypeOperatorDof, DefineQuantityIndexDof ;
	int     DefineQuantityIndexNoDof ;
      } Term ;
      int  InIndex ;
    } GlobalTerm ;


    struct GlobalEquation {
      int  Type, ConstraintIndex ;
      List_T  * GlobalEquationTerm ;
    } GlobalEquation ;

  } Case ;
} ;


struct GlobalEquationTerm {
  int  DefineQuantityIndexNode, DefineQuantityIndexLoop ;
  int  DefineQuantityIndexEqu ;
  int  InIndex ;
} ;


/* EquationTerm.Type */
#define GALERKIN        1
#define GLOBALTERM      2
#define GLOBALEQUATION  3
#define DERHAM          4

/* Term.TypeOfTimeDerivative */
#define NODT_      0
#define DT_        1
#define DTDOF_     2
#define DTDT_      3
#define DTDTDOF_   4
#define JACNL_    10
#define NEVERDT_  11
#define DTNL_     12

/* Term.TypeOperator */
#define NOOP       0

#define EXTDER     1
#define GRAD       2
#define CURL       3
#define DIV        4

#define EXTDERINV  5
#define GRADINV    6
#define CURLINV    7
#define DIVINV     8

/* Tous ces operateurs de trace ne servent a RIEN pour le moment 
   De plus, les 'x' sont ambigus. Il faut penser a definir des 
   operateurs de trace (T ou T*), qui doivent avoir, outre 
   \Gamma=\partial\Omega, l'info concernant \Omega.
 */
#define NPx        9
#define NPxEXTDER 10
#define NPxGRAD   11
#define NPxCURL   12
#define NPxDIV    13

#define NSx       14
#define NSxEXTDER 15
#define NSxGRAD   16
#define NSxCURL   17
#define NSxDIV    18

#define _D1       21
#define _D2       22


/* CanonicalWholeQuantity */
#define CWQ_NONE           0
#define CWQ_DOF            1
#define CWQ_EXP_TIME_DOF   2
#define CWQ_FCT_TIME_DOF   3
#define CWQ_FCT_PVEC_DOF   4

#define CWQ_GF             5
#define CWQ_GF_PSCA_DOF    6
#define CWQ_GF_PSCA_EXP    7
#define CWQ_GF_PVEC_DOF    8
#define CWQ_DOF_PVEC_GF    9
#define CWQ_GF_PVEC_EXP   10 
#define CWQ_EXP_PVEC_GF   11

#define CWQ_EXP_TIME_GF_PSCA_DOF  12
#define CWQ_EXP_TIME_GF_PVEC_DOF  13
#define CWQ_EXP_PVEC_GF_PSCA_DOF  14
#define CWQ_EXP_PVEC_GF_PVEC_DOF  15
#define CWQ_FCT_TIME_GF_PSCA_DOF  16
#define CWQ_FCT_TIME_GF_PVEC_DOF  17
#define CWQ_FCT_PVEC_GF_PSCA_DOF  18
#define CWQ_FCT_PVEC_GF_PVEC_DOF  19

/* ------------------------------------------------------------------------ */
/*  W h o l e Q u a n t i t y                                               */
/* ------------------------------------------------------------------------ */

struct WholeQuantity {
  int  Type ;

  union {
    double Constant ;
    struct Function Function ;
    struct { int  TypeOperator, Index, NbrArguments ;
             int  TypeQuantity ; }                                OperatorAndQuantity ;
    struct { int  Index, NbrArguments ; }                         Expression ;
    struct { List_T *WholeQuantity ; }                            TimeDerivative ;
    struct { List_T *WholeQuantity ; int TimeStep ; }             AtAnteriorTimeStep ;
    struct { double *Value ; }                                    CurrentValue ;
    struct { int  Index ; }                                       Argument ;
    struct { List_T *WholeQuantity_True, *WholeQuantity_False ; } Test ;
    struct { int  Index ; }                                       SaveValue ;
    struct { int  Index ; }                                       ShowValue ;
    struct { int  Index ; }                                       ValueSaved ;
    struct { int  TypeOperator ; void  (*Function)() ; }          Operator ; /* binary or unary */
    struct { List_T *WholeQuantity ; 
             int FunctionSpaceIndexForType, NbrHar ; }            Cast ;
    struct { List_T *WholeQuantity ; 
             int InIndex, DofIndexInWholeQuantity ; }             Trace ;
    struct { char * SystemName ; int DefineSystemIndex ; 
             int DofNumber ; }                                    DofValue ; 
    struct { List_T *WholeQuantity ; 
             int Index, NbrPoints ; }                             MHTransform ;
    struct { int Index, NbrPoints, FreqOffSet ; }                 MHJacNL ;
  } Case ;

} ;


/* WholeQuantity.Type */
#define WQ_OPERATORANDQUANTITY     1
#define WQ_OPERATORANDQUANTITYEVAL 2
#define WQ_BINARYOPERATOR          3
#define WQ_UNARYOPERATOR           4
#define WQ_EXPRESSION              5
#define WQ_BUILTINFUNCTION         6
#define WQ_EXTERNBUILTINFUNCTION   7
#define WQ_CONSTANT                8
#define WQ_CURRENTVALUE            9
#define WQ_ARGUMENT                10
#define WQ_TIMEDERIVATIVE          11
#define WQ_CAST                    12
#define WQ_TEST                    13
#define WQ_SAVEVALUE               14
#define WQ_VALUESAVED              15
#define WQ_SOLIDANGLE              16
#define WQ_TRACE                   17
#define WQ_ORDER                   18
#define WQ_MHTIMEINTEGRATION       19
#define WQ_MHTRANSFORM             199
#define WQ_SHOWVALUE               20
#define WQ_MHTIMEEVAL              211
#define WQ_MHJACNL                 212
#define WQ_POSTSAVE                214
#define WQ_ATANTERIORTIMESTEP      22

/* TypeOperator */
#define OP_PLUS           1
#define OP_MINUS          2
#define OP_TIME           3
#define OP_DIVIDE         4
#define OP_MODULO         5
#define OP_POWER          6
#define OP_CROSSPRODUCT   7
#define OP_LESS           8
#define OP_GREATER        9
#define OP_LESSOREQUAL    10
#define OP_GREATEROREQUAL 11
#define OP_EQUAL          12
#define OP_NOTEQUAL       13
#define OP_APPROXEQUAL    14
#define OP_AND            15
#define OP_OR             16
#define OP_NEG            17
#define OP_NOT            18

/* OperatorAndQuantity.TypeQuantity */

#define QUANTITY_SIMPLE  1
#define QUANTITY_DOF     2
#define QUANTITY_NODOF   3
#define QUANTITY_BF      4


/* ------------------------------------------------------------------------ */
/*  R e s o l u t i o n                                                     */
/* ------------------------------------------------------------------------ */

struct Resolution {
  char    * Name ;
  List_T  * DefineSystem, * Operation ;
} ;

struct DefineSystem {
  char    * Name;
  int     Type ;
  List_T  * FormulationIndex, * FrequencyValue ;
  char    * SolverDataFileName ;

  char    * MeshName, * AdaptName ;
  List_T  * OriginSystemIndex ;
  char    * DestinationSystemName ;
  int     DestinationSystemIndex ;
  int     Flag_FMM ; 
} ;

/* DefineSystem.Type */
#define VAL_REAL     1
#define VAL_COMPLEX  2

struct Operation {
  int  Type, DefineSystemIndex ;

  union {
    struct {
      int DivXYZIndex, Dfar, Precision, FlagDTA ;
    } GenerateFMMGroups ;
    struct {
      List_T * MatrixIndex_L ;
    } GenerateOnly ;
    struct {
      char *String ;
    } SystemCommand ;
    struct {
      int     ExpressionIndex ;
    } SetTime ;
    struct {
      int     ExpressionIndex ;
    } Update ;
    struct {
      int     GroupIndex, Type ;
    } UpdateConstraint ;
    struct {
      int     ExpressionIndex ;
    } SetFrequency ;
    struct {
      List_T  * Frequency ;
      int     DefineSystemIndex[2] ; 
    } FourierTransform ;
    struct {
      int     DefineSystemIndex[2] ;
      double Period, Period_sofar ;
      double * Scales;
    } FourierTransform2 ;
    struct {
      int     Size ;