thermobuilpy 0.0.2__tar.gz

thermobuilpy-0.0.2/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Hannes Hanse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

thermobuilpy-0.0.2/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: thermobuilpy
+Version: 0.0.2
+Summary: ToDo
+Home-page: https://github.com/hanneshanse/MilPython
+Author: Hannes Hanse
+Author-email: hannes.hanse@tu-clausthal.de
+License: MIT
+Keywords: milp,time series,optimization,gurobi,gurobipy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+
+# ThermoBuilPy
+MilPython is a python Framework ... TODO
+

thermobuilpy-0.0.2/README.md

@@ -0,0 +1,3 @@
+# ThermoBuilPy
+MilPython is a python Framework ... TODO
+

thermobuilpy-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

thermobuilpy-0.0.2/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup
+from pathlib import Path
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text()
+
+setup(
+    name='thermobuilpy',
+    version='0.0.2',
+    description='ToDo',
+    license='MIT',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    author='Hannes Hanse',
+    author_email='hannes.hanse@tu-clausthal.de',
+    keywords=['milp','time series','optimization','gurobi','gurobipy'],
+    readme = "README.md",
+    url='https://github.com/hanneshanse/MilPython',
+    install_requires=["numpy","matplotlib"],
+    classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+)

thermobuilpy-0.0.2/src/ThermoBuilPy/__init__.py

@@ -0,0 +1,5 @@
+from .connection import Connection,Conduction,ForcedConvection,FreeConvection,GeneralHeatTransfer
+from .storage import ThermalStorage,ExtStorage,Storage
+from .stratifiedStorage import StratifiedStorage
+from .thermalSystem import ThermalSystem,SimulationMethod
+from .component import Component,Components

thermobuilpy-0.0.2/src/ThermoBuilPy/component.py

@@ -0,0 +1,70 @@
+from abc import ABC, abstractmethod
+import pandas as pd
+
+def get_nested_attr(obj, attr_path):
+    """Greift rekursiv auf verschachtelte Attribute zu, z.B. 'storage1.name'"""
+    attrs = attr_path.split(".")
+    for attr in attrs:
+        obj = getattr(obj, attr)
+    return obj
+
+class Component(ABC):
+    _series_map = {}
+    _counter = 0  # Klassenattribut für Zähler
+
+    def __init__(self, name=None):
+        cls = type(self)  # Unterklasse
+        if not hasattr(cls, "_counter"):
+            cls._counter = 0  # Initialisierung für die Unterklasse
+        cls._counter += 1
+
+        if name is None:
+            # automatischer Name: Klassenname + Zähler
+            self.name = f"{cls.__name__}{cls._counter}"
+        else:
+            self.name = name
+            
+    def toPDSeries(self) -> pd.Series:
+        # data = {col: getattr(self, attr) for col, attr in self._series_map.items()}
+        # return pd.Series(data)
+        data = {}
+        for col_name, attr_name in self._series_map.items():
+            if callable(attr_name):
+                # Methode / Lambda aufrufen
+                value = attr_name(self)
+            else:
+                value = get_nested_attr(self, attr_name)
+
+            # Wenn der Wert eine Liste von Objekten ist, die auch ein Attribut 'name' haben
+            if isinstance(value, list) and value and all(hasattr(v, "name") for v in value):
+                # Wir speichern die Namen der Objekte als Liste
+                data[col_name] = [v.name for v in value]
+            else:
+                data[col_name] = value
+        return pd.Series(data)
+    # @abstractmethod
+    # def updateFromPDSeries(self, pdSeries):
+    #     pass
+    
+class Components:
+    def __init__(self,name,items=None):
+        self.name=name
+        self.items:list[Component]=items or []
+        pass
+    def __iter__(self):
+        return iter(self.items)
+    def __len__(self):
+        return len(self.items)
+    def add_component(self, item:Component):
+        if item is not None:
+            self.items.append(item)
+    def add_components(self, items:list[Component]):
+        if items is not None:
+            self.items.extend(items)
+    def set_simulation_parameter(self,method,stepsize):
+        for item in self.items:
+            item.set_simulation_parameter(method,stepsize)
+    
+    def toDataFrame(self) -> pd.DataFrame:
+        series_list = [c.toPDSeries() for c in self.items]
+        return pd.DataFrame(series_list)

thermobuilpy-0.0.2/src/ThermoBuilPy/connection.py

