35     & varname, array, arraysize, history, range, &
    36     & time, quiet, difftime, timed, time_average_store, err )
    62     character(*), 
intent(in):: varname
    63     integer, 
intent(in):: arraysize
    64     real, 
intent(in):: array(arraysize)
    65     type(
gt_history), 
intent(inout), 
target, 
optional:: history
    66     character(*), 
intent(in), 
optional:: range
    82     real, 
intent(in), 
optional:: time
   104     logical, 
intent(in), 
optional:: quiet
   121     real(DP), 
intent(in), 
optional:: timed
   127     logical, 
intent(in), 
optional:: time_average_store
   144     logical, 
intent(out), 
optional:: err
   158     real, 
target:: array_work(arraysize)
   159     real, 
pointer:: array_work2(:) =>null()
   160     integer:: arraysize_work2
   162     character(STRING):: url, file, time_str
   163     real:: time_value(1:1)
   165     integer, 
allocatable:: start(:), count(:), stride(:)
   166     integer :: i, dims, v_ord
   167     character(STRING):: avr_msg
   169     character(STRING):: time_name
   170     character(*), 
parameter:: bnds_suffix = 
'_bnds'   172     integer:: bnds_ord, time_count, bnds_rank
   174     logical:: output_step
   178     character(STRING):: cause_c
   180       subroutine timegoahead( varname, var, head, history, err )
   183         character(len = *), 
intent(in):: varname
   185         real, 
intent(in):: head
   186         type(
gt_history), 
intent(inout), 
optional, 
target:: history
   187         logical, 
intent(out), 
optional:: err
   190     character(*), 
parameter:: subname = 
"HistoryPutRealEx"   192     call beginsub(subname, 
'varname=%a range=%a', &
   196     if (
present(history)) 
then   205     if ( .not. hst % initialized ) 
then   207       cause_c = 
'GT_HISTORY'   214     if ( ( 
present(time) .or. 
present(difftime) .or. 
present(timed) ) &
   217         & 
'(varname=%c) "range" and "time" or "timed" or "difftime" are not suppored at the same time', &
   218         & c1 = trim(varname) )
   220       cause_c = 
'"range" and "time" or "timed" or "difftime" are not suppored at the same time'   232     if ( 
present(difftime) ) 
then   233       timedw = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   234     elseif ( 
present(timed) ) 
then   236     elseif ( 
present(time) ) 
then   239     if ( v_ord > 0 ) 
then   246       if ( hst % var_avr_count( v_ord ) > -1 ) 
then   251         if (       .not. 
present(time) &
   252           &  .and. .not. 
present(timed) &
   253           &  .and. .not. 
present(difftime) ) 
then   255             & 
'(varname=%c) arguments "time" or "timed" or "difftime" are needed ' // &
   256             & 
'when "time_average=.true." is specified to "HistoryAddVariable"', &
   257             & c1 = trim(varname) )
   269         if ( arraysize /= hst % var_avr_data( v_ord ) % length ) 
then   271             & 
'(varname=%c) size of array should be (%d). size of array is (%d)', &
   272             & i = (/hst % var_avr_data( v_ord ) % length, arraysize/), &
   273             & c1 = trim(varname) )
   289         if ( hst % var_avr_firstput( v_ord ) ) 
then   290           if ( hst % var_avr_count( v_ord ) == 0 ) 
then   292             hst % var_avr_prevtime( v_ord ) = timedw
   294             hst % var_avr_baseint( v_ord ) = &
   295               & timedw - hst % var_avr_prevtime( v_ord )
   297             hst % var_avr_prevtime( v_ord ) = timedw
   298             hst % var_avr_firstput( v_ord ) = .false.
   308           if ( hst % var_avr_count( v_ord ) == 0 ) 
then   309             hst % var_avr_baseint( v_ord ) = &
   310               & timedw - hst % var_avr_prevtime( v_ord )
   312             hst % var_avr_prevtime( v_ord ) = timedw
   319             avr_coef = ( timedw - hst % var_avr_prevtime( v_ord ) ) &
   320               &          / hst % var_avr_baseint( v_ord )
   321             hst % var_avr_prevtime( v_ord ) = timedw
   327         hst % var_avr_data( v_ord ) % a_DataAvr = &
   328           & hst % var_avr_data( v_ord ) % a_DataAvr + array * avr_coef
   333         hst % var_avr_count( v_ord ) = &
   334           & hst % var_avr_count( v_ord ) + 1
   335         hst % var_avr_coefsum( v_ord ) = &
   336           & hst % var_avr_coefsum( v_ord ) + avr_coef
   340         if ( 
present(difftime) ) 
then   341           hst % time_bnds(2:2) = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   342         elseif ( 
present (timed) ) 
then   343           hst % time_bnds(2:2) = timed
   345           hst % time_bnds(2:2) = time
   353     if ( .not. hst % origin_setting ) 
then   354       if ( 
present(difftime) ) 
then   355         hst % origin         = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   356         hst % time_bnds      = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   357         hst % origin_setting = .true.
   358       elseif ( 
present(timed) ) 
then   360         hst % time_bnds      = timed
   361         hst % origin_setting = .true.
   362       elseif ( 
present(time) ) 
then   364         hst % time_bnds      = time
   365         hst % origin_setting = .true.
   391       output_step = .false.
   392     elseif ( 
present(difftime) .or. 
present(timed) .or. 
present(time) ) 
then   393       output_step = .false.
   394       if ( hst % interval == 0 ) 
then   397         if ( 
mod( timedw - hst % origin, hst % interval ) == 0 ) 
then   405     if ( .not. output_step ) 
then   410       if ( v_ord > 0 ) 
then   411         if ( hst % var_avr_count( v_ord ) > -1 ) 
then   413             avr_msg = 
'(time average of ' // trim( 
tochar(hst % var_avr_count( v_ord )) ) // 
' step data)'   422             & ( hst % var_avr_data( v_ord ) % a_DataAvr ) / ( hst % var_avr_coefsum( v_ord ) )
   425           hst % var_avr_data( v_ord ) % a_DataAvr = 0.0
   426           hst % var_avr_count( v_ord ) = 0
   427           hst % var_avr_coefsum( v_ord ) = 0.0_dp
   428           hst % var_avr_firstput( v_ord ) = .false.
   432     array_work2 => array_work
   433     arraysize_work2 = arraysize
   439       & varname = varname, &     
   440                           & head = 
real(array_work2(1)), & 
   442       & history = history, &     
   447       call dbgmessage(
'varname=<%c> has no dimension. so range is ignoread.', &
   452       call put(var, array_work2, arraysize_work2)
   457       allocate(start(dims), count(dims), stride(dims))
   459         call get_slice(var, i, start(i), count(i), stride(i))
   462       call slice(var, range, slice_err)
   463       call put(var, array_work2, arraysize_work2)
   466         call slice(var, i, start(i), count(i), stride(i))
   468       deallocate(start, count, stride)
   471     if ( hst % mpi_gather .and. v_ord > 0 ) 
then   472       deallocate( array_work2 )
   478     if ( v_ord > 0 ) 
then   479       if ( hst % var_avr_count( v_ord ) > -1 ) 
then   483         timevar = hst % dimvars( hst % unlimited_index )
   493         call open( var = bndsvar, &
   494           & url = 
urlmerge(file=file, var=trim(time_name) // bnds_suffix) )
   503         if ( bnds_rank > 1 ) 
then   506             & dimord = hst % growable_indices(bnds_ord), & 
   507             & allcount = time_count )                      
   509         if  ( (hst % time_bnds_output_count < 1) &
   510           &  .or. (hst % time_bnds_output_count < time_count) ) 
then   511           call slice(bndsvar, hst % growable_indices(bnds_ord), & 
   512             & start=hst % time_bnds_output_count+1, count=1)        
   513           call put(bndsvar, hst % time_bnds, 2)
   514           hst % time_bnds_output_count = hst % time_bnds_output_count + 1
   516         call close( var = bndsvar ) 
   517         if ( 
present(difftime) ) 
then   518           hst % time_bnds(1:1) = &
   519             & 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   520         elseif ( 
present(timed) ) 
then   521           hst % time_bnds(1:1) = timed
   523           hst % time_bnds(1:1) = time
   532       call inquire( hst % dimvars(1), & 
   536       if ( hst % unlimited_index < 1 ) 
then   539         timevar = hst % dimvars(hst % unlimited_index)
   540         call slice( timevar, &                     
   541           & 1, start = hst % count(v_ord), count = 1 ) 
   546         time_str = 
'(time=' // trim( 
tochar( time_value(1) )) // 
')'   549         & 
'"%a" => "%a" %a %a', &
   550         & ca = 
stoa( varname, file, time_str, avr_msg ) )
   557     call storeerror( stat, subname, err, cause_c )
   561     & varname, array, arraysize, history, range, &
   562     & time, quiet, difftime, timed, time_average_store, err )
   588     character(*), 
intent(in):: varname
   589     integer, 
intent(in):: arraysize
   590     real(DP), 
intent(in):: array(arraysize)
   591     type(
gt_history), 
intent(inout), 
target, 
optional:: history
   592     character(*), 
intent(in), 
optional:: range
   608     real, 
intent(in), 
optional:: time
   630     logical, 
intent(in), 
optional:: quiet
   647     real(DP), 
intent(in), 
optional:: timed
   653     logical, 
intent(in), 
optional:: time_average_store
   670     logical, 
