def get_range_values(self, kwargs, ranger_name): """ For the ranger given by ranger_name look in kwargs and return the array with all the possible values. """ if ranger_name not in kwargs: return None if str(kwargs[ranger_name]) not in kwargs: return None range_values = [] try: range_data = json.loads(str(kwargs[str(kwargs[ranger_name])])) except Exception: try: range_data = [x.strip() for x in str(kwargs[str(kwargs[ranger_name])]).split(',') if len(x.strip()) > 0] return range_data except Exception: self.logger.exception("Could not launch operation !") raise LaunchException("Could not launch with no data from:" + str(ranger_name)) if type(range_data) in (list, tuple): return range_data if (constants.ATT_MINVALUE in range_data) and (constants.ATT_MAXVALUE in range_data): lo_val = float(range_data[constants.ATT_MINVALUE]) hi_val = float(range_data[constants.ATT_MAXVALUE]) step = float(range_data[constants.ATT_STEP]) range_values = list(Range(lo=lo_val, hi=hi_val, step=step, mode=Range.MODE_INCLUDE_BOTH)) else: for possible_value in range_data: if range_data[possible_value]: range_values.append(possible_value) return range_values
def configure(self, time_series, mother=None, sample_period=None, normalisation=None, q_ratio=None, frequencies='Range', frequencies_parameters=None): """ Store the input shape to be later used to estimate memory usage. Also create the algorithm instance. """ self.input_shape = time_series.read_data_shape() log_debug_array(LOG, time_series, "time_series") ##-------------------- Fill Algorithm for Analysis -------------------## algorithm = ContinuousWaveletTransform() if mother is not None: algorithm.mother = mother if sample_period is not None: algorithm.sample_period = sample_period if (frequencies_parameters is not None and 'lo' in frequencies_parameters and 'hi' in frequencies_parameters and frequencies_parameters['hi'] != frequencies_parameters['lo']): algorithm.frequencies = Range(**frequencies_parameters) if normalisation is not None: algorithm.normalisation = normalisation if q_ratio is not None: algorithm.q_ratio = q_ratio self.algorithm = algorithm self.algorithm.time_series = time_series
def test_generates_range_with_challenging_float_point_arithmetics(self): floats = list(Range(lo=0.0, hi=2.2, step=0.7)) self.assertEqual(floats, [0.0, 0.7, 1.4, 2.1])
def test_generates_range_with_negative_end_but_excluding_start(self): floats = list( Range(lo=1.0, hi=-3.0, step=1.0, mode=Range.MODE_INCLUDE_END)) self.assertEqual(floats, [0.0, -1.0, -2.0, -3.0])
def test_generates_range_with_negative_end_including_both(self): floats = list( Range(lo=1.0, hi=-3.0, step=1.0, mode=Range.MODE_INCLUDE_BOTH)) self.assertEqual(floats, [1.0, 0.0, -1.0, -2.0, -3.0])
def test_generates_range_with_negative_end(self): floats = list(Range(lo=1.0, hi=-3.0, step=1.0)) self.assertEqual(floats, [1.0, 0.0, -1.0, -2.0])
def test_generates_range_with_only_end_included(self): floats = list( Range(lo=0.0, hi=3.0, step=1.0, mode=Range.MODE_INCLUDE_END)) self.assertEqual(floats, [1.0, 2.0, 3.0])
def test_generates_range_with_start_and_end_excluded(self): floats = list( Range(lo=0.0, hi=3.0, step=1.0, mode=Range.MODE_EXCLUDE_BOTH)) self.assertEqual(floats, [1.0, 2.0])
def test_generates_range_with_start_stop_and_periodic_repeating_step(self): floats = list(Range(lo=0.0, hi=1.0, step=1. / 3)) self.assertEqual(floats, [0.0, 0.333333333333, 0.666666666666, 0.999999999999])
def test_generates_range_with_start_stop_and_step_smaller_than_one(self): floats = list(Range(lo=0.0, hi=0.5, step=0.1)) self.assertEqual(floats, [0.0, 0.1, 0.2, 0.3, 0.4])
def test_generates_range_with_start_and_stop(self): floats = list(Range(lo=1.0, hi=3.0, step=1.0)) self.assertEqual(floats, [1.0, 2.0])
def test_generates_range_with_only_stop_provided(self): floats = list(Range(hi=3.0, step=1.0)) self.assertEqual(floats, [0.0, 1.0, 2.0])
class MyNewModelNameHere(models.Model): """ .. [REF_2012] Name A and Then B. * Main Reference Title*. Journal of Wonderful Research Vol, start.page-end.page, YYYY. .. [REF2_2012] Idem See also, http://www.scholarpedia.org/My_Model_is_in_scholarpedia .. automethod:: __init__ """ _ui_name = "My model's name that will be displayed in the web user interface(My Model Name)" #Define traited attributes for this model par_1 = FloatArray( label=":math:`\\par_{1}`", default=numpy.array([ "Insert default value as float number. Ex: 0.5", ]), range=Range(lo="Insert minimum_value here. Ex: 0.0", hi="Insert maximum_value here. Ex: 1.0)"), doc= """ Description of the physical magnitude or the effect of this parameter [units] """ ) par_2 = Integer( label=":math:`\\par_{2}`", default=numpy.array([ "default value as integer number. Ex: 5", ]), range=Range(lo="Insert minimum_value. Ex. 0", hi="Insert maximum_value. Ex: 10"), doc= """ Description of the physical magnitude or the effect of this parameter [units] """ ) # Define the range of possible values that the state variables can have. # This will be used to set the initial conditions state_variable_range = Dict( label="State Variable ranges [lo, hi]", default={ "my_first_state_variable_name": numpy.array( ["low_value_first_variable", "high_value_first_variable"]), "my_second_state_variable_name": numpy.array( ["low_value_second_variable", "high_value_second_variable"]) }, doc="""The values for each state-variable should be set to encompass the expected dynamic range of that state-variable for the current parameters, it is used as a mechanism for bounding random inital conditions when the simulation isn't started from an explicit history, it is also provides the default range of phase-plane plots.""" ) # If the MyNewModel does not have more than 1 mode, then leave this piece of code as it is number_of_modes = Integer(label="Number of modes", default=1, doc=""" Number of modes of the model """) def __init__(self, **kwargs): """ Initialise parameters """ super(MyNewModelNameHere, self).__init__(**kwargs) #state variables names self._state_variables = [ "my_first_state_variable_name", "my_second_state_variable_name" ] # number of state variables self._nvar = 2 self.cvar = numpy.array([0], dtype=numpy.int32) # the variable of interest self.voi = numpy.array([0], dtype=numpy.int32) #If there are derived parameters from the predefined parameters, then initialize them to None self.A = None self.B = None def dfun(self, state_variables, coupling, local_coupling=0.0): """ The equations were taken from [REF_2012] cf. Eqns. (00) and (01), page 2 .. math:: \\dot{my_first_state_variable} &= \\dot{my_second_state_variable} &= """ my_first_state_variable_name = state_variables[0, :] my_second_state_variable_name = state_variables[1, :] # global coupling my_first_global_coupling_coefficient = coupling[0, :] dmy_first_state_variable_name = "Write the first state variable differential equation" dmy_second_state_variable_name = "Write the second state variable differential equation" derivative = numpy.array( [dmy_first_state_variable_name, dmy_second_state_variable_name]) return derivative def update_derived_parameters(self): """ Calculate coefficients for the neural field model based on [REF_2012]. cf. Eqns (X.X) and (Y.Y), page aaa Include equations here .. math:: A &= equation B &= equation """ self.A = "Insert equation here" self.B = "Insert equation here"
def test_generates_range_with_start_and_end_included(self): floats = list( Range(lo=0.0, hi=3.0, step=1.0, mode=Range.MODE_INCLUDE_BOTH)) assert floats == [0.0, 1.0, 2.0, 3.0]
def test_generates_range_with_start_and_stop(self): floats = list(Range(lo=1.0, hi=3.0, step=1.0)) assert floats == [1.0, 2.0]