@@ -0,0 +1,183 @@
+from .component import Component
+from .storage import Storage,ThermalStorage,ExtStorage
+import numpy as np
+CP_Water = 4.186/3.6 # Specific heat capacity of water in Wh/kg (?)#TODO
+class Connection(Component):
+    def get_heatflow_res(self):
+        raise NotImplementedError("This method should be implemented in subclasses.")
+    def set_simulation_parameter(self,method,stepsize):
+        self.simulation_method = method
+        self.stepsize = stepsize
+
+class Conduction(Connection):
+    _series_map = {
+        'Name': 'name',
+        'Storage1': 'storage1.name',
+        'Storage2': 'storage2.name',
+        'Coeff': 'coeff'}
+    def __init__(self, storage1, storage2,coeff,name=None):
+        Component.__init__(self,name)
+        self.coeff=coeff
+        self.storage1:Storage = storage1
+        self.storage2:Storage = storage2
+        self.storages = [storage1, storage2]
+            
+    @classmethod
+    def newConduction(cls,storage1:Storage,storage2,coeff:float,name:str=None):
+        cls=cls(storage1,storage2,coeff,name)
+        return cls
+    
+    def get_heatflow_res(self):
+        from .thermalSystem import SimulationMethod
+        t1_res = self.storage1.get_temp_res()
+        t2_res = self.storage2.get_temp_res()
+        match self.simulation_method:
+            case SimulationMethod.EXPLICIT_EULER:
+                return self.coeff * (t1_res[:-1] - t2_res[:-1])
+            case SimulationMethod.IMPLICIT_EULER:
+                return self.coeff * (t1_res[1:] - t2_res[1:])
+            case SimulationMethod.CRANK_NICOLSON:
+                expl=self.coeff * (t1_res[:-1] - t2_res[:-1])
+                impl=self.coeff * (t1_res[1:] - t2_res[1:])
+                return 0.5 * (expl + impl)
+        
+class GeneralHeatTransfer(Connection):
+    '''
+    ! This is only for cases where the other methods don't work.
+    It only sets the equations for the targetStorage.
+    If you want to set up a connection between multiple storages and can't use the other methods, you have to set up the connection for all storages individually.
+    '''
+    _series_map = {
+        'Name': 'name',
+        'TargetStorage': 'targestStorage.name',
+        'StorageList': 'storageList',
+        'CoeffList': 'coeffList',
+        'b': 'b'
+    }
+    def __init__(self,name):
+        Component.__init__(self,name)
+        self.targestStorage:ThermalStorage = None
+        self.storageList:list[Storage] = None
+        self.coeffList:list[float] = None
+        self.b:float=None
+    
+    @classmethod
+    def newGeneralHeatTransfer(cls, targetStorage:ThermalStorage,storageList:list[Storage],coeffList:list[float],b:float=0, name=None):#TODO was ist mit extStorages
+        con = cls(name)
+        con.targestStorage = targetStorage
+        con.storageList= storageList
+        con.coeffList = coeffList
+        con.b = b
+        return con
+        
+
+class FreeConvection(Connection):
+    '''
+    Free convection in stratified storages between layer a and b where a is below b if temp(a) > temp(b) with given mass flow
+    '''
+    _series_map = {
+        'Name': 'name',
+        'Storage1': 'storage1.name',
+        'Storage2': 'storage2.name',
+        'MassFlow': lambda self: self.get_mFlow(),
+        'CpFluid': 'cpFluid',
+        'Tolerance': 'tolerance'
+    }
+    def __init__(self,name):
+        Component.__init__(self,name)
+        self.storage1:ThermalStorage = None
+        self.storage2:ThermalStorage = None
+        self.__massFlow:float = None
+        self.__massFlow_res = []
+        self.tolerance:float = None
+        self.cpFluid = None
+        
+    @classmethod
+    def newFreeConvection(cls, storage1:ThermalStorage, storage2:ThermalStorage, massFlow:float, cpFluid=CP_Water, tolerance=0.1,name=None):
+        con = cls(name)
+        con.storage1 = storage1
+        con.storage2 = storage2
+        con.__massFlow = massFlow
+        con.cpFluid = cpFluid
+        con.tolerance = tolerance
+        return con
+    
+    def set_mFlow(self, mFlow):
+        if mFlow<0:
+            raise ValueError("mFlow must be non-negative. For flows in opposite direction set up a seperate ForcedFlow.")
+        self.__massFlow = mFlow
+    def get_mFlow(self):
+        return self.__massFlow
+    def save_massFlow(self):
+        self.__massFlow_res.append(self.__massFlow)
+    def get_massFlow_res(self):
+        return self.__massFlow_res
+    
+class ForcedConvection(Connection):
+    _series_map = {
+        'Name': 'name',
+        'StorageList': 'storageList',
+        'MassFlow': lambda self: self.get_mFlow(),
+        'CpFluid': 'cpFluid'
+    }
+    def __init__(self,name):
+        Component.__init__(self,name)
+        self.storageList = None
+        self.__massFlow = None
+        self.cpFluid = None
+        self.__massFlow_res = []
+        
+    def set_mFlow(self, mFlow):
+        if mFlow<0:
+            raise ValueError("mFlow must be non-negative. For flows in opposite direction set up a seperate ForcedFlow.")
+        self.__massFlow = mFlow
+        
+    def get_mFlow(self):
+        return self.__massFlow
+    
+    def save_massFlow(self):
+        self.__massFlow_res.append(self.__massFlow)
+    def get_massFlow_res(self):
+        return np.array(self.__massFlow_res)
+    
+    def get_heatflow_res(self):
+        from .thermalSystem import SimulationMethod
+        temp_res_list = [storage.get_temp_res() for storage in self.storageList]
+        match self.simulation_method:
+            case SimulationMethod.EXPLICIT_EULER:
+                q_lst=[]
+                for i in range(len(self.storageList)-1):
+                    t1_res = temp_res_list[i][:-1]
+                    q = self.get_massFlow_res()[:-1] * self.cpFluid * t1_res
+                    q_lst.append(q)
+                return q_lst
+            case SimulationMethod.IMPLICIT_EULER:
+                q_lst=[]
+                for i in range(len(self.storageList)-1):
+                    t1_res = temp_res_list[i][1:]
+                    q = self.get_massFlow_res()[1:] * self.cpFluid * t1_res
+                    q_lst.append(q)
+                return q_lst
+            case SimulationMethod.CRANK_NICOLSON:
+                q_lst=[]
+                for i in range(len(self.storageList)-1):
+                    t1_res_expl = temp_res_list[i][:-1]
+                    q_expl = self.get_massFlow_res()[:-1] * self.cpFluid * t1_res_expl
+                    t1_res_impl = temp_res_list[i][1:]
+                    q_impl = self.get_massFlow_res()[1:] * self.cpFluid * t1_res_impl
+                    q_lst.append((q_expl+q_impl)/2)
+                return q_lst
+    
+    @classmethod
+    def newForcedConvection(cls,storageList:list[Storage], massFlow, name=None, cpFluid=CP_Water):
+        flow = cls(name)
+        flow.cpFluid = cpFluid
+        storageList = [x for sub in storageList for x in (sub if isinstance(sub, list) else [sub])]
+        if not isinstance(storageList, list):
+            raise TypeError("storageList must be a list of ThermalStorage objects")
+        if not all(isinstance(storage, Storage) for storage in storageList):
+            raise TypeError("All elements in storageList must be instances of Storage")
+        flow.storageList = storageList
+        flow.__massFlow = massFlow
+        return flow
+    

