scale_file_base_meshfield.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!> module FElib / File / Base
!!
!! @par Description
!!          A base module for outputting data with MeshField type 
!!
!! @author Yuta Kawai, Team SCALE
!<
!-------------------------------------------------------------------------------
#include "scaleFElib.h"
module scale_file_base_meshfield
  !-----------------------------------------------------------------------------
  !
  !++ Used modules
  !
  use scale_precision
  use scale_io
  use scale_file_h
  use scale_prc, only: &
    prc_abort
  use scale_file_h, only: &
    file_file_max
  
  use scale_file_common_meshfield, only: &
    file_common_meshfield_diminfo,               &
    get_dtype => file_common_meshfield_get_dtype
  use scale_mesh_base1d, only: &
    mf1d_dimtype_x => meshbase1d_dimtypeid_x, &
    mf1d_dtype_num => meshbase1d_dimtype_num 
  use scale_mesh_base2d, only: &
    mf2d_dimtype_x => meshbase2d_dimtypeid_x, &
    mf2d_dimtype_y => meshbase2d_dimtypeid_y, &
    mf2d_dtype_num => meshbase2d_dimtype_num 
  use scale_mesh_base3d, only: &
    mf3d_dimtype_x => meshbase3d_dimtypeid_x, &
    mf3d_dimtype_y => meshbase3d_dimtypeid_y, &
    mf3d_dimtype_z => meshbase3d_dimtypeid_z, &
    mf3d_dtype_num => meshbase3d_dimtype_num
 
  use scale_element_base, only: elementbase1d, elementbase2d, elementbase3d
  use scale_mesh_base1d, only: meshbase1d
  use scale_mesh_base2d, only: meshbase2d
  use scale_mesh_base3d, only: meshbase3d
  use scale_mesh_rectdom2d, only: meshrectdom2d
  use scale_mesh_cubedspheredom2d, only: meshcubedspheredom2d
  use scale_mesh_cubedom3d, only: meshcubedom3d
  use scale_mesh_cubedspheredom3d, only: meshcubedspheredom3d
  use scale_localmesh_1d, only: localmesh1d
  use scale_localmesh_2d, only: localmesh2d
  use scale_localmesh_3d, only: localmesh3d
 
  use scale_meshfield_base, only: meshfieldbase, meshfield1d, meshfield2d, meshfield3d
  use scale_variableinfo, only: variableinfo
  
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedures
  !
 
  !> Derived type to manage file output with MeshField data for each component
  type :: filebasemeshfieldcomp
    character(len=H_SHORT) :: comp_name         !< Name of the component
    integer, allocatable :: vars_ncid(:)        !< Array to save variable IDs provided by NetCDF library
    character(len=H_SHORT) :: dim_name_postfix  !< Postfix of dimension name for each component
 
    integer :: write_buf_amount
 
    integer :: mesh_type_id                           !< Mesh type ID
    class(MeshBase1D), pointer :: mesh1D              !< Pointer to 1D mesh object
    class(MeshRectDom2D), pointer :: mesh2D           !< Pointer to 2D rectangular mesh object
    class(MeshCubedSphereDom2D), pointer :: meshCS2D  !< Pointer to 2D cubed-sphere mesh object
    class(MeshCubeDom3D), pointer :: mesh3D           !< Pointer to 3D cube mesh object
    class(MeshCubedSphereDom3D), pointer :: meshCS3D  !< Pointer to 3D cubed-sphere mesh object
    type(FILE_common_meshfield_diminfo), allocatable :: dimsinfo(:)
 
    logical :: force_uniform_grid
  end type filebasemeshfieldcomp
  
 
  integer, parameter :: component_num_max = 32  !< Maximum number of components to be registered
 
  !> Derived type to manage file output with MeshField data
  type, public :: file_base_meshfield
    integer :: fid
 
    integer :: comp_num                                     !< Number of registered components
    type(filebasemeshfieldcomp) :: comp(component_num_max)  !< Array of registered components
 
    integer :: main_comp_id !< Registered component ID of main component
 
    logical :: file_axes_written  !< Flag to check whether axes are written or not
  contains
    procedure :: init => file_base_meshfield_init
    procedure :: register_comp => file_base_meshfield_register_comp
    procedure :: open => file_base_meshfield_open
    procedure :: create => file_base_meshfield_create
 
    !-
    procedure :: file_base_meshfield_def_var1
    procedure :: file_base_meshfield_def_var2
    generic :: def_var => file_base_meshfield_def_var1, file_base_meshfield_def_var2
    procedure :: end_def => file_base_meshfield_enddef
    !-
    procedure :: file_base_meshfield_write_var1d
    generic :: write_var1d => file_base_meshfield_write_var1d
    procedure :: file_base_meshfield_write_var2d
    generic :: write_var2d => file_base_meshfield_write_var2d
    procedure :: file_base_meshfield_write_var3d
    generic :: write_var3d => file_base_meshfield_write_var3d
    !-
    procedure :: put_globalattribute_time => file_base_meshfield_put_global_attribute_time
    !-
    procedure :: file_base_meshfield_read_var1d
    procedure :: file_base_meshfield_read_var1d_local
    procedure :: file_base_meshfield_read_var2d
    procedure :: file_base_meshfield_read_var2d_local
    procedure :: file_base_meshfield_read_var3d
    procedure :: file_base_meshfield_read_var3d_local
    generic :: read_var => &
      file_base_meshfield_read_var1d, file_base_meshfield_read_var1d_local, &
      file_base_meshfield_read_var2d, file_base_meshfield_read_var2d_local, &
      file_base_meshfield_read_var3d, file_base_meshfield_read_var3d_local
    
    !-  
    procedure :: get_commoninfo => file_base_meshfield_get_commoninfo
    procedure :: get_datainfo => file_base_meshfield_get_datainfo
    procedure :: get_varstepsize => file_base_meshfield_get_varstepsize
    !-
    procedure :: close => file_base_meshfield_close
    procedure :: final => file_base_meshfield_final
 
    !- Private procedures
    procedure, private :: get_comp_ptr => file_base_meshfield_get_comp
  end type file_base_meshfield
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private procedures
  !
  !-------------------
  
  private :: def_axes
  private :: write_axes
 
  integer, parameter :: meshtype_1d             = 1
  integer, parameter :: meshtype_2d_rectdom     = 2
  integer, parameter :: meshtype_2d_cubedsphere = 3
  integer, parameter :: meshtype_3d_cubedom     = 4
  integer, parameter :: meshtype_3d_cubedsphere = 5
  
