gridman.f

Go to the documentation of this file.

C> @file gridman.f
C> Definition of data types, global constants and variables  
C GRIDMAN, grid managment library. Author: Vladislav Kotov, v.kotov@fz-juelich.de

!    Copyright (c) 2017  Forschungszentrum Juelich GmbH
!                        Vladislav Kotov 
!
!    This file is part of GRIDMAN.
!
!    GRIDMAN 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 3 of the License, or
!    (at your option) any later version.
!
!    GRIDMAN 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 GRIDMAN.  If not, see <http://www.gnu.org/licenses/>.

C> \mainpage
C>
C> GRIDMAN stands for GRID MANagment. 
C> This library contains universal grid description of unstructured grids
C> and a set of tools to store, merge, triangulate them etc.,  
C> as well as converters to and from various legacy formats.  
C> Essential element of the library is indexing of elements 
C> which stays invariant through the transformations.    
C>  
C> \author Vladislav Kotov, v.kotov@fz-juelich.de
C> 
C> Background ideas and maths are written down in this document
C> <a href="../gridman_spec.pdf">gridman_spec.pdf</a> 
C>
C> CONVGRID is a versatile grid converter based on GRIDMAN. 
C> See convgrid.parameters.description
C>
C> MERGERGRID is a simple interface for \ref GRIDMAN_GRID2D_MERGE. 
C> See mergegrid.parameters.description
C>
C> CUTGRID is a simple interface for \ref GRIDMAN_GRID2D_CUT. 
C> See cutgrid.parameters.description
C>
C> TRIANG generates combined EIRENE triangular grid, replacement of TRIAGEOM. 
C> See triang.parameters.description
C>
C> \page ErrorCodes
C> Convention for error (>0) and warning (<0) codes
C> -  100 : wrong input
C> - -100 : wrong input, corrected 
C> -  200 : memory allocation problem
C> - -200 : memory deallocation problem
C> -  300 : file reading/writing problem
C> - -300 : ...
C> -  400 : internal problem
C> - -400 : ...  
C>
C>  \page GeneralConventions
C> General conventions
C>
C> - For _GRID_ subroutines it is normal to assume 
C>   that the input grid object would pass GRIDMAN_GRID_CHECK 
C> - For _INDEX_ subroutines it is normal to assume
C>   that the input index would pass GRIDMAN_INDEX_CHECK 
C> - For _GRID2D_ subroutines it is normal to assume that the input 
C>   grid object would pass GRIDMAN_GRID2D_CHECK 
C>
C> Per default, integrity of input data structures is NOT checked.
C> To enforce checks use set GRIDMAN_CHECK=.TRUE.
C>
C> All text messages from all subroutines are aprinted into unit
C> defined by GRIDMAN_UNIT   
C>
C> Extra debugging output is enforced by setting GRIDMAN_DBG=.TRUE.
C>
C> In case of abnormal termination (IERR>0) the data structures and arrays
C> which have to be created inside the subroutine 
C> are returned in clean (deallocated) state
 
C> Definition of data types, global constants and variables  
      MODULE gridman

      IMPLICIT NONE

C***********************************************************************************
C     CONSTANTS     
C***********************************************************************************


C> Kind parameter for real numbers
      INTEGER,PUBLIC,PARAMETER :: gridman_dp = selected_real_kind(13)
C> Kind parameter for integer numbers 
      INTEGER,PUBLIC,PARAMETER :: gridman_sp = selected_real_kind(7)
C> Index of the current version
C>
C> Format YYMMDD, E.g. 170412 means Year 2017, April (04), 12th
      INTEGER(GRIDMAN_SP),PUBLIC,PARAMETER :: gridman_ver=170412 
C> Length of the description strings
      INTEGER,PUBLIC,PARAMETER :: gridman_length=1024
C>  Length of the string COLUMNS in GRIDMAN_INDEX
      INTEGER,PUBLIC,PARAMETER :: gridman_lword=64

C> PI number
      REAL(GRIDMAN_DP),PUBLIC,PARAMETER :: gridman_pi=atan(1.)*4.
C> 2PI number
      REAL(GRIDMAN_DP),PUBLIC,PARAMETER :: gridman_2pi=atan(1.)*8.

C***********************************************************************************
C     GLOBAL VARIABLES
C***********************************************************************************
C> Index of the standard output unit  
C>
C> Default value 6
      INTEGER,PUBLIC,SAVE :: gridman_unit  
      DATA gridman_unit /6/
C> Switch for debugging mode
C>
C! Extra debugging output is printed if GRIDMAN_DBG=.TRUE. and 
C! is omitted otherwise. Default value .FALSE.    
      LOGICAL,PUBLIC,SAVE :: gridman_dbg  
      DATA gridman_dbg /.false./
C> Tolerance parameter which is used to compare two real numbers
C>
C> Default value 1e-6
      REAL(GRIDMAN_DP),PUBLIC,SAVE :: gridman_tol  
      DATA gridman_tol  /1e-6/
C> Switch to enforce extra checks of input parameters
C>
C> Checks of input objects are enforced if  GRIDMAN_CHECK=.TRUE. and
C! skipped otherwise. Default value .FALSE.
      LOGICAL,PUBLIC,SAVE :: gridman_check 
      DATA gridman_check /.false./

C***********************************************************************************
C     DATA TYPES (OBJECTS)
C***********************************************************************************

C-----------------------------------------------------------------------------------
C     GRIDMAN_INDEX, see index.f
C-----------------------------------------------------------------------------------
C> Data-type which stores indices defined on the grid cells or edges 
      TYPE,PUBLIC :: gridman_index
       INTEGER :: nindex
       INTEGER(GRIDMAN_SP) :: nelements
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: indexes(:,:)
       CHARACTER(LEN=GRIDMAN_LENGTH) :: description 
       CHARACTER(LEN=GRIDMAN_LWORD),ALLOCATABLE :: columns(:) 
      END TYPE gridman_index

