Pular para conteúdo

Referência da API

Documentação gerada automaticamente a partir das docstrings do pacote.

Pacote

voluta

Voluta: geometria da carcaça, dimensionamento e visualização de sopradores.

O pacote reúne as equações do documento Matemática dos Sopradores em uma API Python testável e em uma interface de linha de comando.

Examples:

>>> from voluta import design_blower, volute_profile
>>> profile = volute_profile(turns=1.0)
>>> profile.outlet_radius
125.0
>>> design = design_blower(0.5, 1200, 3000)
>>> round(design.outlet_diameter_mm)
368

Geometria

voluta.geometry

Geometria da voluta (carcaça espiral) de um soprador centrífugo.

A voluta é modelada pela espiral de Arquimedes. Em coordenadas polares, o raio cresce linearmente com o ângulo polar medido a partir da língua da voluta:

.. math::

R(\theta) = R_2 + K \frac{\theta}{2\pi}

onde R2 é o raio externo do rotor e K é a taxa de expansão da voluta (comprimento por volta).

VoluteProfile dataclass

Perfil geométrico completo de uma voluta.

Attributes:

Name Type Description
theta FloatArray

Ângulos polares em radianos.

radius FloatArray

Raios da voluta em milímetros (ou na unidade adotada para r2 e k).

x, y

Coordenadas cartesianas correspondentes.

r2 float

Raio externo do rotor.

k float

Taxa de expansão da voluta por volta.

Source code in src/voluta/geometry.py
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
@dataclass(frozen=True, eq=False)
class VoluteProfile:
    """Perfil geométrico completo de uma voluta.

    Attributes
    ----------
    theta:
        Ângulos polares em radianos.
    radius:
        Raios da voluta em milímetros (ou na unidade adotada para ``r2`` e ``k``).
    x, y:
        Coordenadas cartesianas correspondentes.
    r2:
        Raio externo do rotor.
    k:
        Taxa de expansão da voluta por volta.
    """

    theta: FloatArray
    radius: FloatArray
    x: FloatArray
    y: FloatArray
    r2: float
    k: float

    @property
    def outlet_radius(self) -> float:
        """Raio da voluta no final do traçado."""
        return float(self.radius[-1])

    @property
    def turns(self) -> float:
        """Número de voltas cobertas pelo perfil."""
        return float((self.theta[-1] - self.theta[0]) / TWO_PI)

outlet_radius property

outlet_radius: float

Raio da voluta no final do traçado.

turns property

turns: float

Número de voltas cobertas pelo perfil.

volute_radius

volute_radius(
    theta: ArrayLike, *, r2: float = 100.0, k: float = 25.0
) -> FloatArray

Calcula o raio da voluta em função do ângulo polar.

Parameters:

Name Type Description Default
theta ArrayLike

Ângulo polar em radianos. Pode ser um escalar ou um array.

required
r2 float

Raio externo do rotor, na mesma unidade desejada para o resultado.

100.0
k float

Taxa de expansão da voluta por volta (unidade de comprimento por volta).

25.0

Returns:

Type Description
ndarray

Raio da voluta. Para uma entrada escalar, o resultado é um array 0-D.

Raises:

Type Description
ValueError

Se r2 não for positivo, k for negativo ou theta contiver valores não finitos.

Examples:

>>> float(volute_radius(0.0))
100.0
>>> float(volute_radius(2 * np.pi))
125.0
Source code in src/voluta/geometry.py
 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
def volute_radius(
    theta: ArrayLike,
    *,
    r2: float = 100.0,
    k: float = 25.0,
) -> FloatArray:
    """Calcula o raio da voluta em função do ângulo polar.

    Parameters
    ----------
    theta:
        Ângulo polar em radianos. Pode ser um escalar ou um array.
    r2:
        Raio externo do rotor, na mesma unidade desejada para o resultado.
    k:
        Taxa de expansão da voluta por volta (unidade de comprimento por volta).

    Returns
    -------
    numpy.ndarray
        Raio da voluta. Para uma entrada escalar, o resultado é um array 0-D.

    Raises
    ------
    ValueError
        Se ``r2`` não for positivo, ``k`` for negativo ou ``theta`` contiver
        valores não finitos.

    Examples
    --------
    >>> float(volute_radius(0.0))
    100.0
    >>> float(volute_radius(2 * np.pi))
    125.0
    """
    r2_value = positive(r2, "r2")
    k_value = non_negative(k, "k")

    try:
        theta_array = np.asarray(theta, dtype=float)
    except (TypeError, ValueError) as exc:
        raise TypeError("theta deve ser numérico.") from exc

    if not np.all(np.isfinite(theta_array)):
        raise ValueError("theta deve conter apenas valores finitos.")

    return r2_value + k_value * theta_array / TWO_PI

