data_passive.h

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

/*
 * 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):
 *   David Colignon
 *   Johan Gyselinck
 *   Ruth Sabariego
 *   Tuan Ledinh
 */

#ifndef _DATA_PASSIVE_H_
#define _DATA_PASSIVE_H_

#include "List.h"
#include "Data_Element.h"


#define _0D      0
#define _1D      1
#define _2D      2
#define _3D      3
#define _ALL     4

#define GETDP_PROMPT_STRING  "getdp> "
#define GETDP_TMP_FILENAME   "getdp.tmp"

/* ------------------------------------------------------------------------ */
/*  V a l u e                                                               */
/* ------------------------------------------------------------------------ */

#define MAX_DIM  9   /* second-rank tensor of order 3 : 3^2 = 9  */

/* Please set NBR_MAX_HARMONIC to the lowest possible value for common
   getdp versions, until we do dynamic allocation. Otherwise, some
   postprocessing operations become almost impossible to perform in
   3D.
*/

#if defined(HAVE_MULTIHARMONIC)
#define NBR_MAX_HARMONIC    40
#else
#define NBR_MAX_HARMONIC    2   
#endif

struct Value {
  int     Type ;
  double  Val [NBR_MAX_HARMONIC * MAX_DIM] ;
} ;

/* ------------------------------------------------------------------------ */
/*  P r o b l e m                                                           */
/* ------------------------------------------------------------------------ */

struct Problem {
  List_T  * Group         , * Expression        ; 
  List_T  * FunctionSpace , * Constraint        , * Formulation   ;
  List_T  * JacobianMethod, * IntegrationMethod ;
  List_T  * Resolution    , * PostProcessing    , * PostOperation ;
  List_T  * FMMGroup ;
} ;

/* ------------------------------------------------------------------------ */
/*  G r o u p                                                               */
/* ------------------------------------------------------------------------ */

struct Group {
  char    * Name ;
  int     Num,  Type, FunctionType, SuppListType ;
  List_T  * InitialList , * InitialSuppList ;
  List_T  * ExtendedList, * ExtendedSuppList ;
  struct  MovingBand2D * MovingBand2D ; 
} ;

struct MovingBand2D {
  List_T  * InitialList1, * ExtendedList1, * InitialList2, * ExtendedList2;
  int NbrNodes1, *NumNodes1, NbrNodes2, *NumNodes2 ;
  double *x1, *y1, *z1, *x2, *y2, *z2, Area;
  int  Period2, ntr1, ntr2, Closed1, Closed2;
  int PhysNum, StartNumTr, StartIndexTr ;
  int *b1_p1, *b1_p2, *b1_p3, *b2_p1, *b2_p2, *b2_p3;
} ;


/* Group.Type */
#define REGIONLIST   1
#define ELEMENTLIST  2
#define MOVINGBAND2D 3

/* Group.FunctionType */
#define REGION                     1

#define NODESOF                    2
#define EDGESOF                    3
#define FACETSOF                   4
#define VOLUMESOF                  5
#define ELEMENTSOF                 6

#define GLOBAL                     7

#define GROUPSOFNODESOF           11
#define GROUPSOFEDGESOF           12
#define GROUPSOFFACETSOF          13
#define GROUPSOFEDGESONNODESOF    14

#define EDGESOFTREEIN             21
#define FACETSOFTREEIN            22

#define DUALNODESOF               30
#define DUALEDGESOF               31
#define DUALFACETSOF              32
#define DUALVOLUMESOF             33

#define BOUNDARYOFDUALNODESOF     40
#define BOUNDARYOFDUALEDGESOF     41
#define BOUNDARYOFDUALFACETSOF    42



/* Group.SuppListType */
#define SUPPLIST_NONE              0
#define SUPPLIST_NOT               1
#define SUPPLIST_STARTINGON        2
#define SUPPLIST_ONONESIDEOF       3
#define SUPPLIST_INSUPPORT         4
#define SUPPLIST_CONNECTEDTO       5


