29     & time, varname, value, &  ! (in)
    87     use gtool_history, only: gt_history, historyput, historyinitialized, &
    88       & historyaddvariable, historyinquire, historyvarinfoinquire, &
    95     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
   102     real(DP), 
intent(in):: time
   106     character(*), 
intent(in):: varname
   119     real(DP), 
intent(in), 
target:: value
   137     logical, 
intent(out), 
optional:: err
   153     type(gt_history), 
pointer:: gthist =>null()
   161     character(STRING):: cause_c
   162     integer, 
save:: svnum = 1, svtstep
   163     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble0"   165     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
   172     if ( .not. initialized ) 
then   174       cause_c = 
'gtool_historyauto'   181     if ( time < zero_time ) 
then   184         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
   185         & c1 = trim( cause_c ), c2 = trim( varname ) )
   195       do i = svnum, numvars
   196         if ( trim( varname_vars(i) ) == trim(varname) ) 
then   202         if ( trim( varname_vars(i) ) == trim(varname) ) 
then   227       & stime_index = svtstep )  
   232     if ( create_timing_vars(vnum, svtstep) &
   233       &  .and. .not. histaddvar_vars(vnum)   ) 
then   235         & varname_vars(vnum), time )                           
   236       histaddvar_vars(vnum) = .true.
   237       if ( flag_output_prev_vars(vnum) ) 
then   238         prev_outtime_vars(vnum) = time
   240         flag_output_prev_vars(vnum) = .true.
   241         if ( origin_time_vars(vnum) > zero_time ) 
then   242           prev_outtime_vars(vnum) = origin_time_vars(vnum)
   244           prev_outtime_vars(vnum) = time
   249     if ( close_timing_vars(vnum, svtstep) ) 
then   250       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then   255     if ( renew_timing_vars(vnum, svtstep) ) 
then   256       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then   260         & varname_vars(vnum), time )                           
   261       newfile_createtime_vars(vnum) = time
   262       prev_outtime_vars(vnum) = time
   268     if (       .not. output_timing_vars(vnum, svtstep) &
   269       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then   277     gthist => gthst_history_vars(vnum) % gthist
   296     if (      output_timing_vars(vnum, svtstep) &
   297       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then   300         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
   306     if ( output_timing_vars(vnum, svtstep) ) 
then   308         & history = gthist, &   
   315     if ( output_timing_avr_vars(vnum, svtstep) ) 
then   321         & time_average_store = &
   322         &   .not. output_timing_vars(vnum, svtstep), & 
   335     if ( output_timing_vars(vnum, svtstep) ) 
then   336       if ( .not. create_timing_vars(vnum, svtstep) .and. &
   337         &  .not. renew_timing_vars(vnum, svtstep) ) 
then   339         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then   340           prev_outtime_vars(vnum) = time
   342           prev_outtime_vars(vnum) = &
   343             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
   355     call storeerror(stat, subname, cause_c = cause_c, err = err)
   361     & time, varname, array, &  ! (in)
   382     use gtool_history, only: gt_history, historyput, historyinitialized, &
   383       & historyaddvariable, historyinquire, historyvarinfoinquire, &
   390     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
   397     real(DP), 
intent(in):: time
   399     character(*), 
intent(in):: varname
   401     real(DP), 
intent(in), 
target:: array(:)
   403     logical, 
intent(out), 
optional:: err
   406     type(gt_history), 
pointer:: gthist =>null()
   410                         real(DP), 
pointer:: array_slice(:) =>null()
   412     real(DP), 
pointer:: array_avr(:) =>null()
   417     character(STRING):: cause_c
   418     integer, 
save:: svnum = 1, svtstep
   419     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble1"   421     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
   428     if ( .not. initialized ) 
then   430       cause_c = 
'gtool_historyauto'   437     if ( time < zero_time ) 
then   440         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
   441         & c1 = trim( cause_c ), c2 = trim( varname ) )
   451       do i = svnum, numvars
   452         if ( trim( varname_vars(i) ) == trim(varname) ) 
then   458         if ( trim( varname_vars(i) ) == trim(varname) ) 
then   483       & stime_index = svtstep )  
   488     if ( create_timing_vars(vnum, svtstep) &
   489       &  .and. .not. histaddvar_vars(vnum)   ) 
then   491         & varname_vars(vnum), time )                           
   492       histaddvar_vars(vnum) = .true.
   493       if ( flag_output_prev_vars(vnum) ) 
then   494         prev_outtime_vars(vnum) = time
   496         flag_output_prev_vars(vnum) = .true.
   497         if ( origin_time_vars(vnum) > zero_time ) 
then   498           prev_outtime_vars(vnum) = origin_time_vars(vnum)
   500           prev_outtime_vars(vnum) = time
   505     if ( close_timing_vars(vnum, svtstep) ) 
then   506       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then   511     if ( renew_timing_vars(vnum, svtstep) ) 
then   512       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then   516         & varname_vars(vnum), time )                           
   517       newfile_createtime_vars(vnum) = time
   518       prev_outtime_vars(vnum) = time
   524     if (       .not. output_timing_vars(vnum, svtstep) &
   525       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then   533     gthist => gthst_history_vars(vnum) % gthist
   539                         sv => slice_vars(vnum)
   544     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
   553                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then   554       array_avr => array_slice
   557         & array_slice, space_avr_vars(vnum) % avr, &   
   558                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
   570     if (      output_timing_vars(vnum, svtstep) &
   571       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then   574         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
   580     if ( output_timing_vars(vnum, svtstep) ) 
then   582         & history = gthist, &   
   589     if ( output_timing_avr_vars(vnum, svtstep) ) 
then   595         & time_average_store = &
   596         &   .not. output_timing_vars(vnum, svtstep), & 
   609     if ( output_timing_vars(vnum, svtstep) ) 
then   610       if ( .not. create_timing_vars(vnum, svtstep) .and. &
   611         &  .not. renew_timing_vars(vnum, svtstep) ) 
then   613         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then   614           prev_outtime_vars(vnum) = time
   616           prev_outtime_vars(vnum) = &
   617             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
   626                         nullify( array_avr, array_slice )
   630     call storeerror(stat, subname, cause_c = cause_c, err = err)
   636     & time, varname, array, &  ! (in)
   657     use gtool_history, only: gt_history, historyput, historyinitialized, &
   658       & historyaddvariable, historyinquire, historyvarinfoinquire, &
   665     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
   672     real(DP), 
intent(in):: time
   674     character(*), 
intent(in):: varname
   676     real(DP), 
intent(in), 
target:: array(:,:)
   678     logical, 
intent(out), 
optional:: err
   681     type(gt_history), 
pointer:: gthist =>null()
   685                         real(DP), 
pointer:: array_slice(:,:) =>null()
   687     real(DP), 
pointer:: array_avr(:,:) =>null()
   692     character(STRING):: cause_c
   693     integer, 
save:: svnum = 1, svtstep
   694     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble2"   696     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
   703     if ( .not. initialized ) 
then   705       cause_c = 
'gtool_historyauto'   712     if ( time < zero_time ) 
then   715         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
   716         & c1 = trim( cause_c ), c2 = trim( varname ) )
   726       do i = svnum, numvars
   727         if ( trim( varname_vars(i) ) == trim(varname) ) 
then   733         if ( trim( varname_vars(i) ) == trim(varname) ) 
then   758       & stime_index = svtstep )  
   763     if ( create_timing_vars(vnum, svtstep) &
   764       &  .and. .not. histaddvar_vars(vnum)   ) 
then   766         & varname_vars(vnum), time )                           
   767       histaddvar_vars(vnum) = .true.
   768       if ( flag_output_prev_vars(vnum) ) 
then   769         prev_outtime_vars(vnum) = time
   771         flag_output_prev_vars(vnum) = .true.
   772         if ( origin_time_vars(vnum) > zero_time ) 
then   773           prev_outtime_vars(vnum) = origin_time_vars(vnum)
   775           prev_outtime_vars(vnum) = time
   780     if ( close_timing_vars(vnum, svtstep) ) 
then   781       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then   786     if ( renew_timing_vars(vnum, svtstep) ) 
then   787       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then   791         & varname_vars(vnum), time )                           
   792       newfile_createtime_vars(vnum) = time
   793       prev_outtime_vars(vnum) = time
   799     if (       .not. output_timing_vars(vnum, svtstep) &
   800       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then   808     gthist => gthst_history_vars(vnum) % gthist
   814                         sv => slice_vars(vnum)
   821     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
   822                             & , sv%st(2):sv%ed(2):sv%sd(2) &
   831                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then   832       array_avr => array_slice
   835         & array_slice, space_avr_vars(vnum) % avr, &   
   836                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
   838         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
   850     if (      output_timing_vars(vnum, svtstep) &
   851       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then   854         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
   860     if ( output_timing_vars(vnum, svtstep) ) 
then   862         & history = gthist, &   
   869     if ( output_timing_avr_vars(vnum, svtstep) ) 
then   875         & time_average_store = &
   876         &   .not. output_timing_vars(vnum, svtstep), & 
   889     if ( output_timing_vars(vnum, svtstep) ) 
then   890       if ( .not. create_timing_vars(vnum, svtstep) .and. &
   891         &  .not. renew_timing_vars(vnum, svtstep) ) 
then   893         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then   894           prev_outtime_vars(vnum) = time
   896           prev_outtime_vars(vnum) = &
   897             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
   906                         nullify( array_avr, array_slice )
   910     call storeerror(stat, subname, cause_c = cause_c, err = err)
   916     & time, varname, array, &  ! (in)
   937     use gtool_history, only: gt_history, historyput, historyinitialized, &
   938       & historyaddvariable, historyinquire, historyvarinfoinquire, &
   945     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
   952     real(DP), 
intent(in):: time
   954     character(*), 
intent(in):: varname
   956     real(DP), 
intent(in), 
target:: array(:,:,:)
   958     logical, 
intent(out), 
optional:: err
   961     type(gt_history), 
pointer:: gthist =>null()
   965                         real(DP), 
pointer:: array_slice(:,:,:) =>null()
   967     real(DP), 
pointer:: array_avr(:,:,:) =>null()
   972     character(STRING):: cause_c
   973     integer, 
save:: svnum = 1, svtstep
   974     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble3"   976     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
   983     if ( .not. initialized ) 
then   985       cause_c = 
'gtool_historyauto'   992     if ( time < zero_time ) 
then   995         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
   996         & c1 = trim( cause_c ), c2 = trim( varname ) )
  1006       do i = svnum, numvars
  1007         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1013         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1038       & stime_index = svtstep )  
  1043     if ( create_timing_vars(vnum, svtstep) &
  1044       &  .and. .not. histaddvar_vars(vnum)   ) 
then  1046         & varname_vars(vnum), time )                           
  1047       histaddvar_vars(vnum) = .true.
  1048       if ( flag_output_prev_vars(vnum) ) 
then  1049         prev_outtime_vars(vnum) = time
  1051         flag_output_prev_vars(vnum) = .true.
  1052         if ( origin_time_vars(vnum) > zero_time ) 
then  1053           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  1055           prev_outtime_vars(vnum) = time
  1060     if ( close_timing_vars(vnum, svtstep) ) 