volute_profile

volute_profile(
    *,
    r2: float = 100.0,
    k: float = 25.0,
    turns: float = 1.5,
    samples: int = 1000,
    start_angle: float = 0.0,
) -> VoluteProfile

Gera o perfil cartesiano da voluta.

Parameters:

Name Type Description Default
r2 float

Raio externo do rotor.

100.0
k float

Taxa de expansão da voluta por volta.

25.0
turns float

Número de voltas do traçado. O valor padrão, 1.5, reproduz o exemplo original do projeto.

1.5
samples int

Quantidade de pontos do perfil. Deve ser pelo menos 2.

1000
start_angle float

Ângulo inicial em radianos.

0.0

Returns:

Type Description
VoluteProfile

Ângulos, raios e coordenadas cartesianas do perfil.

Examples:

>>> profile = volute_profile(turns=1.0, samples=5)
>>> len(profile.x)
5
>>> profile.outlet_radius
125.0
Source code in src/voluta/geometry.py
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
def volute_profile(
    *,
    r2: float = 100.0,
    k: float = 25.0,
    turns: float = 1.5,
    samples: int = 1000,
    start_angle: float = 0.0,
) -> VoluteProfile:
    """Gera o perfil cartesiano da voluta.

    Parameters
    ----------
    r2:
        Raio externo do rotor.
    k:
        Taxa de expansão da voluta por volta.
    turns:
        Número de voltas do traçado. O valor padrão, ``1.5``, reproduz o
        exemplo original do projeto.
    samples:
        Quantidade de pontos do perfil. Deve ser pelo menos 2.
    start_angle:
        Ângulo inicial em radianos.

    Returns
    -------
    VoluteProfile
        Ângulos, raios e coordenadas cartesianas do perfil.

    Examples
    --------
    >>> profile = volute_profile(turns=1.0, samples=5)
    >>> len(profile.x)
    5
    >>> profile.outlet_radius
    125.0
    """
    r2_value = positive(r2, "r2")
    k_value = non_negative(k, "k")
    turns_value = positive(turns, "turns")
    start = as_float(start_angle, "start_angle")

    if isinstance(samples, bool) or int(samples) != samples:
        raise TypeError("samples deve ser um número inteiro.")
    samples_value = int(samples)
    if samples_value < 2:
        raise ValueError("samples deve ser maior ou igual a 2.")

    theta = np.linspace(start, start + turns_value * TWO_PI, samples_value)
    radius = volute_radius(theta, r2=r2_value, k=k_value)

    return VoluteProfile(
        theta=theta,
        radius=radius,
        x=radius * np.cos(theta),
        y=radius * np.sin(theta),
        r2=r2_value,
        k=k_value,
    )

Aerodinâmica e dimensionamento

voluta.aero

Equações de dimensionamento e escalabilidade de sopradores centrífugos.

Todas as funções usam unidades do SI: metros, segundos, pascal, watt e rotações por minuto (RPM).

BlowerDesign dataclass

Resultado de um dimensionamento preliminar de soprador centrífugo.

Source code in src/voluta/aero.py
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
@dataclass(frozen=True)
class BlowerDesign:
    """Resultado de um dimensionamento preliminar de soprador centrífugo."""

    flow_rate_m3_s: float
    pressure_rise_pa: float
    rpm: float
    rho_kg_m3: float
    pressure_coefficient: float
    inlet_velocity_m_s: float
    efficiency: float
    tip_speed_m_s: float
    outlet_diameter_m: float
    inlet_diameter_m: float
    shaft_power_w: float

    @property
    def outlet_diameter_mm(self) -> float:
        """Diâmetro externo do rotor em milímetros."""
        return self.outlet_diameter_m * 1_000.0

    @property
    def inlet_diameter_mm(self) -> float:
        """Diâmetro de entrada do rotor em milímetros."""
        return self.inlet_diameter_m * 1_000.0

    @property
    def shaft_power_kw(self) -> float:
        """Potência no eixo em quilowatt."""
        return self.shaft_power_w / 1_000.0

    def to_dict(self) -> dict[str, Any]:
        """Converte o resultado em um dicionário serializável em JSON."""
        result = asdict(self)
        result.update(
            outlet_diameter_mm=self.outlet_diameter_mm,
            inlet_diameter_mm=self.inlet_diameter_mm,
            shaft_power_kw=self.shaft_power_kw,
        )
        return result