intent(out), 
optional:: err
   684     real(DP), 
target:: array_work(arraysize)
   685     real(DP), 
pointer:: array_work2(:) =>null()
   686     integer:: arraysize_work2
   688     character(STRING):: url, file, time_str
   689     real:: time_value(1:1)
   691     integer, 
allocatable:: start(:), count(:), stride(:)
   692     integer :: i, dims, v_ord
   693     character(STRING):: avr_msg
   695     character(STRING):: time_name
   696     character(*), 
parameter:: bnds_suffix = 
'_bnds'   698     integer:: bnds_ord, time_count, bnds_rank
   700     logical:: output_step
   704     character(STRING):: cause_c
   706       subroutine timegoahead( varname, var, head, history, err )
   709         character(len = *), 
intent(in):: varname
   711         real, 
intent(in):: head
   712         type(
gt_history), 
intent(inout), 
optional, 
target:: history
   713         logical, 
intent(out), 
optional:: err
   716     character(*), 
parameter:: subname = 
"HistoryPutDoubleEx"   718     call beginsub(subname, 
'varname=%a range=%a', &
   722     if (
present(history)) 
then   731     if ( .not. hst % initialized ) 
then   733       cause_c = 
'GT_HISTORY'   740     if ( ( 
present(time) .or. 
present(difftime) .or. 
present(timed) ) &
   743         & 
'(varname=%c) "range" and "time" or "timed" or "difftime" are not suppored at the same time', &
   744         & c1 = trim(varname) )
   746       cause_c = 
'"range" and "time" or "timed" or "difftime" are not suppored at the same time'   758     if ( 
present(difftime) ) 
then   759       timedw = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   760     elseif ( 
present(timed) ) 
then   762     elseif ( 
present(time) ) 
then   765     if ( v_ord > 0 ) 
then   772       if ( hst % var_avr_count( v_ord ) > -1 ) 
then   777         if (       .not. 
present(time) &
   778           &  .and. .not. 
present(timed) &
   779           &  .and. .not. 
present(difftime) ) 
then   781             & 
'(varname=%c) arguments "time" or "timed" or "difftime" are needed ' // &
   782             & 
'when "time_average=.true." is specified to "HistoryAddVariable"', &
   783             & c1 = trim(varname) )
   795         if ( arraysize /= hst % var_avr_data( v_ord ) % length ) 
then   797             & 
'(varname=%c) size of array should be (%d). size of array is (%d)', &
   798             & i = (/hst % var_avr_data( v_ord ) % length, arraysize/), &
   799             & c1 = trim(varname) )
   815         if ( hst % var_avr_firstput( v_ord ) ) 
then   816           if ( hst % var_avr_count( v_ord ) == 0 ) 
then   818             hst % var_avr_prevtime( v_ord ) = timedw
   820             hst % var_avr_baseint( v_ord ) = &
   821               & timedw - hst % var_avr_prevtime( v_ord )
   823             hst % var_avr_prevtime( v_ord ) = timedw
   824             hst % var_avr_firstput( v_ord ) = .false.
   834           if ( hst % var_avr_count( v_ord ) == 0 ) 
then   835             hst % var_avr_baseint( v_ord ) = &
   836               & timedw - hst % var_avr_prevtime( v_ord )
   838             hst % var_avr_prevtime( v_ord ) = timedw
   845             avr_coef = ( timedw - hst % var_avr_prevtime( v_ord ) ) &
   846               &          / hst % var_avr_baseint( v_ord )
   847             hst % var_avr_prevtime( v_ord ) = timedw
   853         hst % var_avr_data( v_ord ) % a_DataAvr = &
   854           & hst % var_avr_data( v_ord ) % a_DataAvr + array * avr_coef
   859         hst % var_avr_count( v_ord ) = &
   860           & hst % var_avr_count( v_ord ) + 1
   861         hst % var_avr_coefsum( v_ord ) = &
   862           & hst % var_avr_coefsum( v_ord ) + avr_coef
   866         if ( 
present(difftime) ) 
then   867           hst % time_bnds(2:2) = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   868         elseif ( 
present (timed) ) 
then   869           hst % time_bnds(2:2) = timed
   871           hst % time_bnds(2:2) = time
   879     if ( .not. hst % origin_setting ) 
then   880       if ( 
present(difftime) ) 
then   881         hst % origin         = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   882         hst % time_bnds      = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
   883         hst % origin_setting = .true.
   884       elseif ( 
present(timed) ) 
then   886         hst % time_bnds      = timed
   887         hst % origin_setting = .true.
   888       elseif ( 
present(time) ) 
then   890         hst % time_bnds      = time
   891         hst % origin_setting = .true.
   917       output_step = .false.
   918     elseif ( 
present(difftime) .or. 
present(timed) .or. 
present(time) ) 
then   919       output_step = .false.
   920       if ( hst % interval == 0 ) 
then   923         if ( 
mod( timedw - hst % origin, hst % interval ) == 0 ) 
then   931     if ( .not. output_step ) 
then   936       if ( v_ord > 0 ) 
then   937         if ( hst % var_avr_count( v_ord ) > -1 ) 
then   939             avr_msg = 
'(time average of ' // trim( 
tochar(hst % var_avr_count( v_ord )) ) // 
' step data)'   948             & ( hst % var_avr_data( v_ord ) % a_DataAvr ) / ( hst % var_avr_coefsum( v_ord ) )
   951           hst % var_avr_data( v_ord ) % a_DataAvr = 0.0
   952           hst % var_avr_count( v_ord ) = 0
   953           hst % var_avr_coefsum( v_ord ) = 0.0_dp
   954           hst % var_avr_firstput( v_ord ) = .false.
   958     array_work2 => array_work
   959     arraysize_work2 = arraysize
   965       & varname = varname, &     
   966                           & head = 
real(array_work2(1)), & 
   968       & history = history, &     
   973       call dbgmessage(
'varname=<%c> has no dimension. so range is ignoread.', &
   978       call put(var, array_work2, arraysize_work2)
   983       allocate(start(dims), count(dims), stride(dims))
   985         call get_slice(var, i, start(i), count(i), stride(i))
   988       call slice(var, range, slice_err)
   989       call put(var, array_work2, arraysize_work2)
   992         call slice(var, i, start(i), count(i), stride(i))
   994       deallocate(start, count, stride)
   997     if ( hst % mpi_gather .and. v_ord > 0 ) 
then   998       deallocate( array_work2 )
  1004     if ( v_ord > 0 ) 
then  1005       if ( hst % var_avr_count( v_ord ) > -1 ) 
then  1009         timevar = hst % dimvars( hst % unlimited_index )
  1013           & name = time_name ) 
  1019         call open( var = bndsvar, &
  1020           & url = 
urlmerge(file=file, var=trim(time_name) // bnds_suffix) )
  1027           & rank = bnds_rank )                      
  1029         if ( bnds_rank > 1 ) 
then  1032             & dimord = hst % growable_indices(bnds_ord), & 
  1033             & allcount = time_count )                      
  1035         if  ( (hst % time_bnds_output_count < 1) &
  1036           &  .or. (hst % time_bnds_output_count < time_count) ) 
then  1037           call slice(bndsvar, hst % growable_indices(bnds_ord), & 
  1038             & start=hst % time_bnds_output_count+1, count=1)        
  1039           call put(bndsvar, hst % time_bnds, 2)
  1040           hst % time_bnds_output_count = hst % time_bnds_output_count + 1
  1042         call close( var = bndsvar ) 
  1043         if ( 
present(difftime) ) 
then  1044           hst % time_bnds(1:1) = &
  1045             & 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1046         elseif ( 
present(timed) ) 
then  1047           hst % time_bnds(1:1) = timed
  1049           hst % time_bnds(1:1) = time
  1058       call inquire( hst % dimvars(1), & 
  1062       if ( hst % unlimited_index < 1 ) 
then  1065         timevar = hst % dimvars(hst % unlimited_index)
  1066         call slice( timevar, &                     
  1067           & 1, start = hst % count(v_ord), count = 1 ) 
  1068         call get( timevar, & 
  1072         time_str = 
'(time=' // trim( 
tochar( time_value(1) )) // 
')'  1075         & 
'"%a" => "%a" %a %a', &
  1076         & ca = 
stoa( varname, file, time_str, avr_msg ) )
  1083     call storeerror( stat, subname, err, cause_c )
  1087     & varname, array, arraysize, history, range, &
  1088     & time, quiet, difftime, timed, time_average_store, err )
  1114     character(*), 
intent(in):: varname
  1115     integer, 
intent(in):: arraysize
  1116     integer, 
intent(in):: array(arraysize)
  1117     type(
gt_history), 
intent(inout), 
target, 
optional:: history
  1118     character(*), 
intent(in), 
optional:: range
  1134     real, 
intent(in), 
optional:: time
  1156     logical, 
intent(in), 
optional:: quiet
  1167     type(
dc_difftime), 
intent(in), 
optional:: difftime
  1173     real(DP), 
intent(in), 
optional:: timed
  1179     logical, 
intent(in), 
optional:: time_average_store
  1196     logical, 
intent(out), 
optional:: err
  1210     integer, 
target:: array_work(arraysize)
  1211     integer, 
pointer:: array_work2(:) =>null()
  1212     integer:: arraysize_work2
  1214     character(STRING):: url, file, time_str
  1215     real:: time_value(1:1)
  1217     integer, 