C-----------------------------------------------------------------------------------
C     GRIDMAN_GRID, see grid.f  
C-----------------------------------------------------------------------------------
C> Data-type which describes a grid as a set of edges, methods in grid.f 
C>
C> Each edge is connected to (at max.) two cells. Each edge is
!! defined by a set of points. Here "point" does not necessarily meean
!! a geometrical point, but can be any parameter which defines edges
      TYPE,PUBLIC :: gridman_grid
C> Index of the grid type 
C> 
C> - 2 : 2D unstructured grid
C> - 3 : 3D grid with triangular edges
       INTEGER :: TYPE 
C> String with human-readable description of the grid (title)
       CHARACTER(LEN=GRIDMAN_LENGTH) :: description 
C> Number of edges, must be > 0 
       INTEGER(GRIDMAN_SP) :: nedges   
C> Number of cells, must be >=0 (can be = 0)
       INTEGER(GRIDMAN_SP) :: ncells                                
C> Number of points required to define one edge 
C>
C> EDIM depends on TYPE
C> - TYPE=2: EDIM=2
C> - TYPE=3: EDIM=3
       INTEGER :: edim
C> Dimension of points
C>
C> PDIM depend on TYPE
C> - TYPE=2: PDIM=2
C> - TYPE=3: PDIM=3
       INTEGER :: pdim         
C> Number of points
       INTEGER(GRIDMAN_SP) :: npoints
C> Indices of the neighbour cells or edges for each edge. CELLS(2,NEDGES).
!! Index>0 is the index cell to which the edge is connected 
!! Index<0 is the index of edge to which the edge is connected
C>            (periodicity or "teleportation")             
!! Index=0 is the outer grid boundary
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: cells(:,:)
C> Indices of points which define each edge. POINTS(EDIM,NEDGES)
       INTEGER(GRIDMAN_SP),ALLOCATABLE ::  points(:,:) 
C> Convertion factor into SI uinits (Meter or Radian) for each coordinate
       REAL(GRIDMAN_DP) :: unit2si 
C> Strings with human readable units 
       CHARACTER(LEN=GRIDMAN_LENGTH):: units
C> Cartesian coordinates of points, X(PDIM,NPOINTS)
       REAL(GRIDMAN_DP),ALLOCATABLE :: x(:,:)
C> Number of indices (groups of indices) for edges
       INTEGER :: nedgeindex
C> Number of indices (groups of indices) for cells
       INTEGER :: ncellindex
C> Groups of indices for edges 
       TYPE(gridman_index),ALLOCATABLE :: edgeindex(:)
C> Groups of indices for cells 
       TYPE(gridman_index),ALLOCATABLE :: cellindex(:)
      END TYPE gridman_grid

C-----------------------------------------------------------------------------------
C     GRIDMAN_INDLIST, see indlist.f
C-----------------------------------------------------------------------------------
C> Data-type which describes lists of elements with variable number of indices 
C! for each element, methods in indlist.f
C>
C> Here a simple technique w/o pinters is applied
      TYPE,PUBLIC :: gridman_indlist 
C> Total number of elements
       INTEGER(GRIDMAN_SP) :: n
C> Total number of indices
       INTEGER(GRIDMAN_SP) :: l  
C> Array of indices. IND(L)
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: ind(:)
C> First index in IND for each element
C>
C> IFIRST(I) is the first index in array IND which corresponds to element I  
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: ifirst(:)
C> Last index in IND for each element
C>
C> IFLAST(I) is the last index in array IND which corresponds to element I  
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: ilast(:) 
      END TYPE gridman_indlist 

      END MODULE gridman 

C===================================================================================
C> Explicit interfaces to GRIDMAN subroutines and functions
C===================================================================================
C
C> Those interfaces cannot be placed in module GRIDMAN because for some reasson
C! Fortran does not understand derived types in the interface unless they are 
C! defined in a module which is use associated 
      MODULE gridman_lib

      IMPLICIT NONE

C***********************************************************************************
C     INTERFACES, GRDIMAN_INDEX
C***********************************************************************************
 
      INTERFACE

C
      SUBROUTINE gridman_index_allocate(INDEX,NINDEX,NELEMENTS,IERR)
       USE gridman,ONLY:gridman_index,gridman_sp
       TYPE(gridman_index) :: index
       INTEGER,INTENT(IN) :: nindex
       INTEGER(GRIDMAN_SP),INTENT(IN) :: nelements
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_allocate
C
      SUBROUTINE gridman_index_deallocate(INDEX,IERR)
       USE gridman,ONLY:gridman_index
       IMPLICIT NONE
       TYPE(gridman_index) :: index
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_deallocate
C
      SUBROUTINE gridman_index_check(INDEX,RES,IERR)
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) :: index
       INTEGER,INTENT(OUT) :: res,ierr
      END SUBROUTINE gridman_index_check
C
      SUBROUTINE gridman_index_write(INDEX,IOUT,IERR)
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) :: index
       INTEGER,INTENT(IN) :: iout  
       INTEGER,INTENT(OUT) :: ierr        
      END SUBROUTINE gridman_index_write
C
      SUBROUTINE gridman_index_read(INDEX,IIN,IERR)
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) :: index
       INTEGER,INTENT(IN) :: iin  
       INTEGER,INTENT(OUT) :: ierr        
      END SUBROUTINE gridman_index_read
C
      SUBROUTINE gridman_index_compare(INDEX1,INDEX2,RES,IERR)    
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) :: index1,index2
       INTEGER,INTENT(OUT) :: res,ierr
      END SUBROUTINE gridman_index_compare
C
      SUBROUTINE gridman_index_copy(INDEX2,INDEX1,IERR)   
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) :: index1,index2
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_copy
C
      FUNCTION gridman_index_repeated_elements(INDEX,IERR)
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) :: index
       INTEGER,INTENT(OUT) :: ierr
       LOGICAL :: gridman_index_repeated_elements
      END FUNCTION gridman_index_repeated_elements