inlet_diameter_mm property

inlet_diameter_mm: float

Diâmetro de entrada do rotor em milímetros.

outlet_diameter_mm property

outlet_diameter_mm: float

Diâmetro externo do rotor em milímetros.

shaft_power_kw property

shaft_power_kw: float

Potência no eixo em quilowatt.

to_dict

to_dict() -> dict[str, Any]

Converte o resultado em um dicionário serializável em JSON.

Source code in src/voluta/aero.py
297
298
299
300
301
302
303
304
305
def to_dict(self) -> dict[str, Any]:
    """Converte o resultado em um dicionário serializável em JSON."""
    result = asdict(self)
    result.update(
        outlet_diameter_mm=self.outlet_diameter_mm,
        inlet_diameter_mm=self.inlet_diameter_mm,
        shaft_power_kw=self.shaft_power_kw,
    )
    return result

peripheral_velocity

peripheral_velocity(diameter_m: float, rpm: float) -> float

Velocidade periférica do rotor.

.. math::

U = \frac{\pi D N}{60}

Parameters:

Name Type Description Default
diameter_m float

Diâmetro do rotor em metros.

required
rpm float

Rotação em rotações por minuto.

required

Returns:

Type Description
float

Velocidade periférica em m/s.

Source code in src/voluta/aero.py
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def peripheral_velocity(diameter_m: float, rpm: float) -> float:
    """Velocidade periférica do rotor.

    .. math::

        U = \\frac{\\pi D N}{60}

    Parameters
    ----------
    diameter_m:
        Diâmetro do rotor em metros.
    rpm:
        Rotação em rotações por minuto.

    Returns
    -------
    float
        Velocidade periférica em m/s.
    """
    diameter = positive(diameter_m, "diameter_m")
    rotation = positive(rpm, "rpm")
    return math.pi * diameter * rotation / 60.0

euler_pressure

euler_pressure(
    u2: float,
    c_u2: float,
    *,
    u1: float = 0.0,
    c_u1: float = 0.0,
    rho: float = 1.2,
) -> float

Elevação de pressão teórica pela equação de Euler.

.. math::

\Delta P_{th} = \rho (U_2 C_{u2} - U_1 C_{u1})

Para entrada radial sem pré-rotação, C_u1 = 0.

Parameters:

Name Type Description Default
u2 float

Velocidade periférica e componente tangencial absoluta na saída (m/s).

required
c_u2 float

Velocidade periférica e componente tangencial absoluta na saída (m/s).

required
u1 float

Velocidade periférica e componente tangencial absoluta na entrada (m/s).

0.0
c_u1 float

Velocidade periférica e componente tangencial absoluta na entrada (m/s).

0.0
rho float

Massa específica do ar em kg/m³.

1.2

Returns:

Type Description
float

Elevação de pressão teórica em pascal.

Source code in src/voluta/aero.py
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
def euler_pressure(
    u2: float,
    c_u2: float,
    *,
    u1: float = 0.0,
    c_u1: float = 0.0,
    rho: float = 1.2,
) -> float:
    """Elevação de pressão teórica pela equação de Euler.

    .. math::

        \\Delta P_{th} = \\rho (U_2 C_{u2} - U_1 C_{u1})

    Para entrada radial sem pré-rotação, ``C_u1 = 0``.

    Parameters
    ----------
    u2, c_u2:
        Velocidade periférica e componente tangencial absoluta na saída (m/s).
    u1, c_u1:
        Velocidade periférica e componente tangencial absoluta na entrada (m/s).
    rho:
        Massa específica do ar em kg/m³.

    Returns
    -------
    float
        Elevação de pressão teórica em pascal.
    """
    u2_value = non_negative(u2, "u2")
    c_u2_value = as_float(c_u2, "c_u2")
    u1_value = non_negative(u1, "u1")
    c_u1_value = as_float(c_u1, "c_u1")
    rho_value = positive(rho, "rho")

    return rho_value * (u2_value * c_u2_value - u1_value * c_u1_value)

