fapi.h

Go to the documentation of this file.

#include <front/fdecs.h>

                /* Front IMPORTED Function Prototypes*/

#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif

   IMPORT  void FT_Init(int argc,
            char **argv, 
            F_BASIC_DATA *f_basic );

   IMPORT  void FT_ReadSpaceDomain(char *in_name, 
                    F_BASIC_DATA *f_basic);

   IMPORT  void FT_ReadComparisonDomain(char *in_name, 
                    F_BASIC_DATA *f_basic);

   IMPORT  void FT_StartUp(Front* front ,
                 F_BASIC_DATA* f_basic );

   IMPORT  void FT_InitDebug(char *inname );

   IMPORT  void FT_InitIntfc(Front *front ,
                   LEVEL_FUNC_PACK *level_func_pack );

   IMPORT  void FT_ClipIntfcToSubdomain(Front *front);

   IMPORT  void    FT_InitFrontVeloFunc(Front *front ,
                 VELO_FUNC_PACK *velo_func_pack );


   IMPORT  void FT_ReadTimeControl(char *in_name ,
                     Front *front );

   IMPORT  void FT_ResetTime(Front *front );

   IMPORT  POINTER *FT_CreateLevelHyperSurfs(
            RECT_GRID *rgr,
                INTERFACE *intfc,
                int neg_comp,
                int pos_comp,
                double    (*func)(POINTER,double*),
                POINTER   func_params,
                int       w_type,
                int       *num_hs);

   IMPORT  void FT_Propagate(Front *front);

   IMPORT  void FT_RedistMesh(Front *front);

   IMPORT  void FT_OptimizeMesh(Front *front, SCALED_REDIST_PARAMS params);

   IMPORT  boolean FT_OptimizeSurfMesh(Front *front, SURFACE *surf, SCALED_REDIST_PARAMS params);

   IMPORT  boolean FT_OptimizeCurveMesh(Front *front, CURVE *curve, SCALED_REDIST_PARAMS params);

   IMPORT  void FT_SetCurveSpacing(Front *front, double scaled_spacing);

   IMPORT  void FT_OptimizeCurveMeshWithEqualBonds(Front *front, CURVE *curve);

   IMPORT  void FT_SetTimeStep(Front *front );

   IMPORT  void FT_SetOutputCounter(Front *front );

   IMPORT  void FT_TimeControlFilter(Front *front );

   IMPORT  boolean FT_IsSaveTime(Front *front );

   IMPORT  boolean FT_IsDrawTime(Front *front );

   IMPORT  boolean FT_TimeLimitReached(Front *front );

   IMPORT  void FT_RecordMaxFrontSpeed(
                int dir ,
                double speed ,
                POINTER state ,
                double *coords ,
                Front* front );

   IMPORT  void FT_AddTimeStepToCounter(Front *front );

   IMPORT  void FT_Save(Front *front);

   IMPORT  void FT_Draw(Front *front);

   IMPORT  void FT_XgraphSampleLine(char *dirname,
            char *varname,
            boolean data_in_domain,
            int size,
            double *x,
            double *var);

   IMPORT  void FT_MakeGridIntfc(Front *front );

   IMPORT  void FT_FreeGridIntfc(Front *front );

   IMPORT  void FT_MakeCompGridIntfc(Front *front );

   IMPORT  void FT_FreeCompGridIntfc(Front *front );

   IMPORT  void FT_FreeOldGridIntfc(Front *front );

   IMPORT  void FT_FreeFront(Front *front );

   IMPORT  void FT_FreeMainIntfc(Front *front );

   IMPORT  boolean FT_NormalAtGridCrossing(Front *front ,
                int *icoords ,
                GRID_DIRECTION  dir ,
                int  comp ,
                double *nor ,
                HYPER_SURF **hs ,
                double *crx_coords );

   IMPORT  boolean FT_StateStructAtGridCrossing(Front *front ,
                INTERFACE *grid_intfc,
                int *icoords,
                GRID_DIRECTION  dir,
                int  comp,
                POINTER *state,
                HYPER_SURF **hs,
                double *crx_coords);

   IMPORT  boolean FT_StateVarAtGridCrossing(Front *front ,
                int *icoords ,
                GRID_DIRECTION  dir ,
                int  comp ,
                double (*state_func)(Locstate) ,
                double *ans ,
                double *crx_coords );

   IMPORT  HYPER_SURF *FT_HyperSurfAtGridCrossing(Front *front ,
                int *icoords ,
                GRID_DIRECTION  dir,
                int wave_type);

   IMPORT  boolean FT_IntrpStateVarAtCoords(Front *front ,
                int comp , 
                double *coords , 
                double *var_array , 
                double (*state_func)(POINTER) , 
                double *ans,
                double *default_ans);

   IMPORT  boolean FT_CompGridIntrpStateVarAtCoords(Front *front ,
                int comp , 
                double *coords , 
                double *var_array , 
                double (*state_func)(POINTER) , 
                double *ans,
                double *default_ans);

   IMPORT  boolean FT_NearestRectGridVarInRange(Front *front ,
                int comp , 
                double *coords , 
                double *var_array , 
                int range,
                double *ans);

   IMPORT  boolean FT_FindNearestIntfcPointInRange(Front *front ,
                    int comp ,
                    double *coords ,
                    USE_BOUNDARIES bdry,
                    double *intfc_point ,
                    double *t ,
                    HYPER_SURF_ELEMENT **hse ,
                    HYPER_SURF **hs ,
                    int range );

   IMPORT  void FT_NormalAtPoint(POINT *p ,
                Front *front ,
                double *normal ,
                int comp );

   IMPORT  void FT_CurvatureAtPoint(POINT *p ,
                Front *front ,
                double *curvature );


   IMPORT  double FT_GridSizeInDir(double *dir ,
                Front *front );

   IMPORT  Nor_stencil *FT_CreateNormalStencil(Front *front ,
                                POINT *p ,
                                int comp ,
                                int num_pts );

   IMPORT  boolean FT_ReflectPointThroughBdry(
                Front *front ,
                HYPER_SURF *hs ,
                double *coords ,
                int comp ,
                double *coords_bdry ,
                double *coords_ref ,
                double *normal );

   IMPORT  void FT_SetDirichletBoundary(Front *front ,
                void (*state_func)(double*,HYPER_SURF*,Front*,POINTER,POINTER) ,
                const char *state_func_name ,
                POINTER state_func_params ,
                POINTER state ,
                HYPER_SURF *hs );

   IMPORT  void FT_InsertDirichletBoundary(Front *front ,
                void (*state_func)(double*,HYPER_SURF*,Front*,POINTER,POINTER) ,
                const char *state_func_name ,
                POINTER state_func_params ,
                POINTER state ,
                HYPER_SURF *hs ,
                int index);

   IMPORT  HYPER_SURF **FT_MixedBoundaryHypSurfs(
            INTERFACE *intfc,
            int idir,
            int nb,
            int w_type,
            int *num_hs);

   IMPORT  void FT_PromptSetMixedTypeBoundary2d(
            char *in_name,
            Front *front);

   IMPORT  int FT_Dimension();

   IMPORT  int FT_RectBoundaryType(Front *front ,
                int dir,
                int side);

   IMPORT  boolean FT_FrontContainWaveType(Front *front , int w_type);

   IMPORT  HYPER_SURF *FT_RectBoundaryHypSurf(INTERFACE *intfc ,
                int wave_type,
                int dir,
                int side);

   IMPORT  HYPER_SURF **FT_InteriorHypSurfs(INTERFACE *intfc ,
                int wave_type,
                int *num_hs);

   IMPORT  void FT_ParallelExchIntfcBuffer(Front* front );

   IMPORT  void FT_ParallelExchGridArrayBuffer(double *grid_array ,
                Front* front ,
                int* symmetry);

   IMPORT  void FT_ParallelExchGridIntArrayBuffer(int *iarray ,
                Front* front);

   IMPORT  void FT_ParallelExchGridVectorArrayBuffer(
                double **vec_grid_array ,
                Front* front);

   IMPORT  void FT_ParallelExchCompGridArrayBuffer(double *grid_array ,
                Front* front ,
                int* symmetry);

   IMPORT  void FT_ParallelExchCellIndex(Front* front ,
                int *lbuf,
                int *ubuf,
                POINTER ijk_to_I);

   IMPORT  void FT_ParallelExchCompGridCellIndex(Front* front ,
                int *lbuf,
                int *ubuf,
                POINTER ijk_to_I);

   IMPORT  INTERFACE *FT_CollectHypersurfFromSubdomains(Front* front,
                int *owner,
                int w_type);

   IMPORT  void FT_GetStatesAtPoint(POINT *p,
                HYPER_SURF_ELEMENT *hse,
                HYPER_SURF *hs,
                POINTER *sl,
                POINTER *sr);

   IMPORT  void FT_ScalarMemoryAlloc(POINTER* a,
                int size);

   IMPORT  void FT_VectorMemoryAlloc(POINTER* a,
                int n1,
                int size);

   IMPORT  void FT_MatrixMemoryAlloc(POINTER* a,
                int n1,
                int n2,
                int size);

   IMPORT  void FT_TriArrayMemoryAlloc(POINTER* a,
                int n1,
                int n2,
                int n3,
                int size);

   IMPORT  void FT_QuadArrayMemoryAlloc(POINTER* a,
                int n1,
                int n2,
                int n3,
                int n4,
                int size);

   IMPORT  void FT_QuinArrayMemoryAlloc(POINTER* a,
                int n1,
                int n2,
                int n3,
                int n4,
                int n5,
                int size);

   IMPORT  void FT_SexArrayMemoryAlloc(POINTER* a,
                int n1,
                int n2,
                int n3,
                int n4,
                int n5,
                int n6,
                int size);

   IMPORT  void FT_SetGlobalIndex(Front *front);

   IMPORT  void FT_FreeThese(int n,...);

