def test_numerical_instability_almost_canceling(self): # It's possible that we get almost-but-not-quite zero on the variable # being eliminated when we are doing this with floating point # arithmetic. This can get ugly later becuase it might get muliplied by # a large number later and start to "reappear" m = ConcreteModel() m.x = Var() m.x0 = Var() m.y = Var() m.cons1 = Constraint(expr=(1.342 + 2.371e-8)*m.x0 <= m.x + 17*m.y) m.cons2 = Constraint(expr=(17.56 + 3.2e-7)*m.x0 >= m.y) fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m, vars_to_eliminate=[m.x0], verbose=True, zero_tolerance=1e-9) constraints = m._pyomo_contrib_fme_transformation.projected_constraints # There's going to be numerical error here, and I can't really help # it. What I care about is that x0 really is gone. useful = constraints[1] repn = generate_standard_repn(useful.body) self.assertTrue(repn.is_linear()) self.assertEqual(len(repn.linear_coefs), 2) # this is the real test self.assertEqual(useful.lower, 0) self.assertIs(repn.linear_vars[0], m.x) self.assertAlmostEqual(repn.linear_coefs[0], 0.7451564696962295) self.assertIs(repn.linear_vars[1], m.y) self.assertAlmostEqual(repn.linear_coefs[1], 12.610712377673217) self.assertEqual(repn.constant, 0) self.assertIsNone(useful.upper)
def test_simple_hull_example(self): m = ConcreteModel() m.x0 = Var(bounds=(0, 3)) m.x1 = Var(bounds=(0, 3)) m.x = Var(bounds=(0, 3)) m.disaggregation = Constraint(expr=m.x == m.x0 + m.x1) m.y = Var(domain=Binary) m.cons = Constraint(expr=2 * m.y <= m.x1) fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m, vars_to_eliminate=[m.x0, m.x1]) constraints = m._pyomo_contrib_fme_transformation.projected_constraints constraints.pprint() self.assertEqual(len(constraints), 1) cons = constraints[1] self.assertIsNone(cons.upper) self.assertEqual(value(cons.lower), 0) repn = generate_standard_repn(cons.body) self.assertEqual(repn.constant, 0) self.assertEqual(len(repn.linear_vars), 2) self.assertIs(repn.linear_vars[0], m.x) self.assertEqual(repn.linear_coefs[0], 1) self.assertIs(repn.linear_vars[1], m.y) self.assertEqual(repn.linear_coefs[1], -2) self.assertTrue(repn.is_linear())
def test_project_disaggregated_vars(self): """This is a little bit more of an integration test with GDP, but also an example of why FME is 'useful.' We will give a GDP, take hull relaxation, and then project out the disaggregated variables.""" m, disaggregatedVars = self.create_hull_model() filtered = TransformationFactory('contrib.fourier_motzkin_elimination').\ create_using(m, vars_to_eliminate=disaggregatedVars) TransformationFactory('contrib.fourier_motzkin_elimination').apply_to( m, vars_to_eliminate=disaggregatedVars, constraint_filtering_callback=None) constraints = m._pyomo_contrib_fme_transformation.projected_constraints # we of course get tremendous amounts of garbage, but we make sure that # what should be here is: self.check_hull_projected_constraints( m, constraints, [21, 16, 57, 59, 55, 33, 27, 1, 2, 4, 5]) # and when we filter, it's still there. constraints = filtered._pyomo_contrib_fme_transformation.\ projected_constraints constraints.pprint() self.check_hull_projected_constraints( filtered, constraints, [6, 5, 16, 17, 15, 9, 8, 1, 2, 3, 4])
def test_projected_constraints_named_correctly(self): m = self.make_tiny_model_where_bounds_matter() fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m.b, vars_to_eliminate=[m.y], projected_constraints_name='fme_constraints') self.assertIsInstance(m.b.component("fme_constraints"), Constraint) self.check_tiny_model_constraints(m.b.fme_constraints) self.assertIsNone(m.b._pyomo_contrib_fme_transformation.component( "projected_constraints"))
def test_use_all_var_bounds(self): m = self.make_tiny_model_where_bounds_matter() fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m.b, vars_to_eliminate=[m.y]) constraints = m.b.\ _pyomo_contrib_fme_transformation.projected_constraints # if we hadn't included y's bounds, then we wouldn't get any constraints # and y wouldn't be eliminated. If we do include y's bounds, we get new # information that x <= 5: self.check_tiny_model_constraints(constraints)
def create_hull_model(self): m = ConcreteModel() m.p = Var([1, 2], bounds=(0, 10)) m.time1 = Disjunction(expr=[m.p[1] >= 1, m.p[1] == 0]) m.on = Disjunct() m.on.above_min = Constraint(expr=m.p[2] >= 1) m.on.ramping = Constraint(expr=m.p[2] - m.p[1] <= 3) m.on.on_before = Constraint(expr=m.p[1] >= 1) m.startup = Disjunct() m.startup.startup_limit = Constraint(expr=(1, m.p[2], 2)) m.startup.off_before = Constraint(expr=m.p[1] == 0) m.off = Disjunct() m.off.off = Constraint(expr=m.p[2] == 0) m.time2 = Disjunction(expr=[m.on, m.startup, m.off]) m.obj = Objective(expr=m.p[1] + m.p[2]) hull = TransformationFactory('gdp.hull') hull.apply_to(m) disaggregatedVars = ComponentSet([ hull.get_disaggregated_var(m.p[1], m.time1.disjuncts[0]), hull.get_disaggregated_var(m.p[1], m.time1.disjuncts[1]), hull.get_disaggregated_var(m.p[1], m.on), hull.get_disaggregated_var(m.p[2], m.on), hull.get_disaggregated_var(m.p[1], m.startup), hull.get_disaggregated_var(m.p[2], m.startup), hull.get_disaggregated_var(m.p[1], m.off), hull.get_disaggregated_var(m.p[2], m.off) ]) return m, disaggregatedVars
def _presolve(self, *args, **kwds): if not isinstance(args[0], six.string_types): self._instance = args[0] xfrm = TransformationFactory('mpec.nl') xfrm.apply_to(self._instance) if len(self._instance._transformation_data['mpec.nl'].compl_cuids) == 0: # There were no complementarity conditions # so we don't hold onto the instance self._instance = None else: args = (self._instance,) else: self._instance = None # SystemCallSolver._presolve(self, *args, **kwds)
def _apply_to_impl(self, instance, **kwds): if not instance.ctype in (Block, Disjunct): raise GDP_Error("Transformation called on %s of type %s. " "'instance' must be a ConcreteModel, Block, or " "Disjunct (in the case of nested disjunctions)." % (instance.name, instance.ctype)) config = self.CONFIG(kwds.pop('options', {})) # We will let args override suffixes and estimate as a last # resort. More specific args/suffixes override ones anywhere in # the tree. Suffixes lower down in the tree override ones higher # up. config.set_value(kwds) bigM = config.bigM self.assume_fixed_vars_permanent = config.assume_fixed_vars_permanent targets = config.targets # We need to check that all the targets are in fact on instance. As we # do this, we will use the set below to cache components we know to be # in the tree rooted at instance. knownBlocks = {} if targets is None: targets = (instance, ) # we need to preprocess targets to make sure that if there are any # disjunctions in targets that their disjuncts appear before them in # the list. targets = preprocess_targets(targets, instance, knownBlocks) for t in targets: if t.ctype is Disjunction: if t.is_indexed(): self._transform_disjunction(t, bigM) else: self._transform_disjunctionData(t, bigM, t.index()) else: # We know t.ctype in (Block, Disjunct) after preprocessing if t.is_indexed(): self._transform_block(t, bigM) else: self._transform_blockData(t, bigM) # issue warnings about anything that was in the bigM args dict that we # didn't use if bigM is not None: unused_args = ComponentSet(bigM.keys()) - \ ComponentSet(self.used_args.keys()) if len(unused_args) > 0: warning_msg = ("Unused arguments in the bigM map! " "These arguments were not used by the " "transformation:\n") for component in unused_args: if hasattr(component, 'name'): warning_msg += "\t%s\n" % component.name else: warning_msg += "\t%s\n" % component logger.warning(warning_msg) # at the end, transform any logical constraints that might be on # instance TransformationFactory('core.logical_to_linear').apply_to(instance)
def _presolve(self, *args, **kwds): if not isinstance(args[0], six.string_types): self._instance = args[0] xfrm = TransformationFactory('mpec.nl') xfrm.apply_to(self._instance) if len(self._instance._transformation_data['mpec.nl'].compl_cuids ) == 0: # There were no complementarity conditions # so we don't hold onto the instance self._instance = None else: args = (self._instance, ) else: self._instance = None # SystemCallSolver._presolve(self, *args, **kwds)
def test_transformed_constraints_indexed_var_arg(self): m = self.makeModel() TransformationFactory('contrib.fourier_motzkin_elimination').apply_to( m, vars_to_eliminate=m.lamb, constraint_filtering_callback=None) # we get some trivial constraints too, but let's check that the ones # that should be there really are self.check_projected_constraints(m, self.unfiltered_indices)
def test_transformed_constraints_varData_list_arg(self): m = self.makeModel() TransformationFactory('contrib.fourier_motzkin_elimination').apply_to( m, vars_to_eliminate=[m.lamb[1], m.lamb[2]], constraint_filtering_callback=None) self.check_projected_constraints(m, self.unfiltered_indices)
def test_no_vars_specified(self): m = self.makeModel() self.assertRaisesRegexp( RuntimeError, "The Fourier-Motzkin Elimination transformation " "requires the argument vars_to_eliminate, a " "list of Vars to be projected out of the model.", TransformationFactory('contrib.fourier_motzkin_elimination').\ apply_to, m)
def _transform_blockData(self, obj, bigM): # Transform every (active) disjunction in the block for disjunction in obj.component_objects( Disjunction, active=True, sort=SortComponents.deterministic, descend_into=(Block, Disjunct), descent_order=TraversalStrategy.PostfixDFS): self._transform_disjunction(disjunction, bigM) # transform any logical constraints TransformationFactory('core.logical_to_linear').apply_to(obj)
def test_original_constraints_deactivated(self): m = self.makeModel() TransformationFactory('contrib.fourier_motzkin_elimination').apply_to( m, vars_to_eliminate=m.lamb) self.assertFalse(m.primal1.active) self.assertFalse(m.dual1.active) self.assertFalse(m.dual2.active) self.assertFalse(m.bound_lambdas[1].active) self.assertFalse(m.bound_lambdas[2].active) self.assertFalse(m.bound_y.active)
def test_integer_arithmetic_non1_coefficients(self): m = ConcreteModel() m.x = Var(bounds=(0, 9)) m.y = Var(bounds=(-5, 5)) m.c1 = Constraint(expr=4 * m.x + m.y >= 4) m.c2 = Constraint(expr=m.y >= 2 * m.x) fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m, vars_to_eliminate=m.x, constraint_filtering_callback=None, do_integer_arithmetic=True, verbose=True) constraints = m._pyomo_contrib_fme_transformation.projected_constraints self.assertEqual(len(constraints), 3) cons = constraints[3] self.assertEqual(value(cons.lower), -32) self.assertIs(cons.body, m.y) self.assertIsNone(cons.upper) cons = constraints[2] self.assertEqual(value(cons.lower), 0) self.assertIsNone(cons.upper) repn = generate_standard_repn(cons.body) self.assertTrue(repn.is_linear()) self.assertEqual(len(repn.linear_coefs), 1) self.assertIs(repn.linear_vars[0], m.y) self.assertEqual(repn.linear_coefs[0], 2) cons = constraints[1] self.assertEqual(value(cons.lower), 4) self.assertIsNone(cons.upper) repn = generate_standard_repn(cons.body) self.assertTrue(repn.is_linear()) self.assertEqual(len(repn.linear_coefs), 1) self.assertIs(repn.linear_vars[0], m.y) self.assertEqual(repn.linear_coefs[0], 3)
def test_non_unique_constraint_name_error(self): m = self.make_tiny_model_where_bounds_matter() fme = TransformationFactory('contrib.fourier_motzkin_elimination') self.assertRaisesRegex(RuntimeError, "projected_constraints_name was specified " "as 'c', but this is already a component on " "the instance! Please specify a unique " "name.", fme.apply_to, m.b, vars_to_eliminate=[m.y], projected_constraints_name='c')
def test_infeasible_model_no_var_bounds(self): m = ConcreteModel() m.x = Var() m.cons1 = Constraint(expr=m.x >= 6) m.cons2 = Constraint(expr=m.x <= 2) self.assertRaisesRegexp( RuntimeError, "Fourier-Motzkin found the model is infeasible!", TransformationFactory('contrib.fourier_motzkin_elimination').\ apply_to, m, vars_to_eliminate=m.x)
def test_default_constraint_filtering(self): # We will filter constraints which are trivial based on variable bounds # during the transformation. This checks that we removed the constraints # we expect. m = self.makeModel() TransformationFactory('contrib.fourier_motzkin_elimination').apply_to( m, vars_to_eliminate=m.lamb) # we still have all the right constraints self.check_projected_constraints(m, self.filtered_indices) # but now we *only* have the right constraints constraints = m._pyomo_contrib_fme_transformation.projected_constraints self.assertEqual(len(constraints), 4)
def test_constraint_filtering_callback_not_callable_error(self): m = self.makeModel() fme = TransformationFactory('contrib.fourier_motzkin_elimination') log = StringIO() with LoggingIntercept(log, 'pyomo.contrib.fme', logging.ERROR): self.assertRaisesRegexp(TypeError, "'int' object is not callable", fme.apply_to, m, vars_to_eliminate=m.x, constraint_filtering_callback=5) self.assertRegexpMatches( log.getvalue(), "Problem calling constraint filter callback " "on constraint with right-hand side -1.0 and body:*")
def test_use_all_var_bounds(self): m = ConcreteModel() m.b = Block() m.x = Var(bounds=(0, 15)) m.y = Var(bounds=(3, 5)) m.b.c = Constraint(expr=m.x + m.y <= 8) fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m.b, vars_to_eliminate=[m.y]) constraints = m.b.\ _pyomo_contrib_fme_transformation.projected_constraints # if we hadn't included y's bounds, then we wouldn't get any constraints # and y wouldn't be eliminated. If we do include y's bounds, we get new # information that x <= 5: self.assertEqual(len(constraints), 1) cons = constraints[1] self.assertEqual(value(cons.lower), -5) self.assertIsNone(cons.upper) repn = generate_standard_repn(cons.body) self.assertEqual(repn.constant, 0) self.assertEqual(len(repn.linear_vars), 1) self.assertIs(repn.linear_vars[0], m.x) self.assertEqual(repn.linear_coefs[0], -1)
def create_chull_model(self): m = ConcreteModel() m.p = Var([1, 2], bounds=(0, 10)) m.time1 = Disjunction(expr=[m.p[1] >= 1, m.p[1] == 0]) m.on = Disjunct() m.on.above_min = Constraint(expr=m.p[2] >= 1) m.on.ramping = Constraint(expr=m.p[2] - m.p[1] <= 3) m.on.on_before = Constraint(expr=m.p[1] >= 1) m.startup = Disjunct() m.startup.startup_limit = Constraint(expr=(1, m.p[2], 2)) m.startup.off_before = Constraint(expr=m.p[1] == 0) m.off = Disjunct() m.off.off = Constraint(expr=m.p[2] == 0) m.time2 = Disjunction(expr=[m.on, m.startup, m.off]) m.obj = Objective(expr=m.p[1] + m.p[2]) chull = TransformationFactory('gdp.chull') chull.apply_to(m) disaggregatedVars = ComponentSet([ chull.get_disaggregated_var(m.p[1], m.time1.disjuncts[0]), chull.get_disaggregated_var(m.p[1], m.time1.disjuncts[1]), chull.get_disaggregated_var(m.p[1], m.on), chull.get_disaggregated_var(m.p[2], m.on), chull.get_disaggregated_var(m.p[1], m.startup), chull.get_disaggregated_var(m.p[2], m.startup), chull.get_disaggregated_var(m.p[1], m.off), chull.get_disaggregated_var(m.p[2], m.off) ]) # from nose.tools import set_trace # set_trace() # disaggregatedVars = ComponentSet([relaxationBlocks[0].component("p[1]"), # relaxationBlocks[1].component("p[1]"), # relaxationBlocks[2].component("p[1]"), # relaxationBlocks[2].component("p[2]"), # relaxationBlocks[3].component("p[1]"), # relaxationBlocks[3].component("p[2]"), # relaxationBlocks[4].component("p[1]"), # relaxationBlocks[4].component("p[2]")]) return m, disaggregatedVars
def test_components_we_do_not_understand_error(self): m = self.makeModel() m.disj = Disjunction(expr=[m.x == 0, m.y >= 2]) self.assertRaisesRegexp( RuntimeError, "Found active component %s of type %s. The " "Fourier-Motzkin Elimination transformation can only " "handle purely algebraic models. That is, only " "Sets, Params, Vars, Constraints, Expressions, Blocks, " "and Objectives may be active on the model." % (m.disj.name, m.disj.type()), TransformationFactory('contrib.fourier_motzkin_elimination').\ apply_to, m, vars_to_eliminate=m.x)
def make_model(): m = ConcreteModel() m.time = ContinuousSet(bounds=(0, 10)) m.space = ContinuousSet(bounds=(0, 5)) m.set1 = Set(initialize=['a', 'b', 'c']) m.set2 = Set(initialize=['d', 'e', 'f']) m.fs = Block() m.fs.v0 = Var(m.space, initialize=1) @m.fs.Block() def b1(b): b.v = Var(m.time, m.space, initialize=1) b.dv = DerivativeVar(b.v, wrt=m.time, initialize=0) b.con = Constraint(m.time, m.space, rule=lambda b, t, x: b.dv[t, x] == 7 - b.v[t, x]) # Inconsistent @b.Block(m.time) def b2(b, t): b.v = Var(initialize=2) @m.fs.Block(m.time, m.space) def b2(b, t, x): b.v = Var(m.set1, initialize=2) @b.Block(m.set1) def b3(b, c): b.v = Var(m.set2, initialize=3) @b.Constraint(m.set2) def con(b, s): return (5 * b.v[s] == m.fs.b2[m.time.first(), m.space.first()].v[c]) # inconsistent @m.fs.Constraint(m.time) def con1(fs, t): return fs.b1.v[t, m.space.last()] == 5 # Will be inconsistent @m.fs.Constraint(m.space) def con2(fs, x): return fs.b1.v[m.time.first(), x] == fs.v0[x] # will be consistent disc = TransformationFactory('dae.collocation') disc.apply_to(m, wrt=m.time, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') disc.apply_to(m, wrt=m.space, nfe=5, ncp=2, scheme='LAGRANGE-RADAU') return m
def test_nonlinear_error(self): m = ConcreteModel() m.x = Var() m.cons = Constraint(expr=m.x**2 >= 2) m.cons2 = Constraint(expr=m.x <= 10) self.assertRaisesRegexp( RuntimeError, "Variable x appears in a nonlinear " "constraint. The Fourier-Motzkin " "Elimination transformation can only " "be used to eliminate variables " "which only appear linearly.", TransformationFactory('contrib.fourier_motzkin_elimination').\ apply_to, m, vars_to_eliminate=m.x)
def _apply_to(self, model, **kwds): """Fix all disjuncts in the given model and reclassify them to Blocks.""" config = self.config = self.CONFIG(kwds.pop('options', {})) config.set_value(kwds) self._transformContainer(model) # Reclassify all disjuncts for disjunct_object in model.component_objects(Disjunct, descend_into=(Block, Disjunct)): disjunct_object.parent_block().reclassify_component_type( disjunct_object, Block) # Transform any remaining logical stuff TransformationFactory('core.logical_to_linear').apply_to(model)
def test_bad_constraint_filtering_callback_error(self): m = self.makeModel() def not_a_callback(cons): raise RuntimeError("I don't know how to do my job.") fme = TransformationFactory('contrib.fourier_motzkin_elimination') log = StringIO() with LoggingIntercept(log, 'pyomo.contrib.fme', logging.ERROR): self.assertRaisesRegex( RuntimeError, "I don't know how to do my job.", fme.apply_to, m, vars_to_eliminate=m.x, constraint_filtering_callback=not_a_callback) self.assertRegex( log.getvalue(), "Problem calling constraint filter callback " "on constraint with right-hand side -1.0 and body:*")
def subproblem_solve(gdp, solver, config): subproblem = gdp.clone() TransformationFactory('gdp.fix_disjuncts').apply_to(subproblem) result = solver.solve(subproblem, **config.solver_args) main_obj = next( subproblem.component_data_objects(Objective, active=True)) obj_sign = 1 if main_obj.sense == minimize else -1 if (result.solver.status is SolverStatus.ok and result.solver.termination_condition is tc.optimal): return value( main_obj.expr), result, subproblem.GDPbb_utils.variable_list elif result.solver.termination_condition is tc.unbounded: return obj_sign * float( '-inf'), result, subproblem.GDPbb_utils.variable_list else: return obj_sign * float( 'inf'), result, subproblem.GDPbb_utils.variable_list
def test_noninteger_coefficients_of_vars_not_being_projected_error(self): m = ConcreteModel() m.x = Var(bounds=(0, 9)) m.y = Var(bounds=(-5, 5)) m.c1 = Constraint(expr=2 * m.x + 0.5 * m.y >= 2) m.c2 = Constraint(expr=0.25 * m.y >= 5 * m.x) fme = TransformationFactory('contrib.fourier_motzkin_elimination') self.assertRaisesRegexp( ValueError, "The do_integer_arithmetic flag was " "set to True, but the coefficient of " "y is non-integer within the specified tolerance, " "with value 0.5. \n" "Please set do_integer_arithmetic=" "False, increase integer_tolerance, or make your data integer.", fme.apply_to, m, vars_to_eliminate=m.x, do_integer_arithmetic=True)
def test_combine_three_inequalities_and_flatten_blocks(self): m = ConcreteModel() m.x = Var() m.y = Var() m.b = Block() m.b.c = Constraint(expr=m.x >= 2) m.c = Constraint(expr=m.y <= m.x) m.b.b2 = Block() m.b.b2.c = Constraint(expr=m.y >= 4) TransformationFactory('contrib.fourier_motzkin_elimination').apply_to( m, vars_to_eliminate=m.y) constraints = m._pyomo_contrib_fme_transformation.projected_constraints self.assertEqual(len(constraints), 2) cons = constraints[1] self.assertEqual(value(cons.lower), 2) self.assertIsNone(cons.upper) self.assertIs(cons.body, m.x) cons = constraints[2] self.assertEqual(value(cons.lower), 4) self.assertIsNone(cons.upper) self.assertIs(cons.body, m.x)
def test_post_processing(self): m, disaggregatedVars = self.create_hull_model() fme = TransformationFactory('contrib.fourier_motzkin_elimination') fme.apply_to(m, vars_to_eliminate=disaggregatedVars) # post-process fme.post_process_fme_constraints(m, SolverFactory('glpk')) constraints = m._pyomo_contrib_fme_transformation.projected_constraints self.assertEqual(len(constraints), 11) # They should be the same as the above, but now these are *all* the # constraints self.check_hull_projected_constraints( m, constraints, [6, 5, 16, 17, 15, 9, 8, 1, 2, 3, 4]) # and check that we didn't change the model for disj in m.component_data_objects(Disjunct): self.assertIs(disj.indicator_var.domain, Binary) self.assertEqual(len([o for o in m.component_data_objects(Objective)]), 1) self.assertIsInstance(m.component("obj"), Objective) self.assertTrue(m.obj.active)
def apply_discretization(self, transformation, **kwargs): """Discretizes the model. :param str transformation: The type of transformation (only dae.collocation...) :param dict kwargs: The options for the discretization :return: None """ fixed_times = kwargs.pop('fixed_times', None) if not self.model.alltime.get_discretization_info(): discretizer = TransformationFactory(transformation) if fixed_times == None: discretizer.apply_to(self.model, wrt=self.model.alltime, **kwargs) else: discretizer.apply_to(self.model, wrt=fixed_times, **kwargs) self._alltimes = sorted(self.model.alltime) self._n_alltimes = len(self._alltimes) # This needs to be looked at in more detail to see if it is still needed. #added for optional smoothing parameter with reading values from file CS: # if self._smoothparam_given: # dfps = pd.DataFrame(index=self.model.alltime, columns=self.model.smoothparameter_names) # for t in self.model.alltime: # if t not in self.model.allsmooth_times: # for points that are the same in original meas times and feed times # dfps.loc[t] = float(22.) #something that is not between 0 and 1 # else: # ps_dict_help = dict() # for p in self.model.smoothparameter_names: # ps_dict_help[t, p] = value(self.model.smooth_param_data[t, p]) # dfps.loc[t] = [ps_dict_help[t, p] for p in self.model.smoothparameter_names] # dfallps = dfps # dfallps.sort_index(inplace=True) # dfallps.index = dfallps.index.to_series().apply( # lambda x: np.round(x, 6)) # time from data rounded to 6 digits # dfallpsall = pd.DataFrame(index=self.model.alltime, columns=self.model.smoothparameter_names) # dfsmoothdata = pd.DataFrame(index=sorted(self.model.smooth_param_datatimes), columns=self.model.smoothparameter_names) # for t in self.model.smooth_param_datatimes: # dfsmoothdata.loc[t] = [value(self.model.smooth_param_data[t, p]) for p in self.model.smoothparameter_names] # for p in self.model.smoothparameter_names: # values = interpolate_trajectory(self.model.alltime, dfsmoothdata[p]) # for i, ti in enumerate(self.model.alltime): # if float(dfallps[p][ti]) > 1: # valueinterp=values[i] # dfallpsall[p][ti] = float(valueinterp) # else: # dfallpsall.loc[ti] = float(dfallps[p][ti]) self._default_initialization() # if hasattr(self.model, 'K'): # print('Scaling the parameters') # self.scale_parameters() else: print( '***WARNING: Model already discretized. Ignoring second discretization' )