updating all

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "app",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

pinch_tool/.gitignore

@@ -0,0 +1,376 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python,visualstudiocode,pycharm,microsoftoffice,windows,git,jupyternotebooks
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,visualstudiocode,pycharm,microsoftoffice,windows,git,jupyternotebooks
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+### JupyterNotebooks ###
+# gitignore template for Jupyter Notebooks
+# website: http://jupyter.org/
+
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Remove previous ipynb_checkpoints
+#   git rm -r .ipynb_checkpoints/
+
+### MicrosoftOffice ###
+*.tmp
+
+# Word temporary
+~$*.doc*
+
+# Word Auto Backup File
+Backup of *.doc*
+
+# Excel temporary
+~$*.xls*
+
+# Excel Backup File
+*.xlk
+
+# PowerPoint temporary
+~$*.ppt*
+
+# Visio autosave temporary files
+*.~vsd*
+
+Buffer file for TotalSiteProfile creation.csv
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator/
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+.idea/$CACHE_FILE$
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+.idea/codestream.xml
+
+# Azure Toolkit for IntelliJ plugin
+# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
+.idea/**/azureSettings.xml
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+
+# IPython
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### VisualStudioCode ###
+.vscode/*
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk

pinch_tool/.gitlab-ci.yml

@@ -0,0 +1,3 @@
+include:
+  - project: 'est/est-repo-templates/gitlab-ci-templates'
+    file: 'python/python-default.gitlab-ci.yml'

pinch_tool/HPI_main.py

@@ -0,0 +1,12 @@
+from Pinch_main import Pinchmain
+from Modules.HeatPumpIntegration.HeatPumpIntegration import HeatPumpIntegration as HPI
+import matplotlib.pyplot as plt
+
+class HPImain():
+    def __init__(self, streamsDataFile, TS = None):
+        self.pyPinchHPI = Pinchmain(streamsDataFile, options= {})
+        self.HPI = HPI(streamsDataFile, TS, self.pyPinchHPI)
+    def showHPI(self):
+        self.HPI.HPI()
+        plt.show()
+HPImain('Example.csv').showHPI()

pinch_tool/ISSP_main.py

@@ -0,0 +1,22 @@
+from Pinch_main import Pinchmain
+from Modules.ISSP.ISSP import ISSP
+from Modules.HeatPumpIntegration.HeatPumpIntegration import HeatPumpIntegration as HPI
+import matplotlib.pyplot as plt
+
+class ISSPmain():
+    def __init__(self, streamsDataFile, TS, TProcess, batchtimeSeconds, fromPinch = False, intermediateCircuit = {}):
+        self.pyPinchISSP = Pinchmain(streamsDataFile, options= {})
+        self.pyPinchHPI = Pinchmain(streamsDataFile, options= {})
+        self.HPI = HPI(streamsDataFile, TS, self.pyPinchHPI)
+        self.fromPinch = bool(fromPinch)
+        self.intermediateCircuit = bool(intermediateCircuit)
+        self.ISSP = ISSP(streamsDataFile, TS, TProcess, batchtimeSeconds, self.pyPinchISSP, self.HPI, self.fromPinch, self.intermediateCircuit)
+
+    def solveISSP(self):
+        self.ISSP.CCinkWh()
+        self.ISSP.drawISSPHotIntermediate()
+        self.ISSP.drawISSPColdIntermediate()
+        #self.HPI.drawGrandCompositeCurve()
+        plt.show()
+#ISSPmain('Prozess_neu.csv', 200, 170, batchtimeSeconds= 9240, fromPinch=False).solveISSP()
+ISSPmain('Example.csv', 143, 113, batchtimeSeconds= 1000, fromPinch=False).solveISSP()

pinch_tool/InputCSVs/.gitignore

@@ -0,0 +1 @@
+*.csv

pinch_tool/Modules/HeatPumpIntegration/HPIPlot.py

@@ -0,0 +1,61 @@
+from matplotlib import pyplot as plt
+
+class HPIPlot():
+    def __init__(self, processdesignation, Tsinkout, pyPinch, EvWP, KoWP, COPWerte, COPT, GCCdraw, _temperatures, COPRegression):
+        self.processdesignation = processdesignation
+        self.grandCompositeCurve = GCCdraw
+        self.KoWP = KoWP
+        self.EvWP = EvWP
+        self.COPWerte = COPWerte
+        self.COPT = COPT
+        self.Tsinkout = Tsinkout
+        self.pyPinch = pyPinch
+        self._temperatures = _temperatures
+        self.COPRegression = COPRegression
+    def drawCOPKo(self):
+        self.x = []
+        self.y = []
+        fig1 = plt.figure()
+        for i in self.KoWP[::3]:
+            self.x.append(i)
+        for i in self.COPWerte[::3]:
+            self.y.append(i)
+        plt.plot(self.x,self.y)
+        plt.grid(True)
+        plt.title('COP gegen Qpunkt Ko')#plt.title('Grand Composite Curve')
+        plt.xlabel('Qpunkt Ko [kW]')#plt.xlabel('Net Enthalpy Change ∆H (kW)')
+        plt.ylabel('COP [-]')#plt.ylabel('Shifted Temperature S (degC)')
+    
+    def drawGrandCompositeCurve(self):
+        grandCompositeCurve = self.grandCompositeCurve
+        Tempplus = 0
+        self.heatCascade = self.pyPinch.heatCascade
+        plt.close('all')
+        fig = plt.figure()
+        if self.heatCascade[0]['deltaH'] > 0:  
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [self.grandCompositeCurve['T'][0],self.grandCompositeCurve['T'][1]], 'tab:red')
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [self.grandCompositeCurve['T'][0],self.grandCompositeCurve['T'][1]], 'ro')
+        elif self.heatCascade[0]['deltaH'] < 0:
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [self.grandCompositeCurve['T'][0],self.grandCompositeCurve['T'][1]], 'tab:blue')
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [grandCompositeCurve['T'][0],grandCompositeCurve['T'][1]], 'bo')
+
+        for i in range(1, len(self._temperatures)-1):
+            if self.heatCascade[i]['deltaH'] > 0:
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'tab:red')
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'ro')
+            elif self.heatCascade[i]['deltaH'] < 0:
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'tab:blue')
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'bo')
+            elif self.heatCascade[i]['deltaH'] == 0 and grandCompositeCurve['H'][i]!=0:
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'tab:blue')
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'bo')
+
+        plt.plot(self.EvWP[-1],self.COPT[-1],'g^')
+        plt.plot(self.KoWP[-1],self.Tsinkout,'g^')
+        plt.text(0.94*self.KoWP[-1],0.93*self.Tsinkout,round(self.COPWerte[-1],2))
+        plt.grid(True)
+        name = self.processdesignation
+        plt.suptitle('Großverbundkurve {} °C ({})'.format(round(self.Tsinkout,1),name))#plt.title('Grand Composite Curve')
+        plt.title(self.COPRegression)
+        plt.xlabel('Nettoenthalpiestromänderung ∆H in kW')#plt.xlabel('Net Enthalpy Change ∆H (kW)')
+        plt.ylabel('Verschobene Temperatur in °C')#plt.ylabel('Shifted Temperature S (degC)')

pinch_tool/Modules/HeatPumpIntegration/HeatPumpIntegration.py

@@ -0,0 +1,319 @@
+from tabulate import tabulate
+from Modules.HeatPumpIntegration.HPIPlot import HPIPlot
+from Modules.Utility.TemperaturePocketDeletion import TemperaturePocketDeletion as TPD
+
+class HeatPumpIntegration():
+    def __init__(self,streamsDataFile, Tsinkout, pyPinch):
+        self.Integrationtype = None
+        if Tsinkout == None:
+            self.Integrationtype = 'Itterativ'
+        self.processdesignation = streamsDataFile[:-4]
+        self.streamsDataFile = streamsDataFile
+        self.options = {'draw', 'debug'}
+        self.KoWP = []
+        self.EvWP = []
+        self.COPwerte = []
+        self.COPT = []
+        self.SchrittweiteTemp = 0.05
+        self.Tsinkout = Tsinkout
+
+        self.pyPinch = pyPinch
+
+    def COP(self,T):
+        COPList = []
+        StringList = []
+        if 144 <= self.Tsinkout <= 212 and 25 <= self.Tsinkout-T <= 190: #Prototypical Stirling
+            COPList.append(1.28792 * ((self.Tsinkout-(T)) + 2 * 0.54103)**(-0.37606) * (self.Tsinkout+273 + 0.54103)**0.35992)
+            StringList.append('Prototypical Stirling')
+        if 80 <= self.Tsinkout <= 160 and 25 <= self.Tsinkout-T <= 95: #VHTHP (HFC/HFO)
+            COPList.append(1.9118 * ((self.Tsinkout-(T)) + 2 * 0.04419)**(-0.89094) * (self.Tsinkout+273 + 0.04419)**0.67895)
+            StringList.append('VHTHP (HFC/HFO)')
+        if 25 <= self.Tsinkout <= 100 and 10 <= self.Tsinkout-T <= 78: #SHP and HTHPs (HFC/HFO)
+            COPList.append(1.4480*(10**12) * ((self.Tsinkout-(T)) + 2 * 88.73)**(-4.9469))
+            StringList.append('SHP and HTHPs (HFC/HFO)')
+        if 70 <= self.Tsinkout <= 85 and 30 <= self.Tsinkout-T <= 75: #SHP and HTHPs (R717)
+            COPList.append(40.789 * ((self.Tsinkout-(T)) + 2 * 1.0305)**(-1.0489) * (self.Tsinkout+273 + 1.0305)**0.29998)
+            StringList.append('SHP and HTHPs (R717)')
+        if len(COPList) == 0:
+            COPList.append((self.Tsinkout+273.15)/(self.Tsinkout-T)*0.5) # Carnot
+            StringList.append('Carnot')
+        return max(COPList),StringList[COPList.index(max(COPList))]
+    
+    def get_available_heat_pumps(self, T):
+        """Returns list of all heat pump types with their COPs and availability status"""
+        hp_list = []
+        delta_T = self.Tsinkout - T
+        
+        # Prototypical Stirling
+        if 144 <= self.Tsinkout <= 212 and 25 <= delta_T <= 190:
+            cop = 1.28792 * ((self.Tsinkout-(T)) + 2 * 0.54103)**(-0.37606) * (self.Tsinkout+273 + 0.54103)**0.35992
+            hp_list.append({'name': 'Prototypical Stirling', 'cop': cop, 'available': True, 'reason': ''})
+        else:
+            hp_list.append({'name': 'Prototypical Stirling', 'cop': None, 'available': False, 
+                          'reason': f'Requires: 144°C≤T_sink≤212°C, 25°C≤ΔT≤190°C (Current: T_sink={self.Tsinkout:.1f}°C, ΔT={delta_T:.1f}°C)'})
+        
+        # VHTHP (HFC/HFO)
+        if 80 <= self.Tsinkout <= 160 and 25 <= delta_T <= 95:
+            cop = 1.9118 * ((self.Tsinkout-(T)) + 2 * 0.04419)**(-0.89094) * (self.Tsinkout+273 + 0.04419)**0.67895
+            hp_list.append({'name': 'VHTHP (HFC/HFO)', 'cop': cop, 'available': True, 'reason': ''})
+        else:
+            hp_list.append({'name': 'VHTHP (HFC/HFO)', 'cop': None, 'available': False,
+                          'reason': f'Requires: 80°C≤T_sink≤160°C, 25°C≤ΔT≤95°C (Current: T_sink={self.Tsinkout:.1f}°C, ΔT={delta_T:.1f}°C)'})
+        
+        # SHP and HTHPs (HFC/HFO)
+        if 25 <= self.Tsinkout <= 100 and 10 <= delta_T <= 78:
+            cop = 1.4480*(10**12) * ((self.Tsinkout-(T)) + 2 * 88.73)**(-4.9469)
+            hp_list.append({'name': 'SHP and HTHPs (HFC/HFO)', 'cop': cop, 'available': True, 'reason': ''})
+        else:
+            hp_list.append({'name': 'SHP and HTHPs (HFC/HFO)', 'cop': None, 'available': False,
+                          'reason': f'Requires: 25°C≤T_sink≤100°C, 10°C≤ΔT≤78°C (Current: T_sink={self.Tsinkout:.1f}°C, ΔT={delta_T:.1f}°C)'})
+        
+        # SHP and HTHPs (R717)
+        if 70 <= self.Tsinkout <= 85 and 30 <= delta_T <= 75:
+            cop = 40.789 * ((self.Tsinkout-(T)) + 2 * 1.0305)**(-1.0489) * (self.Tsinkout+273 + 1.0305)**0.29998
+            hp_list.append({'name': 'SHP and HTHPs (R717)', 'cop': cop, 'available': True, 'reason': ''})
+        else:
+            hp_list.append({'name': 'SHP and HTHPs (R717)', 'cop': None, 'available': False,
+                          'reason': f'Requires: 70°C≤T_sink≤85°C, 30°C≤ΔT≤75°C (Current: T_sink={self.Tsinkout:.1f}°C, ΔT={delta_T:.1f}°C)'})
+        
+        # Carnot (always available)
+        cop_carnot = (self.Tsinkout+273.15)/(self.Tsinkout-T)*0.5
+        hp_list.append({'name': 'Carnot', 'cop': cop_carnot, 'available': True, 'reason': ''})
+        
+        return hp_list
+    
+    def COP_specific(self, T, hp_type):
+        """Calculate COP for a specific heat pump type"""
+        if hp_type == 'Prototypical Stirling':
+            if 144 <= self.Tsinkout <= 212 and 25 <= self.Tsinkout-T <= 190:
+                return 1.28792 * ((self.Tsinkout-(T)) + 2 * 0.54103)**(-0.37606) * (self.Tsinkout+273 + 0.54103)**0.35992
+        elif hp_type == 'VHTHP (HFC/HFO)':
+            if 80 <= self.Tsinkout <= 160 and 25 <= self.Tsinkout-T <= 95:
+                return 1.9118 * ((self.Tsinkout-(T)) + 2 * 0.04419)**(-0.89094) * (self.Tsinkout+273 + 0.04419)**0.67895
+        elif hp_type == 'SHP and HTHPs (HFC/HFO)':
+            if 25 <= self.Tsinkout <= 100 and 10 <= self.Tsinkout-T <= 78:
+                return 1.4480*(10**12) * ((self.Tsinkout-(T)) + 2 * 88.73)**(-4.9469)
+        elif hp_type == 'SHP and HTHPs (R717)':
+            if 70 <= self.Tsinkout <= 85 and 30 <= self.Tsinkout-T <= 75:
+                return 40.789 * ((self.Tsinkout-(T)) + 2 * 1.0305)**(-1.0489) * (self.Tsinkout+273 + 1.0305)**0.29998
+        # Fallback to Carnot
+        return (self.Tsinkout+273.15)/(self.Tsinkout-T)*0.5
+        
+    def deleteTemperaturePockets(self):
+        self.pyPinch = self.pyPinch.PinchAnalyse
+        self.hotUtility = self.pyPinch.hotUtility
+        self.heatCascade = self.pyPinch.heatCascade
+        self._temperatures = self.pyPinch._temperatures
+        self.deletedPocketdict = TPD(self.hotUtility, self.heatCascade, self._temperatures).deleteTemperaturePockets()
+
+    def splitHotandCold(self):
+        self.splitHotTemperatures = []
+        self.splitColdTemperatures = []
+        self.splitHotH = []
+        self.splitColdH = []
+        testHot = 0
+        testCold = 0
+    
+        for i in range(len(self.deletedPocketdict['T'][0])):
+            if i >= len(self.deletedPocketdict['deltaH'][0]):
+                continue
+            if self.deletedPocketdict['deltaH'][0][i] > 0 and testHot == 0:
+                    self.splitHotTemperatures.append(self.deletedPocketdict['T'][0][i])
+                    self.splitHotH.append(self.deletedPocketdict['H'][0][i])
+                    self.splitHotTemperatures.append(self.deletedPocketdict['T'][0][i+1])
+                    self.splitHotH.append(self.deletedPocketdict['H'][0][i+1])
+                    testHot = 1
+
+            elif self.deletedPocketdict['deltaH'][0][i] > 0 and testHot == 1:
+                    self.splitHotTemperatures.append(self.deletedPocketdict['T'][0][i+1])
+                    self.splitHotH.append(self.deletedPocketdict['H'][0][i+1])
+
+            elif self.deletedPocketdict['deltaH'][0][i] < 0 and testCold == 0:
+                    self.splitColdTemperatures.append(self.deletedPocketdict['T'][0][i])
+                    self.splitColdH.append(self.deletedPocketdict['H'][0][i])
+                    self.splitColdTemperatures.append(self.deletedPocketdict['T'][0][i+1])
+                    self.splitColdH.append(self.deletedPocketdict['H'][0][i+1])
+                    testCold = 1
+            elif self.deletedPocketdict['deltaH'][0][i] < 0 and testCold == 1:
+                    self.splitColdTemperatures.append(self.deletedPocketdict['T'][0][i+1])
+                    self.splitColdH.append(self.deletedPocketdict['H'][0][i+1])
+            elif self.deletedPocketdict['deltaH'][0][i] == 0:
+                    if self.deletedPocketdict['deltaH'][0][i-1] < 0:
+                        self.splitColdTemperatures.append(self.deletedPocketdict['T'][0][i+1])
+                        self.splitColdH.append(self.deletedPocketdict['H'][0][i+1])
+
+                    elif self.deletedPocketdict['deltaH'][0][i-1] > 0:
+                        self.splitHotTemperatures.append(self.deletedPocketdict['T'][0][i+1])
+                        self.splitHotH.append(self.deletedPocketdict['H'][0][i+1])
+                    else:
+                        pass
+
+            else:
+                    pass
+        
+        
+
+        self.splitColddeltaH = []
+        self.splitHotdeltaH = []                
+        for i in range(len(self.splitColdH)-1):
+            self.splitColddeltaH.append(self.splitColdH[i+1]-self.splitColdH[i])
+
+        for i in range(len(self.splitHotH)-1):
+            self.splitHotdeltaH.append(self.splitHotH[i+1]-self.splitHotH[i])   
+            
+        return {'H':self.splitHotH, 'T':self.splitHotTemperatures, 'deltaH':self.splitHotdeltaH},{'H':self.splitColdH, 'T':self.splitColdTemperatures, 'deltaH':self.splitColddeltaH}
+    
+    def QpunktEv(self,T,Quelle): # FEHLER
+        return self.GCCSource['H'][Quelle] + ((self.GCCSource['H'][Quelle+1]-self.GCCSource['H'][Quelle])/(self.GCCSource['T'][Quelle+1]-self.GCCSource['T'][Quelle])) * (T-self.GCCSource['T'][Quelle])
+    
+    def QpunktKo(self,T,Quelle):
+        return self.GCCSink['H'][Quelle-1] + ((self.GCCSink['H'][Quelle-1]-self.GCCSink['H'][Quelle])/(self.GCCSink['T'][Quelle-1]-self.GCCSink['T'][Quelle])) * (T-self.GCCSink['T'][Quelle-1])
+
+    def TKo(self,H,Quelle):
+        return self.GCCSink['T'][Quelle] - ((self.GCCSink['T'][Quelle]-self.GCCSink['T'][Quelle+1])/(self.GCCSink['H'][Quelle]-self.GCCSink['H'][Quelle+1])) * (self.GCCSink['H'][Quelle]-H)
+
+    def IntegrateHeatPump(self):
+        Test = 0
+        TSTest = 0
+
+        #Starttemperatur
+        if self.Integrationtype == 'Itterativ':
+            self.Tsinkout = self.GCCSink['T'][0]
+        else:
+            pass
+        Quelle = 0
+        self.SchrittweiteTemp = (self.GCCSource['T'][Quelle] - self.GCCSource['T'][Quelle+1])/10
+        T = self.GCCSource['T'][Quelle]-self.SchrittweiteTemp
+
+        while T > self.GCCSource['T'][-1]:
+            if T <= self.GCCSource['T'][Quelle+1]:
+                Quelle +=1
+                self.SchrittweiteTemp = (self.GCCSource['T'][Quelle] - self.GCCSource['T'][Quelle+1])/10
+                T = self.GCCSource['T'][Quelle]-self.SchrittweiteTemp
+                if self.GCCSource['deltaH'][Quelle] == 0.0:
+                    Quelle +=1
+                    self.SchrittweiteTemp = (self.GCCSource['T'][Quelle] - self.GCCSource['T'][Quelle+1])/10
+                    T = self.GCCSource['T'][Quelle]-self.SchrittweiteTemp
+            if T < self.GCCSource['T'][Quelle+1]:
+                T = self.GCCSource['T'][Quelle+1]
+            COP = self.COP(T)
+            QpunktEv = self.QpunktEv(T,Quelle)
+            QpunktKo = QpunktEv * ((1-(1/COP[0]))**(-1))
+            self.COPwerte.append(round(COP[0],3))
+            self.EvWP.append(round(QpunktEv))
+            self.KoWP.append(round(QpunktKo))
+            self.COPT.append(T)
+            for i in range(len(self.GCCSink['T'])):
+                if self.GCCSink['T'][i] <= self.Tsinkout:
+                    KoQuelle = i
+                    break
+            if QpunktKo >= self.QpunktKo(self.Tsinkout, KoQuelle) and self.Integrationtype == None and TSTest == 1 and self.Tsinkout < self.GCCSink['T'][0]:
+                break
+            if QpunktKo >= self.QpunktKo(self.Tsinkout, KoQuelle) and self.Integrationtype == None and TSTest == 0:
+                if self.Tsinkout <= self.GCCSink['T'][0]:
+                    T+=self.SchrittweiteTemp
+                    self.SchrittweiteTemp = self.SchrittweiteTemp/200
+                    TSTest = 1
+                else:
+                    break
+            if QpunktKo >= self.GCCSink['H'][0] and Test == 0:
+                T+=self.SchrittweiteTemp
+                self.SchrittweiteTemp = self.SchrittweiteTemp/200
+                Test = 1
+            elif QpunktKo >= self.GCCSink['H'][0] and Test == 1:
+                break
+            T-=self.SchrittweiteTemp
+            if T < self.GCCSource['T'][Quelle+1]:
+                T = self.GCCSource['T'][Quelle+1]
+
+            if T <= self.GCCSource['T'][-1]:
+                T = self.GCCSource['T'][-1]
+                COP = self.COP(T)
+                QpunktEv = self.GCCSource['H'][-1]
+                QpunktKo = QpunktEv * (1-(1/COP[0]))**(-1)
+                if self.Integrationtype == 'Itterativ':
+                    for i in range(len(self.GCCSink['H'])):
+                        if QpunktKo >= self.GCCSink['H'][i]:
+                            QuelleSenke = i-1
+                            break
+                    self.Tsinkout = self.TKo(QpunktKo,QuelleSenke)
+                    COP = self.COP(T)
+                    QpunktKo = QpunktEv * (1-(1/COP[0]))**(-1)
+                    TSinktest = self.TKo(QpunktKo, QuelleSenke)
+                    while abs(self.Tsinkout - TSinktest) >= 1:
+                        for i in range(len(self.GCCSink['H'])):
+                            if QpunktKo >= self.GCCSink['H'][i]:
+                                QuelleSenke = i-1
+                                break
+                        self.Tsinkout = self.TKo(QpunktKo,QuelleSenke)
+                        COP = self.COP(T)
+                        QpunktKo = QpunktEv * (1-(1/COP[0]))**(-1)
+                        TSinktest = self.TKo(QpunktKo, QuelleSenke)
+                
+                self.COPwerte.append(COP[0])
+                self.EvWP.append(round(QpunktEv))
+                self.KoWP.append(round(QpunktKo))
+                self.COPT.append(T)
+        self.COPRegression = COP[1]
+        table = {'COP':self.COPwerte[::30],'QQuelle':self.EvWP[::30],'QSenke':self.KoWP[::30]}
+        self.tableISSP = {'Temp': self.COPT, 'COP':self.COPwerte,'QQuelle':self.EvWP,'QSenke':self.KoWP}
+        print(tabulate(table,headers='keys'))
+        print({'COP':self.COPwerte[-1],'QQuelle':self.EvWP[-1],'QSenke':self.KoWP[-1]})
+
+    def findIntegration(self):#Genaue Integration implementieren!
+        self.IntegrationPoint = {'Temp': [], 'COP':[],'QQuelle':[],'QSenke':[]}
+        for i in range(len(self.tableISSP['QSenke'])):
+            if self.tableISSP['QSenke'][i] >= self.GCCdraw['H'][0]:
+                self.IntegrationPoint['Temp'].append(self.tableISSP['Temp'][0]+self.SchrittweiteTemp)
+                self.IntegrationPoint['Temp'].append(self.tableISSP['Temp'][i])
+                self.IntegrationPoint['COP'].append(self.tableISSP['COP'][i])
+                self.IntegrationPoint['QQuelle'].append(self.tableISSP['QQuelle'][i])
+                #self.IntegrationPoint['QQuelle'].append(self.tableISSP['QQuelle'][self.tableISSP['Temp'].index(self.IntegrationPoint['Temp'][-1])])
+                self.IntegrationPoint['QSenke'].append(self.tableISSP['QSenke'][i])
+                break
+            else:
+                self.IntegrationPoint['Temp'].append(self.tableISSP['Temp'][0]+self.SchrittweiteTemp)
+                self.IntegrationPoint['Temp'].append(self.tableISSP['Temp'][-1])
+                self.IntegrationPoint['COP'].append(self.tableISSP['COP'][-1])
+                self.IntegrationPoint['QQuelle'].append(self.tableISSP['QQuelle'][-1])
+                #self.IntegrationPoint['QQuelle'].append(self.tableISSP['QQuelle'][self.tableISSP['Temp'].index(self.IntegrationPoint['Temp'][-1])])
+                self.IntegrationPoint['QSenke'].append(self.tableISSP['QSenke'][-1])
+                break
+    
+    def IntegrateHeatPump_specific(self, hp_type):
+        """Same as IntegrateHeatPump but uses specific heat pump type"""
+        self.selected_hp_type = hp_type
+        # Store original COP method
+        original_COP = self.COP
+        # Replace COP method temporarily
+        def COP_wrapper(T):
+            cop_val = self.COP_specific(T, hp_type)
+            return (cop_val, hp_type) if cop_val else original_COP(T)
+        self.COP = COP_wrapper
+        # Run integration
+        self.IntegrateHeatPump()
+        # Restore original method
+        self.COP = original_COP
+
+    
+    def solveforISSP(self):
+        self.GCCdraw = self.pyPinch.solvePinchforHPI().grandCompositeCurve
+        self.GCC = self.deleteTemperaturePockets()
+        self.IntegrateHeatPump()
+        self.findIntegration()
+        return self.IntegrationPoint
+    
+    def HPI(self):
+        self.GCCdraw = self.pyPinch.solvePinchforHPI().grandCompositeCurve
+        Temperaturesdraw = []
+        for i in self.pyPinch.PinchAnalyse._temperatures:
+            Temperaturesdraw.append(i)
+        self.deleteTemperaturePockets()
+        self.GCCSource, self.GCCSink = self.splitHotandCold()
+        self.IntegrateHeatPump()
+        self.findIntegration()
+        HPIPlot(self.streamsDataFile[:-4],self.Tsinkout,self.pyPinch,self.EvWP,self.KoWP, 
+                self.COPwerte,self.COPT,self.GCCdraw, Temperaturesdraw, self.COPRegression).drawCOPKo()
+        HPIPlot(self.streamsDataFile[:-4],self.Tsinkout,self.pyPinch,self.EvWP,self.KoWP, 
+                self.COPwerte,self.COPT,self.GCCdraw, Temperaturesdraw, self.COPRegression).drawGrandCompositeCurve()
+

pinch_tool/Modules/ISSP/ISSP.py

@@ -0,0 +1,142 @@
+from matplotlib import pyplot as plt
+from Modules.Utility.Thermodynamic_Properties import ThermodynamicProperties as Props
+
+class ISSP():
+    def __init__(self, streamsDataFile, TS, TProcess, batchtimeSeconds, pyPinch, HPI, fromPinch, intermediateCircuit = {}):
+
+        self.processdesignation = streamsDataFile[:-4]
+        self.streamsDataFile = streamsDataFile
+        self.options = {'draw', 'debug'}
+        self.fromPinch = bool(fromPinch)
+        self.intermediateCircuit = bool(intermediateCircuit)
+        self.TS = TS
+        self.TProcess = TProcess
+
+        self.IntegrationPoint = HPI.solveforISSP()
+        self.Pinch = pyPinch.solvePinchforISSP()
+        self.CC = self.Pinch[0]
+        self.pyPinch = self.Pinch[1]
+
+        self.deltaTmin = self.pyPinch.tmin
+
+        self.t = batchtimeSeconds/3600
+    
+    def CCinkWh(self):
+        for i in range(len(self.CC['hot']['H'])):
+            self.CC['hot']['H'][i] = self.CC['hot']['H'][i]*self.t
+        self.CC['hot']['kWh'] = self.CC['hot']['H']
+        del self.CC['hot']['H']
+
+        for i in range(len(self.CC['cold']['H'])):
+            self.CC['cold']['H'][i] = self.CC['cold']['H'][i]*self.t
+        self.CC['cold']['kWh'] = self.CC['cold']['H']
+        del self.CC['cold']['H']
+    
+    def ISSPHotIntermediateGerade(self, kWh, Tempdiff):
+        return (self.IntegrationPoint['Temp'][-1]-Tempdiff) + ((self.IntegrationPoint['Temp'][0]-self.TemperaturKorrektur) - (self.IntegrationPoint['Temp'][-1]-Tempdiff))/(self.IntegrationPoint['QQuelle'][0]*self.t) * (kWh-self.DifferenzHot)
+  
+    def drawISSPHotIntermediate(self):#Verdichter
+        if self.fromPinch == True:
+            self.TemperaturKorrektur = 1.25 * self.deltaTmin
+        else:
+            self.TemperaturKorrektur = 0.25 * self.deltaTmin
+        deltaTZwischenlreislauf0 = 2/4 * self.deltaTmin
+        self.DifferenzHot = self.CC['hot']['kWh'][-1] - self.IntegrationPoint['QQuelle'][0]*self.t
+        self.coldUtility = self.pyPinch.coldUtility*self.t
+        self.hotUtility = self.pyPinch.hotUtility*self.t
+        self._temperatures = self.pyPinch._temperatures
+        self.pinchTemperature = self.pyPinch.pinchTemperature
+        m = 0
+        for i in range(len(self.CC['hot']['T'])):
+            if self.CC['hot']['T'][i] >= self.IntegrationPoint['Temp'][-1]:
+                
+                try: m = self.CC['hot']['T'][i-1] + (self.CC['hot']['T'][i] - self.CC['hot']['T'][i-1])/(self.CC['hot']['kWh'][i] - self.CC['hot']['kWh'][i-1]) * (self.DifferenzHot-self.CC['hot']['kWh'][i-1])
+
+                except: print('error m') #m = self.CC['hot']['T'][1] + (self.CC['hot']['T'][i+1] - self.CC['hot']['T'][i])/(self.CC['hot']['kWh'][i+1] - self.CC['hot']['kWh'][i]) * (self.IntegrationPoint['QQuelle'][0]*self.t - self.CC['hot']['kWh'][i])
+                if m != 0:
+                    break
+        if float(self.DifferenzHot) == 0.0 and float(self.CC['hot']['kWh'][-2]) == 0.0:
+            ZwischenkreislaufTemp = self.CC['hot']['T'][-1] - deltaTZwischenlreislauf0
+        else:
+            ZwischenkreislaufTemp = (self.CC['hot']['T'][-2] - deltaTZwischenlreislauf0) + (self.CC['hot']['T'][-2] - m) / (self.CC['hot']['kWh'][-2] - self.DifferenzHot) * (self.CC['hot']['kWh'][-1] -self.CC['hot']['kWh'][-2]) 
+            self.TemperaturKorrektur = (self.CC['hot']['T'][-2] - self.TemperaturKorrektur) + (self.CC['hot']['T'][-2] - m) / (self.CC['hot']['kWh'][-2] - self.DifferenzHot) * (self.CC['hot']['kWh'][-1] -self.CC['hot']['kWh'][-2]) 
+        
+        self.VolumenWWSpeicher = round(self.IntegrationPoint['QQuelle'][0]*self.t * 3600 / (4.18 * (ZwischenkreislaufTemp-(m-deltaTZwischenlreislauf0)))/1000,1) #m^3
+        plt.close('all')
+        fig = plt.figure(num='{} Verd'.format(self.processdesignation))
+        if self.intermediateCircuit == True:
+            plt.plot(self.CC['hot']['kWh'], self.CC['hot']['T'], 'tab:red')
+            plt.plot([self.DifferenzHot,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self.IntegrationPoint['Temp'][-1]-1.25*self.deltaTmin,+self.TemperaturKorrektur], 'tab:blue')
+            plt.plot([self.DifferenzHot,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [m-deltaTZwischenlreislauf0,ZwischenkreislaufTemp], 'k')
+
+            #plt.plot(self.CC['hot']['kWh'], self.CC['hot']['T'], 'ro')
+            plt.plot([self.DifferenzHot,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self.IntegrationPoint['Temp'][-1]-1.25*self.deltaTmin,self.TemperaturKorrektur], 'bo')
+            plt.plot([self.DifferenzHot,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot],[(m-deltaTZwischenlreislauf0),ZwischenkreislaufTemp],'ko')
+        elif self.fromPinch == False: 
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self._temperatures[-1]+0.5*self.deltaTmin,ZwischenkreislaufTemp-self.deltaTmin], 'tab:red')
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self._temperatures[-1]+0.25*self.deltaTmin,self._temperatures[-1]+0.25*self.deltaTmin])#,self.TemperaturKorrektur], 'tab:blue')
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self._temperatures[-1]+0.5*self.deltaTmin,ZwischenkreislaufTemp-self.deltaTmin],linestyle = (0, (5, 10)), color = 'black')
+
+            #plt.plot(self.CC['hot']['kWh'], self.CC['hot']['T'], 'ro')
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self._temperatures[-1]+0.25*self.deltaTmin,self._temperatures[-1]+0.25*self.deltaTmin], 'bo') #self.TemperaturKorrektur
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot],[self._temperatures[-1]+0.5*self.deltaTmin,ZwischenkreislaufTemp-self.deltaTmin],'ko')
+        elif self.fromPinch == True:
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [m-deltaTZwischenlreislauf0,ZwischenkreislaufTemp], 'tab:red')
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self._temperatures[-1]+0.25*self.deltaTmin,self._temperatures[-1]+0.25*self.deltaTmin])#,self.TemperaturKorrektur], 'tab:blue')
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [m-deltaTZwischenlreislauf0,ZwischenkreislaufTemp],linestyle = (0, (5, 10)), color = 'black')
+
+            #plt.plot(self.CC['hot']['kWh'], self.CC['hot']['T'], 'ro')
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot], [self.IntegrationPoint['Temp'][-1]-1.25*self.deltaTmin,self.IntegrationPoint['Temp'][-1]-1.25*self.deltaTmin], 'bo') #self.TemperaturKorrektur
+            plt.plot([0,self.IntegrationPoint['QQuelle'][0]*self.t+self.DifferenzHot],[(m-deltaTZwischenlreislauf0),ZwischenkreislaufTemp],'ko')
+
+
+        plt.grid(True,linewidth=1.5)
+        plt.tick_params(axis='both', which='major', labelsize=12)
+        plt.title('a) ISSP stratified TES', fontsize=14)
+        plt.xlabel('ΔH / Batch in kWh', fontsize=14)
+        plt.ylabel('Shifted temperature T in °C', fontsize=14)
+
+    def drawISSPColdIntermediate(self):
+        deltaTZwischenkreislauf = 3/4 * self.deltaTmin
+        if self.fromPinch == True:
+            Verschiebung = 1.25 * self.deltaTmin
+            Verschiebung2 = 1.25 * self.deltaTmin
+        else:
+            Verschiebung = 0.25 * self.deltaTmin
+            Verschiebung2 = 0.25 * self.deltaTmin
+        self.Dampfmasse = (self.IntegrationPoint['QSenke'][0]*self.t * 3600)/Props.get_latentheat(self.TS)
+            #vStrich1 = 1/925.014712422 #140 °C
+        h1_prime = Props.get_hprime(self.TS)
+        h1_double_prime = Props.get_hdouble_prime(self.TS)
+        v1_prime = Props.get_vprime(self.TS)
+        h2_prime = Props.get_hprime(self.TProcess)
+        h2_double_prime = Props.get_hdouble_prime(self.TProcess)
+
+        Füllgrad = 0.9     
+        self.VolumenDampfSpeicher = round(self.Dampfmasse/ ((Füllgrad/v1_prime)*((h1_prime-h2_prime)/(0.5*(h1_double_prime+h2_double_prime)-h2_prime))),1)
+        #http://berndglueck.de/Waermespeicher
+
+        fig = plt.figure(num='{} Kond'.format(self.processdesignation))
+        if self.intermediateCircuit == True:
+            plt.plot([self.CC['cold']['kWh'][-1],self.IntegrationPoint['QSenke'][0]*self.t+self.CC['cold']['kWh'][-1]], [self.CC['cold']['T'][-1]+Verschiebung,self.CC['cold']['T'][0]+Verschiebung], 'tab:red')
+            plt.plot(self.CC['cold']['kWh'], self.CC['cold']['T'], 'tab:blue')
+            plt.plot([self.CC['cold']['kWh'][-1],self.IntegrationPoint['QSenke'][0]*self.t+self.CC['cold']['kWh'][-1]], [self.CC['cold']['T'][-1]+Verschiebung-deltaTZwischenkreislauf,self.CC['cold']['T'][0]+Verschiebung-deltaTZwischenkreislauf], 'k')
+
+            plt.plot([self.CC['cold']['kWh'][-1],self.IntegrationPoint['QSenke'][0]*self.t+self.CC['cold']['kWh'][-1]], [self.CC['cold']['T'][-1]+Verschiebung,self.CC['cold']['T'][0]+Verschiebung], 'ro')
+            plt.plot(self.CC['cold']['kWh'], self.CC['cold']['T'], 'bo')
+            plt.plot([self.CC['cold']['kWh'][-1],self.IntegrationPoint['QSenke'][0]*self.t+self.CC['cold']['kWh'][-1]], [self.CC['cold']['T'][-1]+Verschiebung-deltaTZwischenkreislauf,self.CC['cold']['T'][0]+Verschiebung-deltaTZwischenkreislauf], 'ko')
+        else:
+            plt.plot([0,self.IntegrationPoint['QSenke'][0]*self.t], [self.CC['cold']['T'][0]+Verschiebung2,self.CC['cold']['T'][0]+Verschiebung2], 'tab:red')
+            plt.plot([0,self.IntegrationPoint['QSenke'][0]*self.t], [self.CC['cold']['T'][-1]+Verschiebung-deltaTZwischenkreislauf,self.CC['cold']['T'][0]+Verschiebung-deltaTZwischenkreislauf], 'tab:blue')
+            plt.plot([0,self.IntegrationPoint['QSenke'][0]*self.t], [self.CC['cold']['T'][-1]+Verschiebung-deltaTZwischenkreislauf,self.CC['cold']['T'][0]+Verschiebung-deltaTZwischenkreislauf],linestyle = (0, (5, 10)), color = 'black')
+
+            plt.plot([0,self.IntegrationPoint['QSenke'][0]*self.t], [self.CC['cold']['T'][0]+Verschiebung2,self.CC['cold']['T'][0]+Verschiebung2], 'ro')
+            #plt.plot(self.CC['cold']['kWh'], self.CC['cold']['T'], 'bo')
+            plt.plot([0,self.IntegrationPoint['QSenke'][0]*self.t], [self.CC['cold']['T'][-1]+Verschiebung-deltaTZwischenkreislauf,self.CC['cold']['T'][0]+Verschiebung-deltaTZwischenkreislauf], 'ko')
+
+        plt.grid(True,linewidth=1.5)
+        plt.tick_params(axis='both', which='major', labelsize=12)
+        plt.title('b) ISSP steam RSA', fontsize=14)
+        plt.xlabel('ΔH / Batch in kWh', fontsize=14)
+        plt.xlim(right = 2500)
+        plt.ylabel('Shifted temperature T in °C', fontsize=14)

pinch_tool/Modules/Pinch/Pinch.py

@@ -0,0 +1,366 @@
+#Based on:
+    #!/usr/bin/env python3
+    # -*- coding: utf-8 -*-
+    # File              : PyPinch.py
+    # License           : License: GNU v3.0
+    # Author            : Andrei Leonard Nicusan <aln705@student.bham.ac.uk>
+    # Date              : 25.05.2019
+
+import csv
+import os
+import numpy as np
+from Modules.Pinch.Streams import Streams 
+from Modules.Pinch.PinchPlot import PinchPlot
+from Modules.Pinch.PinchExport import PinchExport
+
+
+class Pinch:
+
+    def __init__(self, streamsDataFile, options = {}):
+
+        self.tmin =                      0
+        self.streams =                   []
+        self.temperatureInterval =       []
+        self.problemTable =              []
+        self.hotUtility =                0
+        self.coldUtility =               0
+        self.unfeasibleHeatCascade =     []
+        self.heatCascade =               []
+        self.pinchTemperature =          0
+        self.shiftedCompositeDiagram =   {'hot': {'H': [], 'T': []}, 'cold': {'H': [], 'T': []}}
+        self.compositeDiagram =          {'hot': {'H': [], 'T': []}, 'cold': {'H': [], 'T': []}}
+        self.grandCompositeCurve =       {'H': [], 'T': []}
+
+        self._temperatures =             []
+        self._deltaHHot =                []
+        self._deltaHCold =               []
+        self._options =                  {'debug': False, 'draw': False, 'csv': False}
+        self._temperaturesHOT=           []
+        self._temperaturesCOLD =         []
+        self.emptyintervalstartHOT=         []
+        self.emptyintervalstartCOLD = []
+        self.lastHotStream = 0
+        self.lastColdStream = 0
+
+        self.emptyintervalsHot = {'H': [], 'T': []}
+        self.emptyintervalsCold = {'H': [], 'T': []}
+
+        self.processdesignation = streamsDataFile[:-4]
+        path = r"{} Pinch".format(self.processdesignation)
+        self.newpath = 'Output'+ '\\' + path
+
+        self.streams = Streams(streamsDataFile)
+        self.tmin = self.streams.tmin
+
+        if 'debug' in options:
+            self._options['debug'] = True
+        if 'draw' in options:
+            self._options['draw'] = True
+        if 'csv' in options:
+            self._options['csv'] = True
+
+
+    def shiftTemperatures(self):
+        for stream in self.streams:
+            if stream['type'] == 'HOT':
+                stream['ss'] = stream['ts'] - self.tmin / 2
+                stream['st'] = stream['tt'] - self.tmin / 2
+            else:
+                stream['ss'] = stream['ts'] + self.tmin / 2
+                stream['st'] = stream['tt'] + self.tmin / 2
+
+        if self._options['debug'] == True:
+            print("\nStreams: ")
+            for stream in self.streams:
+                print(stream)
+            print("Tmin = {}".format(self.tmin))
+
+
+    def constructTemperatureInterval(self):
+        # Take all shifted temperatures and reverse sort them,
+        # removing all duplicates
+        for stream in self.streams:
+            self._temperatures.append(stream['ss'])
+            self._temperatures.append(stream['st'])
+
+            if (stream["type"] == "HOT"):
+                self._temperaturesHOT.append(stream['ss'])
+                self._temperaturesHOT.append(stream['st'])
+
+            else:
+                self._temperaturesCOLD.append(stream['ss'])
+                self._temperaturesCOLD.append(stream['st'])
+
+
+        self._temperaturesHOT = list(set(self._temperaturesHOT))
+        self._temperaturesHOT.sort()
+        self._temperaturesCOLD = list(set(self._temperaturesCOLD))
+        self._temperaturesCOLD.sort()
+        self._temperatures = list(set(self._temperatures))
+        self._temperatures.sort(reverse = True)
+
+        # Save the stream number of all the streams that pass
+        # through each shifted temperature interval
+        for i in range(len(self._temperatures) - 1):
+            t1 = self._temperatures[i]
+            t2 = self._temperatures[i + 1]
+            interval = {'t1': t1, 't2': t2, 'streamNumbers': []}
+
+            
+            j = 0
+            for stream in self.streams:
+                if (stream['type'] == 'HOT'):
+                    if (stream['ss'] >= t1 and stream['st'] <= t2):
+                        interval['streamNumbers'].append(j)
+                else:
+                    if (stream['st'] >= t1 and stream['ss'] <= t2):
+                        interval['streamNumbers'].append(j)
+                j = j + 1
+
+            self.temperatureInterval.append(interval)
+        
+
+
+        if self._options['debug'] == True:
+            print("\nTemperature Intervals: ")
+            i = 0
+            print(self._temperatures)
+            for interval in self.temperatureInterval:
+                print("Interval {} : {}".format(i, interval))
+                i = i + 1
+
+        if self._options['draw'] == True:
+            PinchPlot().drawTemperatureInterval(self._temperatures, self.streams)
+
+
+
+    def constructProblemTable(self):
+
+        for interval in self.temperatureInterval:
+            row = {}
+            row['deltaS'] = interval['t1'] - interval['t2']
+            row['deltaCP'] = 0
+
+            for i in interval['streamNumbers']:
+                if interval['streamNumbers'] != []:
+                    if self.streams.streamsData[i]['type'] == 'HOT':
+                        row['deltaCP'] = row['deltaCP'] + self.streams.streamsData[i]['cp']
+                    else:
+                        row['deltaCP'] = row['deltaCP'] - self.streams.streamsData[i]['cp']
+                else:
+                    row['deltaCP'] = 0
+
+            row['deltaH'] = row['deltaS'] * row['deltaCP']
+            self.problemTable.append(row)
+
+        if self._options['debug'] == True:
+            print("\nProblem Table: ")
+            i = 0
+            for interval in self.problemTable:
+                print("Interval {} : {}".format(i, interval))
+                i = i + 1
+
+        if self._options['draw'] == True:
+            PinchPlot().drawProblemTable(self.problemTable, self._temperatures)
+
+        if self._options['csv'] == True:
+            PinchExport().csvProblemTable(self.problemTable, self._temperatures, self.newpath)
+ 
+
+    def constructHeatCascade(self):
+
+        exitH = 0
+        lowestExitH = 0
+
+        i = 0
+        pinchInterval = 0
+        for interval in self.problemTable:
+            row = {}
+            row['deltaH'] = interval['deltaH']
+
+            exitH = exitH + row['deltaH']
+            row['exitH'] = exitH
+            if exitH < lowestExitH:
+                lowestExitH = exitH
+                pinchInterval = i
+
+            self.unfeasibleHeatCascade.append(row)
+            i = i + 1
+
+        self.hotUtility = -lowestExitH
+        exitH = self.hotUtility
+
+        for interval in self.problemTable:
+            row = {}
+            row['deltaH'] = interval['deltaH']
+
+            exitH = exitH + row['deltaH']
+            row['exitH'] = exitH
+
+            self.heatCascade.append(row)
+
+        self.coldUtility = exitH
+        if pinchInterval == 0:
+            self.pinchTemperature = self.temperatureInterval[pinchInterval]['t2']
+        else:
+            self.pinchTemperature = self.temperatureInterval[pinchInterval]['t2']
+
+        if self._options['debug'] == True:
+            print("\nUnfeasible Heat Cascade: ")
+            i = 0
+            for interval in self.unfeasibleHeatCascade:
+                print("Interval {} : {}".format(i, interval))
+                i = i + 1
+
+            print("\nFeasible Heat Cascade: ")
+            i = 0
+            for interval in self.heatCascade:
+                print("Interval {} : {}".format(i, interval))
+                i = i + 1
+
+            print("\nPinch Temperature (degC): {}".format(self.pinchTemperature))
+            print("Minimum Hot Utility (kW): {}".format(self.hotUtility))
+            print("Minimum Cold Utility (kW): {}".format(self.coldUtility))
+
+        if self._options['draw'] == True:
+            PinchPlot().drawHeatCascade(self.unfeasibleHeatCascade, self.heatCascade, self.hotUtility)
+
+        if self._options['csv'] == True:
+            PinchExport().csvHeatCascade(self.unfeasibleHeatCascade, self.hotUtility, self.heatCascade, self.pinchTemperature, self.newpath)
+
+
+    def constructShiftedCompositeDiagram(self, localisation):
+        emptylist = []
+        for interval in self.temperatureInterval:
+            hotH = 0
+            coldH = 0
+            # Add CP values for the hot and cold streams
+            # in a given temperature interval
+            for i in interval['streamNumbers']:
+                if interval['streamNumbers'] != []:
+                    if self.streams.streamsData[i]['type'] == 'HOT':
+                        hotH = hotH + self.streams.streamsData[i]['cp']
+                        #self.shiftedCompositeDiagram['hot']['T'].append(self.streamsData[i]['ss'])
+                        #self.shiftedCompositeDiagram['hot']['T'].append(self.streamsData[i]['st'])
+                    else:
+                        coldH = coldH + self.streams.streamsData[i]['cp']
+                        #self.shiftedCompositeDiagram['cold']['T'].append(self.streamsData[i]['ss'])
+                        #self.shiftedCompositeDiagram['cold']['T'].append(self.streamsData[i]['st'])
+                else:
+                    hotH = 0
+                    emptylist.append(i)
+            # Enthalpy = CP * deltaT 
+            #checken ob geprüftes interval einen heißen strom enthält und erst dann anfangen
+            #dann immer wieder prüfen, ob danach noch ein heoßer strom kommt
+            
+            hotH = hotH * (interval['t1'] - interval['t2'])
+            self._deltaHHot.append(hotH)
+
+
+
+            coldH = coldH * (interval['t1'] - interval['t2'])
+            self._deltaHCold.append(coldH)
+
+
+# rot bei 0/t1 anfangen
+# blau bei coldutility/t2 anfangen
+        self.shiftedCompositeDiagram['hot']['T']= []
+
+        self._deltaHHot.reverse()
+        self.shiftedCompositeDiagram['hot']['H'].append(0.0)
+        for i in range(1, len(self._temperatures)):
+            self.shiftedCompositeDiagram['hot']['H'].append(self.shiftedCompositeDiagram['hot']['H'][-1] + self._deltaHHot[i-1])
+            self.shiftedCompositeDiagram['hot']['T'].append(self._temperatures[len(self._temperatures)-i])
+
+
+        self.shiftedCompositeDiagram['hot']['T'].append(self._temperatures[0])
+        #Summe aus allen deltaHCold + coldutility machen und für die Schritte jeweils deltaHCold abziehen
+        coldgesamt = self.coldUtility
+        for i in range(len(self._deltaHCold)):
+            coldgesamt += self._deltaHCold[i]
+
+        #Experimentell
+        self.shiftedCompositeDiagram['cold']['T']= []
+
+        self.shiftedCompositeDiagram['cold']['H'].append(coldgesamt)
+
+        #Experimentell
+        self.shiftedCompositeDiagram['cold']['T'].append(self._temperatures[0])
+        for i in range(1, len(self._temperatures)):
+            self.shiftedCompositeDiagram['cold']['H'].append(self.shiftedCompositeDiagram['cold']['H'][-1] - self._deltaHCold[i-1])
+            self.shiftedCompositeDiagram['cold']['T'].append(self._temperatures[i])
+        
+
+        iliste = []
+        for i in range(1,(len(self.shiftedCompositeDiagram['cold']['H'])-1)):
+            if self.shiftedCompositeDiagram['cold']['H'] == 0.0:
+                iliste.append(i+1)
+            elif self.shiftedCompositeDiagram['cold']['H'][i] == self.shiftedCompositeDiagram['cold']['H'][0]:
+                iliste.append(i-1)
+            elif self.shiftedCompositeDiagram['cold']['H'][i] == self.shiftedCompositeDiagram['cold']['H'][-1]:
+                iliste.append(i+1)
+        iliste.reverse()
+        
+        for i in iliste:
+            self.shiftedCompositeDiagram['cold']['H'].pop(i)
+            self.shiftedCompositeDiagram['cold']['T'].pop(i)
+        iliste = []
+        for i in range(1,(len(self.shiftedCompositeDiagram['hot']['H'])-1)):
+            if self.shiftedCompositeDiagram['hot']['H'][i] == 0.0:
+                iliste.append(i-1)
+            elif self.shiftedCompositeDiagram['hot']['H'][i] == self.shiftedCompositeDiagram['hot']['H'][-1]:
+                iliste.append(i+1)
+        iliste.reverse()
+
+        for i in iliste:
+            self.shiftedCompositeDiagram['hot']['H'].pop(i)
+            self.shiftedCompositeDiagram['hot']['T'].pop(i)
+        
+        if self._options['draw'] == True:
+            PinchPlot().drawShiftedCompositeDiagram(self.shiftedCompositeDiagram, self.coldUtility, 
+                                                    self._temperatures, self.hotUtility, self.pinchTemperature, 
+                                                    self.processdesignation, localisation)
+
+        if self._options['csv'] == True:
+            PinchExport().csvShiftedCompositeDiagram(self.newpath, self.shiftedCompositeDiagram)
+        
+
+
+    def constructCompositeDiagram(self, localisation):
+        self.compositeDiagram['hot']['T'] = [x + self.tmin / 2 for x in self.shiftedCompositeDiagram['hot']['T']]
+        self.compositeDiagram['hot']['H'] = self.shiftedCompositeDiagram['hot']['H']
+        self.compositeDiagram['cold']['T'] = [x - self.tmin / 2 for x in self.shiftedCompositeDiagram['cold']['T']]
+        self.compositeDiagram['cold']['H'] = self.shiftedCompositeDiagram['cold']['H']
+        print(self._temperatures)
+        if self._options['draw'] == True:
+            PinchPlot().drawCompositeDiagram(self.compositeDiagram, self.shiftedCompositeDiagram, 
+                                             self.coldUtility, self._temperatures, self.tmin, self.hotUtility, 
+                                             self.pinchTemperature, self.processdesignation, localisation)
+
+        if self._options['csv'] == True:
+            PinchExport().csvCompositeDiagram(self.newpath, self.compositeDiagram)
+
+
+
+    def constructGrandCompositeCurve(self,localisation):
+        self.grandCompositeCurve['H'].append(self.hotUtility)
+        self.grandCompositeCurve['T'].append(self._temperatures[0])
+        for i in range(1, len(self._temperatures)):
+            self.grandCompositeCurve['H'].append(self.heatCascade[i - 1]['exitH'])
+            self.grandCompositeCurve['T'].append(self._temperatures[i])
+        print(self.grandCompositeCurve)
+        print(self.heatCascade)
+
+        if self._options['debug'] == True:
+            print("\nGrand Composite Curve: ")
+            print("Net H (kW): {}".format(self.grandCompositeCurve['H']))
+            print("T (degC): {}".format(self.grandCompositeCurve['T']))
+            
+
+        if self._options['draw'] == True:
+            PinchPlot().drawGrandCompositeCurve(self.processdesignation, self.heatCascade, 
+                                                self.grandCompositeCurve, self._temperatures, self.pinchTemperature, localisation)
+
+        if self._options['csv'] == True:
+            PinchExport().csvGrandCompositeCurve(self.newpath, self.grandCompositeCurve)
+

pinch_tool/Modules/Pinch/PinchExport.py

@@ -0,0 +1,129 @@
+import os
+import csv
+
+class PinchExport:
+    def __init__(self):
+         pass
+    def csvProblemTable(self, problemTable, _temperatures, newpath):
+        colLabels = ['$Interval: S_i - S_{i+1}$', '$\\Delta T (\\degree C)$', '$\\Delta CP (kW / \\degree C)$', '$\\Delta H (kW)$', '']
+        cellText = []
+
+        i = 1
+        for interval in problemTable:
+            cellRow = []
+            cellRow.extend(['{}: {} - {}'.format(i, _temperatures[i - 1], _temperatures[i]),
+                interval['deltaS'], interval['deltaCP'], interval['deltaH']])
+
+            if interval['deltaH'] > 0:
+                cellRow.append('Surplus')
+            elif interval['deltaH'] == 0:
+                cellRow.append('-')
+            else:
+                cellRow.append('Deficit')
+            cellText.append(cellRow)
+            i = i + 1
+
+
+        if not os.path.exists(newpath):
+            os.makedirs(newpath)
+        fileName = 'ProblemTable.csv'
+
+        path = os.path.join(newpath, fileName)
+        with open(path, 'w', newline='') as f:
+            writer = csv.writer(f, delimiter=',')
+            writer.writerow(['Interval: S1 - S2', 'delta T (degC)', 'delta CP (kW / degC)', 'delta H (kW)', ''])
+            for rowText in cellText:
+                writer.writerow(rowText)
+
+    def csvHeatCascade(self, unfeasibleHeatCascade, hotUtility, heatCascade, pinchTemperature, newpath):
+        cellText = [['Unfeasible Heat Cascade: ']]
+        cellText.append(['', '', 'Hot Utility: 0 kW'])
+        cellText.append(['Interval', 'Delta H (kW)', 'Exit H (total kW)'])
+
+        i = 1
+        for interval in unfeasibleHeatCascade:
+            cellText.append([str(i), interval['deltaH'], interval['exitH']])
+            i = i + 1
+
+        cellText.append(['', '', 'Cold Utility: {} kW'.format(unfeasibleHeatCascade[-1]['exitH'])])
+        cellText.append([''])
+
+        cellText.append(['Feasible Heat Cascade: '])
+        cellText.append(['', '', 'Hot Utility: {} kW'.format(hotUtility)])
+        cellText.append(['Interval', 'Delta H (kW)', 'Exit H (total kW)'])
+
+        i = 1
+        for interval in heatCascade:
+            cellText.append([str(i), interval['deltaH'], interval['exitH']])
+            i = i + 1
+
+        cellText.append(['', '', 'Cold Utility: {} kW'.format(heatCascade[-1]['exitH'])])
+        cellText.append(['','', 'Pinch Temperature: {} degC'.format(pinchTemperature)])
+
+        if not os.path.exists(newpath):
+            os.makedirs(newpath)
+        fileName = 'HeatCascade.csv'
+
+        path = os.path.join(newpath, fileName)
+
+        with open(path, 'w', newline='') as f:
+            writer = csv.writer(f, delimiter=',')
+            for rowText in cellText:
+                writer.writerow(rowText)
+
+
+    def csvShiftedCompositeDiagram(self, newpath, shiftedCompositeDiagram):
+        if not os.path.exists(newpath):
+            os.makedirs(newpath)
+        fileName = 'ShiftedCompositeDiagram.csv'
+
+        path = os.path.join(newpath, fileName)
+        
+        with open(path, 'w', newline='') as f:
+            writer = csv.writer(f, delimiter=',')
+            writer.writerow(['Hot H', 'Hot T'])
+            for i in range(0, len(shiftedCompositeDiagram['hot']['H'])):
+                writer.writerow([shiftedCompositeDiagram['hot']['H'][i],
+                    shiftedCompositeDiagram['hot']['T'][i]])
+
+            writer.writerow([''])
+            writer.writerow(['Cold H', 'Cold T'])
+            for i in range(0, len(shiftedCompositeDiagram['cold']['H'])):
+                writer.writerow([shiftedCompositeDiagram['cold']['H'][i],
+                    shiftedCompositeDiagram['cold']['T'][i]])
+
+
+    def csvCompositeDiagram(self, newpath, compositeDiagram):
+        if not os.path.exists(newpath):
+            os.makedirs(newpath)
+        fileName = 'CompositeDiagram.csv'
+
+        path = os.path.join(newpath, fileName)
+        with open(path, 'w', newline='') as f:
+            writer = csv.writer(f, delimiter=',')
+            writer.writerow(['Hot H', 'Hot T'])
+            for i in range(0, len(compositeDiagram['hot']['H'])):
+                writer.writerow([compositeDiagram['hot']['H'][i],
+                    compositeDiagram['hot']['T'][i]])
+
+            writer.writerow([''])
+            writer.writerow(['Cold H', 'Cold T'])
+            for i in range(0, len(compositeDiagram['cold']['H'])):
+                writer.writerow([compositeDiagram['cold']['H'][i],
+                    compositeDiagram['cold']['T'][i]])
+
+
+
+    def csvGrandCompositeCurve(self, newpath, grandCompositeCurve):
+        if not os.path.exists(newpath):
+            os.makedirs(newpath)
+        fileName = 'GrandCompositeCurve.csv'
+
+        path = os.path.join(newpath, fileName)
+        with open(path, 'w', newline='') as f:
+            writer = csv.writer(f, delimiter=',')
+            writer.writerow(['Net H (kW)', 'T(degC)'])
+            for i in range(0, len(grandCompositeCurve['H'])):
+                writer.writerow([grandCompositeCurve['H'][i],
+                    grandCompositeCurve['T'][i]])
+

pinch_tool/Modules/Pinch/PinchPlot.py

@@ -0,0 +1,193 @@
+import matplotlib.pyplot as plt 
+
+class PinchPlot:
+
+    def drawTemperatureInterval(self, _temperatures, streams):
+        fig, ax = plt.subplots()
+
+        plt.title('Shifted Temperature Interval Diagram')
+        plt.ylabel('Shifted Temperature S (degC)')
+        ax.set_xticklabels([])
+
+        xOffset = 50
+
+        for temperature in _temperatures:
+            plt.plot([0, xOffset * (streams.numberOf + 1)], [temperature, temperature], ':k', alpha=0.8)
+
+        arrow_width = streams.numberOf * 0.05
+        head_width = arrow_width * 15
+        head_length = _temperatures[0] * 0.02
+        i = 1
+        for stream in streams:
+            if stream['type'] == 'HOT':
+                plt.text(xOffset, stream['ss'], str(i), bbox=dict(boxstyle='round', alpha=1, fc='tab:red', ec="k"))
+                plt.arrow(xOffset, stream['ss'], 0, stream['st'] - stream['ss'], color='tab:red', ec='k', alpha=1,
+                        length_includes_head=True, width=arrow_width, head_width=head_width, head_length=head_length)
+            else:
+                plt.text(xOffset, stream['ss'], str(i), bbox=dict(boxstyle='round', alpha=1, fc='tab:blue', ec="k"))
+                plt.arrow(xOffset, stream['ss'], 0, stream['st'] - stream['ss'], color='tab:blue', ec='k', alpha=1,
+                        length_includes_head=True, width=arrow_width, head_width=head_width, head_length=head_length)
+            xOffset = xOffset + 50
+            i = i + 1
+
+    def drawProblemTable(self, problemTable, _temperatures):
+        fig, ax = plt.subplots(figsize=(6, 6))
+        ax.axis('tight')
+        ax.axis('off')
+        ax.set_title('Problem Table')
+
+        colLabels = ['$Interval: S_i - S_{i+1}$', '$\\Delta T (\\degree C)$', '$\\Delta CP (kW / \\degree C)$', '$\\Delta H (kW)$', '']
+        cellText = []
+
+        i = 1
+        for interval in problemTable:
+            cellRow = []
+            cellRow.extend(['{}: {} - {}'.format(i, _temperatures[i - 1], _temperatures[i]),
+                interval['deltaS'], interval['deltaCP'], interval['deltaH']])
+
+            if interval['deltaH'] > 0:
+                cellRow.append('Surplus')
+            elif interval['deltaH'] == 0:
+                cellRow.append('-')
+            else:
+                cellRow.append('Deficit')
+            cellText.append(cellRow)
+            i = i + 1
+
+        table = ax.table(cellText=cellText, colLabels=colLabels, loc='center')
+        table.auto_set_column_width([0, 1, 2, 3, 4])
+        table.scale(1.3, 1.3)
+
+
+    def drawHeatCascade(self, unfeasibleHeatCascade, heatCascade, hotUtility):
+        fig, axs = plt.subplots(1, 2, figsize=(10, 6))
+        axs[0].axis('auto')
+        axs[0].axis('off')
+        axs[1].axis('auto')
+        axs[1].axis('off')
+
+        axs[0].set_title('Unfeasible Heat Cascade')
+        axs[1].set_title('Feasible Heat Cascade')
+
+        cellText = []
+        cellText.append(['', '', 'Hot Utility: 0'])
+        cellText.append(['Interval', '$\\Delta H (kW)$', 'Exit H (total kW)'])
+
+        i = 1
+        for interval in unfeasibleHeatCascade:
+            cellText.append([str(i), interval['deltaH'], interval['exitH']])
+            i = i + 1
+
+        cellText.append(['', '', 'Cold Utility: {}'.format(unfeasibleHeatCascade[-1]['exitH'])])
+        table = axs[0].table(cellText=cellText, loc='center')
+        table.auto_set_column_width([0, 1, 2])
+        table.scale(1.3, 1.3)
+
+        cellText = []
+        cellText.append(['', '', 'Hot Utility: {}'.format(hotUtility)])
+        cellText.append(['Interval', '$\\Delta H (kW)$', 'Exit H (total kW)'])
+
+        i = 1
+        for interval in heatCascade:
+            cellText.append([str(i), interval['deltaH'], interval['exitH']])
+            i = i + 1
+
+        cellText.append(['', '', 'Cold Utility: {}'.format(heatCascade[-1]['exitH'])])
+        table = axs[1].table(cellText=cellText, loc='center')
+        table.auto_set_column_width([0, 1, 2])
+        table.scale(1.3, 1.3)
+
+
+    def drawShiftedCompositeDiagram(self, shiftedCompositeDiagram, coldUtility, _temperatures, hotUtility, pinchTemperature, processdesignation, localisation):
+        fig = plt.figure()
+        plt.plot(shiftedCompositeDiagram['hot']['H'], shiftedCompositeDiagram['hot']['T'], 'tab:red')
+        plt.plot(shiftedCompositeDiagram['cold']['H'], shiftedCompositeDiagram['cold']['T'], 'tab:blue')
+
+        plt.plot(shiftedCompositeDiagram['hot']['H'], shiftedCompositeDiagram['hot']['T'], 'ro')
+        plt.plot(shiftedCompositeDiagram['cold']['H'], shiftedCompositeDiagram['cold']['T'], 'bo')
+
+        maxColdH = max(shiftedCompositeDiagram['cold']['H'])
+
+        try:
+            pinchIndex = shiftedCompositeDiagram['cold']['T'].index(pinchTemperature)
+            pinchH = shiftedCompositeDiagram['cold']['H'][pinchIndex]
+            plt.plot([pinchH, pinchH], [_temperatures[0], _temperatures[-1]], ':')
+        except ValueError:
+            pass
+
+        a = plt.fill_between([coldUtility, shiftedCompositeDiagram['cold']['H'][0]-hotUtility], [shiftedCompositeDiagram['cold']['T'][0]])
+        a.set_hatch('\\')
+        a.set_facecolor('w')
+        plt.grid(True)
+        if localisation == 'DE':
+            plt.title('Verschobene Verbundkurven ({})'.format(processdesignation))#plt.title('Shifted Temperature-Enthalpy Composite Diagram')
+            plt.xlabel('Enthalpiestrom H in kW')
+            plt.ylabel('Verschobene Temperatur in °C')
+        elif localisation == 'EN':
+            plt.title('Shifted Composite Diagram')
+            plt.xlabel('Enthalpy H in kW')
+            plt.ylabel('Shifted Temperature T in °C')
+
+    def drawCompositeDiagram(self, compositeDiagram, shiftedCompositeDiagram, coldUtility, 
+                             _temperatures, tmin, hotUtility, pinchTemperature, processdesignation, localisation):
+        fig = plt.figure()
+        plt.plot(compositeDiagram['hot']['H'], compositeDiagram['hot']['T'], 'tab:red')
+        plt.plot(compositeDiagram['cold']['H'], compositeDiagram['cold']['T'], 'tab:blue')
+
+        plt.plot(compositeDiagram['hot']['H'], compositeDiagram['hot']['T'], 'ro')
+        plt.plot(compositeDiagram['cold']['H'], compositeDiagram['cold']['T'], 'bo')
+
+        maxColdH = max(compositeDiagram['cold']['H'])
+
+        try:
+            pinchIndex = shiftedCompositeDiagram['cold']['T'].index(pinchTemperature)
+            pinchH = shiftedCompositeDiagram['cold']['H'][pinchIndex]
+            plt.plot([pinchH, pinchH], [_temperatures[0], _temperatures[-1]], ':')
+        except ValueError:
+            pass
+
+        plt.grid(True)
+        if localisation == 'DE':
+            plt.title('Verbundkurven ({})'.format(processdesignation))#plt.title('Shifted Temperature-Enthalpy Composite Diagram')
+            plt.xlabel('Enthalpiestrom H in kW')
+            plt.ylabel('Temperatur in °C')
+        elif localisation == 'EN':
+            plt.title('Composite Diagram ({})'.format(processdesignation))
+            plt.xlabel('Enthalpy H in kW')
+            plt.ylabel('Temperature T in °C')
+
+
+    def drawGrandCompositeCurve(self, processdesignation, heatCascade, grandCompositeCurve, _temperatures, pinchTemperature, localisation):
+        fig = plt.figure(num='{}'.format(processdesignation))
+        if heatCascade[0]['deltaH'] > 0:  
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [grandCompositeCurve['T'][0],grandCompositeCurve['T'][1]], 'tab:red')
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [grandCompositeCurve['T'][0],grandCompositeCurve['T'][1]], 'ro')
+        elif heatCascade[0]['deltaH'] < 0:
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [grandCompositeCurve['T'][0],grandCompositeCurve['T'][1]], 'tab:blue')
+            plt.plot([grandCompositeCurve['H'][0],grandCompositeCurve['H'][1]], [grandCompositeCurve['T'][0],grandCompositeCurve['T'][1]], 'bo')
+
+        for i in range(1, len(_temperatures)-1):
+            if heatCascade[i]['deltaH'] > 0:
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'tab:red')
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'ro')
+            elif heatCascade[i]['deltaH'] < 0:
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'tab:blue')
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'bo')
+            elif heatCascade[i]['deltaH'] == 0 and grandCompositeCurve['H'][i]!=0:
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'tab:blue')
+                plt.plot([grandCompositeCurve['H'][i],grandCompositeCurve['H'][i+1]], [grandCompositeCurve['T'][i],grandCompositeCurve['T'][i+1]], 'bo')
+
+        plt.plot([0, grandCompositeCurve['H'][-1]], [pinchTemperature, pinchTemperature], ':')
+
+        plt.grid(True)
+        if localisation == 'DE':
+            plt.title('Großverbundkurve ({})'.format(processdesignation))
+            plt.xlabel('Nettoenthalpiestromänderung ∆H [kW]')
+            plt.ylabel('Verschobene Temperatur [°C]')
+        elif localisation == 'EN':
+            plt.title('Grand Composite Diagram ({})'.format(processdesignation))
+            plt.xlabel('Net Enthalpy Change ∆H in kW')
+            plt.ylabel('Shifted Temperature T in °C')
+
+    def showPlots():
+        plt.show()

pinch_tool/Modules/Pinch/Streams.py

@@ -0,0 +1,105 @@
+import csv
+
+class Streams:
+
+    def __init__(self, streamsDataFile):
+
+        self.tmin =              0
+        self.numberOf =          0
+        self.streamsData =       []
+
+        self._rawStreamsData =   []
+        self._index =            0
+        self._length =           0
+
+
+
+
+        with open(streamsDataFile, newline='') as f:
+            reader = csv.reader(f)
+            for row in reader:
+                self._rawStreamsData.append(row)
+
+        if (self._rawStreamsData[0][0].strip() != 'Tmin' or
+                [ item.strip() for item in self._rawStreamsData[1] ] != ['CP', 'TSUPPLY', 'TTARGET']):
+            raise Exception("""\n[ERROR] Bad formatting in streams data file. \n
+                    The first two rows of the streams data file should be: \n
+                    `` Tmin, <TMIN VALUE> ''
+                    `` CP, TSUPPLY, TTARGET ''\n
+                    Where CP is the heat capacity (kW / degC);
+                    TSUPPLY is the starting temperature of the given stream (degC);
+                    TTARGET is the ending temperature of the given stream (degC);\n""")
+
+        self.createStreams()
+
+
+    def createStreams(self):
+        try:
+            self.tmin = float(self._rawStreamsData[0][1])
+        except ValueError:
+            print("\n[ERROR] Wrong type supplied for Tmin in the streams data file. Perhaps used characters?\n")
+            raise
+        except IndexError:
+            print("\n[ERROR] Missing value for Tmin in the streams data file.\n")
+            raise
+        except:
+            print("\n[ERROR] Unexpected error for Tmin. Try using the supplied streams data file format.\n")
+            raise
+
+
+        for rawStream in self._rawStreamsData[2:]:
+            try:
+                stream = {}
+
+                if float(rawStream[1]) > float(rawStream[2]):
+                    stream["type"] = "HOT"
+                else:
+                    stream["type"] = "COLD"
+
+                stream["cp"] = float(rawStream[0])
+                stream["ts"] = float(rawStream[1])
+                stream["tt"] = float(rawStream[2])
+
+                self.streamsData.append(stream)
+
+            except ValueError:
+                print("\n[ERROR] Wrong number type supplied in the streams data file. Perhaps used characters?\n")
+                raise
+            except IndexError:
+                print("\n[ERROR] Missing number in the streams data file.\n")
+                raise
+            except:
+                print("\n[ERROR] Unexpected error. Try using the supplied streams data file format.\n")
+                raise
+
+        self._length = len(self.streamsData)
+        self.numberOf = len(self.streamsData)
+        if (self._length < 2):
+            raise Exception("\n[ERROR] Need to supply at least 2 streams in the streams data file.\n")
+
+
+    def __iter__(self):
+        return self
+
+
+    def __next__(self):
+        if self._index == self._length:
+            self._index = 0
+            raise StopIteration
+        self._index = self._index + 1
+
+        return self.streamsData[self._index - 1]
+
+
+    def printTmin(self):
+        print(self.tmin)
+
+
+    def printStreams(self):
+        for stream in self.streamsData:
+            print(stream)
+
+
+    def printRawStreams(self):
+        for rawStream in self._rawStreamsData:
+            print(rawStream)

pinch_tool/Modules/TotalSiteProfile/TSPPlot.py

@@ -0,0 +1,96 @@
+import matplotlib.pyplot as plt
+
+class TSPPlot():
+    
+    def drawDeletedCurve(self, heatCascadedeltaH, deletedPocketdict, _temperatures, plottest):
+        fig = plt.figure()
+        if heatCascadedeltaH[0] > 0:  
+            plt.plot([deletedPocketdict['H'][0][0],deletedPocketdict['H'][0][1]], [deletedPocketdict['T'][0][0],deletedPocketdict['T'][0][1]], 'tab:red')
+            plt.plot([deletedPocketdict['H'][0][0],deletedPocketdict['H'][0][1]], [deletedPocketdict['T'][0][0],deletedPocketdict['T'][0][1]], 'ro')
+        elif heatCascadedeltaH[0] < 0:
+            plt.plot([deletedPocketdict['H'][0][0],deletedPocketdict['H'][0][1]], [deletedPocketdict['T'][0][0],deletedPocketdict['T'][0][1]], 'tab:blue')
+            plt.plot([deletedPocketdict['H'][0][0],deletedPocketdict['H'][0][1]], [deletedPocketdict['T'][0][0],deletedPocketdict['T'][0][1]], 'bo')
+        
+        if plottest == 1:
+            for i in range(1, len(_temperatures)-2):
+                if heatCascadedeltaH[i] > 0:
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'tab:red')
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'ro')
+                elif heatCascadedeltaH[i] < 0:
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'tab:blue')
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'bo')
+                else:
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'tab:blue')
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'bo')
+        if plottest == 0:
+            for i in range(1, len(_temperatures)-1):
+                if heatCascadedeltaH[i] > 0:
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'tab:red')
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'ro')
+                elif heatCascadedeltaH[i] < 0:
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'tab:blue')
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'bo')
+                else:
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'tab:blue')
+                    plt.plot([deletedPocketdict['H'][0][i],deletedPocketdict['H'][0][i+1]], [deletedPocketdict['T'][0][i],deletedPocketdict['T'][0][i+1]], 'bo')
+
+        # plt.fill_between([0, deletedPocketdict['H'][0][0]], 0, _temperatures[0], color = 'r', alpha = 0.5)
+        # plt.fill_between([0, deletedPocketdict['H'][0][-1]], 0, _temperatures[-1], color = 'b', alpha = 0.5)
+
+
+        plt.grid(True)
+        plt.title('Grand Composite Curve')
+        plt.xlabel('Net Enthalpy Change ∆H [kW]')
+        plt.ylabel('Shifted Temperature T [°C]')
+
+
+    def drawTotalSiteProfile(self, siteDesignation, tstHotH, tstHotTemperatures, tstColdH, tstColdTemperatures, localisation):
+        #Wieder aus den ausgegebenen Werten fuer alle Prozesse Temperaturintervalle erstellen und diese dann plotten
+        fig, (ax1, ax2) = plt.subplots(1, 2)
+  
+        fig.suptitle('Total Site Profile ({})'.format(siteDesignation))
+        
+        ax1.plot(tstHotH, tstHotTemperatures, 'tab:red')
+        if localisation == 'DE':
+            ax1.set(xlabel='Nettoenthalpieänderung ∆H in kW', ylabel='Verschobene Temperatur T in °C')
+        elif localisation == 'EN':
+            ax1.set(xlabel='Net Enthalpy Change ∆H in kW', ylabel='Shifted Temperature T in °C')
+
+        ax1.grid()
+        ax2.plot(tstColdH, tstColdTemperatures, 'tab:blue')
+        if localisation == 'DE':
+            ax2.set_xlabel('Nettoenthalpieänderung ∆H in kW')
+        elif localisation == 'EN':
+            ax2.set(xlabel='Net Enthalpy Change ∆H in kW')
+        
+        ax2.grid()
+
+        ax2.set_xlim([0,tstColdH[-1]])
+        ax1.set_xlim([tstHotH[0],0]) 
+
+        if tstHotH == [] or tstColdH == []:
+            pass
+
+        elif tstHotTemperatures[-1] > tstColdTemperatures[-1]:
+            if tstHotTemperatures[0] > tstColdTemperatures[0]:
+                ax1.set_ylim([tstColdTemperatures[0]-2.5,tstHotTemperatures[-1]+2.5])
+                ax2.set_ylim([tstColdTemperatures[0]-2.5,tstHotTemperatures[-1]+2.5])
+            elif tstHotTemperatures[0] < tstColdTemperatures[0]:
+                ax1.set_ylim([tstHotTemperatures[0]-2.5,tstHotTemperatures[-1]+2.5])
+                ax2.set_ylim([tstHotTemperatures[0]-2.5,tstHotTemperatures[-1]+2.5])
+            else:
+                pass
+
+        elif tstHotTemperatures[-1] < tstColdTemperatures[-1]:
+            if tstHotTemperatures[0] > tstColdTemperatures[0]:
+                ax1.set_ylim([tstColdTemperatures[0]-2.5,tstColdTemperatures[-1]+2.5])
+                ax2.set_ylim([tstColdTemperatures[0]-2.5,tstColdTemperatures[-1]+2.5])
+            elif tstHotTemperatures[0] < tstColdTemperatures[0]:
+                ax1.set_ylim([tstHotTemperatures[0]-2.5,tstColdTemperatures[-1]+2.5])
+                ax2.set_ylim([tstHotTemperatures[0]-2.5,tstColdTemperatures[-1]+2.5])
+            else:
+                pass
+
+
+    def showPlots(self):
+        plt.show()

pinch_tool/Modules/TotalSiteProfile/TotalSiteProfile.py

@@ -0,0 +1,222 @@
+from Pinch_main import Pinchmain as Pinch
+import csv
+import ast
+from Modules.TotalSiteProfile.TSPPlot import TSPPlot
+from Modules.Utility.TemperaturePocketDeletion import TemperaturePocketDeletion as TPD
+from Modules.Utility.splitStreams import splitStreams
+
+class TotalSiteProfile:
+
+    def __init__(self, siteDesignation, options = {}):
+    
+        self.siteDesignation = siteDesignation
+
+        self.heatCascadedeltaH = []
+        self.heatCascadeexitH = []
+
+        self.deletedPocketdict = []
+        self.heatCascadedeltaHdict = []
+        self.heatCascadeexitHdict = []
+        self.deletedPocketdictlist = []
+        
+        self.splitHotTemperatures = []
+        self.splitColdTemperatures = []
+        self.splitHotH = []
+        self.splitColdH = []
+        self.splitHotdeltaH = []
+        self.splitColddeltaH = []
+        self.splitdict = {'HotTemperatures': [], 'ColdTemperatures': [], 'HotH': [], 'ColdH': [], 'HotdeltaH': [], 'ColddeltaH': [], 'SteigungHot': [], 'SteigungCold': []}
+
+        self.tstHotConstructionAid = {'T': [], 'Process': [], 'Stream': []}
+        self.tstColdConstructionAid = {'T': [], 'Process': [], 'Stream': []}
+
+        self.tstHotTemperatures = []
+        self.tstColdTemperatures = []
+        self.tstHotH = []
+        self.tstColdH = []
+
+        self.emptyintervalsHot = []
+        self.emptyintervalsCold = []
+
+        self._options = {'debug': False, 'draw': False, 'csv': False}
+
+        if 'debug' in options:
+            self._options['debug'] = True
+        if 'draw' in options:
+            self._options['draw'] = True
+        if 'csv' in options:
+            self._options['csv'] = True
+
+
+    def importData(self, siteProfilecsv):
+        nooption = {}
+        Pinch('{}'.format(siteProfilecsv),nooption).solvePinch()
+        with open('Buffer file for TotalSiteProfile creation.csv', newline='') as f:
+            reader = csv.reader(f)
+            csvdata=[]
+            for row in reader:
+                csvdata.append(row)
+        self._temperatures = csvdata[0]
+        self.heatCascade = csvdata[1]
+        for i in range(len(self.heatCascade)):
+            self.heatCascade[i] = ast.literal_eval(self.heatCascade[i])
+        self.hotUtility = float(csvdata[2][0])
+        for i in range(len(self._temperatures)):
+            self._temperatures[i] = float(self._temperatures[i])
+
+    def deleteTemperaturePockets(self):
+        self.deletedPocketdict = TPD(self.hotUtility, self.heatCascade, self._temperatures).deleteTemperaturePockets()
+        
+
+    def noDeletionHelper(self):
+        self.deletedPocketdict = {'H': [], 'deltaH': [], 'T': []}
+        self.heatCascadedeltaH = []
+        self.heatCascadeexitH = []
+        self.heatCascadeexitH.append(self.hotUtility)
+        
+        for o in range(len(self.heatCascade)):
+            self.heatCascadedeltaH.append(self.heatCascade[o]['deltaH'])
+            self.heatCascadeexitH.append(self.heatCascade[o]['exitH'])
+
+        self.deletedPocketdict['H'].append(self.heatCascadeexitH)
+        self.deletedPocketdict['deltaH'].append(self.heatCascadedeltaH)
+        self.deletedPocketdict['T'].append(self._temperatures)
+        self.deletedPocketdictlist.append(self.deletedPocketdict)
+
+    def splitHotandCold(self): # Fall für 2 aufeinander folgende heiße Ströme ohne deletion implementieren
+        self.splitdict = splitStreams(self.deletedPocketdict, self.splitdict).splitHotandCold()
+
+    def constructTotalSiteProfile(self, localisation): #Temperaturen sind in jedem Prozess bereits einzigartig für Heiß/Kalt
+       #Mit ColddeltaH und Temperaturen jeweils Steigungen für alle Schritte in Reihenfolge ermitteln
+       #Dann abfragen, welche Steigung im aktuellen Temperaturintervall benötigt wird(einfach der Reihe nach oder wenn T kleiner als die aktuelle Temperatur aber größer als die vorherige)
+       #Anschließend jeweils die Steigungen addieren und mal dem aktuellen Temperaturintervall rechnen und mit dem vorherigen Wert addiert anfügen
+       
+       
+        for i in range(len(self.splitdict['HotTemperatures'])):
+            for j in range(len(self.splitdict['HotTemperatures'][i])):
+                self.tstHotTemperatures.append(self.splitdict['HotTemperatures'][i][j])
+                
+                if self.splitdict['HotTemperatures'][i][j] not in self.tstHotConstructionAid['T']:
+                    self.tstHotConstructionAid['T'].append(self.splitdict['HotTemperatures'][i][j])
+                    self.tstHotConstructionAid['Process'].append([i])
+                    self.tstHotConstructionAid['Stream'].append([j])
+                
+                elif self.splitdict['HotTemperatures'][i][j] in self.tstHotConstructionAid['T']:
+                    temp = self.tstHotConstructionAid['T'].index(self.splitdict['HotTemperatures'][i][j])
+                    self.tstHotConstructionAid['Process'][temp].append(i)
+                    self.tstHotConstructionAid['Stream'][temp].append(j)
+
+        self.tstHotTemperatures = list(set(self.tstHotTemperatures))
+        self.tstHotTemperatures.sort()
+
+        for i in range(len(self.splitdict['ColdTemperatures'])):
+            for j in range(len(self.splitdict['ColdTemperatures'][i])):
+                self.tstColdTemperatures.append(self.splitdict['ColdTemperatures'][i][j])
+                
+                if self.splitdict['ColdTemperatures'][i][j] not in self.tstColdConstructionAid['T']:
+                    self.tstColdConstructionAid['T'].append(self.splitdict['ColdTemperatures'][i][j])
+                    self.tstColdConstructionAid['Process'].append([i])
+                    self.tstColdConstructionAid['Stream'].append([j])
+                
+                elif self.splitdict['ColdTemperatures'][i][j] in self.tstColdConstructionAid['T']:
+                    temp = self.tstColdConstructionAid['T'].index(self.splitdict['ColdTemperatures'][i][j])
+                    self.tstColdConstructionAid['Process'][temp].append(i)
+                    self.tstColdConstructionAid['Stream'][temp].append(j)
+
+        self.tstColdTemperatures = list(set(self.tstColdTemperatures))
+        self.tstColdTemperatures.sort()
+
+        Steigung = []
+        for Prozess in range(len(self.splitdict['ColdTemperatures'])):
+            for Temperatur in range(len(self.splitdict['ColdTemperatures'][Prozess])-1):
+                if self.splitdict['ColdTemperatures'][Prozess][Temperatur]-self.splitdict['ColdTemperatures'][Prozess][Temperatur+1] == 0:
+                    Steigung.append(0.0)
+                elif self.splitdict['ColdH'][Prozess][Temperatur]-self.splitdict['ColdH'][Prozess][Temperatur+1]<0:
+                    Steigung.append(0.0)
+                else:
+                    Steigung.append((self.splitdict['ColdH'][Prozess][Temperatur]-self.splitdict['ColdH'][Prozess][Temperatur+1])/(self.splitdict['ColdTemperatures'][Prozess][Temperatur]-self.splitdict['ColdTemperatures'][Prozess][Temperatur+1]))
+            self.splitdict['SteigungCold'].append(Steigung)
+            Steigung = []
+        
+        
+        Steigung = []
+        for Prozess in range(len(self.splitdict['HotTemperatures'])):
+            for Temperatur in range(len(self.splitdict['HotTemperatures'][Prozess])-1):
+                if self.splitdict['HotH'][Prozess][Temperatur]-self.splitdict['HotH'][Prozess][Temperatur+1]>0:
+                    Steigung.append(0.0)
+                else:
+                    Steigung.append((self.splitdict['HotH'][Prozess][Temperatur]-self.splitdict['HotH'][Prozess][Temperatur+1])/(self.splitdict['HotTemperatures'][Prozess][Temperatur]-self.splitdict['HotTemperatures'][Prozess][Temperatur+1]))
+            self.splitdict['SteigungHot'].append(Steigung)
+            Steigung = []
+
+        kW = 0.0
+        for Temperatur in self.tstHotTemperatures:
+            for Prozess in reversed(range(len(self.splitdict['HotTemperatures']))):
+                if self.splitdict['HotTemperatures'][Prozess] == []:
+                    continue
+                elif self.splitdict['HotTemperatures'][Prozess][-1] >= Temperatur:
+                    continue
+
+                for Prozesstemperatur in reversed(range(len(self.splitdict['HotTemperatures'][Prozess]))):
+                    if Temperatur == self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur]:
+                        if letzteTemperaturHot > self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur+1] and letzteTemperaturHot < self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur]:
+                            kW += self.splitdict['SteigungHot'][Prozess][Prozesstemperatur] * (self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur] - letzteTemperaturHot)
+                            break
+                        else:
+                            kW += self.splitdict['SteigungHot'][Prozess][Prozesstemperatur] * (Temperatur - self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur+1])
+                            break
+
+                    elif Temperatur > self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur] and Temperatur < self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur-1]:
+                        if letzteTemperaturHot > self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur] and letzteTemperaturHot < self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur-1]:
+                            kW += self.splitdict['SteigungHot'][Prozess][Prozesstemperatur-1] * (Temperatur - letzteTemperaturHot)
+                        else:
+                            kW += self.splitdict['SteigungHot'][Prozess][Prozesstemperatur-1] * (Temperatur - self.splitdict['HotTemperatures'][Prozess][Prozesstemperatur])
+                        break
+                    else:
+                        continue
+            if self.tstHotH == []:
+                self.tstHotH.append(kW)
+            else:
+                self.tstHotH.append(self.tstHotH[-1] + kW)
+            kW = 0.0
+            letzteTemperaturHot = Temperatur
+
+        kW = 0.0
+        for Temperatur in self.tstColdTemperatures:
+            for Prozess in reversed(range(len(self.splitdict['ColdTemperatures']))):
+                if self.splitdict['ColdTemperatures'][Prozess][-1] >= Temperatur:
+                    continue
+
+                for Prozesstemperatur in reversed(range(len(self.splitdict['ColdTemperatures'][Prozess]))):
+                    if Temperatur == self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur]:
+                        if letzteTemperaturCold > self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur+1] and letzteTemperaturCold < self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur]:
+                            kW += self.splitdict['SteigungCold'][Prozess][Prozesstemperatur] * (self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur] - letzteTemperaturCold)
+                            break
+                        else:
+                            kW += self.splitdict['SteigungCold'][Prozess][Prozesstemperatur] * (Temperatur - self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur+1])
+                            break
+
+                    elif Temperatur > self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur] and Temperatur < self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur-1]:
+                        if letzteTemperaturCold > self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur] and letzteTemperaturCold < self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur-1]:
+                            kW += self.splitdict['SteigungCold'][Prozess][Prozesstemperatur-1] * (Temperatur - letzteTemperaturCold)
+                        else:
+                            kW += self.splitdict['SteigungCold'][Prozess][Prozesstemperatur-1] * (Temperatur - self.splitdict['ColdTemperatures'][Prozess][Prozesstemperatur])
+                        break
+                    else:
+                        continue
+            if self.tstColdH == []:
+                self.tstColdH.append(kW)
+            else:
+                self.tstColdH.append(self.tstColdH[-1] + kW)
+            kW = 0.0
+            letzteTemperaturCold = Temperatur
+
+        maxheiß = self.tstHotH[-1]
+        self.tstHotH = [wert - maxheiß for wert in self.tstHotH]
+        a = 1
+        for i in range(len(self.tstHotH)):
+            self.tstHotH[i] = -self.tstHotH[i]
+        if self._options['draw'] == True:
+            TSPPlot().drawTotalSiteProfile(self.siteDesignation, self.tstHotH, 
+                                           self.tstHotTemperatures, self.tstColdH, self.tstColdTemperatures, localisation)
+        

pinch_tool/Modules/Utility/TemperaturePocketDeletion.py

@@ -0,0 +1,280 @@
+from Modules.TotalSiteProfile.TSPPlot  import TSPPlot
+
+class TemperaturePocketDeletion:
+    def __init__(self, hotUtility, heatCascade, _temperatures):
+        self.hotUtility = hotUtility
+        self.heatCascade = heatCascade
+        self._temperatures = _temperatures
+        self._options = {'draw': True}
+
+    def deleteDoubleEmpty(self,u):
+        if u < len(self.heatCascadedeltaH)-2:
+            if self.heatCascadedeltaH[u+1] == 0.0 and self.heatCascadedeltaH[u+2] == 0.0:
+                self.heatCascadedeltaH.pop(u+1)
+                self.heatCascadeexitH.pop(u+2)
+                self._temperatures.pop(u+2)
+
+    def deleteTemperaturePockets(self):
+            self.deletedPocketdict = {'H': [], 'deltaH': [], 'T': []}
+            self.deletedPocketdictlist=[]
+            
+            i = 0
+            j = 0
+            k = 0
+            u = 0
+            plottest = 0
+            self.heatCascadedeltaH = []
+            self.heatCascadeexitH = []
+            self.heatCascadeexitH.append(self.hotUtility)
+            
+            for o in range(len(self.heatCascade)):
+                self.heatCascadedeltaH.append(self.heatCascade[o]['deltaH'])
+                self.heatCascadeexitH.append(self.heatCascade[o]['exitH'])
+
+            for i in range(len(self.heatCascadeexitH)-1):
+                if self.heatCascadeexitH[i] <= 1e-22:
+                    j = i
+                    k = i
+                    break
+            if j == 0 and k == 0:
+                if  self.heatCascadeexitH[-1] <= 1e-22:
+                    k = len(self.heatCascadeexitH)-1
+                    j = len(self.heatCascadeexitH)-1
+                    plottest = 1
+                elif self.heatCascadeexitH[0] <= 1e-22:
+                    j = 0
+            while j < len(self.heatCascadeexitH)-1:
+                if self.heatCascadedeltaH[j] == 0:
+                    j += 1
+                
+                if j >= len(self.heatCascadedeltaH)-1:
+                    break
+
+                if self.heatCascadedeltaH[j] > 0: 
+                    if self.heatCascadedeltaH[j + 1] < 0:
+                        if abs(self.heatCascadedeltaH[j+1]) < abs(self.heatCascadedeltaH[j]):
+                            self._temperatures[j+1] = self._temperatures[j] + ((self._temperatures[j]-self._temperatures[j+1]) / (self.heatCascadeexitH[j] - self.heatCascadeexitH[j+1]))* (self.heatCascadeexitH[j+2])  # lineare regression der Temperatur
+                            self.heatCascadedeltaH[j] = self.heatCascadeexitH[j+2] - self.heatCascadeexitH[j]
+                            self.heatCascadeexitH[j+1]=self.heatCascadeexitH[j+2]
+                            self.heatCascadedeltaH[j+1] = 0.0
+                            self.deleteDoubleEmpty(j)
+                            if self.heatCascadedeltaH[-1] == 0.0:
+                                    self.heatCascadedeltaH.pop()
+                                    self._temperatures.pop()
+                                    self.heatCascadeexitH.pop()
+                                    break
+                            j = i
+                        elif abs(self.heatCascadedeltaH[j+1]) > abs(self.heatCascadedeltaH[j]):
+                            self._temperatures[j+1] = self._temperatures[j+2] + ((self._temperatures[j+1]-self._temperatures[j+2]) / (self.heatCascadeexitH[j+1] - self.heatCascadeexitH[j+2]))* (self.heatCascadeexitH[j] - self.heatCascadeexitH[j+2])  # lineare regression der Temperatur
+                            self.heatCascadeexitH[j+1]=self.heatCascadeexitH[j]
+                            self.heatCascadedeltaH[j] = 0.0
+                            self.deleteDoubleEmpty(j)
+                            if self.heatCascadedeltaH[-1] == 0.0:
+                                    self.heatCascadedeltaH.pop()
+                                    self._temperatures.pop()
+                                    self.heatCascadeexitH.pop()
+                                    break
+                            j=i
+                        else:
+                            self.heatCascadedeltaH = 0.0
+                            self.heatCascadedeltaH.pop(j+1)
+                            self.heatCascadeexitH.pop(j+1)
+                            self._temperatures.pop(j+1)
+                            self.deleteDoubleEmpty(j)
+                            if self.heatCascadedeltaH[-1] == 0.0:
+                                    self.heatCascadedeltaH.pop()
+                                    self._temperatures.pop()
+                                    self.heatCascadeexitH.pop()
+                                    break
+                            j=i
+                    elif self.heatCascadedeltaH[j+1] == 0:
+                        if self.heatCascadedeltaH[j+2]<0:
+                            if abs(self.heatCascadedeltaH[j+2]) > abs(self.heatCascadedeltaH[j]):
+                                self._temperatures[j+2] = self._temperatures[j+3] + ((self._temperatures[j+2]-self._temperatures[j+3]) / (self.heatCascadeexitH[j+2] - self.heatCascadeexitH[j+3]))* (self.heatCascadeexitH[j]-self.heatCascadeexitH[j+3])
+                                self.heatCascadeexitH[j+2] = self.heatCascadeexitH[j]
+                                self.heatCascadedeltaH[j+2] = self.heatCascadedeltaH[j+2] + self.heatCascadedeltaH[j]
+                                self._temperatures.pop(j+1)
+                                self.heatCascadeexitH.pop(j+1)
+                                self.heatCascadedeltaH.pop(j)
+                                self.deleteDoubleEmpty(j)
+                                if self.heatCascadedeltaH[-1] == 0.0:
+                                    self.heatCascadedeltaH.pop()
+                                    self._temperatures.pop()
+                                    self.heatCascadeexitH.pop()
+                                    break
+                                j=i
+                            elif abs(self.heatCascadedeltaH[j+2]) < abs(self.heatCascadedeltaH[j]):
+                                self._temperatures[j+1] = self._temperatures[j+1] - ((self._temperatures[j]-self._temperatures[j+1]) / (self.heatCascadeexitH[j] - self.heatCascadeexitH[j+1]))* (self.heatCascadeexitH[j+1]-self.heatCascadeexitH[j+3])  # lineare regression der Temperatur
+                                self.heatCascadeexitH[j+1] = self.heatCascadeexitH[j+3]
+                                self.heatCascadeexitH.pop(j+2)
+                                self.heatCascadedeltaH[j] = self.heatCascadedeltaH[j] + self.heatCascadedeltaH[j+2]
+                                self.heatCascadedeltaH.pop(j+2)
+                                self._temperatures.pop(j+2)
+                                self.deleteDoubleEmpty(j)
+                                if self.heatCascadedeltaH[-1] == 0.0:
+                                    self.heatCascadedeltaH.pop()
+                                    self._temperatures.pop()
+                                    self.heatCascadeexitH.pop()
+                                    break
+                                j=i
+                            else:
+                                self.heatCascadedeltaH.pop(j+1)
+                                self._temperatures.pop(j+1)
+                                self.heatCascadeexitH.pop(j+1)
+                                self.heatCascadedeltaH.pop(j+1)
+                                self._temperatures.pop(j+1)
+                                self.heatCascadeexitH.pop(j+1)
+                                self.heatCascadedeltaH[j] = 0.0
+                                self.deleteDoubleEmpty(j)
+                                if self.heatCascadedeltaH[-1] == 0.0:
+                                    self.heatCascadedeltaH.pop()
+                                    self._temperatures.pop()
+                                    self.heatCascadeexitH.pop()
+                                    break
+                                j=i
+                        else:
+                            j+=1
+                    else:
+                        j += 1
+                else:
+                    j += 1
+            while u < k-1:
+                if u >= len(self.heatCascadedeltaH)-1:
+                    break
+                #unterscheidung einfügen ob u=0
+                if self.heatCascadedeltaH[u] > 0 and u == 0:        #löscht nur den obersten, wenn der oberste direkt dran ist      
+                    if self.heatCascadedeltaH[u+1] < 0:
+                        if abs(self.heatCascadedeltaH[u+1]) > abs(self.heatCascadedeltaH[u]):
+                            #kalt größer heiß
+                            self._temperatures[u+1] = self._temperatures[u+2] + ((self._temperatures[u+1]-self._temperatures[u+2]) / (self.heatCascadeexitH[u+1] - self.heatCascadeexitH[u+2]))* (self.heatCascadeexitH[u]-self.heatCascadeexitH[u+2])  # lineare regression der Temperatur
+                            self.heatCascadedeltaH[u] = self.heatCascadeexitH[u+2] - self.heatCascadeexitH[u]
+                            self._temperatures.pop(u)
+                            self.heatCascadeexitH.pop(u+1)
+                            self.heatCascadedeltaH.pop(u+1)
+                            self.deleteDoubleEmpty(u)
+                            u = 0
+                        elif abs(self.heatCascadedeltaH[u+1]) < abs(self.heatCascadedeltaH[u]):
+                            self._temperatures[u+1] = self._temperatures[u] + ((self._temperatures[u+1]-self._temperatures[u]) / (self.heatCascadeexitH[u+1] - self.heatCascadeexitH[u]))* (self.heatCascadeexitH[u+2]-self.heatCascadeexitH[u])  # lineare regression der Temperatur
+                            self.heatCascadedeltaH[u] = self.heatCascadeexitH[u] + self.heatCascadeexitH[u+1]
+                            self.heatCascadeexitH[u+1] = self.heatCascadeexitH[u+2]
+                            self.heatCascadedeltaH[u+1] = 0.0
+                            self.deleteDoubleEmpty(u)
+                            u = 0
+                        else:
+                            self._temperatures.pop(u)
+                            self.heatCascadeexitH.pop(u)
+                            self.heatCascadedeltaH.pop(u)
+                            self._temperatures.pop(u)
+                            self.heatCascadeexitH.pop(u)
+                            self.heatCascadedeltaH.pop(u)
+                            u=0
+                    elif self.heatCascadedeltaH[u+1] == 0:
+                        if self.heatCascadedeltaH[u+2]<0:
+                            if abs(self.heatCascadedeltaH[u+2]) > abs(self.heatCascadedeltaH[u]):
+                                self._temperatures[u+2] = self._temperatures[u+3] + ((self._temperatures[u+2]-self._temperatures[u+3]) / (self.heatCascadeexitH[u+2] - self.heatCascadeexitH[u+3]))* (self.heatCascadeexitH[u]-self.heatCascadeexitH[u+3])
+                                self.heatCascadeexitH[u+2] = self.heatCascadeexitH[u]
+                                self.heatCascadedeltaH[u+2] = self.heatCascadedeltaH[u+2] + self.heatCascadedeltaH[u]
+                                self._temperatures.pop(u+1)
+                                self.heatCascadeexitH.pop(u+1)
+                                self.heatCascadedeltaH.pop(u)
+                                self.deleteDoubleEmpty(u)
+                                self._temperatures.pop(u)
+                                self.heatCascadedeltaH.pop(u)
+                                self.heatCascadeexitH.pop(u)
+                                u=0
+                            elif abs(self.heatCascadedeltaH[u+2]) < abs(self.heatCascadedeltaH[u]):
+                                self._temperatures[u+1] = self._temperatures[u+1] - ((self._temperatures[u]-self._temperatures[u+1]) / (self.heatCascadeexitH[u] - self.heatCascadeexitH[u+1]))* (self.heatCascadeexitH[u+1]-self.heatCascadeexitH[u+3])  # lineare regression der Temperatur
+                                self.heatCascadeexitH[u+1] = self.heatCascadeexitH[u+3]
+                                self.heatCascadeexitH.pop(u+2)
+                                self.heatCascadedeltaH[u] = self.heatCascadedeltaH[u] + self.heatCascadedeltaH[u+2]
+                                self.heatCascadedeltaH.pop(u+2)
+                                self._temperatures.pop(u+2)
+                                self.deleteDoubleEmpty(u)
+                                self._temperatures.pop(u)
+                                self.heatCascadedeltaH.pop(u)
+                                self.heatCascadeexitH.pop(u)
+                                u=0
+                            else:
+                                self._temperatures.pop(u)
+                                self.heatCascadeexitH.pop(u)
+                                self.heatCascadedeltaH.pop(u)
+                                self._temperatures.pop(u)
+                                self.heatCascadeexitH.pop(u)
+                                self.heatCascadedeltaH.pop(u)
+                                self._temperatures.pop(u)
+                                self.heatCascadeexitH.pop(u)
+                                self.heatCascadedeltaH.pop(u)
+                                u=0
+                        else:
+                            u+=1
+                    else:
+                        u += 1
+                elif self.heatCascadedeltaH[u] > 0 and u != 0:
+                    if self.heatCascadedeltaH[u + 1] < 0:
+                        if abs(self.heatCascadedeltaH[u+1]) > abs(self.heatCascadedeltaH[u]):
+                            self._temperatures[u+1] = self._temperatures[u+2] + ((self._temperatures[u+1]-self._temperatures[u+2]) / (self.heatCascadeexitH[u+1] - self.heatCascadeexitH[u+2]))* (self.heatCascadeexitH[u]-self.heatCascadeexitH[u+2])  # lineare regression der Temperatur
+                            self.heatCascadedeltaH[u+1] = self.heatCascadedeltaH[u+1] + self.heatCascadedeltaH[u]
+                            self.heatCascadeexitH[u+1] = self.heatCascadeexitH[u]
+                            self.heatCascadedeltaH[u] = 0.0
+                            self.deleteDoubleEmpty(u)
+                            u = 0
+                        elif abs(self.heatCascadedeltaH[u+1]) < abs(self.heatCascadedeltaH[u]):
+                            self._temperatures[u+1] = self._temperatures[u] + ((self._temperatures[u+1]-self._temperatures[u]) / (self.heatCascadeexitH[u+1] - self.heatCascadeexitH[u]))* (self.heatCascadeexitH[u+2]-self.heatCascadeexitH[u])  # lineare regression der Temperatur
+                            self.heatCascadedeltaH[u] = self.heatCascadeexitH[u] + self.heatCascadeexitH[u+1]
+                            self.heatCascadeexitH[u+1] = self.heatCascadeexitH[u+2]
+                            self.heatCascadedeltaH[u+1] = 0.0
+                            self.deleteDoubleEmpty(u)
+                            u = 0 # selbes wie u==0
+                        else:
+                            self._temperatures.pop(u+1)
+                            self.heatCascadeexitH.pop(u+1)
+                            self.heatCascadedeltaH[u] = 0.0
+                            self.heatCascadedeltaH.pop(u+1)
+                            self.deleteDoubleEmpty(u)
+                            u=0
+                    elif self.heatCascadedeltaH[u + 1] == 0:
+                        if self.heatCascadedeltaH[u+2]<0:
+                            if abs(self.heatCascadedeltaH[u+2]) > abs(self.heatCascadedeltaH[u]):
+                                self._temperatures[u+2] = self._temperatures[u+3] + ((self._temperatures[u+2]-self._temperatures[u+3]) / (self.heatCascadeexitH[u+2] - self.heatCascadeexitH[u+3]))* (self.heatCascadeexitH[u]-self.heatCascadeexitH[u+3])
+                                self.heatCascadeexitH[u+2] = self.heatCascadeexitH[u]
+                                self.heatCascadedeltaH[u+2] = self.heatCascadedeltaH[u+2] + self.heatCascadedeltaH[u]
+                                self._temperatures.pop(u+1)
+                                self.heatCascadeexitH.pop(u+1)
+                                self.heatCascadedeltaH.pop(u)
+                                self.deleteDoubleEmpty(u)
+                                u=0
+                            elif abs(self.heatCascadedeltaH[u+2]) < abs(self.heatCascadedeltaH[u]):
+                                self._temperatures[u+1] = self._temperatures[u+1] - ((self._temperatures[u]-self._temperatures[u+1]) / (self.heatCascadeexitH[u] - self.heatCascadeexitH[u+1]))* (self.heatCascadeexitH[u+1]-self.heatCascadeexitH[u+3])  # lineare regression der Temperatur
+                                self.heatCascadeexitH[u+1] = self.heatCascadeexitH[u+3]
+                                self.heatCascadeexitH.pop(u+2)
+                                self.heatCascadedeltaH[u] = self.heatCascadedeltaH[u] + self.heatCascadedeltaH[u+2]
+                                self.heatCascadedeltaH.pop(u+2)
+                                self._temperatures.pop(u+2)
+                                self.deleteDoubleEmpty(u)
+                                u=0
+                            else:
+                                self._temperatures.pop(u+1)
+                                self.heatCascadeexitH.pop(u+1)
+                                self._temperatures.pop(u+1)
+                                self.heatCascadeexitH.pop(u+1)
+                                self.heatCascadedeltaH[u] = 0.0
+                                self.heatCascadedeltaH.pop(u+1)
+                                self.heatCascadedeltaH.pop(u+1)
+                                self.deleteDoubleEmpty(u)
+                                u=0
+                        else:
+                            u+=1
+                    else:
+                        u+=1
+                else:
+                    u+=1
+
+            self.deletedPocketdict['H'].append(self.heatCascadeexitH)
+            self.deletedPocketdict['deltaH'].append(self.heatCascadedeltaH)
+            self.deletedPocketdict['T'].append(self._temperatures)
+            self.deletedPocketdictlist.append(self.deletedPocketdict)
+
+            if self._options['draw'] == True:
+                TSPPlot.drawDeletedCurve(self, self.heatCascadedeltaH, self.deletedPocketdict, self._temperatures, plottest)
+
+            return self.deletedPocketdict

pinch_tool/Modules/Utility/Thermodynamic_Properties.py

@@ -0,0 +1,21 @@
+from CoolProp.CoolProp import PropsSI
+
+class ThermodynamicProperties():
+
+    def get_hprime(T, fluid = 'Water'):
+        TK = float(T)+273.15
+        return PropsSI('H', 'T', TK, 'Q', 0, fluid) / 1000  # kJ/kg
+    
+    def get_hdouble_prime(T, fluid = 'Water'):
+        TK = float(T)+273.15
+        return PropsSI('H', 'T', TK, 'Q', 1, fluid) / 1000  # kJ/kg
+    
+    def get_vprime(T, fluid = 'Water'):
+        TK = float(T)+273.15
+        rho_liq = PropsSI('D', 'T', TK, 'Q', 0, fluid)  # kg/m3
+        return 1 / rho_liq  # m3/kg
+    
+    def get_latentheat(T, fluid = 'Water'):
+        TK = float(T)+273.15
+        return (PropsSI('H', 'T', TK, 'Q', 1, fluid) / 1000) - (PropsSI('H', 'T', TK, 'Q', 0, fluid) / 1000) # kJ/kg
+        

pinch_tool/Modules/Utility/splitStreams.py

@@ -0,0 +1,105 @@
+
+
+class splitStreams():
+    def __init__(self, deletedPocketdict,splitdict):
+        self.deletedPocketdict = deletedPocketdict
+        
+        self.splitdict = splitdict
+
+    def splitHotandCold(self):
+        self.splitHotTemperatures = []
+        self.splitColdTemperatures = []
+        self.splitHotH = []
+        self.splitColdH = []
+        testHot = 0
+        testCold = 0
+    
+        for i in range(len(self.deletedPocketdict['T'])):
+            for j in range(len(self.deletedPocketdict['T'][i])):
+                if j >= len(self.deletedPocketdict['deltaH'][i]):
+                    continue
+                if self.deletedPocketdict['deltaH'][i][j] > 0 and testHot == 0:
+                    self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j])
+                    self.splitHotH.append(self.deletedPocketdict['H'][i][j])
+                    self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                    self.splitHotH.append(self.deletedPocketdict['H'][i][j+1])
+                    testHot = 1
+
+                elif self.deletedPocketdict['deltaH'][i][j] > 0 and testHot == 1:
+                    if j == len(self.deletedPocketdict['deltaH'][i])-1:
+                        self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                        self.splitHotH.append(self.deletedPocketdict['H'][i][j+1])
+                    elif self.deletedPocketdict['deltaH'][i][j+1] < 0:
+                        self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j])
+                        self.splitHotH.append(self.splitHotH[-1])
+                        self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                        self.splitHotH.append(self.splitHotH[-1] + self.deletedPocketdict['deltaH'][i][j])# Anpassen
+                    else:
+                        self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                        self.splitHotH.append(self.deletedPocketdict['H'][i][j+1])
+
+                elif self.deletedPocketdict['deltaH'][i][j] < 0 and testCold == 0:
+                    self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j])
+                    self.splitColdH.append(self.deletedPocketdict['H'][i][j])
+                    self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                    self.splitColdH.append(self.deletedPocketdict['H'][i][j+1])
+                    testCold = 1
+                elif self.deletedPocketdict['deltaH'][i][j] < 0 and testCold == 1:
+                    if j == len(self.deletedPocketdict['deltaH'][i])-1:
+                        if self.splitColdH[-1] < 0:
+                            self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                            self.splitColdH.append(self.deletedPocketdict['deltaH'][i][j] + self.splitColdH[-1])
+                        else:
+                            self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                            self.splitColdH.append(self.deletedPocketdict['H'][i][j+1])
+                    elif self.deletedPocketdict['deltaH'][i][j+1] > 0 or self.deletedPocketdict['deltaH'][i][j-1]:
+                        self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j])
+                        self.splitColdH.append(self.splitColdH[-1])
+                        self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                        self.splitColdH.append(self.deletedPocketdict['deltaH'][i][j] + self.splitColdH[-1])# Anpassen
+                    else:
+                        if self.splitColdH[-1] < 0:
+                            self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                            self.splitColdH.append(self.deletedPocketdict['deltaH'][i][j] + self.splitColdH[-1])
+                        else:
+                            self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                            self.splitColdH.append(self.deletedPocketdict['H'][i][j+1])
+                elif self.deletedPocketdict['deltaH'][i][j] == 0:
+                    if self.deletedPocketdict['deltaH'][i][j-1] < 0:
+                        self.splitColdTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                        self.splitColdH.append(self.deletedPocketdict['H'][i][j+1])
+
+                    elif self.deletedPocketdict['deltaH'][i][j-1] > 0:
+                        self.splitHotTemperatures.append(self.deletedPocketdict['T'][i][j+1])
+                        self.splitHotH.append(self.deletedPocketdict['H'][i][j+1])
+                    else:
+                        pass
+
+                else:
+                    pass
+        
+        
+
+        self.splitColddeltaH = []
+        self.splitHotdeltaH = []                
+        for i in range(len(self.splitColdH)-1):
+            self.splitColddeltaH.append(self.splitColdH[i+1]-self.splitColdH[i])
+
+        for i in range(len(self.splitHotH)-1):
+            self.splitHotdeltaH.append(self.splitHotH[i+1]-self.splitHotH[i])   
+
+        self.splitHotTemperatures
+        #self.splitHotH.sort(reverse=True)
+        self.splitHotdeltaH
+        self.splitColdTemperatures
+        self.splitColdH
+        self.splitColddeltaH
+
+        self.splitdict['HotTemperatures'].append(self.splitHotTemperatures)
+        self.splitdict['HotH'].append(self.splitHotH)
+        self.splitdict['HotdeltaH'].append(self.splitHotdeltaH)
+        self.splitdict['ColdTemperatures'].append(self.splitColdTemperatures)
+        self.splitdict['ColdH'].append(self.splitColdH)
+        self.splitdict['ColddeltaH'].append(self.splitColddeltaH)
+
+        return self.splitdict

pinch_tool/Output/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

pinch_tool/Pinch_main.py

@@ -0,0 +1,53 @@
+import csv
+from Modules.Pinch.Pinch import Pinch
+from Modules.Pinch.PinchPlot import PinchPlot
+
+class Pinchmain():
+    def __init__(self, CSV, options = {}):
+        self.PinchAnalyse = Pinch(CSV, options)
+        self._options = {}
+       
+    def solvePinch(self, localisation = 'DE'):
+
+        self.PinchAnalyse.shiftTemperatures()
+        self.PinchAnalyse.constructTemperatureInterval()
+        self.PinchAnalyse.constructProblemTable()
+        self.PinchAnalyse.constructHeatCascade()
+        self.PinchAnalyse.constructShiftedCompositeDiagram(localisation)
+        self.PinchAnalyse.constructCompositeDiagram(localisation)
+        self.PinchAnalyse.constructGrandCompositeCurve(localisation)
+
+        with open("Buffer file for TotalSiteProfile creation.csv", "w", newline="") as csvfile:
+            self.newstreamsdata = csv.writer(csvfile)
+            self.newstreamsdata.writerow(self.PinchAnalyse._temperatures)
+            self.newstreamsdata.writerow(self.PinchAnalyse.heatCascade)
+            self.newstreamsdata.writerow([self.PinchAnalyse.hotUtility])
+
+
+        if self.PinchAnalyse._options['draw'] == True:
+            PinchPlot.showPlots()  
+
+    def solvePinchforISSP(self, localisation = 'DE'):
+
+        self.PinchAnalyse.shiftTemperatures()
+        self.PinchAnalyse.constructTemperatureInterval()
+        self.PinchAnalyse.constructProblemTable()
+        self.PinchAnalyse.constructHeatCascade()
+        self.PinchAnalyse.constructShiftedCompositeDiagram(localisation)
+
+        return[self.PinchAnalyse.shiftedCompositeDiagram, self.PinchAnalyse]
+    
+    def solvePinchforHPI(self, localisation = 'DE'):
+
+        self.PinchAnalyse.shiftTemperatures()
+        self.PinchAnalyse.constructTemperatureInterval()
+        self.PinchAnalyse.constructProblemTable()
+        self.PinchAnalyse.constructHeatCascade()
+        self.PinchAnalyse.constructShiftedCompositeDiagram(localisation)
+        self.PinchAnalyse.constructCompositeDiagram(localisation)
+        self.PinchAnalyse.constructGrandCompositeCurve(localisation)
+
+        return(self.PinchAnalyse)
+
+#Pinchmain('Example.csv', options={'draw', 'csv'}).solvePinch()
+#Pinchmain('Prozess_neu.csv', options={'draw', 'csv'}).solvePinch()

pinch_tool/README.md

@@ -0,0 +1,90 @@
+# Pinch Tool
+# Python EST Template
+
+One of the first things after creating your repo is to provide some short information about the repo and the code it contains.
+**Describe your project in one or two sentences here (and now)!!!**
+
+
+# Table of contents
+- [Python EST Template](#python-est-template)
+- [Table of contents](#table-of-contents)
+  - [Description](#description)
+  - [Installation](#installation)
+      - [Virtual environments](#virtual-environments)
+        - [Creating a venv in the terminal:](#creating-a-venv-in-the-terminal)
+        - [Creating a venv in VS Code:](#creating-a-venv-in-vs-code)
+        - [Creating a venv in PyCharm:](#creating-a-venv-in-pycharm)
+      - [Installing pip packages (Best practise)](#installing-pip-packages-best-practise)
+  - [Usage](#usage)
+
+## Description
+Here you are asked to provide a detailed project description about your repository.
+This contains the purpose and structure of your project.
+
+## Installation
+When building a larger project, that depends on multiple packages a detailed description on how to set up your environment might be necessary.
+This is your job...
+
+
+The following two sections give you a quick overview on best practises on "workspace management" for python coding...enjoy!
+
+#### Virtual environments
+When programming different projects over longer periods of time, it can happen that more and more packages are installed, some of which are no longer needed because the corresponding repos have long since been deleted.
+This can become a problem when it comes to storage space on your device and will cause the size of your Python installation to grow rapidly.
+
+To solve this problem [virtual environments](https://docs.python.org/3/library/venv.html) (`venv`) come into play.
+These `venv` create a project related virtual python interpreter where the packages are installed, meaning if you delete the project (or more specific the `.venv` folder) all installed packages are deleted as well.
+
+Therefore it is suggested to create a `.venv` for each project.
+
+##### Creating a venv in the terminal:
+
+***Due to some windows-related bullshit the following steps may not work in the PowerShell. Instead use the good old Terminal ("Eingabeaufforderung")!***
+
+1. To create a virtual environment using the terminal simply navigate into the project folder or open the terminal directly in this location
+2. Run the following command to create a new virtual environment: `python -m venv .venv`
+3. Activate your environment for the workspace by executing the following command: `.venv\Scripts\activate`
+   
+You are now working in your virtual environment, congrats! :)
+
+
+##### Creating a venv in VS Code:
+1. Install the Python Environment Manager extension. After installation the python-symbol should occur in the sidebar on the left side.
+
+2. Press on the python icon in the sidebar, then click on the plus sign in your workspace environment section (top left) and select `Venv` in the opening pop-up.
+
+3. Use your general python installation as your interpreter, when asked.
+
+4. Now a new `venv` should be created and a workspace environment called `.venv (...)` should be displayed.
+
+##### Creating a venv in PyCharm:
+
+**@Henning Rahlf** can you update the section for pycharm please?
+
+#### Installing pip packages (Best practise)
+[Pip](https://pip.pypa.io/en/stable/) is one of the most used package manager for python.
+To organize your imported packages and make the required packages visible for other users a common way is to use a `requirements.txt` file.
+This file is included in this template by default.
+
+Whenever adding an import to your source code, you should also update your `requirements.txt` by simply add your package name to a new line.
+```
+## requirements.txt
+matplotlib
+numpy
+pandas
+...
+``` 
+If your code relies on a specific version of an imported package (and you want to maintain compatibility) you can also specifiy the version as shown below:
+```
+numpy==1.21.2
+```
+*Note: You can also use expressions like `>`, `<`, `>=`, `<=` to allow certain ranges of package versions.* 
+
+To install the required packages you can now simply run the following command:
+```
+pip install -r requirements.txt
+```
+insead of installing each package independently.
+
+## Usage
+If required, add instructions on how to use the software here...

pinch_tool/TotalSiteProfile_main.py

@@ -0,0 +1,34 @@
+import csv
+from Modules.TotalSiteProfile.TotalSiteProfile import TotalSiteProfile as TSP
+from Modules.TotalSiteProfile.TSPPlot import TSPPlot as TSPPlot
+
+class TotalSiteProfilemain():
+    def __init__(self, siteDesignation, CSVList, options = {}):
+        self.CSVList = CSVList
+        
+        self.TotalSite = TSP(siteDesignation, options)
+        
+    def solveTotalSiteProfile(self, localisation = 'DE', internalHeatTransfer = True):
+        for siteProfilecsv in self.CSVList:
+            self.TotalSite.importData(siteProfilecsv)
+            if internalHeatTransfer == True:
+                self.TotalSite.deleteTemperaturePockets()
+            else:
+                self.TotalSite.noDeletionHelper()
+            self.TotalSite.splitHotandCold()
+        self.TotalSite.constructTotalSiteProfile(localisation)
+
+        if self.TotalSite._options['draw'] == True:
+            TSPPlot().showPlots()
+
+    def testsolve(self):
+
+        for siteProfilecsv in self.CSVList:
+            self.TotalSite.importData(siteProfilecsv)
+            self.TotalSite.deleteTemperaturePockets()
+
+        if self.TotalSite._options['draw'] == True:
+            TSPPlot().showPlots()
+
+
+TotalSiteProfilemain('Test', ['Example.csv', 'Example.csv'], options={'draw', 'csv'}).solveTotalSiteProfile(internalHeatTransfer = False)

pinch_tool/requirements.txt

@@ -0,0 +1,4 @@
+numpy
+matplotlib
+tabulate
+CoolProp

src/graphics_utils.py

@@ -0,0 +1,45 @@
+from PIL import Image, ImageDraw
+
+
+def draw_smooth_ellipse(base_img, bbox, fill=None, outline=None, width=1, scale=4):
+    """Draw an anti-aliased ellipse on top of `base_img`.
+
+    This function creates a larger temporary overlay at `scale` times the
+    base size, draws the ellipse there, downsamples with LANCZOS and
+    composites it onto the base image. This produces much smoother edges.
+
+    Args:
+        base_img (PIL.Image): RGBA image to draw onto. Returned image is a new
+            Image object (alpha-composited).
+        bbox (sequence): [x0, y0, x1, y1] bounding box in base image coordinates.
+        fill (tuple|str): Fill color (RGBA tuple or PIL color).
+        outline (tuple|str): Outline color.
+        width (int): Outline width in base-image pixels.
+        scale (int): Supersampling factor. 3-6 is usually good. Default 4.
+
+    Returns:
+        PIL.Image: New RGBA image with the ellipse composited.
+    """
+    if base_img.mode != 'RGBA':
+        base_img = base_img.convert('RGBA')
+
+    w, h = base_img.size
+    # Create large transparent overlay
+    overlay_large = Image.new('RGBA', (w * scale, h * scale), (0, 0, 0, 0))
+    draw_large = ImageDraw.Draw(overlay_large)
+
+    x0, y0, x1, y1 = bbox
+    bbox_large = [int(x0 * scale), int(y0 * scale), int(x1 * scale), int(y1 * scale)]
+
+    if fill:
+        draw_large.ellipse(bbox_large, fill=fill)
+
+    if outline and width and width > 0:
+        draw_large.ellipse(bbox_large, outline=outline, width=max(1, int(width * scale)))
+
+    # Downsample overlay to original size with LANCZOS (antialiasing)
+    overlay_small = overlay_large.resize((w, h), Image.Resampling.LANCZOS)
+
+    # Composite overlay onto base image
+    result = Image.alpha_composite(base_img, overlay_small)
+    return result

src/home.py

@@ -0,0 +1,43 @@
+import streamlit as st
+import streamlit.components.v1 as components
+import base64
+
+# Configure the app - this must be the first Streamlit command
+st.set_page_config(
+    page_title="HeatTransPlan App",
+    page_icon="",
+    initial_sidebar_state="expanded"
+)
+
+# Apply styles immediately to prevent flash
+st.markdown(
+    """
+    <style>
+    :root {
+        font-size: 11px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="true"] {
+        width: 180px !important;
+        min-width: 180px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="false"] {
+        width: 0 !important;
+        min-width: 0 !important;
+        margin-left: 0 !important;
+    }
+    
+    /* Smaller fonts and elements - apply to all elements */
+    html, body, .stApp, * {font-size:11px !important;}
+    .stMarkdown p, .stMarkdown span, .stMarkdown li {font-size:11px !important;}
+    .stButton button {font-size:10px !important; padding:0.1rem 0.3rem !important;}
+    .stTextInput input, .stNumberInput input {font-size:10px !important; padding:0.1rem 0.2rem !important;}
+    h1 {font-size: 1.5rem !important; margin-bottom: 0.3rem !important;}
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+
+# Home page content
+st.title("Home page")
+

