pyroll-ring-model-thermal 2.0.0__py3-none-any.whl

pyroll/ring_model_thermal/__init__.py

@@ -0,0 +1,21 @@
+VERSION = "2.0.0"
+
+from . import profile
+from . import roll_pass
+from . import transport
+from .config import Config
+
+from pyroll.core import root_hooks, Unit
+
+root_hooks.add(Unit.OutProfile.temperature)
+root_hooks.add(Unit.OutProfile.ring_temperatures)
+
+import importlib.util
+
+REPORT_INSTALLED = bool(importlib.util.find_spec("pyroll.report"))
+
+if REPORT_INSTALLED:
+    from . import report
+    import pyroll.report
+
+    pyroll.report.plugin_manager.register(report)

pyroll/ring_model_thermal/config.py

@@ -0,0 +1,10 @@
+from pyroll.core import config
+
+
+@config("PYROLL_RING_MODEL_THERMAL")
+class Config:
+    RADIATION_COEFFICIENT = 5.670374419e-8
+    """The Stefan-Boltzmann radiation constant. Only to change if not working with SI-units."""
+
+    ROLL_PASS_ATMOSPHERE_TRANSFER = True
+    """Whether to include the heat transfer to atmosphere at free surfaces in roll passes into the calculation."""

pyroll/ring_model_thermal/profile.py

@@ -0,0 +1,52 @@
+import numpy as np
+from pyroll.core import Profile, Unit
+from pyroll.core.hooks import Hook
+from pyroll.ring_model import RingProfile
+
+
+@Profile.extension_class
+class Profile(RingProfile):
+    ring_temperatures = Hook[np.ndarray]()
+    """Array temperature values from core to surface."""
+
+    relative_radiation_coefficient = Hook[float]()
+    """Heat transfer coefficient by convection to atmosphere."""
+
+
+@Profile.relative_radiation_coefficient
+def relative_radiation_coefficient(self: Profile):
+    return 0.8
+
+
+@Profile.ring_temperatures
+def homogeneous_profile(self: Profile):
+    if self.has_set_or_cached("temperature"):
+        return np.full_like(self.rings, self.temperature)
+
+
+@Unit.OutProfile.ring_temperatures
+def out_ring_temperatures_from_in(self: Unit.OutProfile):
+    if self.unit.in_profile.has_set_or_cached("ring_temperatures"):
+        return np.copy(self.unit.in_profile.ring_temperatures)
+
+
+@Profile.temperature
+def mean_temperature(self: Profile):
+    return np.sum(self.ring_temperatures * [s.area for s in self.ring_sections]) / np.sum(
+        [s.area for s in self.ring_sections])
+
+
+@Profile.surface_temperature
+def surface_temperature(self: Profile):
+    return self.ring_temperatures[-1]
+
+
+@Profile.core_temperature
+def core_temperature(self: Profile):
+    return self.ring_temperatures[0]
+
+
+@Unit.OutProfile.ring_temperatures
+def ring_temperatures_from_disks(self: Unit.OutProfile):
+    if self.unit.subunits:
+        return self.unit.subunits[-1].out_profile.ring_temperatures

pyroll/ring_model_thermal/report.py