contains
  !> Initialize an object to manage file output with MeshField data.
  !! The given component is registered as the main component.
  !!
  subroutine file_base_meshfield_init( this, & ! (inout)
    var_num,                                 & ! (in)
    comp_name,                               & ! (in)
    dim_name_postfix,                        & ! (in)
    mesh1d,                                  & ! (in)
    mesh2d, meshcubedsphere2d,               & ! (in)
    mesh3d, meshcubedsphere3d,               & ! (in)
    force_uniform_grid )                       ! (in)
    implicit none
 
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: var_num                                    !< Number of output variables
    character(len=*), optional, intent(in) :: comp_name               !< Name of the main component
    character(len=*), optional, intent(in) :: dim_name_postfix        !< Postfix of dimension name for each component
    class(meshbase1d), target, optional, intent(in) :: mesh1d                      !< 1D mesh object
    class(meshrectdom2d), target, optional, intent(in) :: mesh2d                   !< 2D rectangular mesh object
    class(meshcubedspheredom2d), target, optional, intent(in) :: meshcubedsphere2d !< 2D cubed-sphere mesh object   
    class(meshcubedom3d), target, optional, intent(in) :: mesh3d                   !< 3D cube mesh object
    class(meshcubedspheredom3d), target, optional, intent(in) :: meshcubedsphere3d !< 3D cubed-sphere mesh object
    logical, intent(in), optional :: force_uniform_grid               !< Flag to output data on uniform grid
 
    character(len=H_MID) :: comp_name_
    character(len=H_SHORT) :: dim_name_postfix_
    !--------------------------------------------------
 
    this%fid = -1
    this%comp_num = 0
  
    if (present(comp_name)) then
      comp_name_ = comp_name
    else
      comp_name_ = "main component"
    end if
 
    if (present(dim_name_postfix)) then
      dim_name_postfix_ = dim_name_postfix
    else
      dim_name_postfix_ = ""
    end if
 
    ! Register mesh and output information with main component
    call this%Register_comp( this%main_comp_id,                     & ! (out)
      comp_name_, var_num, dim_name_postfix_,                       & ! (in)
      mesh1d, mesh2d, meshcubedsphere2d, mesh3d, meshcubedsphere3d, & ! (in)
      force_uniform_grid ) ! (in)
    
    !-
    this%File_axes_written = .false.
  
    return
  end subroutine file_base_meshfield_init
 
  !> Register mesh and output information with each model component
  subroutine file_base_meshfield_register_comp( this, &
    registered_comp_id,                      & ! (out)
    comp_name,                               & ! (in)
    var_num,                                 & ! (in)
    dim_name_postfix,                        & ! (in)
    mesh1d,                                  & ! (in)
    mesh2d, meshcubedsphere2d,               & ! (in)
    mesh3d, meshcubedsphere3d,               & ! (in)
    force_uniform_grid                       ) ! (in)
 
    use scale_file_common_meshfield, only: &
      file_common_meshfield_get_dims    
    implicit none
    class(file_base_meshfield), intent(inout), target :: this
    integer, intent(out) :: registered_comp_id                       !< Registered component ID
    integer, intent(in) :: var_num                                   !< Number of variables to be registered
    character(len=*), intent(in) :: comp_name                        !< Name of the component to be registered
    character(len=*), intent(in) :: dim_name_postfix                 !< Postfix of dimension name for each component
    class(meshbase1d), target, optional, intent(in) :: mesh1d                      !< 1D mesh object
    class(meshrectdom2d), target, optional, intent(in) :: mesh2d                   !< 2D rectangular mesh object
    class(meshcubedspheredom2d), target, optional, intent(in) :: meshcubedsphere2d !< 2D cubed-sphere mesh object
    class(meshcubedom3d), target, optional, intent(in) :: mesh3d                   !< 3D cube mesh object
    class(meshcubedspheredom3d), target, optional, intent(in) :: meshcubedsphere3d !< 3D cubed-sphere mesh object
    logical, intent(in), optional :: force_uniform_grid              !< Flag to output data on uniform grid
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
 
    logical :: check_specify_mesh
    !------------------------------------------------------------------------------
 
    if ( this%comp_num >= component_num_max ) then
      log_error("FILE_base_meshfield_register_comp",*) 'Exceeding maximum number of components. Check!'
      call prc_abort
    end if
 
    this%comp_num = this%comp_num + 1
    registered_comp_id = this%comp_num
 
    comp_ptr => this%comp(registered_comp_id)
    comp_ptr%comp_name = trim(comp_name)
    comp_ptr%write_buf_amount = 0
    comp_ptr%dim_name_postfix = trim(dim_name_postfix)
 
    !-
    allocate( comp_ptr%vars_ncid(var_num) )
    comp_ptr%vars_ncid(:) = -1
 
 
    !- Register mesh information
 
    check_specify_mesh = .false.
    nullify( comp_ptr%mesh1D, comp_ptr%mesh2D, comp_ptr%mesh3D )
    nullify( comp_ptr%meshCS2D, comp_ptr%meshCS3D )
  
    if (present(mesh1d)) then
      comp_ptr%mesh1D => mesh1d
      comp_ptr%mesh_type_id = meshtype_1d
      check_specify_mesh = .true.
  
      allocate( comp_ptr%dimsinfo(mf1d_dtype_num) )
      call file_common_meshfield_get_dims( mesh1d, comp_ptr%dim_name_postfix, & ! (in)
        comp_ptr%dimsinfo(:) ) ! (out)
    end if
    if (present(mesh2d)) then
      comp_ptr%mesh2D => mesh2d
      comp_ptr%mesh_type_id = meshtype_2d_rectdom
      check_specify_mesh = .true.
  
      allocate( comp_ptr%dimsinfo(mf2d_dtype_num) )
      call file_common_meshfield_get_dims( mesh2d, comp_ptr%dim_name_postfix, & ! (in)
        comp_ptr%dimsinfo(:) ) ! (out)
    end if
    if (present(meshcubedsphere2d)) then
      comp_ptr%meshCS2D => meshcubedsphere2d
      comp_ptr%mesh_type_id = meshtype_2d_cubedsphere
      check_specify_mesh = .true.
  
      allocate( comp_ptr%dimsinfo(mf2d_dtype_num) )
      call file_common_meshfield_get_dims( meshcubedsphere2d, comp_ptr%dim_name_postfix, & ! (in)
        comp_ptr%dimsinfo(:) ) ! (out)
    end if
    if (present(mesh3d)) then
      comp_ptr%mesh3D => mesh3d
      comp_ptr%mesh2D => mesh3d%mesh2D
      comp_ptr%mesh_type_id = meshtype_3d_cubedom
      check_specify_mesh = .true.
  
      allocate( comp_ptr%dimsinfo(mf3d_dtype_num) )
      call file_common_meshfield_get_dims( mesh3d, comp_ptr%dim_name_postfix, & ! (in)
        comp_ptr%dimsinfo(:) ) ! (out)
    end if
    if (present(meshcubedsphere3d)) then
      comp_ptr%meshCS3D => meshcubedsphere3d
      comp_ptr%meshCS2D => meshcubedsphere3d%mesh2D
      comp_ptr%mesh_type_id = meshtype_3d_cubedsphere
      check_specify_mesh = .true.
  
      allocate( comp_ptr%dimsinfo(mf3d_dtype_num) )
      call file_common_meshfield_get_dims( meshcubedsphere3d, comp_ptr%dim_name_postfix, & ! (in)
        comp_ptr%dimsinfo(:) ) ! (out)
    end if
 
    if ( present(force_uniform_grid) ) then
      comp_ptr%force_uniform_grid = force_uniform_grid
    else
      comp_ptr%force_uniform_grid = .false.
    end if
     
    if (.not. check_specify_mesh) then
      log_error("FILE_base_meshfield_register_comp",*) 'Specify a mesh among mesh1D, 2D, and 3D. Check!'
      call prc_abort
    end if
 
    return
  end subroutine file_base_meshfield_register_comp
 
  !> Open file
  subroutine file_base_meshfield_open( this, & ! (inout)
    basename, myrank                         ) ! (in)
  
    use scale_file, only: &
      file_open 
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    character(*), intent(in) :: basename
    integer, intent(in), optional :: myrank
    !--------------------------------------------------------------
    
    call file_open( basename,         & ! [in]
                    this%fid,         & ! [out]
                    rankid=myrank     ) ! [in]
  
    return
  end subroutine file_base_meshfield_open
 
  !> Create file
  subroutine file_base_meshfield_create( &
    this, basename, title, dtype,        &
    fileexisted,                         &
    myrank, tunits, calendar )
  
    use scale_file, only: &
      file_create
    implicit none
 
    class(file_base_meshfield), intent(inout) :: this
    character(*), intent(in) :: basename  
    character(*), intent(in) :: title    
    character(*), intent(in) :: dtype
    logical, intent(out) :: fileexisted
    integer, intent(in), optional :: myrank
    character(*), intent(in), optional :: calendar
    character(*), intent(in), optional :: tunits
 
    integer :: i
    !--------------------------------------------------------------
    
    call file_create( basename,                & ! [IN]
                      title,                   & ! [IN]
                      h_source,                & ! [IN]
                      h_institute,             & ! [IN]
                      this%fid,                & ! [OUT]
                      fileexisted,             & ! [OUT]
                      rankid     = myrank,     & ! [IN]
                      time_units = tunits,     & ! [IN]
                      aggregate  = .false.,    & ! [IN]
                      calendar   = calendar    ) ! [IN]
    
    if ( .not. fileexisted ) then
      do i=1, this%comp_num
        call def_axes( this%comp(i), this%fid, dtype )
      end do
      this%File_axes_written = .false.      
    end if
 
    return
  end subroutine file_base_meshfield_create
 
  !> Define a variable in the file with MeshField data
  subroutine file_base_meshfield_def_var1( this, & ! (inout)
    field, desc, vid, dim_type_id, datatype,     & ! (in)
    standard_name, timeinv, nsteps,              & ! (in)
    comp_id                                      ) ! (in)
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    class(meshfieldbase), intent(in) :: field
    character(len=*), intent(in) :: desc
    integer, intent(in) :: dim_type_id
    integer, intent(in) :: vid
    character(len=*), intent(in) :: datatype
    character(len=*), optional, intent(in) :: standard_name
    real(dp), optional, intent(in) :: timeinv
    integer, optional, intent(in) :: nsteps
    integer, optional, intent(in) :: comp_id
    !--------------------------------------------------------------
 
    call this%Def_Var( field%varname, field%unit, &
      desc, vid, dim_type_id, datatype, standard_name, timeinv, nsteps, comp_id )
  
    return
  end subroutine file_base_meshfield_def_var1  
 
  !> Define a variable in the file with MeshField data
  subroutine file_base_meshfield_def_var2( this,      & ! (inout)
    varname, units, desc, vid, dim_type_id, datatype, & ! (in)
    standard_name, timeinv, nsteps, comp_id           ) ! (in)
  
    use scale_file, only: &
      file_opened, &
      file_def_variable, &
      file_set_attribute  
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this    
    character(len=*), intent(in) :: varname
    character(len=*), intent(in) :: units
    character(len=*), intent(in) :: desc
    integer, intent(in) :: dim_type_id
    integer, intent(in) :: vid
    character(len=*), intent(in) :: datatype
    character(len=*), optional, intent(in) :: standard_name
    real(dp), optional, intent(in) :: timeinv
    integer, optional, intent(in) :: nsteps
    integer, optional, intent(in) :: comp_id
  
    integer :: i_dtype
    integer :: ndim
    character(len=H_MID)   :: standard_name_
    
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !--------------------------------------------------------------
 
    call this%get_comp_ptr( comp_id, & ! (in)
      comp_ptr ) ! (out)
 
    i_dtype = get_dtype(datatype)
  
    if ( present(nsteps) ) then
      comp_ptr%write_buf_amount = comp_ptr%write_buf_amount + comp_ptr%dimsinfo(dim_type_id)%size * nsteps
    else
      comp_ptr%write_buf_amount = comp_ptr%write_buf_amount + comp_ptr%dimsinfo(dim_type_id)%size
    end if
    if ( present(standard_name) ) then
      standard_name_ = standard_name
    else
      standard_name_ = ""
    end if
  
    ndim = comp_ptr%dimsinfo(dim_type_id)%ndim
    if ( present(timeinv) ) then
      call file_def_variable( this%fid, varname, desc, units, standard_name_,                &
        ndim, comp_ptr%dimsinfo(dim_type_id)%dims(1:ndim), i_dtype, comp_ptr%vars_ncid(vid), &
        time_int=timeinv )
    else
      call file_def_variable( this%fid, varname, desc, units, standard_name_,                &
        ndim, comp_ptr%dimsinfo(dim_type_id)%dims(1:ndim), i_dtype, comp_ptr%vars_ncid(vid)  )
    end if
  
    return
  end subroutine file_base_meshfield_def_var2  
 
  !> End definition of variables in the file with MeshField data
  subroutine file_base_meshfield_enddef( this ) ! (inout)
 
    use scale_file, only: &
      file_opened,    &
      file_enddef
    implicit none
    class(file_base_meshfield), intent(inout) :: this
  
    integer :: start(3)
    integer :: i
    !--------------------------------------------------------------
  
    if (this%fid == -1) return
  
    call file_enddef( this%fid )
    
    if ( .not. this%File_axes_written ) then
      start(:) = 1
      do i=1, this%comp_num
        call write_axes( this%comp(i), this%fid, start(:) )
      end do
      this%File_axes_written = .true.
    end if
  
    return
  end subroutine file_base_meshfield_enddef
  
  !> Write a 1D variable in the file with MeshField data
