API_functions.c

Go to the documentation of this file.

/* =============================================================================
**  This file is part of the mmg software package for the tetrahedral
**  mesh modification.
**  Copyright (c) Bx INP/CNRS/Inria/UBordeaux/UPMC, 2004-
**
**  mmg is free software: you can redistribute it and/or modify it
**  under the terms of the GNU Lesser General Public License as published
**  by the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  mmg 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 Lesser General Public
**  License for more details.
**
**  You should have received a copy of the GNU Lesser General Public
**  License and of the GNU General Public License along with mmg (in
**  files COPYING.LESSER and COPYING). If not, see
**  <http://www.gnu.org/licenses/>. Please read their terms carefully and
**  use this copy of the mmg distribution only if you accept them.
** =============================================================================
*/

 
#include "mmgcommon_private.h"

void MMG5_Init_parameters(MMG5_pMesh mesh) {
 
  memset(&mesh->info,0, sizeof(MMG5_Info));
 
  /* default values for integers */
  /* [-1..10], Tune level of imprim */
  mesh->info.imprim   =  1;
  /* [0/1]    ,Turn on/off levelset meshing */
  mesh->info.iso      =  MMG5_OFF;
  /* [0/1]    ,Turn on/off levelset meshing */
  mesh->info.isosurf  =  MMG5_OFF;
  /* [n/10]   ,Value for isosurface boundary reference */
  mesh->info.isoref   =  MG_ISO;
  /* [n/-1]   ,Set memory size to n Mbytes/keep the default value */
  mesh->info.mem      = MMG5_NONSET_MEM;
  /* [0/1]    ,Turn on/off debug mode */
  mesh->info.ddebug   =  MMG5_OFF;
  /* [n]      ,number of local parameters */
  mesh->info.npar     =  MMG5_OFF;
  /* [0/1]    ,avoid/allow point insertion/deletion */
  mesh->info.noinsert =  MMG5_OFF;
  /* [0/1]    ,avoid/allow edge or face flipping */
  mesh->info.noswap   =  MMG5_OFF;
  /* [0/1]    ,avoid/allow point relocation */
  mesh->info.nomove   =  MMG5_OFF;
  /* [n]    ,number of user-defined references */
  mesh->info.nmat = MMG5_OFF;
  /* [-1/val]    ,Turn off/on the removal of small bubles in levelset meshing */
  mesh->info.rmc      =  MMG5_NONSET;
  /* [0/1]    ,avoid/allow  */
  mesh->info.nosizreq =  MMG5_OFF;
 
 
  /* default values for doubles */
  /* angle detection */
  mesh->info.dhd      = MMG5_ANGEDG;
  /* minimal mesh size */
  mesh->info.hmin     = MMG5_NONSET_HMIN;
  /* maximal mesh size */
  mesh->info.hmax     = MMG5_NONSET_HMAX;
  /* constant mesh size */
  mesh->info.hsiz     = MMG5_NONSET_HSIZ;
  /* control Hausdorff */
  mesh->info.hausd    = MMG5_HAUSD;
  /* control gradation */
  mesh->info.hgrad    = MMG5_HGRAD;
  /* control gradation on required entities */
  mesh->info.hgradreq = MMG5_HGRADREQ;
  /* xreg relaxation parameter value */
  mesh->info.lxreg    = MMG5_XREG;
 
  /* default values for pointers */
  /* list of user-defined references */
  mesh->info.mat = NULL;

  mesh->info.lag      = MMG5_LAG;
 
  /* initial value for memMax and gap */
  mesh->gap = MMG5_GAP;
  mesh->memMax = MMG5_memSize();
  if ( mesh->memMax ) {
    /* maximal memory = 50% of total physical memory */
    mesh->memMax = (size_t)(mesh->memMax*MMG5_MEMPERCENT);
  } else {
    /* default value = 800 MB */
    printf("  Maximum memory set to default value: %d MB.\n",MMG5_MEMMAX);
    mesh->memMax = MMG5_MEMMAX << MMG5_BITWIZE_MB_TO_B;
  }
 
}
 