allocatable:: start(:), count(:), stride(:)
  1218     integer :: i, dims, v_ord
  1219     character(STRING):: avr_msg
  1220     logical :: slice_err
  1221     character(STRING):: time_name
  1222     character(*), 
parameter:: bnds_suffix = 
'_bnds'  1224     integer:: bnds_ord, time_count, bnds_rank
  1226     logical:: output_step
  1230     character(STRING):: cause_c
  1232       subroutine timegoahead( varname, var, head, history, err )
  1235         character(len = *), 
intent(in):: varname
  1237         real, 
intent(in):: head
  1238         type(
gt_history), 
intent(inout), 
optional, 
target:: history
  1239         logical, 
intent(out), 
optional:: err
  1242     character(*), 
parameter:: subname = 
"HistoryPutIntEx"  1244     call beginsub(subname, 
'varname=%a range=%a', &
  1248     if (
present(history)) 
then  1257     if ( .not. hst % initialized ) 
then  1259       cause_c = 
'GT_HISTORY'  1266     if ( ( 
present(time) .or. 
present(difftime) .or. 
present(timed) ) &
  1269         & 
'(varname=%c) "range" and "time" or "timed" or "difftime" are not suppored at the same time', &
  1270         & c1 = trim(varname) )
  1272       cause_c = 
'"range" and "time" or "timed" or "difftime" are not suppored at the same time'  1284     if ( 
present(difftime) ) 
then  1285       timedw = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1286     elseif ( 
present(timed) ) 
then  1288     elseif ( 
present(time) ) 
then  1291     if ( v_ord > 0 ) 
then  1298       if ( hst % var_avr_count( v_ord ) > -1 ) 
then  1303         if (       .not. 
present(time) &
  1304           &  .and. .not. 
present(timed) &
  1305           &  .and. .not. 
present(difftime) ) 
then  1307             & 
'(varname=%c) arguments "time" or "timed" or "difftime" are needed ' // &
  1308             & 
'when "time_average=.true." is specified to "HistoryAddVariable"', &
  1309             & c1 = trim(varname) )
  1321         if ( arraysize /= hst % var_avr_data( v_ord ) % length ) 
then  1323             & 
'(varname=%c) size of array should be (%d). size of array is (%d)', &
  1324             & i = (/hst % var_avr_data( v_ord ) % length, arraysize/), &
  1325             & c1 = trim(varname) )
  1341         if ( hst % var_avr_firstput( v_ord ) ) 
then  1342           if ( hst % var_avr_count( v_ord ) == 0 ) 
then  1344             hst % var_avr_prevtime( v_ord ) = timedw
  1346             hst % var_avr_baseint( v_ord ) = &
  1347               & timedw - hst % var_avr_prevtime( v_ord )
  1349             hst % var_avr_prevtime( v_ord ) = timedw
  1350             hst % var_avr_firstput( v_ord ) = .false.
  1360           if ( hst % var_avr_count( v_ord ) == 0 ) 
then  1361             hst % var_avr_baseint( v_ord ) = &
  1362               & timedw - hst % var_avr_prevtime( v_ord )
  1364             hst % var_avr_prevtime( v_ord ) = timedw
  1371             avr_coef = ( timedw - hst % var_avr_prevtime( v_ord ) ) &
  1372               &          / hst % var_avr_baseint( v_ord )
  1373             hst % var_avr_prevtime( v_ord ) = timedw
  1379         hst % var_avr_data( v_ord ) % a_DataAvr = &
  1380           & hst % var_avr_data( v_ord ) % a_DataAvr + array * avr_coef
  1385         hst % var_avr_count( v_ord ) = &
  1386           & hst % var_avr_count( v_ord ) + 1
  1387         hst % var_avr_coefsum( v_ord ) = &
  1388           & hst % var_avr_coefsum( v_ord ) + avr_coef
  1392         if ( 
present(difftime) ) 
then  1393           hst % time_bnds(2:2) = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1394         elseif ( 
present (timed) ) 
then  1395           hst % time_bnds(2:2) = timed
  1397           hst % time_bnds(2:2) = time
  1405     if ( .not. hst % origin_setting ) 
then  1406       if ( 
present(difftime) ) 
then  1407         hst % origin         = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1408         hst % time_bnds      = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1409         hst % origin_setting = .true.
  1410       elseif ( 
present(timed) ) 
then  1411         hst % origin         = timed
  1412         hst % time_bnds      = timed
  1413         hst % origin_setting = .true.
  1414       elseif ( 
present(time) ) 
then  1416         hst % time_bnds      = time
  1417         hst % origin_setting = .true.
  1439     output_step = .true.
  1441       output_step = .true.
  1443       output_step = .false.
  1444     elseif ( 
present(difftime) .or. 
present(timed) .or. 
present(time) ) 
then  1445       output_step = .false.
  1446       if ( hst % interval == 0 ) 
then  1447         output_step = .true.
  1449         if ( 
mod( timedw - hst % origin, hst % interval ) == 0 ) 
then  1450           output_step = .true.
  1457     if ( .not. output_step ) 
then  1462       if ( v_ord > 0 ) 
then  1463         if ( hst % var_avr_count( v_ord ) > -1 ) 
then  1465             avr_msg = 
'(time average of ' // trim( 
tochar(hst % var_avr_count( v_ord )) ) // 
' step data)'  1474             & ( hst % var_avr_data( v_ord ) % a_DataAvr ) / ( hst % var_avr_coefsum( v_ord ) )
  1477           hst % var_avr_data( v_ord ) % a_DataAvr = 0.0
  1478           hst % var_avr_count( v_ord ) = 0
  1479           hst % var_avr_coefsum( v_ord ) = 0.0_dp
  1480           hst % var_avr_firstput( v_ord ) = .false.
  1484     array_work2 => array_work
  1485     arraysize_work2 = arraysize
  1491       & varname = varname, &     
  1492                           & head = 
real(array_work2(1)), & 
  1494       & history = history, &     
  1496     call Inquire( var, & 
  1499       call dbgmessage(
'varname=<%c> has no dimension. so range is ignoread.', &
  1504       call put(var, array_work2, arraysize_work2)
  1509       allocate(start(dims), count(dims), stride(dims))
  1511         call get_slice(var, i, start(i), count(i), stride(i))
  1514       call slice(var, range, slice_err)
  1515       call put(var, array_work2, arraysize_work2)
  1518         call slice(var, i, start(i), count(i), stride(i))
  1520       deallocate(start, count, stride)
  1523     if ( hst % mpi_gather .and. v_ord > 0 ) 
then  1524       deallocate( array_work2 )
  1530     if ( v_ord > 0 ) 
then  1531       if ( hst % var_avr_count( v_ord ) > -1 ) 
then  1535         timevar = hst % dimvars( hst % unlimited_index )
  1539           & name = time_name ) 
  1545         call open( var = bndsvar, &
  1546           & url = 
urlmerge(file=file, var=trim(time_name) // bnds_suffix) )
  1553           & rank = bnds_rank )                      
  1555         if ( bnds_rank > 1 ) 
then  1558             & dimord = hst % growable_indices(bnds_ord), & 
  1559             & allcount = time_count )                      
  1561         if  ( (hst % time_bnds_output_count < 1) &
  1562           &  .or. (hst % time_bnds_output_count < time_count) ) 
then  1563           call slice(bndsvar, hst % growable_indices(bnds_ord), & 
  1564             & start=hst % time_bnds_output_count+1, count=1)        
  1565           call put(bndsvar, hst % time_bnds, 2)
  1566           hst % time_bnds_output_count = hst % time_bnds_output_count + 1
  1568         call close( var = bndsvar ) 
  1569         if ( 
present(difftime) ) 
then  1570           hst % time_bnds(1:1) = &
  1571             & 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1572         elseif ( 
present(timed) ) 
then  1573           hst % time_bnds(1:1) = timed
  1575           hst % time_bnds(1:1) = time
  1584       call inquire( hst % dimvars(1), & 
  1588       if ( hst % unlimited_index < 1 ) 
then  1591         timevar = hst % dimvars(hst % unlimited_index)
  1592         call slice( timevar, &                     
  1593           & 1, start = hst % count(v_ord), count = 1 ) 
  1594         call get( timevar, & 
  1598         time_str = 
'(time=' // trim( 
tochar( time_value(1) )) // 
')'  1601         & 
'"%a" => "%a" %a %a', &
  1602         & ca = 
stoa( varname, file, time_str, avr_msg ) )
  1609     call storeerror( stat, subname, err, cause_c )
  1613     & varname, array, arraysize, history, range, &
  1614     & time, quiet, difftime, timed, time_average_store, err )
  1640     character(*), 
intent(in):: varname
  1641     integer, 
intent(in):: arraysize
  1642     character(*), 
intent(in):: array(arraysize)
  1643     type(
gt_history), 
intent(inout), 
target, 
optional:: history
  1644     character(*), 
intent(in), 
optional:: range
  1660     real, 
intent(in), 
optional:: time
  1682     logical, 
intent(in), 
optional:: quiet
  1693     type(
dc_difftime), 
intent(in), 
optional:: difftime
  1699     real(DP), 
intent(in), 
optional:: timed
  1705     logical, 
intent(in), 
optional:: time_average_store
  1722     logical, 
intent(out), 
optional:: err
  1736     character(STRING), 
target:: array_work(arraysize)
  1737     character(STRING), 
