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