/*TMP will move when mature*/
IMPORT  boolean FT_StateStructAtGridCrossing2(Front *front ,
                                int *icoords ,
                                GRID_DIRECTION  dir ,
                                int  comp ,
                                POINTER *state ,
                                HYPER_SURF **hs ,
                                HYPER_SURF_ELEMENT **hse ,
                                double *crx_coords );

   IMPORT  double FT_ComputeTotalVolumeFraction(
                Front *front,
                COMPONENT comp_of_vol);

   IMPORT  void FT_ComputeGridVolumeFraction(
                Front *front,
                COMPONENT comp_of_vol,
                POINTER *grid_vol_frac);

   IMPORT  void FT_CurveSegLengthConstr(
                CURVE *c, 
                BOND *bs, 
                BOND *be, 
                int nb, 
                double seg_length, 
                REDISTRIBUTION_DIRECTION dir);

   IMPORT  CURVE *FT_MakeNodeArrayCurve(Front *front,int num_nodes,double **node_array,COMPONENT neg_comp,COMPONENT pos_comp,boolean is_closed_curve,double scale_factor, int w_type);

   IMPORT  CURVE *FT_MakePointArrayCurve(Front *front,int num_points,double **point_array,COMPONENT neg_comp,COMPONENT pos_comp,boolean is_closed_curve,int w_type);

   IMPORT  void FT_MakeEllipticSurf(Front *front,double *center,double *radius,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,int refinement_level,SURFACE **surf);

   IMPORT  void FT_MakeDumbBellSurf(Front *front,double x0,double x1,double y0,double z0,double R,double r,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

   IMPORT  void FT_MakeProjectileSurf(Front *front,double *center,double R,double r,double h,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

   IMPORT  CURVE *FT_MakeParametricCurve(Front *front, COMPONENT neg_comp, COMPONENT pos_comp, int w_type, boolean (*func)(POINTER,double,double*), POINTER func_params, int refinement_level, boolean is_closed);


   IMPORT  void FT_RotateSurface(SURFACE *surf,double *center,double phi,double theta);

    IMPORT void FT_MakeCuboidSurf(Front *front,double *center,double *edge,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

    IMPORT void FT_MakeCylinderSurf(Front *front,double *center,double radius, double height, COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

    IMPORT void FT_MakeConeSurf(Front *front,double *center,double slope, double height, COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

    IMPORT void FT_MakeTetrahedronSurf(Front *front,double *center,double radius,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

   IMPORT  void FT_MakePlaneSurf(Front *front,double *plane_nor,double *plane_pt,boolean reset_bdry_comp,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,SURFACE **surf);

   IMPORT  void FT_InstallSurfEdge(SURFACE *surf,int hsbdry_type);

   IMPORT  void FT_CutSurfBdry(SURFACE *surf,boolean constr_func(POINTER,double*),POINTER func_params,double **insert_coords,int num_pts,int insert_idir);

   IMPORT  void FT_MakeEllipticCurve(Front *front,double *center,double *radius,COMPONENT neg_comp,COMPONENT pos_comp,int w_type,int refinement_level,CURVE **curve);

   IMPORT  void FT_PrintWaveType(int w_type);

   IMPORT  void FT_PrintBoundaryType(int dir,int side);

   IMPORT  int FT_BoundaryType(int dir,int side);

   IMPORT  double *FT_GridIntfcTopL(Front*);

   IMPORT  double *FT_GridIntfcTopU(Front*);

   IMPORT  double *FT_GridIntfcToph(Front*);

   IMPORT  COMPONENT *FT_GridIntfcTopComp(Front*);

   IMPORT  COMPONENT *FT_GridIntfcTopGmax(Front*);

   IMPORT  RECT_GRID *FT_GridIntfcTopGrid(Front*);

   IMPORT  void FT_AddHdfMovieVariable(
    Front *front,
        boolean preset_bound,
        boolean untracked,
        COMPONENT obst_comp,
        const char *var_name,
    int idir,
        double *var_field,
        double (*getStateFunc)(POINTER),
        double max_var,
        double min_var);

   IMPORT  void FT_AddVtkVectorMovieVariable(
    Front *front,
        const char *var_name,
        double **var_field);

   IMPORT  void FT_AddVtkScalarMovieVariable(
    Front *front,
        const char *var_name,
        double *var_field);

   IMPORT  void FT_AddVtkIntfcMovieVariable(
    Front *front,
        const char *var_name);

   IMPORT  void FT_ResetDomainAndGrid(Front *front,
    double *L,
        double *U,
        int *gmax);

   IMPORT  boolean FT_CoordsInSubdomain(Front* front,
                double *coords);

   IMPORT  void FT_PrintTimeStamp(Front *front);

    IMPORT void FT_MakeCrossCylinderSurf(Front *front,
                double *center1,
                double *center2,
                double radius1,
                double radius2,
                double height1,
                double height2, 
                COMPONENT neg_comp,
                COMPONENT pos_comp,
                int w_type,
                SURFACE **surf);

    IMPORT void FT_MakeBowlSurf(Front *front,
                double *center,
                double radius1,
                double radius2,
                double radius3,
                double height1,
                double height2, 
                COMPONENT neg_comp,
                COMPONENT pos_comp,
                int w_type,
                SURFACE **surf);

    IMPORT void FT_MakePlatformSurf(Front *front,
            double *center,
            double radius, 
            double height, 
            double slope, 
            COMPONENT neg_comp,
            COMPONENT pos_comp,
            int w_type,
            SURFACE **surf);

    IMPORT void FT_MakeStellatedOctahedronSurf(Front *front,
            double *center,
            double edge,
            COMPONENT neg_comp,
            COMPONENT pos_comp,
            int w_type,
            SURFACE **surf);

   IMPORT  void    FT_InitSurfVeloFunc(SURFACE *surf,
            POINTER vparams,
            int (*vfunc)(POINTER,Front*,POINT*,HYPER_SURF_ELEMENT*,HYPER_SURF*,double*));

   IMPORT  void    FT_InitCurveVeloFunc(CURVE *curve,
            POINTER vparams,
            int (*vfunc)(POINTER,Front*,POINT*,HYPER_SURF_ELEMENT*,HYPER_SURF*,double*));

   IMPORT  void    FT_InitNodeVeloFunc(NODE *node,
            POINTER vparams,
            int (*vfunc)(POINTER,Front*,POINT*,HYPER_SURF_ELEMENT*,HYPER_SURF*,double*));


   IMPORT  boolean FT_CheckSurfCompConsistency(
            Front *front,
            SURFACE *surf);

#if defined(c_plusplus) || defined(__cplusplus)
}
#endif