hermes_index_file.f

Go to the documentation of this file.

!                 ************************
                  MODULE hermes_index_file
!                 ************************
!
!***********************************************************************
! HERMES                                                            2018
!***********************************************************************
!
!brief    Implementation of the index files use by concatenated serafin
!         and MED
!
!history YOANN AUDOUIN
!+       10/05/2018
!+       Initial version
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!
      IMPLICIT NONE
!
      INTERFACE read_index
        MODULE PROCEDURE
     &    read_index32,
     &    read_index64
      END INTERFACE read_index
      INTERFACE write_index
        MODULE PROCEDURE
     &    write_index32,
     &    write_index64
      END INTERFACE write_index
!
      CONTAINS

!***********************************************************************
      SUBROUTINE open_index
!***********************************************************************
!
     &(filename, file_id)
!
!***********************************************************************
! HERMES                                                      10/05/2018
!***********************************************************************
!
!BRIEF    Open an index file, either for writing or reading and return
!         the file id.
!
!HISTORY  Judicaël Grasset (Daresbury Lab & EDF)
!+        10/05/2018
!+
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!| FILENAME       |<--| NAME OF THE FILE ASSOCIATED TO THE INDEX
!| FILE_ID        |<--| FILE DESCRIPTOR
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        USE declarations_special
        CHARACTER(LEN=*), INTENT(IN)  :: FILENAME
        INTEGER,          INTENT(OUT) :: FILE_ID
        !
        CHARACTER(LEN=MAXLENFILE) :: INDEX_FILENAME
        INTEGER :: FILENAME_SIZE,IERR
        LOGICAL :: ISOPEN
        CALL get_free_id(file_id)
        !IF THE FILE IS CONCATENATED, THEN THE INDEX FILE IS IN A
        !FILE OF THE SAME NAME WITH THE 'CONCAT' SUFFIX REPLACED
        !BY 'INDEX'
        index_filename=filename
        filename_size=len_trim(index_filename)
        index_filename(filename_size-5:filename_size) = 'INDEX '

        INQUIRE(file=index_filename,opened=isopen)
        IF(isopen)THEN
          INQUIRE(file=index_filename,number=file_id)
        ELSE
          OPEN(unit=file_id,file=trim(index_filename),action='READWRITE'
     &         ,form='UNFORMATTED', access='STREAM',iostat=ierr)
          IF(ierr.NE.0) THEN
            error_message = 'ERROR IN '//
     &           trim(index_filename)//': '//
     &           'OPEN_INDEX_FILE:OPEN'
            RETURN
          ENDIF
        ENDIF
      END SUBROUTINE
!***********************************************************************
      SUBROUTINE read_index64
!***********************************************************************
!
     &(idx_id,openmode,mesh_number,offset_begin,offset_end)
!
!***********************************************************************
! HERMES                                                      10/05/2018
!***********************************************************************
!
!BRIEF    Read offsets from the index file. If openmode is read then we
!         read the offset needed for reading our part. If openmode is
!         write we read the offset needed to write after our part.
!
!HISTORY  Judicaël Grasset (Daresbury Lab & EDF)
!+        10/05/2018
!+
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!| IDX_ID       |-->| FILE ID OF THE INDEX FILE
!| OPENMODE     |-->| OPENMODE OF THE FILE ASSOCIATED TO THE INDEX
!| MESH_NUMBER  |-->| NUMBER OF THE MESH WE ARE WORKING WITH
!| OFFSET_BEGIN |<--| OFFSET TO THE BEGINING OF OUR PART
!| OFFSET_END   |<--| OFFSET TO THE END OF OUR PART
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        USE declarations_special
        INTEGER,          INTENT(IN)  :: IDX_ID
        CHARACTER(LEN=9), INTENT(IN)  :: OPENMODE
        INTEGER,          INTENT(IN)  :: MESH_NUMBER
        INTEGER(KIND=K8), INTENT(OUT) :: OFFSET_BEGIN
        INTEGER(KIND=K8), INTENT(OUT) :: OFFSET_END

        INTEGER(KIND=K8) :: POS
        !GET THE OFFSET OF OUR PART.
        !THE OFFSETS ARE PAIRS OF 64 BITS INTEGER (8 BYTES * 2)
        !IF WE ARE IN READ MODE, THEN WE CAN READ OUR BEGINING OFFSET
        !AND OUR END OFFSET.
        !IF WE ARE IN WRITE MODE, WE CAN ONLY READ OUR BEGINING OFFSET
        !SINCE WE DO NOT KNOW WHERE WE WILL STOP WRITING.
        IF(openmode(1:5)=='WRITE')THEN
          IF(mesh_number==1)THEN
            offset_begin=1
          ELSE
            pos=(mesh_number-2)*8*2+1
            READ(idx_id,pos=pos)offset_begin,offset_end
            offset_begin=offset_end
          ENDIF
          offset_end=-1
        ELSE IF(openmode(1:4)=='READ')THEN
          pos=(mesh_number-1)*8*2+1
          READ(idx_id,pos=pos)offset_begin,offset_end
        ENDIF
      END SUBROUTINE