@@ -0,0 +1,129 @@
+import numpy as np
+from pyroll.report import hookimpl
+from pyroll.core import Unit, PassSequence
+from pyroll.core import DiskElementUnit
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import matplotlib.collections as mcol
+
+
+@hookimpl(specname="unit_plot")
+def disked_unit_temperature_plot(unit: Unit):
+    if isinstance(unit, DiskElementUnit):
+        fig: plt.Figure = plt.figure()
+        ax: plt.Axes = fig.subplots()
+
+        count = len(unit.subunits) + 2
+        cmap = mpl.colormaps['coolwarm_r']
+        colors = cmap(np.linspace(0, 1, count))
+
+        def prepare_data(p):
+            return (
+                np.append(p.rings, p.equivalent_radius) / p.equivalent_radius,
+                np.append(p.ring_temperatures, p.surface_temperature)
+            )
+
+        ip = ax.plot(*prepare_data(unit.in_profile), c=colors[0], label="incoming profile")[0]
+
+        for i in range(1, count - 1):
+            u = unit.subunits[i - 1]
+            ax.plot(*prepare_data(u.out_profile), c=colors[i])
+
+        op = ax.plot(*prepare_data(unit.out_profile), c=colors[-1], label="outgoing profile")[0]
+
+        ax.set_title("Radial Temperature Profile Evolution")
+        ax.set_xlabel("Relative Distance from Core")
+        ax.set_ylabel("Temperature")
+
+        lc = mcol.LineCollection(
+            5 * [[(0, 0)]],
+            colors=cmap(np.linspace(0, 1, 7)[1:-1]),
+            label="intermediate stages",
+        )
+
+        ax.legend(handles=[ip, lc, op], handler_map={type(lc): HandlerDashedLines()})
+
+        return fig
+
+
+@hookimpl(specname="unit_plot")
+def pass_sequence_temperature_plot(unit: Unit):
+    if isinstance(unit, PassSequence):
+        fig: plt.Figure = plt.figure()
+        ax: plt.Axes = fig.subplots()
+
+        def yield_data(u: Unit, name):
+            yield getattr(u.in_profile, name, None)
+            if u.subunits:
+                for su in u.subunits:
+                    yield from yield_data(su, name)
+            yield getattr(u.out_profile, name, None)
+
+        t = np.array(list(yield_data(unit, "t")))
+        core = np.array(list(yield_data(unit, "core_temperature")))
+        surface = np.array(list(yield_data(unit, "surface_temperature")))
+        mean = np.array(list(yield_data(unit, "temperature")))
+
+        ax.plot(t, core, label="core")
+        ax.plot(t, surface, label="surface")
+        ax.plot(t, mean, label="mean")
+
+        ax.legend()
+
+        ax.set_title("Temperature Evolution")
+        ax.set_xlabel("Cumulative Process Time $t$")
+        ax.set_ylabel("Temperature $T$")
+
+        return fig
+
+
+# from https://matplotlib.org/stable/gallery/text_labels_and_annotations/legend_demo.html#sphx-glr-gallery-text-labels-and-annotations-legend-demo-py
+from matplotlib.legend_handler import HandlerLineCollection
+from matplotlib.lines import Line2D
+
+
+class HandlerDashedLines(HandlerLineCollection):
+    """
+    Custom Handler for LineCollection instances.
+    """
+
+    def create_artists(
+            self, legend, orig_handle,
+            xdescent, ydescent, width, height, fontsize, trans
+    ):
+        # figure out how many lines there are
+        numlines = len(orig_handle.get_segments())
+        xdata, xdata_marker = self.get_xdata(
+            legend, xdescent, ydescent,
+            width, height, fontsize
+        )
+        leglines = []
+        # divide the vertical space where the lines will go
+        # into equal parts based on the number of lines
+        ydata = np.full_like(xdata, height / (numlines + 1))
+        # for each line, create the line at the proper location
+        # and set the dash pattern
+        for i in range(numlines):
+            legline = Line2D(xdata, ydata * (numlines - i) - ydescent)
+            self.update_prop(legline, orig_handle, legend)
+            # set color, dash pattern, and linewidth to that
+            # of the lines in linecollection
+            try:
+                color = orig_handle.get_colors()[i]
+            except IndexError:
+                color = orig_handle.get_colors()[0]
+            try:
+                dashes = orig_handle.get_dashes()[i]
+            except IndexError:
+                dashes = orig_handle.get_dashes()[0]
+            try:
+                lw = orig_handle.get_linewidths()[i]
+            except IndexError:
+                lw = orig_handle.get_linewidths()[0]
+            if dashes[1] is not None:
+                legline.set_dashes(dashes[1])
+            legline.set_color(color)
+            legline.set_transform(trans)
+            legline.set_linewidth(lw)
+            leglines.append(legline)
+        return leglines