void MMG5_Init_fileNames(MMG5_pMesh mesh,MMG5_pSol sol
  ) {
  MMG5_Set_inputMeshName(mesh,"");
  MMG5_Set_outputMeshName(mesh,"");
 
  if ( sol ) {
    MMG5_Set_inputSolName(mesh,sol,"");
    MMG5_Set_outputSolName(mesh,sol,"");
  }
 
  return;
}

int MMG5_Set_inputMeshName(MMG5_pMesh mesh, const char* meshin) {
 
  if ( mesh->namein ){
    MMG5_DEL_MEM(mesh,mesh->namein);
  }
 
  if ( meshin && strlen(meshin) ) {
    MMG5_ADD_MEM(mesh,(strlen(meshin)+1)*sizeof(char),"input mesh name",
                  fprintf(stderr,"  Exit program.\n");
                  return 0);
    MMG5_SAFE_CALLOC(mesh->namein,strlen(meshin)+1,char,return 0);
    strcpy(mesh->namein,meshin);
  }
  else {
    MMG5_ADD_MEM(mesh,10*sizeof(char),"input mesh name",
                  fprintf(stderr,"  Exit program.\n");
                  return 0);
    MMG5_SAFE_CALLOC(mesh->namein,10,char,return 0);
    strcpy(mesh->namein,"mesh.mesh");
    if ( (mesh->info.imprim > 5) || mesh->info.ddebug ) {
      fprintf(stderr,"\n  ## Warning: %s: no name given for input mesh.\n",__func__);
      fprintf(stderr,"              Use of default value \"mesh.mesh\".\n");
    }
  }
  return 1;
}

int MMG5_Set_inputSolName(MMG5_pMesh mesh,MMG5_pSol sol, const char* solin) {
  char *ptr;
 
  if ( sol->namein )
    MMG5_DEL_MEM(mesh,sol->namein);
 
  if ( solin && strlen(solin) ) {
    MMG5_ADD_MEM(mesh,(strlen(solin)+1)*sizeof(char),"input sol name",
                  fprintf(stderr,"  Exit program.\n");
                  return 0);
    MMG5_SAFE_CALLOC(sol->namein,strlen(solin)+1,char,return 0);
    strcpy(sol->namein,solin);
  }
  else {
    if ( mesh->namein && strlen(mesh->namein) ) {
      int mesh_len = strlen(mesh->namein)+1;
      MMG5_SAFE_CALLOC(sol->namein,mesh_len,char,return 0);
      strcpy(sol->namein,mesh->namein);
 
      /* Get last dot character to avoid issues with <basename>.mesh.mesh files */
      char *dot = strrchr(sol->namein,'.');
      ptr = NULL;
      if ( dot) {
        ptr = strstr(dot,".mesh");
      }
      if ( ptr ) {
        /* the sol file is renamed concatening the mesh basename and the sol extension */
        *ptr = '\0';
      }
      MMG5_SAFE_REALLOC(sol->namein,mesh_len,(strlen(sol->namein)+5),char,
                        "input sol name",return 0);
 
      MMG5_ADD_MEM(mesh,(strlen(sol->namein)+5)*sizeof(char),"input sol name",
                    fprintf(stderr,"  Exit program.\n");
                    return 0);
      strcat(sol->namein,".sol");
    }
    else {
      MMG5_ADD_MEM(mesh,9*sizeof(char),"input sol name",
                    fprintf(stderr,"  Exit program.\n");
                    return 0);
      MMG5_SAFE_CALLOC(sol->namein,9,char,return 0);
      strcpy(sol->namein,"mesh.sol");
    }
  }
  return 1;
}

