repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
brian-rose/climlab
|
climlab/process/process.py
|
get_axes
|
def get_axes(process_or_domain):
"""Returns a dictionary of all Axis in a domain or dictionary of domains.
:param process_or_domain: a process or a domain object
:type process_or_domain: :class:`~climlab.process.process.Process` or
:class:`~climlab.domain.domain._Domain`
:raises: :exc: `TypeError` if input is not or not having a domain
:returns: dictionary of input's Axis
:rtype: dict
:Example:
::
>>> import climlab
>>> from climlab.process.process import get_axes
>>> model = climlab.EBM()
>>> get_axes(model)
{'lat': <climlab.domain.axis.Axis object at 0x7ff13b9dd2d0>,
'depth': <climlab.domain.axis.Axis object at 0x7ff13b9dd310>}
"""
if isinstance(process_or_domain, Process):
dom = process_or_domain.domains
else:
dom = process_or_domain
if isinstance(dom, _Domain):
return dom.axes
elif isinstance(dom, dict):
axes = {}
for thisdom in list(dom.values()):
assert isinstance(thisdom, _Domain)
axes.update(thisdom.axes)
return axes
else:
raise TypeError('dom must be a domain or dictionary of domains.')
|
python
|
def get_axes(process_or_domain):
"""Returns a dictionary of all Axis in a domain or dictionary of domains.
:param process_or_domain: a process or a domain object
:type process_or_domain: :class:`~climlab.process.process.Process` or
:class:`~climlab.domain.domain._Domain`
:raises: :exc: `TypeError` if input is not or not having a domain
:returns: dictionary of input's Axis
:rtype: dict
:Example:
::
>>> import climlab
>>> from climlab.process.process import get_axes
>>> model = climlab.EBM()
>>> get_axes(model)
{'lat': <climlab.domain.axis.Axis object at 0x7ff13b9dd2d0>,
'depth': <climlab.domain.axis.Axis object at 0x7ff13b9dd310>}
"""
if isinstance(process_or_domain, Process):
dom = process_or_domain.domains
else:
dom = process_or_domain
if isinstance(dom, _Domain):
return dom.axes
elif isinstance(dom, dict):
axes = {}
for thisdom in list(dom.values()):
assert isinstance(thisdom, _Domain)
axes.update(thisdom.axes)
return axes
else:
raise TypeError('dom must be a domain or dictionary of domains.')
|
[
"def",
"get_axes",
"(",
"process_or_domain",
")",
":",
"if",
"isinstance",
"(",
"process_or_domain",
",",
"Process",
")",
":",
"dom",
"=",
"process_or_domain",
".",
"domains",
"else",
":",
"dom",
"=",
"process_or_domain",
"if",
"isinstance",
"(",
"dom",
",",
"_Domain",
")",
":",
"return",
"dom",
".",
"axes",
"elif",
"isinstance",
"(",
"dom",
",",
"dict",
")",
":",
"axes",
"=",
"{",
"}",
"for",
"thisdom",
"in",
"list",
"(",
"dom",
".",
"values",
"(",
")",
")",
":",
"assert",
"isinstance",
"(",
"thisdom",
",",
"_Domain",
")",
"axes",
".",
"update",
"(",
"thisdom",
".",
"axes",
")",
"return",
"axes",
"else",
":",
"raise",
"TypeError",
"(",
"'dom must be a domain or dictionary of domains.'",
")"
] |
Returns a dictionary of all Axis in a domain or dictionary of domains.
:param process_or_domain: a process or a domain object
:type process_or_domain: :class:`~climlab.process.process.Process` or
:class:`~climlab.domain.domain._Domain`
:raises: :exc: `TypeError` if input is not or not having a domain
:returns: dictionary of input's Axis
:rtype: dict
:Example:
::
>>> import climlab
>>> from climlab.process.process import get_axes
>>> model = climlab.EBM()
>>> get_axes(model)
{'lat': <climlab.domain.axis.Axis object at 0x7ff13b9dd2d0>,
'depth': <climlab.domain.axis.Axis object at 0x7ff13b9dd310>}
|
[
"Returns",
"a",
"dictionary",
"of",
"all",
"Axis",
"in",
"a",
"domain",
"or",
"dictionary",
"of",
"domains",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L820-L857
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.add_subprocesses
|
def add_subprocesses(self, procdict):
"""Adds a dictionary of subproceses to this process.
Calls :func:`add_subprocess` for every process given in the
input-dictionary. It can also pass a single process, which will
be given the name *default*.
:param procdict: a dictionary with process names as keys
:type procdict: dict
"""
if isinstance(procdict, Process):
try:
name = procdict.name
except:
name = 'default'
self.add_subprocess(name, procdict)
else:
for name, proc in procdict.items():
self.add_subprocess(name, proc)
|
python
|
def add_subprocesses(self, procdict):
"""Adds a dictionary of subproceses to this process.
Calls :func:`add_subprocess` for every process given in the
input-dictionary. It can also pass a single process, which will
be given the name *default*.
:param procdict: a dictionary with process names as keys
:type procdict: dict
"""
if isinstance(procdict, Process):
try:
name = procdict.name
except:
name = 'default'
self.add_subprocess(name, procdict)
else:
for name, proc in procdict.items():
self.add_subprocess(name, proc)
|
[
"def",
"add_subprocesses",
"(",
"self",
",",
"procdict",
")",
":",
"if",
"isinstance",
"(",
"procdict",
",",
"Process",
")",
":",
"try",
":",
"name",
"=",
"procdict",
".",
"name",
"except",
":",
"name",
"=",
"'default'",
"self",
".",
"add_subprocess",
"(",
"name",
",",
"procdict",
")",
"else",
":",
"for",
"name",
",",
"proc",
"in",
"procdict",
".",
"items",
"(",
")",
":",
"self",
".",
"add_subprocess",
"(",
"name",
",",
"proc",
")"
] |
Adds a dictionary of subproceses to this process.
Calls :func:`add_subprocess` for every process given in the
input-dictionary. It can also pass a single process, which will
be given the name *default*.
:param procdict: a dictionary with process names as keys
:type procdict: dict
|
[
"Adds",
"a",
"dictionary",
"of",
"subproceses",
"to",
"this",
"process",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L191-L210
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.add_subprocess
|
def add_subprocess(self, name, proc):
"""Adds a single subprocess to this process.
:param string name: name of the subprocess
:param proc: a Process object
:type proc: :class:`~climlab.process.process.Process`
:raises: :exc:`ValueError`
if ``proc`` is not a process
:Example:
Replacing an albedo subprocess through adding a subprocess with
same name::
>>> from climlab.model.ebm import EBM_seasonal
>>> from climlab.surface.albedo import StepFunctionAlbedo
>>> # creating EBM model
>>> ebm_s = EBM_seasonal()
>>> print ebm_s
.. code-block:: none
:emphasize-lines: 8
climlab Process of type <class 'climlab.model.ebm.EBM_seasonal'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM_seasonal'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.DailyInsolation'>
::
>>> # creating and adding albedo feedback subprocess
>>> step_albedo = StepFunctionAlbedo(state=ebm_s.state, **ebm_s.param)
>>> ebm_s.add_subprocess('albedo', step_albedo)
>>>
>>> print ebm_s
.. code-block:: none
:emphasize-lines: 8
climlab Process of type <class 'climlab.model.ebm.EBM_seasonal'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM_seasonal'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.DailyInsolation'>
"""
if isinstance(proc, Process):
self.subprocess.update({name: proc})
self.has_process_type_list = False
# Add subprocess diagnostics to parent
# (if there are no name conflicts)
for diagname, value in proc.diagnostics.items():
#if not (diagname in self.diagnostics or hasattr(self, diagname)):
# self.add_diagnostic(diagname, value)
self.add_diagnostic(diagname, value)
else:
raise ValueError('subprocess must be Process object')
|
python
|
def add_subprocess(self, name, proc):
"""Adds a single subprocess to this process.
:param string name: name of the subprocess
:param proc: a Process object
:type proc: :class:`~climlab.process.process.Process`
:raises: :exc:`ValueError`
if ``proc`` is not a process
:Example:
Replacing an albedo subprocess through adding a subprocess with
same name::
>>> from climlab.model.ebm import EBM_seasonal
>>> from climlab.surface.albedo import StepFunctionAlbedo
>>> # creating EBM model
>>> ebm_s = EBM_seasonal()
>>> print ebm_s
.. code-block:: none
:emphasize-lines: 8
climlab Process of type <class 'climlab.model.ebm.EBM_seasonal'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM_seasonal'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.DailyInsolation'>
::
>>> # creating and adding albedo feedback subprocess
>>> step_albedo = StepFunctionAlbedo(state=ebm_s.state, **ebm_s.param)
>>> ebm_s.add_subprocess('albedo', step_albedo)
>>>
>>> print ebm_s
.. code-block:: none
:emphasize-lines: 8
climlab Process of type <class 'climlab.model.ebm.EBM_seasonal'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM_seasonal'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.DailyInsolation'>
"""
if isinstance(proc, Process):
self.subprocess.update({name: proc})
self.has_process_type_list = False
# Add subprocess diagnostics to parent
# (if there are no name conflicts)
for diagname, value in proc.diagnostics.items():
#if not (diagname in self.diagnostics or hasattr(self, diagname)):
# self.add_diagnostic(diagname, value)
self.add_diagnostic(diagname, value)
else:
raise ValueError('subprocess must be Process object')
|
[
"def",
"add_subprocess",
"(",
"self",
",",
"name",
",",
"proc",
")",
":",
"if",
"isinstance",
"(",
"proc",
",",
"Process",
")",
":",
"self",
".",
"subprocess",
".",
"update",
"(",
"{",
"name",
":",
"proc",
"}",
")",
"self",
".",
"has_process_type_list",
"=",
"False",
"# Add subprocess diagnostics to parent",
"# (if there are no name conflicts)",
"for",
"diagname",
",",
"value",
"in",
"proc",
".",
"diagnostics",
".",
"items",
"(",
")",
":",
"#if not (diagname in self.diagnostics or hasattr(self, diagname)):",
"# self.add_diagnostic(diagname, value)",
"self",
".",
"add_diagnostic",
"(",
"diagname",
",",
"value",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'subprocess must be Process object'",
")"
] |
Adds a single subprocess to this process.
:param string name: name of the subprocess
:param proc: a Process object
:type proc: :class:`~climlab.process.process.Process`
:raises: :exc:`ValueError`
if ``proc`` is not a process
:Example:
Replacing an albedo subprocess through adding a subprocess with
same name::
>>> from climlab.model.ebm import EBM_seasonal
>>> from climlab.surface.albedo import StepFunctionAlbedo
>>> # creating EBM model
>>> ebm_s = EBM_seasonal()
>>> print ebm_s
.. code-block:: none
:emphasize-lines: 8
climlab Process of type <class 'climlab.model.ebm.EBM_seasonal'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM_seasonal'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.DailyInsolation'>
::
>>> # creating and adding albedo feedback subprocess
>>> step_albedo = StepFunctionAlbedo(state=ebm_s.state, **ebm_s.param)
>>> ebm_s.add_subprocess('albedo', step_albedo)
>>>
>>> print ebm_s
.. code-block:: none
:emphasize-lines: 8
climlab Process of type <class 'climlab.model.ebm.EBM_seasonal'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM_seasonal'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.DailyInsolation'>
|
[
"Adds",
"a",
"single",
"subprocess",
"to",
"this",
"process",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L212-L282
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.remove_subprocess
|
def remove_subprocess(self, name, verbose=True):
"""Removes a single subprocess from this process.
:param string name: name of the subprocess
:param bool verbose: information whether warning message
should be printed [default: True]
:Example:
Remove albedo subprocess from energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> print model
climlab Process of type <class 'climlab.model.ebm.EBM'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
>>> model.remove_subprocess('albedo')
>>> print model
climlab Process of type <class 'climlab.model.ebm.EBM'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
"""
try:
self.subprocess.pop(name)
except KeyError:
if verbose:
print('WARNING: {} not found in subprocess dictionary.'.format(name))
self.has_process_type_list = False
|
python
|
def remove_subprocess(self, name, verbose=True):
"""Removes a single subprocess from this process.
:param string name: name of the subprocess
:param bool verbose: information whether warning message
should be printed [default: True]
:Example:
Remove albedo subprocess from energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> print model
climlab Process of type <class 'climlab.model.ebm.EBM'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
>>> model.remove_subprocess('albedo')
>>> print model
climlab Process of type <class 'climlab.model.ebm.EBM'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
"""
try:
self.subprocess.pop(name)
except KeyError:
if verbose:
print('WARNING: {} not found in subprocess dictionary.'.format(name))
self.has_process_type_list = False
|
[
"def",
"remove_subprocess",
"(",
"self",
",",
"name",
",",
"verbose",
"=",
"True",
")",
":",
"try",
":",
"self",
".",
"subprocess",
".",
"pop",
"(",
"name",
")",
"except",
"KeyError",
":",
"if",
"verbose",
":",
"print",
"(",
"'WARNING: {} not found in subprocess dictionary.'",
".",
"format",
"(",
"name",
")",
")",
"self",
".",
"has_process_type_list",
"=",
"False"
] |
Removes a single subprocess from this process.
:param string name: name of the subprocess
:param bool verbose: information whether warning message
should be printed [default: True]
:Example:
Remove albedo subprocess from energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> print model
climlab Process of type <class 'climlab.model.ebm.EBM'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
>>> model.remove_subprocess('albedo')
>>> print model
climlab Process of type <class 'climlab.model.ebm.EBM'>.
State variables and domain shapes:
Ts: (90, 1)
The subprocess tree:
top: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
|
[
"Removes",
"a",
"single",
"subprocess",
"from",
"this",
"process",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L284-L330
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.set_state
|
def set_state(self, name, value):
"""Sets the variable ``name`` to a new state ``value``.
:param string name: name of the state
:param value: state variable
:type value: :class:`~climlab.domain.field.Field` or *array*
:raises: :exc:`ValueError`
if state variable ``value`` is not having a domain.
:raises: :exc:`ValueError`
if shape mismatch between existing domain and
new state variable.
:Example:
Resetting the surface temperature of an EBM to
:math:`-5 ^{\circ} \\textrm{C}` on all latitues::
>>> import climlab
>>> from climlab import Field
>>> import numpy as np
>>> # setup model
>>> model = climlab.EBM(num_lat=36)
>>> # create new temperature distribution
>>> initial = -5 * ones(size(model.lat))
>>> model.set_state('Ts', Field(initial, domain=model.domains['Ts']))
>>> np.squeeze(model.Ts)
Field([-5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5.,
-5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5.,
-5., -5., -5., -5., -5., -5., -5., -5., -5., -5.])
"""
if isinstance(value, Field):
# populate domains dictionary with domains from state variables
self.domains.update({name: value.domain})
else:
try:
thisdom = self.state[name].domain
domshape = thisdom.shape
except:
raise ValueError('State variable needs a domain.')
value = np.atleast_1d(value)
if value.shape == domshape:
value = Field(value, domain=thisdom)
else:
raise ValueError('Shape mismatch between existing domain and new state variable.')
# set the state dictionary
self.state[name] = value
for name, value in self.state.items():
#convert int dtype to float
if np.issubdtype(self.state[name].dtype, np.dtype('int').type):
value = self.state[name].astype(float)
self.state[name]=value
self.__setattr__(name, value)
|
python
|
def set_state(self, name, value):
"""Sets the variable ``name`` to a new state ``value``.
:param string name: name of the state
:param value: state variable
:type value: :class:`~climlab.domain.field.Field` or *array*
:raises: :exc:`ValueError`
if state variable ``value`` is not having a domain.
:raises: :exc:`ValueError`
if shape mismatch between existing domain and
new state variable.
:Example:
Resetting the surface temperature of an EBM to
:math:`-5 ^{\circ} \\textrm{C}` on all latitues::
>>> import climlab
>>> from climlab import Field
>>> import numpy as np
>>> # setup model
>>> model = climlab.EBM(num_lat=36)
>>> # create new temperature distribution
>>> initial = -5 * ones(size(model.lat))
>>> model.set_state('Ts', Field(initial, domain=model.domains['Ts']))
>>> np.squeeze(model.Ts)
Field([-5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5.,
-5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5.,
-5., -5., -5., -5., -5., -5., -5., -5., -5., -5.])
"""
if isinstance(value, Field):
# populate domains dictionary with domains from state variables
self.domains.update({name: value.domain})
else:
try:
thisdom = self.state[name].domain
domshape = thisdom.shape
except:
raise ValueError('State variable needs a domain.')
value = np.atleast_1d(value)
if value.shape == domshape:
value = Field(value, domain=thisdom)
else:
raise ValueError('Shape mismatch between existing domain and new state variable.')
# set the state dictionary
self.state[name] = value
for name, value in self.state.items():
#convert int dtype to float
if np.issubdtype(self.state[name].dtype, np.dtype('int').type):
value = self.state[name].astype(float)
self.state[name]=value
self.__setattr__(name, value)
|
[
"def",
"set_state",
"(",
"self",
",",
"name",
",",
"value",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"Field",
")",
":",
"# populate domains dictionary with domains from state variables",
"self",
".",
"domains",
".",
"update",
"(",
"{",
"name",
":",
"value",
".",
"domain",
"}",
")",
"else",
":",
"try",
":",
"thisdom",
"=",
"self",
".",
"state",
"[",
"name",
"]",
".",
"domain",
"domshape",
"=",
"thisdom",
".",
"shape",
"except",
":",
"raise",
"ValueError",
"(",
"'State variable needs a domain.'",
")",
"value",
"=",
"np",
".",
"atleast_1d",
"(",
"value",
")",
"if",
"value",
".",
"shape",
"==",
"domshape",
":",
"value",
"=",
"Field",
"(",
"value",
",",
"domain",
"=",
"thisdom",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Shape mismatch between existing domain and new state variable.'",
")",
"# set the state dictionary",
"self",
".",
"state",
"[",
"name",
"]",
"=",
"value",
"for",
"name",
",",
"value",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"#convert int dtype to float",
"if",
"np",
".",
"issubdtype",
"(",
"self",
".",
"state",
"[",
"name",
"]",
".",
"dtype",
",",
"np",
".",
"dtype",
"(",
"'int'",
")",
".",
"type",
")",
":",
"value",
"=",
"self",
".",
"state",
"[",
"name",
"]",
".",
"astype",
"(",
"float",
")",
"self",
".",
"state",
"[",
"name",
"]",
"=",
"value",
"self",
".",
"__setattr__",
"(",
"name",
",",
"value",
")"
] |
Sets the variable ``name`` to a new state ``value``.
:param string name: name of the state
:param value: state variable
:type value: :class:`~climlab.domain.field.Field` or *array*
:raises: :exc:`ValueError`
if state variable ``value`` is not having a domain.
:raises: :exc:`ValueError`
if shape mismatch between existing domain and
new state variable.
:Example:
Resetting the surface temperature of an EBM to
:math:`-5 ^{\circ} \\textrm{C}` on all latitues::
>>> import climlab
>>> from climlab import Field
>>> import numpy as np
>>> # setup model
>>> model = climlab.EBM(num_lat=36)
>>> # create new temperature distribution
>>> initial = -5 * ones(size(model.lat))
>>> model.set_state('Ts', Field(initial, domain=model.domains['Ts']))
>>> np.squeeze(model.Ts)
Field([-5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5.,
-5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5., -5.,
-5., -5., -5., -5., -5., -5., -5., -5., -5., -5.])
|
[
"Sets",
"the",
"variable",
"name",
"to",
"a",
"new",
"state",
"value",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L332-L387
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process._add_field
|
def _add_field(self, field_type, name, value):
"""Adds a new field to a specified dictionary. The field is also added
as a process attribute. field_type can be 'input', 'diagnostics' """
try:
self.__getattribute__(field_type).update({name: value})
except:
raise ValueError('Problem with field_type %s' %field_type)
# Note that if process has attribute name, this will trigger The
# setter method for that attribute
self.__setattr__(name, value)
|
python
|
def _add_field(self, field_type, name, value):
"""Adds a new field to a specified dictionary. The field is also added
as a process attribute. field_type can be 'input', 'diagnostics' """
try:
self.__getattribute__(field_type).update({name: value})
except:
raise ValueError('Problem with field_type %s' %field_type)
# Note that if process has attribute name, this will trigger The
# setter method for that attribute
self.__setattr__(name, value)
|
[
"def",
"_add_field",
"(",
"self",
",",
"field_type",
",",
"name",
",",
"value",
")",
":",
"try",
":",
"self",
".",
"__getattribute__",
"(",
"field_type",
")",
".",
"update",
"(",
"{",
"name",
":",
"value",
"}",
")",
"except",
":",
"raise",
"ValueError",
"(",
"'Problem with field_type %s'",
"%",
"field_type",
")",
"# Note that if process has attribute name, this will trigger The",
"# setter method for that attribute",
"self",
".",
"__setattr__",
"(",
"name",
",",
"value",
")"
] |
Adds a new field to a specified dictionary. The field is also added
as a process attribute. field_type can be 'input', 'diagnostics'
|
[
"Adds",
"a",
"new",
"field",
"to",
"a",
"specified",
"dictionary",
".",
"The",
"field",
"is",
"also",
"added",
"as",
"a",
"process",
"attribute",
".",
"field_type",
"can",
"be",
"input",
"diagnostics"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L396-L405
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.add_diagnostic
|
def add_diagnostic(self, name, value=None):
"""Create a new diagnostic variable called ``name`` for this process
and initialize it with the given ``value``.
Quantity is accessible in two ways:
* as a process attribute, i.e. ``proc.name``
* as a member of the diagnostics dictionary,
i.e. ``proc.diagnostics['name']``
Use attribute method to set values, e.g.
```proc.name = value ```
:param str name: name of diagnostic quantity to be initialized
:param array value: initial value for quantity [default: None]
:Example:
Add a diagnostic CO2 variable to an energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> # initialize CO2 variable with value 280 ppm
>>> model.add_diagnostic('CO2',280.)
>>> # access variable directly or through diagnostic dictionary
>>> model.CO2
280
>>> model.diagnostics.keys()
['ASR', 'CO2', 'net_radiation', 'icelat', 'OLR', 'albedo']
"""
self._diag_vars.append(name)
self.__setattr__(name, value)
|
python
|
def add_diagnostic(self, name, value=None):
"""Create a new diagnostic variable called ``name`` for this process
and initialize it with the given ``value``.
Quantity is accessible in two ways:
* as a process attribute, i.e. ``proc.name``
* as a member of the diagnostics dictionary,
i.e. ``proc.diagnostics['name']``
Use attribute method to set values, e.g.
```proc.name = value ```
:param str name: name of diagnostic quantity to be initialized
:param array value: initial value for quantity [default: None]
:Example:
Add a diagnostic CO2 variable to an energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> # initialize CO2 variable with value 280 ppm
>>> model.add_diagnostic('CO2',280.)
>>> # access variable directly or through diagnostic dictionary
>>> model.CO2
280
>>> model.diagnostics.keys()
['ASR', 'CO2', 'net_radiation', 'icelat', 'OLR', 'albedo']
"""
self._diag_vars.append(name)
self.__setattr__(name, value)
|
[
"def",
"add_diagnostic",
"(",
"self",
",",
"name",
",",
"value",
"=",
"None",
")",
":",
"self",
".",
"_diag_vars",
".",
"append",
"(",
"name",
")",
"self",
".",
"__setattr__",
"(",
"name",
",",
"value",
")"
] |
Create a new diagnostic variable called ``name`` for this process
and initialize it with the given ``value``.
Quantity is accessible in two ways:
* as a process attribute, i.e. ``proc.name``
* as a member of the diagnostics dictionary,
i.e. ``proc.diagnostics['name']``
Use attribute method to set values, e.g.
```proc.name = value ```
:param str name: name of diagnostic quantity to be initialized
:param array value: initial value for quantity [default: None]
:Example:
Add a diagnostic CO2 variable to an energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> # initialize CO2 variable with value 280 ppm
>>> model.add_diagnostic('CO2',280.)
>>> # access variable directly or through diagnostic dictionary
>>> model.CO2
280
>>> model.diagnostics.keys()
['ASR', 'CO2', 'net_radiation', 'icelat', 'OLR', 'albedo']
|
[
"Create",
"a",
"new",
"diagnostic",
"variable",
"called",
"name",
"for",
"this",
"process",
"and",
"initialize",
"it",
"with",
"the",
"given",
"value",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L407-L441
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.add_input
|
def add_input(self, name, value=None):
'''Create a new input variable called ``name`` for this process
and initialize it with the given ``value``.
Quantity is accessible in two ways:
* as a process attribute, i.e. ``proc.name``
* as a member of the input dictionary,
i.e. ``proc.input['name']``
Use attribute method to set values, e.g.
```proc.name = value ```
:param str name: name of diagnostic quantity to be initialized
:param array value: initial value for quantity [default: None]
'''
self._input_vars.append(name)
self.__setattr__(name, value)
|
python
|
def add_input(self, name, value=None):
'''Create a new input variable called ``name`` for this process
and initialize it with the given ``value``.
Quantity is accessible in two ways:
* as a process attribute, i.e. ``proc.name``
* as a member of the input dictionary,
i.e. ``proc.input['name']``
Use attribute method to set values, e.g.
```proc.name = value ```
:param str name: name of diagnostic quantity to be initialized
:param array value: initial value for quantity [default: None]
'''
self._input_vars.append(name)
self.__setattr__(name, value)
|
[
"def",
"add_input",
"(",
"self",
",",
"name",
",",
"value",
"=",
"None",
")",
":",
"self",
".",
"_input_vars",
".",
"append",
"(",
"name",
")",
"self",
".",
"__setattr__",
"(",
"name",
",",
"value",
")"
] |
Create a new input variable called ``name`` for this process
and initialize it with the given ``value``.
Quantity is accessible in two ways:
* as a process attribute, i.e. ``proc.name``
* as a member of the input dictionary,
i.e. ``proc.input['name']``
Use attribute method to set values, e.g.
```proc.name = value ```
:param str name: name of diagnostic quantity to be initialized
:param array value: initial value for quantity [default: None]
|
[
"Create",
"a",
"new",
"input",
"variable",
"called",
"name",
"for",
"this",
"process",
"and",
"initialize",
"it",
"with",
"the",
"given",
"value",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L443-L460
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.remove_diagnostic
|
def remove_diagnostic(self, name):
""" Removes a diagnostic from the ``process.diagnostic`` dictionary
and also delete the associated process attribute.
:param str name: name of diagnostic quantity to be removed
:Example:
Remove diagnostic variable 'icelat' from energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> # display all diagnostic variables
>>> model.diagnostics.keys()
['ASR', 'OLR', 'net_radiation', 'albedo', 'icelat']
>>> model.remove_diagnostic('icelat')
>>> model.diagnostics.keys()
['ASR', 'OLR', 'net_radiation', 'albedo']
>>> # Watch out for subprocesses that may still want
>>> # to access the diagnostic 'icelat' variable !!!
"""
#_ = self.diagnostics.pop(name)
#delattr(type(self), name)
try:
delattr(self, name)
self._diag_vars.remove(name)
except:
print('No diagnostic named {} was found.'.format(name))
|
python
|
def remove_diagnostic(self, name):
""" Removes a diagnostic from the ``process.diagnostic`` dictionary
and also delete the associated process attribute.
:param str name: name of diagnostic quantity to be removed
:Example:
Remove diagnostic variable 'icelat' from energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> # display all diagnostic variables
>>> model.diagnostics.keys()
['ASR', 'OLR', 'net_radiation', 'albedo', 'icelat']
>>> model.remove_diagnostic('icelat')
>>> model.diagnostics.keys()
['ASR', 'OLR', 'net_radiation', 'albedo']
>>> # Watch out for subprocesses that may still want
>>> # to access the diagnostic 'icelat' variable !!!
"""
#_ = self.diagnostics.pop(name)
#delattr(type(self), name)
try:
delattr(self, name)
self._diag_vars.remove(name)
except:
print('No diagnostic named {} was found.'.format(name))
|
[
"def",
"remove_diagnostic",
"(",
"self",
",",
"name",
")",
":",
"#_ = self.diagnostics.pop(name)",
"#delattr(type(self), name)",
"try",
":",
"delattr",
"(",
"self",
",",
"name",
")",
"self",
".",
"_diag_vars",
".",
"remove",
"(",
"name",
")",
"except",
":",
"print",
"(",
"'No diagnostic named {} was found.'",
".",
"format",
"(",
"name",
")",
")"
] |
Removes a diagnostic from the ``process.diagnostic`` dictionary
and also delete the associated process attribute.
:param str name: name of diagnostic quantity to be removed
:Example:
Remove diagnostic variable 'icelat' from energy balance model::
>>> import climlab
>>> model = climlab.EBM()
>>> # display all diagnostic variables
>>> model.diagnostics.keys()
['ASR', 'OLR', 'net_radiation', 'albedo', 'icelat']
>>> model.remove_diagnostic('icelat')
>>> model.diagnostics.keys()
['ASR', 'OLR', 'net_radiation', 'albedo']
>>> # Watch out for subprocesses that may still want
>>> # to access the diagnostic 'icelat' variable !!!
|
[
"Removes",
"a",
"diagnostic",
"from",
"the",
"process",
".",
"diagnostic",
"dictionary",
"and",
"also",
"delete",
"the",
"associated",
"process",
"attribute",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L472-L503
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.to_xarray
|
def to_xarray(self, diagnostics=False):
""" Convert process variables to ``xarray.Dataset`` format.
With ``diagnostics=True``, both state and diagnostic variables are included.
Otherwise just the state variables are included.
Returns an ``xarray.Dataset`` object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
:Example:
Create a single column radiation model and view as ``xarray`` object::
>>> import climlab
>>> state = climlab.column_state(num_lev=20)
>>> model = climlab.radiation.RRTMG(state=state)
>>> # display model state as xarray:
>>> model.to_xarray()
<xarray.Dataset>
Dimensions: (depth: 1, depth_bounds: 2, lev: 20, lev_bounds: 21)
Coordinates:
* depth (depth) float64 0.5
* depth_bounds (depth_bounds) float64 0.0 1.0
* lev (lev) float64 25.0 75.0 125.0 175.0 225.0 275.0 325.0 ...
* lev_bounds (lev_bounds) float64 0.0 50.0 100.0 150.0 200.0 250.0 ...
Data variables:
Ts (depth) float64 288.0
Tatm (lev) float64 200.0 204.1 208.2 212.3 216.4 220.5 224.6 ...
>>> # take a single timestep to populate the diagnostic variables
>>> model.step_forward()
>>> # Now look at the full output in xarray format
>>> model.to_xarray(diagnostics=True)
<xarray.Dataset>
Dimensions: (depth: 1, depth_bounds: 2, lev: 20, lev_bounds: 21)
Coordinates:
* depth (depth) float64 0.5
* depth_bounds (depth_bounds) float64 0.0 1.0
* lev (lev) float64 25.0 75.0 125.0 175.0 225.0 275.0 325.0 ...
* lev_bounds (lev_bounds) float64 0.0 50.0 100.0 150.0 200.0 250.0 ...
Data variables:
Ts (depth) float64 288.7
Tatm (lev) float64 201.3 204.0 208.0 212.0 216.1 220.2 ...
ASR (depth) float64 240.0
ASRcld (depth) float64 0.0
ASRclr (depth) float64 240.0
LW_flux_down (lev_bounds) float64 0.0 12.63 19.47 26.07 32.92 40.1 ...
LW_flux_down_clr (lev_bounds) float64 0.0 12.63 19.47 26.07 32.92 40.1 ...
LW_flux_net (lev_bounds) float64 240.1 231.2 227.6 224.1 220.5 ...
LW_flux_net_clr (lev_bounds) float64 240.1 231.2 227.6 224.1 220.5 ...
LW_flux_up (lev_bounds) float64 240.1 243.9 247.1 250.2 253.4 ...
LW_flux_up_clr (lev_bounds) float64 240.1 243.9 247.1 250.2 253.4 ...
LW_sfc (depth) float64 128.9
LW_sfc_clr (depth) float64 128.9
OLR (depth) float64 240.1
OLRcld (depth) float64 0.0
OLRclr (depth) float64 240.1
SW_flux_down (lev_bounds) float64 341.3 323.1 318.0 313.5 309.5 ...
SW_flux_down_clr (lev_bounds) float64 341.3 323.1 318.0 313.5 309.5 ...
SW_flux_net (lev_bounds) float64 240.0 223.3 220.2 217.9 215.9 ...
SW_flux_net_clr (lev_bounds) float64 240.0 223.3 220.2 217.9 215.9 ...
SW_flux_up (lev_bounds) float64 101.3 99.88 97.77 95.64 93.57 ...
SW_flux_up_clr (lev_bounds) float64 101.3 99.88 97.77 95.64 93.57 ...
SW_sfc (depth) float64 163.8
SW_sfc_clr (depth) float64 163.8
TdotLW (lev) float64 -1.502 -0.6148 -0.5813 -0.6173 -0.6426 ...
TdotLW_clr (lev) float64 -1.502 -0.6148 -0.5813 -0.6173 -0.6426 ...
TdotSW (lev) float64 2.821 0.5123 0.3936 0.3368 0.3174 0.3299 ...
TdotSW_clr (lev) float64 2.821 0.5123 0.3936 0.3368 0.3174 0.3299 ...
"""
if diagnostics:
dic = self.state.copy()
dic.update(self.diagnostics)
return state_to_xarray(dic)
else:
return state_to_xarray(self.state)
|
python
|
def to_xarray(self, diagnostics=False):
""" Convert process variables to ``xarray.Dataset`` format.
With ``diagnostics=True``, both state and diagnostic variables are included.
Otherwise just the state variables are included.
Returns an ``xarray.Dataset`` object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
:Example:
Create a single column radiation model and view as ``xarray`` object::
>>> import climlab
>>> state = climlab.column_state(num_lev=20)
>>> model = climlab.radiation.RRTMG(state=state)
>>> # display model state as xarray:
>>> model.to_xarray()
<xarray.Dataset>
Dimensions: (depth: 1, depth_bounds: 2, lev: 20, lev_bounds: 21)
Coordinates:
* depth (depth) float64 0.5
* depth_bounds (depth_bounds) float64 0.0 1.0
* lev (lev) float64 25.0 75.0 125.0 175.0 225.0 275.0 325.0 ...
* lev_bounds (lev_bounds) float64 0.0 50.0 100.0 150.0 200.0 250.0 ...
Data variables:
Ts (depth) float64 288.0
Tatm (lev) float64 200.0 204.1 208.2 212.3 216.4 220.5 224.6 ...
>>> # take a single timestep to populate the diagnostic variables
>>> model.step_forward()
>>> # Now look at the full output in xarray format
>>> model.to_xarray(diagnostics=True)
<xarray.Dataset>
Dimensions: (depth: 1, depth_bounds: 2, lev: 20, lev_bounds: 21)
Coordinates:
* depth (depth) float64 0.5
* depth_bounds (depth_bounds) float64 0.0 1.0
* lev (lev) float64 25.0 75.0 125.0 175.0 225.0 275.0 325.0 ...
* lev_bounds (lev_bounds) float64 0.0 50.0 100.0 150.0 200.0 250.0 ...
Data variables:
Ts (depth) float64 288.7
Tatm (lev) float64 201.3 204.0 208.0 212.0 216.1 220.2 ...
ASR (depth) float64 240.0
ASRcld (depth) float64 0.0
ASRclr (depth) float64 240.0
LW_flux_down (lev_bounds) float64 0.0 12.63 19.47 26.07 32.92 40.1 ...
LW_flux_down_clr (lev_bounds) float64 0.0 12.63 19.47 26.07 32.92 40.1 ...
LW_flux_net (lev_bounds) float64 240.1 231.2 227.6 224.1 220.5 ...
LW_flux_net_clr (lev_bounds) float64 240.1 231.2 227.6 224.1 220.5 ...
LW_flux_up (lev_bounds) float64 240.1 243.9 247.1 250.2 253.4 ...
LW_flux_up_clr (lev_bounds) float64 240.1 243.9 247.1 250.2 253.4 ...
LW_sfc (depth) float64 128.9
LW_sfc_clr (depth) float64 128.9
OLR (depth) float64 240.1
OLRcld (depth) float64 0.0
OLRclr (depth) float64 240.1
SW_flux_down (lev_bounds) float64 341.3 323.1 318.0 313.5 309.5 ...
SW_flux_down_clr (lev_bounds) float64 341.3 323.1 318.0 313.5 309.5 ...
SW_flux_net (lev_bounds) float64 240.0 223.3 220.2 217.9 215.9 ...
SW_flux_net_clr (lev_bounds) float64 240.0 223.3 220.2 217.9 215.9 ...
SW_flux_up (lev_bounds) float64 101.3 99.88 97.77 95.64 93.57 ...
SW_flux_up_clr (lev_bounds) float64 101.3 99.88 97.77 95.64 93.57 ...
SW_sfc (depth) float64 163.8
SW_sfc_clr (depth) float64 163.8
TdotLW (lev) float64 -1.502 -0.6148 -0.5813 -0.6173 -0.6426 ...
TdotLW_clr (lev) float64 -1.502 -0.6148 -0.5813 -0.6173 -0.6426 ...
TdotSW (lev) float64 2.821 0.5123 0.3936 0.3368 0.3174 0.3299 ...
TdotSW_clr (lev) float64 2.821 0.5123 0.3936 0.3368 0.3174 0.3299 ...
"""
if diagnostics:
dic = self.state.copy()
dic.update(self.diagnostics)
return state_to_xarray(dic)
else:
return state_to_xarray(self.state)
|
[
"def",
"to_xarray",
"(",
"self",
",",
"diagnostics",
"=",
"False",
")",
":",
"if",
"diagnostics",
":",
"dic",
"=",
"self",
".",
"state",
".",
"copy",
"(",
")",
"dic",
".",
"update",
"(",
"self",
".",
"diagnostics",
")",
"return",
"state_to_xarray",
"(",
"dic",
")",
"else",
":",
"return",
"state_to_xarray",
"(",
"self",
".",
"state",
")"
] |
Convert process variables to ``xarray.Dataset`` format.
With ``diagnostics=True``, both state and diagnostic variables are included.
Otherwise just the state variables are included.
Returns an ``xarray.Dataset`` object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
:Example:
Create a single column radiation model and view as ``xarray`` object::
>>> import climlab
>>> state = climlab.column_state(num_lev=20)
>>> model = climlab.radiation.RRTMG(state=state)
>>> # display model state as xarray:
>>> model.to_xarray()
<xarray.Dataset>
Dimensions: (depth: 1, depth_bounds: 2, lev: 20, lev_bounds: 21)
Coordinates:
* depth (depth) float64 0.5
* depth_bounds (depth_bounds) float64 0.0 1.0
* lev (lev) float64 25.0 75.0 125.0 175.0 225.0 275.0 325.0 ...
* lev_bounds (lev_bounds) float64 0.0 50.0 100.0 150.0 200.0 250.0 ...
Data variables:
Ts (depth) float64 288.0
Tatm (lev) float64 200.0 204.1 208.2 212.3 216.4 220.5 224.6 ...
>>> # take a single timestep to populate the diagnostic variables
>>> model.step_forward()
>>> # Now look at the full output in xarray format
>>> model.to_xarray(diagnostics=True)
<xarray.Dataset>
Dimensions: (depth: 1, depth_bounds: 2, lev: 20, lev_bounds: 21)
Coordinates:
* depth (depth) float64 0.5
* depth_bounds (depth_bounds) float64 0.0 1.0
* lev (lev) float64 25.0 75.0 125.0 175.0 225.0 275.0 325.0 ...
* lev_bounds (lev_bounds) float64 0.0 50.0 100.0 150.0 200.0 250.0 ...
Data variables:
Ts (depth) float64 288.7
Tatm (lev) float64 201.3 204.0 208.0 212.0 216.1 220.2 ...
ASR (depth) float64 240.0
ASRcld (depth) float64 0.0
ASRclr (depth) float64 240.0
LW_flux_down (lev_bounds) float64 0.0 12.63 19.47 26.07 32.92 40.1 ...
LW_flux_down_clr (lev_bounds) float64 0.0 12.63 19.47 26.07 32.92 40.1 ...
LW_flux_net (lev_bounds) float64 240.1 231.2 227.6 224.1 220.5 ...
LW_flux_net_clr (lev_bounds) float64 240.1 231.2 227.6 224.1 220.5 ...
LW_flux_up (lev_bounds) float64 240.1 243.9 247.1 250.2 253.4 ...
LW_flux_up_clr (lev_bounds) float64 240.1 243.9 247.1 250.2 253.4 ...
LW_sfc (depth) float64 128.9
LW_sfc_clr (depth) float64 128.9
OLR (depth) float64 240.1
OLRcld (depth) float64 0.0
OLRclr (depth) float64 240.1
SW_flux_down (lev_bounds) float64 341.3 323.1 318.0 313.5 309.5 ...
SW_flux_down_clr (lev_bounds) float64 341.3 323.1 318.0 313.5 309.5 ...
SW_flux_net (lev_bounds) float64 240.0 223.3 220.2 217.9 215.9 ...
SW_flux_net_clr (lev_bounds) float64 240.0 223.3 220.2 217.9 215.9 ...
SW_flux_up (lev_bounds) float64 101.3 99.88 97.77 95.64 93.57 ...
SW_flux_up_clr (lev_bounds) float64 101.3 99.88 97.77 95.64 93.57 ...
SW_sfc (depth) float64 163.8
SW_sfc_clr (depth) float64 163.8
TdotLW (lev) float64 -1.502 -0.6148 -0.5813 -0.6173 -0.6426 ...
TdotLW_clr (lev) float64 -1.502 -0.6148 -0.5813 -0.6173 -0.6426 ...
TdotSW (lev) float64 2.821 0.5123 0.3936 0.3368 0.3174 0.3299 ...
TdotSW_clr (lev) float64 2.821 0.5123 0.3936 0.3368 0.3174 0.3299 ...
|
[
"Convert",
"process",
"variables",
"to",
"xarray",
".",
"Dataset",
"format",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L505-L583
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.diagnostics
|
def diagnostics(self):
"""Dictionary access to all diagnostic variables
:type: dict
"""
diag_dict = {}
for key in self._diag_vars:
try:
#diag_dict[key] = getattr(self,key)
# using self.__dict__ doesn't count diagnostics defined as properties
diag_dict[key] = self.__dict__[key]
except:
pass
return diag_dict
|
python
|
def diagnostics(self):
"""Dictionary access to all diagnostic variables
:type: dict
"""
diag_dict = {}
for key in self._diag_vars:
try:
#diag_dict[key] = getattr(self,key)
# using self.__dict__ doesn't count diagnostics defined as properties
diag_dict[key] = self.__dict__[key]
except:
pass
return diag_dict
|
[
"def",
"diagnostics",
"(",
"self",
")",
":",
"diag_dict",
"=",
"{",
"}",
"for",
"key",
"in",
"self",
".",
"_diag_vars",
":",
"try",
":",
"#diag_dict[key] = getattr(self,key)",
"# using self.__dict__ doesn't count diagnostics defined as properties",
"diag_dict",
"[",
"key",
"]",
"=",
"self",
".",
"__dict__",
"[",
"key",
"]",
"except",
":",
"pass",
"return",
"diag_dict"
] |
Dictionary access to all diagnostic variables
:type: dict
|
[
"Dictionary",
"access",
"to",
"all",
"diagnostic",
"variables"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L586-L600
|
train
|
brian-rose/climlab
|
climlab/process/process.py
|
Process.input
|
def input(self):
"""Dictionary access to all input variables
That can be boundary conditions and other gridded quantities
independent of the `process`
:type: dict
"""
input_dict = {}
for key in self._input_vars:
try:
input_dict[key] = getattr(self,key)
except:
pass
return input_dict
|
python
|
def input(self):
"""Dictionary access to all input variables
That can be boundary conditions and other gridded quantities
independent of the `process`
:type: dict
"""
input_dict = {}
for key in self._input_vars:
try:
input_dict[key] = getattr(self,key)
except:
pass
return input_dict
|
[
"def",
"input",
"(",
"self",
")",
":",
"input_dict",
"=",
"{",
"}",
"for",
"key",
"in",
"self",
".",
"_input_vars",
":",
"try",
":",
"input_dict",
"[",
"key",
"]",
"=",
"getattr",
"(",
"self",
",",
"key",
")",
"except",
":",
"pass",
"return",
"input_dict"
] |
Dictionary access to all input variables
That can be boundary conditions and other gridded quantities
independent of the `process`
:type: dict
|
[
"Dictionary",
"access",
"to",
"all",
"input",
"variables"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/process.py#L602-L617
|
train
|
brian-rose/climlab
|
climlab/solar/orbital/table.py
|
_get_Berger_data
|
def _get_Berger_data(verbose=True):
'''Read in the Berger and Loutre orbital table as a pandas dataframe, convert to xarray
'''
# The first column of the data file is used as the row index, and represents kyr from present
orbit91_pd, path = load_data_source(local_path = local_path,
remote_source_list = [threddspath, NCDCpath],
open_method = pd.read_csv,
open_method_kwargs = {'delim_whitespace': True, 'skiprows':1},
verbose=verbose,)
# As xarray structure with the dimension named 'kyear'
orbit = xr.Dataset(orbit91_pd).rename({'dim_0': 'kyear'})
# Now change names
orbit = orbit.rename({'ECC': 'ecc', 'OMEGA': 'long_peri',
'OBL': 'obliquity', 'PREC': 'precession'})
# add 180 degrees to long_peri (see lambda definition, Berger 1978 Appendix)
orbit['long_peri'] += 180.
orbit['precession'] *= -1.
orbit.attrs['Description'] = 'The Berger and Loutre (1991) orbital data table'
orbit.attrs['Citation'] = 'https://doi.org/10.1016/0277-3791(91)90033-Q'
orbit.attrs['Source'] = path
orbit.attrs['Note'] = 'Longitude of perihelion is defined to be 0 degrees at Northern Vernal Equinox. This differs by 180 degrees from orbit91 source file.'
return orbit
|
python
|
def _get_Berger_data(verbose=True):
'''Read in the Berger and Loutre orbital table as a pandas dataframe, convert to xarray
'''
# The first column of the data file is used as the row index, and represents kyr from present
orbit91_pd, path = load_data_source(local_path = local_path,
remote_source_list = [threddspath, NCDCpath],
open_method = pd.read_csv,
open_method_kwargs = {'delim_whitespace': True, 'skiprows':1},
verbose=verbose,)
# As xarray structure with the dimension named 'kyear'
orbit = xr.Dataset(orbit91_pd).rename({'dim_0': 'kyear'})
# Now change names
orbit = orbit.rename({'ECC': 'ecc', 'OMEGA': 'long_peri',
'OBL': 'obliquity', 'PREC': 'precession'})
# add 180 degrees to long_peri (see lambda definition, Berger 1978 Appendix)
orbit['long_peri'] += 180.
orbit['precession'] *= -1.
orbit.attrs['Description'] = 'The Berger and Loutre (1991) orbital data table'
orbit.attrs['Citation'] = 'https://doi.org/10.1016/0277-3791(91)90033-Q'
orbit.attrs['Source'] = path
orbit.attrs['Note'] = 'Longitude of perihelion is defined to be 0 degrees at Northern Vernal Equinox. This differs by 180 degrees from orbit91 source file.'
return orbit
|
[
"def",
"_get_Berger_data",
"(",
"verbose",
"=",
"True",
")",
":",
"# The first column of the data file is used as the row index, and represents kyr from present",
"orbit91_pd",
",",
"path",
"=",
"load_data_source",
"(",
"local_path",
"=",
"local_path",
",",
"remote_source_list",
"=",
"[",
"threddspath",
",",
"NCDCpath",
"]",
",",
"open_method",
"=",
"pd",
".",
"read_csv",
",",
"open_method_kwargs",
"=",
"{",
"'delim_whitespace'",
":",
"True",
",",
"'skiprows'",
":",
"1",
"}",
",",
"verbose",
"=",
"verbose",
",",
")",
"# As xarray structure with the dimension named 'kyear'",
"orbit",
"=",
"xr",
".",
"Dataset",
"(",
"orbit91_pd",
")",
".",
"rename",
"(",
"{",
"'dim_0'",
":",
"'kyear'",
"}",
")",
"# Now change names",
"orbit",
"=",
"orbit",
".",
"rename",
"(",
"{",
"'ECC'",
":",
"'ecc'",
",",
"'OMEGA'",
":",
"'long_peri'",
",",
"'OBL'",
":",
"'obliquity'",
",",
"'PREC'",
":",
"'precession'",
"}",
")",
"# add 180 degrees to long_peri (see lambda definition, Berger 1978 Appendix)",
"orbit",
"[",
"'long_peri'",
"]",
"+=",
"180.",
"orbit",
"[",
"'precession'",
"]",
"*=",
"-",
"1.",
"orbit",
".",
"attrs",
"[",
"'Description'",
"]",
"=",
"'The Berger and Loutre (1991) orbital data table'",
"orbit",
".",
"attrs",
"[",
"'Citation'",
"]",
"=",
"'https://doi.org/10.1016/0277-3791(91)90033-Q'",
"orbit",
".",
"attrs",
"[",
"'Source'",
"]",
"=",
"path",
"orbit",
".",
"attrs",
"[",
"'Note'",
"]",
"=",
"'Longitude of perihelion is defined to be 0 degrees at Northern Vernal Equinox. This differs by 180 degrees from orbit91 source file.'",
"return",
"orbit"
] |
Read in the Berger and Loutre orbital table as a pandas dataframe, convert to xarray
|
[
"Read",
"in",
"the",
"Berger",
"and",
"Loutre",
"orbital",
"table",
"as",
"a",
"pandas",
"dataframe",
"convert",
"to",
"xarray"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/solar/orbital/table.py#L14-L36
|
train
|
brian-rose/climlab
|
climlab/utils/data_source.py
|
load_data_source
|
def load_data_source(local_path,
remote_source_list,
open_method,
open_method_kwargs=dict(),
remote_kwargs=dict(),
verbose=True):
'''Flexible data retreiver to download and cache the data files locally.
Usage example (this makes a local copy of the ozone data file):
:Example:
.. code-block:: python
from climlab.utils.data_source import load_data_source
from xarray import open_dataset
ozonename = 'apeozone_cam3_5_54.nc'
ozonepath = 'http://thredds.atmos.albany.edu:8080/thredds/fileServer/CLIMLAB/ozone/' + ozonename
data, path = load_data_source(local_path=ozonename,
remote_source_list=[ozonepath],
open_method=open_dataset)
print(data)
The order of operations is
1. Try to read the data directly from ``local_path``
2. If the file doesn't exist then iterate through ``remote_source_list``.
Try to download and save the file to ``local_path`` using http request
If that works then open the data from ``local_path``.
3. As a last resort, try to read the data remotely from URLs in ``remote_source_list``
In all cases the file is opened and read by the user-supplied ``open_method``
(e.g. ``xarray.open_dataset``), with additional keyword arguments supplied
as a dictionary through ``open_method_kwargs``.
These are passed straight through to ``open_method``.
Additional keyword arguments in ``remote_kwargs``
are only passed to ``open_method`` in option 3 above
(remote access, e.g. through OpenDAP)
Quiet all output by passing ``verbose=False``.
Returns:
- ``data`` is the data object returned by the successful call to ``open_method``
- ``path`` is the path that resulted in a successful call to ``open_method``.
'''
try:
path = local_path
data = open_method(path, **open_method_kwargs)
if verbose:
print('Opened data from {}'.format(path))
#except FileNotFoundError: # this is a more specific exception in Python 3
except IOError: # works for Py2.7 and Py3.x
# First try to load from remote sources and cache the file locally
for source in remote_source_list:
try:
response = _download_and_cache(source, local_path)
data = open_method(local_path, **open_method_kwargs)
if verbose:
print('Data retrieved from {} and saved locally.'.format(source))
break
except Exception:
continue
else:
# as a final resort, try opening the source remotely
for source in remote_source_list:
path = source
try:
# This works fine for Python >= 3.5
#data = open_method(path, **open_method_kwargs, **remote_kwargs)
data = open_method(path, **merge_two_dicts(open_method_kwargs, remote_kwargs))
if verbose:
print('Opened data remotely from {}'.format(source))
break
except Exception:
continue
else:
raise Exception('All data access methods have failed.')
return data, path
|
python
|
def load_data_source(local_path,
remote_source_list,
open_method,
open_method_kwargs=dict(),
remote_kwargs=dict(),
verbose=True):
'''Flexible data retreiver to download and cache the data files locally.
Usage example (this makes a local copy of the ozone data file):
:Example:
.. code-block:: python
from climlab.utils.data_source import load_data_source
from xarray import open_dataset
ozonename = 'apeozone_cam3_5_54.nc'
ozonepath = 'http://thredds.atmos.albany.edu:8080/thredds/fileServer/CLIMLAB/ozone/' + ozonename
data, path = load_data_source(local_path=ozonename,
remote_source_list=[ozonepath],
open_method=open_dataset)
print(data)
The order of operations is
1. Try to read the data directly from ``local_path``
2. If the file doesn't exist then iterate through ``remote_source_list``.
Try to download and save the file to ``local_path`` using http request
If that works then open the data from ``local_path``.
3. As a last resort, try to read the data remotely from URLs in ``remote_source_list``
In all cases the file is opened and read by the user-supplied ``open_method``
(e.g. ``xarray.open_dataset``), with additional keyword arguments supplied
as a dictionary through ``open_method_kwargs``.
These are passed straight through to ``open_method``.
Additional keyword arguments in ``remote_kwargs``
are only passed to ``open_method`` in option 3 above
(remote access, e.g. through OpenDAP)
Quiet all output by passing ``verbose=False``.
Returns:
- ``data`` is the data object returned by the successful call to ``open_method``
- ``path`` is the path that resulted in a successful call to ``open_method``.
'''
try:
path = local_path
data = open_method(path, **open_method_kwargs)
if verbose:
print('Opened data from {}'.format(path))
#except FileNotFoundError: # this is a more specific exception in Python 3
except IOError: # works for Py2.7 and Py3.x
# First try to load from remote sources and cache the file locally
for source in remote_source_list:
try:
response = _download_and_cache(source, local_path)
data = open_method(local_path, **open_method_kwargs)
if verbose:
print('Data retrieved from {} and saved locally.'.format(source))
break
except Exception:
continue
else:
# as a final resort, try opening the source remotely
for source in remote_source_list:
path = source
try:
# This works fine for Python >= 3.5
#data = open_method(path, **open_method_kwargs, **remote_kwargs)
data = open_method(path, **merge_two_dicts(open_method_kwargs, remote_kwargs))
if verbose:
print('Opened data remotely from {}'.format(source))
break
except Exception:
continue
else:
raise Exception('All data access methods have failed.')
return data, path
|
[
"def",
"load_data_source",
"(",
"local_path",
",",
"remote_source_list",
",",
"open_method",
",",
"open_method_kwargs",
"=",
"dict",
"(",
")",
",",
"remote_kwargs",
"=",
"dict",
"(",
")",
",",
"verbose",
"=",
"True",
")",
":",
"try",
":",
"path",
"=",
"local_path",
"data",
"=",
"open_method",
"(",
"path",
",",
"*",
"*",
"open_method_kwargs",
")",
"if",
"verbose",
":",
"print",
"(",
"'Opened data from {}'",
".",
"format",
"(",
"path",
")",
")",
"#except FileNotFoundError: # this is a more specific exception in Python 3",
"except",
"IOError",
":",
"# works for Py2.7 and Py3.x",
"# First try to load from remote sources and cache the file locally",
"for",
"source",
"in",
"remote_source_list",
":",
"try",
":",
"response",
"=",
"_download_and_cache",
"(",
"source",
",",
"local_path",
")",
"data",
"=",
"open_method",
"(",
"local_path",
",",
"*",
"*",
"open_method_kwargs",
")",
"if",
"verbose",
":",
"print",
"(",
"'Data retrieved from {} and saved locally.'",
".",
"format",
"(",
"source",
")",
")",
"break",
"except",
"Exception",
":",
"continue",
"else",
":",
"# as a final resort, try opening the source remotely",
"for",
"source",
"in",
"remote_source_list",
":",
"path",
"=",
"source",
"try",
":",
"# This works fine for Python >= 3.5",
"#data = open_method(path, **open_method_kwargs, **remote_kwargs)",
"data",
"=",
"open_method",
"(",
"path",
",",
"*",
"*",
"merge_two_dicts",
"(",
"open_method_kwargs",
",",
"remote_kwargs",
")",
")",
"if",
"verbose",
":",
"print",
"(",
"'Opened data remotely from {}'",
".",
"format",
"(",
"source",
")",
")",
"break",
"except",
"Exception",
":",
"continue",
"else",
":",
"raise",
"Exception",
"(",
"'All data access methods have failed.'",
")",
"return",
"data",
",",
"path"
] |
Flexible data retreiver to download and cache the data files locally.
Usage example (this makes a local copy of the ozone data file):
:Example:
.. code-block:: python
from climlab.utils.data_source import load_data_source
from xarray import open_dataset
ozonename = 'apeozone_cam3_5_54.nc'
ozonepath = 'http://thredds.atmos.albany.edu:8080/thredds/fileServer/CLIMLAB/ozone/' + ozonename
data, path = load_data_source(local_path=ozonename,
remote_source_list=[ozonepath],
open_method=open_dataset)
print(data)
The order of operations is
1. Try to read the data directly from ``local_path``
2. If the file doesn't exist then iterate through ``remote_source_list``.
Try to download and save the file to ``local_path`` using http request
If that works then open the data from ``local_path``.
3. As a last resort, try to read the data remotely from URLs in ``remote_source_list``
In all cases the file is opened and read by the user-supplied ``open_method``
(e.g. ``xarray.open_dataset``), with additional keyword arguments supplied
as a dictionary through ``open_method_kwargs``.
These are passed straight through to ``open_method``.
Additional keyword arguments in ``remote_kwargs``
are only passed to ``open_method`` in option 3 above
(remote access, e.g. through OpenDAP)
Quiet all output by passing ``verbose=False``.
Returns:
- ``data`` is the data object returned by the successful call to ``open_method``
- ``path`` is the path that resulted in a successful call to ``open_method``.
|
[
"Flexible",
"data",
"retreiver",
"to",
"download",
"and",
"cache",
"the",
"data",
"files",
"locally",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/utils/data_source.py#L4-L84
|
train
|
brian-rose/climlab
|
climlab/radiation/transmissivity.py
|
tril
|
def tril(array, k=0):
'''Lower triangle of an array.
Return a copy of an array with elements above the k-th diagonal zeroed.
Need a multi-dimensional version here because numpy.tril does not
broadcast for numpy verison < 1.9.'''
try:
tril_array = np.tril(array, k=k)
except:
# have to loop
tril_array = np.zeros_like(array)
shape = array.shape
otherdims = shape[:-2]
for index in np.ndindex(otherdims):
tril_array[index] = np.tril(array[index], k=k)
return tril_array
|
python
|
def tril(array, k=0):
'''Lower triangle of an array.
Return a copy of an array with elements above the k-th diagonal zeroed.
Need a multi-dimensional version here because numpy.tril does not
broadcast for numpy verison < 1.9.'''
try:
tril_array = np.tril(array, k=k)
except:
# have to loop
tril_array = np.zeros_like(array)
shape = array.shape
otherdims = shape[:-2]
for index in np.ndindex(otherdims):
tril_array[index] = np.tril(array[index], k=k)
return tril_array
|
[
"def",
"tril",
"(",
"array",
",",
"k",
"=",
"0",
")",
":",
"try",
":",
"tril_array",
"=",
"np",
".",
"tril",
"(",
"array",
",",
"k",
"=",
"k",
")",
"except",
":",
"# have to loop",
"tril_array",
"=",
"np",
".",
"zeros_like",
"(",
"array",
")",
"shape",
"=",
"array",
".",
"shape",
"otherdims",
"=",
"shape",
"[",
":",
"-",
"2",
"]",
"for",
"index",
"in",
"np",
".",
"ndindex",
"(",
"otherdims",
")",
":",
"tril_array",
"[",
"index",
"]",
"=",
"np",
".",
"tril",
"(",
"array",
"[",
"index",
"]",
",",
"k",
"=",
"k",
")",
"return",
"tril_array"
] |
Lower triangle of an array.
Return a copy of an array with elements above the k-th diagonal zeroed.
Need a multi-dimensional version here because numpy.tril does not
broadcast for numpy verison < 1.9.
|
[
"Lower",
"triangle",
"of",
"an",
"array",
".",
"Return",
"a",
"copy",
"of",
"an",
"array",
"with",
"elements",
"above",
"the",
"k",
"-",
"th",
"diagonal",
"zeroed",
".",
"Need",
"a",
"multi",
"-",
"dimensional",
"version",
"here",
"because",
"numpy",
".",
"tril",
"does",
"not",
"broadcast",
"for",
"numpy",
"verison",
"<",
"1",
".",
"9",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/transmissivity.py#L209-L223
|
train
|
brian-rose/climlab
|
climlab/radiation/transmissivity.py
|
Transmissivity.flux_up
|
def flux_up(self, fluxUpBottom, emission=None):
'''Compute downwelling radiative flux at interfaces between layers.
Inputs:
* fluxDownTop: flux down at top
* emission: emission from atmospheric levels (N)
defaults to zero if not given
Returns:
* vector of downwelling radiative flux between levels (N+1)
element 0 is the flux down to the surface.
'''
if emission is None:
emission = np.zeros_like(self.absorptivity)
E = np.concatenate((emission, np.atleast_1d(fluxUpBottom)), axis=-1)
# dot product (matrix multiplication) along last axes
return np.squeeze(matrix_multiply(self.Tup, E[..., np.newaxis]))
|
python
|
def flux_up(self, fluxUpBottom, emission=None):
'''Compute downwelling radiative flux at interfaces between layers.
Inputs:
* fluxDownTop: flux down at top
* emission: emission from atmospheric levels (N)
defaults to zero if not given
Returns:
* vector of downwelling radiative flux between levels (N+1)
element 0 is the flux down to the surface.
'''
if emission is None:
emission = np.zeros_like(self.absorptivity)
E = np.concatenate((emission, np.atleast_1d(fluxUpBottom)), axis=-1)
# dot product (matrix multiplication) along last axes
return np.squeeze(matrix_multiply(self.Tup, E[..., np.newaxis]))
|
[
"def",
"flux_up",
"(",
"self",
",",
"fluxUpBottom",
",",
"emission",
"=",
"None",
")",
":",
"if",
"emission",
"is",
"None",
":",
"emission",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"absorptivity",
")",
"E",
"=",
"np",
".",
"concatenate",
"(",
"(",
"emission",
",",
"np",
".",
"atleast_1d",
"(",
"fluxUpBottom",
")",
")",
",",
"axis",
"=",
"-",
"1",
")",
"# dot product (matrix multiplication) along last axes",
"return",
"np",
".",
"squeeze",
"(",
"matrix_multiply",
"(",
"self",
".",
"Tup",
",",
"E",
"[",
"...",
",",
"np",
".",
"newaxis",
"]",
")",
")"
] |
Compute downwelling radiative flux at interfaces between layers.
Inputs:
* fluxDownTop: flux down at top
* emission: emission from atmospheric levels (N)
defaults to zero if not given
Returns:
* vector of downwelling radiative flux between levels (N+1)
element 0 is the flux down to the surface.
|
[
"Compute",
"downwelling",
"radiative",
"flux",
"at",
"interfaces",
"between",
"layers",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/transmissivity.py#L121-L140
|
train
|
brian-rose/climlab
|
climlab/radiation/transmissivity.py
|
Transmissivity.flux_down
|
def flux_down(self, fluxDownTop, emission=None):
'''Compute upwelling radiative flux at interfaces between layers.
Inputs:
* fluxUpBottom: flux up from bottom
* emission: emission from atmospheric levels (N)
defaults to zero if not given
Returns:
* vector of upwelling radiative flux between levels (N+1)
element N is the flux up to space.
'''
if emission is None:
emission = np.zeros_like(self.absorptivity)
E = np.concatenate((np.atleast_1d(fluxDownTop),emission), axis=-1)
# dot product (matrix multiplication) along last axes
return np.squeeze(matrix_multiply(self.Tdown, E[..., np.newaxis]))
|
python
|
def flux_down(self, fluxDownTop, emission=None):
'''Compute upwelling radiative flux at interfaces between layers.
Inputs:
* fluxUpBottom: flux up from bottom
* emission: emission from atmospheric levels (N)
defaults to zero if not given
Returns:
* vector of upwelling radiative flux between levels (N+1)
element N is the flux up to space.
'''
if emission is None:
emission = np.zeros_like(self.absorptivity)
E = np.concatenate((np.atleast_1d(fluxDownTop),emission), axis=-1)
# dot product (matrix multiplication) along last axes
return np.squeeze(matrix_multiply(self.Tdown, E[..., np.newaxis]))
|
[
"def",
"flux_down",
"(",
"self",
",",
"fluxDownTop",
",",
"emission",
"=",
"None",
")",
":",
"if",
"emission",
"is",
"None",
":",
"emission",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"absorptivity",
")",
"E",
"=",
"np",
".",
"concatenate",
"(",
"(",
"np",
".",
"atleast_1d",
"(",
"fluxDownTop",
")",
",",
"emission",
")",
",",
"axis",
"=",
"-",
"1",
")",
"# dot product (matrix multiplication) along last axes",
"return",
"np",
".",
"squeeze",
"(",
"matrix_multiply",
"(",
"self",
".",
"Tdown",
",",
"E",
"[",
"...",
",",
"np",
".",
"newaxis",
"]",
")",
")"
] |
Compute upwelling radiative flux at interfaces between layers.
Inputs:
* fluxUpBottom: flux up from bottom
* emission: emission from atmospheric levels (N)
defaults to zero if not given
Returns:
* vector of upwelling radiative flux between levels (N+1)
element N is the flux up to space.
|
[
"Compute",
"upwelling",
"radiative",
"flux",
"at",
"interfaces",
"between",
"layers",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/transmissivity.py#L149-L167
|
train
|
brian-rose/climlab
|
climlab/radiation/rrtm/rrtmg_lw.py
|
RRTMG_LW._compute_heating_rates
|
def _compute_heating_rates(self):
'''Prepare arguments and call the RRTGM_LW driver to calculate
radiative fluxes and heating rates'''
(ncol, nlay, icld, permuteseed, irng, idrv, cp,
play, plev, tlay, tlev, tsfc,
h2ovmr, o3vmr, co2vmr, ch4vmr, n2ovmr, o2vmr,
cfc11vmr, cfc12vmr, cfc22vmr, ccl4vmr, emis,
inflglw, iceflglw, liqflglw,
cldfrac, ciwp, clwp, reic, relq, tauc, tauaer,) = self._prepare_lw_arguments()
if icld == 0: # clear-sky only
cldfmcl = np.zeros((ngptlw,ncol,nlay))
ciwpmcl = np.zeros((ngptlw,ncol,nlay))
clwpmcl = np.zeros((ngptlw,ncol,nlay))
reicmcl = np.zeros((ncol,nlay))
relqmcl = np.zeros((ncol,nlay))
taucmcl = np.zeros((ngptlw,ncol,nlay))
else:
# Call the Monte Carlo Independent Column Approximation (McICA, Pincus et al., JC, 2003)
(cldfmcl, ciwpmcl, clwpmcl, reicmcl, relqmcl, taucmcl) = \
_rrtmg_lw.climlab_mcica_subcol_lw(
ncol, nlay, icld,
permuteseed, irng, play,
cldfrac, ciwp, clwp, reic, relq, tauc)
# Call the RRTMG_LW driver to compute radiative fluxes
(uflx, dflx, hr, uflxc, dflxc, hrc, duflx_dt, duflxc_dt) = \
_rrtmg_lw.climlab_rrtmg_lw(ncol, nlay, icld, idrv,
play, plev, tlay, tlev, tsfc,
h2ovmr, o3vmr, co2vmr, ch4vmr, n2ovmr, o2vmr,
cfc11vmr, cfc12vmr, cfc22vmr, ccl4vmr, emis,
inflglw, iceflglw, liqflglw, cldfmcl,
taucmcl, ciwpmcl, clwpmcl, reicmcl, relqmcl,
tauaer)
# Output is all (ncol,nlay+1) or (ncol,nlay)
self.LW_flux_up = _rrtm_to_climlab(uflx) + 0.*self.LW_flux_up
self.LW_flux_down = _rrtm_to_climlab(dflx) + 0.*self.LW_flux_down
self.LW_flux_up_clr = _rrtm_to_climlab(uflxc) + 0.*self.LW_flux_up_clr
self.LW_flux_down_clr = _rrtm_to_climlab(dflxc) + 0.*self.LW_flux_down_clr
# Compute quantities derived from fluxes, including OLR
self._compute_LW_flux_diagnostics()
# calculate heating rates from flux divergence
LWheating_Wm2 = np.array(np.diff(self.LW_flux_net, axis=-1)) + 0.*self.Tatm
LWheating_clr_Wm2 = np.array(np.diff(self.LW_flux_net_clr, axis=-1)) + 0.*self.Tatm
self.heating_rate['Ts'] = np.array(-self.LW_flux_net[..., -1, np.newaxis]) + 0.*self.Ts
self.heating_rate['Tatm'] = LWheating_Wm2
# Convert to K / day
Catm = self.Tatm.domain.heat_capacity
self.TdotLW = LWheating_Wm2 / Catm * const.seconds_per_day
self.TdotLW_clr = LWheating_clr_Wm2 / Catm * const.seconds_per_day
|
python
|
def _compute_heating_rates(self):
'''Prepare arguments and call the RRTGM_LW driver to calculate
radiative fluxes and heating rates'''
(ncol, nlay, icld, permuteseed, irng, idrv, cp,
play, plev, tlay, tlev, tsfc,
h2ovmr, o3vmr, co2vmr, ch4vmr, n2ovmr, o2vmr,
cfc11vmr, cfc12vmr, cfc22vmr, ccl4vmr, emis,
inflglw, iceflglw, liqflglw,
cldfrac, ciwp, clwp, reic, relq, tauc, tauaer,) = self._prepare_lw_arguments()
if icld == 0: # clear-sky only
cldfmcl = np.zeros((ngptlw,ncol,nlay))
ciwpmcl = np.zeros((ngptlw,ncol,nlay))
clwpmcl = np.zeros((ngptlw,ncol,nlay))
reicmcl = np.zeros((ncol,nlay))
relqmcl = np.zeros((ncol,nlay))
taucmcl = np.zeros((ngptlw,ncol,nlay))
else:
# Call the Monte Carlo Independent Column Approximation (McICA, Pincus et al., JC, 2003)
(cldfmcl, ciwpmcl, clwpmcl, reicmcl, relqmcl, taucmcl) = \
_rrtmg_lw.climlab_mcica_subcol_lw(
ncol, nlay, icld,
permuteseed, irng, play,
cldfrac, ciwp, clwp, reic, relq, tauc)
# Call the RRTMG_LW driver to compute radiative fluxes
(uflx, dflx, hr, uflxc, dflxc, hrc, duflx_dt, duflxc_dt) = \
_rrtmg_lw.climlab_rrtmg_lw(ncol, nlay, icld, idrv,
play, plev, tlay, tlev, tsfc,
h2ovmr, o3vmr, co2vmr, ch4vmr, n2ovmr, o2vmr,
cfc11vmr, cfc12vmr, cfc22vmr, ccl4vmr, emis,
inflglw, iceflglw, liqflglw, cldfmcl,
taucmcl, ciwpmcl, clwpmcl, reicmcl, relqmcl,
tauaer)
# Output is all (ncol,nlay+1) or (ncol,nlay)
self.LW_flux_up = _rrtm_to_climlab(uflx) + 0.*self.LW_flux_up
self.LW_flux_down = _rrtm_to_climlab(dflx) + 0.*self.LW_flux_down
self.LW_flux_up_clr = _rrtm_to_climlab(uflxc) + 0.*self.LW_flux_up_clr
self.LW_flux_down_clr = _rrtm_to_climlab(dflxc) + 0.*self.LW_flux_down_clr
# Compute quantities derived from fluxes, including OLR
self._compute_LW_flux_diagnostics()
# calculate heating rates from flux divergence
LWheating_Wm2 = np.array(np.diff(self.LW_flux_net, axis=-1)) + 0.*self.Tatm
LWheating_clr_Wm2 = np.array(np.diff(self.LW_flux_net_clr, axis=-1)) + 0.*self.Tatm
self.heating_rate['Ts'] = np.array(-self.LW_flux_net[..., -1, np.newaxis]) + 0.*self.Ts
self.heating_rate['Tatm'] = LWheating_Wm2
# Convert to K / day
Catm = self.Tatm.domain.heat_capacity
self.TdotLW = LWheating_Wm2 / Catm * const.seconds_per_day
self.TdotLW_clr = LWheating_clr_Wm2 / Catm * const.seconds_per_day
|
[
"def",
"_compute_heating_rates",
"(",
"self",
")",
":",
"(",
"ncol",
",",
"nlay",
",",
"icld",
",",
"permuteseed",
",",
"irng",
",",
"idrv",
",",
"cp",
",",
"play",
",",
"plev",
",",
"tlay",
",",
"tlev",
",",
"tsfc",
",",
"h2ovmr",
",",
"o3vmr",
",",
"co2vmr",
",",
"ch4vmr",
",",
"n2ovmr",
",",
"o2vmr",
",",
"cfc11vmr",
",",
"cfc12vmr",
",",
"cfc22vmr",
",",
"ccl4vmr",
",",
"emis",
",",
"inflglw",
",",
"iceflglw",
",",
"liqflglw",
",",
"cldfrac",
",",
"ciwp",
",",
"clwp",
",",
"reic",
",",
"relq",
",",
"tauc",
",",
"tauaer",
",",
")",
"=",
"self",
".",
"_prepare_lw_arguments",
"(",
")",
"if",
"icld",
"==",
"0",
":",
"# clear-sky only",
"cldfmcl",
"=",
"np",
".",
"zeros",
"(",
"(",
"ngptlw",
",",
"ncol",
",",
"nlay",
")",
")",
"ciwpmcl",
"=",
"np",
".",
"zeros",
"(",
"(",
"ngptlw",
",",
"ncol",
",",
"nlay",
")",
")",
"clwpmcl",
"=",
"np",
".",
"zeros",
"(",
"(",
"ngptlw",
",",
"ncol",
",",
"nlay",
")",
")",
"reicmcl",
"=",
"np",
".",
"zeros",
"(",
"(",
"ncol",
",",
"nlay",
")",
")",
"relqmcl",
"=",
"np",
".",
"zeros",
"(",
"(",
"ncol",
",",
"nlay",
")",
")",
"taucmcl",
"=",
"np",
".",
"zeros",
"(",
"(",
"ngptlw",
",",
"ncol",
",",
"nlay",
")",
")",
"else",
":",
"# Call the Monte Carlo Independent Column Approximation (McICA, Pincus et al., JC, 2003)",
"(",
"cldfmcl",
",",
"ciwpmcl",
",",
"clwpmcl",
",",
"reicmcl",
",",
"relqmcl",
",",
"taucmcl",
")",
"=",
"_rrtmg_lw",
".",
"climlab_mcica_subcol_lw",
"(",
"ncol",
",",
"nlay",
",",
"icld",
",",
"permuteseed",
",",
"irng",
",",
"play",
",",
"cldfrac",
",",
"ciwp",
",",
"clwp",
",",
"reic",
",",
"relq",
",",
"tauc",
")",
"# Call the RRTMG_LW driver to compute radiative fluxes",
"(",
"uflx",
",",
"dflx",
",",
"hr",
",",
"uflxc",
",",
"dflxc",
",",
"hrc",
",",
"duflx_dt",
",",
"duflxc_dt",
")",
"=",
"_rrtmg_lw",
".",
"climlab_rrtmg_lw",
"(",
"ncol",
",",
"nlay",
",",
"icld",
",",
"idrv",
",",
"play",
",",
"plev",
",",
"tlay",
",",
"tlev",
",",
"tsfc",
",",
"h2ovmr",
",",
"o3vmr",
",",
"co2vmr",
",",
"ch4vmr",
",",
"n2ovmr",
",",
"o2vmr",
",",
"cfc11vmr",
",",
"cfc12vmr",
",",
"cfc22vmr",
",",
"ccl4vmr",
",",
"emis",
",",
"inflglw",
",",
"iceflglw",
",",
"liqflglw",
",",
"cldfmcl",
",",
"taucmcl",
",",
"ciwpmcl",
",",
"clwpmcl",
",",
"reicmcl",
",",
"relqmcl",
",",
"tauaer",
")",
"# Output is all (ncol,nlay+1) or (ncol,nlay)",
"self",
".",
"LW_flux_up",
"=",
"_rrtm_to_climlab",
"(",
"uflx",
")",
"+",
"0.",
"*",
"self",
".",
"LW_flux_up",
"self",
".",
"LW_flux_down",
"=",
"_rrtm_to_climlab",
"(",
"dflx",
")",
"+",
"0.",
"*",
"self",
".",
"LW_flux_down",
"self",
".",
"LW_flux_up_clr",
"=",
"_rrtm_to_climlab",
"(",
"uflxc",
")",
"+",
"0.",
"*",
"self",
".",
"LW_flux_up_clr",
"self",
".",
"LW_flux_down_clr",
"=",
"_rrtm_to_climlab",
"(",
"dflxc",
")",
"+",
"0.",
"*",
"self",
".",
"LW_flux_down_clr",
"# Compute quantities derived from fluxes, including OLR",
"self",
".",
"_compute_LW_flux_diagnostics",
"(",
")",
"# calculate heating rates from flux divergence",
"LWheating_Wm2",
"=",
"np",
".",
"array",
"(",
"np",
".",
"diff",
"(",
"self",
".",
"LW_flux_net",
",",
"axis",
"=",
"-",
"1",
")",
")",
"+",
"0.",
"*",
"self",
".",
"Tatm",
"LWheating_clr_Wm2",
"=",
"np",
".",
"array",
"(",
"np",
".",
"diff",
"(",
"self",
".",
"LW_flux_net_clr",
",",
"axis",
"=",
"-",
"1",
")",
")",
"+",
"0.",
"*",
"self",
".",
"Tatm",
"self",
".",
"heating_rate",
"[",
"'Ts'",
"]",
"=",
"np",
".",
"array",
"(",
"-",
"self",
".",
"LW_flux_net",
"[",
"...",
",",
"-",
"1",
",",
"np",
".",
"newaxis",
"]",
")",
"+",
"0.",
"*",
"self",
".",
"Ts",
"self",
".",
"heating_rate",
"[",
"'Tatm'",
"]",
"=",
"LWheating_Wm2",
"# Convert to K / day",
"Catm",
"=",
"self",
".",
"Tatm",
".",
"domain",
".",
"heat_capacity",
"self",
".",
"TdotLW",
"=",
"LWheating_Wm2",
"/",
"Catm",
"*",
"const",
".",
"seconds_per_day",
"self",
".",
"TdotLW_clr",
"=",
"LWheating_clr_Wm2",
"/",
"Catm",
"*",
"const",
".",
"seconds_per_day"
] |
Prepare arguments and call the RRTGM_LW driver to calculate
radiative fluxes and heating rates
|
[
"Prepare",
"arguments",
"and",
"call",
"the",
"RRTGM_LW",
"driver",
"to",
"calculate",
"radiative",
"fluxes",
"and",
"heating",
"rates"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/rrtm/rrtmg_lw.py#L79-L126
|
train
|
brian-rose/climlab
|
climlab/radiation/rrtm/utils.py
|
_prepare_general_arguments
|
def _prepare_general_arguments(RRTMGobject):
'''Prepare arguments needed for both RRTMG_SW and RRTMG_LW with correct dimensions.'''
tlay = _climlab_to_rrtm(RRTMGobject.Tatm)
tlev = _climlab_to_rrtm(interface_temperature(**RRTMGobject.state))
play = _climlab_to_rrtm(RRTMGobject.lev * np.ones_like(tlay))
plev = _climlab_to_rrtm(RRTMGobject.lev_bounds * np.ones_like(tlev))
ncol, nlay = tlay.shape
tsfc = _climlab_to_rrtm_sfc(RRTMGobject.Ts, RRTMGobject.Ts)
# GASES -- put them in proper dimensions and units
vapor_mixing_ratio = mmr_to_vmr(RRTMGobject.specific_humidity, gas='H2O')
h2ovmr = _climlab_to_rrtm(vapor_mixing_ratio * np.ones_like(RRTMGobject.Tatm))
o3vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['O3'] * np.ones_like(RRTMGobject.Tatm))
co2vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CO2'] * np.ones_like(RRTMGobject.Tatm))
ch4vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CH4'] * np.ones_like(RRTMGobject.Tatm))
n2ovmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['N2O'] * np.ones_like(RRTMGobject.Tatm))
o2vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['O2'] * np.ones_like(RRTMGobject.Tatm))
cfc11vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CFC11'] * np.ones_like(RRTMGobject.Tatm))
cfc12vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CFC12'] * np.ones_like(RRTMGobject.Tatm))
cfc22vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CFC22'] * np.ones_like(RRTMGobject.Tatm))
ccl4vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CCL4'] * np.ones_like(RRTMGobject.Tatm))
# Cloud parameters
cldfrac = _climlab_to_rrtm(RRTMGobject.cldfrac * np.ones_like(RRTMGobject.Tatm))
ciwp = _climlab_to_rrtm(RRTMGobject.ciwp * np.ones_like(RRTMGobject.Tatm))
clwp = _climlab_to_rrtm(RRTMGobject.clwp * np.ones_like(RRTMGobject.Tatm))
relq = _climlab_to_rrtm(RRTMGobject.r_liq * np.ones_like(RRTMGobject.Tatm))
reic = _climlab_to_rrtm(RRTMGobject.r_ice * np.ones_like(RRTMGobject.Tatm))
return (ncol, nlay, play, plev, tlay, tlev, tsfc,
h2ovmr, o3vmr, co2vmr, ch4vmr, n2ovmr, o2vmr, cfc11vmr,
cfc12vmr, cfc12vmr, cfc22vmr, ccl4vmr,
cldfrac, ciwp, clwp, relq, reic)
|
python
|
def _prepare_general_arguments(RRTMGobject):
'''Prepare arguments needed for both RRTMG_SW and RRTMG_LW with correct dimensions.'''
tlay = _climlab_to_rrtm(RRTMGobject.Tatm)
tlev = _climlab_to_rrtm(interface_temperature(**RRTMGobject.state))
play = _climlab_to_rrtm(RRTMGobject.lev * np.ones_like(tlay))
plev = _climlab_to_rrtm(RRTMGobject.lev_bounds * np.ones_like(tlev))
ncol, nlay = tlay.shape
tsfc = _climlab_to_rrtm_sfc(RRTMGobject.Ts, RRTMGobject.Ts)
# GASES -- put them in proper dimensions and units
vapor_mixing_ratio = mmr_to_vmr(RRTMGobject.specific_humidity, gas='H2O')
h2ovmr = _climlab_to_rrtm(vapor_mixing_ratio * np.ones_like(RRTMGobject.Tatm))
o3vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['O3'] * np.ones_like(RRTMGobject.Tatm))
co2vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CO2'] * np.ones_like(RRTMGobject.Tatm))
ch4vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CH4'] * np.ones_like(RRTMGobject.Tatm))
n2ovmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['N2O'] * np.ones_like(RRTMGobject.Tatm))
o2vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['O2'] * np.ones_like(RRTMGobject.Tatm))
cfc11vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CFC11'] * np.ones_like(RRTMGobject.Tatm))
cfc12vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CFC12'] * np.ones_like(RRTMGobject.Tatm))
cfc22vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CFC22'] * np.ones_like(RRTMGobject.Tatm))
ccl4vmr = _climlab_to_rrtm(RRTMGobject.absorber_vmr['CCL4'] * np.ones_like(RRTMGobject.Tatm))
# Cloud parameters
cldfrac = _climlab_to_rrtm(RRTMGobject.cldfrac * np.ones_like(RRTMGobject.Tatm))
ciwp = _climlab_to_rrtm(RRTMGobject.ciwp * np.ones_like(RRTMGobject.Tatm))
clwp = _climlab_to_rrtm(RRTMGobject.clwp * np.ones_like(RRTMGobject.Tatm))
relq = _climlab_to_rrtm(RRTMGobject.r_liq * np.ones_like(RRTMGobject.Tatm))
reic = _climlab_to_rrtm(RRTMGobject.r_ice * np.ones_like(RRTMGobject.Tatm))
return (ncol, nlay, play, plev, tlay, tlev, tsfc,
h2ovmr, o3vmr, co2vmr, ch4vmr, n2ovmr, o2vmr, cfc11vmr,
cfc12vmr, cfc12vmr, cfc22vmr, ccl4vmr,
cldfrac, ciwp, clwp, relq, reic)
|
[
"def",
"_prepare_general_arguments",
"(",
"RRTMGobject",
")",
":",
"tlay",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"Tatm",
")",
"tlev",
"=",
"_climlab_to_rrtm",
"(",
"interface_temperature",
"(",
"*",
"*",
"RRTMGobject",
".",
"state",
")",
")",
"play",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"lev",
"*",
"np",
".",
"ones_like",
"(",
"tlay",
")",
")",
"plev",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"lev_bounds",
"*",
"np",
".",
"ones_like",
"(",
"tlev",
")",
")",
"ncol",
",",
"nlay",
"=",
"tlay",
".",
"shape",
"tsfc",
"=",
"_climlab_to_rrtm_sfc",
"(",
"RRTMGobject",
".",
"Ts",
",",
"RRTMGobject",
".",
"Ts",
")",
"# GASES -- put them in proper dimensions and units",
"vapor_mixing_ratio",
"=",
"mmr_to_vmr",
"(",
"RRTMGobject",
".",
"specific_humidity",
",",
"gas",
"=",
"'H2O'",
")",
"h2ovmr",
"=",
"_climlab_to_rrtm",
"(",
"vapor_mixing_ratio",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"o3vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'O3'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"co2vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'CO2'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"ch4vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'CH4'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"n2ovmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'N2O'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"o2vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'O2'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"cfc11vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'CFC11'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"cfc12vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'CFC12'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"cfc22vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'CFC22'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"ccl4vmr",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"absorber_vmr",
"[",
"'CCL4'",
"]",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"# Cloud parameters",
"cldfrac",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"cldfrac",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"ciwp",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"ciwp",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"clwp",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"clwp",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"relq",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"r_liq",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"reic",
"=",
"_climlab_to_rrtm",
"(",
"RRTMGobject",
".",
"r_ice",
"*",
"np",
".",
"ones_like",
"(",
"RRTMGobject",
".",
"Tatm",
")",
")",
"return",
"(",
"ncol",
",",
"nlay",
",",
"play",
",",
"plev",
",",
"tlay",
",",
"tlev",
",",
"tsfc",
",",
"h2ovmr",
",",
"o3vmr",
",",
"co2vmr",
",",
"ch4vmr",
",",
"n2ovmr",
",",
"o2vmr",
",",
"cfc11vmr",
",",
"cfc12vmr",
",",
"cfc12vmr",
",",
"cfc22vmr",
",",
"ccl4vmr",
",",
"cldfrac",
",",
"ciwp",
",",
"clwp",
",",
"relq",
",",
"reic",
")"
] |
Prepare arguments needed for both RRTMG_SW and RRTMG_LW with correct dimensions.
|
[
"Prepare",
"arguments",
"needed",
"for",
"both",
"RRTMG_SW",
"and",
"RRTMG_LW",
"with",
"correct",
"dimensions",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/rrtm/utils.py#L7-L37
|
train
|
brian-rose/climlab
|
climlab/radiation/rrtm/utils.py
|
interface_temperature
|
def interface_temperature(Ts, Tatm, **kwargs):
'''Compute temperature at model layer interfaces.'''
# Actually it's not clear to me how the RRTM code uses these values
lev = Tatm.domain.axes['lev'].points
lev_bounds = Tatm.domain.axes['lev'].bounds
# Interpolate to layer interfaces
f = interp1d(lev, Tatm, axis=-1) # interpolation function
Tinterp = f(lev_bounds[1:-1])
# add TOA value, Assume surface temperature at bottom boundary
Ttoa = Tatm[...,0]
Tinterp = np.concatenate((Ttoa[..., np.newaxis], Tinterp, Ts), axis=-1)
return Tinterp
|
python
|
def interface_temperature(Ts, Tatm, **kwargs):
'''Compute temperature at model layer interfaces.'''
# Actually it's not clear to me how the RRTM code uses these values
lev = Tatm.domain.axes['lev'].points
lev_bounds = Tatm.domain.axes['lev'].bounds
# Interpolate to layer interfaces
f = interp1d(lev, Tatm, axis=-1) # interpolation function
Tinterp = f(lev_bounds[1:-1])
# add TOA value, Assume surface temperature at bottom boundary
Ttoa = Tatm[...,0]
Tinterp = np.concatenate((Ttoa[..., np.newaxis], Tinterp, Ts), axis=-1)
return Tinterp
|
[
"def",
"interface_temperature",
"(",
"Ts",
",",
"Tatm",
",",
"*",
"*",
"kwargs",
")",
":",
"# Actually it's not clear to me how the RRTM code uses these values",
"lev",
"=",
"Tatm",
".",
"domain",
".",
"axes",
"[",
"'lev'",
"]",
".",
"points",
"lev_bounds",
"=",
"Tatm",
".",
"domain",
".",
"axes",
"[",
"'lev'",
"]",
".",
"bounds",
"# Interpolate to layer interfaces",
"f",
"=",
"interp1d",
"(",
"lev",
",",
"Tatm",
",",
"axis",
"=",
"-",
"1",
")",
"# interpolation function",
"Tinterp",
"=",
"f",
"(",
"lev_bounds",
"[",
"1",
":",
"-",
"1",
"]",
")",
"# add TOA value, Assume surface temperature at bottom boundary",
"Ttoa",
"=",
"Tatm",
"[",
"...",
",",
"0",
"]",
"Tinterp",
"=",
"np",
".",
"concatenate",
"(",
"(",
"Ttoa",
"[",
"...",
",",
"np",
".",
"newaxis",
"]",
",",
"Tinterp",
",",
"Ts",
")",
",",
"axis",
"=",
"-",
"1",
")",
"return",
"Tinterp"
] |
Compute temperature at model layer interfaces.
|
[
"Compute",
"temperature",
"at",
"model",
"layer",
"interfaces",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/rrtm/utils.py#L41-L52
|
train
|
brian-rose/climlab
|
climlab/dynamics/meridional_moist_diffusion.py
|
moist_amplification_factor
|
def moist_amplification_factor(Tkelvin, relative_humidity=0.8):
'''Compute the moisture amplification factor for the moist diffusivity
given relative humidity and reference temperature profile.'''
deltaT = 0.01
# slope of saturation specific humidity at 1000 hPa
dqsdTs = (qsat(Tkelvin+deltaT/2, 1000.) - qsat(Tkelvin-deltaT/2, 1000.)) / deltaT
return const.Lhvap / const.cp * relative_humidity * dqsdTs
|
python
|
def moist_amplification_factor(Tkelvin, relative_humidity=0.8):
'''Compute the moisture amplification factor for the moist diffusivity
given relative humidity and reference temperature profile.'''
deltaT = 0.01
# slope of saturation specific humidity at 1000 hPa
dqsdTs = (qsat(Tkelvin+deltaT/2, 1000.) - qsat(Tkelvin-deltaT/2, 1000.)) / deltaT
return const.Lhvap / const.cp * relative_humidity * dqsdTs
|
[
"def",
"moist_amplification_factor",
"(",
"Tkelvin",
",",
"relative_humidity",
"=",
"0.8",
")",
":",
"deltaT",
"=",
"0.01",
"# slope of saturation specific humidity at 1000 hPa",
"dqsdTs",
"=",
"(",
"qsat",
"(",
"Tkelvin",
"+",
"deltaT",
"/",
"2",
",",
"1000.",
")",
"-",
"qsat",
"(",
"Tkelvin",
"-",
"deltaT",
"/",
"2",
",",
"1000.",
")",
")",
"/",
"deltaT",
"return",
"const",
".",
"Lhvap",
"/",
"const",
".",
"cp",
"*",
"relative_humidity",
"*",
"dqsdTs"
] |
Compute the moisture amplification factor for the moist diffusivity
given relative humidity and reference temperature profile.
|
[
"Compute",
"the",
"moisture",
"amplification",
"factor",
"for",
"the",
"moist",
"diffusivity",
"given",
"relative",
"humidity",
"and",
"reference",
"temperature",
"profile",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/dynamics/meridional_moist_diffusion.py#L145-L151
|
train
|
brian-rose/climlab
|
climlab/solar/insolation.py
|
daily_insolation
|
def daily_insolation(lat, day, orb=const.orb_present, S0=const.S0, day_type=1):
"""Compute daily average insolation given latitude, time of year and orbital parameters.
Orbital parameters can be interpolated to any time in the last 5 Myears with
``climlab.solar.orbital.OrbitalTable`` (see example above).
Longer orbital tables are available with ``climlab.solar.orbital.LongOrbitalTable``
Inputs can be scalar, ``numpy.ndarray``, or ``xarray.DataArray``.
The return value will be ``numpy.ndarray`` if **all** the inputs are ``numpy``.
Otherwise ``xarray.DataArray``.
**Function-call argument** \n
:param array lat: Latitude in degrees (-90 to 90).
:param array day: Indicator of time of year. See argument ``day_type``
for details about format.
:param dict orb: a dictionary with three members (as provided by
``climlab.solar.orbital.OrbitalTable``)
* ``'ecc'`` - eccentricity
* unit: dimensionless
* default value: ``0.017236``
* ``'long_peri'`` - longitude of perihelion (precession angle)
* unit: degrees
* default value: ``281.37``
* ``'obliquity'`` - obliquity angle
* unit: degrees
* default value: ``23.446``
:param float S0: solar constant \n
- unit: :math:`\\textrm{W}/\\textrm{m}^2` \n
- default value: ``1365.2``
:param int day_type: Convention for specifying time of year (+/- 1,2) [optional].
*day_type=1* (default):
day input is calendar day (1-365.24), where day 1
is January first. The calendar is referenced to the
vernal equinox which always occurs at day 80.
*day_type=2:*
day input is solar longitude (0-360 degrees). Solar
longitude is the angle of the Earth's orbit measured from spring
equinox (21 March). Note that calendar days and solar longitude are
not linearly related because, by Kepler's Second Law, Earth's
angular velocity varies according to its distance from the sun.
:raises: :exc:`ValueError`
if day_type is neither 1 nor 2
:returns: Daily average solar radiation in unit
:math:`\\textrm{W}/\\textrm{m}^2`.
Dimensions of output are ``(lat.size, day.size, ecc.size)``
:rtype: array
Code is fully vectorized to handle array input for all arguments. \n
Orbital arguments should all have the same sizes.
This is automatic if computed from
:func:`~climlab.solar.orbital.OrbitalTable.lookup_parameters`
For more information about computation of solar insolation see the
:ref:`Tutorial` chapter.
"""
# Inputs can be scalar, numpy vector, or xarray.DataArray.
# If numpy, convert to xarray so that it will broadcast correctly
lat_is_xarray = True
day_is_xarray = True
if type(lat) is np.ndarray:
lat_is_xarray = False
lat = xr.DataArray(lat, coords=[lat], dims=['lat'])
if type(day) is np.ndarray:
day_is_xarray = False
day = xr.DataArray(day, coords=[day], dims=['day'])
ecc = orb['ecc']
long_peri = orb['long_peri']
obliquity = orb['obliquity']
# Convert precession angle and latitude to radians
phi = deg2rad( lat )
# lambda_long (solar longitude) is the angular distance along Earth's orbit measured from spring equinox (21 March)
if day_type==1: # calendar days
lambda_long = solar_longitude(day,orb)
elif day_type==2: #solar longitude (1-360) is specified in input, no need to convert days to longitude
lambda_long = deg2rad(day)
else:
raise ValueError('Invalid day_type.')
# Compute declination angle of the sun
delta = arcsin(sin(deg2rad(obliquity)) * sin(lambda_long))
# suppress warning message generated by arccos here!
oldsettings = np.seterr(invalid='ignore')
# Compute Ho, the hour angle at sunrise / sunset
# Check for no sunrise or no sunset: Berger 1978 eqn (8),(9)
Ho = xr.where( abs(delta)-pi/2+abs(phi) < 0., # there is sunset/sunrise
arccos(-tan(phi)*tan(delta)),
# otherwise figure out if it's all night or all day
xr.where(phi*delta>0., pi, 0.) )
# this is not really the daily average cosine of the zenith angle...
# it's the integral from sunrise to sunset of that quantity...
coszen = Ho*sin(phi)*sin(delta) + cos(phi)*cos(delta)*sin(Ho)
# Compute insolation: Berger 1978 eq (10)
Fsw = S0/pi*( (1+ecc*cos(lambda_long -deg2rad(long_peri)))**2 / (1-ecc**2)**2 * coszen)
if not (lat_is_xarray or day_is_xarray):
# Dimensional ordering consistent with previous numpy code
return Fsw.transpose().values
else:
return Fsw
|
python
|
def daily_insolation(lat, day, orb=const.orb_present, S0=const.S0, day_type=1):
"""Compute daily average insolation given latitude, time of year and orbital parameters.
Orbital parameters can be interpolated to any time in the last 5 Myears with
``climlab.solar.orbital.OrbitalTable`` (see example above).
Longer orbital tables are available with ``climlab.solar.orbital.LongOrbitalTable``
Inputs can be scalar, ``numpy.ndarray``, or ``xarray.DataArray``.
The return value will be ``numpy.ndarray`` if **all** the inputs are ``numpy``.
Otherwise ``xarray.DataArray``.
**Function-call argument** \n
:param array lat: Latitude in degrees (-90 to 90).
:param array day: Indicator of time of year. See argument ``day_type``
for details about format.
:param dict orb: a dictionary with three members (as provided by
``climlab.solar.orbital.OrbitalTable``)
* ``'ecc'`` - eccentricity
* unit: dimensionless
* default value: ``0.017236``
* ``'long_peri'`` - longitude of perihelion (precession angle)
* unit: degrees
* default value: ``281.37``
* ``'obliquity'`` - obliquity angle
* unit: degrees
* default value: ``23.446``
:param float S0: solar constant \n
- unit: :math:`\\textrm{W}/\\textrm{m}^2` \n
- default value: ``1365.2``
:param int day_type: Convention for specifying time of year (+/- 1,2) [optional].
*day_type=1* (default):
day input is calendar day (1-365.24), where day 1
is January first. The calendar is referenced to the
vernal equinox which always occurs at day 80.
*day_type=2:*
day input is solar longitude (0-360 degrees). Solar
longitude is the angle of the Earth's orbit measured from spring
equinox (21 March). Note that calendar days and solar longitude are
not linearly related because, by Kepler's Second Law, Earth's
angular velocity varies according to its distance from the sun.
:raises: :exc:`ValueError`
if day_type is neither 1 nor 2
:returns: Daily average solar radiation in unit
:math:`\\textrm{W}/\\textrm{m}^2`.
Dimensions of output are ``(lat.size, day.size, ecc.size)``
:rtype: array
Code is fully vectorized to handle array input for all arguments. \n
Orbital arguments should all have the same sizes.
This is automatic if computed from
:func:`~climlab.solar.orbital.OrbitalTable.lookup_parameters`
For more information about computation of solar insolation see the
:ref:`Tutorial` chapter.
"""
# Inputs can be scalar, numpy vector, or xarray.DataArray.
# If numpy, convert to xarray so that it will broadcast correctly
lat_is_xarray = True
day_is_xarray = True
if type(lat) is np.ndarray:
lat_is_xarray = False
lat = xr.DataArray(lat, coords=[lat], dims=['lat'])
if type(day) is np.ndarray:
day_is_xarray = False
day = xr.DataArray(day, coords=[day], dims=['day'])
ecc = orb['ecc']
long_peri = orb['long_peri']
obliquity = orb['obliquity']
# Convert precession angle and latitude to radians
phi = deg2rad( lat )
# lambda_long (solar longitude) is the angular distance along Earth's orbit measured from spring equinox (21 March)
if day_type==1: # calendar days
lambda_long = solar_longitude(day,orb)
elif day_type==2: #solar longitude (1-360) is specified in input, no need to convert days to longitude
lambda_long = deg2rad(day)
else:
raise ValueError('Invalid day_type.')
# Compute declination angle of the sun
delta = arcsin(sin(deg2rad(obliquity)) * sin(lambda_long))
# suppress warning message generated by arccos here!
oldsettings = np.seterr(invalid='ignore')
# Compute Ho, the hour angle at sunrise / sunset
# Check for no sunrise or no sunset: Berger 1978 eqn (8),(9)
Ho = xr.where( abs(delta)-pi/2+abs(phi) < 0., # there is sunset/sunrise
arccos(-tan(phi)*tan(delta)),
# otherwise figure out if it's all night or all day
xr.where(phi*delta>0., pi, 0.) )
# this is not really the daily average cosine of the zenith angle...
# it's the integral from sunrise to sunset of that quantity...
coszen = Ho*sin(phi)*sin(delta) + cos(phi)*cos(delta)*sin(Ho)
# Compute insolation: Berger 1978 eq (10)
Fsw = S0/pi*( (1+ecc*cos(lambda_long -deg2rad(long_peri)))**2 / (1-ecc**2)**2 * coszen)
if not (lat_is_xarray or day_is_xarray):
# Dimensional ordering consistent with previous numpy code
return Fsw.transpose().values
else:
return Fsw
|
[
"def",
"daily_insolation",
"(",
"lat",
",",
"day",
",",
"orb",
"=",
"const",
".",
"orb_present",
",",
"S0",
"=",
"const",
".",
"S0",
",",
"day_type",
"=",
"1",
")",
":",
"# Inputs can be scalar, numpy vector, or xarray.DataArray.",
"# If numpy, convert to xarray so that it will broadcast correctly",
"lat_is_xarray",
"=",
"True",
"day_is_xarray",
"=",
"True",
"if",
"type",
"(",
"lat",
")",
"is",
"np",
".",
"ndarray",
":",
"lat_is_xarray",
"=",
"False",
"lat",
"=",
"xr",
".",
"DataArray",
"(",
"lat",
",",
"coords",
"=",
"[",
"lat",
"]",
",",
"dims",
"=",
"[",
"'lat'",
"]",
")",
"if",
"type",
"(",
"day",
")",
"is",
"np",
".",
"ndarray",
":",
"day_is_xarray",
"=",
"False",
"day",
"=",
"xr",
".",
"DataArray",
"(",
"day",
",",
"coords",
"=",
"[",
"day",
"]",
",",
"dims",
"=",
"[",
"'day'",
"]",
")",
"ecc",
"=",
"orb",
"[",
"'ecc'",
"]",
"long_peri",
"=",
"orb",
"[",
"'long_peri'",
"]",
"obliquity",
"=",
"orb",
"[",
"'obliquity'",
"]",
"# Convert precession angle and latitude to radians",
"phi",
"=",
"deg2rad",
"(",
"lat",
")",
"# lambda_long (solar longitude) is the angular distance along Earth's orbit measured from spring equinox (21 March)",
"if",
"day_type",
"==",
"1",
":",
"# calendar days",
"lambda_long",
"=",
"solar_longitude",
"(",
"day",
",",
"orb",
")",
"elif",
"day_type",
"==",
"2",
":",
"#solar longitude (1-360) is specified in input, no need to convert days to longitude",
"lambda_long",
"=",
"deg2rad",
"(",
"day",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Invalid day_type.'",
")",
"# Compute declination angle of the sun",
"delta",
"=",
"arcsin",
"(",
"sin",
"(",
"deg2rad",
"(",
"obliquity",
")",
")",
"*",
"sin",
"(",
"lambda_long",
")",
")",
"# suppress warning message generated by arccos here!",
"oldsettings",
"=",
"np",
".",
"seterr",
"(",
"invalid",
"=",
"'ignore'",
")",
"# Compute Ho, the hour angle at sunrise / sunset",
"# Check for no sunrise or no sunset: Berger 1978 eqn (8),(9)",
"Ho",
"=",
"xr",
".",
"where",
"(",
"abs",
"(",
"delta",
")",
"-",
"pi",
"/",
"2",
"+",
"abs",
"(",
"phi",
")",
"<",
"0.",
",",
"# there is sunset/sunrise",
"arccos",
"(",
"-",
"tan",
"(",
"phi",
")",
"*",
"tan",
"(",
"delta",
")",
")",
",",
"# otherwise figure out if it's all night or all day",
"xr",
".",
"where",
"(",
"phi",
"*",
"delta",
">",
"0.",
",",
"pi",
",",
"0.",
")",
")",
"# this is not really the daily average cosine of the zenith angle...",
"# it's the integral from sunrise to sunset of that quantity...",
"coszen",
"=",
"Ho",
"*",
"sin",
"(",
"phi",
")",
"*",
"sin",
"(",
"delta",
")",
"+",
"cos",
"(",
"phi",
")",
"*",
"cos",
"(",
"delta",
")",
"*",
"sin",
"(",
"Ho",
")",
"# Compute insolation: Berger 1978 eq (10)",
"Fsw",
"=",
"S0",
"/",
"pi",
"*",
"(",
"(",
"1",
"+",
"ecc",
"*",
"cos",
"(",
"lambda_long",
"-",
"deg2rad",
"(",
"long_peri",
")",
")",
")",
"**",
"2",
"/",
"(",
"1",
"-",
"ecc",
"**",
"2",
")",
"**",
"2",
"*",
"coszen",
")",
"if",
"not",
"(",
"lat_is_xarray",
"or",
"day_is_xarray",
")",
":",
"# Dimensional ordering consistent with previous numpy code",
"return",
"Fsw",
".",
"transpose",
"(",
")",
".",
"values",
"else",
":",
"return",
"Fsw"
] |
Compute daily average insolation given latitude, time of year and orbital parameters.
Orbital parameters can be interpolated to any time in the last 5 Myears with
``climlab.solar.orbital.OrbitalTable`` (see example above).
Longer orbital tables are available with ``climlab.solar.orbital.LongOrbitalTable``
Inputs can be scalar, ``numpy.ndarray``, or ``xarray.DataArray``.
The return value will be ``numpy.ndarray`` if **all** the inputs are ``numpy``.
Otherwise ``xarray.DataArray``.
**Function-call argument** \n
:param array lat: Latitude in degrees (-90 to 90).
:param array day: Indicator of time of year. See argument ``day_type``
for details about format.
:param dict orb: a dictionary with three members (as provided by
``climlab.solar.orbital.OrbitalTable``)
* ``'ecc'`` - eccentricity
* unit: dimensionless
* default value: ``0.017236``
* ``'long_peri'`` - longitude of perihelion (precession angle)
* unit: degrees
* default value: ``281.37``
* ``'obliquity'`` - obliquity angle
* unit: degrees
* default value: ``23.446``
:param float S0: solar constant \n
- unit: :math:`\\textrm{W}/\\textrm{m}^2` \n
- default value: ``1365.2``
:param int day_type: Convention for specifying time of year (+/- 1,2) [optional].
*day_type=1* (default):
day input is calendar day (1-365.24), where day 1
is January first. The calendar is referenced to the
vernal equinox which always occurs at day 80.
*day_type=2:*
day input is solar longitude (0-360 degrees). Solar
longitude is the angle of the Earth's orbit measured from spring
equinox (21 March). Note that calendar days and solar longitude are
not linearly related because, by Kepler's Second Law, Earth's
angular velocity varies according to its distance from the sun.
:raises: :exc:`ValueError`
if day_type is neither 1 nor 2
:returns: Daily average solar radiation in unit
:math:`\\textrm{W}/\\textrm{m}^2`.
Dimensions of output are ``(lat.size, day.size, ecc.size)``
:rtype: array
Code is fully vectorized to handle array input for all arguments. \n
Orbital arguments should all have the same sizes.
This is automatic if computed from
:func:`~climlab.solar.orbital.OrbitalTable.lookup_parameters`
For more information about computation of solar insolation see the
:ref:`Tutorial` chapter.
|
[
"Compute",
"daily",
"average",
"insolation",
"given",
"latitude",
"time",
"of",
"year",
"and",
"orbital",
"parameters",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/solar/insolation.py#L46-L160
|
train
|
brian-rose/climlab
|
climlab/solar/insolation.py
|
solar_longitude
|
def solar_longitude( day, orb=const.orb_present, days_per_year = None ):
"""Estimates solar longitude from calendar day.
Method is using an approximation from :cite:`Berger_1978` section 3
(lambda = 0 at spring equinox).
**Function-call arguments** \n
:param array day: Indicator of time of year.
:param dict orb: a dictionary with three members (as provided by
:class:`~climlab.solar.orbital.OrbitalTable`)
* ``'ecc'`` - eccentricity
* unit: dimensionless
* default value: ``0.017236``
* ``'long_peri'`` - longitude of perihelion
(precession angle)
* unit: degrees
* default value: ``281.37``
* ``'obliquity'`` - obliquity angle
* unit: degrees
* default value: ``23.446``
:param float days_per_year: number of days in a year (optional)
(default: 365.2422)
Reads the length of the year from
:mod:`~climlab.utils.constants` if available.
:returns: solar longitude ``lambda_long``
in dimension``( day.size, ecc.size )``
:rtype: array
Works for both scalar and vector orbital parameters.
"""
if days_per_year is None:
days_per_year = const.days_per_year
ecc = orb['ecc']
long_peri_rad = deg2rad( orb['long_peri'])
delta_lambda = (day - 80.) * 2*pi/days_per_year
beta = sqrt(1 - ecc**2)
lambda_long_m = -2*((ecc/2 + (ecc**3)/8 ) * (1+beta) * sin(-long_peri_rad) -
(ecc**2)/4 * (1/2 + beta) * sin(-2*long_peri_rad) + (ecc**3)/8 *
(1/3 + beta) * sin(-3*long_peri_rad)) + delta_lambda
lambda_long = ( lambda_long_m + (2*ecc - (ecc**3)/4)*sin(lambda_long_m - long_peri_rad) +
(5/4)*(ecc**2) * sin(2*(lambda_long_m - long_peri_rad)) + (13/12)*(ecc**3)
* sin(3*(lambda_long_m - long_peri_rad)) )
return lambda_long
|
python
|
def solar_longitude( day, orb=const.orb_present, days_per_year = None ):
"""Estimates solar longitude from calendar day.
Method is using an approximation from :cite:`Berger_1978` section 3
(lambda = 0 at spring equinox).
**Function-call arguments** \n
:param array day: Indicator of time of year.
:param dict orb: a dictionary with three members (as provided by
:class:`~climlab.solar.orbital.OrbitalTable`)
* ``'ecc'`` - eccentricity
* unit: dimensionless
* default value: ``0.017236``
* ``'long_peri'`` - longitude of perihelion
(precession angle)
* unit: degrees
* default value: ``281.37``
* ``'obliquity'`` - obliquity angle
* unit: degrees
* default value: ``23.446``
:param float days_per_year: number of days in a year (optional)
(default: 365.2422)
Reads the length of the year from
:mod:`~climlab.utils.constants` if available.
:returns: solar longitude ``lambda_long``
in dimension``( day.size, ecc.size )``
:rtype: array
Works for both scalar and vector orbital parameters.
"""
if days_per_year is None:
days_per_year = const.days_per_year
ecc = orb['ecc']
long_peri_rad = deg2rad( orb['long_peri'])
delta_lambda = (day - 80.) * 2*pi/days_per_year
beta = sqrt(1 - ecc**2)
lambda_long_m = -2*((ecc/2 + (ecc**3)/8 ) * (1+beta) * sin(-long_peri_rad) -
(ecc**2)/4 * (1/2 + beta) * sin(-2*long_peri_rad) + (ecc**3)/8 *
(1/3 + beta) * sin(-3*long_peri_rad)) + delta_lambda
lambda_long = ( lambda_long_m + (2*ecc - (ecc**3)/4)*sin(lambda_long_m - long_peri_rad) +
(5/4)*(ecc**2) * sin(2*(lambda_long_m - long_peri_rad)) + (13/12)*(ecc**3)
* sin(3*(lambda_long_m - long_peri_rad)) )
return lambda_long
|
[
"def",
"solar_longitude",
"(",
"day",
",",
"orb",
"=",
"const",
".",
"orb_present",
",",
"days_per_year",
"=",
"None",
")",
":",
"if",
"days_per_year",
"is",
"None",
":",
"days_per_year",
"=",
"const",
".",
"days_per_year",
"ecc",
"=",
"orb",
"[",
"'ecc'",
"]",
"long_peri_rad",
"=",
"deg2rad",
"(",
"orb",
"[",
"'long_peri'",
"]",
")",
"delta_lambda",
"=",
"(",
"day",
"-",
"80.",
")",
"*",
"2",
"*",
"pi",
"/",
"days_per_year",
"beta",
"=",
"sqrt",
"(",
"1",
"-",
"ecc",
"**",
"2",
")",
"lambda_long_m",
"=",
"-",
"2",
"*",
"(",
"(",
"ecc",
"/",
"2",
"+",
"(",
"ecc",
"**",
"3",
")",
"/",
"8",
")",
"*",
"(",
"1",
"+",
"beta",
")",
"*",
"sin",
"(",
"-",
"long_peri_rad",
")",
"-",
"(",
"ecc",
"**",
"2",
")",
"/",
"4",
"*",
"(",
"1",
"/",
"2",
"+",
"beta",
")",
"*",
"sin",
"(",
"-",
"2",
"*",
"long_peri_rad",
")",
"+",
"(",
"ecc",
"**",
"3",
")",
"/",
"8",
"*",
"(",
"1",
"/",
"3",
"+",
"beta",
")",
"*",
"sin",
"(",
"-",
"3",
"*",
"long_peri_rad",
")",
")",
"+",
"delta_lambda",
"lambda_long",
"=",
"(",
"lambda_long_m",
"+",
"(",
"2",
"*",
"ecc",
"-",
"(",
"ecc",
"**",
"3",
")",
"/",
"4",
")",
"*",
"sin",
"(",
"lambda_long_m",
"-",
"long_peri_rad",
")",
"+",
"(",
"5",
"/",
"4",
")",
"*",
"(",
"ecc",
"**",
"2",
")",
"*",
"sin",
"(",
"2",
"*",
"(",
"lambda_long_m",
"-",
"long_peri_rad",
")",
")",
"+",
"(",
"13",
"/",
"12",
")",
"*",
"(",
"ecc",
"**",
"3",
")",
"*",
"sin",
"(",
"3",
"*",
"(",
"lambda_long_m",
"-",
"long_peri_rad",
")",
")",
")",
"return",
"lambda_long"
] |
Estimates solar longitude from calendar day.
Method is using an approximation from :cite:`Berger_1978` section 3
(lambda = 0 at spring equinox).
**Function-call arguments** \n
:param array day: Indicator of time of year.
:param dict orb: a dictionary with three members (as provided by
:class:`~climlab.solar.orbital.OrbitalTable`)
* ``'ecc'`` - eccentricity
* unit: dimensionless
* default value: ``0.017236``
* ``'long_peri'`` - longitude of perihelion
(precession angle)
* unit: degrees
* default value: ``281.37``
* ``'obliquity'`` - obliquity angle
* unit: degrees
* default value: ``23.446``
:param float days_per_year: number of days in a year (optional)
(default: 365.2422)
Reads the length of the year from
:mod:`~climlab.utils.constants` if available.
:returns: solar longitude ``lambda_long``
in dimension``( day.size, ecc.size )``
:rtype: array
Works for both scalar and vector orbital parameters.
|
[
"Estimates",
"solar",
"longitude",
"from",
"calendar",
"day",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/solar/insolation.py#L163-L215
|
train
|
brian-rose/climlab
|
climlab/domain/domain.py
|
single_column
|
def single_column(num_lev=30, water_depth=1., lev=None, **kwargs):
"""Creates domains for a single column of atmosphere overlying a slab of water.
Can also pass a pressure array or pressure level axis object specified in ``lev``.
If argument ``lev`` is not ``None`` then function tries to build a level axis
and ``num_lev`` is ignored.
**Function-call argument** \n
:param int num_lev: number of pressure levels
(evenly spaced from surface to TOA) [default: 30]
:param float water_depth: depth of the ocean slab [default: 1.]
:param lev: specification for height axis (optional)
:type lev: :class:`~climlab.domain.axis.Axis` or pressure array
:raises: :exc:`ValueError` if `lev` is given but neither Axis
nor pressure array.
:returns: a list of 2 Domain objects (slab ocean, atmosphere)
:rtype: :py:class:`list` of :class:`SlabOcean`, :class:`SlabAtmosphere`
:Example:
::
>>> from climlab import domain
>>> sfc, atm = domain.single_column(num_lev=2, water_depth=10.)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(1,)
>>> print atm
climlab Domain object with domain_type=atm and shape=(2,)
"""
if lev is None:
levax = Axis(axis_type='lev', num_points=num_lev)
elif isinstance(lev, Axis):
levax = lev
else:
try:
levax = Axis(axis_type='lev', points=lev)
except:
raise ValueError('lev must be Axis object or pressure array')
depthax = Axis(axis_type='depth', bounds=[water_depth, 0.])
slab = SlabOcean(axes=depthax, **kwargs)
atm = Atmosphere(axes=levax, **kwargs)
return slab, atm
|
python
|
def single_column(num_lev=30, water_depth=1., lev=None, **kwargs):
"""Creates domains for a single column of atmosphere overlying a slab of water.
Can also pass a pressure array or pressure level axis object specified in ``lev``.
If argument ``lev`` is not ``None`` then function tries to build a level axis
and ``num_lev`` is ignored.
**Function-call argument** \n
:param int num_lev: number of pressure levels
(evenly spaced from surface to TOA) [default: 30]
:param float water_depth: depth of the ocean slab [default: 1.]
:param lev: specification for height axis (optional)
:type lev: :class:`~climlab.domain.axis.Axis` or pressure array
:raises: :exc:`ValueError` if `lev` is given but neither Axis
nor pressure array.
:returns: a list of 2 Domain objects (slab ocean, atmosphere)
:rtype: :py:class:`list` of :class:`SlabOcean`, :class:`SlabAtmosphere`
:Example:
::
>>> from climlab import domain
>>> sfc, atm = domain.single_column(num_lev=2, water_depth=10.)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(1,)
>>> print atm
climlab Domain object with domain_type=atm and shape=(2,)
"""
if lev is None:
levax = Axis(axis_type='lev', num_points=num_lev)
elif isinstance(lev, Axis):
levax = lev
else:
try:
levax = Axis(axis_type='lev', points=lev)
except:
raise ValueError('lev must be Axis object or pressure array')
depthax = Axis(axis_type='depth', bounds=[water_depth, 0.])
slab = SlabOcean(axes=depthax, **kwargs)
atm = Atmosphere(axes=levax, **kwargs)
return slab, atm
|
[
"def",
"single_column",
"(",
"num_lev",
"=",
"30",
",",
"water_depth",
"=",
"1.",
",",
"lev",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"lev",
"is",
"None",
":",
"levax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lev'",
",",
"num_points",
"=",
"num_lev",
")",
"elif",
"isinstance",
"(",
"lev",
",",
"Axis",
")",
":",
"levax",
"=",
"lev",
"else",
":",
"try",
":",
"levax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lev'",
",",
"points",
"=",
"lev",
")",
"except",
":",
"raise",
"ValueError",
"(",
"'lev must be Axis object or pressure array'",
")",
"depthax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'depth'",
",",
"bounds",
"=",
"[",
"water_depth",
",",
"0.",
"]",
")",
"slab",
"=",
"SlabOcean",
"(",
"axes",
"=",
"depthax",
",",
"*",
"*",
"kwargs",
")",
"atm",
"=",
"Atmosphere",
"(",
"axes",
"=",
"levax",
",",
"*",
"*",
"kwargs",
")",
"return",
"slab",
",",
"atm"
] |
Creates domains for a single column of atmosphere overlying a slab of water.
Can also pass a pressure array or pressure level axis object specified in ``lev``.
If argument ``lev`` is not ``None`` then function tries to build a level axis
and ``num_lev`` is ignored.
**Function-call argument** \n
:param int num_lev: number of pressure levels
(evenly spaced from surface to TOA) [default: 30]
:param float water_depth: depth of the ocean slab [default: 1.]
:param lev: specification for height axis (optional)
:type lev: :class:`~climlab.domain.axis.Axis` or pressure array
:raises: :exc:`ValueError` if `lev` is given but neither Axis
nor pressure array.
:returns: a list of 2 Domain objects (slab ocean, atmosphere)
:rtype: :py:class:`list` of :class:`SlabOcean`, :class:`SlabAtmosphere`
:Example:
::
>>> from climlab import domain
>>> sfc, atm = domain.single_column(num_lev=2, water_depth=10.)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(1,)
>>> print atm
climlab Domain object with domain_type=atm and shape=(2,)
|
[
"Creates",
"domains",
"for",
"a",
"single",
"column",
"of",
"atmosphere",
"overlying",
"a",
"slab",
"of",
"water",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/domain.py#L411-L458
|
train
|
brian-rose/climlab
|
climlab/domain/domain.py
|
zonal_mean_surface
|
def zonal_mean_surface(num_lat=90, water_depth=10., lat=None, **kwargs):
"""Creates a 1D slab ocean Domain in latitude with uniform water depth.
Domain has a single heat capacity according to the specified water depth.
**Function-call argument** \n
:param int num_lat: number of latitude points [default: 90]
:param float water_depth: depth of the slab ocean in meters [default: 10.]
:param lat: specification for latitude axis (optional)
:type lat: :class:`~climlab.domain.axis.Axis` or latitude array
:raises: :exc:`ValueError` if `lat` is given but neither Axis nor latitude array.
:returns: surface domain
:rtype: :class:`SlabOcean`
:Example:
::
>>> from climlab import domain
>>> sfc = domain.zonal_mean_surface(num_lat=36)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(36, 1)
"""
if lat is None:
latax = Axis(axis_type='lat', num_points=num_lat)
elif isinstance(lat, Axis):
latax = lat
else:
try:
latax = Axis(axis_type='lat', points=lat)
except:
raise ValueError('lat must be Axis object or latitude array')
depthax = Axis(axis_type='depth', bounds=[water_depth, 0.])
axes = {'depth': depthax, 'lat': latax}
slab = SlabOcean(axes=axes, **kwargs)
return slab
|
python
|
def zonal_mean_surface(num_lat=90, water_depth=10., lat=None, **kwargs):
"""Creates a 1D slab ocean Domain in latitude with uniform water depth.
Domain has a single heat capacity according to the specified water depth.
**Function-call argument** \n
:param int num_lat: number of latitude points [default: 90]
:param float water_depth: depth of the slab ocean in meters [default: 10.]
:param lat: specification for latitude axis (optional)
:type lat: :class:`~climlab.domain.axis.Axis` or latitude array
:raises: :exc:`ValueError` if `lat` is given but neither Axis nor latitude array.
:returns: surface domain
:rtype: :class:`SlabOcean`
:Example:
::
>>> from climlab import domain
>>> sfc = domain.zonal_mean_surface(num_lat=36)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(36, 1)
"""
if lat is None:
latax = Axis(axis_type='lat', num_points=num_lat)
elif isinstance(lat, Axis):
latax = lat
else:
try:
latax = Axis(axis_type='lat', points=lat)
except:
raise ValueError('lat must be Axis object or latitude array')
depthax = Axis(axis_type='depth', bounds=[water_depth, 0.])
axes = {'depth': depthax, 'lat': latax}
slab = SlabOcean(axes=axes, **kwargs)
return slab
|
[
"def",
"zonal_mean_surface",
"(",
"num_lat",
"=",
"90",
",",
"water_depth",
"=",
"10.",
",",
"lat",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"lat",
"is",
"None",
":",
"latax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lat'",
",",
"num_points",
"=",
"num_lat",
")",
"elif",
"isinstance",
"(",
"lat",
",",
"Axis",
")",
":",
"latax",
"=",
"lat",
"else",
":",
"try",
":",
"latax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lat'",
",",
"points",
"=",
"lat",
")",
"except",
":",
"raise",
"ValueError",
"(",
"'lat must be Axis object or latitude array'",
")",
"depthax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'depth'",
",",
"bounds",
"=",
"[",
"water_depth",
",",
"0.",
"]",
")",
"axes",
"=",
"{",
"'depth'",
":",
"depthax",
",",
"'lat'",
":",
"latax",
"}",
"slab",
"=",
"SlabOcean",
"(",
"axes",
"=",
"axes",
",",
"*",
"*",
"kwargs",
")",
"return",
"slab"
] |
Creates a 1D slab ocean Domain in latitude with uniform water depth.
Domain has a single heat capacity according to the specified water depth.
**Function-call argument** \n
:param int num_lat: number of latitude points [default: 90]
:param float water_depth: depth of the slab ocean in meters [default: 10.]
:param lat: specification for latitude axis (optional)
:type lat: :class:`~climlab.domain.axis.Axis` or latitude array
:raises: :exc:`ValueError` if `lat` is given but neither Axis nor latitude array.
:returns: surface domain
:rtype: :class:`SlabOcean`
:Example:
::
>>> from climlab import domain
>>> sfc = domain.zonal_mean_surface(num_lat=36)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(36, 1)
|
[
"Creates",
"a",
"1D",
"slab",
"ocean",
"Domain",
"in",
"latitude",
"with",
"uniform",
"water",
"depth",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/domain.py#L461-L499
|
train
|
brian-rose/climlab
|
climlab/domain/domain.py
|
surface_2D
|
def surface_2D(num_lat=90, num_lon=180, water_depth=10., lon=None,
lat=None, **kwargs):
"""Creates a 2D slab ocean Domain in latitude and longitude with uniform water depth.
Domain has a single heat capacity according to the specified water depth.
**Function-call argument** \n
:param int num_lat: number of latitude points [default: 90]
:param int num_lon: number of longitude points [default: 180]
:param float water_depth: depth of the slab ocean in meters [default: 10.]
:param lat: specification for latitude axis (optional)
:type lat: :class:`~climlab.domain.axis.Axis` or latitude array
:param lon: specification for longitude axis (optional)
:type lon: :class:`~climlab.domain.axis.Axis` or longitude array
:raises: :exc:`ValueError` if `lat` is given but neither Axis nor latitude array.
:raises: :exc:`ValueError` if `lon` is given but neither Axis nor longitude array.
:returns: surface domain
:rtype: :class:`SlabOcean`
:Example:
::
>>> from climlab import domain
>>> sfc = domain.surface_2D(num_lat=36, num_lat=72)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(36, 72, 1)
"""
if lat is None:
latax = Axis(axis_type='lat', num_points=num_lat)
elif isinstance(lat, Axis):
latax = lat
else:
try:
latax = Axis(axis_type='lat', points=lat)
except:
raise ValueError('lat must be Axis object or latitude array')
if lon is None:
lonax = Axis(axis_type='lon', num_points=num_lon)
elif isinstance(lon, Axis):
lonax = lon
else:
try:
lonax = Axis(axis_type='lon', points=lon)
except:
raise ValueError('lon must be Axis object or longitude array')
depthax = Axis(axis_type='depth', bounds=[water_depth, 0.])
axes = {'lat': latax, 'lon': lonax, 'depth': depthax}
slab = SlabOcean(axes=axes, **kwargs)
return slab
|
python
|
def surface_2D(num_lat=90, num_lon=180, water_depth=10., lon=None,
lat=None, **kwargs):
"""Creates a 2D slab ocean Domain in latitude and longitude with uniform water depth.
Domain has a single heat capacity according to the specified water depth.
**Function-call argument** \n
:param int num_lat: number of latitude points [default: 90]
:param int num_lon: number of longitude points [default: 180]
:param float water_depth: depth of the slab ocean in meters [default: 10.]
:param lat: specification for latitude axis (optional)
:type lat: :class:`~climlab.domain.axis.Axis` or latitude array
:param lon: specification for longitude axis (optional)
:type lon: :class:`~climlab.domain.axis.Axis` or longitude array
:raises: :exc:`ValueError` if `lat` is given but neither Axis nor latitude array.
:raises: :exc:`ValueError` if `lon` is given but neither Axis nor longitude array.
:returns: surface domain
:rtype: :class:`SlabOcean`
:Example:
::
>>> from climlab import domain
>>> sfc = domain.surface_2D(num_lat=36, num_lat=72)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(36, 72, 1)
"""
if lat is None:
latax = Axis(axis_type='lat', num_points=num_lat)
elif isinstance(lat, Axis):
latax = lat
else:
try:
latax = Axis(axis_type='lat', points=lat)
except:
raise ValueError('lat must be Axis object or latitude array')
if lon is None:
lonax = Axis(axis_type='lon', num_points=num_lon)
elif isinstance(lon, Axis):
lonax = lon
else:
try:
lonax = Axis(axis_type='lon', points=lon)
except:
raise ValueError('lon must be Axis object or longitude array')
depthax = Axis(axis_type='depth', bounds=[water_depth, 0.])
axes = {'lat': latax, 'lon': lonax, 'depth': depthax}
slab = SlabOcean(axes=axes, **kwargs)
return slab
|
[
"def",
"surface_2D",
"(",
"num_lat",
"=",
"90",
",",
"num_lon",
"=",
"180",
",",
"water_depth",
"=",
"10.",
",",
"lon",
"=",
"None",
",",
"lat",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"lat",
"is",
"None",
":",
"latax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lat'",
",",
"num_points",
"=",
"num_lat",
")",
"elif",
"isinstance",
"(",
"lat",
",",
"Axis",
")",
":",
"latax",
"=",
"lat",
"else",
":",
"try",
":",
"latax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lat'",
",",
"points",
"=",
"lat",
")",
"except",
":",
"raise",
"ValueError",
"(",
"'lat must be Axis object or latitude array'",
")",
"if",
"lon",
"is",
"None",
":",
"lonax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lon'",
",",
"num_points",
"=",
"num_lon",
")",
"elif",
"isinstance",
"(",
"lon",
",",
"Axis",
")",
":",
"lonax",
"=",
"lon",
"else",
":",
"try",
":",
"lonax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'lon'",
",",
"points",
"=",
"lon",
")",
"except",
":",
"raise",
"ValueError",
"(",
"'lon must be Axis object or longitude array'",
")",
"depthax",
"=",
"Axis",
"(",
"axis_type",
"=",
"'depth'",
",",
"bounds",
"=",
"[",
"water_depth",
",",
"0.",
"]",
")",
"axes",
"=",
"{",
"'lat'",
":",
"latax",
",",
"'lon'",
":",
"lonax",
",",
"'depth'",
":",
"depthax",
"}",
"slab",
"=",
"SlabOcean",
"(",
"axes",
"=",
"axes",
",",
"*",
"*",
"kwargs",
")",
"return",
"slab"
] |
Creates a 2D slab ocean Domain in latitude and longitude with uniform water depth.
Domain has a single heat capacity according to the specified water depth.
**Function-call argument** \n
:param int num_lat: number of latitude points [default: 90]
:param int num_lon: number of longitude points [default: 180]
:param float water_depth: depth of the slab ocean in meters [default: 10.]
:param lat: specification for latitude axis (optional)
:type lat: :class:`~climlab.domain.axis.Axis` or latitude array
:param lon: specification for longitude axis (optional)
:type lon: :class:`~climlab.domain.axis.Axis` or longitude array
:raises: :exc:`ValueError` if `lat` is given but neither Axis nor latitude array.
:raises: :exc:`ValueError` if `lon` is given but neither Axis nor longitude array.
:returns: surface domain
:rtype: :class:`SlabOcean`
:Example:
::
>>> from climlab import domain
>>> sfc = domain.surface_2D(num_lat=36, num_lat=72)
>>> print sfc
climlab Domain object with domain_type=ocean and shape=(36, 72, 1)
|
[
"Creates",
"a",
"2D",
"slab",
"ocean",
"Domain",
"in",
"latitude",
"and",
"longitude",
"with",
"uniform",
"water",
"depth",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/domain.py#L501-L553
|
train
|
brian-rose/climlab
|
climlab/domain/domain.py
|
_Domain._make_axes_dict
|
def _make_axes_dict(self, axes):
"""Makes an axes dictionary.
.. note::
In case the input is ``None``, the dictionary :code:`{'empty': None}`
is returned.
**Function-call argument** \n
:param axes: axes input
:type axes: dict or single instance of
:class:`~climlab.domain.axis.Axis` object or ``None``
:raises: :exc:`ValueError` if input is not an instance of Axis class
or a dictionary of Axis objetcs
:returns: dictionary of input axes
:rtype: dict
"""
if type(axes) is dict:
axdict = axes
elif type(axes) is Axis:
ax = axes
axdict = {ax.axis_type: ax}
elif axes is None:
axdict = {'empty': None}
else:
raise ValueError('axes needs to be Axis object or dictionary of Axis object')
return axdict
|
python
|
def _make_axes_dict(self, axes):
"""Makes an axes dictionary.
.. note::
In case the input is ``None``, the dictionary :code:`{'empty': None}`
is returned.
**Function-call argument** \n
:param axes: axes input
:type axes: dict or single instance of
:class:`~climlab.domain.axis.Axis` object or ``None``
:raises: :exc:`ValueError` if input is not an instance of Axis class
or a dictionary of Axis objetcs
:returns: dictionary of input axes
:rtype: dict
"""
if type(axes) is dict:
axdict = axes
elif type(axes) is Axis:
ax = axes
axdict = {ax.axis_type: ax}
elif axes is None:
axdict = {'empty': None}
else:
raise ValueError('axes needs to be Axis object or dictionary of Axis object')
return axdict
|
[
"def",
"_make_axes_dict",
"(",
"self",
",",
"axes",
")",
":",
"if",
"type",
"(",
"axes",
")",
"is",
"dict",
":",
"axdict",
"=",
"axes",
"elif",
"type",
"(",
"axes",
")",
"is",
"Axis",
":",
"ax",
"=",
"axes",
"axdict",
"=",
"{",
"ax",
".",
"axis_type",
":",
"ax",
"}",
"elif",
"axes",
"is",
"None",
":",
"axdict",
"=",
"{",
"'empty'",
":",
"None",
"}",
"else",
":",
"raise",
"ValueError",
"(",
"'axes needs to be Axis object or dictionary of Axis object'",
")",
"return",
"axdict"
] |
Makes an axes dictionary.
.. note::
In case the input is ``None``, the dictionary :code:`{'empty': None}`
is returned.
**Function-call argument** \n
:param axes: axes input
:type axes: dict or single instance of
:class:`~climlab.domain.axis.Axis` object or ``None``
:raises: :exc:`ValueError` if input is not an instance of Axis class
or a dictionary of Axis objetcs
:returns: dictionary of input axes
:rtype: dict
|
[
"Makes",
"an",
"axes",
"dictionary",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/domain.py#L129-L157
|
train
|
brian-rose/climlab
|
climlab/process/implicit.py
|
ImplicitProcess._compute
|
def _compute(self):
"""Computes the state variable tendencies in time for implicit processes.
To calculate the new state the :func:`_implicit_solver()` method is
called for daughter classes. This however returns the new state of the
variables, not just the tendencies. Therefore, the adjustment is
calculated which is the difference between the new and the old state
and stored in the object's attribute adjustment.
Calculating the new model states through solving the matrix problem
already includes the multiplication with the timestep. The derived
adjustment is divided by the timestep to calculate the implicit
subprocess tendencies, which can be handeled by the
:func:`~climlab.process.time_dependent_process.TimeDependentProcess.compute`
method of the parent
:class:`~climlab.process.time_dependent_process.TimeDependentProcess` class.
:ivar dict adjustment: holding all state variables' adjustments
of the implicit process which are the
differences between the new states (which have
been solved through matrix inversion) and the
old states.
"""
newstate = self._implicit_solver()
adjustment = {}
tendencies = {}
for name, var in self.state.items():
adjustment[name] = newstate[name] - var
tendencies[name] = adjustment[name] / self.timestep
# express the adjustment (already accounting for the finite time step)
# as a tendency per unit time, so that it can be applied along with explicit
self.adjustment = adjustment
self._update_diagnostics(newstate)
return tendencies
|
python
|
def _compute(self):
"""Computes the state variable tendencies in time for implicit processes.
To calculate the new state the :func:`_implicit_solver()` method is
called for daughter classes. This however returns the new state of the
variables, not just the tendencies. Therefore, the adjustment is
calculated which is the difference between the new and the old state
and stored in the object's attribute adjustment.
Calculating the new model states through solving the matrix problem
already includes the multiplication with the timestep. The derived
adjustment is divided by the timestep to calculate the implicit
subprocess tendencies, which can be handeled by the
:func:`~climlab.process.time_dependent_process.TimeDependentProcess.compute`
method of the parent
:class:`~climlab.process.time_dependent_process.TimeDependentProcess` class.
:ivar dict adjustment: holding all state variables' adjustments
of the implicit process which are the
differences between the new states (which have
been solved through matrix inversion) and the
old states.
"""
newstate = self._implicit_solver()
adjustment = {}
tendencies = {}
for name, var in self.state.items():
adjustment[name] = newstate[name] - var
tendencies[name] = adjustment[name] / self.timestep
# express the adjustment (already accounting for the finite time step)
# as a tendency per unit time, so that it can be applied along with explicit
self.adjustment = adjustment
self._update_diagnostics(newstate)
return tendencies
|
[
"def",
"_compute",
"(",
"self",
")",
":",
"newstate",
"=",
"self",
".",
"_implicit_solver",
"(",
")",
"adjustment",
"=",
"{",
"}",
"tendencies",
"=",
"{",
"}",
"for",
"name",
",",
"var",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"adjustment",
"[",
"name",
"]",
"=",
"newstate",
"[",
"name",
"]",
"-",
"var",
"tendencies",
"[",
"name",
"]",
"=",
"adjustment",
"[",
"name",
"]",
"/",
"self",
".",
"timestep",
"# express the adjustment (already accounting for the finite time step)",
"# as a tendency per unit time, so that it can be applied along with explicit",
"self",
".",
"adjustment",
"=",
"adjustment",
"self",
".",
"_update_diagnostics",
"(",
"newstate",
")",
"return",
"tendencies"
] |
Computes the state variable tendencies in time for implicit processes.
To calculate the new state the :func:`_implicit_solver()` method is
called for daughter classes. This however returns the new state of the
variables, not just the tendencies. Therefore, the adjustment is
calculated which is the difference between the new and the old state
and stored in the object's attribute adjustment.
Calculating the new model states through solving the matrix problem
already includes the multiplication with the timestep. The derived
adjustment is divided by the timestep to calculate the implicit
subprocess tendencies, which can be handeled by the
:func:`~climlab.process.time_dependent_process.TimeDependentProcess.compute`
method of the parent
:class:`~climlab.process.time_dependent_process.TimeDependentProcess` class.
:ivar dict adjustment: holding all state variables' adjustments
of the implicit process which are the
differences between the new states (which have
been solved through matrix inversion) and the
old states.
|
[
"Computes",
"the",
"state",
"variable",
"tendencies",
"in",
"time",
"for",
"implicit",
"processes",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/implicit.py#L23-L57
|
train
|
brian-rose/climlab
|
climlab/utils/walk.py
|
walk_processes
|
def walk_processes(top, topname='top', topdown=True, ignoreFlag=False):
"""Generator for recursive tree of climlab processes
Starts walking from climlab process ``top`` and generates a complete
list of all processes and sub-processes that are managed from ``top`` process.
``level`` indicades the rank of specific process in the process hierarchy:
.. note::
* level 0: ``top`` process
* level 1: sub-processes of ``top`` process
* level 2: sub-sub-processes of ``top`` process (=subprocesses of level 1 processes)
The method is based on os.walk().
:param top: top process from where walking should start
:type top: :class:`~climlab.process.process.Process`
:param str topname: name of top process [default: 'top']
:param bool topdown: whether geneterate *process_types* in regular or
in reverse order [default: True]
:param bool ignoreFlag: whether ``topdown`` flag should be ignored or not
[default: False]
:returns: name (str), proc (process), level (int)
:Example:
::
>>> import climlab
>>> from climlab.utils import walk
>>> model = climlab.EBM()
>>> for name, proc, top_proc in walk.walk_processes(model):
... print name
...
top
diffusion
LW
iceline
cold_albedo
warm_albedo
albedo
insolation
"""
if not ignoreFlag:
flag = topdown
else:
flag = True
proc = top
level = 0
if flag:
yield topname, proc, level
if len(proc.subprocess) > 0: # there are sub-processes
level += 1
for name, subproc in proc.subprocess.items():
for name2, subproc2, level2 in walk_processes(subproc,
topname=name,
topdown=subproc.topdown,
ignoreFlag=ignoreFlag):
yield name2, subproc2, level+level2
if not flag:
yield topname, proc, level
|
python
|
def walk_processes(top, topname='top', topdown=True, ignoreFlag=False):
"""Generator for recursive tree of climlab processes
Starts walking from climlab process ``top`` and generates a complete
list of all processes and sub-processes that are managed from ``top`` process.
``level`` indicades the rank of specific process in the process hierarchy:
.. note::
* level 0: ``top`` process
* level 1: sub-processes of ``top`` process
* level 2: sub-sub-processes of ``top`` process (=subprocesses of level 1 processes)
The method is based on os.walk().
:param top: top process from where walking should start
:type top: :class:`~climlab.process.process.Process`
:param str topname: name of top process [default: 'top']
:param bool topdown: whether geneterate *process_types* in regular or
in reverse order [default: True]
:param bool ignoreFlag: whether ``topdown`` flag should be ignored or not
[default: False]
:returns: name (str), proc (process), level (int)
:Example:
::
>>> import climlab
>>> from climlab.utils import walk
>>> model = climlab.EBM()
>>> for name, proc, top_proc in walk.walk_processes(model):
... print name
...
top
diffusion
LW
iceline
cold_albedo
warm_albedo
albedo
insolation
"""
if not ignoreFlag:
flag = topdown
else:
flag = True
proc = top
level = 0
if flag:
yield topname, proc, level
if len(proc.subprocess) > 0: # there are sub-processes
level += 1
for name, subproc in proc.subprocess.items():
for name2, subproc2, level2 in walk_processes(subproc,
topname=name,
topdown=subproc.topdown,
ignoreFlag=ignoreFlag):
yield name2, subproc2, level+level2
if not flag:
yield topname, proc, level
|
[
"def",
"walk_processes",
"(",
"top",
",",
"topname",
"=",
"'top'",
",",
"topdown",
"=",
"True",
",",
"ignoreFlag",
"=",
"False",
")",
":",
"if",
"not",
"ignoreFlag",
":",
"flag",
"=",
"topdown",
"else",
":",
"flag",
"=",
"True",
"proc",
"=",
"top",
"level",
"=",
"0",
"if",
"flag",
":",
"yield",
"topname",
",",
"proc",
",",
"level",
"if",
"len",
"(",
"proc",
".",
"subprocess",
")",
">",
"0",
":",
"# there are sub-processes",
"level",
"+=",
"1",
"for",
"name",
",",
"subproc",
"in",
"proc",
".",
"subprocess",
".",
"items",
"(",
")",
":",
"for",
"name2",
",",
"subproc2",
",",
"level2",
"in",
"walk_processes",
"(",
"subproc",
",",
"topname",
"=",
"name",
",",
"topdown",
"=",
"subproc",
".",
"topdown",
",",
"ignoreFlag",
"=",
"ignoreFlag",
")",
":",
"yield",
"name2",
",",
"subproc2",
",",
"level",
"+",
"level2",
"if",
"not",
"flag",
":",
"yield",
"topname",
",",
"proc",
",",
"level"
] |
Generator for recursive tree of climlab processes
Starts walking from climlab process ``top`` and generates a complete
list of all processes and sub-processes that are managed from ``top`` process.
``level`` indicades the rank of specific process in the process hierarchy:
.. note::
* level 0: ``top`` process
* level 1: sub-processes of ``top`` process
* level 2: sub-sub-processes of ``top`` process (=subprocesses of level 1 processes)
The method is based on os.walk().
:param top: top process from where walking should start
:type top: :class:`~climlab.process.process.Process`
:param str topname: name of top process [default: 'top']
:param bool topdown: whether geneterate *process_types* in regular or
in reverse order [default: True]
:param bool ignoreFlag: whether ``topdown`` flag should be ignored or not
[default: False]
:returns: name (str), proc (process), level (int)
:Example:
::
>>> import climlab
>>> from climlab.utils import walk
>>> model = climlab.EBM()
>>> for name, proc, top_proc in walk.walk_processes(model):
... print name
...
top
diffusion
LW
iceline
cold_albedo
warm_albedo
albedo
insolation
|
[
"Generator",
"for",
"recursive",
"tree",
"of",
"climlab",
"processes"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/utils/walk.py#L3-L71
|
train
|
brian-rose/climlab
|
climlab/utils/walk.py
|
process_tree
|
def process_tree(top, name='top'):
"""Creates a string representation of the process tree for process top.
This method uses the :func:`walk_processes` method to create the process tree.
:param top: top process for which process tree string should be
created
:type top: :class:`~climlab.process.process.Process`
:param str name: name of top process
:returns: string representation of the process tree
:rtype: str
:Example:
::
>>> import climlab
>>> from climlab.utils import walk
>>> model = climlab.EBM()
>>> proc_tree_str = walk.process_tree(model, name='model')
>>> print proc_tree_str
model: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
"""
str1 = ''
for name, proc, level in walk_processes(top, name, ignoreFlag=True):
indent = ' ' * 3 * (level)
str1 += ('{}{}: {}\n'.format(indent, name, type(proc)))
return str1
|
python
|
def process_tree(top, name='top'):
"""Creates a string representation of the process tree for process top.
This method uses the :func:`walk_processes` method to create the process tree.
:param top: top process for which process tree string should be
created
:type top: :class:`~climlab.process.process.Process`
:param str name: name of top process
:returns: string representation of the process tree
:rtype: str
:Example:
::
>>> import climlab
>>> from climlab.utils import walk
>>> model = climlab.EBM()
>>> proc_tree_str = walk.process_tree(model, name='model')
>>> print proc_tree_str
model: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
"""
str1 = ''
for name, proc, level in walk_processes(top, name, ignoreFlag=True):
indent = ' ' * 3 * (level)
str1 += ('{}{}: {}\n'.format(indent, name, type(proc)))
return str1
|
[
"def",
"process_tree",
"(",
"top",
",",
"name",
"=",
"'top'",
")",
":",
"str1",
"=",
"''",
"for",
"name",
",",
"proc",
",",
"level",
"in",
"walk_processes",
"(",
"top",
",",
"name",
",",
"ignoreFlag",
"=",
"True",
")",
":",
"indent",
"=",
"' '",
"*",
"3",
"*",
"(",
"level",
")",
"str1",
"+=",
"(",
"'{}{}: {}\\n'",
".",
"format",
"(",
"indent",
",",
"name",
",",
"type",
"(",
"proc",
")",
")",
")",
"return",
"str1"
] |
Creates a string representation of the process tree for process top.
This method uses the :func:`walk_processes` method to create the process tree.
:param top: top process for which process tree string should be
created
:type top: :class:`~climlab.process.process.Process`
:param str name: name of top process
:returns: string representation of the process tree
:rtype: str
:Example:
::
>>> import climlab
>>> from climlab.utils import walk
>>> model = climlab.EBM()
>>> proc_tree_str = walk.process_tree(model, name='model')
>>> print proc_tree_str
model: <class 'climlab.model.ebm.EBM'>
diffusion: <class 'climlab.dynamics.diffusion.MeridionalDiffusion'>
LW: <class 'climlab.radiation.AplusBT.AplusBT'>
albedo: <class 'climlab.surface.albedo.StepFunctionAlbedo'>
iceline: <class 'climlab.surface.albedo.Iceline'>
cold_albedo: <class 'climlab.surface.albedo.ConstantAlbedo'>
warm_albedo: <class 'climlab.surface.albedo.P2Albedo'>
insolation: <class 'climlab.radiation.insolation.P2Insolation'>
|
[
"Creates",
"a",
"string",
"representation",
"of",
"the",
"process",
"tree",
"for",
"process",
"top",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/utils/walk.py#L74-L111
|
train
|
brian-rose/climlab
|
climlab/radiation/greygas.py
|
GreyGas._compute_fluxes
|
def _compute_fluxes(self):
''' All fluxes are band by band'''
self.emission = self._compute_emission()
self.emission_sfc = self._compute_emission_sfc()
fromspace = self._from_space()
self.flux_down = self.trans.flux_down(fromspace, self.emission)
self.flux_reflected_up = self.trans.flux_reflected_up(self.flux_down, self.albedo_sfc)
# this ensure same dimensions as other fields
self.flux_to_sfc = self.flux_down[..., -1, np.newaxis]
self.flux_from_sfc = (self.emission_sfc +
self.flux_reflected_up[..., -1, np.newaxis])
self.flux_up = self.trans.flux_up(self.flux_from_sfc,
self.emission + self.flux_reflected_up[...,0:-1])
self.flux_net = self.flux_up - self.flux_down
# absorbed radiation (flux convergence) in W / m**2 (per band)
self.absorbed = np.diff(self.flux_net, axis=-1)
self.absorbed_total = np.sum(self.absorbed, axis=-1)
self.flux_to_space = self._compute_flux_top()
|
python
|
def _compute_fluxes(self):
''' All fluxes are band by band'''
self.emission = self._compute_emission()
self.emission_sfc = self._compute_emission_sfc()
fromspace = self._from_space()
self.flux_down = self.trans.flux_down(fromspace, self.emission)
self.flux_reflected_up = self.trans.flux_reflected_up(self.flux_down, self.albedo_sfc)
# this ensure same dimensions as other fields
self.flux_to_sfc = self.flux_down[..., -1, np.newaxis]
self.flux_from_sfc = (self.emission_sfc +
self.flux_reflected_up[..., -1, np.newaxis])
self.flux_up = self.trans.flux_up(self.flux_from_sfc,
self.emission + self.flux_reflected_up[...,0:-1])
self.flux_net = self.flux_up - self.flux_down
# absorbed radiation (flux convergence) in W / m**2 (per band)
self.absorbed = np.diff(self.flux_net, axis=-1)
self.absorbed_total = np.sum(self.absorbed, axis=-1)
self.flux_to_space = self._compute_flux_top()
|
[
"def",
"_compute_fluxes",
"(",
"self",
")",
":",
"self",
".",
"emission",
"=",
"self",
".",
"_compute_emission",
"(",
")",
"self",
".",
"emission_sfc",
"=",
"self",
".",
"_compute_emission_sfc",
"(",
")",
"fromspace",
"=",
"self",
".",
"_from_space",
"(",
")",
"self",
".",
"flux_down",
"=",
"self",
".",
"trans",
".",
"flux_down",
"(",
"fromspace",
",",
"self",
".",
"emission",
")",
"self",
".",
"flux_reflected_up",
"=",
"self",
".",
"trans",
".",
"flux_reflected_up",
"(",
"self",
".",
"flux_down",
",",
"self",
".",
"albedo_sfc",
")",
"# this ensure same dimensions as other fields",
"self",
".",
"flux_to_sfc",
"=",
"self",
".",
"flux_down",
"[",
"...",
",",
"-",
"1",
",",
"np",
".",
"newaxis",
"]",
"self",
".",
"flux_from_sfc",
"=",
"(",
"self",
".",
"emission_sfc",
"+",
"self",
".",
"flux_reflected_up",
"[",
"...",
",",
"-",
"1",
",",
"np",
".",
"newaxis",
"]",
")",
"self",
".",
"flux_up",
"=",
"self",
".",
"trans",
".",
"flux_up",
"(",
"self",
".",
"flux_from_sfc",
",",
"self",
".",
"emission",
"+",
"self",
".",
"flux_reflected_up",
"[",
"...",
",",
"0",
":",
"-",
"1",
"]",
")",
"self",
".",
"flux_net",
"=",
"self",
".",
"flux_up",
"-",
"self",
".",
"flux_down",
"# absorbed radiation (flux convergence) in W / m**2 (per band)",
"self",
".",
"absorbed",
"=",
"np",
".",
"diff",
"(",
"self",
".",
"flux_net",
",",
"axis",
"=",
"-",
"1",
")",
"self",
".",
"absorbed_total",
"=",
"np",
".",
"sum",
"(",
"self",
".",
"absorbed",
",",
"axis",
"=",
"-",
"1",
")",
"self",
".",
"flux_to_space",
"=",
"self",
".",
"_compute_flux_top",
"(",
")"
] |
All fluxes are band by band
|
[
"All",
"fluxes",
"are",
"band",
"by",
"band"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/greygas.py#L129-L146
|
train
|
brian-rose/climlab
|
climlab/radiation/greygas.py
|
GreyGas.flux_components_top
|
def flux_components_top(self):
'''Compute the contributions to the outgoing flux to space due to
emissions from each level and the surface.'''
N = self.lev.size
flux_up_bottom = self.flux_from_sfc
emission = np.zeros_like(self.emission)
this_flux_up = (np.ones_like(self.Ts) *
self.trans.flux_up(flux_up_bottom, emission))
sfcComponent = this_flux_up[..., -1]
atmComponents = np.zeros_like(self.Tatm)
flux_up_bottom = np.zeros_like(self.Ts)
# I'm sure there's a way to write this as a vectorized operation
# but the speed doesn't really matter if it's just for diagnostic
# and we are not calling it every timestep
for n in range(N):
emission = np.zeros_like(self.emission)
emission[..., n] = self.emission[..., n]
this_flux_up = self.trans.flux_up(flux_up_bottom, emission)
atmComponents[..., n] = this_flux_up[..., -1]
return sfcComponent, atmComponents
|
python
|
def flux_components_top(self):
'''Compute the contributions to the outgoing flux to space due to
emissions from each level and the surface.'''
N = self.lev.size
flux_up_bottom = self.flux_from_sfc
emission = np.zeros_like(self.emission)
this_flux_up = (np.ones_like(self.Ts) *
self.trans.flux_up(flux_up_bottom, emission))
sfcComponent = this_flux_up[..., -1]
atmComponents = np.zeros_like(self.Tatm)
flux_up_bottom = np.zeros_like(self.Ts)
# I'm sure there's a way to write this as a vectorized operation
# but the speed doesn't really matter if it's just for diagnostic
# and we are not calling it every timestep
for n in range(N):
emission = np.zeros_like(self.emission)
emission[..., n] = self.emission[..., n]
this_flux_up = self.trans.flux_up(flux_up_bottom, emission)
atmComponents[..., n] = this_flux_up[..., -1]
return sfcComponent, atmComponents
|
[
"def",
"flux_components_top",
"(",
"self",
")",
":",
"N",
"=",
"self",
".",
"lev",
".",
"size",
"flux_up_bottom",
"=",
"self",
".",
"flux_from_sfc",
"emission",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"emission",
")",
"this_flux_up",
"=",
"(",
"np",
".",
"ones_like",
"(",
"self",
".",
"Ts",
")",
"*",
"self",
".",
"trans",
".",
"flux_up",
"(",
"flux_up_bottom",
",",
"emission",
")",
")",
"sfcComponent",
"=",
"this_flux_up",
"[",
"...",
",",
"-",
"1",
"]",
"atmComponents",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"Tatm",
")",
"flux_up_bottom",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"Ts",
")",
"# I'm sure there's a way to write this as a vectorized operation",
"# but the speed doesn't really matter if it's just for diagnostic",
"# and we are not calling it every timestep",
"for",
"n",
"in",
"range",
"(",
"N",
")",
":",
"emission",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"emission",
")",
"emission",
"[",
"...",
",",
"n",
"]",
"=",
"self",
".",
"emission",
"[",
"...",
",",
"n",
"]",
"this_flux_up",
"=",
"self",
".",
"trans",
".",
"flux_up",
"(",
"flux_up_bottom",
",",
"emission",
")",
"atmComponents",
"[",
"...",
",",
"n",
"]",
"=",
"this_flux_up",
"[",
"...",
",",
"-",
"1",
"]",
"return",
"sfcComponent",
",",
"atmComponents"
] |
Compute the contributions to the outgoing flux to space due to
emissions from each level and the surface.
|
[
"Compute",
"the",
"contributions",
"to",
"the",
"outgoing",
"flux",
"to",
"space",
"due",
"to",
"emissions",
"from",
"each",
"level",
"and",
"the",
"surface",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/greygas.py#L185-L204
|
train
|
brian-rose/climlab
|
climlab/radiation/greygas.py
|
GreyGas.flux_components_bottom
|
def flux_components_bottom(self):
'''Compute the contributions to the downwelling flux to surface due to
emissions from each level.'''
N = self.lev.size
atmComponents = np.zeros_like(self.Tatm)
flux_down_top = np.zeros_like(self.Ts)
# same comment as above... would be nice to vectorize
for n in range(N):
emission = np.zeros_like(self.emission)
emission[..., n] = self.emission[..., n]
this_flux_down = self.trans.flux_down(flux_down_top, emission)
atmComponents[..., n] = this_flux_down[..., 0]
return atmComponents
|
python
|
def flux_components_bottom(self):
'''Compute the contributions to the downwelling flux to surface due to
emissions from each level.'''
N = self.lev.size
atmComponents = np.zeros_like(self.Tatm)
flux_down_top = np.zeros_like(self.Ts)
# same comment as above... would be nice to vectorize
for n in range(N):
emission = np.zeros_like(self.emission)
emission[..., n] = self.emission[..., n]
this_flux_down = self.trans.flux_down(flux_down_top, emission)
atmComponents[..., n] = this_flux_down[..., 0]
return atmComponents
|
[
"def",
"flux_components_bottom",
"(",
"self",
")",
":",
"N",
"=",
"self",
".",
"lev",
".",
"size",
"atmComponents",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"Tatm",
")",
"flux_down_top",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"Ts",
")",
"# same comment as above... would be nice to vectorize",
"for",
"n",
"in",
"range",
"(",
"N",
")",
":",
"emission",
"=",
"np",
".",
"zeros_like",
"(",
"self",
".",
"emission",
")",
"emission",
"[",
"...",
",",
"n",
"]",
"=",
"self",
".",
"emission",
"[",
"...",
",",
"n",
"]",
"this_flux_down",
"=",
"self",
".",
"trans",
".",
"flux_down",
"(",
"flux_down_top",
",",
"emission",
")",
"atmComponents",
"[",
"...",
",",
"n",
"]",
"=",
"this_flux_down",
"[",
"...",
",",
"0",
"]",
"return",
"atmComponents"
] |
Compute the contributions to the downwelling flux to surface due to
emissions from each level.
|
[
"Compute",
"the",
"contributions",
"to",
"the",
"downwelling",
"flux",
"to",
"surface",
"due",
"to",
"emissions",
"from",
"each",
"level",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/greygas.py#L206-L218
|
train
|
brian-rose/climlab
|
climlab/surface/turbulent.py
|
LatentHeatFlux._compute
|
def _compute(self):
'''Overides the _compute method of EnergyBudget'''
tendencies = self._temperature_tendencies()
if 'q' in self.state:
# in a model with active water vapor, this flux should affect
# water vapor tendency, NOT air temperature tendency!
tendencies['Tatm'] *= 0.
Pa_per_hPa = 100.
air_mass_per_area = self.Tatm.domain.lev.delta[...,-1] * Pa_per_hPa / const.g
specific_humidity_tendency = 0.*self.q
specific_humidity_tendency[...,-1,np.newaxis] = self.LHF/const.Lhvap / air_mass_per_area
tendencies['q'] = specific_humidity_tendency
return tendencies
|
python
|
def _compute(self):
'''Overides the _compute method of EnergyBudget'''
tendencies = self._temperature_tendencies()
if 'q' in self.state:
# in a model with active water vapor, this flux should affect
# water vapor tendency, NOT air temperature tendency!
tendencies['Tatm'] *= 0.
Pa_per_hPa = 100.
air_mass_per_area = self.Tatm.domain.lev.delta[...,-1] * Pa_per_hPa / const.g
specific_humidity_tendency = 0.*self.q
specific_humidity_tendency[...,-1,np.newaxis] = self.LHF/const.Lhvap / air_mass_per_area
tendencies['q'] = specific_humidity_tendency
return tendencies
|
[
"def",
"_compute",
"(",
"self",
")",
":",
"tendencies",
"=",
"self",
".",
"_temperature_tendencies",
"(",
")",
"if",
"'q'",
"in",
"self",
".",
"state",
":",
"# in a model with active water vapor, this flux should affect",
"# water vapor tendency, NOT air temperature tendency!",
"tendencies",
"[",
"'Tatm'",
"]",
"*=",
"0.",
"Pa_per_hPa",
"=",
"100.",
"air_mass_per_area",
"=",
"self",
".",
"Tatm",
".",
"domain",
".",
"lev",
".",
"delta",
"[",
"...",
",",
"-",
"1",
"]",
"*",
"Pa_per_hPa",
"/",
"const",
".",
"g",
"specific_humidity_tendency",
"=",
"0.",
"*",
"self",
".",
"q",
"specific_humidity_tendency",
"[",
"...",
",",
"-",
"1",
",",
"np",
".",
"newaxis",
"]",
"=",
"self",
".",
"LHF",
"/",
"const",
".",
"Lhvap",
"/",
"air_mass_per_area",
"tendencies",
"[",
"'q'",
"]",
"=",
"specific_humidity_tendency",
"return",
"tendencies"
] |
Overides the _compute method of EnergyBudget
|
[
"Overides",
"the",
"_compute",
"method",
"of",
"EnergyBudget"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/surface/turbulent.py#L187-L199
|
train
|
brian-rose/climlab
|
climlab/utils/legendre.py
|
Pn
|
def Pn(x):
"""Calculate Legendre polyomials P0 to P28 and returns them
in a dictionary ``Pn``.
:param float x: argument to calculate Legendre polynomials
:return Pn: dictionary which contains order of Legendre polynomials
(from 0 to 28) as keys and the corresponding evaluation
of Legendre polynomials as values.
:rtype: dict
"""
Pn = {}
Pn['0'] = P0(x)
Pn['1'] = P1(x)
Pn['2'] = P2(x)
Pn['3'] = P3(x)
Pn['4'] = P4(x)
Pn['5'] = P5(x)
Pn['6'] = P6(x)
Pn['8'] = P8(x)
Pn['10'] = P10(x)
Pn['12'] = P12(x)
Pn['14'] = P14(x)
Pn['16'] = P16(x)
Pn['18'] = P18(x)
Pn['20'] = P20(x)
Pn['22'] = P22(x)
Pn['24'] = P24(x)
Pn['26'] = P26(x)
Pn['28'] = P28(x)
return Pn
|
python
|
def Pn(x):
"""Calculate Legendre polyomials P0 to P28 and returns them
in a dictionary ``Pn``.
:param float x: argument to calculate Legendre polynomials
:return Pn: dictionary which contains order of Legendre polynomials
(from 0 to 28) as keys and the corresponding evaluation
of Legendre polynomials as values.
:rtype: dict
"""
Pn = {}
Pn['0'] = P0(x)
Pn['1'] = P1(x)
Pn['2'] = P2(x)
Pn['3'] = P3(x)
Pn['4'] = P4(x)
Pn['5'] = P5(x)
Pn['6'] = P6(x)
Pn['8'] = P8(x)
Pn['10'] = P10(x)
Pn['12'] = P12(x)
Pn['14'] = P14(x)
Pn['16'] = P16(x)
Pn['18'] = P18(x)
Pn['20'] = P20(x)
Pn['22'] = P22(x)
Pn['24'] = P24(x)
Pn['26'] = P26(x)
Pn['28'] = P28(x)
return Pn
|
[
"def",
"Pn",
"(",
"x",
")",
":",
"Pn",
"=",
"{",
"}",
"Pn",
"[",
"'0'",
"]",
"=",
"P0",
"(",
"x",
")",
"Pn",
"[",
"'1'",
"]",
"=",
"P1",
"(",
"x",
")",
"Pn",
"[",
"'2'",
"]",
"=",
"P2",
"(",
"x",
")",
"Pn",
"[",
"'3'",
"]",
"=",
"P3",
"(",
"x",
")",
"Pn",
"[",
"'4'",
"]",
"=",
"P4",
"(",
"x",
")",
"Pn",
"[",
"'5'",
"]",
"=",
"P5",
"(",
"x",
")",
"Pn",
"[",
"'6'",
"]",
"=",
"P6",
"(",
"x",
")",
"Pn",
"[",
"'8'",
"]",
"=",
"P8",
"(",
"x",
")",
"Pn",
"[",
"'10'",
"]",
"=",
"P10",
"(",
"x",
")",
"Pn",
"[",
"'12'",
"]",
"=",
"P12",
"(",
"x",
")",
"Pn",
"[",
"'14'",
"]",
"=",
"P14",
"(",
"x",
")",
"Pn",
"[",
"'16'",
"]",
"=",
"P16",
"(",
"x",
")",
"Pn",
"[",
"'18'",
"]",
"=",
"P18",
"(",
"x",
")",
"Pn",
"[",
"'20'",
"]",
"=",
"P20",
"(",
"x",
")",
"Pn",
"[",
"'22'",
"]",
"=",
"P22",
"(",
"x",
")",
"Pn",
"[",
"'24'",
"]",
"=",
"P24",
"(",
"x",
")",
"Pn",
"[",
"'26'",
"]",
"=",
"P26",
"(",
"x",
")",
"Pn",
"[",
"'28'",
"]",
"=",
"P28",
"(",
"x",
")",
"return",
"Pn"
] |
Calculate Legendre polyomials P0 to P28 and returns them
in a dictionary ``Pn``.
:param float x: argument to calculate Legendre polynomials
:return Pn: dictionary which contains order of Legendre polynomials
(from 0 to 28) as keys and the corresponding evaluation
of Legendre polynomials as values.
:rtype: dict
|
[
"Calculate",
"Legendre",
"polyomials",
"P0",
"to",
"P28",
"and",
"returns",
"them",
"in",
"a",
"dictionary",
"Pn",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/utils/legendre.py#L6-L36
|
train
|
brian-rose/climlab
|
climlab/utils/legendre.py
|
Pnprime
|
def Pnprime(x):
"""Calculates first derivatives of Legendre polynomials and returns them
in a dictionary ``Pnprime``.
:param float x: argument to calculate first derivate of Legendre polynomials
:return Pn: dictionary which contains order of Legendre polynomials
(from 0 to 4 and even numbers until 14) as keys and
the corresponding evaluation of first derivative of
Legendre polynomials as values.
:rtype: dict
"""
Pnprime = {}
Pnprime['0'] = 0
Pnprime['1'] = P1prime(x)
Pnprime['2'] = P2prime(x)
Pnprime['3'] = P3prime(x)
Pnprime['4'] = P4prime(x)
Pnprime['6'] = P6prime(x)
Pnprime['8'] = P8prime(x)
Pnprime['10'] = P10prime(x)
Pnprime['12'] = P12prime(x)
Pnprime['14'] = P14prime(x)
return Pnprime
|
python
|
def Pnprime(x):
"""Calculates first derivatives of Legendre polynomials and returns them
in a dictionary ``Pnprime``.
:param float x: argument to calculate first derivate of Legendre polynomials
:return Pn: dictionary which contains order of Legendre polynomials
(from 0 to 4 and even numbers until 14) as keys and
the corresponding evaluation of first derivative of
Legendre polynomials as values.
:rtype: dict
"""
Pnprime = {}
Pnprime['0'] = 0
Pnprime['1'] = P1prime(x)
Pnprime['2'] = P2prime(x)
Pnprime['3'] = P3prime(x)
Pnprime['4'] = P4prime(x)
Pnprime['6'] = P6prime(x)
Pnprime['8'] = P8prime(x)
Pnprime['10'] = P10prime(x)
Pnprime['12'] = P12prime(x)
Pnprime['14'] = P14prime(x)
return Pnprime
|
[
"def",
"Pnprime",
"(",
"x",
")",
":",
"Pnprime",
"=",
"{",
"}",
"Pnprime",
"[",
"'0'",
"]",
"=",
"0",
"Pnprime",
"[",
"'1'",
"]",
"=",
"P1prime",
"(",
"x",
")",
"Pnprime",
"[",
"'2'",
"]",
"=",
"P2prime",
"(",
"x",
")",
"Pnprime",
"[",
"'3'",
"]",
"=",
"P3prime",
"(",
"x",
")",
"Pnprime",
"[",
"'4'",
"]",
"=",
"P4prime",
"(",
"x",
")",
"Pnprime",
"[",
"'6'",
"]",
"=",
"P6prime",
"(",
"x",
")",
"Pnprime",
"[",
"'8'",
"]",
"=",
"P8prime",
"(",
"x",
")",
"Pnprime",
"[",
"'10'",
"]",
"=",
"P10prime",
"(",
"x",
")",
"Pnprime",
"[",
"'12'",
"]",
"=",
"P12prime",
"(",
"x",
")",
"Pnprime",
"[",
"'14'",
"]",
"=",
"P14prime",
"(",
"x",
")",
"return",
"Pnprime"
] |
Calculates first derivatives of Legendre polynomials and returns them
in a dictionary ``Pnprime``.
:param float x: argument to calculate first derivate of Legendre polynomials
:return Pn: dictionary which contains order of Legendre polynomials
(from 0 to 4 and even numbers until 14) as keys and
the corresponding evaluation of first derivative of
Legendre polynomials as values.
:rtype: dict
|
[
"Calculates",
"first",
"derivatives",
"of",
"Legendre",
"polynomials",
"and",
"returns",
"them",
"in",
"a",
"dictionary",
"Pnprime",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/utils/legendre.py#L38-L61
|
train
|
brian-rose/climlab
|
climlab/model/ebm.py
|
EBM.inferred_heat_transport
|
def inferred_heat_transport(self):
"""Calculates the inferred heat transport by integrating the TOA
energy imbalance from pole to pole.
The method is calculating
.. math::
H(\\varphi) = 2 \pi R^2 \int_{-\pi/2}^{\\varphi} cos\phi \ R_{TOA} d\phi
where :math:`R_{TOA}` is the net radiation at top of atmosphere.
:return: total heat transport on the latitude grid in unit :math:`\\textrm{PW}`
:rtype: array of size ``np.size(self.lat_lat)``
:Example:
.. plot:: code_input_manual/example_EBM_inferred_heat_transport.py
:include-source:
"""
phi = np.deg2rad(self.lat)
energy_in = np.squeeze(self.net_radiation)
return (1E-15 * 2 * np.math.pi * const.a**2 *
integrate.cumtrapz(np.cos(phi)*energy_in, x=phi, initial=0.))
|
python
|
def inferred_heat_transport(self):
"""Calculates the inferred heat transport by integrating the TOA
energy imbalance from pole to pole.
The method is calculating
.. math::
H(\\varphi) = 2 \pi R^2 \int_{-\pi/2}^{\\varphi} cos\phi \ R_{TOA} d\phi
where :math:`R_{TOA}` is the net radiation at top of atmosphere.
:return: total heat transport on the latitude grid in unit :math:`\\textrm{PW}`
:rtype: array of size ``np.size(self.lat_lat)``
:Example:
.. plot:: code_input_manual/example_EBM_inferred_heat_transport.py
:include-source:
"""
phi = np.deg2rad(self.lat)
energy_in = np.squeeze(self.net_radiation)
return (1E-15 * 2 * np.math.pi * const.a**2 *
integrate.cumtrapz(np.cos(phi)*energy_in, x=phi, initial=0.))
|
[
"def",
"inferred_heat_transport",
"(",
"self",
")",
":",
"phi",
"=",
"np",
".",
"deg2rad",
"(",
"self",
".",
"lat",
")",
"energy_in",
"=",
"np",
".",
"squeeze",
"(",
"self",
".",
"net_radiation",
")",
"return",
"(",
"1E-15",
"*",
"2",
"*",
"np",
".",
"math",
".",
"pi",
"*",
"const",
".",
"a",
"**",
"2",
"*",
"integrate",
".",
"cumtrapz",
"(",
"np",
".",
"cos",
"(",
"phi",
")",
"*",
"energy_in",
",",
"x",
"=",
"phi",
",",
"initial",
"=",
"0.",
")",
")"
] |
Calculates the inferred heat transport by integrating the TOA
energy imbalance from pole to pole.
The method is calculating
.. math::
H(\\varphi) = 2 \pi R^2 \int_{-\pi/2}^{\\varphi} cos\phi \ R_{TOA} d\phi
where :math:`R_{TOA}` is the net radiation at top of atmosphere.
:return: total heat transport on the latitude grid in unit :math:`\\textrm{PW}`
:rtype: array of size ``np.size(self.lat_lat)``
:Example:
.. plot:: code_input_manual/example_EBM_inferred_heat_transport.py
:include-source:
|
[
"Calculates",
"the",
"inferred",
"heat",
"transport",
"by",
"integrating",
"the",
"TOA",
"energy",
"imbalance",
"from",
"pole",
"to",
"pole",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/model/ebm.py#L312-L337
|
train
|
brian-rose/climlab
|
climlab/radiation/rrtm/_rrtmg_lw/setup.py
|
rrtmg_lw_gen_source
|
def rrtmg_lw_gen_source(ext, build_dir):
'''Add RRTMG_LW fortran source if Fortran 90 compiler available,
if no compiler is found do not try to build the extension.'''
thispath = config.local_path
module_src = []
for item in modules:
fullname = join(thispath,'rrtmg_lw_v4.85','gcm_model','modules',item)
module_src.append(fullname)
for item in src:
if item in mod_src:
fullname = join(thispath,'sourcemods',item)
else:
fullname = join(thispath,'rrtmg_lw_v4.85','gcm_model','src',item)
module_src.append(fullname)
sourcelist = [join(thispath, '_rrtmg_lw.pyf'),
join(thispath, 'Driver.f90')]
try:
config.have_f90c()
return module_src + sourcelist
except:
print('No Fortran 90 compiler found, not building RRTMG_LW extension!')
return None
|
python
|
def rrtmg_lw_gen_source(ext, build_dir):
'''Add RRTMG_LW fortran source if Fortran 90 compiler available,
if no compiler is found do not try to build the extension.'''
thispath = config.local_path
module_src = []
for item in modules:
fullname = join(thispath,'rrtmg_lw_v4.85','gcm_model','modules',item)
module_src.append(fullname)
for item in src:
if item in mod_src:
fullname = join(thispath,'sourcemods',item)
else:
fullname = join(thispath,'rrtmg_lw_v4.85','gcm_model','src',item)
module_src.append(fullname)
sourcelist = [join(thispath, '_rrtmg_lw.pyf'),
join(thispath, 'Driver.f90')]
try:
config.have_f90c()
return module_src + sourcelist
except:
print('No Fortran 90 compiler found, not building RRTMG_LW extension!')
return None
|
[
"def",
"rrtmg_lw_gen_source",
"(",
"ext",
",",
"build_dir",
")",
":",
"thispath",
"=",
"config",
".",
"local_path",
"module_src",
"=",
"[",
"]",
"for",
"item",
"in",
"modules",
":",
"fullname",
"=",
"join",
"(",
"thispath",
",",
"'rrtmg_lw_v4.85'",
",",
"'gcm_model'",
",",
"'modules'",
",",
"item",
")",
"module_src",
".",
"append",
"(",
"fullname",
")",
"for",
"item",
"in",
"src",
":",
"if",
"item",
"in",
"mod_src",
":",
"fullname",
"=",
"join",
"(",
"thispath",
",",
"'sourcemods'",
",",
"item",
")",
"else",
":",
"fullname",
"=",
"join",
"(",
"thispath",
",",
"'rrtmg_lw_v4.85'",
",",
"'gcm_model'",
",",
"'src'",
",",
"item",
")",
"module_src",
".",
"append",
"(",
"fullname",
")",
"sourcelist",
"=",
"[",
"join",
"(",
"thispath",
",",
"'_rrtmg_lw.pyf'",
")",
",",
"join",
"(",
"thispath",
",",
"'Driver.f90'",
")",
"]",
"try",
":",
"config",
".",
"have_f90c",
"(",
")",
"return",
"module_src",
"+",
"sourcelist",
"except",
":",
"print",
"(",
"'No Fortran 90 compiler found, not building RRTMG_LW extension!'",
")",
"return",
"None"
] |
Add RRTMG_LW fortran source if Fortran 90 compiler available,
if no compiler is found do not try to build the extension.
|
[
"Add",
"RRTMG_LW",
"fortran",
"source",
"if",
"Fortran",
"90",
"compiler",
"available",
"if",
"no",
"compiler",
"is",
"found",
"do",
"not",
"try",
"to",
"build",
"the",
"extension",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/rrtm/_rrtmg_lw/setup.py#L77-L98
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess.compute
|
def compute(self):
"""Computes the tendencies for all state variables given current state
and specified input.
The function first computes all diagnostic processes. They don't produce
any tendencies directly but they may affect the other processes (such as
change in solar distribution). Subsequently, all tendencies and
diagnostics for all explicit processes are computed.
Tendencies due to implicit and adjustment processes need to be
calculated from a state that is already adjusted after explicit
alteration. For that reason the explicit tendencies are applied to the
states temporarily. Now all tendencies from implicit processes are
calculated by matrix inversions and similar to the explicit tendencies,
the implicit ones are applied to the states temporarily. Subsequently,
all instantaneous adjustments are computed.
Then the changes that were made to the states from explicit and implicit
processes are removed again as this
:class:`~climlab.process.time_dependent_process.TimeDependentProcess.compute()`
function is supposed to calculate only tendencies and not apply them
to the states.
Finally, all calculated tendencies from all processes are collected
for each state, summed up and stored in the dictionary
``self.tendencies``, which is an attribute of the time-dependent-process
object, for which the
:class:`~climlab.process.time_dependent_process.TimeDependentProcess.compute()`
method has been called.
**Object attributes** \n
During method execution following object attributes are modified:
:ivar dict tendencies: dictionary that holds tendencies for all states
is calculated for current timestep through
adding up tendencies from explicit, implicit and
adjustment processes.
:ivar dict diagnostics: process diagnostic dictionary is updated
by diagnostic dictionaries of subprocesses
after computation of tendencies.
"""
# First reset tendencies to zero -- recomputing them is the point of this method
for varname in self.tendencies:
self.tendencies[varname] *= 0.
if not self.has_process_type_list:
self._build_process_type_list()
tendencies = {}
ignored = self._compute_type('diagnostic')
tendencies['explicit'] = self._compute_type('explicit')
# Tendencies due to implicit and adjustment processes need to be
# calculated from a state that is already adjusted after explicit stuff
# So apply the tendencies temporarily and then remove them again
for name, var in self.state.items():
var += tendencies['explicit'][name] * self.timestep
# Now compute all implicit processes -- matrix inversions
tendencies['implicit'] = self._compute_type('implicit')
# Same deal ... temporarily apply tendencies from implicit step
for name, var in self.state.items():
var += tendencies['implicit'][name] * self.timestep
# Finally compute all instantaneous adjustments -- expressed as explicit forward step
tendencies['adjustment'] = self._compute_type('adjustment')
# Now remove the changes from the model state
for name, var in self.state.items():
var -= ( (tendencies['implicit'][name] + tendencies['explicit'][name]) *
self.timestep)
# Sum up all subprocess tendencies
for proctype in ['explicit', 'implicit', 'adjustment']:
for varname, tend in tendencies[proctype].items():
self.tendencies[varname] += tend
# Finally compute my own tendencies, if any
self_tend = self._compute()
# Adjustment processes _compute method returns absolute adjustment
# Needs to be converted to rate of change
if self.time_type is 'adjustment':
for varname, adj in self_tend.items():
self_tend[varname] /= self.timestep
for varname, tend in self_tend.items():
self.tendencies[varname] += tend
return self.tendencies
|
python
|
def compute(self):
"""Computes the tendencies for all state variables given current state
and specified input.
The function first computes all diagnostic processes. They don't produce
any tendencies directly but they may affect the other processes (such as
change in solar distribution). Subsequently, all tendencies and
diagnostics for all explicit processes are computed.
Tendencies due to implicit and adjustment processes need to be
calculated from a state that is already adjusted after explicit
alteration. For that reason the explicit tendencies are applied to the
states temporarily. Now all tendencies from implicit processes are
calculated by matrix inversions and similar to the explicit tendencies,
the implicit ones are applied to the states temporarily. Subsequently,
all instantaneous adjustments are computed.
Then the changes that were made to the states from explicit and implicit
processes are removed again as this
:class:`~climlab.process.time_dependent_process.TimeDependentProcess.compute()`
function is supposed to calculate only tendencies and not apply them
to the states.
Finally, all calculated tendencies from all processes are collected
for each state, summed up and stored in the dictionary
``self.tendencies``, which is an attribute of the time-dependent-process
object, for which the
:class:`~climlab.process.time_dependent_process.TimeDependentProcess.compute()`
method has been called.
**Object attributes** \n
During method execution following object attributes are modified:
:ivar dict tendencies: dictionary that holds tendencies for all states
is calculated for current timestep through
adding up tendencies from explicit, implicit and
adjustment processes.
:ivar dict diagnostics: process diagnostic dictionary is updated
by diagnostic dictionaries of subprocesses
after computation of tendencies.
"""
# First reset tendencies to zero -- recomputing them is the point of this method
for varname in self.tendencies:
self.tendencies[varname] *= 0.
if not self.has_process_type_list:
self._build_process_type_list()
tendencies = {}
ignored = self._compute_type('diagnostic')
tendencies['explicit'] = self._compute_type('explicit')
# Tendencies due to implicit and adjustment processes need to be
# calculated from a state that is already adjusted after explicit stuff
# So apply the tendencies temporarily and then remove them again
for name, var in self.state.items():
var += tendencies['explicit'][name] * self.timestep
# Now compute all implicit processes -- matrix inversions
tendencies['implicit'] = self._compute_type('implicit')
# Same deal ... temporarily apply tendencies from implicit step
for name, var in self.state.items():
var += tendencies['implicit'][name] * self.timestep
# Finally compute all instantaneous adjustments -- expressed as explicit forward step
tendencies['adjustment'] = self._compute_type('adjustment')
# Now remove the changes from the model state
for name, var in self.state.items():
var -= ( (tendencies['implicit'][name] + tendencies['explicit'][name]) *
self.timestep)
# Sum up all subprocess tendencies
for proctype in ['explicit', 'implicit', 'adjustment']:
for varname, tend in tendencies[proctype].items():
self.tendencies[varname] += tend
# Finally compute my own tendencies, if any
self_tend = self._compute()
# Adjustment processes _compute method returns absolute adjustment
# Needs to be converted to rate of change
if self.time_type is 'adjustment':
for varname, adj in self_tend.items():
self_tend[varname] /= self.timestep
for varname, tend in self_tend.items():
self.tendencies[varname] += tend
return self.tendencies
|
[
"def",
"compute",
"(",
"self",
")",
":",
"# First reset tendencies to zero -- recomputing them is the point of this method",
"for",
"varname",
"in",
"self",
".",
"tendencies",
":",
"self",
".",
"tendencies",
"[",
"varname",
"]",
"*=",
"0.",
"if",
"not",
"self",
".",
"has_process_type_list",
":",
"self",
".",
"_build_process_type_list",
"(",
")",
"tendencies",
"=",
"{",
"}",
"ignored",
"=",
"self",
".",
"_compute_type",
"(",
"'diagnostic'",
")",
"tendencies",
"[",
"'explicit'",
"]",
"=",
"self",
".",
"_compute_type",
"(",
"'explicit'",
")",
"# Tendencies due to implicit and adjustment processes need to be",
"# calculated from a state that is already adjusted after explicit stuff",
"# So apply the tendencies temporarily and then remove them again",
"for",
"name",
",",
"var",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"var",
"+=",
"tendencies",
"[",
"'explicit'",
"]",
"[",
"name",
"]",
"*",
"self",
".",
"timestep",
"# Now compute all implicit processes -- matrix inversions",
"tendencies",
"[",
"'implicit'",
"]",
"=",
"self",
".",
"_compute_type",
"(",
"'implicit'",
")",
"# Same deal ... temporarily apply tendencies from implicit step",
"for",
"name",
",",
"var",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"var",
"+=",
"tendencies",
"[",
"'implicit'",
"]",
"[",
"name",
"]",
"*",
"self",
".",
"timestep",
"# Finally compute all instantaneous adjustments -- expressed as explicit forward step",
"tendencies",
"[",
"'adjustment'",
"]",
"=",
"self",
".",
"_compute_type",
"(",
"'adjustment'",
")",
"# Now remove the changes from the model state",
"for",
"name",
",",
"var",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"var",
"-=",
"(",
"(",
"tendencies",
"[",
"'implicit'",
"]",
"[",
"name",
"]",
"+",
"tendencies",
"[",
"'explicit'",
"]",
"[",
"name",
"]",
")",
"*",
"self",
".",
"timestep",
")",
"# Sum up all subprocess tendencies",
"for",
"proctype",
"in",
"[",
"'explicit'",
",",
"'implicit'",
",",
"'adjustment'",
"]",
":",
"for",
"varname",
",",
"tend",
"in",
"tendencies",
"[",
"proctype",
"]",
".",
"items",
"(",
")",
":",
"self",
".",
"tendencies",
"[",
"varname",
"]",
"+=",
"tend",
"# Finally compute my own tendencies, if any",
"self_tend",
"=",
"self",
".",
"_compute",
"(",
")",
"# Adjustment processes _compute method returns absolute adjustment",
"# Needs to be converted to rate of change",
"if",
"self",
".",
"time_type",
"is",
"'adjustment'",
":",
"for",
"varname",
",",
"adj",
"in",
"self_tend",
".",
"items",
"(",
")",
":",
"self_tend",
"[",
"varname",
"]",
"/=",
"self",
".",
"timestep",
"for",
"varname",
",",
"tend",
"in",
"self_tend",
".",
"items",
"(",
")",
":",
"self",
".",
"tendencies",
"[",
"varname",
"]",
"+=",
"tend",
"return",
"self",
".",
"tendencies"
] |
Computes the tendencies for all state variables given current state
and specified input.
The function first computes all diagnostic processes. They don't produce
any tendencies directly but they may affect the other processes (such as
change in solar distribution). Subsequently, all tendencies and
diagnostics for all explicit processes are computed.
Tendencies due to implicit and adjustment processes need to be
calculated from a state that is already adjusted after explicit
alteration. For that reason the explicit tendencies are applied to the
states temporarily. Now all tendencies from implicit processes are
calculated by matrix inversions and similar to the explicit tendencies,
the implicit ones are applied to the states temporarily. Subsequently,
all instantaneous adjustments are computed.
Then the changes that were made to the states from explicit and implicit
processes are removed again as this
:class:`~climlab.process.time_dependent_process.TimeDependentProcess.compute()`
function is supposed to calculate only tendencies and not apply them
to the states.
Finally, all calculated tendencies from all processes are collected
for each state, summed up and stored in the dictionary
``self.tendencies``, which is an attribute of the time-dependent-process
object, for which the
:class:`~climlab.process.time_dependent_process.TimeDependentProcess.compute()`
method has been called.
**Object attributes** \n
During method execution following object attributes are modified:
:ivar dict tendencies: dictionary that holds tendencies for all states
is calculated for current timestep through
adding up tendencies from explicit, implicit and
adjustment processes.
:ivar dict diagnostics: process diagnostic dictionary is updated
by diagnostic dictionaries of subprocesses
after computation of tendencies.
|
[
"Computes",
"the",
"tendencies",
"for",
"all",
"state",
"variables",
"given",
"current",
"state",
"and",
"specified",
"input",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L162-L243
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess._compute_type
|
def _compute_type(self, proctype):
"""Computes tendencies due to all subprocesses of given type
``'proctype'``. Also pass all diagnostics up to parent process."""
tendencies = {}
for varname in self.state:
tendencies[varname] = 0. * self.state[varname]
for proc in self.process_types[proctype]:
# Asynchronous coupling
# if subprocess has longer timestep than parent
# We compute subprocess tendencies once
# and apply the same tendency at each substep
step_ratio = int(proc.timestep / self.timestep)
# Does the number of parent steps divide evenly by the ratio?
# If so, it's time to do a subprocess step.
if self.time['steps'] % step_ratio == 0:
proc.time['active_now'] = True
tenddict = proc.compute()
else:
# proc.tendencies is unchanged from last subprocess timestep if we didn't recompute it above
proc.time['active_now'] = False
tenddict = proc.tendencies
for name, tend in tenddict.items():
tendencies[name] += tend
for diagname, value in proc.diagnostics.items():
self.__setattr__(diagname, value)
return tendencies
|
python
|
def _compute_type(self, proctype):
"""Computes tendencies due to all subprocesses of given type
``'proctype'``. Also pass all diagnostics up to parent process."""
tendencies = {}
for varname in self.state:
tendencies[varname] = 0. * self.state[varname]
for proc in self.process_types[proctype]:
# Asynchronous coupling
# if subprocess has longer timestep than parent
# We compute subprocess tendencies once
# and apply the same tendency at each substep
step_ratio = int(proc.timestep / self.timestep)
# Does the number of parent steps divide evenly by the ratio?
# If so, it's time to do a subprocess step.
if self.time['steps'] % step_ratio == 0:
proc.time['active_now'] = True
tenddict = proc.compute()
else:
# proc.tendencies is unchanged from last subprocess timestep if we didn't recompute it above
proc.time['active_now'] = False
tenddict = proc.tendencies
for name, tend in tenddict.items():
tendencies[name] += tend
for diagname, value in proc.diagnostics.items():
self.__setattr__(diagname, value)
return tendencies
|
[
"def",
"_compute_type",
"(",
"self",
",",
"proctype",
")",
":",
"tendencies",
"=",
"{",
"}",
"for",
"varname",
"in",
"self",
".",
"state",
":",
"tendencies",
"[",
"varname",
"]",
"=",
"0.",
"*",
"self",
".",
"state",
"[",
"varname",
"]",
"for",
"proc",
"in",
"self",
".",
"process_types",
"[",
"proctype",
"]",
":",
"# Asynchronous coupling",
"# if subprocess has longer timestep than parent",
"# We compute subprocess tendencies once",
"# and apply the same tendency at each substep",
"step_ratio",
"=",
"int",
"(",
"proc",
".",
"timestep",
"/",
"self",
".",
"timestep",
")",
"# Does the number of parent steps divide evenly by the ratio?",
"# If so, it's time to do a subprocess step.",
"if",
"self",
".",
"time",
"[",
"'steps'",
"]",
"%",
"step_ratio",
"==",
"0",
":",
"proc",
".",
"time",
"[",
"'active_now'",
"]",
"=",
"True",
"tenddict",
"=",
"proc",
".",
"compute",
"(",
")",
"else",
":",
"# proc.tendencies is unchanged from last subprocess timestep if we didn't recompute it above",
"proc",
".",
"time",
"[",
"'active_now'",
"]",
"=",
"False",
"tenddict",
"=",
"proc",
".",
"tendencies",
"for",
"name",
",",
"tend",
"in",
"tenddict",
".",
"items",
"(",
")",
":",
"tendencies",
"[",
"name",
"]",
"+=",
"tend",
"for",
"diagname",
",",
"value",
"in",
"proc",
".",
"diagnostics",
".",
"items",
"(",
")",
":",
"self",
".",
"__setattr__",
"(",
"diagname",
",",
"value",
")",
"return",
"tendencies"
] |
Computes tendencies due to all subprocesses of given type
``'proctype'``. Also pass all diagnostics up to parent process.
|
[
"Computes",
"tendencies",
"due",
"to",
"all",
"subprocesses",
"of",
"given",
"type",
"proctype",
".",
"Also",
"pass",
"all",
"diagnostics",
"up",
"to",
"parent",
"process",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L245-L270
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess._compute
|
def _compute(self):
"""Where the tendencies are actually computed...
Needs to be implemented for each daughter class
Returns a dictionary with same keys as self.state"""
tendencies = {}
for name, value in self.state.items():
tendencies[name] = value * 0.
return tendencies
|
python
|
def _compute(self):
"""Where the tendencies are actually computed...
Needs to be implemented for each daughter class
Returns a dictionary with same keys as self.state"""
tendencies = {}
for name, value in self.state.items():
tendencies[name] = value * 0.
return tendencies
|
[
"def",
"_compute",
"(",
"self",
")",
":",
"tendencies",
"=",
"{",
"}",
"for",
"name",
",",
"value",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"tendencies",
"[",
"name",
"]",
"=",
"value",
"*",
"0.",
"return",
"tendencies"
] |
Where the tendencies are actually computed...
Needs to be implemented for each daughter class
Returns a dictionary with same keys as self.state
|
[
"Where",
"the",
"tendencies",
"are",
"actually",
"computed",
"..."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L272-L281
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess._build_process_type_list
|
def _build_process_type_list(self):
"""Generates lists of processes organized by process type.
Following object attributes are generated or updated:
:ivar dict process_types: a dictionary with entries:
``'diagnostic'``, ``'explicit'``,
``'implicit'`` and ``'adjustment'`` which
point to a list of processes according to
the process types.
The ``process_types`` dictionary is created while walking
through the processes with :func:`~climlab.utils.walk.walk_processes`
CHANGING THIS TO REFER ONLY TO THE CURRENT LEVEL IN SUBPROCESS TREE
"""
self.process_types = {'diagnostic': [], 'explicit': [], 'implicit': [], 'adjustment': []}
#for name, proc, level in walk.walk_processes(self, topdown=self.topdown):
# self.process_types[proc.time_type].append(proc)
for name, proc in self.subprocess.items():
self.process_types[proc.time_type].append(proc)
self.has_process_type_list = True
|
python
|
def _build_process_type_list(self):
"""Generates lists of processes organized by process type.
Following object attributes are generated or updated:
:ivar dict process_types: a dictionary with entries:
``'diagnostic'``, ``'explicit'``,
``'implicit'`` and ``'adjustment'`` which
point to a list of processes according to
the process types.
The ``process_types`` dictionary is created while walking
through the processes with :func:`~climlab.utils.walk.walk_processes`
CHANGING THIS TO REFER ONLY TO THE CURRENT LEVEL IN SUBPROCESS TREE
"""
self.process_types = {'diagnostic': [], 'explicit': [], 'implicit': [], 'adjustment': []}
#for name, proc, level in walk.walk_processes(self, topdown=self.topdown):
# self.process_types[proc.time_type].append(proc)
for name, proc in self.subprocess.items():
self.process_types[proc.time_type].append(proc)
self.has_process_type_list = True
|
[
"def",
"_build_process_type_list",
"(",
"self",
")",
":",
"self",
".",
"process_types",
"=",
"{",
"'diagnostic'",
":",
"[",
"]",
",",
"'explicit'",
":",
"[",
"]",
",",
"'implicit'",
":",
"[",
"]",
",",
"'adjustment'",
":",
"[",
"]",
"}",
"#for name, proc, level in walk.walk_processes(self, topdown=self.topdown):",
"# self.process_types[proc.time_type].append(proc)",
"for",
"name",
",",
"proc",
"in",
"self",
".",
"subprocess",
".",
"items",
"(",
")",
":",
"self",
".",
"process_types",
"[",
"proc",
".",
"time_type",
"]",
".",
"append",
"(",
"proc",
")",
"self",
".",
"has_process_type_list",
"=",
"True"
] |
Generates lists of processes organized by process type.
Following object attributes are generated or updated:
:ivar dict process_types: a dictionary with entries:
``'diagnostic'``, ``'explicit'``,
``'implicit'`` and ``'adjustment'`` which
point to a list of processes according to
the process types.
The ``process_types`` dictionary is created while walking
through the processes with :func:`~climlab.utils.walk.walk_processes`
CHANGING THIS TO REFER ONLY TO THE CURRENT LEVEL IN SUBPROCESS TREE
|
[
"Generates",
"lists",
"of",
"processes",
"organized",
"by",
"process",
"type",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L283-L305
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess.step_forward
|
def step_forward(self):
"""Updates state variables with computed tendencies.
Calls the :func:`compute` method to get current tendencies for all
process states. Multiplied with the timestep and added up to the state
variables is updating all model states.
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> # checking time step counter
>>> model.time['steps']
0
>>> # stepping the model forward
>>> model.step_forward()
>>> # step counter increased
>>> model.time['steps']
1
"""
tenddict = self.compute()
# Total tendency is applied as an explicit forward timestep
# (already accounting properly for order of operations in compute() )
for varname, tend in tenddict.items():
self.state[varname] += tend * self.timestep
# Update all time counters for this and all subprocesses in the tree
# Also pass diagnostics up the process tree
for name, proc, level in walk.walk_processes(self, ignoreFlag=True):
if proc.time['active_now']:
proc._update_time()
|
python
|
def step_forward(self):
"""Updates state variables with computed tendencies.
Calls the :func:`compute` method to get current tendencies for all
process states. Multiplied with the timestep and added up to the state
variables is updating all model states.
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> # checking time step counter
>>> model.time['steps']
0
>>> # stepping the model forward
>>> model.step_forward()
>>> # step counter increased
>>> model.time['steps']
1
"""
tenddict = self.compute()
# Total tendency is applied as an explicit forward timestep
# (already accounting properly for order of operations in compute() )
for varname, tend in tenddict.items():
self.state[varname] += tend * self.timestep
# Update all time counters for this and all subprocesses in the tree
# Also pass diagnostics up the process tree
for name, proc, level in walk.walk_processes(self, ignoreFlag=True):
if proc.time['active_now']:
proc._update_time()
|
[
"def",
"step_forward",
"(",
"self",
")",
":",
"tenddict",
"=",
"self",
".",
"compute",
"(",
")",
"# Total tendency is applied as an explicit forward timestep",
"# (already accounting properly for order of operations in compute() )",
"for",
"varname",
",",
"tend",
"in",
"tenddict",
".",
"items",
"(",
")",
":",
"self",
".",
"state",
"[",
"varname",
"]",
"+=",
"tend",
"*",
"self",
".",
"timestep",
"# Update all time counters for this and all subprocesses in the tree",
"# Also pass diagnostics up the process tree",
"for",
"name",
",",
"proc",
",",
"level",
"in",
"walk",
".",
"walk_processes",
"(",
"self",
",",
"ignoreFlag",
"=",
"True",
")",
":",
"if",
"proc",
".",
"time",
"[",
"'active_now'",
"]",
":",
"proc",
".",
"_update_time",
"(",
")"
] |
Updates state variables with computed tendencies.
Calls the :func:`compute` method to get current tendencies for all
process states. Multiplied with the timestep and added up to the state
variables is updating all model states.
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> # checking time step counter
>>> model.time['steps']
0
>>> # stepping the model forward
>>> model.step_forward()
>>> # step counter increased
>>> model.time['steps']
1
|
[
"Updates",
"state",
"variables",
"with",
"computed",
"tendencies",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L307-L342
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess._update_time
|
def _update_time(self):
"""Increments the timestep counter by one.
Furthermore ``self.time['days_elapsed']`` and
``self.time['num_steps_per_year']`` are updated.
The function is called by the time stepping methods.
"""
self.time['steps'] += 1
# time in days since beginning
self.time['days_elapsed'] += self.time['timestep'] / const.seconds_per_day
if self.time['day_of_year_index'] >= self.time['num_steps_per_year']-1:
self._do_new_calendar_year()
else:
self.time['day_of_year_index'] += 1
|
python
|
def _update_time(self):
"""Increments the timestep counter by one.
Furthermore ``self.time['days_elapsed']`` and
``self.time['num_steps_per_year']`` are updated.
The function is called by the time stepping methods.
"""
self.time['steps'] += 1
# time in days since beginning
self.time['days_elapsed'] += self.time['timestep'] / const.seconds_per_day
if self.time['day_of_year_index'] >= self.time['num_steps_per_year']-1:
self._do_new_calendar_year()
else:
self.time['day_of_year_index'] += 1
|
[
"def",
"_update_time",
"(",
"self",
")",
":",
"self",
".",
"time",
"[",
"'steps'",
"]",
"+=",
"1",
"# time in days since beginning",
"self",
".",
"time",
"[",
"'days_elapsed'",
"]",
"+=",
"self",
".",
"time",
"[",
"'timestep'",
"]",
"/",
"const",
".",
"seconds_per_day",
"if",
"self",
".",
"time",
"[",
"'day_of_year_index'",
"]",
">=",
"self",
".",
"time",
"[",
"'num_steps_per_year'",
"]",
"-",
"1",
":",
"self",
".",
"_do_new_calendar_year",
"(",
")",
"else",
":",
"self",
".",
"time",
"[",
"'day_of_year_index'",
"]",
"+=",
"1"
] |
Increments the timestep counter by one.
Furthermore ``self.time['days_elapsed']`` and
``self.time['num_steps_per_year']`` are updated.
The function is called by the time stepping methods.
|
[
"Increments",
"the",
"timestep",
"counter",
"by",
"one",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L354-L369
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess.integrate_years
|
def integrate_years(self, years=1.0, verbose=True):
"""Integrates the model by a given number of years.
:param float years: integration time for the model in years
[default: 1.0]
:param bool verbose: information whether model time details
should be printed [default: True]
It calls :func:`step_forward` repetitively and calculates a time
averaged value over the integrated period for every model state and all
diagnostics processes.
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_years(2.)
Integrating for 180 steps, 730.4844 days, or 2.0 years.
Total elapsed time is 2.0 years.
>>> model.global_mean_temperature()
Field(13.531055349437258)
"""
days = years * const.days_per_year
numsteps = int(self.time['num_steps_per_year'] * years)
if verbose:
print("Integrating for " + str(numsteps) + " steps, "
+ str(days) + " days, or " + str(years) + " years.")
# begin time loop
for count in range(numsteps):
# Compute the timestep
self.step_forward()
if count == 0:
# on first step only...
# This implements a generic time-averaging feature
# using the list of model state variables
self.timeave = self.state.copy()
# add any new diagnostics to the timeave dictionary
self.timeave.update(self.diagnostics)
# reset all values to zero
for varname, value in self.timeave.items():
# moves on to the next varname if value is None
# this preserves NoneType diagnostics
if value is None:
continue
self.timeave[varname] = 0*value
# adding up all values for each timestep
for varname in list(self.timeave.keys()):
try:
self.timeave[varname] += self.state[varname]
except:
try:
self.timeave[varname] += self.diagnostics[varname]
except: pass
# calculating mean values through dividing the sum by number of steps
for varname, value in self.timeave.items():
if value is None:
continue
self.timeave[varname] /= numsteps
if verbose:
print("Total elapsed time is %s years."
% str(self.time['days_elapsed']/const.days_per_year))
|
python
|
def integrate_years(self, years=1.0, verbose=True):
"""Integrates the model by a given number of years.
:param float years: integration time for the model in years
[default: 1.0]
:param bool verbose: information whether model time details
should be printed [default: True]
It calls :func:`step_forward` repetitively and calculates a time
averaged value over the integrated period for every model state and all
diagnostics processes.
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_years(2.)
Integrating for 180 steps, 730.4844 days, or 2.0 years.
Total elapsed time is 2.0 years.
>>> model.global_mean_temperature()
Field(13.531055349437258)
"""
days = years * const.days_per_year
numsteps = int(self.time['num_steps_per_year'] * years)
if verbose:
print("Integrating for " + str(numsteps) + " steps, "
+ str(days) + " days, or " + str(years) + " years.")
# begin time loop
for count in range(numsteps):
# Compute the timestep
self.step_forward()
if count == 0:
# on first step only...
# This implements a generic time-averaging feature
# using the list of model state variables
self.timeave = self.state.copy()
# add any new diagnostics to the timeave dictionary
self.timeave.update(self.diagnostics)
# reset all values to zero
for varname, value in self.timeave.items():
# moves on to the next varname if value is None
# this preserves NoneType diagnostics
if value is None:
continue
self.timeave[varname] = 0*value
# adding up all values for each timestep
for varname in list(self.timeave.keys()):
try:
self.timeave[varname] += self.state[varname]
except:
try:
self.timeave[varname] += self.diagnostics[varname]
except: pass
# calculating mean values through dividing the sum by number of steps
for varname, value in self.timeave.items():
if value is None:
continue
self.timeave[varname] /= numsteps
if verbose:
print("Total elapsed time is %s years."
% str(self.time['days_elapsed']/const.days_per_year))
|
[
"def",
"integrate_years",
"(",
"self",
",",
"years",
"=",
"1.0",
",",
"verbose",
"=",
"True",
")",
":",
"days",
"=",
"years",
"*",
"const",
".",
"days_per_year",
"numsteps",
"=",
"int",
"(",
"self",
".",
"time",
"[",
"'num_steps_per_year'",
"]",
"*",
"years",
")",
"if",
"verbose",
":",
"print",
"(",
"\"Integrating for \"",
"+",
"str",
"(",
"numsteps",
")",
"+",
"\" steps, \"",
"+",
"str",
"(",
"days",
")",
"+",
"\" days, or \"",
"+",
"str",
"(",
"years",
")",
"+",
"\" years.\"",
")",
"# begin time loop",
"for",
"count",
"in",
"range",
"(",
"numsteps",
")",
":",
"# Compute the timestep",
"self",
".",
"step_forward",
"(",
")",
"if",
"count",
"==",
"0",
":",
"# on first step only...",
"# This implements a generic time-averaging feature",
"# using the list of model state variables",
"self",
".",
"timeave",
"=",
"self",
".",
"state",
".",
"copy",
"(",
")",
"# add any new diagnostics to the timeave dictionary",
"self",
".",
"timeave",
".",
"update",
"(",
"self",
".",
"diagnostics",
")",
"# reset all values to zero",
"for",
"varname",
",",
"value",
"in",
"self",
".",
"timeave",
".",
"items",
"(",
")",
":",
"# moves on to the next varname if value is None",
"# this preserves NoneType diagnostics",
"if",
"value",
"is",
"None",
":",
"continue",
"self",
".",
"timeave",
"[",
"varname",
"]",
"=",
"0",
"*",
"value",
"# adding up all values for each timestep",
"for",
"varname",
"in",
"list",
"(",
"self",
".",
"timeave",
".",
"keys",
"(",
")",
")",
":",
"try",
":",
"self",
".",
"timeave",
"[",
"varname",
"]",
"+=",
"self",
".",
"state",
"[",
"varname",
"]",
"except",
":",
"try",
":",
"self",
".",
"timeave",
"[",
"varname",
"]",
"+=",
"self",
".",
"diagnostics",
"[",
"varname",
"]",
"except",
":",
"pass",
"# calculating mean values through dividing the sum by number of steps",
"for",
"varname",
",",
"value",
"in",
"self",
".",
"timeave",
".",
"items",
"(",
")",
":",
"if",
"value",
"is",
"None",
":",
"continue",
"self",
".",
"timeave",
"[",
"varname",
"]",
"/=",
"numsteps",
"if",
"verbose",
":",
"print",
"(",
"\"Total elapsed time is %s years.\"",
"%",
"str",
"(",
"self",
".",
"time",
"[",
"'days_elapsed'",
"]",
"/",
"const",
".",
"days_per_year",
")",
")"
] |
Integrates the model by a given number of years.
:param float years: integration time for the model in years
[default: 1.0]
:param bool verbose: information whether model time details
should be printed [default: True]
It calls :func:`step_forward` repetitively and calculates a time
averaged value over the integrated period for every model state and all
diagnostics processes.
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_years(2.)
Integrating for 180 steps, 730.4844 days, or 2.0 years.
Total elapsed time is 2.0 years.
>>> model.global_mean_temperature()
Field(13.531055349437258)
|
[
"Integrates",
"the",
"model",
"by",
"a",
"given",
"number",
"of",
"years",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L380-L449
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess.integrate_days
|
def integrate_days(self, days=1.0, verbose=True):
"""Integrates the model forward for a specified number of days.
It convertes the given number of days into years and calls
:func:`integrate_years`.
:param float days: integration time for the model in days
[default: 1.0]
:param bool verbose: information whether model time details
should be printed [default: True]
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_days(80.)
Integrating for 19 steps, 80.0 days, or 0.219032740466 years.
Total elapsed time is 0.211111111111 years.
>>> model.global_mean_temperature()
Field(11.873680783355553)
"""
years = days / const.days_per_year
self.integrate_years(years=years, verbose=verbose)
|
python
|
def integrate_days(self, days=1.0, verbose=True):
"""Integrates the model forward for a specified number of days.
It convertes the given number of days into years and calls
:func:`integrate_years`.
:param float days: integration time for the model in days
[default: 1.0]
:param bool verbose: information whether model time details
should be printed [default: True]
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_days(80.)
Integrating for 19 steps, 80.0 days, or 0.219032740466 years.
Total elapsed time is 0.211111111111 years.
>>> model.global_mean_temperature()
Field(11.873680783355553)
"""
years = days / const.days_per_year
self.integrate_years(years=years, verbose=verbose)
|
[
"def",
"integrate_days",
"(",
"self",
",",
"days",
"=",
"1.0",
",",
"verbose",
"=",
"True",
")",
":",
"years",
"=",
"days",
"/",
"const",
".",
"days_per_year",
"self",
".",
"integrate_years",
"(",
"years",
"=",
"years",
",",
"verbose",
"=",
"verbose",
")"
] |
Integrates the model forward for a specified number of days.
It convertes the given number of days into years and calls
:func:`integrate_years`.
:param float days: integration time for the model in days
[default: 1.0]
:param bool verbose: information whether model time details
should be printed [default: True]
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_days(80.)
Integrating for 19 steps, 80.0 days, or 0.219032740466 years.
Total elapsed time is 0.211111111111 years.
>>> model.global_mean_temperature()
Field(11.873680783355553)
|
[
"Integrates",
"the",
"model",
"forward",
"for",
"a",
"specified",
"number",
"of",
"days",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L451-L481
|
train
|
brian-rose/climlab
|
climlab/process/time_dependent_process.py
|
TimeDependentProcess.integrate_converge
|
def integrate_converge(self, crit=1e-4, verbose=True):
"""Integrates the model until model states are converging.
:param crit: exit criteria for difference of iterated
solutions [default: 0.0001]
:type crit: float
:param bool verbose: information whether total elapsed time
should be printed [default: True]
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_converge()
Total elapsed time is 10.0 years.
>>> model.global_mean_temperature()
Field(14.288155406577301)
"""
# implemented by m-kreuzer
for varname, value in self.state.items():
value_old = copy.deepcopy(value)
self.integrate_years(1,verbose=False)
while np.max(np.abs(value_old-value)) > crit :
value_old = copy.deepcopy(value)
self.integrate_years(1,verbose=False)
if verbose == True:
print("Total elapsed time is %s years."
% str(self.time['days_elapsed']/const.days_per_year))
|
python
|
def integrate_converge(self, crit=1e-4, verbose=True):
"""Integrates the model until model states are converging.
:param crit: exit criteria for difference of iterated
solutions [default: 0.0001]
:type crit: float
:param bool verbose: information whether total elapsed time
should be printed [default: True]
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_converge()
Total elapsed time is 10.0 years.
>>> model.global_mean_temperature()
Field(14.288155406577301)
"""
# implemented by m-kreuzer
for varname, value in self.state.items():
value_old = copy.deepcopy(value)
self.integrate_years(1,verbose=False)
while np.max(np.abs(value_old-value)) > crit :
value_old = copy.deepcopy(value)
self.integrate_years(1,verbose=False)
if verbose == True:
print("Total elapsed time is %s years."
% str(self.time['days_elapsed']/const.days_per_year))
|
[
"def",
"integrate_converge",
"(",
"self",
",",
"crit",
"=",
"1e-4",
",",
"verbose",
"=",
"True",
")",
":",
"# implemented by m-kreuzer",
"for",
"varname",
",",
"value",
"in",
"self",
".",
"state",
".",
"items",
"(",
")",
":",
"value_old",
"=",
"copy",
".",
"deepcopy",
"(",
"value",
")",
"self",
".",
"integrate_years",
"(",
"1",
",",
"verbose",
"=",
"False",
")",
"while",
"np",
".",
"max",
"(",
"np",
".",
"abs",
"(",
"value_old",
"-",
"value",
")",
")",
">",
"crit",
":",
"value_old",
"=",
"copy",
".",
"deepcopy",
"(",
"value",
")",
"self",
".",
"integrate_years",
"(",
"1",
",",
"verbose",
"=",
"False",
")",
"if",
"verbose",
"==",
"True",
":",
"print",
"(",
"\"Total elapsed time is %s years.\"",
"%",
"str",
"(",
"self",
".",
"time",
"[",
"'days_elapsed'",
"]",
"/",
"const",
".",
"days_per_year",
")",
")"
] |
Integrates the model until model states are converging.
:param crit: exit criteria for difference of iterated
solutions [default: 0.0001]
:type crit: float
:param bool verbose: information whether total elapsed time
should be printed [default: True]
:Example:
::
>>> import climlab
>>> model = climlab.EBM()
>>> model.global_mean_temperature()
Field(11.997968598413685)
>>> model.integrate_converge()
Total elapsed time is 10.0 years.
>>> model.global_mean_temperature()
Field(14.288155406577301)
|
[
"Integrates",
"the",
"model",
"until",
"model",
"states",
"are",
"converging",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/process/time_dependent_process.py#L483-L518
|
train
|
brian-rose/climlab
|
climlab/radiation/cam3/setup.py
|
cam3_gen_source
|
def cam3_gen_source(ext, build_dir):
'''Add CAM3 fortran source if Fortran 90 compiler available,
if no compiler is found do not try to build the extension.'''
# Fortran 90 sources in order of compilation
fort90source = ['pmgrid.F90',
'prescribed_aerosols.F90',
'shr_kind_mod.F90',
'quicksort.F90',
'abortutils.F90',
'absems.F90',
'wv_saturation.F90',
'aer_optics.F90',
'cmparray_mod.F90',
'shr_const_mod.F90',
'physconst.F90',
'pkg_cldoptics.F90',
'gffgch.F90',
'chem_surfvals.F90',
'volcrad.F90',
'radae.F90',
'radlw.F90',
'radsw.F90',
'crm.F90',]
#thispath = abspath(config.local_path)
thispath = config.local_path
sourcelist = []
sourcelist.append(join(thispath,'_cam3.pyf'))
for item in fort90source:
sourcelist.append(join(thispath, 'src', item))
sourcelist.append(join(thispath,'Driver.f90'))
try:
config.have_f90c()
return sourcelist
except:
print('No Fortran 90 compiler found, not building CAM3 extension!')
return None
|
python
|
def cam3_gen_source(ext, build_dir):
'''Add CAM3 fortran source if Fortran 90 compiler available,
if no compiler is found do not try to build the extension.'''
# Fortran 90 sources in order of compilation
fort90source = ['pmgrid.F90',
'prescribed_aerosols.F90',
'shr_kind_mod.F90',
'quicksort.F90',
'abortutils.F90',
'absems.F90',
'wv_saturation.F90',
'aer_optics.F90',
'cmparray_mod.F90',
'shr_const_mod.F90',
'physconst.F90',
'pkg_cldoptics.F90',
'gffgch.F90',
'chem_surfvals.F90',
'volcrad.F90',
'radae.F90',
'radlw.F90',
'radsw.F90',
'crm.F90',]
#thispath = abspath(config.local_path)
thispath = config.local_path
sourcelist = []
sourcelist.append(join(thispath,'_cam3.pyf'))
for item in fort90source:
sourcelist.append(join(thispath, 'src', item))
sourcelist.append(join(thispath,'Driver.f90'))
try:
config.have_f90c()
return sourcelist
except:
print('No Fortran 90 compiler found, not building CAM3 extension!')
return None
|
[
"def",
"cam3_gen_source",
"(",
"ext",
",",
"build_dir",
")",
":",
"# Fortran 90 sources in order of compilation",
"fort90source",
"=",
"[",
"'pmgrid.F90'",
",",
"'prescribed_aerosols.F90'",
",",
"'shr_kind_mod.F90'",
",",
"'quicksort.F90'",
",",
"'abortutils.F90'",
",",
"'absems.F90'",
",",
"'wv_saturation.F90'",
",",
"'aer_optics.F90'",
",",
"'cmparray_mod.F90'",
",",
"'shr_const_mod.F90'",
",",
"'physconst.F90'",
",",
"'pkg_cldoptics.F90'",
",",
"'gffgch.F90'",
",",
"'chem_surfvals.F90'",
",",
"'volcrad.F90'",
",",
"'radae.F90'",
",",
"'radlw.F90'",
",",
"'radsw.F90'",
",",
"'crm.F90'",
",",
"]",
"#thispath = abspath(config.local_path)",
"thispath",
"=",
"config",
".",
"local_path",
"sourcelist",
"=",
"[",
"]",
"sourcelist",
".",
"append",
"(",
"join",
"(",
"thispath",
",",
"'_cam3.pyf'",
")",
")",
"for",
"item",
"in",
"fort90source",
":",
"sourcelist",
".",
"append",
"(",
"join",
"(",
"thispath",
",",
"'src'",
",",
"item",
")",
")",
"sourcelist",
".",
"append",
"(",
"join",
"(",
"thispath",
",",
"'Driver.f90'",
")",
")",
"try",
":",
"config",
".",
"have_f90c",
"(",
")",
"return",
"sourcelist",
"except",
":",
"print",
"(",
"'No Fortran 90 compiler found, not building CAM3 extension!'",
")",
"return",
"None"
] |
Add CAM3 fortran source if Fortran 90 compiler available,
if no compiler is found do not try to build the extension.
|
[
"Add",
"CAM3",
"fortran",
"source",
"if",
"Fortran",
"90",
"compiler",
"available",
"if",
"no",
"compiler",
"is",
"found",
"do",
"not",
"try",
"to",
"build",
"the",
"extension",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/radiation/cam3/setup.py#L39-L74
|
train
|
brian-rose/climlab
|
climlab/domain/field.py
|
global_mean
|
def global_mean(field):
"""Calculates the latitude weighted global mean of a field
with latitude dependence.
:param Field field: input field
:raises: :exc:`ValueError` if input field has no latitude axis
:return: latitude weighted global mean of the field
:rtype: float
:Example:
initial global mean temperature of EBM model::
>>> import climlab
>>> model = climlab.EBM()
>>> climlab.global_mean(model.Ts)
Field(11.997968598413685)
"""
try:
lat = field.domain.lat.points
except:
raise ValueError('No latitude axis in input field.')
try:
# Field is 2D latitude / longitude
lon = field.domain.lon.points
return _global_mean_latlon(field.squeeze())
except:
# Field is 1D latitude only (zonal average)
lat_radians = np.deg2rad(lat)
return _global_mean(field.squeeze(), lat_radians)
|
python
|
def global_mean(field):
"""Calculates the latitude weighted global mean of a field
with latitude dependence.
:param Field field: input field
:raises: :exc:`ValueError` if input field has no latitude axis
:return: latitude weighted global mean of the field
:rtype: float
:Example:
initial global mean temperature of EBM model::
>>> import climlab
>>> model = climlab.EBM()
>>> climlab.global_mean(model.Ts)
Field(11.997968598413685)
"""
try:
lat = field.domain.lat.points
except:
raise ValueError('No latitude axis in input field.')
try:
# Field is 2D latitude / longitude
lon = field.domain.lon.points
return _global_mean_latlon(field.squeeze())
except:
# Field is 1D latitude only (zonal average)
lat_radians = np.deg2rad(lat)
return _global_mean(field.squeeze(), lat_radians)
|
[
"def",
"global_mean",
"(",
"field",
")",
":",
"try",
":",
"lat",
"=",
"field",
".",
"domain",
".",
"lat",
".",
"points",
"except",
":",
"raise",
"ValueError",
"(",
"'No latitude axis in input field.'",
")",
"try",
":",
"# Field is 2D latitude / longitude",
"lon",
"=",
"field",
".",
"domain",
".",
"lon",
".",
"points",
"return",
"_global_mean_latlon",
"(",
"field",
".",
"squeeze",
"(",
")",
")",
"except",
":",
"# Field is 1D latitude only (zonal average)",
"lat_radians",
"=",
"np",
".",
"deg2rad",
"(",
"lat",
")",
"return",
"_global_mean",
"(",
"field",
".",
"squeeze",
"(",
")",
",",
"lat_radians",
")"
] |
Calculates the latitude weighted global mean of a field
with latitude dependence.
:param Field field: input field
:raises: :exc:`ValueError` if input field has no latitude axis
:return: latitude weighted global mean of the field
:rtype: float
:Example:
initial global mean temperature of EBM model::
>>> import climlab
>>> model = climlab.EBM()
>>> climlab.global_mean(model.Ts)
Field(11.997968598413685)
|
[
"Calculates",
"the",
"latitude",
"weighted",
"global",
"mean",
"of",
"a",
"field",
"with",
"latitude",
"dependence",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/field.py#L194-L224
|
train
|
brian-rose/climlab
|
climlab/domain/field.py
|
to_latlon
|
def to_latlon(array, domain, axis = 'lon'):
"""Broadcasts a 1D axis dependent array across another axis.
:param array input_array: the 1D array used for broadcasting
:param domain: the domain associated with that
array
:param axis: the axis that the input array will
be broadcasted across
[default: 'lon']
:return: Field with the same shape as the
domain
:Example:
::
>>> import climlab
>>> from climlab.domain.field import to_latlon
>>> import numpy as np
>>> state = climlab.surface_state(num_lat=3, num_lon=4)
>>> m = climlab.EBM_annual(state=state)
>>> insolation = np.array([237., 417., 237.])
>>> insolation = to_latlon(insolation, domain = m.domains['Ts'])
>>> insolation.shape
(3, 4, 1)
>>> insolation
Field([[[ 237.], [[ 417.], [[ 237.],
[ 237.], [ 417.], [ 237.],
[ 237.], [ 417.], [ 237.],
[ 237.]], [ 417.]], [ 237.]]])
"""
# if array is latitude dependent (has the same shape as lat)
axis, array, depth = np.meshgrid(domain.axes[axis].points, array,
domain.axes['depth'].points)
if axis == 'lat':
# if array is longitude dependent (has the same shape as lon)
np.swapaxes(array,1,0)
return Field(array, domain=domain)
|
python
|
def to_latlon(array, domain, axis = 'lon'):
"""Broadcasts a 1D axis dependent array across another axis.
:param array input_array: the 1D array used for broadcasting
:param domain: the domain associated with that
array
:param axis: the axis that the input array will
be broadcasted across
[default: 'lon']
:return: Field with the same shape as the
domain
:Example:
::
>>> import climlab
>>> from climlab.domain.field import to_latlon
>>> import numpy as np
>>> state = climlab.surface_state(num_lat=3, num_lon=4)
>>> m = climlab.EBM_annual(state=state)
>>> insolation = np.array([237., 417., 237.])
>>> insolation = to_latlon(insolation, domain = m.domains['Ts'])
>>> insolation.shape
(3, 4, 1)
>>> insolation
Field([[[ 237.], [[ 417.], [[ 237.],
[ 237.], [ 417.], [ 237.],
[ 237.], [ 417.], [ 237.],
[ 237.]], [ 417.]], [ 237.]]])
"""
# if array is latitude dependent (has the same shape as lat)
axis, array, depth = np.meshgrid(domain.axes[axis].points, array,
domain.axes['depth'].points)
if axis == 'lat':
# if array is longitude dependent (has the same shape as lon)
np.swapaxes(array,1,0)
return Field(array, domain=domain)
|
[
"def",
"to_latlon",
"(",
"array",
",",
"domain",
",",
"axis",
"=",
"'lon'",
")",
":",
"# if array is latitude dependent (has the same shape as lat)",
"axis",
",",
"array",
",",
"depth",
"=",
"np",
".",
"meshgrid",
"(",
"domain",
".",
"axes",
"[",
"axis",
"]",
".",
"points",
",",
"array",
",",
"domain",
".",
"axes",
"[",
"'depth'",
"]",
".",
"points",
")",
"if",
"axis",
"==",
"'lat'",
":",
"# if array is longitude dependent (has the same shape as lon)",
"np",
".",
"swapaxes",
"(",
"array",
",",
"1",
",",
"0",
")",
"return",
"Field",
"(",
"array",
",",
"domain",
"=",
"domain",
")"
] |
Broadcasts a 1D axis dependent array across another axis.
:param array input_array: the 1D array used for broadcasting
:param domain: the domain associated with that
array
:param axis: the axis that the input array will
be broadcasted across
[default: 'lon']
:return: Field with the same shape as the
domain
:Example:
::
>>> import climlab
>>> from climlab.domain.field import to_latlon
>>> import numpy as np
>>> state = climlab.surface_state(num_lat=3, num_lon=4)
>>> m = climlab.EBM_annual(state=state)
>>> insolation = np.array([237., 417., 237.])
>>> insolation = to_latlon(insolation, domain = m.domains['Ts'])
>>> insolation.shape
(3, 4, 1)
>>> insolation
Field([[[ 237.], [[ 417.], [[ 237.],
[ 237.], [ 417.], [ 237.],
[ 237.], [ 417.], [ 237.],
[ 237.]], [ 417.]], [ 237.]]])
|
[
"Broadcasts",
"a",
"1D",
"axis",
"dependent",
"array",
"across",
"another",
"axis",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/field.py#L243-L281
|
train
|
brian-rose/climlab
|
climlab/domain/xarray.py
|
Field_to_xarray
|
def Field_to_xarray(field):
'''Convert a climlab.Field object to xarray.DataArray'''
dom = field.domain
dims = []; dimlist = []; coords = {};
for axname in dom.axes:
dimlist.append(axname)
try:
assert field.interfaces[dom.axis_index[axname]]
bounds_name = axname + '_bounds'
dims.append(bounds_name)
coords[bounds_name] = dom.axes[axname].bounds
except:
dims.append(axname)
coords[axname] = dom.axes[axname].points
# Might need to reorder the data
da = DataArray(field.transpose([dom.axis_index[name] for name in dimlist]),
dims=dims, coords=coords)
for name in dims:
try:
da[name].attrs['units'] = dom.axes[name].units
except:
pass
return da
|
python
|
def Field_to_xarray(field):
'''Convert a climlab.Field object to xarray.DataArray'''
dom = field.domain
dims = []; dimlist = []; coords = {};
for axname in dom.axes:
dimlist.append(axname)
try:
assert field.interfaces[dom.axis_index[axname]]
bounds_name = axname + '_bounds'
dims.append(bounds_name)
coords[bounds_name] = dom.axes[axname].bounds
except:
dims.append(axname)
coords[axname] = dom.axes[axname].points
# Might need to reorder the data
da = DataArray(field.transpose([dom.axis_index[name] for name in dimlist]),
dims=dims, coords=coords)
for name in dims:
try:
da[name].attrs['units'] = dom.axes[name].units
except:
pass
return da
|
[
"def",
"Field_to_xarray",
"(",
"field",
")",
":",
"dom",
"=",
"field",
".",
"domain",
"dims",
"=",
"[",
"]",
"dimlist",
"=",
"[",
"]",
"coords",
"=",
"{",
"}",
"for",
"axname",
"in",
"dom",
".",
"axes",
":",
"dimlist",
".",
"append",
"(",
"axname",
")",
"try",
":",
"assert",
"field",
".",
"interfaces",
"[",
"dom",
".",
"axis_index",
"[",
"axname",
"]",
"]",
"bounds_name",
"=",
"axname",
"+",
"'_bounds'",
"dims",
".",
"append",
"(",
"bounds_name",
")",
"coords",
"[",
"bounds_name",
"]",
"=",
"dom",
".",
"axes",
"[",
"axname",
"]",
".",
"bounds",
"except",
":",
"dims",
".",
"append",
"(",
"axname",
")",
"coords",
"[",
"axname",
"]",
"=",
"dom",
".",
"axes",
"[",
"axname",
"]",
".",
"points",
"# Might need to reorder the data",
"da",
"=",
"DataArray",
"(",
"field",
".",
"transpose",
"(",
"[",
"dom",
".",
"axis_index",
"[",
"name",
"]",
"for",
"name",
"in",
"dimlist",
"]",
")",
",",
"dims",
"=",
"dims",
",",
"coords",
"=",
"coords",
")",
"for",
"name",
"in",
"dims",
":",
"try",
":",
"da",
"[",
"name",
"]",
".",
"attrs",
"[",
"'units'",
"]",
"=",
"dom",
".",
"axes",
"[",
"name",
"]",
".",
"units",
"except",
":",
"pass",
"return",
"da"
] |
Convert a climlab.Field object to xarray.DataArray
|
[
"Convert",
"a",
"climlab",
".",
"Field",
"object",
"to",
"xarray",
".",
"DataArray"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/xarray.py#L8-L30
|
train
|
brian-rose/climlab
|
climlab/domain/xarray.py
|
state_to_xarray
|
def state_to_xarray(state):
'''Convert a dictionary of climlab.Field objects to xarray.Dataset
Input: dictionary of climlab.Field objects
(e.g. process.state or process.diagnostics dictionary)
Output: xarray.Dataset object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
Any items in the dictionary that are not instances of climlab.Field
are ignored.'''
from climlab.domain.field import Field
ds = Dataset()
for name, field in state.items():
if isinstance(field, Field):
ds[name] = Field_to_xarray(field)
dom = field.domain
for axname, ax in dom.axes.items():
bounds_name = axname + '_bounds'
ds.coords[bounds_name] = DataArray(ax.bounds, dims=[bounds_name],
coords={bounds_name:ax.bounds})
try:
ds[bounds_name].attrs['units'] = ax.units
except:
pass
else:
warnings.warn('{} excluded from Dataset because it is not a Field variable.'.format(name))
return ds
|
python
|
def state_to_xarray(state):
'''Convert a dictionary of climlab.Field objects to xarray.Dataset
Input: dictionary of climlab.Field objects
(e.g. process.state or process.diagnostics dictionary)
Output: xarray.Dataset object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
Any items in the dictionary that are not instances of climlab.Field
are ignored.'''
from climlab.domain.field import Field
ds = Dataset()
for name, field in state.items():
if isinstance(field, Field):
ds[name] = Field_to_xarray(field)
dom = field.domain
for axname, ax in dom.axes.items():
bounds_name = axname + '_bounds'
ds.coords[bounds_name] = DataArray(ax.bounds, dims=[bounds_name],
coords={bounds_name:ax.bounds})
try:
ds[bounds_name].attrs['units'] = ax.units
except:
pass
else:
warnings.warn('{} excluded from Dataset because it is not a Field variable.'.format(name))
return ds
|
[
"def",
"state_to_xarray",
"(",
"state",
")",
":",
"from",
"climlab",
".",
"domain",
".",
"field",
"import",
"Field",
"ds",
"=",
"Dataset",
"(",
")",
"for",
"name",
",",
"field",
"in",
"state",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"field",
",",
"Field",
")",
":",
"ds",
"[",
"name",
"]",
"=",
"Field_to_xarray",
"(",
"field",
")",
"dom",
"=",
"field",
".",
"domain",
"for",
"axname",
",",
"ax",
"in",
"dom",
".",
"axes",
".",
"items",
"(",
")",
":",
"bounds_name",
"=",
"axname",
"+",
"'_bounds'",
"ds",
".",
"coords",
"[",
"bounds_name",
"]",
"=",
"DataArray",
"(",
"ax",
".",
"bounds",
",",
"dims",
"=",
"[",
"bounds_name",
"]",
",",
"coords",
"=",
"{",
"bounds_name",
":",
"ax",
".",
"bounds",
"}",
")",
"try",
":",
"ds",
"[",
"bounds_name",
"]",
".",
"attrs",
"[",
"'units'",
"]",
"=",
"ax",
".",
"units",
"except",
":",
"pass",
"else",
":",
"warnings",
".",
"warn",
"(",
"'{} excluded from Dataset because it is not a Field variable.'",
".",
"format",
"(",
"name",
")",
")",
"return",
"ds"
] |
Convert a dictionary of climlab.Field objects to xarray.Dataset
Input: dictionary of climlab.Field objects
(e.g. process.state or process.diagnostics dictionary)
Output: xarray.Dataset object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
Any items in the dictionary that are not instances of climlab.Field
are ignored.
|
[
"Convert",
"a",
"dictionary",
"of",
"climlab",
".",
"Field",
"objects",
"to",
"xarray",
".",
"Dataset"
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/xarray.py#L32-L60
|
train
|
brian-rose/climlab
|
climlab/domain/xarray.py
|
to_xarray
|
def to_xarray(input):
'''Convert climlab input to xarray format.
If input is a climlab.Field object, return xarray.DataArray
If input is a dictionary (e.g. process.state or process.diagnostics),
return xarray.Dataset object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
Any items in the dictionary that are not instances of climlab.Field
are ignored.'''
from climlab.domain.field import Field
if isinstance(input, Field):
return Field_to_xarray(input)
elif isinstance(input, dict):
return state_to_xarray(input)
else:
raise TypeError('input must be Field object or dictionary of Field objects')
|
python
|
def to_xarray(input):
'''Convert climlab input to xarray format.
If input is a climlab.Field object, return xarray.DataArray
If input is a dictionary (e.g. process.state or process.diagnostics),
return xarray.Dataset object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
Any items in the dictionary that are not instances of climlab.Field
are ignored.'''
from climlab.domain.field import Field
if isinstance(input, Field):
return Field_to_xarray(input)
elif isinstance(input, dict):
return state_to_xarray(input)
else:
raise TypeError('input must be Field object or dictionary of Field objects')
|
[
"def",
"to_xarray",
"(",
"input",
")",
":",
"from",
"climlab",
".",
"domain",
".",
"field",
"import",
"Field",
"if",
"isinstance",
"(",
"input",
",",
"Field",
")",
":",
"return",
"Field_to_xarray",
"(",
"input",
")",
"elif",
"isinstance",
"(",
"input",
",",
"dict",
")",
":",
"return",
"state_to_xarray",
"(",
"input",
")",
"else",
":",
"raise",
"TypeError",
"(",
"'input must be Field object or dictionary of Field objects'",
")"
] |
Convert climlab input to xarray format.
If input is a climlab.Field object, return xarray.DataArray
If input is a dictionary (e.g. process.state or process.diagnostics),
return xarray.Dataset object with all spatial axes,
including 'bounds' axes indicating cell boundaries in each spatial dimension.
Any items in the dictionary that are not instances of climlab.Field
are ignored.
|
[
"Convert",
"climlab",
"input",
"to",
"xarray",
"format",
"."
] |
eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6
|
https://github.com/brian-rose/climlab/blob/eae188a2ae9308229b8cbb8fe0b65f51b50ee1e6/climlab/domain/xarray.py#L62-L79
|
train
|
adamrehn/slidingwindow
|
slidingwindow/SlidingWindow.py
|
generate
|
def generate(data, dimOrder, maxWindowSize, overlapPercent, transforms = []):
"""
Generates a set of sliding windows for the specified dataset.
"""
# Determine the dimensions of the input data
width = data.shape[dimOrder.index('w')]
height = data.shape[dimOrder.index('h')]
# Generate the windows
return generateForSize(width, height, dimOrder, maxWindowSize, overlapPercent, transforms)
|
python
|
def generate(data, dimOrder, maxWindowSize, overlapPercent, transforms = []):
"""
Generates a set of sliding windows for the specified dataset.
"""
# Determine the dimensions of the input data
width = data.shape[dimOrder.index('w')]
height = data.shape[dimOrder.index('h')]
# Generate the windows
return generateForSize(width, height, dimOrder, maxWindowSize, overlapPercent, transforms)
|
[
"def",
"generate",
"(",
"data",
",",
"dimOrder",
",",
"maxWindowSize",
",",
"overlapPercent",
",",
"transforms",
"=",
"[",
"]",
")",
":",
"# Determine the dimensions of the input data",
"width",
"=",
"data",
".",
"shape",
"[",
"dimOrder",
".",
"index",
"(",
"'w'",
")",
"]",
"height",
"=",
"data",
".",
"shape",
"[",
"dimOrder",
".",
"index",
"(",
"'h'",
")",
"]",
"# Generate the windows",
"return",
"generateForSize",
"(",
"width",
",",
"height",
",",
"dimOrder",
",",
"maxWindowSize",
",",
"overlapPercent",
",",
"transforms",
")"
] |
Generates a set of sliding windows for the specified dataset.
|
[
"Generates",
"a",
"set",
"of",
"sliding",
"windows",
"for",
"the",
"specified",
"dataset",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/SlidingWindow.py#L87-L97
|
train
|
adamrehn/slidingwindow
|
slidingwindow/SlidingWindow.py
|
generateForSize
|
def generateForSize(width, height, dimOrder, maxWindowSize, overlapPercent, transforms = []):
"""
Generates a set of sliding windows for a dataset with the specified dimensions and order.
"""
# If the input data is smaller than the specified window size,
# clip the window size to the input size on both dimensions
windowSizeX = min(maxWindowSize, width)
windowSizeY = min(maxWindowSize, height)
# Compute the window overlap and step size
windowOverlapX = int(math.floor(windowSizeX * overlapPercent))
windowOverlapY = int(math.floor(windowSizeY * overlapPercent))
stepSizeX = windowSizeX - windowOverlapX
stepSizeY = windowSizeY - windowOverlapY
# Determine how many windows we will need in order to cover the input data
lastX = width - windowSizeX
lastY = height - windowSizeY
xOffsets = list(range(0, lastX+1, stepSizeX))
yOffsets = list(range(0, lastY+1, stepSizeY))
# Unless the input data dimensions are exact multiples of the step size,
# we will need one additional row and column of windows to get 100% coverage
if len(xOffsets) == 0 or xOffsets[-1] != lastX:
xOffsets.append(lastX)
if len(yOffsets) == 0 or yOffsets[-1] != lastY:
yOffsets.append(lastY)
# Generate the list of windows
windows = []
for xOffset in xOffsets:
for yOffset in yOffsets:
for transform in [None] + transforms:
windows.append(SlidingWindow(
x=xOffset,
y=yOffset,
w=windowSizeX,
h=windowSizeY,
dimOrder=dimOrder,
transform=transform
))
return windows
|
python
|
def generateForSize(width, height, dimOrder, maxWindowSize, overlapPercent, transforms = []):
"""
Generates a set of sliding windows for a dataset with the specified dimensions and order.
"""
# If the input data is smaller than the specified window size,
# clip the window size to the input size on both dimensions
windowSizeX = min(maxWindowSize, width)
windowSizeY = min(maxWindowSize, height)
# Compute the window overlap and step size
windowOverlapX = int(math.floor(windowSizeX * overlapPercent))
windowOverlapY = int(math.floor(windowSizeY * overlapPercent))
stepSizeX = windowSizeX - windowOverlapX
stepSizeY = windowSizeY - windowOverlapY
# Determine how many windows we will need in order to cover the input data
lastX = width - windowSizeX
lastY = height - windowSizeY
xOffsets = list(range(0, lastX+1, stepSizeX))
yOffsets = list(range(0, lastY+1, stepSizeY))
# Unless the input data dimensions are exact multiples of the step size,
# we will need one additional row and column of windows to get 100% coverage
if len(xOffsets) == 0 or xOffsets[-1] != lastX:
xOffsets.append(lastX)
if len(yOffsets) == 0 or yOffsets[-1] != lastY:
yOffsets.append(lastY)
# Generate the list of windows
windows = []
for xOffset in xOffsets:
for yOffset in yOffsets:
for transform in [None] + transforms:
windows.append(SlidingWindow(
x=xOffset,
y=yOffset,
w=windowSizeX,
h=windowSizeY,
dimOrder=dimOrder,
transform=transform
))
return windows
|
[
"def",
"generateForSize",
"(",
"width",
",",
"height",
",",
"dimOrder",
",",
"maxWindowSize",
",",
"overlapPercent",
",",
"transforms",
"=",
"[",
"]",
")",
":",
"# If the input data is smaller than the specified window size,",
"# clip the window size to the input size on both dimensions",
"windowSizeX",
"=",
"min",
"(",
"maxWindowSize",
",",
"width",
")",
"windowSizeY",
"=",
"min",
"(",
"maxWindowSize",
",",
"height",
")",
"# Compute the window overlap and step size",
"windowOverlapX",
"=",
"int",
"(",
"math",
".",
"floor",
"(",
"windowSizeX",
"*",
"overlapPercent",
")",
")",
"windowOverlapY",
"=",
"int",
"(",
"math",
".",
"floor",
"(",
"windowSizeY",
"*",
"overlapPercent",
")",
")",
"stepSizeX",
"=",
"windowSizeX",
"-",
"windowOverlapX",
"stepSizeY",
"=",
"windowSizeY",
"-",
"windowOverlapY",
"# Determine how many windows we will need in order to cover the input data",
"lastX",
"=",
"width",
"-",
"windowSizeX",
"lastY",
"=",
"height",
"-",
"windowSizeY",
"xOffsets",
"=",
"list",
"(",
"range",
"(",
"0",
",",
"lastX",
"+",
"1",
",",
"stepSizeX",
")",
")",
"yOffsets",
"=",
"list",
"(",
"range",
"(",
"0",
",",
"lastY",
"+",
"1",
",",
"stepSizeY",
")",
")",
"# Unless the input data dimensions are exact multiples of the step size,",
"# we will need one additional row and column of windows to get 100% coverage",
"if",
"len",
"(",
"xOffsets",
")",
"==",
"0",
"or",
"xOffsets",
"[",
"-",
"1",
"]",
"!=",
"lastX",
":",
"xOffsets",
".",
"append",
"(",
"lastX",
")",
"if",
"len",
"(",
"yOffsets",
")",
"==",
"0",
"or",
"yOffsets",
"[",
"-",
"1",
"]",
"!=",
"lastY",
":",
"yOffsets",
".",
"append",
"(",
"lastY",
")",
"# Generate the list of windows",
"windows",
"=",
"[",
"]",
"for",
"xOffset",
"in",
"xOffsets",
":",
"for",
"yOffset",
"in",
"yOffsets",
":",
"for",
"transform",
"in",
"[",
"None",
"]",
"+",
"transforms",
":",
"windows",
".",
"append",
"(",
"SlidingWindow",
"(",
"x",
"=",
"xOffset",
",",
"y",
"=",
"yOffset",
",",
"w",
"=",
"windowSizeX",
",",
"h",
"=",
"windowSizeY",
",",
"dimOrder",
"=",
"dimOrder",
",",
"transform",
"=",
"transform",
")",
")",
"return",
"windows"
] |
Generates a set of sliding windows for a dataset with the specified dimensions and order.
|
[
"Generates",
"a",
"set",
"of",
"sliding",
"windows",
"for",
"a",
"dataset",
"with",
"the",
"specified",
"dimensions",
"and",
"order",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/SlidingWindow.py#L100-L143
|
train
|
adamrehn/slidingwindow
|
slidingwindow/SlidingWindow.py
|
SlidingWindow.apply
|
def apply(self, matrix):
"""
Slices the supplied matrix and applies any transform bound to this window
"""
view = matrix[ self.indices() ]
return self.transform(view) if self.transform != None else view
|
python
|
def apply(self, matrix):
"""
Slices the supplied matrix and applies any transform bound to this window
"""
view = matrix[ self.indices() ]
return self.transform(view) if self.transform != None else view
|
[
"def",
"apply",
"(",
"self",
",",
"matrix",
")",
":",
"view",
"=",
"matrix",
"[",
"self",
".",
"indices",
"(",
")",
"]",
"return",
"self",
".",
"transform",
"(",
"view",
")",
"if",
"self",
".",
"transform",
"!=",
"None",
"else",
"view"
] |
Slices the supplied matrix and applies any transform bound to this window
|
[
"Slices",
"the",
"supplied",
"matrix",
"and",
"applies",
"any",
"transform",
"bound",
"to",
"this",
"window"
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/SlidingWindow.py#L27-L32
|
train
|
adamrehn/slidingwindow
|
slidingwindow/SlidingWindow.py
|
SlidingWindow.indices
|
def indices(self, includeChannel=True):
"""
Retrieves the indices for this window as a tuple of slices
"""
if self.dimOrder == DimOrder.HeightWidthChannel:
# Equivalent to [self.y:self.y+self.h+1, self.x:self.x+self.w+1]
return (
slice(self.y, self.y+self.h),
slice(self.x, self.x+self.w)
)
elif self.dimOrder == DimOrder.ChannelHeightWidth:
if includeChannel is True:
# Equivalent to [:, self.y:self.y+self.h+1, self.x:self.x+self.w+1]
return (
slice(None, None),
slice(self.y, self.y+self.h),
slice(self.x, self.x+self.w)
)
else:
# Equivalent to [self.y:self.y+self.h+1, self.x:self.x+self.w+1]
return (
slice(self.y, self.y+self.h),
slice(self.x, self.x+self.w)
)
else:
raise Error('Unsupported order of dimensions: ' + str(self.dimOrder))
|
python
|
def indices(self, includeChannel=True):
"""
Retrieves the indices for this window as a tuple of slices
"""
if self.dimOrder == DimOrder.HeightWidthChannel:
# Equivalent to [self.y:self.y+self.h+1, self.x:self.x+self.w+1]
return (
slice(self.y, self.y+self.h),
slice(self.x, self.x+self.w)
)
elif self.dimOrder == DimOrder.ChannelHeightWidth:
if includeChannel is True:
# Equivalent to [:, self.y:self.y+self.h+1, self.x:self.x+self.w+1]
return (
slice(None, None),
slice(self.y, self.y+self.h),
slice(self.x, self.x+self.w)
)
else:
# Equivalent to [self.y:self.y+self.h+1, self.x:self.x+self.w+1]
return (
slice(self.y, self.y+self.h),
slice(self.x, self.x+self.w)
)
else:
raise Error('Unsupported order of dimensions: ' + str(self.dimOrder))
|
[
"def",
"indices",
"(",
"self",
",",
"includeChannel",
"=",
"True",
")",
":",
"if",
"self",
".",
"dimOrder",
"==",
"DimOrder",
".",
"HeightWidthChannel",
":",
"# Equivalent to [self.y:self.y+self.h+1, self.x:self.x+self.w+1]",
"return",
"(",
"slice",
"(",
"self",
".",
"y",
",",
"self",
".",
"y",
"+",
"self",
".",
"h",
")",
",",
"slice",
"(",
"self",
".",
"x",
",",
"self",
".",
"x",
"+",
"self",
".",
"w",
")",
")",
"elif",
"self",
".",
"dimOrder",
"==",
"DimOrder",
".",
"ChannelHeightWidth",
":",
"if",
"includeChannel",
"is",
"True",
":",
"# Equivalent to [:, self.y:self.y+self.h+1, self.x:self.x+self.w+1]",
"return",
"(",
"slice",
"(",
"None",
",",
"None",
")",
",",
"slice",
"(",
"self",
".",
"y",
",",
"self",
".",
"y",
"+",
"self",
".",
"h",
")",
",",
"slice",
"(",
"self",
".",
"x",
",",
"self",
".",
"x",
"+",
"self",
".",
"w",
")",
")",
"else",
":",
"# Equivalent to [self.y:self.y+self.h+1, self.x:self.x+self.w+1]",
"return",
"(",
"slice",
"(",
"self",
".",
"y",
",",
"self",
".",
"y",
"+",
"self",
".",
"h",
")",
",",
"slice",
"(",
"self",
".",
"x",
",",
"self",
".",
"x",
"+",
"self",
".",
"w",
")",
")",
"else",
":",
"raise",
"Error",
"(",
"'Unsupported order of dimensions: '",
"+",
"str",
"(",
"self",
".",
"dimOrder",
")",
")"
] |
Retrieves the indices for this window as a tuple of slices
|
[
"Retrieves",
"the",
"indices",
"for",
"this",
"window",
"as",
"a",
"tuple",
"of",
"slices"
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/SlidingWindow.py#L46-L78
|
train
|
adamrehn/slidingwindow
|
slidingwindow/Batching.py
|
batchWindows
|
def batchWindows(windows, batchSize):
"""
Splits a list of windows into a series of batches.
"""
return np.array_split(np.array(windows), len(windows) // batchSize)
|
python
|
def batchWindows(windows, batchSize):
"""
Splits a list of windows into a series of batches.
"""
return np.array_split(np.array(windows), len(windows) // batchSize)
|
[
"def",
"batchWindows",
"(",
"windows",
",",
"batchSize",
")",
":",
"return",
"np",
".",
"array_split",
"(",
"np",
".",
"array",
"(",
"windows",
")",
",",
"len",
"(",
"windows",
")",
"//",
"batchSize",
")"
] |
Splits a list of windows into a series of batches.
|
[
"Splits",
"a",
"list",
"of",
"windows",
"into",
"a",
"series",
"of",
"batches",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/Batching.py#L3-L7
|
train
|
adamrehn/slidingwindow
|
slidingwindow/WindowDistance.py
|
generateDistanceMatrix
|
def generateDistanceMatrix(width, height):
"""
Generates a matrix specifying the distance of each point in a window to its centre.
"""
# Determine the coordinates of the exact centre of the window
originX = width / 2
originY = height / 2
# Generate the distance matrix
distances = zerosFactory((height,width), dtype=np.float)
for index, val in np.ndenumerate(distances):
y,x = index
distances[(y,x)] = math.sqrt( math.pow(x - originX, 2) + math.pow(y - originY, 2) )
return distances
|
python
|
def generateDistanceMatrix(width, height):
"""
Generates a matrix specifying the distance of each point in a window to its centre.
"""
# Determine the coordinates of the exact centre of the window
originX = width / 2
originY = height / 2
# Generate the distance matrix
distances = zerosFactory((height,width), dtype=np.float)
for index, val in np.ndenumerate(distances):
y,x = index
distances[(y,x)] = math.sqrt( math.pow(x - originX, 2) + math.pow(y - originY, 2) )
return distances
|
[
"def",
"generateDistanceMatrix",
"(",
"width",
",",
"height",
")",
":",
"# Determine the coordinates of the exact centre of the window",
"originX",
"=",
"width",
"/",
"2",
"originY",
"=",
"height",
"/",
"2",
"# Generate the distance matrix",
"distances",
"=",
"zerosFactory",
"(",
"(",
"height",
",",
"width",
")",
",",
"dtype",
"=",
"np",
".",
"float",
")",
"for",
"index",
",",
"val",
"in",
"np",
".",
"ndenumerate",
"(",
"distances",
")",
":",
"y",
",",
"x",
"=",
"index",
"distances",
"[",
"(",
"y",
",",
"x",
")",
"]",
"=",
"math",
".",
"sqrt",
"(",
"math",
".",
"pow",
"(",
"x",
"-",
"originX",
",",
"2",
")",
"+",
"math",
".",
"pow",
"(",
"y",
"-",
"originY",
",",
"2",
")",
")",
"return",
"distances"
] |
Generates a matrix specifying the distance of each point in a window to its centre.
|
[
"Generates",
"a",
"matrix",
"specifying",
"the",
"distance",
"of",
"each",
"point",
"in",
"a",
"window",
"to",
"its",
"centre",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/WindowDistance.py#L5-L20
|
train
|
adamrehn/slidingwindow
|
slidingwindow/ArrayUtils.py
|
_requiredSize
|
def _requiredSize(shape, dtype):
"""
Determines the number of bytes required to store a NumPy array with
the specified shape and datatype.
"""
return math.floor(np.prod(np.asarray(shape, dtype=np.uint64)) * np.dtype(dtype).itemsize)
|
python
|
def _requiredSize(shape, dtype):
"""
Determines the number of bytes required to store a NumPy array with
the specified shape and datatype.
"""
return math.floor(np.prod(np.asarray(shape, dtype=np.uint64)) * np.dtype(dtype).itemsize)
|
[
"def",
"_requiredSize",
"(",
"shape",
",",
"dtype",
")",
":",
"return",
"math",
".",
"floor",
"(",
"np",
".",
"prod",
"(",
"np",
".",
"asarray",
"(",
"shape",
",",
"dtype",
"=",
"np",
".",
"uint64",
")",
")",
"*",
"np",
".",
"dtype",
"(",
"dtype",
")",
".",
"itemsize",
")"
] |
Determines the number of bytes required to store a NumPy array with
the specified shape and datatype.
|
[
"Determines",
"the",
"number",
"of",
"bytes",
"required",
"to",
"store",
"a",
"NumPy",
"array",
"with",
"the",
"specified",
"shape",
"and",
"datatype",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/ArrayUtils.py#L5-L10
|
train
|
adamrehn/slidingwindow
|
slidingwindow/ArrayUtils.py
|
arrayFactory
|
def arrayFactory(shape, dtype=float):
"""
Creates a new ndarray of the specified shape and datatype, storing
it in memory if there is sufficient available space or else using
a memory-mapped temporary file to provide the underlying buffer.
"""
# Determine the number of bytes required to store the array
requiredBytes = _requiredSize(shape, dtype)
# Determine if there is sufficient available memory
vmem = psutil.virtual_memory()
if vmem.available > requiredBytes:
return np.ndarray(shape=shape, dtype=dtype)
else:
return TempfileBackedArray(shape=shape, dtype=dtype)
|
python
|
def arrayFactory(shape, dtype=float):
"""
Creates a new ndarray of the specified shape and datatype, storing
it in memory if there is sufficient available space or else using
a memory-mapped temporary file to provide the underlying buffer.
"""
# Determine the number of bytes required to store the array
requiredBytes = _requiredSize(shape, dtype)
# Determine if there is sufficient available memory
vmem = psutil.virtual_memory()
if vmem.available > requiredBytes:
return np.ndarray(shape=shape, dtype=dtype)
else:
return TempfileBackedArray(shape=shape, dtype=dtype)
|
[
"def",
"arrayFactory",
"(",
"shape",
",",
"dtype",
"=",
"float",
")",
":",
"# Determine the number of bytes required to store the array",
"requiredBytes",
"=",
"_requiredSize",
"(",
"shape",
",",
"dtype",
")",
"# Determine if there is sufficient available memory",
"vmem",
"=",
"psutil",
".",
"virtual_memory",
"(",
")",
"if",
"vmem",
".",
"available",
">",
"requiredBytes",
":",
"return",
"np",
".",
"ndarray",
"(",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
")",
"else",
":",
"return",
"TempfileBackedArray",
"(",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
")"
] |
Creates a new ndarray of the specified shape and datatype, storing
it in memory if there is sufficient available space or else using
a memory-mapped temporary file to provide the underlying buffer.
|
[
"Creates",
"a",
"new",
"ndarray",
"of",
"the",
"specified",
"shape",
"and",
"datatype",
"storing",
"it",
"in",
"memory",
"if",
"there",
"is",
"sufficient",
"available",
"space",
"or",
"else",
"using",
"a",
"memory",
"-",
"mapped",
"temporary",
"file",
"to",
"provide",
"the",
"underlying",
"buffer",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/ArrayUtils.py#L40-L55
|
train
|
adamrehn/slidingwindow
|
slidingwindow/ArrayUtils.py
|
arrayCast
|
def arrayCast(source, dtype):
"""
Casts a NumPy array to the specified datatype, storing the copy
in memory if there is sufficient available space or else using a
memory-mapped temporary file to provide the underlying buffer.
"""
# Determine the number of bytes required to store the array
requiredBytes = _requiredSize(source.shape, dtype)
# Determine if there is sufficient available memory
vmem = psutil.virtual_memory()
if vmem.available > requiredBytes:
return source.astype(dtype, subok=False)
else:
dest = arrayFactory(source.shape, dtype)
np.copyto(dest, source, casting='unsafe')
return dest
|
python
|
def arrayCast(source, dtype):
"""
Casts a NumPy array to the specified datatype, storing the copy
in memory if there is sufficient available space or else using a
memory-mapped temporary file to provide the underlying buffer.
"""
# Determine the number of bytes required to store the array
requiredBytes = _requiredSize(source.shape, dtype)
# Determine if there is sufficient available memory
vmem = psutil.virtual_memory()
if vmem.available > requiredBytes:
return source.astype(dtype, subok=False)
else:
dest = arrayFactory(source.shape, dtype)
np.copyto(dest, source, casting='unsafe')
return dest
|
[
"def",
"arrayCast",
"(",
"source",
",",
"dtype",
")",
":",
"# Determine the number of bytes required to store the array",
"requiredBytes",
"=",
"_requiredSize",
"(",
"source",
".",
"shape",
",",
"dtype",
")",
"# Determine if there is sufficient available memory",
"vmem",
"=",
"psutil",
".",
"virtual_memory",
"(",
")",
"if",
"vmem",
".",
"available",
">",
"requiredBytes",
":",
"return",
"source",
".",
"astype",
"(",
"dtype",
",",
"subok",
"=",
"False",
")",
"else",
":",
"dest",
"=",
"arrayFactory",
"(",
"source",
".",
"shape",
",",
"dtype",
")",
"np",
".",
"copyto",
"(",
"dest",
",",
"source",
",",
"casting",
"=",
"'unsafe'",
")",
"return",
"dest"
] |
Casts a NumPy array to the specified datatype, storing the copy
in memory if there is sufficient available space or else using a
memory-mapped temporary file to provide the underlying buffer.
|
[
"Casts",
"a",
"NumPy",
"array",
"to",
"the",
"specified",
"datatype",
"storing",
"the",
"copy",
"in",
"memory",
"if",
"there",
"is",
"sufficient",
"available",
"space",
"or",
"else",
"using",
"a",
"memory",
"-",
"mapped",
"temporary",
"file",
"to",
"provide",
"the",
"underlying",
"buffer",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/ArrayUtils.py#L67-L84
|
train
|
adamrehn/slidingwindow
|
slidingwindow/ArrayUtils.py
|
determineMaxWindowSize
|
def determineMaxWindowSize(dtype, limit=None):
"""
Determines the largest square window size that can be used, based on
the specified datatype and amount of currently available system memory.
If `limit` is specified, then this value will be returned in the event
that it is smaller than the maximum computed size.
"""
vmem = psutil.virtual_memory()
maxSize = math.floor(math.sqrt(vmem.available / np.dtype(dtype).itemsize))
if limit is None or limit >= maxSize:
return maxSize
else:
return limit
|
python
|
def determineMaxWindowSize(dtype, limit=None):
"""
Determines the largest square window size that can be used, based on
the specified datatype and amount of currently available system memory.
If `limit` is specified, then this value will be returned in the event
that it is smaller than the maximum computed size.
"""
vmem = psutil.virtual_memory()
maxSize = math.floor(math.sqrt(vmem.available / np.dtype(dtype).itemsize))
if limit is None or limit >= maxSize:
return maxSize
else:
return limit
|
[
"def",
"determineMaxWindowSize",
"(",
"dtype",
",",
"limit",
"=",
"None",
")",
":",
"vmem",
"=",
"psutil",
".",
"virtual_memory",
"(",
")",
"maxSize",
"=",
"math",
".",
"floor",
"(",
"math",
".",
"sqrt",
"(",
"vmem",
".",
"available",
"/",
"np",
".",
"dtype",
"(",
"dtype",
")",
".",
"itemsize",
")",
")",
"if",
"limit",
"is",
"None",
"or",
"limit",
">=",
"maxSize",
":",
"return",
"maxSize",
"else",
":",
"return",
"limit"
] |
Determines the largest square window size that can be used, based on
the specified datatype and amount of currently available system memory.
If `limit` is specified, then this value will be returned in the event
that it is smaller than the maximum computed size.
|
[
"Determines",
"the",
"largest",
"square",
"window",
"size",
"that",
"can",
"be",
"used",
"based",
"on",
"the",
"specified",
"datatype",
"and",
"amount",
"of",
"currently",
"available",
"system",
"memory",
".",
"If",
"limit",
"is",
"specified",
"then",
"this",
"value",
"will",
"be",
"returned",
"in",
"the",
"event",
"that",
"it",
"is",
"smaller",
"than",
"the",
"maximum",
"computed",
"size",
"."
] |
17ea9395b48671e8cb7321b9510c6b25fec5e45f
|
https://github.com/adamrehn/slidingwindow/blob/17ea9395b48671e8cb7321b9510c6b25fec5e45f/slidingwindow/ArrayUtils.py#L87-L100
|
train
|
kwikteam/phy
|
phy/cluster/views/base.py
|
ManualClusteringView.set_state
|
def set_state(self, state):
"""Set the view state.
The passed object is the persisted `self.state` bunch.
May be overriden.
"""
for k, v in state.items():
setattr(self, k, v)
|
python
|
def set_state(self, state):
"""Set the view state.
The passed object is the persisted `self.state` bunch.
May be overriden.
"""
for k, v in state.items():
setattr(self, k, v)
|
[
"def",
"set_state",
"(",
"self",
",",
"state",
")",
":",
"for",
"k",
",",
"v",
"in",
"state",
".",
"items",
"(",
")",
":",
"setattr",
"(",
"self",
",",
"k",
",",
"v",
")"
] |
Set the view state.
The passed object is the persisted `self.state` bunch.
May be overriden.
|
[
"Set",
"the",
"view",
"state",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/cluster/views/base.py#L128-L137
|
train
|
kwikteam/phy
|
phy/utils/_misc.py
|
_fullname
|
def _fullname(o):
"""Return the fully-qualified name of a function."""
return o.__module__ + "." + o.__name__ if o.__module__ else o.__name__
|
python
|
def _fullname(o):
"""Return the fully-qualified name of a function."""
return o.__module__ + "." + o.__name__ if o.__module__ else o.__name__
|
[
"def",
"_fullname",
"(",
"o",
")",
":",
"return",
"o",
".",
"__module__",
"+",
"\".\"",
"+",
"o",
".",
"__name__",
"if",
"o",
".",
"__module__",
"else",
"o",
".",
"__name__"
] |
Return the fully-qualified name of a function.
|
[
"Return",
"the",
"fully",
"-",
"qualified",
"name",
"of",
"a",
"function",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/utils/_misc.py#L123-L125
|
train
|
kwikteam/phy
|
phy/cluster/views/feature.py
|
FeatureView._get_axis_label
|
def _get_axis_label(self, dim):
"""Return the channel id from a dimension, if applicable."""
if u(dim[:-1]).isdecimal():
n = len(self.channel_ids)
return str(self.channel_ids[int(dim[:-1]) % n]) + dim[-1]
else:
return dim
|
python
|
def _get_axis_label(self, dim):
"""Return the channel id from a dimension, if applicable."""
if u(dim[:-1]).isdecimal():
n = len(self.channel_ids)
return str(self.channel_ids[int(dim[:-1]) % n]) + dim[-1]
else:
return dim
|
[
"def",
"_get_axis_label",
"(",
"self",
",",
"dim",
")",
":",
"if",
"u",
"(",
"dim",
"[",
":",
"-",
"1",
"]",
")",
".",
"isdecimal",
"(",
")",
":",
"n",
"=",
"len",
"(",
"self",
".",
"channel_ids",
")",
"return",
"str",
"(",
"self",
".",
"channel_ids",
"[",
"int",
"(",
"dim",
"[",
":",
"-",
"1",
"]",
")",
"%",
"n",
"]",
")",
"+",
"dim",
"[",
"-",
"1",
"]",
"else",
":",
"return",
"dim"
] |
Return the channel id from a dimension, if applicable.
|
[
"Return",
"the",
"channel",
"id",
"from",
"a",
"dimension",
"if",
"applicable",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/cluster/views/feature.py#L132-L138
|
train
|
kwikteam/phy
|
phy/cluster/views/feature.py
|
FeatureView._get_axis_data
|
def _get_axis_data(self, bunch, dim, cluster_id=None, load_all=None):
"""Extract the points from the data on a given dimension.
bunch is returned by the features() function.
dim is the string specifying the dimensions to extract for the data.
"""
if dim in self.attributes:
return self.attributes[dim](cluster_id, load_all=load_all)
masks = bunch.get('masks', None)
assert dim not in self.attributes # This is called only on PC data.
s = 'ABCDEFGHIJ'
# Channel relative index.
c_rel = int(dim[:-1])
# Get the channel_id from the currently-selected channels.
channel_id = self.channel_ids[c_rel % len(self.channel_ids)]
# Skup the plot if the channel id is not displayed.
if channel_id not in bunch.channel_ids: # pragma: no cover
return None
# Get the column index of the current channel in data.
c = list(bunch.channel_ids).index(channel_id)
# Principal component: A=0, B=1, etc.
d = s.index(dim[-1])
if masks is not None:
masks = masks[:, c]
return Bunch(data=bunch.data[:, c, d],
masks=masks,
)
|
python
|
def _get_axis_data(self, bunch, dim, cluster_id=None, load_all=None):
"""Extract the points from the data on a given dimension.
bunch is returned by the features() function.
dim is the string specifying the dimensions to extract for the data.
"""
if dim in self.attributes:
return self.attributes[dim](cluster_id, load_all=load_all)
masks = bunch.get('masks', None)
assert dim not in self.attributes # This is called only on PC data.
s = 'ABCDEFGHIJ'
# Channel relative index.
c_rel = int(dim[:-1])
# Get the channel_id from the currently-selected channels.
channel_id = self.channel_ids[c_rel % len(self.channel_ids)]
# Skup the plot if the channel id is not displayed.
if channel_id not in bunch.channel_ids: # pragma: no cover
return None
# Get the column index of the current channel in data.
c = list(bunch.channel_ids).index(channel_id)
# Principal component: A=0, B=1, etc.
d = s.index(dim[-1])
if masks is not None:
masks = masks[:, c]
return Bunch(data=bunch.data[:, c, d],
masks=masks,
)
|
[
"def",
"_get_axis_data",
"(",
"self",
",",
"bunch",
",",
"dim",
",",
"cluster_id",
"=",
"None",
",",
"load_all",
"=",
"None",
")",
":",
"if",
"dim",
"in",
"self",
".",
"attributes",
":",
"return",
"self",
".",
"attributes",
"[",
"dim",
"]",
"(",
"cluster_id",
",",
"load_all",
"=",
"load_all",
")",
"masks",
"=",
"bunch",
".",
"get",
"(",
"'masks'",
",",
"None",
")",
"assert",
"dim",
"not",
"in",
"self",
".",
"attributes",
"# This is called only on PC data.",
"s",
"=",
"'ABCDEFGHIJ'",
"# Channel relative index.",
"c_rel",
"=",
"int",
"(",
"dim",
"[",
":",
"-",
"1",
"]",
")",
"# Get the channel_id from the currently-selected channels.",
"channel_id",
"=",
"self",
".",
"channel_ids",
"[",
"c_rel",
"%",
"len",
"(",
"self",
".",
"channel_ids",
")",
"]",
"# Skup the plot if the channel id is not displayed.",
"if",
"channel_id",
"not",
"in",
"bunch",
".",
"channel_ids",
":",
"# pragma: no cover",
"return",
"None",
"# Get the column index of the current channel in data.",
"c",
"=",
"list",
"(",
"bunch",
".",
"channel_ids",
")",
".",
"index",
"(",
"channel_id",
")",
"# Principal component: A=0, B=1, etc.",
"d",
"=",
"s",
".",
"index",
"(",
"dim",
"[",
"-",
"1",
"]",
")",
"if",
"masks",
"is",
"not",
"None",
":",
"masks",
"=",
"masks",
"[",
":",
",",
"c",
"]",
"return",
"Bunch",
"(",
"data",
"=",
"bunch",
".",
"data",
"[",
":",
",",
"c",
",",
"d",
"]",
",",
"masks",
"=",
"masks",
",",
")"
] |
Extract the points from the data on a given dimension.
bunch is returned by the features() function.
dim is the string specifying the dimensions to extract for the data.
|
[
"Extract",
"the",
"points",
"from",
"the",
"data",
"on",
"a",
"given",
"dimension",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/cluster/views/feature.py#L140-L167
|
train
|
kwikteam/phy
|
phy/cluster/views/feature.py
|
FeatureView._plot_labels
|
def _plot_labels(self):
"""Plot feature labels along left and bottom edge of subplots"""
# iterate simultaneously over kth row in left column and
# kth column in bottom row:
br = self.n_cols - 1 # bottom row
for k in range(0, self.n_cols):
dim_x, _ = self.grid_dim[0][k].split(',')
_, dim_y = self.grid_dim[k][br].split(',')
# Get the channel ids corresponding to the relative channel indices
# specified in the dimensions. Channel 0 corresponds to the first
# best channel for the selected cluster, and so on.
dim_x = self._get_axis_label(dim_x)
dim_y = self._get_axis_label(dim_y)
# Left edge of left column of subplots.
self[k, 0].text(pos=[-1., 0.],
text=dim_y,
anchor=[-1.03, 0.],
data_bounds=None,
)
# Bottom edge of bottom row of subplots.
self[br, k].text(pos=[0., -1.],
text=dim_x,
anchor=[0., -1.04],
data_bounds=None,
)
|
python
|
def _plot_labels(self):
"""Plot feature labels along left and bottom edge of subplots"""
# iterate simultaneously over kth row in left column and
# kth column in bottom row:
br = self.n_cols - 1 # bottom row
for k in range(0, self.n_cols):
dim_x, _ = self.grid_dim[0][k].split(',')
_, dim_y = self.grid_dim[k][br].split(',')
# Get the channel ids corresponding to the relative channel indices
# specified in the dimensions. Channel 0 corresponds to the first
# best channel for the selected cluster, and so on.
dim_x = self._get_axis_label(dim_x)
dim_y = self._get_axis_label(dim_y)
# Left edge of left column of subplots.
self[k, 0].text(pos=[-1., 0.],
text=dim_y,
anchor=[-1.03, 0.],
data_bounds=None,
)
# Bottom edge of bottom row of subplots.
self[br, k].text(pos=[0., -1.],
text=dim_x,
anchor=[0., -1.04],
data_bounds=None,
)
|
[
"def",
"_plot_labels",
"(",
"self",
")",
":",
"# iterate simultaneously over kth row in left column and",
"# kth column in bottom row:",
"br",
"=",
"self",
".",
"n_cols",
"-",
"1",
"# bottom row",
"for",
"k",
"in",
"range",
"(",
"0",
",",
"self",
".",
"n_cols",
")",
":",
"dim_x",
",",
"_",
"=",
"self",
".",
"grid_dim",
"[",
"0",
"]",
"[",
"k",
"]",
".",
"split",
"(",
"','",
")",
"_",
",",
"dim_y",
"=",
"self",
".",
"grid_dim",
"[",
"k",
"]",
"[",
"br",
"]",
".",
"split",
"(",
"','",
")",
"# Get the channel ids corresponding to the relative channel indices",
"# specified in the dimensions. Channel 0 corresponds to the first",
"# best channel for the selected cluster, and so on.",
"dim_x",
"=",
"self",
".",
"_get_axis_label",
"(",
"dim_x",
")",
"dim_y",
"=",
"self",
".",
"_get_axis_label",
"(",
"dim_y",
")",
"# Left edge of left column of subplots.",
"self",
"[",
"k",
",",
"0",
"]",
".",
"text",
"(",
"pos",
"=",
"[",
"-",
"1.",
",",
"0.",
"]",
",",
"text",
"=",
"dim_y",
",",
"anchor",
"=",
"[",
"-",
"1.03",
",",
"0.",
"]",
",",
"data_bounds",
"=",
"None",
",",
")",
"# Bottom edge of bottom row of subplots.",
"self",
"[",
"br",
",",
"k",
"]",
".",
"text",
"(",
"pos",
"=",
"[",
"0.",
",",
"-",
"1.",
"]",
",",
"text",
"=",
"dim_x",
",",
"anchor",
"=",
"[",
"0.",
",",
"-",
"1.04",
"]",
",",
"data_bounds",
"=",
"None",
",",
")"
] |
Plot feature labels along left and bottom edge of subplots
|
[
"Plot",
"feature",
"labels",
"along",
"left",
"and",
"bottom",
"edge",
"of",
"subplots"
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/cluster/views/feature.py#L199-L223
|
train
|
kwikteam/phy
|
phy/cluster/views/feature.py
|
FeatureView.on_channel_click
|
def on_channel_click(self, channel_id=None, key=None, button=None):
"""Respond to the click on a channel."""
channels = self.channel_ids
if channels is None:
return
if len(channels) == 1:
self.on_select()
return
assert len(channels) >= 2
# Get the axis from the pressed button (1, 2, etc.)
# axis = 'x' if button == 1 else 'y'
d = 0 if button == 1 else 1
# Change the first or second best channel.
old = channels[d]
# Avoid updating the view if the channel doesn't change.
if channel_id == old:
return
channels[d] = channel_id
# Ensure that the first two channels are different.
if channels[1 - d] == channel_id:
channels[1 - d] = old
assert channels[0] != channels[1]
# Remove duplicate channels.
self.channel_ids = _uniq(channels)
logger.debug("Choose channels %d and %d in feature view.",
*channels[:2])
# Fix the channels temporarily.
self.on_select(fixed_channels=True)
|
python
|
def on_channel_click(self, channel_id=None, key=None, button=None):
"""Respond to the click on a channel."""
channels = self.channel_ids
if channels is None:
return
if len(channels) == 1:
self.on_select()
return
assert len(channels) >= 2
# Get the axis from the pressed button (1, 2, etc.)
# axis = 'x' if button == 1 else 'y'
d = 0 if button == 1 else 1
# Change the first or second best channel.
old = channels[d]
# Avoid updating the view if the channel doesn't change.
if channel_id == old:
return
channels[d] = channel_id
# Ensure that the first two channels are different.
if channels[1 - d] == channel_id:
channels[1 - d] = old
assert channels[0] != channels[1]
# Remove duplicate channels.
self.channel_ids = _uniq(channels)
logger.debug("Choose channels %d and %d in feature view.",
*channels[:2])
# Fix the channels temporarily.
self.on_select(fixed_channels=True)
|
[
"def",
"on_channel_click",
"(",
"self",
",",
"channel_id",
"=",
"None",
",",
"key",
"=",
"None",
",",
"button",
"=",
"None",
")",
":",
"channels",
"=",
"self",
".",
"channel_ids",
"if",
"channels",
"is",
"None",
":",
"return",
"if",
"len",
"(",
"channels",
")",
"==",
"1",
":",
"self",
".",
"on_select",
"(",
")",
"return",
"assert",
"len",
"(",
"channels",
")",
">=",
"2",
"# Get the axis from the pressed button (1, 2, etc.)",
"# axis = 'x' if button == 1 else 'y'",
"d",
"=",
"0",
"if",
"button",
"==",
"1",
"else",
"1",
"# Change the first or second best channel.",
"old",
"=",
"channels",
"[",
"d",
"]",
"# Avoid updating the view if the channel doesn't change.",
"if",
"channel_id",
"==",
"old",
":",
"return",
"channels",
"[",
"d",
"]",
"=",
"channel_id",
"# Ensure that the first two channels are different.",
"if",
"channels",
"[",
"1",
"-",
"d",
"]",
"==",
"channel_id",
":",
"channels",
"[",
"1",
"-",
"d",
"]",
"=",
"old",
"assert",
"channels",
"[",
"0",
"]",
"!=",
"channels",
"[",
"1",
"]",
"# Remove duplicate channels.",
"self",
".",
"channel_ids",
"=",
"_uniq",
"(",
"channels",
")",
"logger",
".",
"debug",
"(",
"\"Choose channels %d and %d in feature view.\"",
",",
"*",
"channels",
"[",
":",
"2",
"]",
")",
"# Fix the channels temporarily.",
"self",
".",
"on_select",
"(",
"fixed_channels",
"=",
"True",
")"
] |
Respond to the click on a channel.
|
[
"Respond",
"to",
"the",
"click",
"on",
"a",
"channel",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/cluster/views/feature.py#L317-L344
|
train
|
kwikteam/phy
|
phy/cluster/views/feature.py
|
FeatureView.on_request_split
|
def on_request_split(self):
"""Return the spikes enclosed by the lasso."""
if (self.lasso.count < 3 or
not len(self.cluster_ids)): # pragma: no cover
return np.array([], dtype=np.int64)
assert len(self.channel_ids)
# Get the dimensions of the lassoed subplot.
i, j = self.lasso.box
dim = self.grid_dim[i][j]
dim_x, dim_y = dim.split(',')
# Get all points from all clusters.
pos = []
spike_ids = []
for cluster_id in self.cluster_ids:
# Load all spikes.
bunch = self.features(cluster_id,
channel_ids=self.channel_ids,
load_all=True)
px = self._get_axis_data(bunch, dim_x, cluster_id=cluster_id,
load_all=True)
py = self._get_axis_data(bunch, dim_y, cluster_id=cluster_id,
load_all=True)
points = np.c_[px.data, py.data]
# Normalize the points.
xmin, xmax = self._get_axis_bounds(dim_x, px)
ymin, ymax = self._get_axis_bounds(dim_y, py)
r = Range((xmin, ymin, xmax, ymax))
points = r.apply(points)
pos.append(points)
spike_ids.append(bunch.spike_ids)
pos = np.vstack(pos)
spike_ids = np.concatenate(spike_ids)
# Find lassoed spikes.
ind = self.lasso.in_polygon(pos)
self.lasso.clear()
return np.unique(spike_ids[ind])
|
python
|
def on_request_split(self):
"""Return the spikes enclosed by the lasso."""
if (self.lasso.count < 3 or
not len(self.cluster_ids)): # pragma: no cover
return np.array([], dtype=np.int64)
assert len(self.channel_ids)
# Get the dimensions of the lassoed subplot.
i, j = self.lasso.box
dim = self.grid_dim[i][j]
dim_x, dim_y = dim.split(',')
# Get all points from all clusters.
pos = []
spike_ids = []
for cluster_id in self.cluster_ids:
# Load all spikes.
bunch = self.features(cluster_id,
channel_ids=self.channel_ids,
load_all=True)
px = self._get_axis_data(bunch, dim_x, cluster_id=cluster_id,
load_all=True)
py = self._get_axis_data(bunch, dim_y, cluster_id=cluster_id,
load_all=True)
points = np.c_[px.data, py.data]
# Normalize the points.
xmin, xmax = self._get_axis_bounds(dim_x, px)
ymin, ymax = self._get_axis_bounds(dim_y, py)
r = Range((xmin, ymin, xmax, ymax))
points = r.apply(points)
pos.append(points)
spike_ids.append(bunch.spike_ids)
pos = np.vstack(pos)
spike_ids = np.concatenate(spike_ids)
# Find lassoed spikes.
ind = self.lasso.in_polygon(pos)
self.lasso.clear()
return np.unique(spike_ids[ind])
|
[
"def",
"on_request_split",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"lasso",
".",
"count",
"<",
"3",
"or",
"not",
"len",
"(",
"self",
".",
"cluster_ids",
")",
")",
":",
"# pragma: no cover",
"return",
"np",
".",
"array",
"(",
"[",
"]",
",",
"dtype",
"=",
"np",
".",
"int64",
")",
"assert",
"len",
"(",
"self",
".",
"channel_ids",
")",
"# Get the dimensions of the lassoed subplot.",
"i",
",",
"j",
"=",
"self",
".",
"lasso",
".",
"box",
"dim",
"=",
"self",
".",
"grid_dim",
"[",
"i",
"]",
"[",
"j",
"]",
"dim_x",
",",
"dim_y",
"=",
"dim",
".",
"split",
"(",
"','",
")",
"# Get all points from all clusters.",
"pos",
"=",
"[",
"]",
"spike_ids",
"=",
"[",
"]",
"for",
"cluster_id",
"in",
"self",
".",
"cluster_ids",
":",
"# Load all spikes.",
"bunch",
"=",
"self",
".",
"features",
"(",
"cluster_id",
",",
"channel_ids",
"=",
"self",
".",
"channel_ids",
",",
"load_all",
"=",
"True",
")",
"px",
"=",
"self",
".",
"_get_axis_data",
"(",
"bunch",
",",
"dim_x",
",",
"cluster_id",
"=",
"cluster_id",
",",
"load_all",
"=",
"True",
")",
"py",
"=",
"self",
".",
"_get_axis_data",
"(",
"bunch",
",",
"dim_y",
",",
"cluster_id",
"=",
"cluster_id",
",",
"load_all",
"=",
"True",
")",
"points",
"=",
"np",
".",
"c_",
"[",
"px",
".",
"data",
",",
"py",
".",
"data",
"]",
"# Normalize the points.",
"xmin",
",",
"xmax",
"=",
"self",
".",
"_get_axis_bounds",
"(",
"dim_x",
",",
"px",
")",
"ymin",
",",
"ymax",
"=",
"self",
".",
"_get_axis_bounds",
"(",
"dim_y",
",",
"py",
")",
"r",
"=",
"Range",
"(",
"(",
"xmin",
",",
"ymin",
",",
"xmax",
",",
"ymax",
")",
")",
"points",
"=",
"r",
".",
"apply",
"(",
"points",
")",
"pos",
".",
"append",
"(",
"points",
")",
"spike_ids",
".",
"append",
"(",
"bunch",
".",
"spike_ids",
")",
"pos",
"=",
"np",
".",
"vstack",
"(",
"pos",
")",
"spike_ids",
"=",
"np",
".",
"concatenate",
"(",
"spike_ids",
")",
"# Find lassoed spikes.",
"ind",
"=",
"self",
".",
"lasso",
".",
"in_polygon",
"(",
"pos",
")",
"self",
".",
"lasso",
".",
"clear",
"(",
")",
"return",
"np",
".",
"unique",
"(",
"spike_ids",
"[",
"ind",
"]",
")"
] |
Return the spikes enclosed by the lasso.
|
[
"Return",
"the",
"spikes",
"enclosed",
"by",
"the",
"lasso",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/cluster/views/feature.py#L346-L387
|
train
|
kwikteam/phy
|
phy/plot/interact.py
|
Boxed.get_closest_box
|
def get_closest_box(self, pos):
"""Get the box closest to some position."""
pos = np.atleast_2d(pos)
d = np.sum((np.array(self.box_pos) - pos) ** 2, axis=1)
idx = np.argmin(d)
return idx
|
python
|
def get_closest_box(self, pos):
"""Get the box closest to some position."""
pos = np.atleast_2d(pos)
d = np.sum((np.array(self.box_pos) - pos) ** 2, axis=1)
idx = np.argmin(d)
return idx
|
[
"def",
"get_closest_box",
"(",
"self",
",",
"pos",
")",
":",
"pos",
"=",
"np",
".",
"atleast_2d",
"(",
"pos",
")",
"d",
"=",
"np",
".",
"sum",
"(",
"(",
"np",
".",
"array",
"(",
"self",
".",
"box_pos",
")",
"-",
"pos",
")",
"**",
"2",
",",
"axis",
"=",
"1",
")",
"idx",
"=",
"np",
".",
"argmin",
"(",
"d",
")",
"return",
"idx"
] |
Get the box closest to some position.
|
[
"Get",
"the",
"box",
"closest",
"to",
"some",
"position",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/plot/interact.py#L259-L264
|
train
|
kwikteam/phy
|
phy/plot/interact.py
|
Boxed.update_boxes
|
def update_boxes(self, box_pos, box_size):
"""Set the box bounds from specified box positions and sizes."""
assert box_pos.shape == (self.n_boxes, 2)
assert len(box_size) == 2
self.box_bounds = _get_boxes(box_pos,
size=box_size,
keep_aspect_ratio=self.keep_aspect_ratio,
)
|
python
|
def update_boxes(self, box_pos, box_size):
"""Set the box bounds from specified box positions and sizes."""
assert box_pos.shape == (self.n_boxes, 2)
assert len(box_size) == 2
self.box_bounds = _get_boxes(box_pos,
size=box_size,
keep_aspect_ratio=self.keep_aspect_ratio,
)
|
[
"def",
"update_boxes",
"(",
"self",
",",
"box_pos",
",",
"box_size",
")",
":",
"assert",
"box_pos",
".",
"shape",
"==",
"(",
"self",
".",
"n_boxes",
",",
"2",
")",
"assert",
"len",
"(",
"box_size",
")",
"==",
"2",
"self",
".",
"box_bounds",
"=",
"_get_boxes",
"(",
"box_pos",
",",
"size",
"=",
"box_size",
",",
"keep_aspect_ratio",
"=",
"self",
".",
"keep_aspect_ratio",
",",
")"
] |
Set the box bounds from specified box positions and sizes.
|
[
"Set",
"the",
"box",
"bounds",
"from",
"specified",
"box",
"positions",
"and",
"sizes",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/plot/interact.py#L266-L273
|
train
|
kwikteam/phy
|
phy/gui/qt.py
|
require_qt
|
def require_qt(func):
"""Specify that a function requires a Qt application.
Use this decorator to specify that a function needs a running
Qt application before it can run. An error is raised if that is not
the case.
"""
@wraps(func)
def wrapped(*args, **kwargs):
if not QApplication.instance(): # pragma: no cover
raise RuntimeError("A Qt application must be created.")
return func(*args, **kwargs)
return wrapped
|
python
|
def require_qt(func):
"""Specify that a function requires a Qt application.
Use this decorator to specify that a function needs a running
Qt application before it can run. An error is raised if that is not
the case.
"""
@wraps(func)
def wrapped(*args, **kwargs):
if not QApplication.instance(): # pragma: no cover
raise RuntimeError("A Qt application must be created.")
return func(*args, **kwargs)
return wrapped
|
[
"def",
"require_qt",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapped",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"QApplication",
".",
"instance",
"(",
")",
":",
"# pragma: no cover",
"raise",
"RuntimeError",
"(",
"\"A Qt application must be created.\"",
")",
"return",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"wrapped"
] |
Specify that a function requires a Qt application.
Use this decorator to specify that a function needs a running
Qt application before it can run. An error is raised if that is not
the case.
|
[
"Specify",
"that",
"a",
"function",
"requires",
"a",
"Qt",
"application",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/qt.py#L103-L116
|
train
|
kwikteam/phy
|
phy/gui/qt.py
|
create_app
|
def create_app():
"""Create a Qt application."""
global QT_APP
QT_APP = QApplication.instance()
if QT_APP is None: # pragma: no cover
QT_APP = QApplication(sys.argv)
return QT_APP
|
python
|
def create_app():
"""Create a Qt application."""
global QT_APP
QT_APP = QApplication.instance()
if QT_APP is None: # pragma: no cover
QT_APP = QApplication(sys.argv)
return QT_APP
|
[
"def",
"create_app",
"(",
")",
":",
"global",
"QT_APP",
"QT_APP",
"=",
"QApplication",
".",
"instance",
"(",
")",
"if",
"QT_APP",
"is",
"None",
":",
"# pragma: no cover",
"QT_APP",
"=",
"QApplication",
"(",
"sys",
".",
"argv",
")",
"return",
"QT_APP"
] |
Create a Qt application.
|
[
"Create",
"a",
"Qt",
"application",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/qt.py#L123-L129
|
train
|
kwikteam/phy
|
phy/gui/qt.py
|
AsyncCaller.set
|
def set(self, f):
"""Call a function after a delay, unless another function is set
in the meantime."""
self.stop()
self._create_timer(f)
self.start()
|
python
|
def set(self, f):
"""Call a function after a delay, unless another function is set
in the meantime."""
self.stop()
self._create_timer(f)
self.start()
|
[
"def",
"set",
"(",
"self",
",",
"f",
")",
":",
"self",
".",
"stop",
"(",
")",
"self",
".",
"_create_timer",
"(",
"f",
")",
"self",
".",
"start",
"(",
")"
] |
Call a function after a delay, unless another function is set
in the meantime.
|
[
"Call",
"a",
"function",
"after",
"a",
"delay",
"unless",
"another",
"function",
"is",
"set",
"in",
"the",
"meantime",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/qt.py#L150-L155
|
train
|
kwikteam/phy
|
phy/gui/qt.py
|
AsyncCaller.stop
|
def stop(self):
"""Stop the current timer if there is one and cancel the async call."""
if self._timer:
self._timer.stop()
self._timer.deleteLater()
|
python
|
def stop(self):
"""Stop the current timer if there is one and cancel the async call."""
if self._timer:
self._timer.stop()
self._timer.deleteLater()
|
[
"def",
"stop",
"(",
"self",
")",
":",
"if",
"self",
".",
"_timer",
":",
"self",
".",
"_timer",
".",
"stop",
"(",
")",
"self",
".",
"_timer",
".",
"deleteLater",
"(",
")"
] |
Stop the current timer if there is one and cancel the async call.
|
[
"Stop",
"the",
"current",
"timer",
"if",
"there",
"is",
"one",
"and",
"cancel",
"the",
"async",
"call",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/qt.py#L162-L166
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
_wrap_callback_args
|
def _wrap_callback_args(f, docstring=None): # pragma: no cover
"""Display a Qt dialog when a function has arguments.
The user can write function arguments as if it was a snippet.
"""
def wrapped(checked, *args):
if args:
return f(*args)
if isinstance(f, partial):
argspec = inspect.getargspec(f.func)
else:
argspec = inspect.getargspec(f)
f_args = argspec.args
if 'self' in f_args:
f_args.remove('self')
# Remove arguments with defaults from the list.
if len(argspec.defaults or ()):
f_args = f_args[:-len(argspec.defaults)]
# Remove arguments supplied in a partial.
if isinstance(f, partial):
f_args = f_args[len(f.args):]
f_args = [arg for arg in f_args if arg not in f.keywords]
# If there are no remaining args, we can just run the fu nction.
if not f_args:
return f()
# There are args, need to display the dialog.
# Extract Example: `...` in the docstring to put a predefined text
# in the input dialog.
r = re.search('Example: `([^`]+)`', docstring)
docstring_ = docstring[:r.start()].strip() if r else docstring
text = r.group(1) if r else None
s, ok = _input_dialog(getattr(f, '__name__', 'action'),
docstring_, text)
if not ok or not s:
return
# Parse user-supplied arguments and call the function.
args = _parse_snippet(s)
return f(*args)
return wrapped
|
python
|
def _wrap_callback_args(f, docstring=None): # pragma: no cover
"""Display a Qt dialog when a function has arguments.
The user can write function arguments as if it was a snippet.
"""
def wrapped(checked, *args):
if args:
return f(*args)
if isinstance(f, partial):
argspec = inspect.getargspec(f.func)
else:
argspec = inspect.getargspec(f)
f_args = argspec.args
if 'self' in f_args:
f_args.remove('self')
# Remove arguments with defaults from the list.
if len(argspec.defaults or ()):
f_args = f_args[:-len(argspec.defaults)]
# Remove arguments supplied in a partial.
if isinstance(f, partial):
f_args = f_args[len(f.args):]
f_args = [arg for arg in f_args if arg not in f.keywords]
# If there are no remaining args, we can just run the fu nction.
if not f_args:
return f()
# There are args, need to display the dialog.
# Extract Example: `...` in the docstring to put a predefined text
# in the input dialog.
r = re.search('Example: `([^`]+)`', docstring)
docstring_ = docstring[:r.start()].strip() if r else docstring
text = r.group(1) if r else None
s, ok = _input_dialog(getattr(f, '__name__', 'action'),
docstring_, text)
if not ok or not s:
return
# Parse user-supplied arguments and call the function.
args = _parse_snippet(s)
return f(*args)
return wrapped
|
[
"def",
"_wrap_callback_args",
"(",
"f",
",",
"docstring",
"=",
"None",
")",
":",
"# pragma: no cover",
"def",
"wrapped",
"(",
"checked",
",",
"*",
"args",
")",
":",
"if",
"args",
":",
"return",
"f",
"(",
"*",
"args",
")",
"if",
"isinstance",
"(",
"f",
",",
"partial",
")",
":",
"argspec",
"=",
"inspect",
".",
"getargspec",
"(",
"f",
".",
"func",
")",
"else",
":",
"argspec",
"=",
"inspect",
".",
"getargspec",
"(",
"f",
")",
"f_args",
"=",
"argspec",
".",
"args",
"if",
"'self'",
"in",
"f_args",
":",
"f_args",
".",
"remove",
"(",
"'self'",
")",
"# Remove arguments with defaults from the list.",
"if",
"len",
"(",
"argspec",
".",
"defaults",
"or",
"(",
")",
")",
":",
"f_args",
"=",
"f_args",
"[",
":",
"-",
"len",
"(",
"argspec",
".",
"defaults",
")",
"]",
"# Remove arguments supplied in a partial.",
"if",
"isinstance",
"(",
"f",
",",
"partial",
")",
":",
"f_args",
"=",
"f_args",
"[",
"len",
"(",
"f",
".",
"args",
")",
":",
"]",
"f_args",
"=",
"[",
"arg",
"for",
"arg",
"in",
"f_args",
"if",
"arg",
"not",
"in",
"f",
".",
"keywords",
"]",
"# If there are no remaining args, we can just run the fu nction.",
"if",
"not",
"f_args",
":",
"return",
"f",
"(",
")",
"# There are args, need to display the dialog.",
"# Extract Example: `...` in the docstring to put a predefined text",
"# in the input dialog.",
"r",
"=",
"re",
".",
"search",
"(",
"'Example: `([^`]+)`'",
",",
"docstring",
")",
"docstring_",
"=",
"docstring",
"[",
":",
"r",
".",
"start",
"(",
")",
"]",
".",
"strip",
"(",
")",
"if",
"r",
"else",
"docstring",
"text",
"=",
"r",
".",
"group",
"(",
"1",
")",
"if",
"r",
"else",
"None",
"s",
",",
"ok",
"=",
"_input_dialog",
"(",
"getattr",
"(",
"f",
",",
"'__name__'",
",",
"'action'",
")",
",",
"docstring_",
",",
"text",
")",
"if",
"not",
"ok",
"or",
"not",
"s",
":",
"return",
"# Parse user-supplied arguments and call the function.",
"args",
"=",
"_parse_snippet",
"(",
"s",
")",
"return",
"f",
"(",
"*",
"args",
")",
"return",
"wrapped"
] |
Display a Qt dialog when a function has arguments.
The user can write function arguments as if it was a snippet.
|
[
"Display",
"a",
"Qt",
"dialog",
"when",
"a",
"function",
"has",
"arguments",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L60-L99
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
_get_shortcut_string
|
def _get_shortcut_string(shortcut):
"""Return a string representation of a shortcut."""
if shortcut is None:
return ''
if isinstance(shortcut, (tuple, list)):
return ', '.join([_get_shortcut_string(s) for s in shortcut])
if isinstance(shortcut, string_types):
if hasattr(QKeySequence, shortcut):
shortcut = QKeySequence(getattr(QKeySequence, shortcut))
else:
return shortcut.lower()
assert isinstance(shortcut, QKeySequence)
s = shortcut.toString() or ''
return str(s).lower()
|
python
|
def _get_shortcut_string(shortcut):
"""Return a string representation of a shortcut."""
if shortcut is None:
return ''
if isinstance(shortcut, (tuple, list)):
return ', '.join([_get_shortcut_string(s) for s in shortcut])
if isinstance(shortcut, string_types):
if hasattr(QKeySequence, shortcut):
shortcut = QKeySequence(getattr(QKeySequence, shortcut))
else:
return shortcut.lower()
assert isinstance(shortcut, QKeySequence)
s = shortcut.toString() or ''
return str(s).lower()
|
[
"def",
"_get_shortcut_string",
"(",
"shortcut",
")",
":",
"if",
"shortcut",
"is",
"None",
":",
"return",
"''",
"if",
"isinstance",
"(",
"shortcut",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"return",
"', '",
".",
"join",
"(",
"[",
"_get_shortcut_string",
"(",
"s",
")",
"for",
"s",
"in",
"shortcut",
"]",
")",
"if",
"isinstance",
"(",
"shortcut",
",",
"string_types",
")",
":",
"if",
"hasattr",
"(",
"QKeySequence",
",",
"shortcut",
")",
":",
"shortcut",
"=",
"QKeySequence",
"(",
"getattr",
"(",
"QKeySequence",
",",
"shortcut",
")",
")",
"else",
":",
"return",
"shortcut",
".",
"lower",
"(",
")",
"assert",
"isinstance",
"(",
"shortcut",
",",
"QKeySequence",
")",
"s",
"=",
"shortcut",
".",
"toString",
"(",
")",
"or",
"''",
"return",
"str",
"(",
"s",
")",
".",
"lower",
"(",
")"
] |
Return a string representation of a shortcut.
|
[
"Return",
"a",
"string",
"representation",
"of",
"a",
"shortcut",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L106-L119
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
_get_qkeysequence
|
def _get_qkeysequence(shortcut):
"""Return a QKeySequence or list of QKeySequence from a shortcut string."""
if shortcut is None:
return []
if isinstance(shortcut, (tuple, list)):
return [_get_qkeysequence(s) for s in shortcut]
assert isinstance(shortcut, string_types)
if hasattr(QKeySequence, shortcut):
return QKeySequence(getattr(QKeySequence, shortcut))
sequence = QKeySequence.fromString(shortcut)
assert not sequence.isEmpty()
return sequence
|
python
|
def _get_qkeysequence(shortcut):
"""Return a QKeySequence or list of QKeySequence from a shortcut string."""
if shortcut is None:
return []
if isinstance(shortcut, (tuple, list)):
return [_get_qkeysequence(s) for s in shortcut]
assert isinstance(shortcut, string_types)
if hasattr(QKeySequence, shortcut):
return QKeySequence(getattr(QKeySequence, shortcut))
sequence = QKeySequence.fromString(shortcut)
assert not sequence.isEmpty()
return sequence
|
[
"def",
"_get_qkeysequence",
"(",
"shortcut",
")",
":",
"if",
"shortcut",
"is",
"None",
":",
"return",
"[",
"]",
"if",
"isinstance",
"(",
"shortcut",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"return",
"[",
"_get_qkeysequence",
"(",
"s",
")",
"for",
"s",
"in",
"shortcut",
"]",
"assert",
"isinstance",
"(",
"shortcut",
",",
"string_types",
")",
"if",
"hasattr",
"(",
"QKeySequence",
",",
"shortcut",
")",
":",
"return",
"QKeySequence",
"(",
"getattr",
"(",
"QKeySequence",
",",
"shortcut",
")",
")",
"sequence",
"=",
"QKeySequence",
".",
"fromString",
"(",
"shortcut",
")",
"assert",
"not",
"sequence",
".",
"isEmpty",
"(",
")",
"return",
"sequence"
] |
Return a QKeySequence or list of QKeySequence from a shortcut string.
|
[
"Return",
"a",
"QKeySequence",
"or",
"list",
"of",
"QKeySequence",
"from",
"a",
"shortcut",
"string",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L122-L133
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
_show_shortcuts
|
def _show_shortcuts(shortcuts, name=None):
"""Display shortcuts."""
name = name or ''
print('')
if name:
name = ' for ' + name
print('Keyboard shortcuts' + name)
for name in sorted(shortcuts):
shortcut = _get_shortcut_string(shortcuts[name])
if not name.startswith('_'):
print('- {0:<40}: {1:s}'.format(name, shortcut))
|
python
|
def _show_shortcuts(shortcuts, name=None):
"""Display shortcuts."""
name = name or ''
print('')
if name:
name = ' for ' + name
print('Keyboard shortcuts' + name)
for name in sorted(shortcuts):
shortcut = _get_shortcut_string(shortcuts[name])
if not name.startswith('_'):
print('- {0:<40}: {1:s}'.format(name, shortcut))
|
[
"def",
"_show_shortcuts",
"(",
"shortcuts",
",",
"name",
"=",
"None",
")",
":",
"name",
"=",
"name",
"or",
"''",
"print",
"(",
"''",
")",
"if",
"name",
":",
"name",
"=",
"' for '",
"+",
"name",
"print",
"(",
"'Keyboard shortcuts'",
"+",
"name",
")",
"for",
"name",
"in",
"sorted",
"(",
"shortcuts",
")",
":",
"shortcut",
"=",
"_get_shortcut_string",
"(",
"shortcuts",
"[",
"name",
"]",
")",
"if",
"not",
"name",
".",
"startswith",
"(",
"'_'",
")",
":",
"print",
"(",
"'- {0:<40}: {1:s}'",
".",
"format",
"(",
"name",
",",
"shortcut",
")",
")"
] |
Display shortcuts.
|
[
"Display",
"shortcuts",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L136-L146
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.add
|
def add(self, callback=None, name=None, shortcut=None, alias=None,
docstring=None, menu=None, verbose=True):
"""Add an action with a keyboard shortcut."""
if callback is None:
# Allow to use either add(func) or @add or @add(...).
return partial(self.add, name=name, shortcut=shortcut,
alias=alias, menu=menu)
assert callback
# Get the name from the callback function if needed.
name = name or callback.__name__
alias = alias or _alias(name)
name = name.replace('&', '')
shortcut = shortcut or self._default_shortcuts.get(name, None)
# Skip existing action.
if name in self._actions_dict:
return
# Set the status tip from the function's docstring.
docstring = docstring or callback.__doc__ or name
docstring = re.sub(r'[ \t\r\f\v]{2,}', ' ', docstring.strip())
# Create and register the action.
action = _create_qaction(self.gui, name, callback,
shortcut,
docstring=docstring,
alias=alias,
)
action_obj = Bunch(qaction=action, name=name, alias=alias,
shortcut=shortcut, callback=callback, menu=menu)
if verbose and not name.startswith('_'):
logger.log(5, "Add action `%s` (%s).", name,
_get_shortcut_string(action.shortcut()))
self.gui.addAction(action)
# Add the action to the menu.
menu = menu or self.menu
# Do not show private actions in the menu.
if menu and not name.startswith('_'):
self.gui.get_menu(menu).addAction(action)
self._actions_dict[name] = action_obj
# Register the alias -> name mapping.
self._aliases[alias] = name
# Set the callback method.
if callback:
setattr(self, name, callback)
|
python
|
def add(self, callback=None, name=None, shortcut=None, alias=None,
docstring=None, menu=None, verbose=True):
"""Add an action with a keyboard shortcut."""
if callback is None:
# Allow to use either add(func) or @add or @add(...).
return partial(self.add, name=name, shortcut=shortcut,
alias=alias, menu=menu)
assert callback
# Get the name from the callback function if needed.
name = name or callback.__name__
alias = alias or _alias(name)
name = name.replace('&', '')
shortcut = shortcut or self._default_shortcuts.get(name, None)
# Skip existing action.
if name in self._actions_dict:
return
# Set the status tip from the function's docstring.
docstring = docstring or callback.__doc__ or name
docstring = re.sub(r'[ \t\r\f\v]{2,}', ' ', docstring.strip())
# Create and register the action.
action = _create_qaction(self.gui, name, callback,
shortcut,
docstring=docstring,
alias=alias,
)
action_obj = Bunch(qaction=action, name=name, alias=alias,
shortcut=shortcut, callback=callback, menu=menu)
if verbose and not name.startswith('_'):
logger.log(5, "Add action `%s` (%s).", name,
_get_shortcut_string(action.shortcut()))
self.gui.addAction(action)
# Add the action to the menu.
menu = menu or self.menu
# Do not show private actions in the menu.
if menu and not name.startswith('_'):
self.gui.get_menu(menu).addAction(action)
self._actions_dict[name] = action_obj
# Register the alias -> name mapping.
self._aliases[alias] = name
# Set the callback method.
if callback:
setattr(self, name, callback)
|
[
"def",
"add",
"(",
"self",
",",
"callback",
"=",
"None",
",",
"name",
"=",
"None",
",",
"shortcut",
"=",
"None",
",",
"alias",
"=",
"None",
",",
"docstring",
"=",
"None",
",",
"menu",
"=",
"None",
",",
"verbose",
"=",
"True",
")",
":",
"if",
"callback",
"is",
"None",
":",
"# Allow to use either add(func) or @add or @add(...).",
"return",
"partial",
"(",
"self",
".",
"add",
",",
"name",
"=",
"name",
",",
"shortcut",
"=",
"shortcut",
",",
"alias",
"=",
"alias",
",",
"menu",
"=",
"menu",
")",
"assert",
"callback",
"# Get the name from the callback function if needed.",
"name",
"=",
"name",
"or",
"callback",
".",
"__name__",
"alias",
"=",
"alias",
"or",
"_alias",
"(",
"name",
")",
"name",
"=",
"name",
".",
"replace",
"(",
"'&'",
",",
"''",
")",
"shortcut",
"=",
"shortcut",
"or",
"self",
".",
"_default_shortcuts",
".",
"get",
"(",
"name",
",",
"None",
")",
"# Skip existing action.",
"if",
"name",
"in",
"self",
".",
"_actions_dict",
":",
"return",
"# Set the status tip from the function's docstring.",
"docstring",
"=",
"docstring",
"or",
"callback",
".",
"__doc__",
"or",
"name",
"docstring",
"=",
"re",
".",
"sub",
"(",
"r'[ \\t\\r\\f\\v]{2,}'",
",",
"' '",
",",
"docstring",
".",
"strip",
"(",
")",
")",
"# Create and register the action.",
"action",
"=",
"_create_qaction",
"(",
"self",
".",
"gui",
",",
"name",
",",
"callback",
",",
"shortcut",
",",
"docstring",
"=",
"docstring",
",",
"alias",
"=",
"alias",
",",
")",
"action_obj",
"=",
"Bunch",
"(",
"qaction",
"=",
"action",
",",
"name",
"=",
"name",
",",
"alias",
"=",
"alias",
",",
"shortcut",
"=",
"shortcut",
",",
"callback",
"=",
"callback",
",",
"menu",
"=",
"menu",
")",
"if",
"verbose",
"and",
"not",
"name",
".",
"startswith",
"(",
"'_'",
")",
":",
"logger",
".",
"log",
"(",
"5",
",",
"\"Add action `%s` (%s).\"",
",",
"name",
",",
"_get_shortcut_string",
"(",
"action",
".",
"shortcut",
"(",
")",
")",
")",
"self",
".",
"gui",
".",
"addAction",
"(",
"action",
")",
"# Add the action to the menu.",
"menu",
"=",
"menu",
"or",
"self",
".",
"menu",
"# Do not show private actions in the menu.",
"if",
"menu",
"and",
"not",
"name",
".",
"startswith",
"(",
"'_'",
")",
":",
"self",
".",
"gui",
".",
"get_menu",
"(",
"menu",
")",
".",
"addAction",
"(",
"action",
")",
"self",
".",
"_actions_dict",
"[",
"name",
"]",
"=",
"action_obj",
"# Register the alias -> name mapping.",
"self",
".",
"_aliases",
"[",
"alias",
"]",
"=",
"name",
"# Set the callback method.",
"if",
"callback",
":",
"setattr",
"(",
"self",
",",
"name",
",",
"callback",
")"
] |
Add an action with a keyboard shortcut.
|
[
"Add",
"an",
"action",
"with",
"a",
"keyboard",
"shortcut",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L200-L246
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.separator
|
def separator(self, menu=None):
"""Add a separator"""
self.gui.get_menu(menu or self.menu).addSeparator()
|
python
|
def separator(self, menu=None):
"""Add a separator"""
self.gui.get_menu(menu or self.menu).addSeparator()
|
[
"def",
"separator",
"(",
"self",
",",
"menu",
"=",
"None",
")",
":",
"self",
".",
"gui",
".",
"get_menu",
"(",
"menu",
"or",
"self",
".",
"menu",
")",
".",
"addSeparator",
"(",
")"
] |
Add a separator
|
[
"Add",
"a",
"separator"
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L248-L250
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.disable
|
def disable(self, name=None):
"""Disable one or all actions."""
if name is None:
for name in self._actions_dict:
self.disable(name)
return
self._actions_dict[name].qaction.setEnabled(False)
|
python
|
def disable(self, name=None):
"""Disable one or all actions."""
if name is None:
for name in self._actions_dict:
self.disable(name)
return
self._actions_dict[name].qaction.setEnabled(False)
|
[
"def",
"disable",
"(",
"self",
",",
"name",
"=",
"None",
")",
":",
"if",
"name",
"is",
"None",
":",
"for",
"name",
"in",
"self",
".",
"_actions_dict",
":",
"self",
".",
"disable",
"(",
"name",
")",
"return",
"self",
".",
"_actions_dict",
"[",
"name",
"]",
".",
"qaction",
".",
"setEnabled",
"(",
"False",
")"
] |
Disable one or all actions.
|
[
"Disable",
"one",
"or",
"all",
"actions",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L252-L258
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.enable
|
def enable(self, name=None):
"""Enable one or all actions."""
if name is None:
for name in self._actions_dict:
self.enable(name)
return
self._actions_dict[name].qaction.setEnabled(True)
|
python
|
def enable(self, name=None):
"""Enable one or all actions."""
if name is None:
for name in self._actions_dict:
self.enable(name)
return
self._actions_dict[name].qaction.setEnabled(True)
|
[
"def",
"enable",
"(",
"self",
",",
"name",
"=",
"None",
")",
":",
"if",
"name",
"is",
"None",
":",
"for",
"name",
"in",
"self",
".",
"_actions_dict",
":",
"self",
".",
"enable",
"(",
"name",
")",
"return",
"self",
".",
"_actions_dict",
"[",
"name",
"]",
".",
"qaction",
".",
"setEnabled",
"(",
"True",
")"
] |
Enable one or all actions.
|
[
"Enable",
"one",
"or",
"all",
"actions",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L260-L266
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.run
|
def run(self, name, *args):
"""Run an action as specified by its name."""
assert isinstance(name, string_types)
# Resolve the alias if it is an alias.
name = self._aliases.get(name, name)
# Get the action.
action = self._actions_dict.get(name, None)
if not action:
raise ValueError("Action `{}` doesn't exist.".format(name))
if not name.startswith('_'):
logger.debug("Execute action `%s`.", name)
return action.callback(*args)
|
python
|
def run(self, name, *args):
"""Run an action as specified by its name."""
assert isinstance(name, string_types)
# Resolve the alias if it is an alias.
name = self._aliases.get(name, name)
# Get the action.
action = self._actions_dict.get(name, None)
if not action:
raise ValueError("Action `{}` doesn't exist.".format(name))
if not name.startswith('_'):
logger.debug("Execute action `%s`.", name)
return action.callback(*args)
|
[
"def",
"run",
"(",
"self",
",",
"name",
",",
"*",
"args",
")",
":",
"assert",
"isinstance",
"(",
"name",
",",
"string_types",
")",
"# Resolve the alias if it is an alias.",
"name",
"=",
"self",
".",
"_aliases",
".",
"get",
"(",
"name",
",",
"name",
")",
"# Get the action.",
"action",
"=",
"self",
".",
"_actions_dict",
".",
"get",
"(",
"name",
",",
"None",
")",
"if",
"not",
"action",
":",
"raise",
"ValueError",
"(",
"\"Action `{}` doesn't exist.\"",
".",
"format",
"(",
"name",
")",
")",
"if",
"not",
"name",
".",
"startswith",
"(",
"'_'",
")",
":",
"logger",
".",
"debug",
"(",
"\"Execute action `%s`.\"",
",",
"name",
")",
"return",
"action",
".",
"callback",
"(",
"*",
"args",
")"
] |
Run an action as specified by its name.
|
[
"Run",
"an",
"action",
"as",
"specified",
"by",
"its",
"name",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L272-L283
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.remove
|
def remove(self, name):
"""Remove an action."""
self.gui.removeAction(self._actions_dict[name].qaction)
del self._actions_dict[name]
delattr(self, name)
|
python
|
def remove(self, name):
"""Remove an action."""
self.gui.removeAction(self._actions_dict[name].qaction)
del self._actions_dict[name]
delattr(self, name)
|
[
"def",
"remove",
"(",
"self",
",",
"name",
")",
":",
"self",
".",
"gui",
".",
"removeAction",
"(",
"self",
".",
"_actions_dict",
"[",
"name",
"]",
".",
"qaction",
")",
"del",
"self",
".",
"_actions_dict",
"[",
"name",
"]",
"delattr",
"(",
"self",
",",
"name",
")"
] |
Remove an action.
|
[
"Remove",
"an",
"action",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L285-L289
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.remove_all
|
def remove_all(self):
"""Remove all actions."""
names = sorted(self._actions_dict.keys())
for name in names:
self.remove(name)
|
python
|
def remove_all(self):
"""Remove all actions."""
names = sorted(self._actions_dict.keys())
for name in names:
self.remove(name)
|
[
"def",
"remove_all",
"(",
"self",
")",
":",
"names",
"=",
"sorted",
"(",
"self",
".",
"_actions_dict",
".",
"keys",
"(",
")",
")",
"for",
"name",
"in",
"names",
":",
"self",
".",
"remove",
"(",
"name",
")"
] |
Remove all actions.
|
[
"Remove",
"all",
"actions",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L291-L295
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.shortcuts
|
def shortcuts(self):
"""A dictionary of action shortcuts."""
return {name: action.shortcut
for name, action in self._actions_dict.items()}
|
python
|
def shortcuts(self):
"""A dictionary of action shortcuts."""
return {name: action.shortcut
for name, action in self._actions_dict.items()}
|
[
"def",
"shortcuts",
"(",
"self",
")",
":",
"return",
"{",
"name",
":",
"action",
".",
"shortcut",
"for",
"name",
",",
"action",
"in",
"self",
".",
"_actions_dict",
".",
"items",
"(",
")",
"}"
] |
A dictionary of action shortcuts.
|
[
"A",
"dictionary",
"of",
"action",
"shortcuts",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L298-L301
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Actions.show_shortcuts
|
def show_shortcuts(self):
"""Print all shortcuts."""
gui_name = self.gui.name
actions_name = self.name
name = ('{} - {}'.format(gui_name, actions_name)
if actions_name else gui_name)
_show_shortcuts(self.shortcuts, name)
|
python
|
def show_shortcuts(self):
"""Print all shortcuts."""
gui_name = self.gui.name
actions_name = self.name
name = ('{} - {}'.format(gui_name, actions_name)
if actions_name else gui_name)
_show_shortcuts(self.shortcuts, name)
|
[
"def",
"show_shortcuts",
"(",
"self",
")",
":",
"gui_name",
"=",
"self",
".",
"gui",
".",
"name",
"actions_name",
"=",
"self",
".",
"name",
"name",
"=",
"(",
"'{} - {}'",
".",
"format",
"(",
"gui_name",
",",
"actions_name",
")",
"if",
"actions_name",
"else",
"gui_name",
")",
"_show_shortcuts",
"(",
"self",
".",
"shortcuts",
",",
"name",
")"
] |
Print all shortcuts.
|
[
"Print",
"all",
"shortcuts",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L303-L309
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Snippets.command
|
def command(self):
"""This is used to write a snippet message in the status bar.
A cursor is appended at the end.
"""
msg = self.gui.status_message
n = len(msg)
n_cur = len(self.cursor)
return msg[:n - n_cur]
|
python
|
def command(self):
"""This is used to write a snippet message in the status bar.
A cursor is appended at the end.
"""
msg = self.gui.status_message
n = len(msg)
n_cur = len(self.cursor)
return msg[:n - n_cur]
|
[
"def",
"command",
"(",
"self",
")",
":",
"msg",
"=",
"self",
".",
"gui",
".",
"status_message",
"n",
"=",
"len",
"(",
"msg",
")",
"n_cur",
"=",
"len",
"(",
"self",
".",
"cursor",
")",
"return",
"msg",
"[",
":",
"n",
"-",
"n_cur",
"]"
] |
This is used to write a snippet message in the status bar.
A cursor is appended at the end.
|
[
"This",
"is",
"used",
"to",
"write",
"a",
"snippet",
"message",
"in",
"the",
"status",
"bar",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L372-L381
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Snippets._backspace
|
def _backspace(self):
"""Erase the last character in the snippet command."""
if self.command == ':':
return
logger.log(5, "Snippet keystroke `Backspace`.")
self.command = self.command[:-1]
|
python
|
def _backspace(self):
"""Erase the last character in the snippet command."""
if self.command == ':':
return
logger.log(5, "Snippet keystroke `Backspace`.")
self.command = self.command[:-1]
|
[
"def",
"_backspace",
"(",
"self",
")",
":",
"if",
"self",
".",
"command",
"==",
"':'",
":",
"return",
"logger",
".",
"log",
"(",
"5",
",",
"\"Snippet keystroke `Backspace`.\"",
")",
"self",
".",
"command",
"=",
"self",
".",
"command",
"[",
":",
"-",
"1",
"]"
] |
Erase the last character in the snippet command.
|
[
"Erase",
"the",
"last",
"character",
"in",
"the",
"snippet",
"command",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L390-L395
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Snippets._enter
|
def _enter(self):
"""Disable the snippet mode and execute the command."""
command = self.command
logger.log(5, "Snippet keystroke `Enter`.")
# NOTE: we need to set back the actions (mode_off) before running
# the command.
self.mode_off()
self.run(command)
|
python
|
def _enter(self):
"""Disable the snippet mode and execute the command."""
command = self.command
logger.log(5, "Snippet keystroke `Enter`.")
# NOTE: we need to set back the actions (mode_off) before running
# the command.
self.mode_off()
self.run(command)
|
[
"def",
"_enter",
"(",
"self",
")",
":",
"command",
"=",
"self",
".",
"command",
"logger",
".",
"log",
"(",
"5",
",",
"\"Snippet keystroke `Enter`.\"",
")",
"# NOTE: we need to set back the actions (mode_off) before running",
"# the command.",
"self",
".",
"mode_off",
"(",
")",
"self",
".",
"run",
"(",
"command",
")"
] |
Disable the snippet mode and execute the command.
|
[
"Disable",
"the",
"snippet",
"mode",
"and",
"execute",
"the",
"command",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L397-L404
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Snippets._create_snippet_actions
|
def _create_snippet_actions(self):
"""Add mock Qt actions for snippet keystrokes.
Used to enable snippet mode.
"""
# One action per allowed character.
for i, char in enumerate(self._snippet_chars):
def _make_func(char):
def callback():
logger.log(5, "Snippet keystroke `%s`.", char)
self.command += char
return callback
self.actions.add(name='_snippet_{}'.format(i),
shortcut=char,
callback=_make_func(char))
self.actions.add(name='_snippet_backspace',
shortcut='backspace',
callback=self._backspace)
self.actions.add(name='_snippet_activate',
shortcut=('enter', 'return'),
callback=self._enter)
self.actions.add(name='_snippet_disable',
shortcut='escape',
callback=self.mode_off)
|
python
|
def _create_snippet_actions(self):
"""Add mock Qt actions for snippet keystrokes.
Used to enable snippet mode.
"""
# One action per allowed character.
for i, char in enumerate(self._snippet_chars):
def _make_func(char):
def callback():
logger.log(5, "Snippet keystroke `%s`.", char)
self.command += char
return callback
self.actions.add(name='_snippet_{}'.format(i),
shortcut=char,
callback=_make_func(char))
self.actions.add(name='_snippet_backspace',
shortcut='backspace',
callback=self._backspace)
self.actions.add(name='_snippet_activate',
shortcut=('enter', 'return'),
callback=self._enter)
self.actions.add(name='_snippet_disable',
shortcut='escape',
callback=self.mode_off)
|
[
"def",
"_create_snippet_actions",
"(",
"self",
")",
":",
"# One action per allowed character.",
"for",
"i",
",",
"char",
"in",
"enumerate",
"(",
"self",
".",
"_snippet_chars",
")",
":",
"def",
"_make_func",
"(",
"char",
")",
":",
"def",
"callback",
"(",
")",
":",
"logger",
".",
"log",
"(",
"5",
",",
"\"Snippet keystroke `%s`.\"",
",",
"char",
")",
"self",
".",
"command",
"+=",
"char",
"return",
"callback",
"self",
".",
"actions",
".",
"add",
"(",
"name",
"=",
"'_snippet_{}'",
".",
"format",
"(",
"i",
")",
",",
"shortcut",
"=",
"char",
",",
"callback",
"=",
"_make_func",
"(",
"char",
")",
")",
"self",
".",
"actions",
".",
"add",
"(",
"name",
"=",
"'_snippet_backspace'",
",",
"shortcut",
"=",
"'backspace'",
",",
"callback",
"=",
"self",
".",
"_backspace",
")",
"self",
".",
"actions",
".",
"add",
"(",
"name",
"=",
"'_snippet_activate'",
",",
"shortcut",
"=",
"(",
"'enter'",
",",
"'return'",
")",
",",
"callback",
"=",
"self",
".",
"_enter",
")",
"self",
".",
"actions",
".",
"add",
"(",
"name",
"=",
"'_snippet_disable'",
",",
"shortcut",
"=",
"'escape'",
",",
"callback",
"=",
"self",
".",
"mode_off",
")"
] |
Add mock Qt actions for snippet keystrokes.
Used to enable snippet mode.
|
[
"Add",
"mock",
"Qt",
"actions",
"for",
"snippet",
"keystrokes",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L406-L433
|
train
|
kwikteam/phy
|
phy/gui/actions.py
|
Snippets.run
|
def run(self, snippet):
"""Executes a snippet command.
May be overridden.
"""
assert snippet[0] == ':'
snippet = snippet[1:]
snippet_args = _parse_snippet(snippet)
name = snippet_args[0]
logger.info("Processing snippet `%s`.", snippet)
try:
# Try to run the snippet on all attached Actions instances.
for actions in self.gui.actions:
try:
actions.run(name, *snippet_args[1:])
return
except ValueError:
# This Actions instance doesn't contain the requested
# snippet, trying the next attached Actions instance.
pass
logger.warn("Couldn't find action `%s`.", name)
except Exception as e:
logger.warn("Error when executing snippet: \"%s\".", str(e))
logger.debug(''.join(traceback.format_exception(*sys.exc_info())))
|
python
|
def run(self, snippet):
"""Executes a snippet command.
May be overridden.
"""
assert snippet[0] == ':'
snippet = snippet[1:]
snippet_args = _parse_snippet(snippet)
name = snippet_args[0]
logger.info("Processing snippet `%s`.", snippet)
try:
# Try to run the snippet on all attached Actions instances.
for actions in self.gui.actions:
try:
actions.run(name, *snippet_args[1:])
return
except ValueError:
# This Actions instance doesn't contain the requested
# snippet, trying the next attached Actions instance.
pass
logger.warn("Couldn't find action `%s`.", name)
except Exception as e:
logger.warn("Error when executing snippet: \"%s\".", str(e))
logger.debug(''.join(traceback.format_exception(*sys.exc_info())))
|
[
"def",
"run",
"(",
"self",
",",
"snippet",
")",
":",
"assert",
"snippet",
"[",
"0",
"]",
"==",
"':'",
"snippet",
"=",
"snippet",
"[",
"1",
":",
"]",
"snippet_args",
"=",
"_parse_snippet",
"(",
"snippet",
")",
"name",
"=",
"snippet_args",
"[",
"0",
"]",
"logger",
".",
"info",
"(",
"\"Processing snippet `%s`.\"",
",",
"snippet",
")",
"try",
":",
"# Try to run the snippet on all attached Actions instances.",
"for",
"actions",
"in",
"self",
".",
"gui",
".",
"actions",
":",
"try",
":",
"actions",
".",
"run",
"(",
"name",
",",
"*",
"snippet_args",
"[",
"1",
":",
"]",
")",
"return",
"except",
"ValueError",
":",
"# This Actions instance doesn't contain the requested",
"# snippet, trying the next attached Actions instance.",
"pass",
"logger",
".",
"warn",
"(",
"\"Couldn't find action `%s`.\"",
",",
"name",
")",
"except",
"Exception",
"as",
"e",
":",
"logger",
".",
"warn",
"(",
"\"Error when executing snippet: \\\"%s\\\".\"",
",",
"str",
"(",
"e",
")",
")",
"logger",
".",
"debug",
"(",
"''",
".",
"join",
"(",
"traceback",
".",
"format_exception",
"(",
"*",
"sys",
".",
"exc_info",
"(",
")",
")",
")",
")"
] |
Executes a snippet command.
May be overridden.
|
[
"Executes",
"a",
"snippet",
"command",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/gui/actions.py#L435-L460
|
train
|
kwikteam/phy
|
phy/traces/waveform.py
|
_before_after
|
def _before_after(n_samples):
"""Get the number of samples before and after."""
if not isinstance(n_samples, (tuple, list)):
before = n_samples // 2
after = n_samples - before
else:
assert len(n_samples) == 2
before, after = n_samples
n_samples = before + after
assert before >= 0
assert after >= 0
assert before + after == n_samples
return before, after
|
python
|
def _before_after(n_samples):
"""Get the number of samples before and after."""
if not isinstance(n_samples, (tuple, list)):
before = n_samples // 2
after = n_samples - before
else:
assert len(n_samples) == 2
before, after = n_samples
n_samples = before + after
assert before >= 0
assert after >= 0
assert before + after == n_samples
return before, after
|
[
"def",
"_before_after",
"(",
"n_samples",
")",
":",
"if",
"not",
"isinstance",
"(",
"n_samples",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"before",
"=",
"n_samples",
"//",
"2",
"after",
"=",
"n_samples",
"-",
"before",
"else",
":",
"assert",
"len",
"(",
"n_samples",
")",
"==",
"2",
"before",
",",
"after",
"=",
"n_samples",
"n_samples",
"=",
"before",
"+",
"after",
"assert",
"before",
">=",
"0",
"assert",
"after",
">=",
"0",
"assert",
"before",
"+",
"after",
"==",
"n_samples",
"return",
"before",
",",
"after"
] |
Get the number of samples before and after.
|
[
"Get",
"the",
"number",
"of",
"samples",
"before",
"and",
"after",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/traces/waveform.py#L149-L161
|
train
|
kwikteam/phy
|
phy/traces/waveform.py
|
_slice
|
def _slice(index, n_samples, margin=None):
"""Return a waveform slice."""
if margin is None:
margin = (0, 0)
assert isinstance(n_samples, (tuple, list))
assert len(n_samples) == 2
before, after = n_samples
assert isinstance(margin, (tuple, list))
assert len(margin) == 2
margin_before, margin_after = margin
before += margin_before
after += margin_after
index = int(index)
before = int(before)
after = int(after)
return slice(max(0, index - before), index + after, None)
|
python
|
def _slice(index, n_samples, margin=None):
"""Return a waveform slice."""
if margin is None:
margin = (0, 0)
assert isinstance(n_samples, (tuple, list))
assert len(n_samples) == 2
before, after = n_samples
assert isinstance(margin, (tuple, list))
assert len(margin) == 2
margin_before, margin_after = margin
before += margin_before
after += margin_after
index = int(index)
before = int(before)
after = int(after)
return slice(max(0, index - before), index + after, None)
|
[
"def",
"_slice",
"(",
"index",
",",
"n_samples",
",",
"margin",
"=",
"None",
")",
":",
"if",
"margin",
"is",
"None",
":",
"margin",
"=",
"(",
"0",
",",
"0",
")",
"assert",
"isinstance",
"(",
"n_samples",
",",
"(",
"tuple",
",",
"list",
")",
")",
"assert",
"len",
"(",
"n_samples",
")",
"==",
"2",
"before",
",",
"after",
"=",
"n_samples",
"assert",
"isinstance",
"(",
"margin",
",",
"(",
"tuple",
",",
"list",
")",
")",
"assert",
"len",
"(",
"margin",
")",
"==",
"2",
"margin_before",
",",
"margin_after",
"=",
"margin",
"before",
"+=",
"margin_before",
"after",
"+=",
"margin_after",
"index",
"=",
"int",
"(",
"index",
")",
"before",
"=",
"int",
"(",
"before",
")",
"after",
"=",
"int",
"(",
"after",
")",
"return",
"slice",
"(",
"max",
"(",
"0",
",",
"index",
"-",
"before",
")",
",",
"index",
"+",
"after",
",",
"None",
")"
] |
Return a waveform slice.
|
[
"Return",
"a",
"waveform",
"slice",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/traces/waveform.py#L164-L179
|
train
|
kwikteam/phy
|
phy/traces/waveform.py
|
WaveformLoader._load_at
|
def _load_at(self, time, channels=None):
"""Load a waveform at a given time."""
if channels is None:
channels = slice(None, None, None)
time = int(time)
time_o = time
ns = self.n_samples_trace
if not (0 <= time_o < ns):
raise ValueError("Invalid time {0:d}/{1:d}.".format(time_o, ns))
slice_extract = _slice(time_o,
self.n_samples_before_after,
self._filter_margin)
extract = self._traces[slice_extract][:, channels].astype(np.float32)
# Pad the extracted chunk if needed.
if slice_extract.start <= 0:
extract = _pad(extract, self._n_samples_extract, 'left')
elif slice_extract.stop >= ns - 1:
extract = _pad(extract, self._n_samples_extract, 'right')
assert extract.shape[0] == self._n_samples_extract
return extract
|
python
|
def _load_at(self, time, channels=None):
"""Load a waveform at a given time."""
if channels is None:
channels = slice(None, None, None)
time = int(time)
time_o = time
ns = self.n_samples_trace
if not (0 <= time_o < ns):
raise ValueError("Invalid time {0:d}/{1:d}.".format(time_o, ns))
slice_extract = _slice(time_o,
self.n_samples_before_after,
self._filter_margin)
extract = self._traces[slice_extract][:, channels].astype(np.float32)
# Pad the extracted chunk if needed.
if slice_extract.start <= 0:
extract = _pad(extract, self._n_samples_extract, 'left')
elif slice_extract.stop >= ns - 1:
extract = _pad(extract, self._n_samples_extract, 'right')
assert extract.shape[0] == self._n_samples_extract
return extract
|
[
"def",
"_load_at",
"(",
"self",
",",
"time",
",",
"channels",
"=",
"None",
")",
":",
"if",
"channels",
"is",
"None",
":",
"channels",
"=",
"slice",
"(",
"None",
",",
"None",
",",
"None",
")",
"time",
"=",
"int",
"(",
"time",
")",
"time_o",
"=",
"time",
"ns",
"=",
"self",
".",
"n_samples_trace",
"if",
"not",
"(",
"0",
"<=",
"time_o",
"<",
"ns",
")",
":",
"raise",
"ValueError",
"(",
"\"Invalid time {0:d}/{1:d}.\"",
".",
"format",
"(",
"time_o",
",",
"ns",
")",
")",
"slice_extract",
"=",
"_slice",
"(",
"time_o",
",",
"self",
".",
"n_samples_before_after",
",",
"self",
".",
"_filter_margin",
")",
"extract",
"=",
"self",
".",
"_traces",
"[",
"slice_extract",
"]",
"[",
":",
",",
"channels",
"]",
".",
"astype",
"(",
"np",
".",
"float32",
")",
"# Pad the extracted chunk if needed.",
"if",
"slice_extract",
".",
"start",
"<=",
"0",
":",
"extract",
"=",
"_pad",
"(",
"extract",
",",
"self",
".",
"_n_samples_extract",
",",
"'left'",
")",
"elif",
"slice_extract",
".",
"stop",
">=",
"ns",
"-",
"1",
":",
"extract",
"=",
"_pad",
"(",
"extract",
",",
"self",
".",
"_n_samples_extract",
",",
"'right'",
")",
"assert",
"extract",
".",
"shape",
"[",
"0",
"]",
"==",
"self",
".",
"_n_samples_extract",
"return",
"extract"
] |
Load a waveform at a given time.
|
[
"Load",
"a",
"waveform",
"at",
"a",
"given",
"time",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/traces/waveform.py#L248-L269
|
train
|
kwikteam/phy
|
phy/traces/waveform.py
|
WaveformLoader.get
|
def get(self, spike_ids, channels=None):
"""Load the waveforms of the specified spikes."""
if isinstance(spike_ids, slice):
spike_ids = _range_from_slice(spike_ids,
start=0,
stop=self.n_spikes,
)
if not hasattr(spike_ids, '__len__'):
spike_ids = [spike_ids]
if channels is None:
channels = slice(None, None, None)
nc = self.n_channels
else:
channels = np.asarray(channels, dtype=np.int32)
assert np.all(channels < self.n_channels)
nc = len(channels)
# Ensure a list of time samples are being requested.
spike_ids = _as_array(spike_ids)
n_spikes = len(spike_ids)
# Initialize the array.
# NOTE: last dimension is time to simplify things.
shape = (n_spikes, nc, self._n_samples_extract)
waveforms = np.zeros(shape, dtype=np.float32)
# No traces: return null arrays.
if self.n_samples_trace == 0:
return np.transpose(waveforms, (0, 2, 1))
# Load all spikes.
for i, spike_id in enumerate(spike_ids):
assert 0 <= spike_id < self.n_spikes
time = self._spike_samples[spike_id]
# Extract the waveforms on the unmasked channels.
try:
w = self._load_at(time, channels)
except ValueError as e: # pragma: no cover
logger.warn("Error while loading waveform: %s", str(e))
continue
assert w.shape == (self._n_samples_extract, nc)
waveforms[i, :, :] = w.T
# Filter the waveforms.
waveforms_f = waveforms.reshape((-1, self._n_samples_extract))
# Only filter the non-zero waveforms.
unmasked = waveforms_f.max(axis=1) != 0
waveforms_f[unmasked] = self._filter(waveforms_f[unmasked], axis=1)
waveforms_f = waveforms_f.reshape((n_spikes, nc,
self._n_samples_extract))
# Remove the margin.
margin_before, margin_after = self._filter_margin
if margin_after > 0:
assert margin_before >= 0
waveforms_f = waveforms_f[:, :, margin_before:-margin_after]
assert waveforms_f.shape == (n_spikes,
nc,
self.n_samples_waveforms,
)
# NOTE: we transpose before returning the array.
return np.transpose(waveforms_f, (0, 2, 1))
|
python
|
def get(self, spike_ids, channels=None):
"""Load the waveforms of the specified spikes."""
if isinstance(spike_ids, slice):
spike_ids = _range_from_slice(spike_ids,
start=0,
stop=self.n_spikes,
)
if not hasattr(spike_ids, '__len__'):
spike_ids = [spike_ids]
if channels is None:
channels = slice(None, None, None)
nc = self.n_channels
else:
channels = np.asarray(channels, dtype=np.int32)
assert np.all(channels < self.n_channels)
nc = len(channels)
# Ensure a list of time samples are being requested.
spike_ids = _as_array(spike_ids)
n_spikes = len(spike_ids)
# Initialize the array.
# NOTE: last dimension is time to simplify things.
shape = (n_spikes, nc, self._n_samples_extract)
waveforms = np.zeros(shape, dtype=np.float32)
# No traces: return null arrays.
if self.n_samples_trace == 0:
return np.transpose(waveforms, (0, 2, 1))
# Load all spikes.
for i, spike_id in enumerate(spike_ids):
assert 0 <= spike_id < self.n_spikes
time = self._spike_samples[spike_id]
# Extract the waveforms on the unmasked channels.
try:
w = self._load_at(time, channels)
except ValueError as e: # pragma: no cover
logger.warn("Error while loading waveform: %s", str(e))
continue
assert w.shape == (self._n_samples_extract, nc)
waveforms[i, :, :] = w.T
# Filter the waveforms.
waveforms_f = waveforms.reshape((-1, self._n_samples_extract))
# Only filter the non-zero waveforms.
unmasked = waveforms_f.max(axis=1) != 0
waveforms_f[unmasked] = self._filter(waveforms_f[unmasked], axis=1)
waveforms_f = waveforms_f.reshape((n_spikes, nc,
self._n_samples_extract))
# Remove the margin.
margin_before, margin_after = self._filter_margin
if margin_after > 0:
assert margin_before >= 0
waveforms_f = waveforms_f[:, :, margin_before:-margin_after]
assert waveforms_f.shape == (n_spikes,
nc,
self.n_samples_waveforms,
)
# NOTE: we transpose before returning the array.
return np.transpose(waveforms_f, (0, 2, 1))
|
[
"def",
"get",
"(",
"self",
",",
"spike_ids",
",",
"channels",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"spike_ids",
",",
"slice",
")",
":",
"spike_ids",
"=",
"_range_from_slice",
"(",
"spike_ids",
",",
"start",
"=",
"0",
",",
"stop",
"=",
"self",
".",
"n_spikes",
",",
")",
"if",
"not",
"hasattr",
"(",
"spike_ids",
",",
"'__len__'",
")",
":",
"spike_ids",
"=",
"[",
"spike_ids",
"]",
"if",
"channels",
"is",
"None",
":",
"channels",
"=",
"slice",
"(",
"None",
",",
"None",
",",
"None",
")",
"nc",
"=",
"self",
".",
"n_channels",
"else",
":",
"channels",
"=",
"np",
".",
"asarray",
"(",
"channels",
",",
"dtype",
"=",
"np",
".",
"int32",
")",
"assert",
"np",
".",
"all",
"(",
"channels",
"<",
"self",
".",
"n_channels",
")",
"nc",
"=",
"len",
"(",
"channels",
")",
"# Ensure a list of time samples are being requested.",
"spike_ids",
"=",
"_as_array",
"(",
"spike_ids",
")",
"n_spikes",
"=",
"len",
"(",
"spike_ids",
")",
"# Initialize the array.",
"# NOTE: last dimension is time to simplify things.",
"shape",
"=",
"(",
"n_spikes",
",",
"nc",
",",
"self",
".",
"_n_samples_extract",
")",
"waveforms",
"=",
"np",
".",
"zeros",
"(",
"shape",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
"# No traces: return null arrays.",
"if",
"self",
".",
"n_samples_trace",
"==",
"0",
":",
"return",
"np",
".",
"transpose",
"(",
"waveforms",
",",
"(",
"0",
",",
"2",
",",
"1",
")",
")",
"# Load all spikes.",
"for",
"i",
",",
"spike_id",
"in",
"enumerate",
"(",
"spike_ids",
")",
":",
"assert",
"0",
"<=",
"spike_id",
"<",
"self",
".",
"n_spikes",
"time",
"=",
"self",
".",
"_spike_samples",
"[",
"spike_id",
"]",
"# Extract the waveforms on the unmasked channels.",
"try",
":",
"w",
"=",
"self",
".",
"_load_at",
"(",
"time",
",",
"channels",
")",
"except",
"ValueError",
"as",
"e",
":",
"# pragma: no cover",
"logger",
".",
"warn",
"(",
"\"Error while loading waveform: %s\"",
",",
"str",
"(",
"e",
")",
")",
"continue",
"assert",
"w",
".",
"shape",
"==",
"(",
"self",
".",
"_n_samples_extract",
",",
"nc",
")",
"waveforms",
"[",
"i",
",",
":",
",",
":",
"]",
"=",
"w",
".",
"T",
"# Filter the waveforms.",
"waveforms_f",
"=",
"waveforms",
".",
"reshape",
"(",
"(",
"-",
"1",
",",
"self",
".",
"_n_samples_extract",
")",
")",
"# Only filter the non-zero waveforms.",
"unmasked",
"=",
"waveforms_f",
".",
"max",
"(",
"axis",
"=",
"1",
")",
"!=",
"0",
"waveforms_f",
"[",
"unmasked",
"]",
"=",
"self",
".",
"_filter",
"(",
"waveforms_f",
"[",
"unmasked",
"]",
",",
"axis",
"=",
"1",
")",
"waveforms_f",
"=",
"waveforms_f",
".",
"reshape",
"(",
"(",
"n_spikes",
",",
"nc",
",",
"self",
".",
"_n_samples_extract",
")",
")",
"# Remove the margin.",
"margin_before",
",",
"margin_after",
"=",
"self",
".",
"_filter_margin",
"if",
"margin_after",
">",
"0",
":",
"assert",
"margin_before",
">=",
"0",
"waveforms_f",
"=",
"waveforms_f",
"[",
":",
",",
":",
",",
"margin_before",
":",
"-",
"margin_after",
"]",
"assert",
"waveforms_f",
".",
"shape",
"==",
"(",
"n_spikes",
",",
"nc",
",",
"self",
".",
"n_samples_waveforms",
",",
")",
"# NOTE: we transpose before returning the array.",
"return",
"np",
".",
"transpose",
"(",
"waveforms_f",
",",
"(",
"0",
",",
"2",
",",
"1",
")",
")"
] |
Load the waveforms of the specified spikes.
|
[
"Load",
"the",
"waveforms",
"of",
"the",
"specified",
"spikes",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/traces/waveform.py#L271-L337
|
train
|
kwikteam/phy
|
phy/stats/clusters.py
|
get_waveform_amplitude
|
def get_waveform_amplitude(mean_masks, mean_waveforms):
"""Return the amplitude of the waveforms on all channels."""
assert mean_waveforms.ndim == 2
n_samples, n_channels = mean_waveforms.shape
assert mean_masks.ndim == 1
assert mean_masks.shape == (n_channels,)
mean_waveforms = mean_waveforms * mean_masks
assert mean_waveforms.shape == (n_samples, n_channels)
# Amplitudes.
m, M = mean_waveforms.min(axis=0), mean_waveforms.max(axis=0)
return M - m
|
python
|
def get_waveform_amplitude(mean_masks, mean_waveforms):
"""Return the amplitude of the waveforms on all channels."""
assert mean_waveforms.ndim == 2
n_samples, n_channels = mean_waveforms.shape
assert mean_masks.ndim == 1
assert mean_masks.shape == (n_channels,)
mean_waveforms = mean_waveforms * mean_masks
assert mean_waveforms.shape == (n_samples, n_channels)
# Amplitudes.
m, M = mean_waveforms.min(axis=0), mean_waveforms.max(axis=0)
return M - m
|
[
"def",
"get_waveform_amplitude",
"(",
"mean_masks",
",",
"mean_waveforms",
")",
":",
"assert",
"mean_waveforms",
".",
"ndim",
"==",
"2",
"n_samples",
",",
"n_channels",
"=",
"mean_waveforms",
".",
"shape",
"assert",
"mean_masks",
".",
"ndim",
"==",
"1",
"assert",
"mean_masks",
".",
"shape",
"==",
"(",
"n_channels",
",",
")",
"mean_waveforms",
"=",
"mean_waveforms",
"*",
"mean_masks",
"assert",
"mean_waveforms",
".",
"shape",
"==",
"(",
"n_samples",
",",
"n_channels",
")",
"# Amplitudes.",
"m",
",",
"M",
"=",
"mean_waveforms",
".",
"min",
"(",
"axis",
"=",
"0",
")",
",",
"mean_waveforms",
".",
"max",
"(",
"axis",
"=",
"0",
")",
"return",
"M",
"-",
"m"
] |
Return the amplitude of the waveforms on all channels.
|
[
"Return",
"the",
"amplitude",
"of",
"the",
"waveforms",
"on",
"all",
"channels",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/stats/clusters.py#L41-L55
|
train
|
kwikteam/phy
|
phy/stats/clusters.py
|
get_mean_masked_features_distance
|
def get_mean_masked_features_distance(mean_features_0,
mean_features_1,
mean_masks_0,
mean_masks_1,
n_features_per_channel=None,
):
"""Compute the distance between the mean masked features."""
assert n_features_per_channel > 0
mu_0 = mean_features_0.ravel()
mu_1 = mean_features_1.ravel()
omeg_0 = mean_masks_0
omeg_1 = mean_masks_1
omeg_0 = np.repeat(omeg_0, n_features_per_channel)
omeg_1 = np.repeat(omeg_1, n_features_per_channel)
d_0 = mu_0 * omeg_0
d_1 = mu_1 * omeg_1
return np.linalg.norm(d_0 - d_1)
|
python
|
def get_mean_masked_features_distance(mean_features_0,
mean_features_1,
mean_masks_0,
mean_masks_1,
n_features_per_channel=None,
):
"""Compute the distance between the mean masked features."""
assert n_features_per_channel > 0
mu_0 = mean_features_0.ravel()
mu_1 = mean_features_1.ravel()
omeg_0 = mean_masks_0
omeg_1 = mean_masks_1
omeg_0 = np.repeat(omeg_0, n_features_per_channel)
omeg_1 = np.repeat(omeg_1, n_features_per_channel)
d_0 = mu_0 * omeg_0
d_1 = mu_1 * omeg_1
return np.linalg.norm(d_0 - d_1)
|
[
"def",
"get_mean_masked_features_distance",
"(",
"mean_features_0",
",",
"mean_features_1",
",",
"mean_masks_0",
",",
"mean_masks_1",
",",
"n_features_per_channel",
"=",
"None",
",",
")",
":",
"assert",
"n_features_per_channel",
">",
"0",
"mu_0",
"=",
"mean_features_0",
".",
"ravel",
"(",
")",
"mu_1",
"=",
"mean_features_1",
".",
"ravel",
"(",
")",
"omeg_0",
"=",
"mean_masks_0",
"omeg_1",
"=",
"mean_masks_1",
"omeg_0",
"=",
"np",
".",
"repeat",
"(",
"omeg_0",
",",
"n_features_per_channel",
")",
"omeg_1",
"=",
"np",
".",
"repeat",
"(",
"omeg_1",
",",
"n_features_per_channel",
")",
"d_0",
"=",
"mu_0",
"*",
"omeg_0",
"d_1",
"=",
"mu_1",
"*",
"omeg_1",
"return",
"np",
".",
"linalg",
".",
"norm",
"(",
"d_0",
"-",
"d_1",
")"
] |
Compute the distance between the mean masked features.
|
[
"Compute",
"the",
"distance",
"between",
"the",
"mean",
"masked",
"features",
"."
] |
7e9313dc364304b7d2bd03b92938347343703003
|
https://github.com/kwikteam/phy/blob/7e9313dc364304b7d2bd03b92938347343703003/phy/stats/clusters.py#L58-L80
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.