pyroll/ring_model_thermal/roll_pass.py

@@ -0,0 +1,207 @@
+from typing import Union, Tuple
+
+import numpy as np
+
+from .config import Config
+from .profile import Profile
+from pyroll.core import RollPass, Unit, Hook, DeformationUnit
+import scipy.optimize as scopt
+
+
+@RollPass.Roll.extension_class
+class RollExt(RollPass.Roll):
+    heat_transfer_coefficient = Hook[float]()
+    """Heat transfer coefficient by contact to the roll."""
+
+
+@RollPass.extension_class
+class RollPassExt(RollPass):
+    heat_transfer_coefficient = Hook[float]()
+    """Heat transfer coefficient by convection to atmosphere."""
+
+    deformation_heat_efficiency = Hook[float]()
+    """Efficiency of heat generation by deformation power."""
+
+    environment_temperature = Hook[float]()
+    """Temperature of the surrounding atmosphere."""
+
+
+@RollPassExt.deformation_heat_efficiency
+def deformation_heat_efficiency(self: RollPass):
+    return 0.95
+
+
+@RollPassExt.environment_temperature
+def environment_temperature(self: RollPassExt):
+    return self.roll.temperature
+
+
+@RollExt.heat_transfer_coefficient
+def heat_transfer_coefficient(self: RollPass):
+    return 6000
+
+
+@RollPassExt.heat_transfer_coefficient
+def heat_transfer_coefficient(self: RollPass):
+    return 150
+
+
+def get_increments(unit: DeformationUnit, roll_pass: RollPassExt, ring_temperatures) -> np.ndarray:
+    p: Profile = unit.in_profile
+
+    increments = np.zeros_like(ring_temperatures)
+
+    deformation_resistance = (
+        unit.deformation_resistance
+        if unit.has_value("deformation_resistance")
+        else (unit.in_profile.flow_stress + 2 * unit.out_profile.flow_stress) / 3
+    )
+
+    source_density = roll_pass.deformation_heat_efficiency * deformation_resistance * unit.strain_rate
+
+    cross_section = p.ring_sections[0].area
+    increments[0] = unit.duration / (p.density * p.thermal_capacity * cross_section) * (
+            (ring_temperatures[1] - ring_temperatures[0]) * p.ring_contours[1].length
+            / p.rings[1] * p.thermal_conductivity
+            + source_density * cross_section
+    )
+
+    try:
+        free_surface_ratio = unit.free_surface_area / unit.surface_area
+    except AttributeError:
+        free_surface_ratio = 0
+
+    cross_section = p.ring_sections[-1].area
+
+    roll_contact_transfer = (
+            roll_pass.roll.heat_transfer_coefficient * (roll_pass.roll.temperature - p.surface_temperature)
+            * p.ring_contours[-1].length * (1 - free_surface_ratio)
+    )
+
+    if Config.ROLL_PASS_ATMOSPHERE_TRANSFER:
+        atmosphere_transfer = (
+                (
+                        roll_pass.heat_transfer_coefficient
+                        * (roll_pass.environment_temperature - p.surface_temperature)
+                        + Config.RADIATION_COEFFICIENT * p.relative_radiation_coefficient
+                        * (roll_pass.environment_temperature ** 4 - p.surface_temperature ** 4)
+                )
+                * p.ring_contours[-1].length * free_surface_ratio
+        )
+    else:
+        atmosphere_transfer = 0
+
+    increments[-1] = unit.duration / (p.density * p.thermal_capacity * cross_section) * (
+            roll_contact_transfer + atmosphere_transfer
+            - p.thermal_conductivity * (ring_temperatures[-1] - ring_temperatures[-2])
+            / (p.rings[-1] - p.rings[-2])
+            * p.ring_contours[-2].length
+            + source_density * cross_section
+    )
+
+    for i in range(1, len(increments) - 1):
+        cross_section = p.ring_sections[i].area
+        increments[i] = unit.duration / (p.density * p.thermal_capacity * cross_section) * (
+                p.thermal_conductivity
+                * (
+                        (ring_temperatures[i + 1] - ring_temperatures[i]) * p.ring_contours[i + 1].length
+                        / (p.rings[i + 1] - p.rings[i])
+                        - (ring_temperatures[i] - ring_temperatures[i - 1]) * p.ring_contours[i].length
+                        / (p.rings[i] - p.rings[i - 1])
+                )
+                + source_density * cross_section
+        )
+
+    return increments
+
+
+def _solve_step(unit, roll_pass, in_ring_temperatures):
+    x0 = get_increments(unit, roll_pass, in_ring_temperatures)
+
+    def f(x):
+        out_ring_temperatures = in_ring_temperatures + x
+        return get_increments(unit, roll_pass, out_ring_temperatures) - x
+
+    sol = scopt.root(f, x0=x0)
+
+    if not sol.success:
+        raise RuntimeError(f"Numerical procedure did not succeed: {sol.message}.")
+
+    return in_ring_temperatures + sol.x
+
+
+@RollPass.OutProfile.ring_temperatures
+def ring_temperatures_disk(self: Union[RollPass.OutProfile, Profile]):
+    if not self.roll_pass.disk_elements:
+        roll_pass = self.roll_pass
+
+        return _solve_step(roll_pass, roll_pass, roll_pass.in_profile.ring_temperatures)
+
+
+@RollPass.DiskElement.OutProfile.ring_temperatures
+def ring_temperatures_disk(self: Union[RollPass.DiskElement.OutProfile, Profile]):
+    roll_pass = self.roll_pass
+    disk = self.disk_element
+
+    return _solve_step(disk, roll_pass, disk.in_profile.ring_temperatures)
+
+
+def _surface_temperature(self: Union[RollPass.Profile, Profile]):
+    roll_pass: RollPassExt = self.roll_pass
+
+    try:
+        free_surface_ratio = roll_pass.free_surface_area / roll_pass.surface_area
+    except AttributeError:
+        free_surface_ratio = 0
+
+    def f(ts):
+        roll_contact_transfer = (
+                roll_pass.roll.heat_transfer_coefficient * (roll_pass.roll.temperature - ts)
+                * self.ring_contours[-1].length * (1 - free_surface_ratio)
+        )
+
+        if Config.ROLL_PASS_ATMOSPHERE_TRANSFER:
+            atmosphere_transfer = (
+                    (
+                            roll_pass.heat_transfer_coefficient
+                            * (roll_pass.environment_temperature - ts)
+                            + Config.RADIATION_COEFFICIENT * self.relative_radiation_coefficient
+                            * (roll_pass.environment_temperature ** 4 - ts ** 4)
+                    )
+                    * self.ring_contours[-1].length * free_surface_ratio
+            )
+        else:
+            atmosphere_transfer = 0
+
+        return (
+                roll_contact_transfer + atmosphere_transfer
+                - self.thermal_conductivity
+                * (ts - self.ring_temperatures[-1])
+                / (self.equivalent_radius - self.rings[-1])
+        )
+
+    def fprime(ts):
+        return (
+                - roll_pass.roll.heat_transfer_coefficient * (1 - free_surface_ratio)
+                - ((
+                           roll_pass.heat_transfer_coefficient
+                           + 4 * Config.RADIATION_COEFFICIENT * self.relative_radiation_coefficient
+                           * ts ** 3
+                   ) * free_surface_ratio if Config.ROLL_PASS_ATMOSPHERE_TRANSFER else 0)
+                - self.thermal_conductivity / (self.equivalent_radius - self.rings[-1])
+        )
+
+    sol = scopt.root_scalar(f=f, fprime=fprime, x0=self.ring_temperatures[-1], method="newton")
+
+    if sol.converged:
+        return sol.root
+
+
+@RollPass.Profile.surface_temperature
+def surface_temperature(self: Union[RollPass.Profile, Profile]):
+    return _surface_temperature(self)
+
+
+@RollPass.DiskElement.Profile.surface_temperature
+def disk_surface_temperature(self: Union[RollPass.Profile, Profile]):
+    return _surface_temperature(self)

