Python simular Potencia e Torque

Pedro Vinicius G. C. · 20 de abril de 2024

olá amigos, mesmo acreditando que este não seja o local apropriado para essa pergunta, gostaria de saber se alguém conseguiria me ajudar com um projeto,

contextualizando:

a algum tempo, eu e mais um programador estamos trabalhando em um jogo de corrida com tuning, eu acabei ficando com a parte de programação do motor (já que não sou acostumado com python "puro" e com a bge), demorou um bom tempo para sair algo funcional disso, consegui simular o motor completamente, mas de uma forma meio anormal

o código a seguir calcula um monte de variaveis para simular PI (Potencia indicada) e torque (força de giro)

def Engine(car,gearUp,gearDw):
    #-------------Engine Parameters------------------------------------------
    print('inside_of_engineParam')
    acc = car['accelerator']
    Cylinder_Count = 4
    Cylinder_Diameter = 0.12
    Cylinder_Height = 0.16
    Piston_Curse = 0.13
    Neutral_RPM = 800
    RPM = 11000*acc if 11000*acc > 800 else 1000
    Admicion_Valve = 0.04
    Air_Speed = 0.3
    Valve_Comand_Open_Time = 0.2 #0,01 - 0,27
    #-------------Cylinder Volume------------------------------------------
    r = Cylinder_Diameter/2
    r2 = r * r
    Cylinder_Volume = 3.1415 * r2 * Cylinder_Height
    #-------------Cylinder Area--------------------------------------------
    Ab = 3.1415 * r2
    Al = 2 * 3.1415 * r * Cylinder_Height
    Cylinder_Area = 2 * Ab + Al
    #-------------Expansion Presure----------------------------------------
    Expansion_Presure = 15

    #-------------Combustion Rate------------------------------------------
    Vcam = 0.00004
    Cp = Cylinder_Volume + Vcam
    Combustion_Rate = Cp / Vcam
    #------------- CC Per Cylinder ----------------------------------------
    cc = r2 / Piston_Curse
    #print (cc)
    #-------------Indicated Power -----------------------------------------
    Ip1 = Ab * Expansion_Presure * Cylinder_Count * Piston_Curse * RPM
    Ip2 = 12000
    Indicated_Power = Ip1/Ip2 * Presure

essa parte deveria funcionar por si só, mas não esta, ou melhor não do jeito que deveria

mais ou menos assim:

utilizando ele assim o torque é constante 1.32nm se não me engano, e a potencia vai de 0 a um valor muito alto, de forma constante

para "resolver" isso, alterei a parte da presão de expansão, forçando o torque mudar

 #-------------Expansion Presure----------------------------------------
    Expansion_Presure = 15
    Presure = 0
    
    rpm0000  = .7
    rpm1000  = .50
    rpm2000  = .50
    rpm3000  = .70
    rpm4000  = .70
    rpm5000  = .80
    rpm6000  = .80
    rpm7000  = .70
    rpm8000  = .60
    rpm9000  = .48
    rpm10000 = .23
    rpm11000 = .10
    rpm12000 = .03
    
    if RPM >= 1000 and RPM <= 2000:
        rpm_presure = rpm1000 / rpm2000
        Presure = rpm_presure * RPM / 100
    if RPM >= 2000 and RPM <= 3000:
        rpm_presure = rpm2000 / rpm3000
        Presure = rpm_presure * RPM / 100
    if RPM >= 3000 and RPM <= 4000:
        rpm_presure = rpm3000 / rpm4000
        Presure = rpm_presure * RPM / 100
    if RPM >= 4000 and RPM <= 5000:
        rpm_presure = rpm4000 / rpm5000
        Presure = rpm_presure * RPM / 100
    if RPM >= 5000 and RPM <= 6000:
        rpm_presure = rpm5000 / rpm6000
        Presure = rpm_presure * RPM / 100
    if RPM >= 6000 and RPM <= 7000:
        rpm_presure = rpm6000 / rpm7000
        Presure = rpm_presure * RPM / 100
    if RPM >= 7000 and RPM <= 8000:
        rpm_presure = rpm7000 / rpm8000
        Presure = rpm_presure * RPM / 100
    if RPM >= 8000 and RPM <= 9000:
        rpm_presure = rpm8000 / rpm9000
        Presure = rpm_presure * RPM / 100
    if RPM >= 9000 and RPM <= 10000:
        rpm_presure = rpm9000 / rpm10000
        Presure = rpm_presure * RPM / 100
    if RPM >= 10000 and RPM <= 11000:
        rpm_presure = rpm10000 / rpm11000
        Presure = rpm_presure * RPM / 100
    if RPM >= 11000 and RPM <= 12000:
        rpm_presure = rpm11000 / rpm12000
        Presure = rpm_presure * RPM / 100