pointer:: array_work2(:) =>null()
  1738     integer:: arraysize_work2
  1740     character(STRING):: url, file, time_str
  1741     real:: time_value(1:1)
  1743     integer, 
allocatable:: start(:), count(:), stride(:)
  1744     integer :: i, dims, v_ord
  1745     character(STRING):: avr_msg
  1746     logical :: slice_err
  1747     character(STRING):: time_name
  1748     character(*), 
parameter:: bnds_suffix = 
'_bnds'  1750     integer:: bnds_ord, time_count, bnds_rank
  1752     logical:: output_step
  1756     character(STRING):: cause_c
  1758       subroutine timegoahead( varname, var, head, history, err )
  1761         character(len = *), 
intent(in):: varname
  1763         real, 
intent(in):: head
  1764         type(
gt_history), 
intent(inout), 
optional, 
target:: history
  1765         logical, 
intent(out), 
optional:: err
  1768     character(*), 
parameter:: subname = 
"HistoryPutCharEx"  1770     call beginsub(subname, 
'varname=%a range=%a', &
  1774     if (
present(history)) 
then  1783     if ( .not. hst % initialized ) 
then  1785       cause_c = 
'GT_HISTORY'  1792     if ( ( 
present(time) .or. 
present(difftime) .or. 
present(timed) ) &
  1795         & 
'(varname=%c) "range" and "time" or "timed" or "difftime" are not suppored at the same time', &
  1796         & c1 = trim(varname) )
  1798       cause_c = 
'"range" and "time" or "timed" or "difftime" are not suppored at the same time'  1810     if ( .not. hst % origin_setting ) 
then  1811       if ( 
present(difftime) ) 
then  1812         hst % origin         = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1813         hst % time_bnds      = 
evalbyunit( difftime, 
'', hst % unlimited_units_symbol )
  1814         hst % origin_setting = .true.
  1815       elseif ( 
present(timed) ) 
then  1816         hst % origin         = timed
  1817         hst % time_bnds      = timed
  1818         hst % origin_setting = .true.
  1819       elseif ( 
present(time) ) 
then  1821         hst % time_bnds      = time
  1822         hst % origin_setting = .true.
  1846       & varname = varname, &     
  1849       & history = history, &     
  1852       call dbgmessage(
'varname=<%c> is string. so range is ignoread.', &
  1855     call put(var, array, arraysize)
  1862       call inquire( hst % dimvars(1), & 
  1866       if ( hst % unlimited_index < 1 ) 
then  1869         timevar = hst % dimvars(hst % unlimited_index)
  1870         call slice( timevar, &                     
  1871           & 1, start = hst % count(v_ord), count = 1 ) 
  1872         call get( timevar, & 
  1876         time_str = 
'(time=' // trim( 
tochar( time_value(1) )) // 
')'  1879         & 
'"%a" => "%a" %a %a', &
  1880         & ca = 
stoa( varname, file, time_str, avr_msg ) )
  1887     call storeerror( stat, subname, err, cause_c )
  1926     character(*), 
intent(in):: varname
  1927     real, 
intent(in):: array(:)
  1928     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  1929     logical, 
intent(out), 
optional:: err
  1931     character(STRING):: cause_c
  1932     character(*), 
parameter:: subname = 
"HistoryPutAxisMPIReal"  1934     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  1937     call dbgmessage(
'This library is not built with MPI library')
  1943     call storeerror( stat, subname, err, cause_c )
  1982     character(*), 
intent(in):: varname
  1994     real(DP), 
intent(in):: array(:)
  1998     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2013     logical, 
intent(out), 
optional:: err
  2028     character(STRING):: cause_c
  2029     character(*), 
parameter:: subname = 
"HistoryPutAxisMPIDouble"  2031     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  2034     call dbgmessage(
'This library is not built with MPI library')
  2040     call storeerror( stat, subname, err, cause_c )
  2079     character(*), 
intent(in):: varname
  2080     integer, 
intent(in):: array(:)
  2081     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2082     logical, 
intent(out), 
optional:: err
  2084     character(STRING):: cause_c
  2085     character(*), 
parameter:: subname = 
"HistoryPutAxisMPIInt"  2087     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  2090     call dbgmessage(
'This library is not built with MPI library')
  2096     call storeerror( stat, subname, err, cause_c )
  2100     & history, range, time, quiet, &
  2101     & difftime, timed, time_average_store, err )
  2141     character(*), 
intent(in):: varname
  2151     real(DP), 
intent(in):: value
  2162     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2170     character(*), 
intent(in), 
optional:: range
  2186     real, 
intent(in), 
optional:: time
  2212     logical, 
intent(in), 
optional:: quiet
  2219     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2224     real(DP), 
intent(in), 
optional:: timed
  2229     logical, 
intent(in), 
optional:: time_average_store
  2246     logical, 
intent(out), 
optional:: err
  2262         & varname, array, arraysize, history, range, &
  2263         & time, quiet, difftime, timed, time_average_store, err )
  2267         character(*), 
intent(in):: varname
  2268         integer, 
intent(in):: arraysize
  2269         real(DP), 
intent(in):: array(arraysize)
  2270         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2271         character(*), 
intent(in), 
optional:: range
  2272         real, 
intent(in), 
optional:: time
  2273         logical, 
intent(in), 
optional:: quiet
  2274         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2275         real(DP), 
intent(in), 
optional:: timed
  2276         logical, 
intent(in), 
optional:: time_average_store
  2277         logical, 
intent(out), 
optional:: err
  2280     character(*), 
parameter:: subname = 
"HistoryPutDouble0"  2286       & history = history, &     
  2290       & difftime = difftime, &   
  2292       & time_average_store = &
  2293       &    time_average_store, & 
  2298     & history, range, time, quiet, &
  2299     & difftime, timed, time_average_store, err )
  2307     character(*), 
intent(in):: varname
  2308     real(DP), 
intent(in):: array(:)
  2309     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2310     character(*), 
intent(in), 
optional:: range
  2311     real, 
intent(in), 
optional:: time
  2312     logical, 
intent(in), 
optional:: quiet
  2313     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2314     real(DP), 
intent(in), 
optional:: timed
  2315     logical, 
intent(in), 
optional:: time_average_store
  2316     logical, 
intent(out), 
optional:: err
  2319         & varname, array, arraysize, history, range, &
  2320         & time, quiet, difftime, timed, time_average_store, err )
  2324         character(*), 
intent(in):: varname
  2325         integer, 
intent(in):: arraysize
  2326         real(DP), 
intent(in):: array(arraysize)
  2327         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2328         character(*), 
intent(in), 
optional:: range
  2329         real, 
intent(in), 
optional:: time
  2330         logical, 
intent(in), 
optional:: quiet
  2331         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2332         real(DP), 
intent(in), 
optional:: timed
  2333         logical, 
intent(in), 
optional:: time_average_store
  2334         logical, 
intent(out), 
optional:: err
  2337     character(*), 
parameter:: subname = 
"HistoryPutDouble1"  2342       & pack(array, .true.), 
size(array), &   
  2343       & history = history, &     
  2347       & difftime = difftime, &   
  2349       & time_average_store = &
  2350       &    time_average_store, & 
  2355     & history, range, time, quiet, &
  2356     & difftime, timed, time_average_store, err )
  2364     character(*), 
intent(in):: varname
  2365     real(DP), 
intent(in):: array(:,:)
  2366     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2367     character(*), 
intent(in), 
optional:: range
  2368     real, 
intent(in), 
optional:: time
  2369     logical, 
intent(in), 
optional:: quiet
  2370     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2371     real(DP), 
intent(in), 
optional:: timed
  2372     logical, 
intent(in), 
optional:: time_average_store
  2373     logical, 
intent(out), 
optional:: err
  2376         & varname, array, arraysize, history, range, &
  2377         & time, quiet, difftime, timed, time_average_store, err )
  2381         character(*), 
intent(in):: varname
  2382         integer, 
intent(in):: arraysize
  2383         real(DP), 
intent(in):: array(arraysize)
  2384         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2385         character(*), 
intent(in), 
optional:: range
  2386         real, 
intent(in), 
optional:: time
  2387         logical, 
intent(in), 
optional:: quiet
  2388         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2389         real(DP), 
intent(in), 
optional:: timed
  2390         logical, 
intent(in), 
optional:: time_average_store
  2391         logical, 
intent(out), 
optional:: err
  2394     character(*), 
parameter:: subname = 
"HistoryPutDouble2"  2399       & pack(array, .true.), 
size(array), &   
  2400       & history = history, &     
  2404       & difftime = difftime, &   
  2406       & time_average_store = &
  2407       &    time_average_store, & 
  2412     & history, range, time, quiet, &
  2413     & difftime, timed, time_average_store, err )
  2421     character(*), 
intent(in):: varname
  2422     real(DP), 
intent(in):: array(:,:,:)
  2423     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2424     character(*), 
intent(in), 
optional:: range
  2425     real, 
intent(in), 
optional:: time
  2426     logical, 
intent(in), 
optional:: quiet
  2427     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2428     real(DP), 
intent(in), 
optional:: timed
  2429     logical, 
intent(in), 
optional:: time_average_store
  2430     logical, 
intent(out), 
optional:: err
  2433         & varname, array, arraysize, history, range, &
  2434         & time, quiet, difftime, timed, time_average_store, err )
  2438         character(*), 
intent(in):: varname
  2439         integer, 
intent(in):: arraysize
  2440         real(DP), 
intent(in):: array(arraysize)
  2441         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2442         character(*), 