int MMG5_Set_inputParamName(MMG5_pMesh mesh, const char* fparamin) {
 
  if ( mesh->info.fparam )
    MMG5_DEL_MEM(mesh,mesh->info.fparam);
 
  if ( fparamin && strlen(fparamin) ) {
    MMG5_ADD_MEM(mesh,(strlen(fparamin)+1)*sizeof(char),"input param name",
                  fprintf(stderr,"  Exit program.\n");
                  return 0);
    MMG5_SAFE_CALLOC(mesh->info.fparam,strlen(fparamin)+1,char,return 0);
    strcpy(mesh->info.fparam,fparamin);
  }
  else {
    fprintf(stderr,"\n  ## Warning: %s: no name given for the parameter file.\n",__func__);
    fprintf(stderr,"              We should have never end here.\n");
    return 0;
  }
  return 1;
}

int MMG5_Set_outputMeshName(MMG5_pMesh mesh, const char* meshout) {
  int  fmt = MMG5_FMT_MeditASCII,fmtin;
  char *ptr,*ptrin;
 
  if ( mesh->nameout )
    MMG5_DEL_MEM(mesh,mesh->nameout);
 
  if ( meshout && strlen(meshout) ) {
    ptr   = strrchr(meshout, '.');
 
    MMG5_ADD_MEM(mesh,(strlen(meshout)+7)*sizeof(char),"output mesh name",
                  fprintf(stderr,"  Exit program.\n");
                  return 0);
    MMG5_SAFE_CALLOC(mesh->nameout,strlen(meshout)+7,char,return 0);
    strcpy(mesh->nameout,meshout);
 
    if ( ( ptr && MMG5_Get_format(ptr,0)==MMG5_FMT_Unknown ) || (!ptr) || ptr == meshout ) {
      /* No extension */
      ptrin   = MMG5_Get_filenameExt(mesh->namein);
      fmtin   = MMG5_Get_format(ptrin,MMG5_FMT_MeditASCII);
      fmt     = MMG5_FMT_Unknown;
    }
    strcpy(mesh->nameout,meshout);
 
    if ( fmt == MMG5_FMT_Unknown ) {
      /* No extension */
      switch ( fmtin ) {
      case ( MMG5_FMT_GmshASCII ):
        strcat(mesh->nameout,".msh");
        break;
      case ( MMG5_FMT_GmshBinary ):
        strcat(mesh->nameout,".mshb");
        break;
      case ( MMG5_FMT_VtkVtu ):
        strcat(mesh->nameout,".vtu");
        break;
      case ( MMG5_FMT_VtkVtp ):
        strcat(mesh->nameout,".vtp");
        break;
      case ( MMG5_FMT_VtkVtk ):
        strcat(mesh->nameout,".vtk");
        break;
      case ( MMG5_FMT_MeditBinary ):
        strcat(mesh->nameout,".meshb");
        break;
      case ( MMG5_FMT_MeditASCII ): default:
        strcat(mesh->nameout,".mesh");
        break;
      }
    }
  }
  else {
    if ( mesh->namein && strlen(mesh->namein) ) {
      MMG5_ADD_MEM(mesh,(strlen(mesh->namein)+9)*sizeof(char),"output mesh name",
                    fprintf(stderr,"  Exit program.\n");
                    return 0);
      MMG5_SAFE_CALLOC(mesh->nameout,strlen(mesh->namein)+9,char,return 0);
      strcpy(mesh->nameout,mesh->namein);
 
      ptr   = MMG5_Get_filenameExt(mesh->nameout);
      fmt   = MMG5_Get_format(ptr,MMG5_FMT_MeditASCII);
 
      if ( ptr ) *ptr = '\0';
 
      switch ( fmt ) {
 
      case ( MMG5_FMT_GmshASCII ):
        strcat(mesh->nameout,".o.msh");
        break;
      case ( MMG5_FMT_GmshBinary ):
        strcat(mesh->nameout,".o.mshb");
        break;
      case ( MMG5_FMT_VtkVtu ):
        strcat(mesh->nameout,".o.vtu");
        break;
      case ( MMG5_FMT_VtkVtp ):
        strcat(mesh->nameout,".o.vtp");
        break;
      case ( MMG5_FMT_VtkVtk ):
        strcat(mesh->nameout,".o.vtk");
        break;
      case ( MMG5_FMT_MeditBinary ):
        strcat(mesh->nameout,".o.meshb");
        break;
      case ( MMG5_FMT_MeditASCII ): default:
        strcat(mesh->nameout,".o.mesh");
        break;
      }
    }
    else {
      MMG5_ADD_MEM(mesh,12*sizeof(char),"output mesh name",
                    fprintf(stderr,"  Exit program.\n");
                    return 0);
      MMG5_SAFE_CALLOC(mesh->nameout,12,char,return 0);
      if ( (mesh->info.imprim > 5) || mesh->info.ddebug ) {
        fprintf(stderr,"\n  ## Warning: %s: no name given for output mesh.\n",
                __func__);
        fprintf(stderr,"              Use of default value \"mesh.o.mesh\".\n");
      }
      strcpy(mesh->nameout,"mesh.o.mesh");
    }
  }
  return 1;
}
 

