def select_and_verify_parameters(self, order=2, **props):
"""
A wrapper to the select_parameters method.
This method can deal with overlaps of grids.
But since it does not know the grid apriori,
it is unable to recognize wrong result.
This wrapper checks the result.
input:
order.. maximal number of interpolated spectra
props.. dictionary of interpolated parameters
output:
parlist.. each row represents one spectrum
which is needed to interpolate in
give props
vals.. values in which we interpolate
keys.. names of the interpolated
"""
# all parameters are defined lowercase
# so we have to convert it
for key in props.keys():
v = props.pop(key)
props[key.lower()] = v
if self.debug:
print "In select_and_verify_parameters: order=%i properties:" % (order)
print str(props)
# keys and values
keys = props.keys()
vals = [props[key] for key in props.keys()]
# gets the parameter list
# print order, props
parlist = self.select_parameters(order=order,**props)
# print parlist
# deselect reduntdant spectra
parlist = self.deselect_exact(parlist, **props)
if len(parlist) == 0:
raise Exception('Do %s lie within the grid? I do not think so...' % (str(props)))
if self.debug:
print 'Following parameters were chosen with select_parameters method:'
for row in parlist:
print row
# checks the result
temp = np.array(parlist)
# print temp, vals
for i, val in enumerate(vals):
# print val, temp[:, i], is_within_interval(val, temp[:, i])
if not is_within_interval(val, temp[:, i]):
raise ValueError('Parameters %s lie outside the grid.' % (str(props)))
return parlist, vals, keys
def select_parameters(self, values=[], order=2, constraints={}, **props):
"""
Creates a final list - this is still
first guess. I think that searching up
eligible values and spectra can be done
better.
input:
grid - synthetic spectraList, which is searched
order - how many spectra are used this is
adjusted dynamically if there are not
enough values
constraints - resolve conflicts between grids
props - properties in which we fit
output:
values of spectra for interpolation
"""
# extract the parameter and its values
key = props.keys()[0].lower()
v = props.pop(key)
# print key, constraints, props
# list eligible values for a given parameter
elig_vals = np.array(self.get_available_values_fast(key, **constraints))
# print key, elig_vals
# sorts the grid, from nearest to farthest
ind = np.argsort(abs(elig_vals - v))
vals = elig_vals[ind]
# equality check
# print vals, v, key
# what if the grid step is inhomogeneous? - actually it is
# in z - what shall we do, what shall we do???
if vals[:order].min() > v or vals[:order].max() < v:
# TODO think of something better than this!!!!!!
try:
lower = np.max(vals[np.where(vals - v < ZERO_TOLERANCE)[0]])
upper = np.min(vals[np.where(vals - v > ZERO_TOLERANCE)[0]])
vals = np.array([lower, upper])
except:
pass
# print lower, upper, vals
# checks that there is not equality
# if np.any(abs(vals - v) < ZERO_TOLERANCE):
# ind = np.argmin(abs(vals - v))
# vals = [vals[ind]]
#
# if self.debug:
# print "%s=%s is precise. Skipping choice of parameters." % (key, str(v))
# if the eligible values do not surround the parameter
if not is_within_interval(v, vals):
return values
# if there are no other spectra to interpolate in
if len(props.keys()) == 0:
for i in range(0, len(vals)):
row = []
# append those that are already fixed
for key in constraints.keys():
row.append(constraints[key])
# append the last parameter
row.append(vals[i])
# append the row
values.append(row)
# once 'order' spectra are appended, we can
# end
if i == order - 1:
break
return values
else:
j = 0
for i in range(0, len(vals)):
# add a constraint
constraints[key] = vals[i]
# recursively calls the function
values_new = self.select_parameters(values=copy.deepcopy(values), order=order, constraints=constraints,
**props)
# some searches are in vain - so we
# wait until meaningful calls accumulate
if len(values_new) > len(values):
j += 1
# copis the result, so we can go on
values = values_new
# remove constraint
constraints.pop(key)
if j == order:
break
return values