intent(in), 
optional:: range
  2443         real, 
intent(in), 
optional:: time
  2444         logical, 
intent(in), 
optional:: quiet
  2445         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2446         real(DP), 
intent(in), 
optional:: timed
  2447         logical, 
intent(in), 
optional:: time_average_store
  2448         logical, 
intent(out), 
optional:: err
  2451     character(*), 
parameter:: subname = 
"HistoryPutDouble3"  2456       & pack(array, .true.), 
size(array), &   
  2457       & history = history, &     
  2461       & difftime = difftime, &   
  2463       & time_average_store = &
  2464       &    time_average_store, & 
  2469     & history, range, time, quiet, &
  2470     & difftime, timed, time_average_store, err )
  2478     character(*), 
intent(in):: varname
  2479     real(DP), 
intent(in):: array(:,:,:,:)
  2480     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2481     character(*), 
intent(in), 
optional:: range
  2482     real, 
intent(in), 
optional:: time
  2483     logical, 
intent(in), 
optional:: quiet
  2484     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2485     real(DP), 
intent(in), 
optional:: timed
  2486     logical, 
intent(in), 
optional:: time_average_store
  2487     logical, 
intent(out), 
optional:: err
  2490         & varname, array, arraysize, history, range, &
  2491         & time, quiet, difftime, timed, time_average_store, err )
  2495         character(*), 
intent(in):: varname
  2496         integer, 
intent(in):: arraysize
  2497         real(DP), 
intent(in):: array(arraysize)
  2498         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2499         character(*), 
intent(in), 
optional:: range
  2500         real, 
intent(in), 
optional:: time
  2501         logical, 
intent(in), 
optional:: quiet
  2502         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2503         real(DP), 
intent(in), 
optional:: timed
  2504         logical, 
intent(in), 
optional:: time_average_store
  2505         logical, 
intent(out), 
optional:: err
  2508     character(*), 
parameter:: subname = 
"HistoryPutDouble4"  2513       & pack(array, .true.), 
size(array), &   
  2514       & history = history, &     
  2518       & difftime = difftime, &   
  2520       & time_average_store = &
  2521       &    time_average_store, & 
  2526     & history, range, time, quiet, &
  2527     & difftime, timed, time_average_store, err )
  2535     character(*), 
intent(in):: varname
  2536     real(DP), 
intent(in):: array(:,:,:,:,:)
  2537     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2538     character(*), 
intent(in), 
optional:: range
  2539     real, 
intent(in), 
optional:: time
  2540     logical, 
intent(in), 
optional:: quiet
  2541     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2542     real(DP), 
intent(in), 
optional:: timed
  2543     logical, 
intent(in), 
optional:: time_average_store
  2544     logical, 
intent(out), 
optional:: err
  2547         & varname, array, arraysize, history, range, &
  2548         & time, quiet, difftime, timed, time_average_store, err )
  2552         character(*), 
intent(in):: varname
  2553         integer, 
intent(in):: arraysize
  2554         real(DP), 
intent(in):: array(arraysize)
  2555         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2556         character(*), 
intent(in), 
optional:: range
  2557         real, 
intent(in), 
optional:: time
  2558         logical, 
intent(in), 
optional:: quiet
  2559         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2560         real(DP), 
intent(in), 
optional:: timed
  2561         logical, 
intent(in), 
optional:: time_average_store
  2562         logical, 
intent(out), 
optional:: err
  2565     character(*), 
parameter:: subname = 
"HistoryPutDouble5"  2570       & pack(array, .true.), 
size(array), &   
  2571       & history = history, &     
  2575       & difftime = difftime, &   
  2577       & time_average_store = &
  2578       &    time_average_store, & 
  2583     & history, range, time, quiet, &
  2584     & difftime, timed, time_average_store, err )
  2592     character(*), 
intent(in):: varname
  2593     real(DP), 
intent(in):: array(:,:,:,:,:,:)
  2594     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2595     character(*), 
intent(in), 
optional:: range
  2596     real, 
intent(in), 
optional:: time
  2597     logical, 
intent(in), 
optional:: quiet
  2598     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2599     real(DP), 
intent(in), 
optional:: timed
  2600     logical, 
intent(in), 
optional:: time_average_store
  2601     logical, 
intent(out), 
optional:: err
  2604         & varname, array, arraysize, history, range, &
  2605         & time, quiet, difftime, timed, time_average_store, err )
  2609         character(*), 
intent(in):: varname
  2610         integer, 
intent(in):: arraysize
  2611         real(DP), 
intent(in):: array(arraysize)
  2612         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2613         character(*), 
intent(in), 
optional:: range
  2614         real, 
intent(in), 
optional:: time
  2615         logical, 
intent(in), 
optional:: quiet
  2616         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2617         real(DP), 
intent(in), 
optional:: timed
  2618         logical, 
intent(in), 
optional:: time_average_store
  2619         logical, 
intent(out), 
optional:: err
  2622     character(*), 
parameter:: subname = 
"HistoryPutDouble6"  2627       & pack(array, .true.), 
size(array), &   
  2628       & history = history, &     
  2632       & difftime = difftime, &   
  2634       & time_average_store = &
  2635       &    time_average_store, & 
  2640     & history, range, time, quiet, &
  2641     & difftime, timed, time_average_store, err )
  2649     character(*), 
intent(in):: varname
  2650     real(DP), 
intent(in):: array(:,:,:,:,:,:,:)
  2651     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2652     character(*), 
intent(in), 
optional:: range
  2653     real, 
intent(in), 
optional:: time
  2654     logical, 
intent(in), 
optional:: quiet
  2655     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2656     real(DP), 
intent(in), 
optional:: timed
  2657     logical, 
intent(in), 
optional:: time_average_store
  2658     logical, 
intent(out), 
optional:: err
  2661         & varname, array, arraysize, history, range, &
  2662         & time, quiet, difftime, timed, time_average_store, err )
  2666         character(*), 
intent(in):: varname
  2667         integer, 
intent(in):: arraysize
  2668         real(DP), 
intent(in):: array(arraysize)
  2669         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2670         character(*), 
intent(in), 
optional:: range
  2671         real, 
intent(in), 
optional:: time
  2672         logical, 
intent(in), 
optional:: quiet
  2673         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2674         real(DP), 
intent(in), 
optional:: timed
  2675         logical, 
intent(in), 
optional:: time_average_store
  2676         logical, 
intent(out), 
optional:: err
  2679     character(*), 
parameter:: subname = 
"HistoryPutDouble7"  2684       & pack(array, .true.), 
size(array), &   
  2685       & history = history, &     
  2689       & difftime = difftime, &   
  2691       & time_average_store = &
  2692       &    time_average_store, & 
  2697     & history, range, time, quiet, &
  2698     & difftime, timed, time_average_store, err )
  2706     character(*), 
intent(in):: varname
  2707     real, 
intent(in):: value
  2708     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2709     character(*), 
intent(in), 
optional:: range
  2710     real, 
intent(in), 
optional:: time
  2711     logical, 
intent(in), 
optional:: quiet
  2712     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2713     real(DP), 
intent(in), 
optional:: timed
  2714     logical, 
intent(in), 
optional:: time_average_store
  2715     logical, 
intent(out), 
optional:: err
  2718         & varname, array, arraysize, history, range, &
  2719         & time, quiet, difftime, timed, time_average_store, err )
  2723         character(*), 
intent(in):: varname
  2724         integer, 
intent(in):: arraysize
  2725         real, 
intent(in):: array(arraysize)
  2726         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2727         character(*), 
intent(in), 
optional:: range
  2728         real, 
intent(in), 
optional:: time
  2729         logical, 
intent(in), 
optional:: quiet
  2730         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2731         real(DP), 
intent(in), 
optional:: timed
  2732         logical, 
intent(in), 
optional:: time_average_store
  2733         logical, 
intent(out), 
optional:: err
  2736     character(*), 
parameter:: subname = 
"HistoryPutReal0"  2742       & history = history, &     
  2746       & difftime = difftime, &   
  2748       & time_average_store = &
  2749       &    time_average_store, & 
  2754     & history, range, time, quiet, &
  2755     & difftime, timed, time_average_store, err )
  2763     character(*), 
intent(in):: varname
  2764     real, 
intent(in):: array(:)
  2765     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2766     character(*), 
intent(in), 
optional:: range
  2767     real, 
intent(in), 
optional:: time
  2768     logical, 
intent(in), 
optional:: quiet
  2769     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2770     real(DP), 
intent(in), 
optional:: timed
  2771     logical, 
intent(in), 
optional:: time_average_store
  2772     logical, 
intent(out), 
optional:: err
  2775         & varname, array, arraysize, history, range, &
  2776         & time, quiet, difftime, timed, time_average_store, err )
  2780         character(*), 
intent(in):: varname
  2781         integer, 
intent(in):: arraysize
  2782         real, 
intent(in):: array(arraysize)
  2783         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2784         character(*), 
intent(in), 
optional:: range
  2785         real, 
intent(in), 
optional:: time
  2786         logical, 
intent(in), 
optional:: quiet
  2787         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2788         real(DP), 
intent(in), 
optional:: timed
  2789         logical, 
intent(in), 
optional:: time_average_store
  2790         logical, 
intent(out), 
optional:: err
  2793     character(*), 
