def points0():
# see Ludtke pg. 173 for values.
fluid = dict(
n2=0.0318,
co2=0.0118,
methane=0.8737,
ethane=0.0545,
propane=0.0178,
ibutane=0.0032,
nbutane=0.0045,
ipentane=0.0011,
npentane=0.0009,
nhexane=0.0007,
)
suc = State.define(p=Q_(62.7, "bar"), T=Q_(31.2, "degC"), fluid=fluid)
disch = State.define(p=Q_(76.82, "bar"), T=Q_(48.2, "degC"), fluid=fluid)
disch1 = State.define(p=Q_(76.0, "bar"), T=Q_(48.0, "degC"), fluid=fluid)
p0 = Point(
suc=suc,
disch=disch,
flow_m=85.9,
speed=Q_(13971, "RPM"),
b=Q_(44.2, "mm"),
D=0.318,
)
p1 = Point(
suc=suc,
disch=disch1,
flow_m=86.9,
speed=Q_(13971, "RPM"),
b=Q_(44.2, "mm"),
D=0.318,
)
return p0, p1
def load(cls, file_name):
with open(file_name) as f:
parameters = toml.load(f)
return cls([
Point(**Point._dict_from_load(kwargs))
for kwargs in parameters.values()
])
def load(cls, file):
"""Load impeller from toml file.
Parameters
----------
file : str or pathlib.Path
Filename to which the data is saved.
Returns
-------
impeller : ccp.Impeller
Impeller object.
"""
parameters = toml.load(file)
points = [
Point(**Point._dict_from_load(kwargs))
for kwargs in parameters.values()
]
return cls(points)
def point(self, flow_v=None, flow_m=None, speed=None):
"""Calculate specific point in the performance map.
Given a volumetric flow and a speed this method will calculate a point in the
impeller map according to these arguments.
Parameters
----------
flow_v : pint.Quantity, float
Volumetric flow (m³/s).
flow_m : pint.Quantity, float
Mass flow (kg/s).
speed : pint.Quantity, float
Speed (rad/s).
Returns
-------
point : ccp.Point
Point in the performance map.
"""
current_curve = self.curve(speed)
if flow_m:
flow_v = current_curve.points[0].suc.v() * flow_m
func_T = interp1d(current_curve.flow_v.m,
current_curve.disch.T().m,
fill_value="extrapolate")
func_p = interp1d(current_curve.flow_v.m,
current_curve.disch.p().m,
fill_value="extrapolate")
min_flow_v = min(current_curve.flow_v)
max_flow_v = max(current_curve.flow_v)
if flow_v < min_flow_v or max_flow_v < flow_v:
warnings.warn(
f"Expected point is being extrapolated.\n"
f"Interpolation limits: {min_flow_v:.3f~P} ~ {max_flow_v:.3f~P}\n"
f"Expected point flow: {flow_v:.3f~P}")
disch_T = func_T(flow_v)
disch_p = func_p(flow_v)
p0 = self.points[0]
disch = State.define(p=disch_p, T=disch_T, fluid=p0.suc.fluid)
point = Point(suc=p0.suc,
disch=disch,
flow_v=flow_v,
speed=speed,
b=p0.b,
D=p0.D)
return point
def imp1():
fluid = dict(
methane=0.69945,
ethane=0.09729,
propane=0.0557,
nbutane=0.0178,
ibutane=0.0102,
npentane=0.0039,
ipentane=0.0036,
nhexane=0.0018,
n2=0.0149,
co2=0.09259,
h2s=0.00017,
water=0.002,
)
suc = State.define(p=Q_(1.6995, "MPa"), T=311.55, fluid=fluid)
p0 = Point(
suc=suc,
flow_v=Q_(6501.67, "m**3/h"),
speed=Q_(11145, "RPM"),
head=Q_(179.275, "kJ/kg"),
eff=0.826357,
b=Q_(28.5, "mm"),
D=Q_(365, "mm"),
)
p1 = Point(
suc=suc,
flow_v=Q_(7016.72, "m**3/h"),
speed=Q_(11145, "RPM"),
head=Q_(173.057, "kJ/kg"),
eff=0.834625,
b=Q_(28.5, "mm"),
D=Q_(365, "mm"),
)
imp1 = Impeller([p0, p1])
return imp1
def convert_from(cls,
original_impeller,
suc=None,
find="speed",
speed=None):
"""Convert performance map from an impeller.
Parameters
----------
original_impeller : ccp.Impeller
The original impeller.
suc : ccp.State
The new suction condition to which we want to convert to.
find : str, optional
The method in which the curves will be converted.
For now only 'speed' is implemented, which means that, based on volume ratio,
we calculate new values of speed for each curve and the respective discharge
condition.
speed : float, pint.Quantity, optional
Desired speed. If find="speed", this should be None.
Returns
-------
converted_impeller : ccp.Impeller
The new impeller with the converted performance map for the required
suction condition.
"""
all_converted_points = []
for curve in original_impeller.curves:
with multiprocessing.Pool() as pool:
converter_args = [(p, suc, find) for p in curve]
converted_points = pool.map(converter, converter_args)
if speed is None:
speed_mean = np.mean(
[p.speed.magnitude for p in converted_points])
converted_points = [
Point.convert_from(
p,
suc=p.suc,
find="volume_ratio",
speed=speed_mean,
) for p in converted_points
]
all_converted_points += converted_points
return cls(all_converted_points)
def imp2():
points = [
Point(
suc=State.define(p=Q_("100663 Pa"), T=Q_("305 K"), fluid={"AIR": 1.00000}),
speed=Q_("1263 rad/s"),
flow_v=Q_("1.15 m³/s"),
head=Q_("147634 J/kg"),
eff=Q_("0.819"),
b=0.010745,
D=0.32560,
),
Point(
suc=State.define(p=Q_("100663 Pa"), T=Q_("305 K"), fluid={"AIR": 1.00000}),
speed=Q_("1263 rad/s"),
flow_v=Q_("1.26 m³/s"),
head=Q_("144664 J/kg"),
eff=Q_("0.829"),
b=0.010745,
D=0.32560,
),
Point(
suc=State.define(p=Q_("100663 Pa"), T=Q_("305 K"), fluid={"AIR": 1.00000}),
speed=Q_("1263 rad/s"),
flow_v=Q_("1.36 m³/s"),
head=Q_("139945 J/kg"),
eff=Q_("0.831"),
b=0.010745,
D=0.32560,
),
Point(
suc=State.define(p=Q_("100663 Pa"), T=Q_("305 K"), fluid={"AIR": 1.00000}),
speed=Q_("1337 rad/s"),
flow_v=Q_("1.22 m³/s"),
head=Q_("166686 J/kg"),
eff=Q_("0.814"),
b=0.010745,
D=0.32560,
),
Point(
suc=State.define(p=Q_("100663 Pa"), T=Q_("305 K"), fluid={"AIR": 1.00000}),
speed=Q_("1337 rad/s"),
flow_v=Q_("1.35 m³/s"),
head=Q_("163620 J/kg"),
eff=Q_("0.825"),
b=0.010745,
D=0.32560,
),
Point(
suc=State.define(p=Q_("100663 Pa"), T=Q_("305 K"), fluid={"AIR": 1.00000}),
speed=Q_("1337 rad/s"),
flow_v=Q_("1.48 m³/s"),
head=Q_("158536 J/kg"),
eff=Q_("0.830"),
b=0.010745,
D=0.32560,
),
]
imp2 = Impeller(points)
return imp2
def create_points_parallel(x):
"""Helper function used to parallelize creation of points."""
return Point(**x)
def converter(x):
"""Helper function used to parallelize conversion of points."""
point, suc, find = x
return Point.convert_from(point, suc=suc, find=find)
def curve(self, speed=None):
"""Calculate specific point in the performance map.
Given a speed this method will calculate a curve in the
impeller map according to these arguments.
Parameters
----------
speed : pint.Quantity, float
Speed (rad/s).
Returns
-------
curve : ccp.Curve
Point in the performance map.
"""
speeds = np.array([curve.speed.magnitude for curve in self.curves])
closest_curves_idxs = find_closest_speeds(speeds, speed.magnitude)
curves = [
self.curves[closest_curves_idxs[0]],
self.curves[closest_curves_idxs[1]],
]
# calculate factor
speed_range = curves[1].speed.magnitude - curves[0].speed.magnitude
factor = (speed.magnitude - curves[0].speed.magnitude) / speed_range
current_curve = []
p0 = self.points[0]
number_of_points = len(curves[0])
for i in range(number_of_points):
flow_T, disch_T = get_interpolated_values(
factor,
curves[0].flow_v.magnitude[i],
curves[0][i].disch.T().m,
curves[1].flow_v.magnitude[i],
curves[1][i].disch.T().m,
)
flow_p, disch_p = get_interpolated_values(
factor,
curves[0].flow_v.magnitude[i],
curves[0][i].disch.p().m,
curves[1].flow_v.magnitude[i],
curves[1][i].disch.p().m,
)
disch = State.define(p=disch_p, T=disch_T, fluid=p0.suc.fluid)
p = Point(
suc=p0.suc,
disch=disch,
flow_v=(flow_T + flow_p) / 2,
speed=speed,
b=p0.b,
D=p0.D,
)
current_curve.append(p)
current_curve = Curve(current_curve)
return current_curve