then  1061       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1066     if ( renew_timing_vars(vnum, svtstep) ) 
then  1067       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1071         & varname_vars(vnum), time )                           
  1072       newfile_createtime_vars(vnum) = time
  1073       prev_outtime_vars(vnum) = time
  1079     if (       .not. output_timing_vars(vnum, svtstep) &
  1080       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  1088     gthist => gthst_history_vars(vnum) % gthist
  1094                         sv => slice_vars(vnum)
  1103     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  1104                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  1106       & , sv%st(3):sv%ed(3):sv%sd(3) &
  1115                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  1116       array_avr => array_slice
  1119         & array_slice, space_avr_vars(vnum) % avr, &   
  1120                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  1122         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  1124         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  1136     if (      output_timing_vars(vnum, svtstep) &
  1137       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  1140         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  1146     if ( output_timing_vars(vnum, svtstep) ) 
then  1148         & history = gthist, &   
  1155     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  1160         & timed = settime, &      
  1161         & time_average_store = &
  1162         &   .not. output_timing_vars(vnum, svtstep), & 
  1163         & history = gthist )                  
  1169         & history = gthist )      
  1175     if ( output_timing_vars(vnum, svtstep) ) 
then  1176       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  1177         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  1179         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  1180           prev_outtime_vars(vnum) = time
  1182           prev_outtime_vars(vnum) = &
  1183             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  1192                         nullify( array_avr, array_slice )
  1196     call storeerror(stat, subname, cause_c = cause_c, err = err)
  1202     & time, varname, array, &  ! (in)
  1223     use gtool_history, only: gt_history, historyput, historyinitialized, &
  1224       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  1231     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  1238     real(DP), 
intent(in):: time
  1240     character(*), 
intent(in):: varname
  1242     real(DP), 
intent(in), 
target:: array(:,:,:,:)
  1244     logical, 
intent(out), 
optional:: err
  1247     type(gt_history), 
pointer:: gthist =>null()
  1251                         real(DP), 
pointer:: array_slice(:,:,:,:) =>null()
  1253     real(DP), 
pointer:: array_avr(:,:,:,:) =>null()
  1258     character(STRING):: cause_c
  1259     integer, 
save:: svnum = 1, svtstep
  1260     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble4"  1262     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  1269     if ( .not. initialized ) 
then  1271       cause_c = 
'gtool_historyauto'  1278     if ( time < zero_time ) 
then  1281         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  1282         & c1 = trim( cause_c ), c2 = trim( varname ) )
  1292       do i = svnum, numvars
  1293         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1299         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1324       & stime_index = svtstep )  
  1329     if ( create_timing_vars(vnum, svtstep) &
  1330       &  .and. .not. histaddvar_vars(vnum)   ) 
then  1332         & varname_vars(vnum), time )                           
  1333       histaddvar_vars(vnum) = .true.
  1334       if ( flag_output_prev_vars(vnum) ) 
then  1335         prev_outtime_vars(vnum) = time
  1337         flag_output_prev_vars(vnum) = .true.
  1338         if ( origin_time_vars(vnum) > zero_time ) 
then  1339           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  1341           prev_outtime_vars(vnum) = time
  1346     if ( close_timing_vars(vnum, svtstep) ) 
then  1347       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1352     if ( renew_timing_vars(vnum, svtstep) ) 
then  1353       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1357         & varname_vars(vnum), time )                           
  1358       newfile_createtime_vars(vnum) = time
  1359       prev_outtime_vars(vnum) = time
  1365     if (       .not. output_timing_vars(vnum, svtstep) &
  1366       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  1374     gthist => gthst_history_vars(vnum) % gthist
  1380                         sv => slice_vars(vnum)
  1391     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  1392                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  1394       & , sv%st(3):sv%ed(3):sv%sd(3) &
  1396       & , sv%st(4):sv%ed(4):sv%sd(4) &
  1405                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  1406       array_avr => array_slice
  1409         & array_slice, space_avr_vars(vnum) % avr, &   
  1410                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  1412         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  1414         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  1416         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  1428     if (      output_timing_vars(vnum, svtstep) &
  1429       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  1432         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  1438     if ( output_timing_vars(vnum, svtstep) ) 
then  1440         & history = gthist, &   
  1447     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  1452         & timed = settime, &      
  1453         & time_average_store = &
  1454         &   .not. output_timing_vars(vnum, svtstep), & 
  1455         & history = gthist )                  
  1461         & history = gthist )      
  1467     if ( output_timing_vars(vnum, svtstep) ) 
then  1468       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  1469         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  1471         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  1472           prev_outtime_vars(vnum) = time
  1474           prev_outtime_vars(vnum) = &
  1475             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  1484                         nullify( array_avr, array_slice )
  1488     call storeerror(stat, subname, cause_c = cause_c, err = err)
  1494     & time, varname, array, &  ! (in)
  1515     use gtool_history, only: gt_history, historyput, historyinitialized, &
  1516       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  1523     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  1530     real(DP), 
intent(in):: time
  1532     character(*), 
intent(in):: varname
  1534     real(DP), 
intent(in), 
target:: array(:,:,:,:,:)
  1536     logical, 
intent(out), 
optional:: err
  1539     type(gt_history), 
pointer:: gthist =>null()
  1543                         real(DP), 
pointer:: array_slice(:,:,:,:,:) =>null()
  1545     real(DP), 
pointer:: array_avr(:,:,:,:,:) =>null()
  1550     character(STRING):: cause_c
  1551     integer, 
save:: svnum = 1, svtstep
  1552     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble5"  1554     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  1561     if ( .not. initialized ) 
then  1563       cause_c = 
'gtool_historyauto'  1570     if ( time < zero_time ) 
then  1573         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  1574         & c1 = trim( cause_c ), c2 = trim( varname ) )
  1584       do i = svnum, numvars
  1585         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1591         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1616       & stime_index = svtstep )  
  1621     if ( create_timing_vars(vnum, svtstep) &
  1622       &  .and. .not. histaddvar_vars(vnum)   ) 
then  1624         & varname_vars(vnum), time )                           
  1625       histaddvar_vars(vnum) = .true.
  1626       if ( flag_output_prev_vars(vnum) ) 
then  1627         prev_outtime_vars(vnum) = time
  1629         flag_output_prev_vars(vnum) = .true.
  1630         if ( origin_time_vars(vnum) > zero_time ) 
then  1631           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  1633           prev_outtime_vars(vnum) = time
  1638     if ( close_timing_vars(vnum, svtstep) ) 
then  1639       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1644     if ( renew_timing_vars(vnum, svtstep) ) 
then  1645       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1649         & varname_vars(vnum), time )                           
  1650       newfile_createtime_vars(vnum) = time
  1651       prev_outtime_vars(vnum) = time
  1657     if (       .not. output_timing_vars(vnum, svtstep) &
  1658       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  1666     gthist => gthst_history_vars(vnum) % gthist
  1672                         sv => slice_vars(vnum)
  1685     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  1686                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  1688       & , sv%st(3):sv%ed(3):sv%sd(3) &
  1690       & , sv%st(4):sv%ed(4):sv%sd(4) &
  1692       & , sv%st(5):sv%ed(5):sv%sd(5) &
  1701                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  1702       array_avr => array_slice
  1705         & array_slice, space_avr_vars(vnum) % avr, &   
  1706                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  1708         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  1710         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  1712         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  1714         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  1726     if (      output_timing_vars(vnum, svtstep) &
  1727       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  1730         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  1736     if ( output_timing_vars(vnum, svtstep) ) 
then  1738         & history = gthist, &   
  1745     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  1750         & timed = settime, &      
  1751         & time_average_store = &
  1752         &   .not. output_timing_vars(vnum, svtstep), & 
  1753         & history = gthist )                  
  1759         & history = gthist )      
  1765     if ( output_timing_vars(vnum, svtstep) ) 
then  1766       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  1767         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  1769         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  1770           prev_outtime_vars(vnum) = time
  1772           prev_outtime_vars(vnum) = &
  1773             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  1782                         nullify( array_avr, array_slice )
  1786     call storeerror(stat, subname, cause_c = cause_c, err = err)
  1792     & time, varname, array, &  ! (in)
  1813     use gtool_history, only: gt_history, historyput, historyinitialized, &
  1814       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  1821     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  1828     real(DP), 
intent(in):: time
  1830     character(*), 
intent(in):: varname
  1832     real(DP), 
intent(in), 
target:: array(:,:,:,:,:,:)
  1834     logical, 
intent(out), 
optional:: err
  1837     type(gt_history), 
pointer:: gthist =>null()
  1841                         real(DP), 
pointer:: array_slice(:,:,:,:,:,:) =>null()
  1843     real(DP), 
pointer:: array_avr(:,:,:,:,:,:) =>null()
  1848     character(STRING):: cause_c
  1849     integer, 
save:: svnum = 1, svtstep
  1850     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble6"  1852     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  1859     if ( .not. initialized ) 
then  1861       cause_c = 
'gtool_historyauto'  1868     if ( time < zero_time ) 
then  1871         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  1872         & c1 = trim( cause_c ), c2 = trim( varname ) )
  1882       do i = svnum, numvars
  1883         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1889         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  1914       & stime_index = svtstep )  
  1919     if ( create_timing_vars(vnum, svtstep) &
  1920       &  .and. .not. histaddvar_vars(vnum)   ) 
then  1922         & varname_vars(vnum), time )                           
  1923       histaddvar_vars(vnum) = .true.
  1924       if ( flag_output_prev_vars(vnum) ) 
then  1925         prev_outtime_vars(vnum) = time
  1927         flag_output_prev_vars(vnum) = .true.
  1928         if ( origin_time_vars(vnum) > zero_time ) 
then  1929           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  1931           prev_outtime_vars(vnum) = time
  1936     if ( close_timing_vars(vnum, svtstep) ) 
then  1937       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1942     if ( renew_timing_vars(vnum, svtstep) ) 
then  1943       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  1947         & varname_vars(vnum), time )                           
  1948       newfile_createtime_vars(vnum) = time
  1949       prev_outtime_vars(vnum) = time
  1955     if (       .not. output_timing_vars(vnum, svtstep) &
  1956       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  1964     gthist => gthst_history_vars(vnum) % gthist
  1970                         sv => slice_vars(vnum)
  1985     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  1986                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  1988       & , sv%st(3):sv%ed(3):sv%sd(3) &
  1990       & , sv%st(4):sv%ed(4):sv%sd(4) &
  1992       & , sv%st(5):sv%ed(5):sv%sd(5) &
  1994       & , sv%st(6):sv%ed(6):sv%sd(6) &
  2003                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  2004       array_avr => array_slice
  2007         & array_slice, space_avr_vars(vnum) % avr, &   
  2008                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  2010         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  2012         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  2014         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  2016         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  2018         & weight_vars(vnum) % wgt6( sv%st(6):sv%ed(6):sv%sd(6) ) , &   
  2030     if (      output_timing_vars(vnum, svtstep) &
  2031       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  2034         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  2040     if ( output_timing_vars(vnum, svtstep) ) 
then  2042         & history = gthist, &   
  2049     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  2054         & timed = settime, &      
  2055         & time_average_store = &
  2056         &   .not. output_timing_vars(vnum, svtstep), & 
  2057         & history = gthist )                  
  2063         & history = gthist )      
  2069     if ( output_timing_vars(vnum, svtstep) ) 
then  2070       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  2071         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  2073         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  2074           prev_outtime_vars(vnum) = time
  2076           prev_outtime_vars(vnum) = &
  2077             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  2086                         nullify( array_avr, array_slice )
  2090     call storeerror(stat, subname, cause_c = cause_c, err = err)
  2096     & time, varname, array, &  ! (in)
  2117     use gtool_history, only: gt_history, historyput, historyinitialized, &
  2118       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  2125     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  2132     real(DP), 
intent(in):: time
  2134     character(*), 
intent(in):: varname
  2136     real(DP), 
intent(in), 
target:: array(:,:,:,:,:,:,:)
  2138     logical, 
