pyroll-engineering-report 3.0.0__py3-none-any.whl

pyroll/engineering_report/__init__.py

@@ -0,0 +1,6 @@
+from .report import engineering_report
+from .translations import LANGUAGES
+
+VERSION = "3.0.0"
+
+__all__ = ["engineering_report", "LANGUAGES", "VERSION"]

pyroll/engineering_report/report.py

@@ -0,0 +1,321 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Callable, Optional
+
+from fpdf import FPDF, FontFace
+from pyroll.core import PassSequence, RollPass
+
+from . import units
+from .translations import LANGUAGES, translate
+
+PAGE_WIDTH = 210.0
+MARGIN = 10.0
+CONTENT_WIDTH = PAGE_WIDTH - 2 * MARGIN
+LOGO_WIDTH = 40.0
+FONT = "Helvetica"
+MISSING_VALUE = "-"
+
+
+class EngineeringReportPdf(FPDF):
+    """A4 page layout with optional logo, company name and product name."""
+
+    def __init__(
+            self,
+            language: str,
+            generated_at: datetime,
+            product_name: Optional[str],
+            company_name: Optional[str],
+            mill_name: Optional[str],
+            logo: Optional[Path],
+    ):
+        super().__init__(orientation="P", unit="mm", format="A4")
+        self.language = language
+        self.generated_at = generated_at
+        self.product_name = product_name
+        self.company_name = company_name
+        self.mill_name = mill_name
+        self.logo = logo
+        self.set_margins(left=MARGIN, top=MARGIN, right=MARGIN)
+        self.set_auto_page_break(auto=True, margin=20)
+
+    def translate(self, key: str) -> str:
+        return translate(key, self.language)
+
+    def header(self):
+        top = MARGIN
+        if self.logo is not None:
+            image_info = self.image(str(self.logo), x=MARGIN, y=top, w=LOGO_WIDTH)
+            top += image_info.rendered_height + 3
+
+        self.set_xy(MARGIN, MARGIN)
+        self.set_font(FONT, size=9)
+        self.cell(CONTENT_WIDTH, 5, f"{self.translate('page')} {self.page_no()}/{{nb}}", align="R")
+
+        title = self.translate("roll_pass_design")
+        if self.company_name:
+            title = f"{self.company_name} - {title}"
+
+        self.set_xy(MARGIN, top)
+        self.set_font(FONT, style="B", size=12)
+        self.cell(CONTENT_WIDTH * 0.75, 6, title)
+        self.set_font(FONT, size=9)
+        self.cell(CONTENT_WIDTH * 0.25, 6, self.generated_at.strftime("%d.%m.%Y"), align="R",
+                  new_x="LMARGIN", new_y="NEXT")
+
+        self.set_font(FONT, size=9)
+        if self.mill_name:
+            self.cell(CONTENT_WIDTH, 5, f"{self.translate('rolling_mill')}: {self.mill_name}", new_x="LMARGIN", new_y="NEXT")
+        if self.product_name:
+            self.cell(CONTENT_WIDTH, 5, f"{self.translate('product')}: {self.product_name}", new_x="LMARGIN", new_y="NEXT")
+
+        line_y = self.get_y() + 1.5
+        self.set_line_width(0.3)
+        self.line(MARGIN, line_y, PAGE_WIDTH - MARGIN, line_y)
+        self.set_y(line_y + 4)
+
+    def footer(self):
+        self.set_y(-16)
+        self.set_line_width(0.2)
+        self.line(MARGIN, self.get_y(), PAGE_WIDTH - MARGIN, self.get_y())
+        self.ln(2)
+
+        self.set_font(FONT, style="I", size=7)
+        self.set_text_color(110, 110, 110)
+        third = CONTENT_WIDTH / 3
+        self.cell(third, 4, f"{self.translate('generated')} {self.generated_at:%Y-%m-%d %H:%M:%S}")
+        self.cell(third, 4, self.company_name or "", align="C")
+        self.cell(third, 4, self.translate("generated_with"), align="R")
+        self.set_text_color(0, 0, 0)
+
+
+def _format(value_getter: Callable[[], float], number_format: str) -> str:
+    """Formatted value of the getter or MISSING_VALUE if the value is not available."""
+    try:
+        value = value_getter()
+    except (AttributeError, TypeError, ValueError, ZeroDivisionError):
+        return MISSING_VALUE
+    if value is None:
+        return MISSING_VALUE
+    return format(value, number_format)
+
+
+def _groove_label(roll_pass: RollPass) -> str:
+    label = getattr(roll_pass.roll.groove, "label", None)
+    return MISSING_VALUE if label in (None, "") else str(label)
+
+
+def _reduction(roll_pass: RollPass) -> float:
+    in_area = roll_pass.in_profile.cross_section.area
+    return (in_area - roll_pass.out_profile.cross_section.area) / in_area
+
+
+def _utilization(roll_pass: RollPass) -> float:
+    return roll_pass.engine.power / roll_pass.engine.maximum_power
+
+
+def _material_name(profile) -> str:
+    material = getattr(profile, "material", None)
+    if not material:
+        return MISSING_VALUE
+    if isinstance(material, str):
+        return material
+    return str(list(material)[0])
+
+
+def _mass_per_length(area: float, density: float) -> float:
+    return area * density
+
+
+def _info_lines(
+        pdf: EngineeringReportPdf,
+        sequence: PassSequence,
+        max_heating_capacity: Optional[float],
+        nominal_area: Optional[float],
+        target_mass_deviation: Optional[float],
+) -> list[tuple[str, str]]:
+    in_profile = sequence.in_profile
+    out_profile = sequence.out_profile
+    last_pass = sequence.roll_passes[-1]
+    area_times_velocity = out_profile.cross_section.area * last_pass.out_profile.velocity
+    material_name = _material_name(in_profile)
+
+    lines = [
+        (pdf.translate("material"), material_name),
+        (pdf.translate("rolling_speed"), f"{_format(lambda: last_pass.out_profile.velocity, '.2f')} m/s"),
+        ("A × v", f"{_format(lambda: units.to_mm2(area_times_velocity), '.1f')} mm²·m/s"),
+        (
+            pdf.translate("in_profile_size"),
+            f"{_format(lambda: units.to_mm(in_profile.height), '.1f')} × "
+            f"{_format(lambda: units.to_mm(in_profile.width), '.1f')} mm",
+        ),
+        (pdf.translate("in_profile_temperature"), f"{_format(lambda: units.to_celsius(in_profile.temperature), '.0f')} °C"),
+        (
+            pdf.translate("production"),
+            f"{_format(lambda: units.to_tonnes_per_hour(area_times_velocity * in_profile.density), '.1f')} t/h",
+        ),
+    ]
+
+    if max_heating_capacity is not None:
+        lines.append((pdf.translate("max_heating_capacity"), f"{units.to_tonnes_per_hour(max_heating_capacity):.1f} t/h"))
+
+    if nominal_area is not None:
+        nominal_mass = _mass_per_length(nominal_area, in_profile.density)
+        lines.append((pdf.translate("nominal_mass"), f"{nominal_mass:.3f} kg/m"))
+        if target_mass_deviation is not None:
+            target_mass = nominal_mass * (1 + target_mass_deviation)
+            lines.append(
+                (pdf.translate("target_mass"), f"{target_mass:.3f} kg/m ({units.to_percent(target_mass_deviation):+.1f} %)")
+            )
+
+    return lines
+
+
+def _write_info_block(pdf: EngineeringReportPdf, info_lines: list[tuple[str, str]]):
+    pdf.set_font(FONT, size=9)
+    for label, value in info_lines:
+        pdf.cell(55, 4.5, label)
+        pdf.cell(CONTENT_WIDTH - 55, 4.5, f": {value}", new_x="LMARGIN", new_y="NEXT")
+    pdf.ln(4)
+
+
+def _write_table(
+        pdf: EngineeringReportPdf,
+        title_keys: list[str],
+        unit_labels: list[str],
+        rows: list[list[str]],
+        column_widths: list[float],
+):
+    pdf.set_font(FONT, size=7)
+    heading_style = FontFace(emphasis="BOLD", fill_color=(225, 225, 225))
+    with pdf.table(
+            col_widths=column_widths,
+            text_align="RIGHT",
+            num_heading_rows=2,
+            headings_style=heading_style,
+            line_height=4,
+            first_row_as_headings=True,
+    ) as table:
+        title_row = table.row()
+        for key in title_keys:
+            title_row.cell(pdf.translate(key), align="CENTER")
+        unit_row = table.row()
+        for unit_label in unit_labels:
+            unit_row.cell(unit_label, align="CENTER")
+        for values in rows:
+            table_row = table.row()
+            for value in values:
+                table_row.cell(value)
+
+
+def _pass_schedule_rows(sequence: PassSequence) -> list[list[str]]:
+    rows = []
+    for roll_pass in sequence.roll_passes:
+        out_profile = roll_pass.out_profile
+        rows.append([
+            str(roll_pass.label),
+            _groove_label(roll_pass),
+            _format(lambda: units.to_mm(roll_pass.roll.nominal_diameter), ".1f"),
+            _format(lambda: units.to_mm(roll_pass.gap), ".2f"),
+            f"{_format(lambda: units.to_mm(out_profile.height), '.2f')} × "
+            f"{_format(lambda: units.to_mm(out_profile.width), '.2f')}",
+            _format(lambda: units.to_mm2(out_profile.cross_section.area), ".1f"),
+            _format(lambda: units.to_percent(out_profile.filling_ratio), ".1f"),
+            _format(lambda: units.to_percent(_reduction(roll_pass)), ".1f"),
+            _format(lambda: units.to_celsius(out_profile.temperature), ".0f"),
+        ])
+    return rows
+
+
+def _speeds_and_loads_rows(sequence: PassSequence) -> list[list[str]]:
+    rows = []
+    for roll_pass in sequence.roll_passes:
+        roll = roll_pass.roll
+        engine = roll_pass.engine
+        rows.append([
+            str(roll_pass.label),
+            _groove_label(roll_pass),
+            _format(lambda: roll_pass.out_profile.velocity, ".2f"),
+            _format(lambda: units.to_mm(roll.working_diameter), ".1f"),
+            _format(lambda: units.to_per_minute(roll.rotational_frequency), ".1f"),
+            _format(lambda: engine.gear_ratio, ".3f"),
+            _format(lambda: units.to_per_minute(engine.rotational_frequency), ".0f"),
+            _format(lambda: roll_pass.elongation, ".3f"),
+            _format(lambda: units.to_mm(roll.nominal_diameter - roll.working_diameter), ".1f"),
+            _format(lambda: units.to_kilo(roll_pass.roll_force), ".1f"),
+            _format(lambda: units.to_kilo(2 * roll.roll_torque), ".2f"),
+            _format(lambda: units.to_kilo(engine.power), ".0f"),
+            _format(lambda: units.to_percent(_utilization(roll_pass)), ".1f"),
+        ])
+    return rows
+
+
+def _total_power(sequence: PassSequence) -> Optional[float]:
+    try:
+        return sum(roll_pass.engine.power for roll_pass in sequence.roll_passes)
+    except (AttributeError, TypeError):
+        return None
+
+
+def engineering_report(
+        sequence: PassSequence,
+        output_path: Path,
+        language: str = "en",
+        product_name: Optional[str] = None,
+        company_name: Optional[str] = None,
+        mill_name: Optional[str] = None,
+        logo: Optional[Path] = None,
+        max_heating_capacity: Optional[float] = None,
+        nominal_area: Optional[float] = None,
+        target_mass_deviation: Optional[float] = None,
+) -> Path:
+    """Writes the engineering report of a solved pass sequence as PDF and returns its path."""
+    if language not in LANGUAGES:
+        raise ValueError(f"Language '{language}' not available, choose one of {LANGUAGES}.")
+
+    pdf = EngineeringReportPdf(
+        language=language,
+        generated_at=datetime.now(),
+        product_name=product_name,
+        company_name=company_name,
+        mill_name=mill_name,
+        logo=Path(logo) if logo is not None else None,
+    )
+    info_lines = _info_lines(pdf, sequence, max_heating_capacity, nominal_area, target_mass_deviation)
+
+    pdf.add_page()
+    _write_info_block(pdf, info_lines)
+    pdf.set_font(FONT, style="B", size=10)
+    pdf.cell(CONTENT_WIDTH, 6, pdf.translate("pass_schedule"), new_x="LMARGIN", new_y="NEXT")
+    _write_table(
+        pdf,
+        title_keys=["stand", "groove", "roll_diameter", "gap", "height_x_width", "area", "filling_ratio",
+                    "reduction", "temperature"],
+        unit_labels=["", "", "mm", "mm", "mm", "mm²", "%", "%", "°C"],
+        rows=_pass_schedule_rows(sequence),
+        column_widths=[16, 14, 20, 16, 34, 22, 22, 22, 24],
+    )
+
+    pdf.add_page()
+    _write_info_block(pdf, info_lines)
+    pdf.set_font(FONT, style="B", size=10)
+    pdf.cell(CONTENT_WIDTH, 6, pdf.translate("speeds_and_loads"), new_x="LMARGIN", new_y="NEXT")
+    _write_table(
+        pdf,
+        title_keys=["stand", "groove", "speed", "working_diameter", "roll_rotational_frequency", "gear_ratio",
+                    "motor_rotational_frequency", "elongation", "groove_factor", "roll_force", "roll_torque",
+                    "power", "utilization"],
+        unit_labels=["", "", "m/s", "mm", "1/min", "", "1/min", "", "mm", "kN", "kNm", "kW", "%"],
+        rows=_speeds_and_loads_rows(sequence),
+        column_widths=[14, 12, 14, 15, 16, 15, 15, 19, 14, 15, 14, 14, 12],
+    )
+
+    total_power = _total_power(sequence)
+    pdf.ln(3)
+    pdf.set_font(FONT, style="B", size=9)
+    total_power_text = MISSING_VALUE if total_power is None else f"{units.to_kilo(total_power):.0f}"
+    pdf.cell(CONTENT_WIDTH, 5, f"{pdf.translate('total_power')}: {total_power_text} kW", align="R")
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    pdf.output(str(output_path))
+    return output_path

