Esempio n. 1
0
    def setUp(self):
        self.depth = 1000.0              # meters
        self.potential_temperature = 4.0 # Celsius
        self.water_flux = 10.0           # m / day

        self.grid = create_grid()

        self.theta = PISM.IceModelVec2S(self.grid, "theta_ocean", PISM.WITHOUT_GHOSTS)
        self.theta.set(self.potential_temperature)

        self.Qsg = PISM.IceModelVec2S(self.grid, "subglacial_water_flux",
                                      PISM.WITHOUT_GHOSTS)
        self.Qsg.set_attrs("climate", "subglacial water flux", "m2 / s", "m2 / s", "", 0)

        grid_spacing = 0.5 * (self.grid.dx() + self.grid.dy())
        cross_section_area = self.depth * grid_spacing

        self.Qsg.set(self.water_flux * cross_section_area / (grid_spacing * seconds_per_day))

        self.geometry = create_geometry(self.grid)
        self.geometry.ice_thickness.set(self.depth)
        self.geometry.sea_level_elevation.set(self.depth)

        self.geometry.ensure_consistency(config.get_number("geometry.ice_free_thickness_standard"))

        self.inputs = PISM.FrontalMeltInputs()
        self.inputs.geometry = self.geometry
        self.inputs.subglacial_water_flux = self.Qsg
Esempio n. 2
0
    def setUp(self):

        self.frontal_melt_rate = 100.0

        self.grid = create_grid()
        self.geometry = create_geometry(self.grid)

        self.filename = "given_input.nc"

        self.create_input(self.filename, self.frontal_melt_rate)

        config.set_string("frontal_melt.given.file", self.filename)

        self.water_flux = PISM.IceModelVec2S(self.grid, "water_flux", PISM.WITHOUT_GHOSTS)
        self.water_flux.set(0.0)

        self.inputs = PISM.FrontalMeltInputs()
        self.inputs.geometry = self.geometry
        self.inputs.subglacial_water_flux = self.water_flux
Esempio n. 3
0
def constant_test():
    "Model Constant"

    # compute mass flux
    melt_rate = config.get_number("frontal_melt.constant.melt_rate", "m second-1")

    grid = create_grid()
    geometry = create_geometry(grid)

    inputs = PISM.FrontalMeltInputs()
    water_flux = PISM.IceModelVec2S(grid, "water_flux", PISM.WITHOUT_GHOSTS)
    water_flux.set(0.0)
    inputs.geometry = geometry
    inputs.subglacial_water_flux = water_flux

    model = PISM.FrontalMeltConstant(grid)

    model.init(geometry)
    model.update(inputs, 0, 1)

    check_model(model, melt_rate)

    assert model.max_timestep(0).infinite()
Esempio n. 4
0
ctx = context.ctx
config = context.config
config.set_string("frontal_melt.routing.file", routing_file)

registration = PISM.CELL_CENTER

grid = PISM.IceGrid.FromFile(ctx, input_file, ("bed", "thickness"),
                             registration)
geometry = PISM.Geometry(grid)
geometry.ice_thickness.regrid(input_file, critical=True)
geometry.bed_elevation.regrid(input_file, critical=True)
min_thickness = config.get_double("geometry.ice_free_thickness_standard")
geometry.ensure_consistency(min_thickness)

theta = 1.0
salinity = 0.0

inputs = PISM.FrontalMeltInputs()
cell_area = grid.dx() * grid.dy()
water_density = config.get_double("constants.fresh_water.density")

Qsg = PISM.IceModelVec2S(grid,
                         "subglacial_water_mass_change_at_grounding_line",
                         PISM.WITHOUT_GHOSTS)
Qsg.set_attrs("climate", "subglacial discharge at grounding line", "kg", "kg")
# Qsg.set(self.subglacial_discharge * cell_area * water_density * self.dt)

model = PISM.FrontalMeltDischargeRouting(grid)
model.init(geometry)
# model.update(inputs, 0, 0.1)