def _cut_flame(flame, x_cut=0): """ Create a new "cutted" flame removing the points before x_cut. The grid is shifted and a final point added to have the same mesh extension of the original flame. Parameters ---------- flame: pyFLUT.Flame1D Original flame solution x_cut: float Value of the grid to cut Returns ------- pyFLUT.Flame1D """ # FIXME: define if including the last point with T=T0 data = flame.data[flame['X'] > x_cut, :] cutted_flame = pyFLUT.Flame1D(data=data, input_var='X', output_dict=flame.output_dict, variables=flame.variables) cutted_flame['X'] = cutted_flame['X'] - cutted_flame['X'][0] return cutted_flame.extend_length(flame['X'][-1])
def get_equilibrium(fuel, oxidizer, variables, P, mechanism, Z): """ Estimate equilibrium solution for the given fuel and oxidizer """ eq = pyFLUT.equilibrium.EquilibriumSolution(fuel=fuel, oxidizer=oxidizer, pressure=P, mechanism=mechanism, Z=Z) Zmin = z_from_phi(0.1, eq.Z_st) Zmax = z_from_phi(3, eq.Z_st) eq.calc_equilibrium(Zmin=Zmin, Zmax=Zmax) get_equilibrium._log.debug('var=%s Zmin=%s Zmax=%s, T_fuel=%s - %s', variables, Zmin, Zmax, eq['T'][-1], fuel['T']) return pyFLUT.Flame1D(data=eq.data, output_dict=eq.output_dict, input_var='Z', variables=variables)
def _search_closeset_solution(self, res, results): def is_similar(res0, res1): if res0.variables == res1.variables: return False else: return all( res0.variables[p] == res1.variables[p] if p != 'velratio' else res0.variables[p] > res1.variables[p] for p in self._parameter_names) similar_results = [ r for r in results if r.variables if is_similar(r, res) ] closest_res = sorted(similar_results, key=lambda r: r.variables['velratio'])[0] self.__log.debug('closest is %', closest_res.variables['velratio']) return pyFLUT.Flame1D(data=closest_res.data, output_dict=closest_res.output_dict, variables=res.variables)
def _flame_from_init(self, basename_calc, parameters): """ Create a flame solution from ULF init """ res_init = pyFLUT.Flame1D.read_ulf(basename_calc + 'init.ulf') data = np.empty((2, len(res_init.output_variables))) data[0] = res_init.data[0] data[-1] = res_init.data[0] data[-1, res_init.output_dict['X']] = res_init['X'][-1] res = pyFLUT.Flame1D( data=data, output_dict=res_init.output_variables, variables={ par: value for par, value in zip(self._parameter_names, parameters) }) res['deltah'] = 0 # dump the file res.write_ascii(self.basename + self.create_label(parameters) + '.ulf') return res
def assemble_data(self, results, n_p=1): ''' Assemble flame1D ulf files to FLUT Parameters ---------- results: list(ulf.UlfData) list of ulf.UlfData solutions with variables ['Hnorm', 'chist', 'Y' ''' toRm = [] numberOfResults = len(results) print("numberOfResults: {}\n".format(numberOfResults)) for idx in range(0, numberOfResults): #print("Start:\nX[{}]: min {}, max {}".format(idx,results[idx]['X'].min(),results[idx]['X'].max())) r = results[idx] T = r['T'] if (T[0] >= T[-1]): print("remove case {}: {}".format(idx, r.variables)) toRm.append(idx) #del results[idx] if not r.output_dict.has_key('deltah'): #work on fp setups print("case {} has no deltah: {}".format(idx, r.variables)) results[idx]['deltah'] = 0.0 * results[idx]['X'] if r.data[0][0] < 0.0: #remove first point #results[idx] = pyFLUT.Flame1D(output_dict=list(r.output_dict.keys()), # input_var=r.input_variables, # data=r.data[1:], # variables=r.variables) #safe last x val xlast = r['X'][-1] #shift data and remove last point r['X'] -= r.data[0][0] results[idx] = pyFLUT.Flame1D(output_dict=list( r.output_dict.keys()), input_var=r.input_variables, data=r.data[r['X'] <= xlast], variables=r.variables) results[idx]['X'][-1] = xlast else: #work on bs setups #safe first x val xfirst = r['X'][0] #safe last x val xlast = r['X'][-1] #shift data and remove first points r['X'] -= self.TpatchEnd results[idx] = pyFLUT.Flame1D(output_dict=list( r.output_dict.keys()), input_var=r.input_variables, data=r.data[r['X'] >= xfirst], variables=r.variables) results[idx]['X'][0] = xfirst results[idx]['X'][-1] = xlast #print("End:\nX[{}]: min {}, max {}".format(idx,results[idx]['X'].min(),results[idx]['X'].max())) #remove entries results = [r for i, r in enumerate(results) if i not in toRm] Zlist = [r.variables['Z'] for r in results] Z_values = sorted(list(set(Zlist))) flut_list = [] for Z in Z_values: Zresults = [r for r in results if r.variables['Z'] == Z] self.Zresults = Zresults Ylist = [r.variables['Y'] for r in Zresults] Y_values = sorted(list(set(Ylist))) flut_ylist = [] for Y in Y_values: Yresults = [r for r in Zresults if r.variables['Y'] == Y] self.Yresults = Yresults # create a new X grid -> non uniform X grid X_new = np.unique( np.sort(np.concatenate([r['X'] for r in Yresults]))) # ignore values < 0 X_new = X_new[X_new >= 0.0] self.__log.debug('Create X_new with %s points', len(X_new)) print("Xnew: min {}, max {}\n".format(X_new.min(), X_new.max())) # interpolate existing solutions to the new grid [ r.convert_to_new_grid(variable='X', new_grid=X_new) for r in Yresults ] fluty = pyFLUT.ulf.Flut(input_data=Yresults, key_variable='X', verbose=True) fluty.set_cantera(self.mechanism) fluty.calc_progress_variable( definition_dict=self.pv_definition, along_variable='X') fluty = fluty.convert_cc_to_uniform_grid(n_points=101, n_proc=n_p, verbose=True) calc_Hnorm(fluty) fluty = fluty.map_variables(from_inp='VelRatio', to_inp='Hnorm', n_points=len(self.Hnorm), n_proc=n_p, verbose=True) flut_ylist.append(fluty) self.flut_ylist = flut_ylist flutz = pyFLUT.data.join(flut_ylist, axis='Y') flut_list.append(flutz) self.flut_list = flut_list #joined=flut_list[0]; #for r in flut_list[1:]: # joined=pyFLUT.data.join([joined,r],axis='Z'); #print("joined 1:",joined) joined = pyFLUT.data.join(flut_list, axis='Z') self.joined = pyFLUT.Flut(data=joined.data, input_dict=joined.input_dict, output_dict=joined.output_dict) self.joined.set_cantera(self.mechanism) self.joined.add_missing_properties(verbose=True) self.joined.pv_definition = self.pv_definition self.joined.calc_Le_yc(along='Z') print("joined 2: ", self.joined) #self.joined.write_bin("joined.h5") #output_variables = list(set(self.export_variables+self.gas.species_names)) #self.joined.write_hdf5(file_name="FLUT_joined.h5" # ,cantera_file=self.mechanism # ,regular_grid=False # ,verbose=True # ,output_variables = output_variables # ,turbulent=False, n_proc=n_p) super(pyFLUT.ulf.dflut.DFLUT_2stream, self).__init__(input_dict=self.joined.input_dict, output_dict=self.joined.output_dict, data=self.joined.data, verbose=True) self.__log.debug('Create data structure with dimension %s', self.ndim) for var, val in self.input_dict.items(): self.__log.debug('%s defined from %s to %s with % points', var, val[0], val[-1], len(val))