C
      SUBROUTINE gridman_index_elmap(ELMAP,NMIN,NMAX,INDEX,IERR)
       USE gridman,ONLY:gridman_index,gridman_sp
       INTEGER(GRIDMAN_SP),ALLOCATABLE,INTENT(OUT) :: elmap(:)
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: nmin,nmax
       TYPE(gridman_index) :: index
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_elmap
C
      SUBROUTINE gridman_index_create121(INDEX,N,IERR)
       USE gridman,ONLY:gridman_index,gridman_sp
       TYPE(gridman_index) :: index
       INTEGER(GRIDMAN_SP),INTENT(IN) :: n
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_create121
C
      SUBROUTINE gridman_index_transform(INDEX2,INDEX1,IMAP12,N12,IERR)
       USE gridman,ONLY:gridman_index,gridman_sp
       TYPE(gridman_index) :: index2,index1
       INTEGER(GRIDMAN_SP),INTENT(IN) :: n12
       INTEGER(GRIDMAN_SP),INTENT(IN) :: imap12(2,n12)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_transform
C
      SUBROUTINE gridman_index_merge(INDEX,INDEX1,INDEX2,IERR) 
       USE gridman,ONLY:gridman_index
       TYPE(gridman_index) ::index,index1,index2
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_index_merge

      END INTERFACE
      
C***********************************************************************************
C     INTERFACES, GRIDMAN_INDLIST
C***********************************************************************************
     
      INTERFACE

C
       SUBROUTINE gridman_indlist_allocate(INDLIST,L,N,IERR)
        USE gridman,ONLY:gridman_indlist,gridman_sp
        TYPE(gridman_indlist) :: indlist
        INTEGER(GRIDMAN_SP),INTENT(IN) :: n,l
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_indlist_allocate
C    
       SUBROUTINE gridman_indlist_deallocate(CELLS,IERR)
        USE gridman,ONLY:gridman_indlist
        TYPE(gridman_indlist) :: cells
        INTEGER,INTENT(OUT) :: ierr      
       END SUBROUTINE gridman_indlist_deallocate

      END INTERFACE

C***********************************************************************************
C     INTERFACES, GRDIMAN_GRID
C***********************************************************************************

      INTERFACE
C
       SUBROUTINE gridman_grid_allocate(GRID,TYPE,NEDGES,NPOINTS,NCELLS,
     s                                  ierr,nedgeindex,ncellindex)
        USE gridman,ONLY:gridman_grid,gridman_sp
        TYPE(gridman_grid) :: grid    
        INTEGER,INTENT(IN) :: TYPE    
        INTEGER(GRIDMAN_SP),INTENT(IN) :: ncells,nedges,npoints
        INTEGER,INTENT(OUT) :: ierr
        INTEGER,INTENT(IN),OPTIONAL :: nedgeindex,ncellindex
       END SUBROUTINE gridman_grid_allocate
C
       SUBROUTINE gridman_grid_deallocate(GRID,IERR)
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid         
        INTEGER,INTENT(OUT) :: ierr    
       END SUBROUTINE gridman_grid_deallocate
C
       SUBROUTINE gridman_grid_check(GRID,RES,IERR) 
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid      
        INTEGER,INTENT(OUT) :: res,ierr  
       END SUBROUTINE gridman_grid_check
C
       SUBROUTINE gridman_grid_copy(GRID2,GRID1,IERR)   
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid1,grid2
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid_copy
C
       SUBROUTINE gridman_grid_comp(GRID1,GRID2,RES,IERR)       
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid1,grid2 
        INTEGER,INTENT(OUT) :: res,ierr 
       END SUBROUTINE gridman_grid_comp
C            
       SUBROUTINE gridman_grid_take(GRID2,GRID1,IERR)   
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid1,grid2 
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid_take
C
       SUBROUTINE gridman_grid_count(GRID,NCOUNT,IERR)
        USE gridman,ONLY:gridman_grid,gridman_sp
        TYPE(gridman_grid) :: grid 
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: ncount
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid_count  
 
      END INTERFACE

C
      INTERFACE gridman_grid_write

      SUBROUTINE gridman_grid_unitwrite(GRID,IOUT,IERR)
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid      
       INTEGER,INTENT(IN) :: iout  
       INTEGER,INTENT(OUT) :: ierr             
      END SUBROUTINE gridman_grid_unitwrite

      SUBROUTINE gridman_grid_filewrite(GRID,FNAME,IERR)
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid      
       CHARACTER(*),INTENT(IN) :: fname  
       INTEGER,INTENT(OUT) :: ierr             
      END SUBROUTINE gridman_grid_filewrite

      END INTERFACE

C
      INTERFACE gridman_grid_read

      SUBROUTINE gridman_grid_unitread(GRID,IIN,IERR)  
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid  
       INTEGER,INTENT(IN) :: iin   
       INTEGER,INTENT(OUT) :: ierr 
      END SUBROUTINE gridman_grid_unitread

      SUBROUTINE gridman_grid_fileread(GRID,FNAME,IERR)  
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid  
       CHARACTER(*),INTENT(IN) :: fname       
       INTEGER,INTENT(OUT) :: ierr 
      END SUBROUTINE gridman_grid_fileread

      END INTERFACE

C
      INTERFACE
C
       SUBROUTINE gridman_grid_combine(GRID,GRID1,GRID2,IERR)
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid,  !RESULTING GRID
     t                        grid1, !GRIDS TO BE COMBINED        
     t                        grid2
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid_combine
C
       SUBROUTINE gridman_grid_cells(EDGES,GRID,IERR)
        USE gridman,ONLY:gridman_grid,gridman_indlist
        TYPE(gridman_indlist) :: edges
        TYPE(gridman_grid) :: grid
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid_cells
C
      SUBROUTINE gridman_grid_points(EDGES,GRID,IERR)
       USE gridman,ONLY:gridman_grid,gridman_indlist
       TYPE(gridman_indlist) :: edges
       TYPE(gridman_grid) :: grid
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_grid_points
C
      SUBROUTINE gridman_grid_eliminate_cells(GRID_NEW,GRID,LTAKE,IERR)
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid_new,grid
       LOGICAL,INTENT(IN) :: ltake(grid%ncells)  
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_grid_eliminate_cells
C
      SUBROUTINE gridman_grid_eliminate_edges(GRID_NEW,GRID,LTAKE,IERR)
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid_new,grid
       LOGICAL,INTENT(IN) :: ltake(grid%nedges)  
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_grid_eliminate_edges
C
      SUBROUTINE gridman_grid_remove_free_edges(GRID_NEW,GRID,IERR)
       USE gridman,ONLY:gridman_grid
       TYPE(gridman_grid) :: grid_new,grid
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_grid_remove_free_edges

      END INTERFACE

