volgrid6d_var_class.F90

! Copyright (C) 2010  ARPA-SIM <urpsim@smr.arpa.emr.it>
! authors:
! Davide Cesari <dcesari@arpa.emr.it>
! Paolo Patruno <ppatruno@arpa.emr.it>

! This program 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 2 of 
! the License, or (at your option) any later version.

! This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
#include "config.h"

MODULE volgrid6d_var_class
USE kinds
USE missing_values
USE err_handling
USE vol7d_var_class
USE file_utilities
USE grid_id_class

IMPLICIT NONE

TYPE volgrid6d_var
  integer :: centre
  integer :: category
  integer :: number
  integer :: discipline
  CHARACTER(len=65) :: description
  CHARACTER(len=24) :: unit
END TYPE  volgrid6d_var

TYPE(volgrid6d_var),PARAMETER :: volgrid6d_var_miss= &
 volgrid6d_var(imiss,imiss,imiss,imiss,cmiss,cmiss) 

TYPE(vol7d_var),PARAMETER :: vol7d_var_horstag(2) = (/ &
 vol7d_var('B11003', '', '', 0, 0, 0, 0, 0, 0), &
 vol7d_var('B11004', '', '', 0, 0, 0, 0, 0, 0) &
 /)

TYPE(vol7d_var),PARAMETER :: vol7d_var_horcomp(4) = (/ &! RESHAPE( (/ &
 vol7d_var('B11003', '', '', 0, 0, 0, 0, 0, 0), &
 vol7d_var('B11004', '', '', 0, 0, 0, 0, 0, 0), &
 vol7d_var('B11200', '', '', 0, 0, 0, 0, 0, 0), &
 vol7d_var('B11201', '', '', 0, 0, 0, 0, 0, 0) &
/)
!/), (/2,2/)) ! bug in gfortran

TYPE conv_func
  PRIVATE
  REAL :: a, b
END TYPE conv_func

TYPE(conv_func), PARAMETER :: conv_func_miss=conv_func(rmiss,rmiss)
TYPE(conv_func), PARAMETER :: conv_func_identity=conv_func(1.0,0.0)

TYPE vg6d_v7d_var_conv
  TYPE(volgrid6d_var) :: vg6d_var
  TYPE(vol7d_var) :: v7d_var
  TYPE(conv_func) :: c_func
! aggiungere informazioni ad es. su rotazione del vento
END TYPE vg6d_v7d_var_conv

TYPE(vg6d_v7d_var_conv), PARAMETER :: vg6d_v7d_var_conv_miss= &
 vg6d_v7d_var_conv(volgrid6d_var_miss, vol7d_var_miss, conv_func_miss)

TYPE(vg6d_v7d_var_conv), ALLOCATABLE :: conv_fwd(:), conv_bwd(:)

INTERFACE init
  MODULE PROCEDURE volgrid6d_var_init
END INTERFACE

INTERFACE delete
  MODULE PROCEDURE volgrid6d_var_delete
END INTERFACE

INTERFACE c_e
  MODULE PROCEDURE volgrid6d_var_c_e
END INTERFACE


INTERFACE OPERATOR (==)
  MODULE PROCEDURE volgrid6d_var_eq, conv_func_eq
END INTERFACE

INTERFACE OPERATOR (/=)
  MODULE PROCEDURE volgrid6d_var_ne, conv_func_ne
END INTERFACE

#define VOL7D_POLY_TYPE TYPE(volgrid6d_var)
#define VOL7D_POLY_TYPES _var6d
#include "array_utilities_pre.F90"

INTERFACE display
  MODULE PROCEDURE display_volgrid6d_var
END INTERFACE

INTERFACE OPERATOR (*)
  MODULE PROCEDURE conv_func_mult
END INTERFACE OPERATOR (*)

INTERFACE compute
  MODULE PROCEDURE conv_func_compute
END INTERFACE