porém isso tem um problema, o torque e potencia viram meio qu8e uma escada, da seguinte forma:

(não exatamente assim, mas dá para ter uma ideia)

outra coisa, a primeira marcha se transformou na velocidade máxima, e com a maior aceleração, a segunda marcha tem menos aceleração, mas a velocidade máxima também é reduzida

  #------------ GearBox -------------------------------------------------
    print('inside_of_gearbox')
    gear_ratio = 0
    gears_count = 5
    gear = car['gear']
    
    # shifting
    if gearUp:
        if car['gear'] < gears_count:
            car['gear'] += 1
    if gearDw:
        if car['gear'] > -1:
            car['gear'] -= 1
    #print(car['gear'])
        
    gear_rear   = -4.1
    gear_one    = 3.5
    gear_two    = 2.7
    gear_three  = 2.2
    gear_four   = 1.8
    gear_five   = 1.5
    gear_six    = 1.3
    gear_seven  = 1.0
    gear_eight  = 0.8
    
    differential = 4.1
    
    if gear == -1:
        gear_ratio = gear_rear * differential * car['clutch']
    if gear == 0:
        gear_ratio = 0
    if gear == 1:
        gear_ratio = gear_one * differential * car['clutch']
    if gear == 2:
        gear_ratio = gear_two * differential * car['clutch']
    if gear == 3:
        gear_ratio = gear_three * differential * car['clutch']
    if gear == 4:
        gear_ratio = gear_four * differential * car['clutch']
    if gear == 5:
        gear_ratio = gear_five * differential * car['clutch']
    if gear == 6:
        gear_ratio = gear_six * differential * car['clutch']
    if gear == 7:
        gear_ratio = gear_seven * differential * car['clutch']
    if gear == 8:
        gear_ratio = gear_eight * differential * car['clutch']
    
    
    Wheel_Torque = Indicated_Power * gear_ratio
    
    HP = Indicated_Power * RPM / 7127
    #print("wheel_torque", Wheel_Torque)
    #print("HP", HP)
    return HP, Wheel_Torque

saberiam o que posso fazer, ao menos para reduzir esses problemas, desde já obrigado

Swalls · 23 de abril de 2024

Pow amigão, de python eu domino, agora de motor sou um zero a esquerda, apesar de ter feito calculo 1,2, 3 e aplicado, para mim você está falando arabe.

mas posso ajudar melhorando um pouco o código (n vou seguir SOLID, Design patterns ou clean code porque n to com tempo, mas irei atomizar e deixar os cálculos dinâmicos para você conseguir analisar valores mudando atributos em um único objeto).

Em 20/04/2024 às 20:39, Pedro Vinicius G. C. disse:

essa parte deveria funcionar por si só, mas não esta, ou melhor não do jeito que deveria

Não funciona porque você não definiu presure na ultima parte do primeiro código.

from math import pi as PI