thermobuilpy-0.0.2/src/ThermoBuilPy/storage.py

@@ -0,0 +1,133 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from abc import abstractmethod
+from .component import Component
+CP_Water = 4.186/3.6 # Specific heat capacity of water in Wh/kg (?)#TODO
+
+def temp_to_Q(temp,cap):
+        return temp * cap
+
+class Storage(Component):
+    @abstractmethod
+    def get_temp(self):
+        pass
+    @abstractmethod
+    def get_temp_res(self):
+        pass
+    
+class ThermalStorage(Storage):
+    _series_map = {
+        'Name': 'name',
+        'Capacity': 'cap',
+        'Temperature': lambda self: self.get_temp(),
+        }
+    def __init__(self,name):
+        Component.__init__(self,name)
+        self.col=None
+        self.cap=None
+        self.temp=None
+        self.__Q=None
+        self.mass=None  # Volume, if applicable
+    @classmethod
+    def fromPDSeries(cls, pdSeries):
+        return cls.newStorage(
+            cap=pdSeries['Capacity'],
+            temp=pdSeries['Temperature'],
+            name=pdSeries['Name'])
+    @classmethod    
+    def newStorage(cls,cap,temp,name=None):
+        storage = cls(name)
+        storage.cap = cap
+        storage.__Q = temp_to_Q(temp, cap)
+        return storage
+    
+    @classmethod
+    def newStorageByMass(cls,mass,cp,temp,name=None):
+        storage = cls(name)
+        storage.cap = mass * cp
+        storage.mass=mass
+        storage.__Q = temp_to_Q(temp, storage.cap)
+        return storage
+    
+    def sim_prep(self, num_steps=None):
+        if num_steps:
+            self.__Q_res = np.zeros(num_steps+1)
+        else:
+            self.__Q_res = []
+    
+    def set_col(self,col:int):
+        self.col = col
+    
+    def set_Q(self, Q, t):
+        self.__Q = Q
+        if isinstance(self.__Q_res,np.ndarray):
+            self.__Q_res[t] = Q
+        else:
+            self.__Q_res.append(Q)
+    
+    def set_temp(self,temp):
+        self.__Q = temp_to_Q(temp, self.cap)
+    
+    def get_Q(self):
+        return self.__Q
+    
+    def get_temp(self):
+        return self.__Q / self.cap 
+    
+    def get_temp_res(self):
+        return np.array(self.__Q_res) / self.cap
+    
+    def get_Q_res(self):
+        try:
+            return self.__Q_res
+        except:
+            raise Exception('First run the simulation, then get get results.')
+    
+    def plot_temp_res(self,ax,color=None):
+        temp_res = self.get_temp_res()
+        if color:
+            ax.plot(temp_res,label=self.name,color=color)
+        else:
+            ax.plot(temp_res,label=self.name)
+
+
+class ExtStorage(Storage):
+    _series_map = {
+        'Name': 'name',
+        'Temperature': lambda self: self.get_temp(),
+        }
+    def __init__(self,name,temp):
+        Component.__init__(self,name)
+        self.__temp = temp
+        self.__temp_res = []
+    @classmethod
+    def newExtStorage(cls,name=None,temp=0):
+        storage = cls(name,temp)
+        return storage
+    
+    def sim_prep(self, num_steps=None):
+        self.Q_sum = 0
+        if num_steps:
+            self.__q_res = np.zeros(num_steps+1)
+        else:
+            self.__q_res = []
+    
+    def add_q(self, q, t=None):
+        self.Q_sum += q
+        if t:
+            self.__q_res[t] = q
+    def set_temp(self,temp):
+        self.__temp = temp
+    def get_temp(self):
+        return self.__temp
+    def get_q_res(self):
+        return self.__q_res
+    def save_temp(self):
+        self.__temp_res.append(self.__temp)
+    def get_temp_res(self):
+        return np.array(self.__temp_res)
+    @classmethod
+    def fromPDSeries(cls, pdSeries):
+        return cls.newExtStorage(
+            temp=pdSeries['Temperature'],
+            name=pdSeries['Name'])

