rdcmps.f

Go to the documentation of this file.

C> @file
C> @brief Read the next compressed BUFR data subset into internal arrays.
C>
C> @author Woollen @date 2000-09-19
 
C> Read the next compressed BUFR data subset into internal arrays.
C>
C> This subroutine uncompresses and unpacks the next subset
C> from the internal compressed message buffer (array mbay in module
C> @ref moda_bitbuf) and stores the unpacked subset within the internal
C> array val(*,lun) in module @ref moda_usrint.
C>
C> @param[in] LUN - integer: File ID.
C>
C> @author Woollen @date 2000-09-19
      SUBROUTINE rdcmps(LUN)
 
      USE modv_bmiss
      USE modv_mxrst
 
      USE moda_usrint
      USE moda_msgcwd
      USE moda_bitbuf
      USE moda_tables
      USE moda_rlccmn
      use moda_stcode
 
      CHARACTER*128 BORT_STR
      CHARACTER*8   CREF,CVAL
      equivalence(cval,rval)
      real*8        rval,ups
 
      integer(8) :: ival,lref,ninc,lps
 
C-----------------------------------------------------------------------
C     Statement function to compute BUFR "missing value" for field
C     of length LBIT bits (all bits "on"):
 
      lps(lbit) = max(2_8**(lbit)-1,1)
C-----------------------------------------------------------------------
 
C  SETUP THE SUBSET TEMPLATE
C  -------------------------
 
      CALL usrtpl(lun,1,1)
 
C  UNCOMPRESS A SUBSET INTO THE VAL ARRAY ACCORDING TO TABLE B
C  -----------------------------------------------------------
 
      nsbs = nsub(lun)
 
C     Note that we are going to unpack the (NSBS)th subset from within
C     the current BUFR message.
 
      ibit = mbyt(lun)
      nrst = 0
 
C     Loop through each element of the subset.
 
      n = 0
 
1     DO n=n+1,nval(lun)
      node = inv(n,lun)
      nrfelm(n,lun) = igetrfel(n,lun)
      nbit = ibt(node)
      ityp = itp(node)
 
C     In each of the following code blocks, the "local reference value"
C     for the element is determined first, followed by the 6-bit value
C     which indicates how many bits are used to store the increment
C     (i.e. offset) from this "local reference value".  Then, we jump
C     ahead to where this increment is stored for this particular subset,
C     unpack it, and add it to the "local reference value" to determine
C     the final uncompressed value for this element from this subset.
 
C     Note that, if an element has the same final uncompressed value
C     for each subset in the message, then the encoding rules for BUFR
C     compression dictate that the "local reference value" will be equal
C     to this value, the 6-bit increment length indicator will have
C     a value of zero, and the actual increments themselves will be
C     omitted from the message.
 
      IF(ityp.EQ.1.OR.ityp.EQ.2) THEN
 
C        This is a numeric element.
 
         CALL up8(lref,nbit,mbay(1,lun),ibit)
         CALL upb(linc,   6,mbay(1,lun),ibit)
         jbit = ibit + linc*(nsbs-1)
         CALL up8(ninc,linc,mbay(1,lun),jbit)
         IF(ninc.EQ.lps(linc)) THEN
            ival = lps(nbit)
         ELSE
            ival = lref+ninc
         ENDIF
         IF(ityp.EQ.1) THEN
            nbmp=int(ival)
            CALL usrtpl(lun,n,nbmp)
            if (iscodes(lun) .ne. 0) return
            GOTO 1
         ENDIF
         IF(ival.LT.lps(nbit)) val(n,lun) = ups(ival,node)
         CALL strbtm(n,lun)
         ibit = ibit + linc*msub(lun)
      ELSEIF(ityp.EQ.3) THEN
 
C        This is a character element.  If there are more than 8
C        characters, then only the first 8 will be unpacked by this
C        routine, and a separate subsequent call to BUFR archive library
C        subroutine READLC will be required to unpack the remainder of
C        the string.  In this case, pointers will be saved within
C        COMMON /RLCCMN/ for later use within READLC.
 
C        Unpack the local reference value.
 
         lelm = nbit/8
         nchr = min(8,lelm)
         ibsv = ibit
         cref = ' '
         CALL upc(cref,nchr,mbay(1,lun),ibit,.true.)
         IF(lelm.GT.8) THEN
            ibit = ibit + (lelm-8)*8
            nrst = nrst + 1
            IF(nrst.GT.mxrst) GOTO 900
            crtag(nrst) = tag(node)
         ENDIF
 
C        Unpack the increment length indicator.  For character elements,
C        this length is in bytes rather than bits.
 
         CALL upb(linc,   6,mbay(1,lun),ibit)
         IF(linc.EQ.0) THEN
            IF(lelm.GT.8) THEN
               irnch(nrst) = lelm
               irbit(nrst) = ibsv
            ENDIF
            cval = cref
         ELSE
            jbit = ibit + linc*(nsbs-1)*8
            IF(lelm.GT.8) THEN
               irnch(nrst) = linc
               irbit(nrst) = jbit
            ENDIF
            nchr = min(8,linc)
            cval = ' '
            CALL upc(cval,nchr,mbay(1,lun),jbit,.true.)
         ENDIF
         IF (lelm.LE.8 .AND. icbfms(cval,nchr).NE.0) THEN
            val(n,lun) = bmiss
         ELSE
            val(n,lun) = rval
         ENDIF
         ibit = ibit + 8*linc*msub(lun)
      ENDIF
      ENDDO
 
      RETURN
900   WRITE(bort_str,'("BUFRLIB: RDCMPS - NUMBER OF LONG CHARACTER ' //
     .   'STRINGS EXCEEDS THE LIMIT (",I4,")")') mxrst
      CALL bort(bort_str)
      END