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