pyroll/engineering_report/translations.py

@@ -0,0 +1,49 @@
+LANGUAGES = ("de", "en", "it")
+
+TEXTS = {
+    "roll_pass_design": {"de": "Walzenkalibrierung", "en": "Roll pass design", "it": "Calibratura dei cilindri"},
+    "rolling_mill": {"de": "Walzstraße", "en": "Rolling mill", "it": "Laminatoio"},
+    "product": {"de": "Produkt", "en": "Product", "it": "Prodotto"},
+    "page": {"de": "Seite", "en": "Page", "it": "Pagina"},
+    "generated": {"de": "Erstellt", "en": "Generated", "it": "Generato"},
+    "generated_with": {"de": "Erstellt mit PyRolL", "en": "Generated with PyRolL", "it": "Generato con PyRolL"},
+    "pass_schedule": {"de": "Stichplan", "en": "Pass schedule", "it": "Schema di laminazione"},
+    "speeds_and_loads": {
+        "de": "Geschwindigkeiten und Belastungen",
+        "en": "Speeds and loads",
+        "it": "Velocità e carichi",
+    },
+    "material": {"de": "Werkstoff", "en": "Material", "it": "Materiale"},
+    "rolling_speed": {"de": "Walzgeschwindigkeit", "en": "Rolling speed", "it": "Velocità di laminazione"},
+    "in_profile_size": {"de": "Knüppelabmessung", "en": "Billet size", "it": "Dimensione billetta"},
+    "in_profile_temperature": {"de": "Knüppeltemperatur", "en": "Billet temperature", "it": "Temperatura billetta"},
+    "max_heating_capacity": {"de": "Max. Ofenleistung", "en": "Max. heating capacity", "it": "Capacità max. forno"},
+    "production": {"de": "Produktionsleistung", "en": "Production", "it": "Produzione"},
+    "nominal_mass": {"de": "Nennmasse", "en": "Nominal mass", "it": "Massa nominale"},
+    "target_mass": {"de": "Zielmasse", "en": "Target mass", "it": "Massa obiettivo"},
+    "total_power": {"de": "Gesamte Walzleistung", "en": "Total rolling power", "it": "Potenza totale di laminazione"},
+    "stand": {"de": "Gerüst", "en": "Stand", "it": "Gabbia"},
+    "groove": {"de": "Kaliber", "en": "Groove", "it": "Calibro"},
+    "roll_diameter": {"de": "Walzen-Ø", "en": "Roll dia.", "it": "Ø cilindro"},
+    "gap": {"de": "Spalt", "en": "Gap", "it": "Luce"},
+    "height_x_width": {"de": "Höhe × Breite", "en": "Height × width", "it": "Altezza × larghezza"},
+    "area": {"de": "Fläche", "en": "Area", "it": "Area"},
+    "filling_ratio": {"de": "Füllgrad", "en": "Filling ratio", "it": "Riempimento"},
+    "reduction": {"de": "Abnahme", "en": "Reduction", "it": "Riduzione"},
+    "temperature": {"de": "Temperatur", "en": "Temperature", "it": "Temperatura"},
+    "speed": {"de": "Geschw.", "en": "Speed", "it": "Velocità"},
+    "working_diameter": {"de": "Arbeits-Ø", "en": "Work. dia.", "it": "Ø lavoro"},
+    "roll_rotational_frequency": {"de": "Walzendrehzahl", "en": "Roll speed", "it": "Giri cilindro"},
+    "gear_ratio": {"de": "Übersetzung", "en": "Gear ratio", "it": "Rapporto riduzione"},
+    "motor_rotational_frequency": {"de": "Motordrehzahl", "en": "Motor speed", "it": "Giri motore"},
+    "elongation": {"de": "Streckung", "en": "Elongation", "it": "Allungamento"},
+    "groove_factor": {"de": "Kaliberfaktor", "en": "Groove factor", "it": "Fattore calibro"},
+    "roll_force": {"de": "Walzkraft", "en": "Roll force", "it": "Forza"},
+    "roll_torque": {"de": "Walzmoment", "en": "Roll torque", "it": "Coppia"},
+    "power": {"de": "Leistung", "en": "Power", "it": "Potenza"},
+    "utilization": {"de": "Auslastung", "en": "Utilization", "it": "Utilizzo"},
+}
+
+
+def translate(key: str, language: str) -> str:
+    return TEXTS[key][language]

