data_function.h

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

#undef POI
#undef LIN
#undef TRI
#undef QUA
#undef TET
#undef HEX
#undef PRI
#undef PYR
          
#undef ALL


/* ------------------------------------------------------------------------ */
/*  Keywords, their assigned functions and 2 numbers                        */
/* ------------------------------------------------------------------------ */


struct StringXFunction2Nbr  F_Function[] = {    /* #Par #Arg */

  /* #Par = -1 => free number of Parameters ; = -2 free even number */
  /* #Arg ... same */

  /* F_Math */

  {"Exp"               , (CAST)F_Exp              ,   0,   1 },
  {"Log"               , (CAST)F_Log              ,   0,   1 },
  {"Log10"             , (CAST)F_Log10            ,   0,   1 },
  {"Sqrt"              , (CAST)F_Sqrt             ,   0,   1 },
  {"Sin"               , (CAST)F_Sin              ,   0,   1 },
  {"Asin"              , (CAST)F_Asin             ,   0,   1 },
  {"Cos"               , (CAST)F_Cos              ,   0,   1 },
  {"Acos"              , (CAST)F_Acos             ,   0,   1 },
  {"Tan"               , (CAST)F_Tan              ,   0,   1 },
  {"Atan"              , (CAST)F_Atan             ,   0,   1 },
  {"Sinh"              , (CAST)F_Sinh             ,   0,   1 },
  {"Cosh"              , (CAST)F_Cosh             ,   0,   1 },
  {"Tanh"              , (CAST)F_Tanh             ,   0,   1 },
  {"Fabs"              , (CAST)F_Fabs             ,   0,   1 },
  {"Floor"             , (CAST)F_Floor            ,   0,   1 },
  {"Ceil"              , (CAST)F_Ceil             ,   0,   1 },
  {"Atan2"             , (CAST)F_Atan2            ,   0,   2 },
  {"Fmod"              , (CAST)F_Fmod             ,   0,   2 },

  /* F_ExtMath */

  {"Hypot"             , (CAST)F_Hypot            ,   0,   2 },
  {"TanhC2"            , (CAST)F_TanhC2           ,   0,   1 },
  {"Transpose"         , (CAST)F_Transpose        ,   0,   1 },
  {"TTrace"            , (CAST)F_Trace            ,   0,   1 },
  {"Rotate"            , (CAST)F_RotateXYZ        ,   0,   4 },
  {"Norm"              , (CAST)F_Norm             ,   0,   1 },
  {"SquNorm"           , (CAST)F_SquNorm          ,   0,   1 },
  {"Unit"              , (CAST)F_Unit             ,   0,   1 },
  {"Normalized"        , (CAST)F_Unit             ,   0,   1 },
  {"F_Cos_wt_p"        , (CAST)F_Cos_wt_p         ,   2,   0 },
  {"F_Sin_wt_p"        , (CAST)F_Sin_wt_p         ,   2,   0 },
  {"F_Period"          , (CAST)F_Period           ,   1,   1 },
  {"Interval"          , (CAST)F_Interval         ,   3,   3 },

  /* F_Type */

  {"Complex"           , (CAST)F_Complex          ,   0,  -2 },
  {"Complex_MH"        , (CAST)F_Complex_MH       ,  -1,  -2 },
  {"Re"                , (CAST)F_Re               ,   0,   1 },
  {"Im"                , (CAST)F_Im               ,   0,   1 },
  {"Conj"              , (CAST)F_Conj             ,   0,   1 },
  {"Cart2Pol"          , (CAST)F_Cart2Pol         ,   0,   1 },
  {"Vector"            , (CAST)F_Vector           ,   0,   3 },
  {"Tensor"            , (CAST)F_Tensor           ,   0,   9 },
  {"TensorV"           , (CAST)F_TensorV          ,   0,   3 },
  {"TensorSym"         , (CAST)F_TensorSym        ,   0,   6 },
  {"TensorDiag"        , (CAST)F_TensorDiag       ,   0,   3 },
  {"SquDyadicProduct"  , (CAST)F_SquDyadicProduct ,   0,   1 },
  {"CompX"             , (CAST)F_CompX            ,   0,   1 },
  {"CompY"             , (CAST)F_CompY            ,   0,   1 },
  {"CompZ"             , (CAST)F_CompZ            ,   0,   1 },
  {"CompXX"            , (CAST)F_CompXX           ,   0,   1 },
  {"CompXY"            , (CAST)F_CompXY           ,   0,   1 },
  {"CompXZ"            , (CAST)F_CompXZ           ,   0,   1 },
  {"CompYX"            , (CAST)F_CompYX           ,   0,   1 },
  {"CompYY"            , (CAST)F_CompYY           ,   0,   1 },
  {"CompYZ"            , (CAST)F_CompYZ           ,   0,   1 },
  {"CompZX"            , (CAST)F_CompZX           ,   0,   1 },
  {"CompZY"            , (CAST)F_CompZY           ,   0,   1 },
  {"CompZZ"            , (CAST)F_CompZZ           ,   0,   1 },
  {"Cart2Sph"          , (CAST)F_Cart2Sph         ,   0,   1 },
  {"Cart2Cyl"          , (CAST)F_Cart2Cyl         ,   0,   1 },
  {"UnitVectorX"       , (CAST)F_UnitVectorX      ,   0,   0 },
  {"UnitVectorY"       , (CAST)F_UnitVectorY      ,   0,   0 },
  {"UnitVectorZ"       , (CAST)F_UnitVectorZ      ,   0,   0 },

