Changeset 6688 for TOOLS


Ignore:
Timestamp:
12/06/23 10:13:00 (5 months ago)
Author:
omamce
Message:

O.M. :

WATER_BUDGET : put function common to ATM and OCE in WAterUtils library

use of dictionary for all input parameters

Location:
TOOLS/WATER_BUDGET
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • TOOLS/WATER_BUDGET/ATM_waterbudget.py

    r6676 r6688  
    2525import sys 
    2626import os 
     27import types 
    2728import configparser 
    2829 
    … …  
    5152print ("Output file : ", FullIniFile ) 
    5253 
    53 ## Experiment parameters 
    54 ## -------------------- 
     54## Experiment parameters : read in .ini file 
     55## ----------------------------------------- 
    5556dpar = wu.ReadConfig ( IniFile ) 
    5657 
    … …  
    9495def kg2myear (pval, rho=ATM_RHO) : 
    9596    '''From kg to m/year''' 
    96     return pval/ATM_aire_sea_tot/rho/NbYear 
     97    return pval/ATM.aire_sea_tot/rho/NbYear 
    9798 
    9899def var2prt (pvar, small=False, rho=ATM_RHO) : 
    … …  
    121122## ------------------ 
    122123d_ATM_his = xr.open_dataset ( file_ATM_his, use_cftime=True, decode_times=True, decode_cf=True ).squeeze() 
    123 if SRF : 
     124if SECHIBA : 
    124125    d_SRF_his = xr.open_dataset ( file_SRF_his, use_cftime=True, decode_times=True, decode_cf=True ).squeeze() 
    125126    if Routing == 'SECHIBA' : d_RUN_his = d_SRF_his 
    … …  
    127128 
    128129echo ( f'{file_ATM_his = }' ) 
    129 if SRF : 
     130if SECHIBA : 
    130131    echo ( f'{file_SRF_his = }' ) 
    131132     
    … …  
    135136echo ( f'\nRun length : {(dtime/np.timedelta64(1, "D")).values:8.2f} days' ) 
    136137dtime_sec = (dtime/np.timedelta64(1, "s")).values.item() # Convert in seconds 
     138dpar['Experiment']['dtime_sec'] = dtime_sec 
    137139 
    138140##-- Compute length of each period 
    … …  
    142144dtime_per_sec = xr.DataArray (dtime_per_sec, dims=["time_counter", ], coords=[d_ATM_his.time_counter,] ) 
    143145dtime_per_sec.attrs['unit'] = 's' 
     146dpar['Experiment']['dtime_per_sec'] = dtime_per_sec 
    144147 
    145148##-- Number of years (approximative) 
    146149NbYear = dtime_sec / YEAR_LENGTH 
     150dpar['Experiment']['NbYear'] = NbYear 
    147151 
    148152## Define restart periods and file names 
    149153## ------------------------------------- 
    150 dpar = wu.SetRestartNames ( dpar, f_out)  
     154dpar = wu.SetRestartNames ( dpar, f_out )  
    151155 
    152156## Put dpar values in local namespace 
    … …  
    159163         
    160164## Extract restart files from tar 
    161 ## ---------------------------------- 
    162  
     165## ------------------------------ 
    163166liste_beg = [file_ATM_beg, ] 
    164167liste_end = [file_ATM_end, ] 
    … …  
    173176    dpar['Files']['file_DYN_aire'] = file_DYN_aire 
    174177 
    175 if SRF and Routing == 'SIMPLE' : 
     178if SECHIBA and Routing == 'SIMPLE' : 
    176179    liste_beg.append ( file_RUN_beg ) 
    177180    liste_end.append ( file_RUN_end ) 
    178181 
    179182echo ( '\nExtract restart files from tar : ATM, ICO', end='') 
    180 if SRF : echo ( ' and SRF') 
     183if SECHIBA : echo ( ' and SECHIBA') 
    181184else   : echo (' ') 
    182185 
    … …  
    228231ErrorCount = 0 
    229232 
     233echo ( f'Extract {file_ATM_beg = }' ) 
    230234ErrorCount += extract ( file_name=file_ATM_beg, tar_restart=tar_restart_beg_ATM, file_dir_comp=FileDir ) 
     235echo ( f'Extract {file_DYN_beg = }' ) 
    231236ErrorCount += extract ( file_name=file_DYN_beg, tar_restart=tar_restart_beg_DYN, file_dir_comp=FileDir ) 
    232237 
     238echo ( f'Extract {file_ATM_end = }' ) 
    233239ErrorCount += extract ( file_name=file_ATM_end, tar_restart=tar_restart_end_ATM, file_dir_comp=FileDir ) 
     240echo ( f'Extract {file_DYN_end = }' ) 
    234241ErrorCount += extract ( file_name=file_DYN_end, tar_restart=tar_restart_end_DYN, file_dir_comp=FileDir ) 
    235242 
    236 if SRF : 
     243if SECHIBA : 
     244    echo ( f'Extract {file_SRF_beg = }' ) 
    237245    ErrorCount += extract ( file_name=file_SRF_beg, tar_restart=tar_restart_beg_SRF, file_dir_comp=FileDir ) 
     246    echo ( f'Extract {file_SRF_end = }' ) 
    238247    ErrorCount += extract ( file_name=file_SRF_end, tar_restart=tar_restart_end_SRF, file_dir_comp=FileDir ) 
    239248 
    240249    if Routing == 'SIMPLE' : 
     250        echo ( f'Extract {file_RUN_beg = }' ) 
    241251        ErrorCount += extract ( file_name=file_RUN_beg, tar_restart=tar_restart_beg_RUN, file_dir_comp=FileDir ) 
     252        echo ( f'Extract {file_RUN_end = }' ) 
    242253        ErrorCount += extract ( file_name=file_RUN_end, tar_restart=tar_restart_end_RUN, file_dir_comp=FileDir ) 
    243254 
    244 ##-- Exit in case of error in the opening file phase 
     255##-- Exit in case of error in the extracting file phase 
    245256if ErrorCount > 0 : 
    246257    echo ( '  ' ) 
    … …  
    248259 
    249260## 
    250 echo ('\nOpening ATM SRF and ICO restart files') 
     261echo ('\nOpening ATM SECHIBA and ICO restart files') 
    251262d_ATM_beg = xr.open_dataset ( os.path.join (FileDir, file_ATM_beg), decode_times=False, decode_cf=True ).squeeze() 
    252263d_ATM_end = xr.open_dataset ( os.path.join (FileDir, file_ATM_end), decode_times=False, decode_cf=True ).squeeze() 
    253 if SRF : 
     264if SECHIBA : 
    254265    d_SRF_beg = xr.open_dataset ( os.path.join (FileDir, file_SRF_beg), decode_times=False, decode_cf=True ).squeeze() 
    255266    d_SRF_end = xr.open_dataset ( os.path.join (FileDir, file_SRF_end), decode_times=False, decode_cf=True ).squeeze() 
    … …  
    257268d_DYN_end = xr.open_dataset ( os.path.join (FileDir, file_DYN_end), decode_times=False, decode_cf=True ).squeeze() 
    258269 
    259 if SRF : 
     270if SECHIBA : 
    260271    for var in d_SRF_beg.variables : 
    261272        d_SRF_beg[var] = d_SRF_beg[var].where ( d_SRF_beg[var]<1.e20, 0.) 
    … …  
    277288d_ATM_beg = to_cell ( d_ATM_beg ) 
    278289d_ATM_end = to_cell ( d_ATM_end ) 
    279 if SRF : 
     290if SECHIBA : 
    280291    d_SRF_beg = to_cell ( d_SRF_beg ) 
    281292    d_SRF_end = to_cell ( d_SRF_end ) 
    … …  
    283294d_DYN_end = to_cell ( d_DYN_end ) 
    284295 
    285 if SRF and Routing == 'SIMPLE' : 
     296if SECHIBA and Routing == 'SIMPLE' : 
    286297    d_RUN_beg = to_cell ( d_RUN_beg ) 
    287298    d_RUN_end = to_cell ( d_RUN_end ) 
    288299 
    289300d_ATM_his = to_cell ( d_ATM_his ) 
    290 if SRF : d_SRF_his = to_cell ( d_SRF_his ) 
     301if SECHIBA : d_SRF_his = to_cell ( d_SRF_his ) 
    291302 
    292303echo ( f'{file_ATM_beg = }' ) 
    … …  
    294305echo ( f'{file_DYN_beg = }' ) 
    295306echo ( f'{file_DYN_end = }' ) 
    296 if SRF : 
     307if SECHIBA : 
    297308    echo ( f'{file_SRF_beg = }' ) 
    298309    echo ( f'{file_SRF_end = }' ) 
    … …  
    301312        echo ( f'{file_RUN_end = }' ) 
    302313 
    303 # ATM grid with cell surfaces 
    304 if LMDZ : 
    305     echo ('ATM grid with cell surfaces : LMDZ') 
    306     ATM_lat       = lmdz.geo2point (   rprec (d_ATM_his ['lat'])+0*rprec (d_ATM_his ['lon']), dim1d='cell' ) 
    307     ATM_lon       = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat'])+  rprec (d_ATM_his ['lon']), dim1d='cell' ) 
    308     ATM_aire      = lmdz.geo2point ( rprec (d_ATM_his ['aire']     [0]), cumul_poles=True, dim1d='cell' ) 
    309     ATM_fter      = lmdz.geo2point ( rprec (d_ATM_his ['fract_ter'][0]), dim1d='cell' ) 
    310     ATM_foce      = lmdz.geo2point ( rprec (d_ATM_his ['fract_oce'][0]), dim1d='cell' ) 
    311     ATM_fsic      = lmdz.geo2point ( rprec (d_ATM_his ['fract_sic'][0]), dim1d='cell' ) 
    312     ATM_flic      = lmdz.geo2point ( rprec (d_ATM_his ['fract_lic'][0]), dim1d='cell' ) 
    313     if SRF : 
    314         SRF_lat       = lmdz.geo2point (   rprec (d_SRF_his ['lat'])+0*rprec (d_SRF_his ['lon']), dim1d='cell' ) 
    315         SRF_lon       = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat'])+  rprec (d_SRF_his ['lon']), dim1d='cell' ) 
    316         SRF_aire      = lmdz.geo2point ( rprec (d_SRF_his ['Areas']) * rprec (d_SRF_his ['Contfrac']), dim1d='cell', cumul_poles=True ) 
    317         SRF_areas     = lmdz.geo2point ( rprec (d_SRF_his ['Areas'])  ,  dim1d='cell', cumul_poles=True ) 
    318         SRF_contfrac  = lmdz.geo2point ( rprec (d_SRF_his ['Contfrac']), dim1d='cell' ) 
    319  
    320 if ICO : 
    321     if ATM_HIS == 'latlon' : 
    322         echo ( 'ATM areas and fractions on LATLON grid' ) 
    323         if 'lat_dom_out' in d_ATM_his.variables : 
    324             ATM_lat  = lmdz.geo2point (   rprec (d_ATM_his ['lat_dom_out'])+0*rprec (d_ATM_his ['lon_dom_out']), dim1d='cell' ) 
    325             ATM_lon  = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat_dom_out'])+  rprec (d_ATM_his ['lon_dom_out']), dim1d='cell' ) 
    326         else : 
    327             ATM_lat  = lmdz.geo2point (   rprec (d_ATM_his ['lat'])+0*rprec (d_ATM_his ['lon']), dim1d='cell' ) 
    328             ATM_lon  = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat'])+  rprec (d_ATM_his ['lon']), dim1d='cell' ) 
    329         ATM_aire = lmdz.geo2point ( rprec (d_ATM_his ['aire'][0]).squeeze(), cumul_poles=True, dim1d='cell' ) 
    330         ATM_fter = lmdz.geo2point ( rprec (d_ATM_his ['fract_ter'][0]), dim1d='cell' ) 
    331         ATM_foce = lmdz.geo2point ( rprec (d_ATM_his ['fract_oce'][0]), dim1d='cell' ) 
    332         ATM_fsic = lmdz.geo2point ( rprec (d_ATM_his ['fract_sic'][0]), dim1d='cell' ) 
    333         ATM_flic = lmdz.geo2point ( rprec (d_ATM_his ['fract_lic'][0]), dim1d='cell' ) 
    334  
    335     if ATM_HIS == 'ico' : 
    336         echo ( 'ATM areas and fractions on ICO grid' ) 
    337         ATM_aire =  rprec (d_ATM_his ['aire']     [0]).squeeze() 
    338         ATM_lat  =  rprec (d_ATM_his ['lat']         ) 
    339         ATM_lon  =  rprec (d_ATM_his ['lon']         ) 
    340         ATM_fter =  rprec (d_ATM_his ['fract_ter'][0]) 
    341         ATM_foce =  rprec (d_ATM_his ['fract_oce'][0]) 
    342         ATM_fsic =  rprec (d_ATM_his ['fract_sic'][0]) 
    343         ATM_flic =  rprec (d_ATM_his ['fract_lic'][0]) 
    344  
    345     if SRF : 
    346         if SRF_HIS == 'latlon' : 
    347             echo ( 'SRF areas and fractions on LATLON grid' ) 
    348             if 'lat_domain_landpoints_out' in d_SRF_his  : 
    349                 SRF_lat  = lmdz.geo2point (   rprec (d_SRF_his ['lat_domain_landpoints_out'])+0*rprec (d_SRF_his ['lon_domain_landpoints_out']), dim1d='cell' ) 
    350                 SRF_lon  = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat_domain_landpoints_out'])+  rprec (d_SRF_his ['lon_domain_landpoints_out']), dim1d='cell' ) 
    351             else : 
    352                 if 'lat_domain_landpoints_out' in d_SRF_his : 
    353                     SRF_lat  = lmdz.geo2point (   rprec (d_SRF_his ['lat_dom_out'])+0*rprec (d_SRF_his ['lon_dom_out']), dim1d='cell' ) 
    354                     SRF_lon  = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat_dom_out'])+  rprec (d_SRF_his ['lon_dom_out']), dim1d='cell' ) 
    355                 else : 
    356                     SRF_lat  = lmdz.geo2point (   rprec (d_SRF_his ['lat'])+0*rprec (d_SRF_his ['lon']), dim1d='cell' ) 
    357                     SRF_lon  = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat'])+  rprec (d_SRF_his ['lon']), dim1d='cell' ) 
    358  
    359             SRF_areas     = lmdz.geo2point ( rprec (d_SRF_his ['Areas']   )   , dim1d='cell', cumul_poles=True ) 
    360             SRF_areafrac  = lmdz.geo2point ( rprec (d_SRF_his ['AreaFrac'])   , dim1d='cell', cumul_poles=True ) 
    361             SRF_contfrac  = lmdz.geo2point ( rprec (d_SRF_his ['Contfrac'])   , dim1d='cell', cumul_poles=True ) 
    362             SRF_aire = SRF_areafrac 
    363  
    364         if SRF_HIS == 'ico' : 
    365             echo ( 'SRF areas and fractions on ICO grid' ) 
    366             SRF_lat       =  rprec (d_SRF_his ['lat']     ) 
    367             SRF_lon       =  rprec (d_SRF_his ['lon']     ) 
    368             SRF_areas     =  rprec (d_SRF_his ['Areas']   ) 
    369             SRF_contfrac  =  rprec (d_SRF_his ['Contfrac']) 
    370             SRF_aire      =  SRF_areas * SRF_contfrac 
    371  
    372 ATM_fsea      = ATM_foce + ATM_fsic 
    373 ATM_flnd      = ATM_fter + ATM_flic 
    374 ATM_aire_fter = ATM_aire * ATM_fter 
    375 ATM_aire_flic = ATM_aire * ATM_flic 
    376 ATM_aire_fsic = ATM_aire * ATM_fsic 
    377 ATM_aire_foce = ATM_aire * ATM_foce 
    378 ATM_aire_flnd = ATM_aire * ATM_flnd 
    379 ATM_aire_fsea = ATM_aire * ATM_fsea 
    380  
    381 #SRF_aire = SRF_aire.where ( np.abs (SRF_aire) < 1E15, 0. ) 
    382  
     314## Compute aire, fractions, etc ... 
     315## -------------------------------- 
    383316if ICO : 
    384317    # Area on icosahedron grid 
    385     echo ( f'{file_DYN_aire = }' ) 
     318    #echo ( f'{file_DYN_aire = }' ) 
    386319    d_DYN_aire = xr.open_dataset ( file_DYN_aire, decode_times=False ).squeeze() 
    387      
    388     if SortIco : 
    389             # Creation d'une clef de tri pour le fichier aire 
    390             DYN_aire_keysort = np.lexsort ( (d_DYN_aire['lat'], d_DYN_aire['lon']) ) 
    391     else : 
    392             DYN_aire_keysort = np.arange ( len ( d_DYN_aire['lat'] ) ) 
    393              
    394     DYN_lat = d_DYN_aire['lat'] 
    395     DYN_lon = d_DYN_aire['lon'] 
     320else : 
     321    d_DYN_aire = None 
    396322         
    397     DYN_aire = d_DYN_aire['aire'] 
    398     DYN_fsea = d_DYN_aire['fract_oce'] + d_DYN_aire['fract_sic'] 
    399          
    400     DYN_flnd = 1.0 - DYN_fsea 
    401     DYN_fter = d_ATM_beg['FTER'] 
    402     DYN_flic = d_ATM_beg['FLIC'] 
    403     DYN_foce = d_ATM_beg['FOCE'] 
    404     DYN_aire_fter = DYN_aire * DYN_fter 
    405  
    406 #if ATM_HIS == 'ico' : 
    407 #    ATM_aire      = DYN_aire 
    408 #    ATM_aire_fter = DYN_aire * ATM_fter 
    409 #    ATM_aire_flic = DYN_aire * ATM_flic 
    410 #    ATM_aire_fsic = DYN_aire * ATM_fsic 
    411 #    ATM_aire_foce = DYN_aire * ATM_foce 
    412 #    ATM_aire_flnd = DYN_aire * ATM_flnd 
    413 #    ATM_aire_fsea = DYN_aire * ATM_fsea 
    414  
    415 if ATM_HIS == 'ico' : 
    416     DYN_aire      = ATM_aire 
    417     DYN_foce      = ATM_foce 
    418     DYN_fsic      = ATM_fsic 
    419     DYN_flic      = ATM_flic 
    420     DYN_fter      = ATM_fter 
    421     DYN_fsea      = ATM_fsea 
    422     DYN_flnd      = ATM_flnd 
    423     DYN_aire_fter = ATM_aire_fter 
    424     DYN_aire_flic = ATM_aire_flic 
    425     DYN_aire_fsic = ATM_aire_fsic 
    426     DYN_aire_foce = ATM_aire_foce 
    427     DYN_aire_flnd = ATM_aire_flnd 
    428     DYN_aire_fsea = ATM_aire_fsea 
    429  
    430 if LMDZ : 
    431     # Area on lon/lat grid 
    432     DYN_aire = ATM_aire 
    433     DYN_fsea = ATM_fsea 
    434     DYN_flnd = ATM_flnd 
    435     DYN_fter = rprec (d_ATM_beg['FTER']) 
    436     DYN_flic = rprec (d_ATM_beg['FLIC']) 
    437     DYN_aire_fter = DYN_aire * DYN_fter 
     323dpar, ATM = wu.ComputeGridATM ( dpar, d_ATM_his )  
     324dpar, SRF = wu.ComputeGridSRF ( dpar, d_SRF_his ) 
     325dpar, DYN = wu.ComputeGridDYN ( dpar, ATM, d_DYN_aire, d_ATM_beg ) 
    438326 
    439327if ICO and ATM_HIS == 'ico' : 
    440328    # Comparaison des aires sur ATM et DYN 
    441     aire_diff = ATM_aire - DYN_aire 
    442     echo ( 'f{Difference Aire hist file vs. grid file {aire_diff.mean()=} {aire_diff.min()=}  {aire_diff.max()=} ' ) 
    443      
     329    aire_diff = ATM.aire - DYN.aire 
     330    echo ( f'Difference Aire hist file vs. grid file mean:{aire_diff.mean().values} min:{aire_diff.min().values} max:{aire_diff.max().values} ' ) 
    444331 
    445332# Functions computing integrals and sum 
    … …  
    447334def DYN_stock_int (stock) : 
    448335    '''Integrate (* surface) stock on atmosphere grid''' 
    449     return wu.Psum ( (stock * DYN_aire).to_masked_array().ravel() ) 
     336    return wu.P1sum ( stock * DYN.aire ) 
    450337 
    451338@Timer 
    452339def ATM_flux_int (flux) : 
    453340    '''Integrate (* time * surface) flux on atmosphere grid''' 
    454     return wu.Psum ( (flux * dtime_per_sec * ATM_aire).to_masked_array().ravel() ) 
     341    return wu.P1sum ( flux * dtime_per_sec * ATM.aire ) 
    455342 
    456343@Timer 
    457344def LIC_flux_int (flux) : 
    458345    '''Integrate (* time * surface) flux on land ice grid''' 
    459     return wu.Psum ( (flux * dtime_per_sec * ATM_aire_flic).to_masked_array().ravel() ) 
    460  
    461 if SRF : 
     346    return wu.P1sum ( flux * dtime_per_sec * ATM.aire_flic ) 
     347 
     348if SECHIBA : 
    462349    @Timer 
    463350    def SRF_stock_int (stock) : 
    464351        '''Integrate (* surface) stock on land grid''' 
    465         return wu.Ksum (  ( (stock * DYN_aire_fter).to_masked_array().ravel()) ) 
     352        return wu.P1sum ( stock * DYN.aire_fter ) 
    466353 
    467354    @Timer 
    468355    def SRF_flux_int (flux) : 
    469356        '''Integrate (* time * surface) flux on land grid''' 
    470         return wu.Psum (  (flux * dtime_per_sec * SRF_aire).to_masked_array().ravel() ) 
     357        return wu.P1sum ( flux * dtime_per_sec * SRF.aire ) 
    471358 
    472359@Timer 
    473360def ONE_stock_int (stock) : 
    474361    '''Sum stock''' 
    475     return wu.Psum ( stock.to_masked_array().ravel() ) 
     362    return wu.P1sum ( stock )  
    476363 
    477364@Timer 
    … …  
    485372    return wu.Psum ( np.array ( tlist) ) 
    486373 
    487 ATM_aire_sea     = ATM_aire * ATM_fsea 
    488  
    489 ATM_aire_tot     = ONE_stock_int (ATM_aire) 
    490 ATM_aire_sea_tot = ONE_stock_int (ATM_aire_fsea) 
    491 ATM_aire_ter_tot = ONE_stock_int (ATM_aire_fter) 
    492 ATM_aire_lic_tot = ONE_stock_int (ATM_aire_flic) 
    493  
    494 DYN_aire_tot     = ONE_stock_int ( DYN_aire ) 
    495 if SRF : SRF_aire_tot     = ONE_stock_int ( SRF_aire ) 
    496  
    497374echo ('') 
    498 echo ( f'ATM DYN : Area of atmosphere        : {DYN_aire_tot:18.9e}' ) 
    499 echo ( f'ATM HIS : Area of atmosphere        : {ATM_aire_tot:18.9e}' ) 
    500 echo ( f'ATM HIS : Area of ter in atmosphere : {ATM_aire_ter_tot:18.9e}' ) 
    501 echo ( f'ATM HIS : Area of lic in atmosphere : {ATM_aire_lic_tot:18.9e}' ) 
    502 if SRF : 
    503     echo ( f'ATM SRF : Area of atmosphere        : {SRF_aire_tot:18.9e}' ) 
     375echo ( f'ATM DYN : Area of atmosphere        : {DYN.aire_tot:18.9e}' ) 
     376echo ( f'ATM HIS : Area of atmosphere        : {ATM.aire_tot:18.9e}' ) 
     377echo ( f'ATM HIS : Area of ter in atmosphere : {ATM.aire_ter_tot:18.9e}' ) 
     378echo ( f'ATM HIS : Area of lic in atmosphere : {ATM.aire_lic_tot:18.9e}' ) 
     379if SECHIBA : 
     380    echo ( f'ATM SECHIBA : Area of atmosphere        : {SRF.aire_tot:18.9e}' ) 
    504381echo ('') 
    505 echo ( 'ATM DYN : Area of atmosphere/(4pi R^2)        : {:18.9f}'.format(DYN_aire_tot/(RA*RA*4*np.pi) ) ) 
    506 echo ( 'ATM HIS : Area of atmosphere/(4pi R^2)        : {:18.9f}'.format(ATM_aire_tot/(RA*RA*4*np.pi) ) ) 
    507 echo ( 'ATM HIS : Area of ter in atmosphere/(4pi R^2) : {:18.9f}'.format(ATM_aire_ter_tot/(RA*RA*4*np.pi) ) ) 
    508 if SRF : 
    509     echo ( 'ATM SRF : Area of atmosphere/(4pi R^2)        : {:18.9f}'.format(SRF_aire_tot/(RA*RA*4*np.pi) ) ) 
     382echo ( 'ATM DYN : Area of atmosphere/(4pi R^2)        : {:18.9f}'.format(DYN.aire_tot/(RA*RA*4*np.pi) ) ) 
     383echo ( 'ATM HIS : Area of atmosphere/(4pi R^2)        : {:18.9f}'.format(ATM.aire_tot/(RA*RA*4*np.pi) ) ) 
     384echo ( 'ATM HIS : Area of ter in atmosphere/(4pi R^2) : {:18.9f}'.format(ATM.aire_ter_tot/(RA*RA*4*np.pi) ) ) 
     385if SECHIBA : 
     386    echo ( 'ATM SECHIBA : Area of atmosphere/(4pi R^2)        : {:18.9f}'.format(SRF.aire_tot/(RA*RA*4*np.pi) ) ) 
    510387    echo ('') 
    511     echo ( f'ATM SRF : Area of atmosphere (no contfrac): {ONE_stock_int (SRF_areas):18.9e}' ) 
    512  
    513  
    514 if np.abs (ATM_aire_tot/(RA*RA*4*np.pi) - 1.0) > 0.01 : 
     388    echo ( f'ATM SECHIBA : Area of atmosphere (no contfrac): {ONE_stock_int (SRF.areas):18.9e}' ) 
     389 
     390 
     391if np.abs (ATM.aire_tot/(RA*RA*4*np.pi) - 1.0) > 0.01 : 
    515392    raise RuntimeError ('Error of atmosphere surface interpolated on lon/lat grid') 
    516393 
    … …  
    522399 
    523400echo ( 'ATM vertical grid' ) 
    524 ATM_Ahyb = d_ATM_his['Ahyb'].squeeze() 
    525 ATM_Bhyb = d_ATM_his['Bhyb'].squeeze() 
     401ATM.Ahyb = d_ATM_his['Ahyb'].squeeze() 
     402ATM.Bhyb = d_ATM_his['Bhyb'].squeeze() 
    526403 
    527404echo ( 'Surface pressure' ) 
    528405if ICO : 
    529     DYN_psol_beg = d_DYN_beg['ps'] 
    530     DYN_psol_end = d_DYN_end['ps'] 
     406    DYN.psol_beg = d_DYN_beg['ps'] 
     407    DYN.psol_end = d_DYN_end['ps'] 
    531408if LMDZ : 
    532     DYN_psol_beg = lmdz.geo2point ( d_DYN_beg['ps'].isel(rlonv=slice(0,-1)), dim1d='cell' ) 
    533     DYN_psol_end = lmdz.geo2point ( d_DYN_end['ps'].isel(rlonv=slice(0,-1)), dim1d='cell' ) 
    534  
    535 echo ( '3D Pressure at the interface layers (not scalar points)' ) 
    536 DYN_pres_beg = ATM_Ahyb + ATM_Bhyb * DYN_psol_beg 
    537 DYN_pres_end = ATM_Ahyb + ATM_Bhyb * DYN_psol_end 
     409    DYN.psol_beg = lmdz.geo2point ( d_DYN_beg['ps'].isel(rlonv=slice(0,-1)), dim1d='cell' ) 
     410    DYN.psol_end = lmdz.geo2point ( d_DYN_end['ps'].isel(rlonv=slice(0,-1)), dim1d='cell' ) 
     411 
     412echo ( '3D Pressure at the interface layers (not at scalar points)' ) 
     413DYN.pres_beg = ATM.Ahyb + ATM.Bhyb * DYN.psol_beg 
     414DYN.pres_end = ATM.Ahyb + ATM.Bhyb * DYN.psol_end 
    538415 
    539416echo ( 'Check computation of pressure levels' ) 
    … …  
    541418ind = np.empty (8) 
    542419 
    543 ind[0] = (DYN_pres_beg[ 0]-DYN_psol_beg).min().item() 
    544 ind[1] = (DYN_pres_beg[ 0]-DYN_psol_beg).max().item() 
    545 ind[2] = (DYN_pres_beg[-1]).min().item() 
    546 ind[3] = (DYN_pres_beg[-1]).max().item() 
    547 ind[4] = (DYN_pres_end[ 0]-DYN_psol_end).min().item() 
    548 ind[5] = (DYN_pres_end[ 0]-DYN_psol_end).max().item() 
    549 ind[6] = (DYN_pres_end[-1]).min().item() 
    550 ind[7] = (DYN_pres_end[-1]).max().item() 
     420ind[0] = (DYN.pres_beg[ 0]-DYN.psol_beg).min().item() 
     421ind[1] = (DYN.pres_beg[ 0]-DYN.psol_beg).max().item() 
     422ind[2] = (DYN.pres_beg[-1]).min().item() 
     423ind[3] = (DYN.pres_beg[-1]).max().item() 
     424ind[4] = (DYN.pres_end[ 0]-DYN.psol_end).min().item() 
     425ind[5] = (DYN.pres_end[ 0]-DYN.psol_end).max().item() 
     426ind[6] = (DYN.pres_end[-1]).min().item() 
     427ind[7] = (DYN.pres_end[-1]).max().item() 
    551428 
    552429if any ( ind != 0) : 
    553430    echo ( 'All values should be zero' ) 
    554     echo ( f'(DYN_pres_beg[ 0]-DYN_psol_beg).min().item() = {ind[0]}' ) 
    555     echo ( f'(DYN_pres_beg[ 0]-DYN_psol_beg).max().item() = {ind[1]}' ) 
    556     echo ( f'(DYN_pres_beg[-1]).min().item()              = {ind[2]}' ) 
    557     echo ( f'(DYN_pres_beg[-1]).max().item()              = {ind[3]}' ) 
    558     echo ( f'(DYN_pres_end[ 0]-DYN_psol_end).min().item() = {ind[4]}' ) 
    559     echo ( f'(DYN_pres_end[ 0]-DYN_psol_end).max().item() = {ind[5]}' ) 
    560     echo ( f'(DYN_pres_end[-1]).min().item()              = {ind[6]}' ) 
    561     echo ( f'(DYN_pres_end[-1]).max().item()              = {ind[7]}' ) 
     431    echo ( f'(DYN.pres_beg[ 0]-DYN.psol_beg).min().item() = {ind[0]}' ) 
     432    echo ( f'(DYN.pres_beg[ 0]-DYN.psol_beg).max().item() = {ind[1]}' ) 
     433    echo ( f'(DYN.pres_beg[-1]).min().item()              = {ind[2]}' ) 
     434    echo ( f'(DYN.pres_beg[-1]).max().item()              = {ind[3]}' ) 
     435    echo ( f'(DYN.pres_end[ 0]-DYN.psol_end).min().item() = {ind[4]}' ) 
     436    echo ( f'(DYN.pres_end[ 0]-DYN.psol_end).max().item() = {ind[5]}' ) 
     437    echo ( f'(DYN.pres_end[-1]).min().item()              = {ind[6]}' ) 
     438    echo ( f'(DYN.pres_end[-1]).max().item()              = {ind[7]}' ) 
    562439    raise RuntimeError 
    563440 
    564 klevp1 = ATM_Bhyb.shape[-1] 
    565 cell   = DYN_psol_beg.shape[-1] 
     441klevp1 = ATM.Bhyb.shape[-1] 
     442cell   = DYN.psol_beg.shape[-1] 
    566443klev   = klevp1 - 1 
    567444 
    568 echo ( 'Layer thickness (pressure)' ) 
    569 DYN_mass_beg = xr.DataArray ( np.empty( (klev, cell)), dims = ('sigs', 'cell'), coords=(np.arange(klev), np.arange(cell) ) ) 
    570 DYN_mass_end = xr.DataArray ( np.empty( (klev, cell)), dims = ('sigs', 'cell'), coords=(np.arange(klev), np.arange(cell) ) ) 
    571  
     445echo ( 'Layer thickness (in pressure)' ) 
     446DYN.mass_beg = xr.DataArray ( np.empty( (klev, cell)), dims = ('sigs', 'cell'), coords=(np.arange(klev), np.arange(cell) ) ) 
     447DYN.mass_end = xr.DataArray ( np.empty( (klev, cell)), dims = ('sigs', 'cell'), coords=(np.arange(klev), np.arange(cell) ) ) 
     448 
     449echo ( 'Layer mass (kg/m2)' ) 
    572450for k in np.arange (klev) : 
    573     DYN_mass_beg[k,:] = ( DYN_pres_beg[k,:] - DYN_pres_beg[k+1,:] ) / GRAV 
    574     DYN_mass_end[k,:] = ( DYN_pres_end[k,:] - DYN_pres_end[k+1,:] ) / GRAV 
    575  
    576 DYN_mass_beg_2D = DYN_mass_beg.sum (dim='sigs') 
    577 DYN_mass_end_2D = DYN_mass_end.sum (dim='sigs') 
    578  
    579 DYN_mas_air_beg = DYN_stock_int ( DYN_mass_beg_2D ) 
    580 DYN_mas_air_end = DYN_stock_int ( DYN_mass_end_2D ) 
     451    DYN.mass_beg[k,:] = ( DYN.pres_beg[k,:] - DYN.pres_beg[k+1,:] ) / GRAV 
     452    DYN.mass_end[k,:] = ( DYN.pres_end[k,:] - DYN.pres_end[k+1,:] ) / GRAV 
     453 
     454echo ( 'Column mass (kg/m2)' ) 
     455DYN.mass_beg_2D = DYN.mass_beg.sum (dim='sigs') 
     456DYN.mass_end_2D = DYN.mass_end.sum (dim='sigs') 
     457 
     458echo ( 'Atmosphere mass (kg)' ) 
     459DYN.mass_air_beg = DYN_stock_int ( DYN.mass_beg_2D ) 
     460DYN.mass_air_end = DYN_stock_int ( DYN.mass_end_2D ) 
     461 
     462echo ( 'Atmosphere mass change (kg)' ) 
     463DYN.diff_mass_air = DYN.mass_air_end - DYN.mass_air_beg 
     464 
     465echo ( f'\nChange of atmosphere mass (dynamics)  -- {Title} ' ) 
     466echo ( '------------------------------------------------------------------------------------' ) 
     467echo ( 'DYN.mass_air_beg = {:12.6e} kg | DYN.mass_air_end = {:12.6e} kg'.format (DYN.mass_air_beg, DYN.mass_air_end) ) 
     468echo ( f'dMass (atm) : {DYN.diff_mass_air:9.4e} kg' ) 
     469echo ( f'dMass (atm) : {(DYN.diff_mass_air/DYN.mass_air_beg):9.4e} (-)' ) 
    581470 
    582471echo ( 'Vertical and horizontal integral, and sum of liquid, solid and vapor water phases' ) 
    … …  
    584473    if 'H2Ov' in d_DYN_beg.variables : 
    585474        echo ('reading LATLON : H2Ov, H2Ol, H2Oi' ) 
    586         DYN_wat_beg = lmdz.geo3point ( d_DYN_beg['H2Ov'] + d_DYN_beg['H2Ol'] + d_DYN_beg['H2Oi'].isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
    587         DYN_wat_end = lmdz.geo3point ( d_DYN_end['H2Ov'] + d_DYN_end['H2Ol'] + d_DYN_end['H2Oi'].isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
    588     if 'H2Ov_g' in d_DYN_beg.variables : 
     475        DYN.wat_beg = lmdz.geo3point ( (d_DYN_beg['H2Ov']   + d_DYN_beg['H2Ol']  + d_DYN_beg['H2Oi']).isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
     476        DYN.wat_end = lmdz.geo3point ( (d_DYN_end['H2Ov']   + d_DYN_end['H2Ol']  + d_DYN_end['H2Oi']).isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
     477    if 'H2O_g' in d_DYN_beg.variables : 
    589478        echo ('reading LATLON : H2O_g, H2O_l, H2O_s' ) 
    590         DYN_wat_beg = lmdz.geo3point ( (d_DYN_beg['H2O_g'] + d_DYN_beg['H2O_l'] + d_DYN_beg['H2O_s']).isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
    591         DYN_wat_end = lmdz.geo3point ( (d_DYN_end['H2O_g'] + d_DYN_end['H2O_l'] + d_DYN_end['H2O_s']).isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
     479        DYN.wat_beg = lmdz.geo3point ( (d_DYN_beg['H2O_g'] + d_DYN_beg['H2O_l'] + d_DYN_beg['H2O_s']).isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
     480        DYN.wat_end = lmdz.geo3point ( (d_DYN_end['H2O_g'] + d_DYN_end['H2O_l'] + d_DYN_end['H2O_s']).isel(rlonv=slice(0,-1) ), dim1d='cell' ) 
    592481if ICO : 
    593     if 'H2Ov_g' in d_DYN_beg.variables : 
     482    if   'H2Ov_g' in d_DYN_beg.variables : 
    594483        echo ('reading ICO : H2Ov_g, H2Ov_l, H2Ov_s' ) 
    595         DYN_wat_beg = d_DYN_beg['H2Ov_g'] + d_DYN_beg['H2Ov_l'] + d_DYN_beg['H2Ov_s'] 
    596         DYN_wat_end = d_DYN_end['H2Ov_g'] + d_DYN_end['H2Ov_l'] + d_DYN_end['H2Ov_s'] 
    597     elif 'H2O_g' in d_DYN_beg.variables : 
     484        DYN.wat_beg = d_DYN_beg['H2Ov_g'] + d_DYN_beg['H2Ov_l'] + d_DYN_beg['H2Ov_s'] 
     485        DYN.wat_end = d_DYN_end['H2Ov_g'] + d_DYN_end['H2Ov_l'] + d_DYN_end['H2Ov_s'] 
     486    if 'H2O_g' in d_DYN_beg.variables : 
    598487        echo ('reading ICO : H2O_g, H2O_l, H2O_s' ) 
    599         DYN_wat_beg = d_DYN_beg['H2O_g'] + d_DYN_beg['H2O_l']   + d_DYN_beg['H2O_s'] 
    600         DYN_wat_end = d_DYN_end['H2O_g'] + d_DYN_end['H2O_l']   + d_DYN_end['H2O_s'] 
    601     elif 'q' in d_DYN_beg.variables : 
     488        DYN.wat_beg = d_DYN_beg['H2O_g']  + d_DYN_beg['H2O_l']  + d_DYN_beg['H2O_s'] 
     489        DYN.wat_end = d_DYN_end['H2O_g']  + d_DYN_end['H2O_l']  + d_DYN_end['H2O_s'] 
     490    if 'q' in d_DYN_beg.variables : 
    602491        echo ('reading ICO : q' ) 
    603         DYN_wat_beg = d_DYN_beg['q'].isel(nq=0) + d_DYN_beg['q'].isel(nq=1) + d_DYN_beg['q'].isel(nq=2) 
    604         DYN_wat_end = d_DYN_end['q'].isel(nq=0) + d_DYN_end['q'].isel(nq=1) + d_DYN_end['q'].isel(nq=2) 
    605  
    606 if 'lev' in DYN_wat_beg.dims : 
    607     DYN_wat_beg = DYN_wat_beg.rename ( {'lev':'sigs'} ) 
    608     DYN_wat_end = DYN_wat_end.rename ( {'lev':'sigs'} ) 
     492        DYN.wat_beg = d_DYN_beg['q'].isel(nq=0) + d_DYN_beg['q'].isel(nq=1) + d_DYN_beg['q'].isel(nq=2) 
     493        DYN.wat_end = d_DYN_end['q'].isel(nq=0) + d_DYN_end['q'].isel(nq=1) + d_DYN_end['q'].isel(nq=2) 
     494 
     495if 'lev' in DYN.wat_beg.dims : 
     496    DYN.wat_beg = DYN.wat_beg.rename ( {'lev':'sigs'} ) 
     497    DYN.wat_end = DYN.wat_end.rename ( {'lev':'sigs'} ) 
    609498 
    610499echo ( 'Compute water content : vertical and horizontal integral' ) 
    611500 
    612 DYN_wat_beg_2D =  (DYN_mass_beg * DYN_wat_beg).sum (dim='sigs') 
    613 DYN_wat_end_2D =  (DYN_mass_end * DYN_wat_end).sum (dim='sigs') 
    614  
    615 DYN_mas_wat_beg = DYN_stock_int ( DYN_wat_beg_2D ) 
    616 DYN_mas_wat_end = DYN_stock_int ( DYN_wat_end_2D ) 
     501DYN.wat_beg_2D =  (DYN.mass_beg * DYN.wat_beg).sum (dim='sigs') 
     502DYN.wat_end_2D =  (DYN.mass_end * DYN.wat_end).sum (dim='sigs') 
     503 
     504DYN.mass_wat_beg = DYN_stock_int ( DYN.wat_beg_2D ) 
     505DYN.mass_wat_end = DYN_stock_int ( DYN.wat_end_2D ) 
    617506 
    618507echo ( 'Variation of water content' ) 
    619 dDYN_mas_wat = DYN_mas_wat_end - DYN_mas_wat_beg 
     508DYN.diff_mass_wat = DYN.mass_wat_end - DYN.mass_wat_beg 
    620509 
    621510echo ( f'\nChange of atmosphere water content (dynamics)  -- {Title} ' ) 
    622511echo ( '------------------------------------------------------------------------------------' ) 
    623 echo ( 'DYN_mas_air_beg = {:12.6e} kg | DYN_mas_air_end = {:12.6e} kg'.format (DYN_mas_air_beg, DYN_mas_air_end) ) 
    624 echo ( 'DYN_mas_wat_beg = {:12.6e} kg | DYN_mas_wat_end = {:12.6e} kg'.format (DYN_mas_wat_beg, DYN_mas_wat_end) ) 
    625 prtFlux ( 'dMass (atm)  ', dDYN_mas_wat, 'e', True ) 
    626  
    627 ATM_sno_beg = d_ATM_beg['SNOW01']*d_ATM_beg['FTER'] + d_ATM_beg['SNOW02']*d_ATM_beg['FLIC'] + \ 
     512echo ( 'DYN.mass_wat_beg = {:12.6e} kg | DYN.mass_wat_end = {:12.6e} kg'.format (DYN.mass_wat_beg, DYN.mass_wat_end) ) 
     513prtFlux ( 'dMass water (atm)', DYN.diff_mass_wat, 'e', True ) 
     514echo (   f'dMass water (atm) : {(DYN.diff_mass_wat/DYN.mass_wat_beg):9.4e} (-)' ) 
     515 
     516 
     517ATM.sno_beg = d_ATM_beg['SNOW01']*d_ATM_beg['FTER'] + d_ATM_beg['SNOW02']*d_ATM_beg['FLIC'] + \ 
    628518              d_ATM_beg['SNOW03']*d_ATM_beg['FOCE'] + d_ATM_beg['SNOW04']*d_ATM_beg['FSIC'] 
    629 ATM_sno_end = d_ATM_end['SNOW01']*d_ATM_end['FTER'] + d_ATM_end['SNOW02']*d_ATM_end['FLIC'] + \ 
     519ATM.sno_end = d_ATM_end['SNOW01']*d_ATM_end['FTER'] + d_ATM_end['SNOW02']*d_ATM_end['FLIC'] + \ 
    630520              d_ATM_end['SNOW03']*d_ATM_end['FOCE'] + d_ATM_end['SNOW04']*d_ATM_end['FSIC'] 
    631521 
    632 ATM_qs_beg  = d_ATM_beg['QS01']  *d_ATM_beg['FTER'] + d_ATM_beg['QS02']  *d_ATM_beg['FLIC'] + \ 
     522ATM.qs_beg  = d_ATM_beg['QS01']  *d_ATM_beg['FTER'] + d_ATM_beg['QS02']  *d_ATM_beg['FLIC'] + \ 
    633523              d_ATM_beg['QS03']  *d_ATM_beg['FOCE'] + d_ATM_beg['QS04']  *d_ATM_beg['FSIC'] 
    634 ATM_qs_end  = d_ATM_end['QS01']  *d_ATM_end['FTER'] + d_ATM_end['QS02']  *d_ATM_end['FLIC'] + \ 
     524ATM.qs_end  = d_ATM_end['QS01']  *d_ATM_end['FTER'] + d_ATM_end['QS02']  *d_ATM_end['FLIC'] + \ 
    635525              d_ATM_end['QS03']  *d_ATM_end['FOCE'] + d_ATM_end['QS04']  *d_ATM_end['FSIC'] 
    636526 
    637 ATM_qsol_beg     = d_ATM_beg['QSOL'] 
    638 ATM_qsol_end     = d_ATM_end['QSOL'] 
    639  
    640 LIC_sno_beg      = d_ATM_beg['SNOW02']*d_ATM_beg['FLIC'] 
    641 LIC_sno_end      = d_ATM_end['SNOW02']*d_ATM_end['FLIC'] 
    642  
    643 LIC_runlic0_beg  = d_ATM_beg['RUNOFFLIC0'] 
    644 LIC_runlic0_end  = d_ATM_end['RUNOFFLIC0'] 
    645  
    646 ATM_qs01_beg     = d_ATM_beg['QS01'] * d_ATM_beg['FTER'] 
    647 ATM_qs02_beg     = d_ATM_beg['QS02'] * d_ATM_beg['FLIC'] 
    648 ATM_qs03_beg     = d_ATM_beg['QS03'] * d_ATM_beg['FOCE'] 
    649 ATM_qs04_beg     = d_ATM_beg['QS04'] * d_ATM_beg['FSIC'] 
    650  
    651 ATM_qs01_end     = d_ATM_end['QS01'] * d_ATM_end['FTER'] 
    652 ATM_qs02_end     = d_ATM_end['QS02'] * d_ATM_end['FLIC'] 
    653 ATM_qs03_end     = d_ATM_end['QS03'] * d_ATM_end['FOCE'] 
    654 ATM_qs04_end     = d_ATM_end['QS04'] * d_ATM_end['FSIC'] 
    655  
    656 LIC_qs_beg = ATM_qs02_beg 
    657 LIC_qs_end = ATM_qs02_end 
    658  
    659 ATM_mas_sno_beg     = DYN_stock_int ( ATM_sno_beg  ) 
    660 ATM_mas_sno_end     = DYN_stock_int ( ATM_sno_end  ) 
    661  
    662 ATM_mas_qs_beg      = DYN_stock_int ( ATM_qs_beg   ) 
    663 ATM_mas_qs_end      = DYN_stock_int ( ATM_qs_end   ) 
    664 ATM_mas_qsol_beg    = DYN_stock_int ( ATM_qsol_beg ) 
    665 ATM_mas_qs01_beg    = DYN_stock_int ( ATM_qs01_beg ) 
    666 ATM_mas_qs02_beg    = DYN_stock_int ( ATM_qs02_beg ) 
    667 ATM_mas_qs03_beg    = DYN_stock_int ( ATM_qs03_beg ) 
    668 ATM_mas_qs04_beg    = DYN_stock_int ( ATM_qs04_beg ) 
    669 ATM_mas_qsol_end    = DYN_stock_int ( ATM_qsol_end ) 
    670 ATM_mas_qs01_end    = DYN_stock_int ( ATM_qs01_end ) 
    671 ATM_mas_qs02_end    = DYN_stock_int ( ATM_qs02_end ) 
    672 ATM_mas_qs03_end    = DYN_stock_int ( ATM_qs03_end ) 
    673 ATM_mas_qs04_end    = DYN_stock_int ( ATM_qs04_end ) 
    674  
    675 LIC_mas_sno_beg     = DYN_stock_int ( LIC_sno_beg     ) 
    676 LIC_mas_sno_end     = DYN_stock_int ( LIC_sno_end     ) 
    677 LIC_mas_runlic0_beg = DYN_stock_int ( LIC_runlic0_beg ) 
    678 LIC_mas_runlic0_end = DYN_stock_int ( LIC_runlic0_end ) 
    679  
    680 LIC_mas_qs_beg  = ATM_mas_qs02_beg 
    681 LIC_mas_qs_end  = ATM_mas_qs02_end 
    682 LIC_mas_wat_beg = LIC_mas_qs_beg + LIC_mas_sno_beg 
    683 LIC_mas_wat_end = LIC_mas_qs_end + LIC_mas_sno_end 
    684  
    685 dATM_mas_sno  = ATM_mas_sno_end  - ATM_mas_sno_beg 
    686 dATM_mas_qs   = ATM_mas_qs_end   - ATM_mas_qs_beg 
    687 dATM_mas_qsol = ATM_mas_qsol_end - ATM_mas_qsol_beg 
    688  
    689 dATM_mas_qs01 = ATM_mas_qs01_end - ATM_mas_qs01_beg 
    690 dATM_mas_qs02 = ATM_mas_qs02_end - ATM_mas_qs02_beg 
    691 dATM_mas_qs03 = ATM_mas_qs03_end - ATM_mas_qs03_beg 
    692 dATM_mas_qs04 = ATM_mas_qs04_end - ATM_mas_qs04_beg 
    693  
    694 dLIC_mas_qs      = LIC_mas_qs_end      - LIC_mas_qs_beg 
    695 dLIC_mas_sno     = LIC_mas_sno_end     - LIC_mas_sno_beg 
    696 dLIC_mas_runlic0 = LIC_mas_runlic0_end - LIC_mas_runlic0_beg 
    697  
    698 dLIC_mas_wat     = dLIC_mas_qs + dLIC_mas_sno # + dLIC_mas_runlic0 
     527ATM.qsol_beg     = d_ATM_beg['QSOL'] 
     528ATM.qsol_end     = d_ATM_end['QSOL'] 
     529 
     530ATM.LIC_sno_beg      = d_ATM_beg['SNOW02']*d_ATM_beg['FLIC'] 
     531ATM.LIC_sno_end      = d_ATM_end['SNOW02']*d_ATM_end['FLIC'] 
     532 
     533ATM.LIC_runlic0_beg  = d_ATM_beg['RUNOFFLIC0'] 
     534ATM.LIC_runlic0_end  = d_ATM_end['RUNOFFLIC0'] 
     535 
     536ATM.qs01_beg     = d_ATM_beg['QS01'] * d_ATM_beg['FTER'] 
     537ATM.qs02_beg     = d_ATM_beg['QS02'] * d_ATM_beg['FLIC'] 
     538ATM.qs03_beg     = d_ATM_beg['QS03'] * d_ATM_beg['FOCE'] 
     539ATM.qs04_beg     = d_ATM_beg['QS04'] * d_ATM_beg['FSIC'] 
     540 
     541ATM.qs01_end     = d_ATM_end['QS01'] * d_ATM_end['FTER'] 
     542ATM.qs02_end     = d_ATM_end['QS02'] * d_ATM_end['FLIC'] 
     543ATM.qs03_end     = d_ATM_end['QS03'] * d_ATM_end['FOCE'] 
     544ATM.qs04_end     = d_ATM_end['QS04'] * d_ATM_end['FSIC'] 
     545 
     546ATM.LIC_qs_beg = ATM.qs02_beg 
     547ATM.LIC_qs_end = ATM.qs02_end 
     548 
     549ATM.mass_sno_beg     = DYN_stock_int ( ATM.sno_beg  ) 
     550ATM.mass_sno_end     = DYN_stock_int ( ATM.sno_end  ) 
     551 
     552ATM.mass_qs_beg      = DYN_stock_int ( ATM.qs_beg   ) 
     553ATM.mass_qs_end      = DYN_stock_int ( ATM.qs_end   ) 
     554ATM.mass_qsol_beg    = DYN_stock_int ( ATM.qsol_beg ) 
     555ATM.mass_qs01_beg    = DYN_stock_int ( ATM.qs01_beg ) 
     556ATM.mass_qs02_beg    = DYN_stock_int ( ATM.qs02_beg ) 
     557ATM.mass_qs03_beg    = DYN_stock_int ( ATM.qs03_beg ) 
     558ATM.mass_qs04_beg    = DYN_stock_int ( ATM.qs04_beg ) 
     559ATM.mass_qsol_end    = DYN_stock_int ( ATM.qsol_end ) 
     560ATM.mass_qs01_end    = DYN_stock_int ( ATM.qs01_end ) 
     561ATM.mass_qs02_end    = DYN_stock_int ( ATM.qs02_end ) 
     562ATM.mass_qs03_end    = DYN_stock_int ( ATM.qs03_end ) 
     563ATM.mass_qs04_end    = DYN_stock_int ( ATM.qs04_end ) 
     564 
     565ATM.LIC_mass_sno_beg     = DYN_stock_int ( ATM.LIC_sno_beg     ) 
     566ATM.LIC_mass_sno_end     = DYN_stock_int ( ATM.LIC_sno_end     ) 
     567ATM.LIC_mass_runlic0_beg = DYN_stock_int ( ATM.LIC_runlic0_beg ) 
     568ATM.LIC_mass_runlic0_end = DYN_stock_int ( ATM.LIC_runlic0_end ) 
     569 
     570ATM.LIC_mass_qs_beg  = ATM.mass_qs02_beg 
     571ATM.LIC_mass_qs_end  = ATM.mass_qs02_end 
     572ATM.LIC_mass_wat_beg = ATM.LIC_mass_qs_beg + ATM.LIC_mass_sno_beg 
     573ATM.LIC_mass_wat_end = ATM.LIC_mass_qs_end + ATM.LIC_mass_sno_end 
     574 
     575ATM.diff_mass_sno  = ATM.mass_sno_end  - ATM.mass_sno_beg 
     576ATM.diff_mass_qs   = ATM.mass_qs_end   - ATM.mass_qs_beg 
     577ATM.diff_mass_qsol = ATM.mass_qsol_end - ATM.mass_qsol_beg 
     578 
     579ATM.diff_mass_qs01 = ATM.mass_qs01_end - ATM.mass_qs01_beg 
     580ATM.diff_mass_qs02 = ATM.mass_qs02_end - ATM.mass_qs02_beg 
     581ATM.diff_mass_qs03 = ATM.mass_qs03_end - ATM.mass_qs03_beg 
     582ATM.diff_mass_qs04 = ATM.mass_qs04_end - ATM.mass_qs04_beg 
     583 
     584ATM.LIC_diff_mass_qs      = ATM.LIC_mass_qs_end      - ATM.LIC_mass_qs_beg 
     585ATM.LIC_diff_mass_sno     = ATM.LIC_mass_sno_end     - ATM.LIC_mass_sno_beg 
     586ATM.LIC_diff_mass_runlic0 = ATM.LIC_mass_runlic0_end - ATM.LIC_mass_runlic0_beg 
     587 
     588ATM.LIC_diff_mass_wat     = ATM.LIC_diff_mass_qs + ATM.LIC_diff_mass_sno # + ATM.LIC_diff_mass_runlic0 
    699589 
    700590echo ( f'\nChange of atmosphere snow content (Land ice) -- {Title} ' ) 
    701591echo ( '------------------------------------------------------------------------------------' ) 
    702 echo ( 'ATM_mas_sno_beg  = {:12.6e} kg | ATM_mas_sno_end  = {:12.6e} kg'.format (ATM_mas_sno_beg, ATM_mas_sno_end) ) 
    703 prtFlux ( 'dMass (neige atm) ', dATM_mas_sno  , 'e', True  ) 
     592echo ( 'ATM.mass_sno_beg  = {:12.6e} kg | ATM.mass_sno_end  = {:12.6e} kg'.format (ATM.mass_sno_beg, ATM.mass_sno_end) ) 
     593prtFlux ( 'dMass (neige atm) ', ATM.diff_mass_sno  , 'e', True  ) 
    704594 
    705595echo ( f'\nChange of soil humidity content -- {Title} ' ) 
    706596echo ( '------------------------------------------------------------------------------------' ) 
    707 echo ( 'ATM_mas_qs_beg  = {:12.6e} kg | ATM_mas_qs_end  = {:12.6e} kg'.format (ATM_mas_qs_beg, ATM_mas_qs_end) ) 
    708 prtFlux ( 'dMass (neige atm) ', dATM_mas_qs, 'e', True ) 
     597echo ( 'ATM.mass_qs_beg  = {:12.6e} kg | ATM.mass_qs_end  = {:12.6e} kg'.format (ATM.mass_qs_beg, ATM.mass_qs_end) ) 
     598prtFlux ( 'dMass (neige atm) ', ATM.diff_mass_qs, 'e', True ) 
    709599 
    710600echo ( f'\nChange of atmosphere water+snow content -- {Title}  ' ) 
    711601echo ( '------------------------------------------------------------------------------------' ) 
    712 prtFlux ( 'dMass (eau + neige atm) ', dDYN_mas_wat + dATM_mas_sno , 'e', True) 
    713  
    714 if SRF : 
     602prtFlux ( 'dMass (eau + neige atm) ', DYN.diff_mass_wat + ATM.diff_mass_sno , 'e', True) 
     603 
     604if SECHIBA : 
    715605    echo ( '\n====================================================================================' ) 
    716     echo ( f'-- SRF changes  -- {Title} ' ) 
     606    echo ( f'-- SECHIBA changes  -- {Title} ' ) 
    717607 
    718608    if Routing == 'SIMPLE' : 
    719         RUN_mas_wat_fast_beg   = ONE_stock_int ( d_RUN_beg ['fast_reservoir']   ) 
    720         RUN_mas_wat_slow_beg   = ONE_stock_int ( d_RUN_beg ['slow_reservoir']   ) 
    721         RUN_mas_wat_stream_beg = ONE_stock_int ( d_RUN_beg ['stream_reservoir'] ) 
    722         RUN_mas_wat_flood_beg  = ONE_stock_int ( d_SRF_beg ['floodres']  ) 
    723         RUN_mas_wat_lake_beg   = ONE_stock_int ( d_SRF_beg ['lakeres']   ) 
    724         RUN_mas_wat_pond_beg   = ONE_stock_int ( d_SRF_beg ['pondres']   ) 
    725  
    726         RUN_mas_wat_fast_end   = ONE_stock_int ( d_RUN_end ['fast_reservoir']   ) 
    727         RUN_mas_wat_slow_end   = ONE_stock_int ( d_RUN_end ['slow_reservoir']   ) 
    728         RUN_mas_wat_stream_end = ONE_stock_int ( d_RUN_end ['stream_reservoir'] ) 
    729  
    730         RUN_mas_wat_flood_end  = ONE_stock_int ( d_SRF_end ['floodres']  ) 
    731         RUN_mas_wat_lake_end   = ONE_stock_int ( d_SRF_end ['lakeres']   ) 
    732         RUN_mas_wat_pond_end   = ONE_stock_int ( d_SRF_end ['pondres']   ) 
     609        SRF.RUN_mass_wat_fast_beg   = ONE_stock_int ( d_RUN_beg ['fast_reservoir']   ) 
     610        SRF.RUN_mass_wat_slow_beg   = ONE_stock_int ( d_RUN_beg ['slow_reservoir']   ) 
     611        SRF.RUN_mass_wat_stream_beg = ONE_stock_int ( d_RUN_beg ['stream_reservoir'] ) 
     612        SRF.RUN_mass_wat_flood_beg  = ONE_stock_int ( d_SRF_beg ['floodres']  ) 
     613        SRF.RUN_mass_wat_lake_beg   = ONE_stock_int ( d_SRF_beg ['lakeres']   ) 
     614        SRF.RUN_mass_wat_pond_beg   = ONE_stock_int ( d_SRF_beg ['pondres']   ) 
     615 
     616        SRF.RUN_mass_wat_fast_end   = ONE_stock_int ( d_RUN_end ['fast_reservoir']   ) 
     617        SRF.RUN_mass_wat_slow_end   = ONE_stock_int ( d_RUN_end ['slow_reservoir']   ) 
     618        SRF.RUN_mass_wat_stream_end = ONE_stock_int ( d_RUN_end ['stream_reservoir'] ) 
     619 
     620        SRF.RUN_mass_wat_flood_end  = ONE_stock_int ( d_SRF_end ['floodres']  ) 
     621        SRF.RUN_mass_wat_lake_end   = ONE_stock_int ( d_SRF_end ['lakeres']   ) 
     622        SRF.RUN_mass_wat_pond_end   = ONE_stock_int ( d_SRF_end ['pondres']   ) 
    733623 
    734624    if Routing == 'SECHIBA' : 
    735         RUN_mas_wat_fast_beg   = ONE_stock_int ( d_SRF_beg ['fastres']   ) 
    736         RUN_mas_wat_slow_beg   = ONE_stock_int ( d_SRF_beg ['slowres']   ) 
    737         RUN_mas_wat_stream_beg = ONE_stock_int ( d_SRF_beg ['streamres'] ) 
    738         RUN_mas_wat_flood_beg  = ONE_stock_int ( d_SRF_beg ['floodres']  ) 
    739         RUN_mas_wat_lake_beg   = ONE_stock_int ( d_SRF_beg ['lakeres']   ) 
    740         RUN_mas_wat_pond_beg   = ONE_stock_int ( d_SRF_beg ['pondres']   ) 
    741  
    742         RUN_mas_wat_fast_end   = ONE_stock_int ( d_SRF_end ['fastres']   ) 
    743         RUN_mas_wat_slow_end   = ONE_stock_int ( d_SRF_end ['slowres']   ) 
    744         RUN_mas_wat_stream_end = ONE_stock_int ( d_SRF_end ['streamres'] ) 
    745         RUN_mas_wat_flood_end  = ONE_stock_int ( d_SRF_end ['floodres']  ) 
    746         RUN_mas_wat_lake_end   = ONE_stock_int ( d_SRF_end ['lakeres']   ) 
    747         RUN_mas_wat_pond_end   = ONE_stock_int ( d_SRF_end ['pondres']   ) 
    748  
    749     RUN_mas_wat_beg = Sprec ( [RUN_mas_wat_fast_beg , RUN_mas_wat_slow_beg, RUN_mas_wat_stream_beg, 
    750                             RUN_mas_wat_flood_beg, RUN_mas_wat_lake_beg, RUN_mas_wat_pond_beg] ) 
    751  
    752     RUN_mas_wat_end = Sprec ( [RUN_mas_wat_fast_end  , RUN_mas_wat_slow_end , RUN_mas_wat_stream_end, 
    753                             RUN_mas_wat_flood_end , RUN_mas_wat_lake_end , RUN_mas_wat_pond_end] ) 
    754  
    755     dRUN_mas_wat_fast   = RUN_mas_wat_fast_end   - RUN_mas_wat_fast_beg 
    756     dRUN_mas_wat_slow   = RUN_mas_wat_slow_end   - RUN_mas_wat_slow_beg 
    757     dRUN_mas_wat_stream = RUN_mas_wat_stream_end - RUN_mas_wat_stream_beg 
    758     dRUN_mas_wat_flood  = RUN_mas_wat_flood_end  - RUN_mas_wat_flood_beg 
    759     dRUN_mas_wat_lake   = RUN_mas_wat_lake_end   - RUN_mas_wat_lake_beg 
    760     dRUN_mas_wat_pond   = RUN_mas_wat_pond_end   - RUN_mas_wat_pond_beg 
    761  
    762     dRUN_mas_wat        = RUN_mas_wat_end        - RUN_mas_wat_beg 
     625        SRF.RUN_mass_wat_fast_beg   = ONE_stock_int ( d_SRF_beg ['fastres']   ) 
     626        SRF.RUN_mass_wat_slow_beg   = ONE_stock_int ( d_SRF_beg ['slowres']   ) 
     627        SRF.RUN_mass_wat_stream_beg = ONE_stock_int ( d_SRF_beg ['streamres'] ) 
     628        SRF.RUN_mass_wat_flood_beg  = ONE_stock_int ( d_SRF_beg ['floodres']  ) 
     629        SRF.RUN_mass_wat_lake_beg   = ONE_stock_int ( d_SRF_beg ['lakeres']   ) 
     630        SRF.RUN_mass_wat_pond_beg   = ONE_stock_int ( d_SRF_beg ['pondres']   ) 
     631 
     632        SRF.RUN_mass_wat_fast_end   = ONE_stock_int ( d_SRF_end ['fastres']   ) 
     633        SRF.RUN_mass_wat_slow_end   = ONE_stock_int ( d_SRF_end ['slowres']   ) 
     634        SRF.RUN_mass_wat_stream_end = ONE_stock_int ( d_SRF_end ['streamres'] ) 
     635        SRF.RUN_mass_wat_flood_end  = ONE_stock_int ( d_SRF_end ['floodres']  ) 
     636        SRF.RUN_mass_wat_lake_end   = ONE_stock_int ( d_SRF_end ['lakeres']   ) 
     637        SRF.RUN_mass_wat_pond_end   = ONE_stock_int ( d_SRF_end ['pondres']   ) 
     638 
     639    SRF.RUN_mass_wat_beg = Sprec ( [SRF.RUN_mass_wat_fast_beg , SRF.RUN_mass_wat_slow_beg, SRF.RUN_mass_wat_stream_beg, 
     640                                   SRF.RUN_mass_wat_flood_beg, SRF.RUN_mass_wat_lake_beg, SRF.RUN_mass_wat_pond_beg] ) 
     641 
     642    SRF.RUN_mass_wat_end = Sprec ( [SRF.RUN_mass_wat_fast_end  , SRF.RUN_mass_wat_slow_end , SRF.RUN_mass_wat_stream_end, 
     643                                   SRF.RUN_mass_wat_flood_end , SRF.RUN_mass_wat_lake_end , SRF.RUN_mass_wat_pond_end] ) 
     644 
     645    SRF.RUN_diff_mass_wat_fast   = SRF.RUN_mass_wat_fast_end   - SRF.RUN_mass_wat_fast_beg 
     646    SRF.RUN_diff_mass_wat_slow   = SRF.RUN_mass_wat_slow_end   - SRF.RUN_mass_wat_slow_beg 
     647    SRF.RUN_diff_mass_wat_stream = SRF.RUN_mass_wat_stream_end - SRF.RUN_mass_wat_stream_beg 
     648    SRF.RUN_diff_mass_wat_flood  = SRF.RUN_mass_wat_flood_end  - SRF.RUN_mass_wat_flood_beg 
     649    SRF.RUN_diff_mass_wat_lake   = SRF.RUN_mass_wat_lake_end   - SRF.RUN_mass_wat_lake_beg 
     650    SRF.RUN_diff_mass_wat_pond   = SRF.RUN_mass_wat_pond_end   - SRF.RUN_mass_wat_pond_beg 
     651 
     652    SRF.RUN_diff_mass_wat        = SRF.RUN_mass_wat_end        - SRF.RUN_mass_wat_beg 
    763653 
    764654    echo ( f'\nRunoff reservoirs -- {Title} ') 
    765655    echo (  '------------------------------------------------------------------------------------' ) 
    766     echo ( f'RUN_mas_wat_fast_beg   = {RUN_mas_wat_fast_beg  :12.6e} kg | RUN_mas_wat_fast_end   = {RUN_mas_wat_fast_end  :12.6e} kg ' ) 
    767     echo ( f'RUN_mas_wat_slow_beg   = {RUN_mas_wat_slow_beg  :12.6e} kg | RUN_mas_wat_slow_end   = {RUN_mas_wat_slow_end  :12.6e} kg ' ) 
    768     echo ( f'RUN_mas_wat_stream_beg = {RUN_mas_wat_stream_beg:12.6e} kg | RUN_mas_wat_stream_end = {RUN_mas_wat_stream_end:12.6e} kg ' ) 
    769     echo ( f'RUN_mas_wat_flood_beg  = {RUN_mas_wat_flood_beg :12.6e} kg | RUN_mas_wat_flood_end  = {RUN_mas_wat_flood_end :12.6e} kg ' ) 
    770     echo ( f'RUN_mas_wat_lake_beg   = {RUN_mas_wat_lake_beg  :12.6e} kg | RUN_mas_wat_lake_end   = {RUN_mas_wat_lake_end  :12.6e} kg ' ) 
    771     echo ( f'RUN_mas_wat_pond_beg   = {RUN_mas_wat_pond_beg  :12.6e} kg | RUN_mas_wat_pond_end   = {RUN_mas_wat_pond_end  :12.6e} kg ' ) 
    772     echo ( f'RUN_mas_wat_beg        = {RUN_mas_wat_beg       :12.6e} kg | RUN_mas_wat_end        = {RUN_mas_wat_end       :12.6e} kg ' ) 
     656    echo ( f'SRF.RUN_mass_wat_fast_beg   = {SRF.RUN_mass_wat_fast_beg  :12.6e} kg | SRF.RUN_mass_wat_fast_end   = {SRF.RUN_mass_wat_fast_end  :12.6e} kg ' ) 
     657    echo ( f'SRF.RUN_mass_wat_slow_beg   = {SRF.RUN_mass_wat_slow_beg  :12.6e} kg | SRF.RUN_mass_wat_slow_end   = {SRF.RUN_mass_wat_slow_end  :12.6e} kg ' ) 
     658    echo ( f'SRF.RUN_mass_wat_stream_beg = {SRF.RUN_mass_wat_stream_beg:12.6e} kg | SRF.RUN_mass_wat_stream_end = {SRF.RUN_mass_wat_stream_end:12.6e} kg ' ) 
     659    echo ( f'SRF.RUN_mass_wat_flood_beg  = {SRF.RUN_mass_wat_flood_beg :12.6e} kg | SRF.RUN_mass_wat_flood_end  = {SRF.RUN_mass_wat_flood_end :12.6e} kg ' ) 
     660    echo ( f'SRF.RUN_mass_wat_lake_beg   = {SRF.RUN_mass_wat_lake_beg  :12.6e} kg | SRF.RUN_mass_wat_lake_end   = {SRF.RUN_mass_wat_lake_end  :12.6e} kg ' ) 
     661    echo ( f'SRF.RUN_mass_wat_pond_beg   = {SRF.RUN_mass_wat_pond_beg  :12.6e} kg | SRF.RUN_mass_wat_pond_end   = {SRF.RUN_mass_wat_pond_end  :12.6e} kg ' ) 
     662    echo ( f'SRF.RUN_mass_wat_beg        = {SRF.RUN_mass_wat_beg       :12.6e} kg | SRF.RUN_mass_wat_end        = {SRF.RUN_mass_wat_end       :12.6e} kg ' ) 
    773663 
    774664    echo ( '------------------------------------------------------------------------------------' ) 
    775665 
    776     prtFlux ( 'dMass (fast)   ', dRUN_mas_wat_fast  , 'e', True ) 
    777     prtFlux ( 'dMass (slow)   ', dRUN_mas_wat_slow  , 'e', True ) 
    778     prtFlux ( 'dMass (stream) ', dRUN_mas_wat_stream, 'e', True ) 
    779     prtFlux ( 'dMass (flood)  ', dRUN_mas_wat_flood , 'e', True ) 
    780     prtFlux ( 'dMass (lake)   ', dRUN_mas_wat_lake  , 'e', True ) 
    781     prtFlux ( 'dMass (pond)   ', dRUN_mas_wat_pond  , 'e', True ) 
    782     prtFlux ( 'dMass (all)    ', dRUN_mas_wat       , 'e', True ) 
     666    prtFlux ( 'dMass (fast)   ', SRF.RUN_diff_mass_wat_fast  , 'e', True ) 
     667    prtFlux ( 'dMass (slow)   ', SRF.RUN_diff_mass_wat_slow  , 'e', True ) 
     668    prtFlux ( 'dMass (stream) ', SRF.RUN_diff_mass_wat_stream, 'e', True ) 
     669    prtFlux ( 'dMass (flood)  ', SRF.RUN_diff_mass_wat_flood , 'e', True ) 
     670    prtFlux ( 'dMass (lake)   ', SRF.RUN_diff_mass_wat_lake  , 'e', True ) 
     671    prtFlux ( 'dMass (pond)   ', SRF.RUN_diff_mass_wat_pond  , 'e', True ) 
     672    prtFlux ( 'dMass (all)    ', SRF.RUN_diff_mass_wat       , 'e', True ) 
    783673 
    784674    echo ( f'\nWater content in routing  -- {Title} ' ) 
    785675    echo ( '------------------------------------------------------------------------------------' ) 
    786     echo ( f'RUN_mas_wat_beg = {RUN_mas_wat_end:12.6e} kg | RUN_mas_wat_end = {RUN_mas_wat_end:12.6e} kg' ) 
    787     prtFlux ( 'dMass (routing) ', dRUN_mas_wat , 'e', True   ) 
     676    echo ( f'SRF.RUN_mass_wat_beg = {SRF.RUN_mass_wat_end:12.6e} kg | SRF.RUN_mass_wat_end = {SRF.RUN_mass_wat_end:12.6e} kg' ) 
     677    prtFlux ( 'dMass (routing) ', SRF.RUN_diff_mass_wat , 'e', True   ) 
    788678 
    789679    echo ( '\n====================================================================================' ) 
    790     print ( 'Reading SRF restart') 
    791     SRF_tot_watveg_beg  = d_SRF_beg['tot_watveg_beg']  ; SRF_tot_watveg_beg  = SRF_tot_watveg_beg .where (SRF_tot_watveg_beg  < 1E15, 0.) 
    792     SRF_tot_watsoil_beg = d_SRF_beg['tot_watsoil_beg'] ; SRF_tot_watsoil_beg = SRF_tot_watsoil_beg.where (SRF_tot_watsoil_beg < 1E15, 0.) 
    793     SRF_snow_beg        = d_SRF_beg['snow_beg']        ; SRF_snow_beg        = SRF_snow_beg       .where (SRF_snow_beg        < 1E15, 0.) 
    794     SRF_lakeres_beg     = d_SRF_beg['lakeres']         ; SRF_lakeres_beg     = SRF_lakeres_beg    .where (SRF_lakeres_beg     < 1E15, 0.) 
    795  
    796     SRF_tot_watveg_end  = d_SRF_end['tot_watveg_beg']  ; SRF_tot_watveg_end  = SRF_tot_watveg_end .where (SRF_tot_watveg_end  < 1E15, 0.) 
    797     SRF_tot_watsoil_end = d_SRF_end['tot_watsoil_beg'] ; SRF_tot_watsoil_end = SRF_tot_watsoil_end.where (SRF_tot_watsoil_end < 1E15, 0.) 
    798     SRF_snow_end        = d_SRF_end['snow_beg']        ; SRF_snow_end        = SRF_snow_end       .where (SRF_snow_end        < 1E15, 0.) 
    799     SRF_lakeres_end     = d_SRF_end['lakeres']         ; SRF_lakeres_end     = SRF_lakeres_end    .where (SRF_lakeres_end     < 1E15, 0.) 
     680    print ( 'Reading SECHIBA restart') 
     681    SRF.tot_watveg_beg  = d_SRF_beg['tot_watveg_beg']  ; SRF.tot_watveg_beg  = SRF.tot_watveg_beg .where (SRF.tot_watveg_beg  < 1E15, 0.) 
     682    SRF.tot_watsoil_beg = d_SRF_beg['tot_watsoil_beg'] ; SRF.tot_watsoil_beg = SRF.tot_watsoil_beg.where (SRF.tot_watsoil_beg < 1E15, 0.) 
     683    SRF.snow_beg        = d_SRF_beg['snow_beg']        ; SRF.snow_beg        = SRF.snow_beg       .where (SRF.snow_beg        < 1E15, 0.) 
     684    SRF.lakeres_beg     = d_SRF_beg['lakeres']         ; SRF.lakeres_beg     = SRF.lakeres_beg    .where (SRF.lakeres_beg     < 1E15, 0.) 
     685 
     686    SRF.tot_watveg_end  = d_SRF_end['tot_watveg_beg']  ; SRF.tot_watveg_end  = SRF.tot_watveg_end .where (SRF.tot_watveg_end  < 1E15, 0.) 
     687    SRF.tot_watsoil_end = d_SRF_end['tot_watsoil_beg'] ; SRF.tot_watsoil_end = SRF.tot_watsoil_end.where (SRF.tot_watsoil_end < 1E15, 0.) 
     688    SRF.snow_end        = d_SRF_end['snow_beg']        ; SRF.snow_end        = SRF.snow_end       .where (SRF.snow_end        < 1E15, 0.) 
     689    SRF.lakeres_end     = d_SRF_end['lakeres']         ; SRF.lakeres_end     = SRF.lakeres_end    .where (SRF.lakeres_end     < 1E15, 0.) 
    800690 
    801691    if LMDZ : 
    802         SRF_tot_watveg_beg  = lmdz.geo2point (SRF_tot_watveg_beg , dim1d='cell') 
    803         SRF_tot_watsoil_beg = lmdz.geo2point (SRF_tot_watsoil_beg, dim1d='cell') 
    804         SRF_snow_beg        = lmdz.geo2point (SRF_snow_beg       , dim1d='cell') 
    805         SRF_lakeres_beg     = lmdz.geo2point (SRF_lakeres_beg    , dim1d='cell') 
    806         SRF_tot_watveg_end  = lmdz.geo2point (SRF_tot_watveg_end , dim1d='cell') 
    807         SRF_tot_watsoil_end = lmdz.geo2point (SRF_tot_watsoil_end, dim1d='cell') 
    808         SRF_snow_end        = lmdz.geo2point (SRF_snow_end       , dim1d='cell') 
    809         SRF_lakeres_end     = lmdz.geo2point (SRF_lakeres_end    , dim1d='cell') 
     692        SRF.tot_watveg_beg  = lmdz.geo2point (SRF.tot_watveg_beg , dim1d='cell') 
     693        SRF.tot_watsoil_beg = lmdz.geo2point (SRF.tot_watsoil_beg, dim1d='cell') 
     694        SRF.snow_beg        = lmdz.geo2point (SRF.snow_beg       , dim1d='cell') 
     695        SRF.lakeres_beg     = lmdz.geo2point (SRF.lakeres_beg    , dim1d='cell') 
     696        SRF.tot_watveg_end  = lmdz.geo2point (SRF.tot_watveg_end , dim1d='cell') 
     697        SRF.tot_watsoil_end = lmdz.geo2point (SRF.tot_watsoil_end, dim1d='cell') 
     698        SRF.snow_end        = lmdz.geo2point (SRF.snow_end       , dim1d='cell') 
     699        SRF.lakeres_end     = lmdz.geo2point (SRF.lakeres_end    , dim1d='cell') 
    810700 
    811701 
    812702    # Stock dSoilHum dInterce dSWE dStream dFastR dSlowR dLake dPond dFlood 
    813703 
    814     SRF_wat_beg = SRF_tot_watveg_beg + SRF_tot_watsoil_beg + SRF_snow_beg 
    815     SRF_wat_end = SRF_tot_watveg_end + SRF_tot_watsoil_end + SRF_snow_end 
     704    SRF.wat_beg = SRF.tot_watveg_beg + SRF.tot_watsoil_beg + SRF.snow_beg 
     705    SRF.wat_end = SRF.tot_watveg_end + SRF.tot_watsoil_end + SRF.snow_end 
    816706 
    817707    echo ( '\n====================================================================================' ) 
    … …  
    819709 
    820710    print ( ' 1/8', end='' ) ; sys.stdout.flush () 
    821     SRF_mas_watveg_beg   = SRF_stock_int ( SRF_tot_watveg_beg  ) 
     711    SRF.mass_watveg_beg   = SRF_stock_int ( SRF.tot_watveg_beg  ) 
    822712    print ( ' 2/8', end='' ) ; sys.stdout.flush () 
    823     SRF_mas_watsoil_beg  = SRF_stock_int ( SRF_tot_watsoil_beg ) 
     713    SRF.mass_watsoil_beg  = SRF_stock_int ( SRF.tot_watsoil_beg ) 
    824714    print ( ' 3/8', end='' ) ; sys.stdout.flush () 
    825     SRF_mas_snow_beg     = SRF_stock_int ( SRF_snow_beg        ) 
     715    SRF.mass_snow_beg     = SRF_stock_int ( SRF.snow_beg        ) 
    826716    print ( ' 4/8', end='' ) ; sys.stdout.flush () 
    827     SRF_mas_lake_beg     = ONE_stock_int ( SRF_lakeres_beg     ) 
     717    SRF.mass_lake_beg     = ONE_stock_int ( SRF.lakeres_beg     ) 
    828718    print ( ' 5/8', end='' ) ; sys.stdout.flush () 
    829719 
    830     SRF_mas_watveg_end   = SRF_stock_int ( SRF_tot_watveg_end  ) 
     720    SRF.mass_watveg_end   = SRF_stock_int ( SRF.tot_watveg_end  ) 
    831721    print ( ' 6/8', end='' ) ; sys.stdout.flush () 
    832     SRF_mas_watsoil_end  = SRF_stock_int ( SRF_tot_watsoil_end ) 
     722    SRF.mass_watsoil_end  = SRF_stock_int ( SRF.tot_watsoil_end ) 
    833723    print ( ' 7/8', end='' ) ; sys.stdout.flush () 
    834     SRF_mas_snow_end     = SRF_stock_int ( SRF_snow_end        ) 
     724    SRF.mass_snow_end     = SRF_stock_int ( SRF.snow_end        ) 
    835725    print ( ' 8/8', end='' ) ; sys.stdout.flush () 
    836     SRF_mas_lake_end     = ONE_stock_int ( SRF_lakeres_end     ) 
     726    SRF.mass_lake_end     = ONE_stock_int ( SRF.lakeres_end     ) 
    837727 
    838728    print (' -- ') ; sys.stdout.flush () 
    839729 
    840     dSRF_mas_watveg   = Sprec ( [SRF_mas_watveg_end , -SRF_mas_watveg_beg] ) 
    841     dSRF_mas_watsoil  = Sprec ( [SRF_mas_watsoil_end, -SRF_mas_watsoil_beg] ) 
    842     dSRF_mas_snow     = Sprec ( [SRF_mas_snow_end   , -SRF_mas_snow_beg] ) 
    843     dSRF_mas_lake     = Sprec ( [SRF_mas_lake_end   , -SRF_mas_lake_beg] ) 
     730    SRF.diff_mass_watveg   = Sprec ( [SRF.mass_watveg_end , -SRF.mass_watveg_beg] ) 
     731    SRF.diff_mass_watsoil  = Sprec ( [SRF.mass_watsoil_end, -SRF.mass_watsoil_beg] ) 
     732    SRF.diff_mass_snow     = Sprec ( [SRF.mass_snow_end   , -SRF.mass_snow_beg] ) 
     733    SRF.diff_mass_lake     = Sprec ( [SRF.mass_lake_end   , -SRF.mass_lake_beg] ) 
    844734 
    845735    echo ( '------------------------------------------------------------------------------------' ) 
    846736    echo ( f'\nSurface reservoirs  -- {Title} ') 
    847     echo ( f'SRF_mas_watveg_beg   = {SRF_mas_watveg_beg :12.6e} kg | SRF_mas_watveg_end   = {SRF_mas_watveg_end :12.6e} kg ' ) 
    848     echo ( f'SRF_mas_watsoil_beg  = {SRF_mas_watsoil_beg:12.6e} kg | SRF_mas_watsoil_end  = {SRF_mas_watsoil_end:12.6e} kg ' ) 
    849     echo ( f'SRF_mas_snow_beg     = {SRF_mas_snow_beg   :12.6e} kg | SRF_mas_snow_end     = {SRF_mas_snow_end   :12.6e} kg ' ) 
    850     echo ( f'SRF_mas_lake_beg     = {SRF_mas_lake_beg   :12.6e} kg | SRF_mas_lake_end     = {SRF_mas_lake_end   :12.6e} kg ' ) 
    851  
    852     prtFlux ( 'dMass (watveg) ', dSRF_mas_watveg , 'e' , True ) 
    853     prtFlux ( 'dMass (watsoil)', dSRF_mas_watsoil, 'e' , True ) 
    854     prtFlux ( 'dMass (snow)   ', dSRF_mas_snow   , 'e' , True ) 
    855     prtFlux ( 'dMass (lake)   ', dSRF_mas_lake   , 'e' , True ) 
    856  
    857     SRF_mas_wat_beg = Sprec ( [SRF_mas_watveg_beg , SRF_mas_watsoil_beg, SRF_mas_snow_beg] ) 
    858     SRF_mas_wat_end = Sprec ( [SRF_mas_watveg_end , SRF_mas_watsoil_end, SRF_mas_snow_end] ) 
    859  
    860     dSRF_mas_wat    = Sprec ( [+SRF_mas_watveg_end , +SRF_mas_watsoil_end, +SRF_mas_snow_end, 
    861                                -SRF_mas_watveg_beg , -SRF_mas_watsoil_beg, -SRF_mas_snow_beg]  ) 
     737    echo ( f'SRF.mass_watveg_beg   = {SRF.mass_watveg_beg :12.6e} kg | SRF.mass_watveg_end   = {SRF.mass_watveg_end :12.6e} kg ' ) 
     738    echo ( f'SRF.mass_watsoil_beg  = {SRF.mass_watsoil_beg:12.6e} kg | SRF.mass_watsoil_end  = {SRF.mass_watsoil_end:12.6e} kg ' ) 
     739    echo ( f'SRF.mass_snow_beg     = {SRF.mass_snow_beg   :12.6e} kg | SRF.mass_snow_end     = {SRF.mass_snow_end   :12.6e} kg ' ) 
     740    echo ( f'SRF.mass_lake_beg     = {SRF.mass_lake_beg   :12.6e} kg | SRF.mass_lake_end     = {SRF.mass_lake_end   :12.6e} kg ' ) 
     741 
     742    prtFlux ( 'dMass (watveg) ', SRF.diff_mass_watveg , 'e' , True ) 
     743    prtFlux ( 'dMass (watsoil)', SRF.diff_mass_watsoil, 'e' , True ) 
     744    prtFlux ( 'dMass (snow)   ', SRF.diff_mass_snow   , 'e' , True ) 
     745    prtFlux ( 'dMass (lake)   ', SRF.diff_mass_lake   , 'e' , True ) 
     746 
     747    SRF.mass_wat_beg = Sprec ( [SRF.mass_watveg_beg , SRF.mass_watsoil_beg, SRF.mass_snow_beg] ) 
     748    SRF.mass_wat_end = Sprec ( [SRF.mass_watveg_end , SRF.mass_watsoil_end, SRF.mass_snow_end] ) 
     749 
     750    SRF.diff_mass_wat    = Sprec ( [+SRF.mass_watveg_end , +SRF.mass_watsoil_end, +SRF.mass_snow_end, 
     751                               -SRF.mass_watveg_beg , -SRF.mass_watsoil_beg, -SRF.mass_snow_beg]  ) 
    862752 
    863753    echo ( '------------------------------------------------------------------------------------' ) 
    864754    echo ( f'Water content in surface  -- {Title} ' ) 
    865     echo ( f'SRF_mas_wat_beg   = {SRF_mas_wat_beg:12.6e} kg | SRF_mas_wat_end  = {SRF_mas_wat_end:12.6e} kg ') 
    866     prtFlux ( 'dMass (water srf)', dSRF_mas_wat, 'e', True ) 
     755    echo ( f'SRF.mass_wat_beg   = {SRF.mass_wat_beg:12.6e} kg | SRF.mass_wat_end  = {SRF.mass_wat_end:12.6e} kg ') 
     756    prtFlux ( 'dMass (water srf)', SRF.diff_mass_wat, 'e', True ) 
    867757 
    868758    echo ( '------------------------------------------------------------------------------------' ) 
    869     echo ( 'Water content in  ATM + SRF + RUN + LAKE' ) 
    870     echo ( 'mas_wat_beg = {:12.6e} kg | mas_wat_end = {:12.6e} kg '. 
    871             format (DYN_mas_wat_beg + ATM_mas_sno_beg + RUN_mas_wat_beg + SRF_mas_wat_beg + SRF_mas_lake_beg , 
    872                     DYN_mas_wat_end + ATM_mas_sno_end + RUN_mas_wat_end + SRF_mas_wat_end + SRF_mas_lake_end ) ) 
    873     prtFlux ( 'dMass (water atm+srf+run+lake)', dDYN_mas_wat + dATM_mas_sno + dRUN_mas_wat + dSRF_mas_wat + dSRF_mas_lake, 'e', True) 
     759    echo ( 'Water content in  ATM + SECHIBA + RUN + LAKE' ) 
     760    echo ( 'mass_wat_beg = {:12.6e} kg | mass_wat_end = {:12.6e} kg '. 
     761            format (DYN.mass_wat_beg + ATM.mass_sno_beg + SRF.RUN_mass_wat_beg + SRF.mass_wat_beg + SRF.mass_lake_beg , 
     762                    DYN.mass_wat_end + ATM.mass_sno_end + SRF.RUN_mass_wat_end + SRF.mass_wat_end + SRF.mass_lake_end ) ) 
     763    prtFlux ( 'dMass (water atm+srf+run+lake)', DYN.diff_mass_wat + ATM.diff_mass_sno + SRF.RUN_diff_mass_wat + SRF.diff_mass_wat + SRF.diff_mass_lake, 'e', True) 
    874764 
    875765echo ( '\n====================================================================================' ) 
    … …  
    878768if ATM_HIS == 'latlon' : 
    879769    echo ( ' latlon case' ) 
    880     ATM_wbilo_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_oce']), dim1d='cell' ) 
    881     ATM_wbilo_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_sic']), dim1d='cell' ) 
    882     ATM_wbilo_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_ter']), dim1d='cell' ) 
    883     ATM_wbilo_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_lic']), dim1d='cell' ) 
    884     ATM_runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1d='cell' ) 
    885     ATM_fqcalving   = lmdz.geo2point ( rprec (d_ATM_his ['fqcalving']), dim1d='cell' ) 
    886     ATM_fqfonte     = lmdz.geo2point ( rprec (d_ATM_his ['fqfonte']  ), dim1d='cell' ) 
    887     ATM_precip      = lmdz.geo2point ( rprec (d_ATM_his ['precip']   ), dim1d='cell' ) 
    888     ATM_snowf       = lmdz.geo2point ( rprec (d_ATM_his ['snow']     ), dim1d='cell' ) 
    889     ATM_evap        = lmdz.geo2point ( rprec (d_ATM_his ['evap']     ), dim1d='cell' ) 
    890     ATM_wevap_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_ter']), dim1d='cell' ) 
    891     ATM_wevap_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_oce']), dim1d='cell' ) 
    892     ATM_wevap_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_lic']), dim1d='cell' ) 
    893     ATM_wevap_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_sic']), dim1d='cell' ) 
    894     ATM_wrain_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_ter']), dim1d='cell' ) 
    895     ATM_wrain_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_oce']), dim1d='cell' ) 
    896     ATM_wrain_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_lic']), dim1d='cell' ) 
    897     ATM_wrain_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_sic']), dim1d='cell' ) 
    898     ATM_wsnow_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_ter']), dim1d='cell' ) 
    899     ATM_wsnow_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_oce']), dim1d='cell' ) 
    900     ATM_wsnow_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_lic']), dim1d='cell' ) 
    901     ATM_wsnow_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_sic']), dim1d='cell' ) 
    902     ATM_runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1d='cell' ) 
     770    ATM.wbilo_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_oce']), dim1d='cell' ) 
     771    ATM.wbilo_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_sic']), dim1d='cell' ) 
     772    ATM.wbilo_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_ter']), dim1d='cell' ) 
     773    ATM.wbilo_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_lic']), dim1d='cell' ) 
     774    ATM.runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1d='cell' ) 
     775    ATM.fqcalving   = lmdz.geo2point ( rprec (d_ATM_his ['fqcalving']), dim1d='cell' ) 
     776    ATM.fqfonte     = lmdz.geo2point ( rprec (d_ATM_his ['fqfonte']  ), dim1d='cell' ) 
     777    ATM.precip      = lmdz.geo2point ( rprec (d_ATM_his ['precip']   ), dim1d='cell' ) 
     778    ATM.snowf       = lmdz.geo2point ( rprec (d_ATM_his ['snow']     ), dim1d='cell' ) 
     779    ATM.evap        = lmdz.geo2point ( rprec (d_ATM_his ['evap']     ), dim1d='cell' ) 
     780    ATM.wevap_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_ter']), dim1d='cell' ) 
     781    ATM.wevap_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_oce']), dim1d='cell' ) 
     782    ATM.wevap_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_lic']), dim1d='cell' ) 
     783    ATM.wevap_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_sic']), dim1d='cell' ) 
     784    ATM.wrain_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_ter']), dim1d='cell' ) 
     785    ATM.wrain_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_oce']), dim1d='cell' ) 
     786    ATM.wrain_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_lic']), dim1d='cell' ) 
     787    ATM.wrain_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_sic']), dim1d='cell' ) 
     788    ATM.wsnow_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_ter']), dim1d='cell' ) 
     789    ATM.wsnow_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_oce']), dim1d='cell' ) 
     790    ATM.wsnow_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_lic']), dim1d='cell' ) 
     791    ATM.wsnow_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_sic']), dim1d='cell' ) 
     792    ATM.runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1d='cell' ) 
    903793    echo ( 'End of LATLON case') 
    904794 
    905795if ATM_HIS == 'ico' : 
    906796    echo (' ico case') 
    907     ATM_wbilo_oce   = rprec (d_ATM_his ['wbilo_oce']) 
    908     ATM_wbilo_sic   = rprec (d_ATM_his ['wbilo_sic']) 
    909     ATM_wbilo_ter   = rprec (d_ATM_his ['wbilo_ter']) 
    910     ATM_wbilo_lic   = rprec (d_ATM_his ['wbilo_lic']) 
    911     ATM_runofflic   = rprec (d_ATM_his ['runofflic']) 
    912     ATM_fqcalving   = rprec (d_ATM_his ['fqcalving']) 
    913     ATM_fqfonte     = rprec (d_ATM_his ['fqfonte']  ) 
    914     ATM_precip      = rprec (d_ATM_his ['precip']   ) 
    915     ATM_snowf       = rprec (d_ATM_his ['snow']     ) 
    916     ATM_evap        = rprec (d_ATM_his ['evap']     ) 
    917     ATM_wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
    918     ATM_wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
    919     ATM_wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
    920     ATM_wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
    921     ATM_runofflic   = rprec (d_ATM_his ['runofflic']) 
    922     ATM_wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
    923     ATM_wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
    924     ATM_wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
    925     ATM_wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
    926     ATM_wrain_ter   = rprec (d_ATM_his ['wrain_ter']) 
    927     ATM_wrain_oce   = rprec (d_ATM_his ['wrain_oce']) 
    928     ATM_wrain_lic   = rprec (d_ATM_his ['wrain_lic']) 
    929     ATM_wrain_sic   = rprec (d_ATM_his ['wrain_sic']) 
    930     ATM_wsnow_ter   = rprec (d_ATM_his ['wsnow_ter']) 
    931     ATM_wsnow_oce   = rprec (d_ATM_his ['wsnow_oce']) 
    932     ATM_wsnow_lic   = rprec (d_ATM_his ['wsnow_lic']) 
    933     ATM_wsnow_sic   = rprec (d_ATM_his ['wsnow_sic']) 
     797    ATM.wbilo_oce   = rprec (d_ATM_his ['wbilo_oce']) 
     798    ATM.wbilo_sic   = rprec (d_ATM_his ['wbilo_sic']) 
     799    ATM.wbilo_ter   = rprec (d_ATM_his ['wbilo_ter']) 
     800    ATM.wbilo_lic   = rprec (d_ATM_his ['wbilo_lic']) 
     801    ATM.runofflic   = rprec (d_ATM_his ['runofflic']) 
     802    ATM.fqcalving   = rprec (d_ATM_his ['fqcalving']) 
     803    ATM.fqfonte     = rprec (d_ATM_his ['fqfonte']  ) 
     804    ATM.precip      = rprec (d_ATM_his ['precip']   ) 
     805    ATM.snowf       = rprec (d_ATM_his ['snow']     ) 
     806    ATM.evap        = rprec (d_ATM_his ['evap']     ) 
     807    ATM.wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
     808    ATM.wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
     809    ATM.wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
     810    ATM.wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
     811    ATM.runofflic   = rprec (d_ATM_his ['runofflic']) 
     812    ATM.wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
     813    ATM.wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
     814    ATM.wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
     815    ATM.wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
     816    ATM.wrain_ter   = rprec (d_ATM_his ['wrain_ter']) 
     817    ATM.wrain_oce   = rprec (d_ATM_his ['wrain_oce']) 
     818    ATM.wrain_lic   = rprec (d_ATM_his ['wrain_lic']) 
     819    ATM.wrain_sic   = rprec (d_ATM_his ['wrain_sic']) 
     820    ATM.wsnow_ter   = rprec (d_ATM_his ['wsnow_ter']) 
     821    ATM.wsnow_oce   = rprec (d_ATM_his ['wsnow_oce']) 
     822    ATM.wsnow_lic   = rprec (d_ATM_his ['wsnow_lic']) 
     823    ATM.wsnow_sic   = rprec (d_ATM_his ['wsnow_sic']) 
    934824    echo ( 'End of ico case ') 
    935825 
    936826echo ( 'ATM wprecip_oce' ) 
    937 ATM_wprecip_oce = ATM_wrain_oce + ATM_wsnow_oce 
    938 ATM_wprecip_ter = ATM_wrain_ter + ATM_wsnow_ter 
    939 ATM_wprecip_sic = ATM_wrain_sic + ATM_wsnow_sic 
    940 ATM_wprecip_lic = ATM_wrain_lic + ATM_wsnow_lic 
    941  
    942 ATM_wbilo       = ATM_wbilo_oce   + ATM_wbilo_sic   + ATM_wbilo_ter   + ATM_wbilo_lic 
    943 ATM_wevap       = ATM_wevap_oce   + ATM_wevap_sic   + ATM_wevap_ter   + ATM_wevap_lic 
    944 ATM_wprecip     = ATM_wprecip_oce + ATM_wprecip_sic + ATM_wprecip_ter + ATM_wprecip_lic 
    945 ATM_wsnow       = ATM_wsnow_oce   + ATM_wsnow_sic   + ATM_wsnow_ter   + ATM_wsnow_lic 
    946 ATM_wrain       = ATM_wrain_oce   + ATM_wrain_sic   + ATM_wrain_ter   + ATM_wrain_lic 
    947 ATM_wemp        = ATM_wevap - ATM_wprecip 
    948 ATM_emp         = ATM_evap  - ATM_precip 
    949  
    950 ATM_wprecip_sea = ATM_wprecip_oce + ATM_wprecip_sic 
    951 ATM_wsnow_sea   = ATM_wsnow_oce   + ATM_wsnow_sic 
    952 ATM_wrain_sea   = ATM_wrain_oce   + ATM_wrain_sic 
    953 ATM_wbilo_sea   = ATM_wbilo_oce   + ATM_wbilo_sic 
    954 ATM_wevap_sea   = ATM_wevap_sic   + ATM_wevap_oce 
    955  
    956 ATM_wemp_ter    = ATM_wevap_ter - ATM_wprecip_ter 
    957 ATM_wemp_oce    = ATM_wevap_oce - ATM_wprecip_oce 
    958 ATM_wemp_sic    = ATM_wevap_sic - ATM_wprecip_sic 
    959 ATM_wemp_lic    = ATM_wevap_lic - ATM_wprecip_lic 
    960 ATM_wemp_sea    = ATM_wevap_sic - ATM_wprecip_oce 
    961  
    962 if SRF : 
     827ATM.wprecip_oce = ATM.wrain_oce + ATM.wsnow_oce 
     828ATM.wprecip_ter = ATM.wrain_ter + ATM.wsnow_ter 
     829ATM.wprecip_sic = ATM.wrain_sic + ATM.wsnow_sic 
     830ATM.wprecip_lic = ATM.wrain_lic + ATM.wsnow_lic 
     831 
     832ATM.wbilo       = ATM.wbilo_oce   + ATM.wbilo_sic   + ATM.wbilo_ter   + ATM.wbilo_lic 
     833ATM.wevap       = ATM.wevap_oce   + ATM.wevap_sic   + ATM.wevap_ter   + ATM.wevap_lic 
     834ATM.wprecip     = ATM.wprecip_oce + ATM.wprecip_sic + ATM.wprecip_ter + ATM.wprecip_lic 
     835ATM.wsnow       = ATM.wsnow_oce   + ATM.wsnow_sic   + ATM.wsnow_ter   + ATM.wsnow_lic 
     836ATM.wrain       = ATM.wrain_oce   + ATM.wrain_sic   + ATM.wrain_ter   + ATM.wrain_lic 
     837ATM.wemp        = ATM.wevap - ATM.wprecip 
     838ATM.emp         = ATM.evap  - ATM.precip 
     839 
     840ATM.wprecip_sea = ATM.wprecip_oce + ATM.wprecip_sic 
     841ATM.wsnow_sea   = ATM.wsnow_oce   + ATM.wsnow_sic 
     842ATM.wrain_sea   = ATM.wrain_oce   + ATM.wrain_sic 
     843ATM.wbilo_sea   = ATM.wbilo_oce   + ATM.wbilo_sic 
     844ATM.wevap_sea   = ATM.wevap_sic   + ATM.wevap_oce 
     845 
     846ATM.wemp_ter    = ATM.wevap_ter - ATM.wprecip_ter 
     847ATM.wemp_oce    = ATM.wevap_oce - ATM.wprecip_oce 
     848ATM.wemp_sic    = ATM.wevap_sic - ATM.wprecip_sic 
     849ATM.wemp_lic    = ATM.wevap_lic - ATM.wprecip_lic 
     850ATM.wemp_sea    = ATM.wevap_sic - ATM.wprecip_oce 
     851 
     852if SECHIBA : 
    963853    if RUN_HIS == 'latlon' : 
    964854        echo ( 'RUN costalflow Grille LATLON' ) 
    965855        if TestInterp : 
    966856            echo ( 'RUN runoff TestInterp' ) 
    967             RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff_contfrac_interp']  )   , dim1d='cell' ) 
    968             RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage_contfrac_interp'])   , dim1d='cell' ) 
     857            SRF.RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff_contfrac_interp']  )   , dim1d='cell' ) 
     858            SRF.RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage_contfrac_interp'])   , dim1d='cell' ) 
    969859        else : 
    970860            echo ( 'RUN runoff' ) 
    971             RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff']         ), dim1d='cell' ) 
    972             RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage']       ), dim1d='cell' ) 
    973  
    974         RUN_coastalflow     = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow']    ), dim1d='cell' ) 
    975         RUN_riverflow       = lmdz.geo2point ( rprec (d_RUN_his ['riverflow']      ), dim1d='cell' ) 
    976         RUN_riversret       = lmdz.geo2point ( rprec (d_RUN_his ['riversret']      ), dim1d='cell' ) 
    977         RUN_coastalflow_cpl = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow_cpl']), dim1d='cell' ) 
    978         RUN_riverflow_cpl   = lmdz.geo2point ( rprec (d_RUN_his ['riverflow_cpl']  ), dim1d='cell' ) 
     861            SRF.RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff']         ), dim1d='cell' ) 
     862            SRF.RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage']       ), dim1d='cell' ) 
     863 
     864        SRF.RUN_coastalflow     = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow']    ), dim1d='cell' ) 
     865        SRF.RUN_riverflow       = lmdz.geo2point ( rprec (d_RUN_his ['riverflow']      ), dim1d='cell' ) 
     866        SRF.RUN_riversret       = lmdz.geo2point ( rprec (d_RUN_his ['riversret']      ), dim1d='cell' ) 
     867        SRF.RUN_coastalflow_cpl = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow_cpl']), dim1d='cell' ) 
     868        SRF.RUN_riverflow_cpl   = lmdz.geo2point ( rprec (d_RUN_his ['riverflow_cpl']  ), dim1d='cell' ) 
    979869 
    980870    if RUN_HIS == 'ico' : 
    981871        echo ( 'RUN costalflow Grille ICO' ) 
    982         RUN_coastalflow =  rprec (d_RUN_his ['coastalflow']) 
    983         RUN_riverflow   =  rprec (d_RUN_his ['riverflow']  ) 
    984         RUN_runoff      =  rprec (d_RUN_his ['runoff']     ) 
    985         RUN_drainage    =  rprec (d_RUN_his ['drainage']   ) 
    986         RUN_riversret   =  rprec (d_RUN_his ['riversret']  ) 
    987  
    988         RUN_coastalflow_cpl = rprec (d_RUN_his ['coastalflow_cpl']) 
    989         RUN_riverflow_cpl   = rprec (d_RUN_his ['riverflow_cpl']  ) 
     872        SRF.RUN_coastalflow =  rprec (d_RUN_his ['coastalflow']) 
     873        SRF.RUN_riverflow   =  rprec (d_RUN_his ['riverflow']  ) 
     874        SRF.RUN_runoff      =  rprec (d_RUN_his ['runoff']     ) 
     875        SRF.RUN_drainage    =  rprec (d_RUN_his ['drainage']   ) 
     876        SRF.RUN_riversret   =  rprec (d_RUN_his ['riversret']  ) 
     877 
     878        SRF.RUN_coastalflow_cpl = rprec (d_RUN_his ['coastalflow_cpl']) 
     879        SRF.RUN_riverflow_cpl   = rprec (d_RUN_his ['riverflow_cpl']  ) 
    990880 
    991881    Step = 0 
    … …  
    993883    if SRF_HIS == 'latlon' : 
    994884        if TestInterp : 
    995             echo ( 'SRF rain TestInterp' ) 
    996             SRF_rain     = lmdz.geo2point ( rprec (d_SRF_his ['rain_contfrac_interp'] ), dim1d='cell') 
    997             SRF_evap     = lmdz.geo2point ( rprec (d_SRF_his ['evap_contfrac_interp'] ), dim1d='cell') 
    998             SRF_snowf    = lmdz.geo2point ( rprec (d_SRF_his ['snow_contfrac_interp'] ), dim1d='cell') 
    999             SRF_subli    = lmdz.geo2point ( rprec (d_SRF_his ['subli_contfrac_interp']), dim1d='cell') 
    1000             SRF_transpir = lmdz.geo2point ( rprec (d_SRF_his ['transpir_contfrac_interp']).sum(dim='veget'), dim1d='cell' ) 
    1001             #SRF_rain.attrs.update     ( d_SRF_his ['rain_contfrac_interp'].attrs ) 
    1002             #SRF_evap.attrs.update     ( d_SRF_his ['evap_contfrac_interp'].attrs ) 
    1003             #SRF_snowf.attrs.update    ( d_SRF_his ['snow_contfrac_interp'].attrs ) 
    1004             #SRF_subli.attrs.update    ( d_SRF_his ['subli_contfrac_interp'].attrs ) 
    1005             #SRF_transpir.attrs.update ( d_SRF_his ['transpir_contfrac_interp'].attrs ) 
     885            echo ( 'SECHIBA rain TestInterp' ) 
     886            SRF.rain     = lmdz.geo2point ( rprec (d_SRF_his ['rain_contfrac_interp'] ), dim1d='cell') 
     887            SRF.evap     = lmdz.geo2point ( rprec (d_SRF_his ['evap_contfrac_interp'] ), dim1d='cell') 
     888            SRF.snowf    = lmdz.geo2point ( rprec (d_SRF_his ['snow_contfrac_interp'] ), dim1d='cell') 
     889            SRF.subli    = lmdz.geo2point ( rprec (d_SRF_his ['subli_contfrac_interp']), dim1d='cell') 
     890            SRF.transpir = lmdz.geo2point ( rprec (d_SRF_his ['transpir_contfrac_interp']).sum(dim='veget'), dim1d='cell' ) 
     891            #SRF.rain.attrs.update     ( d_SRF_his ['rain_contfrac_interp'].attrs ) 
     892            #SRF.evap.attrs.update     ( d_SRF_his ['evap_contfrac_interp'].attrs ) 
     893            #SRF.snowf.attrs.update    ( d_SRF_his ['snow_contfrac_interp'].attrs ) 
     894            #SRF.subli.attrs.update    ( d_SRF_his ['subli_contfrac_interp'].attrs ) 
     895            #SRF.transpir.attrs.update ( d_SRF_his ['transpir_contfrac_interp'].attrs ) 
    1006896        else : 
    1007             echo ( 'SRF rain' ) 
    1008             SRF_rain     = lmdz.geo2point ( rprec (d_SRF_his ['rain'] ) , dim1d='cell') 
    1009             SRF_evap     = lmdz.geo2point ( rprec (d_SRF_his ['evap'] ) , dim1d='cell') 
    1010             SRF_snowf    = lmdz.geo2point ( rprec (d_SRF_his ['snowf']) , dim1d='cell') 
    1011             SRF_subli    = lmdz.geo2point ( rprec (d_SRF_his ['subli']) , dim1d='cell') 
    1012             SRF_transpir = lmdz.geo2point ( rprec (d_SRF_his ['transpir']).sum(dim='veget'), dim1d='cell' ) 
     897            echo ( 'SECHIBA rain' ) 
     898            SRF.rain     = lmdz.geo2point ( rprec (d_SRF_his ['rain'] ) , dim1d='cell') 
     899            SRF.evap     = lmdz.geo2point ( rprec (d_SRF_his ['evap'] ) , dim1d='cell') 
     900            SRF.snowf    = lmdz.geo2point ( rprec (d_SRF_his ['snowf']) , dim1d='cell') 
     901            SRF.subli    = lmdz.geo2point ( rprec (d_SRF_his ['subli']) , dim1d='cell') 
     902            SRF.transpir = lmdz.geo2point ( rprec (d_SRF_his ['transpir']).sum(dim='veget'), dim1d='cell' ) 
    1013903 
    1014904    if SRF_HIS == 'ico' : 
    1015         echo ( 'SRF rain') 
    1016         SRF_rain     = rprec (d_SRF_his ['rain'] ) 
    1017         SRF_evap     = rprec (d_SRF_his ['evap'] ) 
    1018         SRF_snowf    = rprec (d_SRF_his ['snowf']) 
    1019         SRF_subli    = rprec (d_SRF_his ['subli']) 
    1020         SRF_transpir = rprec (d_SRF_his ['transpir']).sum(dim='veget') 
    1021  
    1022     echo ( 'SRF emp' ) 
    1023     SRF_transpir.attrs['units'] = d_SRF_his ['transpir'].attrs['units'] 
    1024     SRF_emp      = SRF_evap - SRF_rain - SRF_snowf ; SRF_emp.attrs['units'] = SRF_rain.attrs['units'] 
     905        echo ( 'SECHIBA rain') 
     906        SRF.rain     = rprec (d_SRF_his ['rain'] ) 
     907        SRF.evap     = rprec (d_SRF_his ['evap'] ) 
     908        SRF.snowf    = rprec (d_SRF_his ['snowf']) 
     909        SRF.subli    = rprec (d_SRF_his ['subli']) 
     910        SRF.transpir = rprec (d_SRF_his ['transpir']).sum(dim='veget') 
     911 
     912    echo ( 'SECHIBA emp' ) 
     913    SRF.transpir.attrs['units'] = d_SRF_his ['transpir'].attrs['units'] 
     914    SRF.emp      = SRF.evap - SRF.rain - SRF.snowf ; SRF.emp.attrs['units'] = SRF.rain.attrs['units'] 
    1025915 
    1026916    ## Correcting units of SECHIBA variables 
    1027     def mmd2si ( pvar ) : 
     917    def mmd2SI ( Var ) : 
    1028918        '''Change unit from mm/d or m^3/s to kg/s if needed''' 
    1029         if 'units' in pvar.attrs : 
    1030             if pvar.attrs['units'] in ['m^3/s', 'm3/s', 'm3.s-1',] : 
    1031                 pvar.values = pvar.values  * ATM_RHO                    ;  pvar.attrs['units'] = 'kg/s' 
    1032             if pvar.attrs['units'] == 'mm/d' : 
    1033                 pvar.values = pvar.values  * ATM_RHO * (1e-3/lmdz.RDAY) ;  pvar.attrs['units'] = 'kg/s' 
    1034             if pvar.attrs['units'] in ['m^3', 'm3', ] : 
    1035                 pvar.values = pvar.values  * ATM_RHO                    ;  pvar.attrs['units'] = 'kg' 
    1036  
    1037     for var in [ 'runoff', 'drainage', 'riversret', 'coastalflow', 'riverflow', 'coastalflow_cpl', 'riverflow_cpl' ] : 
    1038         zvar = locals()['RUN_' + var] 
    1039         mmd2si (zvar) 
    1040  
    1041     for var in ['evap', 'snowf', 'subli', 'transpir', 'rain', 'emp' ] : 
    1042         zvar = locals()['SRF_' + var] 
    1043         mmd2si (zvar) 
     919        if 'units' in Var.attrs :  
     920            if Var.attrs['units'] in ['m^3/s', 'm3/s', 'm3.s-1',] : 
     921                Var.values = Var.values  * ATM_RHO                 ;  Var.attrs['units'] = 'kg/s' 
     922            if Var.attrs['units'] == 'mm/d' : 
     923                Var.values = Var.values  * ATM_RHO * (1e-3/86400.) ;  Var.attrs['units'] = 'kg/s' 
     924            if Var.attrs['units'] in ['m^3', 'm3', ] : 
     925                Var.values = Var.values  * ATM_RHO                 ;  Var.attrs['units'] = 'kg' 
     926        return Var 
     927     
     928    SRF.RUN_coastalflow     = mmd2SI ( SRF.RUN_coastalflow ) 
     929    SRF.RUN_coastalflow_cpl = mmd2SI ( SRF.RUN_coastalflow_cpl ) 
     930    SRF.RUN_drainage        = mmd2SI ( SRF.RUN_drainage ) 
     931    SRF.RUN_riverflow       = mmd2SI ( SRF.RUN_riverflow ) 
     932    SRF.RUN_riverflow_cpl   = mmd2SI ( SRF.RUN_riverflow_cpl ) 
     933    SRF.RUN_riversret       = mmd2SI ( SRF.RUN_riversret ) 
     934    SRF.RUN_runoff          = mmd2SI ( SRF.RUN_runoff ) 
     935             
     936    SRF.evap     = mmd2SI ( SRF.evap ) 
     937    SRF.snowf    = mmd2SI ( SRF.snowf ) 
     938    SRF.subli    = mmd2SI ( SRF.subli ) 
     939    SRF.transpir = mmd2SI ( SRF.transpir ) 
     940    SRF.rain     = mmd2SI ( SRF.rain ) 
     941    SRF.emp      = mmd2SI ( SRF.emp ) 
    1044942 
    1045943    echo ( 'RUN input' ) 
    1046     RUN_input  = RUN_runoff      + RUN_drainage 
    1047     RUN_output = RUN_coastalflow + RUN_riverflow 
     944    SRF.RUN_input  = SRF.RUN_runoff      + SRF.RUN_drainage 
     945    SRF.RUN_output = SRF.RUN_coastalflow + SRF.RUN_riverflow 
    1048946 
    1049947echo ( 'ATM flw_wbilo' ) 
    1050 ATM_flx_wbilo       = ATM_flux_int ( ATM_wbilo      ) 
    1051 ATM_flx_wevap       = ATM_flux_int ( ATM_wevap      ) 
    1052 ATM_flx_wprecip     = ATM_flux_int ( ATM_wprecip    ) 
    1053 ATM_flx_wsnow       = ATM_flux_int ( ATM_wsnow      ) 
    1054 ATM_flx_wrain       = ATM_flux_int ( ATM_wrain      ) 
    1055 ATM_flx_wemp        = ATM_flux_int ( ATM_wemp       ) 
    1056  
    1057 ATM_flx_wbilo_lic   = ATM_flux_int ( ATM_wbilo_lic  ) 
    1058 ATM_flx_wbilo_oce   = ATM_flux_int ( ATM_wbilo_oce  ) 
    1059 ATM_flx_wbilo_sea   = ATM_flux_int ( ATM_wbilo_sea  ) 
    1060 ATM_flx_wbilo_sic   = ATM_flux_int ( ATM_wbilo_sic  ) 
    1061 ATM_flx_wbilo_ter   = ATM_flux_int ( ATM_wbilo_ter  ) 
     948ATM.flx_wbilo       = ATM_flux_int ( ATM.wbilo      ) 
     949ATM.flx_wevap       = ATM_flux_int ( ATM.wevap      ) 
     950ATM.flx_wprecip     = ATM_flux_int ( ATM.wprecip    ) 
     951ATM.flx_wsnow       = ATM_flux_int ( ATM.wsnow      ) 
     952ATM.flx_wrain       = ATM_flux_int ( ATM.wrain      ) 
     953ATM.flx_wemp        = ATM_flux_int ( ATM.wemp       ) 
     954 
     955ATM.flx_wbilo_lic   = ATM_flux_int ( ATM.wbilo_lic  ) 
     956ATM.flx_wbilo_oce   = ATM_flux_int ( ATM.wbilo_oce  ) 
     957ATM.flx_wbilo_sea   = ATM_flux_int ( ATM.wbilo_sea  ) 
     958ATM.flx_wbilo_sic   = ATM_flux_int ( ATM.wbilo_sic  ) 
     959ATM.flx_wbilo_ter   = ATM_flux_int ( ATM.wbilo_ter  ) 
    1062960# Type d'integration a verifier 
    1063 ATM_flx_calving     = ATM_flux_int ( ATM_fqcalving  ) 
    1064 ATM_flx_fqfonte     = ATM_flux_int ( ATM_fqfonte    ) 
    1065  
    1066 LIC_flx_calving     = LIC_flux_int ( ATM_fqcalving  ) 
    1067 LIC_flx_fqfonte     = LIC_flux_int ( ATM_fqfonte    ) 
     961ATM.flx_calving     = ATM_flux_int ( ATM.fqcalving  ) 
     962ATM.flx_fqfonte     = ATM_flux_int ( ATM.fqfonte    ) 
     963 
     964ATM.LIC_flx_calving     = LIC_flux_int ( ATM.fqcalving  ) 
     965ATM.LIC_flx_fqfonte     = LIC_flux_int ( ATM.fqfonte    ) 
    1068966 
    1069967echo ( 'ATM flx precip' ) 
    1070 ATM_flx_precip      = ATM_flux_int ( ATM_precip     ) 
    1071 ATM_flx_snowf       = ATM_flux_int ( ATM_snowf      ) 
    1072 ATM_flx_evap        = ATM_flux_int ( ATM_evap       ) 
    1073 ATM_flx_runlic      = ATM_flux_int ( ATM_runofflic  ) 
    1074  
    1075 LIC_flx_precip      = LIC_flux_int ( ATM_precip     ) 
    1076 LIC_flx_snowf       = LIC_flux_int ( ATM_snowf      ) 
    1077 LIC_flx_evap        = LIC_flux_int ( ATM_evap       ) 
    1078 LIC_flx_runlic      = LIC_flux_int ( ATM_runofflic  ) 
     968ATM.flx_precip      = ATM_flux_int ( ATM.precip     ) 
     969ATM.flx_snowf       = ATM_flux_int ( ATM.snowf      ) 
     970ATM.flx_evap        = ATM_flux_int ( ATM.evap       ) 
     971ATM.flx_runlic      = ATM_flux_int ( ATM.runofflic  ) 
     972 
     973ATM.LIC_flx_precip      = LIC_flux_int ( ATM.precip     ) 
     974ATM.LIC_flx_snowf       = LIC_flux_int ( ATM.snowf      ) 
     975ATM.LIC_flx_evap        = LIC_flux_int ( ATM.evap       ) 
     976ATM.LIC_flx_runlic      = LIC_flux_int ( ATM.runofflic  ) 
    1079977 
    1080978echo ( 'ATM flx_wrain_ter' ) 
    1081 ATM_flx_wrain_ter    = ATM_flux_int ( ATM_wrain_ter ) 
    1082 ATM_flx_wrain_oce    = ATM_flux_int ( ATM_wrain_oce ) 
    1083 ATM_flx_wrain_lic    = ATM_flux_int ( ATM_wrain_lic ) 
    1084 ATM_flx_wrain_sic    = ATM_flux_int ( ATM_wrain_sic ) 
    1085 ATM_flx_wrain_sea    = ATM_flux_int ( ATM_wrain_sea ) 
    1086  
    1087 ATM_flx_wsnow_ter    = ATM_flux_int ( ATM_wsnow_ter ) 
    1088 ATM_flx_wsnow_oce    = ATM_flux_int ( ATM_wsnow_oce ) 
    1089 ATM_flx_wsnow_lic    = ATM_flux_int ( ATM_wsnow_lic ) 
    1090 ATM_flx_wsnow_sic    = ATM_flux_int ( ATM_wsnow_sic ) 
    1091 ATM_flx_wsnow_sea    = ATM_flux_int ( ATM_wsnow_sea ) 
     979ATM.flx_wrain_ter    = ATM_flux_int ( ATM.wrain_ter ) 
     980ATM.flx_wrain_oce    = ATM_flux_int ( ATM.wrain_oce ) 
     981ATM.flx_wrain_lic    = ATM_flux_int ( ATM.wrain_lic ) 
     982ATM.flx_wrain_sic    = ATM_flux_int ( ATM.wrain_sic ) 
     983ATM.flx_wrain_sea    = ATM_flux_int ( ATM.wrain_sea ) 
     984 
     985ATM.flx_wsnow_ter    = ATM_flux_int ( ATM.wsnow_ter ) 
     986ATM.flx_wsnow_oce    = ATM_flux_int ( ATM.wsnow_oce ) 
     987ATM.flx_wsnow_lic    = ATM_flux_int ( ATM.wsnow_lic ) 
     988ATM.flx_wsnow_sic    = ATM_flux_int ( ATM.wsnow_sic ) 
     989ATM.flx_wsnow_sea    = ATM_flux_int ( ATM.wsnow_sea ) 
    1092990 
    1093991echo ( 'ATM flx_evap_ter' ) 
    1094 ATM_flx_wevap_ter    = ATM_flux_int ( ATM_wevap_ter ) 
    1095 ATM_flx_wevap_oce    = ATM_flux_int ( ATM_wevap_oce ) 
    1096 ATM_flx_wevap_lic    = ATM_flux_int ( ATM_wevap_lic ) 
    1097 ATM_flx_wevap_sic    = ATM_flux_int ( ATM_wevap_sic ) 
    1098 ATM_flx_wevap_sea    = ATM_flux_int ( ATM_wevap_sea ) 
    1099 ATM_flx_wprecip_lic  = ATM_flux_int ( ATM_wprecip_lic ) 
    1100 ATM_flx_wprecip_oce  = ATM_flux_int ( ATM_wprecip_oce ) 
    1101 ATM_flx_wprecip_sic  = ATM_flux_int ( ATM_wprecip_sic ) 
    1102 ATM_flx_wprecip_ter  = ATM_flux_int ( ATM_wprecip_ter ) 
    1103 ATM_flx_wprecip_sea  = ATM_flux_int ( ATM_wprecip_sea ) 
    1104 ATM_flx_wemp_lic     = ATM_flux_int ( ATM_wemp_lic ) 
    1105 ATM_flx_wemp_oce     = ATM_flux_int ( ATM_wemp_oce ) 
    1106 ATM_flx_wemp_sic     = ATM_flux_int ( ATM_wemp_sic ) 
    1107 ATM_flx_wemp_ter     = ATM_flux_int ( ATM_wemp_ter ) 
    1108 ATM_flx_wemp_sea     = ATM_flux_int ( ATM_wemp_sea ) 
    1109  
    1110 ATM_flx_emp          = ATM_flux_int ( ATM_emp ) 
    1111  
    1112 if SRF : 
     992ATM.flx_wevap_ter    = ATM_flux_int ( ATM.wevap_ter ) 
     993ATM.flx_wevap_oce    = ATM_flux_int ( ATM.wevap_oce ) 
     994ATM.flx_wevap_lic    = ATM_flux_int ( ATM.wevap_lic ) 
     995ATM.flx_wevap_sic    = ATM_flux_int ( ATM.wevap_sic ) 
     996ATM.flx_wevap_sea    = ATM_flux_int ( ATM.wevap_sea ) 
     997ATM.flx_wprecip_lic  = ATM_flux_int ( ATM.wprecip_lic ) 
     998ATM.flx_wprecip_oce  = ATM_flux_int ( ATM.wprecip_oce ) 
     999ATM.flx_wprecip_sic  = ATM_flux_int ( ATM.wprecip_sic ) 
     1000ATM.flx_wprecip_ter  = ATM_flux_int ( ATM.wprecip_ter ) 
     1001ATM.flx_wprecip_sea  = ATM_flux_int ( ATM.wprecip_sea ) 
     1002ATM.flx_wemp_lic     = ATM_flux_int ( ATM.wemp_lic ) 
     1003ATM.flx_wemp_oce     = ATM_flux_int ( ATM.wemp_oce ) 
     1004ATM.flx_wemp_sic     = ATM_flux_int ( ATM.wemp_sic ) 
     1005ATM.flx_wemp_ter     = ATM_flux_int ( ATM.wemp_ter ) 
     1006ATM.flx_wemp_sea     = ATM_flux_int ( ATM.wemp_sea ) 
     1007 
     1008ATM.flx_emp          = ATM_flux_int ( ATM.emp ) 
     1009 
     1010if SECHIBA : 
    11131011    echo ( 'RUN flx_coastal' ) 
    1114     RUN_flx_coastal     = ONE_flux_int ( RUN_coastalflow) 
     1012    SRF.RUN_flx_coastal     = ONE_flux_int ( SRF.RUN_coastalflow) 
    11151013    echo ( 'RUN flx_river' ) 
    1116     RUN_flx_river       = ONE_flux_int ( RUN_riverflow  ) 
     1014    SRF.RUN_flx_river       = ONE_flux_int ( SRF.RUN_riverflow  ) 
    11171015    echo ( 'RUN flx_coastal_cpl' ) 
    1118     RUN_flx_coastal_cpl = ONE_flux_int ( RUN_coastalflow_cpl) 
     1016    SRF.RUN_flx_coastal_cpl = ONE_flux_int ( SRF.RUN_coastalflow_cpl) 
    11191017    echo ( 'RUN flx_river_cpl' ) 
    1120     RUN_flx_river_cpl   = ONE_flux_int ( RUN_riverflow_cpl  ) 
     1018    SRF.RUN_flx_river_cpl   = ONE_flux_int ( SRF.RUN_riverflow_cpl  ) 
    11211019    echo ( 'RUN flx_drainage' ) 
    1122     RUN_flx_drainage    = SRF_flux_int ( RUN_drainage   ) 
     1020    SRF.RUN_flx_drainage    = SRF_flux_int ( SRF.RUN_drainage   ) 
    11231021    echo ( 'RUN flx_riversset' ) 
    1124     RUN_flx_riversret   = SRF_flux_int ( RUN_riversret  ) 
     1022    SRF.RUN_flx_riversret   = SRF_flux_int ( SRF.RUN_riversret  ) 
    11251023    echo ( 'RUN flx_runoff' ) 
    1126     RUN_flx_runoff      = SRF_flux_int ( RUN_runoff     ) 
     1024    SRF.RUN_flx_runoff      = SRF_flux_int ( SRF.RUN_runoff     ) 
    11271025    echo ( 'RUN flx_input' ) 
    1128     RUN_flx_input       = SRF_flux_int ( RUN_input      ) 
     1026    SRF.RUN_flx_input       = SRF_flux_int ( SRF.RUN_input      ) 
    11291027    echo ( 'RUN flx_output' ) 
    1130     RUN_flx_output      = ONE_flux_int ( RUN_output     ) 
     1028    SRF.RUN_flx_output      = ONE_flux_int ( SRF.RUN_output     ) 
    11311029 
    11321030    echo ( 'RUN flx_bil' ) ; Step += 1 
    1133     #RUN_flx_bil    = RUN_flx_input   - RUN_flx_output 
    1134     #RUN_flx_rivcoa = RUN_flx_coastal + RUN_flx_river 
    1135  
    1136     RUN_flx_bil    = ONE_flux_int ( RUN_input       - RUN_output) 
    1137     RUN_flx_rivcoa = ONE_flux_int ( RUN_coastalflow + RUN_riverflow) 
    1138  
    1139 prtFlux ('wbilo_oce            ', ATM_flx_wbilo_oce     , 'f' ) 
    1140 prtFlux ('wbilo_sic            ', ATM_flx_wbilo_sic     , 'f' ) 
    1141 prtFlux ('wbilo_sic+oce        ', ATM_flx_wbilo_sea     , 'f' ) 
    1142 prtFlux ('wbilo_ter            ', ATM_flx_wbilo_ter     , 'f' ) 
    1143 prtFlux ('wbilo_lic            ', ATM_flx_wbilo_lic     , 'f' ) 
    1144 prtFlux ('Sum wbilo_*          ', ATM_flx_wbilo         , 'f', True) 
    1145 prtFlux ('E-P                  ', ATM_flx_emp           , 'f', True) 
    1146 prtFlux ('calving              ', ATM_flx_calving       , 'f' ) 
    1147 prtFlux ('fqfonte              ', ATM_flx_fqfonte       , 'f' ) 
    1148 prtFlux ('precip               ', ATM_flx_precip        , 'f' ) 
    1149 prtFlux ('snowf                ', ATM_flx_snowf         , 'f' ) 
    1150 prtFlux ('evap                 ', ATM_flx_evap          , 'f' ) 
    1151 prtFlux ('runoff lic           ', ATM_flx_runlic        , 'f' ) 
    1152  
    1153 prtFlux ('ATM_flx_wevap*       ', ATM_flx_wevap         , 'f' ) 
    1154 prtFlux ('ATM_flx_wrain*       ', ATM_flx_wrain         , 'f' ) 
    1155 prtFlux ('ATM_flx_wsnow*       ', ATM_flx_wsnow         , 'f' ) 
    1156 prtFlux ('ATM_flx_wprecip*     ', ATM_flx_wprecip       , 'f' ) 
    1157 prtFlux ('ATM_flx_wemp*        ', ATM_flx_wemp          , 'f', True ) 
     1031    #SRF.RUN_flx_bil    = SRF.RUN_flx_input   - SRF.RUN_flx_output 
     1032    #SRF.RUN_flx_rivcoa = SRF.RUN_flx_coastal + SRF.RUN_flx_river 
     1033 
     1034    SRF.RUN_flx_bil    = ONE_flux_int ( SRF.RUN_input       - SRF.RUN_output) 
     1035    SRF.RUN_flx_rivcoa = ONE_flux_int ( SRF.RUN_coastalflow + SRF.RUN_riverflow) 
     1036 
     1037prtFlux ('wbilo_oce            ', ATM.flx_wbilo_oce     , 'f' ) 
     1038prtFlux ('wbilo_sic            ', ATM.flx_wbilo_sic     , 'f' ) 
     1039prtFlux ('wbilo_sic+oce        ', ATM.flx_wbilo_sea     , 'f' ) 
     1040prtFlux ('wbilo_ter            ', ATM.flx_wbilo_ter     , 'f' ) 
     1041prtFlux ('wbilo_lic            ', ATM.flx_wbilo_lic     , 'f' ) 
     1042prtFlux ('Sum wbilo_*          ', ATM.flx_wbilo         , 'f', True) 
     1043prtFlux ('E-P                  ', ATM.flx_emp           , 'f', True) 
     1044prtFlux ('calving              ', ATM.flx_calving       , 'f' ) 
     1045prtFlux ('fqfonte              ', ATM.flx_fqfonte       , 'f' ) 
     1046prtFlux ('precip               ', ATM.flx_precip        , 'f' ) 
     1047prtFlux ('snowf                ', ATM.flx_snowf         , 'f' ) 
     1048prtFlux ('evap                 ', ATM.flx_evap          , 'f' ) 
     1049prtFlux ('runoff lic           ', ATM.flx_runlic        , 'f' ) 
     1050 
     1051prtFlux ('ATM.flx_wevap*       ', ATM.flx_wevap         , 'f' ) 
     1052prtFlux ('ATM.flx_wrain*       ', ATM.flx_wrain         , 'f' ) 
     1053prtFlux ('ATM.flx_wsnow*       ', ATM.flx_wsnow         , 'f' ) 
     1054prtFlux ('ATM.flx_wprecip*     ', ATM.flx_wprecip       , 'f' ) 
     1055prtFlux ('ATM.flx_wemp*        ', ATM.flx_wemp          , 'f', True ) 
    11581056 
    11591057echo ( 'Errors <field> vs. wbil_<field>' ) 
    1160 prtFlux ('ERROR evap           ', ATM_flx_wevap   - ATM_flx_evap  , 'e', True ) 
    1161 prtFlux ('ERROR precip         ', ATM_flx_wprecip - ATM_flx_precip, 'e', True ) 
    1162 prtFlux ('ERROR snow           ', ATM_flx_wsnow   - ATM_flx_snowf , 'e', True ) 
    1163 prtFlux ('ERROR emp            ', ATM_flx_wemp    - ATM_flx_emp   , 'e', True ) 
    1164  
    1165 if SRF : 
     1058prtFlux ('ERROR evap           ', ATM.flx_wevap   - ATM.flx_evap  , 'e', True ) 
     1059prtFlux ('ERROR precip         ', ATM.flx_wprecip - ATM.flx_precip, 'e', True ) 
     1060prtFlux ('ERROR snow           ', ATM.flx_wsnow   - ATM.flx_snowf , 'e', True ) 
     1061prtFlux ('ERROR emp            ', ATM.flx_wemp    - ATM.flx_emp   , 'e', True ) 
     1062 
     1063if SECHIBA : 
    11661064    echo ( '\n====================================================================================' ) 
    11671065    echo ( f'-- RUNOFF Fluxes  -- {Title} ' ) 
    1168     prtFlux ('coastalflow   ', RUN_flx_coastal    , 'f' ) 
    1169     prtFlux ('riverflow     ', RUN_flx_river      , 'f' ) 
    1170     prtFlux ('coastal_cpl   ', RUN_flx_coastal_cpl, 'f' ) 
    1171     prtFlux ('riverf_cpl    ', RUN_flx_river_cpl  , 'f' ) 
    1172     prtFlux ('river+coastal ', RUN_flx_rivcoa     , 'f' ) 
    1173     prtFlux ('drainage      ', RUN_flx_drainage   , 'f' ) 
    1174     prtFlux ('riversret     ', RUN_flx_riversret  , 'f' ) 
    1175     prtFlux ('runoff        ', RUN_flx_runoff     , 'f' ) 
    1176     prtFlux ('river in      ', RUN_flx_input      , 'f' ) 
    1177     prtFlux ('river out     ', RUN_flx_output     , 'f' ) 
    1178     prtFlux ('river bil     ', RUN_flx_bil        , 'f' ) 
    1179  
    1180 ATM_flx_budget = -ATM_flx_wbilo + ATM_flx_calving + ATM_flx_runlic #+# ATM_flx_fqfonte #+ RUN_flx_river 
     1066    prtFlux ('coastalflow   ', SRF.RUN_flx_coastal    , 'f' ) 
     1067    prtFlux ('riverflow     ', SRF.RUN_flx_river      , 'f' ) 
     1068    prtFlux ('coastal_cpl   ', SRF.RUN_flx_coastal_cpl, 'f' ) 
     1069    prtFlux ('riverf_cpl    ', SRF.RUN_flx_river_cpl  , 'f' ) 
     1070    prtFlux ('river+coastal ', SRF.RUN_flx_rivcoa     , 'f' ) 
     1071    prtFlux ('drainage      ', SRF.RUN_flx_drainage   , 'f' ) 
     1072    prtFlux ('riversret     ', SRF.RUN_flx_riversret  , 'f' ) 
     1073    prtFlux ('runoff        ', SRF.RUN_flx_runoff     , 'f' ) 
     1074    prtFlux ('river in      ', SRF.RUN_flx_input      , 'f' ) 
     1075    prtFlux ('river out     ', SRF.RUN_flx_output     , 'f' ) 
     1076    prtFlux ('river bil     ', SRF.RUN_flx_bil        , 'f' ) 
     1077 
     1078ATM.flx_budget = -ATM.flx_wbilo + ATM.flx_calving + ATM.flx_runlic #+# ATM.flx_fqfonte #+ SRF.RUN_flx_river 
    11811079 
    11821080 
    11831081echo ('') 
    1184 #echo ('  Global        {:12.3e} kg | {:12.4f} Sv | {:12.4f} m '.format ( ATM_flx_budget , ATM_flx_budget / dtime_sec*1E-9, ATM_flx_budget /ATM_aire_sea_tot/ATM_rho )) 
    1185  
    1186 #echo ('  E-P-R         {:12.3e} kg | {:12.4e} Sv | {:12.4f} m '.format ( ATM_flx_emp      , ATM_flx_emp      / dtime_sec*1E-6/ATM_rho, ATM_flx_emp      /ATM_aire_sea_tot/ATM_rho )) 
    1187  
    1188 ATM_flx_toSRF = -ATM_flx_wbilo_ter 
     1082#echo ('  Global        {:12.3e} kg | {:12.4f} Sv | {:12.4f} m '.format ( ATM.flx_budget , ATM.flx_budget / dtime_sec*1E-9, ATM.flx_budget /ATM.aire_sea_tot/ATM.rho )) 
     1083 
     1084#echo ('  E-P-R         {:12.3e} kg | {:12.4e} Sv | {:12.4f} m '.format ( ATM.flx_emp      , ATM.flx_emp      / dtime_sec*1E-6/ATM_RHO, ATM.flx_emp      /ATM.aire_sea_tot/ATM_rho )) 
     1085 
     1086ATM.flx_toSRF = -ATM.flx_wbilo_ter 
    11891087 
    11901088echo (' ') 
    11911089echo ( '\n====================================================================================' ) 
    11921090echo ( f'--  Atmosphere  -- {Title} ' ) 
    1193 echo ( f'Mass begin = {DYN_mas_wat_beg:12.6e} kg | Mass end = {DYN_mas_wat_end:12.6e} kg' ) 
    1194 prtFlux ( 'dmass (atm)  = ', dDYN_mas_wat , 'e', True ) 
    1195 prtFlux ( 'Sum wbilo_*  = ', ATM_flx_wbilo, 'e', True ) 
    1196 prtFlux ( 'E-P          = ', ATM_flx_emp  , 'e', True ) 
     1091echo ( f'Mass begin = {DYN.mass_wat_beg:12.6e} kg | Mass end = {DYN.mass_wat_end:12.6e} kg' ) 
     1092prtFlux ( 'dmass (atm) ', DYN.diff_mass_wat , 'e', True ) 
     1093prtFlux ( 'Sum wbilo_* ', ATM.flx_wbilo, 'e', True ) 
     1094prtFlux ( 'E-P         ', ATM.flx_emp  , 'e', True ) 
    11971095echo ( ' ' ) 
    1198 prtFlux ( 'Water loss atm from wbil_*', ATM_flx_wbilo - dDYN_mas_wat, 'f', True ) 
    1199 echo ( 'Water loss atm = {:12.3e} (rel)  '.format ( (ATM_flx_wbilo - dDYN_mas_wat)/dDYN_mas_wat  ) ) 
     1096prtFlux ( 'Water loss atm from wbil_*', ATM.flx_wbilo - DYN.diff_mass_wat, 'f', True ) 
     1097echo ( 'Water loss atm = {:12.3e} (rel)  '.format ( (ATM.flx_wbilo - DYN.diff_mass_wat)/DYN.diff_mass_wat  ) ) 
    12001098 
    12011099echo (' ') 
    1202 prtFlux ( 'Water loss atm from E-P', ATM_flx_emp  - dDYN_mas_wat , 'f', True ) 
    1203 echo ( 'Water loss atm = {:12.3e} (rel)  '.format ( (ATM_flx_emp-dDYN_mas_wat)/dDYN_mas_wat  ) ) 
     1100prtFlux ( 'Water loss atm from E-P', ATM.flx_emp  - DYN.diff_mass_wat , 'f', True ) 
     1101echo ( 'Water loss atm = {:12.3e} (rel)  '.format ( (ATM.flx_emp-DYN.diff_mass_wat)/DYN.diff_mass_wat  ) ) 
    12041102echo (' ') 
    12051103 
    1206 ATM_error =  ATM_flx_emp  - dDYN_mas_wat 
     1104ATM.error =  ATM.flx_emp  - DYN.diff_mass_wat 
    12071105 
    12081106 
    … …  
    12101108echo ( '\n====================================================================================' ) 
    12111109 
    1212 LIC_flx_budget1 = Sprec ( [-ATM_flx_wemp_lic  , -LIC_flx_calving , -LIC_flx_fqfonte] ) 
    1213 LIC_flx_budget2 = Sprec ( [-ATM_flx_wbilo_lic , -LIC_flx_calving , -LIC_flx_fqfonte] ) 
    1214 LIC_flx_budget3 = Sprec ( [-ATM_flx_wbilo_lic , -LIC_flx_runlic] ) 
    1215 LIC_flx_budget4 = Sprec ( [-ATM_flx_wemp_lic  , -LIC_flx_runlic] ) 
     1110ATM.LIC_flx_budget1 = Sprec ( [-ATM.flx_wemp_lic  , -ATM.LIC_flx_calving , -ATM.LIC_flx_fqfonte] ) 
     1111ATM.LIC_flx_budget2 = Sprec ( [-ATM.flx_wbilo_lic , -ATM.LIC_flx_calving , -ATM.LIC_flx_fqfonte] ) 
     1112ATM.LIC_flx_budget3 = Sprec ( [-ATM.flx_wbilo_lic , -ATM.LIC_flx_runlic] ) 
     1113ATM.LIC_flx_budget4 = Sprec ( [-ATM.flx_wemp_lic  , -ATM.LIC_flx_runlic] ) 
    12161114 
    12171115echo ( f'--  LIC  -- {Title} ' ) 
    1218 echo ( f'Mass total   begin = {LIC_mas_wat_beg    :12.6e} kg | Mass end = {LIC_mas_wat_end    :12.6e} kg' ) 
    1219 echo ( f'Mass snow    begin = {LIC_mas_sno_beg    :12.6e} kg | Mass end = {LIC_mas_sno_end    :12.6e} kg' ) 
    1220 echo ( f'Mass qs      begin = {LIC_mas_qs_beg     :12.6e} kg | Mass end = {LIC_mas_qs_end     :12.6e} kg' ) 
    1221 echo ( f'Mass runlic0 begin = {LIC_mas_runlic0_beg:12.6e} kg | Mass end = {LIC_mas_runlic0_end:12.6e} kg' ) 
    1222 prtFlux ( 'dmass (LIC sno)       ', dLIC_mas_sno          , 'f', True, width=45 ) 
    1223 prtFlux ( 'dmass (LIC qs)        ', dLIC_mas_qs           , 'e', True, width=45 ) 
    1224 prtFlux ( 'dmass (LIC wat)       ', dLIC_mas_wat          , 'f', True, width=45 ) 
    1225 prtFlux ( 'dmass (LIC runlic0)   ', dLIC_mas_runlic0      , 'e', True, width=45 ) 
    1226 prtFlux ( 'dmass (LIC total)     ', dLIC_mas_wat          , 'e', True, width=45 ) 
    1227 prtFlux ( 'LIC ATM_flx_wemp_lic  ', ATM_flx_wemp_lic      , 'f', True, width=45 ) 
    1228 prtFlux ( 'LIC LIC_flx_fqfonte   ', LIC_flx_fqfonte       , 'f', True, width=45 ) 
    1229 prtFlux ( 'LIC LIC_flx_calving   ', LIC_flx_calving       , 'f', True, width=45 ) 
    1230 prtFlux ( 'LIC LIC_flx_runofflic ', LIC_flx_runlic        , 'f', True, width=45 ) 
    1231 prtFlux ( 'LIC fqfonte + calving ', LIC_flx_calving+LIC_flx_fqfonte , 'f', True, width=45 ) 
    1232 prtFlux ( 'LIC fluxes 1 ( wemp_lic   - fqcalving - fqfonte)) ', LIC_flx_budget1              , 'f', True, width=45 ) 
    1233 prtFlux ( 'LIC fluxes 2 (-wbilo_lic - fqcalving - fqfonte)   ', LIC_flx_budget2              , 'f', True, width=45 ) 
    1234 prtFlux ( 'LIC fluxes 3 (-wbilo_lic - runofflic*frac_lic)    ', LIC_flx_budget3              , 'f', True, width=45 ) 
    1235 prtFlux ( 'LIC fluxes 3 ( wemp_lic  - runofflic*frac_lic)    ', LIC_flx_budget4              , 'f', True, width=45 ) 
    1236 prtFlux ( 'LIC error 1                                       ', LIC_flx_budget1-dLIC_mas_wat , 'e', True, width=45 ) 
    1237 prtFlux ( 'LIC error 2                                       ', LIC_flx_budget2-dLIC_mas_wat , 'e', True, width=45 ) 
    1238 prtFlux ( 'LIC error 3                                       ', LIC_flx_budget3-dLIC_mas_wat , 'e', True, width=45 ) 
    1239 echo ( 'LIC error (wevap - precip*frac_lic  - fqcalving - fqfonte)    = {:12.4e} (rel) '.format ( (LIC_flx_budget1-dLIC_mas_wat)/dLIC_mas_wat) ) 
    1240 echo ( 'LIC error (-wbilo_lic - fqcalving - fqfonte)                  = {:12.4e} (rel) '.format ( (LIC_flx_budget2-dLIC_mas_wat)/dLIC_mas_wat) ) 
    1241 echo ( 'LIC error (-wbilo_lic - runofflic*frac_lic)                   = {:12.4e} (rel) '.format ( (LIC_flx_budget3-dLIC_mas_wat)/dLIC_mas_wat) ) 
    1242  
    1243 if SRF : 
     1116echo ( f'Mass total   begin = {ATM.LIC_mass_wat_beg    :12.6e} kg | Mass end = {ATM.LIC_mass_wat_end    :12.6e} kg' ) 
     1117echo ( f'Mass snow    begin = {ATM.LIC_mass_sno_beg    :12.6e} kg | Mass end = {ATM.LIC_mass_sno_end    :12.6e} kg' ) 
     1118echo ( f'Mass qs      begin = {ATM.LIC_mass_qs_beg     :12.6e} kg | Mass end = {ATM.LIC_mass_qs_end     :12.6e} kg' ) 
     1119echo ( f'Mass runlic0 begin = {ATM.LIC_mass_runlic0_beg:12.6e} kg | Mass end = {ATM.LIC_mass_runlic0_end:12.6e} kg' ) 
     1120prtFlux ( 'dmass (LIC sno)       ', ATM.LIC_diff_mass_sno          , 'f', True, width=45 ) 
     1121prtFlux ( 'dmass (LIC qs)        ', ATM.LIC_diff_mass_qs           , 'e', True, width=45 ) 
     1122prtFlux ( 'dmass (LIC wat)       ', ATM.LIC_diff_mass_wat          , 'f', True, width=45 ) 
     1123prtFlux ( 'dmass (LIC runlic0)   ', ATM.LIC_diff_mass_runlic0      , 'e', True, width=45 ) 
     1124prtFlux ( 'dmass (LIC total)     ', ATM.LIC_diff_mass_wat          , 'e', True, width=45 ) 
     1125prtFlux ( 'LIC ATM.flx_wemp_lic  ', ATM.flx_wemp_lic          , 'f', True, width=45 ) 
     1126prtFlux ( 'LIC LIC_flx_fqfonte   ', ATM.LIC_flx_fqfonte       , 'f', True, width=45 ) 
     1127prtFlux ( 'LIC LIC_flx_calving   ', ATM.LIC_flx_calving       , 'f', True, width=45 ) 
     1128prtFlux ( 'LIC LIC_flx_runofflic ', ATM.LIC_flx_runlic        , 'f', True, width=45 ) 
     1129prtFlux ( 'LIC fqfonte + calving ', ATM.LIC_flx_calving+ATM.LIC_flx_fqfonte , 'f', True, width=45 ) 
     1130prtFlux ( 'LIC fluxes 1 ( wemp_lic   - fqcalving - fqfonte)) ', ATM.LIC_flx_budget1              , 'f', True, width=45 ) 
     1131prtFlux ( 'LIC fluxes 2 (-wbilo_lic - fqcalving - fqfonte)   ', ATM.LIC_flx_budget2              , 'f', True, width=45 ) 
     1132prtFlux ( 'LIC fluxes 3 (-wbilo_lic - runofflic*frac_lic)    ', ATM.LIC_flx_budget3              , 'f', True, width=45 ) 
     1133prtFlux ( 'LIC fluxes 3 ( wemp_lic  - runofflic*frac_lic)    ', ATM.LIC_flx_budget4              , 'f', True, width=45 ) 
     1134prtFlux ( 'LIC error 1                                       ', ATM.LIC_flx_budget1-ATM.LIC_diff_mass_wat , 'e', True, width=45 ) 
     1135prtFlux ( 'LIC error 2                                       ', ATM.LIC_flx_budget2-ATM.LIC_diff_mass_wat , 'e', True, width=45 ) 
     1136prtFlux ( 'LIC error 3                                       ', ATM.LIC_flx_budget3-ATM.LIC_diff_mass_wat , 'e', True, width=45 ) 
     1137echo ( 'LIC error (wevap - precip*frac_lic  - fqcalving - fqfonte)    = {:12.4e} (rel) '.format ( (ATM.LIC_flx_budget1-ATM.LIC_diff_mass_wat)/ATM.LIC_diff_mass_wat) ) 
     1138echo ( 'LIC error (-wbilo_lic - fqcalving - fqfonte)                  = {:12.4e} (rel) '.format ( (ATM.LIC_flx_budget2-ATM.LIC_diff_mass_wat)/ATM.LIC_diff_mass_wat) ) 
     1139echo ( 'LIC error (-wbilo_lic - runofflic*frac_lic)                   = {:12.4e} (rel) '.format ( (ATM.LIC_flx_budget3-ATM.LIC_diff_mass_wat)/ATM.LIC_diff_mass_wat) ) 
     1140 
     1141if SECHIBA : 
    12441142    echo ( '\n====================================================================================' ) 
    12451143    echo ( f'-- SECHIBA fluxes  -- {Title} ' ) 
    12461144 
    1247     SRF_flx_rain     = SRF_flux_int ( SRF_rain     ) 
    1248     SRF_flx_evap     = SRF_flux_int ( SRF_evap     ) 
    1249     SRF_flx_snowf    = SRF_flux_int ( SRF_snowf    ) 
    1250     SRF_flx_subli    = SRF_flux_int ( SRF_subli    ) 
    1251     SRF_flx_transpir = SRF_flux_int ( SRF_transpir ) 
    1252     SRF_flx_emp      = SRF_flux_int ( SRF_emp      ) 
    1253  
    1254     RUN_flx_torouting   = SRF_flux_int  ( RUN_runoff       + RUN_drainage) 
    1255     RUN_flx_fromrouting = ONE_flux_int  ( RUN_coastalflow + RUN_riverflow ) 
    1256  
    1257     SRF_flx_all =  SRF_flux_int  ( SRF_rain + SRF_snowf - SRF_evap - RUN_runoff - RUN_drainage ) 
    1258  
    1259     prtFlux ('rain         ', SRF_flx_rain       , 'f' ) 
    1260     prtFlux ('evap         ', SRF_flx_evap       , 'f' ) 
    1261     prtFlux ('snowf        ', SRF_flx_snowf      , 'f' ) 
    1262     prtFlux ('E-P          ', SRF_flx_emp        , 'f' ) 
    1263     prtFlux ('subli        ', SRF_flx_subli      , 'f' ) 
    1264     prtFlux ('transpir     ', SRF_flx_transpir   , 'f' ) 
    1265     prtFlux ('to routing   ', RUN_flx_torouting  , 'f' ) 
    1266     prtFlux ('budget       ', SRF_flx_all        , 'f', small=True ) 
     1145    SRF.flx_rain     = SRF_flux_int ( SRF.rain     ) 
     1146    SRF.flx_evap     = SRF_flux_int ( SRF.evap     ) 
     1147    SRF.flx_snowf    = SRF_flux_int ( SRF.snowf    ) 
     1148    SRF.flx_subli    = SRF_flux_int ( SRF.subli    ) 
     1149    SRF.flx_transpir = SRF_flux_int ( SRF.transpir ) 
     1150    SRF.flx_emp      = SRF_flux_int ( SRF.emp      ) 
     1151 
     1152    SRF.RUN_flx_torouting   = SRF_flux_int  ( SRF.RUN_runoff      + SRF.RUN_drainage) 
     1153    SRF.RUN_flx_fromrouting = ONE_flux_int  ( SRF.RUN_coastalflow + SRF.RUN_riverflow ) 
     1154 
     1155    SRF.flx_all =  SRF_flux_int  ( SRF.rain + SRF.snowf - SRF.evap - SRF.RUN_runoff - SRF.RUN_drainage ) 
     1156 
     1157    prtFlux ('rain         ', SRF.flx_rain       , 'f' ) 
     1158    prtFlux ('evap         ', SRF.flx_evap       , 'f' ) 
     1159    prtFlux ('snowf        ', SRF.flx_snowf      , 'f' ) 
     1160    prtFlux ('E-P          ', SRF.flx_emp        , 'f' ) 
     1161    prtFlux ('subli        ', SRF.flx_subli      , 'f' ) 
     1162    prtFlux ('transpir     ', SRF.flx_transpir   , 'f' ) 
     1163    prtFlux ('to routing   ', SRF.RUN_flx_torouting  , 'f' ) 
     1164    prtFlux ('budget       ', SRF.flx_all        , 'f', small=True ) 
    12671165 
    12681166    echo ( '\n------------------------------------------------------------------------------------' ) 
    12691167    echo ( 'Water content in surface ' ) 
    1270     echo ( f'SRF_mas_wat_beg  = {SRF_mas_wat_beg:12.6e} kg | SRF_mas_wat_end  = {SRF_mas_wat_end:12.6e} kg ' ) 
    1271     prtFlux ( 'dMass (water srf)', dSRF_mas_wat, 'e', small=True) 
    1272     prtFlux ( 'Error            ',  SRF_flx_all-dSRF_mas_wat, 'e', small=True ) 
    1273     echo ( 'dMass (water srf) = {:12.4e} (rel)   '.format ( (SRF_flx_all-dSRF_mas_wat)/dSRF_mas_wat) ) 
     1168    echo ( f'SRF.mass_wat_beg  = {SRF.mass_wat_beg:12.6e} kg | SRF.mass_wat_end  = {SRF.mass_wat_end:12.6e} kg ' ) 
     1169    prtFlux ( 'dMass (water srf)', SRF.diff_mass_wat, 'e', small=True) 
     1170    prtFlux ( 'Error            ', SRF.flx_all-SRF.diff_mass_wat, 'e', small=True ) 
     1171    echo ( 'dMass (water srf) = {:12.4e} (rel)   '.format ( (SRF.flx_all-SRF.diff_mass_wat)/SRF.diff_mass_wat) ) 
    12741172 
    12751173    echo ( '\n====================================================================================' ) 
    1276     echo ( f'-- Check ATM vs. SRF -- {Title} ' ) 
    1277     prtFlux ('E-P ATM       ', ATM_flx_wemp_ter   , 'f' ) 
    1278     prtFlux ('wbilo ter     ', ATM_flx_wbilo_ter  , 'f' ) 
    1279     prtFlux ('E-P SRF       ', SRF_flx_emp        , 'f' ) 
    1280     prtFlux ('SRF/ATM error ', ATM_flx_wbilo_ter - SRF_flx_emp, 'e', True) 
    1281     echo ( 'SRF/ATM error {:12.3e} (rel)  '.format ( (ATM_flx_wbilo_ter - SRF_flx_emp)/SRF_flx_emp ) ) 
     1174    echo ( f'-- Check ATM vs. SECHIBA -- {Title} ' ) 
     1175    prtFlux ('E-P ATM       ', ATM.flx_wemp_ter   , 'f' ) 
     1176    prtFlux ('wbilo ter     ', ATM.flx_wbilo_ter  , 'f' ) 
     1177    prtFlux ('E-P SECHIBA   ', SRF.flx_emp        , 'f' ) 
     1178    prtFlux ('SRF/ATM error ', ATM.flx_wbilo_ter - SRF.flx_emp, 'e', True) 
     1179    echo ( 'SRF/ATM error {:12.3e} (rel)  '.format ( (ATM.flx_wbilo_ter - SRF.flx_emp)/SRF.flx_emp ) ) 
    12821180 
    12831181    echo ('') 
    12841182    echo ( '\n====================================================================================' ) 
    12851183    echo ( f'-- RUNOFF fluxes  -- {Title} ' ) 
    1286     RUN_flx_all = RUN_flx_torouting - RUN_flx_river - RUN_flx_coastal 
    1287     prtFlux ('runoff    ', RUN_flx_runoff      , 'f' ) 
    1288     prtFlux ('drainage  ', RUN_flx_drainage    , 'f' ) 
    1289     prtFlux ('run+drain ', RUN_flx_torouting   , 'f' ) 
    1290     prtFlux ('river     ', RUN_flx_river       , 'f' ) 
    1291     prtFlux ('coastal   ', RUN_flx_coastal     , 'f' ) 
    1292     prtFlux ('riv+coa   ', RUN_flx_fromrouting , 'f' ) 
    1293     prtFlux ('budget    ', RUN_flx_all         , 'f' , small=True) 
     1184    SRF.RUN_flx_all = SRF.RUN_flx_torouting - SRF.RUN_flx_river - SRF.RUN_flx_coastal 
     1185    prtFlux ('runoff    ', SRF.RUN_flx_runoff      , 'f' ) 
     1186    prtFlux ('drainage  ', SRF.RUN_flx_drainage    , 'f' ) 
     1187    prtFlux ('run+drain ', SRF.RUN_flx_torouting   , 'f' ) 
     1188    prtFlux ('river     ', SRF.RUN_flx_river       , 'f' ) 
     1189    prtFlux ('coastal   ', SRF.RUN_flx_coastal     , 'f' ) 
     1190    prtFlux ('riv+coa   ', SRF.RUN_flx_fromrouting , 'f' ) 
     1191    prtFlux ('budget    ', SRF.RUN_flx_all         , 'f' , small=True) 
    12941192 
    12951193    echo ( '\n------------------------------------------------------------------------------------' ) 
    12961194    echo ( f'Water content in routing+lake  -- {Title} ' ) 
    1297     echo ( f'RUN_mas_wat_beg  = {RUN_mas_wat_beg:12.6e} kg | RUN_mas_wat_end = {RUN_mas_wat_end:12.6e} kg ' ) 
    1298     prtFlux ( 'dMass (routing)  ', dRUN_mas_wat+dSRF_mas_lake, 'f', small=True) 
    1299     prtFlux ( 'Routing error    ', RUN_flx_all+dSRF_mas_lake-dRUN_mas_wat, 'e', small=True ) 
    1300     echo ( 'Routing error : {:12.3e} (rel)'.format ( (RUN_flx_all-dSRF_mas_lake-dRUN_mas_wat)/(dRUN_mas_wat+dSRF_mas_lake) ) ) 
     1195    echo ( f'SRF.RUN_mass_wat_beg  = {SRF.RUN_mass_wat_beg:12.6e} kg | SRF.RUN_mass_wat_end = {SRF.RUN_mass_wat_end:12.6e} kg ' ) 
     1196    prtFlux ( 'dMass (routing)  ', SRF.RUN_diff_mass_wat+SRF.diff_mass_lake, 'f', small=True) 
     1197    prtFlux ( 'Routing error    ', SRF.RUN_flx_all+SRF.diff_mass_lake-SRF.RUN_diff_mass_wat, 'e', small=True ) 
     1198    echo ( 'Routing error : {:12.3e} (rel)'.format ( (SRF.RUN_flx_all-SRF.diff_mass_lake-SRF.RUN_diff_mass_wat)/(SRF.RUN_diff_mass_wat+SRF.diff_mass_lake) ) ) 
    13011199 
    13021200    echo ( '\n------------------------------------------------------------------------------------' ) 
    13031201    echo ( f'Water content in routing  -- {Title} ' ) 
    1304     echo ( f'RUN_mas_wat_beg  = {RUN_mas_wat_beg:12.6e} kg | RUN_mas_wat_end = {RUN_mas_wat_end:12.6e} kg ' ) 
    1305     prtFlux ( 'dMass (routing) ', dRUN_mas_wat, 'f', small=True  ) 
    1306     prtFlux ( 'Routing error   ', RUN_flx_all-dRUN_mas_wat, 'e', small=True) 
    1307     echo ( 'Routing error : {:12.3e} (rel)'.format ( (RUN_flx_all-dRUN_mas_wat)/dRUN_mas_wat ) ) 
     1202    echo ( f'SRF.RUN_mass_wat_beg  = {SRF.RUN_mass_wat_beg:12.6e} kg | SRF.RUN_mass_wat_end = {SRF.RUN_mass_wat_end:12.6e} kg ' ) 
     1203    prtFlux ( 'dMass (routing) ', SRF.RUN_diff_mass_wat, 'f', small=True  ) 
     1204    prtFlux ( 'Routing error   ', SRF.RUN_flx_all-SRF.RUN_diff_mass_wat, 'e', small=True) 
     1205    echo ( 'Routing error : {:12.3e} (rel)'.format ( (SRF.RUN_flx_all-SRF.RUN_diff_mass_wat)/SRF.RUN_diff_mass_wat ) ) 
    13081206 
    13091207echo ( ' ' ) 

  • TOOLS/WATER_BUDGET/CPL_waterbudget.py

    r6676 r6688  
    1212## 
    1313## 
    14 # SVN information 
    15 #  $Author$ 
    16 #  $Date$ 
    17 #  $Revision$ 
    18 #  $Id$ 
    19 #  $HeadURL$ 
    20  
    2114# SVN Information 
    2215SVN = { 
    … …  
    10194def kg2myear (val, rho=ATM_RHO) : 
    10295    '''From kg to m/year''' 
    103     return val/ATM_aire_sea_tot/rho/NbYear 
     96    return val/ATM.aire_sea_tot/rho/NbYear 
    10497 
    10598def var2prt (var, small=False, rho=ATM_RHO) : 
    … …  
    126119    f_out.flush () 
    127120    return None 
    128  
    129  
    130  
    131121         
    132122d_ATM_his = xr.open_dataset ( file_ATM_his, use_cftime=True, decode_times=True, decode_cf=True ).squeeze() 
    133 if SRF :  
     123if SECHIBA :  
    134124    d_SRF_his = xr.open_dataset ( file_SRF_his, use_cftime=True, decode_times=True, decode_cf=True ).squeeze() 
    135125    if Routing == 'SECHIBA' : d_RUN_his = d_SRF_his 
    … …  
    170160params_out.close () 
    171161 
    172 # ATM grid with cell surfaces 
    173 if LMDZ : 
    174     echo ('ATM grid with cell surfaces : LMDZ') 
    175     ATM_lat       = lmdz.geo2point (   rprec (d_ATM_his ['lat'])+0*rprec (d_ATM_his ['lon']), dim1D='cell' ) 
    176     ATM_lon       = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat'])+  rprec (d_ATM_his ['lon']), dim1D='cell' ) 
    177     ATM_aire      = lmdz.geo2point ( rprec (d_ATM_his ['aire'] )    [0], cumulPoles=True, dim1D='cell' ) 
    178     ATM_fter      = lmdz.geo2point ( rprec (d_ATM_his ['fract_ter'][0]), dim1D='cell' ) 
    179     ATM_foce      = lmdz.geo2point ( rprec (d_ATM_his ['fract_oce'][0]), dim1D='cell' ) 
    180     ATM_fsic      = lmdz.geo2point ( rprec (d_ATM_his ['fract_sic'][0]), dim1D='cell' ) 
    181     ATM_flic      = lmdz.geo2point ( rprec (d_ATM_his ['fract_lic'][0]), dim1D='cell' ) 
    182     if SRF :  
    183         SRF_lat       = lmdz.geo2point (   rprec (d_SRF_his ['lat'])+0*rprec (d_SRF_his ['lon']), dim1D='cell' ) 
    184         SRF_lon       = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat'])+  rprec (d_SRF_his ['lon']), dim1D='cell' ) 
    185         SRF_aire      = lmdz.geo2point ( rprec (d_SRF_his ['Areas']) * rprec (d_SRF_his ['Contfrac']), dim1D='cell', cumulPoles=True ) 
    186         SRF_areas     = lmdz.geo2point ( rprec (d_SRF_his ['Areas'])  ,  dim1D='cell', cumulPoles=True ) 
    187         SRF_contfrac  = lmdz.geo2point ( rprec (d_SRF_his ['Contfrac']), dim1D='cell' ) 
     162## Compute aire, fractions, etc ... 
     163## -------------------------------- 
     164if ICO : 
     165    if not file_DYN_aire : 
     166        file_DYN_aire = os.path.join ( R_IN, 'ATM', 'GRID', ResolAtm+'_grid.nc' ) 
     167    dpar['Files']['file_DYN_aire'] = file_DYN_aire 
     168    echo ( f'{file_DYN_aire = }' ) 
     169    d_DYN_aire = xr.open_dataset ( file_DYN_aire, decode_times=False ).squeeze() 
     170else : 
     171    d_DYN_aire = None 
    188172         
    189 if ICO : 
    190     if ATM_HIS == 'latlon' : 
    191         echo ( 'ATM areas and fractions on latlon grid' ) 
    192         if 'lat_dom_out' in d_ATM_his.variables : 
    193             ATM_lat  = lmdz.geo2point (   rprec (d_ATM_his ['lat_dom_out'])+0*rprec (d_ATM_his ['lon_dom_out']), dim1D='cell' ) 
    194             ATM_lon  = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat_dom_out'])+  rprec (d_ATM_his ['lon_dom_out']), dim1D='cell' ) 
    195         else : 
    196             ATM_lat  = lmdz.geo2point (   rprec (d_ATM_his ['lat'])+0*rprec (d_ATM_his ['lon']), dim1D='cell' ) 
    197             ATM_lon  = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat'])+  rprec (d_ATM_his ['lon']), dim1D='cell' ) 
    198         ATM_aire = lmdz.geo2point ( rprec (d_ATM_his ['aire'][0]).squeeze(), cumulPoles=True, dim1D='cell' ) 
    199         ATM_fter = lmdz.geo2point ( rprec (d_ATM_his ['fract_ter'][0]), dim1D='cell' ) 
    200         ATM_foce = lmdz.geo2point ( rprec (d_ATM_his ['fract_oce'][0]), dim1D='cell' ) 
    201         ATM_fsic = lmdz.geo2point ( rprec (d_ATM_his ['fract_sic'][0]), dim1D='cell' ) 
    202         ATM_flic = lmdz.geo2point ( rprec (d_ATM_his ['fract_lic'][0]), dim1D='cell' ) 
    203  
    204     if ATM_HIS == 'ico' : 
    205         echo ( 'ATM areas and fractions on ICO grid' ) 
    206         ATM_aire =  rprec (d_ATM_his ['aire']     [0]).squeeze() 
    207         ATM_lat  =  rprec (d_ATM_his ['lat']         ) 
    208         ATM_lon  =  rprec (d_ATM_his ['lon']         ) 
    209         ATM_fter =  rprec (d_ATM_his ['fract_ter'][0]) 
    210         ATM_foce =  rprec (d_ATM_his ['fract_oce'][0]) 
    211         ATM_fsic =  rprec (d_ATM_his ['fract_sic'][0]) 
    212         ATM_flic =  rprec (d_ATM_his ['fract_lic'][0]) 
    213  
    214     if SRF :  
    215         if SRF_HIS == 'latlon' : 
    216             echo ( 'SRF areas and fractions on latlon grid' ) 
    217             if 'lat_domain_landpoints_out' in d_SRF_his  :  
    218                 SRF_lat  = lmdz.geo2point (   rprec (d_SRF_his ['lat_domain_landpoints_out'])+0*rprec (d_SRF_his ['lon_domain_landpoints_out']), dim1D='cell' ) 
    219                 SRF_lon  = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat_domain_landpoints_out'])+  rprec (d_SRF_his ['lon_domain_landpoints_out']), dim1D='cell' ) 
    220             else :  
    221                 if 'lat_domain_landpoints_out' in d_SRF_his : 
    222                     SRF_lat  = lmdz.geo2point (   rprec (d_SRF_his ['lat_dom_out'])+0*rprec (d_SRF_his ['lon_dom_out']), dim1D='cell' ) 
    223                     SRF_lon  = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat_dom_out'])+  rprec (d_SRF_his ['lon_dom_out']), dim1D='cell' ) 
    224                 else : 
    225                     SRF_lat  = lmdz.geo2point (   rprec (d_SRF_his ['lat'])+0*rprec (d_SRF_his ['lon']), dim1D='cell' ) 
    226                     SRF_lon  = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat'])+  rprec (d_SRF_his ['lon']), dim1D='cell' ) 
    227                      
    228             SRF_areas     = lmdz.geo2point ( rprec (d_SRF_his ['Areas']   )   , dim1D='cell', cumulPoles=True ) 
    229             SRF_areafrac  = lmdz.geo2point ( rprec (d_SRF_his ['AreaFrac'])   , dim1D='cell', cumulPoles=True ) 
    230             SRF_contfrac  = lmdz.geo2point ( rprec (d_SRF_his ['Contfrac'])   , dim1D='cell', cumulPoles=True ) 
    231             SRF_aire = SRF_areafrac 
    232   
    233         if SRF_HIS == 'ico' : 
    234             echo ( 'SRF areas and fractions on latlon grid' ) 
    235             SRF_lat       =  rprec (d_SRF_his ['lat']     ) 
    236             SRF_lon       =  rprec (d_SRF_his ['lon']     ) 
    237             SRF_areas     =  rprec (d_SRF_his ['Areas']   )  
    238             SRF_contfrac  =  rprec (d_SRF_his ['Contfrac']) 
    239             SRF_aire      =  SRF_areas * SRF_contfrac 
    240              
    241 ATM_fsea      = ATM_foce + ATM_fsic 
    242 ATM_flnd      = ATM_fter + ATM_flic 
    243 ATM_aire_fter = ATM_aire * ATM_fter 
    244 ATM_aire_flic = ATM_aire * ATM_flic 
    245 ATM_aire_fsic = ATM_aire * ATM_fsic 
    246 ATM_aire_foce = ATM_aire * ATM_foce 
    247 ATM_aire_flnd = ATM_aire * ATM_flnd 
    248 ATM_aire_fsea = ATM_aire * ATM_fsea 
    249  
    250 #SRF_aire = SRF_aire.where ( SRF_aire < 1E15, 0.) 
    251  
    252 # if ICO : 
    253 #     if wu.unDefined ('file_DYN_aire') : file_DYN_aire = os.path.join ( R_IN, 'ATM', 'GRID', ATM+'_grid.nc' ) 
    254 #     config['Files']['file_DYN_aire'] = file_DYN_aire 
    255  
    256 # if ICO : 
    257 #     # Area on icosahedron grid 
    258 #     d_DYN_aire = xr.open_dataset ( file_DYN_aire, decode_times=False ).squeeze() 
    259             
    260 #     DYN_lat = d_DYN_aire['lat'] 
    261 #     DYN_lon = d_DYN_aire['lon'] 
    262  
    263 #     DYN_aire = d_DYN_aire['aire'] 
    264 #     DYN_fsea = d_DYN_aire['fract_oce'] + d_DYN_aire['fract_sic'] 
    265 #     DYN_flnd = 1.0 - DYN_fsea 
    266 #     DYN_fter = d_ATM_beg['FTER'] 
    267 #     DYN_flic = d_ATM_beg['FLIC'] 
    268 #     DYN_aire_fter = DYN_aire * DYN_fter 
    269      
    270 # if LMDZ : 
    271 #     # Area on lon/lat grid 
    272 #     DYN_aire = ATM_aire 
    273 #     DYN_fsea = ATM_fsea 
    274 #     DYN_flnd = ATM_flnd 
    275 #     DYN_fter = rprec (d_ATM_beg['FTER']) 
    276 #     DYN_flic = rprec (d_ATM_beg['FLIC']) 
    277 #     DYN_aire_fter = DYN_aire * DYN_fter 
    278  
    279 # Functions computing integrals and sum 
    280 # def ATM_stock_int (stock) : 
    281 #     '''Integrate (* surface) stock on atmosphere grid''' 
    282 #     ATM_stock_int  = wu.Psum ( (stock * DYN_aire).to_masked_array().ravel() )  
    283 #     return ATM_stock_int 
     173dpar, ATM = wu.ComputeGridATM ( dpar, d_ATM_his)  
     174dpar, SRF = wu.ComputeGridSRF ( dpar, d_SRF_his) 
     175dpar, OCE = wu.ComputeGridOCE ( dpar, d_OCE_his, nperio=nperio ) 
    284176 
    285177def ATM_flux_int (flux) : 
    286178    '''Integrate (* time * surface) flux on atmosphere grid''' 
    287     ATM_flux_int  = wu.Psum ( (flux * dtime_per_sec * ATM_aire).to_masked_array().ravel() ) 
    288     return ATM_flux_int 
    289  
    290 # def SRF_stock_int (stock) : 
    291 #     '''Integrate (* surface) stock on land grid''' 
    292 #     ATM_stock_int  = wu.Ksum (  ( (stock * DYN_aire_fter).to_masked_array().ravel()) ) 
    293 #     return ATM_stock_int 
     179    zATM_flux_int  = wu.P1sum ( flux * dtime_per_sec * ATM.aire ) 
     180    return zATM_flux_int 
    294181 
    295182def SRF_flux_int (flux) : 
    296183    '''Integrate (* time * surface) flux on land grid''' 
    297     SRF_flux_int  = wu.Psum (  (flux * dtime_per_sec * SRF_aire).to_masked_array().ravel() ) 
    298     return SRF_flux_int 
    299  
    300 # def LIC_flux_int (flux) : 
    301 #     '''Integrate (* time * surface) flux on land ice grid''' 
    302 #     LIC_flux_int  = wu.Psum ( (flux * dtime_per_sec * ATM_aire_flic).to_masked_array().ravel() ) 
    303 #     return LIC_flux_int 
    304  
    305 # def OCE_stock_int (stock) : 
    306 #     '''Integrate stock on ocean grid''' 
    307 #     OCE_stock_int = np.sum (  np.sort ( (stock * OCE_aire ).to_masked_array().ravel()) ) 
    308 #     return OCE_stock_int 
     184    zSRF_flux_int  = wu.P1sum ( flux * dtime_per_sec * SRF.aire ) 
     185    return zSRF_flux_int 
    309186 
    310187def ONE_stock_int (stock) : 
    311188    '''Sum stock''' 
    312     ONE_stock_int =  wu.Psum ( stock.to_masked_array().ravel() ) 
    313     return ONE_stock_int 
     189    zONE_stock_int =  wu.P1sum ( stock ) 
     190    return zONE_stock_int 
    314191 
    315192def OCE_flux_int (flux) : 
    316193    '''Integrate flux on oce grid''' 
    317     OCE_flux_int = wu.Psum ( (flux * OCE_aire * dtime_per_sec).to_masked_array().ravel() ) 
    318     return OCE_flux_int 
     194    zOCE_flux_int = wu.P1sum ( flux * OCE.OCE_aire * dtime_per_sec ) 
     195    return zOCE_flux_int 
    319196 
    320197def ONE_flux_int (flux) : 
    321198    '''Integrate flux on oce grid''' 
    322     OCE_flux_int = wu.Psum ( (flux * dtime_per_sec).to_masked_array().ravel() ) 
    323     return OCE_flux_int 
    324  
    325 # Get mask and surfaces 
    326 sos = d_OCE_his ['sos'][0].squeeze() 
    327 OCE_msk = nemo.lbc_mask ( xr.where ( sos>0, 1., 0.0 ), cd_type = 'T', nperio=nperio ) 
    328 so = sos = d_OCE_his ['sos'][0].squeeze() 
    329 OCE_msk3 = nemo.lbc_mask ( xr.where ( so>0., 1., 0. ), cd_type = 'T', sval = 0., nperio=nperio ) 
    330  
    331 # lbc_mask removes the duplicate points (periodicity and north fold) 
    332 OCE_aire = nemo.lbc_mask ( d_OCE_his ['area'] * OCE_msk, cd_type = 'T', sval = 0.0, nperio=nperio ) 
    333 ICE_aire = OCE_aire 
    334  
    335 ATM_aire_tot = ONE_stock_int (ATM_aire) 
    336 if SRF :  
    337     SRF_aire_tot = ONE_stock_int (SRF_aire) 
    338 OCE_aire_tot = ONE_stock_int (OCE_aire) 
    339 ICE_aire_tot = ONE_stock_int (ICE_aire) 
    340  
    341 ATM_aire_sea     = ATM_aire * ATM_fsea 
    342 ATM_aire_sea_tot = ONE_stock_int ( ATM_aire_sea ) 
     199    zOCE_flux_int = wu.P1sum ( flux * dtime_per_sec ) 
     200    return zOCE_flux_int 
    343201 
    344202echo ( '\n====================================================================================' ) 
    … …  
    347205if ATM_HIS == 'latlon' : 
    348206    echo ( ' latlon case' ) 
    349     ATM_wbilo_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_oce']), dim1D='cell' ) 
    350     ATM_wbilo_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_sic']), dim1D='cell' ) 
    351     ATM_wbilo_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_ter']), dim1D='cell' ) 
    352     ATM_wbilo_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_lic']), dim1D='cell' ) 
    353     ATM_runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1D='cell' ) 
    354     ATM_fqcalving   = lmdz.geo2point ( rprec (d_ATM_his ['fqcalving']), dim1D='cell' ) 
    355     ATM_fqfonte     = lmdz.geo2point ( rprec (d_ATM_his ['fqfonte']  ), dim1D='cell' ) 
    356     ATM_precip      = lmdz.geo2point ( rprec (d_ATM_his ['precip']   ), dim1D='cell' ) 
    357     ATM_snowf       = lmdz.geo2point ( rprec (d_ATM_his ['snow']     ), dim1D='cell' ) 
    358     ATM_evap        = lmdz.geo2point ( rprec (d_ATM_his ['evap']     ), dim1D='cell' ) 
    359     ATM_wevap_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_ter']), dim1D='cell' ) 
    360     ATM_wevap_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_oce']), dim1D='cell' ) 
    361     ATM_wevap_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_lic']), dim1D='cell' ) 
    362     ATM_wevap_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_sic']), dim1D='cell' ) 
    363     ATM_wrain_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_ter']), dim1D='cell' ) 
    364     ATM_wrain_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_oce']), dim1D='cell' ) 
    365     ATM_wrain_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_lic']), dim1D='cell' ) 
    366     ATM_wrain_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_sic']), dim1D='cell' ) 
    367     ATM_wsnow_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_ter']), dim1D='cell' ) 
    368     ATM_wsnow_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_oce']), dim1D='cell' ) 
    369     ATM_wsnow_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_lic']), dim1D='cell' ) 
    370     ATM_wsnow_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_sic']), dim1D='cell' ) 
    371     ATM_runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1D='cell' ) 
     207    ATM.wbilo_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_oce']), dim1D='cell' ) 
     208    ATM.wbilo_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_sic']), dim1D='cell' ) 
     209    ATM.wbilo_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_ter']), dim1D='cell' ) 
     210    ATM.wbilo_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wbilo_lic']), dim1D='cell' ) 
     211    ATM.runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1D='cell' ) 
     212    ATM.fqcalving   = lmdz.geo2point ( rprec (d_ATM_his ['fqcalving']), dim1D='cell' ) 
     213    ATM.fqfonte     = lmdz.geo2point ( rprec (d_ATM_his ['fqfonte']  ), dim1D='cell' ) 
     214    ATM.precip      = lmdz.geo2point ( rprec (d_ATM_his ['precip']   ), dim1D='cell' ) 
     215    ATM.snowf       = lmdz.geo2point ( rprec (d_ATM_his ['snow']     ), dim1D='cell' ) 
     216    ATM.evap        = lmdz.geo2point ( rprec (d_ATM_his ['evap']     ), dim1D='cell' ) 
     217    ATM.wevap_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_ter']), dim1D='cell' ) 
     218    ATM.wevap_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_oce']), dim1D='cell' ) 
     219    ATM.wevap_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_lic']), dim1D='cell' ) 
     220    ATM.wevap_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wevap_sic']), dim1D='cell' ) 
     221    ATM.wrain_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_ter']), dim1D='cell' ) 
     222    ATM.wrain_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_oce']), dim1D='cell' ) 
     223    ATM.wrain_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_lic']), dim1D='cell' ) 
     224    ATM.wrain_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wrain_sic']), dim1D='cell' ) 
     225    ATM.wsnow_ter   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_ter']), dim1D='cell' ) 
     226    ATM.wsnow_oce   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_oce']), dim1D='cell' ) 
     227    ATM.wsnow_lic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_lic']), dim1D='cell' ) 
     228    ATM.wsnow_sic   = lmdz.geo2point ( rprec (d_ATM_his ['wsnow_sic']), dim1D='cell' ) 
     229    ATM.runofflic   = lmdz.geo2point ( rprec (d_ATM_his ['runofflic']), dim1D='cell' ) 
    372230    echo ( f'End of LATLON case') 
    373231     
    374232if ATM_HIS == 'ico' : 
    375233    echo (' ico case') 
    376     ATM_wbilo_oce   = rprec (d_ATM_his ['wbilo_oce']) 
    377     ATM_wbilo_sic   = rprec (d_ATM_his ['wbilo_sic']) 
    378     ATM_wbilo_ter   = rprec (d_ATM_his ['wbilo_ter']) 
    379     ATM_wbilo_lic   = rprec (d_ATM_his ['wbilo_lic']) 
    380     ATM_runofflic   = rprec (d_ATM_his ['runofflic']) 
    381     ATM_fqcalving   = rprec (d_ATM_his ['fqcalving']) 
    382     ATM_fqfonte     = rprec (d_ATM_his ['fqfonte']  ) 
    383     ATM_precip      = rprec (d_ATM_his ['precip']   ) 
    384     ATM_snowf       = rprec (d_ATM_his ['snow']     ) 
    385     ATM_evap        = rprec (d_ATM_his ['evap']     ) 
    386     ATM_wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
    387     ATM_wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
    388     ATM_wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
    389     ATM_wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
    390     ATM_runofflic   = rprec (d_ATM_his ['runofflic']) 
    391     ATM_wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
    392     ATM_wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
    393     ATM_wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
    394     ATM_wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
    395     ATM_wrain_ter   = rprec (d_ATM_his ['wrain_ter']) 
    396     ATM_wrain_oce   = rprec (d_ATM_his ['wrain_oce']) 
    397     ATM_wrain_lic   = rprec (d_ATM_his ['wrain_lic']) 
    398     ATM_wrain_sic   = rprec (d_ATM_his ['wrain_sic']) 
    399     ATM_wsnow_ter   = rprec (d_ATM_his ['wsnow_ter']) 
    400     ATM_wsnow_oce   = rprec (d_ATM_his ['wsnow_oce']) 
    401     ATM_wsnow_lic   = rprec (d_ATM_his ['wsnow_lic']) 
    402     ATM_wsnow_sic   = rprec (d_ATM_his ['wsnow_sic']) 
     234    ATM.wbilo_oce   = rprec (d_ATM_his ['wbilo_oce']) 
     235    ATM.wbilo_sic   = rprec (d_ATM_his ['wbilo_sic']) 
     236    ATM.wbilo_ter   = rprec (d_ATM_his ['wbilo_ter']) 
     237    ATM.wbilo_lic   = rprec (d_ATM_his ['wbilo_lic']) 
     238    ATM.runofflic   = rprec (d_ATM_his ['runofflic']) 
     239    ATM.fqcalving   = rprec (d_ATM_his ['fqcalving']) 
     240    ATM.fqfonte     = rprec (d_ATM_his ['fqfonte']  ) 
     241    ATM.precip      = rprec (d_ATM_his ['precip']   ) 
     242    ATM.snowf       = rprec (d_ATM_his ['snow']     ) 
     243    ATM.evap        = rprec (d_ATM_his ['evap']     ) 
     244    ATM.wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
     245    ATM.wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
     246    ATM.wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
     247    ATM.wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
     248    ATM.runofflic   = rprec (d_ATM_his ['runofflic']) 
     249    ATM.wevap_ter   = rprec (d_ATM_his ['wevap_ter']) 
     250    ATM.wevap_oce   = rprec (d_ATM_his ['wevap_oce']) 
     251    ATM.wevap_lic   = rprec (d_ATM_his ['wevap_lic']) 
     252    ATM.wevap_sic   = rprec (d_ATM_his ['wevap_sic']) 
     253    ATM.wrain_ter   = rprec (d_ATM_his ['wrain_ter']) 
     254    ATM.wrain_oce   = rprec (d_ATM_his ['wrain_oce']) 
     255    ATM.wrain_lic   = rprec (d_ATM_his ['wrain_lic']) 
     256    ATM.wrain_sic   = rprec (d_ATM_his ['wrain_sic']) 
     257    ATM.wsnow_ter   = rprec (d_ATM_his ['wsnow_ter']) 
     258    ATM.wsnow_oce   = rprec (d_ATM_his ['wsnow_oce']) 
     259    ATM.wsnow_lic   = rprec (d_ATM_his ['wsnow_lic']) 
     260    ATM.wsnow_sic   = rprec (d_ATM_his ['wsnow_sic']) 
    403261    echo ( f'End of ico case ') 
    404262     
    405263echo ( 'ATM wprecip_oce' ) 
    406 ATM_wprecip_oce = ATM_wrain_oce + ATM_wsnow_oce 
    407 ATM_wprecip_ter = ATM_wrain_ter + ATM_wsnow_ter 
    408 ATM_wprecip_sic = ATM_wrain_sic + ATM_wsnow_sic 
    409 ATM_wprecip_lic = ATM_wrain_lic + ATM_wsnow_lic 
    410  
    411 ATM_wbilo       = ATM_wbilo_oce   + ATM_wbilo_sic   + ATM_wbilo_ter   + ATM_wbilo_lic 
    412 ATM_wevap       = ATM_wevap_oce   + ATM_wevap_sic   + ATM_wevap_ter   + ATM_wevap_lic 
    413 ATM_wprecip     = ATM_wprecip_oce + ATM_wprecip_sic + ATM_wprecip_ter + ATM_wprecip_lic 
    414 ATM_wsnow       = ATM_wsnow_oce   + ATM_wsnow_sic   + ATM_wsnow_ter   + ATM_wsnow_lic 
    415 ATM_wrain       = ATM_wrain_oce   + ATM_wrain_sic   + ATM_wrain_ter   + ATM_wrain_lic 
    416 ATM_wemp        = ATM_wevap - ATM_wprecip 
    417 ATM_emp         = ATM_evap  - ATM_precip 
    418  
    419 ATM_wprecip_sea = ATM_wprecip_oce + ATM_wprecip_sic 
    420 ATM_wsnow_sea   = ATM_wsnow_oce   + ATM_wsnow_sic 
    421 ATM_wrain_sea   = ATM_wrain_oce   + ATM_wrain_sic 
    422 ATM_wbilo_sea   = ATM_wbilo_oce   + ATM_wbilo_sic 
    423 ATM_wevap_sea   = ATM_wevap_sic   + ATM_wevap_oce 
    424  
    425 ATM_wemp_ter    = ATM_wevap_ter - ATM_wprecip_ter 
    426 ATM_wemp_oce    = ATM_wevap_oce - ATM_wprecip_oce 
    427 ATM_wemp_sic    = ATM_wevap_sic - ATM_wprecip_sic 
    428 ATM_wemp_lic    = ATM_wevap_lic - ATM_wprecip_lic 
    429 ATM_wemp_sea    = ATM_wevap_sic - ATM_wprecip_oce 
    430  
    431 if SRF :  
     264ATM.wprecip_oce = ATM.wrain_oce + ATM.wsnow_oce 
     265ATM.wprecip_ter = ATM.wrain_ter + ATM.wsnow_ter 
     266ATM.wprecip_sic = ATM.wrain_sic + ATM.wsnow_sic 
     267ATM.wprecip_lic = ATM.wrain_lic + ATM.wsnow_lic 
     268 
     269ATM.wbilo       = ATM.wbilo_oce   + ATM.wbilo_sic   + ATM.wbilo_ter   + ATM.wbilo_lic 
     270ATM.wevap       = ATM.wevap_oce   + ATM.wevap_sic   + ATM.wevap_ter   + ATM.wevap_lic 
     271ATM.wprecip     = ATM.wprecip_oce + ATM.wprecip_sic + ATM.wprecip_ter + ATM.wprecip_lic 
     272ATM.wsnow       = ATM.wsnow_oce   + ATM.wsnow_sic   + ATM.wsnow_ter   + ATM.wsnow_lic 
     273ATM.wrain       = ATM.wrain_oce   + ATM.wrain_sic   + ATM.wrain_ter   + ATM.wrain_lic 
     274ATM.wemp        = ATM.wevap - ATM.wprecip 
     275ATM.emp         = ATM.evap  - ATM.precip 
     276 
     277ATM.wprecip_sea = ATM.wprecip_oce + ATM.wprecip_sic 
     278ATM.wsnow_sea   = ATM.wsnow_oce   + ATM.wsnow_sic 
     279ATM.wrain_sea   = ATM.wrain_oce   + ATM.wrain_sic 
     280ATM.wbilo_sea   = ATM.wbilo_oce   + ATM.wbilo_sic 
     281ATM.wevap_sea   = ATM.wevap_sic   + ATM.wevap_oce 
     282 
     283ATM.wemp_ter    = ATM.wevap_ter - ATM.wprecip_ter 
     284ATM.wemp_oce    = ATM.wevap_oce - ATM.wprecip_oce 
     285ATM.wemp_sic    = ATM.wevap_sic - ATM.wprecip_sic 
     286ATM.wemp_lic    = ATM.wevap_lic - ATM.wprecip_lic 
     287ATM.wemp_sea    = ATM.wevap_sic - ATM.wprecip_oce 
     288 
     289if SECHIBA :  
    432290    if RUN_HIS == 'latlon' : 
    433291        echo ( f'RUN costalflow Grille LATLON' ) 
    434292        if TestInterp : 
    435293            echo ( f'RUN runoff TestInterp' ) 
    436             RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff_contfrac_interp']  )   , dim1D='cell' ) 
    437             RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage_contfrac_interp'])   , dim1D='cell' ) 
     294            SRF.RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff_contfrac_interp']  )   , dim1D='cell' ) 
     295            SRF.RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage_contfrac_interp'])   , dim1D='cell' ) 
    438296        else :  
    439297            echo ( f'RUN runoff' ) 
    440             RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff']         ), dim1D='cell' ) 
    441             RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage']       ), dim1D='cell' ) 
     298            SRF.RUN_runoff      = lmdz.geo2point ( rprec (d_RUN_his ['runoff']         ), dim1D='cell' ) 
     299            SRF.RUN_drainage    = lmdz.geo2point ( rprec (d_RUN_his ['drainage']       ), dim1D='cell' ) 
    442300             
    443         RUN_coastalflow     = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow']    ), dim1D='cell' )  
    444         RUN_riverflow       = lmdz.geo2point ( rprec (d_RUN_his ['riverflow']      ), dim1D='cell' ) 
    445         RUN_riversret       = lmdz.geo2point ( rprec (d_RUN_his ['riversret']      ), dim1D='cell' ) 
    446         RUN_coastalflow_cpl = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow_cpl']), dim1D='cell' )  
    447         RUN_riverflow_cpl   = lmdz.geo2point ( rprec (d_RUN_his ['riverflow_cpl']  ), dim1D='cell' ) 
     301        SRF.RUN_coastalflow     = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow']    ), dim1D='cell' )  
     302        SRF.RUN_riverflow       = lmdz.geo2point ( rprec (d_RUN_his ['riverflow']      ), dim1D='cell' ) 
     303        SRF.RUN_riversret       = lmdz.geo2point ( rprec (d_RUN_his ['riversret']      ), dim1D='cell' ) 
     304        SRF.RUN_coastalflow_cpl = lmdz.geo2point ( rprec (d_RUN_his ['coastalflow_cpl']), dim1D='cell' )  
     305        SRF.RUN_riverflow_cpl   = lmdz.geo2point ( rprec (d_RUN_his ['riverflow_cpl']  ), dim1D='cell' ) 
    448306         
    449307    if RUN_HIS == 'ico' : 
    450308        echo ( f'RUN costalflow Grille ICO' ) 
    451         RUN_coastalflow =  rprec (d_RUN_his ['coastalflow']) 
    452         RUN_riverflow   =  rprec (d_RUN_his ['riverflow']  ) 
    453         RUN_runoff      =  rprec (d_RUN_his ['runoff']     ) 
    454         RUN_drainage    =  rprec (d_RUN_his ['drainage']   ) 
    455         RUN_riversret   =  rprec (d_RUN_his ['riversret']  ) 
    456309         
    457         RUN_coastalflow_cpl = rprec (d_RUN_his ['coastalflow_cpl']) 
    458         RUN_riverflow_cpl   = rprec (d_RUN_his ['riverflow_cpl']  ) 
     310        SRF.RUN_coastalflow     =  rprec (d_RUN_his ['coastalflow']) 
     311        SRF.RUN_riverflow       =  rprec (d_RUN_his ['riverflow']  ) 
     312        SRF.RUN_runoff          =  rprec (d_RUN_his ['runoff']     ) 
     313        SRF.RUN_drainage        =  rprec (d_RUN_his ['drainage']   ) 
     314        SRF.RUN_riversret       =  rprec (d_RUN_his ['riversret']  ) 
     315        SRF.RUN_coastalflow_cpl = rprec (d_RUN_his ['coastalflow_cpl']) 
     316        SRF.RUN_riverflow_cpl   = rprec (d_RUN_his ['riverflow_cpl']  ) 
    459317         
    460         ## Correcting units of SECHIBA variables 
     318    ## Correcting units of SECHIBA variables 
    461319    def mmd2SI ( Var ) : 
    462320        '''Change unit from mm/d or m^3/s to kg/s if needed''' 
    463         if 'units' in VarT.attrs :  
    464             if VarT.attrs['units'] in ['m^3/s', 'm3/s', 'm3.s-1',] : 
    465                 VarT.values = VarT.values  * ATM_RHO                 ;  VarT.attrs['units'] = 'kg/s' 
    466             if VarT.attrs['units'] == 'mm/d' : 
    467                 VarT.values = VarT.values  * ATM_RHO * (1e-3/86400.) ;  VarT.attrs['units'] = 'kg/s' 
    468             if VarT.attrs['units'] in ['m^3', 'm3', ] : 
    469                 VarT.values = VarT.values  * ATM_RHO                 ;  VarT.attrs['units'] = 'kg' 
    470                  
    471     for var in [ 'runoff', 'drainage', 'riversret', 'coastalflow', 'riverflow', 'coastalflow_cpl', 'riverflow_cpl' ] : 
    472         VarT = locals()['RUN_' + var] 
    473         mmd2SI (VarT) 
    474          
    475     #for var in ['evap', 'snowf', 'subli', 'transpir', 'rain', 'emp' ] : 
    476     #    VarT = locals()['SRF_' + var] 
    477     #    mmd2SI (VarT) 
    478     echo ( f'RUN input' ) 
    479     RUN_input  = RUN_runoff      + RUN_drainage 
    480     RUN_output = RUN_coastalflow + RUN_riverflow 
     321        if 'units' in Var.attrs :  
     322            if Var.attrs['units'] in ['m^3/s', 'm3/s', 'm3.s-1',] : 
     323                Var.values = Var.values  * ATM_RHO                 ;  Var.attrs['units'] = 'kg/s' 
     324            if Var.attrs['units'] == 'mm/d' : 
     325                Var.values = Var.values  * ATM_RHO * (1e-3/86400.) ;  Var.attrs['units'] = 'kg/s' 
     326            if Var.attrs['units'] in ['m^3', 'm3', ] : 
     327                Var.values = Var.values  * ATM_RHO                 ;  Var.attrs['units'] = 'kg' 
     328        return Var 
     329             
     330    SRF.RUN_coastalflow     = mmd2SI ( SRF.RUN_coastalflow ) 
     331    SRF.RUN_coastalflow_cpl = mmd2SI ( SRF.RUN_coastalflow_cpl ) 
     332    SRF.RUN_drainage        = mmd2SI ( SRF.RUN_drainage ) 
     333    SRF.RUN_riverflow       = mmd2SI ( SRF.RUN_riverflow ) 
     334    SRF.RUN_riverflow_cpl   = mmd2SI ( SRF.RUN_riverflow_cpl ) 
     335    SRF.RUN_riversret       = mmd2SI ( SRF.RUN_riversret ) 
     336    SRF.RUN_runoff          = mmd2SI ( SRF.RUN_runoff ) 
     337 
     338    SRF.RUN_input  = SRF.RUN_runoff      + SRF.RUN_drainage 
     339    SRF.RUN_output = SRF.RUN_coastalflow + SRF.RUN_riverflow 
    481340     
    482341echo ( f'ATM flw_wbilo' ) 
    483 ATM_flx_wbilo       = ATM_flux_int ( ATM_wbilo      ) 
    484 ATM_flx_wevap       = ATM_flux_int ( ATM_wevap      ) 
    485 ATM_flx_wprecip     = ATM_flux_int ( ATM_wprecip    ) 
    486 ATM_flx_wsnow       = ATM_flux_int ( ATM_wsnow      ) 
    487 ATM_flx_wrain       = ATM_flux_int ( ATM_wrain      ) 
    488 ATM_flx_wemp        = ATM_flux_int ( ATM_wemp       ) 
    489  
    490 ATM_flx_wbilo_lic   = ATM_flux_int ( ATM_wbilo_lic  ) 
    491 ATM_flx_wbilo_oce   = ATM_flux_int ( ATM_wbilo_oce  ) 
    492 ATM_flx_wbilo_sea   = ATM_flux_int ( ATM_wbilo_sea  ) 
    493 ATM_flx_wbilo_sic   = ATM_flux_int ( ATM_wbilo_sic  ) 
    494 ATM_flx_wbilo_ter   = ATM_flux_int ( ATM_wbilo_ter  ) 
    495 ATM_flx_calving     = ATM_flux_int ( ATM_fqcalving  ) 
    496 ATM_flx_fqfonte     = ATM_flux_int ( ATM_fqfonte    ) 
    497  
    498 LIC_flx_calving     = ATM_flux_int ( ATM_fqcalving  ) 
    499 LIC_flx_fqfonte     = ATM_flux_int ( ATM_fqfonte    ) 
    500  
    501 ATM_flx_precip      = ATM_flux_int ( ATM_precip     ) 
    502 ATM_flx_snowf       = ATM_flux_int ( ATM_snowf      ) 
    503 ATM_flx_evap        = ATM_flux_int ( ATM_evap       ) 
    504 ATM_flx_runlic      = ATM_flux_int ( ATM_runofflic  ) 
    505  
    506 #LIC_flx_precip      = LIC_flux_int ( ATM_precip     ) 
    507 #LIC_flx_snowf       = LIC_flux_int ( ATM_snowf      ) 
    508 #LIC_flx_evap        = LIC_flux_int ( ATM_evap       ) 
    509 #LIC_flx_runlic      = LIC_flux_int ( ATM_runofflic  ) 
    510  
    511 ATM_flx_wrain_ter   = ATM_flux_int ( ATM_wrain_ter ) 
    512 ATM_flx_wrain_oce   = ATM_flux_int ( ATM_wrain_oce ) 
    513 ATM_flx_wrain_lic   = ATM_flux_int ( ATM_wrain_lic ) 
    514 ATM_flx_wrain_sic   = ATM_flux_int ( ATM_wrain_sic ) 
    515 ATM_flx_wrain_sea   = ATM_flux_int ( ATM_wrain_sea ) 
    516  
    517 ATM_flx_wsnow_ter   = ATM_flux_int ( ATM_wsnow_ter ) 
    518 ATM_flx_wsnow_oce   = ATM_flux_int ( ATM_wsnow_oce ) 
    519 ATM_flx_wsnow_lic   = ATM_flux_int ( ATM_wsnow_lic ) 
    520 ATM_flx_wsnow_sic   = ATM_flux_int ( ATM_wsnow_sic ) 
    521 ATM_flx_wsnow_sea   = ATM_flux_int ( ATM_wsnow_sea ) 
    522  
    523 ATM_flx_wevap_ter   = ATM_flux_int ( ATM_wevap_ter ) 
    524 ATM_flx_wevap_oce   = ATM_flux_int ( ATM_wevap_oce ) 
    525 ATM_flx_wevap_lic   = ATM_flux_int ( ATM_wevap_lic ) 
    526 ATM_flx_wevap_sic   = ATM_flux_int ( ATM_wevap_sic ) 
    527 ATM_flx_wevap_sea   = ATM_flux_int ( ATM_wevap_sea ) 
    528 ATM_flx_wprecip_lic = ATM_flux_int ( ATM_wprecip_lic ) 
    529 ATM_flx_wprecip_oce = ATM_flux_int ( ATM_wprecip_oce ) 
    530 ATM_flx_wprecip_sic = ATM_flux_int ( ATM_wprecip_sic ) 
    531 ATM_flx_wprecip_ter = ATM_flux_int ( ATM_wprecip_ter ) 
    532 ATM_flx_wprecip_sea = ATM_flux_int ( ATM_wprecip_sea ) 
    533 ATM_flx_wemp_lic    = ATM_flux_int ( ATM_wemp_lic ) 
    534 ATM_flx_wemp_oce    = ATM_flux_int ( ATM_wemp_oce ) 
    535 ATM_flx_wemp_sic    = ATM_flux_int ( ATM_wemp_sic ) 
    536 ATM_flx_wemp_ter    = ATM_flux_int ( ATM_wemp_ter ) 
    537 ATM_flx_wemp_sea    = ATM_flux_int ( ATM_wemp_sea ) 
    538  
    539 ATM_flx_emp          = ATM_flux_int ( ATM_emp ) 
    540  
    541 if SRF :  
    542     RUN_flx_coastal     = ONE_flux_int ( RUN_coastalflow) 
    543     RUN_flx_river       = ONE_flux_int ( RUN_riverflow  ) 
    544     RUN_flx_coastal_cpl = ONE_flux_int ( RUN_coastalflow_cpl) 
    545     RUN_flx_river_cpl   = ONE_flux_int ( RUN_riverflow_cpl  ) 
    546     RUN_flx_drainage    = SRF_flux_int ( RUN_drainage   ) 
    547     RUN_flx_riversret   = SRF_flux_int ( RUN_riversret  ) 
    548     RUN_flx_runoff      = SRF_flux_int ( RUN_runoff     ) 
    549     RUN_flx_input       = SRF_flux_int ( RUN_input      ) 
    550     RUN_flx_output      = ONE_flux_int ( RUN_output     ) 
    551      
    552     RUN_flx_bil    = ONE_flux_int ( RUN_input       - RUN_output) 
    553     RUN_flx_rivcoa = ONE_flux_int ( RUN_coastalflow + RUN_riverflow) 
    554      
    555 prtFlux ('wbilo_oce            ', ATM_flx_wbilo_oce     , 'f' )           
    556 prtFlux ('wbilo_sic            ', ATM_flx_wbilo_sic     , 'f' )           
    557 prtFlux ('wbilo_sic+oce        ', ATM_flx_wbilo_sea     , 'f' )           
    558 prtFlux ('wbilo_ter            ', ATM_flx_wbilo_ter     , 'f' )           
    559 prtFlux ('wbilo_lic            ', ATM_flx_wbilo_lic     , 'f' )           
    560 prtFlux ('Sum wbilo_*          ', ATM_flx_wbilo         , 'f', True)   
    561 prtFlux ('E-P                  ', ATM_flx_emp           , 'f', True)   
    562 prtFlux ('calving              ', ATM_flx_calving       , 'f' )  
    563 prtFlux ('fqfonte              ', ATM_flx_fqfonte       , 'f' )        
    564 prtFlux ('precip               ', ATM_flx_precip        , 'f' )        
    565 prtFlux ('snowf                ', ATM_flx_snowf         , 'f' )         
    566 prtFlux ('evap                 ', ATM_flx_evap          , 'f' ) 
    567 prtFlux ('runoff lic           ', ATM_flx_runlic        , 'f' ) 
    568  
    569 prtFlux ('ATM_flx_wevap*       ', ATM_flx_wevap         , 'f' ) 
    570 prtFlux ('ATM_flx_wrain*       ', ATM_flx_wrain         , 'f' ) 
    571 prtFlux ('ATM_flx_wsnow*       ', ATM_flx_wsnow         , 'f' ) 
    572 prtFlux ('ATM_flx_wprecip*     ', ATM_flx_wprecip       , 'f' ) 
    573 prtFlux ('ATM_flx_wemp*        ', ATM_flx_wemp          , 'f', True ) 
    574  
    575 prtFlux ('ERROR evap           ', ATM_flx_wevap   - ATM_flx_evap  , 'e', True ) 
    576 prtFlux ('ERROR precip         ', ATM_flx_wprecip - ATM_flx_precip, 'e', True ) 
    577 prtFlux ('ERROR snow           ', ATM_flx_wsnow   - ATM_flx_snowf , 'e', True ) 
    578 prtFlux ('ERROR emp            ', ATM_flx_wemp    - ATM_flx_emp   , 'e', True ) 
    579  
    580 if SRF :  
     342ATM.flx_wbilo       = ATM_flux_int ( ATM.wbilo      ) 
     343ATM.flx_wevap       = ATM_flux_int ( ATM.wevap      ) 
     344ATM.flx_wprecip     = ATM_flux_int ( ATM.wprecip    ) 
     345ATM.flx_wsnow       = ATM_flux_int ( ATM.wsnow      ) 
     346ATM.flx_wrain       = ATM_flux_int ( ATM.wrain      ) 
     347ATM.flx_wemp        = ATM_flux_int ( ATM.wemp       ) 
     348 
     349ATM.flx_wbilo_lic   = ATM_flux_int ( ATM.wbilo_lic  ) 
     350ATM.flx_wbilo_oce   = ATM_flux_int ( ATM.wbilo_oce  ) 
     351ATM.flx_wbilo_sea   = ATM_flux_int ( ATM.wbilo_sea  ) 
     352ATM.flx_wbilo_sic   = ATM_flux_int ( ATM.wbilo_sic  ) 
     353ATM.flx_wbilo_ter   = ATM_flux_int ( ATM.wbilo_ter  ) 
     354ATM.flx_calving     = ATM_flux_int ( ATM.fqcalving  ) 
     355ATM.flx_fqfonte     = ATM_flux_int ( ATM.fqfonte    ) 
     356 
     357ATM.LIC_flx_calving     = ATM_flux_int ( ATM.fqcalving  ) 
     358ATM.LIC_flx_fqfonte     = ATM_flux_int ( ATM.fqfonte    ) 
     359 
     360ATM.flx_precip      = ATM_flux_int ( ATM.precip     ) 
     361ATM.flx_snowf       = ATM_flux_int ( ATM.snowf      ) 
     362ATM.flx_evap        = ATM_flux_int ( ATM.evap       ) 
     363ATM.flx_runlic      = ATM_flux_int ( ATM.runofflic  ) 
     364 
     365ATM.flx_wrain_ter   = ATM_flux_int ( ATM.wrain_ter ) 
     366ATM.flx_wrain_oce   = ATM_flux_int ( ATM.wrain_oce ) 
     367ATM.flx_wrain_lic   = ATM_flux_int ( ATM.wrain_lic ) 
     368ATM.flx_wrain_sic   = ATM_flux_int ( ATM.wrain_sic ) 
     369ATM.flx_wrain_sea   = ATM_flux_int ( ATM.wrain_sea ) 
     370 
     371ATM.flx_wsnow_ter   = ATM_flux_int ( ATM.wsnow_ter ) 
     372ATM.flx_wsnow_oce   = ATM_flux_int ( ATM.wsnow_oce ) 
     373ATM.flx_wsnow_lic   = ATM_flux_int ( ATM.wsnow_lic ) 
     374ATM.flx_wsnow_sic   = ATM_flux_int ( ATM.wsnow_sic ) 
     375ATM.flx_wsnow_sea   = ATM_flux_int ( ATM.wsnow_sea ) 
     376 
     377ATM.flx_wevap_ter   = ATM_flux_int ( ATM.wevap_ter ) 
     378ATM.flx_wevap_oce   = ATM_flux_int ( ATM.wevap_oce ) 
     379ATM.flx_wevap_lic   = ATM_flux_int ( ATM.wevap_lic ) 
     380ATM.flx_wevap_sic   = ATM_flux_int ( ATM.wevap_sic ) 
     381ATM.flx_wevap_sea   = ATM_flux_int ( ATM.wevap_sea ) 
     382ATM.flx_wprecip_lic = ATM_flux_int ( ATM.wprecip_lic ) 
     383ATM.flx_wprecip_oce = ATM_flux_int ( ATM.wprecip_oce ) 
     384ATM.flx_wprecip_sic = ATM_flux_int ( ATM.wprecip_sic ) 
     385ATM.flx_wprecip_ter = ATM_flux_int ( ATM.wprecip_ter ) 
     386ATM.flx_wprecip_sea = ATM_flux_int ( ATM.wprecip_sea ) 
     387ATM.flx_wemp_lic    = ATM_flux_int ( ATM.wemp_lic ) 
     388ATM.flx_wemp_oce    = ATM_flux_int ( ATM.wemp_oce ) 
     389ATM.flx_wemp_sic    = ATM_flux_int ( ATM.wemp_sic ) 
     390ATM.flx_wemp_ter    = ATM_flux_int ( ATM.wemp_ter ) 
     391ATM.flx_wemp_sea    = ATM_flux_int ( ATM.wemp_sea ) 
     392 
     393ATM.flx_emp          = ATM_flux_int ( ATM.emp ) 
     394 
     395if SECHIBA :  
     396    SRF.RUN_flx_coastal     = ONE_flux_int ( SRF.RUN_coastalflow) 
     397    SRF.RUN_flx_river       = ONE_flux_int ( SRF.RUN_riverflow  ) 
     398    SRF.RUN_flx_coastal_cpl = ONE_flux_int ( SRF.RUN_coastalflow_cpl) 
     399    SRF.RUN_flx_river_cpl   = ONE_flux_int ( SRF.RUN_riverflow_cpl  ) 
     400    SRF.RUN_flx_drainage    = SRF_flux_int ( SRF.RUN_drainage   ) 
     401    SRF.RUN_flx_riversret   = SRF_flux_int ( SRF.RUN_riversret  ) 
     402    SRF.RUN_flx_runoff      = SRF_flux_int ( SRF.RUN_runoff     ) 
     403    SRF.RUN_flx_input       = SRF_flux_int ( SRF.RUN_input      ) 
     404    SRF.RUN_flx_output      = ONE_flux_int ( SRF.RUN_output     ) 
     405     
     406    SRF.RUN_flx_bil    = ONE_flux_int ( SRF.RUN_input       - SRF.RUN_output) 
     407    SRF.RUN_flx_rivcoa = ONE_flux_int ( SRF.RUN_coastalflow + SRF.RUN_riverflow) 
     408     
     409prtFlux ('wbilo_oce            ', ATM.flx_wbilo_oce     , 'f' )           
     410prtFlux ('wbilo_sic            ', ATM.flx_wbilo_sic     , 'f' )           
     411prtFlux ('wbilo_sic+oce        ', ATM.flx_wbilo_sea     , 'f' )           
     412prtFlux ('wbilo_ter            ', ATM.flx_wbilo_ter     , 'f' )           
     413prtFlux ('wbilo_lic            ', ATM.flx_wbilo_lic     , 'f' )           
     414prtFlux ('Sum wbilo_*          ', ATM.flx_wbilo         , 'f', True)   
     415prtFlux ('E-P                  ', ATM.flx_emp           , 'f', True)   
     416prtFlux ('calving              ', ATM.flx_calving       , 'f' )  
     417prtFlux ('fqfonte              ', ATM.flx_fqfonte       , 'f' )        
     418prtFlux ('precip               ', ATM.flx_precip        , 'f' )        
     419prtFlux ('snowf                ', ATM.flx_snowf         , 'f' )         
     420prtFlux ('evap                 ', ATM.flx_evap          , 'f' ) 
     421prtFlux ('runoff lic           ', ATM.flx_runlic        , 'f' ) 
     422 
     423prtFlux ('ATM.flx_wevap*       ', ATM.flx_wevap         , 'f' ) 
     424prtFlux ('ATM.flx_wrain*       ', ATM.flx_wrain         , 'f' ) 
     425prtFlux ('ATM.flx_wsnow*       ', ATM.flx_wsnow         , 'f' ) 
     426prtFlux ('ATM.flx_wprecip*     ', ATM.flx_wprecip       , 'f' ) 
     427prtFlux ('ATM.flx_wemp*        ', ATM.flx_wemp          , 'f', True ) 
     428 
     429prtFlux ('ERROR evap           ', ATM.flx_wevap   - ATM.flx_evap  , 'e', True ) 
     430prtFlux ('ERROR precip         ', ATM.flx_wprecip - ATM.flx_precip, 'e', True ) 
     431prtFlux ('ERROR snow           ', ATM.flx_wsnow   - ATM.flx_snowf , 'e', True ) 
     432prtFlux ('ERROR emp            ', ATM.flx_wemp    - ATM.flx_emp   , 'e', True ) 
     433 
     434if SECHIBA :  
    581435    echo ( '\n====================================================================================' ) 
    582436    echo ( f'-- RUNOFF Fluxes  -- {Title} ' ) 
    583     prtFlux ('coastalflow   ', RUN_flx_coastal    , 'f' )  
    584     prtFlux ('riverflow     ', RUN_flx_river      , 'f' )         
    585     prtFlux ('coastal_cpl   ', RUN_flx_coastal_cpl, 'f' )   
    586     prtFlux ('riverf_cpl    ', RUN_flx_river_cpl  , 'f' )     
    587     prtFlux ('river+coastal ', RUN_flx_rivcoa     , 'f' )    
    588     prtFlux ('drainage      ', RUN_flx_drainage   , 'f' )    
    589     prtFlux ('riversret     ', RUN_flx_riversret  , 'f' )    
    590     prtFlux ('runoff        ', RUN_flx_runoff     , 'f' )    
    591     prtFlux ('river in      ', RUN_flx_input      , 'f' )    
    592     prtFlux ('river out     ', RUN_flx_output     , 'f' )    
    593     prtFlux ('river bil     ', RUN_flx_bil        , 'f' )  
     437    prtFlux ('coastalflow   ', SRF.RUN_flx_coastal    , 'f' )  
     438    prtFlux ('riverflow     ', SRF.RUN_flx_river      , 'f' )         
     439    prtFlux ('coastal_cpl   ', SRF.RUN_flx_coastal_cpl, 'f' )   
     440    prtFlux ('riverf_cpl    ', SRF.RUN_flx_river_cpl  , 'f' )     
     441    prtFlux ('river+coastal ', SRF.RUN_flx_rivcoa     , 'f' )    
     442    prtFlux ('drainage      ', SRF.RUN_flx_drainage   , 'f' )    
     443    prtFlux ('riversret     ', SRF.RUN_flx_riversret  , 'f' )    
     444    prtFlux ('runoff        ', SRF.RUN_flx_runoff     , 'f' )    
     445    prtFlux ('river in      ', SRF.RUN_flx_input      , 'f' )    
     446    prtFlux ('river out     ', SRF.RUN_flx_output     , 'f' )    
     447    prtFlux ('river bil     ', SRF.RUN_flx_bil        , 'f' )  
    594448     
    595449echo ( '\n====================================================================================' ) 
    … …  
    597451 
    598452# Read variable and computes integral over space and time 
    599 OCE_empmr      = rprec (d_OCE_his['wfo']     )    ; OCE_mas_empmr    = OCE_flux_int ( OCE_empmr    ) 
    600 OCE_wfob       = rprec (d_OCE_his['wfob']    )    ; OCE_mas_wfob     = OCE_flux_int ( OCE_wfob     ) 
    601 OCE_emp_oce    = rprec (d_OCE_his['emp_oce'] )    ; OCE_mas_emp_oce  = OCE_flux_int ( OCE_emp_oce  ) 
    602 OCE_emp_ice    = rprec (d_OCE_his['emp_ice'] )    ; OCE_mas_emp_ice  = OCE_flux_int ( OCE_emp_ice  ) 
    603 OCE_iceshelf   = rprec (d_OCE_his['iceshelf'])    ; OCE_mas_iceshelf = OCE_flux_int ( OCE_iceshelf ) 
    604 OCE_calving    = rprec (d_OCE_his['calving'] )    ; OCE_mas_calving  = OCE_flux_int ( OCE_calving  ) 
    605 OCE_iceberg    = rprec (d_OCE_his['iceberg'] )    ; OCE_mas_iceberg  = OCE_flux_int ( OCE_iceberg  ) 
    606 OCE_friver     = rprec (d_OCE_his['friver']  )    ; OCE_mas_friver   = OCE_flux_int ( OCE_friver   ) 
    607 OCE_runoffs    = rprec (d_OCE_his['runoffs'] )    ; OCE_mas_runoffs  = OCE_flux_int ( OCE_runoffs  ) 
     453OCE.OCE_empmr      = rprec (d_OCE_his['wfo']     )    ; OCE.OCE_mass_empmr    = OCE_flux_int ( OCE.OCE_empmr    ) 
     454OCE.OCE_wfob       = rprec (d_OCE_his['wfob']    )    ; OCE.OCE_mass_wfob     = OCE_flux_int ( OCE.OCE_wfob     ) 
     455OCE.OCE_emp_oce    = rprec (d_OCE_his['emp_oce'] )    ; OCE.OCE_mass_emp_oce  = OCE_flux_int ( OCE.OCE_emp_oce  ) 
     456OCE.OCE_emp_ice    = rprec (d_OCE_his['emp_ice'] )    ; OCE.OCE_mass_emp_ice  = OCE_flux_int ( OCE.OCE_emp_ice  ) 
     457OCE.OCE_iceshelf   = rprec (d_OCE_his['iceshelf'])    ; OCE.OCE_mass_iceshelf = OCE_flux_int ( OCE.OCE_iceshelf ) 
     458OCE.OCE_calving    = rprec (d_OCE_his['calving'] )    ; OCE.OCE_mass_calving  = OCE_flux_int ( OCE.OCE_calving  ) 
     459OCE.OCE_iceberg    = rprec (d_OCE_his['iceberg'] )    ; OCE.OCE_mass_iceberg  = OCE_flux_int ( OCE.OCE_iceberg  ) 
     460OCE.OCE_friver     = rprec (d_OCE_his['friver']  )    ; OCE.OCE_mass_friver   = OCE_flux_int ( OCE.OCE_friver   ) 
     461OCE.OCE_runoffs    = rprec (d_OCE_his['runoffs'] )    ; OCE.OCE_mass_runoffs  = OCE_flux_int ( OCE.OCE_runoffs  ) 
    608462if NEMO == 4.0 or NEMO == 4.2 : 
    609     OCE_wfxice     = rprec (d_OCE_his['vfxice']) ; OCE_mas_wfxice   = OCE_flux_int ( OCE_wfxice ) 
    610     OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw']) ; OCE_mas_wfxsnw   = OCE_flux_int ( OCE_wfxsnw ) 
    611     OCE_wfxsub     = rprec (d_OCE_his['vfxsub']) ; OCE_mas_wfxsub   = OCE_flux_int ( OCE_wfxsub ) 
     463    OCE.OCE_wfxice     = rprec (d_OCE_his['vfxice']) ; OCE.OCE_mass_wfxice   = OCE_flux_int ( OCE.OCE_wfxice ) 
     464    OCE.OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw']) ; OCE.OCE_mass_wfxsnw   = OCE_flux_int ( OCE.OCE_wfxsnw ) 
     465    OCE.OCE_wfxsub     = rprec (d_OCE_his['vfxsub']) ; OCE.OCE_mass_wfxsub   = OCE_flux_int ( OCE.OCE_wfxsub ) 
    612466if NEMO == 3.6 : 
    613     OCE_wfxice     = rprec (d_OCE_his['vfxice'])/86400.*ICE_RHO_ICE ; OCE_mas_wfxice   = OCE_flux_int ( OCE_wfxice ) 
    614     OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw'])/86400.*ICE_RHO_SNO ; OCE_mas_wfxsnw   = OCE_flux_int ( OCE_wfxsnw ) 
    615     OCE_wfxsub     = rprec (d_OCE_his['vfxsub'])/86400.*ICE_RHO_SNO ; OCE_mas_wfxsub   = OCE_flux_int ( OCE_wfxsub ) 
     467    OCE.OCE_wfxice     = rprec (d_OCE_his['vfxice'])/86400.*OCE.ICE_RHO_ICE ; OCE.OCE_mass_wfxice   = OCE_flux_int ( OCE.OCE_wfxice ) 
     468    OCE.OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw'])/86400.*OCE.ICE_RHO_SNO ; OCE.OCE_mass_wfxsnw   = OCE_flux_int ( OCE.OCE_wfxsnw ) 
     469    OCE.OCE_wfxsub     = rprec (d_OCE_his['vfxsub'])/86400.*ICE_RHO_SNO     ; OCE.OCE_mass_wfxsub   = OCE_flux_int ( OCE.OCE_wfxsub ) 
    616470# Additional checks 
    617 OCE_evap_oce   = rprec (d_OCE_his['evap_ao_cea']) ; OCE_mas_evap_oce   = OCE_flux_int ( OCE_evap_oce ) 
    618 ICE_evap_ice   = rprec (d_OCE_his['subl_ai_cea']) ; ICE_mas_evap_ice   = OCE_flux_int ( ICE_evap_ice ) 
    619 OCE_snow_oce   = rprec (d_OCE_his['snow_ao_cea']) ; OCE_mas_snow_oce   = OCE_flux_int ( OCE_snow_oce ) 
    620 OCE_snow_ice   = rprec (d_OCE_his['snow_ai_cea']) ; OCE_mas_snow_ice   = OCE_flux_int ( OCE_snow_ice ) 
    621 OCE_rain       = rprec (d_OCE_his['rain']       ) ; OCE_mas_rain       = OCE_flux_int ( OCE_rain     ) 
    622 ICE_wfxsub_err = rprec (d_ICE_his['vfxsub_err'] ) ; ICE_mas_wfxsub_err = OCE_flux_int ( ICE_wfxsub_err ) 
     471OCE.OCE_evap_oce   = rprec (d_OCE_his['evap_ao_cea']) ; OCE.OCE_mass_evap_oce   = OCE_flux_int ( OCE.OCE_evap_oce ) 
     472OCE.ICE_evap_ice   = rprec (d_OCE_his['subl_ai_cea']) ; OCE.ICE_mass_evap_ice   = OCE_flux_int ( OCE.ICE_evap_ice ) 
     473OCE.OCE_snow_oce   = rprec (d_OCE_his['snow_ao_cea']) ; OCE.OCE_mass_snow_oce   = OCE_flux_int ( OCE.OCE_snow_oce ) 
     474OCE.OCE_snow_ice   = rprec (d_OCE_his['snow_ai_cea']) ; OCE.OCE_mass_snow_ice   = OCE_flux_int ( OCE.OCE_snow_ice ) 
     475OCE.OCE_rain       = rprec (d_OCE_his['rain']       ) ; OCE.OCE_mass_rain       = OCE_flux_int ( OCE.OCE_rain     ) 
     476OCE.ICE_wfxsub_err = rprec (d_ICE_his['vfxsub_err'] ) ; OCE.ICE_mass_wfxsub_err = OCE_flux_int ( OCE.ICE_wfxsub_err ) 
    623477if NEMO == 4.0 or NEMO == 4.2 : 
    624     ICE_wfxpnd     = rprec (d_ICE_his['vfxpnd']    ) ; ICE_mas_wfxpnd     = OCE_flux_int ( ICE_wfxpnd     ) 
    625     ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsnw_sub']) ; ICE_mas_wfxsnw_sub = OCE_flux_int ( ICE_wfxsnw_sub ) 
    626     ICE_wfxsnw_pre = rprec (d_ICE_his['vfxsnw_pre']) ; ICE_mas_wfxsnw_pre = OCE_flux_int ( ICE_wfxsnw_pre ) 
     478    OCE.ICE_wfxpnd     = rprec (d_ICE_his['vfxpnd']    ) ; OCE.ICE_mass_wfxpnd     = OCE_flux_int ( OCE.ICE_wfxpnd     ) 
     479    OCE.ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsnw_sub']) ; OCE.ICE_mass_wfxsnw_sub = OCE_flux_int ( OCE.ICE_wfxsnw_sub ) 
     480    OCE.ICE_wfxsnw_pre = rprec (d_ICE_his['vfxsnw_pre']) ; OCE.ICE_mass_wfxsnw_pre = OCE_flux_int ( OCE.ICE_wfxsnw_pre ) 
    627481if NEMO == 3.6 : 
    628     ICE_wfxpnd = 0.0 ; ICE_mas_wfxpnd = 0.0 
    629     ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsub'])/86400.*ICE_RHO_SNO  ; ICE_mas_wfxsnw_sub = OCE_flux_int ( ICE_wfxsnw_sub ) 
    630     ICE_wfxsnw_pre = rprec (d_ICE_his['vfxspr'])/86400.*ICE_RHO_SNO  ; ICE_mas_wfxsnw_pre = OCE_flux_int ( ICE_wfxsnw_pre     ) 
    631  
    632 OCE_wfcorr    = rprec (d_OCE_his['wfcorr']) ; OCE_mas_wfcorr  = OCE_flux_int ( OCE_wfcorr ) 
     482    OCE.ICE_wfxpnd = 0.0 ; OCE.ICE_mass_wfxpnd = 0.0 
     483    OCE.ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsub'])/86400.*ICE_RHO_SNO  ; OCE.ICE_mass_wfxsnw_sub = OCE_flux_int ( OCE.ICE_wfxsnw_sub ) 
     484    OCE.ICE_wfxsnw_pre = rprec (d_ICE_his['vfxspr'])/86400.*ICE_RHO_SNO  ; OCE.ICE_mass_wfxsnw_pre = OCE_flux_int ( OCE.ICE_wfxsnw_pre     ) 
     485 
     486OCE.OCE_wfcorr    = rprec (d_OCE_his['wfcorr']) ; OCE.OCE_mass_wfcorr  = OCE_flux_int ( OCE.OCE_wfcorr ) 
    633487if OCE_relax  : 
    634488    # ssr and fwb are included in emp=>empmr but not in emp_oce (outputed by sea-ice) 
    635     OCE_vflx_fwb = rprec (d_OCE_his['vflx_fwb']) ; OCE_mas_vflx_fwb   = OCE_flux_int ( OCE_vflx_fwb ) 
    636     OCE_vflx_ssr = rprec (d_OCE_his['vflx_ssr']) ; OCE_mas_vflx_ssr   = OCE_flux_int ( OCE_vflx_ssr ) 
     489    OCE.OCE_vflx_fwb = rprec (d_OCE_his['vflx_fwb']) ; OCE.OCE_mass_vflx_fwb   = OCE_flux_int ( OCE.OCE_vflx_fwb ) 
     490    OCE.OCE_vflx_ssr = rprec (d_OCE_his['vflx_ssr']) ; OCE.OCE_mass_vflx_ssr   = OCE_flux_int ( OCE.OCE_vflx_ssr ) 
    637491else :  
    638     OCE_fwb = 0.0 ; OCE_mas_fwb = 0.0 
    639     OCE_ssr = 0.0 ; OCE_mas_ssr = 0.0 
     492    OCE.OCE_fwb = 0.0 ; OCE.OCE_mass_fwb = 0.0 
     493    OCE.OCE_ssr = 0.0 ; OCE.OCE_mass_ssr = 0.0 
    640494if OCE_icb : 
    641     OCE_berg_icb    = rprec (d_OCE_his['berg_floating_melt']) ; OCE_mas_berg_icb = OCE_flux_int ( OCE_berg_icb    ) 
    642     OCE_calving_icb = rprec (d_OCE_his['calving_icb']       ) ; OCE_mas_calv_icb = OCE_flux_int ( OCE_calving_icb ) 
     495    OCE.OCE_berg_icb    = rprec (d_OCE_his['berg_floating_melt']) ; OCE.OCE_mass_berg_icb = OCE_flux_int ( OCE.OCE_berg_icb    ) 
     496    OCE.OCE_calving_icb = rprec (d_OCE_his['calving_icb']       ) ; OCE.OCE_mass_calv_icb = OCE_flux_int ( OCE.OCE_calving_icb ) 
    643497else : 
    644     OCE_berg_icb = 0. ; OCE_mas_berg_icb = 0. 
    645     OCE_calv_icb = 0. ; OCE_mas_calv_icb = 0. 
    646  
    647 OCE_mas_emp = OCE_mas_emp_oce - OCE_mas_wfxice  - OCE_mas_wfxsnw  - ICE_mas_wfxpnd - ICE_mas_wfxsub_err 
    648 OCE_mas_all = OCE_mas_emp_oce + OCE_mas_emp_ice - OCE_mas_runoffs - OCE_mas_iceshelf 
    649  
    650 prtFlux ('OCE+ICE budget ', OCE_mas_all       , 'e', True) 
    651 prtFlux ('  EMPMR        ', OCE_mas_empmr     , 'e', True) 
    652 prtFlux ('  WFOB         ', OCE_mas_wfob      , 'e', True) 
    653 prtFlux ('  EMP_OCE      ', OCE_mas_emp_oce   , 'e', True) 
    654 prtFlux ('  EMP_ICE      ', OCE_mas_emp_ice   , 'e', True) 
    655 prtFlux ('  EMP          ', OCE_mas_emp       , 'e', True) 
    656 prtFlux ('  ICEBERG      ', OCE_mas_iceberg   , 'e',     ) 
    657 prtFlux ('  ICESHELF     ', OCE_mas_iceshelf  , 'e', True) 
    658 prtFlux ('  CALVING      ', OCE_mas_calving   , 'e', True) 
    659 prtFlux ('  FRIVER       ', OCE_mas_friver    , 'e',     )   
    660 prtFlux ('  RUNOFFS      ', OCE_mas_runoffs   , 'e', True) 
    661 prtFlux ('  WFXICE       ', OCE_mas_wfxice    , 'e', True) 
    662 prtFlux ('  WFXSNW       ', OCE_mas_wfxsnw    , 'e', True) 
    663 prtFlux ('  WFXSUB       ', OCE_mas_wfxsub    , 'e', True) 
    664 prtFlux ('  WFXPND       ', ICE_mas_wfxpnd    , 'e', True) 
    665 prtFlux ('  WFXSNW_SUB   ', ICE_mas_wfxsnw_sub, 'e', True) 
    666 prtFlux ('  WFXSNW_PRE   ', ICE_mas_wfxsnw_pre, 'e', True) 
    667 prtFlux ('  WFXSUB_ERR   ', ICE_mas_wfxsub_err, 'e', True) 
    668 prtFlux ('  EVAP_OCE     ', OCE_mas_evap_oce  , 'e'      ) 
    669 prtFlux ('  EVAP_ICE     ', ICE_mas_evap_ice  , 'e', True) 
    670 prtFlux ('  SNOW_OCE     ', OCE_mas_snow_oce  , 'e', True) 
    671 prtFlux ('  SNOW_ICE     ', OCE_mas_snow_ice  , 'e', True) 
    672 prtFlux ('  RAIN         ', OCE_mas_rain      , 'e'      ) 
    673 prtFlux ('  FWB          ', OCE_mas_fwb       , 'e', True) 
    674 prtFlux ('  SSR          ', OCE_mas_ssr       , 'e', True) 
    675 prtFlux ('  WFCORR       ', OCE_mas_wfcorr    , 'e', True) 
    676 prtFlux ('  BERG_ICB     ', OCE_mas_berg_icb  , 'e', True) 
    677 prtFlux ('  CALV_ICB     ', OCE_mas_calv_icb  , 'e', True) 
     498    OCE.OCE_berg_icb = 0. ; OCE.OCE_mass_berg_icb = 0. 
     499    OCE.OCE_calv_icb = 0. ; OCE.OCE_mass_calv_icb = 0. 
     500 
     501OCE.OCE_mass_emp = OCE.OCE_mass_emp_oce - OCE.OCE_mass_wfxice  - OCE.OCE_mass_wfxsnw  - OCE.ICE_mass_wfxpnd - OCE.ICE_mass_wfxsub_err 
     502OCE.OCE_mass_all = OCE.OCE_mass_emp_oce + OCE.OCE_mass_emp_ice - OCE.OCE_mass_runoffs - OCE.OCE_mass_iceshelf 
     503 
     504prtFlux ('OCE+ICE budget ', OCE.OCE_mass_all       , 'e', True) 
     505prtFlux ('  EMPMR        ', OCE.OCE_mass_empmr     , 'e', True) 
     506prtFlux ('  WFOB         ', OCE.OCE_mass_wfob      , 'e', True) 
     507prtFlux ('  EMP_OCE      ', OCE.OCE_mass_emp_oce   , 'e', True) 
     508prtFlux ('  EMP_ICE      ', OCE.OCE_mass_emp_ice   , 'e', True) 
     509prtFlux ('  EMP          ', OCE.OCE_mass_emp       , 'e', True) 
     510prtFlux ('  ICEBERG      ', OCE.OCE_mass_iceberg   , 'e',     ) 
     511prtFlux ('  ICESHELF     ', OCE.OCE_mass_iceshelf  , 'e', True) 
     512prtFlux ('  CALVING      ', OCE.OCE_mass_calving   , 'e', True) 
     513prtFlux ('  FRIVER       ', OCE.OCE_mass_friver    , 'e',     )   
     514prtFlux ('  RUNOFFS      ', OCE.OCE_mass_runoffs   , 'e', True) 
     515prtFlux ('  WFXICE       ', OCE.OCE_mass_wfxice    , 'e', True) 
     516prtFlux ('  WFXSNW       ', OCE.OCE_mass_wfxsnw    , 'e', True) 
     517prtFlux ('  WFXSUB       ', OCE.OCE_mass_wfxsub    , 'e', True) 
     518prtFlux ('  WFXPND       ', OCE.ICE_mass_wfxpnd    , 'e', True) 
     519prtFlux ('  WFXSNW_SUB   ', OCE.ICE_mass_wfxsnw_sub, 'e', True) 
     520prtFlux ('  WFXSNW_PRE   ', OCE.ICE_mass_wfxsnw_pre, 'e', True) 
     521prtFlux ('  WFXSUB_ERR   ', OCE.ICE_mass_wfxsub_err, 'e', True) 
     522prtFlux ('  EVAP_OCE     ', OCE.OCE_mass_evap_oce  , 'e'      ) 
     523prtFlux ('  EVAP_ICE     ', OCE.ICE_mass_evap_ice  , 'e', True) 
     524prtFlux ('  SNOW_OCE     ', OCE.OCE_mass_snow_oce  , 'e', True) 
     525prtFlux ('  SNOW_ICE     ', OCE.OCE_mass_snow_ice  , 'e', True) 
     526prtFlux ('  RAIN         ', OCE.OCE_mass_rain      , 'e'      ) 
     527prtFlux ('  FWB          ', OCE.OCE_mass_fwb       , 'e', True) 
     528prtFlux ('  SSR          ', OCE.OCE_mass_ssr       , 'e', True) 
     529prtFlux ('  WFCORR       ', OCE.OCE_mass_wfcorr    , 'e', True) 
     530prtFlux ('  BERG_ICB     ', OCE.OCE_mass_berg_icb  , 'e', True) 
     531prtFlux ('  CALV_ICB     ', OCE.OCE_mass_calv_icb  , 'e', True) 
    678532 
    679533 
    680534echo (' ') 
    681535 
    682 prtFlux ( 'wbilo sea  ', ATM_flux_int (ATM_wbilo_sea), 'e',   ) 
    683 if SRF :  
    684     prtFlux ( 'costalflow ', ONE_flux_int (RUN_coastalflow), 'e',   ) 
    685     prtFlux ( 'riverflow  ', RUN_flx_river  , 'e',   ) 
    686     prtFlux ( 'costalflow ', RUN_flx_coastal, 'e',   ) 
    687     prtFlux ( 'runoff     ', RUN_flx_river+RUN_flx_coastal, 'e',   ) 
    688  
    689 #ATM_to_OCE   =  ATM_flux_int (ATM_wbilo_sea) - RUN_flx_river - RUN_flx_coastal - ATM_flx_calving 
    690 ATM_to_OCE   =  ATM_flux_int (ATM_wbilo_sea) - ATM_flx_river - ATM_flx_coastal - ATM_flx_calving 
    691 #OCE_from_ATM = -OCE_mas_emp_oce - OCE_mas_emp_ice + OCE_mas_runoffs + OCE_mas_iceberg + OCE_mas_calving + OCE_mas_iceshelf 
    692 OCE_from_ATM = OCE_mas_all 
    693  
    694 prtFlux ( 'ATM_to_OCE  ', ATM_to_OCE  , 'e', True ) 
    695 prtFlux ( 'OCE_from_ATM', OCE_from_ATM, 'e', True ) 
     536prtFlux ( 'wbilo sea  ', ATM_flux_int (ATM.wbilo_sea), 'e',   ) 
     537if SECHIBA :  
     538    prtFlux ( 'costalflow ', ONE_flux_int (SRF.RUN_coastalflow), 'e',   ) 
     539    prtFlux ( 'riverflow  ', SRF.RUN_flx_river  , 'e',   ) 
     540    prtFlux ( 'costalflow ', SRF.RUN_flx_coastal, 'e',   ) 
     541    prtFlux ( 'runoff     ', SRF.RUN_flx_river+SRF.RUN_flx_coastal, 'e',   ) 
     542 
     543#ATM.to_OCE   =  ATM_flux_int (ATM.wbilo_sea) - SRF.RUN_flx_river - SRF.RUN_flx_coastal - ATM.flx_calving 
     544ATM.to_OCE   =  ATM_flux_int (ATM.wbilo_sea) - SRF.RUN_flx_river - SRF.RUN_flx_coastal - ATM.flx_calving 
     545#OCE.OCE_from_ATM = -OCE.OCE_mass_emp_oce - OCE.OCE_mass_emp_ice + OCE.OCE_mass_runoffs + OCE.OCE_mass_iceberg + OCE.OCE_mass_calving + OCE.OCE_mass_iceshelf 
     546OCE.OCE_from_ATM = OCE.OCE_mass_all 
     547 
     548prtFlux ( 'ATM.to_OCE      ', ATM.to_OCE      , 'e', True ) 
     549prtFlux ( 'OCE.OCE_from_ATM', OCE.OCE_from_ATM, 'e', True ) 
    696550 
    697551echo ( ' ' ) 

  • TOOLS/WATER_BUDGET/OCE_waterbudget.py

    r6676 r6688  
    4545    raise FileExistsError ( f"File not found : {IniFile = }" ) 
    4646 
    47 if 'full' in IniFile or 'ATM' in IniFile : 
     47if 'full' in IniFile or 'OCE' in IniFile : 
    4848    FullIniFile = IniFile 
    4949else : 
    50     FullIniFile = 'ATM_' + IniFile 
     50    FullIniFile = 'OCE_' + IniFile 
    5151 
    5252 
    … …  
    9898def kg2myear (val, rho=ATM_RHO) : 
    9999    '''From kg to m/year''' 
    100     return val/OCE_aire_tot/rho/NbYear 
     100    return val/OCE.OCE_aire_tot/rho/NbYear 
    101101 
    102102def var2prt (var, small=False, rho=ATM_RHO) : 
    … …  
    295295 
    296296# Get mask and surfaces 
    297 sos = d_OCE_his ['sos'][0].squeeze() 
    298 OCE_msk = nemo.lbc_mask ( xr.where ( sos>0., 1., 0. ), cd_type = 'T', nperio=nperio, sval = 0. ) 
    299  
    300 so = sos = d_OCE_his ['sos'][0].squeeze() 
    301 OCE_msk3 = nemo.lbc_mask ( xr.where ( so>0., 1., 0. ), cd_type = 'T', nperio=nperio, sval = 0. ) 
    302  
    303 # lbc_mask removes the duplicate points (periodicity and north fold) 
    304 OCE_aire = nemo.lbc_mask ( d_OCE_his ['area'] * OCE_msk, cd_type = 'T', nperio=nperio, sval = 0.0 ) 
    305 ICE_aire = OCE_aire 
     297 
     298dpar, OCE = wu.ComputeGridOCE ( dpar, d_OCE_his, nperio=nperio ) 
     299         
     300# sos = d_OCE_his ['sos'][0].squeeze() 
     301# OCE_msk = nemo.lbc_mask ( xr.where ( sos>0., 1., 0. ), cd_type = 'T', nperio=nperio, sval = 0. ) 
     302 
     303# so = sos = d_OCE_his ['sos'][0].squeeze() 
     304# OCE_msk3 = nemo.lbc_mask ( xr.where ( so>0., 1., 0. ), cd_type = 'T', nperio=nperio, sval = 0. ) 
     305 
     306# # lbc_mask removes the duplicate points (periodicity and north fold) 
     307# OCE.OCE_aire = nemo.lbc_mask ( d_OCE_his ['area'] * OCE_msk, cd_type = 'T', nperio=nperio, sval = 0.0 ) 
     308# OCE.ICE_aire = OCE_aire 
    306309 
    307310@Timer 
    308311def OCE_stock_int (stock) : 
    309312    '''Integrate stock on ocean grid''' 
    310     return wu.Psum (  (stock * OCE_aire ).to_masked_array().ravel() ) 
     313    return wu.P1sum ( stock * OCE.OCE_aire ) 
    311314 
    312315@Timer 
    313316def ONE_stock_int (stock) : 
    314317    '''Sum stock''' 
    315     return wu.Psum ( stock.to_masked_array().ravel() ) 
     318    return wu.P1sum ( stock ) 
    316319 
    317320@Timer 
    318321def OCE_flux_int (flux) : 
    319322    '''Integrate flux on oce grid''' 
    320     return wu.Psum  ( (flux * OCE_aire * dtime_per_sec).to_masked_array().ravel() ) 
     323    return wu.P1sum  ( flux * OCE.OCE_aire * dtime_per_sec ) 
    321324 
    322325@Timer 
    323326def ONE_flux_int (flux) : 
    324327    '''Integrate flux on oce grid''' 
    325     return wu.Psum ( (flux * dtime_per_sec).to_masked_array().ravel() ) 
    326  
    327 OCE_aire_tot = ONE_stock_int ( OCE_aire ) 
    328 ICE_aire_tot = ONE_stock_int ( ICE_aire ) 
     328    return wu.P1sum ( flux * dtime_per_sec ) 
     329 
     330#OCE.OCE_aire_tot = ONE_stock_int ( OCE.OCE_aire ) 
     331#OCE.ICE_aire_tot = ONE_stock_int ( OCE.ICE_aire ) 
    329332 
    330333echo ( '\n------------------------------------------------------------------------------------' ) 
    … …  
    335338#-- Change in ocean volume in freshwater equivalent 
    336339 
    337 OCE_ssh_beg = d_OCE_beg['sshn'] 
    338 OCE_ssh_end = d_OCE_end['sshn'] 
    339  
    340 OCE_sum_ssh_beg = OCE_stock_int ( OCE_ssh_beg ) 
    341 OCE_sum_ssh_end = OCE_stock_int ( OCE_ssh_end ) 
    342  
    343 if NEMO == 3.6 : 
    344     OCE_e3tn_beg = d_OCE_beg['fse3t_n'] 
    345     OCE_e3tn_end = d_OCE_end['fse3t_n'] 
    346     OCE_sum_e3tn_beg = OCE_stock_int ( OCE_e3tn_beg * OCE_msk3) 
    347     OCE_sum_e3tn_end = OCE_stock_int ( OCE_e3tn_end * OCE_msk3) 
    348  
    349 echo ( f'OCE_sum_ssh_beg = {OCE_sum_ssh_beg:12.6e} m^3  - OCE_sum_ssh_end = {OCE_sum_ssh_end:12.6e} m^3' ) 
    350 dOCE_ssh_vol = OCE_sum_ssh_end - OCE_sum_ssh_beg 
    351 dOCE_ssh_mas = dOCE_ssh_vol * OCE_RHO_LIQ 
    352  
    353 if NEMO == 3.6 : 
    354     echo ( f'OCE_sum_e3tn_beg = {OCE_sum_e3tn_beg:12.6e} m^3  - OCE_sum_e3tn_end = {OCE_sum_e3tn_end:12.6e} m^3' ) 
    355     dOCE_e3tn_vol = OCE_sum_e3tn_end - OCE_sum_e3tn_beg 
    356     dOCE_e3tn_mas = dOCE_e3tn_vol * OCE_RHO_LIQ 
    357  
    358 dOCE_vol_wat = dOCE_ssh_vol ; dOCE_mas_wat = dOCE_ssh_mas 
    359  
    360 echo ( f'dOCE vol    = {dOCE_vol_wat             :12.3e} m^3' ) 
    361 echo ( f'dOCE ssh    = {dOCE_vol_wat/OCE_aire_tot:12.3e} m  ' ) 
    362 prtFlux ( 'dOCE mass ', dOCE_mas_wat, 'e' ) 
    363  
    364 if NEMO == 3.6 : 
    365     echo ( f'dOCE e3tn   vol    = {dOCE_e3tn_vol:12.3e} m^3' ) 
    366     prtFlux ( 'dOCE e3tn   mass', dOCE_e3tn_mas, 'e' ) 
     340OCE.OCE_ssh_beg = d_OCE_beg['sshn'] 
     341OCE.OCE_ssh_end = d_OCE_end['sshn'] 
     342 
     343OCE.OCE_sum_ssh_beg = OCE_stock_int ( OCE.OCE_ssh_beg ) 
     344OCE.OCE_sum_ssh_end = OCE_stock_int ( OCE.OCE_ssh_end ) 
     345 
     346if NEMO == 3.6 : 
     347    OCE.OCE_e3tn_beg = d_OCE_beg['fse3t_n'] 
     348    OCE.OCE_e3tn_end = d_OCE_end['fse3t_n'] 
     349    OCE.OCE_sum_e3tn_beg = OCE_stock_int ( OCE.OCE_e3tn_beg * OCE.OCE_msk3) 
     350    OCE.OCE_sum_e3tn_end = OCE_stock_int ( OCE.OCE_e3tn_end * OCE.OCE_msk3) 
     351 
     352echo ( f'OCE.OCE_sum_ssh_beg = {OCE.OCE_sum_ssh_beg:12.6e} m^3  - OCE.OCE_sum_ssh_end = {OCE.OCE_sum_ssh_end:12.6e} m^3' ) 
     353OCE.OCE_diff_ssh_vol = OCE.OCE_sum_ssh_end - OCE.OCE_sum_ssh_beg 
     354OCE.OCE_diff_ssh_mas = OCE.OCE_diff_ssh_vol * OCE_RHO_LIQ 
     355 
     356if NEMO == 3.6 : 
     357    echo ( f'OCE.OCE_sum_e3tn_beg = {OCE.OCE_sum_e3tn_beg:12.6e} m^3  - OCE.OCE_sum_e3tn_end = {OCE.OCE_sum_e3tn_end:12.6e} m^3' ) 
     358    OCE.OCE_diff_e3tn_vol = OCE.OCE_sum_e3tn_end - OCE.OCE_sum_e3tn_beg 
     359    OCE.OCE_diff_e3tn_mas = OCE.OCE_diff_e3tn_vol * OCE_RHO_LIQ 
     360 
     361OCE.OCE_diff_vol_wat = OCE.OCE_diff_ssh_vol ; OCE.OCE_diff_mas_wat = OCE.OCE_diff_ssh_mas 
     362 
     363echo ( f'dOCE vol    = {OCE.OCE_diff_vol_wat             :12.3e} m^3' ) 
     364echo ( f'dOCE ssh    = {OCE.OCE_diff_vol_wat/OCE.OCE_aire_tot:12.3e} m  ' ) 
     365prtFlux ( 'dOCE mass ', OCE.OCE_diff_mas_wat, 'e' ) 
     366 
     367if NEMO == 3.6 : 
     368    echo ( f'dOCE e3tn   vol    = {OCE.OCE_diff_e3tn_vol:12.3e} m^3' ) 
     369    prtFlux ( 'dOCE e3tn   mass', OCE.OCE_diff_e3tn_mas, 'e' ) 
    367370 
    368371## Glace et neige 
    369372if NEMO == 3.6 : 
    370     ICE_ice_beg = d_ICE_beg['v_i_htc1']+d_ICE_beg['v_i_htc2']+d_ICE_beg['v_i_htc3']+d_ICE_beg['v_i_htc4']+d_ICE_beg['v_i_htc5'] 
    371     ICE_ice_end = d_ICE_end['v_i_htc1']+d_ICE_end['v_i_htc2']+d_ICE_end['v_i_htc3']+d_ICE_end['v_i_htc4']+d_ICE_end['v_i_htc5'] 
    372  
    373     ICE_sno_beg = d_ICE_beg['v_s_htc1']+d_ICE_beg['v_s_htc2']+d_ICE_beg['v_s_htc3']+d_ICE_beg['v_s_htc4']+d_ICE_beg['v_s_htc5'] 
    374     ICE_sno_end = d_ICE_end['v_s_htc1']+d_ICE_end['v_s_htc2']+d_ICE_end['v_s_htc3']+d_ICE_end['v_s_htc4']+d_ICE_end['v_s_htc5'] 
    375  
    376     ICE_pnd_beg = 0.0 ; ICE_pnd_end = 0.0 ; ICE_fzl_beg = 0.0 ; ICE_fzl_end = 0.0 
    377  
    378     ICE_mas_wat_beg = ICE_ice_beg*ICE_RHO_ICE + ICE_sno_beg*ICE_RHO_SNO 
    379     ICE_mas_wat_end = ICE_ice_end*ICE_RHO_ICE + ICE_sno_end*ICE_RHO_SNO 
     373    OCE.ICE_ice_beg = d_ICE_beg['v_i_htc1']+d_ICE_beg['v_i_htc2']+d_ICE_beg['v_i_htc3']+d_ICE_beg['v_i_htc4']+d_ICE_beg['v_i_htc5'] 
     374    OCE.ICE_ice_end = d_ICE_end['v_i_htc1']+d_ICE_end['v_i_htc2']+d_ICE_end['v_i_htc3']+d_ICE_end['v_i_htc4']+d_ICE_end['v_i_htc5'] 
     375 
     376    OCE.ICE_sno_beg = d_ICE_beg['v_s_htc1']+d_ICE_beg['v_s_htc2']+d_ICE_beg['v_s_htc3']+d_ICE_beg['v_s_htc4']+d_ICE_beg['v_s_htc5'] 
     377    OCE.ICE_sno_end = d_ICE_end['v_s_htc1']+d_ICE_end['v_s_htc2']+d_ICE_end['v_s_htc3']+d_ICE_end['v_s_htc4']+d_ICE_end['v_s_htc5'] 
     378 
     379    OCE.ICE_pnd_beg = 0.0 ; OCE.ICE_pnd_end = 0.0 ; OCE.ICE_fzl_beg = 0.0 ; OCE.ICE_fzl_end = 0.0 
     380 
     381    OCE.ICE_mas_wat_beg = OCE.ICE_ice_beg*ICE_RHO_ICE + OCE.ICE_sno_beg*ICE_RHO_SNO 
     382    OCE.ICE_mas_wat_end = OCE.ICE_ice_end*ICE_RHO_ICE + OCE.ICE_sno_end*ICE_RHO_SNO 
    380383 
    381384if NEMO in [ 4.0, 4.2 ] : 
    382     ICE_ice_beg = d_ICE_beg['v_i']  ; ICE_ice_end = d_ICE_end['v_i'] 
    383     ICE_sno_beg = d_ICE_beg['v_s']  ; ICE_sno_end = d_ICE_end['v_s'] 
    384     ICE_pnd_beg = d_ICE_beg['v_ip'] ; ICE_pnd_end = d_ICE_end['v_ip'] # Ice ponds 
    385     ICE_fzl_beg = d_ICE_beg['v_il'] ; ICE_fzl_end = d_ICE_end['v_il'] # Frozen Ice Ponds 
    386  
    387     ICE_mas_wat_beg =  OCE_stock_int ( d_ICE_beg['snwice_mass'] ) 
    388     ICE_mas_wat_end =  OCE_stock_int ( d_ICE_end['snwice_mass'] ) 
    389  
    390 ICE_vol_ice_beg = OCE_stock_int ( ICE_ice_beg ) 
    391 ICE_vol_ice_end = OCE_stock_int ( ICE_ice_end ) 
    392  
    393 ICE_vol_sno_beg = OCE_stock_int ( ICE_sno_beg ) 
    394 ICE_vol_sno_end = OCE_stock_int ( ICE_sno_end ) 
    395  
    396 ICE_vol_pnd_beg = OCE_stock_int ( ICE_pnd_beg ) 
    397 ICE_vol_pnd_end = OCE_stock_int ( ICE_pnd_end ) 
    398  
    399 ICE_vol_fzl_beg = OCE_stock_int ( ICE_fzl_beg ) 
    400 ICE_vol_fzl_end = OCE_stock_int ( ICE_fzl_end ) 
     385    OCE.ICE_ice_beg = d_ICE_beg['v_i']  ; OCE.ICE_ice_end = d_ICE_end['v_i'] 
     386    OCE.ICE_sno_beg = d_ICE_beg['v_s']  ; OCE.ICE_sno_end = d_ICE_end['v_s'] 
     387    OCE.ICE_pnd_beg = d_ICE_beg['v_ip'] ; OCE.ICE_pnd_end = d_ICE_end['v_ip'] # Ice ponds 
     388    OCE.ICE_fzl_beg = d_ICE_beg['v_il'] ; OCE.ICE_fzl_end = d_ICE_end['v_il'] # Frozen Ice Ponds 
     389 
     390    OCE.ICE_mas_wat_beg =  OCE_stock_int ( d_ICE_beg['snwice_mass'] ) 
     391    OCE.ICE_mas_wat_end =  OCE_stock_int ( d_ICE_end['snwice_mass'] ) 
     392 
     393OCE.ICE_vol_ice_beg = OCE_stock_int ( OCE.ICE_ice_beg ) 
     394OCE.ICE_vol_ice_end = OCE_stock_int ( OCE.ICE_ice_end ) 
     395 
     396OCE.ICE_vol_sno_beg = OCE_stock_int ( OCE.ICE_sno_beg ) 
     397OCE.ICE_vol_sno_end = OCE_stock_int ( OCE.ICE_sno_end ) 
     398 
     399OCE.ICE_vol_pnd_beg = OCE_stock_int ( OCE.ICE_pnd_beg ) 
     400OCE.ICE_vol_pnd_end = OCE_stock_int ( OCE.ICE_pnd_end ) 
     401 
     402OCE.ICE_vol_fzl_beg = OCE_stock_int ( OCE.ICE_fzl_beg ) 
     403OCE.ICE_vol_fzl_end = OCE_stock_int ( OCE.ICE_fzl_end ) 
    401404 
    402405#-- Converting to freswater volume 
    403 dICE_vol_ice = ICE_vol_ice_end - ICE_vol_ice_beg 
    404 dICE_mas_ice = dICE_vol_ice * ICE_RHO_ICE 
    405  
    406 dICE_vol_sno = ICE_vol_sno_end - ICE_vol_sno_beg 
    407 dICE_mas_sno = dICE_vol_sno * ICE_RHO_SNO 
    408  
    409 dICE_vol_pnd = ICE_vol_pnd_end - ICE_vol_pnd_beg 
    410 dICE_mas_pnd = dICE_vol_pnd * ICE_RHO_PND 
    411  
    412 dICE_vol_fzl= ICE_vol_fzl_end - ICE_vol_fzl_beg 
    413 dICE_mas_fzl = dICE_vol_fzl * ICE_RHO_PND 
    414  
    415 if NEMO == 3.6 : 
    416     dICE_mas_wat = dICE_mas_ice + dICE_mas_sno 
    417     dSEA_mas_wat = dOCE_mas_wat + dICE_mas_ice + dICE_mas_sno 
     406OCE.ICE_diff_vol_ice = OCE.ICE_vol_ice_end - OCE.ICE_vol_ice_beg 
     407OCE.ICE_diff_mas_ice = OCE.ICE_diff_vol_ice * ICE_RHO_ICE 
     408 
     409OCE.ICE_diff_vol_sno = OCE.ICE_vol_sno_end - OCE.ICE_vol_sno_beg 
     410OCE.ICE_diff_mas_sno = OCE.ICE_diff_vol_sno * ICE_RHO_SNO 
     411 
     412OCE.ICE_diff_vol_pnd = OCE.ICE_vol_pnd_end - OCE.ICE_vol_pnd_beg 
     413OCE.ICE_diff_mas_pnd = OCE.ICE_diff_vol_pnd * ICE_RHO_PND 
     414 
     415OCE.ICE_diff_vol_fzl= OCE.ICE_vol_fzl_end - OCE.ICE_vol_fzl_beg 
     416OCE.ICE_diff_mas_fzl = OCE.ICE_diff_vol_fzl * ICE_RHO_PND 
     417 
     418if NEMO == 3.6 : 
     419    OCE.ICE_diff_mas_wat = OCE.ICE_diff_mas_ice + OCE.ICE_diff_mas_sno 
     420    OCE.OCE_diff_SEA_mas_wat = OCE.OCE_diff_mas_wat + OCE.ICE_diff_mas_ice + OCE.ICE_diff_mas_sno 
    418421 
    419422if NEMO in [4.0, 4.2 ] : 
    420     dICE_mas_wat = ICE_mas_wat_end - ICE_mas_wat_beg 
    421     dSEA_mas_wat = dOCE_mas_wat + dICE_mas_wat 
    422  
    423 echo ( f'ICE_vol_ice_beg = {ICE_vol_ice_beg:12.6e} m^3 | ICE_vol_ice_end = {ICE_vol_ice_end:12.6e} m^3' ) 
    424 echo ( f'ICE_vol_sno_beg = {ICE_vol_sno_beg:12.6e} m^3 | ICE_vol_sno_end = {ICE_vol_sno_end:12.6e} m^3' ) 
    425 echo ( f'ICE_vol_pnd_beg = {ICE_vol_pnd_beg:12.6e} m^3 | ICE_vol_pnd_end = {ICE_vol_pnd_end:12.6e} m^3' ) 
    426 echo ( f'ICE_vol_fzl_beg = {ICE_vol_fzl_beg:12.6e} m^3 | ICE_vol_fzl_end = {ICE_vol_fzl_end:12.6e} m^3' ) 
    427  
    428 echo ( f'dICE_vol_ice   = {dICE_vol_ice:12.3e} m^3' ) 
    429 echo ( f'dICE_vol_sno   = {dICE_vol_sno:12.3e} m^3' ) 
    430 echo ( f'dICE_vol_pnd   = {dICE_vol_pnd:12.3e} m^3' ) 
    431 echo ( f'dICE_mas_ice   = {dICE_mas_ice:12.3e} m^3' ) 
    432 echo ( f'dICE_mas_sno   = {dICE_mas_sno:12.3e} m^3' ) 
    433 echo ( f'dICE_mas_pnd   = {dICE_mas_pnd:12.3e} m^3' ) 
    434 echo ( f'dICE_mas_fzl   = {dICE_mas_fzl:12.3e} m^3' ) 
     423    OCE.ICE_diff_mas_wat = OCE.ICE_mas_wat_end - OCE.ICE_mas_wat_beg 
     424    OCE.OCE_diff_SEA_mas_wat = OCE.OCE_diff_mas_wat + OCE.ICE_diff_mas_wat 
     425 
     426echo ( f'OCE.ICE_vol_ice_beg = {OCE.ICE_vol_ice_beg:12.6e} m^3 | OCE.ICE_vol_ice_end = {OCE.ICE_vol_ice_end:12.6e} m^3' ) 
     427echo ( f'OCE.ICE_vol_sno_beg = {OCE.ICE_vol_sno_beg:12.6e} m^3 | OCE.ICE_vol_sno_end = {OCE.ICE_vol_sno_end:12.6e} m^3' ) 
     428echo ( f'OCE.ICE_vol_pnd_beg = {OCE.ICE_vol_pnd_beg:12.6e} m^3 | OCE.ICE_vol_pnd_end = {OCE.ICE_vol_pnd_end:12.6e} m^3' ) 
     429echo ( f'OCE.ICE_vol_fzl_beg = {OCE.ICE_vol_fzl_beg:12.6e} m^3 | OCE.ICE_vol_fzl_end = {OCE.ICE_vol_fzl_end:12.6e} m^3' ) 
     430 
     431echo ( f'OCE.ICE_diff_vol_ice   = {OCE.ICE_diff_vol_ice:12.3e} m^3' ) 
     432echo ( f'OCE.ICE_diff_vol_sno   = {OCE.ICE_diff_vol_sno:12.3e} m^3' ) 
     433echo ( f'OCE.ICE_diff_vol_pnd   = {OCE.ICE_diff_vol_pnd:12.3e} m^3' ) 
     434echo ( f'OCE.ICE_diff_mas_ice   = {OCE.ICE_diff_mas_ice:12.3e} m^3' ) 
     435echo ( f'OCE.ICE_diff_mas_sno   = {OCE.ICE_diff_mas_sno:12.3e} m^3' ) 
     436echo ( f'OCE.ICE_diff_mas_pnd   = {OCE.ICE_diff_mas_pnd:12.3e} m^3' ) 
     437echo ( f'OCE.ICE_diff_mas_fzl   = {OCE.ICE_diff_mas_fzl:12.3e} m^3' ) 
    435438 
    436439echo ( '\n------------------------------------------------------------') 
    437440echo ( 'Change in water content (ocean + ice) ' ) 
    438 prtFlux ( 'dMass (ocean)', dSEA_mas_wat, 'e', True ) 
     441prtFlux ( 'dMass (ocean)', OCE.OCE_diff_SEA_mas_wat, 'e', True ) 
    439442 
    440443 
    … …  
    454457# dice = - emp_ice - wfx_snw - wfx_ice - wfx_pnd(v4.0.6) - wfx_err_sub 
    455458 
    456 #OCE_emp = evap - precip (including blowing snow) - calving 
    457 #ICE_emp = wfx_spr(<0) + wfx_sub(>0) + wfx_snw_sub(v4.0.6) - wfx_err_sub(<0) 
     459#OCE.OCE_emp = evap - precip (including blowing snow) - calving 
     460#OCE.ICE_emp = wfx_spr(<0) + wfx_sub(>0) + wfx_snw_sub(v4.0.6) - wfx_err_sub(<0) 
    458461 
    459462echo ( '\n------------------------------------------------------------------------------------' ) 
    … …  
    461464 
    462465# Read variable and computes integral over space and time 
    463 OCE_empmr      = rprec (d_OCE_his['wfo']     )    ; OCE_mas_empmr    = OCE_flux_int ( OCE_empmr    ) 
    464 OCE_wfob       = rprec (d_OCE_his['wfob']    )    ; OCE_mas_wfob     = OCE_flux_int ( OCE_wfob     ) 
    465 OCE_emp_oce    = rprec (d_OCE_his['emp_oce'] )    ; OCE_mas_emp_oce  = OCE_flux_int ( OCE_emp_oce  ) 
    466 OCE_emp_ice    = rprec (d_OCE_his['emp_ice'] )    ; OCE_mas_emp_ice  = OCE_flux_int ( OCE_emp_ice  ) 
    467 OCE_iceshelf   = rprec (d_OCE_his['iceshelf'])    ; OCE_mas_iceshelf = OCE_flux_int ( OCE_iceshelf ) 
    468 OCE_calving    = rprec (d_OCE_his['calving'] )    ; OCE_mas_calving  = OCE_flux_int ( OCE_calving  ) 
    469 OCE_iceberg    = rprec (d_OCE_his['iceberg'] )    ; OCE_mas_iceberg  = OCE_flux_int ( OCE_iceberg  ) 
    470 OCE_friver     = rprec (d_OCE_his['friver']  )    ; OCE_mas_friver   = OCE_flux_int ( OCE_friver   ) 
    471 OCE_runoffs    = rprec (d_OCE_his['runoffs'] )    ; OCE_mas_runoffs  = OCE_flux_int ( OCE_runoffs  ) 
     466OCE.OCE_empmr      = rprec (d_OCE_his['wfo']     )    ; OCE.OCE_mas_empmr    = OCE_flux_int ( OCE.OCE_empmr    ) 
     467OCE.OCE_wfob       = rprec (d_OCE_his['wfob']    )    ; OCE.OCE_mas_wfob     = OCE_flux_int ( OCE.OCE_wfob     ) 
     468OCE.OCE_emp_oce    = rprec (d_OCE_his['emp_oce'] )    ; OCE.OCE_mas_emp_oce  = OCE_flux_int ( OCE.OCE_emp_oce  ) 
     469OCE.OCE_emp_ice    = rprec (d_OCE_his['emp_ice'] )    ; OCE.OCE_mas_emp_ice  = OCE_flux_int ( OCE.OCE_emp_ice  ) 
     470OCE.OCE_iceshelf   = rprec (d_OCE_his['iceshelf'])    ; OCE.OCE_mas_iceshelf = OCE_flux_int ( OCE.OCE_iceshelf ) 
     471OCE.OCE_calving    = rprec (d_OCE_his['calving'] )    ; OCE.OCE_mas_calving  = OCE_flux_int ( OCE.OCE_calving  ) 
     472OCE.OCE_iceberg    = rprec (d_OCE_his['iceberg'] )    ; OCE.OCE_mas_iceberg  = OCE_flux_int ( OCE.OCE_iceberg  ) 
     473OCE.OCE_friver     = rprec (d_OCE_his['friver']  )    ; OCE.OCE_mas_friver   = OCE_flux_int ( OCE.OCE_friver   ) 
     474OCE.OCE_runoffs    = rprec (d_OCE_his['runoffs'] )    ; OCE.OCE_mas_runoffs  = OCE_flux_int ( OCE.OCE_runoffs  ) 
    472475if NEMO in [ 4.0, 4.2 ] : 
    473     OCE_wfxice     = rprec (d_OCE_his['vfxice']) ; OCE_mas_wfxice   = OCE_flux_int ( OCE_wfxice ) 
    474     OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw']) ; OCE_mas_wfxsnw   = OCE_flux_int ( OCE_wfxsnw ) 
    475     OCE_wfxsub     = rprec (d_OCE_his['vfxsub']) ; OCE_mas_wfxsub   = OCE_flux_int ( OCE_wfxsub ) 
    476 if NEMO == 3.6 : 
    477     OCE_wfxice     = rprec (d_OCE_his['vfxice'])/nemo.RDAY*ICE_RHO_ICE ; OCE_mas_wfxice   = OCE_flux_int ( OCE_wfxice ) 
    478     OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw'])/nemo.RDAY*ICE_RHO_SNO ; OCE_mas_wfxsnw   = OCE_flux_int ( OCE_wfxsnw ) 
    479     OCE_wfxsub     = rprec (d_OCE_his['vfxsub'])/nemo.RDAY*ICE_RHO_SNO ; OCE_mas_wfxsub   = OCE_flux_int ( OCE_wfxsub ) 
     476    OCE.OCE_wfxice     = rprec (d_OCE_his['vfxice']) ; OCE.OCE_mas_wfxice   = OCE_flux_int ( OCE.OCE_wfxice ) 
     477    OCE.OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw']) ; OCE.OCE_mas_wfxsnw   = OCE_flux_int ( OCE.OCE_wfxsnw ) 
     478    OCE.OCE_wfxsub     = rprec (d_OCE_his['vfxsub']) ; OCE.OCE_mas_wfxsub   = OCE_flux_int ( OCE.OCE_wfxsub ) 
     479if NEMO == 3.6 : 
     480    OCE.OCE_wfxice     = rprec (d_OCE_his['vfxice'])/nemo.RDAY*ICE_RHO_ICE ; OCE.OCE_mas_wfxice   = OCE_flux_int ( OCE.OCE_wfxice ) 
     481    OCE.OCE_wfxsnw     = rprec (d_OCE_his['vfxsnw'])/nemo.RDAY*ICE_RHO_SNO ; OCE.OCE_mas_wfxsnw   = OCE_flux_int ( OCE.OCE_wfxsnw ) 
     482    OCE.OCE_wfxsub     = rprec (d_OCE_his['vfxsub'])/nemo.RDAY*ICE_RHO_SNO ; OCE.OCE_mas_wfxsub   = OCE_flux_int ( OCE.OCE_wfxsub ) 
    480483# Additional checks 
    481 OCE_evap_oce   = rprec (d_OCE_his['evap_ao_cea']) ; OCE_mas_evap_oce   = OCE_flux_int ( OCE_evap_oce ) 
    482 ICE_evap_ice   = rprec (d_OCE_his['subl_ai_cea']) ; ICE_mas_evap_ice   = OCE_flux_int ( ICE_evap_ice ) 
    483 OCE_snow_oce   = rprec (d_OCE_his['snow_ao_cea']) ; OCE_mas_snow_oce   = OCE_flux_int ( OCE_snow_oce ) 
    484 OCE_snow_ice   = rprec (d_OCE_his['snow_ai_cea']) ; OCE_mas_snow_ice   = OCE_flux_int ( OCE_snow_ice ) 
    485 OCE_rain       = rprec (d_OCE_his['rain']       ) ; OCE_mas_rain       = OCE_flux_int ( OCE_rain     ) 
    486 ICE_wfxsub_err = rprec (d_ICE_his['vfxsub_err'] ) ; ICE_mas_wfxsub_err = OCE_flux_int ( ICE_wfxsub_err ) 
     484OCE.OCE_evap_oce   = rprec (d_OCE_his['evap_ao_cea']) ; OCE.OCE_mas_evap_oce   = OCE_flux_int ( OCE.OCE_evap_oce ) 
     485OCE.ICE_evap_ice   = rprec (d_OCE_his['subl_ai_cea']) ; OCE.ICE_mas_evap_ice   = OCE_flux_int ( OCE.ICE_evap_ice ) 
     486OCE.OCE_snow_oce   = rprec (d_OCE_his['snow_ao_cea']) ; OCE.OCE_mas_snow_oce   = OCE_flux_int ( OCE.OCE_snow_oce ) 
     487OCE.OCE_snow_ice   = rprec (d_OCE_his['snow_ai_cea']) ; OCE.OCE_mas_snow_ice   = OCE_flux_int ( OCE.OCE_snow_ice ) 
     488OCE.OCE_rain       = rprec (d_OCE_his['rain']       ) ; OCE.OCE_mas_rain       = OCE_flux_int ( OCE.OCE_rain     ) 
     489OCE.ICE_wfxsub_err = rprec (d_ICE_his['vfxsub_err'] ) ; OCE.ICE_mas_wfxsub_err = OCE_flux_int ( OCE.ICE_wfxsub_err ) 
    487490if NEMO in [ 4.0, 4.2 ] : 
    488     ICE_wfxpnd     = rprec (d_ICE_his['vfxpnd']    ) ; ICE_mas_wfxpnd     = OCE_flux_int ( ICE_wfxpnd     ) 
    489     ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsnw_sub']) ; ICE_mas_wfxsnw_sub = OCE_flux_int ( ICE_wfxsnw_sub ) 
    490     ICE_wfxsnw_pre = rprec (d_ICE_his['vfxsnw_pre']) ; ICE_mas_wfxsnw_pre = OCE_flux_int ( ICE_wfxsnw_pre ) 
    491 if NEMO == 3.6 : 
    492     ICE_wfxpnd = 0.0 ; ICE_mas_wfxpnd = 0.0 
    493     ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsub'])/nemo.RDAY*ICE_RHO_SNO  ; ICE_mas_wfxsnw_sub = OCE_flux_int ( ICE_wfxsnw_sub ) 
    494     ICE_wfxsnw_pre = rprec (d_ICE_his['vfxspr'])/nemo.RDAY*ICE_RHO_SNO  ; ICE_mas_wfxsnw_pre = OCE_flux_int ( ICE_wfxsnw_pre ) 
    495  
    496 OCE_wfcorr    = rprec (d_OCE_his['wfcorr']) ; OCE_mas_wfcorr  = OCE_flux_int ( OCE_wfcorr ) 
     491    OCE.ICE_wfxpnd     = rprec (d_ICE_his['vfxpnd']    ) ; OCE.ICE_mas_wfxpnd     = OCE_flux_int ( OCE.ICE_wfxpnd     ) 
     492    OCE.ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsnw_sub']) ; OCE.ICE_mas_wfxsnw_sub = OCE_flux_int ( OCE.ICE_wfxsnw_sub ) 
     493    OCE.ICE_wfxsnw_pre = rprec (d_ICE_his['vfxsnw_pre']) ; OCE.ICE_mas_wfxsnw_pre = OCE_flux_int ( OCE.ICE_wfxsnw_pre ) 
     494if NEMO == 3.6 : 
     495    OCE.ICE_wfxpnd = 0.0 ; OCE.ICE_mas_wfxpnd = 0.0 
     496    OCE.ICE_wfxsnw_sub = rprec (d_ICE_his['vfxsub'])/nemo.RDAY*ICE_RHO_SNO  ; OCE.ICE_mas_wfxsnw_sub = OCE_flux_int ( OCE.ICE_wfxsnw_sub ) 
     497    OCE.ICE_wfxsnw_pre = rprec (d_ICE_his['vfxspr'])/nemo.RDAY*ICE_RHO_SNO  ; OCE.ICE_mas_wfxsnw_pre = OCE_flux_int ( OCE.ICE_wfxsnw_pre ) 
     498 
     499OCE.OCE_wfcorr    = rprec (d_OCE_his['wfcorr']) ; OCE.OCE_mas_wfcorr  = OCE_flux_int ( OCE.OCE_wfcorr ) 
    497500if OCE_relax  : 
    498501    # ssr and fwb are included in emp=>empmr but not in emp_oce (outputed by sea-ice) 
    499     OCE_vflx_fwb = rprec (d_OCE_his['vflx_fwb']) ; OCE_mas_vflx_fwb   = OCE_flux_int ( OCE_vflx_fwb ) 
    500     OCE_vflx_ssr = rprec (d_OCE_his['vflx_ssr']) ; OCE_mas_vflx_ssr   = OCE_flux_int ( OCE_vflx_ssr ) 
     502    OCE.OCE_vflx_fwb = rprec (d_OCE_his['vflx_fwb']) ; OCE.OCE_mas_vflx_fwb   = OCE_flux_int ( OCE.OCE_vflx_fwb ) 
     503    OCE.OCE_vflx_ssr = rprec (d_OCE_his['vflx_ssr']) ; OCE.OCE_mas_vflx_ssr   = OCE_flux_int ( OCE.OCE_vflx_ssr ) 
    501504else : 
    502     OCE_fwb = 0.0 ; OCE_mas_fwb = 0.0 
    503     OCE_ssr = 0.0 ; OCE_mas_ssr = 0.0 
     505    OCE.OCE_fwb = 0.0 ; OCE.OCE_mas_fwb = 0.0 
     506    OCE.OCE_ssr = 0.0 ; OCE.OCE_mas_ssr = 0.0 
    504507if OCE_icb : 
    505     OCE_berg_icb    = rprec (d_OCE_his['berg_floating_melt']) ; OCE_mas_berg_icb = OCE_flux_int ( OCE_berg_icb    ) 
    506     OCE_calving_icb = rprec (d_OCE_his['calving_icb']       ) ; OCE_mas_calv_icb = OCE_flux_int ( OCE_calving_icb ) 
     508    OCE.OCE_berg_icb    = rprec (d_OCE_his['berg_floating_melt']) ; OCE.OCE_mas_berg_icb = OCE_flux_int ( OCE.OCE_berg_icb    ) 
     509    OCE.OCE_calving_icb = rprec (d_OCE_his['calving_icb']       ) ; OCE.OCE_mas_calv_icb = OCE_flux_int ( OCE.OCE_calving_icb ) 
    507510else : 
    508     OCE_berg_icb = 0. ; OCE_mas_berg_icb = 0. 
    509     OCE_calv_icb = 0. ; OCE_mas_calv_icb = 0. 
    510  
    511 OCE_mas_emp = OCE_mas_emp_oce - OCE_mas_wfxice - OCE_mas_wfxsnw - ICE_mas_wfxpnd - ICE_mas_wfxsub_err 
    512 OCE_mas_all = OCE_mas_emp_oce + OCE_mas_emp_ice - OCE_mas_runoffs - OCE_mas_iceshelf 
     511    OCE.OCE_berg_icb = 0. ; OCE.OCE_mas_berg_icb = 0. 
     512    OCE.OCE_calv_icb = 0. ; OCE.OCE_mas_calv_icb = 0. 
     513 
     514OCE.OCE_mas_emp = OCE.OCE_mas_emp_oce - OCE.OCE_mas_wfxice - OCE.OCE_mas_wfxsnw - OCE.ICE_mas_wfxpnd - OCE.ICE_mas_wfxsub_err 
     515OCE.OCE_mas_all = OCE.OCE_mas_emp_oce + OCE.OCE_mas_emp_ice - OCE.OCE_mas_runoffs - OCE.OCE_mas_iceshelf 
    513516 
    514517echo ('\n-- Fields:' ) 
    515 prtFlux ('OCE+ICE budget ', OCE_mas_all       , 'e', True) 
    516 prtFlux ('  EMPMR        ', OCE_mas_empmr     , 'e', True) 
    517 prtFlux ('  WFOB         ', OCE_mas_wfob      , 'e', True) 
    518 prtFlux ('  EMP_OCE      ', OCE_mas_emp_oce   , 'e', True) 
    519 prtFlux ('  EMP_ICE      ', OCE_mas_emp_ice   , 'e', True) 
    520 prtFlux ('  EMP          ', OCE_mas_emp       , 'e', True) 
    521 prtFlux ('  ICEBERG      ', OCE_mas_iceberg   , 'e', True) 
    522 prtFlux ('  ICESHELF     ', OCE_mas_iceshelf  , 'e', True) 
    523 prtFlux ('  CALVING      ', OCE_mas_calving   , 'e', True) 
    524 prtFlux ('  FRIVER       ', OCE_mas_friver    , 'e', True) 
    525 prtFlux ('  RUNOFFS      ', OCE_mas_runoffs   , 'e', True) 
    526 prtFlux ('  WFXICE       ', OCE_mas_wfxice    , 'e', True) 
    527 prtFlux ('  WFXSNW       ', OCE_mas_wfxsnw    , 'e', True) 
    528 prtFlux ('  WFXSUB       ', OCE_mas_wfxsub    , 'e', True) 
    529 prtFlux ('  WFXPND       ', ICE_mas_wfxpnd    , 'e', True) 
    530 prtFlux ('  WFXSNW_SUB   ', ICE_mas_wfxsnw_sub, 'e', True) 
    531 prtFlux ('  WFXSNW_PRE   ', ICE_mas_wfxsnw_pre, 'e', True) 
    532 prtFlux ('  WFXSUB_ERR   ', ICE_mas_wfxsub_err, 'e', True) 
    533 prtFlux ('  EVAP_OCE     ', OCE_mas_evap_oce  , 'e'      ) 
    534 prtFlux ('  EVAP_ICE     ', ICE_mas_evap_ice  , 'e', True) 
    535 prtFlux ('  SNOW_OCE     ', OCE_mas_snow_oce  , 'e', True) 
    536 prtFlux ('  SNOW_ICE     ', OCE_mas_snow_ice  , 'e', True) 
    537 prtFlux ('  RAIN         ', OCE_mas_rain      , 'e'      ) 
    538 prtFlux ('  FWB          ', OCE_mas_fwb       , 'e', True) 
    539 prtFlux ('  SSR          ', OCE_mas_ssr       , 'e', True) 
    540 prtFlux ('  WFCORR       ', OCE_mas_wfcorr    , 'e', True) 
    541 prtFlux ('  BERG_ICB     ', OCE_mas_berg_icb  , 'e', True) 
    542 prtFlux ('  CALV_ICB     ', OCE_mas_calv_icb  , 'e', True) 
     518prtFlux ('OCE+ICE budget ', OCE.OCE_mas_all       , 'e', True) 
     519prtFlux ('  EMPMR        ', OCE.OCE_mas_empmr     , 'e', True) 
     520prtFlux ('  WFOB         ', OCE.OCE_mas_wfob      , 'e', True) 
     521prtFlux ('  EMP_OCE      ', OCE.OCE_mas_emp_oce   , 'e', True) 
     522prtFlux ('  EMP_ICE      ', OCE.OCE_mas_emp_ice   , 'e', True) 
     523prtFlux ('  EMP          ', OCE.OCE_mas_emp       , 'e', True) 
     524prtFlux ('  ICEBERG      ', OCE.OCE_mas_iceberg   , 'e', True) 
     525prtFlux ('  ICESHELF     ', OCE.OCE_mas_iceshelf  , 'e', True) 
     526prtFlux ('  CALVING      ', OCE.OCE_mas_calving   , 'e', True) 
     527prtFlux ('  FRIVER       ', OCE.OCE_mas_friver    , 'e', True) 
     528prtFlux ('  RUNOFFS      ', OCE.OCE_mas_runoffs   , 'e', True) 
     529prtFlux ('  WFXICE       ', OCE.OCE_mas_wfxice    , 'e', True) 
     530prtFlux ('  WFXSNW       ', OCE.OCE_mas_wfxsnw    , 'e', True) 
     531prtFlux ('  WFXSUB       ', OCE.OCE_mas_wfxsub    , 'e', True) 
     532prtFlux ('  WFXPND       ', OCE.ICE_mas_wfxpnd    , 'e', True) 
     533prtFlux ('  WFXSNW_SUB   ', OCE.ICE_mas_wfxsnw_sub, 'e', True) 
     534prtFlux ('  WFXSNW_PRE   ', OCE.ICE_mas_wfxsnw_pre, 'e', True) 
     535prtFlux ('  WFXSUB_ERR   ', OCE.ICE_mas_wfxsub_err, 'e', True) 
     536prtFlux ('  EVAP_OCE     ', OCE.OCE_mas_evap_oce  , 'e'      ) 
     537prtFlux ('  EVAP_ICE     ', OCE.ICE_mas_evap_ice  , 'e', True) 
     538prtFlux ('  SNOW_OCE     ', OCE.OCE_mas_snow_oce  , 'e', True) 
     539prtFlux ('  SNOW_ICE     ', OCE.OCE_mas_snow_ice  , 'e', True) 
     540prtFlux ('  RAIN         ', OCE.OCE_mas_rain      , 'e'      ) 
     541prtFlux ('  FWB          ', OCE.OCE_mas_fwb       , 'e', True) 
     542prtFlux ('  SSR          ', OCE.OCE_mas_ssr       , 'e', True) 
     543prtFlux ('  WFCORR       ', OCE.OCE_mas_wfcorr    , 'e', True) 
     544prtFlux ('  BERG_ICB     ', OCE.OCE_mas_berg_icb  , 'e', True) 
     545prtFlux ('  CALV_ICB     ', OCE.OCE_mas_calv_icb  , 'e', True) 
    543546 
    544547echo (' ') 
    545548if Coupled : 
    546     prtFlux ( 'Bilan ocean :', -OCE_mas_emp_oce - OCE_mas_emp_ice + OCE_mas_runoffs + OCE_mas_iceshelf, 'e', True ) 
     549    prtFlux ( 'Bilan ocean :', -OCE.OCE_mas_emp_oce - OCE.OCE_mas_emp_ice + OCE.OCE_mas_runoffs + OCE.OCE_mas_iceshelf, 'e', True ) 
    547550else : 
    548     prtFlux ( 'Bilan ocean :', -OCE_mas_emp_oce - OCE_mas_emp_ice + OCE_mas_runoffs + OCE_mas_iceberg + OCE_mas_calving + OCE_mas_iceshelf, 'e', True ) 
     551    prtFlux ( 'Bilan ocean :', -OCE.OCE_mas_emp_oce - OCE.OCE_mas_emp_ice + OCE.OCE_mas_runoffs + OCE.OCE_mas_iceberg + OCE.OCE_mas_calving + OCE.OCE_mas_iceshelf, 'e', True ) 
    549552 
    550553 
    551554echo     ('\n===>  Comparing ===>' ) 
    552 echo     ('  WFX OCE                     = -empmr + iceshelf                                            = {:12.5e} (kg) '.format ( -OCE_mas_empmr + OCE_mas_iceshelf) ) 
    553 echo     ('     versus d OCE                                                                            = {:12.5e} (kg) '.format ( dOCE_mas_wat) ) 
    554 echo     ('  WFX ICE+SNW+PND 1           = emp_ice - wfxice - wfxsnw - wfxpnd - wfxsub_err              = {:12.5e} (kg) '.format ( -OCE_mas_emp_ice - OCE_mas_wfxice - OCE_mas_wfxsnw - ICE_mas_wfxpnd - ICE_mas_wfxsub_err) ) 
    555 echo     ('  WFX ICE+SNW+PND 2           = -emp_ice + empmr - emp_oce + runoffs                         = {:12.5e} (kg) '.format ( -OCE_mas_emp_ice + OCE_mas_empmr - OCE_mas_emp_oce + OCE_mas_runoffs )) 
    556 echo     ('     versus d ICE+SNW+PND                                                                    = {:12.5e} (kg) '.format ( dICE_mas_wat))  # Manque PND ? 
     555echo     ('  WFX OCE                     = -empmr + iceshelf                                            = {:12.5e} (kg) '.format ( -OCE.OCE_mas_empmr + OCE.OCE_mas_iceshelf) ) 
     556echo     ('     versus d OCE                                                                            = {:12.5e} (kg) '.format ( OCE.OCE_diff_mas_wat) ) 
     557echo     ('  WFX ICE+SNW+PND 1           = emp_ice - wfxice - wfxsnw - wfxpnd - wfxsub_err              = {:12.5e} (kg) '.format ( -OCE.OCE_mas_emp_ice - OCE.OCE_mas_wfxice - OCE.OCE_mas_wfxsnw - OCE.ICE_mas_wfxpnd - OCE.ICE_mas_wfxsub_err) ) 
     558echo     ('  WFX ICE+SNW+PND 2           = -emp_ice + empmr - emp_oce + runoffs                         = {:12.5e} (kg) '.format ( -OCE.OCE_mas_emp_ice + OCE.OCE_mas_empmr - OCE.OCE_mas_emp_oce + OCE.OCE_mas_runoffs )) 
     559echo     ('     versus d ICE+SNW+PND                                                                    = {:12.5e} (kg) '.format ( OCE.ICE_diff_mas_wat))  # Manque PND ? 
    557560if Coupled : 
    558     echo ('  WFX OCE+ICE+SNW+PND         = -emp_oce - emp_ice + runoffs + iceshelf                      = {:12.5e} (kg) '.format ( -OCE_mas_emp_oce - OCE_mas_emp_ice + OCE_mas_runoffs + OCE_mas_iceshelf)) 
     561    echo ('  WFX OCE+ICE+SNW+PND         = -emp_oce - emp_ice + runoffs + iceshelf                      = {:12.5e} (kg) '.format ( -OCE.OCE_mas_emp_oce - OCE.OCE_mas_emp_ice + OCE.OCE_mas_runoffs + OCE.OCE_mas_iceshelf)) 
    559562else : 
    560     echo ('  WFX OCE+ICE+SNW+PND         = -emp_oce - emp_ice + runoffs + iceberg + calving + iceshelf  = {:12.5e} (kg) '.format ( -OCE_mas_emp_oce - OCE_mas_emp_ice + OCE_mas_runoffs + OCE_mas_iceberg + OCE_mas_calving + OCE_mas_iceshelf)) 
    561 echo     ('     versus d OCE+ICE+SNW+PND                                                                = {:12.5e} (kg) '.format ( dSEA_mas_wat  )) # Manque PND 
     563    echo ('  WFX OCE+ICE+SNW+PND         = -emp_oce - emp_ice + runoffs + iceberg + calving + iceshelf  = {:12.5e} (kg) '.format ( -OCE.OCE_mas_emp_oce - OCE.OCE_mas_emp_ice + OCE.OCE_mas_runoffs + OCE.OCE_mas_iceberg + OCE.OCE_mas_calving + OCE.OCE_mas_iceshelf)) 
     564echo     ('     versus d OCE+ICE+SNW+PND                                                                = {:12.5e} (kg) '.format ( OCE.OCE_diff_SEA_mas_wat  )) # Manque PND 
    562565 
    563566echo ('\n===> Leaks ===>') 
    564 echo ('   Leak OCE             = dOCE_mas_wat + empmr - iceshelf                                                 = {:12.3e} (kg) '.format ( dOCE_mas_wat + OCE_mas_empmr - OCE_mas_iceshelf) ) 
    565 echo ('                        = (dOCE_mas_wat + empmr - iceshelf)/abs(dOCE_mas_wat)                             = {:12.1e} (-)  '.format ( (dOCE_mas_wat + OCE_mas_empmr - OCE_mas_iceshelf )  / abs (dOCE_mas_wat)  ) ) 
    566 echo ('   Leak ICE+SNW+PND 1   = dICE_mas_wat + emp_ice + wfxice + wfxsnw + wfxpnd + wfxsub_err                  = {:12.3e} (kg) '.format ( dICE_mas_wat + OCE_mas_emp_ice + OCE_mas_wfxice + OCE_mas_wfxsnw + ICE_mas_wfxpnd + ICE_mas_wfxsub_err ) ) 
    567 echo ('                        = (dICE_mas_wat + emp_ice + wfxice + wfxsnw + wfxpnd + wfxsub_err )/dICE_mas_wat  = {:12.1e} (-)  '.format ( (dICE_mas_wat + OCE_mas_emp_ice + OCE_mas_wfxice + OCE_mas_wfxsnw + ICE_mas_wfxpnd + ICE_mas_wfxsub_err)/abs(dICE_mas_wat)) ) 
    568 echo ('   Leak ICE+SNW+PND 2   = dICE_mas_wat + emp_ice - empmr + emp_oce - runoffs                              = {:12.3e} (kg) '.format ( dICE_mas_wat + OCE_mas_emp_ice - OCE_mas_empmr + OCE_mas_emp_oce - OCE_mas_runoffs )) 
    569 echo ('                        = (dICE_mas_wat - empmr  + emp_oce - runoffs)/abs(dICE_mas_wat)                   = {:12.1e} (-)  '.format ( (dICE_mas_wat - OCE_mas_empmr  + OCE_mas_emp_oce - OCE_mas_runoffs)/abs(dICE_mas_wat)) ) 
    570 echo ('   Leak OCE+ICE+SNW+PND =  d(ICE+OCE)_mas_wat + emp_oce + emp_ice - runoffs - iceshelf                    = {:12.3e} (kg) '.format ( dSEA_mas_wat + OCE_mas_emp_oce +OCE_mas_emp_ice - OCE_mas_runoffs - OCE_mas_iceshelf )) 
    571 echo ('                        = (dSEA_mas_wat + emp_oce + emp_ice - runoffs - iceshelf)*/abs(dSEA_mas_wat)      = {:12.1e} (-)  '.format ( (dSEA_mas_wat + OCE_mas_emp_oce + OCE_mas_emp_ice - OCE_mas_runoffs - OCE_mas_iceshelf)/abs(dSEA_mas_wat) ) ) 
    572  
    573 prtFlux ('   Leak OCE             ', ( dOCE_mas_wat + OCE_mas_empmr - OCE_mas_iceshelf) , 'e', True ) 
    574 prtFlux ('   Leak ICE+SNW+PND     ', ( dICE_mas_wat + OCE_mas_emp_ice + OCE_mas_wfxice + OCE_mas_wfxsnw + ICE_mas_wfxpnd + ICE_mas_wfxsub_err ) , 'e', True ) 
    575 prtFlux ('   Leak OCE+ICE+SNW+PND ',  ( dSEA_mas_wat + OCE_mas_emp_oce +OCE_mas_emp_ice - OCE_mas_runoffs - OCE_mas_iceshelf ) , 'e', True ) 
     567echo ('   Leak OCE             = OCE.OCE_diff_mas_wat + empmr - iceshelf                                                 = {:12.3e} (kg) '.format ( OCE.OCE_diff_mas_wat + OCE.OCE_mas_empmr - OCE.OCE_mas_iceshelf) ) 
     568echo ('                        = (OCE.OCE_diff_mas_wat + empmr - iceshelf)/abs(OCE.OCE_diff_mas_wat)                             = {:12.1e} (-)  '.format ( (OCE.OCE_diff_mas_wat + OCE.OCE_mas_empmr - OCE.OCE_mas_iceshelf )  / abs (OCE.OCE_diff_mas_wat)  ) ) 
     569echo ('   Leak ICE+SNW+PND 1   = OCE.ICE_diff_mas_wat + emp_ice + wfxice + wfxsnw + wfxpnd + wfxsub_err                  = {:12.3e} (kg) '.format ( OCE.ICE_diff_mas_wat + OCE.OCE_mas_emp_ice + OCE.OCE_mas_wfxice + OCE.OCE_mas_wfxsnw + OCE.ICE_mas_wfxpnd + OCE.ICE_mas_wfxsub_err ) ) 
     570echo ('                        = (OCE.ICE_diff_mas_wat + emp_ice + wfxice + wfxsnw + wfxpnd + wfxsub_err )/OCE.ICE_diff_mas_wat  = {:12.1e} (-)  '.format ( (OCE.ICE_diff_mas_wat + OCE.OCE_mas_emp_ice + OCE.OCE_mas_wfxice + OCE.OCE_mas_wfxsnw + OCE.ICE_mas_wfxpnd + OCE.ICE_mas_wfxsub_err)/abs(OCE.ICE_diff_mas_wat)) ) 
     571echo ('   Leak ICE+SNW+PND 2   = OCE.ICE_diff_mas_wat + emp_ice - empmr + emp_oce - runoffs                              = {:12.3e} (kg) '.format ( OCE.ICE_diff_mas_wat + OCE.OCE_mas_emp_ice - OCE.OCE_mas_empmr + OCE.OCE_mas_emp_oce - OCE.OCE_mas_runoffs )) 
     572echo ('                        = (OCE.ICE_diff_mas_wat - empmr  + emp_oce - runoffs)/abs(OCE.ICE_diff_mas_wat)                   = {:12.1e} (-)  '.format ( (OCE.ICE_diff_mas_wat - OCE.OCE_mas_empmr  + OCE.OCE_mas_emp_oce - OCE.OCE_mas_runoffs)/abs(OCE.ICE_diff_mas_wat)) ) 
     573echo ('   Leak OCE+ICE+SNW+PND =  d(ICE+OCE)_mas_wat + emp_oce + emp_ice - runoffs - iceshelf                    = {:12.3e} (kg) '.format ( OCE.OCE_diff_SEA_mas_wat + OCE.OCE_mas_emp_oce +OCE.OCE_mas_emp_ice - OCE.OCE_mas_runoffs - OCE.OCE_mas_iceshelf )) 
     574echo ('                        = (OCE.OCE_diff_SEA_mas_wat + emp_oce + emp_ice - runoffs - iceshelf)*/abs(OCE.OCE_diff_SEA_mas_wat)      = {:12.1e} (-)  '.format ( (OCE.OCE_diff_SEA_mas_wat + OCE.OCE_mas_emp_oce + OCE.OCE_mas_emp_ice - OCE.OCE_mas_runoffs - OCE.OCE_mas_iceshelf)/abs(OCE.OCE_diff_SEA_mas_wat) ) ) 
     575 
     576prtFlux ('   Leak OCE             ', ( OCE.OCE_diff_mas_wat + OCE.OCE_mas_empmr - OCE.OCE_mas_iceshelf) , 'e', True ) 
     577prtFlux ('   Leak ICE+SNW+PND     ', ( OCE.ICE_diff_mas_wat + OCE.OCE_mas_emp_ice + OCE.OCE_mas_wfxice + OCE.OCE_mas_wfxsnw + OCE.ICE_mas_wfxpnd + OCE.ICE_mas_wfxsub_err ) , 'e', True ) 
     578prtFlux ('   Leak OCE+ICE+SNW+PND ',  ( OCE.OCE_diff_SEA_mas_wat + OCE.OCE_mas_emp_oce +OCE.OCE_mas_emp_ice - OCE.OCE_mas_runoffs - OCE.OCE_mas_iceshelf ) , 'e', True ) 
    576579 
    577580# check if emp     = emp_ice + emp_oce - calving 
    … …  
    579582 
    580583echo     ('\n===> Checks ===>' ) 
    581 echo     ('   Check EMPMR           = empmr - emp_oce + runoffs + wfxice + wfxsnw + wfxpnd + wfxsub_err = {:12.5e} (kg) '.format ( OCE_mas_empmr - OCE_mas_emp_oce + OCE_mas_runoffs + OCE_mas_wfxice + OCE_mas_wfxsnw + ICE_mas_wfxpnd + ICE_mas_wfxsub_err )) 
     584echo     ('   Check EMPMR           = empmr - emp_oce + runoffs + wfxice + wfxsnw + wfxpnd + wfxsub_err = {:12.5e} (kg) '.format ( OCE.OCE_mas_empmr - OCE.OCE_mas_emp_oce + OCE.OCE_mas_runoffs + OCE.OCE_mas_wfxice + OCE.OCE_mas_wfxsnw + OCE.ICE_mas_wfxpnd + OCE.ICE_mas_wfxsub_err )) 
    582585if Coupled : 
    583     echo ('   Check EMP_OCE         = emp_oce + fwb + ssr - evap_oce + rain + snow_oce + calving        = {:12.5e} (kg) '.format ( OCE_mas_emp_oce + OCE_mas_fwb + OCE_mas_ssr - OCE_mas_evap_oce + OCE_mas_rain + OCE_mas_snow_oce + OCE_mas_calving )) 
     586    echo ('   Check EMP_OCE         = emp_oce + fwb + ssr - evap_oce + rain + snow_oce + calving        = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce + OCE.OCE_mas_fwb + OCE.OCE_mas_ssr - OCE.OCE_mas_evap_oce + OCE.OCE_mas_rain + OCE.OCE_mas_snow_oce + OCE.OCE_mas_calving )) 
    584587else : 
    585     echo ('   Check EMP_OCE         = emp_oce + ssr + fwb - evap_oce + rain + snow_oce                  = {:12.5e} (kg) '.format ( OCE_mas_emp_oce + OCE_mas_ssr + OCE_mas_fwb - OCE_mas_evap_oce + OCE_mas_rain + OCE_mas_snow_oce )) 
    586 echo     ('   Check EMP_ICE         = emp_ice - evap_ice + snow_ice                                     = {:12.5e} (kg) '.format ( OCE_mas_emp_ice - ICE_mas_evap_ice + OCE_mas_snow_ice )) 
    587 echo     ('   Check EMP_ICE vs WFX  = emp_ice - wfxsub - wfxsnw_sub - wfxsnw_pre + wfxsub_err           = {:12.5e} (kg) '.format ( OCE_mas_emp_ice - OCE_mas_wfxsub - ICE_mas_wfxsnw_sub - ICE_mas_wfxsnw_pre + ICE_mas_wfxsub_err )) 
     588    echo ('   Check EMP_OCE         = emp_oce + ssr + fwb - evap_oce + rain + snow_oce                  = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce + OCE.OCE_mas_ssr + OCE.OCE_mas_fwb - OCE.OCE_mas_evap_oce + OCE.OCE_mas_rain + OCE.OCE_mas_snow_oce )) 
     589echo     ('   Check EMP_ICE         = emp_ice - evap_ice + snow_ice                                     = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_ice - OCE.ICE_mas_evap_ice + OCE.OCE_mas_snow_ice )) 
     590echo     ('   Check EMP_ICE vs WFX  = emp_ice - wfxsub - wfxsnw_sub - wfxsnw_pre + wfxsub_err           = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_ice - OCE.OCE_mas_wfxsub - OCE.ICE_mas_wfxsnw_sub - OCE.ICE_mas_wfxsnw_pre + OCE.ICE_mas_wfxsub_err )) 
    588591 
    589592echo ( '\n------------------------------------------------------------------------------------' ) 
    590593echo ( '-- Computations in the PDF note of Clément Rousset') 
    591 echo ( 'Freshwater budget of the ice-ocean system          = emp_oce + emp_ice - runoffs - iceberg - iceshelf                = {:12.5e} (kg) '.format ( OCE_mas_emp_oce + OCE_mas_emp_ice - OCE_mas_runoffs - OCE_mas_iceberg - OCE_mas_iceshelf )) 
    592 echo ( 'Freshwater budget of the ice-ocean system          = emp_oce + emp_ice - friver  - iceberg - iceshelf                = {:12.5e} (kg) '.format ( OCE_mas_emp_oce + OCE_mas_emp_ice - OCE_mas_friver  - OCE_mas_iceberg - OCE_mas_iceshelf )) 
    593 echo ( 'Freshwater budget in the ocean = ocean mass change = emp_oce - vfxice - ( vfxsnw + vfxsub_err ) - runoffs - iceshelf = {:12.5e} (kg) '.format ( OCE_mas_emp_oce - OCE_mas_wfxice - ( OCE_mas_wfxsnw + ICE_mas_wfxsub_err ) - OCE_mas_runoffs - OCE_mas_iceshelf )) 
    594 echo ( 'Freshwater budget in the ocean = ocean mass change = emp_oce - vfxice - ( vfxsnw + vfxsub_err ) - friver  - iceshelf = {:12.5e} (kg) '.format ( OCE_mas_emp_oce - OCE_mas_wfxice - ( OCE_mas_wfxsnw + ICE_mas_wfxsub_err ) - OCE_mas_friver  - OCE_mas_iceshelf )) 
    595 echo ( 'Freshwater budget in the ice = ice mass change     = vfxice + ( vfxsnw + vfxsub + vfxspr )                           = {:12.5e} (kg) '.format ( OCE_mas_wfxice  + OCE_mas_wfxsnw + OCE_mas_wfxsub + ICE_mas_wfxsnw_pre )) 
    596 echo ( 'Freshwater flux at the interface [ice/snow]-ocean  = vfxice + ( vfxsnw + vfxsub_err )                                = {:12.5e} (kg) '.format ( OCE_mas_wfxsub  + ICE_mas_wfxsnw_pre )) 
    597 echo ( 'Freshwater flux at the interface [ice/snow]-atm    = ( vfxsub + vfxspr )                                             = {:12.5e} (kg) '.format ( OCE_mas_emp_ice + ICE_mas_wfxsub_err )) 
    598 echo ( 'Freshwater flux at the interface [ice/snow]-atm    = emp_ice + vfxsub_err                                            = {:12.5e} (kg) '.format ( OCE_mas_emp_ice + ICE_mas_wfxsub_err )) 
    599 echo ( 'Freshwater flux at the interface ocean-atm         = emp_oce + calving - vfxsub_err                                  = {:12.5e} (kg) '.format ( OCE_mas_emp_oce + OCE_mas_calving - ICE_mas_wfxsub_err )) 
     594echo ( 'Freshwater budget of the ice-ocean system          = emp_oce + emp_ice - runoffs - iceberg - iceshelf                = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce + OCE.OCE_mas_emp_ice - OCE.OCE_mas_runoffs - OCE.OCE_mas_iceberg - OCE.OCE_mas_iceshelf )) 
     595echo ( 'Freshwater budget of the ice-ocean system          = emp_oce + emp_ice - friver  - iceberg - iceshelf                = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce + OCE.OCE_mas_emp_ice - OCE.OCE_mas_friver  - OCE.OCE_mas_iceberg - OCE.OCE_mas_iceshelf )) 
     596echo ( 'Freshwater budget in the ocean = ocean mass change = emp_oce - vfxice - ( vfxsnw + vfxsub_err ) - runoffs - iceshelf = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce - OCE.OCE_mas_wfxice - ( OCE.OCE_mas_wfxsnw + OCE.ICE_mas_wfxsub_err ) - OCE.OCE_mas_runoffs - OCE.OCE_mas_iceshelf )) 
     597echo ( 'Freshwater budget in the ocean = ocean mass change = emp_oce - vfxice - ( vfxsnw + vfxsub_err ) - friver  - iceshelf = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce - OCE.OCE_mas_wfxice - ( OCE.OCE_mas_wfxsnw + OCE.ICE_mas_wfxsub_err ) - OCE.OCE_mas_friver  - OCE.OCE_mas_iceshelf )) 
     598echo ( 'Freshwater budget in the ice = ice mass change     = vfxice + ( vfxsnw + vfxsub + vfxspr )                           = {:12.5e} (kg) '.format ( OCE.OCE_mas_wfxice  + OCE.OCE_mas_wfxsnw + OCE.OCE_mas_wfxsub + OCE.ICE_mas_wfxsnw_pre )) 
     599echo ( 'Freshwater flux at the interface [ice/snow]-ocean  = vfxice + ( vfxsnw + vfxsub_err )                                = {:12.5e} (kg) '.format ( OCE.OCE_mas_wfxsub  + OCE.ICE_mas_wfxsnw_pre )) 
     600echo ( 'Freshwater flux at the interface [ice/snow]-atm    = ( vfxsub + vfxspr )                                             = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_ice + OCE.ICE_mas_wfxsub_err )) 
     601echo ( 'Freshwater flux at the interface [ice/snow]-atm    = emp_ice + vfxsub_err                                            = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_ice + OCE.ICE_mas_wfxsub_err )) 
     602echo ( 'Freshwater flux at the interface ocean-atm         = emp_oce + calving - vfxsub_err                                  = {:12.5e} (kg) '.format ( OCE.OCE_mas_emp_oce + OCE.OCE_mas_calving - OCE.ICE_mas_wfxsub_err )) 
    600603 
    601604echo ( "scsshtot   : global_average_sea_level_change                            = {:12.3e} (m) ".format ( np.sum (d_OCE_sca['scsshtot']  ).values  ) ) 
    602 echo ( "scsshtot   : global_average_sea_level_change                            = {:12.3e} (kg)".format ( np.sum (d_OCE_sca['scsshtot']  ).values  * OCE_aire_tot*OCE_RHO_LIQ  ) ) 
     605echo ( "scsshtot   : global_average_sea_level_change                            = {:12.3e} (kg)".format ( np.sum (d_OCE_sca['scsshtot']  ).values  * OCE.OCE_aire_tot*OCE_RHO_LIQ  ) ) 
    603606echo ( "bgvolssh   : drift in global mean ssh volume wrt timestep 1             = {:12.3e} (kg)".format ( np.sum (d_OCE_sca['bgvolssh']  ).values  * 1e9 * OCE_RHO_LIQ  ) ) 
    604607echo ( "bgvole3t   : drift in global mean volume variation (e3t) wrt timestep 1 = {:12.3e} (kg)".format ( np.sum (d_OCE_sca['bgvole3t']  ).values  * 1e9 * OCE_RHO_LIQ  ) ) 

  • TOOLS/WATER_BUDGET/WaterUtils.py

    r6676 r6688  
    1313  software by incorrectly or partially configured personal 
    1414 
    15  
    1615 SVN information 
    1716 $Author$ 
    … …  
    2221''' 
    2322 
    24 import os, sys 
     23import os, sys, types 
    2524import functools 
    2625import time 
    2726import configparser, re 
    2827import numpy as np 
    29 import libIGCM_sys 
     28import xarray as xr 
     29import libIGCM_sys, libIGCM_date as ldate 
     30import nemo 
     31import lmdz 
    3032 
    3133def ReadConfig ( ini_file, default_ini_file='defaults.ini' ) : 
    … …  
    3638    Reads <ini_file> config file to set all experiment parameters 
    3739    Reads config.card files if specified in <ini_file> 
    38      
     40 
     41    Returns a dictionary with all parameters 
    3942    ''' 
    4043    ## Read file with defaults values 
    … …  
    6669            config = configparser.ConfigParser (interpolation=configparser.ExtendedInterpolation() ) 
    6770            config.optionxform = str # To keep capitals 
    68              
    6971            config.read (ConfigCard) 
    7072             
    7173            for VarName in ['JobName', 'ExperimentName', 'SpaceName', 'LongName', 'ModelName', 'TagName', 
    72                             'ORCA_version', 'ExpType', 'PeriodLength', 'ResolAtm', 'ResolOce' ] : 
     74                            'ORCA_version', 'ExpType', 'PeriodLength', 'ResolAtm', 'ResolOce', 'CalendarType' ] : 
    7375                if VarName in config['UserChoices'].keys() : 
    74                     exp_params['Experiment'][VarName] = str2value ( config['UserChoices'][VarName] ) 
     76                    exp_params['Experiment'][VarName] = config['UserChoices'][VarName] 
    7577                     
    7678            if 'Post' in config.sections() : 
    … …  
    98100    ## ---------------------------------------- 
    99101    pdict['Experiment']['ICO']  = 'ICO' in pdict['Experiment']['ResolAtm'] 
    100     pdict['Experiment']['LMDZ'] = 'LMD' in pdict['Experiment']['ResolAtm'] 
    101  
    102     mm = libIGCM_sys.config ( TagName       = pdict['Experiment']['TagName'], 
    103                               SpaceName     = pdict['Experiment']['SpaceName'], 
    104                               ExperimentName= pdict['Experiment']['ExperimentName'], 
    105                               JobName       = pdict['Experiment']['JobName'], 
    106                               User          = pdict['Experiment']['User'], 
    107                               Group         = pdict['Experiment']['Group'], 
    108                               ARCHIVE       = pdict['libIGCM']['ARCHIVE'], 
    109                               SCRATCHDIR    = pdict['libIGCM']['SCRATCHDIR'], 
    110                               STORAGE       = pdict['libIGCM']['STORAGE'], 
    111                               R_IN          = pdict['libIGCM']['R_IN'], 
    112                               R_OUT         = pdict['libIGCM']['R_OUT'], 
    113                               R_FIG         = pdict['libIGCM']['R_FIG'], 
    114                               TmpDir        = pdict['Files']['TmpDir'], 
    115                               R_SAVE        = pdict['libIGCM']['R_SAVE'], 
    116                               R_FIGR        = pdict['libIGCM']['R_FIGR'], 
    117                               R_BUFR        = pdict['libIGCM']['R_BUFR'], 
    118                               R_BUF_KSH     = pdict['libIGCM']['R_BUF_KSH'], 
    119                               POST_DIR      = pdict['libIGCM']['POST_DIR'], 
    120                               L_EXP         = pdict['libIGCM']['L_EXP'] ) 
    121  
    122      
    123     pdict['Files']['TmpDir'] =  mm['TmpDir'] 
    124      
    125     for key in mm.keys() : 
    126         pdict['libIGCM'][key] = mm[key] 
     102    #pdict['Experiment']['LMDZ'] = 'LMD' in pdict['Experiment']['ResolAtm'] 
     103    pdict['Experiment']['LMDZ'] = not pdict['Experiment']['ICO'] 
     104 
     105    mm = libIGCM_sys.config ( 
     106        JobName        = pdict['Experiment']['JobName'], 
     107        ExperimentName = pdict['Experiment']['ExperimentName'], 
     108        TagName        = pdict['Experiment']['TagName'], 
     109        SpaceName      = pdict['Experiment']['SpaceName'], 
     110        User           = pdict['Experiment']['User'], 
     111        Group          = pdict['Experiment']['Group'], 
     112        TmpDir         = pdict['Files']['TmpDir'], 
     113        ARCHIVE        = pdict['libIGCM']['ARCHIVE'], 
     114        SCRATCHDIR     = pdict['libIGCM']['SCRATCHDIR'], 
     115        STORAGE        = pdict['libIGCM']['STORAGE'], 
     116        R_IN           = pdict['libIGCM']['R_IN'], 
     117        R_OUT          = pdict['libIGCM']['R_OUT'], 
     118        R_FIG          = pdict['libIGCM']['R_FIG'], 
     119        R_SAVE         = pdict['libIGCM']['R_SAVE'], 
     120        R_FIGR         = pdict['libIGCM']['R_FIGR'], 
     121        R_BUFR         = pdict['libIGCM']['R_BUFR'], 
     122        R_BUF_KSH      = pdict['libIGCM']['R_BUF_KSH'], 
     123        POST_DIR       = pdict['libIGCM']['POST_DIR'], 
     124        L_EXP          = pdict['libIGCM']['L_EXP'] 
     125        ) 
     126     
     127    pdict['Files']['TmpDir'] = mm['TmpDir'] 
     128    pdict['libIGCM'].update (mm) 
    127129         
    128130    ## Complete configuration 
    … …  
    160162        pdict['Experiment']['DateBegin'] = f"{pdict['Experiment']['YearBegin']}0101" 
    161163    else : 
    162         YearBegin, MonthBegin, DayBegin = SplitDate ( pdict['Experiment']['DateBegin'] ) 
     164        YearBegin, MonthBegin, DayBegin = ldate.GetYearMonthDay ( pdict['Experiment']['DateBegin'] ) 
    163165        DateBegin = FormatToGregorian (pdict['Experiment']['DateBegin']) 
    164166        pdict['Experiment']['YearBegin'] = YearBegin 
    … …  
    167169        pdict['Experiment']['DateEnd'] = f"{pdict['Experiment']['YearEnd']}1231" 
    168170    else : 
    169         YearEnd, MonthEnd, DayEnd = SplitDate ( pdict['Experiment']['DateEnd'] ) 
     171        YearEnd, MonthEnd, DayEnd = ldate.GetYearMonthDay ( pdict['Experiment']['DateEnd'] ) 
    170172        DateEnd   = FormatToGregorian (pdict['Experiment']['DateEnd']) 
    171173        pdict['Experiment']['DateEnd'] = DateEnd 
    172174         
    173175    if not pdict['Experiment']['PackFrequency'] : 
    174         PackFrequencypdict['Experiment']['PackFrequency'] = YearEnd - YearBegin + 1 
    175          
    176     if isinstance ( pdict['Experiment']['PackFrequency'], str ) : 
    177         if 'Y' in pdict['Experiment']['PackFrequency'] : 
    178             zPackFrequency = pdict['Experiment']['PackFrequency'].replace ( 'Y', '') 
    179             pdict['Experiment']['PackFrequency'] = f'{zPackFrequency}Y' 
    180             pdict['Experiment']['zPackFrequency'] = int (zPackFrequency) 
    181         if 'M' in pdict['Experiment']['PackFrequency'] : 
    182             zPackFrequency = pdict['Experiment']['PackFrequency'].replace ( 'M', '') 
    183             pdict['Experiment']['PackFrequency'] = f'{zPackFrequency}M' 
    184             pdict['Experiment']['zPackFrequency'] = int (zPackFrequency) 
     176        PackFrequencypdict['Experiment']['PackFrequency'] = f"{YearEnd - YearBegin + 1}YE" 
     177    
    185178 
    186179    ## Set directory to extract files 
    … …  
    205198 
    206199    echo (' ', f_out) 
    207     echo ( f"JobName     : {pdict['Experiment']['JobName']}" , f_out=f_out ) 
    208     echo ( f"Comment     : {pdict['Experiment']['Comment']}" , f_out=f_out ) 
    209     echo ( f"TmpDir      : {pdict['Files']['TmpDir']}"       , f_out=f_out ) 
    210     echo ( f"FileDir     : {pdict['Files']['FileDir']}"      , f_out=f_out ) 
     200    echo ( f"JobName : {pdict['Experiment']['JobName']}" , f_out=f_out ) 
     201    echo ( f"Comment : {pdict['Experiment']['Comment']}" , f_out=f_out ) 
     202    echo ( f"TmpDir  : {pdict['Files']['TmpDir']}"       , f_out=f_out ) 
     203    echo ( f"FileDir : {pdict['Files']['FileDir']}"      , f_out=f_out ) 
    211204     
    212205    echo ( f"\nDealing with {pdict['libIGCM']['L_EXP']}", f_out ) 
    … …  
    235228    echo ( f"{pdict['Files']['dir_OCE_his'] = }" , f_out ) 
    236229    echo ( f"{pdict['Files']['dir_ICE_his'] = }" , f_out ) 
    237  
    238230     
    239231    ## Creates files names 
    … …  
    265257            pdict['Files']['file_SRF_his'] = os.path.join ( pdict['Files']['dir_SRF_his'], f"{pdict['Files']['FileCommon']}_sechiba_history_ico.nc" ) 
    266258         
    267     if pdict['Experiment']['SRF'] and pdict['Experiment']['Routing'] == 'SIMPLE' : 
     259    if pdict['Experiment']['SECHIBA'] and pdict['Experiment']['Routing'] == 'SIMPLE' : 
    268260        if not pdict['Files']['file_RUN_his'] : 
    269261            if pdict['Experiment']['RUN_HIS'] == 'latlon' : 
    … …  
    273265             
    274266    echo ( f"{pdict['Files']['file_ATM_his'] = }", f_out ) 
    275     if pdict['Experiment']['SRF'] : 
     267    if pdict['Experiment']['SECHIBA'] : 
    276268        echo ( f"{pdict['Files']['file_SRF_his'] = }", f_out ) 
    277269        if pdict['Experiment']['Routing'] == 'SIMPLE' : echo ( f"{pdict['Files']['file_RUN_his'] = }", f_out ) 
    278  
    279270 
    280271    if not pdict['Files']['file_OCE_his'] : 
    … …  
    290281 
    291282def SetRestartNames ( pdict, f_out) : 
    292     zdict = pdict 
    293     if not zdict['Files']['TarRestartDate_beg'] : 
    294         zdict['Files']['TarRestartDate_beg'] = DateMinusOneDay ( zdict['Experiment']['DateBegin'] ) 
    295     if not zdict['Files']['TarRestartDate_end'] : 
    296         zdict['Files']['TarRestartDate_end'] = FormatToGregorian ( zdict['Experiment']['DateEnd'] ) 
    297      
    298     if not zdict['Files']['TarRestartPeriod_beg'] : 
    299          
    300         zdict['Files']['TarRestartPeriod_beg_DateEnd'] = zdict['Files']['TarRestartDate_beg'] 
    301         zdict['Files']['TarRestartPeriod_beg_DateBeg'] = DateAddYear ( zdict['Files']['TarRestartPeriod_beg_DateEnd'], -zdict['Experiment']['zPackFrequency'] ) 
    302         zdict['Files']['TarRestartPeriod_beg_DateBeg'] = DatePlusOneDay ( zdict['Files']['TarRestartPeriod_beg_DateBeg'] ) 
    303          
    304         zdict['Files']['TarRestartPeriod_beg'] = f"{zdict['Files']['TarRestartPeriod_beg_DateBeg']}_{zdict['Files']['TarRestartPeriod_beg_DateEnd']}" 
    305         echo ( f"Tar period for initial restart : {zdict['Files']['TarRestartPeriod_beg']}", f_out) 
    306          
    307     if not zdict['Files']['TarRestartPeriod_end'] : 
    308  
    309         zdict['Files']['TarRestartPeriod_end_DateEnd'] = zdict['Files']['TarRestartDate_end'] 
    310         zdict['Files']['TarRestartPeriod_end_DateBeg'] = DateAddYear ( zdict['Files']['TarRestartPeriod_end_DateEnd'], -zdict['Experiment']['zPackFrequency'] ) 
    311         zdict['Files']['TarRestartPeriod_end_DateBeg'] = DatePlusOneDay ( zdict['Files']['TarRestartPeriod_end_DateBeg']) 
    312          
    313         zdict['Files']['TarRestartPeriod_end'] = f"{zdict['Files']['TarRestartPeriod_end_DateBeg']}_{zdict['Files']['TarRestartPeriod_end_DateEnd']}" 
    314         echo ( f"Tar period for final restart : {zdict['Files']['TarRestartPeriod_end']}", f_out ) 
    315          
    316     echo ( f"Restart dates - Start : {zdict['Files']['TarRestartPeriod_beg']}  /  End : {zdict['Files']['TarRestartPeriod_end']}", f_out) 
    317          
    318     if not zdict['Files']['tar_restart_beg'] : 
    319         zdict['Files']['tar_restart_beg'] = os.path.join ( zdict['libIGCM']['R_SAVE'], 'RESTART', f"{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartPeriod_beg']}_restart.tar" ) 
    320     if not  zdict['Files']['tar_restart_end'] : 
    321         zdict['Files']['tar_restart_end'] = os.path.join ( zdict['libIGCM']['R_SAVE'], 'RESTART', f"{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartPeriod_end']}_restart.tar" ) 
    322          
    323     echo ( f"{ zdict['Files']['tar_restart_beg'] = }", f_out ) 
    324     echo ( f"{ zdict['Files']['tar_restart_end'] = }", f_out ) 
     283    ''' 
     284    Defines dates for restart files 
     285    Define names of tar files with restart 
     286 
     287    Returns a dictionary 
     288    ''' 
     289     
     290    if not pdict['Files']['TarRestartDate_beg'] : 
     291        pdict['Files']['TarRestartDate_beg'] = ldate.SubOneDayToDate ( pdict['Experiment']['DateBegin'], pdict['Experiment']['CalendarType'] ) 
     292    if not pdict['Files']['TarRestartDate_end'] : 
     293        pdict['Files']['TarRestartDate_end'] = ldate.ConvertFormatToGregorian ( pdict['Experiment']['DateEnd'] ) 
     294     
     295    if not pdict['Files']['TarRestartPeriod_beg'] : 
     296         
     297        pdict['Files']['TarRestartPeriod_beg_DateEnd'] = pdict['Files']['TarRestartDate_beg'] 
     298        pdict['Files']['TarRestartPeriod_beg_DateBeg'] = ldate.DateAddPeriod ( pdict['Files']['TarRestartPeriod_beg_DateEnd'], 
     299                                                                                   f"-{pdict['Experiment']['PackFrequency']}") 
     300        pdict['Files']['TarRestartPeriod_beg_DateBeg'] = ldate.AddOneDayToDate ( pdict['Files']['TarRestartPeriod_beg_DateBeg'], 
     301                                                                                     pdict['Experiment']['CalendarType']  ) 
     302         
     303        pdict['Files']['TarRestartPeriod_beg'] = f"{pdict['Files']['TarRestartPeriod_beg_DateBeg']}_{pdict['Files']['TarRestartPeriod_beg_DateEnd']}" 
     304        echo ( f"Tar period for initial restart : {pdict['Files']['TarRestartPeriod_beg']}", f_out) 
     305         
     306    if not pdict['Files']['TarRestartPeriod_end'] : 
     307 
     308        pdict['Files']['TarRestartPeriod_end_DateEnd'] = pdict['Files']['TarRestartDate_end'] 
     309        pdict['Files']['TarRestartPeriod_end_DateBeg'] = ldate.DateAddPeriod ( pdict['Files']['TarRestartPeriod_end_DateEnd'], 
     310                                                                                   f"-{pdict['Experiment']['PackFrequency']}" ) 
     311        pdict['Files']['TarRestartPeriod_end_DateBeg'] = ldate.AddOneDayToDate ( pdict['Files']['TarRestartPeriod_end_DateBeg'], 
     312                                                                                     pdict['Experiment']['CalendarType'] ) 
     313         
     314        pdict['Files']['TarRestartPeriod_end'] = f"{pdict['Files']['TarRestartPeriod_end_DateBeg']}_{pdict['Files']['TarRestartPeriod_end_DateEnd']}" 
     315        echo ( f"Tar period for final restart : {pdict['Files']['TarRestartPeriod_end']}", f_out ) 
     316         
     317    echo ( f"Restart dates - Start : {pdict['Files']['TarRestartPeriod_beg']}  /  End : {pdict['Files']['TarRestartPeriod_end']}", f_out) 
     318         
     319    if not pdict['Files']['tar_restart_beg'] : 
     320        pdict['Files']['tar_restart_beg'] = os.path.join ( pdict['libIGCM']['R_SAVE'], 'RESTART', f"{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartPeriod_beg']}_restart.tar" ) 
     321    if not  pdict['Files']['tar_restart_end'] : 
     322        pdict['Files']['tar_restart_end'] = os.path.join ( pdict['libIGCM']['R_SAVE'], 'RESTART', f"{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartPeriod_end']}_restart.tar" ) 
     323         
     324    echo ( f"{ pdict['Files']['tar_restart_beg'] = }", f_out ) 
     325    echo ( f"{ pdict['Files']['tar_restart_end'] = }", f_out ) 
    325326 
    326327    ##-- Names of tar files with restarts 
    327328     
    328     if not zdict['Files']['tar_restart_beg_ATM'] : 
    329         zdict['Files']['tar_restart_beg_ATM'] = zdict['Files']['tar_restart_beg'] 
    330     if not zdict['Files']['tar_restart_beg_DYN'] : 
    331         zdict['Files']['tar_restart_beg_DYN'] = zdict['Files']['tar_restart_beg'] 
    332     if not zdict['Files']['tar_restart_beg_RUN'] : 
    333         zdict['Files']['tar_restart_beg_RUN'] = zdict['Files']['tar_restart_beg'] 
    334     if not zdict['Files']['tar_restart_beg_OCE'] : 
    335         zdict['Files']['tar_restart_beg_OCE'] = zdict['Files']['tar_restart_beg'] 
    336     if not zdict['Files']['tar_restart_beg_ICE'] : 
    337         zdict['Files']['tar_restart_beg_ICE'] = zdict['Files']['tar_restart_beg'] 
    338          
    339     if not zdict['Files']['tar_restart_end_ATM'] : 
    340         zdict['Files']['tar_restart_end_ATM'] = zdict['Files']['tar_restart_end'] 
    341     if not zdict['Files']['tar_restart_end_DYN'] : 
    342         zdict['Files']['tar_restart_end_DYN'] = zdict['Files']['tar_restart_end'] 
    343     if not zdict['Files']['tar_restart_end_RUN'] : 
    344         zdict['Files']['tar_restart_end_RUN'] = zdict['Files']['tar_restart_end'] 
    345     if not zdict['Files']['tar_restart_end_OCE'] : 
    346         zdict['Files']['tar_restart_end_OCE'] = zdict['Files']['tar_restart_end'] 
    347     if not zdict['Files']['tar_restart_end_ICE'] : 
    348         zdict['Files']['tar_restart_end_ICE'] = zdict['Files']['tar_restart_end'] 
    349          
    350     if not zdict['Files']['file_DYN_beg'] : 
    351         if zdict['Experiment']['LMDZ'] : 
    352             zdict['Files']['file_DYN_beg'] = f"{zdict['Files']['FileDir']}/ATM_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_restart.nc" 
    353         if zdict['Experiment']['ICO']  : 
    354             zdict['Files']['file_DYN_beg'] = f"{zdict['Files']['FileDir']}/ICO_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_restart.nc" 
    355          
    356     if not zdict['Files']['file_DYN_end'] : 
    357         if zdict['Experiment']['LMDZ'] : 
    358             zdict['Files']['file_DYN_end'] = f"{zdict['Files']['FileDir']}/ATM_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_restart.nc" 
    359         if zdict['Experiment']['ICO']  : 
    360             zdict['Files']['file_DYN_end'] = f"{zdict['Files']['FileDir']}/ICO_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_restart.nc" 
    361          
    362     if zdict['Experiment']['SRF'] : 
    363         if not zdict['Files']['file_SRF_beg'] : 
    364             zdict['Files']['file_SRF_beg'] = f"{zdict['Files']['FileDir']}/SRF_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_sechiba_rest.nc" 
    365         if not zdict['Files']['file_SRF_end'] : 
    366             zdict['Files']['file_SRF_end'] = f"{zdict['Files']['FileDir']}/SRF_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_sechiba_rest.nc" 
    367          
    368     if zdict['Experiment']['SRF'] : 
    369         if not zdict['Files']['tar_restart_beg_SRF'] : 
    370             zdict['Files']['tar_restart_beg_SRF'] = zdict['Files']['tar_restart_beg'] 
    371         if not zdict['Files']['tar_restart_end_SRF'] : 
    372             zdict['Files']['tar_restart_end_SRF'] = zdict['Files']['tar_restart_end'] 
    373              
    374     if not zdict['Files']['file_ATM_beg'] : 
    375         zdict['Files']['file_ATM_beg'] = f"{zdict['Files']['FileDir']}/ATM_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_restartphy.nc" 
    376     if not zdict['Files']['file_ATM_end'] : 
    377         zdict['Files']['file_ATM_end'] = f"{zdict['Files']['FileDir']}/ATM_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_restartphy.nc" 
    378          
    379     if zdict['Experiment']['SRF'] : 
    380         echo ( f"{zdict['Files']['file_SRF_beg'] = }", f_out) 
    381         echo ( f"{zdict['Files']['file_SRF_end'] = }", f_out) 
    382          
    383     if zdict['Experiment']['ICO'] : 
    384         if not zdict['Files']['file_DYN_aire'] : 
    385             zdict['Files']['file_DYN_aire'] = os.path.join ( zdict['libIGCM']['R_IN'], 'ATM', 'GRID',  f"{zdict['Experiment']['ResolAtm']}_grid.nc" ) 
    386          
    387     if zdict['Experiment']['SRF'] and zdict['Experiment']['Routing'] == 'SIMPLE' : 
    388         if not zdict['Files']['file_RUN_beg'] : 
    389             zdict['Files']['file_RUN_beg'] = f"{ zdict['Files']['FileDir']}/SRF_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_routing_restart.nc" 
    390         if not zdict['Files']['file_RUN_end'] : 
    391             zdict['Files']['file_RUN_end'] = f"{ zdict['Files']['FileDir']}/SRF_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_routing_restart.nc" 
    392  
    393     if not zdict['Files']['tar_restart_beg_OCE'] : 
    394         zdict['Files']['tar_restart_beg_OCE'] = zdict['Files']['tar_restart_beg'] 
    395     if not zdict['Files']['tar_restart_beg_ICE'] : 
    396         zdict['Files']['tar_restart_beg_ICE'] = zdict['Files']['tar_restart_beg'] 
    397          
    398     if not zdict['Files']['tar_restart_end_OCE'] : 
    399         zdict['Files']['tar_restart_end_OCE'] = zdict['Files']['tar_restart_end'] 
    400     if not zdict['Files']['tar_restart_end_ICE'] : 
    401         zdict['Files']['tar_restart_end_ICE'] = zdict['Files']['tar_restart_end'] 
    402          
    403     if not zdict['Files']['file_OCE_beg'] : 
    404         zdict['Files']['file_OCE_beg'] = f"{zdict['Files']['FileDir']}/OCE_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_restart.nc" 
    405     if not zdict['Files']['file_OCE_end'] : 
    406         zdict['Files']['file_OCE_end'] = f"{zdict['Files']['FileDir']}/OCE_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_restart.nc" 
    407     if not zdict['Files']['file_ICE_beg'] : 
    408         zdict['Files']['file_ICE_beg'] = f"{zdict['Files']['FileDir']}/ICE_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_beg']}_restart_icemod.nc" 
    409     if not zdict['Files']['file_ICE_end'] : 
    410         zdict['Files']['file_ICE_end'] = f"{zdict['Files']['FileDir']}/ICE_{zdict['Experiment']['JobName']}_{zdict['Files']['TarRestartDate_end']}_restart_icemod.nc" 
    411              
    412     return zdict 
     329    if not pdict['Files']['tar_restart_beg_ATM'] : 
     330        pdict['Files']['tar_restart_beg_ATM'] = pdict['Files']['tar_restart_beg'] 
     331    if not pdict['Files']['tar_restart_beg_DYN'] : 
     332        pdict['Files']['tar_restart_beg_DYN'] = pdict['Files']['tar_restart_beg'] 
     333    if not pdict['Files']['tar_restart_beg_RUN'] : 
     334        pdict['Files']['tar_restart_beg_RUN'] = pdict['Files']['tar_restart_beg'] 
     335    if not pdict['Files']['tar_restart_beg_OCE'] : 
     336        pdict['Files']['tar_restart_beg_OCE'] = pdict['Files']['tar_restart_beg'] 
     337    if not pdict['Files']['tar_restart_beg_ICE'] : 
     338        pdict['Files']['tar_restart_beg_ICE'] = pdict['Files']['tar_restart_beg'] 
     339         
     340    if not pdict['Files']['tar_restart_end_ATM'] : 
     341        pdict['Files']['tar_restart_end_ATM'] = pdict['Files']['tar_restart_end'] 
     342    if not pdict['Files']['tar_restart_end_DYN'] : 
     343        pdict['Files']['tar_restart_end_DYN'] = pdict['Files']['tar_restart_end'] 
     344    if not pdict['Files']['tar_restart_end_RUN'] : 
     345        pdict['Files']['tar_restart_end_RUN'] = pdict['Files']['tar_restart_end'] 
     346    if not pdict['Files']['tar_restart_end_OCE'] : 
     347        pdict['Files']['tar_restart_end_OCE'] = pdict['Files']['tar_restart_end'] 
     348    if not pdict['Files']['tar_restart_end_ICE'] : 
     349        pdict['Files']['tar_restart_end_ICE'] = pdict['Files']['tar_restart_end'] 
     350         
     351    if not pdict['Files']['file_DYN_beg'] : 
     352        if pdict['Experiment']['LMDZ'] : 
     353            pdict['Files']['file_DYN_beg'] = f"{pdict['Files']['FileDir']}/ATM_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_restart.nc" 
     354        if pdict['Experiment']['ICO']  : 
     355            pdict['Files']['file_DYN_beg'] = f"{pdict['Files']['FileDir']}/ICO_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_restart.nc" 
     356         
     357    if not pdict['Files']['file_DYN_end'] : 
     358        if pdict['Experiment']['LMDZ'] : 
     359            pdict['Files']['file_DYN_end'] = f"{pdict['Files']['FileDir']}/ATM_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_restart.nc" 
     360        if pdict['Experiment']['ICO']  : 
     361            pdict['Files']['file_DYN_end'] = f"{pdict['Files']['FileDir']}/ICO_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_restart.nc" 
     362         
     363    if pdict['Experiment']['SECHIBA'] : 
     364        if not pdict['Files']['file_SRF_beg'] : 
     365            pdict['Files']['file_SRF_beg'] = f"{pdict['Files']['FileDir']}/SRF_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_sechiba_rest.nc" 
     366        if not pdict['Files']['file_SRF_end'] : 
     367            pdict['Files']['file_SRF_end'] = f"{pdict['Files']['FileDir']}/SRF_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_sechiba_rest.nc" 
     368         
     369    if pdict['Experiment']['SECHIBA'] : 
     370        if not pdict['Files']['tar_restart_beg_SRF'] : 
     371            pdict['Files']['tar_restart_beg_SRF'] = pdict['Files']['tar_restart_beg'] 
     372        if not pdict['Files']['tar_restart_end_SRF'] : 
     373            pdict['Files']['tar_restart_end_SRF'] = pdict['Files']['tar_restart_end'] 
     374             
     375    if not pdict['Files']['file_ATM_beg'] : 
     376        pdict['Files']['file_ATM_beg'] = f"{pdict['Files']['FileDir']}/ATM_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_restartphy.nc" 
     377    if not pdict['Files']['file_ATM_end'] : 
     378        pdict['Files']['file_ATM_end'] = f"{pdict['Files']['FileDir']}/ATM_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_restartphy.nc" 
     379         
     380    if pdict['Experiment']['SECHIBA'] : 
     381        echo ( f"{pdict['Files']['file_SRF_beg'] = }", f_out) 
     382        echo ( f"{pdict['Files']['file_SRF_end'] = }", f_out) 
     383         
     384    if pdict['Experiment']['ICO'] : 
     385        if not pdict['Files']['file_DYN_aire'] : 
     386            pdict['Files']['file_DYN_aire'] = os.path.join ( pdict['libIGCM']['R_IN'], 'ATM', 'GRID',  f"{pdict['Experiment']['ResolAtm']}_grid.nc" ) 
     387         
     388    if pdict['Experiment']['SECHIBA'] and pdict['Experiment']['Routing'] == 'SIMPLE' : 
     389        if not pdict['Files']['file_RUN_beg'] : 
     390            pdict['Files']['file_RUN_beg'] = f"{ pdict['Files']['FileDir']}/SRF_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_routing_restart.nc" 
     391        if not pdict['Files']['file_RUN_end'] : 
     392            pdict['Files']['file_RUN_end'] = f"{ pdict['Files']['FileDir']}/SRF_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_routing_restart.nc" 
     393 
     394    if not pdict['Files']['tar_restart_beg_OCE'] : 
     395        pdict['Files']['tar_restart_beg_OCE'] = pdict['Files']['tar_restart_beg'] 
     396    if not pdict['Files']['tar_restart_beg_ICE'] : 
     397        pdict['Files']['tar_restart_beg_ICE'] = pdict['Files']['tar_restart_beg'] 
     398         
     399    if not pdict['Files']['tar_restart_end_OCE'] : 
     400        pdict['Files']['tar_restart_end_OCE'] = pdict['Files']['tar_restart_end'] 
     401    if not pdict['Files']['tar_restart_end_ICE'] : 
     402        pdict['Files']['tar_restart_end_ICE'] = pdict['Files']['tar_restart_end'] 
     403         
     404    if not pdict['Files']['file_OCE_beg'] : 
     405        pdict['Files']['file_OCE_beg'] = f"{pdict['Files']['FileDir']}/OCE_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_restart.nc" 
     406    if not pdict['Files']['file_OCE_end'] : 
     407        pdict['Files']['file_OCE_end'] = f"{pdict['Files']['FileDir']}/OCE_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_restart.nc" 
     408    if not pdict['Files']['file_ICE_beg'] : 
     409        pdict['Files']['file_ICE_beg'] = f"{pdict['Files']['FileDir']}/ICE_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_beg']}_restart_icemod.nc" 
     410    if not pdict['Files']['file_ICE_end'] : 
     411        pdict['Files']['file_ICE_end'] = f"{pdict['Files']['FileDir']}/ICE_{pdict['Experiment']['JobName']}_{pdict['Files']['TarRestartDate_end']}_restart_icemod.nc" 
     412             
     413    return pdict 
     414 
     415def ComputeGridATM ( dpar, d_ATM_his ) : 
     416    readPrec = dpar['Config']['readPrec'] 
     417    if repr(readPrec) in [ "<class 'numpy.float64'>" , float ] : 
     418        def rprec (ptab) : 
     419            return ptab 
     420    else                 : 
     421        def rprec (ptab) : 
     422            return ptab.astype(readPrec).astype(float) 
     423     
     424    ATM = types.SimpleNamespace () 
     425 
     426    # ATM grid with cell surfaces 
     427    if dpar['Experiment']['LMDZ'] : 
     428        #echo ('ATM grid with cell surfaces : LMDZ', f_out) 
     429        ATM.lat       = lmdz.geo2point (   rprec (d_ATM_his ['lat'])+0*rprec (d_ATM_his ['lon']), dim1d='cell' ) 
     430        ATM.lon       = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat'])+  rprec (d_ATM_his ['lon']), dim1d='cell' ) 
     431        ATM.aire      = lmdz.geo2point ( rprec (d_ATM_his ['aire']     [0]), cumul_poles=True, dim1d='cell' ) 
     432        ATM.fter      = lmdz.geo2point ( rprec (d_ATM_his ['fract_ter'][0]), dim1d='cell' ) 
     433        ATM.foce      = lmdz.geo2point ( rprec (d_ATM_his ['fract_oce'][0]), dim1d='cell' ) 
     434        ATM.fsic      = lmdz.geo2point ( rprec (d_ATM_his ['fract_sic'][0]), dim1d='cell' ) 
     435        ATM.flic      = lmdz.geo2point ( rprec (d_ATM_his ['fract_lic'][0]), dim1d='cell' ) 
     436         
     437    if  dpar['Experiment']['ICO'] : 
     438        if  dpar['Experiment']['ATM_HIS'] == 'latlon' : 
     439            #echo ( 'ATM areas and fractions on LATLON grid' ) 
     440            if 'lat_dom_out' in d_ATM_his.variables : 
     441                ATM.lat  = lmdz.geo2point (   rprec (d_ATM_his ['lat_dom_out'])+0*rprec (d_ATM_his ['lon_dom_out']), dim1d='cell' ) 
     442                ATM.lon  = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat_dom_out'])+  rprec (d_ATM_his ['lon_dom_out']), dim1d='cell' ) 
     443            else : 
     444                ATM.lat  = lmdz.geo2point (   rprec (d_ATM_his ['lat'])+0*rprec (d_ATM_his ['lon']), dim1d='cell' ) 
     445                ATM.lon  = lmdz.geo2point ( 0*rprec (d_ATM_his ['lat'])+  rprec (d_ATM_his ['lon']), dim1d='cell' ) 
     446            ATM.aire = lmdz.geo2point ( rprec (d_ATM_his ['aire'][0]).squeeze(), cumul_poles=True, dim1d='cell' ) 
     447            ATM.fter = lmdz.geo2point ( rprec (d_ATM_his ['fract_ter'][0]), dim1d='cell' ) 
     448            ATM.foce = lmdz.geo2point ( rprec (d_ATM_his ['fract_oce'][0]), dim1d='cell' ) 
     449            ATM.fsic = lmdz.geo2point ( rprec (d_ATM_his ['fract_sic'][0]), dim1d='cell' ) 
     450            ATM.flic = lmdz.geo2point ( rprec (d_ATM_his ['fract_lic'][0]), dim1d='cell' ) 
     451 
     452             
     453        if  dpar['Experiment']['ATM_HIS'] == 'ico' : 
     454            #echo ( 'ATM areas and fractions on ICO grid' ) 
     455            ATM.aire =  rprec (d_ATM_his ['aire']     [0]).squeeze() 
     456            ATM.lat  =  rprec (d_ATM_his ['lat']         ) 
     457            ATM.lon  =  rprec (d_ATM_his ['lon']         ) 
     458            ATM.fter =  rprec (d_ATM_his ['fract_ter'][0]) 
     459            ATM.foce =  rprec (d_ATM_his ['fract_oce'][0]) 
     460            ATM.fsic =  rprec (d_ATM_his ['fract_sic'][0]) 
     461            ATM.flic =  rprec (d_ATM_his ['fract_lic'][0]) 
     462             
     463        
     464    ATM.fsea      = ATM.foce + ATM.fsic 
     465    ATM.flnd      = ATM.fter + ATM.flic 
     466    ATM.aire_fter = ATM.aire * ATM.fter 
     467    ATM.aire_flic = ATM.aire * ATM.flic 
     468    ATM.aire_fsic = ATM.aire * ATM.fsic 
     469    ATM.aire_foce = ATM.aire * ATM.foce 
     470    ATM.aire_flnd = ATM.aire * ATM.flnd 
     471    ATM.aire_fsea = ATM.aire * ATM.fsea 
     472 
     473    ATM.aire_sea     = ATM.aire * ATM.fsea 
     474    ATM.aire_tot     = P1sum ( ATM.aire      ) 
     475    ATM.aire_sea_tot = P1sum ( ATM.aire_fsea ) 
     476    ATM.aire_ter_tot = P1sum ( ATM.aire_fter ) 
     477    ATM.aire_lic_tot = P1sum ( ATM.aire_flic ) 
     478    
     479    return dpar, ATM 
     480 
     481def ComputeGridSRF ( dpar, d_SRF_his ) : 
     482    readPrec = dpar['Config']['readPrec'] 
     483    if repr(readPrec) in [ "<class 'numpy.float64'>" , float ] : 
     484        def rprec (ptab) : 
     485            return ptab 
     486    else                 : 
     487        def rprec (ptab) : 
     488            return ptab.astype(readPrec).astype(float) 
     489     
     490    SRF = types.SimpleNamespace () 
     491     
     492    if dpar['Experiment']['SECHIBA'] :  
     493        if dpar['Experiment']['LMDZ'] : 
     494            SRF.lat       = lmdz.geo2point (   rprec (d_SRF_his ['lat'])+0*rprec (d_SRF_his ['lon']), dim1d='cell' ) 
     495            SRF.lon       = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat'])+  rprec (d_SRF_his ['lon']), dim1d='cell' ) 
     496            SRF.aire      = lmdz.geo2point ( rprec (d_SRF_his ['Areas']) * rprec (d_SRF_his ['Contfrac']), dim1d='cell', cumul_poles=True ) 
     497            SRF.areas     = lmdz.geo2point ( rprec (d_SRF_his ['Areas'])  ,  dim1d='cell', cumul_poles=True ) 
     498            SRF.contfrac  = lmdz.geo2point ( rprec (d_SRF_his ['Contfrac']), dim1d='cell' ) 
     499     
     500        if dpar['Experiment']['ICO'] : 
     501            if dpar['Experiment']['SRF_HIS'] == 'latlon' : 
     502                #echo ( 'SRF areas and fractions on LATLON grid' ) 
     503                if 'lat_domain_landpoints_out' in d_SRF_his  : 
     504                    SRF.lat = lmdz.geo2point (   rprec (d_SRF_his ['lat_domain_landpoints_out'])+0*rprec (d_SRF_his ['lon_domain_landpoints_out']), dim1d='cell' ) 
     505                    SRF.lon = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat_domain_landpoints_out'])+  rprec (d_SRF_his ['lon_domain_landpoints_out']), dim1d='cell' ) 
     506                else : 
     507                    if 'lat_domain_landpoints_out' in d_SRF_his : 
     508                        SRF.lat = lmdz.geo2point (   rprec (d_SRF_his ['lat_dom_out'])+0*rprec (d_SRF_his ['lon_dom_out']), dim1d='cell' ) 
     509                        SRF.lon = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat_dom_out'])+  rprec (d_SRF_his ['lon_dom_out']), dim1d='cell' ) 
     510                    else : 
     511                        SRF.lat = lmdz.geo2point (   rprec (d_SRF_his ['lat'])+0*rprec (d_SRF_his ['lon']), dim1d='cell' ) 
     512                        SRF.lon = lmdz.geo2point ( 0*rprec (d_SRF_his ['lat'])+  rprec (d_SRF_his ['lon']), dim1d='cell' ) 
     513     
     514                SRF.areas     = lmdz.geo2point ( rprec (d_SRF_his ['Areas']   )   , dim1d='cell', cumul_poles=True ) 
     515                SRF.areafrac  = lmdz.geo2point ( rprec (d_SRF_his ['AreaFrac'])   , dim1d='cell', cumul_poles=True ) 
     516                SRF.contfrac  = lmdz.geo2point ( rprec (d_SRF_his ['Contfrac'])   , dim1d='cell', cumul_poles=True ) 
     517                SRF.aire      = SRF.areafrac 
     518     
     519            if dpar['Experiment']['SRF_HIS'] == 'ico' : 
     520                #echo ( 'SRF areas and fractions on ICO grid' ) 
     521                SRF.lat       =  rprec (d_SRF_his ['lat']     ) 
     522                SRF.lon       =  rprec (d_SRF_his ['lon']     ) 
     523                SRF.areas     =  rprec (d_SRF_his ['Areas']   ) 
     524                SRF.contfrac  =  rprec (d_SRF_his ['Contfrac']) 
     525                SRF.aire      =  SRF.areas * SRF.contfrac 
     526 
     527        SRF.aire_tot = P1sum ( SRF.aire ) 
     528 
     529    return dpar, SRF 
     530 
     531def ComputeGridDYN ( dpar, ATM, d_DYN_aire, d_ATM_beg ) :  
     532    readPrec = dpar['Config']['readPrec'] 
     533    if repr(readPrec) in [ "<class 'numpy.float64'>" , float ] : 
     534        def rprec (ptab) : 
     535            return ptab 
     536    else                 : 
     537        def rprec (ptab) : 
     538            return ptab.astype(readPrec).astype(float) 
     539         
     540    DYN = types.SimpleNamespace () 
     541    if dpar['Experiment']['ICO'] : 
     542        if dpar['Config']['SortIco'] : 
     543            # Creation d'une clef de tri pour le fichier aire 
     544            DYN.aire_keysort = np.lexsort ( (d_DYN_aire['lat'], d_DYN_aire['lon']) ) 
     545        else : 
     546            DYN.aire_keysort = np.arange ( len ( d_DYN_aire['lat'] ) ) 
     547             
     548        DYN.lat = d_DYN_aire['lat'] 
     549        DYN.lon = d_DYN_aire['lon'] 
     550         
     551        DYN.aire = d_DYN_aire['aire'] 
     552        DYN.fsea = d_DYN_aire['fract_oce'] + d_DYN_aire['fract_sic'] 
     553         
     554        DYN.flnd = 1.0 - DYN.fsea 
     555        DYN.fter = d_ATM_beg['FTER'] 
     556        DYN.flic = d_ATM_beg['FLIC'] 
     557        DYN.foce = d_ATM_beg['FOCE'] 
     558        DYN.aire_fter = DYN.aire * DYN.fter 
     559         
     560    if dpar['Experiment']['ATM_HIS'] == 'ico' : 
     561        DYN.aire      = ATM.aire 
     562        DYN.foce      = ATM.foce 
     563        DYN.fsic      = ATM.fsic 
     564        DYN.flic      = ATM.flic 
     565        DYN.fter      = ATM.fter 
     566        DYN.fsea      = ATM.fsea 
     567        DYN.flnd      = ATM.flnd 
     568        DYN.aire_fter = ATM.aire_fter 
     569        DYN.aire_flic = ATM.aire_flic 
     570        DYN.aire_fsic = ATM.aire_fsic 
     571        DYN.aire_foce = ATM.aire_foce 
     572        DYN.aire_flnd = ATM.aire_flnd 
     573        DYN.aire_fsea = ATM.aire_fsea 
     574     
     575    if dpar['Experiment']['LMDZ'] : 
     576        # Area on lon/lat grid 
     577        DYN.aire = ATM.aire 
     578        DYN.fsea = ATM.fsea 
     579        DYN.flnd = ATM.flnd 
     580        DYN.fter = rprec (d_ATM_beg['FTER']) 
     581        DYN.flic = rprec (d_ATM_beg['FLIC']) 
     582        DYN.aire_fter = DYN.aire * DYN.fter 
     583         
     584    DYN.aire_tot =  P1sum ( DYN.aire )  
     585     
     586    return dpar, DYN 
     587 
     588def ComputeGridOCE ( dpar, d_OCE_his, nperio=None ) : 
     589    OCE = types.SimpleNamespace () 
     590 
     591    # Get mask and surfaces 
     592    sos = d_OCE_his ['sos'][0].squeeze() 
     593    OCE.OCE_msk = nemo.lbc_mask ( xr.where ( sos>0., 1., 0. ), cd_type = 'T', nperio=nperio, sval = 0. ) 
     594     
     595    so = sos = d_OCE_his ['sos'][0].squeeze() 
     596    OCE.msk3 = nemo.lbc_mask ( xr.where ( so>0., 1., 0. ), cd_type = 'T', nperio=nperio, sval = 0. ) 
     597     
     598    # lbc_mask removes the duplicate points (periodicity and north fold) 
     599    OCE.OCE_aire = nemo.lbc_mask ( d_OCE_his ['area'] * OCE.OCE_msk, cd_type = 'T', nperio=nperio, sval = 0.0 ) 
     600    OCE.ICE_aire = OCE.OCE_aire 
     601 
     602    OCE.OCE_aire_tot = P1sum ( OCE.OCE_aire ) 
     603    OCE.ICE_aire_tot = P1sum ( OCE.ICE_aire ) 
     604 
     605    return dpar, OCE 
    413606 
    414607def config2dict ( pconf ) : 
    … …  
    416609    Convert a config parser object into a dictionary 
    417610    ''' 
    418     zdict = {} 
     611    pdict = {} 
    419612    for section in pconf.keys () : 
    420         zdict[section] = {} 
     613        pdict[section] = {} 
    421614        for key in pconf[section].keys() : 
    422615            zz = str2value ( pconf[section][key] ) 
    423             zdict[section].update ( {key:zz} )         
    424     return zdict 
     616            pdict[section].update ( {key:zz} )         
     617    return pdict 
    425618 
    426619def dict2config ( pdict ): 
    427620    ''' 
    428621    Convert a dictionary into a configparser object 
    429  
    430     The dictionary should have two levels (see configparser) 
     622    All values are converted to strings 
     623 
     624    The dictionary must have two levels (see configparser) 
    431625    ''' 
    432626    zconf = configparser.ConfigParser ( interpolation=configparser.ExtendedInterpolation() ) 
    433627    zconf.optionxform = str # To keep capitals 
    434      
    435     for section in pdict.keys () : 
    436         zconf[section] = {} 
     628    zconf.read_dict(dict2str(pdict)) 
     629     
     630    return zconf 
     631 
     632def updateConf ( pconf, pdict ): 
     633    ''' 
     634    Update a config parser with a dictionary 
     635    All values are converted to strings 
     636 
     637    The dictionary must have two levels (see configparser) 
     638    ''' 
     639    pconf.read_dict (dict1str(pdict)) 
     640    #for section in pdict.keys() : 
     641    #    if section not in pconf.keys() : pconf[section] = {} 
     642    #    for key in pdict[section].keys() : 
     643    #        pconf[section][key] = str(pdict[section][key]) 
     644    return pconf 
     645 
     646def dict2str (pdict) : 
     647    ''' 
     648    Convert all values of a dictionary to strings 
     649    ''' 
     650    zout = {} 
     651    for section in pdict.keys() : 
     652        zout[section] = {} 
    437653        for key in pdict[section].keys() : 
    438             zconf[section][key] = str (pdict[section][key]  )   
    439      
    440     return zconf 
    441  
    442 # def updateConf ( pconf, pdict ): 
    443 #     ''' 
    444 #     Update a config parser with a dictionary 
    445 #     ''' 
    446 #     zconf = pconf 
    447 #     for section in pdict.keys() : 
    448 #         if section not in pconf.keys() : pconf[section] = {} 
    449 #         for key in pdict[section].keys() : 
    450 #             pconf[section][key] = str(pdict[section][key]) 
    451 #     return pconf 
    452      
     654            zout[section][key] = str(pdict[section][key]) 
     655    return zout 
     656 
    453657def echo (string, f_out, end='\n') : 
    454658    '''Function to print to stdout *and* output file''' 
    … …  
    479683def setNum (chars) : 
    480684    '''Convert specific char string in integer or real if possible''' 
     685    zset_num = chars 
    481686    if isinstance (chars, str) : 
    482687        realnum   = re.compile ("^[-+]?[0-9]*\.?[0-9]+(e[-+]?[0-9]+)?$") 
    … …  
    486691            if is_int : zset_num = int   (chars) 
    487692            else      : zset_num = float (chars) 
    488         else : zset_num = chars 
    489     else : 
    490         zset_num = chars 
     693    
    491694    return zset_num 
    492695 
    … …  
    501704    '''True if a variable is not defined, or set to None''' 
    502705    if char in globals () : 
    503         if globals()[char] is None : 
    504             zun_defined = True 
    505         else : zun_defined = False 
     706        if globals()[char] : 
     707            zun_defined = False 
     708        else : zun_defined = True 
    506709    else :     zun_defined = True 
    507710    return zun_defined 
    … …  
    552755Psum = KSsum 
    553756 
    554 def IsLeapYear ( year, CalendarType="Gregorian" ) : 
    555     '''True is Year is a leap year''' 
    556     year = int ( year ) 
    557     zis_leap_year = None 
    558  
    559     # What is the calendar : 
    560     if CalendarType in [ '360d', '360_day', 'noleap', '365_day'] : 
    561         zis_leap_year = False 
    562  
    563     if CalendarType in [ 'all_leap', '366_day' ] : 
    564         zis_leap_year = True 
    565  
    566     # a year is a leap year if it is even divisible by 4 
    567     # but not evenly divisible by 100 
    568     # unless it is evenly divisible by 400 
    569  
    570     # if it is evenly divisible by 400 it must be a leap year 
    571     if not zis_leap_year and np.mod ( year, 400 ) == 0 : 
    572         zis_leap_year = True 
    573  
    574     # if it is evenly divisible by 100 it must not be a leap year 
    575     if not zis_leap_year and np.mod ( year, 100 ) == 0 : 
    576         zis_leap_year = False 
    577  
    578     # if it is evenly divisible by 4 it must be a leap year 
    579     if not zis_leap_year and np.mod ( year, 4 ) == 0 : 
    580         zis_leap_year = True 
    581  
    582     if not zis_leap_year : 
    583         zis_leap_year = False 
    584  
    585     return zis_leap_year 
    586  
    587 def DateFormat ( date ) : 
    588     '''Get date format : 
    589  
    590       [yy]yymmdd   is Gregorian 
    591       [yy]yy-mm-dd is Human 
    592     ''' 
    593     if isinstance (date, str) : 
    594         if '-' in date : 
    595             zdate_format = 'Human' 
    596         else : 
    597             zdate_format = 'Gregorian' 
    598     if isinstance (date, int) : zdate_format = 'Gregorian' 
    599     return zdate_format 
    600  
    601 def PrintDate ( ye, mo, da, pformat ) : 
    602     '''Return a date in the requested format 
    603     ''' 
    604     if pformat == 'Human'     : zPrintDate = f'{ye:04d}-{mo:02d}-{da:02d}' 
    605     if pformat == 'Gregorian' : zPrintDate = f'{ye:04d}{mo:02d}{da:02d}' 
    606     return zPrintDate 
    607  
    608 def FormatToGregorian ( date ) : 
    609     '''From a yyyy-mm-dd or yyymmdd date format returns 
    610         a yyymmdd date format 
    611     ''' 
    612     ye, mo, da = SplitDate ( date ) 
    613     return f'{ye:04d}{mo:02d}{da:02d}' 
    614  
    615 def FormatToHuman ( date ) : 
    616     '''From a yyyymmdd or yyymmdd date format returns 
    617         a yyy-mm-dd date format 
    618     ''' 
    619     ye, mo, da = SplitDate ( date ) 
    620     return f'{ye:04d}-{mo:02d}-{da:02d}' 
    621  
    622 def SplitDate  ( date ) : 
    623     '''Split Date in format [yy]yymmdd or [yy]yy-mm-dd 
    624        to yy, mm, dd ''' 
    625     if isinstance (date, str) : 
    626         if '-' in date : 
    627             ye, mo, da = date.split ('-') 
    628         else : 
    629             ye, mo, da = date[:-4], date[-4:-2], date[-2:] 
    630     if isinstance (date, int) : 
    631         da = np.mod ( date, 100) 
    632         mo = np.mod ( date//100, 100) 
    633         ye = date // 10000 
    634  
    635     ye = int(ye) ; mo = int(mo) ; da=int(da) 
    636     return ye, mo, da 
    637  
    638 def DateAddYear ( date, year_inc=1 ) : 
    639     '''Add on year(s) to date in format [yy]yymmdd or [yy]yy-mm-dd''' 
    640     zformat = DateFormat ( date ) 
    641     ye, mo, da = SplitDate ( date ) 
    642     ye_new = ye + year_inc 
    643     return PrintDate ( ye_new, mo, da, zformat) 
    644  
    645 def DateMinusOneDay ( date ) : 
    646     '''Substracts one day to date in format [yy]yymmdd or [yy]yy-mm-dd''' 
    647     zformat = DateFormat ( date ) 
    648     mth_length = np.array ( [31, 28, 31,  30,  31,  30,  31,  31,  30,  31,  30,  31] ) 
    649     ye, mo, da = SplitDate ( date ) 
    650     if IsLeapYear ( ye) : mth_length[1] += 1 
    651  
    652     ye = int(ye) ; mo = int(mo) ; da=int(da) 
    653     if da ==  1 : 
    654         if mo == 1 : 
    655             da_new, mo_new, ye_new = mth_length[-1  ], 12    , ye - 1 
    656         else       : 
    657             da_new, mo_new, ye_new = mth_length[mo-2], mo - 1, ye 
    658     else : 
    659         da_new, mo_new, ye_new = da - 1, mo, ye 
    660  
    661     return PrintDate ( ye_new, mo_new, da_new, zformat) 
    662  
    663 def DatePlusOneDay ( date ) : 
    664     '''Add one day to date in format [yy]yymmdd or [yy]yy-mm-dd''' 
    665     zformat = DateFormat ( date ) 
    666     mth_length = np.array ( [31, 28, 31,  30,  31,  30,  31,  31,  30,  31,  30,  31] ) 
    667     ye, mo, da = SplitDate ( date ) 
    668     if IsLeapYear ( ye ) : mth_length[1] += 1 
    669  
    670     ye_new = ye 
    671     mo_new = mo 
    672     da_new = da+1 
    673     if da_new > mth_length [mo_new-1] : 
    674         da_new = 1 
    675         mo_new = mo_new + 1 
    676         if mo_new == 13 : 
    677             mo_new =  1 
    678             ye_new += 1 
    679  
    680     return PrintDate ( ye_new, mo_new, da_new, zformat ) 
     757def P1sum (ptab) : 
     758    return Psum ( ptab.to_masked_array().ravel() ) 
    681759 
    682760class Timer : 

  • TOOLS/WATER_BUDGET/libIGCM_sys.py

    r6676 r6688  
    11# -*- coding: utf-8 -*- 
    2 ## =========================================================================== 
    3 ## 
    4 ##  This software is governed by the CeCILL  license under French law and 
    5 ##  abiding by the rules of distribution of free software.  You can  use, 
    6 ##  modify and/ or redistribute the software under the terms of the CeCILL 
    7 ##  license as circulated by CEA, CNRS and INRIA at the following URL 
    8 ##  "http://www.cecill.info". 
    9 ## 
    10 ##  Warning, to install, configure, run, use any of Olivier Marti's 
    11 ##  software or to read the associated documentation you'll need at least 
    12 ##  one (1) brain in a reasonably working order. Lack of this implement 
    13 ##  will void any warranties (either express or implied). 
    14 ##  O. Marti assumes no responsability for errors, omissions, 
    15 ##  data loss, or any other consequences caused directly or indirectly by 
    16 ##  the usage of his software by incorrectly or partially configured 
    17 ##  personal. 
    18 ## 
    19 ## =========================================================================== 
    202''' 
    213Defines libIGCM directories, depending of the computer 
    224 
    235olivier.marti@lsce.ipsl.fr 
     6 
     7  This library if a layer under some usefull 
     8  environment variables and commands. 
     9  All those definitions depend on host particularities. 
     10  It manages a stack mechanism and test validity of operations. 
     11 
     12  This software is governed by the CeCILL  license under French law and 
     13  abiding by the rules of distribution of free software.  You can  use, 
     14  modify and/ or redistribute the software under the terms of the CeCILL 
     15  license as circulated by CEA, CNRS and INRIA at the following URL 
     16  "http://www.cecill.info". 
     17 
     18  Warning, to install, configure, run, use any of Olivier Marti's 
     19  software or to read the associated documentation you'll need at least 
     20  one (1) brain in a reasonably working order. Lack of this implement 
     21  will void any warranties (either express or implied). 
     22  O. Marti assumes no responsability for errors, omissions, 
     23  data loss, or any other consequences caused directly or indirectly by 
     24  the usage of his software by incorrectly or partially configured 
     25  personal. 
     26 
     27SVN information 
     28 $Author$ 
     29 $Date$ 
     30 $Revision$ 
     31 $Id$ 
     32 $HeadURL$ 
    2433''' 
    2534 
Note: See TracChangeset for help on using the changeset viewer.