C
      INTERFACE gridman_grid_metadata
C
      SUBROUTINE gridman_grid_metadata_text(GRID,TEXT,NT,IERR)
       USE gridman,ONLY:gridman_grid,gridman_length
       TYPE(gridman_grid) :: grid
       CHARACTER(GRIDMAN_LENGTH),ALLOCATABLE :: text(:)      
       INTEGER,INTENT(OUT) :: nt
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_grid_metadata_text
C 
      SUBROUTINE gridman_grid_metadata_unit(GRID,IUNIT,IERR) 
       USE gridman,ONLY:gridman_grid,gridman_length
       TYPE(gridman_grid) :: grid
       INTEGER,INTENT(IN) :: iunit
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_grid_metadata_unit

      END INTERFACE gridman_grid_metadata

C***********************************************************************************
C     INTERFACES, BASIC GEOMETRICAL SUBROUTINES
C***********************************************************************************
C
      INTERFACE

       FUNCTION gridman_triaarea(X1,Y1,X2,Y2,X3,Y3)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x1,y1,x2,y2,x3,y3
        REAL(GRIDMAN_DP) :: gridman_triaarea
       END FUNCTION gridman_triaarea

C
       FUNCTION gridman_triavol(X1,Y1,X2,Y2,X3,Y3)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x1,y1,x2,y2,x3,y3
        REAL(GRIDMAN_DP) :: gridman_triavol
       END FUNCTION gridman_triavol

C
       FUNCTION gridman_dist2d(X1,Y1,X2,Y2)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x1,y1,x2,y2
        REAL(GRIDMAN_DP) :: gridman_dist2d
       END FUNCTION gridman_dist2d

C
       SUBROUTINE gridman_norm2d(X0,Y0,XN,YN)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x0,y0
        REAL(GRIDMAN_DP),INTENT(OUT) :: xn,yn   
       END SUBROUTINE gridman_norm2d

C
       FUNCTION gridman_conarea(X1,Y1,X2,Y2)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x1,y1,x2,y2
        REAL(GRIDMAN_DP) :: gridman_conarea
       END FUNCTION gridman_conarea  

C
       FUNCTION gridman_cross2d(X0,Y0,VX0,VY0,X1,Y1,X2,Y2,XI,YI)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x0,y0,vx0,vy0,x1,y1,x2,y2  
        REAL(GRIDMAN_DP),INTENT(OUT) :: xi,yi             
        LOGICAL gridman_cross2d
       END FUNCTION gridman_cross2d

C
       FUNCTION gridman_intersect2d(X11,Y11,X12,Y12,
     f                              x21,y21,x22,y22,xi,yi)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x11,y11,x12,y12,x21,y21,x22,y22  
        REAL(GRIDMAN_DP),INTENT(OUT) :: xi,yi                    
        LOGICAL :: gridman_intersect2d
       END FUNCTION gridman_intersect2d

C
       FUNCTION gridman_point_in_polygon(XP,YP,NP,X0,Y0) 
        USE gridman,ONLY:gridman_dp,gridman_sp
        INTEGER(GRIDMAN_SP),INTENT(IN) :: np
        REAL(GRIDMAN_DP) :: xp(np),yp(np),x0,y0
        LOGICAL :: gridman_point_in_polygon
       END FUNCTION gridman_point_in_polygon

C
       FUNCTION gridman_close2interval2d(X1,Y1,X2,Y2,X,Y,TOL)
        USE gridman,ONLY:gridman_dp
        REAL(GRIDMAN_DP),INTENT(IN) :: x1,y1,x2,y2,x,y,tol
        LOGICAL :: gridman_close2interval2d
       END FUNCTION gridman_close2interval2d

      END INTERFACE

C***********************************************************************************
C     INTERFACES, GRID2D
C***********************************************************************************
      INTERFACE
C
       SUBROUTINE gridman_grid2d_check(GRID,RES,IERR)
        USE gridman,ONLY:gridman_grid,gridman_sp
        TYPE(gridman_grid) :: grid
        INTEGER,INTENT(OUT) :: res,ierr
       END SUBROUTINE gridman_grid2d_check
C 
       SUBROUTINE gridman_grid2d_chains(GRID,CHAINS,IERR)
        USE gridman,ONLY:gridman_grid,gridman_indlist
        TYPE(gridman_grid) :: grid
        TYPE(gridman_indlist) :: chains
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2d_chains
C
       SUBROUTINE gridman_grid2d_lengths(GRID,LEDGES,IERR) 
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid 
        REAL(GRIDMAN_DP) :: ledges(grid%nedges)
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2d_lengths
C
       SUBROUTINE gridman_grid2d_crossect(GRID,SCELLS,IERR)
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid
        REAL(GRIDMAN_DP) :: scells(grid%ncells)
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2d_crossect
C
       SUBROUTINE gridman_grid2d_center(GRID,XCN,IERR)
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid 
        REAL(GRIDMAN_DP) :: xcn(2,grid%ncells)
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2d_center
C
       SUBROUTINE gridman_grid2d_norm(GRID,VN,IERR)
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid 
        REAL(GRIDMAN_DP) :: vn(2,grid%nedges)
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2d_norm
C
       SUBROUTINE gridman_grid2d_isconvex(GRID,ISCONVEX,IERR)
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: grid
        LOGICAL :: isconvex(grid%ncells)
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2d_isconvex
C
       SUBROUTINE gridman_grid2d_cylareas(GRID,SEDGES,IERR,ANGLE) 
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid 
        REAL(GRIDMAN_DP) :: sedges(grid%nedges) 
        INTEGER,INTENT(OUT) :: ierr 
        REAL(GRIDMAN_DP),OPTIONAL :: angle
       END SUBROUTINE gridman_grid2d_cylareas
