new modules

pinch_tool/HPI_main.py

@@ -1,4 +1,4 @@
-from Pinch_main import Pinchmain
+from Modules.Pinch_main import Pinchmain
 from Modules.HeatPumpIntegration.HeatPumpIntegration import HeatPumpIntegration as HPI
 import matplotlib.pyplot as plt
 

pinch_tool/ISSP_main.py

@@ -1,4 +1,4 @@
-from Pinch_main import Pinchmain
+from Modules.Pinch_main import Pinchmain
 from Modules.ISSP.ISSP import ISSP
 from Modules.HeatPumpIntegration.HeatPumpIntegration import HeatPumpIntegration as HPI
 import matplotlib.pyplot as plt

pinch_tool/Modules/TotalSiteProfile/TotalSiteProfile.py

@@ -1,4 +1,4 @@
-from Pinch_main import Pinchmain as Pinch
+from Modules.Pinch_main import Pinchmain as Pinch
 import csv
 import ast
 from Modules.TotalSiteProfile.TSPPlot import TSPPlot

src/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)')

src/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()
+

src/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)

src/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)
+

src/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]])
+

src/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()

src/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)

src/Modules/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()

src/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()

src/Modules/TotalSiteProfile/TotalSiteProfile.py

@@ -0,0 +1,222 @@
+from Modules.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)
+        

src/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

src/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
+        

src/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

src/pages/potential_analysis.py

@@ -10,16 +10,16 @@ from PIL import Image, ImageDraw, ImageFont
 from graphics_utils import draw_smooth_ellipse
 from datetime import datetime
 
-# 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)
+# # Add the src directory to the path for imports
+# src_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+# if src_path not in sys.path:
+#     sys.path.insert(0, src_path)
 
 # Import pinch analysis modules
 try:
     from Modules.Pinch.Pinch import Pinch
     from Modules.HeatPumpIntegration.HeatPumpIntegration import HeatPumpIntegration as HPI
-    from Pinch_main import Pinchmain
+    from Modules.Pinch_main import Pinchmain
     PINCH_AVAILABLE = True
     PINCH_IMPORT_ERROR = None
 except ImportError as e: