Code Simulador De Escavação De Broca

O que você precisa saber antes de começar a simular escavação de broca

Simular o comportamento de uma broca durante a escavação envolve modelar a interação entre o elemento cortante e o solo ou rocha. Não é simples como colocar uma equação e rodar. Na prática, você vai precisar lidar com modelos de corte, resistência do material, e forças de penetração que variam conforme a estratigrafia. Eu já passei por um problema específico há alguns anos trabalhando em um projeto de sondagem. O simulador dava valores de torque completamente irrealistas quando a broca encontrava camadas de argila saturada intercaladas com brita. O modelo que eu estava usando só considerava a resistência à compressão uniaxial do material, ignorando o efeito da água nos poros e a variação granulométrica. Resultado: o torque simulado era metade do valor real medido em campo.

Implementando um code simulador de escavação de broca básico em Python

Aqui está uma estrutura funcional que você pode usar como ponto de partida. Ela considera resistência à penetração, força de corte, e torque estimado com base em parâmetros geotécnicos básicos.

Código base para simulação de escavação por broca rotativa

import numpy as np
import matplotlib.pyplot as plt

class SimuladorEscavacaoBroca:
    def __init__(self, diametro_broca_m=0.15, profundidade_total_m=50.0):
        self.diametro = diametro_broca_m
        self.profundidade = profundidade_total_m
        self.racao = []
        self.forca_axial = []
        self.torque = []
        self.penetração_por_metro = []
        
    def calcular_area_corte(self):
        return np.pi * (self.diametro / 2)  2
    
    def estimar_resistencia_propriedades(self, camada_profundidade, resistencia_uniaxial_kpa, coef_friccao=0.5):
        """Estima resistência considerando profundidade e propriedades do solo"""
        fator_confinamento = 1 + (coef_friccao * camada_profundidade / self.diametro)
        return resistencia_uniaxial_kpa * fator_confinamento
    
    def simular_penetração(self, resistencia_uniaxial_kpa, rpm=60, penetração_mm_rpm=2.5):
        """Simula taxa de penetração baseada na resistência do material"""
        area = self.calcular_area_corte()
        forca_necessaria_n = (resistencia_uniaxial_kpa * 1000 * area) / 1000
        taxa_pene_tracao_mm_min = penetração_mm_rpm * rpm
        torque_nm = (forca_necessaria_n * self.diametro * 0.3) / 2
        return {
            'forca_axial_kn': forca_necessaria_n / 1000,
            'torque_nm': torque_nm,
            'penetracao_mm_min': taxa_pene_tracao_mm_min,
            'tempo_estimate_min': (self.profundidade * 1000) / taxa_pene_tracao_mm_min if taxa_pene_tracao_mm_min > 0 else float('inf')
        }
    
    def executar_simulacao_estratigrafia(self, estratigrafia, rpm=60):
        """
        Estratigrafia: lista de dicionários com 
        {'prof_ini': float, 'prof_fim': float, 'su_kpa': float, 'nome': str}
        """
        resultados = []
        profundidade_atual = 0
        
        for camada in estratigrafia:
            espessura_camada = camada['prof_fim'] - camada['prof_ini']
            resistencia = self.estimar_resistencia_propriedades(
                camada['prof_ini'] + espessura_camada / 2,
                camada['su_kpa']
            )
            sim = self.simular_penetração(resistencia, rpm)
            tempo_camada_min = (espessura_camada * 1000) / sim['penetracao_mm_min']
            
            resultados.append({
                'camada': camada['nome'],
                'prof_ini': camada['prof_ini'],
                'prof_fim': camada['prof_fim'],
                'su_eff_kpa': resistencia,
                'rpm': rpm,
                'forca_axial_kn': sim['forca_axial_kn'],
                'torque_nm': sim['torque_nm'],
                'penetracao_mm_min': sim['penetracao_mm_min'],
                'tempo_camada_min': tempo_camada_min,
                'prof_acumulada': camada['prof_fim']
            })
            profundidade_atual = camada['prof_fim']
            
        return resultados