intent(out), 
optional:: err
  2141     type(gt_history), 
pointer:: gthist =>null()
  2145                         real(DP), 
pointer:: array_slice(:,:,:,:,:,:,:) =>null()
  2147     real(DP), 
pointer:: array_avr(:,:,:,:,:,:,:) =>null()
  2152     character(STRING):: cause_c
  2153     integer, 
save:: svnum = 1, svtstep
  2154     character(*), 
parameter:: subname = 
"HistoryAutoPutDouble7"  2156     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  2163     if ( .not. initialized ) 
then  2165       cause_c = 
'gtool_historyauto'  2172     if ( time < zero_time ) 
then  2175         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  2176         & c1 = trim( cause_c ), c2 = trim( varname ) )
  2186       do i = svnum, numvars
  2187         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  2193         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  2218       & stime_index = svtstep )  
  2223     if ( create_timing_vars(vnum, svtstep) &
  2224       &  .and. .not. histaddvar_vars(vnum)   ) 
then  2226         & varname_vars(vnum), time )                           
  2227       histaddvar_vars(vnum) = .true.
  2228       if ( flag_output_prev_vars(vnum) ) 
then  2229         prev_outtime_vars(vnum) = time
  2231         flag_output_prev_vars(vnum) = .true.
  2232         if ( origin_time_vars(vnum) > zero_time ) 
then  2233           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  2235           prev_outtime_vars(vnum) = time
  2240     if ( close_timing_vars(vnum, svtstep) ) 
then  2241       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  2246     if ( renew_timing_vars(vnum, svtstep) ) 
then  2247       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  2251         & varname_vars(vnum), time )                           
  2252       newfile_createtime_vars(vnum) = time
  2253       prev_outtime_vars(vnum) = time
  2259     if (       .not. output_timing_vars(vnum, svtstep) &
  2260       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  2268     gthist => gthst_history_vars(vnum) % gthist
  2274                         sv => slice_vars(vnum)
  2291     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  2292                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  2294       & , sv%st(3):sv%ed(3):sv%sd(3) &
  2296       & , sv%st(4):sv%ed(4):sv%sd(4) &
  2298       & , sv%st(5):sv%ed(5):sv%sd(5) &
  2300       & , sv%st(6):sv%ed(6):sv%sd(6) &
  2302       & , sv%st(7):sv%ed(7):sv%sd(7) &
  2311                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  2312       array_avr => array_slice
  2315         & array_slice, space_avr_vars(vnum) % avr, &   
  2316                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  2318         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  2320         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  2322         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  2324         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  2326         & weight_vars(vnum) % wgt6( sv%st(6):sv%ed(6):sv%sd(6) ) , &   
  2328         & weight_vars(vnum) % wgt7( sv%st(7):sv%ed(7):sv%sd(7) ) , &   
  2340     if (      output_timing_vars(vnum, svtstep) &
  2341       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  2344         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  2350     if ( output_timing_vars(vnum, svtstep) ) 
then  2352         & history = gthist, &   
  2359     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  2364         & timed = settime, &      
  2365         & time_average_store = &
  2366         &   .not. output_timing_vars(vnum, svtstep), & 
  2367         & history = gthist )                  
  2373         & history = gthist )      
  2379     if ( output_timing_vars(vnum, svtstep) ) 
then  2380       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  2381         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  2383         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  2384           prev_outtime_vars(vnum) = time
  2386           prev_outtime_vars(vnum) = &
  2387             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  2396                         nullify( array_avr, array_slice )
  2400     call storeerror(stat, subname, cause_c = cause_c, err = err)
  2406     & time, varname, value, &  ! (in)
  2427     use gtool_history, only: gt_history, historyput, historyinitialized, &
  2428       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  2435     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  2442     real(DP), 
intent(in):: time
  2444     character(*), 
intent(in):: varname
  2446     real, 
intent(in), 
target:: value
  2448     logical, 
intent(out), 
optional:: err
  2451     type(gt_history), 
pointer:: gthist =>null()
  2459     character(STRING):: cause_c
  2460     integer, 
save:: svnum = 1, svtstep
  2461     character(*), 
parameter:: subname = 
"HistoryAutoPutReal0"  2463     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  2470     if ( .not. initialized ) 
then  2472       cause_c = 
'gtool_historyauto'  2479     if ( time < zero_time ) 
then  2482         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  2483         & c1 = trim( cause_c ), c2 = trim( varname ) )
  2493       do i = svnum, numvars
  2494         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  2500         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  2525       & stime_index = svtstep )  
  2530     if ( create_timing_vars(vnum, svtstep) &
  2531       &  .and. .not. histaddvar_vars(vnum)   ) 
then  2533         & varname_vars(vnum), time )                           
  2534       histaddvar_vars(vnum) = .true.
  2535       if ( flag_output_prev_vars(vnum) ) 
then  2536         prev_outtime_vars(vnum) = time
  2538         flag_output_prev_vars(vnum) = .true.
  2539         if ( origin_time_vars(vnum) > zero_time ) 
then  2540           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  2542           prev_outtime_vars(vnum) = time
  2547     if ( close_timing_vars(vnum, svtstep) ) 
then  2548       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  2553     if ( renew_timing_vars(vnum, svtstep) ) 
then  2554       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  2558         & varname_vars(vnum), time )                           
  2559       newfile_createtime_vars(vnum) = time
  2560       prev_outtime_vars(vnum) = time
  2566     if (       .not. output_timing_vars(vnum, svtstep) &
  2567       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  2575     gthist => gthst_history_vars(vnum) % gthist
  2594     if (      output_timing_vars(vnum, svtstep) &
  2595       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  2598         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  2604     if ( output_timing_vars(vnum, svtstep) ) 
then  2606         & history = gthist, &   
  2613     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  2618         & timed = settime, &      
  2619         & time_average_store = &
  2620         &   .not. output_timing_vars(vnum, svtstep), & 
  2621         & history = gthist )                  
  2627         & history = gthist )      
  2633     if ( output_timing_vars(vnum, svtstep) ) 
then  2634       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  2635         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  2637         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  2638           prev_outtime_vars(vnum) = time
  2640           prev_outtime_vars(vnum) = &
  2641             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  2653     call storeerror(stat, subname, cause_c = cause_c, err = err)
  2659     & time, varname, array, &  ! (in)
  2680     use gtool_history, only: gt_history, historyput, historyinitialized, &
  2681       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  2688     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  2695     real(DP), 
intent(in):: time
  2697     character(*), 
intent(in):: varname
  2699     real, 
intent(in), 
target:: array(:)
  2701     logical, 
intent(out), 
optional:: err
  2704     type(gt_history), 
pointer:: gthist =>null()
  2708                         real, 
pointer:: array_slice(:) =>null()
  2710     real, 
pointer:: array_avr(:) =>null()
  2715     character(STRING):: cause_c
  2716     integer, 
save:: svnum = 1, svtstep
  2717     character(*), 
parameter:: subname = 
"HistoryAutoPutReal1"  2719     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  2726     if ( .not. initialized ) 
then  2728       cause_c = 
'gtool_historyauto'  2735     if ( time < zero_time ) 
then  2738         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  2739         & c1 = trim( cause_c ), c2 = trim( varname ) )
  2749       do i = svnum, numvars
  2750         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  2756         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  2781       & stime_index = svtstep )  
  2786     if ( create_timing_vars(vnum, svtstep) &
  2787       &  .and. .not. histaddvar_vars(vnum)   ) 
then  2789         & varname_vars(vnum), time )                           
  2790       histaddvar_vars(vnum) = .true.
  2791       if ( flag_output_prev_vars(vnum) ) 
then  2792         prev_outtime_vars(vnum) = time
  2794         flag_output_prev_vars(vnum) = .true.
  2795         if ( origin_time_vars(vnum) > zero_time ) 
then  2796           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  2798           prev_outtime_vars(vnum) = time
  2803     if ( close_timing_vars(vnum, svtstep) ) 
then  2804       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  2809     if ( renew_timing_vars(vnum, svtstep) ) 
then  2810       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  2814         & varname_vars(vnum), time )                           
  2815       newfile_createtime_vars(vnum) = time
  2816       prev_outtime_vars(vnum) = time
  2822     if (       .not. output_timing_vars(vnum, svtstep) &
  2823       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  2831     gthist => gthst_history_vars(vnum) % gthist
  2837                         sv => slice_vars(vnum)
  2842     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  2851                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  2852       array_avr => array_slice
  2855         & array_slice, space_avr_vars(vnum) % avr, &   
  2856                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  2868     if (      output_timing_vars(vnum, svtstep) &
  2869       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  2872         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  2878     if ( output_timing_vars(vnum, svtstep) ) 
then  2880         & history = gthist, &   
  2887     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  2892         & timed = settime, &      
  2893         & time_average_store = &
  2894         &   .not. output_timing_vars(vnum, svtstep), & 
  2895         & history = gthist )                  
  2901         & history = gthist )      
  2907     if ( output_timing_vars(vnum, svtstep) ) 
then  2908       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  2909         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  2911         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  2912           prev_outtime_vars(vnum) = time
  2914           prev_outtime_vars(vnum) = &
  2915             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  2924                         nullify( array_avr, array_slice )
  2928     call storeerror(stat, subname, cause_c = cause_c, err = err)
  2934     & time, varname, array, &  ! (in)
  2955     use gtool_history, only: gt_history, historyput, historyinitialized, &
  2956       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  2963     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  2970     real(DP), 
intent(in):: time
  2972     character(*), 
intent(in):: varname
  2974     real, 
intent(in), 
target:: array(:,:)
  2976     logical, 
intent(out), 
optional:: err
  2979     type(gt_history), 
pointer:: gthist =>null()
  2983                         real, 
pointer:: array_slice(:,:) =>null()
  2985     real, 
pointer:: array_avr(:,:) =>null()
  2990     character(STRING):: cause_c
  2991     integer, 
save:: svnum = 1, svtstep
  2992     character(*), 
parameter:: subname = 
"HistoryAutoPutReal2"  2994     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  3001     if ( .not. initialized ) 
then  3003       cause_c = 
'gtool_historyauto'  3010     if ( time < zero_time ) 
then  3013         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  3014         & c1 = trim( cause_c ), c2 = trim( varname ) )
  3024       do i = svnum, numvars
  3025         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3031         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3056       & stime_index = svtstep )  
  3061     if ( create_timing_vars(vnum, svtstep) &
  3062       &  .and. .not. histaddvar_vars(vnum)   ) 
then  3064         & varname_vars(vnum), time )                           
  3065       histaddvar_vars(vnum) = .true.
  3066       if ( flag_output_prev_vars(vnum) ) 
then  3067         prev_outtime_vars(vnum) = time
  3069         flag_output_prev_vars(vnum) = .true.
  3070         if ( origin_time_vars(vnum) > zero_time ) 
then  3071           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  3073           prev_outtime_vars(vnum) = time
  3078     if ( close_timing_vars(vnum, svtstep) ) 
then  3079       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3084     if ( renew_timing_vars(vnum, svtstep) ) 
then  3085       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3089         & varname_vars(vnum), time )                           
  3090       newfile_createtime_vars(vnum) = time
  3091       prev_outtime_vars(vnum) = time
  3097     if (       .not. output_timing_vars(vnum, svtstep) &
  3098       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  3106     gthist => gthst_history_vars(vnum) % gthist
  3112                         sv => slice_vars(vnum)
  3119     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  3120                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  3129                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  3130       array_avr => array_slice
  3133         & array_slice, space_avr_vars(vnum) % avr, &   
  3134                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  3136         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  3148     if (      output_timing_vars(vnum, svtstep) &
  3149       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  3152         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  3158     if ( output_timing_vars(vnum, svtstep) ) 
then  3160         & history = gthist, &   
  3167     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  3172         & timed = settime, &      
  3173         & time_average_store = &
  3174         &   .not. output_timing_vars(vnum, svtstep), & 
  3175         & history = gthist )                  
  3181         & history = gthist )      
  3187     if ( output_timing_vars(vnum, svtstep) ) 