int MMG5_Set_outputSolName(MMG5_pMesh mesh,MMG5_pSol sol, const char* solout) {
  char *ptr;
  int oldsize;
 
  if ( sol->nameout )
    MMG5_DEL_MEM(mesh,sol->nameout);
 
  if ( solout && strlen(solout) ) {
    MMG5_ADD_MEM(mesh,(strlen(solout)+1)*sizeof(char),"output sol name",
                  fprintf(stderr,"  Exit program.\n");
                  return 0);
    MMG5_SAFE_CALLOC(sol->nameout,strlen(solout)+1,char,return 0);
    strcpy(sol->nameout,solout);
  }
  else {
    if ( mesh->nameout && strlen(mesh->nameout) ) {
      /* Get last dot character to avoid issues with <basename>.mesh.mesh files */
      char *dot = strrchr(mesh->nameout,'.');
      ptr = NULL;
      if ( dot) {
        ptr = strstr(dot,".mesh");
      }
      if ( ptr ) {
        MMG5_SAFE_CALLOC(sol->nameout,strlen(mesh->nameout)+1,char,return 0);
        oldsize = strlen(mesh->nameout)+1;
      }
      else {
        MMG5_SAFE_CALLOC(sol->nameout,strlen(mesh->nameout)+6,char,return 0);
        oldsize = strlen(mesh->nameout)+6;
      }
      strcpy(sol->nameout,mesh->nameout);
      dot = strrchr(sol->nameout,'.');
      ptr = NULL;
      if ( dot) {
        ptr = strstr(dot,".mesh");
      }
      if ( ptr )
        /* the sol file is renamed with the meshfile basename and .sol ext */
        *ptr = '\0';
 
      MMG5_ADD_MEM(mesh,(strlen(sol->nameout)+5)*sizeof(char),"output sol name",
                    fprintf(stderr,"  Exit program.\n");
                    return 0);
      MMG5_SAFE_REALLOC(sol->nameout,oldsize,(strlen(sol->nameout)+5),char,
                         "output sol name",return 0);
      strcat(sol->nameout,".sol");
 
    }
    else {
      fprintf(stderr,"\n  ## Error: %s: no name for output mesh. please, use",
              __func__);
      fprintf(stderr," the MMG5_Set_outputMeshName to set the mesh name.\n");
      return 0;
    }
  }
  return 1;
}
 
