def write_state(model):
"Test writing of the model state"
o_filename = tmp_name("atmosphere_model_state")
o_diagnostics = tmp_name("atmosphere_diagnostics")
try:
output = PISM.util.prepare_output(o_filename)
model.define_model_state(output)
model.write_model_state(output)
output.close()
ds = model.diagnostics()
output = PISM.util.prepare_output(o_diagnostics)
for d in ds:
ds[d].define(output, PISM.PISM_DOUBLE)
for d in ds:
ds[d].compute().write(output)
output.close()
finally:
os.remove(o_filename)
os.remove(o_diagnostics)
def setUp(self):
self.filename = tmp_name("atmosphere_one_station")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.T = 263.15
self.P = 10.0
time_name = config.get_string("time.dimension_name")
output = PISM.util.prepare_output(self.filename, append_time=True)
output.redef()
output.define_dimension("nv", 2)
output.define_variable("time_bounds", PISM.PISM_DOUBLE,
[time_name, "nv"])
output.write_attribute(time_name, "bounds", "time_bounds")
output.define_variable("precipitation", PISM.PISM_DOUBLE, [time_name])
output.write_attribute("precipitation", "units", "kg m-2 s-1")
output.define_variable("air_temp", PISM.PISM_DOUBLE, [time_name])
output.write_attribute("air_temp", "units", "Kelvin")
output.write_variable("precipitation", [0], [1], [self.P])
output.write_variable("air_temp", [0], [1], [self.T])
output.write_variable("time_bounds", [0, 0], [1, 2], [0, 1])
output.close()
config.set_string("atmosphere.one_station.file", self.filename)
def setUp(self):
self.filename = tmp_name("atmosphere_yearly_cycle")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.T_mean = 250.0
self.T_summer = 270.0
self.P = 15.0
output = PISM.util.prepare_output(self.filename)
precipitation(self.grid, self.P).write(output)
T_mean = PISM.IceModelVec2S(self.grid, "air_temp_mean_annual",
PISM.WITHOUT_GHOSTS)
T_mean.set_attrs("climate", "mean annual near-surface air temperature",
"K", "K", "", 0)
T_mean.set(self.T_mean)
T_mean.write(output)
T_summer = PISM.IceModelVec2S(self.grid, "air_temp_mean_summer",
PISM.WITHOUT_GHOSTS)
T_summer.set_attrs("climate",
"mean summer near-surface air temperature", "K",
"K", "", 0)
T_summer.set(self.T_summer)
T_summer.write(output)
config.set_string("atmosphere.yearly_cycle.file", self.filename)
def setUp(self):
ice_thickness = 1000.0
salinity = 35.0
potential_temperature = 270.0
self.average_water_column_pressure = water_column_pressure(
ice_thickness)
self.temperature = 270.17909999999995
self.mass_flux = -6.489250000000001e-05
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(ice_thickness)
self.geometry.bed_elevation.set(-2 * ice_thickness)
self.geometry.ensure_consistency(0.0)
self.filename = tmp_name("ocean_given_th_input")
filename = self.filename
PISM.util.prepare_output(filename)
Th = PISM.IceModelVec2S(self.grid, "theta_ocean", PISM.WITHOUT_GHOSTS)
Th.set_attrs("climate", "potential temperature", "Kelvin", "Kelvin",
"", 0)
Th.set(potential_temperature)
Th.write(filename)
S = PISM.IceModelVec2S(self.grid, "salinity_ocean",
PISM.WITHOUT_GHOSTS)
S.set_attrs("climate", "ocean salinity", "g/kg", "g/kg", "", 0)
S.set(salinity)
S.write(filename)
config.set_string("ocean.th.file", self.filename)
def setUp(self):
self.filename = tmp_name("ocean_frac_MBP_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.model = PISM.OceanConstant(self.grid)
self.Lambda = 0.5
self.H = 1000.0
g = config.get_number("constants.standard_gravity")
rho_w = config.get_number("constants.sea_water.density")
rho_i = config.get_number("constants.ice.density")
def P(depth, density, g):
return 0.5 * density * g * depth
P_water = water_column_pressure(self.H)
P_ice = 0.5 * rho_i * g * self.H
self.dP = self.Lambda * (P_ice - P_water)
self.geometry.ice_thickness.set(self.H)
self.geometry.bed_elevation.set(-2 * self.H)
self.geometry.ensure_consistency(0.0)
create_scalar_forcing(self.filename,
"frac_MBP",
"1", [self.Lambda], [0],
time_bounds=[0, 1])
def setUp(self):
self.filename = tmp_name("atmosphere_anomaly_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.model = PISM.AtmosphereUniform(self.grid)
self.dT = -5.0
self.dP = 20.0
dT = PISM.IceModelVec2S(self.grid, "air_temp_anomaly",
PISM.WITHOUT_GHOSTS)
dT.set_attrs("climate", "air temperature anomaly", "Kelvin", "Kelvin",
"", 0)
dT.set(self.dT)
dP = PISM.IceModelVec2S(self.grid, "precipitation_anomaly",
PISM.WITHOUT_GHOSTS)
dP.set_attrs("climate", "precipitation anomaly", "kg m-2 s-1",
"kg m-2 s-1", "", 0)
dP.set(self.dP)
output = PISM.util.prepare_output(self.filename)
dT.write(output)
dP.write(output)
config.set_string("atmosphere.anomaly.file", self.filename)
def setUp(self):
self.filename = tmp_name("atmosphere_reference_surface")
self.grid = shallow_grid()
self.dTdz = 1.0 # Kelvin per km
self.dPdz = 1000.0 # (kg/m^2)/year per km
self.dz = 1000.0 # m
self.dT = -self.dTdz * self.dz / 1000.0
self.dP = -PISM.util.convert(self.dPdz * self.dz / 1000.0,
"kg m-2 year-1", "kg m-2 s-1")
self.precip_dTdz = 2.0 # Kelvin per km
self.geometry = PISM.Geometry(self.grid)
# save current surface elevation to use it as a "reference" surface elevation
self.geometry.ice_surface_elevation.dump(self.filename)
config.set_string("atmosphere.elevation_change.file", self.filename)
config.set_number(
"atmosphere.elevation_change.precipitation.lapse_rate", self.dPdz)
config.set_number(
"atmosphere.elevation_change.precipitation.temp_lapse_rate",
self.precip_dTdz)
config.set_number("atmosphere.elevation_change.temperature_lapse_rate",
self.dTdz)
def setUp(self):
self.filename = tmp_name("atmosphere_pik_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.latitude.set(-80.0)
self.P = 10.0 # this is very high, but that's fine
precipitation(self.grid, self.P).dump(self.filename)
config.set_string("atmosphere.pik.file", self.filename)
def setUp(self):
self.filename = tmp_name("atmosphere_delta_T_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.model = PISM.AtmosphereUniform(self.grid)
self.dT = -5.0
create_scalar_forcing(self.filename,
"delta_T",
"Kelvin", [self.dT], [0],
time_bounds=[0, 1])
def setUp(self):
self.filename = tmp_name("ocean_delta_SL_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.geometry.ensure_consistency(0.0)
self.model = PISM.SeaLevel(self.grid)
self.dSL = -5.0
create_scalar_forcing(self.filename,
"delta_SL",
"meters", [self.dSL], [0],
time_bounds=[0, 1])
def setUp(self):
self.filename = tmp_name("ocean_frac_SMB_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.geometry.ensure_consistency(0.0)
self.model = PISM.OceanConstant(self.grid)
self.dSMB = 0.5
create_scalar_forcing(self.filename,
"frac_mass_flux",
"1", [self.dSMB], [0],
time_bounds=[0, 1])
def setUp(self):
self.filename = tmp_name("atmosphere_given_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.P = 10.0
self.T = 250.0
output = PISM.util.prepare_output(self.filename)
precipitation(self.grid, self.P).write(output)
air_temperature(self.grid, self.T).write(output)
config.set_string("atmosphere.given.file", self.filename)
def setUp(self):
self.filename = tmp_name("ocean_delta_T_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.geometry.ensure_consistency(0.0)
self.model = PISM.OceanConstant(self.grid)
self.dT = -5.0
PISM.testing.create_scalar_forcing(self.filename,
"delta_T",
"Kelvin", [self.dT], [0],
time_bounds=[0, 1])
def setUp(self):
self.filename = tmp_name("atmosphere_frac_P_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.model = PISM.AtmosphereUniform(self.grid)
self.P_ratio = 5.0
create_scalar_forcing(self.filename,
"frac_P",
"1", [self.P_ratio], [0],
time_bounds=[0, 1])
config.set_string("atmosphere.frac_P.file", self.filename)
def setUp(self):
self.filename = tmp_name("atmosphere_searise_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.latitude.set(70.0)
self.geometry.longitude.set(-45.0)
self.geometry.ice_thickness.set(2500.0)
self.geometry.ensure_consistency(0.0)
self.P = 10.0
output = PISM.util.prepare_output(self.filename)
precipitation(self.grid, self.P).write(output)
config.set_string("atmosphere.searise_greenland.file", self.filename)
def setUp(self):
self.filename = tmp_name("ocean_delta_MBP_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.model = PISM.OceanConstant(self.grid)
self.dP = 100.0 # Pascal (over the thickness of melange)
self.H = 1000.0 # meters
self.dP_ice = config.get_number(
"ocean.delta_MBP.melange_thickness") * self.dP / self.H
self.geometry.ice_thickness.set(self.H)
self.geometry.bed_elevation.set(-2 * self.H)
self.geometry.ensure_consistency(0.0)
create_scalar_forcing(self.filename,
"delta_MBP",
"Pa", [self.dP], [0],
time_bounds=[0, 1])
def setUp(self):
self.filename = tmp_name("ocean_delta_SL_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.geometry.ensure_consistency(0.0)
self.model = PISM.SeaLevel(self.grid)
self.dSL = -5.0
bounds = [0, 0.5 * seconds_per_year, 1.5 * seconds_per_year]
PISM.testing.create_forcing(self.grid,
self.filename,
"delta_SL",
"meters",
values=[0, 2 * self.dSL],
times=[0, seconds_per_year],
time_bounds=bounds)
config.set_string("ocean.delta_sl_2d.file", self.filename)
def setUp(self):
self.filename = tmp_name("ocean_delta_BMB_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.geometry.ensure_consistency(0.0)
self.model = PISM.OceanConstant(self.grid)
self.dBMB = -5.0
delta_BMB = PISM.IceModelVec2S(self.grid,
"shelf_base_mass_flux_anomaly",
PISM.WITHOUT_GHOSTS)
delta_BMB.set_attrs("climate_forcing",
"2D shelf base mass flux anomaly", "kg m-2 s-1",
"kg m-2 s-1", "", 0)
delta_BMB.set(self.dBMB)
delta_BMB.dump(self.filename)
def setUp(self):
self.filename = tmp_name("atmosphere_frac_P_input")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.model = PISM.AtmosphereUniform(self.grid)
self.P_ratio = 5.0
frac_P = PISM.IceModelVec2S(self.grid, "frac_P", PISM.WITHOUT_GHOSTS)
frac_P.set_attrs("climate", "precipitation scaling", "1", "1", "", 0)
frac_P.set(self.P_ratio)
try:
output = PISM.util.prepare_output(self.filename)
frac_P.write(output)
finally:
output.close()
config.set_string("atmosphere.frac_P.file", self.filename)
def setUp(self):
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.filename = tmp_name("ocean_given_input")
self.temperature = 263.0
self.mass_flux = 3e-3
ice_thickness = 1000.0
self.geometry.ice_thickness.set(ice_thickness)
self.geometry.bed_elevation.set(-2 * ice_thickness)
self.geometry.ensure_consistency(0.0)
self.average_water_column_pressure = water_column_pressure(
ice_thickness)
create_given_input_file(self.filename, self.grid, self.temperature,
self.mass_flux)
config.set_string("ocean.given.file", self.filename)
def setUp(self):
self.filename = tmp_name("ocean_dT")
self.grid = shallow_grid()
self.geometry = PISM.Geometry(self.grid)
self.geometry.ice_thickness.set(1000.0)
self.geometry.ensure_consistency(0.0)
self.constant = PISM.OceanConstant(self.grid)
time_bounds = np.array([0, 1, 1, 2, 2, 3, 3, 4]) * seconds_per_year
create_scalar_forcing(self.filename,
"delta_T",
"Kelvin", [1, 2, 3, 4],
times=None,
time_bounds=time_bounds)
config.set_string("ocean.delta_T.file", self.filename)
self.delta_T = PISM.OceanDeltaT(self.grid, self.constant)
config.set_number("ocean.cache.update_interval", 2.0)