!OCL_SERIAL
  subroutine file_base_meshfield_write_var1d( this, & ! (inout)
    vid, field1d, sec_str, sec_end,                 & ! (in)
    comp_id                                         ) ! (in)
 
    use scale_file, only: &
        file_opened, &
        file_write 
    use scale_file_common_meshfield, only: &
      file_common_meshfield_put_field1d_cartesbuf
    implicit none
 
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: vid
    class(meshfield1d), intent(in) :: field1d
    real(dp), intent(in) :: sec_str
    real(dp), intent(in) :: sec_end
    integer, intent(in), optional :: comp_id
    
    real(rp), allocatable :: buf(:)
    integer :: dims(1)
    integer :: start(1)
    
    integer :: ldomid
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
 
    call this%get_comp_ptr( comp_id, & ! (in)
      comp_ptr ) ! (out)
    
    if ( this%fid /= -1 ) then
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf1d_dimtype_x)%size
      allocate( buf(dims(1)) )
 
#ifdef _OPENACC
      do ldomid=1, field1d%mesh%LOCAL_MESH_NUM
        !$acc update host( field1d%local(ldomID)%val ) async(1)
      end do
      !$acc wait(1)
#endif      
 
      call file_common_meshfield_put_field1d_cartesbuf( comp_ptr%mesh1D, field1d, buf(:), &
        comp_ptr%force_uniform_grid )
 
      call file_write( comp_ptr%vars_ncid(vid), buf(:), & ! (in)
        sec_str, sec_end, start=start                   ) ! (in)
    end if
 
    return
  end subroutine file_base_meshfield_write_var1d
 
  !> Write a 2D variable in the file with MeshField data
