Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python
from attr import define, field
from math import pi


@define
class MotorBlock:
    speed = field()
    stroke = field()

    @property
    def mean_piston_speed(self):
        return 2 * self.stroke * 2 * self.speed


@define
class Cylinder(MotorBlock):
    piston_diameter = field()

    @property
    def piston_area(self):
        return pi * self.piston_diameter**2 / 4


def main():
    input_data = {"speed": 500, "stroke": 120, "pistons": [100, 60]}
    cylinders = [
        Cylinder(input_data["speed"], input_data["stroke"], piston_diameter)
        for piston_diameter in input_data["pistons"]
    ]
   


if __name__ == "__main__":
    main()

Code: Alles auswählen

from functools import partial

def berechne_gasstrom_für_einen_zylinder(ein_zylinder, druck):
    return ein_zylinder.berechne_gasstrom(druck)

def berechne_irgendwie_neuen_druck(liste_mit_gasströmen, aktueller_druck):
    # berechne was
    return neuer_druck_der_hoffentlich_zu einem_besseren_ergebnis_führt
    
def abweichung_vom_gleichgewicht_immer_noch_zu_groß(liste_mit_gasströmen):
    # berechne was
    return True oder False
 
aktueller_druck = 1.0 # irgendwo muss man ja anfangen

liste_mit_gasströmen = map(partial(berechne_gasstrom_für_einen_zylinder, druck = aktueller_druck), liste_mit_zylindern)
while abweichung_vom_gleichgewicht_immer_noch_zu_groß(liste_mit_gasströmen):
    aktueller_druck = berechne_irgendwie_neuen_druck(liste_mit_gasströmen, aktueller_druck)
    liste_mit_gasströmen = map(partial(berechne_gasstrom_für_einen_zylinder, druck = aktueller_druck), liste_mit_zylindern)

Code: Alles auswählen

...und man kann es vielleicht mit einen Motor wieder ganz gut erklären.

Code: Alles auswählen

#!/usr/bin/env python

from math import pi
from functools import cached_property

from attr import define, field



@define
class Cylinder:
    piston_diameter = field()
    xyz_factor = field()
    abc_factor = field()

    def _piston_area(self):
        return pi / 4 * self.piston_diameter**2

    def _volume(self, stroke):
        return 2 * stroke * self._piston_area()

    def _volume_flow(self, speed, stroke):
        return self._volume(stroke) * speed

    def _volume_factor(self, inlet, outlet, polytrope):
        return 1 - self.xyz_factor * (
            self.abc_factor * (outlet / inlet) ** (1 / polytrope) - 1
        )

    def volume_flow(
        self,
        inlet,
        outlet,
        polytrope,
        speed,
        stroke,
        temperature_factor,
    ):
        return (
            self._volume_flow(speed, stroke)
            * self.xyz_factor
            * self._volume_factor(inlet, outlet, polytrope)
            * temperature_factor
        )


@define
class Motor:
    cylinders: list[Cylinder] = field()
    stroke = field()
    speed = field()
    inlet = field()
    outlet = field()
    inlet_temperature = field()
    gas = field()

    @property
    def piston_speed(self):
        return 2 * self.stroke * 2 * self.speed

    @cached_property
    def another_value(self):
        return (self.inlet_temperature - 273.15) / (
            237.3 + (self.inlet_temperature - 273.15)
        )

    def norm_volume_flow(self, inlet, another_value, volume_flow):
        return self.inlet * (inlet - self.gas.humidity * another_value) * volume_flow

    @staticmethod
    def polytrop(inlet, outlet):
        # Calculation with inlet and outlet
        return 42

    def temperature_factor(self, inlet, outlet, piston_diameter, xyz_factor):
        return (
            xyz_factor
            * piston_diameter
            * self.gas.density
            * self.piston_speed
            * piston_diameter
            * self.stroke
            / piston_diameter
            * outlet
            / inlet
        )


def get_norm_volume_flow(motor, cylinders):
    cylinder_1, cylinder_2 = cylinders
    start = motor.inlet + 100000
    inlet_1 = start
    outlet_2 = start
    while True:
        temperature_factor = motor.temperature_factor(
            motor.inlet,
            inlet_1,
            cylinder_1.piston_diameter,
            cylinder_1.xyz_factor,
        )
        polytrope = motor.polytrop(motor.inlet, inlet_1)
        flow = cylinder_1.volume_flow(
            motor.inlet,
            inlet_1,
            polytrope,
            motor.speed,
            motor.stroke,
            temperature_factor,
        )

        norm_volume_flow_1 = motor.norm_volume_flow(
            motor.inlet,
            motor.another_value,
            flow,
        )

        temperature_factor = motor.temperature_factor(
            outlet_2,
            motor.outlet,
            cylinder_2.piston_diameter,
            cylinder_2.xyz_factor,
        )
        polytrope = motor.polytrop(outlet_2, motor.outlet)

        flow = cylinder_2.volume_flow(
            outlet_2,
            motor.outlet,
            polytrope,
            motor.speed,
            motor.stroke,
            temperature_factor,
        )

        norm_volume_flow_2 = motor.norm_volume_flow(outlet_2, motor.another_value, flow)

        if abs(norm_volume_flow_1 - norm_volume_flow_2) < 0.0001:
            return norm_volume_flow_1
        inlet_1 += 1
        outlet_2 += 1


def main():
    pass


if __name__ == "__main__":
    main()