parameter:: subname = 
"HistoryPutReal1"  2798       & pack(array, .true.), 
size(array), &   
  2799       & history = history, &     
  2803       & difftime = difftime, &   
  2805       & time_average_store = &
  2806       &    time_average_store, & 
  2811     & history, range, time, quiet, &
  2812     & difftime, timed, time_average_store, err )
  2820     character(*), 
intent(in):: varname
  2821     real, 
intent(in):: array(:,:)
  2822     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2823     character(*), 
intent(in), 
optional:: range
  2824     real, 
intent(in), 
optional:: time
  2825     logical, 
intent(in), 
optional:: quiet
  2826     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2827     real(DP), 
intent(in), 
optional:: timed
  2828     logical, 
intent(in), 
optional:: time_average_store
  2829     logical, 
intent(out), 
optional:: err
  2832         & varname, array, arraysize, history, range, &
  2833         & time, quiet, difftime, timed, time_average_store, err )
  2837         character(*), 
intent(in):: varname
  2838         integer, 
intent(in):: arraysize
  2839         real, 
intent(in):: array(arraysize)
  2840         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2841         character(*), 
intent(in), 
optional:: range
  2842         real, 
intent(in), 
optional:: time
  2843         logical, 
intent(in), 
optional:: quiet
  2844         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2845         real(DP), 
intent(in), 
optional:: timed
  2846         logical, 
intent(in), 
optional:: time_average_store
  2847         logical, 
intent(out), 
optional:: err
  2850     character(*), 
parameter:: subname = 
"HistoryPutReal2"  2855       & pack(array, .true.), 
size(array), &   
  2856       & history = history, &     
  2860       & difftime = difftime, &   
  2862       & time_average_store = &
  2863       &    time_average_store, & 
  2868     & history, range, time, quiet, &
  2869     & difftime, timed, time_average_store, err )
  2877     character(*), 
intent(in):: varname
  2878     real, 
intent(in):: array(:,:,:)
  2879     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2880     character(*), 
intent(in), 
optional:: range
  2881     real, 
intent(in), 
optional:: time
  2882     logical, 
intent(in), 
optional:: quiet
  2883     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2884     real(DP), 
intent(in), 
optional:: timed
  2885     logical, 
intent(in), 
optional:: time_average_store
  2886     logical, 
intent(out), 
optional:: err
  2889         & varname, array, arraysize, history, range, &
  2890         & time, quiet, difftime, timed, time_average_store, err )
  2894         character(*), 
intent(in):: varname
  2895         integer, 
intent(in):: arraysize
  2896         real, 
intent(in):: array(arraysize)
  2897         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2898         character(*), 
intent(in), 
optional:: range
  2899         real, 
intent(in), 
optional:: time
  2900         logical, 
intent(in), 
optional:: quiet
  2901         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2902         real(DP), 
intent(in), 
optional:: timed
  2903         logical, 
intent(in), 
optional:: time_average_store
  2904         logical, 
intent(out), 
optional:: err
  2907     character(*), 
parameter:: subname = 
"HistoryPutReal3"  2912       & pack(array, .true.), 
size(array), &   
  2913       & history = history, &     
  2917       & difftime = difftime, &   
  2919       & time_average_store = &
  2920       &    time_average_store, & 
  2925     & history, range, time, quiet, &
  2926     & difftime, timed, time_average_store, err )
  2934     character(*), 
intent(in):: varname
  2935     real, 
intent(in):: array(:,:,:,:)
  2936     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2937     character(*), 
intent(in), 
optional:: range
  2938     real, 
intent(in), 
optional:: time
  2939     logical, 
intent(in), 
optional:: quiet
  2940     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2941     real(DP), 
intent(in), 
optional:: timed
  2942     logical, 
intent(in), 
optional:: time_average_store
  2943     logical, 
intent(out), 
optional:: err
  2946         & varname, array, arraysize, history, range, &
  2947         & time, quiet, difftime, timed, time_average_store, err )
  2951         character(*), 
intent(in):: varname
  2952         integer, 
intent(in):: arraysize
  2953         real, 
intent(in):: array(arraysize)
  2954         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  2955         character(*), 
intent(in), 
optional:: range
  2956         real, 
intent(in), 
optional:: time
  2957         logical, 
intent(in), 
optional:: quiet
  2958         type(
dc_difftime), 
intent(in), 
optional:: difftime
  2959         real(DP), 
intent(in), 
optional:: timed
  2960         logical, 
intent(in), 
optional:: time_average_store
  2961         logical, 
intent(out), 
optional:: err
  2964     character(*), 
parameter:: subname = 
"HistoryPutReal4"  2969       & pack(array, .true.), 
size(array), &   
  2970       & history = history, &     
  2974       & difftime = difftime, &   
  2976       & time_average_store = &
  2977       &    time_average_store, & 
  2982     & history, range, time, quiet, &
  2983     & difftime, timed, time_average_store, err )
  2991     character(*), 
intent(in):: varname
  2992     real, 
intent(in):: array(:,:,:,:,:)
  2993     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  2994     character(*), 
intent(in), 
optional:: range
  2995     real, 
intent(in), 
optional:: time
  2996     logical, 
intent(in), 
optional:: quiet
  2997     type(
dc_difftime), 
intent(in), 
optional:: difftime
  2998     real(DP), 
intent(in), 
optional:: timed
  2999     logical, 
intent(in), 
optional:: time_average_store
  3000     logical, 
intent(out), 
optional:: err
  3003         & varname, array, arraysize, history, range, &
  3004         & time, quiet, difftime, timed, time_average_store, err )
  3008         character(*), 
intent(in):: varname
  3009         integer, 
intent(in):: arraysize
  3010         real, 
intent(in):: array(arraysize)
  3011         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3012         character(*), 
intent(in), 
optional:: range
  3013         real, 
intent(in), 
optional:: time
  3014         logical, 
intent(in), 
optional:: quiet
  3015         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3016         real(DP), 
intent(in), 
optional:: timed
  3017         logical, 
intent(in), 
optional:: time_average_store
  3018         logical, 
intent(out), 
optional:: err
  3021     character(*), 
parameter:: subname = 
"HistoryPutReal5"  3026       & pack(array, .true.), 
size(array), &   
  3027       & history = history, &     
  3031       & difftime = difftime, &   
  3033       & time_average_store = &
  3034       &    time_average_store, & 
  3039     & history, range, time, quiet, &
  3040     & difftime, timed, time_average_store, err )
  3048     character(*), 
intent(in):: varname
  3049     real, 
intent(in):: array(:,:,:,:,:,:)
  3050     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3051     character(*), 
intent(in), 
optional:: range
  3052     real, 
intent(in), 
optional:: time
  3053     logical, 
intent(in), 
optional:: quiet
  3054     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3055     real(DP), 
intent(in), 
optional:: timed
  3056     logical, 
intent(in), 
optional:: time_average_store
  3057     logical, 
intent(out), 
optional:: err
  3060         & varname, array, arraysize, history, range, &
  3061         & time, quiet, difftime, timed, time_average_store, err )
  3065         character(*), 
intent(in):: varname
  3066         integer, 
intent(in):: arraysize
  3067         real, 
intent(in):: array(arraysize)
  3068         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3069         character(*), 
intent(in), 
optional:: range
  3070         real, 
intent(in), 
optional:: time
  3071         logical, 
intent(in), 
optional:: quiet
  3072         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3073         real(DP), 
intent(in), 
optional:: timed
  3074         logical, 
intent(in), 
optional:: time_average_store
  3075         logical, 
intent(out), 
optional:: err
  3078     character(*), 
parameter:: subname = 
"HistoryPutReal6"  3083       & pack(array, .true.), 
size(array), &   
  3084       & history = history, &     
  3088       & difftime = difftime, &   
  3090       & time_average_store = &
  3091       &    time_average_store, & 
  3096     & history, range, time, quiet, &
  3097     & difftime, timed, time_average_store, err )
  3105     character(*), 
intent(in):: varname
  3106     real, 
intent(in):: array(:,:,:,:,:,:,:)
  3107     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3108     character(*), 
intent(in), 
optional:: range
  3109     real, 
intent(in), 
optional:: time
  3110     logical, 
intent(in), 
optional:: quiet
  3111     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3112     real(DP), 
intent(in), 
optional:: timed
  3113     logical, 
intent(in), 
optional:: time_average_store
  3114     logical, 
intent(out), 
optional:: err
  3117         & varname, array, arraysize, history, range, &
  3118         & time, quiet, difftime, timed, time_average_store, err )
  3122         character(*), 
intent(in):: varname
  3123         integer, 
intent(in):: arraysize
  3124         real, 
intent(in):: array(arraysize)
  3125         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3126         character(*), 
intent(in), 
optional:: range
  3127         real, 
intent(in), 
optional:: time
  3128         logical, 
intent(in), 
optional:: quiet
  3129         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3130         real(DP), 
intent(in), 
optional:: timed
  3131         logical, 
intent(in), 
optional:: time_average_store
  3132         logical, 
intent(out), 
optional:: err
  3135     character(*), 
parameter:: subname = 
"HistoryPutReal7"  3140       & pack(array, .true.), 
size(array), &   
  3141       & history = history, &     
  3145       & difftime = difftime, &   
  3147       & time_average_store = &
  3148       &    time_average_store, & 
  3153     & history, range, time, quiet, &
  3154     & difftime, timed, time_average_store, err )
  3162     character(*), 
intent(in):: varname
  3163     integer, 
intent(in):: value
  3164     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3165     character(*), 
intent(in), 
optional:: range
  3166     real, 