!OCL_SERIAL
  subroutine file_base_meshfield_write_var2d( this, & ! (inout)
    vid, field2d, sec_str, sec_end,                 & ! (in)
    comp_id                                         ) ! (in)
 
    use scale_file, only: &
        file_opened, &
        file_write 
    use scale_file_common_meshfield, only: &
      file_common_meshfield_put_field2d_cartesbuf,             &
      file_common_meshfield_put_field2d_cubedsphere_cartesbuf
    implicit none
 
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: vid
    class(meshfield2d), intent(in) :: field2d
    real(dp), intent(in) :: sec_str
    real(dp), intent(in) :: sec_end
    integer, intent(in), optional :: comp_id
    real(rp), allocatable :: buf(:,:)
    integer :: dims(2)
    integer :: start(2)
 
    integer :: ldomid
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
 
    call this%get_comp_ptr( comp_id, & ! (in)
      comp_ptr ) ! (out)
    
    if ( this%fid /= -1 ) then
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf2d_dimtype_x)%size
      dims(2) = comp_ptr%dimsinfo(mf2d_dimtype_y)%size
      allocate( buf(dims(1),dims(2)) )
 
#ifdef _OPENACC
      do ldomid=1, field2d%mesh%LOCAL_MESH_NUM
        !$acc update host( field2d%local(ldomID)%val ) async(1)
      end do
      !$acc wait(1)
#endif      
 
      if ( associated(comp_ptr%mesh2D) ) then
        call file_common_meshfield_put_field2d_cartesbuf( comp_ptr%mesh2D, field2d, buf(:,:), &
          comp_ptr%force_uniform_grid )
      else if ( associated(comp_ptr%meshCS2D) ) then
        call file_common_meshfield_put_field2d_cubedsphere_cartesbuf( comp_ptr%meshCS2D, field2d, buf(:,:) )
      end if
      call file_write( comp_ptr%vars_ncid(vid), buf(:,:),   & ! (in)
        sec_str, sec_end, start=start                       ) ! (in)
    end if
 
    return
  end subroutine file_base_meshfield_write_var2d
 
  !> Write a 3D variable in the file with MeshField data