  /* F_Coord */

  {"CoordX"            , (CAST)F_CoordX           ,   0,   0 },
  {"CoordY"            , (CAST)F_CoordY           ,   0,   0 },
  {"CoordZ"            , (CAST)F_CoordZ           ,   0,   0 },
  {"CoordXYZ"          , (CAST)F_CoordXYZ         ,   0,   0 },
  {"X"                 , (CAST)F_CoordX           ,   0,   0 },
  {"Y"                 , (CAST)F_CoordY           ,   0,   0 },
  {"Z"                 , (CAST)F_CoordZ           ,   0,   0 },
  {"XYZ"               , (CAST)F_CoordXYZ         ,   0,   0 },
  {"F_aX_bY_cZ"        , (CAST)F_aX_bY_cZ         ,   3,   0 },
  {"F_aX21_bY21_cZ21"  , (CAST)F_aX21_bY21_cZ21   ,   3,   0 },


  /* F_Misc */

  {"Printf"            , (CAST)F_Printf           ,   0,   1 },
  {"Normal"            , (CAST)F_Normal           ,   0,   0 },
  {"NormalSource"      , (CAST)F_NormalSource     ,   0,   0 },
  {"Tangent"           , (CAST)F_Tangent          ,   0,   0 },
  {"CompElementNum"    , (CAST)F_CompElementNum   ,   0,   0 },
  {"ElementVol"        , (CAST)F_ElementVol       ,   0,   0 },
  {"SurfaceArea"       , (CAST)F_SurfaceArea      ,  -1,   0 },
  {"InterpolationLinear"   , (CAST)F_InterpolationLinear   ,  -2,   1 },
  {"dInterpolationLinear"  , (CAST)F_dInterpolationLinear  ,  -2,   1 },
  {"dInterpolationLinear2" , (CAST)F_dInterpolationLinear2 ,  -2,   1 },
  {"InterpolationAkima"    , (CAST)F_InterpolationAkima    ,  -2,   1 },
  {"dInterpolationAkima"   , (CAST)F_dInterpolationAkima   ,  -2,   1 },

  {"InterpolationMatrix"   , (CAST)F_InterpolationMatrix   ,  -1,   1 },

  {"ValueFromIndex"        , (CAST)F_ValueFromIndex        ,  -1,   0 },

  {"TransformTensor"       , (CAST)F_TransformTensor       ,   4,   4 }, /* pour Tuan */
  {"TransformPerm"         , (CAST)F_TransformPerm         ,   3,   1 }, /* pour Tuan */
  {"TransformPiezo"        , (CAST)F_TransformPiezo        ,   4,   2 }, /* pour Tuan */
  {"TransformPiezoT"       , (CAST)F_TransformPiezoT       ,   4,   2 }, /* pour Tuan */

  {"VirtualWork"           , (CAST)F_VirtualWork           ,   0,   1 }, /* pour Patrick */

  {"dhdb_Jiles"            , (CAST)F_dhdb_Jiles            ,   1,   3 }, /* pour Johan */
  {"dbdh_Jiles"            , (CAST)F_dbdh_Jiles            ,   1,   3 }, /* pour Johan */
  {"h_Jiles"               , (CAST)F_h_Jiles               ,   1,   3 }, /* pour Johan */
  {"b_Jiles"               , (CAST)F_b_Jiles               ,   1,   3 }, /* pour Johan */


  /* F_MultiHar */

  {"MHToTime"          , (CAST)F_MHToTime         ,   0,   2 },

  /* F_Analytic */

  {"F_Sphere"          , (CAST)F_Sphere           ,   6,   0 },
  {"F_Cylinder"        , (CAST)F_Cylinder         ,   7,   0 },
 
  {"JFIE_ZPolAnalyticOnCyl",      (CAST)F_JFIE_ZPolCyl     ,   4,   1 },
  {"RCS_ZPolAnalyticCyl",         (CAST)F_RCS_ZPolCyl      ,   3,   1 }, 
  {"JFIE_TransZPolAnalyticOnCyl", (CAST)F_JFIE_TransZPolCyl,   3,   1 },
  {"JFIE_OnSphCutTheta",          (CAST)F_JFIE_SphTheta,       4,   1 },
  {"RCS_SphTheta",                (CAST)F_RCS_SphTheta,        4,   1 },
  {"JFIE_OnSphCutPhi",            (CAST)F_JFIE_SphPhi,         4,   1 },
  {"RCS_SphPhi",                  (CAST)F_RCS_SphPhi,          4,   1 },