INTERFACE convert
  MODULE PROCEDURE varbufr2vargrib_convert, vargrib2varbufr_convert
END INTERFACE

PRIVATE
PUBLIC volgrid6d_var, volgrid6d_var_miss, volgrid6d_var_new, init, delete, &
 c_e, volgrid6d_var_normalize, &
 OPERATOR(==), OPERATOR(/=), OPERATOR(*), &
 count_distinct, pack_distinct, count_and_pack_distinct, &
 map_distinct, map_inv_distinct, &
 index, display, &
 vargrib2varbufr, varbufr2vargrib, &
 conv_func, conv_func_miss, compute, convert, &
 volgrid6d_var_hor_comp_index, volgrid6d_var_is_hor_comp


CONTAINS


ELEMENTAL FUNCTION volgrid6d_var_new(centre, category, number, &
 discipline, description, unit) RESULT(this)
integer,INTENT(in),OPTIONAL :: centre
integer,INTENT(in),OPTIONAL :: category
integer,INTENT(in),OPTIONAL :: number
integer,INTENT(in),OPTIONAL :: discipline
CHARACTER(len=*),INTENT(in),OPTIONAL :: description
CHARACTER(len=*),INTENT(in),OPTIONAL :: unit

TYPE(volgrid6d_var) :: this

CALL init(this, centre, category, number, discipline, description, unit)

END FUNCTION volgrid6d_var_new


! documented in the interface
ELEMENTAL SUBROUTINE volgrid6d_var_init(this, centre, category, number, discipline,description,unit)
TYPE(volgrid6d_var),INTENT(INOUT) :: this ! object to be initialized
INTEGER,INTENT(in),OPTIONAL :: centre ! centre
INTEGER,INTENT(in),OPTIONAL :: category ! grib2: category / grib1: grib table version number
INTEGER,INTENT(in),OPTIONAL :: number ! parameter number
INTEGER,INTENT(in),OPTIONAL :: discipline ! grib2: discipline / grib1: 255
CHARACTER(len=*),INTENT(in),OPTIONAL :: description ! optional textual description of the variable
CHARACTER(len=*),INTENT(in),OPTIONAL :: unit ! optional textual description of the variable's unit

IF (PRESENT(centre)) THEN
  this%centre = centre
ELSE
  this%centre = imiss
  this%category = imiss
  this%number = imiss
  this%discipline = imiss
  RETURN
ENDIF

IF (PRESENT(category)) THEN
  this%category = category
ELSE
  this%category = imiss
  this%number = imiss
  this%discipline = imiss
  RETURN
ENDIF


IF (PRESENT(number)) THEN
  this%number = number
ELSE
  this%number = imiss
  this%discipline = imiss
  RETURN
ENDIF

! se sono arrivato fino a qui ho impostato centre, category e number
!per il grib 1 manca discipline e imposto 255 (missing del grib2) 

IF (PRESENT(discipline)) THEN
  this%discipline = discipline
ELSE
  this%discipline = 255
ENDIF

IF (PRESENT(description)) THEN
  this%description = description
ELSE
  this%description = cmiss
ENDIF

IF (PRESENT(unit)) THEN
  this%unit = unit
ELSE
  this%unit = cmiss
ENDIF



END SUBROUTINE volgrid6d_var_init


! documented in the interface
SUBROUTINE volgrid6d_var_delete(this)
TYPE(volgrid6d_var),INTENT(INOUT) :: this

this%centre = imiss
this%category = imiss
this%number = imiss
this%discipline = imiss
this%description = cmiss
this%unit = cmiss

END SUBROUTINE volgrid6d_var_delete


ELEMENTAL FUNCTION volgrid6d_var_c_e(this) RESULT(c_e)
TYPE(volgrid6d_var),INTENT(IN) :: this
LOGICAL :: c_e
c_e = this /= volgrid6d_var_miss
END FUNCTION volgrid6d_var_c_e