void MMG5_Set_constantSize(MMG5_pMesh mesh,MMG5_pSol met,double hsiz) {
  MMG5_pPoint ppt;
  MMG5_int    k,iadr;
 
  if ( met->size == 1 ) {
    for (k=1; k<=mesh->np; k++) {
      ppt = &mesh->point[k];
      if ( !MG_VOK(ppt) ) continue;
      met->m[k] = hsiz;
    }
  }
  else {
    hsiz    = 1./(hsiz*hsiz);
 
    if ( mesh->dim==2 ) {
      for (k=1; k<=mesh->np; k++) {
        ppt = &mesh->point[k];
        if ( !MG_VOK(ppt) ) continue;
 
        iadr           = 3*k;
        met->m[iadr]   = hsiz;
        met->m[iadr+1] = 0.;
        met->m[iadr+2] = hsiz;
      }
    }
    else {
      assert ( mesh->dim==3 );
      for (k=1; k<=mesh->np; k++) {
        ppt = &mesh->point[k];
        if ( !MG_VOK(ppt) ) continue;
 
        iadr           = 6*k;
        met->m[iadr]   = hsiz;
        met->m[iadr+1] = 0.;
        met->m[iadr+2] = 0.;
        met->m[iadr+3] = hsiz;
        met->m[iadr+4] = 0.;
        met->m[iadr+5] = hsiz;
      }
    }
  }
 
  return;
}
 
int MMG5_Free_allSols(MMG5_pMesh mesh,MMG5_pSol *sol) {
  int i;
 
  if ( sol ) {
    if ( mesh->nsols ) {
      for ( i=0; i<mesh->nsols; ++i ) {
        MMG5_DEL_MEM(mesh,(*sol)[i].m);
      }
    }
    MMG5_DEL_MEM(mesh,(*sol));
  }
 
  return 1;
}

void MMG5_Free_structures(MMG5_pMesh mesh,MMG5_pSol sol){
 
  if ( mesh->point )
    MMG5_DEL_MEM(mesh,mesh->point);
 
  if ( mesh->xpoint )
    MMG5_DEL_MEM(mesh,mesh->xpoint);
 
  if ( mesh->edge )
    MMG5_DEL_MEM(mesh,mesh->edge);
 
  if ( mesh->adja )
    MMG5_DEL_MEM(mesh,mesh->adja);
 
  if ( mesh->tria )
    MMG5_DEL_MEM(mesh,mesh->tria);
 
  if ( mesh->adjt )
    MMG5_DEL_MEM(mesh,mesh->adjt);
 
  /* sol */
  if ( sol && sol->m )
    MMG5_DEL_MEM(mesh,sol->m);
 
  /* mesh->info */
  if ( mesh->info.npar && mesh->info.par )
    MMG5_DEL_MEM(mesh,mesh->info.par);
 
  if ( mesh->info.nmat ) {
    if( mesh->info.mat )
      MMG5_DEL_MEM(mesh,mesh->info.mat);
    if( mesh->info.invmat.lookup )
      MMG5_DEL_MEM(mesh,mesh->info.invmat.lookup);
  }
 
  if ( mesh->info.imprim>5 || mesh->info.ddebug ) {
    printf("  MEMORY USED AT END (Bytes) %zu\n",mesh->memCur);
  }
 
  return;
}

void MMG5_mmgFree_names(MMG5_pMesh mesh,MMG5_pSol met){
 
  /* mesh */
  if ( mesh->nameout ) {
    MMG5_DEL_MEM(mesh,mesh->nameout);
  }
 
  if ( mesh->namein ) {
    MMG5_DEL_MEM(mesh,mesh->namein);
  }
 
  /* met */
  if ( met ) {
    if ( met->namein ) {
      MMG5_DEL_MEM(mesh,met->namein);
    }
 
    if ( met->nameout ) {
      MMG5_DEL_MEM(mesh,met->nameout);
    }
  }
}
 