!OCL_SERIAL
  subroutine file_base_meshfield_write_var3d( this, & ! (inout)
    vid, field3d, sec_str, sec_end,                 & ! (in)
    comp_id                                         ) ! (in)
  
    use scale_file, only: &
        file_opened, &
        file_write 
    use scale_file_common_meshfield, only: &
      file_common_meshfield_put_field3d_cartesbuf,            &
      file_common_meshfield_put_field3d_cubedsphere_cartesbuf
    use scale_prof
    implicit none
 
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: vid
    class(meshfield3d), intent(in) :: field3d
    real(dp), intent(in) :: sec_str
    real(dp), intent(in) :: sec_end
    integer, intent(in), optional :: comp_id
    
    real(rp), allocatable :: buf(:,:,:)
    integer :: dims(3)
    integer :: start(3)
 
    integer :: ldomid
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
  
    call this%get_comp_ptr( comp_id, & ! (in)
      comp_ptr ) ! (out)
    
    if ( this%fid /= -1 ) then
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf3d_dimtype_x)%size
      dims(2) = comp_ptr%dimsinfo(mf3d_dimtype_y)%size
      dims(3) = comp_ptr%dimsinfo(mf3d_dimtype_z)%size
      allocate( buf(dims(1),dims(2),dims(3)) )
 
#ifdef _OPENACC
      do ldomid=1, field3d%mesh%LOCAL_MESH_NUM
        !$acc update host( field3d%local(ldomID)%val ) async(1)
      end do
      !$acc wait(1)
#endif      
 
      if ( associated(comp_ptr%mesh3D) ) then
        call file_common_meshfield_put_field3d_cartesbuf( comp_ptr%mesh3D, field3d, buf(:,:,:), &
          comp_ptr%force_uniform_grid )
      else if ( associated(comp_ptr%meshCS3D) ) then
        call file_common_meshfield_put_field3d_cubedsphere_cartesbuf( comp_ptr%meshCS3D, field3d, buf(:,:,:) )
      end if
 
      call file_write( comp_ptr%vars_ncid(vid), buf(:,:,:),     & ! (in)
        sec_str, sec_end, start                                 ) ! (in)
    end if
  
    return
  end subroutine file_base_meshfield_write_var3d
 
  !> Get common information of the file with MeshField data
  subroutine file_base_meshfield_get_commoninfo( this, & ! (in)
    title, source, institution                         ) ! (out)
    use scale_file, only: &
      file_get_attribute
    implicit none
    
    class(file_base_meshfield), intent(in) :: this
    character(len=FILE_HMID), intent(out), optional :: title        !< Title of the file
    character(len=FILE_HMID), intent(out), optional :: source       !< Source of the file
    character(len=FILE_HMID), intent(out), optional :: institution  !< Institution of the file
    !-------------------------------------------------
 
    if ( present(title) ) call file_get_attribute( this%fid, 'global', 'title', title )
    if ( present(source) ) call file_get_attribute( this%fid, 'global', 'source', source )
    if ( present(institution) ) call file_get_attribute( this%fid, 'global', 'institution', institution )
 
    return
  end subroutine file_base_meshfield_get_commoninfo
 
  !> Get the number of time steps associated with the variable in the file
  subroutine file_base_meshfield_get_varstepsize( this, varname, & ! (in)
    len                                                          ) ! (out)
    use scale_file, only: &
      file_get_stepsize    
    implicit none
 
    class(file_base_meshfield), intent(in) :: this
    character(*), intent(in) :: varname              !< Name of the variable
    integer, intent(out) :: len                      !< Number of time steps associated with the variable
    !-------------------------------------------------
 
    call file_get_stepsize( this%fid, varname, & ! (in)
      len )                                      ! (out)
    
    return    
  end subroutine file_base_meshfield_get_varstepsize
 
  !> Get information of the variable in the file with MeshField data
  subroutine file_base_meshfield_get_datainfo( this, varname, istep, & ! (in)
    description, units, standard_name,                               & ! (out)
    time_start, time_end, time_units, calendar                       ) ! (out)
    use scale_file, only: &
      file_get_datainfo
    implicit none
    
    class(file_base_meshfield), intent(in) :: this
    character(*), intent(in) :: varname                              !< Name of the variable
    integer, intent(in), optional :: istep                           !< Time step of the variable
    character(len=FILE_HMID), intent(out), optional :: description   !< Description of the variable
    character(len=FILE_HSHORT), intent(out), optional :: units       !< Units of the variable
    character(len=FILE_HMID), intent(out), optional :: standard_name !< Standard name of the variable
    real(dp), intent(out), optional :: time_start                    !< Start time of the variable
    real(dp), intent(out), optional :: time_end                      !< End time of the variable
    character(len=FILE_HMID), intent(out), optional :: time_units    !< Time units of the variable
    character(len=FILE_HSHORT), intent(out), optional :: calendar    !< Calendar name
    !-------------------------------------------------
 
    call file_get_datainfo( this%fid, varname, istep=istep,                               & ! (in)
      description=description, units=units, standard_name=standard_name,                  & ! (out)
      time_start=time_start, time_end=time_end, time_units=time_units, calendar=calendar  ) ! (out)
 
    return
  end subroutine file_base_meshfield_get_datainfo
 
  !> Read a 1D variable in the file with MeshField data
!OCL_SERIAL
  subroutine file_base_meshfield_read_var1d( this,    & ! (inout)
    dim_typeid, varname,                              & ! (in)
    field1d,                                          & ! (inout)
    step, allow_missing, comp_id )                      ! (in)
  
    use scale_file, only: &
      file_read
    use scale_file_common_meshfield, only: &
      file_common_meshfield_set_cartesbuf_field1d
 
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: dim_typeid
    character(*), intent(in) :: varname
    class(meshfield1d), intent(inout) :: field1d
    integer, intent(in), optional :: step
    logical, intent(in), optional :: allow_missing
    integer, intent(in), optional :: comp_id
  
    real(rp), allocatable :: buf(:)
    integer :: dims(1)
    integer :: start(1)   ! start offset of globale variable
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
      
    if ( this%fid /= -1 ) then
      call this%get_comp_ptr( comp_id, & ! (in)
        comp_ptr ) ! (out)
 
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(dim_typeid)%size
      allocate( buf(dims(1)) )
  
      call file_read( this%fid, varname,                       & ! (in)
        buf(:),                                                & ! (out)
        step=step, allow_missing=allow_missing                 ) ! (in)
  
      call file_common_meshfield_set_cartesbuf_field1d( comp_ptr%mesh1D, buf(:), &
        field1d )
    end if
  
    return
  end subroutine file_base_meshfield_read_var1d
 
  !> Read a 1D variable with local mesh in the file