then  3188       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  3189         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  3191         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  3192           prev_outtime_vars(vnum) = time
  3194           prev_outtime_vars(vnum) = &
  3195             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  3204                         nullify( array_avr, array_slice )
  3208     call storeerror(stat, subname, cause_c = cause_c, err = err)
  3214     & time, varname, array, &  ! (in)
  3235     use gtool_history, only: gt_history, historyput, historyinitialized, &
  3236       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  3243     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  3250     real(DP), 
intent(in):: time
  3252     character(*), 
intent(in):: varname
  3254     real, 
intent(in), 
target:: array(:,:,:)
  3256     logical, 
intent(out), 
optional:: err
  3259     type(gt_history), 
pointer:: gthist =>null()
  3263                         real, 
pointer:: array_slice(:,:,:) =>null()
  3265     real, 
pointer:: array_avr(:,:,:) =>null()
  3270     character(STRING):: cause_c
  3271     integer, 
save:: svnum = 1, svtstep
  3272     character(*), 
parameter:: subname = 
"HistoryAutoPutReal3"  3274     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  3281     if ( .not. initialized ) 
then  3283       cause_c = 
'gtool_historyauto'  3290     if ( time < zero_time ) 
then  3293         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  3294         & c1 = trim( cause_c ), c2 = trim( varname ) )
  3304       do i = svnum, numvars
  3305         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3311         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3336       & stime_index = svtstep )  
  3341     if ( create_timing_vars(vnum, svtstep) &
  3342       &  .and. .not. histaddvar_vars(vnum)   ) 
then  3344         & varname_vars(vnum), time )                           
  3345       histaddvar_vars(vnum) = .true.
  3346       if ( flag_output_prev_vars(vnum) ) 
then  3347         prev_outtime_vars(vnum) = time
  3349         flag_output_prev_vars(vnum) = .true.
  3350         if ( origin_time_vars(vnum) > zero_time ) 
then  3351           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  3353           prev_outtime_vars(vnum) = time
  3358     if ( close_timing_vars(vnum, svtstep) ) 
then  3359       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3364     if ( renew_timing_vars(vnum, svtstep) ) 
then  3365       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3369         & varname_vars(vnum), time )                           
  3370       newfile_createtime_vars(vnum) = time
  3371       prev_outtime_vars(vnum) = time
  3377     if (       .not. output_timing_vars(vnum, svtstep) &
  3378       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  3386     gthist => gthst_history_vars(vnum) % gthist
  3392                         sv => slice_vars(vnum)
  3401     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  3402                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  3404       & , sv%st(3):sv%ed(3):sv%sd(3) &
  3413                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  3414       array_avr => array_slice
  3417         & array_slice, space_avr_vars(vnum) % avr, &   
  3418                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  3420         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  3422         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  3434     if (      output_timing_vars(vnum, svtstep) &
  3435       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  3438         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  3444     if ( output_timing_vars(vnum, svtstep) ) 
then  3446         & history = gthist, &   
  3453     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  3458         & timed = settime, &      
  3459         & time_average_store = &
  3460         &   .not. output_timing_vars(vnum, svtstep), & 
  3461         & history = gthist )                  
  3467         & history = gthist )      
  3473     if ( output_timing_vars(vnum, svtstep) ) 
then  3474       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  3475         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  3477         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  3478           prev_outtime_vars(vnum) = time
  3480           prev_outtime_vars(vnum) = &
  3481             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  3490                         nullify( array_avr, array_slice )
  3494     call storeerror(stat, subname, cause_c = cause_c, err = err)
  3500     & time, varname, array, &  ! (in)
  3521     use gtool_history, only: gt_history, historyput, historyinitialized, &
  3522       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  3529     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  3536     real(DP), 
intent(in):: time
  3538     character(*), 
intent(in):: varname
  3540     real, 
intent(in), 
target:: array(:,:,:,:)
  3542     logical, 
intent(out), 
optional:: err
  3545     type(gt_history), 
pointer:: gthist =>null()
  3549                         real, 
pointer:: array_slice(:,:,:,:) =>null()
  3551     real, 
pointer:: array_avr(:,:,:,:) =>null()
  3556     character(STRING):: cause_c
  3557     integer, 
save:: svnum = 1, svtstep
  3558     character(*), 
parameter:: subname = 
"HistoryAutoPutReal4"  3560     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  3567     if ( .not. initialized ) 
then  3569       cause_c = 
'gtool_historyauto'  3576     if ( time < zero_time ) 
then  3579         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  3580         & c1 = trim( cause_c ), c2 = trim( varname ) )
  3590       do i = svnum, numvars
  3591         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3597         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3622       & stime_index = svtstep )  
  3627     if ( create_timing_vars(vnum, svtstep) &
  3628       &  .and. .not. histaddvar_vars(vnum)   ) 
then  3630         & varname_vars(vnum), time )                           
  3631       histaddvar_vars(vnum) = .true.
  3632       if ( flag_output_prev_vars(vnum) ) 
then  3633         prev_outtime_vars(vnum) = time
  3635         flag_output_prev_vars(vnum) = .true.
  3636         if ( origin_time_vars(vnum) > zero_time ) 
then  3637           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  3639           prev_outtime_vars(vnum) = time
  3644     if ( close_timing_vars(vnum, svtstep) ) 
then  3645       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3650     if ( renew_timing_vars(vnum, svtstep) ) 
then  3651       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3655         & varname_vars(vnum), time )                           
  3656       newfile_createtime_vars(vnum) = time
  3657       prev_outtime_vars(vnum) = time
  3663     if (       .not. output_timing_vars(vnum, svtstep) &
  3664       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  3672     gthist => gthst_history_vars(vnum) % gthist
  3678                         sv => slice_vars(vnum)
  3689     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  3690                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  3692       & , sv%st(3):sv%ed(3):sv%sd(3) &
  3694       & , sv%st(4):sv%ed(4):sv%sd(4) &
  3703                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  3704       array_avr => array_slice
  3707         & array_slice, space_avr_vars(vnum) % avr, &   
  3708                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  3710         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  3712         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  3714         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  3726     if (      output_timing_vars(vnum, svtstep) &
  3727       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  3730         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  3736     if ( output_timing_vars(vnum, svtstep) ) 
then  3738         & history = gthist, &   
  3745     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  3750         & timed = settime, &      
  3751         & time_average_store = &
  3752         &   .not. output_timing_vars(vnum, svtstep), & 
  3753         & history = gthist )                  
  3759         & history = gthist )      
  3765     if ( output_timing_vars(vnum, svtstep) ) 
then  3766       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  3767         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  3769         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  3770           prev_outtime_vars(vnum) = time
  3772           prev_outtime_vars(vnum) = &
  3773             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  3782                         nullify( array_avr, array_slice )
  3786     call storeerror(stat, subname, cause_c = cause_c, err = err)
  3792     & time, varname, array, &  ! (in)
  3813     use gtool_history, only: gt_history, historyput, historyinitialized, &
  3814       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  3821     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  3828     real(DP), 
intent(in):: time
  3830     character(*), 
intent(in):: varname
  3832     real, 
intent(in), 
target:: array(:,:,:,:,:)
  3834     logical, 
intent(out), 
optional:: err
  3837     type(gt_history), 
pointer:: gthist =>null()
  3841                         real, 
pointer:: array_slice(:,:,:,:,:) =>null()
  3843     real, 
pointer:: array_avr(:,:,:,:,:) =>null()
  3848     character(STRING):: cause_c
  3849     integer, 
save:: svnum = 1, svtstep
  3850     character(*), 
parameter:: subname = 
"HistoryAutoPutReal5"  3852     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  3859     if ( .not. initialized ) 
then  3861       cause_c = 
'gtool_historyauto'  3868     if ( time < zero_time ) 
then  3871         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  3872         & c1 = trim( cause_c ), c2 = trim( varname ) )
  3882       do i = svnum, numvars
  3883         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3889         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  3914       & stime_index = svtstep )  
  3919     if ( create_timing_vars(vnum, svtstep) &
  3920       &  .and. .not. histaddvar_vars(vnum)   ) 
then  3922         & varname_vars(vnum), time )                           
  3923       histaddvar_vars(vnum) = .true.
  3924       if ( flag_output_prev_vars(vnum) ) 
then  3925         prev_outtime_vars(vnum) = time
  3927         flag_output_prev_vars(vnum) = .true.
  3928         if ( origin_time_vars(vnum) > zero_time ) 
then  3929           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  3931           prev_outtime_vars(vnum) = time
  3936     if ( close_timing_vars(vnum, svtstep) ) 
then  3937       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3942     if ( renew_timing_vars(vnum, svtstep) ) 
then  3943       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  3947         & varname_vars(vnum), time )                           
  3948       newfile_createtime_vars(vnum) = time
  3949       prev_outtime_vars(vnum) = time
  3955     if (       .not. output_timing_vars(vnum, svtstep) &
  3956       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  3964     gthist => gthst_history_vars(vnum) % gthist
  3970                         sv => slice_vars(vnum)
  3983     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  3984                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  3986       & , sv%st(3):sv%ed(3):sv%sd(3) &
  3988       & , sv%st(4):sv%ed(4):sv%sd(4) &
  3990       & , sv%st(5):sv%ed(5):sv%sd(5) &
  3999                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  4000       array_avr => array_slice
  4003         & array_slice, space_avr_vars(vnum) % avr, &   
  4004                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  4006         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  4008         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  4010         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  4012         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  4024     if (      output_timing_vars(vnum, svtstep) &
  4025       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  4028         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  4034     if ( output_timing_vars(vnum, svtstep) ) 
then  4036         & history = gthist, &   
  4043     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  4048         & timed = settime, &      
  4049         & time_average_store = &
  4050         &   .not. output_timing_vars(vnum, svtstep), & 
  4051         & history = gthist )                  
  4057         & history = gthist )      
  4063     if ( output_timing_vars(vnum, svtstep) ) 
then  4064       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  4065         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  4067         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  4068           prev_outtime_vars(vnum) = time
  4070           prev_outtime_vars(vnum) = &
  4071             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  4080                         nullify( array_avr, array_slice )
  4084     call storeerror(stat, subname, cause_c = cause_c, err = err)
  4090     & time, varname, array, &  ! (in)
  4111     use gtool_history, only: gt_history, historyput, historyinitialized, &
  4112       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  4119     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  4126     real(DP), 
intent(in):: time
  4128     character(*), 
intent(in):: varname
  4130     real, 
intent(in), 
target:: array(:,:,:,:,:,:)
  4132     logical, 
intent(out), 
optional:: err
  4135     type(gt_history), 
pointer:: gthist =>null()
  4139                         real, 
pointer:: array_slice(:,:,:,:,:,:) =>null()
  4141     real, 
pointer:: array_avr(:,:,:,:,:,:) =>null()
  4146     character(STRING):: cause_c
  4147     integer, 
save:: svnum = 1, svtstep
  4148     character(*), 