C
       SUBROUTINE gridman_grid2d_cylvolumes(GRID,VCELLS,IERR,ANGLE)
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid
        REAL(GRIDMAN_DP) :: vcells(grid%ncells)
        INTEGER,INTENT(OUT) :: ierr 
        REAL(GRIDMAN_DP),OPTIONAL :: angle
       END SUBROUTINE gridman_grid2d_cylvolumes
C
       SUBROUTINE gridman_grid2d_triang(TRIA,GRID,IERR)
        USE gridman,ONLY:gridman_grid
        TYPE(gridman_grid) :: tria
        TYPE(gridman_grid) :: grid  
        INTEGER,INTENT(OUT) :: ierr   
       END  SUBROUTINE gridman_grid2d_triang
C
       SUBROUTINE gridman_grid2d_merge(GRID,GRID1,GRID2,TOL,IERR)
        USE gridman,ONLY:gridman_grid,gridman_dp
        TYPE(gridman_grid) :: grid,grid1,grid2       
        REAL(GRIDMAN_DP),INTENT(IN) :: tol 
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid2d_merge
C
       SUBROUTINE gridman_grid2d_cut(CUTGRID,GRID,XP,YP,NP,LEX,IERR)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: cutgrid,grid
        INTEGER(GRIDMAN_SP),INTENT(IN) :: np
        REAL(GRIDMAN_DP),INTENT(IN) :: xp(np),yp(np)
        LOGICAL,INTENT(IN) :: lex 
        INTEGER,INTENT(OUT) :: ierr   
       END SUBROUTINE gridman_grid2d_cut

      END INTERFACE

C***********************************************************************************
C     INTERFACES, FORMATS 
C***********************************************************************************
      INTERFACE gridman_tria_read
C
       SUBROUTINE gridman_tria_read_array(FNAMES,NRKNOT,NTRII,XYTRIAN,
     s                                    necke,nchbar,nseite,itri,ierr)
        USE gridman,ONLY:gridman_dp,gridman_sp
        CHARACTER(*) :: fnames(3)     
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: nrknot,ntrii 
        REAL(GRIDMAN_DP),ALLOCATABLE :: xytrian(:,:) 
        INTEGER(GRIDMAN_SP),ALLOCATABLE :: necke(:,:),nchbar(:,:),
     i                         nseite(:,:),itri(:,:)    
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_tria_read_array
C
       SUBROUTINE gridman_tria_read_grid(GRID,FNAMES,IERR)
        USE gridman,ONLY:gridman_grid
        CHARACTER(*) :: fnames(3)     
        TYPE(gridman_grid) :: grid  
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_tria_read_grid

      END INTERFACE gridman_tria_read

      INTERFACE gridman_tria_write
C
      SUBROUTINE gridman_tria_write_array(FNAMES,NRKNOT,NTRII,XYTRIAN,
     s                                    necke,nchbar,nseite,itri,ierr)
       USE gridman,ONLY:gridman_dp,gridman_sp  
       CHARACTER(*) :: fnames(3)        
       INTEGER(GRIDMAN_SP),INTENT(IN) :: nrknot,ntrii            
       REAL(GRIDMAN_DP),INTENT(IN) :: xytrian(2,nrknot)
       INTEGER(GRIDMAN_SP),INTENT(IN) :: necke(3,ntrii),nchbar(3,ntrii), 
     i                                   nseite(3,ntrii),itri(5,ntrii)    
       INTEGER,INTENT(OUT) :: ierr 
      END SUBROUTINE gridman_tria_write_array
C
      SUBROUTINE gridman_tria_write_grid(GRID,FNAMES,IERR)
       USE gridman,ONLY:gridman_grid
       CHARACTER(*) :: fnames(3)  
       TYPE(gridman_grid) :: grid      
       INTEGER,INTENT(OUT) :: ierr 
      END SUBROUTINE gridman_tria_write_grid

      END INTERFACE gridman_tria_write

C
      INTERFACE gridman_carre_read30     
C
      SUBROUTINE gridman_carre_read30_array(FNAME,SONNETFILE,NX,NY,
     s                                     nncut,nxcut,nycut,
     s                                     nniso,nxiso,nyiso,br,bz,ierr)    
       USE gridman,ONLY:gridman_dp,gridman_sp
       CHARACTER(*),INTENT(IN) :: fname        
       CHARACTER(*),INTENT(OUT) :: sonnetfile    
       INTEGER(GRIDMAN_SP),INTENT(OUT) :: nx,ny             
       INTEGER(GRIDMAN_SP),INTENT(OUT) :: nncut,nniso 
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: nxcut(:,:),nycut(:,:),
     i                                    nxiso(:,:),nyiso(:,:) 
       REAL(GRIDMAN_DP),ALLOCATABLE :: br(:,:,:),bz(:,:,:)         
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_carre_read30_array
C
      SUBROUTINE gridman_carre_read30_grid(GRID,FNAME,IERR,LEIR)    
       USE gridman,ONLY:gridman_grid
       CHARACTER(*),INTENT(IN) :: fname     
       TYPE(gridman_grid) :: grid  
       INTEGER,INTENT(OUT) :: ierr
       LOGICAL,OPTIONAL :: leir
      END SUBROUTINE gridman_carre_read30_grid      

      END INTERFACE gridman_carre_read30   

C
      INTERFACE gridman_carre_readsonnet
C
      SUBROUTINE gridman_carre_readsonnet_array(FNAME,NX,NY,
     s                                          nncut,nxcut,nycut,
     s                                          nniso,nxiso,nyiso,
     s                                          rbt,br,bz,pit,bc,ierr)
       USE gridman,ONLY:gridman_dp,gridman_sp
       CHARACTER(*),INTENT(IN) :: fname          
       INTEGER(GRIDMAN_SP),INTENT(OUT) :: nx,ny            
       INTEGER(GRIDMAN_SP),INTENT(OUT) ::  nncut, nniso 
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: nxcut(:),nycut(:),
     i                                    nxiso(:),nyiso(:) 
       REAL(GRIDMAN_DP) :: rbt
       REAL(GRIDMAN_DP),ALLOCATABLE :: br(:,:,:),bz(:,:,:),
     r                                 bc(:,:,:),pit(:,:)
       INTEGER,INTENT(OUT) :: ierr
      END  SUBROUTINE gridman_carre_readsonnet_array