intent(in), 
optional:: time
  3167     logical, 
intent(in), 
optional:: quiet
  3168     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3169     real(DP), 
intent(in), 
optional:: timed
  3170     logical, 
intent(in), 
optional:: time_average_store
  3171     logical, 
intent(out), 
optional:: err
  3174         & varname, array, arraysize, history, range, &
  3175         & time, quiet, difftime, timed, time_average_store, err )
  3179         character(*), 
intent(in):: varname
  3180         integer, 
intent(in):: arraysize
  3181         integer, 
intent(in):: array(arraysize)
  3182         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3183         character(*), 
intent(in), 
optional:: range
  3184         real, 
intent(in), 
optional:: time
  3185         logical, 
intent(in), 
optional:: quiet
  3186         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3187         real(DP), 
intent(in), 
optional:: timed
  3188         logical, 
intent(in), 
optional:: time_average_store
  3189         logical, 
intent(out), 
optional:: err
  3192     character(*), 
parameter:: subname = 
"HistoryPutInt0"  3198       & history = history, &     
  3202       & difftime = difftime, &   
  3204       & time_average_store = &
  3205       &    time_average_store, & 
  3210     & history, range, time, quiet, &
  3211     & difftime, timed, time_average_store, err )
  3219     character(*), 
intent(in):: varname
  3220     integer, 
intent(in):: array(:)
  3221     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3222     character(*), 
intent(in), 
optional:: range
  3223     real, 
intent(in), 
optional:: time
  3224     logical, 
intent(in), 
optional:: quiet
  3225     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3226     real(DP), 
intent(in), 
optional:: timed
  3227     logical, 
intent(in), 
optional:: time_average_store
  3228     logical, 
intent(out), 
optional:: err
  3231         & varname, array, arraysize, history, range, &
  3232         & time, quiet, difftime, timed, time_average_store, err )
  3236         character(*), 
intent(in):: varname
  3237         integer, 
intent(in):: arraysize
  3238         integer, 
intent(in):: array(arraysize)
  3239         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3240         character(*), 
intent(in), 
optional:: range
  3241         real, 
intent(in), 
optional:: time
  3242         logical, 
intent(in), 
optional:: quiet
  3243         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3244         real(DP), 
intent(in), 
optional:: timed
  3245         logical, 
intent(in), 
optional:: time_average_store
  3246         logical, 
intent(out), 
optional:: err
  3249     character(*), 
parameter:: subname = 
"HistoryPutInt1"  3254       & pack(array, .true.), 
size(array), &   
  3255       & history = history, &     
  3259       & difftime = difftime, &   
  3261       & time_average_store = &
  3262       &    time_average_store, & 
  3267     & history, range, time, quiet, &
  3268     & difftime, timed, time_average_store, err )
  3276     character(*), 
intent(in):: varname
  3277     integer, 
intent(in):: array(:,:)
  3278     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3279     character(*), 
intent(in), 
optional:: range
  3280     real, 
intent(in), 
optional:: time
  3281     logical, 
intent(in), 
optional:: quiet
  3282     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3283     real(DP), 
intent(in), 
optional:: timed
  3284     logical, 
intent(in), 
optional:: time_average_store
  3285     logical, 
intent(out), 
optional:: err
  3288         & varname, array, arraysize, history, range, &
  3289         & time, quiet, difftime, timed, time_average_store, err )
  3293         character(*), 
intent(in):: varname
  3294         integer, 
intent(in):: arraysize
  3295         integer, 
intent(in):: array(arraysize)
  3296         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3297         character(*), 
intent(in), 
optional:: range
  3298         real, 
intent(in), 
optional:: time
  3299         logical, 
intent(in), 
optional:: quiet
  3300         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3301         real(DP), 
intent(in), 
optional:: timed
  3302         logical, 
intent(in), 
optional:: time_average_store
  3303         logical, 
intent(out), 
optional:: err
  3306     character(*), 
parameter:: subname = 
"HistoryPutInt2"  3311       & pack(array, .true.), 
size(array), &   
  3312       & history = history, &     
  3316       & difftime = difftime, &   
  3318       & time_average_store = &
  3319       &    time_average_store, & 
  3324     & history, range, time, quiet, &
  3325     & difftime, timed, time_average_store, err )
  3333     character(*), 
intent(in):: varname
  3334     integer, 
intent(in):: array(:,:,:)
  3335     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3336     character(*), 
intent(in), 
optional:: range
  3337     real, 
intent(in), 
optional:: time
  3338     logical, 
intent(in), 
optional:: quiet
  3339     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3340     real(DP), 
intent(in), 
optional:: timed
  3341     logical, 
intent(in), 
optional:: time_average_store
  3342     logical, 
intent(out), 
optional:: err
  3345         & varname, array, arraysize, history, range, &
  3346         & time, quiet, difftime, timed, time_average_store, err )
  3350         character(*), 
intent(in):: varname
  3351         integer, 
intent(in):: arraysize
  3352         integer, 
intent(in):: array(arraysize)
  3353         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3354         character(*), 
intent(in), 
optional:: range
  3355         real, 
intent(in), 
optional:: time
  3356         logical, 
intent(in), 
optional:: quiet
  3357         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3358         real(DP), 
intent(in), 
optional:: timed
  3359         logical, 
intent(in), 
optional:: time_average_store
  3360         logical, 
intent(out), 
optional:: err
  3363     character(*), 
parameter:: subname = 
"HistoryPutInt3"  3368       & pack(array, .true.), 
size(array), &   
  3369       & history = history, &     
  3373       & difftime = difftime, &   
  3375       & time_average_store = &
  3376       &    time_average_store, & 
  3381     & history, range, time, quiet, &
  3382     & difftime, timed, time_average_store, err )
  3390     character(*), 
intent(in):: varname
  3391     integer, 
intent(in):: array(:,:,:,:)
  3392     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3393     character(*), 
intent(in), 
optional:: range
  3394     real, 
intent(in), 
optional:: time
  3395     logical, 
intent(in), 
optional:: quiet
  3396     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3397     real(DP), 
intent(in), 
optional:: timed
  3398     logical, 
intent(in), 
optional:: time_average_store
  3399     logical, 
intent(out), 
optional:: err
  3402         & varname, array, arraysize, history, range, &
  3403         & time, quiet, difftime, timed, time_average_store, err )
  3407         character(*), 
intent(in):: varname
  3408         integer, 
intent(in):: arraysize
  3409         integer, 
intent(in):: array(arraysize)
  3410         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3411         character(*), 
intent(in), 
optional:: range
  3412         real, 
intent(in), 
optional:: time
  3413         logical, 
intent(in), 
optional:: quiet
  3414         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3415         real(DP), 
intent(in), 
optional:: timed
  3416         logical, 
intent(in), 
optional:: time_average_store
  3417         logical, 
intent(out), 
optional:: err
  3420     character(*), 
parameter:: subname = 
"HistoryPutInt4"  3425       & pack(array, .true.), 
size(array), &   
  3426       & history = history, &     
  3430       & difftime = difftime, &   
  3432       & time_average_store = &
  3433       &    time_average_store, & 
  3438     & history, range, time, quiet, &
  3439     & difftime, timed, time_average_store, err )
  3447     character(*), 
intent(in):: varname
  3448     integer, 
intent(in):: array(:,:,:,:,:)
  3449     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3450     character(*), 
intent(in), 
optional:: range
  3451     real, 
intent(in), 
optional:: time
  3452     logical, 
intent(in), 
optional:: quiet
  3453     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3454     real(DP), 
intent(in), 
optional:: timed
  3455     logical, 
intent(in), 
optional:: time_average_store
  3456     logical, 
intent(out), 
optional:: err
  3459         & varname, array, arraysize, history, range, &
  3460         & time, quiet, difftime, timed, time_average_store, err )
  3464         character(*), 
intent(in):: varname
  3465         integer, 
intent(in):: arraysize
  3466         integer, 
intent(in):: array(arraysize)
  3467         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3468         character(*), 
intent(in), 
optional:: range
  3469         real, 
intent(in), 
optional:: time
  3470         logical, 
intent(in), 
optional:: quiet
  3471         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3472         real(DP), 
intent(in), 
optional:: timed
  3473         logical, 
intent(in), 
optional:: time_average_store
  3474         logical, 
intent(out), 
optional:: err
  3477     character(*), 
parameter:: subname = 
"HistoryPutInt5"  3482       & pack(array, .true.), 
size(array), &   
  3483       & history = history, &     
  3487       & difftime = difftime, &   
  3489       & time_average_store = &
  3490       &    time_average_store, & 
  3495     & history, range, time, quiet, &
  3496     & difftime, timed, time_average_store, err )
  3504     character(*), 
intent(in):: varname
  3505     integer, 
intent(in):: array(:,:,:,:,:,:)
  3506     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3507     character(*), 
intent(in), 
optional:: range
  3508     real, 
intent(in), 
optional:: time
  3509     logical, 
intent(in), 
optional:: quiet
  3510     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3511     real(DP), 
intent(in), 
optional:: timed
  3512     logical, 
intent(in), 
optional:: time_average_store
  3513     logical, 
intent(out), 
optional:: err
  3516         & varname, array, arraysize, history, range, &
  3517         & time, quiet, difftime, timed, time_average_store, err )
  3521         character(*), 
intent(in):: varname
  3522         integer, 
intent(in):: arraysize
  3523         integer, 