parameter:: subname = 
"HistoryAutoPutReal6"  4150     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  4157     if ( .not. initialized ) 
then  4159       cause_c = 
'gtool_historyauto'  4166     if ( time < zero_time ) 
then  4169         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  4170         & c1 = trim( cause_c ), c2 = trim( varname ) )
  4180       do i = svnum, numvars
  4181         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  4187         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  4212       & stime_index = svtstep )  
  4217     if ( create_timing_vars(vnum, svtstep) &
  4218       &  .and. .not. histaddvar_vars(vnum)   ) 
then  4220         & varname_vars(vnum), time )                           
  4221       histaddvar_vars(vnum) = .true.
  4222       if ( flag_output_prev_vars(vnum) ) 
then  4223         prev_outtime_vars(vnum) = time
  4225         flag_output_prev_vars(vnum) = .true.
  4226         if ( origin_time_vars(vnum) > zero_time ) 
then  4227           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  4229           prev_outtime_vars(vnum) = time
  4234     if ( close_timing_vars(vnum, svtstep) ) 
then  4235       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  4240     if ( renew_timing_vars(vnum, svtstep) ) 
then  4241       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  4245         & varname_vars(vnum), time )                           
  4246       newfile_createtime_vars(vnum) = time
  4247       prev_outtime_vars(vnum) = time
  4253     if (       .not. output_timing_vars(vnum, svtstep) &
  4254       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  4262     gthist => gthst_history_vars(vnum) % gthist
  4268                         sv => slice_vars(vnum)
  4283     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  4284                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  4286       & , sv%st(3):sv%ed(3):sv%sd(3) &
  4288       & , sv%st(4):sv%ed(4):sv%sd(4) &
  4290       & , sv%st(5):sv%ed(5):sv%sd(5) &
  4292       & , sv%st(6):sv%ed(6):sv%sd(6) &
  4301                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  4302       array_avr => array_slice
  4305         & array_slice, space_avr_vars(vnum) % avr, &   
  4306                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  4308         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  4310         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  4312         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  4314         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  4316         & weight_vars(vnum) % wgt6( sv%st(6):sv%ed(6):sv%sd(6) ) , &   
  4328     if (      output_timing_vars(vnum, svtstep) &
  4329       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  4332         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  4338     if ( output_timing_vars(vnum, svtstep) ) 
then  4340         & history = gthist, &   
  4347     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  4352         & timed = settime, &      
  4353         & time_average_store = &
  4354         &   .not. output_timing_vars(vnum, svtstep), & 
  4355         & history = gthist )                  
  4361         & history = gthist )      
  4367     if ( output_timing_vars(vnum, svtstep) ) 
then  4368       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  4369         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  4371         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  4372           prev_outtime_vars(vnum) = time
  4374           prev_outtime_vars(vnum) = &
  4375             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  4384                         nullify( array_avr, array_slice )
  4388     call storeerror(stat, subname, cause_c = cause_c, err = err)
  4394     & time, varname, array, &  ! (in)
  4415     use gtool_history, only: gt_history, historyput, historyinitialized, &
  4416       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  4423     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  4430     real(DP), 
intent(in):: time
  4432     character(*), 
intent(in):: varname
  4434     real, 
intent(in), 
target:: array(:,:,:,:,:,:,:)
  4436     logical, 
intent(out), 
optional:: err
  4439     type(gt_history), 
pointer:: gthist =>null()
  4443                         real, 
pointer:: array_slice(:,:,:,:,:,:,:) =>null()
  4445     real, 
pointer:: array_avr(:,:,:,:,:,:,:) =>null()
  4450     character(STRING):: cause_c
  4451     integer, 
save:: svnum = 1, svtstep
  4452     character(*), 
parameter:: subname = 
"HistoryAutoPutReal7"  4454     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  4461     if ( .not. initialized ) 
then  4463       cause_c = 
'gtool_historyauto'  4470     if ( time < zero_time ) 
then  4473         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  4474         & c1 = trim( cause_c ), c2 = trim( varname ) )
  4484       do i = svnum, numvars
  4485         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  4491         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  4516       & stime_index = svtstep )  
  4521     if ( create_timing_vars(vnum, svtstep) &
  4522       &  .and. .not. histaddvar_vars(vnum)   ) 
then  4524         & varname_vars(vnum), time )                           
  4525       histaddvar_vars(vnum) = .true.
  4526       if ( flag_output_prev_vars(vnum) ) 
then  4527         prev_outtime_vars(vnum) = time
  4529         flag_output_prev_vars(vnum) = .true.
  4530         if ( origin_time_vars(vnum) > zero_time ) 
then  4531           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  4533           prev_outtime_vars(vnum) = time
  4538     if ( close_timing_vars(vnum, svtstep) ) 
then  4539       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  4544     if ( renew_timing_vars(vnum, svtstep) ) 
then  4545       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  4549         & varname_vars(vnum), time )                           
  4550       newfile_createtime_vars(vnum) = time
  4551       prev_outtime_vars(vnum) = time
  4557     if (       .not. output_timing_vars(vnum, svtstep) &
  4558       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  4566     gthist => gthst_history_vars(vnum) % gthist
  4572                         sv => slice_vars(vnum)
  4589     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  4590                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  4592       & , sv%st(3):sv%ed(3):sv%sd(3) &
  4594       & , sv%st(4):sv%ed(4):sv%sd(4) &
  4596       & , sv%st(5):sv%ed(5):sv%sd(5) &
  4598       & , sv%st(6):sv%ed(6):sv%sd(6) &
  4600       & , sv%st(7):sv%ed(7):sv%sd(7) &
  4609                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  4610       array_avr => array_slice
  4613         & array_slice, space_avr_vars(vnum) % avr, &   
  4614                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  4616         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  4618         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  4620         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  4622         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  4624         & weight_vars(vnum) % wgt6( sv%st(6):sv%ed(6):sv%sd(6) ) , &   
  4626         & weight_vars(vnum) % wgt7( sv%st(7):sv%ed(7):sv%sd(7) ) , &   
  4638     if (      output_timing_vars(vnum, svtstep) &
  4639       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  4642         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  4648     if ( output_timing_vars(vnum, svtstep) ) 
then  4650         & history = gthist, &   
  4657     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  4662         & timed = settime, &      
  4663         & time_average_store = &
  4664         &   .not. output_timing_vars(vnum, svtstep), & 
  4665         & history = gthist )                  
  4671         & history = gthist )      
  4677     if ( output_timing_vars(vnum, svtstep) ) 
then  4678       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  4679         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  4681         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  4682           prev_outtime_vars(vnum) = time
  4684           prev_outtime_vars(vnum) = &
  4685             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  4694                         nullify( array_avr, array_slice )
  4698     call storeerror(stat, subname, cause_c = cause_c, err = err)
  4704     & time, varname, value, &  ! (in)
  4725     use gtool_history, only: gt_history, historyput, historyinitialized, &
  4726       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  4733     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  4740     real(DP), 
intent(in):: time
  4742     character(*), 
intent(in):: varname
  4744     integer, 
intent(in), 
target:: value
  4746     logical, 
intent(out), 
optional:: err
  4749     type(gt_history), 
pointer:: gthist =>null()
  4757     character(STRING):: cause_c
  4758     integer, 
save:: svnum = 1, svtstep
  4759     character(*), 
parameter:: subname = 
"HistoryAutoPutInt0"  4761     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  4768     if ( .not. initialized ) 
then  4770       cause_c = 
'gtool_historyauto'  4777     if ( time < zero_time ) 
then  4780         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  4781         & c1 = trim( cause_c ), c2 = trim( varname ) )
  4791       do i = svnum, numvars
  4792         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  4798         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  4823       & stime_index = svtstep )  
  4828     if ( create_timing_vars(vnum, svtstep) &
  4829       &  .and. .not. histaddvar_vars(vnum)   ) 
then  4831         & varname_vars(vnum), time )                           
  4832       histaddvar_vars(vnum) = .true.
  4833       if ( flag_output_prev_vars(vnum) ) 
then  4834         prev_outtime_vars(vnum) = time
  4836         flag_output_prev_vars(vnum) = .true.
  4837         if ( origin_time_vars(vnum) > zero_time ) 
then  4838           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  4840           prev_outtime_vars(vnum) = time
  4845     if ( close_timing_vars(vnum, svtstep) ) 
then  4846       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  4851     if ( renew_timing_vars(vnum, svtstep) ) 
then  4852       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  4856         & varname_vars(vnum), time )                           
  4857       newfile_createtime_vars(vnum) = time
  4858       prev_outtime_vars(vnum) = time
  4864     if (       .not. output_timing_vars(vnum, svtstep) &
  4865       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  4873     gthist => gthst_history_vars(vnum) % gthist
  4892     if (      output_timing_vars(vnum, svtstep) &
  4893       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  4896         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  4902     if ( output_timing_vars(vnum, svtstep) ) 
then  4904         & history = gthist, &   
  4911     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  4916         & timed = settime, &      
  4917         & time_average_store = &
  4918         &   .not. output_timing_vars(vnum, svtstep), & 
  4919         & history = gthist )                  
  4925         & history = gthist )      
  4931     if ( output_timing_vars(vnum, svtstep) ) 
then  4932       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  4933         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  4935         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  4936           prev_outtime_vars(vnum) = time
  4938           prev_outtime_vars(vnum) = &
  4939             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  4951     call storeerror(stat, subname, cause_c = cause_c, err = err)
  4957     & time, varname, array, &  ! (in)
  4978     use gtool_history, only: gt_history, historyput, historyinitialized, &
  4979       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  4986     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  4993     real(DP), 
intent(in):: time
  4995     character(*), 
intent(in):: varname
  4997     integer, 
intent(in), 
target:: array(:)
  4999     logical, 
intent(out), 
optional:: err
  5002     type(gt_history), 
pointer:: gthist =>null()
  5006                         integer, 
pointer:: array_slice(:) =>null()
  5008     integer, 
pointer:: array_avr(:) =>null()
  5013     character(STRING):: cause_c
  5014     integer, 
save:: svnum = 1, svtstep
  5015     character(*), 
parameter:: subname = 
"HistoryAutoPutInt1"  5017     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  5024     if ( .not. initialized ) 
then  5026       cause_c = 
'gtool_historyauto'  5033     if ( time < zero_time ) 
then  5036         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  5037         & c1 = trim( cause_c ), c2 = trim( varname ) )
  5047       do i = svnum, numvars
  5048         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5054         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5079       & stime_index = svtstep )  
  5084     if ( create_timing_vars(vnum, svtstep) &
  5085       &  .and. .not. histaddvar_vars(vnum)   ) 
then  5087         & varname_vars(vnum), time )                           
  5088       histaddvar_vars(vnum) = .true.
  5089       if ( flag_output_prev_vars(vnum) ) 
then  5090         prev_outtime_vars(vnum) = time
  5092         flag_output_prev_vars(vnum) = .true.
  5093         if ( origin_time_vars(vnum) > zero_time ) 
then  5094           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  5096           prev_outtime_vars(vnum) = time
  5101     if ( close_timing_vars(vnum, svtstep) ) 
then  5102       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5107     if ( renew_timing_vars(vnum, svtstep) ) 
then  5108       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5112         & varname_vars(vnum), time )                           
  5113       newfile_createtime_vars(vnum) = time
  5114       prev_outtime_vars(vnum) = time
  5120     if (       .not. output_timing_vars(vnum, svtstep) &
  5121       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  5129     gthist => gthst_history_vars(vnum) % gthist
  5135                         sv => slice_vars(vnum)
  5140     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  5149                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  5150       array_avr => array_slice
  5153         & array_slice, space_avr_vars(vnum) % avr, &   
  5154                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  5166     if (      output_timing_vars(vnum, svtstep) &
  5167       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  5170         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  5176     if ( output_timing_vars(vnum, svtstep) ) 
then  5178         & history = gthist, &   
  5185     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  5190         & timed = settime, &      
  5191         & time_average_store = &
  5192         &   .not. output_timing_vars(vnum, svtstep), & 
  5193         & history = gthist )                  
  5199         & history = gthist )      
  5205     if ( output_timing_vars(vnum, svtstep) ) 