C
      SUBROUTINE gridman_carre_readsonnet_grid(GRID,FNAME,IERR,LEIR)    
       USE gridman,ONLY:gridman_grid
       CHARACTER(*),INTENT(IN) :: fname     
       TYPE(gridman_grid) :: grid  
       INTEGER,INTENT(OUT) :: ierr
       LOGICAL,OPTIONAL :: leir
      END SUBROUTINE gridman_carre_readsonnet_grid

      END INTERFACE gridman_carre_readsonnet

C
      INTERFACE gridman_addsurf2d_read

      SUBROUTINE gridman_addsurf2d_read_array(FNAME,NSURF,X,Y,ISRF,IERR) 
       USE gridman,ONLY:gridman_dp,gridman_sp
       CHARACTER(*),INTENT(IN) :: fname
       INTEGER(GRIDMAN_SP),INTENT(OUT) :: nsurf   
       REAL(GRIDMAN_DP),ALLOCATABLE :: x(:,:),y(:,:)        
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: isrf(:)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_addsurf2d_read_array

      SUBROUTINE gridman_addsurf2d_read_grid(GRID,FNAME,IERR)
       USE gridman,ONLY:gridman_grid
       IMPLICIT NONE
       TYPE(gridman_grid) :: grid
       CHARACTER(*),INTENT(IN) :: fname
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_addsurf2d_read_grid

      END INTERFACE gridman_addsurf2d_read

C
      INTERFACE gridman_addsurf3d_read

      SUBROUTINE gridman_addsurf3d_read_array(FNAME,NSURF,X,Y,Z,
     s                                        isrf,ierr) 
       USE gridman,ONLY:gridman_dp,gridman_sp
       CHARACTER(*),INTENT(IN) :: fname
       INTEGER(GRIDMAN_SP),INTENT(OUT) :: nsurf   
       REAL(GRIDMAN_DP),ALLOCATABLE :: x(:,:),y(:,:),z(:,:)       
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: isrf(:)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_addsurf3d_read_array

      SUBROUTINE gridman_addsurf3d_read_grid(GRID,FNAME,IERR)
       USE gridman,ONLY:gridman_grid 
       TYPE(gridman_grid) :: grid
       CHARACTER(*),INTENT(IN) :: fname
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_addsurf3d_read_grid

      END INTERFACE gridman_addsurf3d_read

C
      INTERFACE gridman_template_read

      SUBROUTINE gridman_template_read_array(FNAME,M,N,L,X,Y,IERR) 
       USE gridman,ONLY:gridman_dp,gridman_sp
       CHARACTER(*),INTENT(IN) :: fname    
       INTEGER(GRIDMAN_SP),INTENT(OUT) :: m,l
       INTEGER(GRIDMAN_SP),ALLOCATABLE :: n(:)
       REAL(GRIDMAN_DP),ALLOCATABLE :: x(:),y(:)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_template_read_array

      SUBROUTINE gridman_template_read_grid(GRID,FNAME,IERR)
       USE gridman,ONLY:gridman_grid 
       TYPE(gridman_grid) :: grid
       CHARACTER(*),INTENT(IN) :: fname  
       INTEGER,INTENT(OUT) :: ierr
      END  SUBROUTINE gridman_template_read_grid

      END INTERFACE gridman_template_read

      INTERFACE gridman_template_write

      SUBROUTINE gridman_template_write_array(FNAME,M,N,L,X,Y,IERR) 
       USE gridman,ONLY:gridman_dp,gridman_sp
       IMPLICIT NONE
       CHARACTER(*),INTENT(IN) :: fname    
       INTEGER(GRIDMAN_SP),INTENT(IN) :: m,n(m),l
       REAL(GRIDMAN_DP),INTENT(IN) :: x(l),y(l)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_template_write_array

C
      SUBROUTINE gridman_template_write_grid(GRID,FNAME,IERR)
       USE gridman,ONLY:gridman_grid 
       TYPE(gridman_grid) :: grid
       CHARACTER(*),INTENT(IN) :: fname  
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_template_write_grid

      END INTERFACE gridman_template_write

      INTERFACE
C
      SUBROUTINE gridman_vtk_write_grid(IOUT,HEADER,
     s                                  npoints,ncells,nvertex,nd,
     s                                  x,ifirst,lvertex,ivertex,
     s                                  ctype,ierr)
       USE gridman,ONLY:gridman_sp,gridman_dp
       INTEGER,INTENT(IN) :: iout
       CHARACTER(*),INTENT(IN) :: header
       INTEGER(GRIDMAN_SP),INTENT(IN) :: npoints,ncells,nvertex
       INTEGER,INTENT(IN) :: nd
       REAL(GRIDMAN_DP),INTENT(IN) :: x(nd,npoints)
       INTEGER(GRIDMAN_SP),INTENT(IN) :: ifirst(ncells),lvertex(ncells),
     i                                   ivertex(nvertex)
       INTEGER,INTENT(IN) :: ctype(ncells)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_vtk_write_grid

C 
      SUBROUTINE gridman_vtk_write_scalars(IOUT,DATANAME,N,S,IERR)
       USE gridman,ONLY:gridman_sp,gridman_dp
       INTEGER,INTENT(IN) :: iout
       CHARACTER(*),INTENT(IN) :: dataname
       INTEGER(GRIDMAN_SP),INTENT(IN) :: n
       REAL(GRIDMAN_DP),INTENT(IN) :: s(n)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_vtk_write_scalars
C
      SUBROUTINE gridman_vtk_write_vectors(IOUT,DATANAME,N,ND,V,IERR)
       USE gridman,ONLY:gridman_sp,gridman_dp
       INTEGER,INTENT(IN) :: iout
       CHARACTER(*) :: dataname
       INTEGER(GRIDMAN_SP),INTENT(IN) :: n
       INTEGER,INTENT(IN) :: nd
       REAL(GRIDMAN_DP) :: v(nd,n)
       INTEGER,INTENT(OUT) :: ierr
      END SUBROUTINE gridman_vtk_write_vectors