inline
int MMG5_Set_defaultTruncatureSizes(MMG5_pMesh mesh,int8_t sethmin,int8_t sethmax) {
 
  if ( !sethmin ) {
    if ( sethmax ) {
      mesh->info.hmin  = MG_MIN ( MMG5_HMINCOE, MMG5_HMINCOE * mesh->info.hmax);
    } else {
      mesh->info.hmin  = MMG5_HMINCOE;
    }
  }
 
  if ( !sethmax ) {
    if ( sethmin ) {
      mesh->info.hmax = MG_MAX ( MMG5_HMAXCOE, 1./MMG5_HMINCOE * mesh->info.hmin);
    }
    else {
      mesh->info.hmax  = MMG5_HMAXCOE;
    }
  }
 
  if ( mesh->info.hmax < mesh->info.hmin ) {
    assert ( sethmin && sethmax );
    fprintf(stderr,"\n  ## Error: %s: Mismatched options:"
            " minimal mesh size larger than maximal one.\n",__func__);
    return 0;
  }
 
  if ( mesh->info.ddebug ) {
    /* print unscaled values for debug purpose */
    fprintf(stdout,"     After truncature computation:   hmin %lf (user setted %d)\n"
            "                                     hmax %lf (user setted %d)\n",
            mesh->info.delta * mesh->info.hmin,mesh->info.sethmin,
            mesh->info.delta * mesh->info.hmax,mesh->info.sethmax);
  }
 
  return 1;
}
 
int MMG5_Compute_constantSize(MMG5_pMesh mesh,MMG5_pSol met,double *hsiz) {
 
  if ( mesh->info.hmin > mesh->info.hsiz ) {
    fprintf(stderr,"\n  ## Error: %s: Mismatched options: hmin (%e) is greater"
            " than hsiz (%e). Exit Program.\n",__func__,
            mesh->info.hmin,mesh->info.hsiz);
    return 0;
  }
 
  if ( mesh->info.hmax > 0. && mesh->info.hmax < mesh->info.hsiz ) {
    fprintf(stderr,"\n  ## Error: %s: Mismatched options: hmax (%e) is lower"
            " than hsiz (%e). Exit Program.\n",__func__,
            mesh->info.hmax,mesh->info.hsiz);
    return 0;
  }
 
  *hsiz = mesh->info.hsiz;
 
  if ( !MMG5_check_setted_hminhmax(mesh) ) {
    return 0;
  }
 
  if ( mesh->info.sethmin ) {
    *hsiz    =  MG_MAX(mesh->info.hmin,*hsiz);
  }
 
  if ( mesh->info.sethmax ) {
    *hsiz    = MG_MIN(mesh->info.hmax,*hsiz);
  }
 
  /* Set hmin */
  if ( !mesh->info.sethmin ) {
    if ( mesh->info.sethmax ) {
      mesh->info.hmin  = MG_MIN(0.1*(*hsiz),0.1*mesh->info.hmax);
    } else {
      mesh->info.hmin  = 0.1*(*hsiz);
    }
  }
 
  /* Set hmax */
  if ( !mesh->info.sethmax ) {
    if ( mesh->info.sethmin ) {
      mesh->info.hmax  = MG_MAX(10.*(*hsiz),10.*mesh->info.hmin);
    } else {
      mesh->info.hmax  = 10.*(*hsiz);
    }
  }
 
  if ( mesh->info.ddebug ) {
    /* print unscaled values for debug purpose */
    fprintf(stdout,"     After hsiz computation:   hmin %lf (user setted %d)\n"
            "                               hmax %lf (user setted %d)\n",
            mesh->info.delta * mesh->info.hmin,mesh->info.sethmin,
            mesh->info.delta * mesh->info.hmax,mesh->info.sethmax);
  }
 
  return 1;
}
 