src/pages_test/exploration.py

@@ -0,0 +1,351 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import plotly.figure_factory as ff
+from plotly.subplots import make_subplots
+import matplotlib.pyplot as plt
+import seaborn as sns
+from io import BytesIO
+
+st.set_page_config(
+    page_title="Data Exploration",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Apply styles
+st.markdown(
+    """
+    <style>
+    :root {
+        font-size: 11px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="true"] {
+        width: 180px !important;
+        min-width: 180px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="false"] {
+        width: 0 !important;
+        min-width: 0 !important;
+        margin-left: 0 !important;
+    }
+    html, body, .stApp, * {font-size:11px !important;}
+    .stMarkdown p, .stMarkdown span, .stMarkdown li {font-size:11px !important;}
+    .stButton button {font-size:10px !important; padding:0.1rem 0.3rem !important;}
+    .stTextInput input, .stNumberInput input {font-size:10px !important; padding:0.1rem 0.2rem !important;}
+    h1 {font-size: 1.5rem !important; margin-bottom: 0.3rem !important;}
+    h2 {font-size: 1.2rem !important; margin-bottom: 0.2rem !important;}
+    h3 {font-size: 1rem !important; margin-bottom: 0.2rem !important;}
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.title("Data Exploration")
+
+st.markdown("Upload a dataset to explore and analyze your data.")
+
+uploaded_file = st.file_uploader("Upload your dataset (CSV)", type=["csv"])
+
+if uploaded_file is not None:
+    try:
+        # Read the CSV file
+        df = pd.read_csv(uploaded_file)
+        
+        # Store original dataframe in session state
+        if 'original_df' not in st.session_state:
+            st.session_state['original_df'] = df.copy()
+        
+        # ============================================================
+        # SECTION 1: Datetime Column Selection
+        # ============================================================
+        with st.expander("📅 1. Datetime Column Selection", expanded=True):
+            all_columns = ["None"] + list(df.columns)
+            datetime_col = st.selectbox(
+                "Select the datetime column (if any):",
+                options=all_columns,
+                index=0,
+                help="If your dataset has a datetime column, select it here to enable time series analysis."
+            )
+            
+            # Parse datetime if selected
+            if datetime_col != "None":
+                try:
+                    df[datetime_col] = pd.to_datetime(df[datetime_col])
+                    st.success(f"✅ Column '{datetime_col}' successfully parsed as datetime.")
+                except Exception as e:
+                    st.warning(f"⚠️ Could not parse '{datetime_col}' as datetime: {e}")
+                    datetime_col = "None"
+        
+        # ============================================================
+        # SECTION 2: Data Preview
+        # ============================================================
+        with st.expander("👁️ 2. Data Preview", expanded=True):
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Rows", df.shape[0])
+            with col2:
+                st.metric("Columns", df.shape[1])
+            with col3:
+                st.metric("Memory Usage", f"{df.memory_usage(deep=True).sum() / 1024:.2f} KB")
+            
+            st.dataframe(df.head(20), use_container_width=True)
+        
+        # ============================================================
+        # SECTION 3: Variable Summary
+        # ============================================================
+        with st.expander("📊 3. Variable Summary", expanded=True):
+            # Classify columns
+            summary_data = []
+            numerical_cols = []
+            categorical_cols = []
+            datetime_cols_list = []
+            
+            for col in df.columns:
+                col_dtype = df[col].dtype
+                missing_count = df[col].isna().sum()
+                missing_pct = (missing_count / len(df)) * 100
+                unique_count = df[col].nunique()
+                
+                # Determine variable type
+                if pd.api.types.is_datetime64_any_dtype(df[col]):
+                    var_type = "Datetime"
+                    datetime_cols_list.append(col)
+                elif pd.api.types.is_numeric_dtype(df[col]):
+                    var_type = "Numerical"
+                    numerical_cols.append(col)
+                else:
+                    # Try to convert to numeric
+                    try:
+                        df[col] = pd.to_numeric(df[col], errors='raise')
+                        var_type = "Numerical (converted)"
+                        numerical_cols.append(col)
+                    except:
+                        # Check if it could be datetime
+                        if col != datetime_col:
+                            try:
+                                pd.to_datetime(df[col].dropna().head(10))
+                                var_type = "Potential Datetime"
+                            except:
+                                var_type = "Categorical"
+                                categorical_cols.append(col)
+                        else:
+                            var_type = "Categorical"
+                            categorical_cols.append(col)
+                
+                summary_data.append({
+                    "Column": col,
+                    "Type": var_type,
+                    "Dtype": str(col_dtype),
+                    "Missing": missing_count,
+                    "Missing %": f"{missing_pct:.2f}%",
+                    "Unique": unique_count,
+                    "Sample": str(df[col].dropna().iloc[0]) if len(df[col].dropna()) > 0 else "N/A"
+                })
+            
+            summary_df = pd.DataFrame(summary_data)
+            st.dataframe(summary_df, use_container_width=True)
+            
+            # Missing values visualization
+            st.markdown("#### Missing Values")
+            missing_data = df.isnull().sum()
+            missing_data = missing_data[missing_data > 0]
+            
+            if len(missing_data) > 0:
+                fig_missing = px.bar(
+                    x=missing_data.index,
+                    y=missing_data.values,
+                    labels={'x': 'Column', 'y': 'Missing Count'},
+                    title='Missing Values per Column',
+                    color=missing_data.values,
+                    color_continuous_scale='Reds'
+                )
+                fig_missing.update_layout(height=400)
+                st.plotly_chart(fig_missing, use_container_width=True)
+            else:
+                st.success("✅ No missing values in the dataset!")
+        
+        # Filter numerical columns (exclude datetime) - do this once for all sections
+        num_cols_for_dist = [c for c in numerical_cols if c != datetime_col]
+        
+        # ============================================================
+        # SECTION 4: Distributions
+        # ============================================================
+        with st.expander("📈 4. Variable Distributions", expanded=False):
+            if num_cols_for_dist:
+                st.markdown("#### Numerical Variables")
+                
+                # Create distribution plots in a grid
+                n_cols = min(3, len(num_cols_for_dist))
+                n_rows = (len(num_cols_for_dist) + n_cols - 1) // n_cols
+                
+                for row_idx in range(n_rows):
+                    cols = st.columns(n_cols)
+                    for col_idx in range(n_cols):
+                        var_idx = row_idx * n_cols + col_idx
+                        if var_idx < len(num_cols_for_dist):
+                            var_name = num_cols_for_dist[var_idx]
+                            with cols[col_idx]:
+                                fig = px.histogram(
+                                    df, 
+                                    x=var_name,
+                                    title=f'{var_name}',
+                                    marginal="box",
+                                    nbins=30
+                                )
+                                fig.update_layout(
+                                    height=300,
+                                    showlegend=False,
+                                    margin=dict(l=20, r=20, t=40, b=20)
+                                )
+                                st.plotly_chart(fig, use_container_width=True)
+            
+            if categorical_cols:
+                st.markdown("#### Categorical Variables")
+                
+                # Limit to top 10 categories for each variable
+                for cat_col in categorical_cols[:5]:  # Limit to first 5 categorical columns
+                    value_counts = df[cat_col].value_counts().head(10)
+                    fig = px.bar(
+                        x=value_counts.index.astype(str),
+                        y=value_counts.values,
+                        labels={'x': cat_col, 'y': 'Count'},
+                        title=f'Distribution of {cat_col} (Top 10)'
+                    )
+                    fig.update_layout(height=300)
+                    st.plotly_chart(fig, use_container_width=True)
+        
+        # ============================================================
+        # SECTION 5: Time Series Visualization
+        # ============================================================
+        with st.expander("⏱️ 5. Time Series Visualization", expanded=False):
+            if datetime_col != "None":
+                # Sort by datetime
+                df_sorted = df.sort_values(by=datetime_col)
+                n_points = len(df_sorted)
+                
+                st.info(f"Dataset has {n_points} data points. {'Using Plotly (interactive)' if n_points < 4000 else 'Using Seaborn (static) for performance'}.")
+                
+                # Select variables to plot
+                ts_vars = st.multiselect(
+                    "Select variables to visualize as time series:",
+                    options=num_cols_for_dist,
+                    default=num_cols_for_dist[:min(3, len(num_cols_for_dist))]
+                )
+                
+                if ts_vars:
+                    if n_points < 4000:
+                        # Use Plotly for interactive visualization
+                        for var in ts_vars:
+                            fig = px.line(
+                                df_sorted,
+                                x=datetime_col,
+                                y=var,
+                                title=f'{var} over Time'
+                            )
+                            fig.update_layout(
+                                height=350,
+                                xaxis_title="Time",
+                                yaxis_title=var,
+                                hovermode='x unified'
+                            )
+                            st.plotly_chart(fig, use_container_width=True)
+                    else:
+                        # Use Seaborn/Matplotlib for large datasets
+                        for var in ts_vars:
+                            fig, ax = plt.subplots(figsize=(12, 4))
+                            ax.plot(df_sorted[datetime_col], df_sorted[var], linewidth=0.5)
+                            ax.set_xlabel("Time")
+                            ax.set_ylabel(var)
+                            ax.set_title(f'{var} over Time')
+                            plt.xticks(rotation=45)
+                            plt.tight_layout()
+                            st.pyplot(fig)
+                            plt.close()
+                        
+                        st.caption("Using static plots for better performance with large datasets (>4000 points).")
+            else:
+                st.info("Select a datetime column in Section 1 to enable time series visualization.")
+        
+        # ============================================================
+        # SECTION 6: Correlation Matrix
+        # ============================================================
+        with st.expander("🔗 6. Correlation Matrix", expanded=False):
+            if len(num_cols_for_dist) > 1:
+                # Calculate correlation matrix using only numeric data
+                numeric_df = df[num_cols_for_dist].select_dtypes(include=[np.number])
+                corr_matrix = numeric_df.corr()
+                
+                # Get column names as lists
+                x_labels = corr_matrix.columns.tolist()
+                y_labels = corr_matrix.index.tolist()
+                
+                # Get correlation values as a 2D list
+                z_values = corr_matrix.values.tolist()
+                
+                # Create annotation text
+                z_text = [[f'{val:.2f}' for val in row] for row in z_values]
+                
+                # Create heatmap using go.Heatmap for more control
+                fig_corr = go.Figure(data=go.Heatmap(
+                    z=z_values,
+                    x=x_labels,
+                    y=y_labels,
+                    colorscale='RdBu_r',
+                    zmin=-1,
+                    zmax=1,
+                    text=z_text,
+                    texttemplate='%{text}',
+                    textfont={"size": 10},
+                    hovertemplate='%{x} vs %{y}: %{z:.3f}<extra></extra>'
+                ))
+                
+                fig_corr.update_layout(
+                    title='Correlation Matrix',
+                    height=max(400, len(x_labels) * 40),
+                    width=max(600, len(x_labels) * 50),
+                    xaxis=dict(tickangle=45),
+                    yaxis=dict(autorange='reversed')
+                )
+                
+                st.plotly_chart(fig_corr, use_container_width=True)
+                
+                # Show highly correlated pairs
+                st.markdown("#### Highly Correlated Pairs (|r| > 0.7)")
+                high_corr = []
+                for i in range(len(corr_matrix.columns)):
+                    for j in range(i+1, len(corr_matrix.columns)):
+                        corr_val = corr_matrix.iloc[i, j]
+                        if not np.isnan(corr_val) and abs(corr_val) > 0.7:
+                            high_corr.append({
+                                "Variable 1": corr_matrix.columns[i],
+                                "Variable 2": corr_matrix.columns[j],
+                                "Correlation": f"{corr_val:.3f}"
+                            })
+                
+                if high_corr:
+                    st.dataframe(pd.DataFrame(high_corr), use_container_width=True)
+                else:
+                    st.info("No highly correlated pairs found (|r| > 0.7)")
+            else:
+                st.warning("Need at least 2 numerical columns for correlation analysis.")
+        
+        # ============================================================
+        # SECTION 7: Statistical Summary
+        # ============================================================
+        with st.expander("📋 7. Statistical Summary", expanded=False):
+            if num_cols_for_dist:
+                numeric_df = df[num_cols_for_dist].select_dtypes(include=[np.number])
+                stats_df = numeric_df.describe().T
+                stats_df['skewness'] = numeric_df.skew()
+                stats_df['kurtosis'] = numeric_df.kurtosis()
+                st.dataframe(stats_df.round(3), use_container_width=True)
+            else:
+                st.warning("No numerical columns available for statistical summary.")
+
+    except Exception as e:
+        st.error(f"Error loading file: {e}")
+        import traceback
+        st.code(traceback.format_exc())

src/pages_test/home_testing.py

@@ -0,0 +1,56 @@
+import streamlit as st
+import streamlit.components.v1 as components
+import base64
+
+# Configure the app - this must be the first Streamlit command
+st.set_page_config(
+    page_title="HeatTransPlan App",
+    page_icon="",
+    initial_sidebar_state="expanded"
+)
+
+# Apply styles immediately to prevent flash
+st.markdown(
+    """
+    <style>
+    :root {
+        font-size: 11px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="true"] {
+        width: 180px !important;
+        min-width: 180px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="false"] {
+        width: 0 !important;
+        min-width: 0 !important;
+        margin-left: 0 !important;
+    }
+    
+    /* Smaller fonts and elements - apply to all elements */
+    html, body, .stApp, * {font-size:11px !important;}
+    .stMarkdown p, .stMarkdown span, .stMarkdown li {font-size:11px !important;}
+    .stButton button {font-size:10px !important; padding:0.1rem 0.3rem !important;}
+    .stTextInput input, .stNumberInput input {font-size:10px !important; padding:0.1rem 0.2rem !important;}
+    h1 {font-size: 1.5rem !important; margin-bottom: 0.3rem !important;}
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+# Display the logo
+st.image("../data/symbol.svg", width=200)
+# Home page content
+st.title("Home page")
+
+
+st.subheader("Information")
+
+# Display a clickable image from the HeatTransPlan website
+with open("../data/image_project.jpeg", "rb") as f:
+    image_data = f.read()
+encoded_image = base64.b64encode(image_data).decode()
+st.markdown(f'<a href="https://www.heattransplan.de/" target="_blank"><img src="data:image/jpeg;base64,{encoded_image}" width="400" style="transition: transform 0.3s ease; border: none;" onmouseover="this.style.transform=\'scale(1.1)\'" onmouseout="this.style.transform=\'scale(1)\'"></a>', unsafe_allow_html=True)
+st.markdown("About HeatTransPlan")
+
+st.subheader("Navigate to Pages")
+st.page_link("pages/data_collection.py", label="📊 Energy Data Collection", help="Collect and manage energy data")

src/potential_analysis_map.py

@@ -0,0 +1,1165 @@
+import streamlit as st
+import sys
+import os
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import tempfile
+import csv
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
+from graphics_utils import draw_smooth_ellipse
+import math
+
+# Add the pinch_tool directory to the path for imports
+pinch_tool_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'pinch_tool'))
+if pinch_tool_path not in sys.path:
+    sys.path.insert(0, pinch_tool_path)
+
+# Import pinch analysis modules
+try:
+    from Modules.Pinch.Pinch import Pinch
+    PINCH_AVAILABLE = True
+    PINCH_IMPORT_ERROR = None
+except ImportError as e:
+    PINCH_AVAILABLE = False
+    PINCH_IMPORT_ERROR = str(e)
+
+st.set_page_config(
+    page_title="Potential Analysis",
+    initial_sidebar_state="collapsed",
+    layout="wide"
+)
+
+# Helper function to convert lon/lat to pixel coordinates on snapshot
+def snapshot_lonlat_to_pixel(lon_val_in, lat_val_in, center_ll, z_level, img_w, img_h):
+    def lonlat_to_xy(lon_inner, lat_inner, z_val):
+        lat_rad = math.radians(lat_inner)
+        n_val = 2.0 ** z_val
+        xtile = (lon_inner + 180.0) / 360.0 * n_val
+        ytile = (1.0 - math.log(math.tan(lat_rad) + 1 / math.cos(lat_rad)) / math.pi) / 2.0 * n_val
+        return xtile, ytile
+    lon0, lat0 = center_ll
+    xtile0, ytile0 = lonlat_to_xy(lon0, lat0, z_level)
+    xtile, ytile = lonlat_to_xy(lon_val_in, lat_val_in, z_level)
+    dxtile = xtile - xtile0
+    dytile = ytile - ytile0
+    px_per_tile = 256
+    snapshot_px = img_w / 2 + dxtile * px_per_tile
+    snapshot_py = img_h / 2 + dytile * px_per_tile
+    return snapshot_px, snapshot_py
+
+# Apply styles immediately to prevent flash
+st.markdown(
+    """
+    <style>
+    :root {
+        font-size: 11px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="true"] {
+        width: 180px !important;
+        min-width: 180px !important;
+    }
+    section[data-testid="stSidebar"][aria-expanded="false"] {
+        width: 0 !important;
+        min-width: 0 !important;
+        margin-left: 0 !important;
+    }
+    
+    /* Smaller fonts and elements - apply to all elements */
+    html, body, .stApp, * {font-size:11px !important;}
+    .stMarkdown p, .stMarkdown span, .stMarkdown li {font-size:11px !important; margin:0 !important; padding:0 !important;}
+    .stButton button {font-size:10px !important; padding:0.1rem 0.3rem !important;}
+    .stTextInput input, .stNumberInput input {font-size:10px !important; padding:0.1rem 0.2rem !important;}
+    h1 {font-size: 1.5rem !important; margin-bottom: 0.3rem !important;}
+    /* Compact layout */
+    .block-container {padding-top: 1rem !important; padding-bottom: 0 !important;}
+    div[data-testid="stVerticalBlock"] > div {padding: 0 !important; margin: 0 !important;}
+    hr {margin: 0.3rem 0 !important;}
+    .stCheckbox {margin: 0 !important; padding: 0 !important;}
+    div[data-testid="stHorizontalBlock"] {gap: 0.2rem !important;}
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.title("Potential Analysis")
+
+# =====================================================
+# HELPER FUNCTION: Generate mini-map with kW circles for each STREAM
+# =====================================================
+def generate_stream_kw_minimap(processes, map_snapshot, map_center, map_zoom, max_width=500, max_height=400):
+    """
+    Generate a mini-map image showing each stream as a circle sized by kW.
+    Streams are positioned near their parent subprocess location.
+    Returns a PIL Image or None if no snapshot available.
+    """
+    if not map_snapshot:
+        return None
+    
+    try:
+        # Load the base map snapshot
+        base_img = Image.open(BytesIO(map_snapshot)).convert("RGBA")
+        orig_w, orig_h = base_img.size
+        
+        # Calculate scale to fit within max dimensions while maintaining aspect ratio
+        scale = min(max_width / orig_w, max_height / orig_h)
+        new_w = int(orig_w * scale)
+        new_h = int(orig_h * scale)
+        
+        # Resize the base image
+        base_img = base_img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+        
+        # Create drawing context
+        draw = ImageDraw.Draw(base_img)
+        
+        # Try to load a font
+        try:
+            font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 11)
+            font_small = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 9)
+        except (OSError, IOError):
+            try:
+                font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", 11)
+                font_small = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", 9)
+            except (OSError, IOError):
+                font = ImageFont.load_default()
+                font_small = font
+        
+        # Collect all streams with their kW values and positions
+        all_streams = []
+        
+        for proc_idx, subprocess in enumerate(processes):
+            sub_lat = subprocess.get('lat')
+            sub_lon = subprocess.get('lon')
+            subprocess_name = subprocess.get('name', f'Subprocess {proc_idx + 1}')
+            
+            streams = subprocess.get('streams', [])
+            
+            for s_idx, stream in enumerate(streams):
+                stream_name = stream.get('name', f'Stream {s_idx + 1}')
+                
+                # Extract stream data
+                props = stream.get('properties', {})
+                vals = stream.get('values', {})
+                
+                tin = None
+                tout = None
+                mdot = None
+                cp_val = None
+                
+                if isinstance(props, dict) and isinstance(vals, dict):
+                    for pk, pname in props.items():
+                        vk = pk.replace('prop', 'val')
+                        v = vals.get(vk, '')
+                        
+                        if pname == 'Tin' and v:
+                            try:
+                                tin = float(v)
+                            except (ValueError, TypeError):
+                                pass
+                        elif pname == 'Tout' and v:
+                            try:
+                                tout = float(v)
+                            except (ValueError, TypeError):
+                                pass
+                        elif pname == 'ṁ' and v:
+                            try:
+                                mdot = float(v)
+                            except (ValueError, TypeError):
+                                pass
+                        elif pname == 'cp' and v:
+                            try:
+                                cp_val = float(v)
+                            except (ValueError, TypeError):
+                                pass
+                
+                # Fallback to legacy fields
+                if tin is None and stream.get('temp_in'):
+                    try:
+                        tin = float(stream['temp_in'])
+                    except (ValueError, TypeError):
+                        pass
+                if tout is None and stream.get('temp_out'):
+                    try:
+                        tout = float(stream['temp_out'])
+                    except (ValueError, TypeError):
+                        pass
+                if mdot is None and stream.get('mdot'):
+                    try:
+                        mdot = float(stream['mdot'])
+                    except (ValueError, TypeError):
+                        pass
+                if cp_val is None and stream.get('cp'):
+                    try:
+                        cp_val = float(stream['cp'])
+                    except (ValueError, TypeError):
+                        pass
+                
+                # Calculate kW = mdot * cp * |ΔT|
+                stream_kw = 0.0
+                is_hot = None
+                if tin is not None and tout is not None and mdot is not None and cp_val is not None:
+                    delta_t = abs(tin - tout)
+                    stream_kw = mdot * cp_val * delta_t
+                    is_hot = tin > tout  # True = HOT (cooling), False = COLD (heating)
+                
+                all_streams.append({
+                    'proc_idx': proc_idx,
+                    'stream_idx': s_idx,
+                    'subprocess_name': subprocess_name,
+                    'stream_name': stream_name,
+                    'lat': sub_lat,
+                    'lon': sub_lon,
+                    'kw': stream_kw,
+                    'is_hot': is_hot,
+                    'tin': tin,
+                    'tout': tout
+                })
+        
+        # Find max kW for scaling circle sizes
+        kw_values = [s['kw'] for s in all_streams if s['kw'] > 0]
+        max_kw = max(kw_values) if kw_values else 1.0
+        if max_kw == 0:
+            max_kw = 1.0
+        
+        # Group streams by subprocess for positioning
+        subprocess_streams = {}
+        for s in all_streams:
+            key = s['proc_idx']
+            if key not in subprocess_streams:
+                subprocess_streams[key] = []
+            subprocess_streams[key].append(s)
+        
+        # Draw circles for each stream
+        for proc_idx, streams_list in subprocess_streams.items():
+            if not streams_list:
+                continue
+            
+            # Get subprocess position
+            first_stream = streams_list[0]
+            lat = first_stream['lat']
+            lon = first_stream['lon']
+            
+            if lat is None or lon is None:
+                continue
+            
+            try:
+                lat_f = float(lat)
+                lon_f = float(lon)
+                
+                # Convert to pixel coordinates (on original size, then scale)
+                base_px, base_py = snapshot_lonlat_to_pixel(
+                    lon_f, lat_f,
+                    (map_center[1], map_center[0]),
+                    map_zoom,
+                    orig_w, orig_h
+                )
+                
+                # Scale to new dimensions
+                base_px = base_px * scale
+                base_py = base_py * scale
+                
+                # Skip if outside bounds
+                if base_px < -50 or base_py < -50 or base_px > new_w + 50 or base_py > new_h + 50:
+                    continue
+                
+                # Draw subprocess name first
+                subprocess_name = first_stream['subprocess_name']
+                if font:
+                    bbox = draw.textbbox((0, 0), subprocess_name, font=font)
+                    tw = bbox[2] - bbox[0]
+                    th = bbox[3] - bbox[1]
+                else:
+                    tw = len(subprocess_name) * 6
+                    th = 10
+                
+                # Draw subprocess label above streams
+                label_x = int(base_px - tw / 2)
+                label_y = int(base_py - 50)
+                draw.rectangle([label_x - 3, label_y - 2, label_x + tw + 3, label_y + th + 2], 
+                              fill=(255, 255, 255, 230), outline=(100, 100, 100, 200))
+                draw.text((label_x, label_y), subprocess_name, fill=(0, 0, 0, 255), font=font)
+                
+                # Position streams in a row below the label
+                n_streams = len(streams_list)
+                stream_spacing = 45  # pixels between stream circles
+                start_x = base_px - (n_streams - 1) * stream_spacing / 2
+                
+                for i, stream_data in enumerate(streams_list):
+                    px = start_x + i * stream_spacing
+                    py = base_py
+                    
+                    kw = stream_data['kw']
+                    is_hot = stream_data['is_hot']
+                    
+                    # Calculate circle radius based on kW (min 12, max 35 pixels)
+                    if kw > 0:
+                        radius = 12 + (kw / max_kw) * 23
+                    else:
+                        radius = 10
+                    
+                    # Determine color based on hot/cold
+                    if is_hot is True:
+                        fill_color = (255, 80, 80, 220)  # Red for HOT
+                        border_color = (180, 30, 30, 255)
+                    elif is_hot is False:
+                        fill_color = (80, 140, 255, 220)  # Blue for COLD
+                        border_color = (30, 80, 180, 255)
+                    else:
+                        fill_color = (180, 180, 180, 180)  # Gray for unknown
+                        border_color = (120, 120, 120, 220)
+                    
+                    # Draw circle
+                    x0 = int(px - radius)
+                    y0 = int(py - radius)
+                    x1 = int(px + radius)
+                    y1 = int(py + radius)
+                    
+                    base_img = draw_smooth_ellipse(base_img, [x0, y0, x1, y1], fill=fill_color, outline=border_color, width=2)
+                    draw = ImageDraw.Draw(base_img)
+                    
+                    # Draw kW label inside circle
+                    if kw > 0:
+                        kw_text = f"{kw:.0f}"
+                        if font_small:
+                            bbox = draw.textbbox((0, 0), kw_text, font=font_small)
+                            text_w = bbox[2] - bbox[0]
+                            text_h = bbox[3] - bbox[1]
+                        else:
+                            text_w = len(kw_text) * 5
+                            text_h = 8
+                        
+                        tx = int(px - text_w / 2)
+                        ty = int(py - text_h / 2)
+                        
+                        # White text for visibility
+                        draw.text((tx, ty), kw_text, fill=(255, 255, 255, 255), font=font_small)
+                    
+                    # Draw stream name below circle
+                    stream_name = stream_data['stream_name']
+                    if font_small:
+                        bbox = draw.textbbox((0, 0), stream_name, font=font_small)
+                        name_w = bbox[2] - bbox[0]
+                        name_h = bbox[3] - bbox[1]
+                    else:
+                        name_w = len(stream_name) * 5
+                        name_h = 8
+                    
+                    name_x = int(px - name_w / 2)
+                    name_y = int(py + radius + 4)
+                    
+                    draw.rectangle([name_x - 2, name_y - 1, name_x + name_w + 2, name_y + name_h + 1], 
+                                  fill=(255, 255, 255, 220))
+                    draw.text((name_x, name_y), stream_name, fill=(0, 0, 0, 255), font=font_small)
+                    
+            except (ValueError, TypeError):
+                continue
+        
+        # Add legend in top-left corner
+        legend_x = 10
+        legend_y = 10
+        legend_w = 70
+        legend_h = 55
+        
+        # Legend background
+        draw.rectangle([legend_x, legend_y, legend_x + legend_w, legend_y + legend_h], 
+                      fill=(255, 255, 255, 240), outline=(150, 150, 150, 200))
+        
+        # Legend title
+        draw.text((legend_x + 5, legend_y + 3), "kW", fill=(0, 0, 0, 255), font=font)
+        
+        # Hot indicator
+        base_img = draw_smooth_ellipse(base_img, [legend_x + 5, legend_y + 20, legend_x + 17, legend_y + 32], 
+                           fill=(255, 80, 80, 220), outline=(180, 30, 30, 255), width=1)
+        draw = ImageDraw.Draw(base_img)
+        draw.text((legend_x + 22, legend_y + 21), "Hot", fill=(0, 0, 0, 255), font=font_small)
+        
+        # Cold indicator
+        base_img = draw_smooth_ellipse(base_img, [legend_x + 5, legend_y + 37, legend_x + 17, legend_y + 49], 
+                           fill=(80, 140, 255, 220), outline=(30, 80, 180, 255), width=1)
+        draw = ImageDraw.Draw(base_img)
+        draw.text((legend_x + 22, legend_y + 38), "Cold", fill=(0, 0, 0, 255), font=font_small)
+        
+        return base_img
+        
+    except Exception as e:
+        return None
+
+# Initialize session state for selections if not exists
+if 'selected_items' not in st.session_state:
+    st.session_state['selected_items'] = {}
+
+# Get processes from session state
+processes = st.session_state.get('processes', [])
+
+if not processes:
+    st.info("No processes found. Please add processes in the Data Collection page first.")
+else:
+    # Helper function to determine stream type and extract data
+    def get_stream_info(stream):
+        """Extract Tin, Tout, mdot, cp from stream and determine if HOT or COLD"""
+        properties = stream.get('properties', {})
+        values = stream.get('values', {})
+        
+        tin = None
+        tout = None
+        mdot = None
+        cp_val = None
+        
+        # Check properties dict structure
+        if isinstance(properties, dict) and isinstance(values, dict):
+            for pk, pname in properties.items():
+                vk = pk.replace('prop', 'val')
+                v = values.get(vk, '')
+                
+                if pname == 'Tin' and v:
+                    try:
+                        tin = float(v)
+                    except (ValueError, TypeError):
+                        pass
+                elif pname == 'Tout' and v:
+                    try:
+                        tout = float(v)
+                    except (ValueError, TypeError):
+                        pass
+                elif pname == 'ṁ' and v:
+                    try:
+                        mdot = float(v)
+                    except (ValueError, TypeError):
+                        pass
+                elif pname == 'cp' and v:
+                    try:
+                        cp_val = float(v)
+                    except (ValueError, TypeError):
+                        pass
+        
+        # Fallback to legacy fields
+        if tin is None and stream.get('temp_in'):
+            try:
+                tin = float(stream['temp_in'])
+            except (ValueError, TypeError):
+                pass
+        if tout is None and stream.get('temp_out'):
+            try:
+                tout = float(stream['temp_out'])
+            except (ValueError, TypeError):
+                pass
+        if mdot is None and stream.get('mdot'):
+            try:
+                mdot = float(stream['mdot'])
+            except (ValueError, TypeError):
+                pass
+        if cp_val is None and stream.get('cp'):
+            try:
+                cp_val = float(stream['cp'])
+            except (ValueError, TypeError):
+                pass
+        
+        # Determine stream type
+        stream_type = None
+        if tin is not None and tout is not None:
+            if tin > tout:
+                stream_type = "HOT"
+            else:
+                stream_type = "COLD"
+        
+        # Calculate CP if possible
+        cp_flow = None
+        if mdot is not None and cp_val is not None:
+            cp_flow = mdot * cp_val
+        
+        # Calculate kW = mdot * cp * |ΔT|
+        kw = None
+        if tin is not None and tout is not None and mdot is not None and cp_val is not None:
+            kw = mdot * cp_val * abs(tin - tout)
+        
+        return {
+            'tin': tin,
+            'tout': tout,
+            'mdot': mdot,
+            'cp': cp_val,
+            'CP': cp_flow,
+            'kW': kw,
+            'type': stream_type
+        }
+    
+    # =====================================================
+    # TWO-COLUMN LAYOUT: Stream Selection (left) + Map (right)
+    # =====================================================
+    stream_col, map_col = st.columns([1, 1.2])
+    
+    with stream_col:
+        st.markdown("**Select streams for analysis:**")
+        
+        # Display each process and its streams
+        for idx, process in enumerate(processes):
+            process_name = process.get('name', f'Subprocess {idx + 1}')
+            
+            # Only show process header if it has streams
+            streams = process.get('streams', [])
+            if streams:
+                st.markdown(f"**{process_name}**")
+                
+                for stream_idx, stream in enumerate(streams):
+                    stream_key = f"stream_{idx}_{stream_idx}"
+                    if stream_key not in st.session_state['selected_items']:
+                        st.session_state['selected_items'][stream_key] = False
+                    
+                    stream_cols = st.columns([0.05, 0.20, 0.75])
+                    stream_selected = stream_cols[0].checkbox(
+                        "S",
+                        key=f"cb_{stream_key}",
+                        value=st.session_state['selected_items'][stream_key],
+                        label_visibility="collapsed"
+                    )
+                    st.session_state['selected_items'][stream_key] = stream_selected
+                    
+                    # Display stream name
+                    stream_name = stream.get('name', f'Stream {stream_idx + 1}')
+                    stream_cols[1].write(stream_name)
+                    
+                    # Get stream info and display type + key values
+                    info = get_stream_info(stream)
+                    
+                    display_parts = []
+                    if info['tin'] is not None:
+                        display_parts.append(f"Tin:{info['tin']}°C")
+                    if info['tout'] is not None:
+                        display_parts.append(f"Tout:{info['tout']}°C")
+                    if info['kW'] is not None:
+                        display_parts.append(f"**{info['kW']:.0f} kW**")
+                    
+                    if info['type']:
+                        type_color = "🔴" if info['type'] == "HOT" else "🔵"
+                        display_parts.append(f"{type_color} {info['type']}")
+                    
+                    if display_parts:
+                        stream_cols[2].caption(' | '.join(display_parts))
+                    else:
+                        stream_cols[2].caption("(incomplete data)")
+    
+    with map_col:
+        st.markdown("**Energy Map Overview (circle size = kW):**")
+        
+        # Generate and display mini-map with kW circles for each stream
+        map_snapshot = st.session_state.get('map_snapshot')
+        map_snapshots = st.session_state.get('map_snapshots', {})
+        current_base = st.session_state.get('current_base', 'OpenStreetMap')
+        
+        # Use the appropriate snapshot based on current base layer
+        if current_base in map_snapshots:
+            snapshot_to_use = map_snapshots[current_base]
+        else:
+            snapshot_to_use = map_snapshot
+        
+        map_center = st.session_state.get('map_center', [51.708, 8.772])
+        map_zoom = st.session_state.get('map_zoom', 17.5)
+        
+        if snapshot_to_use:
+            minimap_img = generate_stream_kw_minimap(
+                processes=processes,
+                map_snapshot=snapshot_to_use,
+                map_center=map_center,
+                map_zoom=map_zoom,
+                max_width=600,
+                max_height=450
+            )
+            
+            if minimap_img:
+                st.image(minimap_img)
+            else:
+                st.caption("📍 Could not generate map preview")
+        else:
+            st.info("📍 Lock the map in Data Collection page first to see the energy overview.")
+    
+    # Count selected streams
+    selected_count = sum(1 for k, v in st.session_state['selected_items'].items() 
+                         if v and k.startswith("stream_"))
+    
+    # =====================================================
+    # PINCH ANALYSIS SECTION
+    # =====================================================
+    st.markdown("---")
+    
+    if not PINCH_AVAILABLE:
+        st.error(f"Pinch analysis module not available: {PINCH_IMPORT_ERROR or 'Unknown error'}")
+        st.info("Please ensure the pinch_tool module is properly installed.")
+    else:
+        # Helper function to extract stream data from selection
+        def extract_stream_data(procs, sel_items):
+            """
+            Extract stream data from selected items.
+            Returns list of dicts with: CP (calculated as mdot * cp), Tin, Tout
+            """
+            result_streams = []
+            
+            for sel_key, is_sel in sel_items.items():
+                if not is_sel:
+                    continue
+                    
+                if sel_key.startswith("stream_"):
+                    parts_split = sel_key.split("_")
+                    p_idx = int(parts_split[1])
+                    s_idx = int(parts_split[2])
+                    
+                    if p_idx < len(procs):
+                        proc = procs[p_idx]
+                        proc_streams = proc.get('streams', [])
+                        
+                        if s_idx < len(proc_streams):
+                            strm = proc_streams[s_idx]
+                            
+                            # Extract values from properties/values structure
+                            props = strm.get('properties', {})
+                            vals = strm.get('values', {})
+                            
+                            tin = None
+                            tout = None
+                            mdot = None
+                            cp_val = None
+                            
+                            # Check properties dict structure
+                            if isinstance(props, dict) and isinstance(vals, dict):
+                                for pk, pname in props.items():
+                                    vk = pk.replace('prop', 'val')
+                                    v = vals.get(vk, '')
+                                    
+                                    if pname == 'Tin' and v:
+                                        try:
+                                            tin = float(v)
+                                        except (ValueError, TypeError):
+                                            pass
+                                    elif pname == 'Tout' and v:
+                                        try:
+                                            tout = float(v)
+                                        except (ValueError, TypeError):
+                                            pass
+                                    elif pname == 'ṁ' and v:
+                                        try:
+                                            mdot = float(v)
+                                        except (ValueError, TypeError):
+                                            pass
+                                    elif pname == 'cp' and v:
+                                        try:
+                                            cp_val = float(v)
+                                        except (ValueError, TypeError):
+                                            pass
+                            
+                            # Fallback to legacy fields
+                            if tin is None and strm.get('temp_in'):
+                                try:
+                                    tin = float(strm['temp_in'])
+                                except (ValueError, TypeError):
+                                    pass
+                            if tout is None and strm.get('temp_out'):
+                                try:
+                                    tout = float(strm['temp_out'])
+                                except (ValueError, TypeError):
+                                    pass
+                            if mdot is None and strm.get('mdot'):
+                                try:
+                                    mdot = float(strm['mdot'])
+                                except (ValueError, TypeError):
+                                    pass
+                            if cp_val is None and strm.get('cp'):
+                                try:
+                                    cp_val = float(strm['cp'])
+                                except (ValueError, TypeError):
+                                    pass
+                            
+                            # Calculate CP = mdot * cp
+                            if tin is not None and tout is not None and mdot is not None and cp_val is not None:
+                                CP = mdot * cp_val
+                                strm_name = strm.get('name', f'Stream {s_idx + 1}')
+                                proc_nm = proc.get('name', f'Subprocess {p_idx + 1}')
+                                result_streams.append({
+                                    'name': f"{proc_nm} - {strm_name}",
+                                    'CP': CP,
+                                    'Tin': tin,
+                                    'Tout': tout
+                                })
+            
+            return result_streams
+        
+        # Helper function to run pinch analysis
+        def run_pinch_analysis(strm_data, delta_tmin):
+            """
+            Run pinch analysis on the given stream data.
+            Returns the Pinch object with results.
+            """
+            # Create a temporary CSV file with the stream data
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False, newline='') as f:
+                writer = csv.writer(f)
+                writer.writerow(['Tmin', str(delta_tmin)])
+                writer.writerow(['CP', 'TSUPPLY', 'TTARGET'])
+                
+                for strm in strm_data:
+                    writer.writerow([strm['CP'], strm['Tin'], strm['Tout']])
+                
+                temp_csv_path = f.name
+            
+            try:
+                # Run pinch analysis without drawing (we'll draw ourselves)
+                pinch_obj = Pinch(temp_csv_path, options={})
+                pinch_obj.shiftTemperatures()
+                pinch_obj.constructTemperatureInterval()
+                pinch_obj.constructProblemTable()
+                pinch_obj.constructHeatCascade()
+                pinch_obj.constructShiftedCompositeDiagram('EN')
+                pinch_obj.constructCompositeDiagram('EN')
+                pinch_obj.constructGrandCompositeCurve('EN')
+                
+                return pinch_obj
+            finally:
+                # Clean up temp file
+                os.unlink(temp_csv_path)
+        
+        # Extract stream data from selections
+        streams_data = extract_stream_data(processes, st.session_state['selected_items'])
+        
+        if len(streams_data) < 2:
+            st.info("Select at least 2 streams with complete data (Tin, Tout, ṁ, cp) to run pinch analysis.")
+            
+            # Show what data is missing for selected streams
+            if selected_count > 0:
+                st.markdown("**Data status for selected items:**")
+                for sel_key, is_sel in st.session_state['selected_items'].items():
+                    if not is_sel:
+                        continue
+                    if sel_key.startswith("stream_"):
+                        parts_split = sel_key.split("_")
+                        p_idx = int(parts_split[1])
+                        s_idx = int(parts_split[2])
+                        
+                        if p_idx < len(processes):
+                            proc = processes[p_idx]
+                            proc_streams = proc.get('streams', [])
+                            
+                            if s_idx < len(proc_streams):
+                                strm = proc_streams[s_idx]
+                                strm_name = strm.get('name', f'Stream {s_idx + 1}')
+                                proc_nm = proc.get('name', f'Subprocess {p_idx + 1}')
+                                
+                                # Check what data is available
+                                props = strm.get('properties', {})
+                                vals = strm.get('values', {})
+                                
+                                has_tin = False
+                                has_tout = False
+                                has_mdot = False
+                                has_cp = False
+                                
+                                if isinstance(props, dict) and isinstance(vals, dict):
+                                    for pk, pname in props.items():
+                                        vk = pk.replace('prop', 'val')
+                                        v = vals.get(vk, '')
+                                        if pname == 'Tin' and v:
+                                            has_tin = True
+                                        elif pname == 'Tout' and v:
+                                            has_tout = True
+                                        elif pname == 'ṁ' and v:
+                                            has_mdot = True
+                                        elif pname == 'cp' and v:
+                                            has_cp = True
+                                
+                                # Fallback to legacy
+                                if not has_tin and strm.get('temp_in'):
+                                    has_tin = True
+                                if not has_tout and strm.get('temp_out'):
+                                    has_tout = True
+                                if not has_mdot and strm.get('mdot'):
+                                    has_mdot = True
+                                if not has_cp and strm.get('cp'):
+                                    has_cp = True
+                                
+                                missing = []
+                                if not has_tin:
+                                    missing.append("Tin")
+                                if not has_tout:
+                                    missing.append("Tout")
+                                if not has_mdot:
+                                    missing.append("ṁ")
+                                if not has_cp:
+                                    missing.append("cp")
+                                
+                                if missing:
+                                    st.warning(f"⚠️ {proc_nm} - {strm_name}: Missing {', '.join(missing)}")
+                                else:
+                                    st.success(f"✅ {proc_nm} - {strm_name}: Complete data")
+        else:
+            # Auto-run pinch analysis
+            try:
+                # Row: Shifted toggle | ΔTmin (small) | spacer | Hot Utility | Cold Utility | Pinch Temp
+                toggle_col, tmin_col, spacer, metric1, metric2, metric3 = st.columns([0.6, 0.5, 0.4, 0.7, 0.7, 0.7])
+                
+                with toggle_col:
+                    show_shifted = st.toggle("Show Shifted Composite Curves", value=False, key="shifted_toggle")
+                
+                with tmin_col:
+                    tmin = st.number_input(
+                        "ΔTmin",
+                        min_value=1.0,
+                        max_value=50.0,
+                        value=10.0,
+                        step=1.0,
+                        key="tmin_input",
+                        format="%.0f"
+                    )
+                
+                pinch = run_pinch_analysis(streams_data, tmin)
+                results = {
+                    'hot_utility': pinch.hotUtility,
+                    'cold_utility': pinch.coldUtility,
+                    'pinch_temperature': pinch.pinchTemperature,
+                    'tmin': pinch.tmin,
+                    'composite_diagram': pinch.compositeDiagram,
+                    'shifted_composite_diagram': pinch.shiftedCompositeDiagram,
+                    'grand_composite_curve': pinch.grandCompositeCurve,
+                    'heat_cascade': pinch.heatCascade,
+                    'unfeasible_heat_cascade': pinch.unfeasibleHeatCascade,
+                    'problem_table': pinch.problemTable,
+                    'temperatures': pinch._temperatures,
+                    'streams': list(pinch.streams)
+                }
+                
+                metric1.metric("Hot Utility", f"{results['hot_utility']:.2f} kW")
+                metric2.metric("Cold Utility", f"{results['cold_utility']:.2f} kW")
+                metric3.metric("Pinch Temp", f"{results['pinch_temperature']:.1f} °C")
+                
+                # Side by side plots: Composite Curves (left) and Grand Composite Curve (right)
+                plot_col1, plot_col2 = st.columns(2)
+                
+                # Build hover text for streams
+                hot_streams = [s for s in streams_data if s['Tin'] > s['Tout']]
+                cold_streams = [s for s in streams_data if s['Tin'] < s['Tout']]
+                
+                with plot_col1:
+                    fig1 = go.Figure()
+                    
+                    # Select which diagram to show
+                    if show_shifted:
+                        diagram = results['shifted_composite_diagram']
+                        curve_label = "Shifted"
+                        title_text = "Shifted Composite Curves"
+                        # For shifted, temperatures are shifted by ±Tmin/2
+                        tmin_half = results['tmin'] / 2
+                    else:
+                        diagram = results['composite_diagram']
+                        curve_label = ""
+                        title_text = "Composite Curves"
+                        tmin_half = 0
+                    
+                    # Hot composite curve with hover info
+                    hot_T = diagram['hot']['T']
+                    hot_H = diagram['hot']['H']
+                    
+                    # Create hover text for hot curve points
+                    hot_hover = []
+                    for i, (h, t) in enumerate(zip(hot_H, hot_T)):
+                        # Find streams at this temperature (adjust for shifted temps)
+                        if show_shifted:
+                            actual_t = t + tmin_half  # Convert back to actual temp
+                        else:
+                            actual_t = t
+                        matching = [s['name'] for s in hot_streams if min(s['Tin'], s['Tout']) <= actual_t <= max(s['Tin'], s['Tout'])]
+                        stream_info = '<br>'.join(matching) if matching else 'Composite'
+                        label = f"<b>Hot {curve_label}</b>" if curve_label else "<b>Hot Composite</b>"
+                        hot_hover.append(f"{label}<br>T: {t:.1f}°C<br>H: {h:.1f} kW<br>Streams: {stream_info}")
+                    
+                    fig1.add_trace(go.Scatter(
+                        x=hot_H, y=hot_T,
+                        mode='lines+markers',
+                        name='Hot',
+                        line=dict(color='red', width=2),
+                        marker=dict(size=6),
+                        hovertemplate='%{text}<extra></extra>',
+                        text=hot_hover
+                    ))
+                    
+                    # Cold composite curve with hover info
+                    cold_T = diagram['cold']['T']
+                    cold_H = diagram['cold']['H']
+                    
+                    # Create hover text for cold curve points
+                    cold_hover = []
+                    for i, (h, t) in enumerate(zip(cold_H, cold_T)):
+                        if show_shifted:
+                            actual_t = t - tmin_half  # Convert back to actual temp
+                        else:
+                            actual_t = t
+                        matching = [s['name'] for s in cold_streams if min(s['Tin'], s['Tout']) <= actual_t <= max(s['Tin'], s['Tout'])]
+                        stream_info = '<br>'.join(matching) if matching else 'Composite'
+                        label = f"<b>Cold {curve_label}</b>" if curve_label else "<b>Cold Composite</b>"
+                        cold_hover.append(f"{label}<br>T: {t:.1f}°C<br>H: {h:.1f} kW<br>Streams: {stream_info}")
+                    
+                    fig1.add_trace(go.Scatter(
+                        x=cold_H, y=cold_T,
+                        mode='lines+markers',
+                        name='Cold',
+                        line=dict(color='blue', width=2),
+                        marker=dict(size=6),
+                        hovertemplate='%{text}<extra></extra>',
+                        text=cold_hover
+                    ))
+                    
+                    # Pinch temperature line
+                    fig1.add_hline(
+                        y=results['pinch_temperature'],
+                        line_dash='dash',
+                        line_color='gray',
+                        annotation_text=f"Pinch: {results['pinch_temperature']:.1f}°C",
+                        annotation_position='top right'
+                    )
+                    
+                    fig1.update_layout(
+                        title=dict(text=title_text, font=dict(size=14)),
+                        xaxis_title='Enthalpy H (kW)',
+                        yaxis_title='Temperature T (°C)',
+                        height=400,
+                        margin=dict(l=60, r=20, t=40, b=50),
+                        legend=dict(x=0.7, y=0.1),
+                        hovermode='closest',
+                        xaxis=dict(rangemode='tozero'),
+                        yaxis=dict(rangemode='tozero')
+                    )
+                    
+                    st.plotly_chart(fig1, width='stretch', key="composite_chart")
+                
+                with plot_col2:
+                    fig2 = go.Figure()
+                    
+                    gcc_H = results['grand_composite_curve']['H']
+                    gcc_T = results['grand_composite_curve']['T']
+                    heat_cascade = results['heat_cascade']
+                    temperatures = results['temperatures']
+                    
+                    # Create hover text for GCC points
+                    gcc_hover = []
+                    for i, (h, t) in enumerate(zip(gcc_H, gcc_T)):
+                        if i < len(heat_cascade):
+                            dh = heat_cascade[i]['deltaH']
+                            region = 'Heat deficit (needs heating)' if dh > 0 else ('Heat surplus (needs cooling)' if dh < 0 else 'Balanced')
+                        else:
+                            region = ''
+                        gcc_hover.append(f"<b>GCC</b><br>Shifted T: {t:.1f}°C<br>Net ΔH: {h:.1f} kW<br>{region}")
+                    
+                    # Plot GCC with color segments
+                    for i in range(len(gcc_H) - 1):
+                        if i < len(heat_cascade):
+                            if heat_cascade[i]['deltaH'] > 0:
+                                color = 'red'
+                            elif heat_cascade[i]['deltaH'] < 0:
+                                color = 'blue'
+                            else:
+                                color = 'gray'
+                        else:
+                            color = 'gray'
+                        
+                        fig2.add_trace(go.Scatter(
+                            x=[gcc_H[i], gcc_H[i+1]],
+                            y=[gcc_T[i], gcc_T[i+1]],
+                            mode='lines+markers',
+                            line=dict(color=color, width=2),
+                            marker=dict(size=6, color=color),
+                            hovertemplate='%{text}<extra></extra>',
+                            text=[gcc_hover[i], gcc_hover[i+1] if i+1 < len(gcc_hover) else ''],
+                            showlegend=False
+                        ))
+                    
+                    # Pinch temperature line
+                    fig2.add_hline(
+                        y=results['pinch_temperature'],
+                        line_dash='dash',
+                        line_color='gray',
+                        annotation_text=f"Pinch: {results['pinch_temperature']:.1f}°C",
+                        annotation_position='top right'
+                    )
+                    
+                    # Zero enthalpy line
+                    fig2.add_vline(x=0, line_color='black', line_width=1, opacity=0.3)
+                    
+                    fig2.update_layout(
+                        title=dict(text='Grand Composite Curve', font=dict(size=14)),
+                        xaxis_title='Net ΔH (kW)',
+                        yaxis_title='Shifted Temperature (°C)',
+                        height=400,
+                        margin=dict(l=60, r=20, t=40, b=50),
+                        hovermode='closest',
+                        yaxis=dict(rangemode='tozero')
+                    )
+                    
+                    st.plotly_chart(fig2, width='stretch', key="gcc_chart")
+                
+                # More information expander
+                with st.expander("More information"):
+                    import pandas as pd
+                    
+                    
+                    temps = results['temperatures']
+                    pinch_streams = results['streams']
+                    
+                    if pinch_streams and temps:
+                        fig_interval = go.Figure()
+                        
+                        num_streams = len(pinch_streams)
+                        x_positions = [(i + 1) * 1.0 for i in range(num_streams)]
+                        
+                        # Draw horizontal temperature lines
+                        for temperature in temps:
+                            fig_interval.add_shape(
+                                type="line",
+                                x0=0, x1=num_streams + 1,
+                                y0=temperature, y1=temperature,
+                                line=dict(color="gray", width=1, dash="dot"),
+                            )
+                        
+                        # Draw pinch temperature line
+                        fig_interval.add_shape(
+                            type="line",
+                            x0=0, x1=num_streams + 1,
+                            y0=results['pinch_temperature'], y1=results['pinch_temperature'],
+                            line=dict(color="black", width=2, dash="dash"),
+                        )
+                        fig_interval.add_annotation(
+                            x=num_streams + 0.5, y=results['pinch_temperature'],
+                            text=f"Pinch: {results['pinch_temperature']:.1f}°C",
+                            showarrow=False, font=dict(size=10),
+                            xanchor='left'
+                        )
+                        
+                        # Draw stream arrows
+                        for i, stream in enumerate(pinch_streams):
+                            ss = stream['ss']  # Shifted supply temp
+                            st_temp = stream['st']  # Shifted target temp
+                            stream_type = stream['type']
+                            x_pos = x_positions[i]
+                            
+                            # Color based on stream type
+                            color = 'red' if stream_type == 'HOT' else 'blue'
+                            stream_name = streams_data[i]['name'] if i < len(streams_data) else f'Stream {i+1}'
+                            
+                            # Draw arrow as a line with annotation for arrowhead
+                            fig_interval.add_trace(go.Scatter(
+                                x=[x_pos, x_pos],
+                                y=[ss, st_temp],
+                                mode='lines',
+                                line=dict(color=color, width=8),
+                                hovertemplate=f"<b>{stream_name}</b><br>" +
+                                             f"Type: {stream_type}<br>" +
+                                             f"T_supply (shifted): {ss:.1f}°C<br>" +
+                                             f"T_target (shifted): {st_temp:.1f}°C<br>" +
+                                             f"CP: {stream['cp']:.2f} kW/K<extra></extra>",
+                                showlegend=False
+                            ))
+                            
+                            # Add arrowhead
+                            fig_interval.add_annotation(
+                                x=x_pos, y=st_temp,
+                                ax=x_pos, ay=ss,
+                                xref='x', yref='y',
+                                axref='x', ayref='y',
+                                showarrow=True,
+                                arrowhead=2,
+                                arrowsize=1.5,
+                                arrowwidth=3,
+                                arrowcolor=color
+                            )
+                            
+                            # Stream label at top
+                            label_y = max(ss, st_temp) + (max(temps) - min(temps)) * 0.03
+                            fig_interval.add_annotation(
+                                x=x_pos, y=label_y,
+                                text=f"<b>S{i+1}</b>",
+                                showarrow=False,
+                                font=dict(size=11, color='white'),
+                                bgcolor=color,
+                                bordercolor='black',
+                                borderwidth=1,
+                                borderpad=3
+                            )
+                            
+                            # CP value in middle
+                            mid_y = (ss + st_temp) / 2
+                            fig_interval.add_annotation(
+                                x=x_pos, y=mid_y,
+                                text=f"CP={stream['cp']:.1f}",
+                                showarrow=False,
+                                font=dict(size=9, color='white'),
+                                textangle=-90
+                            )
+                        
+                        fig_interval.update_layout(
+                            title=dict(text='Shifted Temperature Interval Diagram', font=dict(size=14)),
+                            xaxis=dict(
+                                title='Streams',
+                                showticklabels=False,
+                                range=[0, num_streams + 1],
+                                showgrid=False
+                            ),
+                            yaxis=dict(
+                                title='Shifted Temperature S (°C)',
+                                showgrid=True,
+                                gridcolor='rgba(0,0,0,0.1)'
+                            ),
+                            height=400,
+                            margin=dict(l=60, r=20, t=40, b=40),
+                            hovermode='closest',
+                            showlegend=False
+                        )
+                        
+                        st.plotly_chart(fig_interval, width='stretch', key="interval_chart")
+                    
+                    st.markdown("---")
+                    
+                    # Problem Table
+                    st.markdown("##### Problem Table")
+                    if results['problem_table']:
+                        problem_df = pd.DataFrame(results['problem_table'])
+                        # Rename columns for clarity
+                        col_rename = {
+                            'T': 'T (°C)',
+                            'deltaT': 'ΔT (°C)',
+                            'cpHot': 'ΣCP Hot (kW/K)',
+                            'cpCold': 'ΣCP Cold (kW/K)',
+                            'deltaCp': 'ΔCP (kW/K)',
+                            'deltaH': 'ΔH (kW)'
+                        }
+                        problem_df = problem_df.rename(columns={k: v for k, v in col_rename.items() if k in problem_df.columns})
+                        st.dataframe(problem_df, width='stretch', hide_index=True)
+                    else:
+                        st.info("No problem table data available")
+                    
+                    # Heat Cascades side by side
+                    cascade_col1, cascade_col2 = st.columns(2)
+                    
+                    with cascade_col1:
+                        st.markdown("##### Unfeasible Heat Cascade")
+                        if results['unfeasible_heat_cascade']:
+                            # Add temperature column to dataframe
+                            unfeasible_data = []
+                            for i, item in enumerate(results['unfeasible_heat_cascade']):
+                                row = {'T (°C)': temps[i+1] if i+1 < len(temps) else '', 
+                                       'ΔH (kW)': item['deltaH'], 
+                                       'Cascade (kW)': item['exitH']}
+                                unfeasible_data.append(row)
+                            unfeasible_df = pd.DataFrame(unfeasible_data)
+                            st.dataframe(unfeasible_df, width='stretch', hide_index=True)
+                        else:
+                            st.info("No unfeasible cascade data")
+                    
+                    with cascade_col2:
+                        st.markdown("##### Feasible Heat Cascade")
+                        if results['heat_cascade']:
+                            # Add temperature column to dataframe
+                            feasible_data = []
+                            for i, item in enumerate(results['heat_cascade']):
+                                row = {'T (°C)': temps[i+1] if i+1 < len(temps) else '', 
+                                       'ΔH (kW)': item['deltaH'], 
+                                       'Cascade (kW)': item['exitH']}
+                                feasible_data.append(row)
+                            feasible_df = pd.DataFrame(feasible_data)
+                            st.dataframe(feasible_df, width='stretch', hide_index=True)
+                        else:
+                            st.info("No feasible cascade data")
+                
+            except Exception as e:
+                st.error(f"Error: {str(e)}")

src/process_models.json

@@ -0,0 +1,26 @@
+{
+  "Drying": {
+    "Spray drying": ["milk powder", "coffee powder", "egg powder"],
+    "Granular drying": ["grain", "sand", "plastic granules"],
+    "Tunnel drying": ["fruits", "vegetables", "ceramics"],
+    "Contact drying": ["paper", "food", "wood"],
+    "Freeze drying": ["coffee extract", "fruit extract"]
+  },
+  "Autoclaving": {
+    "Sterilization": ["canned food", "medical tools"],
+    "Hardening": ["vulcanization of rubber"]
+  },
+  "Thermal activation solid products": {
+    "Boiling small scale": ["canned food", "vegetables"],
+    "Boiling large scale": ["specialty chemicals", "food"]
+  },
+  "Thermal activation fluid products": {
+    "Continuous bath heating": ["boiling vegetables", "pasteurization"],
+    "Continuous heating of fluid": ["alcohol chemical conversion", "milk pasteurization"]
+  },
+  "Thermal separation": {
+    "Distillation": ["alcohol chemical conversion", "specialty chemicals"],
+    "Evaporation": ["fruit juice", "milk"],
+    "Shipping": ["sugar syrup"]
+  }
+}

src/process_utils.py

@@ -0,0 +1,436 @@
+import pandas as pd
+import io
+import copy
+from typing import List, Dict, Tuple, Optional, Any, Generator
+
+def init_process_state(session_state):
+    if 'processes' not in session_state:
+        session_state['processes'] = []  # list of proc dicts
+    if 'selected_process_idx' not in session_state:
+        session_state['selected_process_idx'] = None
+
+REQUIRED_PROC_COLS = {"name","next","conntemp","product_tout","connm","conncp","stream_no","mdot","temp_in","temp_out","cp"}
+
+# Level names for different hierarchy depths
+LEVEL_NAMES = {
+    0: 'Process',
+    1: 'Subprocess', 
+    2: 'Sub-subprocess',
+    3: 'Sub-sub-subprocess',
+    4: 'Sub-sub-sub-subprocess'
+}
+
+def get_level_name(level: int) -> str:
+    """Get the display name for a hierarchy level."""
+    return LEVEL_NAMES.get(level, f'Level-{level} Process')
+
+
+def create_stream(name: str = '', stream_type: str = 'product') -> Dict[str, Any]:
+    """
+    Create a new stream with consistent structure.
+    This is the reusable function for creating streams at any level.
+    
+    Args:
+        name: Name of the stream
+        stream_type: Type of stream (product, steam, air, water)
+    
+    Returns:
+        A dict representing the stream with all standard fields
+    """
+    return {
+        'name': name,
+        'type': stream_type,
+        'properties': {
+            'prop1': 'Tin',
+            'prop2': 'Tout',
+            'prop3': 'ṁ',
+            'prop4': 'cp'
+        },
+        'values': {
+            'val1': '',
+            'val2': '',
+            'val3': '',
+            'val4': ''
+        },
+        # Legacy fields for backward compatibility
+        'mdot': '',
+        'temp_in': '',
+        'temp_out': '',
+        'cp': ''
+    }
+
+
+def create_process_node(name: str = '', level: int = 0) -> Dict[str, Any]:
+    """
+    Create a new process/subprocess/sub-subprocess node with a consistent structure.
+    This is a REUSABLE function that creates nodes at ANY hierarchy level.
+    
+    The same structure is used for:
+    - Processes (level 0)
+    - Subprocesses (level 1)
+    - Sub-subprocesses (level 2)
+    - And so on...
+    
+    Args:
+        name: Name of the process node
+        level: Hierarchy level (0=process, 1=subprocess, 2=sub-subprocess, etc.)
+    
+    Returns:
+        A dict representing the process node with all standard fields
+    """
+    return {
+        'name': name or f'{get_level_name(level)} 1',
+        'level': level,
+        'next': '',
+        'conntemp': '',      # Product Tin
+        'product_tout': '',  # Product Tout
+        'connm': '',         # Product ṁ
+        'conncp': '',        # Product cp
+        'streams': [],
+        'children': [],      # Sub-nodes (subprocesses, sub-subprocesses, etc.) - RECURSIVE!
+        'lat': None,
+        'lon': None,
+        'box_scale': 1.0 if level > 0 else 1.5,
+        'extra_info': {
+            'air_tin': '',
+            'air_tout': '',
+            'air_mdot': '',
+            'air_cp': '',
+            'water_content_in': '',
+            'water_content_out': '',
+            'density': '',
+            'pressure': '',
+            'notes': ''
+        },
+        'expanded': False,       # UI state: whether this node is expanded
+        'info_expanded': False,  # UI state: whether info section is expanded
+        'model': {'level1': None, 'level2': None},  # Process model selection
+        'params': {  # Process parameters
+            'tin': '', 'tout': '', 'time': '', 'cp': '',
+            'mass_flow': None, 'thermal_power': None
+        },
+        'params_requested': False,
+        'hours': ''  # Operating hours
+    }
+
+
+def add_child_to_node(parent_node: Dict[str, Any], child_name: str = '') -> Dict[str, Any]:
+    """
+    Add a child node (subprocess/sub-subprocess/etc.) to a parent node.
+    This works recursively at ANY level - the same function is used to:
+    - Add subprocess to process
+    - Add sub-subprocess to subprocess
+    - Add sub-sub-subprocess to sub-subprocess
+    - etc.
+    
+    Args:
+        parent_node: The parent process node to add a child to
+        child_name: Optional name for the child
+    
+    Returns:
+        The newly created child node
+    """
+    if 'children' not in parent_node:
+        parent_node['children'] = []
+    
+    parent_level = parent_node.get('level', 0)
+    child_level = parent_level + 1
+    child_index = len(parent_node['children'])
+    
+    default_name = f"{get_level_name(child_level)} {child_index + 1}"
+    
+    child_node = create_process_node(
+        name=child_name or default_name,
+        level=child_level
+    )
+    
+    parent_node['children'].append(child_node)
+    return child_node
+
+
+def delete_child_from_node(parent_node: Dict[str, Any], child_index: int) -> bool:
+    """
+    Delete a child node from a parent node by index.
+    Works at any hierarchy level.
+    
+    Args:
+        parent_node: The parent process node
+        child_index: Index of the child to delete
+    
+    Returns:
+        True if successful, False otherwise
+    """
+    if 'children' not in parent_node:
+        return False
+    
+    children = parent_node['children']
+    if 0 <= child_index < len(children):
+        children.pop(child_index)
+        return True
+    return False
+
+
+def add_stream_to_node(node: Dict[str, Any], stream_name: str = '') -> Dict[str, Any]:
+    """
+    Add a stream to ANY process node (process, subprocess, sub-subprocess, etc.).
+    This is the REUSABLE function for adding streams at any level.
+    
+    Args:
+        node: The process node to add a stream to
+        stream_name: Optional name for the stream
+    
+    Returns:
+        The newly created stream
+    """
+    if 'streams' not in node:
+        node['streams'] = []
+    
+    stream_count = len(node['streams'])
+    stream = create_stream(
+        name=stream_name or f'Stream {stream_count + 1}',
+        stream_type='product'
+    )
+    node['streams'].append(stream)
+    return stream
+
+
+def delete_stream_from_node(node: Dict[str, Any], stream_index: int) -> bool:
+    """
+    Delete a stream from ANY process node.
+    This is the REUSABLE function for deleting streams at any level.
+    
+    Args:
+        node: The process node
+        stream_index: Index of the stream to delete
+    
+    Returns:
+        True if successful, False otherwise
+    """
+    if 'streams' not in node:
+        return False
+    
+    streams = node['streams']
+    if 0 <= stream_index < len(streams):
+        streams.pop(stream_index)
+        return True
+    return False
+
+
+def iterate_all_nodes(nodes: List[Dict[str, Any]]) -> Generator[Tuple[Dict[str, Any], int, List[int]], None, None]:
+    """
+    Generator that yields all nodes in a tree structure (depth-first).
+    Useful for operations that need to traverse the entire hierarchy.
+    
+    Args:
+        nodes: List of root nodes
+    
+    Yields:
+        Tuples of (node, level, path_indices)
+        - node: The process node
+        - level: Hierarchy level (0=process, 1=subprocess, etc.)
+        - path_indices: List of indices from root to this node, e.g., [0, 2, 1]
+    """
+    def _iterate(node_list: List[Dict], level: int, path: List[int]):
+        for i, node in enumerate(node_list):
+            current_path = path + [i]
+            yield node, level, current_path
+            # Recurse into children
+            children = node.get('children', [])
+            if children:
+                yield from _iterate(children, level + 1, current_path)
+    
+    yield from _iterate(nodes, 0, [])
+
+
+def get_node_by_path(root_nodes: List[Dict[str, Any]], path: List[int]) -> Optional[Dict[str, Any]]:
+    """
+    Get a node by its path indices (e.g., [0, 1, 2] means process 0, child 1, grandchild 2).
+    
+    Args:
+        root_nodes: List of root process nodes
+        path: List of indices forming the path to the node
+    
+    Returns:
+        The node if found, None otherwise
+    """
+    if not path or path[0] >= len(root_nodes):
+        return None
+    
+    current = root_nodes[path[0]]
+    
+    for idx in path[1:]:
+        children = current.get('children', [])
+        if idx >= len(children):
+            return None
+        current = children[idx]
+    
+    return current
+
+
+def copy_streams_to_all_descendants(parent_node: Dict[str, Any]):
+    """
+    Copy streams from a parent node to ALL its descendants (children, grandchildren, etc.).
+    This implements the requirement that changing streams should propagate to all descendants.
+    
+    Args:
+        parent_node: The parent node whose streams to copy to all descendants
+    """
+    parent_streams = parent_node.get('streams', [])
+    
+    def _copy_recursive(node: Dict[str, Any]):
+        children = node.get('children', [])
+        for child in children:
+            # Deep copy the streams to child
+            child['streams'] = copy.deepcopy(parent_streams)
+            # Recurse to grandchildren
+            _copy_recursive(child)
+    
+    _copy_recursive(parent_node)
+
+
+def sync_node_with_parent(child_node: Dict[str, Any], parent_node: Dict[str, Any], 
+                          sync_streams: bool = True, sync_info: bool = False):
+    """
+    Sync data from parent to a specific child node.
+    
+    Args:
+        child_node: The child node to update
+        parent_node: The parent node to copy from
+        sync_streams: Whether to sync streams
+        sync_info: Whether to sync extra_info fields
+    """
+    if sync_streams:
+        child_node['streams'] = copy.deepcopy(parent_node.get('streams', []))
+    
+    if sync_info:
+        child_node['extra_info'] = copy.deepcopy(parent_node.get('extra_info', {}))
+
+
+def count_all_descendants(node: Dict[str, Any]) -> int:
+    """
+    Count all descendants (children, grandchildren, etc.) of a node.
+    
+    Args:
+        node: The node to count descendants for
+    
+    Returns:
+        Total number of descendants
+    """
+    count = 0
+    children = node.get('children', [])
+    count += len(children)
+    for child in children:
+        count += count_all_descendants(child)
+    return count
+
+
+# =============================================================================
+# LEGACY FUNCTIONS - Keep for backward compatibility with existing code
+# =============================================================================
+
+def parse_process_csv_file(uploaded_file) -> Tuple[Optional[list], str]:
+    if uploaded_file is None:
+        return None, "No file provided"
+    try:
+        content = uploaded_file.read()
+        text = content.decode('utf-8')
+        df = pd.read_csv(io.StringIO(text))
+        if not REQUIRED_PROC_COLS.issubset(df.columns):
+            return None, "CSV missing required columns"
+        procs = []
+        proc_lookup = {}
+        for _, row in df.iterrows():
+            # Include product_tout in key for uniqueness if present
+            key = (row['name'], row['next'], row['conntemp'], row.get('product_tout',''), row['connm'], row['conncp'])
+            if key not in proc_lookup:
+                p = {
+                    "name": row.get('name',''),
+                    "next": row.get('next',''),
+                    "conntemp": row.get('conntemp',''),  # Product Tin
+                    "product_tout": row.get('product_tout',''),  # P Tout
+                    "connm": row.get('connm',''),  # P ṁ
+                    "conncp": row.get('conncp',''),  # P cp
+                    "streams": [],
+                    "children": [],  # Support for sub-levels
+                    "lat": row.get('lat') if 'lat' in df.columns else None,
+                    "lon": row.get('lon') if 'lon' in df.columns else None,
+                }
+                procs.append(p)
+                proc_lookup[key] = p
+            stream_no = row.get('stream_no')
+            if pd.notna(stream_no):
+                proc_lookup[key]['streams'].append({
+                    "mdot": row.get('mdot',''),
+                    "temp_in": row.get('temp_in',''),
+                    "temp_out": row.get('temp_out',''),
+                    "cp": row.get('cp',''),
+                })
+        return procs, f"Loaded {len(procs)} processes"
+    except (UnicodeDecodeError, OSError, ValueError) as e:
+        return None, f"Failed: {e}"
+
+def processes_to_csv_bytes(processes: List[Dict]) -> bytes:
+    """Export processes to CSV, including nested children."""
+    rows = []
+    
+    def _add_process_rows(p: Dict, parent_name: str = ''):
+        """Recursively add rows for a process and its children."""
+        proc_name = p.get('name', '')
+        full_name = f"{parent_name} > {proc_name}" if parent_name else proc_name
+        
+        if not p.get('streams'):
+            rows.append({
+                'name': full_name, 'next': p.get('next',''), 'conntemp': p.get('conntemp',''), 
+                'product_tout': p.get('product_tout',''),
+                'connm': p.get('connm',''), 'conncp': p.get('conncp',''), 'stream_no': '', 
+                'mdot':'','temp_in':'','temp_out':'','cp':'',
+                'lat': p.get('lat'), 'lon': p.get('lon'),
+                'level': p.get('level', 0)
+            })
+        else:
+            for idx, s in enumerate(p['streams'], start=1):
+                rows.append({
+                    'name': full_name, 'next': p.get('next',''), 'conntemp': p.get('conntemp',''), 
+                    'product_tout': p.get('product_tout',''),
+                    'connm': p.get('connm',''), 'conncp': p.get('conncp',''), 'stream_no': idx,
+                    'mdot': s.get('mdot',''), 'temp_in': s.get('temp_in',''), 
+                    'temp_out': s.get('temp_out',''), 'cp': s.get('cp',''),
+                    'lat': p.get('lat'), 'lon': p.get('lon'),
+                    'level': p.get('level', 0)
+                })
+        
+        # Recurse into children
+        for child in p.get('children', []):
+            _add_process_rows(child, full_name)
+    
+    for p in processes:
+        _add_process_rows(p)
+    
+    df = pd.DataFrame(rows)
+    buf = io.StringIO()
+    df.to_csv(buf, index=False)
+    return buf.getvalue().encode('utf-8')
+
+def add_process(session_state):
+    """Legacy function - adds a subprocess to the flat processes list."""
+    new_proc = create_process_node(level=1)  # Level 1 for subprocess
+    new_proc['name'] = ''  # Let UI set the name
+    session_state['processes'].append(new_proc)
+    session_state['selected_process_idx'] = len(session_state['processes'])-1
+
+def delete_process(session_state, idx):
+    """Legacy function - deletes a subprocess from the flat processes list."""
+    if 0 <= idx < len(session_state['processes']):
+        session_state['processes'].pop(idx)
+        if session_state['selected_process_idx'] == idx:
+            session_state['selected_process_idx'] = None
+
+def add_stream_to_process(session_state, pidx):
+    """Legacy function - adds a stream to a subprocess in the flat list."""
+    if 0 <= pidx < len(session_state['processes']):
+        add_stream_to_node(session_state['processes'][pidx])
+
+def delete_stream_from_process(session_state, pidx, sidx):
+    """Legacy function - deletes a stream from a subprocess in the flat list."""
+    if 0 <= pidx < len(session_state['processes']):
+        delete_stream_from_node(session_state['processes'][pidx], sidx)

src/requirements.txt

@@ -0,0 +1,110 @@
+altair==5.5.0
+annotated-types==0.7.0
+appnope==0.1.4
+asttokens==3.0.1
+attrs==25.3.0
+blinker==1.9.0
+branca==0.8.1
+cachetools==6.2.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
+click==8.2.1
+comm==0.2.3
+contourpy==1.3.3
+CoolProp==7.2.0
+cycler==0.12.1
+dacite==1.9.2
+debugpy==1.8.17
+decorator==5.2.1
+executing==2.2.1
+filetype==1.2.0
+folium==0.20.0
+fonttools==4.61.0
+gitdb==4.0.12
+GitPython==3.1.45
+idna==3.10
+ImageHash==4.3.2
+importlib_metadata==8.7.0
+ipykernel==7.1.0
+ipython==9.7.0
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+Jinja2==3.1.6
+joblib==1.5.2
+jsonschema==4.25.1
+jsonschema-specifications==2025.9.1
+jupyter_client==8.6.3
+jupyter_core==5.9.1
+kiwisolver==1.4.9
+llvmlite==0.45.1
+MarkupSafe==3.0.2
+matplotlib==3.10.0
+matplotlib-inline==0.2.1
+minify_html==0.18.1
+multimethod==1.12
+narwhals==2.4.0
+nest_asyncio==1.6.0
+networkx==3.6
+numba==0.62.1
+numpy==2.3.2
+packaging==25.0
+pandas==2.3.2
+parso==0.8.5
+patsy==1.0.2
+pexpect==4.9.0
+phik==0.12.5
+pillow==11.3.0
+pip==25.2
+platformdirs==4.5.0
+plotly==6.5.0
+prompt_toolkit==3.0.52
+protobuf==6.32.0
+psutil==7.1.3
+ptyprocess==0.7.0
+pure_eval==0.2.3
+puremagic==1.30
+pyarrow==21.0.0
+pydantic==2.12.5
+pydantic_core==2.41.5
+pydeck==0.9.1
+Pygments==2.19.2
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyWavelets==1.9.0
+PyYAML==6.0.3
+pyzmq==27.1.0
+referencing==0.36.2
+reportlab==4.4.5
+requests==2.32.5
+rpds-py==0.27.1
+scipy==1.16.3
+seaborn==0.13.2
+setuptools==78.1.1
+six==1.17.0
+smmap==5.0.2
+stack_data==0.6.3
+staticmap==0.5.7
+statsmodels==0.14.5
+streamlit==1.52.1
+streamlit-folium==0.25.1
+streamlit-image-coordinates==0.4.0
+tabulate==0.9.0
+tenacity==9.1.2
+toml==0.10.2
+tornado==6.5.2
+tqdm==4.67.1
+traitlets==5.14.3
+typeguard==4.4.4
+typing_extensions==4.15.0
+typing-inspection==0.4.2
+tzdata==2025.2
+urllib3==2.5.0
+visions==0.8.1
+watchdog==6.0.0
+wcwidth==0.2.14
+wheel==0.45.1
+wordcloud==1.9.4
+xyzservices==2025.4.0
+ydata-profiling==4.18.0
+zipp==3.23.0

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))