then  5206       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  5207         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  5209         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  5210           prev_outtime_vars(vnum) = time
  5212           prev_outtime_vars(vnum) = &
  5213             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  5222                         nullify( array_avr, array_slice )
  5226     call storeerror(stat, subname, cause_c = cause_c, err = err)
  5232     & time, varname, array, &  ! (in)
  5253     use gtool_history, only: gt_history, historyput, historyinitialized, &
  5254       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  5261     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  5268     real(DP), 
intent(in):: time
  5270     character(*), 
intent(in):: varname
  5272     integer, 
intent(in), 
target:: array(:,:)
  5274     logical, 
intent(out), 
optional:: err
  5277     type(gt_history), 
pointer:: gthist =>null()
  5281                         integer, 
pointer:: array_slice(:,:) =>null()
  5283     integer, 
pointer:: array_avr(:,:) =>null()
  5288     character(STRING):: cause_c
  5289     integer, 
save:: svnum = 1, svtstep
  5290     character(*), 
parameter:: subname = 
"HistoryAutoPutInt2"  5292     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  5299     if ( .not. initialized ) 
then  5301       cause_c = 
'gtool_historyauto'  5308     if ( time < zero_time ) 
then  5311         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  5312         & c1 = trim( cause_c ), c2 = trim( varname ) )
  5322       do i = svnum, numvars
  5323         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5329         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5354       & stime_index = svtstep )  
  5359     if ( create_timing_vars(vnum, svtstep) &
  5360       &  .and. .not. histaddvar_vars(vnum)   ) 
then  5362         & varname_vars(vnum), time )                           
  5363       histaddvar_vars(vnum) = .true.
  5364       if ( flag_output_prev_vars(vnum) ) 
then  5365         prev_outtime_vars(vnum) = time
  5367         flag_output_prev_vars(vnum) = .true.
  5368         if ( origin_time_vars(vnum) > zero_time ) 
then  5369           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  5371           prev_outtime_vars(vnum) = time
  5376     if ( close_timing_vars(vnum, svtstep) ) 
then  5377       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5382     if ( renew_timing_vars(vnum, svtstep) ) 
then  5383       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5387         & varname_vars(vnum), time )                           
  5388       newfile_createtime_vars(vnum) = time
  5389       prev_outtime_vars(vnum) = time
  5395     if (       .not. output_timing_vars(vnum, svtstep) &
  5396       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  5404     gthist => gthst_history_vars(vnum) % gthist
  5410                         sv => slice_vars(vnum)
  5417     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  5418                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  5427                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  5428       array_avr => array_slice
  5431         & array_slice, space_avr_vars(vnum) % avr, &   
  5432                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  5434         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  5446     if (      output_timing_vars(vnum, svtstep) &
  5447       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  5450         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  5456     if ( output_timing_vars(vnum, svtstep) ) 
then  5458         & history = gthist, &   
  5465     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  5470         & timed = settime, &      
  5471         & time_average_store = &
  5472         &   .not. output_timing_vars(vnum, svtstep), & 
  5473         & history = gthist )                  
  5479         & history = gthist )      
  5485     if ( output_timing_vars(vnum, svtstep) ) 
then  5486       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  5487         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  5489         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  5490           prev_outtime_vars(vnum) = time
  5492           prev_outtime_vars(vnum) = &
  5493             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  5502                         nullify( array_avr, array_slice )
  5506     call storeerror(stat, subname, cause_c = cause_c, err = err)
  5512     & time, varname, array, &  ! (in)
  5533     use gtool_history, only: gt_history, historyput, historyinitialized, &
  5534       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  5541     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  5548     real(DP), 
intent(in):: time
  5550     character(*), 
intent(in):: varname
  5552     integer, 
intent(in), 
target:: array(:,:,:)
  5554     logical, 
intent(out), 
optional:: err
  5557     type(gt_history), 
pointer:: gthist =>null()
  5561                         integer, 
pointer:: array_slice(:,:,:) =>null()
  5563     integer, 
pointer:: array_avr(:,:,:) =>null()
  5568     character(STRING):: cause_c
  5569     integer, 
save:: svnum = 1, svtstep
  5570     character(*), 
parameter:: subname = 
"HistoryAutoPutInt3"  5572     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  5579     if ( .not. initialized ) 
then  5581       cause_c = 
'gtool_historyauto'  5588     if ( time < zero_time ) 
then  5591         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  5592         & c1 = trim( cause_c ), c2 = trim( varname ) )
  5602       do i = svnum, numvars
  5603         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5609         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5634       & stime_index = svtstep )  
  5639     if ( create_timing_vars(vnum, svtstep) &
  5640       &  .and. .not. histaddvar_vars(vnum)   ) 
then  5642         & varname_vars(vnum), time )                           
  5643       histaddvar_vars(vnum) = .true.
  5644       if ( flag_output_prev_vars(vnum) ) 
then  5645         prev_outtime_vars(vnum) = time
  5647         flag_output_prev_vars(vnum) = .true.
  5648         if ( origin_time_vars(vnum) > zero_time ) 
then  5649           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  5651           prev_outtime_vars(vnum) = time
  5656     if ( close_timing_vars(vnum, svtstep) ) 
then  5657       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5662     if ( renew_timing_vars(vnum, svtstep) ) 
then  5663       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5667         & varname_vars(vnum), time )                           
  5668       newfile_createtime_vars(vnum) = time
  5669       prev_outtime_vars(vnum) = time
  5675     if (       .not. output_timing_vars(vnum, svtstep) &
  5676       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  5684     gthist => gthst_history_vars(vnum) % gthist
  5690                         sv => slice_vars(vnum)
  5699     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  5700                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  5702       & , sv%st(3):sv%ed(3):sv%sd(3) &
  5711                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  5712       array_avr => array_slice
  5715         & array_slice, space_avr_vars(vnum) % avr, &   
  5716                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  5718         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  5720         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  5732     if (      output_timing_vars(vnum, svtstep) &
  5733       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  5736         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  5742     if ( output_timing_vars(vnum, svtstep) ) 
then  5744         & history = gthist, &   
  5751     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  5756         & timed = settime, &      
  5757         & time_average_store = &
  5758         &   .not. output_timing_vars(vnum, svtstep), & 
  5759         & history = gthist )                  
  5765         & history = gthist )      
  5771     if ( output_timing_vars(vnum, svtstep) ) 
then  5772       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  5773         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  5775         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  5776           prev_outtime_vars(vnum) = time
  5778           prev_outtime_vars(vnum) = &
  5779             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  5788                         nullify( array_avr, array_slice )
  5792     call storeerror(stat, subname, cause_c = cause_c, err = err)
  5798     & time, varname, array, &  ! (in)
  5819     use gtool_history, only: gt_history, historyput, historyinitialized, &
  5820       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  5827     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  5834     real(DP), 
intent(in):: time
  5836     character(*), 
intent(in):: varname
  5838     integer, 
intent(in), 
target:: array(:,:,:,:)
  5840     logical, 
intent(out), 
optional:: err
  5843     type(gt_history), 
pointer:: gthist =>null()
  5847                         integer, 
pointer:: array_slice(:,:,:,:) =>null()
  5849     integer, 
pointer:: array_avr(:,:,:,:) =>null()
  5854     character(STRING):: cause_c
  5855     integer, 
save:: svnum = 1, svtstep
  5856     character(*), 
parameter:: subname = 
"HistoryAutoPutInt4"  5858     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  5865     if ( .not. initialized ) 
then  5867       cause_c = 
'gtool_historyauto'  5874     if ( time < zero_time ) 
then  5877         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  5878         & c1 = trim( cause_c ), c2 = trim( varname ) )
  5888       do i = svnum, numvars
  5889         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5895         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  5920       & stime_index = svtstep )  
  5925     if ( create_timing_vars(vnum, svtstep) &
  5926       &  .and. .not. histaddvar_vars(vnum)   ) 
then  5928         & varname_vars(vnum), time )                           
  5929       histaddvar_vars(vnum) = .true.
  5930       if ( flag_output_prev_vars(vnum) ) 
then  5931         prev_outtime_vars(vnum) = time
  5933         flag_output_prev_vars(vnum) = .true.
  5934         if ( origin_time_vars(vnum) > zero_time ) 
then  5935           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  5937           prev_outtime_vars(vnum) = time
  5942     if ( close_timing_vars(vnum, svtstep) ) 
then  5943       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5948     if ( renew_timing_vars(vnum, svtstep) ) 
then  5949       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  5953         & varname_vars(vnum), time )                           
  5954       newfile_createtime_vars(vnum) = time
  5955       prev_outtime_vars(vnum) = time
  5961     if (       .not. output_timing_vars(vnum, svtstep) &
  5962       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  5970     gthist => gthst_history_vars(vnum) % gthist
  5976                         sv => slice_vars(vnum)
  5987     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  5988                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  5990       & , sv%st(3):sv%ed(3):sv%sd(3) &
  5992       & , sv%st(4):sv%ed(4):sv%sd(4) &
  6001                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  6002       array_avr => array_slice
  6005         & array_slice, space_avr_vars(vnum) % avr, &   
  6006                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  6008         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  6010         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  6012         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  6024     if (      output_timing_vars(vnum, svtstep) &
  6025       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  6028         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  6034     if ( output_timing_vars(vnum, svtstep) ) 
then  6036         & history = gthist, &   
  6043     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  6048         & timed = settime, &      
  6049         & time_average_store = &
  6050         &   .not. output_timing_vars(vnum, svtstep), & 
  6051         & history = gthist )                  
  6057         & history = gthist )      
  6063     if ( output_timing_vars(vnum, svtstep) ) 
then  6064       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  6065         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  6067         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  6068           prev_outtime_vars(vnum) = time
  6070           prev_outtime_vars(vnum) = &
  6071             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  6080                         nullify( array_avr, array_slice )
  6084     call storeerror(stat, subname, cause_c = cause_c, err = err)
  6090     & time, varname, array, &  ! (in)
  6111     use gtool_history, only: gt_history, historyput, historyinitialized, &
  6112       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  6119     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  6126     real(DP), 
intent(in):: time
  6128     character(*), 
intent(in):: varname
  6130     integer, 
intent(in), 
target:: array(:,:,:,:,:)
  6132     logical, 
intent(out), 
optional:: err
  6135     type(gt_history), 
pointer:: gthist =>null()
  6139                         integer, 
pointer:: array_slice(:,:,:,:,:) =>null()
  6141     integer, 
pointer:: array_avr(:,:,:,:,:) =>null()
  6146     character(STRING):: cause_c
  6147     integer, 
save:: svnum = 1, svtstep
  6148     character(*), 
parameter:: subname = 
"HistoryAutoPutInt5"  6150     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  6157     if ( .not. initialized ) 
then  6159       cause_c = 
'gtool_historyauto'  6166     if ( time < zero_time ) 
then  6169         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  6170         & c1 = trim( cause_c ), c2 = trim( varname ) )
  6180       do i = svnum, numvars
  6181         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  6187         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  6212       & stime_index = svtstep )  
  6217     if ( create_timing_vars(vnum, svtstep) &
  6218       &  .and. .not. histaddvar_vars(vnum)   ) 
then  6220         & varname_vars(vnum), time )                           
  6221       histaddvar_vars(vnum) = .true.
  6222       if ( flag_output_prev_vars(vnum) ) 
