READ_DIME_FILEMESH.f90 File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	read_dime_filemesh (gridfile, nb_mate, lab_mate, nb_dirix, lab_dirix, nb_diriy, lab_diriy, nb_diri
	Reads dimensions in gridfile (*.mesh)

Function/Subroutine Documentation

read_dime_filemesh()

subroutine read_dime_filemesh	(	character*70	gridfile,
		integer*4	nb_mate,
		integer*4, dimension(nb_mate)	lab_mate,
		integer*4	nb_dirix,
		integer*4, dimension(nb_dirix)	lab_dirix,
		integer*4	nb_diriy,
		integer*4, dimension(nb_diriy)	lab_diriy,
			nb_diri
	)

Reads dimensions in gridfile (*.mesh)

Author

Ilario Mazzieri

Date

September, 2013

Version

1.0

Parameters

[in]	gridfile	file name (*.mesh)
[in]	nb_mate	number of blocks (materials)
[in]	lab_mate	tag for materials
[in]	nb_diriX	number of Dirichlet b.c. (x-dir)
[in]	nb_diriY	number of Dirichlet b.c. (y-dir)
[in]	nb_diriZ	number of Dirichlet b.c. (z-dir)
[in]	lab_diriX	label for Dirichlet b.c. (x-dir)
[in]	lab_diriY	label for Dirichlet b.c. (y-dir)
[in]	lab_diriZ	label for Dirichlet b.c. (z-dir)
[in]	nb_neuX	number of Neumann boundary loads (x-dir)
[in]	nb_neuY	number of Neumann boundary loads (y-dir)
[in]	nb_neuZ	number of Neumann boundary loads (z-dir)
[in]	lab_neuX	label for Neumann boundary loads (x-dir)
[in]	lab_neuY	label for Neumann boundary loads (y-dir)
[in]	lab_neuZ	label for Neumann boundary loads (z-dir)
[in]	nb_neuN	number of Neumann boundary loads (normal direction)
[in]	lab_neuN	label for Neumann boundary loads
[in]	nnb_abc	number of absorbing boundary conditions
[in]	lab_abc	label for absorbing boundary condition
[in]	nnb_dg	number of discontinuos interfaces (where DG scheme is applied)
[in]	lab_dg	label for DG interface conditions
[out]	nb_node	number of mesh node
[out]	nb_hexa	number of hexahedral elements
[out]	nb_quad	number of quadrilateral elements

Definition at line 50 of file READ_DIME_FILEMESH.f90.

                           nb_neux,lab_neux,nb_neuy,lab_neuy,nb_neuz,lab_neuz,&
                           nb_neun,lab_neun, & 
                           nb_abc,lab_abc,&
                           nb_dg,lab_dg,&
                           nb_node,nb_hexa,nb_quad)
      
 
      implicit none
      
      character*70 :: gridfile
      character*80 :: inline
      character*20 :: el_code
 
      integer*4 :: nb_mate,nb_diriX,nb_diriY,nb_diriZ,nb_neuX,nb_neuY,nb_neuZ,nb_abc,nb_dg
      integer*4 :: nb_neuN 
      integer*4 :: nb_elem,ie,i,mat_code,ileft,iright,sl,trash,status,control
 
      integer*4, dimension(nb_mate) :: lab_mate
 
      integer*4, dimension(nb_diriX) :: lab_diriX
      integer*4, dimension(nb_diriY) :: lab_diriY
      integer*4, dimension(nb_diriZ) :: lab_diriZ
      integer*4, dimension(nb_neuX) :: lab_neuX
      integer*4, dimension(nb_neuY) :: lab_neuY
      integer*4, dimension(nb_neuZ) :: lab_neuZ
      integer*4, dimension(nb_neuN) :: lab_neuN
      integer*4, dimension(nb_abc) :: lab_abc
      integer*4, dimension(nb_dg) :: lab_dg
      integer*4 :: nb_node,nb_hexa,nb_quad
      
      
      nb_node = 0;  nb_hexa = 0;  nb_quad = 0
      
      open(40,file=gridfile)
      
      do 
         read(40,'(A)') inline
         if (inline(1:1) .ne. '#') exit
      enddo
      
      read(inline,*)nb_node,nb_elem
      
      do i = 1,nb_node
         read(40,'(A)')inline
      enddo
      
      do ie = 1,nb_elem
         read(40,'(A)')inline
         
         sl = len(inline)
         ileft = 0
         iright = 0 
         do i = 1,sl
            if (inline(i:i).ge.'A') exit
         enddo
         ileft = i
         do i = ileft,sl
            if (inline(i:i).lt.'A') exit
         enddo
         iright = i
         
         el_code = inline(ileft:iright)
         
         read(inline(1:ileft),*)trash,mat_code
         
         if ((el_code.eq.'hex').or.(el_code.eq.'HEX')) then
            control = 0
            do i = 1,nb_mate
               if (lab_mate(i).eq.mat_code) control = 1
            enddo
            !
            if (control.ne.0) nb_hexa = nb_hexa +1
         !
         elseif ((el_code.eq.'quad').or.(el_code.eq.'QUAD')) then
            control = 0
            do i = 1,nb_dirix
               if (lab_dirix(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_diriy
               if (lab_diriy(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_diriz
               if (lab_diriz(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_neux
               if (lab_neux(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_neuy
               if (lab_neuy(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_neuz
               if (lab_neuz(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_neun                                                        
               if (lab_neun(i).eq.mat_code) control = 1                                
            enddo                                                                
            do i = 1,nb_abc
               if (lab_abc(i).eq.mat_code) control = 1
            enddo
            do i = 1,nb_dg
               if (lab_dg(i).eq.mat_code) control = 1
            enddo
            
 
            if (control.ne.0) nb_quad = nb_quad +1
         endif
      enddo
      
      close(40)
      
      return

Referenced by read_input_files().

Here is the caller graph for this function: