"""
Module mwd_setup
Defined at smash/solver/derived_type/mwd_setup.f90 lines 48-164
This module `mwd_setup` encapsulates all SMASH setup.
This module is wrapped and differentiated.
SetupDT type:
</> Public
========================== =====================================
`Variables` Description
========================== =====================================
``dt`` Solver time step [s] (default: 3600)
``start_time`` Simulation start time [%Y%m%d%H%M] (default: '...')
``end_time`` Simulation end time [%Y%m%d%H%M] (default: '...')
``sparse_storage`` Forcing sparse storage(default: .false.)
``read_qobs`` Read observed discharge(default: .false.)
``qobs_directory`` Observed discharge directory path(default: '...')
``read_prcp`` Read precipitation(default: .false.)
``prcp_format`` Precipitation format(default: 'tif')
``prcp_yyyymmdd_access`` Access with absolute path(YYYY/MM/dd/) (default: \
.false.)
``prcp_conversion_factor`` Precipitation conversion factor(default: 1)
``prcp_directory`` Precipiation directory path(default: '...')
``read_pet`` Reap potential evapotranspiration(default: .false.)
``pet_format`` Potential evapotranspiration format(default: 'tif')
``pet_conversion_factor`` Potential evapotranpisration conversion \
factor(default: 1)
``pet_directory`` Potential evapotranspiration directory path(default: '...')
``daily_interannual_pet`` Read daily interannual potential \
evapotranspiration(default: .false.)
``mean_forcing`` Compute mean forcing(default: .true.)
``read_descriptor`` Read descriptor map(s) (default: .false.)
``descriptor_format`` Descriptor map(s) format(default: .false.)
``descriptor_directory`` Descriptor map(s) directory(default: "...")
``descriptor_name`` Descriptor map(s) names
``save_qsim_domain`` Save simulated discharge on the domain(default: .false.)
``save_net_prcp_domain`` Save net precipitation on the domain(default: .false.)
</> Private
========================== =====================================
`Variables` Description
========================== =====================================
``optimize`` Optimize_SetupDT which contains all optimize options
``ntime_step`` Number of time step
``nd`` Number of descriptor map(s)
``name_parameters`` Name of SMASH parameters(default: see below)
``name_states`` Name of SMASH states(default: see below)
========================= =====================================
contains
[1] SetupDT_initialise
"""
from __future__ import print_function, absolute_import, division
from smash.solver._mw_derived_type_copy import copy_setup
from smash.solver._f90wrap_decorator import char_array_getter_handler, char_array_setter_handler
from smash.solver._f90wrap_decorator import char_getter_handler
from smash.solver._f90wrap_decorator import getter_index_handler, setter_index_handler
from smash.solver import _solver
import f90wrap.runtime
import logging
import numpy
_arrays = {}
_objs = {}
@f90wrap.runtime.register_class("solver.Optimize_SetupDT")
class Optimize_SetupDT(f90wrap.runtime.FortranDerivedType):
"""
Type(name=optimize_setupdt)
Defined at smash/solver/derived_type/mwd_setup.f90 lines 53-80
Notes
-----
Optimize_SetupDT Derived Type.
"""
def __init__(self, ntime_step, nd, ng, mapping, njf, njr, handle=None):
"""
self = Optimize_Setupdt(ntime_step, nd, ng, mapping, njf, njr)
Defined at smash/solver/derived_type/mwd_setup.f90 lines 118-150
Parameters
----------
ntime_step : int
nd : int
ng : int
mapping : str
njf : int
njr : int
Returns
-------
this : Optimize_Setupdt
Notes
-----
Optimize_SetupDT initialisation subroutine
only: sp, lchar, &
& G_NP, G_NS, GPARAMETERS_NAME, GSTATES_NAME, &
& GLB_PARAMETERS, GUB_PARAMETERS, GLB_STATES, GUB_STATES
"""
f90wrap.runtime.FortranDerivedType.__init__(self)
result = _solver.f90wrap_optimize_setupdt_initialise(ntime_step=ntime_step, \
nd=nd, ng=ng, mapping=mapping, njf=njf, njr=njr)
self._handle = result[0] if isinstance(result, tuple) else result
def __del__(self):
"""
Destructor for class Optimize_Setupdt
Defined at smash/solver/derived_type/mwd_setup.f90 lines 53-80
Parameters
----------
this : Optimize_Setupdt
Object to be destructed
Automatically generated destructor for optimize_setupdt
"""
if self._alloc:
try:
_solver.f90wrap_optimize_setupdt_finalise(this=self._handle)
except:
pass
@property
@char_getter_handler
def algorithm(self):
"""
Element algorithm ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 57
"""
return _solver.f90wrap_optimize_setupdt__get__algorithm(self._handle)
@algorithm.setter
def algorithm(self, algorithm):
_solver.f90wrap_optimize_setupdt__set__algorithm(self._handle, algorithm)
@property
@char_array_getter_handler
def jobs_fun(self):
"""
Element jobs_fun ftype=character(20) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 58
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__jobs_fun(self._handle)
if array_handle in self._arrays:
jobs_fun = self._arrays[array_handle]
else:
jobs_fun = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__jobs_fun)
self._arrays[array_handle] = jobs_fun
return jobs_fun
@jobs_fun.setter
@char_array_setter_handler
def jobs_fun(self, jobs_fun):
self.jobs_fun[...] = jobs_fun
@property
def wjobs_fun(self):
"""
Element wjobs_fun ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 59
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__wjobs_fun(self._handle)
if array_handle in self._arrays:
wjobs_fun = self._arrays[array_handle]
else:
wjobs_fun = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__wjobs_fun)
self._arrays[array_handle] = wjobs_fun
return wjobs_fun
@wjobs_fun.setter
def wjobs_fun(self, wjobs_fun):
self.wjobs_fun[...] = wjobs_fun
@property
def wjreg(self):
"""
Element wjreg ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 60
"""
return _solver.f90wrap_optimize_setupdt__get__wjreg(self._handle)
@wjreg.setter
def wjreg(self, wjreg):
_solver.f90wrap_optimize_setupdt__set__wjreg(self._handle, wjreg)
@property
@char_array_getter_handler
def jreg_fun(self):
"""
Element jreg_fun ftype=character(20) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 61
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__jreg_fun(self._handle)
if array_handle in self._arrays:
jreg_fun = self._arrays[array_handle]
else:
jreg_fun = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__jreg_fun)
self._arrays[array_handle] = jreg_fun
return jreg_fun
@jreg_fun.setter
@char_array_setter_handler
def jreg_fun(self, jreg_fun):
self.jreg_fun[...] = jreg_fun
@property
def wjreg_fun(self):
"""
Element wjreg_fun ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 62
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__wjreg_fun(self._handle)
if array_handle in self._arrays:
wjreg_fun = self._arrays[array_handle]
else:
wjreg_fun = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__wjreg_fun)
self._arrays[array_handle] = wjreg_fun
return wjreg_fun
@wjreg_fun.setter
def wjreg_fun(self, wjreg_fun):
self.wjreg_fun[...] = wjreg_fun
@property
def reg_descriptors_for_params(self):
"""
Element reg_descriptors_for_params ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 63
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__reg_descriptors_for_params(self._handle)
if array_handle in self._arrays:
reg_descriptors_for_params = self._arrays[array_handle]
else:
reg_descriptors_for_params = \
f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__reg_descriptors_for_params)
self._arrays[array_handle] = reg_descriptors_for_params
return reg_descriptors_for_params
@reg_descriptors_for_params.setter
def reg_descriptors_for_params(self, reg_descriptors_for_params):
self.reg_descriptors_for_params[...] = reg_descriptors_for_params
@property
def reg_descriptors_for_states(self):
"""
Element reg_descriptors_for_states ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 64
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__reg_descriptors_for_states(self._handle)
if array_handle in self._arrays:
reg_descriptors_for_states = self._arrays[array_handle]
else:
reg_descriptors_for_states = \
f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__reg_descriptors_for_states)
self._arrays[array_handle] = reg_descriptors_for_states
return reg_descriptors_for_states
@reg_descriptors_for_states.setter
def reg_descriptors_for_states(self, reg_descriptors_for_states):
self.reg_descriptors_for_states[...] = reg_descriptors_for_states
@property
def njf(self):
"""
Element njf ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 65
"""
return _solver.f90wrap_optimize_setupdt__get__njf(self._handle)
@njf.setter
def njf(self, njf):
_solver.f90wrap_optimize_setupdt__set__njf(self._handle, njf)
@property
def njr(self):
"""
Element njr ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 66
"""
return _solver.f90wrap_optimize_setupdt__get__njr(self._handle)
@njr.setter
def njr(self, njr):
_solver.f90wrap_optimize_setupdt__set__njr(self._handle, njr)
@property
def verbose(self):
"""
Element verbose ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 67
"""
return _solver.f90wrap_optimize_setupdt__get__verbose(self._handle)
@verbose.setter
def verbose(self, verbose):
_solver.f90wrap_optimize_setupdt__set__verbose(self._handle, verbose)
@property
@char_getter_handler
def mapping(self):
"""
Element mapping ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 68
"""
return _solver.f90wrap_optimize_setupdt__get__mapping(self._handle)
@mapping.setter
def mapping(self, mapping):
_solver.f90wrap_optimize_setupdt__set__mapping(self._handle, mapping)
@property
def denormalize_forward(self):
"""
Element denormalize_forward ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 69
"""
return _solver.f90wrap_optimize_setupdt__get__denormalize_forward(self._handle)
@denormalize_forward.setter
def denormalize_forward(self, denormalize_forward):
_solver.f90wrap_optimize_setupdt__set__denormalize_forward(self._handle, \
denormalize_forward)
@property
def nhyper(self):
"""
Element nhyper ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 70
"""
return _solver.f90wrap_optimize_setupdt__get__nhyper(self._handle)
@nhyper.setter
def nhyper(self, nhyper):
_solver.f90wrap_optimize_setupdt__set__nhyper(self._handle, nhyper)
@property
def optimize_start_step(self):
"""
Element optimize_start_step ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 71
"""
return _solver.f90wrap_optimize_setupdt__get__optimize_start_step(self._handle)
@optimize_start_step.setter
def optimize_start_step(self, optimize_start_step):
_solver.f90wrap_optimize_setupdt__set__optimize_start_step(self._handle, \
optimize_start_step)
@property
def maxiter(self):
"""
Element maxiter ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 72
"""
return _solver.f90wrap_optimize_setupdt__get__maxiter(self._handle)
@maxiter.setter
def maxiter(self, maxiter):
_solver.f90wrap_optimize_setupdt__set__maxiter(self._handle, maxiter)
@property
def optim_parameters(self):
"""
Element optim_parameters ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 73
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__optim_parameters(self._handle)
if array_handle in self._arrays:
optim_parameters = self._arrays[array_handle]
else:
optim_parameters = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__optim_parameters)
self._arrays[array_handle] = optim_parameters
return optim_parameters
@optim_parameters.setter
def optim_parameters(self, optim_parameters):
self.optim_parameters[...] = optim_parameters
@property
def optim_states(self):
"""
Element optim_states ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 74
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__optim_states(self._handle)
if array_handle in self._arrays:
optim_states = self._arrays[array_handle]
else:
optim_states = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__optim_states)
self._arrays[array_handle] = optim_states
return optim_states
@optim_states.setter
def optim_states(self, optim_states):
self.optim_states[...] = optim_states
@property
def lb_parameters(self):
"""
Element lb_parameters ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 75
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__lb_parameters(self._handle)
if array_handle in self._arrays:
lb_parameters = self._arrays[array_handle]
else:
lb_parameters = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__lb_parameters)
self._arrays[array_handle] = lb_parameters
return lb_parameters
@lb_parameters.setter
def lb_parameters(self, lb_parameters):
self.lb_parameters[...] = lb_parameters
@property
def ub_parameters(self):
"""
Element ub_parameters ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 76
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__ub_parameters(self._handle)
if array_handle in self._arrays:
ub_parameters = self._arrays[array_handle]
else:
ub_parameters = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__ub_parameters)
self._arrays[array_handle] = ub_parameters
return ub_parameters
@ub_parameters.setter
def ub_parameters(self, ub_parameters):
self.ub_parameters[...] = ub_parameters
@property
def lb_states(self):
"""
Element lb_states ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 77
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__lb_states(self._handle)
if array_handle in self._arrays:
lb_states = self._arrays[array_handle]
else:
lb_states = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__lb_states)
self._arrays[array_handle] = lb_states
return lb_states
@lb_states.setter
def lb_states(self, lb_states):
self.lb_states[...] = lb_states
@property
def ub_states(self):
"""
Element ub_states ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 78
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__ub_states(self._handle)
if array_handle in self._arrays:
ub_states = self._arrays[array_handle]
else:
ub_states = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__ub_states)
self._arrays[array_handle] = ub_states
return ub_states
@ub_states.setter
def ub_states(self, ub_states):
self.ub_states[...] = ub_states
@property
def wgauge(self):
"""
Element wgauge ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 79
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__wgauge(self._handle)
if array_handle in self._arrays:
wgauge = self._arrays[array_handle]
else:
wgauge = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__wgauge)
self._arrays[array_handle] = wgauge
return wgauge
@wgauge.setter
def wgauge(self, wgauge):
self.wgauge[...] = wgauge
@property
def mask_event(self):
"""
Element mask_event ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 80
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_optimize_setupdt__array__mask_event(self._handle)
if array_handle in self._arrays:
mask_event = self._arrays[array_handle]
else:
mask_event = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_optimize_setupdt__array__mask_event)
self._arrays[array_handle] = mask_event
return mask_event
@mask_event.setter
def mask_event(self, mask_event):
self.mask_event[...] = mask_event
def __str__(self):
ret = ['<optimize_setupdt>{\n']
ret.append(' algorithm : ')
ret.append(repr(self.algorithm))
ret.append(',\n jobs_fun : ')
ret.append(repr(self.jobs_fun))
ret.append(',\n wjobs_fun : ')
ret.append(repr(self.wjobs_fun))
ret.append(',\n wjreg : ')
ret.append(repr(self.wjreg))
ret.append(',\n jreg_fun : ')
ret.append(repr(self.jreg_fun))
ret.append(',\n wjreg_fun : ')
ret.append(repr(self.wjreg_fun))
ret.append(',\n reg_descriptors_for_params : ')
ret.append(repr(self.reg_descriptors_for_params))
ret.append(',\n reg_descriptors_for_states : ')
ret.append(repr(self.reg_descriptors_for_states))
ret.append(',\n njf : ')
ret.append(repr(self.njf))
ret.append(',\n njr : ')
ret.append(repr(self.njr))
ret.append(',\n verbose : ')
ret.append(repr(self.verbose))
ret.append(',\n mapping : ')
ret.append(repr(self.mapping))
ret.append(',\n denormalize_forward : ')
ret.append(repr(self.denormalize_forward))
ret.append(',\n nhyper : ')
ret.append(repr(self.nhyper))
ret.append(',\n optimize_start_step : ')
ret.append(repr(self.optimize_start_step))
ret.append(',\n maxiter : ')
ret.append(repr(self.maxiter))
ret.append(',\n optim_parameters : ')
ret.append(repr(self.optim_parameters))
ret.append(',\n optim_states : ')
ret.append(repr(self.optim_states))
ret.append(',\n lb_parameters : ')
ret.append(repr(self.lb_parameters))
ret.append(',\n ub_parameters : ')
ret.append(repr(self.ub_parameters))
ret.append(',\n lb_states : ')
ret.append(repr(self.lb_states))
ret.append(',\n ub_states : ')
ret.append(repr(self.ub_states))
ret.append(',\n wgauge : ')
ret.append(repr(self.wgauge))
ret.append(',\n mask_event : ')
ret.append(repr(self.mask_event))
ret.append('}')
return ''.join(ret)
_dt_array_initialisers = []
[docs]@f90wrap.runtime.register_class("solver.SetupDT")
class SetupDT(f90wrap.runtime.FortranDerivedType):
"""
Type(name=setupdt)
Defined at smash/solver/derived_type/mwd_setup.f90 lines 82-115
Notes
-----
SetupDT Derived Type.
"""
def __init__(self, nd, ng, handle=None):
"""
self = Setupdt(nd, ng)
Defined at smash/solver/derived_type/mwd_setup.f90 lines 152-164
Parameters
----------
nd : int
ng : int
Returns
-------
this : Setupdt
Notes
-----
SetupDT initialisation subroutine
"""
f90wrap.runtime.FortranDerivedType.__init__(self)
result = _solver.f90wrap_setupdt_initialise(nd=nd, ng=ng)
self._handle = result[0] if isinstance(result, tuple) else result
def __del__(self):
"""
Destructor for class Setupdt
Defined at smash/solver/derived_type/mwd_setup.f90 lines 82-115
Parameters
----------
this : Setupdt
Object to be destructed
Automatically generated destructor for setupdt
"""
if self._alloc:
try:
_solver.f90wrap_setupdt_finalise(this=self._handle)
except:
pass
def copy(self):
return copy_setup(self)
@property
@char_getter_handler
def structure(self):
"""
Element structure ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 86
"""
return _solver.f90wrap_setupdt__get__structure(self._handle)
@structure.setter
def structure(self, structure):
_solver.f90wrap_setupdt__set__structure(self._handle, structure)
@property
def dt(self):
"""
Element dt ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 87
"""
return _solver.f90wrap_setupdt__get__dt(self._handle)
@dt.setter
def dt(self, dt):
_solver.f90wrap_setupdt__set__dt(self._handle, dt)
@property
@char_getter_handler
def start_time(self):
"""
Element start_time ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 88
"""
return _solver.f90wrap_setupdt__get__start_time(self._handle)
@start_time.setter
def start_time(self, start_time):
_solver.f90wrap_setupdt__set__start_time(self._handle, start_time)
@property
@char_getter_handler
def end_time(self):
"""
Element end_time ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 89
"""
return _solver.f90wrap_setupdt__get__end_time(self._handle)
@end_time.setter
def end_time(self, end_time):
_solver.f90wrap_setupdt__set__end_time(self._handle, end_time)
@property
def sparse_storage(self):
"""
Element sparse_storage ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 90
"""
return _solver.f90wrap_setupdt__get__sparse_storage(self._handle)
@sparse_storage.setter
def sparse_storage(self, sparse_storage):
_solver.f90wrap_setupdt__set__sparse_storage(self._handle, sparse_storage)
@property
def read_qobs(self):
"""
Element read_qobs ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 91
"""
return _solver.f90wrap_setupdt__get__read_qobs(self._handle)
@read_qobs.setter
def read_qobs(self, read_qobs):
_solver.f90wrap_setupdt__set__read_qobs(self._handle, read_qobs)
@property
@char_getter_handler
def qobs_directory(self):
"""
Element qobs_directory ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 92
"""
return _solver.f90wrap_setupdt__get__qobs_directory(self._handle)
@qobs_directory.setter
def qobs_directory(self, qobs_directory):
_solver.f90wrap_setupdt__set__qobs_directory(self._handle, qobs_directory)
@property
def read_prcp(self):
"""
Element read_prcp ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 93
"""
return _solver.f90wrap_setupdt__get__read_prcp(self._handle)
@read_prcp.setter
def read_prcp(self, read_prcp):
_solver.f90wrap_setupdt__set__read_prcp(self._handle, read_prcp)
@property
@char_getter_handler
def prcp_format(self):
"""
Element prcp_format ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 94
"""
return _solver.f90wrap_setupdt__get__prcp_format(self._handle)
@prcp_format.setter
def prcp_format(self, prcp_format):
_solver.f90wrap_setupdt__set__prcp_format(self._handle, prcp_format)
@property
def prcp_yyyymmdd_access(self):
"""
Element prcp_yyyymmdd_access ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 95
"""
return _solver.f90wrap_setupdt__get__prcp_yyyymmdd_access(self._handle)
@prcp_yyyymmdd_access.setter
def prcp_yyyymmdd_access(self, prcp_yyyymmdd_access):
_solver.f90wrap_setupdt__set__prcp_yyyymmdd_access(self._handle, \
prcp_yyyymmdd_access)
@property
def prcp_conversion_factor(self):
"""
Element prcp_conversion_factor ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 96
"""
return _solver.f90wrap_setupdt__get__prcp_conversion_factor(self._handle)
@prcp_conversion_factor.setter
def prcp_conversion_factor(self, prcp_conversion_factor):
_solver.f90wrap_setupdt__set__prcp_conversion_factor(self._handle, \
prcp_conversion_factor)
@property
@char_getter_handler
def prcp_directory(self):
"""
Element prcp_directory ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 97
"""
return _solver.f90wrap_setupdt__get__prcp_directory(self._handle)
@prcp_directory.setter
def prcp_directory(self, prcp_directory):
_solver.f90wrap_setupdt__set__prcp_directory(self._handle, prcp_directory)
@property
def read_pet(self):
"""
Element read_pet ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 98
"""
return _solver.f90wrap_setupdt__get__read_pet(self._handle)
@read_pet.setter
def read_pet(self, read_pet):
_solver.f90wrap_setupdt__set__read_pet(self._handle, read_pet)
@property
@char_getter_handler
def pet_format(self):
"""
Element pet_format ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 99
"""
return _solver.f90wrap_setupdt__get__pet_format(self._handle)
@pet_format.setter
def pet_format(self, pet_format):
_solver.f90wrap_setupdt__set__pet_format(self._handle, pet_format)
@property
def pet_conversion_factor(self):
"""
Element pet_conversion_factor ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_setup.f90 line 100
"""
return _solver.f90wrap_setupdt__get__pet_conversion_factor(self._handle)
@pet_conversion_factor.setter
def pet_conversion_factor(self, pet_conversion_factor):
_solver.f90wrap_setupdt__set__pet_conversion_factor(self._handle, \
pet_conversion_factor)
@property
@char_getter_handler
def pet_directory(self):
"""
Element pet_directory ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 101
"""
return _solver.f90wrap_setupdt__get__pet_directory(self._handle)
@pet_directory.setter
def pet_directory(self, pet_directory):
_solver.f90wrap_setupdt__set__pet_directory(self._handle, pet_directory)
@property
def daily_interannual_pet(self):
"""
Element daily_interannual_pet ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 102
"""
return _solver.f90wrap_setupdt__get__daily_interannual_pet(self._handle)
@daily_interannual_pet.setter
def daily_interannual_pet(self, daily_interannual_pet):
_solver.f90wrap_setupdt__set__daily_interannual_pet(self._handle, \
daily_interannual_pet)
@property
def mean_forcing(self):
"""
Element mean_forcing ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 103
"""
return _solver.f90wrap_setupdt__get__mean_forcing(self._handle)
@mean_forcing.setter
def mean_forcing(self, mean_forcing):
_solver.f90wrap_setupdt__set__mean_forcing(self._handle, mean_forcing)
@property
def read_descriptor(self):
"""
Element read_descriptor ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 104
"""
return _solver.f90wrap_setupdt__get__read_descriptor(self._handle)
@read_descriptor.setter
def read_descriptor(self, read_descriptor):
_solver.f90wrap_setupdt__set__read_descriptor(self._handle, read_descriptor)
@property
@char_getter_handler
def descriptor_format(self):
"""
Element descriptor_format ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 105
"""
return _solver.f90wrap_setupdt__get__descriptor_format(self._handle)
@descriptor_format.setter
def descriptor_format(self, descriptor_format):
_solver.f90wrap_setupdt__set__descriptor_format(self._handle, descriptor_format)
@property
@char_getter_handler
def descriptor_directory(self):
"""
Element descriptor_directory ftype=character(lchar) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 106
"""
return _solver.f90wrap_setupdt__get__descriptor_directory(self._handle)
@descriptor_directory.setter
def descriptor_directory(self, descriptor_directory):
_solver.f90wrap_setupdt__set__descriptor_directory(self._handle, \
descriptor_directory)
@property
@char_array_getter_handler
def descriptor_name(self):
"""
Element descriptor_name ftype=character(20) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 107
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_setupdt__array__descriptor_name(self._handle)
if array_handle in self._arrays:
descriptor_name = self._arrays[array_handle]
else:
descriptor_name = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_setupdt__array__descriptor_name)
self._arrays[array_handle] = descriptor_name
return descriptor_name
@descriptor_name.setter
@char_array_setter_handler
def descriptor_name(self, descriptor_name):
self.descriptor_name[...] = descriptor_name
@property
def save_qsim_domain(self):
"""
Element save_qsim_domain ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 108
"""
return _solver.f90wrap_setupdt__get__save_qsim_domain(self._handle)
@save_qsim_domain.setter
def save_qsim_domain(self, save_qsim_domain):
_solver.f90wrap_setupdt__set__save_qsim_domain(self._handle, save_qsim_domain)
@property
def save_net_prcp_domain(self):
"""
Element save_net_prcp_domain ftype=logical pytype=bool
Defined at smash/solver/derived_type/mwd_setup.f90 line 109
"""
return _solver.f90wrap_setupdt__get__save_net_prcp_domain(self._handle)
@save_net_prcp_domain.setter
def save_net_prcp_domain(self, save_net_prcp_domain):
_solver.f90wrap_setupdt__set__save_net_prcp_domain(self._handle, \
save_net_prcp_domain)
@property
def _optimize(self):
"""
Element optimize ftype=type(optimize_setupdt) pytype=Optimize_Setupdt
Defined at smash/solver/derived_type/mwd_setup.f90 line 110
"""
optimize_handle = _solver.f90wrap_setupdt__get__optimize(self._handle)
if tuple(optimize_handle) in self._objs:
optimize = self._objs[tuple(optimize_handle)]
else:
optimize = Optimize_SetupDT.from_handle(optimize_handle)
self._objs[tuple(optimize_handle)] = optimize
return optimize
@_optimize.setter
def _optimize(self, optimize):
optimize = optimize._handle
_solver.f90wrap_setupdt__set__optimize(self._handle, optimize)
@property
def _ntime_step(self):
"""
Element ntime_step ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 111
"""
return _solver.f90wrap_setupdt__get__ntime_step(self._handle)
@_ntime_step.setter
def _ntime_step(self, ntime_step):
_solver.f90wrap_setupdt__set__ntime_step(self._handle, ntime_step)
@property
def _nd(self):
"""
Element nd ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 112
"""
return _solver.f90wrap_setupdt__get__nd(self._handle)
@_nd.setter
def _nd(self, nd):
_solver.f90wrap_setupdt__set__nd(self._handle, nd)
@property
def _ncpu(self):
"""
Element ncpu ftype=integer pytype=int
Defined at smash/solver/derived_type/mwd_setup.f90 line 113
"""
return _solver.f90wrap_setupdt__get__ncpu(self._handle)
@_ncpu.setter
def _ncpu(self, ncpu):
_solver.f90wrap_setupdt__set__ncpu(self._handle, ncpu)
@property
@char_array_getter_handler
def _parameters_name(self):
"""
Element parameters_name ftype=character(10) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 114
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_setupdt__array__parameters_name(self._handle)
if array_handle in self._arrays:
parameters_name = self._arrays[array_handle]
else:
parameters_name = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_setupdt__array__parameters_name)
self._arrays[array_handle] = parameters_name
return parameters_name
@_parameters_name.setter
@char_array_setter_handler
def _parameters_name(self, parameters_name):
self._parameters_name[...] = parameters_name
@property
@char_array_getter_handler
def _states_name(self):
"""
Element states_name ftype=character(10) pytype=str
Defined at smash/solver/derived_type/mwd_setup.f90 line 115
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_setupdt__array__states_name(self._handle)
if array_handle in self._arrays:
states_name = self._arrays[array_handle]
else:
states_name = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_setupdt__array__states_name)
self._arrays[array_handle] = states_name
return states_name
@_states_name.setter
@char_array_setter_handler
def _states_name(self, states_name):
self._states_name[...] = states_name
def __str__(self):
ret = ['<setupdt>{\n']
ret.append(' structure : ')
ret.append(repr(self.structure))
ret.append(',\n dt : ')
ret.append(repr(self.dt))
ret.append(',\n start_time : ')
ret.append(repr(self.start_time))
ret.append(',\n end_time : ')
ret.append(repr(self.end_time))
ret.append(',\n sparse_storage : ')
ret.append(repr(self.sparse_storage))
ret.append(',\n read_qobs : ')
ret.append(repr(self.read_qobs))
ret.append(',\n qobs_directory : ')
ret.append(repr(self.qobs_directory))
ret.append(',\n read_prcp : ')
ret.append(repr(self.read_prcp))
ret.append(',\n prcp_format : ')
ret.append(repr(self.prcp_format))
ret.append(',\n prcp_yyyymmdd_access : ')
ret.append(repr(self.prcp_yyyymmdd_access))
ret.append(',\n prcp_conversion_factor : ')
ret.append(repr(self.prcp_conversion_factor))
ret.append(',\n prcp_directory : ')
ret.append(repr(self.prcp_directory))
ret.append(',\n read_pet : ')
ret.append(repr(self.read_pet))
ret.append(',\n pet_format : ')
ret.append(repr(self.pet_format))
ret.append(',\n pet_conversion_factor : ')
ret.append(repr(self.pet_conversion_factor))
ret.append(',\n pet_directory : ')
ret.append(repr(self.pet_directory))
ret.append(',\n daily_interannual_pet : ')
ret.append(repr(self.daily_interannual_pet))
ret.append(',\n mean_forcing : ')
ret.append(repr(self.mean_forcing))
ret.append(',\n read_descriptor : ')
ret.append(repr(self.read_descriptor))
ret.append(',\n descriptor_format : ')
ret.append(repr(self.descriptor_format))
ret.append(',\n descriptor_directory : ')
ret.append(repr(self.descriptor_directory))
ret.append(',\n descriptor_name : ')
ret.append(repr(self.descriptor_name))
ret.append(',\n save_qsim_domain : ')
ret.append(repr(self.save_qsim_domain))
ret.append(',\n save_net_prcp_domain : ')
ret.append(repr(self.save_net_prcp_domain))
ret.append('}')
return ''.join(ret)
_dt_array_initialisers = []
_array_initialisers = []
_dt_array_initialisers = []
try:
for func in _array_initialisers:
func()
except ValueError:
logging.debug('unallocated array(s) detected on import of module "mwd_setup".')
for func in _dt_array_initialisers:
func()