pyroll/engineering_report/units.py

@@ -0,0 +1,31 @@
+"""Conversion of SI values into the units printed in the report."""
+
+KELVIN_OFFSET = 273.15
+
+
+def to_mm(value_m: float) -> float:
+    return value_m * 1e3
+
+
+def to_mm2(value_m2: float) -> float:
+    return value_m2 * 1e6
+
+
+def to_celsius(value_kelvin: float) -> float:
+    return value_kelvin - KELVIN_OFFSET
+
+
+def to_kilo(value: float) -> float:
+    return value * 1e-3
+
+
+def to_percent(ratio: float) -> float:
+    return ratio * 1e2
+
+
+def to_per_minute(frequency_per_second: float) -> float:
+    return frequency_per_second * 60
+
+
+def to_tonnes_per_hour(mass_flow_kg_per_s: float) -> float:
+    return mass_flow_kg_per_s * 3.6

pyroll_engineering_report-3.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: pyroll-engineering-report
+Version: 3.0.0
+Summary: Plugin for PyRolL providing a printable PDF engineering report (pass schedule, speeds and loads) of a solved pass sequence.
+Project-URL: Homepage, https://pyroll.readthedocs.io
+Project-URL: Repository, https://codeberg.org/pyroll-project/pyroll-engineering-report
+Project-URL: Documentation, https://codeberg.org/pyroll-project/pyroll-engineering-report/src/branch/main/docs/docs.pdf
+Author-email: Christoph Renzing <christoph.renzing@imf.tu-freiberg.de>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: fpdf2>=2.8
+Requires-Dist: pyroll-core<4.0,>=3.1

