include/mmh_intf.h

Go to the documentation of this file.

/************************************************************************
File mmh_intf.h - interface with mesh manipulation module of the code.

Apart from some refinement functions (and possibly some special functions, 
e.g. for remesh module) mesh module functions are local (O(1)) and do not
have to be parallelized (they are even not assumed to be thread safe!!!) 

Contains declarations of constants and interface routines:
  mmr_module_introduce - to return the mesh name
  mmr_init_mesh - to initialize the mesh data structure
  mmr_export_mesh - to export (write to a file) mesh data in a specified format
  mmr_test_mesh - to test the integrity of mesh data
  OBSOLETE !!! mmr_get_mesh_i_params - to return mesh parameters
  mmr_get_nr_elem - to return the number of active elements
  mmr_get_max_elem_id - to return the maximal element id
  mmr_get_next_act_elem - to return the next active element id
  mmr_get_next_elem_all - to return the next element id (active or inactive)
  mmr_get_nr_face - to return the number of active faces
  mmr_get_max_face_id - to return the maximal face id
  mmr_get_next_act_face - to return the next active face id
  mmr_get_next_face_all - to return the next face id (active or inactive)
  mmr_get_nr_edge - to return the number of active edges
  mmr_get_max_edge_id - to return the maximal edge id
  mmr_get_next_edge_all - to return the next edgeent id (active or inactive)
  mmr_get_nr_node - to return the number of active nodes
  mmr_get_max_node_id - to return the maximal node id
  mmr_get_next_node_all - to return the next node id (active or inactive)
  mmr_get_max_gen - to get maximal allowed generation level for elements
  mmr_set_max_gen - to set maximal allowed generation level for elements
  mmr_get_max_gen_diff - to get maximal allowed generation difference between
                         neighboring elements
  mmr_set_max_gen_diff - to set maximal allowed generation difference between
                         neighboring elements

  mmr_get_max_elem_max - to return the maximal possible element id
  mmr_get_max_face_max - to return the maximal possible face id
  mmr_get_max_edge_max - to return the maximal possible edge id
  mmr_get_max_node_max - to return the maximal possible vertex id

  mmr_init_ref - to initialize the process of refinement
  mmr_refine_el - to refine an element  WITHOUT IRREGULARITY CHECK
  mmr_r_refine - to r-refine an element with given boundary conditions
  mmr_derefine_el - to derefine an element  WITHOUT IRREGULARITY CHECK
  mmr_refine_mesh - to refine the WHOLE mesh WITHOUT IRREGULARITY CHECK
  mmr_derefine_mesh - to derefine the WHOLE mesh WITHOUT IRREGULARITY CHECK
  mmr_final_ref - to finalize the process of refinement after rewriting DOFs
  mmr_is_ready_for_proj_dof_ref - to check if mesh module is ready for dofs projection
  mmr_free_mesh - to free space allocated for mesh data structure

  mmr_gen_boundary_layer - to generate boundary layer (for tetrahedral meshes only)
  mmr_elem_structure - to return elem structure (e.g. for sending)
  mmr_el_status - to return element status (active, inactive, free space)
  mmr_el_type - to return element type
  mmr_el_groupID - to return material ID for element
  mmr_el_set_mate - to set material number for element
  mmr_el_type_ref - to return element's type of refinement
  mmr_el_faces - to get faces and big neighbors of an element
  mmr_el_edges - to get element's edges
  mmr_el_node_coor - to get the coordinates of element's nodes
  mmr_el_fam - to return family information for an element
  mmr_el_fam_all - to return all recursive family information for an element
  mmr_el_gen - to return generation level for an element
  mmr_el_ancestor - to find the ancestor of an element
  mmr_el_eq_neig - to get equal size (or larger) neighbors of an element
  mmr_el_hsize - to compute a characteristic linear size for an element
  mmr_set_elem_fath - to set family data for an elem
  mmr_set_elem_fam - to set family data for an elem
  mmr_el_fa_nodes - to get list of local indexes for face nodes in elem

  mmr_face_structure - to return face structure (e.g. for sending)
  mmr_fa_status - to return face status (active, inactive, free space)
  mmr_fa_type - to return face type (triangle, quad, free space)
  mmr_fa_bc - to get the boundary condition flag for a face
  mmr_fa_sub_bnd - to indicate face is on the subdomain boundary
  mmr_fa_set_sub_bnd - to indicate face is on the subdomain boundary
  mmr_fa_edges - to return a list of face's edges
  mmr_fa_eq_neig - to return a list of face's neighbors and
        corresponding neighbors' sides (only equal size
        neighbors considered)
  mmr_fa_neig - to return a list of face's neighbors and
        corresponding neighbors' sides (for active
        faces all neighbors are active)
  mmr_fa_node_coor - to get the list and coordinates of faces's nodes
  mmr_fa_elem_coor - to find coordinates within neighboring
        elements for a point on face
  mmr_fa_area - to compute the area of face and vector normal
  mmr_fa_fam - to return face's family information
  mmr_set_face_fam - to set family data for an face
  mmr_set_face_neig - to set neighbors data for a face

  mmr_edge_status - to return edge status (active, inactive, free space)
  mmr_edge_nodes - to return edge node's IDs
  mmr_edge_sons - to return edge son's numbers
  mmr_edge_elems - to return a list of elements containing the edge
  mmr_edge_structure - to return edge structure (e.g. for sending)
  mmr_set_edge_type - to set type for an edge
  mmr_set_edge_fam - to set family data for an edge

  mmr_node_status - to return node status (active, free space)
  mmr_node_coor - to return node coordinates
  mmr_set_node_coor - set node coordinates
  mmr_move_node - moves node by vector

  mmr_loc_loc - to compute local coordinates within an element,
    given local coordinates within an element of the same family

  mmr_create_element - to create an element and fill its data structure
  mmr_create_face - to create a new face
  mmr_create_edge - to create a new edge structure
  mmr_create_node - to create a node
  mmr_clust_face - to cluster back a family of faces
  mmr_clust_edge  - to cluster two edges back into their father

  mmr_divide_face - to divide a face into sons
  mmr_divide_edge - to divide an edge into two sons

  mmr_del_elem    - to free an element structure
  mmr_del_face    - to free a face structure
  mmr_del_edge    - to free an edge structure
  mmr_del_node    - to free a node structure


// The five next functions are not supported by mmd_prism, mmd_prism_2D and mmd_remesh modules!!!

  mmr_reserve - to inform mesh module about new target number of elems,faces,edges and nodes
  mmr_add_elem - to add (append) new element
  mmr_add_face - to add (append) new face
  mmr_add_edge - to add (append) new edge
  mmr_add_node - to add (append) new node

// Groups and contact BCs handling
extern int mmr_groups_number(const int Mesh_id);
extern int mmr_groups_ids(const int Mesh_id, int *tab, int l_tab);
extern int mmr_split_into_blocks_add_contact(const char *workdir,const int Mesh_id, int *tabMat,int l_mat,int *tabBlock,int l_block,int *war,int l_war,double *tempBlock,int l_tempBlock,int *groups_fluid,int l_groups_fluid);
int mmr_get_fa_el_bc_connect(int face_id,int &el_id) - return 0 if normal bc else return connected face_id


// Below are functions used by modules intarfacing with REMESH module ONLY !!!!

  mmr_init_dist2bound - to initialize and pre-compute resources for mmr_get_el_dist2bound
  mmr_get_el_dist2boundary - to get distance from point inside element to nearest boundary

  mmr_get_coor_from_element_motion(int idEl,int idLP,double *coor,int flagaSiatki);

  mmr_copyMESH(int flaga);
  mmr_create_mesh_Cube(const char *nazwa,int node_x,int node_y,int node_z,double size_x,double size_y,double size_z,double divide,int *warunki);
  mmr_init_all_change(int a);
  mmr_test_mesh_motion(int ileWarstw,int obecny_krok, int od_krok,int ileKrok,double minPoprawy,double px0,double py0,double pz0,double px1,double py1,double pz1,double endX,double endY,double endZ);
  mmr_test_weldpool(double obecnyKrok, double krok_start,double minPoprawy,double doX,double doY,double dl,double zmiejszaPrzes,double limit,double szerokosc);


------------------------------
History:
    02.2002 - Krzysztof Banas, initial version
    06.2010 - Kazimierz Michalik, hybrid mesh
    10.2012 - Kazimierz Michalik, modyfied I/O
*************************************************************************/