thermobuilpy-0.0.2/src/ThermoBuilPy/stratifiedStorage.py

@@ -0,0 +1,110 @@
+from .storage import ThermalStorage
+from .connection import Conduction,FreeConvection
+from .component import Component
+CP_Water = 4.186/3.6 # Specific heat capacity of water in Wh/kg (?)#TODO
+import matplotlib.pyplot as plt
+class StratifiedStorage(Component):
+    _series_map = {
+        'Name': 'name',
+        'Layers': 'layers',
+        'Conductions': 'conductions',
+        'FreeConvections': 'freeConvections'
+    }
+    def __init__(self,name):
+        Component.__init__(self,name)
+        self.layers:list[ThermalStorage] = []
+        self.conductions:list[Conduction] = []
+        self.freeConvections:list[FreeConvection] = []
+    
+    @classmethod
+    def newStratifiedStorageByMasses(cls, layerMasses:list,layerTemperatures:list,conductionCoeff:list[float]|float,freeConvectionMassFlow:list[float]|float=0,cpFluid=CP_Water, name=None): #TODO name: Stratified or MultiLayer?
+        storage = cls(name)
+        if not isinstance(conductionCoeff,list):
+            conductionCoeff = [conductionCoeff] * (len(layerMasses) - 1)
+        if not isinstance(freeConvectionMassFlow,list):
+            freeConvectionMassFlow = [freeConvectionMassFlow] * (len(layerMasses) - 1)
+        if not len(layerMasses) == len(layerTemperatures) == len(conductionCoeff)+1:
+            raise ValueError("layerVolumes and layerTemperatures must have the same length.")
+        
+        for i in range(len(layerMasses)):
+            storage.layers.append(ThermalStorage.newStorageByMass(layerMasses[i], cpFluid, layerTemperatures[i]))
+        for i, cond_coeff in enumerate(conductionCoeff):
+            storage.conductions.append(
+                Conduction(
+                    storage1=storage.layers[i],
+                    storage2=storage.layers[i+1],
+                    coeff=cond_coeff
+                )
+            )
+        for i, mFlow in enumerate(freeConvectionMassFlow):
+            storage.freeConvections.append(
+                FreeConvection.newFreeConvection(
+                    storage1=storage.layers[i],
+                    storage2=storage.layers[i+1],
+                    massFlow=mFlow,
+                    cpFluid=cpFluid
+                    )
+                )
+        return storage
+    
+    @classmethod
+    def newStratifiedStorageByCapacities(cls, layerCapacities:list,layerTemperatures:list,conductionCoeff:list[float]|float,freeConvectionMassFlow:list[float]|float=0,cpFluid=CP_Water, name=None): #TODO name: Stratified or MultiLayer?
+        storage = cls(name)
+        if not isinstance(conductionCoeff,list):
+            conductionCoeff = [conductionCoeff] * (len(layerCapacities) - 1)
+        if not isinstance(freeConvectionMassFlow,list):
+            freeConvectionMassFlow = [freeConvectionMassFlow] * (len(layerCapacities) - 1)
+        if not len(layerCapacities) == len(layerTemperatures) == len(conductionCoeff)+1:
+            raise ValueError("layerCapacities and layerTemperatures must have the same length.")
+        
+        for i in range(len(layerCapacities)):
+            storage.layers.append(ThermalStorage.newStorage(layerCapacities[i],layerTemperatures[i]))
+        for i, cond_coeff in enumerate(conductionCoeff):
+            storage.conductions.append(
+                Conduction(
+                    storage1=storage.layers[i],
+                    storage2=storage.layers[i+1],
+                    coeff=cond_coeff
+                )
+            )
+        for i, mFlow in enumerate(freeConvectionMassFlow):
+            storage.freeConvections.append(
+                FreeConvection.newFreeConvection(
+                    storage1=storage.layers[i],
+                    storage2=storage.layers[i+1],
+                    massFlow=mFlow,
+                    cpFluid=cpFluid
+                    )
+                )
+        return storage
+    
+    def updateConductionCoeffs(self, conductionCoeff:list[float]|float):
+        if not isinstance(conductionCoeff,list):
+            conductionCoeff = [conductionCoeff] * (len(self.layers) - 1)
+        if not len(conductionCoeff) == len(self.layers) - 1:
+            raise ValueError("conductionCoeff must have length equal to number of layers - 1.")
+        for i,cond in enumerate(self.conductions):
+            cond.coeff = conductionCoeff[i]
+    
+    
+    def getLayers(self, start:int, end:int):
+        if start < 0 or end >= len(self.layers) :
+            raise IndexError("Invalid layer indices.")
+        if start<end:
+            return self.layers[start:end+1]
+        else:
+            return list(reversed(self.layers[end:start+1]))
+        
+    def getLayer(self, i:int):
+        if i<0 or i> len(self.layers)-1:
+            raise ValueError(f'Storage has {len(self.layers)} layers. Index must be 0<=i<{len(self.layers)}')
+        return self.layers[i]
+    
+    def plot_temp_res(self):
+        for i,layer in enumerate(self.layers):
+            plt.plot(layer.get_temp_res(), label=layer.name)
+        plt.title(f'Temperature of {self.name} Layers Over Time')
+        plt.xlabel('Time Step')
+        plt.ylabel('Temperature (°C)')
+        plt.legend()
+        plt.show()