pyroll_engineering_report-3.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyroll/engineering_report/__init__.py,sha256=p4emyjz1ZZxHbOsSq9iK3K9Ur3ZEE4kd27dKhwgAFP0,152
+pyroll/engineering_report/report.py,sha256=tSUk2DUvBFYEffK0bJlkExr1KC1kAFsil3LZWfJMbBQ,12496
+pyroll/engineering_report/translations.py,sha256=zUoQ_AhMDoIy5y8kHWRD1Qhs_1v9Ke1jdzvQU9CsSgg,3380
+pyroll/engineering_report/units.py,sha256=H7C4GIFulTdytBWR9SO9pK-nxdCgmWEsMzEyT8lgUQM,629
+pyroll_engineering_report-3.0.0.dist-info/METADATA,sha256=v9DqhOYOBakfO6soJqUoqw_w18vmuZ-pph-nGwndFkY,675
+pyroll_engineering_report-3.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pyroll_engineering_report-3.0.0.dist-info/licenses/LICENSE,sha256=ba04C9xPoD_SK1gQPi-rnym3Kktrfbe0dWCbqnsw_Mk,1448
+pyroll_engineering_report-3.0.0.dist-info/RECORD,,

pyroll_engineering_report-3.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyroll_engineering_report-3.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2022 ...
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.