!OCL_SERIAL
  subroutine file_base_meshfield_read_var1d_local( this, & ! (inout)
    dim_typeid, varname, lcmesh, i0_s,                   & ! (in)
    val,                                                 & ! (out)
    step, allow_missing, comp_id )                         ! (in)
  
    use scale_file, only: &
      file_read
    use scale_file_common_meshfield, only: &
      file_common_meshfield_set_cartesbuf_field1d_local
  
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: dim_typeid
    character(*), intent(in) :: varname
    class(localmesh1d), intent(in) :: lcmesh
    integer, intent(in) :: i0_s
    real(rp), intent(out) :: val(lcmesh%refelem1d%np,lcmesh%nea)
    integer, intent(in), optional :: step
    logical, intent(in), optional :: allow_missing
    integer, intent(in), optional :: comp_id
    real(rp), allocatable :: buf(:)
    integer :: dims(1)
    integer :: start(1)   ! start offset of globale variable
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
  
    if ( this%fid /= -1 ) then
      call this%get_comp_ptr( comp_id, & ! (in)
        comp_ptr ) ! (out)
      
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(dim_typeid)%size
      allocate( buf(dims(1)) )
  
      call file_read( this%fid, varname,                       & ! (in)
        buf(:),                                                & ! (out)
        step=step, allow_missing=allow_missing                 ) ! (in)
  
      call file_common_meshfield_set_cartesbuf_field1d_local( &
        lcmesh, buf(:), i0_s,                                 &
        val(:,:) )
    end if
  
    return
  end subroutine file_base_meshfield_read_var1d_local 
 
  !> Read a 2D variable in the file with MeshField data
!OCL_SERIAL
  subroutine file_base_meshfield_read_var2d( this, & ! (inout)
    dim_typeid, varname,                           & ! (in)
    field2d,                                       & ! (inout)
    step, allow_missing, comp_id                   ) ! (in)
  
    use scale_file, only: &
      file_read
    use scale_file_common_meshfield, only: &
      file_common_meshfield_set_cartesbuf_field2d,           &
      file_common_meshfield_set_cartesbuf_field2d_cubedsphere
  
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: dim_typeid
    character(*), intent(in) :: varname
    class(meshfield2d), intent(inout) :: field2d
    integer, intent(in), optional :: step
    logical, intent(in), optional :: allow_missing
    integer, intent(in), optional :: comp_id
  
    real(rp), allocatable :: buf(:,:)
    integer :: dims(2)
    integer :: start(2)   ! start offset of globale variable
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
  
    if ( this%fid /= -1 ) then
      call this%get_comp_ptr( comp_id, & ! (in)
        comp_ptr ) ! (out)
      
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf2d_dimtype_x)%size
      dims(2) = comp_ptr%dimsinfo(mf2d_dimtype_y)%size
      allocate( buf(dims(1),dims(2)) )
  
      call file_read( this%fid, varname,                       & ! (in)
        buf(:,:),                                              & ! (out)
        step=step, allow_missing=allow_missing                 ) ! (in)
  
      if ( associated( comp_ptr%meshCS2D) ) then
        call file_common_meshfield_set_cartesbuf_field2d_cubedsphere( &
          comp_ptr%meshCS2D, buf(:,:),                                &
          field2d )
      else if ( associated( comp_ptr%mesh2D) ) then
        call file_common_meshfield_set_cartesbuf_field2d( comp_ptr%mesh2D, buf(:,:),   &
          field2d )
      end if
    end if
  
    return
  end subroutine file_base_meshfield_read_var2d
 
  !> Read a 2D variable with local mesh in the file
!OCL_SERIAL
  subroutine file_base_meshfield_read_var2d_local( this, & ! (inout)
    dim_typeid, varname, lcmesh, i0_s, j0_s,             & ! (in)
    val,                                                 & ! (out)
    step, allow_missing, comp_id )                         ! (in)
  
    use scale_file, only: &
      file_read
    use scale_file_common_meshfield, only: &
      file_common_meshfield_set_cartesbuf_field2d_local
  
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: dim_typeid
    character(*), intent(in) :: varname
    class(localmesh2d), intent(in) :: lcmesh
    integer, intent(in) :: i0_s, j0_s
    real(rp), intent(out) :: val(lcmesh%refelem2d%np,lcmesh%nea)
    integer, intent(in), optional :: step
    logical, intent(in), optional :: allow_missing
    integer, intent(in), optional :: comp_id
  
    real(rp), allocatable :: buf(:,:)
    integer :: dims(2)
    integer :: start(2)   ! start offset of globale variable
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
  
    if ( this%fid /= -1 ) then
      call this%get_comp_ptr( comp_id, & ! (in)
        comp_ptr ) ! (out)
      
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf2d_dimtype_x)%size
      dims(2) = comp_ptr%dimsinfo(mf2d_dimtype_y)%size
      allocate( buf(dims(1),dims(2)) )
  
      call file_read( this%fid, varname,                       & ! (in)
        buf(:,:),                                              & ! (out)
        step=step, allow_missing=allow_missing                 ) ! (in)
  
      call file_common_meshfield_set_cartesbuf_field2d_local( &
        lcmesh, buf(:,:), i0_s, j0_s,                         &
        val(:,:) )
    end if
  
    return
  end subroutine file_base_meshfield_read_var2d_local
 
  !> Read a 3D variable in the file with MeshField data