thermobuilpy-0.0.2/src/ThermoBuilPy/thermalSystem.py

@@ -0,0 +1,356 @@
+from .connection import Connection,Conduction,ForcedConvection,GeneralHeatTransfer,FreeConvection
+from .storage import ExtStorage, ThermalStorage
+from .stratifiedStorage import StratifiedStorage
+from .component import Component,Components
+import numpy as np
+from enum import Enum
+import matplotlib.pyplot as plt
+import pandas as pd
+
+class SimulationMethod(Enum):
+    EXPLICIT_EULER = 1
+    IMPLICIT_EULER = 2
+    CRANK_NICOLSON = 3
+
+def expl_euler(M, Q0, b_expl,dt):
+    M_expl = np.eye(M.shape[0]) + M * dt
+    rhs = M_expl.dot(Q0) + b_expl*dt
+    Q1_expl = rhs
+    return Q1_expl
+
+def impl_euler(M, Q0, b_impl,dt):
+    M_impl = np.eye(M.shape[0]) - M * dt
+    M_impl_inv = np.linalg.inv(M_impl)
+    rhs = Q0 + b_impl*dt
+    Q1_impl = M_impl_inv.dot(rhs)
+    return Q1_impl
+
+def crank_nicolson(M, Q0, b_CN,dt):
+    M1 = np.eye(M.shape[0]) - M * dt / 2
+    M2 = np.eye(M.shape[0]) + M * dt / 2
+    M_1_inv = np.linalg.inv(M1)
+    rhs = M2.dot(Q0) + b_CN*dt
+    Q1_CN = M_1_inv.dot(rhs)
+    return Q1_CN
+
+class ThermalSystem:
+    def __init__(self,name):
+        self.storages:Components = Components('Thermal Storages')
+        self.conductions:Components = Components('Conductions')
+        self.forcedConvections:Components = Components('Forced Convections')
+        self.freeConvections:Components = Components('Free Convections')
+        self.stratfiedStorages:Components = Components('Stratified Storages')
+        self.generalHeatTransfers:Components = Components('General Heat Transfers')
+        self.ext_storages:Components = Components('External Storages')
+        self.__componentsLst=[self.storages,self.conductions,self.forcedConvections,self.freeConvections,self.ext_storages,self.stratfiedStorages,self.generalHeatTransfers]
+        self.name = name
+        
+    @classmethod
+    def newThermalSystem(cls, storages=None,conductions=None,forcedConvection=None,freeConvection=None,extStorages=None,stratifiedStorages=None,generalHeatTransfers=None,name=None):
+        system = cls(name)
+        system.storages.add_components(storages)
+        system.conductions.add_components(conductions)
+        system.forcedConvections.add_components(forcedConvection)
+        system.freeConvections.add_components(freeConvection)
+        system.ext_storages.add_components(extStorages)
+        system.generalHeatTransfers.add_components(generalHeatTransfers)
+        if stratifiedStorages is not None:
+            for stratifiedStorage in stratifiedStorages:
+                system.add_stratifiedStorage(stratifiedStorage)
+        return system
+    
+    def add_storage(self, storage: ThermalStorage):
+        self.storages.add_component(storage)
+    
+    def add_conduction(self, conduction: Conduction):
+        self.conductions.add_component(conduction)
+        
+    def add_forcedConvection(self, florcedFlow:ForcedConvection):
+        self.forcedConvections.add_component(florcedFlow)
+        
+    def add_freeConvection(self, freeConvection:FreeConvection):
+        self.freeConvections.add_component(freeConvection)
+        
+    def add_extStorage(self, extStorage: ExtStorage):
+        self.ext_storages.add_component(extStorage)
+    
+    def add_stratifiedStorage(self, stratifiedStorage: StratifiedStorage):
+        self.stratfiedStorages.add_component(stratifiedStorage)
+        self.storages.add_components(stratifiedStorage.layers)
+        self.conductions.add_components(stratifiedStorage.conductions)
+        self.freeConvections.add_components(stratifiedStorage.freeConvections)
+        
+    def prepare_simulation(self,stepsize,simulation_method=SimulationMethod.CRANK_NICOLSON):
+        self.stepsize = stepsize
+        self.simulation_method = simulation_method
+        
+        self.conductions.set_simulation_parameter(simulation_method,self.stepsize)
+        self.forcedConvections.set_simulation_parameter(simulation_method,self.stepsize)
+        self.freeConvections.set_simulation_parameter(simulation_method,self.stepsize)
+        self.generalHeatTransfers.set_simulation_parameter(simulation_method,self.stepsize)
+        
+        for i,storage in enumerate(self.storages):
+            storage.set_col(i)
+            storage.sim_prep()
+        for ext_storage in self.ext_storages:
+            ext_storage.sim_prep()   
+        self.dim=len(self.storages)
+        self.M=np.zeros((self.dim, self.dim))
+        self.b=np.zeros(self.dim)
+        self.Q=np.zeros(self.dim)
+        
+        [self.Q.__setitem__(i, storage.get_Q()) for i, storage in enumerate(self.storages)]
+        self.set_therm_storage_Qs(self.Q,0)
+        self.did_simstep_info()
+        self.M_cond = np.zeros((self.dim, self.dim))
+        
+        for cond in self.conductions:
+
+            if isinstance(cond.storage1,ThermalStorage):
+                c1 = cond.coeff / cond.storage1.cap
+                self.M_cond[cond.storage1.col, cond.storage1.col] += -c1
+                if isinstance(cond.storage2,ThermalStorage):
+                    c2 = cond.coeff / cond.storage2.cap
+                    self.M_cond[cond.storage1.col, cond.storage2.col] += c2
+                    self.M_cond[cond.storage2.col, cond.storage2.col] += -c2
+                    self.M_cond[cond.storage2.col, cond.storage1.col] += c1
+            else:
+                # External storage case
+                if isinstance(cond.storage2, ThermalStorage):
+                    c2 = cond.coeff / cond.storage2.cap
+                    self.M_cond[cond.storage2.col, cond.storage2.col] += -c2
+                else:
+                    raise TypeError("Conduction must connect two ThermalStorage objects or one ExtStorage and one ThermalStorage")
+        
+    def do_simstep(self):
+        self.__sim_step(t=None)
+    
+    def simulate(self,num_steps=1000,stepsize=1/60,simulation_method=SimulationMethod.CRANK_NICOLSON):
+        self.num_steps=num_steps
+        self.stepsize=stepsize#! stepsize als timedelta?
+        self.simulation_method = simulation_method
+        self.__sim_prep()
+        for t in range(1,self.num_steps+1):
+            self.__sim_step(t)
+    
+    def __sim_prep(self):
+        
+        self.conductions.set_simulation_parameter(self.simulation_method,self.stepsize)
+        self.forcedConvections.set_simulation_parameter(self.simulation_method,self.stepsize)
+        self.freeConvections.set_simulation_parameter(self.simulation_method,self.stepsize)
+        self.generalHeatTransfers.set_simulation_parameter(self.simulation_method,self.stepsize)
+        
+        for i,storage in enumerate(self.storages):
+            storage.set_col(i)
+            storage.sim_prep(num_steps=self.num_steps)
+        for ext_storage in self.ext_storages:
+            ext_storage.sim_prep(num_steps=self.num_steps)   
+        self.dim=len(self.storages)
+        self.M=np.zeros((self.dim, self.dim))
+        self.b=np.zeros(self.dim)
+        self.Q=np.zeros(self.dim)
+        
+        [self.Q.__setitem__(i, storage.get_Q()) for i, storage in enumerate(self.storages)]
+        self.set_therm_storage_Qs(self.Q,0)
+        self.did_simstep_info()
+        self.M_cond = np.zeros((self.dim, self.dim))
+        
+        for cond in self.conductions:
+
+            if isinstance(cond.storage1,ThermalStorage):
+                c1 = cond.coeff / cond.storage1.cap
+                self.M_cond[cond.storage1.col, cond.storage1.col] += -c1
+                if isinstance(cond.storage2,ThermalStorage):
+                    c2 = cond.coeff / cond.storage2.cap
+                    self.M_cond[cond.storage1.col, cond.storage2.col] += c2
+                    self.M_cond[cond.storage2.col, cond.storage2.col] += -c2
+                    self.M_cond[cond.storage2.col, cond.storage1.col] += c1
+            else:
+                # External storage case
+                if isinstance(cond.storage2, ThermalStorage):
+                    c2 = cond.coeff / cond.storage2.cap
+                    self.M_cond[cond.storage2.col, cond.storage2.col] += -c2
+                else:
+                    raise TypeError("Conduction must connect two ThermalStorage objects or one ExtStorage and one ThermalStorage")
+            
+        # vorbereitung von listen für zeitreihensimulation
+        
+        
+        # wo werden die Ergebnisse gespeichert? hier zentral oder in den Klassen?
+    def sim_step_control(self,t):
+        pass
+    
+    def __sim_step(self,t):
+        self.b_cond = np.zeros(self.dim)
+        
+        for cond in self.conductions:
+            if isinstance(cond.storage1,ExtStorage):
+                c = cond.coeff * cond.storage1.get_temp()
+                self.b_cond[cond.storage2.col] += c
+            elif isinstance(cond.storage2,ExtStorage):
+                c = cond.coeff * cond.storage2.get_temp()
+                self.b_cond[cond.storage1.col] += c
+                
+                
+        # Free Convection
+        self.M_freeConvection = np.zeros((self.dim, self.dim))
+        for conv in self.freeConvections:
+            if conv.storage1.get_temp() > conv.storage2.get_temp() + conv.tolerance:
+                c1 = conv.get_mFlow() / conv.storage1.cap * conv.cpFluid
+                c2 = conv.get_mFlow() / conv.storage2.cap * conv.cpFluid
+                self.M_freeConvection[conv.storage1.col,conv.storage1.col] += -c1
+                self.M_freeConvection[conv.storage1.col,conv.storage2.col] += c2
+                self.M_freeConvection[conv.storage2.col,conv.storage1.col] += c2
+                self.M_freeConvection[conv.storage2.col,conv.storage2.col] += -c2
+                #TODO richtig so?
+                
+                
+        # forced Convection
+        self.M_forcedConvection = np.zeros((self.dim, self.dim))
+        self.b_forcedConvection = np.zeros(self.dim)
+        for conv in self.forcedConvections:
+            mFlow = conv.get_mFlow()
+            if mFlow is None:
+                raise ValueError("mFlow must be set for ForcedFlow")
+            
+            for i in range(len(conv.storageList)-1):
+                from_stor = conv.storageList[i]
+                to_stor = conv.storageList[i+1]
+                if isinstance(from_stor,ExtStorage):
+                    coeff = mFlow * from_stor.get_temp() * conv.cpFluid
+                    self.b_forcedConvection[to_stor.col] += coeff
+                    from_stor.add_q(-coeff, t)
+                else:
+                    coeff = mFlow / from_stor.cap * conv.cpFluid
+                    self.M_forcedConvection[from_stor.col, from_stor.col] += -coeff
+                    if isinstance(to_stor,ExtStorage):
+                        to_stor.add_q(coeff, t)#! das hier ist falsch: q_from fehlt
+                    else:
+                        self.M_forcedConvection[to_stor.col, from_stor.col] += coeff 
+                m=self.M_forcedConvection
+                pass
+        
+        self.M_generalHeatTransfer = np.zeros((self.dim, self.dim))
+        self.b_generalHeatTransfer = np.zeros(self.dim)
+        for ht in self.generalHeatTransfers:
+            targetStorage = ht.targestStorage
+            coeff = ht.b
+            for i,storage in enumerate(ht.storageList):
+                self.M_generalHeatTransfer[targetStorage.col, storage.col] += ht.coeffList[i]
+            self.b_generalHeatTransfer[targetStorage.col] += coeff
+                        
+        
+        self.M = self.M_forcedConvection+self.M_cond+self.M_generalHeatTransfer + self.M_freeConvection #TODO
+        self.b = self.b_forcedConvection+self.b_cond+self.b_generalHeatTransfer
+        match self.simulation_method:
+            case SimulationMethod.EXPLICIT_EULER:
+                self.Q = expl_euler(self.M,self.Q,self.b,self.stepsize)
+            case SimulationMethod.IMPLICIT_EULER:
+                self.Q = impl_euler(self.M,self.Q,self.b,self.stepsize)
+            case SimulationMethod.CRANK_NICOLSON:
+                self.Q = crank_nicolson(self.M, self.Q, self.b, self.stepsize) 
+                
+        self.did_simstep_info()
+        self.set_therm_storage_Qs(self.Q,t)
+        self.sim_step_control(t)
+        
+    def did_simstep_info(self):
+        for ext_storage in self.ext_storages:
+            ext_storage.save_temp()
+        for forcedConv in self.forcedConvections:
+            forcedConv.save_massFlow()
+        for freeConv in self.freeConvections:
+            freeConv.save_massFlow()
+    
+    def set_therm_storage_Qs(self, Q,t):
+        for i, storage in enumerate(self.storages):
+            storage.set_Q(Q[i],t)
+               
+    def to_Excel(self, filename):
+        # Placeholder for exporting to Excel logic
+        with pd.ExcelWriter(filename) as writer:
+            for comp in self.__componentsLst:
+                sheet_name = comp.name if comp.name else 'Component'
+                comp.toDataFrame().to_excel(writer, sheet_name=sheet_name, index=False)
+    
+    def plot_temps(self,storage_list:list[ThermalStorage],color_list:list[str]=None,xLabel='Steps',yLabel='Temp in °C'):
+        _,ax = plt.subplots()
+        for i,stor in enumerate(storage_list):
+            if color_list:
+                stor.plot_temp_res(ax,color_list[i])
+            else:
+                stor.plot_temp_res(ax)
+        ax.legend()
+        plt.xlabel(xLabel)
+        plt.ylabel(yLabel)
+        plt.show()
+                
+    @classmethod
+    def from_Excel(cls, filename):
+        xls = pd.ExcelFile(filename)
+        system = cls(filename)
+        for sheet_name in xls.sheet_names:
+            df = pd.read_excel(xls, sheet_name=sheet_name)
+            match sheet_name:
+                case 'Thermal Storages':
+                    storages = [ThermalStorage.fromPDSeries(row) for _, row in df.iterrows()]
+                    system.storages.add_components(storages)
+                case 'External Storages':
+                    extStor = [ExtStorage.fromPDSeries(row) for _, row in df.iterrows()]
+                    system.ext_storages.add_components(extStor)
+                case _:
+                    pass
+                
+        for sheet_name in xls.sheet_names:
+            df = pd.read_excel(xls, sheet_name=sheet_name)
+            match sheet_name:
+                case 'Conductions':
+                    conds=[]
+                    for _,row in df.iterrows():
+                        storage1 = next((st for st in system.storages.items if st.name==row['Storage1']),None)
+                        if storage1 is None:
+                            storage1 = next((st for st in system.ext_storages.items if st.name==row['Storage1']),None)
+                        if storage1 is None:
+                            raise ValueError(f"Can not find Storage1: {row['Storage1']} of {row['Name']} in {sheet_name}. Check if storage exists.")
+                        
+                        storage2 = next((st for st in system.storages.items if st.name==row['Storage2']),None)
+                        if storage2 is None:
+                            storage2 = next((st for st in system.ext_storages.items if st.name==row['Storage2']),None)
+                        if storage2 is None:
+                            raise ValueError(f"Can not find Storage2: {row['Storage2']} of {row['Name']} in {sheet_name}. Check if storage exists.")
+                        conds.append(Conduction(storage1,storage2,row['Coeff'],row['Name']))
+                    system.conductions.add_components(conds)
+                case 'Forced Convections':
+                    forcedConv=[]
+                    for _,row in df.iterrows():
+                        stors=[]
+                        for storage in eval(row['StorageList']):
+                            stor = next((st for st in system.storages.items if st.name==storage),None)
+                            if stor is None:
+                                stor = next((st for st in system.ext_storages.items if st.name==storage),None)
+                            if stor is None:
+                                raise ValueError(f"Can not find storage: {storage} of {row['Name']} in {sheet_name}. Check if storage exists.")
+                            stors.append(stor)
+                        forcedConv.append(ForcedConvection.newForcedConvection(stors,row['MassFlow'],row['Name'],row['CpFluid']))
+                    system.forcedConvections.add_components(forcedConv)
+                case 'Free Convections':
+                    freeConvs=[]
+                    for _,row in df.iterrows():
+                        storage1 = next((st for st in system.storages.items if st.name==row['Storage1']),None)
+                        if storage1 is None:
+                            storage1 = next((st for st in system.ext_storages.items if st.name==row['Storage1']),None)
+                        if storage1 is None:
+                            raise ValueError(f"Can not find Storage1: {row['Storage1']} of {row['Name']} in {sheet_name}. Check if storage exists.")
+                        
+                        storage2 = next((st for st in system.storages.items if st.name==row['Storage2']),None)
+                        if storage2 is None:
+                            storage2 = next((st for st in system.ext_storages.items if st.name==row['Storage2']),None)
+                        if storage2 is None:
+                            raise ValueError(f"Can not find Storage2: {row['Storage2']} of {row['Name']} in {sheet_name}. Check if storage exists.")
+                        freeConvs.append(FreeConvection.newFreeConvection(storage1,storage2,row['MassFlow'],row['CpFluid'],row['Tolerance'],row['Name']))
+                    system.freeConvections.add_components(freeConvs)
+                case 'General Heat Transfers':
+                    pass #TODO
+                case _:
+                    pass
+            return system