outlet_diameter

outlet_diameter(
    pressure_rise_pa: float,
    rpm: float,
    *,
    rho: float = 1.2,
    pressure_coefficient: float = 0.6,
) -> float

Diâmetro externo do rotor a partir do coeficiente de pressão.

.. math::

U_2 = \sqrt{\frac{2 \Delta P_t}{\rho \psi}},
\qquad D_2 = \frac{60 U_2}{\pi N}

Parameters:

Name Type Description Default
pressure_rise_pa float

Aumento de pressão total desejado em pascal.

required
rpm float

Rotação em RPM.

required
rho float

Massa específica do ar em kg/m³.

1.2
pressure_coefficient float

Coeficiente adimensional de pressão :math:\psi.

0.6

Returns:

Type Description
float

Diâmetro externo do rotor em metros.

Source code in src/voluta/aero.py
 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
def outlet_diameter(
    pressure_rise_pa: float,
    rpm: float,
    *,
    rho: float = 1.2,
    pressure_coefficient: float = 0.6,
) -> float:
    """Diâmetro externo do rotor a partir do coeficiente de pressão.

    .. math::

        U_2 = \\sqrt{\\frac{2 \\Delta P_t}{\\rho \\psi}},
        \\qquad D_2 = \\frac{60 U_2}{\\pi N}

    Parameters
    ----------
    pressure_rise_pa:
        Aumento de pressão total desejado em pascal.
    rpm:
        Rotação em RPM.
    rho:
        Massa específica do ar em kg/m³.
    pressure_coefficient:
        Coeficiente adimensional de pressão :math:`\\psi`.

    Returns
    -------
    float
        Diâmetro externo do rotor em metros.
    """
    pressure = positive(pressure_rise_pa, "pressure_rise_pa")
    rotation = positive(rpm, "rpm")
    rho_value = positive(rho, "rho")
    coefficient = positive(pressure_coefficient, "pressure_coefficient")

    tip_speed = math.sqrt(2.0 * pressure / (rho_value * coefficient))
    return 60.0 * tip_speed / (math.pi * rotation)

inlet_diameter

inlet_diameter(
    flow_rate_m3_s: float, inlet_velocity_m_s: float
) -> float

Diâmetro de entrada do rotor pela continuidade.

.. math::

D_1 = \sqrt{\frac{4Q}{\pi C_{1m}}}

Parameters:

Name Type Description Default
flow_rate_m3_s float

Vazão volumétrica em m³/s.

required
inlet_velocity_m_s float

Velocidade meridional na entrada em m/s. Valores usuais ficam entre 15 e 25 m/s.

required

Returns:

Type Description
float

Diâmetro de entrada em metros.

Source code in src/voluta/aero.py
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
def inlet_diameter(flow_rate_m3_s: float, inlet_velocity_m_s: float) -> float:
    """Diâmetro de entrada do rotor pela continuidade.

    .. math::

        D_1 = \\sqrt{\\frac{4Q}{\\pi C_{1m}}}

    Parameters
    ----------
    flow_rate_m3_s:
        Vazão volumétrica em m³/s.
    inlet_velocity_m_s:
        Velocidade meridional na entrada em m/s. Valores usuais ficam entre
        15 e 25 m/s.

    Returns
    -------
    float
        Diâmetro de entrada em metros.
    """
    flow = positive(flow_rate_m3_s, "flow_rate_m3_s")
    velocity = positive(inlet_velocity_m_s, "inlet_velocity_m_s")
    return math.sqrt(4.0 * flow / (math.pi * velocity))

blade_width

blade_width(
    flow_rate_m3_s: float,
    diameter_m: float,
    meridional_velocity_m_s: float,
) -> float

Largura da pá em uma seção, pela conservação de massa.

.. math::

b = \frac{Q}{\pi D C_m}

Parameters:

Name Type Description Default
flow_rate_m3_s float

Vazão volumétrica em m³/s.

required
diameter_m float

Diâmetro da seção em metros.

required
meridional_velocity_m_s float

Componente meridional da velocidade em m/s.

required

Returns:

Type Description
float

Largura da pá em metros.