then  6223         prev_outtime_vars(vnum) = time
  6225         flag_output_prev_vars(vnum) = .true.
  6226         if ( origin_time_vars(vnum) > zero_time ) 
then  6227           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  6229           prev_outtime_vars(vnum) = time
  6234     if ( close_timing_vars(vnum, svtstep) ) 
then  6235       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  6240     if ( renew_timing_vars(vnum, svtstep) ) 
then  6241       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  6245         & varname_vars(vnum), time )                           
  6246       newfile_createtime_vars(vnum) = time
  6247       prev_outtime_vars(vnum) = time
  6253     if (       .not. output_timing_vars(vnum, svtstep) &
  6254       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  6262     gthist => gthst_history_vars(vnum) % gthist
  6268                         sv => slice_vars(vnum)
  6281     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  6282                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  6284       & , sv%st(3):sv%ed(3):sv%sd(3) &
  6286       & , sv%st(4):sv%ed(4):sv%sd(4) &
  6288       & , sv%st(5):sv%ed(5):sv%sd(5) &
  6297                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  6298       array_avr => array_slice
  6301         & array_slice, space_avr_vars(vnum) % avr, &   
  6302                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  6304         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  6306         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  6308         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  6310         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  6322     if (      output_timing_vars(vnum, svtstep) &
  6323       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  6326         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  6332     if ( output_timing_vars(vnum, svtstep) ) 
then  6334         & history = gthist, &   
  6341     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  6346         & timed = settime, &      
  6347         & time_average_store = &
  6348         &   .not. output_timing_vars(vnum, svtstep), & 
  6349         & history = gthist )                  
  6355         & history = gthist )      
  6361     if ( output_timing_vars(vnum, svtstep) ) 
then  6362       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  6363         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  6365         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  6366           prev_outtime_vars(vnum) = time
  6368           prev_outtime_vars(vnum) = &
  6369             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  6378                         nullify( array_avr, array_slice )
  6382     call storeerror(stat, subname, cause_c = cause_c, err = err)
  6388     & time, varname, array, &  ! (in)
  6409     use gtool_history, only: gt_history, historyput, historyinitialized, &
  6410       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  6417     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  6424     real(DP), 
intent(in):: time
  6426     character(*), 
intent(in):: varname
  6428     integer, 
intent(in), 
target:: array(:,:,:,:,:,:)
  6430     logical, 
intent(out), 
optional:: err
  6433     type(gt_history), 
pointer:: gthist =>null()
  6437                         integer, 
pointer:: array_slice(:,:,:,:,:,:) =>null()
  6439     integer, 
pointer:: array_avr(:,:,:,:,:,:) =>null()
  6444     character(STRING):: cause_c
  6445     integer, 
save:: svnum = 1, svtstep
  6446     character(*), 
parameter:: subname = 
"HistoryAutoPutInt6"  6448     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  6455     if ( .not. initialized ) 
then  6457       cause_c = 
'gtool_historyauto'  6464     if ( time < zero_time ) 
then  6467         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  6468         & c1 = trim( cause_c ), c2 = trim( varname ) )
  6478       do i = svnum, numvars
  6479         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  6485         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  6510       & stime_index = svtstep )  
  6515     if ( create_timing_vars(vnum, svtstep) &
  6516       &  .and. .not. histaddvar_vars(vnum)   ) 
then  6518         & varname_vars(vnum), time )                           
  6519       histaddvar_vars(vnum) = .true.
  6520       if ( flag_output_prev_vars(vnum) ) 
then  6521         prev_outtime_vars(vnum) = time
  6523         flag_output_prev_vars(vnum) = .true.
  6524         if ( origin_time_vars(vnum) > zero_time ) 
then  6525           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  6527           prev_outtime_vars(vnum) = time
  6532     if ( close_timing_vars(vnum, svtstep) ) 
then  6533       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  6538     if ( renew_timing_vars(vnum, svtstep) ) 
then  6539       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  6543         & varname_vars(vnum), time )                           
  6544       newfile_createtime_vars(vnum) = time
  6545       prev_outtime_vars(vnum) = time
  6551     if (       .not. output_timing_vars(vnum, svtstep) &
  6552       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  6560     gthist => gthst_history_vars(vnum) % gthist
  6566                         sv => slice_vars(vnum)
  6581     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  6582                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  6584       & , sv%st(3):sv%ed(3):sv%sd(3) &
  6586       & , sv%st(4):sv%ed(4):sv%sd(4) &
  6588       & , sv%st(5):sv%ed(5):sv%sd(5) &
  6590       & , sv%st(6):sv%ed(6):sv%sd(6) &
  6599                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  6600       array_avr => array_slice
  6603         & array_slice, space_avr_vars(vnum) % avr, &   
  6604                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  6606         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  6608         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  6610         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  6612         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  6614         & weight_vars(vnum) % wgt6( sv%st(6):sv%ed(6):sv%sd(6) ) , &   
  6626     if (      output_timing_vars(vnum, svtstep) &
  6627       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  6630         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  6636     if ( output_timing_vars(vnum, svtstep) ) 
then  6638         & history = gthist, &   
  6645     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  6650         & timed = settime, &      
  6651         & time_average_store = &
  6652         &   .not. output_timing_vars(vnum, svtstep), & 
  6653         & history = gthist )                  
  6659         & history = gthist )      
  6665     if ( output_timing_vars(vnum, svtstep) ) 
then  6666       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  6667         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  6669         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  6670           prev_outtime_vars(vnum) = time
  6672           prev_outtime_vars(vnum) = &
  6673             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  6682                         nullify( array_avr, array_slice )
  6686     call storeerror(stat, subname, cause_c = cause_c, err = err)
  6692     & time, varname, array, &  ! (in)
  6713     use gtool_history, only: gt_history, historyput, historyinitialized, &
  6714       & historyaddvariable, historyinquire, historyvarinfoinquire, &
  6721     use dc_calendar, only: unit_symbol_sec, dccalconvertbyunit
  6728     real(DP), 
intent(in):: time
  6730     character(*), 
intent(in):: varname
  6732     integer, 
intent(in), 
target:: array(:,:,:,:,:,:,:)
  6734     logical, 
intent(out), 
optional:: err
  6737     type(gt_history), 
pointer:: gthist =>null()
  6741                         integer, 
pointer:: array_slice(:,:,:,:,:,:,:) =>null()
  6743     integer, 
pointer:: array_avr(:,:,:,:,:,:,:) =>null()
  6748     character(STRING):: cause_c
  6749     integer, 
save:: svnum = 1, svtstep
  6750     character(*), 
parameter:: subname = 
"HistoryAutoPutInt7"  6752     call beginsub(subname, 
'varname=%c', c1 = trim(varname) )
  6759     if ( .not. initialized ) 
then  6761       cause_c = 
'gtool_historyauto'  6768     if ( time < zero_time ) 
then  6771         & 
'"time=<%c>" must be positive value (varname=<%c>).', &
  6772         & c1 = trim( cause_c ), c2 = trim( varname ) )
  6782       do i = svnum, numvars
  6783         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  6789         if ( trim( varname_vars(i) ) == trim(varname) ) 
then  6814       & stime_index = svtstep )  
  6819     if ( create_timing_vars(vnum, svtstep) &
  6820       &  .and. .not. histaddvar_vars(vnum)   ) 
then  6822         & varname_vars(vnum), time )                           
  6823       histaddvar_vars(vnum) = .true.
  6824       if ( flag_output_prev_vars(vnum) ) 
then  6825         prev_outtime_vars(vnum) = time
  6827         flag_output_prev_vars(vnum) = .true.
  6828         if ( origin_time_vars(vnum) > zero_time ) 
then  6829           prev_outtime_vars(vnum) = origin_time_vars(vnum)
  6831           prev_outtime_vars(vnum) = time
  6836     if ( close_timing_vars(vnum, svtstep) ) 
then  6837       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  6842     if ( renew_timing_vars(vnum, svtstep) ) 
then  6843       if ( historyinitialized( gthst_history_vars(vnum) % gthist ) ) 
then  6847         & varname_vars(vnum), time )                           
  6848       newfile_createtime_vars(vnum) = time
  6849       prev_outtime_vars(vnum) = time
  6855     if (       .not. output_timing_vars(vnum, svtstep) &
  6856       &  .and. .not. output_timing_avr_vars(vnum, svtstep) ) 
then  6864     gthist => gthst_history_vars(vnum) % gthist
  6870                         sv => slice_vars(vnum)
  6887     array_slice => array(sv%st(1):sv%ed(1):sv%sd(1) &
  6888                             & , sv%st(2):sv%ed(2):sv%sd(2) &
  6890       & , sv%st(3):sv%ed(3):sv%sd(3) &
  6892       & , sv%st(4):sv%ed(4):sv%sd(4) &
  6894       & , sv%st(5):sv%ed(5):sv%sd(5) &
  6896       & , sv%st(6):sv%ed(6):sv%sd(6) &
  6898       & , sv%st(7):sv%ed(7):sv%sd(7) &
  6907                         if ( count(space_avr_vars(vnum) % avr) == 0 ) 
then  6908       array_avr => array_slice
  6911         & array_slice, space_avr_vars(vnum) % avr, &   
  6912                               & weight_vars(vnum) % wgt1( sv%st(1):sv%ed(1):sv%sd(1) ) , &   
  6914         & weight_vars(vnum) % wgt2( sv%st(2):sv%ed(2):sv%sd(2) ) , &   
  6916         & weight_vars(vnum) % wgt3( sv%st(3):sv%ed(3):sv%sd(3) ) , &   
  6918         & weight_vars(vnum) % wgt4( sv%st(4):sv%ed(4):sv%sd(4) ) , &   
  6920         & weight_vars(vnum) % wgt5( sv%st(5):sv%ed(5):sv%sd(5) ) , &   
  6922         & weight_vars(vnum) % wgt6( sv%st(6):sv%ed(6):sv%sd(6) ) , &   
  6924         & weight_vars(vnum) % wgt7( sv%st(7):sv%ed(7):sv%sd(7) ) , &   
  6936     if (      output_timing_vars(vnum, svtstep) &
  6937       &  .or. output_timing_avr_vars(vnum, svtstep) ) 
then  6940         & dccalconvertbyunit( time, unit_symbol_sec, interval_unitsym_vars(vnum), cal_save )
  6946     if ( output_timing_vars(vnum, svtstep) ) 
then  6948         & history = gthist, &   
  6955     if ( output_timing_avr_vars(vnum, svtstep) ) 
then  6960         & timed = settime, &      
  6961         & time_average_store = &
  6962         &   .not. output_timing_vars(vnum, svtstep), & 
  6963         & history = gthist )                  
  6969         & history = gthist )      
  6975     if ( output_timing_vars(vnum, svtstep) ) 
then  6976       if ( .not. create_timing_vars(vnum, svtstep) .and. &
  6977         &  .not. renew_timing_vars(vnum, svtstep) ) 
then  6979         if ( 
mod(time, interval_time_vars(vnum) ) == zero_time ) 
then  6980           prev_outtime_vars(vnum) = time
  6982           prev_outtime_vars(vnum) = &
  6983             & prev_outtime_vars(vnum) + interval_time_vars(vnum)
  6992                         nullify( array_avr, array_slice )
  6996     call storeerror(stat, subname, cause_c = cause_c, err = err)
  7002     & time, varname, value, &  ! (in)
  7013     character(*), 
intent(in):: varname
  7014     real(DP), 
intent(in), 
target:: value
  7015     logical, 