!OCL_SERIAL
  subroutine file_base_meshfield_read_var3d( this, & ! (inout)
    dim_typeid, varname,                           & ! (in)
    field3d,                                       & ! (inout)
    step, allow_missing, comp_id                   ) ! (in)
  
    use scale_file, only: &
      file_read
    use scale_file_common_meshfield, only: &
      file_common_meshfield_set_cartesbuf_field3d,            &
      file_common_meshfield_set_cartesbuf_field3d_cubedsphere
 
  
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: dim_typeid
    character(*), intent(in) :: varname
    class(meshfield3d), intent(inout) :: field3d
    integer, intent(in), optional :: step
    logical, intent(in), optional :: allow_missing
    integer, intent(in), optional :: comp_id
  
    real(rp), allocatable :: buf(:,:,:)
    integer :: dims(3)
    integer :: start(3)   ! start offset of globale variable
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
  
    if ( this%fid /= -1 ) then
      call this%get_comp_ptr( comp_id, & ! (in)
        comp_ptr ) ! (out)
      
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf3d_dimtype_x)%size
      dims(2) = comp_ptr%dimsinfo(mf3d_dimtype_y)%size
      dims(3) = comp_ptr%dimsinfo(mf3d_dimtype_z)%size
      allocate( buf(dims(1),dims(2),dims(3)) )
  
      call file_read( this%fid, varname,                       & ! (in)
        buf(:,:,:),                                            & ! (out)
        step=step, allow_missing=allow_missing                 ) ! (in)
  
      if ( associated(comp_ptr%meshCS3D) ) then
        call file_common_meshfield_set_cartesbuf_field3d_cubedsphere( &
          comp_ptr%meshCS3D, buf(:,:,:),                              &
          field3d )
      else if ( associated(comp_ptr%mesh3D) ) then
        call file_common_meshfield_set_cartesbuf_field3d( comp_ptr%mesh3D, buf(:,:,:), &
          field3d )
      end if
    end if
  
    return
  end subroutine file_base_meshfield_read_var3d
 
  !> Read a 3D variable with local mesh in the file
!OCL_SERIAL
  subroutine file_base_meshfield_read_var3d_local( this, & ! (inout)
    dim_typeid, varname, lcmesh, i0_s, j0_s, k0_s,       & ! (in)
    val,                                                 & ! (out)
    step, allow_missing, comp_id  )                        ! (in)
  
    use scale_file, only: &
      file_read
    use scale_file_common_meshfield, only: &
      file_common_meshfield_set_cartesbuf_field3d_local
  
    implicit none
  
    class(file_base_meshfield), intent(inout) :: this
    integer, intent(in) :: dim_typeid
    character(*), intent(in) :: varname
    class(localmesh3d), intent(in) :: lcmesh
    integer, intent(in) :: i0_s, j0_s, k0_s
    real(rp), intent(out) :: val(lcmesh%refelem3d%np,lcmesh%nea)
    integer, intent(in), optional :: step
    logical, intent(in), optional :: allow_missing
    integer, intent(in), optional :: comp_id
  
    real(rp), allocatable :: buf(:,:,:)
    integer :: dims(3)
    integer :: start(3)   ! start offset of globale variable
 
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !-------------------------------------------------
  
    if ( this%fid /= -1 ) then
      call this%get_comp_ptr( comp_id, & ! (in)
        comp_ptr ) ! (out)
      
      start(:) = 1
      dims(1) = comp_ptr%dimsinfo(mf3d_dimtype_x)%size
      dims(2) = comp_ptr%dimsinfo(mf3d_dimtype_y)%size
      dims(3) = comp_ptr%dimsinfo(mf3d_dimtype_z)%size
      allocate( buf(dims(1),dims(2),dims(3)) )
  
      call file_read( this%fid, varname,                       & ! (in)
        buf(:,:,:),                                            & ! (out)
        step=step, allow_missing=allow_missing                 ) ! (in)
  
      call file_common_meshfield_set_cartesbuf_field3d_local( &
        lcmesh, buf(:,:,:), i0_s, j0_s, k0_s,                 &
        val(:,:) )
    end if
  
    return
  end subroutine file_base_meshfield_read_var3d_local
 
  !> Close the file with MeshField data
  subroutine file_base_meshfield_close( this ) ! (inout)
    use scale_file, only: file_close
    
    implicit none
    class(file_base_meshfield), intent(inout) :: this
    !--------------------------------------------------
  
    if ( this%fid /= -1 ) then
      call file_close( this%fid ) ! [IN]
      this%fid = -1
    end if
  
    return
  end subroutine file_base_meshfield_close
 
  !> Finalize an object to manage file output of meshfield data.
