def test_infinite_taylor_error(): mg = RasterModelGrid((5, 5)) z = mg.add_zeros("topographic__elevation", at="node") z += mg.node_x.copy()**4 Cdiff = TaylorNonLinearDiffuser(mg, nterms=400) with pytest.raises(RuntimeError): Cdiff.soilflux(10)
def __init__(self, input_file=None, params=None, BaselevelHandlerClass=None): """Initialize the BasicCh.""" # Call ErosionModel's init super(BasicCh, self).__init__(input_file=input_file, params=params, BaselevelHandlerClass=BaselevelHandlerClass) # Get Parameters and convert units if necessary: self.K_sp = self.get_parameter_from_exponent('K_sp') linear_diffusivity = (self._length_factor**2.)*self.get_parameter_from_exponent('linear_diffusivity') # has units length^2/time # Instantiate a FlowAccumulator with DepressionFinderAndRouter using D8 method self.flow_router = FlowAccumulator(self.grid, flow_director='D8', depression_finder = DepressionFinderAndRouter) # Instantiate a FastscapeEroder component self.eroder = FastscapeEroder(self.grid, K_sp=self.K_sp, m_sp=self.params['m_sp'], n_sp=self.params['n_sp']) # Instantiate a LinearDiffuser component self.diffuser = TaylorNonLinearDiffuser(self.grid, linear_diffusivity=linear_diffusivity, slope_crit=self.params['slope_crit'], nterms=11)
def test_raise_stability_error(): mg = RasterModelGrid((5, 5)) z = mg.add_zeros("topographic__elevation", at="node") z += mg.node_x.copy()**2 Cdiff = TaylorNonLinearDiffuser(mg, if_unstable="raise") with pytest.raises(RuntimeError): Cdiff.soilflux(10)
def __init__(self, input_file=None, params=None): """Initialize the CubicDiffusionModel.""" # Call ErosionModel's init super(CubicDiffusionModel, self).__init__(input_file=input_file, params=params) # Instantiate a LinearDiffuser component self.diffuser = TaylorNonLinearDiffuser(self.grid, **self.params)
def __init__(self, input_file=None, params=None, BaselevelHandlerClass=None): """Initialize the BasicChRt model.""" # Call ErosionModel's init super(BasicChRtTh, self).__init__(input_file=input_file, params=params, BaselevelHandlerClass=BaselevelHandlerClass) contact_zone__width = (self._length_factor) * self.params[ 'contact_zone__width'] # has units length self.K_rock_sp = self.get_parameter_from_exponent('K_rock_sp') self.K_till_sp = self.get_parameter_from_exponent('K_till_sp') rock_erosion__threshold = self.get_parameter_from_exponent( 'rock_erosion__threshold') till_erosion__threshold = self.get_parameter_from_exponent( 'till_erosion__threshold') linear_diffusivity = ( self._length_factor** 2.) * self.get_parameter_from_exponent('linear_diffusivity') # Set up rock-till self.setup_rock_and_till(self.params['rock_till_file__name'], self.K_rock_sp, self.K_till_sp, rock_erosion__threshold, till_erosion__threshold, contact_zone__width) # Instantiate a FlowAccumulator with DepressionFinderAndRouter using D8 method self.flow_router = FlowAccumulator( self.grid, flow_director='D8', depression_finder=DepressionFinderAndRouter) # Instantiate a StreamPowerSmoothThresholdEroder component self.eroder = StreamPowerSmoothThresholdEroder( self.grid, K_sp=self.erody, threshold_sp=self.threshold, m_sp=self.params['m_sp'], n_sp=self.params['n_sp']) # Instantiate a LinearDiffuser component self.diffuser = TaylorNonLinearDiffuser( self.grid, linear_diffusivity=linear_diffusivity, slope_crit=self.params['slope_crit'], nterms=7)
def __init__( self, clock, grid, water_erosion_rule_upper__threshold=1.0, water_erosion_rule_lower__threshold=1.0, critical_slope=0.3, number_of_taylor_terms=7, **kwargs ): """ Parameters ---------- clock : terrainbento Clock instance grid : landlab model grid instance The grid must have all required fields. m_sp : float, optional Drainage area exponent (:math:`m`). Default is 0.5. n_sp : float, optional Slope exponent (:math:`n`). Default is 1.0. water_erodibility_upper : float, optional Water erodibility of the upper layer (:math:`K_{1}`). Default is 0.001. water_erodibility_lower : float, optional Water erodibility of the upper layer (:math:`K_{2}`). Default is 0.0001. contact_zone__width : float, optional Thickness of the contact zone (:math:`W_c`). Default is 1. regolith_transport_parameter : float, optional Regolith transport efficiency (:math:`D`). Default is 0.1. water_erosion_rule_upper__threshold : float, optional. Erosion threshold of the upper layer (:math:`\omega_{c1}`). Default is 1. water_erosion_rule_lower__threshold: float, optional. Erosion threshold of the upper layer (:math:`\omega_{c2}`). Default is 1. critical_slope : float, optional Critical slope (:math:`S_c`, unitless). Default is 0.3. number_of_taylor_terms : int, optional Number of terms in the Taylor Series Expansion (:math:`N`). Default is 7. **kwargs : Keyword arguments to pass to :py:class:`TwoLithologyErosionModel`. Importantly these arguments specify the precipitator and the runoff generator that control the generation of surface water discharge (:math:`Q`). Returns ------- BasicChRtTh : model object Examples -------- This is a minimal example to demonstrate how to construct an instance of model **BasicChRtCh**. For more detailed examples, including steady-state test examples, see the terrainbento tutorials. To begin, import the model class. >>> from landlab import RasterModelGrid >>> from landlab.values import random, constant >>> from terrainbento import Clock, BasicChRtTh >>> clock = Clock(start=0, stop=100, step=1) >>> grid = RasterModelGrid((5,5)) >>> _ = random(grid, "topographic__elevation") >>> _ = constant(grid, "lithology_contact__elevation", value=-10.) Construct the model. >>> model = BasicChRtTh(clock, grid) Running the model with ``model.run()`` would create output, so here we will just run it one step. >>> model.run_one_step(1.) >>> model.model_time 1.0 """ # Call ErosionModel"s init super(BasicChRtTh, self).__init__(clock, grid, **kwargs) if float(self.n) != 1.0: raise ValueError("Model only supports n equals 1.") # verify correct fields are present. self._verify_fields(self._required_fields) # Save the threshold values for rock and till self.rock_thresh = water_erosion_rule_lower__threshold self.till_thresh = water_erosion_rule_upper__threshold # Set up rock-till boundary and associated grid fields. self._setup_rock_and_till_with_threshold() # Instantiate a StreamPowerSmoothThresholdEroder component self.eroder = StreamPowerSmoothThresholdEroder( self.grid, K_sp=self.erody, threshold_sp=self.threshold, m_sp=self.m, n_sp=self.n, use_Q="surface_water__discharge", ) # Instantiate a LinearDiffuser component self.diffuser = TaylorNonLinearDiffuser( self.grid, linear_diffusivity=self.regolith_transport_parameter, slope_crit=critical_slope, nterms=number_of_taylor_terms, )
def test_raise_kwargs_error(): mg = RasterModelGrid((5, 5)) z = mg.add_zeros("topographic__elevation", at="node") z += mg.node_x.copy()**2 with pytest.raises(TypeError): TaylorNonLinearDiffuser(mg, bad_name="true")
hydraulic_conductivity=ksat, regularization_f=0.01, recharge_rate=0.0, courant_coefficient=0.9, vn_coefficient=0.9, ) pdr = PrecipitationDistribution( grid, mean_storm_duration=tr, mean_interstorm_duration=tb, mean_storm_depth=ds, total_t=Th, ) pdr.seed_generator(seedval=1235) nld = TaylorNonLinearDiffuser(grid, linear_diffusivity=D, slope_crit=Sc, dynamic_dt=True) #initialize other models svm = SchenkVadoseModel( potential_evapotranspiration_rate=pet, available_relative_saturation=Srange, profile_depth=b, porosity=n, num_bins=Nz, ) hm = HydrologyEventVadoseStreamPower( grid, precip_generator=pdr, groundwater_model=gdp, vadose_model=svm,
def __init__( self, clock, grid, m_sp=0.5, n_sp=1.0, water_erodibility=0.0001, regolith_transport_parameter=0.1, critical_slope=0.3, number_of_taylor_terms=11, **kwargs ): """ Parameters ---------- clock : terrainbento Clock instance grid : landlab model grid instance The grid must have all required fields. m_sp : float, optional Drainage area exponent (:math:`m`). Default is 0.5. n_sp : float, optional Slope exponent (:math:`n`). Default is 1.0. water_erodibility : float, optional Water erodibility (:math:`K`). Default is 0.0001. regolith_transport_parameter : float, optional Regolith transport efficiency (:math:`D`). Default is 0.1. critical_slope : float, optional Critical slope (:math:`S_c`, unitless). Default is 0.3. number_of_taylor_terms : int, optional Number of terms in the Taylor Series Expansion (:math:`N`). Default is 11. **kwargs : Keyword arguments to pass to :py:class:`ErosionModel`. Importantly these arguments specify the precipitator and the runoff generator that control the generation of surface water discharge (:math:`Q`). Returns ------- BasicCh : model object Examples -------- This is a minimal example to demonstrate how to construct an instance of model **BasicCh**. For more detailed examples, including steady-state test examples, see the terrainbento tutorials. To begin, import the model class. >>> from landlab import RasterModelGrid >>> from landlab.values import random >>> from terrainbento import Clock, BasicCh >>> clock = Clock(start=0, stop=100, step=1) >>> grid = RasterModelGrid((5,5)) >>> _ = random(grid, "topographic__elevation") Construct the model. >>> model = BasicCh(clock, grid) Running the model with ``model.run()`` would create output, so here we will just run it one step. >>> model.run_one_step(1.) >>> model.model_time 1.0 """ # Call ErosionModel"s init super(BasicCh, self).__init__(clock, grid, **kwargs) # verify correct fields are present. self._verify_fields(self._required_fields) # Get Parameters and convert units if necessary: self.m = m_sp self.n = n_sp self.K = water_erodibility regolith_transport_parameter = regolith_transport_parameter # Instantiate a FastscapeEroder component self.eroder = FastscapeEroder( self.grid, K_sp=self.K, m_sp=self.m, n_sp=self.n, discharge_name="surface_water__discharge", ) # Instantiate a NonLinearDiffuser component self.diffuser = TaylorNonLinearDiffuser( self.grid, linear_diffusivity=regolith_transport_parameter, slope_crit=critical_slope, nterms=number_of_taylor_terms, )
def test_infinite_taylor_error(): mg = RasterModelGrid((5, 5)) z = mg.add_zeros('node', 'topographic__elevation') z += mg.node_x.copy()**4 Cdiff = TaylorNonLinearDiffuser(mg, nterms=400) assert_raises(RuntimeError, Cdiff.soilflux, 10)
def test_raise_stability_error(): mg = RasterModelGrid((5, 5)) z = mg.add_zeros('node', 'topographic__elevation') z += mg.node_x.copy()**2 Cdiff = TaylorNonLinearDiffuser(mg) assert_raises(RuntimeError, Cdiff.soilflux, 10, if_unstable='raise')