Source code for smash.solver._mwd_input_data
"""
Module mwd_input_data
Defined at smash/solver/derived_type/mwd_input_data.f90 lines 23-79
This module `mwd_input_data` encapsulates all SMASH input_data.
This module is wrapped and differentiated.
Input_DataDT type:
</> Public
======================== =======================================
`Variables` Description
======================== =======================================
``qobs`` Oberserved discharge at gauge [m3/s]
``prcp`` Precipitation field [mm]
``pet`` Potential evapotranspiration field [mm]
``descriptor`` Descriptor map(s) field [(descriptor dependent)]
``sparse_prcp`` Sparse precipitation field [mm]
``sparse_pet`` Spase potential evapotranspiration field [mm]
``mean_prcp`` Mean precipitation at gauge [mm]
``mean_pet`` Mean potential evapotranspiration at gauge [mm]
======================== =======================================
contains
[1] Input_DataDT_initialise
"""
from __future__ import print_function, absolute_import, division
from smash.solver._mw_derived_type_copy import copy_input_data
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 = {}
[docs]@f90wrap.runtime.register_class("solver.Input_DataDT")
class Input_DataDT(f90wrap.runtime.FortranDerivedType):
"""
Type(name=input_datadt)
Defined at smash/solver/derived_type/mwd_input_data.f90 lines 28-39
Notes
-----
Input_DataDT Derived Type.
"""
def __init__(self, setup, mesh, handle=None):
"""
self = Input_Datadt(setup, mesh)
Defined at smash/solver/derived_type/mwd_input_data.f90 lines 42-79
Parameters
----------
setup : Setupdt
mesh : Meshdt
Returns
-------
this : Input_Datadt
Notes
-----
Input_DataDT initialisation subroutine.
only: sp
only: SetupDT
only: MeshDT
"""
f90wrap.runtime.FortranDerivedType.__init__(self)
result = _solver.f90wrap_input_datadt_initialise(setup=setup._handle, \
mesh=mesh._handle)
self._handle = result[0] if isinstance(result, tuple) else result
def __del__(self):
"""
Destructor for class Input_Datadt
Defined at smash/solver/derived_type/mwd_input_data.f90 lines 28-39
Parameters
----------
this : Input_Datadt
Object to be destructed
Automatically generated destructor for input_datadt
"""
if self._alloc:
try:
_solver.f90wrap_input_datadt_finalise(this=self._handle)
except:
pass
def copy(self):
return copy_input_data(self)
@property
def qobs(self):
"""
Element qobs ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 32
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__qobs(self._handle)
if array_handle in self._arrays:
qobs = self._arrays[array_handle]
else:
qobs = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__qobs)
self._arrays[array_handle] = qobs
return qobs
@qobs.setter
def qobs(self, qobs):
self.qobs[...] = qobs
@property
def prcp(self):
"""
Element prcp ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 33
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__prcp(self._handle)
if array_handle in self._arrays:
prcp = self._arrays[array_handle]
else:
prcp = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__prcp)
self._arrays[array_handle] = prcp
return prcp
@prcp.setter
def prcp(self, prcp):
self.prcp[...] = prcp
@property
def pet(self):
"""
Element pet ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 34
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__pet(self._handle)
if array_handle in self._arrays:
pet = self._arrays[array_handle]
else:
pet = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__pet)
self._arrays[array_handle] = pet
return pet
@pet.setter
def pet(self, pet):
self.pet[...] = pet
@property
def descriptor(self):
"""
Element descriptor ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 35
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__descriptor(self._handle)
if array_handle in self._arrays:
descriptor = self._arrays[array_handle]
else:
descriptor = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__descriptor)
self._arrays[array_handle] = descriptor
return descriptor
@descriptor.setter
def descriptor(self, descriptor):
self.descriptor[...] = descriptor
@property
def sparse_prcp(self):
"""
Element sparse_prcp ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 36
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__sparse_prcp(self._handle)
if array_handle in self._arrays:
sparse_prcp = self._arrays[array_handle]
else:
sparse_prcp = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__sparse_prcp)
self._arrays[array_handle] = sparse_prcp
return sparse_prcp
@sparse_prcp.setter
def sparse_prcp(self, sparse_prcp):
self.sparse_prcp[...] = sparse_prcp
@property
def sparse_pet(self):
"""
Element sparse_pet ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 37
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__sparse_pet(self._handle)
if array_handle in self._arrays:
sparse_pet = self._arrays[array_handle]
else:
sparse_pet = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__sparse_pet)
self._arrays[array_handle] = sparse_pet
return sparse_pet
@sparse_pet.setter
def sparse_pet(self, sparse_pet):
self.sparse_pet[...] = sparse_pet
@property
def mean_prcp(self):
"""
Element mean_prcp ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 38
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__mean_prcp(self._handle)
if array_handle in self._arrays:
mean_prcp = self._arrays[array_handle]
else:
mean_prcp = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__mean_prcp)
self._arrays[array_handle] = mean_prcp
return mean_prcp
@mean_prcp.setter
def mean_prcp(self, mean_prcp):
self.mean_prcp[...] = mean_prcp
@property
def mean_pet(self):
"""
Element mean_pet ftype=real(sp) pytype=float
Defined at smash/solver/derived_type/mwd_input_data.f90 line 39
"""
array_ndim, array_type, array_shape, array_handle = \
_solver.f90wrap_input_datadt__array__mean_pet(self._handle)
if array_handle in self._arrays:
mean_pet = self._arrays[array_handle]
else:
mean_pet = f90wrap.runtime.get_array(f90wrap.runtime.sizeof_fortran_t,
self._handle,
_solver.f90wrap_input_datadt__array__mean_pet)
self._arrays[array_handle] = mean_pet
return mean_pet
@mean_pet.setter
def mean_pet(self, mean_pet):
self.mean_pet[...] = mean_pet
def __str__(self):
ret = ['<input_datadt>{\n']
ret.append(' qobs : ')
ret.append(repr(self.qobs))
ret.append(',\n prcp : ')
ret.append(repr(self.prcp))
ret.append(',\n pet : ')
ret.append(repr(self.pet))
ret.append(',\n descriptor : ')
ret.append(repr(self.descriptor))
ret.append(',\n sparse_prcp : ')
ret.append(repr(self.sparse_prcp))
ret.append(',\n sparse_pet : ')
ret.append(repr(self.sparse_pet))
ret.append(',\n mean_prcp : ')
ret.append(repr(self.mean_prcp))
ret.append(',\n mean_pet : ')
ret.append(repr(self.mean_pet))
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_input_data".')
for func in _dt_array_initialisers:
func()