def calculate_chemical_scaling_factors_for_material_balances(unit): # Next, try adding scaling for species min = 1e-3 for i in unit.control_volume.properties_out[0.0].mole_frac_phase_comp: # i[0] = phase, i[1] = species if unit.inlet.mole_frac_comp[0, i[1]].value > min: scale = unit.inlet.mole_frac_comp[0, i[1]].value else: scale = min iscale.set_scaling_factor( unit.control_volume.properties_out[0.0].mole_frac_comp[i[1]], 10 / scale) iscale.set_scaling_factor( unit.control_volume.properties_out[0.0].mole_frac_phase_comp[i], 10 / scale) iscale.set_scaling_factor( unit.control_volume.properties_out[0.0].flow_mol_phase_comp[i], 10 / scale) iscale.constraint_scaling_transform( unit.control_volume.properties_out[0.0].component_flow_balances[ i[1]], 10 / scale, ) iscale.constraint_scaling_transform( unit.control_volume.material_balances[0.0, i[1]], 10 / scale)
def calculate_chemical_scaling_factors_for_energy_balances(unit): max = 1 min = 1 try: for phase in unit.control_volume.properties_in[0.0].enth_mol_phase: val = abs( value(unit.control_volume.properties_in[0.0]. enth_mol_phase[phase].expr)) if val >= max: max = val if val <= min: val = min iscale.set_scaling_factor( unit.control_volume.properties_in[0.0]. _enthalpy_flow_term[phase], 10 / val, ) iscale.set_scaling_factor( unit.control_volume.properties_out[0.0]. _enthalpy_flow_term[phase], 10 / val, ) iscale.constraint_scaling_transform( unit.control_volume.enthalpy_balances[0.0], 10 / max) except: pass
def calculate_scaling_factors(self): super().calculate_scaling_factors() for ind, c in self.control_volume.isothermal_balance.items(): sf = iscale.get_scaling_factor( self.control_volume.properties_in[0].temperature) iscale.constraint_scaling_transform(c, sf)
def calculate_scaling_factors(self): if hasattr(self, "mixer_pressure_constraint"): for t, c in self.mixer_pressure_constraint.items(): sf = iscale.get_scaling_factor(self.steam_state[t].pressure, default=1, warning=True) iscale.constraint_scaling_transform(c, sf)
def scale_pretreatment_NF(m, **kwargs): calculate_scaling_factors(m.fs.feed) calculate_scaling_factors(m.fs.NF) if kwargs["has_bypass"]: calculate_scaling_factors(m.fs.splitter) set_scaling_factor( m.fs.splitter.split_fraction, 1 ) # TODO: should have an IDAES default constraint_scaling_transform( m.fs.splitter.sum_split_frac[0], 1 ) # TODO: should have an IDAES default calculate_scaling_factors(m.fs.mixer) set_scaling_factor( m.fs.mixer.minimum_pressure, get_scaling_factor(m.fs.mixer.mixed_state[0].pressure), ) # TODO: IDAES should have a default and link to the constraint for c in [ m.fs.mixer.minimum_pressure_constraint[0, 1], m.fs.mixer.minimum_pressure_constraint[0, 2], m.fs.mixer.mixture_pressure[0.0], ]: constraint_scaling_transform( c, get_scaling_factor(m.fs.mixer.minimum_pressure) ) if kwargs["NF_type"] == "ZO": set_scaling_factor(m.fs.pump_NF.control_volume.work, 1e-3) calculate_scaling_factors(m.fs.pump_NF) set_scaling_factor( m.fs.pump_NF.ratioP, 1 ) # TODO: IDAES should have a default and link to the constraint
def build_ZONF(m, base='ion'): """ Builds a ZONF model based on specified rejection and solvent flux. Requires prop_ion property package. """ if base not in ['ion']: raise ValueError('Unexpected property base {base} for build_ZONF' ''.format(base=base)) prop = property_models.get_prop(m, base=base) m.fs.NF = NanofiltrationZO(default={ "property_package": prop, "has_pressure_change": False }) # specify m.fs.NF.flux_vol_solvent.fix(1.67e-6) m.fs.NF.area.fix(500) m.fs.NF.properties_permeate[0].pressure.fix(101325) m.fs.NF.rejection_phase_comp[0, 'Liq', 'Na'].fix(0.01) m.fs.NF.rejection_phase_comp[0, 'Liq', 'Ca'].fix(0.79) m.fs.NF.rejection_phase_comp[0, 'Liq', 'Mg'].fix(0.94) m.fs.NF.rejection_phase_comp[0, 'Liq', 'SO4'].fix(0.87) m.fs.NF.rejection_phase_comp[ 0, 'Liq', 'Cl'] = 0.15 # guess, but electroneutrality enforced below charge_comp = {'Na': 1, 'Ca': 2, 'Mg': 2, 'SO4': -2, 'Cl': -1} m.fs.NF.eq_electroneutrality = Constraint(expr=0 == sum( charge_comp[j] * m.fs.NF.feed_side.properties_out[0].conc_mol_phase_comp['Liq', j] for j in charge_comp)) constraint_scaling_transform(m.fs.NF.eq_electroneutrality, 1)
def set_scaling_factors(m): """ Set scaling factors for variables and expressions. These are used for variable scaling and used by the framework to scale constraints. Args: m: plant model to set scaling factors for. Returns: None """ # Set scaling factors for boiler system iscale.set_scaling_factor(m.fs.tank.control_volume.energy_holdup, 1e-10) iscale.set_scaling_factor(m.fs.tank.control_volume.material_holdup, 1e-6) if m.dynamic: for t, c in m.fs.tank.control_volume\ .energy_accumulation_disc_eq.items(): iscale.constraint_scaling_transform(c, 1e-6) # scaling factor for control valves for t in m.fs.config.time: iscale.set_scaling_factor( m.fs.valve.control_volume.properties_in[t].flow_mol, 0.001) # Calculate calculated scaling factors iscale.calculate_scaling_factors(m)
def simulate_enrtl_FpcTP(state_var_args): m = ConcreteModel() m.fs = FlowsheetBlock(default={"dynamic": False}) m.fs.params = GenericParameterBlock( default=entrl_config_FpcTP.configuration) m.fs.state = m.fs.params.build_state_block(m.fs.time, default={"defined_state": True}) for (v_name, ind), val in state_var_args.items(): var = getattr(m.fs.state[0], v_name) var[ind].fix(val) # scale model calculate_scaling_factors(m) for (ind, c) in m.fs.state[0].true_to_appr_species.items(): sf = get_scaling_factor( m.fs.state[0].flow_mol_phase_comp_apparent[ind]) constraint_scaling_transform(c, sf) for (ind, c) in m.fs.state[0].appr_mole_frac_constraint.items(): sf = get_scaling_factor( m.fs.state[0].mole_frac_phase_comp_apparent[ind]) constraint_scaling_transform(c, sf) check_scaling(m) solve_block(m) ksp = 3.2e-9 # Gibbs energy gives 3.9e-8, but this fits expectations better saturation_index = value(m.fs.state[0].act_phase_comp["Liq", "Ca_2+"] * m.fs.state[0].act_phase_comp["Liq", "SO4_2-"] * m.fs.state[0].act_phase_comp["Liq", "H2O"]**2 / ksp) return saturation_index
def calculate_scaling_factors(self): super().calculate_scaling_factors() iscale.set_scaling_factor(self.pressure_ratio, 1) iscale.set_scaling_factor(self.efficiency, 1) for j, c in self.eq_mass_balance_isentropic.items(): sf = iscale.get_scaling_factor( self.control_volume.properties_in[0].flow_mass_phase_comp[ j, "H2O"]) iscale.constraint_scaling_transform(c, sf) # Pressure constraints sf = iscale.get_scaling_factor( self.control_volume.properties_in[0].pressure) iscale.constraint_scaling_transform(self.eq_pressure_ratio, sf) iscale.constraint_scaling_transform(self.eq_isentropic_pressure, sf) # Temperature constraint sf = iscale.get_scaling_factor( self.control_volume.properties_in[0].temperature) iscale.constraint_scaling_transform(self.eq_isentropic_temperature, sf) # Efficiency, work constraints sf = iscale.get_scaling_factor(self.control_volume.work) iscale.constraint_scaling_transform(self.eq_efficiency, sf)
def build_SepRO(m, base="TDS"): """ Builds RO model based on the IDAES separator. Requires prop_TDS property package. """ prop = property_models.get_prop(m, base=base) m.fs.RO = Separator( default={ "property_package": prop, "outlet_list": ["retentate", "permeate"], "split_basis": SplittingType.componentFlow, "energy_split_basis": EnergySplittingType.equal_temperature, } ) # specify if base == "TDS": m.fs.RO.split_fraction[0, "permeate", "H2O"].fix(0.5) m.fs.RO.split_fraction[0, "permeate", "TDS"].fix(0.01) else: raise ValueError( "Unexpected property base {base} provided to build_SepRO" "".format(base=base) ) # scale set_scaling_factor( m.fs.RO.split_fraction, 1 ) # TODO: IDAES should set these scaling factors by default constraint_scaling_transform(m.fs.RO.sum_split_frac[0.0, "H2O"], 1) constraint_scaling_transform(m.fs.RO.sum_split_frac[0.0, "TDS"], 1)
def scale_temperature_bubble(b, overwrite=True): sf_P = iscale.get_scaling_factor(b.pressure, default=1e-5, warning=True) sf_mf = iscale.get_scaling_factor(b.mole_frac_comp, default=1e3, warning=True) for pp in b.params._pe_pairs: for j in b.component_list: (l_phase, v_phase, vl_comps, henry_comps, l_only_comps, v_only_comps) = _valid_VL_component_list(b, pp) if l_phase is None or v_phase is None: continue elif v_only_comps != []: continue if j in vl_comps: sf = sf_P * sf_mf else: sf = sf_mf iscale.constraint_scaling_transform( b.eq_temperature_bubble[pp[0], pp[1]], sf_P, overwrite=overwrite) iscale.constraint_scaling_transform(b.eq_mole_frac_tbub[pp[0], pp[1], j], sf, overwrite=overwrite)
def scale_pressure_dew(b): sf_P = iscale.get_scaling_factor(b.pressure, default=1e-5, warning=True) sf_mf = iscale.get_scaling_factor(b.mole_frac_comp, default=1e3, warning=True) for pp in b.params._pe_pairs: for j in b.component_list: (l_phase, v_phase, vl_comps, l_only_comps, v_only_comps) = _valid_VL_component_list(b, pp) if l_phase is None or v_phase is None: continue elif v_only_comps != []: continue if j in vl_comps: sf = sf_P * sf_mf else: sf = sf_mf # b.eq_pressure_dew is well-scaled by default iscale.constraint_scaling_transform( b.eq_mole_frac_pdew[pp[0], pp[1], j], sf)
def _set_mat_bal_scaling_FTPx(unit, min_mole_frac_comp=1e-3): # For species for i in unit.control_volume.properties_out[0.0].mole_frac_phase_comp: # i[0] = phase, i[1] = species scale = max(min_mole_frac_comp, unit.inlet.mole_frac_comp[0, i[1]].value) iscale.set_scaling_factor( unit.control_volume.properties_out[0.0].mole_frac_comp[i[1]], 10 / scale) iscale.set_scaling_factor( unit.control_volume.properties_out[0.0].mole_frac_phase_comp[i], 10 / scale) iscale.set_scaling_factor( unit.control_volume.properties_out[0.0].flow_mol_phase_comp[i], 10 / scale) iscale.constraint_scaling_transform( unit.control_volume.properties_out[0.0].component_flow_balances[ i[1]], 10 / scale, ) iscale.constraint_scaling_transform( unit.control_volume.material_balances[0.0, i[1]], 10 / scale) if hasattr(unit.control_volume, "volume"): iscale.set_scaling_factor(unit.control_volume.volume, 10 / unit.volume[0.0].value)
def scale_desalination(m, **kwargs): """ Scales the model created by build_desalination. Arguments: m: pyomo concrete model with a built desalination train **kwargs: same keywords as provided to the build_desalination function """ if kwargs["has_desal_feed"]: calculate_scaling_factors(m.fs.feed) if kwargs["RO_type"] == "1D": set_scaling_factor(m.fs.RO.feed_side.area, 1e3) set_scaling_factor(m.fs.RO.area, 1e-1) set_scaling_factor(m.fs.RO.width, 1) calculate_scaling_factors(m.fs.RO) if kwargs["is_twostage"]: if kwargs["RO_type"] == "1D": set_scaling_factor(m.fs.RO2.feed_side.area, 1e3) set_scaling_factor(m.fs.RO2.area, 1e-1) set_scaling_factor(m.fs.RO2.width, 1) calculate_scaling_factors(m.fs.RO2) if kwargs["RO_type"] == "0D" or kwargs["RO_type"] == "1D": set_scaling_factor(m.fs.pump_RO.control_volume.work, 1e-3) calculate_scaling_factors(m.fs.pump_RO) set_scaling_factor( m.fs.pump_RO.ratioP, 1) # TODO: IDAES should have a default and link to the constraint if kwargs["is_twostage"]: set_scaling_factor(m.fs.pump_RO2.control_volume.work, 1e-3) calculate_scaling_factors(m.fs.pump_RO2) set_scaling_factor( m.fs.pump_RO2.ratioP, 1 ) # TODO: IDAES should have a default and link to the constraint calculate_scaling_factors(m.fs.mixer_permeate) set_scaling_factor( m.fs.mixer_permeate.minimum_pressure, get_scaling_factor( m.fs.mixer_permeate.mixed_state[0].pressure), ) # TODO: IDAES should have a default and link to the constraint for c in [ m.fs.mixer_permeate.minimum_pressure_constraint[0, 1], m.fs.mixer_permeate.minimum_pressure_constraint[0, 2], m.fs.mixer_permeate.mixture_pressure[0.0], ]: constraint_scaling_transform( c, get_scaling_factor(m.fs.mixer_permeate.minimum_pressure)) if kwargs["has_ERD"]: set_scaling_factor(m.fs.ERD.control_volume.work, 1e-3) set_scaling_factor( m.fs.ERD.ratioP, 1) # TODO: IDAES should have a default and link to the constraint calculate_scaling_factors(m.fs.ERD)
def calculate_scaling_factors(self): super().calculate_scaling_factors() for (t, j), c in self.control_volume.mass_balance.items(): sf = iscale.get_scaling_factor( self.control_volume.properties_in[t].flow_mass_phase_comp[ "Vap", j]) iscale.constraint_scaling_transform(c, sf)
def calculate_scaling_factors(self): super().calculate_scaling_factors() if self.is_property_constructed("sum_component_eqn"): iscale.constraint_scaling_transform( self.sum_component_eqn, iscale.get_scaling_factor(self.mole_frac_comp['Fe2O3']), overwrite=False)
def calculate_scaling_factors(self): super().calculate_scaling_factors() for t, c in self.pressure_flow_equation.items(): s = iscale.get_scaling_factor( self.control_volume.properties_in[t].flow_mol) s = s**2 iscale.constraint_scaling_transform(c, s, overwrite=False)
def calculate_scaling_factors(self): super().calculate_scaling_factors() for t, c in self.stodola_equation.items(): s = iscale.get_scaling_factor( self.control_volume.properties_in[t].flow_mol, default=1, warning=True)**2 iscale.constraint_scaling_transform(c, s)
def scale_costing(self): for b_unit in self.component_objects(Block, descend_into=True): if hasattr(b_unit, "costing"): base = b_unit.costing for var in base.component_objects(Var): if iscale.get_scaling_factor(var) is None: iscale.set_scaling_factor(var, 1e-3) for con in base.component_data_objects(Constraint): iscale.constraint_scaling_transform(con, 1e-3)
def _apparent_species_scaling(b): for p, j in b.params.true_phase_component_set: sf = iscale.get_scaling_factor(b.flow_mol_phase_comp_true[p, j], default=1, warning=True) iscale.constraint_scaling_transform(b.appr_to_true_species[p, j], sf) iscale.constraint_scaling_transform(b.true_mole_frac_constraint[p, j], sf)
def calculate_scaling_factors(b): for p, j in b.phase_component_set: sf = iscale.get_scaling_factor(b.flow_mol_phase_comp[ p, j], default=1, warning=True) iscale.constraint_scaling_transform( b.mole_frac_phase_comp_eq[p, j], sf, overwrite=False) if b.params._electrolyte: calculate_electrolyte_scaling(b)
def calculate_scaling_factors(self): super().calculate_scaling_factors() for i, c in self.tube_heat_transfer_eq.items(): iscale.constraint_scaling_transform( c, iscale.get_scaling_factor(self.tube.heat[i], default=1, warning=True))
def test_greater_than_constraint(self, model): sc.constraint_scaling_transform(model.c3, 1e-3) assert sc.get_scaling_factor(model.c3) == None assert model.c3.lower.value == pytest.approx(1) assert model.c3.body() == pytest.approx(model.x.value / 1e3) assert model.c3.upper is None sc.constraint_scaling_transform_undo(model.c3) assert model.c3.lower.value == pytest.approx(1e3) assert model.c3.body() == pytest.approx(model.x.value)
def calculate_scaling_factors(self): super().calculate_scaling_factors() mb_type = self.config.material_balance_type if mb_type == MaterialBalanceType.useDefault: t_ref = self.flowsheet().time.first() mb_type = self.mixed_state[t_ref].default_material_balance_type() if hasattr(self, "pressure_equality_constraints"): for (t, i), c in self.pressure_equality_constraints.items(): s = iscale.get_scaling_factor(self.mixed_state[t].pressure, default=1, warning=True) iscale.constraint_scaling_transform(c, s) if hasattr(self, "material_mixing_equations"): if mb_type == MaterialBalanceType.componentPhase: for (t, p, j), c in self.material_mixing_equations.items(): flow_term = self.mixed_state[t].get_material_flow_terms( p, j) s = iscale.get_scaling_factor(flow_term, default=1) iscale.constraint_scaling_transform(c, s, overwrite=False) elif mb_type == MaterialBalanceType.componentTotal: for (t, j), c in self.material_mixing_equations.items(): for i, p in enumerate(self.mixed_state.phase_list): try: ft = self.mixed_state[t].get_material_flow_terms( p, j) except (KeyError, AttributeError): continue # component not in phase if i == 0: s = iscale.get_scaling_factor(ft, default=1) else: _s = iscale.get_scaling_factor(ft, default=1) s = _s if _s < s else s iscale.constraint_scaling_transform(c, s, overwrite=False) elif mb_type == MaterialBalanceType.total: pc_set = self.mixed_state.phase_component_set for t, c in self.material_mixing_equations.items(): for i, (p, j) in enumerate(pc_set): ft = self.mixed_state[t].get_material_flow_terms(p, j) if i == 0: s = iscale.get_scaling_factor(ft, default=1) else: _s = iscale.get_scaling_factor(ft, default=1) s = _s if _s < s else s iscale.constraint_scaling_transform(c, s, overwrite=False) if hasattr(self, "enthalpy_mixing_equations"): for t, c in self.enthalpy_mixing_equations.items(): def scale_gen(): for v in self.mixed_state[t].phase_list: yield self.mixed_state[t].get_enthalpy_flow_terms(p) s = iscale.min_scaling_factor(scale_gen(), default=1) iscale.constraint_scaling_transform(c, s, overwrite=False)
def calculate_scaling_factors(self): super().calculate_scaling_factors() for t, c in self.eq_pressure_ratio.items(): s = iscale.get_scaling_factor( self.control_volume.properties_in[t].pressure) iscale.constraint_scaling_transform(c, s, overwrite=False) for t, c in self.eq_work.items(): s = iscale.get_scaling_factor(self.control_volume.work[t]) iscale.constraint_scaling_transform(c, s, overwrite=False)
def calculate_chemical_scaling_factors_for_equilibrium_log_reactions(unit, rxn_params): try: for i in unit.control_volume.equilibrium_reaction_extent_index: if i[1] != "dummy": scale = value(unit.control_volume.reactions[0.0].k_eq[i[1]].expr) iscale.set_scaling_factor(unit.control_volume.equilibrium_reaction_extent[0.0,i[1]], 10/scale) iscale.constraint_scaling_transform(unit.control_volume.reactions[0.0]. equilibrium_constraint[i[1]], 0.1) except: pass
def calculate_scaling_factors(self): # set a default Reynolds number scaling for v in self.N_Re.values(): if iscale.get_scaling_factor(v, warning=True) is None: iscale.set_scaling_factor(v, 1e-4) for v in self.friction_factor_darcy.values(): if iscale.get_scaling_factor(v, warning=True) is None: iscale.set_scaling_factor(v, 100) for v in self.deltaP_gravity.values(): if iscale.get_scaling_factor(v, warning=True) is None: iscale.set_scaling_factor(v, 1e-3) for v in self.deltaP_friction.values(): if iscale.get_scaling_factor(v, warning=True) is None: iscale.set_scaling_factor(v, 1e-3) for t, c in self.volume_eqn.items(): sf = iscale.get_scaling_factor(self.volume[t], default=1, warning=True) iscale.constraint_scaling_transform(c, sf, overwrite=False) for t, c in self.Reynolds_number_eqn.items(): sf = iscale.get_scaling_factor(self.N_Re[t], default=1, warning=True) sf *= iscale.get_scaling_factor( self.control_volume.properties_in[t].visc_d_phase["Liq"], default=1, warning=True) iscale.constraint_scaling_transform(c, sf, overwrite=False) for t, c in self.pressure_change_friction_eqn.items(): sf = iscale.get_scaling_factor(self.deltaP_friction[t], default=1, warning=True) iscale.constraint_scaling_transform(c, sf, overwrite=False) for t, c in self.pressure_change_gravity_eqn.items(): sf = iscale.get_scaling_factor(self.deltaP_gravity[t], default=1, warning=True) iscale.constraint_scaling_transform(c, sf, overwrite=False) for t, c in self.pressure_change_total_eqn.items(): sf = iscale.get_scaling_factor(self.deltaP[t], default=1, warning=True) iscale.constraint_scaling_transform(c, sf, overwrite=False)
def calculate_scaling_factors(b, phase_pair): suffix = "_" + phase_pair[0] + "_" + phase_pair[1] sf_T = iscale.get_scaling_factor(b.temperature, default=1, warning=True) try: _t1 = getattr(b, "_t1" + suffix) _t1_cons = getattr(b, "_t1_constraint" + suffix) iscale.set_scaling_factor(_t1, sf_T) iscale.constraint_scaling_transform(_t1_cons, sf_T) except AttributeError: pass _teq_cons = getattr(b, "_teq_constraint" + suffix) iscale.constraint_scaling_transform(_teq_cons, sf_T)
def calculate_scaling_factors(self): # Get default scale factors and do calculations from base classes super().calculate_scaling_factors() # Lock attribute creation to avoid hasattr triggering builds self._lock_attribute_creation = True # Due to the exponential relationship between most reaction properties # and temeprature, it is very hard to calculate good scaling factors # from order-of-magnitude guesses. Thus ,reaction scaling will always # require a lot of user input. Here we will calculate scaling factors # for those properties that have non-exponential relationships to T. if hasattr(self, "dh_rxn"): for r, v in self.dh_rxn.items(): if iscale.get_scaling_factor(v) is None: rblock = getattr(self.params, "reaction_" + r) try: carg = self.params.config.rate_reactions[r] except (AttributeError, KeyError): carg = self.params.config.equilibrium_reactions[r] sf = carg["heat_of_reaction"].calculate_scaling_factors( self, rblock) iscale.set_scaling_factor(v, sf) if hasattr(self, "k_eq"): for r, v in self.k_eq.items(): if iscale.get_scaling_factor(v) is None: rblock = getattr(self.params, "reaction_" + r) carg = self.params.config.equilibrium_reactions[r] sf = carg[ "equilibrium_constant"].calculate_scaling_factors( self, rblock) iscale.set_scaling_factor(v, sf) if hasattr(self, "equilibrium_constraint"): for r, v in self.equilibrium_constraint.items(): if iscale.get_scaling_factor(v) is None: sf = iscale.get_scaling_factor(self.k_eq[r], default=1, warning=True) sf_const = carg["equilibrium_form"].calculate_scaling_factors( self, sf) iscale.constraint_scaling_transform(v, sf_const, overwrite=False) # Unlock attribute creation when done self._lock_attribute_creation = False
def calculate_scaling_factors(self): super().calculate_scaling_factors() for v in self.N_Re.values(): if iscale.get_scaling_factor(v, warning=True) is None: iscale.set_scaling_factor(v, 1e-6) for t, c in self.Reynolds_number_eqn.items(): s = iscale.get_scaling_factor(self.N_Re[t], default=1, warning=True) iscale.constraint_scaling_transform(c, s * 1e5, overwrite=False) for t, c in self.heat_flux_conv_eqn.items(): s = iscale.get_scaling_factor(self.heat_flux_conv[t], default=1, warning=True) iscale.constraint_scaling_transform(c, s, overwrite=False) for t, c in self.hconv_eqn.items(): s = iscale.get_scaling_factor(self.hconv[t], default=1, warning=True) s *= iscale.get_scaling_factor(self.diameter_in, default=1, warning=True) iscale.constraint_scaling_transform(c, s, overwrite=False) for t, c in self.pressure_change_eqn.items(): s = iscale.get_scaling_factor(self.deltaP[t], default=1, warning=True) s *= iscale.get_scaling_factor(self.diameter_in, default=1, warning=True) iscale.constraint_scaling_transform(c, s, overwrite=False)