ELEMENTAL FUNCTION volgrid6d_var_eq(this, that) RESULT(res)
TYPE(volgrid6d_var),INTENT(IN) :: this, that
LOGICAL :: res

IF (this%discipline == that%discipline) THEN

  IF (this%discipline == 255) THEN ! grib1, WMO tables are all equivalent
    res = ((this%category == that%category) .OR. &
    (this%category >= 1 .AND. this%category <=3 .AND. &
     that%category >= 1 .AND. that%category <=3)) .AND. &
     this%number == that%number

    IF ((this%category >= 128 .AND. this%category <= 254) .OR. &
     (this%number >= 128 .AND. this%number <= 254)) THEN
      res = res .AND. this%centre == that%centre ! local definition, centre matters
    ENDIF

  ELSE ! grib2
    res = this%category == that%category .AND. &
     this%number == that%number

    IF ((this%discipline >= 192 .AND. this%discipline <= 254) .OR. &
     (this%category >= 192 .AND. this%category <= 254) .OR. &
     (this%number >= 192 .AND. this%number <= 254)) THEN
      res = res .AND. this%centre == that%centre ! local definition, centre matters
    ENDIF
  ENDIF

ELSE ! different edition or different discipline
  res = .false.
ENDIF

END FUNCTION volgrid6d_var_eq


ELEMENTAL FUNCTION volgrid6d_var_ne(this, that) RESULT(res)
TYPE(volgrid6d_var),INTENT(IN) :: this, that
LOGICAL :: res

res = .NOT.(this == that)

END FUNCTION volgrid6d_var_ne


#include "array_utilities_inc.F90"


SUBROUTINE display_volgrid6d_var(this)
TYPE(volgrid6d_var),INTENT(in) :: this

print*,"GRIDVAR: ",this%centre,this%discipline,this%category,this%number

END SUBROUTINE display_volgrid6d_var


SUBROUTINE vargrib2varbufr(vargrib, varbufr, c_func)
TYPE(volgrid6d_var),INTENT(in) :: vargrib(:)
TYPE(vol7d_var),INTENT(out) :: varbufr(:)
TYPE(conv_func),POINTER :: c_func(:)

INTEGER :: i, n, stallo

n = min(SIZE(varbufr), SIZE(vargrib))
ALLOCATE(c_func(n),stat=stallo)
IF (stallo /= 0) THEN
  call l4f_log(l4f_fatal,"allocating memory")
  call raise_fatal_error()
ENDIF

DO i = 1, n
  varbufr(i) = convert(vargrib(i), c_func(i))
ENDDO

END SUBROUTINE vargrib2varbufr


FUNCTION vargrib2varbufr_convert(vargrib, c_func) RESULT(convert)
TYPE(volgrid6d_var),INTENT(in) :: vargrib
TYPE(conv_func),INTENT(out),OPTIONAL :: c_func
TYPE(vol7d_var) :: convert

INTEGER :: i

IF (.NOT. ALLOCATED(conv_fwd)) CALL vg6d_v7d_var_conv_setup()

DO i = 1, SIZE(conv_fwd)
  IF (vargrib == conv_fwd(i)%vg6d_var) THEN
    convert = conv_fwd(i)%v7d_var
    IF (PRESENT(c_func)) c_func = conv_fwd(i)%c_func
    RETURN
  ENDIF
ENDDO
! not found
convert = vol7d_var_miss
IF (PRESENT(c_func)) c_func = conv_func_miss

! set hint for backwards conversion
convert%gribhint(:) = (/vargrib%centre, vargrib%category, vargrib%number, &
 vargrib%discipline/)

CALL l4f_log(l4f_warn, 'vargrib2varbufr: variable '// &
 trim(to_char(vargrib%centre))//':'//trim(to_char(vargrib%category))//':'// &
 trim(to_char(vargrib%number))//':'//trim(to_char(vargrib%discipline))// &
 ' not found in table')

