Estudo de caso – Comparativo entre laje de 10 e 12 cm no custo global

Quando um cliente nos pede para analisar custos, uma das primeiras perguntas que surgem é sobre a espessura das lajes. A lógica parece simples: “Se eu diminuir a laje de 12cm para 10cm, vou precisar de mais aço pra combater esses esforços, certo?”

A resposta é: sim, mas…

Uma análise de engenharia nunca pode parar no elemento isolado. Um projeto estrutural é um sistema complexo onde tudo está interligado. A “economia” em um ponto pode facilmente se transformar em um custo extra em outro.

Para demonstrar isso, foi-se realizado um estudo comparativo em um projeto real, analisando o custo global da estrutura em dois cenários:

  • Cenário 1: Todas as lajes com 10cm
  • Cenário 2: Todas as lajes com 12cm

Os custos dos materiais, fck (C40) e dimensões de vigas e pilares foram mantidos. O que mudou foi apenas a espessura da laje.


Análise 1: A “Economia Local” (Olhando só a Laje)

Se o nosso trabalho dependesse somente de um estudo localizado olhando o elemento principal, os nossos resultados seriam mostrados em algo parecido com a tabela “Custos Lajes”:

Ao reduzir a espessura para 10cm teríamos uma redução no custo do concreto, mas teríamos um aumento de 8,34% no custo do aço utilizado nas lajes. Mas por que a laje com espessura menor teve um maior consumo de aço? Isso se dá pelo fato de que uma laje de 10cm tem menos concreto útil que uma laje de 12, resultando em uma área de aço necessária maior. A versão com laje de 12 é mais barata pois a economia no aço é maior do que o aumento do custo do concreto.

Resposta 1: Laje de 12 é mais econômica.


Análise 2: A “Verdade Global” (O Impacto do consumo de concreto)

Mas não podemos esquecer de um detalhe, uma estrutura de concreto armado nunca deve ser avaliada de forma local, precisamos avaliar o contexto inteiro. Para fazer uma análise mais globalizada, iremos observar a tabela de consumo de concreto e aço deste edifício:

Observa-se que apesar do consumo de aço da estrutura ser 0,09% menor quando se utiliza laje de 12cm, o volume de concreto fica em torno de 7,85% maior. Mas o que isso implicaria na prática? É melhor economizar no aço ou no concreto? Tendo esses questionamentos em mente, foi-se realizado um estudo no custo global desta obra para termos certeza da melhor escolha para o cliente.

Dessa maneira, nota-se que para este estudo, a utilização de lajes de 10cm de altura seria vantajoso para este cliente. Apesar da obra ficar 0,15% mais cara se olhássemos somente o aço a ser consumido, há uma economia de 7,85% no valor do concreto. Mas por que com a laje de 10 o consumo de aço global tem essa pouca diferença, se no estudo local a diferença era maior? A resposta é que a laje de 10 tem um peso próprio menor, que acumulado em 27 andares traz economia para vigas e pilares. Este fato somado à economia de concreto acumulada em todos os andares resulta na seguinte conclusão:

Resposta 2: Laje de 10 é mais econômica.

Esta é a lição mais importante: É preciso analisar todos os parâmetros de um projeto para saber seu real custo-benefício e as melhores escolhas.


Conclusão

Analisando o custo global da obra com quantitativos de concreto e aço simultâneamente, temos os seguintes valores:

  • Custo Total da Estrutura (Laje 10): R$ 3.830.323,98
  • Custo Total da Estrutura (Laje 12): R$ 3.962.818,78

Mesmo com a diferença de aço não sendo tão significante, o estudo de aço junto ao concreto nos deu a diferença final de R$ 132.494,80, o que representa uma economia global de 3,34%.

Isso nos mostra que uma decisão estrutural nunca deve ser tomada olhando para uma “foto” (só a volume de aço), mas sim para o “filme” (a estrutura inteira). Assim, podendo economizar aproximadamente 130 mil reais neste empreendimento, o que é um bom resultado e somente UM dos estudos realizados para este empreendimento.

O que você achou deste resultado? Deseja ver mais informações sobre como economizar em sua obra? Deixe seu comentário!

Como criar menus em Python no TQS (EAG.PYMEN e EAGXXX.PYMEN)

Este artigo ensina a transformar scripts Python em menus nativos nos editores gráficos do TQS (EAG), automatizando tarefas repetitivas com comandos de um clique. O tutorial técnico cobre a localização, criação e estruturação dos arquivos .PYMEN (tanto globais quanto específicos por aplicação), além de detalhar a assinatura padrão das funções Python necessárias para interagir diretamente com os desenhos.

A criação de menus Python no TQS é hoje um dos jeitos mais eficientes de transformar tarefas repetitivas em comandos de um clique dentro dos editores gráficos (EAG). Em vez de “rodar um script”, você passa a ter um item de menu nativo chamando sua rotina em Python.

Abaixo faço um passo a passo direto ao ponto, usando como base o manual oficial do TQS e exemplos reais (como os menus de alvenaria desenvolvidos pela BRGT).


No TQS, os editores gráficos (EAGW.EXE) são configurados por menus do tipo .MEN, armazenados em TQSW\EXEC\EAGMENU. Eles apontam para comandos escritos em DLLs C++ – é o menu padrão que você já usa.