Source code in src/voluta/aero.py
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
def blade_width(
    flow_rate_m3_s: float,
    diameter_m: float,
    meridional_velocity_m_s: float,
) -> float:
    """Largura da pá em uma seção, pela conservação de massa.

    .. math::

        b = \\frac{Q}{\\pi D C_m}

    Parameters
    ----------
    flow_rate_m3_s:
        Vazão volumétrica em m³/s.
    diameter_m:
        Diâmetro da seção em metros.
    meridional_velocity_m_s:
        Componente meridional da velocidade em m/s.

    Returns
    -------
    float
        Largura da pá em metros.
    """
    flow = positive(flow_rate_m3_s, "flow_rate_m3_s")
    diameter = positive(diameter_m, "diameter_m")
    velocity = positive(meridional_velocity_m_s, "meridional_velocity_m_s")
    return flow / (math.pi * diameter * velocity)

shaft_power

shaft_power(
    flow_rate_m3_s: float,
    pressure_rise_pa: float,
    *,
    efficiency: float = 0.7,
) -> float

Potência mecânica no eixo considerando a eficiência global.

.. math::

P_{eixo} = \frac{Q \Delta P_t}{\eta}

Parameters:

Name Type Description Default
flow_rate_m3_s float

Vazão volumétrica em m³/s.

required
pressure_rise_pa float

Aumento de pressão total em pascal.

required
efficiency float

Eficiência global entre 0 e 1.

0.7

Returns:

Type Description
float

Potência no eixo em watt.

Source code in src/voluta/aero.py
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
def shaft_power(
    flow_rate_m3_s: float,
    pressure_rise_pa: float,
    *,
    efficiency: float = 0.7,
) -> float:
    """Potência mecânica no eixo considerando a eficiência global.

    .. math::

        P_{eixo} = \\frac{Q \\Delta P_t}{\\eta}

    Parameters
    ----------
    flow_rate_m3_s:
        Vazão volumétrica em m³/s.
    pressure_rise_pa:
        Aumento de pressão total em pascal.
    efficiency:
        Eficiência global entre 0 e 1.

    Returns
    -------
    float
        Potência no eixo em watt.
    """
    flow = positive(flow_rate_m3_s, "flow_rate_m3_s")
    pressure = positive(pressure_rise_pa, "pressure_rise_pa")
    eta = positive(efficiency, "efficiency")
    if eta > 1.0:
        raise ValueError("efficiency deve estar entre 0 e 1.")

    return flow * pressure / eta

affinity_flow

affinity_flow(
    flow_rate_m3_s: float,
    *,
    speed_ratio: float = 1.0,
    diameter_ratio: float = 1.0,
) -> float

Nova vazão pelas leis de afinidade.

.. math::

Q_2 = Q_1 \left(\frac{N_2}{N_1}\right)
\left(\frac{D_2}{D_1}\right)^3
Source code in src/voluta/aero.py
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
def affinity_flow(
    flow_rate_m3_s: float,
    *,
    speed_ratio: float = 1.0,
    diameter_ratio: float = 1.0,
) -> float:
    """Nova vazão pelas leis de afinidade.

    .. math::

        Q_2 = Q_1 \\left(\\frac{N_2}{N_1}\\right)
        \\left(\\frac{D_2}{D_1}\\right)^3
    """
    flow = positive(flow_rate_m3_s, "flow_rate_m3_s")
    n_ratio = positive_ratio(speed_ratio, "speed_ratio")
    d_ratio = positive_ratio(diameter_ratio, "diameter_ratio")
    return flow * n_ratio * d_ratio**3

affinity_pressure

affinity_pressure(
    pressure_rise_pa: float,
    *,
    speed_ratio: float = 1.0,
    diameter_ratio: float = 1.0,
) -> float

Nova elevação de pressão pelas leis de afinidade.

.. math::

\Delta P_2 = \Delta P_1 \left(\frac{N_2}{N_1}\right)^2
\left(\frac{D_2}{D_1}\right)^2
Source code in src/voluta/aero.py
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
def affinity_pressure(
    pressure_rise_pa: float,
    *,
    speed_ratio: float = 1.0,
    diameter_ratio: float = 1.0,
) -> float:
    """Nova elevação de pressão pelas leis de afinidade.

    .. math::

        \\Delta P_2 = \\Delta P_1 \\left(\\frac{N_2}{N_1}\\right)^2
        \\left(\\frac{D_2}{D_1}\\right)^2
    """
    pressure = positive(pressure_rise_pa, "pressure_rise_pa")
    n_ratio = positive_ratio(speed_ratio, "speed_ratio")
    d_ratio = positive_ratio(diameter_ratio, "diameter_ratio")
    return pressure * n_ratio**2 * d_ratio**2