END FUNCTION vargrib2varbufr_convert


SUBROUTINE varbufr2vargrib(varbufr, vargrib, c_func, grid_id_template)
TYPE(vol7d_var),INTENT(in) :: varbufr(:)
TYPE(volgrid6d_var),INTENT(out) :: vargrib(:)
TYPE(conv_func),POINTER :: c_func(:)
TYPE(grid_id),INTENT(in),OPTIONAL :: grid_id_template

INTEGER :: i, n, stallo

n = min(SIZE(varbufr), SIZE(vargrib))
ALLOCATE(c_func(n),stat=stallo)
IF (stallo /= 0) THEN
  CALL l4f_log(l4f_fatal,"allocating memory")
  CALL raise_fatal_error()
ENDIF

DO i = 1, n
  vargrib(i) = convert(varbufr(i), c_func(i), grid_id_template)
ENDDO

END SUBROUTINE varbufr2vargrib


FUNCTION varbufr2vargrib_convert(varbufr, c_func, grid_id_template) RESULT(convert)
TYPE(vol7d_var),INTENT(in) :: varbufr
TYPE(conv_func),INTENT(out),OPTIONAL :: c_func
TYPE(grid_id),INTENT(in),OPTIONAL :: grid_id_template
TYPE(volgrid6d_var) :: convert

INTEGER :: i
#ifdef HAVE_LIBGRIBAPI
INTEGER :: gaid, editionnumber, category, centre
#endif

IF (.NOT. ALLOCATED(conv_bwd)) CALL vg6d_v7d_var_conv_setup()

#ifdef HAVE_LIBGRIBAPI
editionnumber=255; category=255; centre=255
#endif
IF (PRESENT(grid_id_template)) THEN
#ifdef HAVE_LIBGRIBAPI
  gaid = grid_id_get_gaid(grid_id_template)
  IF (c_e(gaid)) THEN
    CALL grib_get(gaid, 'GRIBEditionNumber', editionnumber)
    IF (editionnumber == 1) THEN
      CALL grib_get(gaid,'gribTablesVersionNo',category)
    ENDIF
    CALL grib_get(gaid,'centre',centre)
  ENDIF
#endif
ENDIF

DO i = 1, SIZE(conv_bwd)
  IF (varbufr == conv_bwd(i)%v7d_var) THEN
#ifdef HAVE_LIBGRIBAPI
    IF (editionnumber /= 255) THEN ! further check required (gaid present)
      IF (editionnumber == 1) THEN
        IF (conv_bwd(i)%vg6d_var%discipline /= 255) cycle ! wrong edition
      ELSE IF (editionnumber == 2) THEN
        IF (conv_bwd(i)%vg6d_var%discipline == 255) cycle ! wrong edition
      ENDIF
      IF (conv_bwd(i)%vg6d_var%centre /= 255 .AND. &
       conv_bwd(i)%vg6d_var%centre /= centre) cycle ! wrong centre
    ENDIF
#endif
    convert = conv_bwd(i)%vg6d_var
    IF (PRESENT(c_func)) c_func = conv_bwd(i)%c_func
    RETURN
  ENDIF
ENDDO
! not found
convert = volgrid6d_var_miss
IF (PRESENT(c_func)) c_func = conv_func_miss

! if hint available use it as a fallback
IF (any(varbufr%gribhint /= imiss)) THEN
  convert%centre = varbufr%gribhint(1)
  convert%category = varbufr%gribhint(2)
  convert%number = varbufr%gribhint(3)
  convert%discipline = varbufr%gribhint(4)
ENDIF

CALL l4f_log(l4f_warn, 'varbufr2vargrib: variable '// &
 trim(varbufr%btable)//" : "//trim(varbufr%description)//" : "//trim(varbufr%unit)// &
 ' not found in table')

END FUNCTION varbufr2vargrib_convert