pyroll/ring_model_thermal/transport.py

@@ -0,0 +1,133 @@
+from typing import Union
+
+import numpy as np
+import scipy.optimize as scopt
+from pyroll.core import Transport, Unit, Hook
+
+from .config import Config
+from .profile import Profile
+
+
+@Transport.extension_class
+class TransportExt(Transport):
+    heat_transfer_coefficient = Hook[float]()
+    """Heat transfer coefficient by convection to atmosphere."""
+
+
+@TransportExt.heat_transfer_coefficient
+def heat_transfer_coefficient(self: Transport):
+    return 15
+
+
+def get_increments(unit: Unit, transport: TransportExt, ring_temperatures) -> np.ndarray:
+    p: Profile = unit.out_profile
+
+    increments = np.zeros_like(ring_temperatures)
+
+    source_density = 0  # TODO source density term in W / m^3
+
+    cross_section = p.ring_sections[0].area
+    increments[0] = unit.duration / (p.density * p.thermal_capacity * cross_section) * (
+            (ring_temperatures[1] - ring_temperatures[0]) * p.ring_contours[1].length
+            / p.rings[1] * p.thermal_conductivity
+            + source_density * cross_section
+    )
+
+    cross_section = p.ring_sections[-1].area
+    increments[-1] = unit.duration / (p.density * p.thermal_capacity * cross_section) * (
+            (
+                    transport.heat_transfer_coefficient
+                    * (transport.environment_temperature - p.surface_temperature)
+                    + Config.RADIATION_COEFFICIENT * p.relative_radiation_coefficient
+                    * (transport.environment_temperature ** 4 - p.surface_temperature ** 4)
+            )
+            * p.ring_contours[-1].length
+            - p.thermal_conductivity * (ring_temperatures[-1] - ring_temperatures[-2])
+            / (p.rings[-1] - p.rings[-2])
+            * p.ring_contours[-2].length
+            + source_density * cross_section
+    )
+
+    for i in range(1, len(increments) - 1):
+        cross_section = p.ring_sections[i].area
+        increments[i] = unit.duration / (p.density * p.thermal_capacity * cross_section) * (
+                p.thermal_conductivity
+                * (
+                        (ring_temperatures[i + 1] - ring_temperatures[i]) * p.ring_contours[i + 1].length
+                        / (p.rings[i + 1] - p.rings[i])
+                        - (ring_temperatures[i] - ring_temperatures[i - 1]) * p.ring_contours[i].length
+                        / (p.rings[i] - p.rings[i - 1])
+                )
+                + source_density * cross_section
+        )
+
+    return increments
+
+
+def _solve_step(unit, transport, in_ring_temperatures):
+    x0 = get_increments(unit, transport, in_ring_temperatures)
+
+    def f(x):
+        out_ring_temperatures = in_ring_temperatures + x
+        return get_increments(unit, transport, out_ring_temperatures) - x
+
+    sol = scopt.root(f, x0=x0)
+
+    if not sol.success:
+        raise RuntimeError(f"Numerical procedure did not succeed: {sol.message}.")
+
+    return in_ring_temperatures + sol.x
+
+
+@Transport.OutProfile.ring_temperatures
+def ring_temperatures_disk(self: Union[Transport.OutProfile, Profile]):
+    if not self.transport.disk_elements:
+        transport = self.transport
+
+        return _solve_step(transport, transport, transport.in_profile.ring_temperatures)
+
+
+@Transport.DiskElement.OutProfile.ring_temperatures
+def ring_temperatures_disk(self: Union[Transport.DiskElement.OutProfile, Profile]):
+    transport = self.transport
+    disk = self.disk_element
+
+    return _solve_step(disk, transport, disk.in_profile.ring_temperatures)
+
+
+def _surface_temperature(self: Union[Transport.Profile, Profile]):
+    transport: TransportExt = self.transport
+
+    def f(ts):
+        return (
+                transport.heat_transfer_coefficient
+                * (transport.environment_temperature - ts)
+                + Config.RADIATION_COEFFICIENT * self.relative_radiation_coefficient
+                * (transport.environment_temperature ** 4 - ts ** 4)
+                - self.thermal_conductivity
+                * (ts - self.ring_temperatures[-1])
+                / (self.equivalent_radius - self.rings[-1])
+        )
+
+    def fprime(ts):
+        return (
+                -4 * Config.RADIATION_COEFFICIENT * self.relative_radiation_coefficient
+                * ts ** 3
+                - transport.heat_transfer_coefficient
+                - self.thermal_conductivity / (self.equivalent_radius - self.rings[-1])
+        )
+
+    sol = scopt.root_scalar(f=f, fprime=fprime, x0=self.ring_temperatures[-1], method="newton")
+
+    if sol.converged:
+        return sol.root
+
+
+@Transport.Profile.surface_temperature
+def surface_temperature(self: Union[Transport.Profile, Profile]):
+    return _surface_temperature(self)
+
+
+@Transport.DiskElement.Profile.surface_temperature
+def disk_surface_temperature(self: Union[Transport.Profile, Profile]):
+    return _surface_temperature(self)