affinity_power

affinity_power(
    power_w: float,
    *,
    speed_ratio: float = 1.0,
    diameter_ratio: float = 1.0,
) -> float

Nova potência pelas leis de afinidade.

.. math::

P_2 = P_1 \left(\frac{N_2}{N_1}\right)^3
\left(\frac{D_2}{D_1}\right)^5
Source code in src/voluta/aero.py
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
def affinity_power(
    power_w: float,
    *,
    speed_ratio: float = 1.0,
    diameter_ratio: float = 1.0,
) -> float:
    """Nova potência pelas leis de afinidade.

    .. math::

        P_2 = P_1 \\left(\\frac{N_2}{N_1}\\right)^3
        \\left(\\frac{D_2}{D_1}\\right)^5
    """
    power = positive(power_w, "power_w")
    n_ratio = positive_ratio(speed_ratio, "speed_ratio")
    d_ratio = positive_ratio(diameter_ratio, "diameter_ratio")
    return power * n_ratio**3 * d_ratio**5

design_blower

design_blower(
    flow_rate_m3_s: float,
    pressure_rise_pa: float,
    rpm: float,
    *,
    rho: float = 1.2,
    pressure_coefficient: float = 0.6,
    inlet_velocity_m_s: float = 20.0,
    efficiency: float = 0.7,
) -> BlowerDesign

Dimensiona os principais parâmetros geométricos de um soprador.

O cálculo combina o coeficiente de pressão, a continuidade na entrada e a potência no eixo. O resultado é preliminar e não substitui a verificação de perdas, resistência mecânica e curvas reais do rotor.

Parameters:

Name Type Description Default
flow_rate_m3_s float

Vazão volumétrica em m³/s.

required
pressure_rise_pa float

Aumento de pressão total em pascal.

required
rpm float

Rotação em RPM.

required
rho float

Massa específica do ar em kg/m³.

1.2
pressure_coefficient float

Coeficiente adimensional de pressão :math:\psi.

0.6
inlet_velocity_m_s float

Velocidade meridional na entrada em m/s.

20.0
efficiency float

Eficiência global entre 0 e 1.

0.7

Returns:

Type Description
BlowerDesign

Diâmetros, velocidade periférica e potência no eixo.

Source code in src/voluta/aero.py
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
def design_blower(
    flow_rate_m3_s: float,
    pressure_rise_pa: float,
    rpm: float,
    *,
    rho: float = 1.2,
    pressure_coefficient: float = 0.6,
    inlet_velocity_m_s: float = 20.0,
    efficiency: float = 0.7,
) -> BlowerDesign:
    """Dimensiona os principais parâmetros geométricos de um soprador.

    O cálculo combina o coeficiente de pressão, a continuidade na entrada e a
    potência no eixo. O resultado é preliminar e não substitui a verificação
    de perdas, resistência mecânica e curvas reais do rotor.

    Parameters
    ----------
    flow_rate_m3_s:
        Vazão volumétrica em m³/s.
    pressure_rise_pa:
        Aumento de pressão total em pascal.
    rpm:
        Rotação em RPM.
    rho:
        Massa específica do ar em kg/m³.
    pressure_coefficient:
        Coeficiente adimensional de pressão :math:`\\psi`.
    inlet_velocity_m_s:
        Velocidade meridional na entrada em m/s.
    efficiency:
        Eficiência global entre 0 e 1.

    Returns
    -------
    BlowerDesign
        Diâmetros, velocidade periférica e potência no eixo.
    """
    flow = positive(flow_rate_m3_s, "flow_rate_m3_s")
    pressure = positive(pressure_rise_pa, "pressure_rise_pa")
    rotation = positive(rpm, "rpm")
    rho_value = positive(rho, "rho")
    coefficient = positive(pressure_coefficient, "pressure_coefficient")
    inlet_velocity = positive(inlet_velocity_m_s, "inlet_velocity_m_s")
    eta = positive(efficiency, "efficiency")
    if eta > 1.0:
        raise ValueError("efficiency deve estar entre 0 e 1.")

    tip_speed = math.sqrt(2.0 * pressure / (rho_value * coefficient))
    d2 = 60.0 * tip_speed / (math.pi * rotation)
    d1 = math.sqrt(4.0 * flow / (math.pi * inlet_velocity))
    power = flow * pressure / eta

    return BlowerDesign(
        flow_rate_m3_s=flow,
        pressure_rise_pa=pressure,
        rpm=rotation,
        rho_kg_m3=rho_value,
        pressure_coefficient=coefficient,
        inlet_velocity_m_s=inlet_velocity,
        efficiency=eta,
        tip_speed_m_s=tip_speed,
        outlet_diameter_m=d2,
        inlet_diameter_m=d1,
        shaft_power_w=power,
    )