SUBROUTINE volgrid6d_var_normalize(this, c_func, grid_id_template)
TYPE(volgrid6d_var),INTENT(inout) :: this
TYPE(conv_func),INTENT(out) :: c_func
TYPE(grid_id),INTENT(in) :: grid_id_template

LOGICAL :: eqed, eqcentre
INTEGER :: gaid, editionnumber, centre
TYPE(volgrid6d_var) :: tmpgrib
TYPE(vol7d_var) :: tmpbufr
TYPE(conv_func) tmpc_func1, tmpc_func2

eqed = .true.
eqcentre = .true.
c_func = conv_func_miss

#ifdef HAVE_LIBGRIBAPI
gaid = grid_id_get_gaid(grid_id_template)
IF (c_e(gaid)) THEN
  CALL grib_get(gaid, 'GRIBEditionNumber', editionnumber)
  CALL grib_get(gaid, 'centre', centre)
  eqed = editionnumber == 1 .EQV. this%discipline == 255
  eqcentre = centre == this%centre
ENDIF
#endif

IF (eqed .AND. eqcentre) RETURN ! nothing to do

tmpbufr = convert(this, tmpc_func1)
tmpgrib = convert(tmpbufr, tmpc_func2, grid_id_template)

IF (tmpgrib /= volgrid6d_var_miss) THEN
! conversion back and forth successful, set also conversion function
  this = tmpgrib
  c_func = tmpc_func1 * tmpc_func2
! set to missing in common case to avoid useless computation
  IF (c_func == conv_func_identity) c_func = conv_func_miss
ELSE IF (.NOT.eqed) THEN
! conversion back and forth unsuccessful and grib edition incompatible, set to miss
  this = tmpgrib
ENDIF

END SUBROUTINE volgrid6d_var_normalize


! Private subroutine for reading forward and backward conversion tables
! todo: better error handling
SUBROUTINE vg6d_v7d_var_conv_setup()
INTEGER :: un, i, n, stallo

! forward, grib to bufr
un = open_package_file('vargrib2bufr.csv', filetype_data)
n=0
DO WHILE(.true.)
  READ(un,*,end=100)
  n = n + 1
ENDDO

100 CONTINUE

rewind(un)
ALLOCATE(conv_fwd(n),stat=stallo)
IF (stallo /= 0) THEN
  CALL l4f_log(l4f_fatal,"allocating memory")
  CALL raise_fatal_error()
ENDIF

conv_fwd(:) = vg6d_v7d_var_conv_miss
CALL import_var_conv(un, conv_fwd)
CLOSE(un)

! backward, bufr to grib
un = open_package_file('vargrib2bufr.csv', filetype_data)
! use the same file for now
!un = open_package_file('varbufr2grib.csv', filetype_data)
n=0
DO WHILE(.true.)
  READ(un,*,end=300)
  n = n + 1
ENDDO

300 CONTINUE

rewind(un)
ALLOCATE(conv_bwd(n),stat=stallo)
IF (stallo /= 0) THEN
  CALL l4f_log(l4f_fatal,"allocating memory")
  CALL raise_fatal_error()
end if

conv_bwd(:) = vg6d_v7d_var_conv_miss
CALL import_var_conv(un, conv_bwd)
DO i = 1, n
  conv_bwd(i)%c_func%a = 1./conv_bwd(i)%c_func%a
  conv_bwd(i)%c_func%b = - conv_bwd(i)%c_func%b
ENDDO
CLOSE(un)

CONTAINS

SUBROUTINE import_var_conv(un, conv_type)
INTEGER, INTENT(in) :: un
TYPE(vg6d_v7d_var_conv), INTENT(out) :: conv_type(:)

INTEGER :: i
TYPE(csv_record) :: csv
CHARACTER(len=1024) :: line
CHARACTER(len=10) :: btable
INTEGER :: centre, category, number, discipline