intent(in):: array(arraysize)
  3524         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3525         character(*), 
intent(in), 
optional:: range
  3526         real, 
intent(in), 
optional:: time
  3527         logical, 
intent(in), 
optional:: quiet
  3528         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3529         real(DP), 
intent(in), 
optional:: timed
  3530         logical, 
intent(in), 
optional:: time_average_store
  3531         logical, 
intent(out), 
optional:: err
  3534     character(*), 
parameter:: subname = 
"HistoryPutInt6"  3539       & pack(array, .true.), 
size(array), &   
  3540       & history = history, &     
  3544       & difftime = difftime, &   
  3546       & time_average_store = &
  3547       &    time_average_store, & 
  3552     & history, range, time, quiet, &
  3553     & difftime, timed, time_average_store, err )
  3561     character(*), 
intent(in):: varname
  3562     integer, 
intent(in):: array(:,:,:,:,:,:,:)
  3563     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3564     character(*), 
intent(in), 
optional:: range
  3565     real, 
intent(in), 
optional:: time
  3566     logical, 
intent(in), 
optional:: quiet
  3567     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3568     real(DP), 
intent(in), 
optional:: timed
  3569     logical, 
intent(in), 
optional:: time_average_store
  3570     logical, 
intent(out), 
optional:: err
  3573         & varname, array, arraysize, history, range, &
  3574         & time, quiet, difftime, timed, time_average_store, err )
  3578         character(*), 
intent(in):: varname
  3579         integer, 
intent(in):: arraysize
  3580         integer, 
intent(in):: array(arraysize)
  3581         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3582         character(*), 
intent(in), 
optional:: range
  3583         real, 
intent(in), 
optional:: time
  3584         logical, 
intent(in), 
optional:: quiet
  3585         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3586         real(DP), 
intent(in), 
optional:: timed
  3587         logical, 
intent(in), 
optional:: time_average_store
  3588         logical, 
intent(out), 
optional:: err
  3591     character(*), 
parameter:: subname = 
"HistoryPutInt7"  3596       & pack(array, .true.), 
size(array), &   
  3597       & history = history, &     
  3601       & difftime = difftime, &   
  3603       & time_average_store = &
  3604       &    time_average_store, & 
  3609     & history, range, time, quiet, &
  3610     & difftime, timed, time_average_store, err )
  3618     character(*), 
intent(in):: varname
  3619     character(*), 
intent(in):: value
  3620     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3621     character(*), 
intent(in), 
optional:: range
  3622     real, 
intent(in), 
optional:: time
  3623     logical, 
intent(in), 
optional:: quiet
  3624     type(
dc_difftime), 
intent(in), 
optional:: difftime
  3625     real(DP), 
intent(in), 
optional:: timed
  3626     logical, 
intent(in), 
optional:: time_average_store
  3627     logical, 
intent(out), 
optional:: err
  3630         & varname, array, arraysize, history, range, &
  3631         & time, quiet, difftime, timed, time_average_store, err )
  3635         character(*), 
intent(in):: varname
  3636         integer, 
intent(in):: arraysize
  3637         character(*), 
intent(in):: array(arraysize)
  3638         type(
gt_history), 
intent(inout), 
target, 
optional:: history
  3639         character(*), 
intent(in), 
optional:: range
  3640         real, 
intent(in), 
optional:: time
  3641         logical, 
intent(in), 
optional:: quiet
  3642         type(
dc_difftime), 
intent(in), 
optional:: difftime
  3643         real(DP), 
intent(in), 
optional:: timed
  3644         logical, 
intent(in), 
optional:: time_average_store
  3645         logical, 
intent(out), 
optional:: err
  3648     character(*), 
parameter:: subname = 
"HistoryPutChar0"  3654       & history = history, &     
  3658       & difftime = difftime, &   
  3660       & time_average_store = &
  3661       &    time_average_store, & 
  3665   subroutine timegoahead( varname, var, head, history, err )
  3698     character(len = *), 
intent(in)            :: varname
  3700     real, 
intent(in):: head
  3701     type(
gt_history), 
intent(inout), 
optional, 
target:: history
  3702     logical,            
intent(out), 
optional :: err
  3706     real, 
pointer:: time(:) =>null()
  3709     integer:: timestart, rest
  3714     character(STRING):: cause_c, subname_r
  3715     character(*), 
parameter:: subname = 
"TimeGoAhead"  3717     call beginsub(subname, 
'varname=%c head=%r', &
  3718       & c1=trim(varname), r=(/head/))
  3722     if (
present(history)) 
then  3731     if (v_ord == 0) 
goto 1000
  3733     if (hst % growable_indices(v_ord) == 0) 
then  3736     if (hst % dim_value_written(hst % unlimited_index)) 
then  3742       call slice(var, hst % growable_indices(v_ord), & 
  3743         & start=hst % count(1), count=1)               
  3751       hst % count(v_ord) = hst % count(v_ord) + 1
  3752       call slice(var, hst % growable_indices(v_ord), & 
  3753         & start=hst % count(v_ord), count=1)           
  3761       timevar = hst % dimvars(hst % unlimited_index)
  3762       call get_slice(timevar, 1, start=timestart)
  3763       call dbgmessage(
'map(timevar)start is <%d>. map(%c)start is <%d>', &
  3764         &       i=(/timestart, hst % count(v_ord)/), &
  3765         &       c1=trim(varname) )
  3766       call get(timevar, time, get_err)
  3767       call dbgmessage(
'time(%d)=<%*r>, err=<%b>',      &
  3768         &       i=(/
size(time)/), r=(/time(:)/), &
  3769         &       l=(/get_err/), n=(/
size(time)/)         )
  3770       if (get_err .or. hst % count(v_ord) == 1 .and. timestart == 1) 
then  3776         call slice(timevar, 1, start=1, count=1)
  3777         curtime = hst % origin
  3779         call put(timevar, (/curtime/), 1) 
  3780       elseif (hst % count(v_ord) > timestart) 
then  3786         rest = timestart + 1
  3788           call slice(timevar, 1, start=rest, count=1)
  3789           curtime = hst % origin + hst % interval * (rest - 1)
  3793           call put(timevar, (/curtime/), 1 ) 
  3795           if ( rest > hst % count(v_ord) ) 
exit  3812     if (d_ord == 0) 
then  3813       subname_r = 
'HistoryPut'  3815       cause_c = 
'varname="' // trim(varname) // 
'" is not found'  3818     hst % dim_value_written(d_ord) = .true.
  3819     if (d_ord /= hst % unlimited_index) 
then  3825     hst % count(:) = maxval(hst % count(:)) + 1
  3828     hst % newest = 
max(hst % newest, head)
  3829     hst % oldest = 
min(hst % oldest, head)
  3830     call slice(var, 1, start=hst % count(1), count=1)
  3832     call storeerror(stat, trim(subname_r), err, cause_c)
 
subroutine historyputreal1(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
recursive subroutine historyputdoubleex(varname, array, arraysize, history, range, time, quiet, difftime, timed, time_average_store, err)
 
integer, parameter, public dc_earglack
 
subroutine historyputint2(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
type(gt_history), target, save, public default
 
recursive subroutine historyputintex(varname, array, arraysize, history, range, time, quiet, difftime, timed, time_average_store, err)
 
integer, parameter, public usr_errno
 
integer, parameter, public dc_enotinit
 
subroutine historyputint3(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputaxismpireal(varname, array, history, err)
 
subroutine historyputreal0(varname, value, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputint7(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputreal6(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
integer, parameter, public token
単語やキーワードを保持する文字型変数の種別型パラメタ 
 
logical function, public present_and_true(arg)
 
subroutine historyputdouble6(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputaxismpiint(varname, array, history, err)
 
subroutine historyputint5(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputdouble5(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputdouble1(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputdouble4(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputreal2(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputreal4(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine, public storeerror(number, where, err, cause_c, cause_i)
 
integer, parameter, public dc_noerr
 
logical function, public present_and_false(arg)
 
character(string) function, public joinchar(carray, expr)
 
subroutine historyputchar0(varname, value, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputdouble7(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine gtvarsync(var, stat)
 
subroutine historyputint1(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
integer, parameter, public dp
倍精度実数型変数 
 
subroutine historyputint4(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine, public dbgmessage(fmt, i, r, d, L, n, c1, c2, c3, ca)
 
subroutine historyputdouble2(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
logical function, public present_and_not_empty(arg)
 
subroutine, public beginsub(name, fmt, i, r, d, L, n, c1, c2, c3, ca, version)
 
subroutine historyputreal3(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputreal5(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputint6(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
integer, parameter, public gt_eargsizemismatch
 
subroutine historyputdouble0(varname, value, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputint0(varname, value, history, range, time, quiet, difftime, timed, time_average_store, err)
 
recursive subroutine historyputcharex(varname, array, arraysize, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine historyputdouble3(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
integer, parameter, public gt_ebaddimname
 
subroutine historyputreal7(varname, array, history, range, time, quiet, difftime, timed, time_average_store, err)
 
recursive subroutine historyputrealex(varname, array, arraysize, history, range, time, quiet, difftime, timed, time_average_store, err)
 
subroutine timegoahead(varname, var, head, history, err)
 
subroutine, public endsub(name, fmt, i, r, d, L, n, c1, c2, c3, ca)
 
subroutine historyputaxismpidouble(varname, array, history, err)
 
integer, parameter, public string
文字列を保持する 文字型変数の種別型パラメタ