Visualização

voluta.plots

Visualização do perfil da voluta com matplotlib.

plot_volute

plot_volute(
    profile: VoluteProfile | None = None,
    *,
    r2: float = 100.0,
    k: float = 25.0,
    turns: float = 1.5,
    samples: int = 1000,
    output: str | Path | None = None,
    dpi: int = 150,
    show: bool = False,
    title: str = DEFAULT_TITLE,
) -> Figure

Plota o perfil da voluta e o rotor.

Se profile não for informado, o perfil é criado com volute_profile usando r2, k, turns e samples.

Parameters:

Name Type Description Default
profile VoluteProfile | None

Perfil já calculado. Quando omitido, é gerado a partir dos parâmetros.

None
r2 float

Parâmetros usados apenas quando profile é None.

100.0
k float

Parâmetros usados apenas quando profile é None.

100.0
turns float

Parâmetros usados apenas quando profile é None.

100.0
samples float

Parâmetros usados apenas quando profile é None.

100.0
output str | Path | None

Caminho opcional para salvar a figura (PNG, SVG, PDF etc.).

None
dpi int

Resolução usada ao salvar a figura.

150
show bool

Se True, abre a janela interativa do matplotlib.

False
title str

Título do gráfico.

DEFAULT_TITLE

Returns:

Type Description
Figure

Figura criada. Quando show=False, a figura é fechada antes do retorno para liberar memória.

Source code in src/voluta/plots.py
 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
def plot_volute(
    profile: VoluteProfile | None = None,
    *,
    r2: float = 100.0,
    k: float = 25.0,
    turns: float = 1.5,
    samples: int = 1000,
    output: str | Path | None = None,
    dpi: int = 150,
    show: bool = False,
    title: str = DEFAULT_TITLE,
) -> Figure:
    """Plota o perfil da voluta e o rotor.

    Se ``profile`` não for informado, o perfil é criado com ``volute_profile``
    usando ``r2``, ``k``, ``turns`` e ``samples``.

    Parameters
    ----------
    profile:
        Perfil já calculado. Quando omitido, é gerado a partir dos parâmetros.
    r2, k, turns, samples:
        Parâmetros usados apenas quando ``profile`` é ``None``.
    output:
        Caminho opcional para salvar a figura (PNG, SVG, PDF etc.).
    dpi:
        Resolução usada ao salvar a figura.
    show:
        Se ``True``, abre a janela interativa do matplotlib.
    title:
        Título do gráfico.

    Returns
    -------
    matplotlib.figure.Figure
        Figura criada. Quando ``show=False``, a figura é fechada antes do
        retorno para liberar memória.
    """
    if profile is None:
        profile = volute_profile(r2=r2, k=k, turns=turns, samples=samples)

    fig, ax = plt.subplots(figsize=(7, 7))
    draw_volute(ax, profile, title=title)
    fig.tight_layout()

    if output is not None:
        destination = Path(output)
        destination.parent.mkdir(parents=True, exist_ok=True)
        fig.savefig(destination, dpi=dpi)

    if show:
        plt.show()
    else:
        plt.close(fig)

    return fig

Linha de comando

voluta.cli

Interface de linha de comando do projeto.

build_parser

build_parser() -> argparse.ArgumentParser

Cria o parser de argumentos da CLI.

Source code in src/voluta/cli.py
 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