  {"AcousticSoftSphere",          (CAST)F_AcousticSoftSphere,  0,   4 },
  {"AcousticFieldSoftCylinder",   (CAST)F_AcousticFieldSoftCylinder, 2, 1},
  {"DrAcousticFieldSoftCylinder", (CAST)F_DrAcousticFieldSoftCylinder, 2, 1},
  {"AcousticFieldHardCylinder",   (CAST)F_AcousticFieldHardCylinder, 2, 1},

  {"OSRC_C0",   (CAST)F_OSRC_C0, 2, 0},
  {"OSRC_Aj",   (CAST)F_OSRC_Aj, 3, 0},
  {"OSRC_Bj",   (CAST)F_OSRC_Bj, 3, 0},

  /* GF_XXX : Green Functions */

  {"Laplace"           , (CAST)GF_Laplace          ,   1,   0 },
  {"GradLaplace"       , (CAST)GF_GradLaplace      ,   1,   0 },
  {"NPxGradLaplace"    , (CAST)GF_NPxGradLaplace   ,   1,   0 },
  {"NSxGradLaplace"    , (CAST)GF_NSxGradLaplace   ,   1,   0 },
  {"ApproximateLaplace", (CAST)GF_ApproximateLaplace,  2,   0 },

  {"Helmholtz"         , (CAST)GF_Helmholtz        ,   2,   0 },
  {"HelmholtzThinWire" , (CAST)GF_HelmholtzThinWire,   3,   0 },
  {"GradHelmholtz"     , (CAST)GF_GradHelmholtz    ,   2,   0 },
  {"NPxGradHelmholtz"  , (CAST)GF_NPxGradHelmholtz ,   2,   0 },
  {"NSxGradHelmholtz"  , (CAST)GF_NSxGradHelmholtz ,   2,   0 },

  /* Biot Savart law */
  {"BiotSavart"        , (CAST)F_BiotSavart        ,   1,   0 },
  /* Pocklintong's integral equation */
  {"Pocklington"       , (CAST)F_Pocklington       ,   2,   0 },

  /* F_DiscreteGeometry */
  {"IncMatrixEdgesXNodes"    , (CAST)F_IncMatrixEdgesXNodes       ,   0,   0 },

  {"MatrixDualEdgesXEdges"    , (CAST)F_MatrixDualEdgesXEdges     ,   0,   1 },



  {NULL                , NULL                      ,   0,   0 } 

} ;




/* ------------------------------------------------------------------------ */
/*  The Green Function and its associated Analytical Integration function   */
/* ------------------------------------------------------------------------ */


struct FunctionXFunction  GF_Function[] = {

  {(CAST)GF_Laplace         , (CAST)GF_LaplacexForm        } ,
  {(CAST)GF_GradLaplace     , (CAST)GF_GradLaplacexForm    } ,
  {(CAST)GF_NPxGradLaplace  , (CAST)GF_NPxGradLaplacexForm } ,
  {(CAST)GF_NSxGradLaplace  , (CAST)GF_NSxGradLaplacexForm } ,
  {(CAST)GF_ApproximateLaplace  , (CAST)GF_ApproximateLaplacexForm  } ,
  {(CAST)GF_Helmholtz         , (CAST)GF_HelmholtzxForm        } ,
  {NULL                       , NULL }  

} ;


/* ------------------------------------------------------------------------ */
/* The Green Function and its associated FMM Matrix-Vector product function */
/* ------------------------------------------------------------------------ */


struct FunctionXFunction FMMProd_Function2D[] = {

  {(CAST)GF_Laplace         , (CAST)FMMProd_AllLaplace2D        } ,
  {(CAST)GF_GradLaplace     , (CAST)FMMProd_AllLaplace2D    } ,
  {(CAST)GF_NPxGradLaplace  , (CAST)FMMProd_AllLaplace2D    } ,
  {(CAST)GF_Helmholtz       , (CAST)FMMProd_AllHelmholtz   } ,
  {(CAST)GF_GradHelmholtz   , (CAST)FMMProd_AllHelmholtz   } ,
  {(CAST)GF_NSxGradHelmholtz, (CAST)FMMProd_AllHelmholtz   } ,
  {NULL                     , NULL }  

} ;


struct FunctionXFunction FMMProd_Function3D[] = {

  {(CAST)GF_Laplace         , (CAST)FMMProd_AllLaplace3D   } ,
  {(CAST)GF_GradLaplace     , (CAST)FMMProd_AllLaplace3D   } ,
  {(CAST)GF_NPxGradLaplace  , (CAST)FMMProd_AllLaplace3D  } ,
  {(CAST)GF_Helmholtz       , (CAST)FMMProd_AllHelmholtz   } ,
  {(CAST)GF_HelmholtzThinWire, (CAST)FMMProd_AllHelmholtz   } ,
  {(CAST)GF_GradHelmholtz   , (CAST)FMMProd_AllHelmholtz   } ,
  {(CAST)GF_NSxGradHelmholtz, (CAST)FMMProd_AllHelmholtz   } ,
  {NULL                     , NULL }  

} ;



#undef CAST

#endif