C
      SUBROUTINE gridman_vtk_write(FNAME,HEADER,
     s                             npoints,ncells,nvertex,nd,
     s                             x,ifirst,lvertex,ivertex,ctype,
     s                             ncs,ncv,nps,npv,ierr,
     s                             cell_scalar,csname, 
     s                             cell_vector,cvname,
     s                             point_scalar,psname, 
     s                             point_vector,pvname) 
       USE gridman,ONLY:gridman_sp,gridman_dp
       CHARACTER(*),INTENT(IN) :: fname,header
       INTEGER(GRIDMAN_SP),INTENT(IN) :: npoints,ncells,nvertex
       INTEGER,INTENT(IN) :: nd
       REAL(GRIDMAN_DP),INTENT(IN) :: x(nd,npoints)
       INTEGER(GRIDMAN_SP),INTENT(IN) :: ifirst(ncells),lvertex(ncells),
     i                                   ivertex(nvertex)
       INTEGER,INTENT(IN) :: ctype(ncells)
       INTEGER,INTENT(IN) :: ncs,ncv,nps,npv
       INTEGER,INTENT(OUT) :: ierr
       REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                             cell_scalar(ncells,ncs),
     r                             cell_vector(nd,ncells,ncv),
     r                             point_scalar(npoints,nps),
     r                             point_vector(nd,npoints,npv)
       CHARACTER(*),INTENT(IN),OPTIONAL :: csname(ncs),         
     c                                     cvname(ncv),       
     c                                     psname(nps),         
     c                                     pvname(npv)    
      END SUBROUTINE gridman_vtk_write
    
      END INTERFACE

C***********************************************************************************
C     INTERFACES, CONVERT
C***********************************************************************************
      INTERFACE
C
       SUBROUTINE gridman_tria2grid(GRID,NRKNOT,NTRII,XYTRIAN,NECKE,
     s                              nchbar,nseite,itri,ierr)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: grid 
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nrknot,ntrii
        REAL(GRIDMAN_DP),INTENT(IN) :: xytrian(2,nrknot)               
        INTEGER(GRIDMAN_SP),INTENT(IN) ::
     i                      necke(3,ntrii),nchbar(3,ntrii), 
     i                      nseite(3,ntrii),itri(5,ntrii) 
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_tria2grid
C
       SUBROUTINE gridman_grid2tria(GRID,XYTRIAN,NECKE,
     s                              nchbar,nseite,itri,ierr)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: grid   
        REAL(GRIDMAN_DP),INTENT(IN) :: xytrian(2,grid%npoints)               
        INTEGER(GRIDMAN_SP),INTENT(IN) :: 
     i                      necke(3,grid%NCELLS),nchbar(3,grid%NCELLS),   
     i                      nseite(3,grid%NCELLS),itri(5,grid%NCELLS)
        INTEGER,INTENT(OUT) :: ierr 
       END SUBROUTINE gridman_grid2tria

C
       SUBROUTINE gridman_carre2grid_fort30(GRID,LXB,LYB,NXB,NYB,NNCUT,
     s                                      nxcut,nycut,nniso,
     s                                      nxiso,nyiso,br,bz,
     s                                      lx,ly,nxl,nyl,ierr,leir)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: grid               
        INTEGER(GRIDMAN_SP),INTENT(IN) ::  lxb,lyb,nxb,nyb,lx,ly,nxl,nyl    
        INTEGER(GRIDMAN_SP),INTENT(IN) ::  nncut,nniso 
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nxcut(2,nncut),nycut(2,nncut),
     i                                    nxiso(2,nniso),nyiso(2,nniso)  
        REAL(GRIDMAN_DP) :: br(lxb:nxb,lyb:nyb,4),bz(lxb:nxb,lyb:nyb,4)                  
        INTEGER,INTENT(OUT) :: ierr 
        LOGICAL,OPTIONAL :: leir
       END SUBROUTINE gridman_carre2grid_fort30

C
       SUBROUTINE gridman_carre2grid(GRID,
     s                               lxb,lyb,nxb,nyb,nncut,nxcut,nycut,
     s                               nniso,nxiso,nyiso,br,bz,
     s                               lx,ly,nxl,nyl,ierr,leir)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: grid               
        INTEGER(GRIDMAN_SP),INTENT(IN) :: lxb,lyb,nxb,nyb,lx,ly,nxl,nyl 
        INTEGER(GRIDMAN_SP),INTENT(IN) ::  nncut,nniso 
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nxcut(nncut),nycut(nncut),
     i                                    nxiso(nniso),nyiso(nniso)  
        REAL(GRIDMAN_DP) ::  br(lxb:nxb,lyb:nyb,4),bz(lxb:nxb,lyb:nyb,4)                  
        INTEGER,INTENT(OUT) :: ierr 
        LOGICAL,OPTIONAL :: leir
       END SUBROUTINE gridman_carre2grid
    
C
       SUBROUTINE gridman_addsurf2grid_2d(GRID,NSURF,X,Y,ISRF,IERR)
        USE gridman,ONLY:gridman_grid,gridman_sp,gridman_dp
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nsurf  
        REAL(GRIDMAN_DP) :: x(2,nsurf),y(2,nsurf)
        INTEGER(GRIDMAN_SP) :: isrf(nsurf)
        INTEGER :: ierr
       END SUBROUTINE gridman_addsurf2grid_2d

C
       SUBROUTINE gridman_addsurf2grid_3d(GRID,NSURF,X,Y,Z,ISRF,IERR)
        USE gridman,ONLY:gridman_grid,gridman_sp,gridman_dp
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nsurf  
        REAL(GRIDMAN_DP) :: x(3,nsurf),y(3,nsurf),z(3,nsurf)
        INTEGER(GRIDMAN_SP) :: isrf(nsurf)
        INTEGER :: ierr
       END SUBROUTINE gridman_addsurf2grid_3d

