def test_piping(): P1 = nearest_pipe(Di=0.021) assert_close1d(P1, (1, 0.02664, 0.0334, 0.0033799999999999998)) P2 = nearest_pipe(Do=.273, schedule='5S') assert_close1d(P2, (10, 0.26630000000000004, 0.2731, 0.0034)) ans_str = nearest_pipe(Do=0.5, schedule='80') ans_int = nearest_pipe(Do=0.5, schedule=80) ans_float = nearest_pipe(Do=0.5, schedule=80.0) ans_expect = (20, 0.45562, 0.508, 0.02619) assert_close1d(ans_str, ans_expect) assert_close1d(ans_str, ans_int) assert_close1d(ans_str, ans_float)
def calculate(doc_original): doc = deepcopy(doc_original) treeUnitConvert(doc, doc['units'], SI_UNITS) doc['errors'] = [] calculation_option = doc['input']['calculation_option']['_val'] try: if (calculation_option == 'NPS'): NPS = parseFloat(doc['input']['NPS']['_val']) Schedule = doc['input']['Schedule']['_val'] nps, di, do, t = nearest_pipe(NPS=NPS, schedule=Schedule) if (calculation_option == 'Di'): Di = parseFloat(doc['input']['Di']['_val']) Schedule = doc['input']['Schedule']['_val'] nps, di, do, t = nearest_pipe(Di=Di, schedule=Schedule) if (calculation_option == 'Do'): Do = parseFloat(doc['input']['Do']['_val']) Schedule = doc['input']['Schedule']['_val'] nps, di, do, t = nearest_pipe(Do=Do, schedule=Schedule) except Exception as e: doc['errors'].append(str(e)) nps = math.nan di = math.nan do = math.nan t = math.nan doc['result'].update({'NPS': {'_val': str(roundit(nps))}}) doc['result'].update({'Di': {'_val': str(roundit(di)), '_dim': 'length'}}) doc['result'].update({'Do': {'_val': str(roundit(do)), '_dim': 'length'}}) doc['result'].update({'t': {'_val': str(roundit(t)), '_dim': 'length'}}) treeUnitConvert(doc, SI_UNITS, doc['units'], autoRoundOff=True) doc_original['result'].update(doc['result']) doc_original['errors'] = doc['errors'] return True
def calculate(doc_original): doc = deepcopy(doc_original) treeUnitConvert(doc, doc['units'], SI_UNITS) K_pipe = 0 K_fittings = 0 K_entry = 0 K_exit = 0 K_fixed = 0 K_LbyD = 0 K_total = 0 LbyD_total = 0 deltaP_fixed = 0 deltaP_total = 0 size_definition = doc['input']['pipe']['size_definition']['_val'] if (size_definition == "NPS"): nps = float(doc['input']['pipe']['NPS']['_val']) schedule = doc['input']['pipe']['schedule']['_val'] NPS, Di, Do, t = nearest_pipe(NPS=nps, schedule=schedule) else: Di = float(doc['input']['pipe']['Dia_inner']['_val']) NPS = math.nan Do = math.nan t = math.nan doc['result'].update({'Di': {'_val': str(Di), '_dim': 'length_mili'}}) doc['result'].update({'Do': {'_val': str(Do), '_dim': 'length_mili'}}) doc['result'].update({'t': {'_val': str(t), '_dim': 'length_mili'}}) area = math.pi * pow(Di / 2, 2) Q = float(doc['input']['fluidData']['Q']['_val']) V = roundit(Q / area) doc['result'].update({'V': {'_val': str(V), '_dim': 'speed'}}) mu = float(doc['input']['fluidData']['mu']['_val']) rho = float(doc['input']['fluidData']['rho']['_val']) Re = roundit(Reynolds(V=V, D=Di, rho=rho, mu=mu)) doc['result'].update({'Re': {'_val': str(Re)}}) Hdyn = roundit(rho * pow(V, 2) / 2) doc['result'].update({'Hdyn': {'_val': str(Hdyn), '_dim': 'length'}}) #K calculation for straigth pipe roughness_basis = doc['input']['pipe']['roughness_basis']['_val'] if (roughness_basis == "Material"): material = doc['input']['pipe']['material']['_val'] roughness = get_roughness(material) else: roughness = float(doc['input']['pipe']['roughness']['_val']) eD = roughness / Di doc['result'].update({'eD': {'_val': str(eD)}}) fd = roundit(friction_factor(Re=Re, eD=eD, Method="Moody")) doc['result'].update({'fd_Moody': {'_val': str(fd)}}) length = float(doc['input']['pipe']['length']['_val']) K_pipe = roundit(K_from_f(fd=fd, L=length, D=Di)) doc['result'].update({'K_pipe': {'_val': str(K_pipe)}}) deltaP_pipe = roundit(dP_from_K(K_pipe, rho, V)) doc['result'].update( {'deltaP_pipe': { '_val': str(deltaP_pipe), '_dim': 'pressure' }}) #calculating pressure drop for entrance entry_type = doc['input']['entrance']['entry_type']['_val'] print('entry type is') print(entry_type) if entry_type == 'none': K_entry = 0 elif entry_type == 'Sharp': K_entry = fluids.fittings.entrance_sharp() elif entry_type == 'Rounded': Rc = float(doc['input']['entrance']['Rc']['_val']) K_entry = fluids.fittings.entrance_rounded(Di, Rc) elif entry_type == 'Angled': angle_radians = float(doc['input']['entrance']['angle']['_val']) angle = angle_radians * 57.2958 K_entry = fluids.fittings.entrance_angled(angle) elif entry_type == 'Projecting': wall_thickness = float( doc['input']['entrance']['wall_thickness']['_val']) K_entry = fluids.fittings.entrance_distance(Di, wall_thickness) K_entry = roundit(K_entry) doc['result'].update({'K_entry': {'_val': str(K_entry)}}) deltaP_entry = roundit(dP_from_K(K_entry, rho, V)) doc['result'].update( {'deltaP_entry': { '_val': str(deltaP_entry), '_dim': 'pressure' }}) #calculating pressure drop for exit exit_type = doc['input']['exit']['exit_type']['_val'] print('exit_type') print(exit_type) if (exit_type == 'Normal'): K_exit = exit_normal() else: K_exit = 0 K_exit = roundit(K_exit) doc['result'].update({'K_exit': {'_val': str(K_exit)}}) deltaP_exit = roundit(dP_from_K(K_exit, rho, V)) doc['result'].update( {'deltaP_exit': { '_val': str(deltaP_exit), '_dim': 'pressure' }}) #calculating pressure drop for fittings fittings_list = doc['input']['fittings'] for fitting in fittings_list: name = get_hooper_list()[fitting['index']] Di_inch = Di * 39.3701 K_fitting = Hooper2K(Di_inch, Re, name=name) K_fittings += K_fitting * fitting['quantity'] K_fittings = roundit(K_fittings) doc['result'].update({'K_fittings': {'_val': str(K_fittings)}}) deltaP_fittings = dP_from_K(K_fittings, rho, V) deltaP_fittings = roundit(deltaP_fittings) doc['result'].update({ 'deltaP_fittings': { '_val': str(deltaP_fittings), '_dim': 'pressure' } }) #calculating pressure drop for sharp contractions deltaP_contractions_sharp = 0 contractions_sharp = doc['input']['contractions_sharp']['_list'] for contraction in contractions_sharp: D1 = contraction['D1'] D2 = contraction['D2'] A2 = 3.1416 * (D2**2) / 4 V2 = Q / A2 K_contraction = fluids.fittings.contraction_sharp(D1, D2) deltaP = dP_from_K(K_contraction, rho, V2) deltaP_contractions_sharp += deltaP deltaP_contractions_sharp = roundit(deltaP_contractions_sharp) doc['result'].update({ 'deltaP_contractions_sharp': { '_val': str(deltaP_contractions_sharp), '_dim': 'pressure' } }) #calculating pressure drop for rounded contractions deltaP_contractions_rounded = 0 contractions_rounded = doc['input']['contractions_rounded']['_list'] for contraction in contractions_rounded: D1 = contraction['D1'] D2 = contraction['D2'] Rc = contraction['Rc'] A2 = 3.1416 * (D2**2) / 4 V2 = Q / A2 K_contraction = fluids.fittings.contraction_round(D1, D2, Rc) deltaP = dP_from_K(K_contraction, rho, V2) deltaP_contractions_rounded += deltaP deltaP_contractions_rounded = roundit(deltaP_contractions_rounded) doc['result'].update({ 'deltaP_contractions_rounded': { '_val': str(deltaP_contractions_rounded), '_dim': 'pressure' } }) #calculating pressure drop for conical contractions deltaP_contractions_conical = 0 contractions_conical = doc['input']['contractions_conical']['_list'] for contraction in contractions_conical: D1 = contraction['D1'] D2 = contraction['D2'] L = contraction['L'] A2 = 3.1416 * (D2**2) / 4 V2 = Q / A2 K_contraction = fluids.fittings.contraction_conical(D1, D2, fd=fd, l=L) deltaP = dP_from_K(K_contraction, rho, V2) deltaP_contractions_conical += deltaP deltaP_contractions_conical = roundit(deltaP_contractions_conical) doc['result'].update({ 'deltaP_contractions_conical': { '_val': str(deltaP_contractions_conical), '_dim': 'pressure' } }) #calculating pressure drop for pipe reducers contractions deltaP_contractions_reducer = 0 contractions_reducer = doc['input']['contractions_reducer']['_list'] for contraction in contractions_reducer: reducer_size = contraction['reducer_size'] D1, D2, L = reducer_dimensions(reducer_size) A2 = 3.1416 * (D2**2) / 4 V2 = Q / A2 K_contraction = fluids.fittings.contraction_conical(D1, D2, fd=fd, l=L) deltaP = dP_from_K(K_contraction, rho, V2) deltaP_contractions_reducer += deltaP deltaP_contractions_reducer = roundit(deltaP_contractions_reducer) doc['result'].update({ 'deltaP_contractions_reducer': { '_val': str(deltaP_contractions_reducer), '_dim': 'pressure' } }) # calculating total pressure drop in all contractions deltaP_contractions = deltaP_contractions_sharp + deltaP_contractions_rounded + deltaP_contractions_conical + deltaP_contractions_reducer deltaP_contractions = roundit(deltaP_contractions) doc['result'].update({ 'deltaP_contractions': { '_val': str(deltaP_contractions), '_dim': 'pressure' } }) #calculating pressure drop for sharp expansions deltaP_expansions_sharp = 0 expansions_sharp = doc['input']['expansions_sharp']['_list'] for contraction in expansions_sharp: D1 = contraction['D1'] D2 = contraction['D2'] A1 = 3.1416 * (D1**2) / 4 V1 = Q / A1 K_contraction = fluids.fittings.diffuser_sharp(D1, D2) deltaP = dP_from_K(K_contraction, rho, V1) deltaP_expansions_sharp += deltaP deltaP_expansions_sharp = roundit(deltaP_expansions_sharp) doc['result'].update({ 'deltaP_expansions_sharp': { '_val': str(deltaP_expansions_sharp), '_dim': 'pressure' } }) #calculating pressure drop for conical expansions deltaP_expansions_conical = 0 expansions_conical = doc['input']['expansions_conical']['_list'] for contraction in expansions_conical: D1 = contraction['D1'] D2 = contraction['D2'] L = contraction['L'] A1 = 3.1416 * (D1**2) / 4 V1 = Q / A1 K_contraction = fluids.fittings.diffuser_conical(D1, D2, fd=fd, l=L) deltaP = dP_from_K(K_contraction, rho, V1) deltaP_expansions_conical += deltaP deltaP_expansions_conical = roundit(deltaP_expansions_conical) doc['result'].update({ 'deltaP_expansions_conical': { '_val': str(deltaP_expansions_conical), '_dim': 'pressure' } }) #calculating pressure drop for pipe reducer expansions deltaP_expansions_reducer = 0 expansions_reducer = doc['input']['expansions_reducer']['_list'] for contraction in expansions_reducer: reducer_size = contraction['reducer_size'] D2, D1, L = reducer_dimensions(reducer_size) A1 = 3.1416 * (D1**2) / 4 V1 = Q / A1 K_contraction = fluids.fittings.diffuser_conical(D1, D2, fd=fd, l=L) deltaP = dP_from_K(K_contraction, rho, V1) deltaP_expansions_reducer += deltaP deltaP_expansions_reducer = roundit(deltaP_expansions_reducer) doc['result'].update({ 'deltaP_expansions_reducer': { '_val': str(deltaP_expansions_reducer), '_dim': 'pressure' } }) # calculating total pressure drop in all expansions deltaP_expansions = deltaP_expansions_sharp + deltaP_expansions_conical + deltaP_expansions_reducer doc['result'].update( {'deltaP_expansions': { '_val': deltaP_expansions, '_dim': 'pressure' }}) fixed_K_loss = doc['input']['fixed_K_losses']['_list'] for loss in fixed_K_loss: K_fixed += loss['K'] * loss['quantity'] deltaP_fixed_K = dP_from_K(K_fixed, rho, V) fixed_LbyD_loss = doc['input']['fixed_LbyD_losses']['_list'] for loss in fixed_LbyD_loss: L_D = loss['LbyD'] K_LbyD += K_from_L_equiv(L_D=L_D, fd=fd) * loss['quantity'] deltaP_fixed_LbyD = dP_from_K(K_LbyD, rho, V) fixed_deltaP_loss = doc['input']['fixed_deltaP_losses']['_list'] for loss in fixed_deltaP_loss: deltaP_fixed += loss['deltaP'] * loss['quantity'] deltaP_fixed_deltaP = deltaP_fixed deltaP_fixed_all = deltaP_fixed_K + deltaP_fixed_LbyD + deltaP_fixed_deltaP deltaP_fixed_all = roundit(deltaP_fixed_all) doc['result'].update({ 'deltaP_fixed_all': { '_val': str(deltaP_fixed_all), '_dim': 'pressure' } }) deltaP_total = deltaP_pipe + deltaP_entry + deltaP_exit + deltaP_fittings + deltaP_contractions + deltaP_expansions + deltaP_fixed_all deltaP_total = roundit(deltaP_total) doc['result'].update( {'deltaP_total': { '_val': str(deltaP_total), '_dim': 'pressure' }}) # doc_original['input'].update(doc['input']) doc_original['result'].update(doc['result']) treeUnitConvert(doc, SI_UNITS, doc['units'], autoRoundOff=True) return True
def test_gauge(): g1s = gauge_from_t(.5, False, 'BWG'), gauge_from_t(0.005588, True) assert_close1d(g1s, (0.2, 5)) g2s = gauge_from_t(0.5165, False, 'AWG'), gauge_from_t(0.00462026, True, 'AWG') assert_close1d(g2s, (0.2, 5)) g3s = gauge_from_t(.4305, False, 'SWG'), gauge_from_t(0.0052578, True, 'SWG') assert_close1d(g3s, (0.2, 5)) g4s = gauge_from_t(.005, False, 'MWG'), gauge_from_t(0.0003556, True, 'MWG') assert_close1d(g4s, (0.2, 5)) g5s = gauge_from_t(.432, False, 'BSWG'), gauge_from_t(0.0053848, True, 'BSWG') assert_close1d(g5s, (0.2, 5)) g6s = gauge_from_t(0.227, False, 'SSWG'), gauge_from_t(0.0051816, True, 'SSWG') assert_close1d(g6s, (1, 5)) with pytest.raises(Exception): gauge_from_t(.5, False, 'FAIL') # Not in schedule with pytest.raises(Exception): gauge_from_t(0.02) # Too large g1 = gauge_from_t(0.002) # not in index; gauge 14, 2 mm g2 = gauge_from_t( 0.00185) # not in index, gauge 15, within tol (10% default) # Limits between them are 0.0018288 and 0.0021082 m. g3 = gauge_from_t(0.00002) assert_close1d([g1, g2, g3], [14, 15, 0.004]) t1s = t_from_gauge(.2, False, 'BWG'), t_from_gauge(5, True) assert_close1d(t1s, (0.5, 0.005588)) t2s = t_from_gauge(.2, False, 'AWG'), t_from_gauge(5, True, 'AWG') assert_close1d(t2s, (0.5165, 0.00462026)) t3s = t_from_gauge(.2, False, 'SWG'), t_from_gauge(5, True, 'SWG') assert_close1d(t3s, (0.4305, 0.0052578)) t4s = t_from_gauge(.2, False, 'MWG'), t_from_gauge(5, True, 'MWG') assert_close1d(t4s, (0.005, 0.0003556)) t5s = t_from_gauge(.2, False, 'BSWG'), t_from_gauge(5, True, 'BSWG') assert_close1d(t5s, (0.432, 0.0053848)) t6s = t_from_gauge(1, False, 'SSWG'), t_from_gauge(5, True, 'SSWG') assert_close1d(t6s, (0.227, 0.0051816)) with pytest.raises(Exception): t_from_gauge(17.5, schedule='FAIL') with pytest.raises(Exception): t_from_gauge(17.5, schedule='MWG') # Test schedule is implemented NPS, Di, Do, t = nearest_pipe(Do=.273, schedule='80D1527') assert NPS == 10 assert_close1d((Di, Do, t), (0.2429256, 0.27305, 0.015062200000000001)) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=8, schedule='ABSD2680') assert NPS == 8 assert_close1d((0.19685, 0.239014, 0.021082), (Di, Do, t), rtol=1e-12) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=27, schedule='PS115F679') assert NPS == 27 assert_close1d((0.6591046, 0.7100062, 0.025450800000000003), (Di, Do, t), rtol=1e-12) NPS, Di, Do, t = nearest_pipe(NPS=27, schedule='PS75F679') assert NPS == 27 assert_close1d((0.665607, 0.7100062, 0.0221996), (Di, Do, t), rtol=1e-12) NPS, Di, Do, t = nearest_pipe(NPS=27, schedule='PS46F679') assert NPS == 27 assert_close1d((0.6721602, 0.7100062, 0.018923), (Di, Do, t), rtol=1e-12) from fluids.piping import NPS120_D1785 assert_close(NPS120_D1785[0], 0.5) assert_close(NPS120_D1785[-1], 12) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=6, schedule='PVCD2665') assert_close1d((0.154051, 0.168275, 0.007112), (Di, Do, t), rtol=1e-12) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=6, schedule='80D1785') assert_close1d((0.1463294, 0.168275, 0.0109728), (Di, Do, t), rtol=1e-12) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=6, schedule='DR21D2241') assert_close1d((0.15222219999999997, 0.168275, 0.008026400000000001), (Di, Do, t), rtol=1e-12) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=1, schedule='DR21D2241CTS') assert_close1d((0.025527, 0.028575, 0.001524), (Di, Do, t), rtol=1e-12) # initially accidentally implemented this using the mm's given in the standard # however the IPS ones are authoritative. NPS, Di, Do, t = nearest_pipe(NPS=10, schedule='DR325D2241PIP') assert_close1d((0.2431288, 0.25908, 0.0079756), (Di, Do, t), rtol=1e-12) # Test schedule with DN NPS, Di, Do, t = nearest_pipe(NPS=100, schedule='S40F441SI') assert_close1d((0.10226, 0.1143, 0.006019999999999999), (Di, Do, t), rtol=1e-12)
def calculate(doc_original): doc = deepcopy(doc_original) treeUnitConvert(doc, doc['units'], SI_UNITS) doc['errors'] = [] calculation_option = doc['input']['calculation_option']['_val'] ''' ''' try: if (calculation_option == 'NPS'): NPS = parseFloat(doc['input']['NPS']['_val']) Schedule = doc['input']['Schedule']['_val'] NPS, d, D, tn = nearest_pipe(NPS=NPS, schedule=Schedule) if (calculation_option == 'd'): d = parseFloat(doc['input']['d']['_val']) Schedule = doc['input']['Schedule']['_val'] NPS, d, D, tn = nearest_pipe(Di=d, schedule=Schedule) if (calculation_option == 'D'): D = parseFloat(doc['input']['D']['_val']) Schedule = doc['input']['Schedule']['_val'] NPS, d, D, tn = nearest_pipe(Do=D, schedule=Schedule) except Exception as e: doc['errors'].append(str(e)) NPS = math.nan d = math.nan D = math.nan tn = math.nan P = parseFloat(doc['input']['P']['_val']) Tdesign = parseFloat(doc['input']['Tdesign']['_val']) materialSpec = doc['input']['materialSpec']['_val'] weldType = doc['input']['weldType']['_val'] W = parseFloat(doc['input']['W']['_val']) ca = parseFloat(doc['input']['ca']['_val']) h = parseFloat(doc['input']['h']['_val']) ut = parseFloat(doc['input']['ut']['_val']) t_ut = tn * ut / 100 # thickness lost due to undertolerance T = tn - t_ut # guaranteed thickness available as a minimum c = ca + h # get sum total of all corrosion and threading allowance S = getS(materialSpec, Tdesign) Y = getY(materialSpec, Tdesign) E = getE(weldType) t = t_pressure(P, D, S, E, W, Y) # pressure design thickness tm = t + c # min required thickness if (T >= tm): acceptability = "OK" else: acceptability = "Not OK" doc['result'].update({'NPS': {'_val': str(roundit(NPS))}}) doc['result'].update({'d': {'_val': str(roundit(d)), '_dim': 'length'}}) doc['result'].update({'D': {'_val': str(roundit(D)), '_dim': 'length'}}) doc['result'].update({'tn': {'_val': str(roundit(tn)), '_dim': 'length'}}) doc['result'].update( {'t_ut': { '_val': str(roundit(t_ut)), '_dim': 'length' }}) doc['result'].update({'T': {'_val': str(roundit(T)), '_dim': 'length'}}) doc['result'].update({'S': {'_val': str(roundit(S)), '_dim': 'pressure'}}) doc['result'].update({'Y': {'_val': str(roundit(Y))}}) doc['result'].update({'E': {'_val': str(E)}}) doc['result'].update({'t': {'_val': str(roundit(t)), '_dim': 'length'}}) doc['result'].update({'c': {'_val': str(roundit(c)), '_dim': 'length'}}) doc['result'].update({'tm': {'_val': str(roundit(tm)), '_dim': 'length'}}) doc['result'].update({'acceptability': {'_val': acceptability}}) treeUnitConvert(doc, SI_UNITS, doc['units'], autoRoundOff=True) doc_original['result'].update(doc['result']) doc_original['errors'] = doc['errors'] return True