/* Useful tools to manage C strings */
char *MMG5_Get_basename(char *path) {
  char *s = strrchr(path, '/');
 
  if (!s)
    return strdup(path);
  else
    return strdup(s + 1);
}
 
 
const char* MMG5_Get_entitiesName(enum MMG5_entities ent)
{
  switch (ent)
  {
  case MMG5_Noentity:
    return "MMG5_Noentity";
    break;
  case MMG5_Vertex:
    return "MMG5_Vertex";
    break;
  case MMG5_Edg:
    return "MMG5_Edg";
    break;
  case MMG5_Triangle:
    return "MMG5_Triangle";
    break;
  case MMG5_Tetrahedron:
    return "MMG5_Tetrahedron";
    break;
  default:
    return"MMG5_Unknown";
  }
}
const char* MMG5_Get_typeName(enum MMG5_type typ)
{
  switch (typ)
  {
  case MMG5_Notype:
    return "MMG5_Notype";
    break;
  case MMG5_Scalar:
    return "MMG5_Scalar";
    break;
  case MMG5_Vector:
    return "MMG5_Vector";
    break;
  case MMG5_Tensor:
    return "MMG5_Tensor";
    break;
  default:
    return "MMG5_Unknown";
  }
}
 
const char* MMG5_Get_tagName(uint16_t tag)
{
  static char tags_name[1024];
 
  if ( !tag )
  {
    return "No tag";
  }
 
  if ( tag & MG_NUL ) {
    return "Removed";
  }
 
  strcpy(tags_name, "\0");
 
  if ( tag & MG_REF ) {
    strcat(tags_name,"Reference ");
  }
 
  if ( tag & MG_GEO) {
    strcat(tags_name,"Ridge ");
  }
 
  if ( tag & MG_REQ) {
    strcat(tags_name,"Required ");
      }
 
  if ( tag & MG_NOM) {
    strcat(tags_name,"Non-manifold ");
      }
 
  if ( tag & MG_BDY) {
    strcat(tags_name,"Boundary ");
      }
 
  if ( tag & MG_CRN) {
    strcat(tags_name,"Corner ");
    }
 
  if ( tag & MG_NOSURF) {
    strcat(tags_name,"Nosurf ");
  }
 
  if ( tag & MG_OPNBDY) {
    strcat(tags_name,"Opnbdy ");
  }
 
  if ( tag & MG_OLDPARBDY) {
    strcat(tags_name,"Old-parbdy ");
  }
 
  if ( tag & MG_PARBDYBDY) {
    strcat(tags_name,"Parbdybdy ");
  }
 
  if ( tag & MG_PARBDY) {
    strcat(tags_name,"Parbdy ");
  }
 
  if ( tag & MG_OVERLAP) {
    strcat(tags_name,"Overlap ");
  }
 
  strcat(tags_name,"tag(s).");
 
  return tags_name;
}

int MMG5_Get_format( char *ptr, int fmt ) {
  /* Default is the Medit file format or a format given as input */
  int defFmt = fmt;
 
  if ( !ptr ) return defFmt;
 
  if ( !strncmp ( ptr,".meshb",strlen(".meshb") ) ) {
    return MMG5_FMT_MeditBinary;
  }
  else if ( !strncmp( ptr,".mesh",strlen(".mesh") ) ) {
    return MMG5_FMT_MeditASCII;
  }
  else if ( !strncmp( ptr,".mshb",strlen(".mshb") ) ) {
    return MMG5_FMT_GmshBinary;
  }
  else if ( !strncmp( ptr,".msh",strlen(".msh") ) ) {
    return MMG5_FMT_GmshASCII;
  }
  else if ( !strncmp ( ptr,".pvtu",strlen(".pvtu") ) ) {
    return MMG5_FMT_VtkPvtu;
  }
  else if ( !strncmp ( ptr,".vtu",strlen(".vtu") ) ) {
    return MMG5_FMT_VtkVtu;
  }
  else if ( !strncmp ( ptr,".pvtp",strlen(".pvtu") ) ) {
    return MMG5_FMT_VtkPvtp;
  }
  else if ( !strncmp ( ptr,".vtp",strlen(".vtp") ) ) {
    return MMG5_FMT_VtkVtp;
  }
  else if ( !strncmp ( ptr,".vtk",strlen(".vtk") ) ) {
    return MMG5_FMT_VtkVtk;
  }
  else if ( !strncmp ( ptr,".node",strlen(".node") ) ) {
    return MMG5_FMT_Tetgen;
  }
 
  return defFmt;
}

