/
control_valve.py
1530 lines (1308 loc) · 54.3 KB
/
control_valve.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# -*- coding: utf-8 -*-
'''Chemical Engineering Design Library (ChEDL). Utilities for process modeling.
Copyright (C) 2016, Caleb Bell <Caleb.Andrew.Bell@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.'''
from __future__ import division
from math import log10, exp, pi
from fluids.constants import R, psi, gallon, minute
from fluids.numerics import interp, implementation_optimize_tck, splev
from fluids.fittings import Cv_to_Kv, Kv_to_Cv
__all__ = ['size_control_valve_l', 'size_control_valve_g', 'cavitation_index',
'FF_critical_pressure_ratio_l', 'is_choked_turbulent_l',
'is_choked_turbulent_g', 'Reynolds_valve',
'loss_coefficient_piping', 'Reynolds_factor',
'Cv_char_quick_opening', 'Cv_char_linear',
'Cv_char_equal_percentage',
'convert_flow_coefficient', 'control_valve_choke_P_l',
'control_valve_choke_P_g', 'control_valve_noise_l_2015',
'control_valve_noise_g_2011']
N1 = 0.1 # m^3/hr, kPa
N2 = 1.6E-3 # mm
N4 = 7.07E-2 # m^3/hr, m^2/s
N5 = 1.8E-3 # mm
N6 = 3.16 # kg/hr, kPa, kg/m^3
N7 = 4.82 # m^3/hr kPa K
N8 = 1.10 # kPa kg/hr K
#N9 = 2.60E1 # m^3/hr kPa K at 15 deg C
N9 = 2.46E1 # m^3/hr kPa K at 0 deg C
N18 = 8.65E-1 # mm
N19 = 2.5 # mm
#N22 = 1.84E1 # m^3/hr kPa K at 15 deg C
N27 = 7.75E-1 # kg/hr kPa K at 0 deg C
N32 = 1.4E2 # mm
rho0 = 999.10329075702327 # Water at 288.15 K
def cavitation_index(P1, P2, Psat):
r'''Calculates the cavitation index of a valve with upstream and downstream
absolute pressures `P1` and `P2` for a fluid with a vapor pressure `Psat`.
.. math::
\sigma = \frac{P_1 - P_{sat}}{P_1 - P_2}
Parameters
----------
P1 : float
Absolute pressure upstream of the valve [Pa]
P2 : float
Absolute pressure downstream of the valve [Pa]
Psat : float
Saturation pressure of the liquid at inlet temperature [Pa]
Returns
-------
sigma : float
Cavitation index of the valve [-]
Notes
-----
Larger values are safer. Models for adjusting cavitation indexes provided
by the manufacturer to the user's conditions are available, making use
of scaling the pressure differences and size differences.
Values can be calculated for incipient cavitation, constant cavitation,
maximum vibration cavitation, incipient damage, and choking cavitation.
Has also been defined as:
.. math::
\sigma = \frac{P_2 - P_{sat}}{P_1 - P_2}
Another definition and notation series is:
.. math::
K = xF = \frac{1}{\sigma} = \frac{P_1 - P_2}{P_1 - P_{sat}}
Examples
--------
>>> cavitation_index(1E6, 8E5, 2E5)
4.0
References
----------
.. [1] ISA. "RP75.23 Considerations for Evaluating Control Valve
Cavitation." 1995.
'''
return (P1 - Psat)/(P1 - P2)
def FF_critical_pressure_ratio_l(Psat, Pc):
r'''Calculates FF, the liquid critical pressure ratio factor,
for use in IEC 60534 liquid valve sizing calculations.
.. math::
F_F = 0.96 - 0.28\sqrt{\frac{P_{sat}}{P_c}}
Parameters
----------
Psat : float
Saturation pressure of the liquid at inlet temperature [Pa]
Pc : float
Critical pressure of the liquid [Pa]
Returns
-------
FF : float
Liquid critical pressure ratio factor [-]
Examples
--------
From [1]_, matching example.
>>> FF_critical_pressure_ratio_l(70100.0, 22120000.0)
0.9442375225233299
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
return 0.96 - 0.28*(Psat/Pc)**0.5
def control_valve_choke_P_l(Psat, Pc, FL, P1=None, P2=None, disp=True):
r'''Calculates either the upstream or downstream pressure at which choked
flow though a liquid control valve occurs, given either a set upstream or
downstream pressure. Implements an analytical solution of
the needed equations from the full function
:py:func:`~.size_control_valve_l`. For some pressures, no choked flow
is possible; for choked flow to occur the direction if flow must be
reversed. If `disp` is True, an exception will be raised for these
conditions.
.. math::
P_1 = \frac{F_{F} F_{L}^{2} P_{sat} - P_{2}}{F_{L}^{2} - 1}
.. math::
P_2 = F_{F} F_{L}^{2} P_{sat} - F_{L}^{2} P_{1} + P_{1}
Parameters
----------
Psat : float
Saturation pressure of the liquid at inlet temperature [Pa]
Pc : float
Critical pressure of the liquid [Pa]
FL : float, optional
Liquid pressure recovery factor of a control valve without attached
fittings [-]
P1 : float, optional
Absolute pressure upstream of the valve [Pa]
P2 : float, optional
Absolute pressure downstream of the valve [Pa]
disp : bool, optional
Whether or not to raise an exception on flow reversal, [-]
Returns
-------
P_choke : float
Pressure at which a choke occurs in the liquid valve [Pa]
Notes
-----
Extremely cheap to compute.
Examples
--------
>>> control_valve_choke_P_l(69682.89291024722, 22048320.0, 0.6, 680000.0)
458887.5306077305
>>> control_valve_choke_P_l(69682.89291024722, 22048320.0, 0.6, P2=458887.5306077305)
680000.0
'''
FF = 0.96 - 0.28*(Psat/Pc)**0.5 #FF_critical_pressure_ratio_l(Psat=Psat, Pc=Pc)
Pmin_absolute = FF*Psat
if P2 is None:
ans = P2 = FF*FL*FL*Psat - FL*FL*P1 + P1
elif P1 is None:
ans = P1 = (FF*FL*FL*Psat - P2)/(FL*FL - 1.0)
else:
raise ValueError('Either P1 or P2 needs to be specified')
if P2 > P1 and disp:
raise ValueError('Specified P1 is too low for choking to occur '
'at any downstream pressure; minimum '
'upstream pressure for choking to be possible '
'is %g Pa.' %Pmin_absolute)
return ans
def control_valve_choke_P_g(xT, gamma, P1=None, P2=None):
r'''Calculates either the upstream or downstream pressure at which choked
flow though a gas control valve occurs, given either a set upstream or
downstream pressure. Implements an analytical solution of
the needed equations from the full function
:py:func:`~.size_control_valve_g`. A singularity arises as `xT` goes to 1
and `gamma` goes to 1.4.
.. math::
P_1 = - \frac{7 P_{2}}{5 \gamma x_T - 7}
.. math::
P_2 = \frac{P_{1}}{7} \left(- 5 \gamma x_T + 7\right)
Parameters
----------
xT : float, optional
Pressure difference ratio factor of a valve without fittings at choked
flow [-]
gamma : float
Specific heat capacity ratio [-]
P1 : float, optional
Absolute pressure upstream of the valve [Pa]
P2 : float, optional
Absolute pressure downstream of the valve [Pa]
Returns
-------
P_choke : float
Pressure at which a choke occurs in the gas valve [Pa]
Notes
-----
Extremely cheap to compute.
Examples
--------
>>> control_valve_choke_P_g(1.0, 1.3, 1E5)
7142.857142857143
>>> control_valve_choke_P_g(1.0, 1.3, P2=7142.857142857143)
100000.0
'''
if P2 is None:
ans = P2 = P1*(-5.0*gamma*xT + 7.0)/7.0
elif P1 is None:
ans = P1 = -7.0*P2/(5.0*gamma*xT - 7.0)
else:
raise ValueError('Either P1 or P2 needs to be specified')
return ans
def is_choked_turbulent_l(dP, P1, Psat, FF, FL=None, FLP=None, FP=None):
r'''Calculates if a liquid flow in IEC 60534 calculations is critical or
not, for use in IEC 60534 liquid valve sizing calculations.
Either FL may be provided or FLP and FP, depending on the calculation
process.
.. math::
\Delta P > F_L^2(P_1 - F_F P_{sat})
.. math::
\Delta P >= \left(\frac{F_{LP}}{F_P}\right)^2(P_1 - F_F P_{sat})
Parameters
----------
dP : float
Differential pressure across the valve, with reducer/expanders [Pa]
P1 : float
Pressure of the fluid before the valve and reducers/expanders [Pa]
Psat : float
Saturation pressure of the fluid at inlet temperature [Pa]
FF : float
Liquid critical pressure ratio factor [-]
FL : float, optional
Liquid pressure recovery factor of a control valve without attached fittings [-]
FLP : float, optional
Combined liquid pressure recovery factor with piping geometry factor,
for a control valve with attached fittings [-]
FP : float, optional
Piping geometry factor [-]
Returns
-------
choked : bool
Whether or not the flow is choked [-]
Examples
--------
>>> is_choked_turbulent_l(460.0, 680.0, 70.1, 0.94, 0.9)
False
>>> is_choked_turbulent_l(460.0, 680.0, 70.1, 0.94, 0.6)
True
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
if FLP and FP:
return dP >= FLP*FLP/(FP*FP)*(P1-FF*Psat)
elif FL:
return dP >= FL*FL*(P1-FF*Psat)
else:
raise ValueError('Either (FLP and FP) or FL is needed')
def is_choked_turbulent_g(x, Fgamma, xT=None, xTP=None):
r'''Calculates if a gas flow in IEC 60534 calculations is critical or
not, for use in IEC 60534 gas valve sizing calculations.
Either xT or xTP must be provided, depending on the calculation process.
.. math::
x \ge F_\gamma x_T
.. math::
x \ge F_\gamma x_{TP}
Parameters
----------
x : float
Differential pressure over inlet pressure, [-]
Fgamma : float
Specific heat ratio factor [-]
xT : float, optional
Pressure difference ratio factor of a valve without fittings at choked
flow [-]
xTP : float
Pressure difference ratio factor of a valve with fittings at choked
flow [-]
Returns
-------
choked : bool
Whether or not the flow is choked [-]
Examples
--------
Example 3, compressible flow, non-choked with attached fittings:
>>> is_choked_turbulent_g(0.544, 0.929, 0.6)
False
>>> is_choked_turbulent_g(0.544, 0.929, xTP=0.625)
False
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
if xT:
return x >= Fgamma*xT
elif xTP:
return x >= Fgamma*xTP
else:
raise ValueError('Either xT or xTP is needed')
def Reynolds_valve(nu, Q, D1, FL, Fd, C):
r'''Calculates Reynolds number of a control valve for a liquid or gas
flowing through it at a specified Q, for a specified D1, FL, Fd, C, and
with kinematic viscosity `nu` according to IEC 60534 calculations.
.. math::
Re_v = \frac{N_4 F_d Q}{\nu \sqrt{C F_L}}\left(\frac{F_L^2 C^2}
{N_2D^4} +1\right)^{1/4}
Parameters
----------
nu : float
Kinematic viscosity, [m^2/s]
Q : float
Volumetric flow rate of the fluid [m^3/s]
D1 : float
Diameter of the pipe before the valve [m]
FL : float, optional
Liquid pressure recovery factor of a control valve without attached
fittings []
Fd : float
Valve style modifier [-]
C : float
Metric Kv valve flow coefficient (flow rate of water at a pressure drop
of 1 bar) [m^3/hr]
Returns
-------
Rev : float
Valve reynolds number [-]
Examples
--------
>>> Reynolds_valve(3.26e-07, 360, 150.0, 0.9, 0.46, 165)
2966984.7525455453
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
return N4*Fd*Q/nu*(C*FL)**-0.5*(FL*FL*C*C/N2*D1**-4.0 + 1.0)**0.25
def loss_coefficient_piping(d, D1=None, D2=None):
r'''Calculates the sum of loss coefficients from possible
inlet/outlet reducers/expanders around a control valve according to
IEC 60534 calculations.
.. math::
\Sigma \xi = \xi_1 + \xi_2 + \xi_{B1} - \xi_{B2}
.. math::
\xi_1 = 0.5\left[1 -\left(\frac{d}{D_1}\right)^2\right]^2
.. math::
\xi_2 = 1.0\left[1 -\left(\frac{d}{D_2}\right)^2\right]^2
.. math::
\xi_{B1} = 1 - \left(\frac{d}{D_1}\right)^4
.. math::
\xi_{B2} = 1 - \left(\frac{d}{D_2}\right)^4
Parameters
----------
d : float
Diameter of the valve [m]
D1 : float
Diameter of the pipe before the valve [m]
D2 : float
Diameter of the pipe after the valve [m]
Returns
-------
loss : float
Sum of the four loss coefficients [-]
Examples
--------
In example 3, non-choked compressible flow with fittings:
>>> loss_coefficient_piping(0.05, 0.08, 0.1)
0.6580810546875
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
loss = 0.
if D1:
dr = d/D1
dr2 = dr*dr
loss += 1. - dr2*dr2 # Inlet flow energy
loss += 0.5*(1. - dr2)*(1.0 - dr2) # Inlet reducer
if D2:
dr = d/D2
dr2 = dr*dr
loss += 1.0*(1. - dr2)*(1.0 - dr2) # Outlet reducer (expander)
loss -= 1. - dr2*dr2 # Outlet flow energy
return loss
def Reynolds_factor(FL, C, d, Rev, full_trim=True):
r'''Calculates the Reynolds number factor `FR` for a valve with a Reynolds
number `Rev`, diameter `d`, flow coefficient `C`, liquid pressure recovery
factor `FL`, and with either full or reduced trim, all according to
IEC 60534 calculations.
If full trim:
.. math::
F_{R,1a} = 1 + \left(\frac{0.33F_L^{0.5}}{n_1^{0.25}}\right)\log_{10}
\left(\frac{Re_v}{10000}\right)
.. math::
F_{R,2} = \min(\frac{0.026}{F_L}\sqrt{n_1 Re_v},\; 1)
.. math::
n_1 = \frac{N_2}{\left(\frac{C}{d^2}\right)^2}
.. math::
F_R = F_{R,2} \text{ if Rev < 10 else } \min(F_{R,1a}, F_{R,2})
Otherwise :
.. math::
F_{R,3a} = 1 + \left(\frac{0.33F_L^{0.5}}{n_2^{0.25}}\right)\log_{10}
\left(\frac{Re_v}{10000}\right)
.. math::
F_{R,4} = \frac{0.026}{F_L}\sqrt{n_2 Re_v}
.. math::
n_2 = 1 + N_{32}\left(\frac{C}{d}\right)^{2/3}
.. math::
F_R = F_{R,4} \text{ if Rev < 10 else } \min(F_{R,3a}, F_{R,4})
Parameters
----------
FL : float
Liquid pressure recovery factor of a control valve without attached
fittings []
C : float
Metric Kv valve flow coefficient (flow rate of water at a pressure drop
of 1 bar) [m^3/hr]
d : float
Diameter of the valve [m]
Rev : float
Valve reynolds number [-]
full_trim : bool
Whether or not the valve has full trim
Returns
-------
FR : float
Reynolds number factor for laminar or transitional flow []
Examples
--------
In Example 4, compressible flow with small flow trim sized for gas flow
(Cv in the problem was converted to Kv here to make FR match with N32, N2):
>>> Reynolds_factor(FL=0.98, C=0.015483, d=15., Rev=1202., full_trim=False)
0.7148753122302025
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
if full_trim:
n1 = N2/(min(C/(d*d), 0.04))**2 # C/d**2 must not exceed 0.04
FR_1a = 1.0 + (0.33*FL**0.5)/n1**0.25*log10(Rev/10000.)
FR_2 = 0.026/FL*(n1*Rev)**0.5
if Rev < 10.0:
FR = FR_2
else:
FR = min(FR_2, FR_1a)
else:
n2 = 1 + N32*(C/d**2)**(2/3.)
FR_3a = 1 + (0.33*FL**0.5)/n2**0.25*log10(Rev/10000.)
FR_4 = min(0.026/FL*(n2*Rev)**0.5, 1)
if Rev < 10:
FR = FR_4
else:
FR = min(FR_3a, FR_4)
return FR
def size_control_valve_l(rho, Psat, Pc, mu, P1, P2, Q, D1=None, D2=None,
d=None, FL=0.9, Fd=1, allow_choked=True,
allow_laminar=True, full_output=False):
r'''Calculates flow coefficient of a control valve passing a liquid
according to IEC 60534. Uses a large number of inputs in SI units. Note the
return value is not standard SI. All parameters are required.
This sizing model does not officially apply to liquid mixtures, slurries,
non-Newtonian fluids, or liquid-solid conveyance systems. For details
of the calculations, consult [1]_.
Parameters
----------
rho : float
Density of the liquid at the inlet [kg/m^3]
Psat : float
Saturation pressure of the fluid at inlet temperature [Pa]
Pc : float
Critical pressure of the fluid [Pa]
mu : float
Viscosity of the fluid [Pa*s]
P1 : float
Inlet pressure of the fluid before valves and reducers [Pa]
P2 : float
Outlet pressure of the fluid after valves and reducers [Pa]
Q : float
Volumetric flow rate of the fluid [m^3/s]
D1 : float, optional
Diameter of the pipe before the valve [m]
D2 : float, optional
Diameter of the pipe after the valve [m]
d : float, optional
Diameter of the valve [m]
FL : float, optional
Liquid pressure recovery factor of a control valve without attached
fittings (normally 0.8-0.9 at full open and decreasing as opened
further to below 0.5; use default very cautiously!) []
Fd : float, optional
Valve style modifier (0.1 to 1; varies tremendously depending on the
type of valve and position; do not use the default at all!) []
allow_choked : bool, optional
Overrides the automatic transition into the choked regime if this is
False and returns as if choked flow does not exist
allow_laminar : bool, optional
Overrides the automatic transition into the laminar regime if this is
False and returns as if laminar flow does not exist
full_output : bool, optional
If True, returns intermediate calculation values as
well as Kv in the form of a dictionary containing 'Kv', 'Rev', 'choked',
'FL', 'FLP', 'FR', 'FP', and 'laminar'. Some may be None if they are
not used in the calculation.
Returns
-------
Kv : float
Metric Kv valve flow coefficient (flow rate of water at a pressure drop
of 1 bar) [m^3/hr]
Notes
-----
It is possible to use this model without any diameters specified; in that
case, turbulent flow is assumed. Choked flow can still be modeled. This is
not recommended. All three diameters need to be None for this to work.
`FL` and `Fd` are not used by the models when the diameters are not
specified.
Examples
--------
From [1]_, matching example 1 for a globe, parabolic plug,
flow-to-open valve.
>>> size_control_valve_l(rho=965.4, Psat=70.1E3, Pc=22120E3, mu=3.1472E-4,
... P1=680E3, P2=220E3, Q=0.1, D1=0.15, D2=0.15, d=0.15,
... FL=0.9, Fd=0.46)
164.9954763704956
From [1]_, matching example 2 for a ball, segmented ball,
flow-to-open valve.
>>> size_control_valve_l(rho=965.4, Psat=70.1E3, Pc=22120E3, mu=3.1472E-4,
... P1=680E3, P2=220E3, Q=0.1, D1=0.1, D2=0.1, d=0.1,
... FL=0.6, Fd=0.98)
238.05817216710483
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
if full_output:
ans = {'FLP': None, 'FP': None, 'FR': None}
# Pa to kPa, according to constants in standard
P1, P2, Psat, Pc = P1/1000., P2/1000., Psat/1000., Pc/1000.
Q = Q*3600. # m^3/s to m^3/hr, according to constants in standard
nu = mu/rho # kinematic viscosity used in standard
MAX_C_POSSIBLE = 1E40 # Quit iterations if C reaches this high
dP = P1 - P2
FF = FF_critical_pressure_ratio_l(Psat=Psat, Pc=Pc)
choked = is_choked_turbulent_l(dP=dP, P1=P1, Psat=Psat, FF=FF, FL=FL)
if choked and allow_choked:
# Choked flow, equation 3
C = Q/N1/FL*(rho/rho0/(P1 - FF*Psat))**0.5
else:
# non-choked flow, eq 1
C = Q/N1*(rho/rho0/dP)**0.5
if D1 is None and D2 is None and d is None:
# Assume turbulent if no diameters are provided, no other calculations
Rev = 1e5
else:
# m to mm, according to constants in standard
D1, D2, d = D1*1000., D2*1000., d*1000.
Rev = Reynolds_valve(nu=nu, Q=Q, D1=D1, FL=FL, Fd=Fd, C=C)
# normal calculation path
if (Rev > 10000 or not allow_laminar) and (D1 != d or D2 != d):
# liquid, using Fp and FLP
FP = 1.0
Ci = C
MAX_ITER = 20
def iterate_piping_turbulent_l(Ci, iterations):
loss = loss_coefficient_piping(d, D1, D2)
FP = (1 + loss/N2*(Ci/d**2)**2)**-0.5
if d > D1:
loss_upstream = 0.0
else:
loss_upstream = loss_coefficient_piping(d, D1)
FLP = FL*(1 + FL**2/N2*loss_upstream*(Ci/d**2)**2)**-0.5
choked = is_choked_turbulent_l(dP, P1, Psat, FF, FLP=FLP, FP=FP)
if choked:
# Choked flow with piping, equation 4
C = Q/N1/FLP*(rho/rho0/(P1-FF*Psat))**0.5
else:
# Non-Choked flow with piping, equation 5
C = Q/N1/FP*(rho/rho0/dP)**0.5
if Ci/C < 0.99 and iterations < MAX_ITER and Ci < MAX_C_POSSIBLE:
C = iterate_piping_turbulent_l(C, iterations+1)
if MAX_ITER == iterations or Ci >= MAX_C_POSSIBLE:
ans['warning'] = 'Not converged in inner loop'
if full_output:
ans['FLP'] = FLP
ans['FP'] = FP
return C
C = iterate_piping_turbulent_l(Ci, 0)
elif Rev <= 10000 and allow_laminar:
# Laminar
def iterate_piping_laminar_l(C):
Ci = 1.3*C
Rev = Reynolds_valve(nu=nu, Q=Q, D1=D1, FL=FL, Fd=Fd, C=Ci)
if Ci/d**2 > 0.016*N18:
FR = Reynolds_factor(FL=FL, C=Ci, d=d, Rev=Rev, full_trim=False)
else:
FR = Reynolds_factor(FL=FL, C=Ci, d=d, Rev=Rev, full_trim=True)
if C/FR >= Ci:
Ci = iterate_piping_laminar_l(Ci) # pragma: no cover
if full_output:
ans['Rev'] = Rev
ans['FR'] = FR
return Ci
C = iterate_piping_laminar_l(C)
if full_output:
ans['FF'] = FF
ans['choked'] = choked
ans['Kv'] = C
ans['laminar'] = Rev <= 10000
# For the laminar case this is already set and needs to not be overwritten
if 'Rev' not in ans:
ans['Rev'] = Rev
return ans
else:
# return C, choked, laminar, FF, FR, Rev, FP, FLP, warning
return C
def size_control_valve_g(T, MW, mu, gamma, Z, P1, P2, Q, D1=None, D2=None,
d=None, FL=0.9, Fd=1, xT=0.7, allow_choked=True,
allow_laminar=True, full_output=False):
r'''Calculates flow coefficient of a control valve passing a gas
according to IEC 60534. Uses a large number of inputs in SI units. Note the
return value is not standard SI. All parameters are required. For details
of the calculations, consult [1]_. Note the inlet gas flow conditions.
Parameters
----------
T : float
Temperature of the gas at the inlet [K]
MW : float
Molecular weight of the gas [g/mol]
mu : float
Viscosity of the fluid at inlet conditions [Pa*s]
gamma : float
Specific heat capacity ratio [-]
Z : float
Compressibility factor at inlet conditions, [-]
P1 : float
Inlet pressure of the gas before valves and reducers [Pa]
P2 : float
Outlet pressure of the gas after valves and reducers [Pa]
Q : float
Volumetric flow rate of the gas at *273.15 K* and 1 atm specifically
[m^3/s]
D1 : float, optional
Diameter of the pipe before the valve [m]
D2 : float, optional
Diameter of the pipe after the valve [m]
d : float, optional
Diameter of the valve [m]
FL : float, optional
Liquid pressure recovery factor of a control valve without attached
fittings (normally 0.8-0.9 at full open and decreasing as opened
further to below 0.5; use default very cautiously!) []
Fd : float, optional
Valve style modifier (0.1 to 1; varies tremendously depending on the
type of valve and position; do not use the default at all!) []
xT : float, optional
Pressure difference ratio factor of a valve without fittings at choked
flow (increasing to 0.9 or higher as the valve is closed further and
decreasing to 0.1 or lower as the valve is opened further; use default
very cautiously!) [-]
allow_choked : bool, optional
Overrides the automatic transition into the choked regime if this is
False and returns as if choked flow does not exist
allow_laminar : bool, optional
Overrides the automatic transition into the laminar regime if this is
False and returns as if laminar flow does not exist
full_output : bool, optional
If True, returns intermediate calculation values as
well as Kv in the form of a dictionary containing 'Kv', 'Rev', 'choked',
'Y', 'FR', 'FP', 'xTP', and 'laminar'. Some may be None if they are
not used in the calculation.
Returns
-------
Kv : float
Metric Kv valve flow coefficient (flow rate of water at a pressure drop
of 1 bar) [m^3/hr]
Notes
-----
It is possible to use this model without any diameters specified; in that
case, turbulent flow is assumed. Choked flow can still be modeled. This is
not recommended. All three diameters need to be None for this to work.
`FL` and `Fd` are not used by the models when the diameters are not
specified, but `xT` definitely is used by the model.
When this model does not converge, the result is normally because of the
specified delta P being less than that caused by the piping diameter
changes.
Examples
--------
From [1]_, matching example 3 for non-choked gas flow with attached
fittings and a rotary, eccentric plug, flow-to-open control valve:
>>> size_control_valve_g(T=433., MW=44.01, mu=1.4665E-4, gamma=1.30,
... Z=0.988, P1=680E3, P2=310E3, Q=38/36., D1=0.08, D2=0.1, d=0.05,
... FL=0.85, Fd=0.42, xT=0.60)
72.58664545391052
From [1]_, roughly matching example 4 for a small flow trim sized tapered
needle plug valve. Difference is 3% and explained by the difference in
algorithms used.
>>> size_control_valve_g(T=320., MW=39.95, mu=5.625E-5, gamma=1.67, Z=1.0,
... P1=2.8E5, P2=1.3E5, Q=0.46/3600., D1=0.015, D2=0.015, d=0.015, FL=0.98,
... Fd=0.07, xT=0.8)
0.016498765335995726
References
----------
.. [1] IEC 60534-2-1 / ISA-75.01.01-2007
'''
MAX_C_POSSIBLE = 1E40 # Quit iterations if C reaches this high
# Pa to kPa, according to constants in standard
P1, P2 = P1*1e-3, P2*1e-3
Q = Q*3600. # m^3/s to m^3/hr, according to constants in standard
# Convert dynamic viscosity to kinematic viscosity
Vm = Z*R*T/(P1*1000)
rho = MW*1e-3/Vm
nu = mu/rho # kinematic viscosity used in standard
dP = P1 - P2
Fgamma = gamma/1.40
x = dP/P1
Y = max(1 - x/(3*Fgamma*xT), 2/3.)
choked = is_choked_turbulent_g(x, Fgamma, xT)
if choked and allow_choked:
# Choked, and flow coefficient from eq 14a
C = Q/(N9*P1*Y)*(MW*T*Z/xT/Fgamma)**0.5
else:
# Non-choked, and flow coefficient from eq 8a
C = Q/(N9*P1*Y)*(MW*T*Z/x)**0.5
if full_output: # numba: delete
ans = {'FP': None, 'xTP': None, 'FR': None, 'choked': choked, 'Y': Y} # numba: delete
if D1 is None and D2 is None and d is None:
# Assume turbulent if no diameters are provided, no other calculations
Rev = 1e5
if full_output: ans['Rev'] = None # numba: delete
else:
# m to mm, according to constants in standard
D1, D2, d = D1*1000., D2*1000., d*1000. # Convert diameters to mm which is used in the standard
Rev = Reynolds_valve(nu=nu, Q=Q, D1=D1, FL=FL, Fd=Fd, C=C)
if full_output: ans['Rev'] = Rev # numba: delete
if (Rev > 10000 or not allow_laminar) and (D1 != d or D2 != d):
# gas, using xTP and FLP
FP = 1.
MAX_ITER = 20
def iterate_piping_coef_g(Ci, iterations):
loss = loss_coefficient_piping(d, D1, D2)
FP = (1. + loss/N2*(Ci/d**2)**2)**-0.5
loss_upstream = loss_coefficient_piping(d, D1)
xTP = xT/FP**2/(1 + xT*loss_upstream/N5*(Ci/d**2)**2)
choked = is_choked_turbulent_g(x, Fgamma, xTP=xTP)
if choked:
# Choked flow with piping, equation 17a
C = Q/(N9*FP*P1*Y)*(MW*T*Z/xTP/Fgamma)**0.5
else:
# Non-choked flow with piping, equation 11a
C = Q/(N9*FP*P1*Y)*(MW*T*Z/x)**0.5
if Ci/C < 0.99 and iterations < MAX_ITER and Ci < MAX_C_POSSIBLE:
C = iterate_piping_coef_g(C, iterations+1)
if full_output: # numba: delete
ans['xTP'] = xTP # numba: delete
ans['FP'] = FP # numba: delete
ans['choked'] = choked # numba: delete
if MAX_ITER == iterations or Ci >= MAX_C_POSSIBLE: # numba: delete
ans['warning'] = 'Not converged in inner loop' # numba: delete
return C
# def err_piping_coeff(Ci):
# loss = loss_coefficient_piping(d, D1, D2)
# FP = (1. + loss/N2*(Ci/d**2)**2)**-0.5
# loss_upstream = loss_coefficient_piping(d, D1)
# xTP = xT/FP**2/(1 + xT*loss_upstream/N5*(Ci/d**2)**2)
# choked = is_choked_turbulent_g(x, Fgamma, xTP=xTP)
# if choked:
# # Choked flow with piping, equation 17a
# C = Q/(N9*FP*P1*Y)*(MW*T*Z/xTP/Fgamma)**0.5
# else:
# # Non-choked flow with piping, equation 11a
# C = Q/(N9*FP*P1*Y)*(MW*T*Z/x)**0.5
# return C - Ci
# import matplotlib.pyplot as plt
# from fluids.numerics import linspace
# Cs = linspace(C/50, C*50, 5000)
# errs = [err_piping_coeff(C_test) for C_test in Cs]
# plt.plot(Cs, errs)
# plt.show()
C = iterate_piping_coef_g(C, 0)
elif Rev <= 10000 and allow_laminar:
# Laminar;
def iterate_piping_laminar_g(C):
Ci = 1.3*C
Rev = Reynolds_valve(nu=nu, Q=Q, D1=D1, FL=FL, Fd=Fd, C=Ci)
if Ci/d**2 > 0.016*N18:
FR = Reynolds_factor(FL=FL, C=Ci, d=d, Rev=Rev, full_trim=False)
else:
FR = Reynolds_factor(FL=FL, C=Ci, d=d, Rev=Rev, full_trim=True)
if C/FR >= Ci:
Ci = iterate_piping_laminar_g(Ci)
if full_output: # numba: delete
ans['FR'] = FR # numba: delete
ans['Rev'] = Rev # numba: delete
return Ci
C = iterate_piping_laminar_g(C)
if full_output: # numba: delete
ans['Kv'] = C # numba: delete
ans['laminar'] = Rev <= 10000 # numba: delete
ans['choked'] = choked # numba: delete
return ans # numba: delete
return C
# Valve data from Emerson Valve Handbook 5E
# Quick opening valve data, spline fit, and interpolating function
opening_quick = [0.0, 0.0136, 0.02184, 0.03256, 0.04575, 0.06221, 0.07459, 0.0878, 0.10757, 0.12654, 0.14301, 0.16032,
0.18009, 0.18999, 0.20233, 0.23105, 0.25483, 0.28925, 0.32365, 0.36541, 0.42188, 0.46608, 0.53319, 0.61501,
0.7034, 0.78033, 0.84415, 0.91944, 1.000]
frac_CV_quick = [0.0, 0.04984, 0.07582, 0.12044, 0.16614, 0.21707, 0.26998, 0.32808, 0.39353, 0.46516, 0.52125, 0.58356,
0.64798, 0.68845, 0.72277, 0.76565, 0.79399, 0.82459, 0.84589, 0.86732, 0.88078, 0.89399, 0.90867, 0.92053,
0.93973, 0.95872, 0.96817, 0.98611, 1.0]
opening_quick_tck = implementation_optimize_tck([[0.0, 0.0, 0.0, 0.0, 0.02184, 0.03256, 0.04575, 0.06221, 0.07459,
0.0878, 0.10757, 0.12654, 0.14301, 0.16032, 0.18009, 0.18999, 0.20233, 0.23105, 0.25483, 0.28925,
0.32365, 0.36541, 0.42188, 0.46608, 0.53319, 0.61501, 0.7034, 0.78033, 0.84415, 1.0, 1.0, 1.0, 1.0],
[-3.2479258181113327e-19, 0.037650956835178835, 0.054616164261637117, 0.12657862552611354,
0.17115105822542115, 0.2075233903194021, 0.27084055195333684, 0.34208963001568016, 0.38730839943796663,
0.4656002247400036, 0.5196995880922897, 0.5907033063634928, 0.6304293931726886, 0.6953064258075168,
0.7382935002453699, 0.7631579537132379, 0.7997961180795559, 0.8262370617883222, 0.8471954722933543,
0.873096858463145, 0.8776128736976467, 0.897647305294458, 0.9105672165523071, 0.9192771703370824,
0.9377349743236904, 0.9603716623033031, 0.9688863605959851, 0.9980062718267431, 1.0, 0.0, 0.0, 0.0, 0.0],
3])
Cv_char_quick_opening = lambda opening: float(splev(opening, opening_quick_tck))
opening_linear = [0., 1.0]
frac_CV_linear = [0, 1]
Cv_char_linear = lambda opening: interp(opening, opening_linear, frac_CV_linear)
# Equal opening valve data, spline fit, and interpolating function
opening_equal = [0.0, 0.05523, 0.09287, 0.15341, 0.18942, 0.22379, 0.25816, 0.29582, 0.33348, 0.34985, 0.3826, 0.45794,
0.49235, 0.51365, 0.54479, 0.57594, 0.60218, 0.62843, 0.77628, 0.796, 0.83298, 0.86995, 0.90936, 0.95368, 1.00]
frac_CV_equal = [0.0, 0.00845, 0.01339, 0.01877, 0.02579, 0.0349, 0.04189, 0.05528, 0.07079, 0.07533, 0.09074, 0.13444,
0.15833, 0.17353, 0.20159, 0.23388, 0.26819, 0.30461, 0.60113, 0.64588, 0.72583, 0.80788, 0.87519, 0.94999, 1.]
opening_equal_tck = implementation_optimize_tck([[0.0, 0.0, 0.0, 0.0, 0.09287, 0.15341, 0.18942, 0.22379, 0.25816,
0.29582, 0.33348, 0.34985, 0.3826, 0.45794, 0.49235, 0.51365, 0.54479, 0.57594, 0.60218, 0.62843,
0.77628, 0.796, 0.83298, 0.86995, 0.90936, 1.0, 1.0, 1.0, 1.0],
[1.3522591106779132e-19, 0.004087873896711868, 0.014374150571122216, 0.016455484312674015, 0.024946845435605228,
0.03592972456181881, 0.040710119644626126, 0.054518468768197687, 0.06976905178508139,
0.07587146190282387, 0.0985485829020452, 0.1238160142641967, 0.15558350087382017, 0.17487348629353283,
0.20157507610951217, 0.22995771158118564, 0.2683886931491415, 0.3574766835730407, 0.5027678906008036,
0.659729970241158, 0.7233389559355903, 0.8155475382785987, 0.8983628328699896, 0.9871204658597236, 1.0,
0.0, 0.0, 0.0, 0.0],
3])
Cv_char_equal_percentage = lambda opening: float(splev(opening, opening_equal_tck))
def convert_flow_coefficient(flow_coefficient, old_scale, new_scale):
'''Convert from one flow coefficient scale to another; supports the `Kv`
`Cv`, and `Av` scales.
Other scales are `Qn` and `Cg`, but clear definitions have yet to be
found.
Parameters
----------
flow_coefficient : float
Value of the flow coefficient to be converted, expressed in the
original scale.
old_scale : str
String specifying the original scale; one of 'Av', 'Cv', or 'Kv', [-]
new_scale : str
String specifying the new scale; one of 'Av', 'Cv', or 'Kv', [-]
Returns
-------
converted_flow_coefficient : float
Flow coefficient converted to the specified scale.
Notes
-----