A interface Python entra como uma extensão desse menu:

  • Para cada EAGXXX.MEN carregado, o editor tenta carregar automaticamente um arquivo EAGXXX.PYMEN na pasta TQSW\EXEC\Python.
  • A partir da versão V24, sempre que um editor gráfico abre, ele tenta carregar antes o menu EAG.PYMEN, que é um menu Python comum a todos os editores (formas, ferros, alvenaria, modelador etc.).

Isso significa que você pode:

  • Ter comandos globais (em EAG.PYMEN, valendo em qualquer editor);
  • Ter comandos específicos de uma aplicação (por exemplo, EAGALV.PYMEN só para Alvenaria em planta).

2. Estrutura básica de um arquivo .PYMEN

Um menu Python segue praticamente a mesma lógica dos menus .MEN, mas trocando DLL por módulo Python. A estrutura típica é:

ini
[PYTHON]
EAGALV.PY

[CMD]
ID_EXEMPLO,EAGALV.PY,meu_comando
Texto de ajuda do comando

[MENU]
SUBMENU,&BRGT – Automação
MENUITEM,ID_EXEMPLO,Executar &exemplo
FIMSUBMENU

Pontos importantes:

  • [PYTHON] – lista os módulos .PY que o menu pode chamar (devem estar em TQSW\EXEC\Python).
  • [CMD] – para cada comando:
  • um ID (ID_EXEMPLO),
  • o nome do módulo (EAGALV.PY),
  • o nome da função Python (meu_comando),
  • e uma linha de ajuda que aparece em tooltip/rodapé.
  • [MENU] – monta o menu dropdown:
  • SUBMENU abre um menu,
  • MENUITEM associa um item ao ID,
  • SEPARADOR insere linhas de separação,
  • FIMSUBMENU fecha o submenu.

O & no texto do menu define o atalho de teclado (Alt + letra).


3. Assinatura das rotinas Python chamadas pelo menu

Toda função chamada por um .PYMEN tem sempre a mesma assinatura:

python
def seu_comando(eag, tqsjan):
…

Onde:

  • eag é um objeto TQSEag.Eag (controle do editor: menus, estados, entrada simulada, mensagens, execuções de comando etc.);
  • tqsjan é um objeto TQSJan.Window, que dá acesso à janela e ao desenho aberto;
  • o desenho em si é tqsjan.dwg, um TQSDwg.Dwg, permitindo ler e alterar elementos do DWG.

Exemplo simplificado baseado na lógica dos exemplos oficiais:

python
from TQS import TQSDwg, TQSEag

def meu_comando(eag, tqsjan):
dwg = tqsjan.dwg
# Exemplo bem simples: dar zoom total e avisar o usuário
tqsjan.ZoomTotal()
eag.msg.Print("Comando Python executado com sucesso!")

Nos menus avançados da BRGT (como EAGALV.PY), essa mesma assinatura é usada para tarefas mais pesadas, como: detectar blocos por layer, corrigir escala, inserir graute e armaduras verticais automaticamente, apagar blocos sob portas, etc.


4. Ligando o menu Python a uma aplicação específica

O fluxo típico para criar um menu de aplicação é:

  1. Descobrir o menu do editor que você quer estender
    • Ex.: planta de alvenaria usa o menu EAGALV.MEN.
  2. Criar o arquivo EAGALV.PYMEN em TQSW\EXEC\Python
    • Com as seções [PYTHON], [CMD], [MENU] explicadas acima.
  3. Criar o módulo EAGALV.PY na mesma pasta
    • Implementando as funções def comando_x(eag, tqsjan): para cada ID definido em [CMD].
  4. Abrir um desenho correspondente (por exemplo, uma planta de alvenaria) e verificar se o novo submenu aparece no final da barra de menus.

5. Menus globais: usando o EAG.PYMEN

Se você quer comandos disponíveis em qualquer editor gráfico (formas, ferros, alvenaria, modelador, paredes, etc.), use o menu global:

  • Crie/edite o arquivo EAG.PYMEN em TQSW\EXEC\Python;
  • A estrutura é a mesma ([PYTHON], [CMD], [MENU]);
  • Esse menu é carregado antes do menu específico da aplicação, então os comandos ficam sempre visíveis.

Isso é útil para:

  • Ferramentas genéricas de revisão de desenho;
  • Rotinas de auditoria de layers, escalas, blocos;
  • Utilitários internos de escritório que você quer padronizar em toda a equipe.

6. Reaproveitando código de menu com INCLUIR

Se você tiver um conjunto de comandos comum a vários editores, o manual recomenda separar esse trecho em um arquivo .PYMEN “comum” e incluir nos demais com:

ini
INCLUIR,COMUM.PYMEN

Isso evita copiar/colar blocos gigantes de menu e facilita manter tudo padronizado.


7. Checklist rápido para começar

  1. Python 3.x instalado, pacote TQSPythonInterface instalado (pasta TQSW\EXEC\Python).
  2. Criar/editar EAG.PYMEN (global) ou EAGXXX.PYMEN (por aplicação).
  3. Apontar, em [PYTHON], para o(s) módulo(s) .PY que você vai usar.
  4. Criar IDs em [CMD], ligando cada um a uma função def … (eag, tqsjan) no seu .PY.
  5. Montar o submenu em [MENU].
  6. Abrir o editor correspondente no TQS e testar.

Material de Apoio:

https://drive.google.com/drive/folders/192wvOMPrOG6yG3w9w5Wb0Ge56-Olhwb6?usp=drive_link