const char* MMG5_Get_formatName(enum MMG5_Format fmt)
{
  switch (fmt)
  {
  case MMG5_FMT_MeditASCII:
    return "MMG5_FMT_MeditASCII";
    break;
  case MMG5_FMT_MeditBinary:
    return "MMG5_FMT_MeditBinary";
    break;
  case MMG5_FMT_VtkVtu:
    return "MMG5_FMT_VtkVtu";
    break;
  case MMG5_FMT_VtkVtp:
    return "MMG5_FMT_VtkVtp";
    break;
  case MMG5_FMT_VtkPvtu:
    return "MMG5_FMT_VtkPvtu";
    break;
  case MMG5_FMT_VtkPvtp:
    return "MMG5_FMT_VtkPvtp";
    break;
  case MMG5_FMT_VtkVtk:
    return "MMG5_FMT_VtkVtk";
    break;
  case MMG5_FMT_GmshASCII:
    return "MMG5_FMT_GmshASCII";
    break;
  case MMG5_FMT_GmshBinary:
    return "MMG5_FMT_GmshBinary";
    break;
  case MMG5_FMT_Tetgen:
    return "MMG5_FMT_Tetgen";
    break;
  default:
    return "MMG5_Unknown";
  }
}

char *MMG5_Get_filenameExt( char *filename ) {
  const char pathsep='/';
  char       *dot,*lastpath;
 
  if ( !filename ) {
    return NULL;
  }
 
  dot = strrchr(filename, '.');
  lastpath = (pathsep == 0) ? NULL : strrchr (filename, pathsep);
 
  if ( (!dot) || dot == filename || (lastpath>dot) || (!strcmp(dot,".o")) ) {
    /* No extension */
    return filename + strlen(filename);
  }
 
  return dot;
}

char *MMG5_Get_path(char *path) {
  char *lastpath,*retpath;
  int len;
 
  if ( path == NULL) return NULL;
 
  lastpath = (MMG5_PATHSEP == 0) ? NULL : strrchr (path, MMG5_PATHSEP);
 
  if ( !lastpath ) {
    return NULL;
  }
 
 
  len = 0;
  while ( path+len != lastpath ) {
    ++len;
  }
 
  MMG5_SAFE_MALLOC(retpath,len+1,char,return NULL);
 
  /* Copy the string without the extension and add \0 */
  strncpy ( retpath, path, len );
  retpath[len] = '\0';
 
  return retpath;
}

char *MMG5_Remove_ext (char* path,char *ext) {
  int        len;
  char       *retpath, *lastext, *lastpath;
  char       *extloc;
 
  /* Default extension if not provided */
  if ( (!ext) || !*ext ) {
    extloc = ".";
  }
  else {
    extloc = ext;
  }
 
  /* Error checks and string allocation. */
  if ( path == NULL) return NULL;
 
  /* Find the relevant characters and the length of the string without
   * extension */
  lastext = strstr (path, extloc);
  lastpath = (MMG5_PATHSEP == 0) ? NULL : strrchr (path, MMG5_PATHSEP);
 
  if ( lastext == NULL || (lastpath != NULL && lastpath > lastext) ) {
    /* No extension or the extension is left from a separator (i.e. it is not an
     * extension) */
    len = strlen(path);
  }
  else {
    /* An extension is found */
    len = 0;
    while ( path+len != lastext ) {
      ++len;
    }
  }
 
  MMG5_SAFE_MALLOC(retpath,len+1,char,return NULL);
 
  /* Copy the string without the extension and add \0 */
  strncpy ( retpath, path, len );
  retpath[len] = '\0';
 
  return retpath;
}