C
       SUBROUTINE gridman_template2grid(GRID,M,N,L,X,Y,IERR)
        USE gridman,ONLY:gridman_grid,gridman_sp,gridman_dp
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(IN) :: m,l,n(m)
        REAL(GRIDMAN_DP),INTENT(IN) :: x(l),y(l)
       INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_template2grid

C
       SUBROUTINE gridman_2dgrid2vtk_index(GRID,N,M,RINDEXES, 
     s                                              sindexes,ierr)
        USE gridman,ONLY:gridman_grid,gridman_sp,gridman_dp,
     u                   gridman_length      
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: n
        INTEGER,INTENT(OUT) :: m
        REAL(GRIDMAN_DP),ALLOCATABLE,INTENT(OUT) :: rindexes(:,:)
        CHARACTER(GRIDMAN_LENGTH) :: sindexes(:)
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_2dgrid2vtk_index

C
       SUBROUTINE gridman_grid2template(GRID,M,N,L,X,Y,IERR)
        USE gridman,ONLY:gridman_grid,gridman_sp,gridman_dp
        TYPE(gridman_grid) :: grid  
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: m,l 
        INTEGER(GRIDMAN_SP),ALLOCATABLE :: n(:) 
        REAL(GRIDMAN_DP),ALLOCATABLE :: x(:),y(:)
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_grid2template

C
       SUBROUTINE gridman_2dgrid2vtk(GRID,NPOINTS,NCELLS,NVERTEX,
     s                               x,ifirst,lvertex,ivertex,ctype,
     s                               ierr,ntheta,theta)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: npoints,ncells,nvertex
        REAL(GRIDMAN_DP),ALLOCATABLE,INTENT(OUT) :: x(:,:)
        INTEGER(GRIDMAN_SP),ALLOCATABLE,INTENT(OUT) ::
     i                      ifirst(:),lvertex(:),ivertex(:)
        INTEGER,ALLOCATABLE,INTENT(OUT) :: ctype(:)
        INTEGER,INTENT(OUT) :: ierr
        INTEGER,INTENT(IN) :: ntheta
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: theta(ntheta)
       END SUBROUTINE gridman_2dgrid2vtk

C
       SUBROUTINE gridman_3dgrid2vtk(GRID,NPOINTS,NCELLS,NVERTEX,X,
     s                               ifirst,lvertex,ivertex,
     s                               ctype,ierr)
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: npoints,ncells,nvertex
        REAL(GRIDMAN_DP),ALLOCATABLE,INTENT(OUT) :: x(:,:)
        INTEGER(GRIDMAN_SP),ALLOCATABLE,INTENT(OUT) :: 
     i                      ifirst(:),lvertex(:),ivertex(:)
        INTEGER,ALLOCATABLE,INTENT(OUT) :: ctype(:)
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_3dgrid2vtk

C
       SUBROUTINE gridman_3dgrid2vtk_index(GRID,N,M,RINDEXES,
     s                                              sindexes,ierr)
        USE gridman,ONLY:gridman_grid,gridman_sp,gridman_dp,  
     u                   gridman_length      
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(OUT) :: n
        INTEGER,INTENT(OUT) :: m
        REAL(GRIDMAN_DP),ALLOCATABLE,INTENT(OUT) :: rindexes(:,:)
        CHARACTER(GRIDMAN_LENGTH),ALLOCATABLE,INTENT(OUT) :: sindexes(:)
        INTEGER,INTENT(OUT) :: ierr
       END SUBROUTINE gridman_3dgrid2vtk_index

C
       SUBROUTINE gridman_vtk_grid2d_write(FNAME,HEADER,
     s                                     grid,nelements,
     s                                     ncs,ncv,nps,npv,ierr,
     s                                     cell_scalar,csname, 
     s                                     cell_vector,cvname,
     s                                     point_scalar,psname, 
     s                                     point_vector,pvname) 
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        CHARACTER(*),INTENT(IN) :: fname,header
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nelements
        INTEGER,INTENT(IN) :: ncs,ncv,nps,npv
        INTEGER,INTENT(OUT) :: ierr
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                              cell_scalar(grid%NCELLS,ncs)
        CHARACTER(*),INTENT(IN),OPTIONAL :: csname(ncs)         
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                              cell_vector(2,grid%NCELLS,ncv)
        CHARACTER(*),INTENT(IN),OPTIONAL :: cvname(ncv)        
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                             point_scalar(grid%NPOINTS,nps)
        CHARACTER(*),INTENT(IN),OPTIONAL :: psname(nps)         
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                              point_vector(2,grid%NPOINTS,npv)
        CHARACTER(*),INTENT(IN),OPTIONAL :: pvname(npv)    
       END SUBROUTINE gridman_vtk_grid2d_write

C
       SUBROUTINE gridman_vtk_grid3d_write(FNAME,HEADER,
     s                                     grid,nelements,
     s                                     ncs,ncv,nps,npv,ierr,            
     s                                     cell_scalar,csname, 
     s                                     cell_vector,cvname,
     s                                     point_scalar,psname, 
     s                                     point_vector,pvname) 
        USE gridman,ONLY:gridman_grid,gridman_dp,gridman_sp
        CHARACTER(*),INTENT(IN) :: fname,header
        TYPE(gridman_grid) :: grid
        INTEGER(GRIDMAN_SP),INTENT(IN) :: nelements
        INTEGER,INTENT(IN) :: ncs,ncv,nps,npv
        INTEGER,INTENT(OUT) :: ierr
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL ::
     r                                     cell_scalar(nelements,ncs)
        CHARACTER(*),INTENT(IN),OPTIONAL :: csname(ncs)         
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                                      cell_vector(3,nelements,ncv)
        CHARACTER(*),INTENT(IN),OPTIONAL :: cvname(ncv)        
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                              point_scalar(grid%NPOINTS,nps)
        CHARACTER(*),INTENT(IN),OPTIONAL :: psname(nps)         
        REAL(GRIDMAN_DP),INTENT(IN),OPTIONAL :: 
     r                              point_vector(3,grid%NPOINTS,npv)
        CHARACTER(*),INTENT(IN),OPTIONAL :: pvname(npv)    
       END SUBROUTINE gridman_vtk_grid3d_write

      END INTERFACE

      END MODULE gridman_lib