class Engine:
    def __init__(self, car, gearUp, gearDw) -> None:
        """
        Inicializa um objeto Engine com parâmetros iniciais do motor.

        Args:
            car (dict): Um dicionário contendo informações sobre o carro.
            gearUp (float): Marcha superior.
            gearDw (float): Marcha inferior.
        """
        # Atributos iniciais do motor baseados nas informações do carro
        self.acc = car['accelerator']  # Acelerador
        self.Cylinder_Count = 4  # Número de cilindros
        self.Cylinder_Diameter = 0.12  # Diâmetro do cilindro em metros
        self.Cylinder_Height = 0.16  # Altura do cilindro em metros
        self.piston_curse = 0.13  # Curso do pistão em metros
        self.neutral_RPM = 800  # RPM neutro
        self.admicion_valve = 0.04  # Válvula de admissão
        self.Air_Speed = 0.3  # Velocidade do ar
        self.valve_comand_open_time = 0.2  # Tempo de abertura do comando de válvulas
        self.expansion_presure = 15  # Pressão de expansão
        self.vcam = 0.00004  # Valor de vcam
        self.presure: float  # Valor de pressão (parece que precisa de uma explicação mais detalhada ou inicialização)
        self.rpm_ranges = {
            (1000, 2000): (.50, .50),
            (2000, 3000): (.50, .70),
            (3000, 4000): (.70, .70),
            (4000, 5000): (.70, .80),
            (5000, 6000): (.80, .80),
            (6000, 7000): (.80, .70),
            (7000, 8000): (.70, .60),
            (8000, 9000): (.60, .48),
            (9000, 10000): (.48, .23),
            (10000, 11000): (.23, .10),
            (11000, 12000): (.10, .03)
        }

    def get_RPM(self):
        """
        Calcula as RPM do motor com base no acelerador.

        Returns:
            float: As RPM calculadas.
        """
        return 11000 * self.acc if 11000 * self.acc > 800 else 1000

    def get_cylinder_volume(self, arred=False):
        """
        Calcula o volume de um cilindro.

        Args:
            arred (bool, optional): Se True, arredonda o resultado. Defaults to False.

        Returns:
            float: O volume do cilindro.
        """
        r2 = (self.Cylinder_Diameter / 2) ** 2
        Cylinder_Volume = PI * r2 * self.Cylinder_Height
        if arred:
            return round(Cylinder_Volume, 5)
        else:
            return Cylinder_Volume

    def get_cylinder_area(self, arred=False):
        """
        Calcula a área da superfície do cilindro.

        Args:
            arred (bool, optional): Se True, arredonda o resultado. Defaults to False.

        Returns:
            float: A área da superfície do cilindro.
        """
        Ab = PI * (self.Cylinder_Diameter / 2) ** 2
        Al = 2 * PI * (self.Cylinder_Diameter / 2) * self.Cylinder_Height
        Cylinder_Area = 2 * Ab + Al
        if arred:
            return round(Cylinder_Area, 5)
        else:
            return Cylinder_Area

    def get_combustion_rate(self, arred=False):
        """
        Calcula a taxa de combustão.

        Args:
            arred (bool, optional): Se True, arredonda o resultado. Defaults to False.

        Returns:
            float: A taxa de combustão.
        """
        cp = self.get_cylinder_volume() + self.vcam
        Combustion_Rate = cp / self.vcam
        if arred:
            return round(Combustion_Rate, 5)
        else:
            return Combustion_Rate

    def get_cc_per_cylinder(self):
        """
        Calcula a capacidade cúbica por cilindro.

        Returns:
            float: A capacidade cúbica por cilindro.
        """
        return (self.Cylinder_Diameter / 2) ** 2 / self.piston_curse

    def get_indicated_power(self):
        """
        Calcula a potência indicada.

        Returns:
            float: A potência indicada.
        """
        Ip1 = PI * (self.Cylinder_Diameter / 2) ** 2 * self.expansion_presure * self.Cylinder_Count * self.piston_curse * self.get_RPM()
        Ip2 = 12000
        return Ip1 / Ip2 * self.presure

    def get_presure(self):
        """
        Calcula a pressão.

        Returns:
            float: A pressão.
        """
        rpm = self.get_RPM()
        return self.rpm_ranges[rpm] * rpm / 100

Pedro Vinicius G. C. · 23 de abril de 2024

@Swalls muito obrigado, diferentemente de você, eu sou intermediário em gdscript, e iniciante em python puro, decidi reescrever o motor inteiro e verificar cada uma das funções. até encontrei documentação com 300 paginas que pode ajudar, mas esta tudo em inglês (estou com muita preguiça de ter que interpretar), se me permite vou utilizar sua linha de raciocínio como base, ira ficar até mais fácil para o segundo desenvolvedor interpretar o que esta acontecendo

Swalls · 24 de abril de 2024

@Pedro Vinicius G. C. Continue firme e conseguirá! python é fácil!

Uma dica, use classes. Por se tratar de um motor, sempre que você mudar um valor todos os outros valores mudam também, Logo é mais relevante declarar um objeto (ou seja, criar um motor a partir da classe motores) e mudar suas propriedades para analisar o que acontece com esse objeto.

Ao usar esse meio, você pode, por ex, criar uma familia de motores e faze-lo herdar o motor padrão, por ex:

class V8_Engine(Engine):
	def __init__(self):  # aqui você constroi o v8
		super().__init__(car, gearUp, gearDw)  # aqui você entrega ao v8 como herança tudo que o engine tem.
        	# aqui você coloca as propriedas que o v8 tem diferente de uma engine comum.