class GEF: def __init__(self, CSV_PATH_NAME, ): self.VS_D_DENSITY = np.array([]) # numpy array self.STAGE_COUNT = 3 # Endwert der Anpassung für die Trennstufe self.PATH_CSV = CSV_PATH_NAME # PATH from class eingabe erfolgt bei Aufruf der Klasse self.Name_CSV = 'Berechnet.csv' # Name der Ergebnis CSV # Ab hier werden die Funktionen aufgerufen self.DATA_READ = self.GEF_Reader(self.PATH_CSV)# liest den Parameter ein self.GEF_FUNCTION_EXPERIMENT = self.GEF_Maker_EXP(self.DATA_READ)#nur Typ Änderung self.velo_config = self.Velo_size_config(self.DATA_READ) self.V_DOT_QOU_FIX = self.v_dot_exp(self.DATA_READ) self.main_gef(self.GEF_FUNCTION_EXPERIMENT, self.velo_config, self.V_DOT_QOU_FIX) def GEF_Reader(self, path): path_velo = pl.WindowsPath(path) # Aus dem Text wird ein Windows-Dateipfad oi = os.path.splitext(path_velo) # Teilen des Windows-Dateipfad, damit ein csv_check = False # Festlegung des Switches als False, damit bei falscher Dateiendung nichts eingelesen wird if oi[1] == '.csv': csv_check = True if os.path.exists(path_velo) & csv_check: data_velo_pd = pd.read_csv(path_velo, sep=';') # decimal=','Umstellen auf deutsche Excel, sollten csv mit , als Dezimalstelle verwendet werden, dann decimal=',' eingeben. #Die erste Zeile wird als Header eingelesen und fällt in der Zählung der Matrix "weg" return ( data_velo_pd) # Gibt eingelesene pandas-Datenframe zurück (Wäre auch mit einer Matrixlösung möglich) def GEF_Maker_EXP(self, data_velo_pd): data_velo_pd.iloc[4:20, 1:11] = data_velo_pd.iloc[4:20, 1:11].astype('float64') return data_velo_pd.iloc[4:20, 1:11] def Velo_size_config(self,data_velo_pd): data_velo_pd.iloc[4:20, 0] = data_velo_pd.iloc[4:20, 0].astype('float64') return data_velo_pd.iloc[4:20, 0].to_list() # Vorsicht bei Fishhook über 50 Prozent def v_dot_exp(self, data_velo_pd): data_velo_pd.iloc[0, 1:11] = data_velo_pd.iloc[0 , 1:11].astype('float64') return data_velo_pd.iloc[0, 1:11] def main_gef(self, gef_function, velo_den_siz_config_normal, v_dot_qou_exp): for name in gef_function.columns: t50_normal_velo = self.t50_calc(velo_den_siz_config_normal, gef_function[name]) (vs_d_density_data_calc, stage_count, r2fitting, v_dot_qou, velo_den_siz_config, x_achse_fein) = self.grade_efficiency_function_fitting( gef_function[name].to_list(), t50_normal_velo, velo_den_siz_config_normal, v_dot_qou_exp[name]) # Zur übersichtlichkeit wurden die Matrixen(Data-Frames getrennt) erstellt. # Eine Matrix wird anschließend mit concat erstellt. pd_data_Modell = pd.DataFrame( {'Sinkgeschwindigkeit des Modells': x_achse_fein, 'Modellierte Funktion': vs_d_density_data_calc}) pd_data_Modell_3_5 = pd.DataFrame( {'Sinkgeschwindigkeit des Modells (Trennstufe 3)': self.dummyfun(t50_normal_velo, x_achse_fein, v_dot_qou, 3.0), 'Sinkgeschwindigkeit des Modells (Trennstufe 5)': self.dummyfun(t50_normal_velo, x_achse_fein, v_dot_qou, 5.0)}) pd_Data_Exp= pd.DataFrame({ 'Sinkgeschwindigkeit': velo_den_siz_config_normal, 'Trennfunktion': gef_function[name]}) pd_data_Modellparameters = pd.DataFrame( {'Modellierte Trennstufe': [stage_count], 'Volumenqoutient': [v_dot_qou_exp[name]], 'X50':t50_normal_velo},) pd_data_out = pd.concat([pd_data_Modell, pd_data_Modell_3_5,pd_Data_Exp,pd_data_Modellparameters], axis=1) pd_data_out.to_csv((os.path.join("Ergebnisse mit Anpassung der Funktion/", name+'Output.csv')), sep=';', decimal=',', ) def grade_efficiency_function_fitting(self, experimentell_data_gef, VS_D_DENSITY_T50, velo_den_siz_config, v_dot_qou): stage_count_eff = np.arange(1, self.STAGE_COUNT, 0.1) # Reihen des Numpy-arrays wird aufgerufen Warnung matrix_square = np.array([[0, 0, 0]]) # Fitting Ergebnis model_range_calc = [] # checking for nan in experimentell data for nan_find in range(0, len(experimentell_data_gef)): if not np.isnan(experimentell_data_gef[nan_find]): model_range_calc.append(velo_den_siz_config[nan_find]) vs_d_density_data_calc = np.array([]) #for PAR_QOU in v_dot_qou: for PAR in stage_count_eff: for PARI in model_range_calc: vs_d_density_data_calc = np.append(vs_d_density_data_calc, self.grade_efficiency_function(v_dot_qou, VS_D_DENSITY_T50, PARI, PAR)) new = 1 / len(experimentell_data_gef) * np.sum( np.power( vs_d_density_data_calc - experimentell_data_gef[:len(model_range_calc)], 2)) matrix_square = np.append(matrix_square, [[new, v_dot_qou, PAR]], axis=0) # wichtig ist axis, da ansonsten ein array entsteht vs_d_density_data_calc = np.delete(vs_d_density_data_calc, range(len(vs_d_density_data_calc))) #vs_d_density_data_calc = np.delete(vs_d_density_data_calc, range(len(vs_d_density_data_calc))) matrix_square = np.delete(matrix_square, 0, 0) # Weil ich null als Ausgangslage definiert habe / geht minimal_fit = np.argmin(matrix_square, axis=0) stage_count = matrix_square[minimal_fit[0], 2] h_fitting = matrix_square[minimal_fit[0], 0] #v_dot_qou = matrix_square[minimal_fit[0], 1]#bei einem Parameter unnötig feinfitting = np.arange(min(model_range_calc), max(model_range_calc), 0.1) for PARI in feinfitting: # Erste Spalte spezifischen Daten /zweite Spalte die kumulierte Häufigkeit # (NICHT IN PROZENT) # PAR_QOU ersetzt self.V_DOT_QOU vs_d_density_data_calc = np.append(vs_d_density_data_calc, self.grade_efficiency_function(v_dot_qou, VS_D_DENSITY_T50, PARI, stage_count)) '''Vorsicht! Eingabe Maske!!!''' return vs_d_density_data_calc, stage_count, h_fitting, v_dot_qou, model_range_calc, feinfitting def grade_efficiency_function(self, v_dot_qou, vs_d_density_t50, experimentell_data_vs_d_density, stage_count): alpha_turbo_par = 1 grade_efficiency_function_value = 1 / (1 + v_dot_qou ** ((1 - (experimentell_data_vs_d_density / vs_d_density_t50) ** alpha_turbo_par) * stage_count)) return grade_efficiency_function_value def t50_calc(self, velo_den_siz_config, sum_curve_exp_data_vs_d_density): VS_D_DENSITY_T50 = np.interp(0.5, sum_curve_exp_data_vs_d_density, velo_den_siz_config) return VS_D_DENSITY_T50 def dummyfun(self, vs_d_density_t50, velo_den_siz_config, PAR_QOU, dummystage): vs_d_density_data_calc = np.array([]) for PARI in velo_den_siz_config: vs_d_density_data_calc = np.append(vs_d_density_data_calc, self.grade_efficiency_function(PAR_QOU, vs_d_density_t50, PARI, dummystage)) return vs_d_density_data_calc if __name__ == "__main__": import numpy as np import pandas as pd import pathlib as pl import os as os GEF('Trennfunktion_Veröffentlichung_Verbesserung_Tesla.csv')