!***********************************************************************
      SUBROUTINE write_index64
!***********************************************************************
!
     &(idx_id,mesh_number,offset_begin,offset_end)
!
!***********************************************************************
! HERMES                                                      10/05/2018
!***********************************************************************
!
!BRIEF    Write the offset of our part into the index file
!
!HISTORY  Judicaël Grasset (Daresbury Lab & EDF)
!+        10/05/2018
!+
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!| IDX_ID       |-->| FILE ID OF THE INDEX FILE
!| MESH_NUMBER  |-->| NUMBER OF THE MESH WE ARE WORKING WITH
!| OFFSET_BEGIN |-->| OFFSET TO THE BEGINING OF OUR PART
!| OFFSET_END   |-->| OFFSET TO THE END OF OUR PART
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        USE declarations_special
        INTEGER,          INTENT(IN) :: IDX_ID
        INTEGER,          INTENT(IN) :: MESH_NUMBER
        INTEGER(KIND=K8), INTENT(IN) :: OFFSET_BEGIN
        INTEGER(KIND=K8), INTENT(IN) :: OFFSET_END

        INTEGER(KIND=K8) :: POS
        pos=(mesh_number-1)*8*2+1
        WRITE(unit=idx_id,pos=pos)offset_begin,offset_end
      END SUBROUTINE
!***********************************************************************
      SUBROUTINE read_index32
!***********************************************************************
!
     &(idx_id,openmode,mesh_number,offset_begin,offset_end)
!
!***********************************************************************
! HERMES                                                      10/05/2018
!***********************************************************************
!
!BRIEF    Read offsets from the index file. If openmode is read then we
!         read the offset needed for reading our part. If openmode is
!         write we read the offset needed to write after our part.
!
!HISTORY  Judicaël Grasset (Daresbury Lab & EDF)
!+        10/05/2018
!+
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!| IDX_ID       |-->| FILE ID OF THE INDEX FILE
!| OPENMODE     |-->| OPENMODE OF THE FILE ASSOCIATED TO THE INDEX
!| MESH_NUMBER  |-->| NUMBER OF THE MESH WE ARE WORKING WITH
!| OFFSET_BEGIN |<--| OFFSET TO THE BEGINING OF OUR PART
!| OFFSET_END   |<--| OFFSET TO THE END OF OUR PART
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        USE declarations_special
        INTEGER,          INTENT(IN)  :: IDX_ID
        CHARACTER(LEN=9), INTENT(IN)  :: OPENMODE
        INTEGER,          INTENT(IN)  :: MESH_NUMBER
        INTEGER,          INTENT(OUT) :: OFFSET_BEGIN
        INTEGER,          INTENT(OUT) :: OFFSET_END

        INTEGER(KIND=K8) :: POS
        !GET THE OFFSET OF OUR PART.
        !THE OFFSETS ARE PAIRS OF 32 BITS INTEGER (4 BYTES * 2)
        !IF WE ARE IN READ MODE, THEN WE CAN READ OUR BEGINING OFFSET
        !AND OUR END OFFSET.
        !IF WE ARE IN WRITE MODE, WE CAN ONLY READ OUR BEGINING OFFSET
        !SINCE WE DO NOT KNOW WHERE WE WILL STOP WRITING.
        IF(openmode(1:5)=='WRITE')THEN
          IF(mesh_number==1)THEN
            offset_begin=1
          ELSE
            pos=(mesh_number-2)*4*2+1
            READ(idx_id,pos=pos)offset_begin,offset_end
            offset_begin=offset_end
          ENDIF
          offset_end=-1
        ELSE IF(openmode(1:4)=='READ')THEN
          pos=(mesh_number-1)*4*2+1
          READ(idx_id,pos=pos)offset_begin,offset_end
        ENDIF
      END SUBROUTINE
!***********************************************************************
      SUBROUTINE write_index32
!***********************************************************************
!
     &(idx_id,mesh_number,offset_begin,offset_end)
!
!***********************************************************************
! HERMES                                                      10/05/2018
!***********************************************************************
!
!BRIEF    Write the offset of our part into the index file
!
!HISTORY  Judicaël Grasset (Daresbury Lab & EDF)
!+        10/05/2018
!+
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!| IDX_ID       |-->| FILE ID OF THE INDEX FILE
!| MESH_NUMBER  |-->| NUMBER OF THE MESH WE ARE WORKING WITH
!| OFFSET_BEGIN |-->| OFFSET TO THE BEGINING OF OUR PART
!| OFFSET_END   |-->| OFFSET TO THE END OF OUR PART
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        USE declarations_special
        INTEGER, INTENT(IN) :: IDX_ID
        INTEGER, INTENT(IN) :: MESH_NUMBER
        INTEGER, INTENT(IN) :: OFFSET_BEGIN
        INTEGER, INTENT(IN) :: OFFSET_END

        INTEGER(KIND=K8) :: POS
        pos=(mesh_number-1)*4*2+1
        WRITE(unit=idx_id,pos=pos)offset_begin,offset_end
      END SUBROUTINE
!
      END MODULE hermes_index_file