12 KiB
12 KiB
VentoApp: Plataforma para Cálculo de Forças Devidas ao Vento (NBR 6123:2023)
Plano Técnico de Implantação e Arquitetura de Software
Este documento serve como especificação técnica detalhada para o desenvolvimento do VentoApp. Ele foi estruturado para guiar engenheiros de software e Modelos de Linguagem (LLMs) na codificação completa da plataforma, garantindo rigor normativo, responsividade multiplataforma (mobile/desktop), interatividade 3D orbital e precisão de cálculo.
1. Stack Tecnológica Recomendada
Para atender à exigência de rodar em dispositivos móveis e desktops com alto desempenho gráfico (3D) e capacidade offline, a arquitetura recomendada é baseada em web standards modernos:
- Frontend Framework: React.js ou Vue.js (com TypeScript para garantir tipagem estática e evitar bugs matemáticos).
- Build Tool: Vite (rápido e otimizado).
- Engine 3D: Three.js com React Three Fiber (R3F) para controle declarativo do ambiente 3D, ou BabylonJS.
- Estilização (UI/UX): Vanilla CSS ou Tailwind CSS, utilizando conceitos de glassmorphism, temas Dark/Light nativos e transições suaves de micro-interações.
- Gerenciador de Estado: Redux Toolkit ou Zustand (Zustand é recomendado pela simplicidade em aplicações com intensa reatividade gráfica).
- Banco de Dados Local (Offline): IndexedDB (via biblioteca Wrapper
Dexie.js) para persistência de projetos no navegador do usuário sem necessidade de conexão imediata com o backend. - Geração de PDF:
react-pdfoujspdfcombinada comhtml2canvaspara renderização de relatórios altamente diagramados diretamente no cliente. - Módulos de Teste: Jest ou Vitest (essencial para validar as rotinas matemáticas de forma rigorosa).
2. Arquitetura de Software (Engine de Cálculo)
A Engine de Cálculo deve ser isolada da interface do usuário. Recomenda-se utilizar o padrão de projeto Strategy para desacoplar as regras de carregamento de vento de acordo com o tipo de estrutura geométrica.
Diagrama Conceitual de Classes/Módulos:
+--------------------------------+
| Configuração Global |
| (V0, S1, S2, S3, Categoria, |
| Classe, Rugosidade, z) |
+--------------------------------+
|
v
+--------------------------------+
| Kernel de Pressão (q) |
| Calcula Vk e Dinâmica q |
+--------------------------------+
|
+---------------------+---------------------+
| | |
v v v
+-----------------+ +-----------------+ +-----------------+
| Calculadora | | Calculadora | | Calculadora |
| Galpao | | TorreTrel | | SiloCilindro |
| (Strategy A) | | (Strategy B) | | (Strategy C) |
+-----------------+ +-----------------+ +-----------------+
| | |
+---------------------+---------------------+
|
v
+--------------------------------+
| Conversor de Cargas Globais |
| e Coeficientes Locais |
+--------------------------------+
3. Lógica e Modelagem Matemática (NBR 6123)
O Kernel do sistema deve programar rigorosamente as seguintes equações físicas:
3.1. Pressão Dinâmica Básica
-
Velocidade Característica (
V_k):V_k = V_0 \cdot S_1 \cdot S_2 \cdot S_3Onde:
V_0: Velocidade básica do vento (obtida do banco de dados de isopletas/municípios do Brasil ou inserida manualmente pelo usuário).S_1: Fator topográfico (Fórmulas para taludes/encostas e vales conforme Seção 5.2 da norma).S_2: Fator de rugosidade e dimensões (Equação exponencial:S_2 = b \cdot F_r \cdot (z/10)^ponde os parâmetrosb,F_repdependem da categoria de rugosidade (I a V) e da classe da estrutura (A, B, C) conforme Tabela 2 da norma).S_3: Fator estatístico (Valores discretos definidos conforme o grupo de ocupação da estrutura, variando de0,83a1,10conforme Tabela 3).
-
Pressão Dinâmica (
q):q = 0,613 \cdot V_k^2 \quad (\text{em } N/m^2 \text{ ou } Pa)
3.2. Mecanismo de Interpolação de Tabelas (NBR 6123)
Muitas tabelas da norma fornecem coeficientes de pressão externa (C_{pe}) discretos para relações geométricas específicas (ex: h/b = 0.5, 1.0, 2.0 e a/b = 1.0, 1.5, 2.0, 4.0).
- A Engine de Cálculo deve implementar uma função de Interpolação Bilinear para mapear dados geométricos exatos inseridos pelo usuário.
- Fórmula de Interpolação Bilinear:
Dados quatro pontos conhecidos
Q_{11}(x_1, y_1),Q_{12}(x_1, y_2),Q_{21}(x_2, y_1)eQ_{22}(x_2, y_2), a interpolação para o ponto(x, y)é dada por:f(x, y) \approx \frac{(x_2 - x)(y_2 - y)}{(x_2 - x_1)(y_2 - y_1)} f(Q_{11}) + \frac{(x - x_1)(y_2 - y)}{(x_2 - x_1)(y_2 - y_1)} f(Q_{21}) + \frac{(x_2 - x)(y - y_1)}{(x_2 - x_1)(y_2 - y_1)} f(Q_{12}) + \frac{(x - x_1)(y - y_1)}{(x_2 - x_1)(y_2 - y_1)} f(Q_{22})
4. Estrutura dos Módulos Geométricos
O app deve comportar o cadastro das seguintes estruturas físicas de forma independente:
4.1. Módulo Galpão Retangular (Edificações Correntes)
- Entradas de dados necessárias:
- Comprimento (
a), Largura (b), Pé-direito lateral (h), Inclinação do telhado (\thetaou %). - Espaçamento entre pórticos principais (para linearização de cargas em pilares).
- Espaçamento entre terças (para linearização de cargas no telhado).
- Permeabilidade das paredes (área de abertura em cada uma das 4 fachadas e seleção de abertura dominante ativa para o cálculo de
C_{pi}).
- Comprimento (
- Lógica interna:
- Mapeia as zonas de parede (A, B, C, D) e cobertura (E, F, G, H, I, J) conforme as Tabelas 4 e 5 da NBR 6123.
- Calcula a pressão interna combinada
C_{pi}(limites normativos+0,9a-0,9, dependendo das aberturas). - Executa a combinação de cargas:
p = (C_{pe} - C_{pi}) \cdot q. - Saída: Vetores de pressão local aplicados em cada região.
4.2. Módulo Torres de Linhas de Transmissão e Telecomunicações
- Entradas de dados necessárias:
- Altura da torre (
H), largura da base (B_{base}), largura do topo (B_{topo}). - Número de tramos (módulos verticais).
- Tipo de seção (Triangular ou Quadrada).
- Perfis constitutivos (Cantoneiras de abas iguais ou Perfis Tubulares).
- Taxa de solidez da treliça (
\phi).
- Altura da torre (
- Lógica interna:
- Determina o coeficiente de arrasto (
C_a) para vento perpendicular e vento diagonal conforme Tabela 18 da norma. - Aplica fatores de blindagem caso haja painéis paralelos.
- Calcula a força global por tramo usando a fórmula de força de arrasto:
F = C_a \cdot q \cdot A_e(OndeA_eé a área efetiva projetada dos membros da torre).
- Determina o coeficiente de arrasto (
4.3. Módulo Silos Cilíndricos e Reservatórios
- Entradas de dados necessárias:
- Diâmetro (
D), Altura do cilindro (H), Tipo de cobertura (plana, cônica, calota esférica).
- Diâmetro (
- Lógica interna:
- Calcula os coeficientes de pressão externa como função do ângulo de incidência do vento (
\alpha, variando de0^\circa180^\circ) conforme a Figura 16 da norma. - Aplica fatores de correção para relação
H/D.
- Calcula os coeficientes de pressão externa como função do ângulo de incidência do vento (
5. Visualização 3D Orbital e Experiência do Usuário (UI/UX)
A interface deve ser desenhada com o fluxo em etapas ("Wizard") e com o visualizador 3D acoplado:
5.1. O Visualizador 3D (Implementação WebGL)
- Utilizar React Three Fiber para renderizar um modelo paramétrico da estrutura selecionada.
- O modelo é gerado proceduralmente com base nos inputs de largura, comprimento, altura e inclinação.
- Texturas Dinâmicas (Mapas de Pressão / Vertex Coloring):
- Mapear as coordenadas 3D de cada polígono do modelo para a sua respectiva zona de pressão.
- Pintar os polígonos usando um gradiente de cores:
- Vermelho/Laranja: Altas pressões positivas (esforço empurrando para dentro da estrutura).
- Azul/Roxo: Altas pressões negativas (sucção/arrancamento).
- Verde/Cinza: Zonas neutras ou de baixa pressão.
- Mostrar setas indicativas de força tridimensionais (vetores normais às superfícies) saindo ou entrando nas faces da estrutura de acordo com a hipótese de vento selecionada.
5.2. Interatividade no Modelo 3D
- Controle Orbital: Rotação livre com botão esquerdo do mouse (desktop) ou arrastar com um dedo (mobile); Pan com botão direito/dois dedos; Zoom com scroll/pinch.
- Raycasting para Inspeção: Ao clicar (ou tocar) em um polígono do modelo 3D, o sistema deve detectar a zona colidida e disparar uma gaveta de informações (Drawer lateral) mostrando o memorial de cálculo daquela face da estrutura.
6. Fluxo de Geração de Relatórios e Exportação de Dados
O aplicativo deve gerar memórias de cálculo profissionais em formato PDF e permitir a integração com outros softwares.
6.1. Memorial em PDF Ilustrado (Didático)
O PDF exportado deve seguir uma estrutura moderna com grid limpo:
- Capa: Nome do projeto, dados do cliente, engenheiro responsável, ART/CREA, data e localização geográfica.
- Fatores Globais: Tabela com valores e justificativas adotadas para
V_0, S_1, S_2, S_3e o valor resultante da pressão dinâmica de projeto (q). - Modelagem 3D Estática: Captura de tela gerada automaticamente pelo canvas do WebGL mostrando o mapa de calor de pressões para as principais hipóteses de vento.
- Tabelas de Carga de Projeto: Planilhas detalhadas das pressões em cada parede e vertente de telhado para vento a
0^\circe90^\circ, combinadas com sobrepressão e sucção interna. - Equações Passo a Passo: Renderização de fórmulas matemáticas formatadas em LaTeX (com substituição numérica passo a passo) para fins de auditoria acadêmica.
6.2. Exportação de Dados para Softwares Estruturais
- Ftool Integration: Exportação de um arquivo formato texto com extensão proprietária compatível com o Ftool, onde o pórtico representativo do galpão já vem desenhado com todas as cargas lineares distribuídas aplicadas sobre as barras.
- Formatos Abertos: Exportação de dados das cargas em formato CSV/Excel ou arquivo JSON estruturado para que o engenheiro possa importar em sistemas internos ou outros softwares de cálculo estrutural tridimensional.
7. Estratégia de Testes e Validação de Confiabilidade
Para garantir que o aplicativo seja auditável e 100% confiável, a seguinte rotina de testes deve ser implementada no processo de CI/CD (Integração Contínua):
- Testes de Unidade Matemáticos (Vitest/Jest):
- Cadastrar uma suite de testes unitários baseados nos exemplos resolvidos de livros de referência (ex: "O Vento na Engenharia Estrutural", de J. Blessmann, ou manuais acadêmicos de vento em galpões).
- O teste insere dimensões idênticas às dos exemplos e valida, casa decimal por casa decimal, se os coeficientes e pressões finais obtidos pela engine do app batem exatamente com as referências bibliográficas.
- Qualquer alteração no código que altere os resultados de cálculo gera falha no build, impedindo a publicação de versões com erros de engenharia.