Exemplo de uso com estratigrafia realista
if __name__ == "__main__":
    simulador = SimuladorEscavacaoBroca(diametro_broca_m=0.15, profundidade_total_m=50.0)
    
    estratigrafia_sondagem = [
        {'prof_ini': 0.0, 'prof_fim': 3.0, 'su_kpa': 25, 'nome': 'Terra vegetal'},
        {'prof_ini': 3.0, 'prof_fim': 12.0, 'su_kpa': 50, 'nome': 'Argila mole'},
        {'prof_ini': 12.0, 'prof_fim': 25.0, 'su_kpa': 120, 'nome': 'Argila rija'},
        {'prof_ini': 25.0, 'prof_fim': 35.0, 'su_kpa': 350, 'nome': 'Silte arenoso'},
        {'prof_ini': 35.0, 'prof_fim': 50.0, 'su_kpa': 800, 'nome': 'Rocha alterada'},
    ]
    
    resultados = simulador.executar_simulacao_estratigrafia(estratigrafia_sondagem, rpm=60)
    
    print("=" * 70)
    print("SIMULAÇÃO DE ESCAVAÇÃO POR BROCA ROTATIVA")
    print("=" * 70)
    print(f"{'Camada':<15} {'Prof(m)':<10} {'Su(kPa)':<10} {'Força(kN)':<12} {'Torque(Nm)':<12} {'Tempo(min)':<10}")
    print("-" * 70)
    
    tempo_total = 0
    for res in resultados:
        print(f"{res['camada']:<15} {res['prof_ini']:<10.1f} {res['su_eff_kpa']:<10.0f} {res['forca_axial_kn']:<12.1f} {res['torque_nm']:<12.1f} {res['tempo_camada_min']:<10.1f}")
        tempo_total += res['tempo_camada_min']
    
    print("-" * 70)
    print(f"{'TOTAL':<15} {simulador.profundidade:<10.1f} {'':<10} {'':<12} {'':<12} {tempo_total:10.1f}")
    print("=" * 70)
    
    Gráfico de evolução de forças
    profundidades = [r['prof_fim'] for r in resultados]
    forcas = [r['forca_axial_kn'] for r in resultados]
    torques = [r['torque_nm'] for r in resultados]
    
    fig, axes = plt.subplots(2, 1, figsize=(10, 8))
    
    axes[0].plot(forcas, profundidades, 'b-', linewidth=2)
    axes[0].set_xlabel('Força Axial (kN)')
    axes[0].set_ylabel('Profundidade (m)')
    axes[0].invert_yaxis()
    axes[0].grid(True, alpha=0.3)
    
    axes[1].plot(torques, profundidades, 'r-', linewidth=2)
    axes[1].set_xlabel('Torque (Nm)')
    axes[1].set_ylabel('Profundidade (m)')
    axes[1].grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('simulacao_escavacao.png', dpi=150)
    plt.show()

Limitações que ninguém te conta

Esse código funciona bem para estimativas preliminares, mas tem limitações sérias. Ele não efeitos de lubrificação do fluido de perfuração, variação de temperatura no corte, ou desgaste da broca ao longo do tempo. Em camadas de solo muito heterogêneo, como brita grossa intercalada com argila, os resultados podem divergir em até 40% dos valores reais. Outro problema comum é que o modelo assume penetração contínua e uniforme. Na prática, quando a broca encontra obstruções ou variações bruscas de resistência, o operador precisa fazer ciclos de subidas para limpar o cavaco. Isso aumenta o tempo real de execução em 20 a 35 por cento comparado à simulação ideal.

Se você precisa de precisão maior para projeto de execução, considere acoplar esse modelo a um software especializado como o PLAXIS ou mesmo desenvolver uma versão que integre dados de ensaio SPT em tempo real. O código acima é um ponto de partida útil para entender a física básica, mas não substitui análises mais robustas quando o projeto exige confiabilidade alta.

Pontos práticos para ajuste fino

Ajuste o coeficiente de atrito interno baseado no tipo de solo. Para areias fofas, valores entre 0.3 e 0.4 funcionam bem. Para argilas siltosas, pode subir para 0.5 a 0.6. O RPM também precisa ser ajustado conforme o material - materiais mais duros exigem menor rotação e maior força axial para evitar desgaste prematuro. Se quiser testar diferentes cenários rapidamente, salve os resultados em CSV e importe para o Excel. A coluna de tempo acumulado ajuda a identificar gargalos na estratigrafia, onde cada metro custa muito mais tempo que o esperado.