DO i = 1, SIZE(conv_type)
  READ(un,'(A)',end=200)line
  CALL init(csv, line)
  CALL csv_record_getfield(csv, btable)
  CALL csv_record_getfield(csv) ! skip fields for description and unit,
  CALL csv_record_getfield(csv) ! they correspond to grib information, not bufr Btable
  CALL init(conv_type(i)%v7d_var, btable=btable)

  CALL csv_record_getfield(csv, centre)
  CALL csv_record_getfield(csv, category)
  CALL csv_record_getfield(csv, number)
  CALL csv_record_getfield(csv, discipline)
  CALL init(conv_type(i)%vg6d_var, centre=centre, category=category, &
   number=number, discipline=discipline) ! controllare l'ordine

  CALL csv_record_getfield(csv, conv_type(i)%c_func%a)
  CALL csv_record_getfield(csv, conv_type(i)%c_func%b)
  CALL delete(csv)
ENDDO

200 CONTINUE

END SUBROUTINE import_var_conv

END SUBROUTINE vg6d_v7d_var_conv_setup


ELEMENTAL FUNCTION conv_func_eq(this, that) RESULT(res)
TYPE(conv_func),INTENT(IN) :: this, that
LOGICAL :: res

res = this%a == that%a .AND. this%b == that%b

END FUNCTION conv_func_eq


ELEMENTAL FUNCTION conv_func_ne(this, that) RESULT(res)
TYPE(conv_func),INTENT(IN) :: this, that
LOGICAL :: res

res = .NOT.(this == that)

END FUNCTION conv_func_ne


FUNCTION conv_func_mult(this, that) RESULT(mult)
TYPE(conv_func),INTENT(in) :: this
TYPE(conv_func),INTENT(in) :: that

TYPE(conv_func) :: mult

IF (this == conv_func_miss .OR. that == conv_func_miss) THEN
  mult = conv_func_miss
ELSE
  mult%a = this%a*that%a
  mult%b = this%a*that%b+this%b
ENDIF

END FUNCTION conv_func_mult

ELEMENTAL SUBROUTINE conv_func_compute(this, values)
TYPE(conv_func),INTENT(in) :: this
REAL,INTENT(inout) :: values

IF (this /= conv_func_miss) THEN
  IF (c_e(values)) values = values*this%a + this%b
ELSE
  values=rmiss
ENDIF

END SUBROUTINE conv_func_compute


SUBROUTINE volgrid6d_var_hor_comp_index(this, xind, yind)
TYPE(volgrid6d_var),INTENT(in) :: this(:)
INTEGER,POINTER :: xind(:), yind(:)

TYPE(vol7d_var) :: varbufr(size(this))
TYPE(conv_func),POINTER :: c_func(:)
INTEGER :: i, nv, counts(size(vol7d_var_horcomp))

NULLIFY(xind, yind)
counts(:) = 0

CALL vargrib2varbufr(this, varbufr, c_func)

DO i = 1, SIZE(vol7d_var_horcomp)
  counts(i) = count(varbufr(:) == vol7d_var_horcomp(i))
ENDDO

IF (any(counts(1::2) > 1)) THEN
  CALL l4f_log(l4f_warn, '> 1 variable refer to x component of the same field, (un)rotation impossible')
  DEALLOCATE(c_func)
  RETURN
ENDIF
IF (any(counts(2::2) > 1)) THEN
  CALL l4f_log(l4f_warn, '> 1 variable refer to y component of the same field, (un)rotation impossible')
  DEALLOCATE(c_func)
  RETURN
ENDIF

