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)
