about: ValueError: cannot reshape array of size 1 into shape (13872,)

kwds)) File "/opt/software/Python/3.6.3-foss-2017b/lib/python3.6/multiprocessing/pool.py", line 44, in mapstar return list(map(

#!/usr/bin/python
# 
# Author: PY. Barriat
# Date  : January 2018

# Python imports
from os import path
import shutil
import zipfile
import oggm
import pathlib
import argparse

# Module logger
import logging
log = logging.getLogger(__name__)

# Libs
import salem

# Locals
import oggm.cfg as cfg
from oggm import tasks, utils, workflow
from oggm.workflow import execute_entity_task

# For timing the run
import time

#############################

def run_from_climate(gdirs, filesuffix, gcm, equilibre, spinup):

  # Process GCM data
  if gcm == 'cesm':
    execute_entity_task(tasks.process_gcm_data, gdirs, filesuffix=filesuffix, scalendar='365_day')
  elif gcm == 'bcc-csm':
    execute_entity_task(tasks.process_gcm_data, gdirs, filesuffix=filesuffix, scalendar='365_day') 
  elif gcm == 'giss':
    execute_entity_task(tasks.process_gcm_data, gdirs, filesuffix=filesuffix, scalendar='365_day')
  elif gcm == 'ipsl':
    execute_entity_task(tasks.process_gcm_data, gdirs, filesuffix=filesuffix, scalendar='360_day')
  elif gcm == 'mpi':
    execute_entity_task(tasks.process_gcm_data, gdirs, filesuffix=filesuffix, scalendar='proleptic_gregorian')
  else:
    log.info('OGGM: problem in run_from_climate')
    return
  tasks.distribute_t_stars(gdirs)
  execute_entity_task(tasks.apparent_mb, gdirs)

  # Inversion tasks
  # fl.flux
  execute_entity_task(tasks.prepare_for_inversion, gdirs)
  # We use the default parameters for this run
  execute_entity_task(tasks.volume_inversion, gdirs, glen_a=cfg.A, fs=0)
  execute_entity_task(tasks.filter_inversion_output, gdirs)

  # Final preparation for the run
  execute_entity_task(tasks.init_present_time_glacier, gdirs)

  # Run the historical glacier evolution with GCM data
  if equilibre:
    efilesuffix = filesuffix + '_eqm'
    execute_entity_task(tasks.run_constant_climate, gdirs, climate_filename='cesm_data', climate_input_filesuffix=filesuffix,
        output_filesuffix=efilesuffix)
    ofilesuffix = filesuffix + '_with_eqm'
    execute_entity_task(tasks.run_from_climate_data, gdirs, climate_filename='cesm_data', climate_input_filesuffix=filesuffix,
        init_model_filesuffix=efilesuffix, output_filesuffix=ofilesuffix)
    filesuffix = ofilesuffix
    #execute_entity_task(tasks.run_from_gcm_eqm, gdirs, filename='cesm_data', input_filesuffix=filesuffix, filesuffix=filesuffix)
    #filesuffix = filesuffix + '_eqm'
  elif spinup:
    sfilesuffix = '_spinup'
    execute_entity_task(tasks.run_constant_climate, gdirs,nyears=300, bias=0, temperature_bias=-0.5, output_filesuffix=sfilesuffix)
    ofilesuffix = filesuffix + '_with_spinup'
    execute_entity_task(tasks.run_from_climate_data, gdirs, climate_filename='cesm_data', climate_input_filesuffix=filesuffix, 
        init_model_filesuffix=sfilesuffix, output_filesuffix=ofilesuffix)
    filesuffix = ofilesuffix
  else:
    execute_entity_task(tasks.run_from_climate_data, gdirs, climate_filename='cesm_data', climate_input_filesuffix=filesuffix, 
        output_filesuffix=filesuffix)

  # Compile output
  log.info('Compiling output')
  utils.glacier_characteristics(gdirs)
  utils.compile_run_output(gdirs, filesuffix=filesuffix)
  if equilibre:
    utils.compile_run_output(gdirs, filesuffix=efilesuffix)
  #elif spinup:
  #  utils.compile_run_output(gdirs, filesuffix=sfilesuffix)

start = time.time()
cfg.initialize()

# Initialize OGGM and set up the run parameters

parser = argparse.ArgumentParser(description='Initialize OGGM and set up the run parameters')
parser.add_argument('gcmval', action='store', help ="Set the input model: cesm, bcc-csm, giss, ipsl, mpi")
group = parser.add_mutually_exclusive_group()
group.add_argument('-e', '--equil', action='store_true', dest='eqmval',  help ="Start from an equilibrium", default=False)
group.add_argument('-s', '--spinup', action='store_true', dest='spinval',  help ="Start a past climate run based on a spinup", default=False)
results = parser.parse_args()

# Set the input model: cesm, bcc-csm, giss, ipsl, mpi 
GCM = format(results.gcmval)

# Set EQM True if you need to start from an equilibrium
EQM = results.eqmval

# Run a past climate run based on this spinup
SPIN = results.spinval

#############################

# Ensemble
# In the folder 'fens', you must have 'iens' temp_file, precc_file, precl_file
# Respect the naming rule: same name with '_001', '_002', ... 'iens' suffix (before '.nc')
ENS = False
iens = 3 # max 999
fens = 'ensemble/'

# Filesuffix of the shapefile to use
shpfilesuffix = '_forni'
shpfilesuffix = '_leclercq'
shpfilesuffix = '_5alps'
shpfilesuffix = '_argentiere'
#shpfilesuffix = '_5alps'
#Filesuffix for the output of the run
filesuffix = '_forni_eqm'
filesuffix = '_leclercq'
filesuffix = '_5alps'
filesuffix = '_argentiere'
#filesuffix = '_5alps'

cfg.PATHS['working_dir'] = '/afast/pbarriat/oggm_wkdir/'

# Use multiprocessing?
cfg.PARAMS['use_multiprocessing'] = True
cfg.PARAMS['optimize_inversion_params'] = True

# Here we override some of the default parameters
# How many grid points around the glacier?
# Make it large if you expect your glaciers to grow large
cfg.PARAMS['border'] = 100

# Set to True for operational runs
cfg.PARAMS['continue_on_error'] = False
cfg.PARAMS['ys'] = 851
cfg.PARAMS['ye'] = 2005

#############################

# Info
print("MODEL: %s" % GCM)
print("FROM EQUILIBRIUM: %s" % EQM)
print("FROM SPINUP: %s" % SPIN)
print("ENSEMBLE: %s" % ENS)
if ENS:
  print("MEMBERS: %f" % iens)

# Check path
cfg.PATHS['working_dir'] = path.join(cfg.PATHS['working_dir'], GCM)
pathlib.Path(cfg.PATHS['working_dir']).mkdir(parents=True, exist_ok=True)
rgi_selections = cfg.PATHS['rgi_dir'] + '/selections/'

# Don't use divides for now
#PEDRO#cfg.set_divides_db()

# But we use intersects
# (this is slow, it could be replaced with a subset of the global file)
rgi_dir = utils.get_rgi_intersects_dir()
cfg.set_intersects_db(path.join(rgi_dir, '00_rgi50_AllRegs', 'intersects_rgi50_AllRegs.shp'))

# Pre-download other files which will be needed later
utils.get_cru_file(var='tmp')
utils.get_cru_file(var='pre')

# Precalibrated t* values are already downloaded and stored in OGGM/wkdir/ref_tstars.csv
# They are used to interpolate the t* for other glaciers

# Read the RGI datafile
rgidf = salem.read_shapefile(path.join(rgi_selections, 'rgi_selection%s.shp' % shpfilesuffix))

# Sort for more efficient parallel computing
rgidf = rgidf.sort_values('Area', ascending=False)

log.info('Starting OGGM run')
log.info('Number of glaciers: {}'.format(len(rgidf)))

# Go - initialize working directories
gdirs = workflow.init_glacier_regions(rgidf)

# Preprocessing tasks
task_list = [
    tasks.glacier_masks,
    tasks.compute_centerlines,
    tasks.initialize_flowlines,
    tasks.compute_downstream_line,
    tasks.compute_downstream_bedshape,
    tasks.catchment_area,
    tasks.catchment_intersections,
    tasks.catchment_width_geom,
    tasks.catchment_width_correction,
    ]
for task in task_list:
  execute_entity_task(task, gdirs)

# Climate tasks -- processing of cru and cesm data, t* interpolation
execute_entity_task(tasks.process_cru_data, gdirs) # CRU data is needed for run_from_gcm

# Check CESM inputs files
cesm_files_list = [ 
    'TREFHT_Amon_CCSM4_LM_r1i1p1_085001-200512.nc',
    'PREC_Amon_CCSM4_LM_r1i1p1_085001-200512.nc',
    ]   
# Check BCC-CSM inputs files
bcccsm_files_list = [
    'TREFHT_Amon_bcc-csm1-1_LM_r1i1p1_085001-200512.nc',
    'PREC_Amon_bcc-csm1-1_LM_r1i1p1_085001-200512.nc',
    ]
# Check GISS inputs files
giss_files_list = [
    'TREFHT_Amon_GISS-E2-R_LM_r1i1p121_085001-200512.nc',
    'PREC_Amon_GISS-E2-R_LM_r1i1p121_085001-200512.nc',
    ]
# Check MPI inputs files
mpi_files_list = [
    'TREFHT_Amon_MPI-ESM-P_LM_r1i1p1_085001-200512.nc',
    'PREC_Amon_MPI-ESM-P_LM_r1i1p1_085001-200512.nc',
    ]
# Check IPSL inputs files
ipsl_files_list = [ 
    'TREFHT_Amon_IPSL-CM5A-LR_LM_r1i1p1_085001-200512.nc',
    'PREC_Amon_IPSL-CM5A-LR_LM_r1i1p1_085001-200512.nc',
    ]

# Select the list
if GCM == 'cesm':
  gcm_files_list = cesm_files_list
elif GCM == 'bcc-csm':
  gcm_files_list = bcccsm_files_list 
elif GCM == 'giss':
  gcm_files_list = giss_files_list
elif GCM == 'ipsl':
  gcm_files_list = ipsl_files_list
elif GCM == 'mpi':
  gcm_files_list = mpi_files_list
else:
  log.info('OGGM: problem in list selection')
  gcm_files_list = cesm_files_list

# Check GCM inputs files
gcm_dir = cfg.PATHS['rgi_dir'] + '/../mod/' + GCM + '/'
pathlib.Path(gcm_dir).mkdir(parents=True, exist_ok=True) 
if ENS:
  gcm_files_list = [
      'TREFHT.085001-200512',
      'PRECP.085001-200512',
      ]
  gcm_dir = gcm_dir + fens
  wkdir = cfg.PATHS['working_dir']
  for e in range(1, (iens+1)):
    print("Member is %d / %d" % (e, iens))
    if e < 10:
      mbmsuf = "00" + str(e)
    elif e < 100:
      mbmsuf = "0" + str(e)
    else:
      mbmsuf = str(e)
    cfg.PATHS['gcm_temp_file'] = path.join(gcm_dir, gcm_files_list[0] + '_' + mbmsuf + '.nc')
    print("Temp file is %s" % (cfg.PATHS['gcm_temp_file']))
    cfg.PATHS['gcm_precp_file'] = path.join(gcm_dir, gcm_files_list[1] + '_' + mbmsuf + '.nc')
    outdir = wkdir + '/' + fens + mbmsuf
    pathlib.Path(outdir).mkdir(parents=True, exist_ok=True)
    print("Output dir is %s" % (outdir))
    cfg.PATHS['working_dir'] = outdir
    #
    run_from_climate(gdirs, filesuffix, GCM, EQM, SPIN)
else:
  # Check forcings inputs files
  for gcm_file in gcm_files_list:
    test_file = path.join(gcm_dir, gcm_file)
    print("Check %s" % (test_file))
    if not path.exists(test_file):
      #url = 'https://nextcloud.cism.ucl.ac.be/s/1rB3hFWp3d2kq10/download?path=%2F' + GCM + '&files='
      url = 'http://www.climate.be/oggm/mod/' + GCM + '/'
      dfile = url + gcm_file
      print("Downloading %s" % (gcm_file))
      ofile = utils.file_downloader(dfile,reset=True)
      shutil.copyfile(ofile, test_file)
  cfg.PATHS['gcm_temp_file'] = path.join(gcm_dir, gcm_files_list[0])
  cfg.PATHS['gcm_precp_file'] = path.join(gcm_dir, gcm_files_list[1])
  #
  run_from_climate(gdirs, filesuffix, GCM, EQM, SPIN) 

# Log
m, s = divmod(time.time() - start, 60)
h, m = divmod(m, 60)
log.info("OGGM is done! Time needed: %d:%02d:%02d" % (h, m, s))

OGGM / oggm

about: ValueError: cannot reshape array of size 1 into shape (13872,) #675