! check that variables are paired and count pairs
nv = 0
DO i = 1, SIZE(vol7d_var_horcomp), 2
  IF (counts(i) == 0 .AND. counts(i+1) > 0) THEN
    CALL l4f_log(l4f_warn, 'variable '//trim(vol7d_var_horcomp(i+1)%btable)// &
     ' present but the corresponding x-component '// &
     trim(vol7d_var_horcomp(i)%btable)//' is missing, (un)rotation impossible')
    RETURN
  ELSE  IF (counts(i+1) == 0 .AND. counts(i) > 0) THEN
    CALL l4f_log(l4f_warn, 'variable '//trim(vol7d_var_horcomp(i)%btable)// &
     ' present but the corresponding y-component '// &
     trim(vol7d_var_horcomp(i+1)%btable)//' is missing, (un)rotation impossible')
    RETURN
  ENDIF
  IF (counts(i) == 1 .AND. counts(i+1) == 1) nv = nv + 1
ENDDO

! repeat the loop storing indices
ALLOCATE(xind(nv), yind(nv))
nv = 0
DO i = 1, SIZE(vol7d_var_horcomp), 2
  IF (counts(i) == 1 .AND. counts(i+1) == 1) THEN
    nv = nv + 1
    xind(nv) = index(varbufr(:), vol7d_var_horcomp(i))
    yind(nv) = index(varbufr(:), vol7d_var_horcomp(i+1))
  ENDIF
ENDDO
DEALLOCATE(c_func)

END SUBROUTINE volgrid6d_var_hor_comp_index


FUNCTION volgrid6d_var_is_hor_comp(this) RESULT(is_hor_comp)
TYPE(volgrid6d_var),INTENT(in) :: this
LOGICAL :: is_hor_comp

TYPE(vol7d_var) :: varbufr

varbufr = convert(this)
is_hor_comp = any(varbufr == vol7d_var_horcomp(:))

END FUNCTION volgrid6d_var_is_hor_comp

! before unstaggering??

!IF (.NOT. ALLOCATED(conv_fwd)) CALL vg6d_v7d_var_conv_setup()
!
!call init(varu,btable="B11003")
!call init(varv,btable="B11004")
!
! test about presence of u and v in standard table
!if ( index(conv_fwd(:)%v7d_var,varu) == 0  .or. index(conv_fwd(:)%v7d_var,varv) == 0 )then
!  call l4f_category_log(this%category,L4F_FATAL, &
!   "variables B11003 and/or B11004 (wind components) not defined by vg6d_v7d_var_conv_setup")
!  CALL raise_error()
!  RETURN
!end if
!
!if (associated(this%var))then
!  nvar=size(this%var)
!  allocate(varbufr(nvar),stat=stallo)
!  if (stallo /=0)then
!    call l4f_log(L4F_FATAL,"allocating memory")
!    call raise_fatal_error("allocating memory")
!  end if
!
!  CALL vargrib2varbufr(this%var, varbufr)
!ELSE
!  CALL l4f_category_log(this%category, L4F_ERROR, &
!   "trying to destagger an incomplete volgrid6d object")
!  CALL raise_error()
!  RETURN
!end if
!
!nvaru=COUNT(varbufr==varu)
!nvarv=COUNT(varbufr==varv)
!
!if (nvaru > 1 )then
!  call l4f_category_log(this%category,L4F_WARN, &
!   ">1 variables refer to u wind component, destaggering will not be done ")
!  DEALLOCATE(varbufr)
!  RETURN
!endif
!
!if (nvarv > 1 )then
!  call l4f_category_log(this%category,L4F_WARN, &
!   ">1 variables refer to v wind component, destaggering will not be done ")
!  DEALLOCATE(varbufr)
!  RETURN
!endif
!
!if (nvaru == 0 .and. nvarv == 0) then
!  call l4f_category_log(this%category,L4F_WARN, &
!   "no u or v wind component found in volume, nothing to do")
!  DEALLOCATE(varbufr)
!  RETURN
!endif
!
!if (COUNT(varbufr/=varu .and. varbufr/=varv) > 0) then
!  call l4f_category_log(this%category,L4F_WARN, &
!   "there are variables different from u and v wind component in C grid")
!endif


END MODULE volgrid6d_var_class