thermobuilpy-0.0.2/src/ThermoBuilPy.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: thermobuilpy
+Version: 0.0.2
+Summary: ToDo
+Home-page: https://github.com/hanneshanse/MilPython
+Author: Hannes Hanse
+Author-email: hannes.hanse@tu-clausthal.de
+License: MIT
+Keywords: milp,time series,optimization,gurobi,gurobipy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+
+# ThermoBuilPy
+MilPython is a python Framework ... TODO
+

thermobuilpy-0.0.2/src/ThermoBuilPy.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE.txt
+README.md
+setup.py
+src/ThermoBuilPy/__init__.py
+src/ThermoBuilPy/component.py
+src/ThermoBuilPy/connection.py
+src/ThermoBuilPy/storage.py
+src/ThermoBuilPy/stratifiedStorage.py
+src/ThermoBuilPy/thermalSystem.py
+src/ThermoBuilPy.egg-info/PKG-INFO
+src/ThermoBuilPy.egg-info/SOURCES.txt
+src/ThermoBuilPy.egg-info/dependency_links.txt
+src/ThermoBuilPy.egg-info/requires.txt
+src/ThermoBuilPy.egg-info/top_level.txt
+src/thermobuilpy.egg-info/PKG-INFO
+src/thermobuilpy.egg-info/SOURCES.txt
+src/thermobuilpy.egg-info/dependency_links.txt
+src/thermobuilpy.egg-info/requires.txt
+src/thermobuilpy.egg-info/top_level.txt

thermobuilpy-0.0.2/src/ThermoBuilPy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

thermobuilpy-0.0.2/src/ThermoBuilPy.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+matplotlib

thermobuilpy-0.0.2/src/ThermoBuilPy.egg-info/top_level.txt

@@ -0,0 +1 @@
+ThermoBuilPy