LCOV - code coverage report
Current view: top level - physics/clubb/src/CLUBB_core - file_functions.F90 (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 27 0.0 %
Date: 2024-12-17 17:57:11 Functions: 0 2 0.0 %

          Line data    Source code
       1             : !-----------------------------------------------------------------------
       2             : ! $Id$
       3             : !===============================================================================
       4             : module file_functions
       5             : 
       6             :   implicit none
       7             : 
       8             :   public :: file_read_1d, file_read_2d
       9             : 
      10             :   private ! Default Scope
      11             : 
      12             :   contains
      13             : 
      14             : !===============================================================================
      15           0 :   subroutine file_read_1d( file_unit, path_and_filename,  & 
      16             :                            num_datapts, entries_per_line, &
      17           0 :                            variable )
      18             : 
      19             : !     Description:
      20             : !     This subroutine reads in values from a data file with a number of
      21             : !     rows and a declared number of columns (entries_per_line) of data.
      22             : !     It reads in the data in the form of:
      23             : !     1 ==> (row 1, column 1); 2 ==> (row 1, column 2); etc.
      24             : !
      25             : !     Example:  a diagram of a data file with 18 total data points
      26             : !               (DP1 to DP18), with 4 data points per row.
      27             : !
      28             : !              i = 1     i = 2     i = 3     i = 4
      29             : !           ---------------------------------------
      30             : !     k = 1 |   DP1       DP2       DP3       DP4
      31             : !           |
      32             : !     k = 2 |   DP5       DP6       DP7       DP8
      33             : !           |
      34             : !     k = 3 |   DP9       DP10      DP11      DP12
      35             : !           |
      36             : !     k = 4 |   DP13      DP14      DP15      DP16
      37             : !           |
      38             : !     k = 5 |   DP17      DP18
      39             : !
      40             : !     See Michael Falk's comments below for more information.
      41             : !-----------------------------------------------------------------------
      42             : 
      43             :     use clubb_precision, only: &
      44             :         core_rknd ! Variable(s)
      45             : 
      46             :     use constants_clubb, only: fstderr ! Constant(s)
      47             : 
      48             :     implicit none
      49             : 
      50             :     integer, intent(in) :: & 
      51             :      file_unit,          & ! Unit number of file being read.
      52             :      num_datapts,        & ! Total number of data points being read in.
      53             :      entries_per_line   ! Number of data points
      54             :     ! on one line of the file being read.
      55             : 
      56             :     character(*), intent(in) :: & 
      57             :      path_and_filename  ! Path to file and filename of file being read.
      58             : 
      59             :     real( kind = core_rknd ), dimension(num_datapts), intent(out) :: & 
      60             :      variable           ! Data values output into variable
      61             : 
      62             :     integer :: k        ! Data file row number.
      63             :     integer :: i        ! Data file column number.
      64             :     integer :: ierr
      65             : 
      66             :     ! ---- Begin Code ----
      67             : ! A ThreadLock is necessary here because FORTRAN can only have each file open on
      68             : ! one file_unit at a time. For example, suppose we are running CLUBB in parallel
      69             : ! with OpenMP using two threads. Suppose the first thread opens the file with file_unit = 0
      70             : ! (file_unit is assigned a value based on thread number).
      71             : ! Then suppose, that before thread 1 exits, thread 2 opens the same file with file_unit = 1.
      72             : ! This would cause FORTRAN to crash.
      73             : !$omp critical
      74             : 
      75             :     ! Open data file.
      76             :     open( unit=file_unit, file=path_and_filename, action='read', status='old', &
      77           0 :           iostat=ierr )
      78           0 :     if ( ierr /= 0 ) then
      79           0 :       write(fstderr,*) "CLUBB encountered an error trying to open "//path_and_filename
      80           0 :       error stop "Error opening forcings file"
      81             :     end if
      82             : 
      83             :     ! Michael Falk wrote this routine to read data files in a particular format for mpace_a.
      84             :     ! Each line has a specific number of values, until the last line in the file, which
      85             :     ! has the last few values and then ends.  This reads the correct number of values on
      86             :     ! each line.  24 September 2007
      87             : 
      88             :     ! Loop over each full line of the input file.
      89           0 :     do k = 1, (num_datapts/entries_per_line), 1
      90           0 :       read(file_unit,*) ( variable( ((k-1)*entries_per_line) + i ), & 
      91           0 :                                     i=1,entries_per_line )
      92             :     enddo
      93             :     ! Read any partial line remaining.
      94           0 :     if ( mod(num_datapts,entries_per_line) /= 0 ) then
      95           0 :       k = (num_datapts/entries_per_line)
      96           0 :       read(file_unit,*) ( variable( (k*entries_per_line) + i ), & 
      97           0 :                           i=1,(mod(num_datapts,entries_per_line)) )
      98             :     endif
      99             : 
     100             :     ! Close data file.
     101           0 :     close( file_unit )
     102             : 
     103             : !$omp end critical
     104             : 
     105           0 :     return
     106             : 
     107             :   end subroutine file_read_1d
     108             : 
     109             : !===============================================================================
     110           0 :   subroutine file_read_2d( device, file_path, file_dimension1, & 
     111           0 :                            file_dimension2, file_per_line, variable )
     112             : 
     113             : ! Description:
     114             : !   Michael Falk wrote this routine to read data files in a particular format for mpace_a.
     115             : !   The 2d mpace_a files list the (file_dimension2) values on a given vertical level, then
     116             : !   moves to the next level to list its values.
     117             : !   Each line has a specific number of values, until the last line on a level, which
     118             : !   is short-- it has the last few values and then a line break.  The next line, beginning
     119             : !   the next level, is full-sized again.  24 September 2007
     120             : !
     121             : ! References:
     122             : !   None
     123             : !-------------------------------------------------------------------------------
     124             : 
     125             :     use clubb_precision, only: &
     126             :         core_rknd ! Variable(s)
     127             : 
     128             :     implicit none
     129             : 
     130             :     integer, intent(in) :: & 
     131             :       device, & 
     132             :       file_dimension1, & 
     133             :       file_dimension2, & 
     134             :       file_per_line
     135             : 
     136             :     character(*), intent(in) :: & 
     137             :       file_path
     138             : 
     139             :     real( kind = core_rknd ), dimension(file_dimension1,file_dimension2), intent(out) :: & 
     140             :       variable
     141             : 
     142             :     integer i, j, k
     143             : 
     144             :     ! ---- Begin Code ----
     145             : 
     146           0 :     variable = -999._core_rknd ! Initialize to nonsense values
     147             : 
     148           0 :     open(device,file=file_path,action='read')
     149             : 
     150           0 :     do k=1,(file_dimension1)                ! For each level in the data file,
     151           0 :       do j=0,((file_dimension2/file_per_line)-1)
     152           0 :         read(device,*) (variable(k,(j*file_per_line)+i), & ! read file_per_line values in,
     153           0 :             i=1,file_per_line)
     154             :       end do
     155           0 :       read (device,*) (variable(k,(j*file_per_line)+i),           & ! then read the partial line
     156           0 :             i=1,(mod(file_dimension2,file_per_line)))
     157             :     end do                                              ! and then start over at the next level.
     158             : 
     159           0 :     close(device)
     160             : 
     161           0 :     return
     162             :   end subroutine file_read_2d
     163             : 
     164             : !===============================================================================
     165             : 
     166             : end module file_functions

Generated by: LCOV version 1.14