pyroll_ring_model_thermal-2.0.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: pyroll-ring-model-thermal
+Version: 2.0.0
+Summary: Plugin for PyRoll providing a radial thermal approach based on the ring model.
+Author-email: Max Weiner <max.weiner@imf.tu-freiberg.de>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: <4.0,>=3.9
+Requires-Dist: pyroll-core~=2.0
+Requires-Dist: pyroll-ring-model~=2.0

pyroll_ring_model_thermal-2.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyroll/ring_model_thermal/__init__.py,sha256=qbbGudfCewqkZOijlLcruoQ_rC3GqmYnF3viq18-tLk,467
+pyroll/ring_model_thermal/config.py,sha256=-_4WFcZNqAiFkukexpMb_ygZNi69CigBF782JEDdIeU,380
+pyroll/ring_model_thermal/profile.py,sha256=u5z9NadWPQyWBDluy_QDj04KDfZoFdKpjKx7LQ3cCnc,1510
+pyroll/ring_model_thermal/report.py,sha256=PHH2gxlbCsH-kUlLyE4qeYH4P0KTSFuKXmhnHaEGcv4,4573
+pyroll/ring_model_thermal/roll_pass.py,sha256=oCyxnv4rRSHsqKXYzK7WAvaiDnLlfk-cRHEbFL7Wxl8,7288
+pyroll/ring_model_thermal/transport.py,sha256=8be2cDEjzRGZTtwAQ_lDUcjnVopHZWA-IH2aEFcvWSY,4759
+pyroll_ring_model_thermal-2.0.0.dist-info/METADATA,sha256=_X9TOMQPU-sAgGJSHDLluRS-Z8IXhm78AXmR3gXeLKc,367
+pyroll_ring_model_thermal-2.0.0.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+pyroll_ring_model_thermal-2.0.0.dist-info/licenses/LICENSE,sha256=cC-Hopqx0dkfeivDS5kNfOOAZ-IBvUe5BEF4z9MY1Mo,1474
+pyroll_ring_model_thermal-2.0.0.dist-info/RECORD,,

pyroll_ring_model_thermal-2.0.0.dist-info/WHEEL

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

pyroll_ring_model_thermal-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2022 Max Weiner, Christoph Renzing
+
+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.