def build_parser() -> argparse.ArgumentParser:
    """Cria o parser de argumentos da CLI."""
    parser = argparse.ArgumentParser(
        prog="voluta",
        description="Geometria e dimensionamento de sopradores centrífugos.",
    )
    parser.add_argument(
        "--version",
        action="version",
        version=f"%(prog)s {_package_version()}",
    )
    subparsers = parser.add_subparsers(dest="command", required=True)

    plot_parser = subparsers.add_parser(
        "plot",
        help="Gera o traçado da voluta em uma imagem.",
        description="Gera o traçado geométrico da voluta e do rotor.",
    )
    plot_parser.add_argument("--r2", type=float, default=100.0, help="Raio externo do rotor.")
    plot_parser.add_argument("--k", type=float, default=25.0, help="Expansão da voluta por volta.")
    plot_parser.add_argument(
        "--turns", type=float, default=1.5, help="Número de voltas do traçado."
    )
    plot_parser.add_argument("--samples", type=int, default=1000, help="Pontos do perfil.")
    plot_parser.add_argument(
        "--output",
        type=Path,
        default=Path("voluta.png"),
        help="Arquivo de saída (padrão: voluta.png).",
    )
    plot_parser.add_argument("--dpi", type=int, default=150, help="Resolução da imagem.")
    plot_parser.add_argument("--title", default=None, help="Título personalizado do gráfico.")
    plot_parser.add_argument(
        "--show",
        action="store_true",
        help="Abre a janela interativa em vez de apenas salvar.",
    )

    design_parser = subparsers.add_parser(
        "design",
        help="Calcula um dimensionamento preliminar do soprador.",
        description="Calcula diâmetros, velocidade periférica e potência no eixo.",
    )
    design_parser.add_argument("--flow", type=float, required=True, help="Vazão em m³/s.")
    design_parser.add_argument(
        "--pressure",
        type=float,
        required=True,
        help="Elevação de pressão total em Pa.",
    )
    design_parser.add_argument("--rpm", type=float, required=True, help="Rotação em RPM.")
    design_parser.add_argument("--rho", type=float, default=1.2, help="Massa específica do ar.")
    design_parser.add_argument(
        "--psi",
        type=float,
        default=0.6,
        help="Coeficiente adimensional de pressão.",
    )
    design_parser.add_argument(
        "--inlet-velocity",
        type=float,
        default=20.0,
        help="Velocidade meridional na entrada em m/s.",
    )
    design_parser.add_argument(
        "--efficiency",
        type=float,
        default=0.7,
        help="Eficiência global entre 0 e 1.",
    )
    design_parser.add_argument("--json", action="store_true", help="Imprime o resultado em JSON.")

    gui_parser = subparsers.add_parser(
        "gui",
        help="Abre a interface gráfica Qt.",
        description="Abre a interface gráfica para explorar a geometria e o dimensionamento.",
    )
    gui_parser.add_argument(
        "--smoke-test",
        action="store_true",
        help=argparse.SUPPRESS,
    )

    return parser

main

main(argv: Sequence[str] | None = None) -> int

Executa a CLI e retorna o código de saída.

Source code in src/voluta/cli.py
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
def main(argv: Sequence[str] | None = None) -> int:
    """Executa a CLI e retorna o código de saída."""
    parser = build_parser()
    args = parser.parse_args(argv)

    try:
        if args.command == "plot":
            profile = volute_profile(
                r2=args.r2,
                k=args.k,
                turns=args.turns,
                samples=args.samples,
            )
            kwargs = {}
            if args.title is not None:
                kwargs["title"] = args.title
            plot_volute(
                profile,
                output=args.output,
                dpi=args.dpi,
                show=args.show,
                **kwargs,
            )
            if not args.show:
                print(f"Figura salva em: {args.output.resolve()}")
            return 0

        if args.command == "design":
            design = design_blower(
                flow_rate_m3_s=args.flow,
                pressure_rise_pa=args.pressure,
                rpm=args.rpm,
                rho=args.rho,
                pressure_coefficient=args.psi,
                inlet_velocity_m_s=args.inlet_velocity,
                efficiency=args.efficiency,
            )
            if args.json:
                print(json.dumps(design.to_dict(), indent=2, ensure_ascii=False))
            else:
                print(_format_design(design))
            return 0

        if args.command == "gui":
            if find_spec("PySide6") is None:
                parser.error("A interface gráfica requer PySide6. Instale com: uv sync --group gui")
            try:
                from .gui import run
            except ImportError as exc:
                parser.error(
                    "Não foi possível carregar a interface gráfica Qt.\n"
                    f"Detalhe: {exc}\n"
                    "No Linux/NixOS, verifique as bibliotecas de sistema do Qt "
                    "(libGL, libxkbcommon, libxcb, libX11 e dbus)."
                )
            return run(smoke_test=args.smoke_test)
    except (TypeError, ValueError) as exc:
        parser.error(str(exc))

    parser.error("comando não reconhecido")
    return 2