intent(out), 
optional:: err
  7023       & timed, varname, 
value, &  
  7030     & time, varname, array, &  ! (in)
  7041     character(*), 
intent(in):: varname
  7042     real(DP), 
intent(in), 
target:: array(:)
  7043     logical, 
intent(out), 
optional:: err
  7051       & timed, varname, array, &  
  7058     & time, varname, array, &  ! (in)
  7069     character(*), 
intent(in):: varname
  7070     real(DP), 
intent(in), 
target:: array(:,:)
  7071     logical, 
intent(out), 
optional:: err
  7079       & timed, varname, array, &  
  7086     & time, varname, array, &  ! (in)
  7097     character(*), 
intent(in):: varname
  7098     real(DP), 
intent(in), 
target:: array(:,:,:)
  7099     logical, 
intent(out), 
optional:: err
  7107       & timed, varname, array, &  
  7114     & time, varname, array, &  ! (in)
  7125     character(*), 
intent(in):: varname
  7126     real(DP), 
intent(in), 
target:: array(:,:,:,:)
  7127     logical, 
intent(out), 
optional:: err
  7135       & timed, varname, array, &  
  7142     & time, varname, array, &  ! (in)
  7153     character(*), 
intent(in):: varname
  7154     real(DP), 
intent(in), 
target:: array(:,:,:,:,:)
  7155     logical, 
intent(out), 
optional:: err
  7163       & timed, varname, array, &  
  7170     & time, varname, array, &  ! (in)
  7181     character(*), 
intent(in):: varname
  7182     real(DP), 
intent(in), 
target:: array(:,:,:,:,:,:)
  7183     logical, 
intent(out), 
optional:: err
  7191       & timed, varname, array, &  
  7198     & time, varname, array, &  ! (in)
  7209     character(*), 
intent(in):: varname
  7210     real(DP), 
intent(in), 
target:: array(:,:,:,:,:,:,:)
  7211     logical, 
intent(out), 
optional:: err
  7219       & timed, varname, array, &  
  7226     & time, varname, value, &  ! (in)
  7237     character(*), 
intent(in):: varname
  7238     real, 
intent(in), 
target:: value
  7239     logical, 
intent(out), 
optional:: err
  7247       & timed, varname, 
value, &  
  7254     & time, varname, array, &  ! (in)
  7265     character(*), 
intent(in):: varname
  7266     real, 
intent(in), 
target:: array(:)
  7267     logical, 
intent(out), 
optional:: err
  7275       & timed, varname, array, &  
  7282     & time, varname, array, &  ! (in)
  7293     character(*), 
intent(in):: varname
  7294     real, 
intent(in), 
target:: array(:,:)
  7295     logical, 
intent(out), 
optional:: err
  7303       & timed, varname, array, &  
  7310     & time, varname, array, &  ! (in)
  7321     character(*), 
intent(in):: varname
  7322     real, 
intent(in), 
target:: array(:,:,:)
  7323     logical, 
intent(out), 
optional:: err
  7331       & timed, varname, array, &  
  7338     & time, varname, array, &  ! (in)
  7349     character(*), 
intent(in):: varname
  7350     real, 
intent(in), 
target:: array(:,:,:,:)
  7351     logical, 
intent(out), 
optional:: err
  7359       & timed, varname, array, &  
  7366     & time, varname, array, &  ! (in)
  7377     character(*), 
intent(in):: varname
  7378     real, 
intent(in), 
target:: array(:,:,:,:,:)
  7379     logical, 
intent(out), 
optional:: err
  7387       & timed, varname, array, &  
  7394     & time, varname, array, &  ! (in)
  7405     character(*), 
intent(in):: varname
  7406     real, 
intent(in), 
target:: array(:,:,:,:,:,:)
  7407     logical, 
intent(out), 
optional:: err
  7415       & timed, varname, array, &  
  7422     & time, varname, array, &  ! (in)
  7433     character(*), 
intent(in):: varname
  7434     real, 
intent(in), 
target:: array(:,:,:,:,:,:,:)
  7435     logical, 
intent(out), 
optional:: err
  7443       & timed, varname, array, &  
  7450     & time, varname, value, &  ! (in)
  7461     character(*), 
intent(in):: varname
  7462     integer, 
intent(in), 
target:: value
  7463     logical, 
intent(out), 
optional:: err
  7471       & timed, varname, 
value, &  
  7478     & time, varname, array, &  ! (in)
  7489     character(*), 
intent(in):: varname
  7490     integer, 
intent(in), 
target:: array(:)
  7491     logical, 
intent(out), 
optional:: err
  7499       & timed, varname, array, &  
  7506     & time, varname, array, &  ! (in)
  7517     character(*), 
intent(in):: varname
  7518     integer, 
intent(in), 
target:: array(:,:)
  7519     logical, 
intent(out), 
optional:: err
  7527       & timed, varname, array, &  
  7534     & time, varname, array, &  ! (in)
  7545     character(*), 
intent(in):: varname
  7546     integer, 
intent(in), 
target:: array(:,:,:)
  7547     logical, 
intent(out), 
optional:: err
  7555       & timed, varname, array, &  
  7562     & time, varname, array, &  ! (in)
  7573     character(*), 
intent(in):: varname
  7574     integer, 
intent(in), 
target:: array(:,:,:,:)
  7575     logical, 
intent(out), 
optional:: err
  7583       & timed, varname, array, &  
  7590     & time, varname, array, &  ! (in)
  7601     character(*), 
intent(in):: varname
  7602     integer, 
intent(in), 
target:: array(:,:,:,:,:)
  7603     logical, 
intent(out), 
optional:: err
  7611       & timed, varname, array, &  
  7618     & time, varname, array, &  ! (in)
  7629     character(*), 
intent(in):: varname
  7630     integer, 
intent(in), 
target:: array(:,:,:,:,:,:)
  7631     logical, 
intent(out), 
optional:: err
  7639       & timed, varname, array, &  
  7646     & time, varname, array, &  ! (in)
  7657     character(*), 
intent(in):: varname
  7658     integer, 
intent(in), 
target:: array(:,:,:,:,:,:,:)
  7659     logical, 
intent(out), 
optional:: err
  7667       & timed, varname, array, &  
 
subroutine historyautoputold1real6(time, varname, array, err)
 
subroutine historyautoputint2(time, varname, array, err)
 
subroutine historyautoputreal5(time, varname, array, err)
 
subroutine historyautoputdouble0(time, varname, value, err)
 
subroutine historyautoputold1double2(time, varname, array, err)
 
subroutine historyautoputint0(time, varname, value, err)
 
subroutine historyautoputdouble2(time, varname, array, err)
 
subroutine historyautoputint1(time, varname, array, err)
 
subroutine historyautoputdouble6(time, varname, array, err)
 
type(slice_info), dimension(1:max_vars), target, save, public slice_vars
 
subroutine historyautoputold1double0(time, varname, value, err)
 
logical, save, public initialized
 
subroutine historyautoputreal0(time, varname, value, err)
 
subroutine historyautoputreal1(time, varname, array, err)
 
integer, parameter, public dc_enotinit
 
subroutine historysettime(time, history, difftime, timed)
 
subroutine historyautoputdouble4(time, varname, array, err)
 
subroutine historyautoputold1double7(time, varname, array, err)
 
subroutine historyautoputdouble5(time, varname, array, err)
 
logical, dimension(1:max_vars, 1:save_tstepnum), save, public renew_timing_vars
 
integer, save, public numvars
 
real(dp), dimension(1:max_vars), save, public interval_time_vars
 
subroutine historyautoputold1double1(time, varname, array, err)
 
subroutine historyautoputold1double4(time, varname, array, err)
 
subroutine historyautoputdouble1(time, varname, array, err)
 
type(space_avr_info), dimension(1:max_vars), target, save, public space_avr_vars
 
integer, parameter, public token
単語やキーワードを保持する文字型変数の種別型パラメタ 
 
logical, dimension(1:max_vars, 1:save_tstepnum), save, public output_timing_vars
 
subroutine historyautoputold1int3(time, varname, array, err)
 
subroutine historyautoputold1double3(time, varname, array, err)
 
subroutine historyautoputint6(time, varname, array, err)
 
logical, dimension(1:max_vars, 1:save_tstepnum), save, public output_timing_avr_vars
 
subroutine historyautoputold1real2(time, varname, array, err)
 
subroutine historyautoputreal7(time, varname, array, err)
 
subroutine, public storeerror(number, where, err, cause_c, cause_i)
 
integer, parameter, public dc_noerr
 
subroutine historyautoputreal4(time, varname, array, err)
 
subroutine historyautoputold1real7(time, varname, array, err)
 
subroutine historyautoputreal2(time, varname, array, err)
 
integer, parameter, public hst_ebadvarname
 
logical, dimension(1:max_vars), save, public flag_output_prev_vars
 
subroutine historyautoputold1int4(time, varname, array, err)
 
real(dp), dimension(1:max_vars), save, public origin_time_vars
 
subroutine historyclose(history, quiet, err)
 
logical, dimension(1:max_vars, 1:save_tstepnum), save, public create_timing_vars
 
integer, parameter, public dp
倍精度実数型変数 
 
subroutine, public beginsub(name, fmt, i, r, d, L, n, c1, c2, c3, ca, version)
 
integer, dimension(1:max_vars), save, public interval_unitsym_vars
 
subroutine historyautoputint5(time, varname, array, err)
 
subroutine historyautoputold1int7(time, varname, array, err)
 
subroutine historyautoputold1double5(time, varname, array, err)
 
subroutine historyautoputold1int5(time, varname, array, err)
 
subroutine historyautoputold1real0(time, varname, value, err)
 
subroutine historyautoputold1int1(time, varname, array, err)
 
subroutine historyautoputold1int2(time, varname, array, err)
 
character(token), dimension(1:max_vars), save, public varname_vars
 
subroutine historyautoputreal3(time, varname, array, err)
 
real(dp), dimension(1:max_vars), save, public prev_outtime_vars
 
subroutine historyautoputold1real5(time, varname, array, err)
 
subroutine historyautoputint3(time, varname, array, err)
 
logical, dimension(1:max_vars), save, public histaddvar_vars
 
subroutine historyautoputold1int0(time, varname, value, err)
 
integer, parameter, public gt_eargsizemismatch
 
real(dp), save, public zero_time
 
subroutine historyautoputold1real1(time, varname, array, err)
 
subroutine historyautoputdouble7(time, varname, array, err)
 
integer, save, public numdims
 
subroutine historyautoputint4(time, varname, array, err)
 
subroutine historyautoputold1int6(time, varname, array, err)
 
type(gthst_nmlinfo), save, public gthstnml
 
subroutine historyautoputreal6(time, varname, array, err)
 
subroutine historyautoputold1real4(time, varname, array, err)
 
subroutine, public endsub(name, fmt, i, r, d, L, n, c1, c2, c3, ca)
 
subroutine historyautoputint7(time, varname, array, err)
 
type(dc_cal), save, public cal_save
 
type(axes_weight), dimension(1:max_vars), target, save, public weight_vars
 
type(gt_history_multi), dimension(1:max_vars), save, public gthst_history_vars
 
real(dp), dimension(1:max_vars), save, public newfile_createtime_vars
 
subroutine historyautoputold1real3(time, varname, array, err)
 
logical, dimension(1:max_vars, 1:save_tstepnum), save, public close_timing_vars
 
integer, parameter, public dc_enegative
 
subroutine historyautoputold1double6(time, varname, array, err)
 
subroutine historyautoputdouble3(time, varname, array, err)
 
integer, parameter, public string
文字列を保持する 文字型変数の種別型パラメタ