#ifndef _mmh_intf_
#define _mmh_intf_

#include <stdio.h>

#ifdef __cplusplus
extern "C"{
#endif

#define MMC_MAXELFAC        5   
#define MMC_MAXFAVNO        4   
#define MMC_MAXELVNO        6   
#define MMC_MAXELSONS       8   
#define MMC_MAXELEDGES      9   
extern const int MMC_MAX_EDGE_ELEMS;/*max number of elements containg an edge*/

extern const int MMC_CUR_MESH_ID; 
extern const int MMC_INIT_GEN_LEVEL;   // value of 'initial mesh' generation level

typedef enum {
    MMC_MOD_FEM_MESH_DATA   = 0, 
    MMC_MOD_FEM_PRISM_DATA  = 1, 
    MMC_MOD_FEM_TETRA_DATA  = 2, 
    MMC_MOD_FEM_HYBRID_DATA = 3, 
    MMC_GRADMESH_DATA       = 10, 
    MMC_HP_FEM_MESH_DATA    = 1, 
    MMC_NASTRAN_DATA        = (int)'n',
    MMC_NASTRAN_FREE_DATA   = MMC_NASTRAN_DATA,
    MMC_NASTRAN_SHORT_DATA  = (int)'s',
    MMC_NASTRAN_LONG_DATA   = (int)'l',
    MMC_BINARY_DATA         = (int)'b', 
    MMC_BOUND_VERTS_DATA    = (int)'m', 
    MMC_IN_ANSYS_DATA       = (int)'i', 
    MMC_PARAVIEW_VTK_DATA   = (int)'v', 
    MMC_MSH_DATA            = (int)'f', 
    MMC_MAX_FILE_TYPE=126
} mmt_file_type;


extern const int MMC_AUTO_GENERATE_ID;

extern const int MMC_BOUNDARY;         
extern const int MMC_BIG_NGB;          
extern const int MMC_SUB_BND;         
/* Identifiers of mesh entities */
typedef enum {
    MMC_NODE    = 0,
    MMC_EDGE    = 1,
    MMC_FACE    = 2,
    MMC_ELEMENT = 3,
    MMC_ALL_N_TYPES
} mmt_mesh_entity;

typedef enum {
    MMC_QUAD            = 4, 
    MMC_TRIA            = 3, 
    MMC_TETRA           = 7, 
    MMC_PRISM           = 5, 
    MMC_BRICK           = 6, 
    MMC_ENTITY_UNKNOWN  = -1 
} mmt_mesh_entity_types;



extern const int MMC_DO_UNI_REF;   
extern const int MMC_DO_UNI_DEREF; 
extern const int MMC_ACTIVE;           
extern const int MMC_INACTIVE;         
extern const int MMC_FREE;             
extern const int MMC_PRINT_NOT;     
extern const int MMC_PRINT_ERRORS;  
extern const int MMC_PRINT_INFO;    
extern const int MMC_PRINT_ALLINFO; 
extern const int MMC_NOT_REF;          
extern const int MMC_REF_ISO;          
extern const int MMC_REF_ANI;          
extern const int MMC_INIT_GEN_LEVEL;   // value of 'initial mesh' generation level
extern const int MMC_NO_FATH;       
extern const int MMC_FACE_NODES_FOR_TETRA[4][3];
extern const int MMC_FACE_NODES_FOR_PRISM[5][4];

extern const int MMC_IS_SUPPORTING_NEW_MPI;

extern int mmr_module_introduce(
  char* Mesh_name 
  );

extern void* mmr_module_internals(
  int Mesh_id
  );


extern int mmr_init_mesh(  
  int Control,      
  char *Filename,    
  FILE* interactive_output // in: name of the output file to write out messages
  );

//------------------------------------------------------------
//  mmr_init_mesh - to initialize the mesh data structure
//------------------------------------------------------------
// NOTE: this is NOT a resize function. It does NOT ADD any elements.
// It only creates new mesh and reserves resources for it.
// To add mesh entities use mmr_add_* functions.
//------------------------------------------------------------
extern int mmr_init_mesh2(  
    FILE* Interactive_output, // in: name of the output file to write out messages
    const int N_nodes, //IN: target count of nodes
    const int N_edges, //IN: target count of edges
    const int N_faces, //IN: target count of faces
    const int N_elems  //IN: target count of elements
  );

extern int mmr_export_mesh( 
  int Mesh_id,    
  int Control,    
  char *Filename  
  );

extern int mmr_test_mesh( 
  int Mesh_id   
  );

int mmr_mesh_i_params(  
  int Mesh_id,  
  int Num          
  );

extern int mmr_get_nr_elem(
  int Mesh_id   
  );

extern int mmr_get_max_elem_id(  
  int Mesh_id   
  );

extern int mmr_get_next_act_elem(
  int Mesh_id,  
  int Nel       
  );

extern int mmr_get_next_elem_all( 
  int Mesh_id,  
  int Nel       
  );

extern int mmr_get_nr_face(
  int Mesh_id   
  );

extern int mmr_get_max_face_id(  
  int Mesh_id   
  );

extern int mmr_get_next_act_face( 
  int Mesh_id,  
  int Nfa       
  );

extern int mmr_get_next_face_all( 
  int Mesh_id,  
  int Nfa       
  );

extern int mmr_get_nr_edge(
  int Mesh_id   
  );

extern int mmr_get_max_edge_id(  
  int Mesh_id   
  );

extern int mmr_get_next_edge_all( 
  int Mesh_id,  
  int Ned       
  );

extern int mmr_get_nr_node(
  int Mesh_id   
  );

extern int mmr_get_max_node_id(  
  int Mesh_id   
  );

extern int mmr_get_next_node_all( 
  int Mesh_id,  
  int Nno       
  );

extern int mmr_get_max_gen(
  int Mesh_id   
  );

extern int mmr_set_max_gen(
  int Mesh_id,  
  int Max_gen   
  );

extern int mmr_get_max_gen_diff(
  int Mesh_id   
  );

extern int mmr_set_max_gen_diff(
  int Mesh_id,  
  int Max_gen_diff    
  );

extern int mmr_init_ref(  
  int Mesh_id   
);

int mmr_refine_el( 
  int Mesh_id,  
  int El   
);

int mmr_derefine_el( 
  int Mesh_id,  
  int El  
);

int mmr_refine_mesh( 
  int Mesh_id  
);

int mmr_derefine_mesh( 
  int Mesh_id   
);

extern int mmr_is_ready_for_proj_dof_ref(
  int Mesh_id
);

extern int mmr_r_refine( 
  int Mesh_id,
  int Bc,
  void (*reallocation_func)(double * x,double * y, double * z)
);

extern int mmr_gen_boundary_layer(
  int Mesh_id,
  int Bc,
  int thicknessProc,
    // in: total thickness of boundary layers expressed as % of mesh size
  int noLayers, //in: number of layers
  int distribuiton, //in: layer distributin (linear=1, exp=2)
  double * ignoreVect
);

extern int mmr_final_ref(  
  int Mesh_id   
);

extern int mmr_free_mesh(  
  int Mesh_id   
  );


extern int mmr_elem_structure(
  int Mesh_id,     
  int El,      
  int* Elem_struct 
  );

extern int mmr_el_status( 
  int Mesh_id,  
  int El    
  );


extern int mmr_el_type( 
            /*   7 (MMC_TETRA) - tetrahedron */
            /*   5 (MMC_PRISM) - prism */
            /*   6 (MMC_BRICK) - brick */
            /*   0 (MMC_FREE)  - free space */
  int Mesh_id,  
  int El    
  );

extern int mmr_el_groupID( 
  int Mesh_id,  
  int El    
  );

extern int mmr_el_set_groupID(
  int Mesh_id,  
  int El,   
  int Group_id    
  );

extern int mmr_el_type_ref(
  int Mesh_id,  
  int El    
  );

extern int mmr_el_faces( 
  int Mesh_id,  
  int El,       
  int* Faces,   
                /*  (Faces[0] - number of faces) */
  int* Orient   
            /*  +1 (MMC_SAME_ORIENT) - the same as element */
            /*  -1 (MMC_OPP_ORIENT) - opposite */
  );

extern int mmr_el_node_coor(    
  int Mesh_id,    
  int El,     
  int* Nodes,     
              /*    (Nodes[0] - number of nodes) */
  double* Node_coor 
  );

int mmr_el_edges(   
  int Mesh_id,  
  int El,     
  int* Edges      
              /*    (Edges[0] - number of edges) */
  );

extern int mmr_el_fam( 
  int Mesh_id,  
  int El,       
  int *Elsons,  
  int *Type 
  );

//---------------------------------------------------------
// mmr_el_fam_all - to return all recursive family information for an element
//---------------------------------------------------------
extern int mmr_el_fam_all( 
  int Mesh_id,  
  int El,       
  int *Elsonscd   
  );


extern int mmr_el_gen(   
  int Mesh_id,  
  int El        
  );

extern int mmr_el_ancestor( 
  int Mesh_id,  
  int El,       
  int Ilev      
  );

extern double mmr_el_hsize(   
  int Mesh_id,    
  int El,         
  double *Size_x, 
  double *Size_y,
  double *Size_z
  );

extern int mmr_el_eq_neig( 
  int Mesh_id,  
  int El,       
  int* Neig,    
  int* Neig_sides 
  );

extern int mmr_face_structure(
  int Mesh_id,     
  int Fa,      
  int* Face_struct 
  );

extern int mmr_fa_status( 
              /*     1 (MMC_ACTIVE)   - active face */
              /*     0 (MMC_FREE)     - free space */
              /*    -1 (MMC_INACTIVE) - inactive face */
  int Mesh_id,  
  int Fa    
  );

extern int mmr_fa_type( 
            /*   3 (MMC_TRIA) - triangle */
            /*   4 (MMC_QUAD) - quadrilateral */
            /*   0 (MMC_FREE) - free space */
  int Mesh_id,  
  int Fa    
  );

extern int mmr_fa_bc( 
  int Mesh_id,  
  int Fa          
  );

extern int mmr_fa_set_bc( 
  int Mesh_id,  
  int Fa,         
  int Bc_num    //in: Boundary Condition number associated with face Fa
  );


extern int mmr_fa_sub_bnd( 
  int Mesh_id,    
  int Face_id     
  );

extern int mmr_fa_set_sub_bnd(
  int Mesh_id,    
  int Face_id,    
  int Side_id     
  );

extern int mmr_fa_edges( 
  int Mesh_id,  
  int Fa,         
  int *Fa_edges,  
  int *Ed_orient  
              /*    +1 (MMC_SAME_ORIENT) - the same as face */
              /*    -1 (MMC_OPP_ORIENT)  - opposite */
  );

extern void mmr_fa_eq_neig(
  int Mesh_id,  
  int Fa,       
  int *Fa_neig, 
  int *Neig_sides,      
  int *Node_shift   
            /*  first face's node for first and second */
  );

extern void mmr_fa_neig(
  int Mesh_id,  
  int Fa,               
  int *Fa_neig,         
  int *Neig_sides,      
  int *Node_shift,      
                    /*  first face's node for first and second */
  int *Diff_gen,    
  double *Acoeff,       
  double *Bcoeff    
  );

extern int mmr_fa_fam( 
  int Mesh_id,  
  int Fa,       
  int* Fasons,  
  int* Node_mid 
  );

extern int mmr_fa_node_coor( 
  int Mesh_id,  
  int Fa,        
  int* Nodes,        
  double* Node_coor  
  );


extern int mmr_el_fa_nodes( // returns face type flag
  int Mesh_id,  
  int El,       // in: global elem ID
  int Fa,       
  int *Fa_nodes     
  );

extern void mmr_fa_elem_coor(
  int Mesh_id,  
  double *Xloc,         
  int *Fa_neig,         
                        /*  first - same orientation */
                    /*  second - opposite orientation */
  int *Neig_sides,      
  int Node_shift,       
            /*  first face's node for first and second */
  double *Acoeff,       
  double *Bcoeff,   
  double *Xneig         
  );

extern void mmr_fa_area(
  int Mesh_id,  
  int Fa,       
  double *Area,         
  double *Vec_norm      
  );

extern int mmr_edge_status( 
  int Mesh_id,  
  int Ed    
  );

extern int mmr_edge_nodes( 
  int Mesh_id,  
  int Ed,       
  int *Edge_nodes   
  );

extern int mmr_edge_elems( 
  int Mesh_id,  
  int Ed,       
  int *Edge_elems   
  );

int mmr_create_edge_elems( 
  int  Mesh_id,  
  int Max_edge_id 
  );

extern int mmr_edge_sons( 
  int Mesh_id,  
  int Ed,       
  int *Edge_sons,   
  int *Edge_mid_node    
  );

extern int mmr_edge_structure(
  int Mesh_id,     
  int Ed,      
  int* Edge_struct 
  );

extern int mmr_set_edge_type( 
  int Mesh_id,     
  int Edge_id,     
  int Type         
  );

extern int mmr_set_edge_fam( 
  int Mesh_id,     
  int Edge_id,     
  int Son1,        
  int Son2         
  );

extern int mmr_set_face_fam( 
  int Mesh_id,     
  int Face_id,     
  int *Sons       
  );

extern int mmr_set_face_neig( 
  int Mesh_id,     
  int Face_id,     
  int Neig1,       
  int Neig2,        
  int Neig1Type,    
  int Neig2Type     
  );

int mmr_set_elem_fath( 
  int Mesh_id,     
  int Elem_id,     
  int Fath        
  );

extern int mmr_set_elem_fam( 
  int Mesh_id,     
  int Elem_id,     
  int Fath,        
  int *Sons        
  );

extern int mmr_node_status( 
  int Mesh_id,  
  int Node      
  );

extern int mmr_node_coor( 
  int Mesh_id,  
  int Node,     
  double *Coor  
  );

/*---------------------------------------------------------
mmr_set_node_coor - set node coordinates
---------------------------------------------------------*/
extern int mmr_set_node_coor( /* returns success (>=0) or error (<0) code */
  int Mesh_id,  /* in: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh */
  int Node,     /* in: node ID */
  double *Xcoor     /* in: node coordinates */
  );

/*---------------------------------------------------------
mmr_move_node - moves node by vector
---------------------------------------------------------*/
extern int mmr_move_node( /* returns success (>=0) or error (<0) code */
  int Mesh_id,  /* in: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh */
  int Node,     /* in: node ID */
  double *Dx    /* in: displacement (vector) */
  );

extern int mmr_loc_loc(
  int Mesh_id,   
  int El_from,  
  double* X_from, 
  int El_to,    
  double* X_to  
  );

extern int mmr_create_element(
  int  Mesh_id,  
  int  Type,     
  int  Mate,     
  int  Fath,     
  int  Refi,     
  int* Faces,    
  int* Sons      
  );

extern int mmr_create_face( 
  int  Mesh_id,  
  int  Type,     
  int  Flag_bc,  
  int* Edges,    
  int* Neig,     
  int* Sons      
);

extern int mmr_create_edge( 
  int  Mesh_id,  
  int Type,      
  int  Node1,    
  int  Node2
);

extern int mmr_create_node( 
  int  Mesh_id,  
  double Xcoor,  
  double Ycoor,
  double Zcoor
);

extern int mmr_clust_face( 
  int  Mesh_id, 
  int Face,      
  int* Face_sons 
);

extern int mmr_clust_edge( 
  int  Mesh_id, 
  int Edge_id   
);


extern int mmr_divide_face(
  int  Mesh_id,    
  int  Fa,         
  int* Face_sons,  
  int* Sons_edges, 
  int* New_nodes   
);

extern int mmr_divide_edge( 
  int  Mesh_id,   
  int  Edge,      
  int* Edge_sons, 
  int* Node_mid   
);

extern int mmr_del_elem( 
  int  Mesh_id, 
  int Elem      
  );

extern int mmr_del_face( 
  int  Mesh_id, 
  int Face      
);

extern int mmr_del_edge( 
  int  Mesh_id, 
  int Edge      
);

extern int mmr_del_node( 
  int  Mesh_id, 
  int Node      
);

extern int mmr_get_max_elem_max(  
  int Mesh_id   
  );

extern int mmr_get_max_face_max(  
  int Mesh_id   
  );

extern int mmr_get_max_edge_max(  
  int Mesh_id   
  );

extern int mmr_get_max_node_max(  
  int Mesh_id   
  );


//******************************************************************************//
// The five next functions are not supported by mmd_prism and mmd_prism_2D modules!!!!!!!
//******************************************************************************//

extern int mmr_init_read( // return >=0 - success, <0 - error code
    const int Mesh_id, 
    const int N_nodes, 
    const int N_edges, 
    const int N_faces, 
    const int N_elems  
  );


extern int mmr_finish_read( // return >=0 - success, <0 - error code
    const int Mesh_id // IN: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh
  );


//---------------------------------------------------------
//  mmr_add_elem - to add (append) new element
//---------------------------------------------------------
extern int mmr_add_elem(// returns: added element id
    const int Mesh_id, // IN: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh
    const int Id, // IN: MMC_AUTO_GENERATE_ID or id numebr if known
    const int El_type, // IN: type of new element
    const int El_nodes[6], //IN: if known: nodes of new element, otherwise NULL
    const int El_faces[5]  //IN: if known: faces of new element, otherwise NULL
    , const int Material_idx); //IN: material id
// NOTE: if both El_nodes and El_faces are NULLs
// then an element is udefined and an error is returned!

//---------------------------------------------------------
//  mmr_add_face - to add (append) new face
//---------------------------------------------------------
extern int mmr_add_face(// returns: added face id
    const int Mesh_id,  // IN: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh
    const int Id, // IN: MMC_AUTO_GENERATE_ID or id numebr if known
    const int Fa_type,  // IN: type of new face
    const int Fa_nodes[4], // IN: if known: nodes of new face, otherwise NULL
    const int Fa_edges[4], // IN: if known: edges of new face, otherwise NULL
    const int Fa_neigs[2]  // IN: if known: neigs of new face, otherwise NULL
    , const int B_cond_val);
// NOTE: if both Fa_nodes and Fa_edges are NULLs
// then a face is udefined and an error is returned!

//---------------------------------------------------------
//  mmr_add_edge - to add (append) new edge
//---------------------------------------------------------
extern int mmr_add_edge(// returns: added edge id
    const int Mesh_id,  //IN: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh
    const int Id, // IN: MMC_AUTO_GENERATE_ID or id numebr if known
    const int nodes[2]  //IN: nodes for new edge
    );
// NOTE: if nodes==NULL edge is undefined and an error is returned!

//---------------------------------------------------------
//  mmr_add_node - to add (append) new node
//---------------------------------------------------------
extern int mmr_add_node( // returns: added node id
    const int Mesh_id,  //IN: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh
    const int Id, // IN: MMC_AUTO_GENERATE_ID or id numebr if known
    const double Coords[3] //IN: geometrical coordinates of node
    );
// NOTE: if Coords==NULL node is undefined and an error is returned!


extern int mmr_current_mesh_state_hash( // returns a state-stamp for mesh
        const int Mesh_id); // Mesh_id for state-stamp


//******************************************************************************//
// Below are functions used by modules intarfacing with REMESH module ONLY !!!!
//******************************************************************************//

extern int mmr_init_dist2bound( // returns 0 if succesfull
  const int Mesh_id, //in: mesh ID or 0 (MMC_CUR_MESH_ID)
  const int* BCs, //in: c-array of accepted BC numbers
  const int nBCs); //in: length of BCs parameter


extern double mmr_get_el_dist2boundary(  
  const int Mesh_id, /*in: mesh ID or 0 (MMC_CUR_MESH_ID) for the current mesh*/
  const int El_id,   // in: El_id wihch includes point Coord
  const double * Coord); // GLOBAL coords of point inside El_id



extern void mmr_get_coor_from_motion_element(
  const int Mesh_id,
  int idEl,
  int idLP,
  double *coor,
  int flagaSiatki
);

extern void mmr_copyMESH(const int Mesh_id,int flaga);


extern void mmr_create_mesh_Cube(
  const int Mesh_id,
  const char *nazwa,
  int node_x,
  int node_y,
  int node_z,
  double size_x,
  double size_y,
  double size_z,
  double divide,
  int *warunki
);

extern void mmr_init_all_change(const int Mesh_id,int a);

extern void mmr_test_mesh_motion(const int Mesh_id,int ileWarstw,int obecny_krok, int od_krok,int ileKrok,double minPoprawy,double px0,double py0,double pz0,double px1,double py1,double pz1,double endX,double endY,double endZ);

extern double mmr_test_weldpool(const int Mesh_id,double obecnyKrok, double krok_start,double minPoprawy,double doX,double doY,double dl,double zmiejszaPrzes,double limit,double szerokosc);


extern int mmr_groups_number(const int Mesh_id);
extern int mmr_groups_ids(const int Mesh_id, int *tab, int l_tab);


extern void mmr_get_vec_norm_at_node(const int Mesh_id,int node_id,double *vec_norm);

extern int mmr_get_fa_el_bc_connect(
        const int Mesh_id,
        int face_id,
        int *el_id
        );
 // end of group


#ifdef __cplusplus
}
#endif

#endif

---