/* FMM operations */
#define FMM_DIRECT         0
#define FMM_AGGREGATION    1       
#define FMM_DISAGGREGATION 2       
#define FMM_TRANSLATION    3       

/* ------------------------------------------------------------------------ */
/*  E x p r e s s i o n                                                     */
/* ------------------------------------------------------------------------ */

struct Expression {
  char * Name ;
  int  Type ;
  union {
    double  Constant ;
    List_T  * WholeQuantity ;
    struct {
      List_T  * ExpressionPerRegion ;
      int  NumLastRegion ;  struct Expression  * ExpressionForLastRegion ;
    }  PieceWiseFunction ;
  }  Case ;
} ;

struct ExpressionPerRegion {
  int  RegionIndex, ExpressionIndex ;
} ;

/* Expression.Type */
#define UNDEFINED_EXP         0
#define CONSTANT              1
#define WHOLEQUANTITY         2
#define PIECEWISEFUNCTION     3


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

struct Constraint {
  char    * Name ;
  int     Type ;
  List_T  * ConstraintPerRegion ;
  List_T  * MultiConstraintPerRegion ;
} ;


struct ConstraintPerRegion {
  int  Type, RegionIndex, SubRegionIndex, TimeFunctionIndex ;
  union {
    struct { int  ExpressionIndex ; } Fixed ;
    struct { char *ResolutionName ; } Solve ;
    struct { int  Node1, Node2 ;    } Network ;
    struct {
      int  RegionRefIndex, SubRegionRefIndex ;
      int  FilterIndex, CoefIndex, FunctionIndex  ;
      int  FilterIndex2, CoefIndex2, FunctionIndex2  ;
    } Link ;
  } Case ;
} ;


struct MultiConstraintPerRegion {
  char    * Name ;
  List_T  * ConstraintPerRegion ;
  struct ConstraintActive  * Active ;
} ;

/* Constraint.Type & ConstraintPerRegion.Type */
#define NONE                  0
#define ASSIGN                1
#define INIT                  2
#define ASSIGNFROMRESOLUTION  3
#define INITFROMRESOLUTION    4
#define NETWORK               5
#define CST_LINK              6
#define CST_LINKCPLX          7


/* ------------------------------------------------------------------------ */
/*  J a c o b i a n M e t h o d                                             */
/* ------------------------------------------------------------------------ */

struct JacobianMethod {
  char    * Name ;
  List_T  * JacobianCase ;
} ;

struct JacobianCase {
  int  RegionIndex, TypeJacobian ;
  int  NbrParameters ;  double  * Para ;
} ;

/* JacobianCase.TypeJacobian */
/* WARNING! The numbering is important (boundary operator -> -1) */

#define JACOBIAN_PNT                     0
#define JACOBIAN_LIN                     1
#define JACOBIAN_SUR                     2
#define JACOBIAN_VOL                     3

#define JACOBIAN_SUR_AXI                 10
#define JACOBIAN_VOL_AXI                 11

#define JACOBIAN_SUR_AXI_SQU             20
#define JACOBIAN_VOL_AXI_SQU             21

#define JACOBIAN_SUR_SPH_SHELL           30
#define JACOBIAN_VOL_SPH_SHELL           31

#define JACOBIAN_SUR_AXI_SPH_SHELL       40
#define JACOBIAN_VOL_AXI_SPH_SHELL       41

#define JACOBIAN_SUR_AXI_SQU_SPH_SHELL   50
#define JACOBIAN_VOL_AXI_SQU_SPH_SHELL   51

#define JACOBIAN_SUR_RECT_SHELL          60
#define JACOBIAN_VOL_RECT_SHELL          61

#define JACOBIAN_SUR_AXI_RECT_SHELL      70
#define JACOBIAN_VOL_AXI_RECT_SHELL      71

