def get_component_instance(self):
# Create Radiation Prognostic
radiation = climt.RRTMGLongwave()
# Create Convection Prognostic
convection = climt.EmanuelConvection()
# Create a SimplePhysics Prognostic
boundary_layer = TimeDifferencingWrapper(climt.SimplePhysics())
return GFSDynamicalCore([radiation, convection, boundary_layer])
def __init__(self,
dt_seconds=1800,
nx=64,
ny=32,
nz=10,
state=None,
input_fields_to_store=input_vars,
output_fields_to_store=output_vars,
input_save_fn=None,
output_save_fn=None,
save_interval=6,
convection=None,
extra_components=[]):
"""
Initialize model. Uses SSTs from Andersen and Kuang 2012.
Creates initial state unless state is given.
"""
climt.set_constants_from_dict(
{'stellar_irradiance': {
'value': 200,
'units': 'W m^-2'
}})
self.model_time_step = timedelta(seconds=dt_seconds)
self.step_counter = 0
self.save_interval = save_interval
# Create components
if convection is None:
convection = climt.EmanuelConvection(
tendencies_in_diagnostics=True)
simple_physics = TimeDifferencingWrapper(
climt.SimplePhysics(tendencies_in_diagnostics=True))
radiation = climt.GrayLongwaveRadiation(tendencies_in_diagnostics=True)
components = [simple_physics, radiation, convection] + extra_components
self.dycore = climt.GFSDynamicalCore(components,
number_of_damped_levels=2)
grid = climt.get_grid(nx=nx, ny=ny, nz=nz)
if state is None:
self.create_initial_state(grid)
else:
self.state = state
if not input_save_fn is None:
self.input_netcdf_monitor = NetCDFMonitor(
input_save_fn,
write_on_store=True,
store_names=input_fields_to_store)
if not output_save_fn is None:
self.output_netcdf_monitor = NetCDFMonitor(
output_save_fn,
write_on_store=True,
store_names=output_fields_to_store)
def test_scaling_implicit_output():
simple_physics = climt.SimplePhysics()
simple_physics = simple_physics.scaled_version(output_scale_factors=dict(
air_temperature=0))
state = climt.get_default_state([simple_physics])
diagnostics, output = simple_physics(state, timedelta(hours=1))
assert np.all(output['air_temperature'].values == 0)
fields_to_store = ['air_temperature', 'air_pressure', 'eastward_wind',
'northward_wind', 'air_pressure_on_interface_levels',
'surface_pressure', 'upwelling_longwave_flux_in_air',
'specific_humidity', 'surface_temperature',
'latitude', 'longitude',
'convective_heating_rate']
climt.set_constants_from_dict({
'stellar_irradiance': {'value': 200, 'units': 'W m^-2'}})
model_time_step = timedelta(seconds=600)
# Create components
convection = climt.EmanuelConvection()
simple_physics = TimeDifferencingWrapper(climt.SimplePhysics())
constant_duration = 6
radiation_lw = UpdateFrequencyWrapper(
climt.RRTMGLongwave(), constant_duration*model_time_step)
radiation_sw = UpdateFrequencyWrapper(
climt.RRTMGShortwave(), constant_duration*model_time_step)
slab_surface = climt.SlabSurface()
dycore = climt.GFSDynamicalCore(
[simple_physics, slab_surface, radiation_sw,
radiation_lw, convection], number_of_damped_levels=5
)
{'stellar_irradiance': {
'value': 200,
'units': 'W m^-2'
}})
# Create components
dycore = climt.GFSDynamicalCore(number_of_longitudes=128,
number_of_latitudes=62,
number_of_damped_levels=5,
time_step=1200.)
model_time_step = dycore._time_step
convection = climt.EmanuelConvection(
convective_momentum_transfer_coefficient=1)
simple_physics = climt.SimplePhysics()
simple_physics = simple_physics.prognostic_version()
simple_physics.current_time_step = model_time_step
convection.current_time_step = model_time_step
# run radiation once every hour
constant_duration = 3
radiation_lw = climt.RRTMGLongwave()
radiation_lw = radiation_lw.piecewise_constant_version(constant_duration *
model_time_step)
radiation_sw = climt.RRTMGShortwave(use_solar_constant_from_fortran=False)
radiation_sw = radiation_sw.piecewise_constant_version(constant_duration *
model_time_step)
def get_component_instance(self):
return climt.SimplePhysics(boundary_layer=False)
def get_component_instance(self):
return climt.SimplePhysics(boundary_layer=False,
use_external_surface_specific_humidity=True)