!OCL_SERIAL
  subroutine file_base_meshfield_final( this ) ! (inout)
    implicit none
    class(file_base_meshfield), intent(inout) :: this
 
    integer :: i
    type(filebasemeshfieldcomp), pointer :: comp_ptr
    !--------------------------------------------------
  
    do i=1, this%comp_num
      call this%get_comp_ptr( i, comp_ptr )
      if ( allocated(comp_ptr%vars_ncid) ) deallocate( comp_ptr%vars_ncid )
      if ( allocated(comp_ptr%dimsinfo) ) deallocate( comp_ptr%dimsinfo )
      nullify( comp_ptr%mesh1D, comp_ptr%mesh2D, comp_ptr%mesh3D )
      nullify( comp_ptr%meshCS2D, comp_ptr%meshCS3D )
    end do
  
    return
  end subroutine file_base_meshfield_final
 
  !> Put global attributes related to time in the file with MeshField data
  subroutine file_base_meshfield_put_global_attribute_time( &
    this, date, subsec  )
 
    use scale_file, only: &
      file_set_attribute, &
      file_get_cftunits
    use scale_calendar, only: &
      calendar_get_name
       
    implicit none
 
    class(file_base_meshfield), intent(inout) :: this 
    integer, intent(in) :: date(6)
    real(dp), intent(in) :: subsec
 
    character(34) :: tunits
    character(len=H_SHORT) :: calendar_name
    !------------------------------------
 
    call file_set_attribute( this%fid, "global", "Conventions", "CF-1.6" ) ! [IN]
    call file_set_attribute( this%fid, "global", "grid_name", "hoge"     ) ! [IN]
 
    !- time
 
    if ( date(1) > 0 ) then
      call file_get_cftunits( date(:), tunits )
      call calendar_get_name( calendar_name )
    else
      tunits        = 'seconds'
      calendar_name = ''
    endif
        
    if ( calendar_name /= "" ) &
      call file_set_attribute( this%fid, "global", "calendar", calendar_name )
    call file_set_attribute( this%fid, "global", "time_units", tunits )
    call file_set_attribute( this%fid, "global", "time_start", (/ subsec /) )
 
    return
  end subroutine file_base_meshfield_put_global_attribute_time
 
  !- private -----------------------------------------
 
  subroutine def_axes( this, & ! (in)
    fid, dtype               ) ! (in)
    use scale_const, only: &
      undef => const_undef
    use scale_file, only: &
      file_def_axis,                 &
      file_set_attribute,            &
      file_def_associatedcoordinate, &
      file_add_associatedvariable
 
    implicit none
 
    class(filebasemeshfieldcomp), intent(in) :: this
    integer, intent(in) :: fid
 
    character(*), intent(in) :: dtype
    integer :: d
    integer :: i_dtype
    integer :: ndim
    !------------
 
    i_dtype = get_dtype( dtype )
 
    select case ( this%mesh_type_id )
    case ( meshtype_1d )
      ndim = 1
    case ( meshtype_2d_rectdom, meshtype_2d_cubedsphere )
      ndim = 2
    case ( meshtype_3d_cubedom, meshtype_3d_cubedsphere )
      ndim = 3
    end select
 
    !- Define axes
    do d=1, ndim
      call file_def_axis( fid, &
        this%dimsinfo(d)%name, this%dimsinfo(d)%desc, this%dimsinfo(d)%unit, &
        this%dimsinfo(d)%name, i_dtype, this%dimsinfo(d)%size                )
    end do
    return
  end subroutine def_axes
 
  subroutine write_axes( this, & ! (in)
    fid, start                 ) ! (in)
    use scale_const, only: &
      undef => const_undef
    use scale_file, only: &
      file_write_axis, &
      file_set_attribute
    use scale_file_common_meshfield, only: &
      file_common_meshfield_get_axis
    implicit none
 
    class(filebasemeshfieldcomp), intent(in) :: this
    integer, intent(in) :: fid
    integer, intent(in) :: start(3)
 
    real(rp), allocatable :: x(:)
    real(rp), allocatable :: y(:)
    real(rp), allocatable :: z(:)
    !------------
 
    select case ( this%mesh_type_id )
    case ( meshtype_1d ) ! 1D mesh
      allocate( x(this%dimsinfo(1)%size) )
    case ( meshtype_2d_rectdom, meshtype_2d_cubedsphere ) ! 2D mesh
      allocate( x(this%dimsinfo(1)%size), y(this%dimsinfo(2)%size) )
    case ( meshtype_3d_cubedom, meshtype_3d_cubedsphere ) ! 3D mesh
      allocate( x(this%dimsinfo(1)%size), y(this%dimsinfo(2)%size), z(this%dimsinfo(3)%size) )
    end select
 
    !-
    select case ( this%mesh_type_id )
    case ( meshtype_1d )             ! 1D mesh
      call file_common_meshfield_get_axis( this%mesh1D, this%dimsinfo, x(:), this%force_uniform_grid )
    case ( meshtype_2d_rectdom )     ! 2D mesh
      call file_common_meshfield_get_axis( this%mesh2D, this%dimsinfo, x(:), y(:), this%force_uniform_grid )
    case ( meshtype_2d_cubedsphere ) ! 2D mesh
      call file_common_meshfield_get_axis( this%meshCS2D, this%dimsinfo, x(:), y(:) )
    case ( meshtype_3d_cubedom )     ! 3D mesh
      call file_common_meshfield_get_axis( this%mesh3D, this%dimsinfo, x(:), y(:), z(:), this%force_uniform_grid )
    case ( meshtype_3d_cubedsphere ) ! 3D mesh
      call file_common_meshfield_get_axis( this%meshCS3D, this%dimsinfo, x(:), y(:), z(:) )
    end select
 
    !-
    select case ( this%mesh_type_id )
    case ( meshtype_1d ) ! 1D mesh
      call file_write_axis( fid, this%dimsinfo(1)%name, x(:), start(1:1) )
    case ( meshtype_2d_rectdom, meshtype_2d_cubedsphere ) ! 2D mesh
      call file_write_axis( fid, this%dimsinfo(1)%name, x(:), start(1:1) )
      call file_write_axis( fid, this%dimsinfo(2)%name, y(:), start(2:2) )
    case ( meshtype_3d_cubedom, meshtype_3d_cubedsphere ) ! 3D mesh
      call file_write_axis( fid, this%dimsinfo(1)%name, x(:), start(1:1) )
      call file_write_axis( fid, this%dimsinfo(2)%name, y(:), start(2:2) )
      call file_write_axis( fid, this%dimsinfo(3)%name, z(:), start(3:3) )
      if ( this%dimsinfo(3)%positive_down(1) ) &
        call file_set_attribute( fid, this%dimsinfo(3)%name, "positive", "down" )
    end select
 
    return
  end subroutine write_axes
 
!OCL SERIAL
  subroutine file_base_meshfield_get_comp( this, comp_id, & ! (in)
    comp_ptr ) ! (out)
    implicit none
    class(file_base_meshfield), intent(in), target :: this
    integer, intent(in), optional :: comp_id
    type(filebasemeshfieldcomp), intent(out), pointer :: comp_ptr
    !--------------------------------------------------------------
 
    if ( present(comp_id) ) then
      if ( comp_id < 1 .or. comp_id > this%comp_num ) then
        log_error("FILE_base_meshfield_get_comp",*) 'Invalid component ID. Check!'
        call prc_abort
      end if
      comp_ptr => this%comp(comp_id)
    else
      comp_ptr => this%comp(this%main_comp_id)
    end if
    return
  end subroutine file_base_meshfield_get_comp
 
end module scale_file_base_meshfield