#define JACOBIAN_SUR_AXI_SQU_RECT_SHELL  80
#define JACOBIAN_VOL_AXI_SQU_RECT_SHELL  81

#define JACOBIAN_VOL_PLPD_X              90

#define JACOBIAN_VOL_AXI_PLPD_X          100


/* type of transformation */
#define JACOBIAN_SPH                     0
#define JACOBIAN_RECT                    1

/* All the preceding definitions should be changed to something like:
#define JACOBIAN_POINT    (1<<0)
#define JACOBIAN_LINE     (1<<1)
#define JACOBIAN_SURFACE  (1<<2)
#define JACOBIAN_VOLUME   (1<<3)
#define JACOBIAN_AXI      (1<<4)
#define JACOBIAN_SQUARED  (1<<5)
#define JACOBIAN_SPHERE   (1<<6)
#define JACOBIAN_RECT     (1<<7)
and the calls should be made with  JACOBIAN_VOLUME | JACOBIAN_AXI, etc.
But I have to change the de Rham stuff first.
*/

/* ------------------------------------------------------------------------ */
/*  I n t e g r a t i o n   M e t h o d                                     */
/* ------------------------------------------------------------------------ */

struct IntegrationMethod {
  char    *Name ;
  List_T  *IntegrationCase ;
  int      CriterionIndex ;
} ;

struct IntegrationCase {
  int     Type, SubType ;
  List_T  *Case ;
} ;

/* IntegrationCase.Type */
#define ANALYTIC               1
#define GAUSS                  2
#define GAUSSLEGENDRE          3

/* IntegrationCase.SubType */
#define STANDARD               1
#define SINGULAR               2
#define ADAPTATIVE             3

struct Quadrature {
  int    ElementType ;
  int    NumberOfPoints, MaxNumberOfPoints ;
  int    NumberOfDivisions, MaxNumberOfDivisions ;
  double StoppingCriterion ;
  void   (*Function)() ;
} ;


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

struct FunctionSpace {
  char    * Name ;
  int     Type ;
  List_T  * BasisFunction, * SubSpace, * GlobalQuantity, * Constraint ;

  struct DofData  * DofData, *MainDofData ;
} ;

struct BasisFunction {
  char    * Name, * NameOfCoef ;
  List_T  * GlobalBasisFunction ;
  int     Dimension, Num ;
  void    (*Function)();
  void    (*dFunction)();
  void    (*dInvFunction)();
  List_T  * SubFunction, * SubdFunction ;
  int     SupportIndex, EntityIndex ;
  double  Order ;
  int     ElementType ;
} ;

struct GlobalBasisFunction {
  int   EntityIndex ; /* Must be the first element of the structure */
  int   FormulationIndex, DefineQuantityIndex, ResolutionIndex ;
  struct QuantityStorage  * QuantityStorage ;
} ;

/* BasisFunction.Type */
/* WARNING! The numbering is important (exterior derivative -> +1) */
#define FORM0        0
#define FORM1        1
#define FORM2        2
#define FORM3        3

#define FORM0S       4
#define FORM1S       5
#define FORM2S       6
#define FORM3S       7

#define FORM0P      10
#define FORM1P      11
#define FORM2P      12
#define FORM3P      13

#define SCALAR      20 
#define VECTOR      21
#define TENSOR      22  /* second-rank tensor of order 3 */
#define TENSOR_SYM  23
#define TENSOR_DIAG 24

#define TENSOR_MH   25

/*  VECTOR  TENSOR_DIAG  TENSOR_SYM  TENSOR
    |0|     |0    |      |0 1 2|     |0 1 2|
    |1|     |  1  |      |s 3 4|     |3 4 5|
    |2|     |    2|      |s s 5|     |6 7 8| */

#define VECTORP     31

struct SubSpace {
  char    * Name ;
  List_T  * BasisFunction ;
} ;

struct GlobalQuantity {