def create_specsheet(conjugate_type, **inputs):
if conjugate_type == 'finite':
# setup finite conjugate defaults
fev = create_etendue_dict()
fev['field']['object'] = dict([('height', None)])
fev['aperture']['object'] = dict([('f/#', None), ('NA', None)])
fev['field']['image'] = dict([('height', None)])
fev['aperture']['image'] = dict([('f/#', None), ('NA', None)])
fss = SpecSheet('finite', etendue_values=fev, **inputs)
return fss
elif conjugate_type == 'infinite':
# setup infinite conjugate defaults
imager_inputs = {'s': -math.inf}
imager = IdealImager(None, -math.inf, None, None, None)
iev = create_etendue_dict()
iev['field']['object'] = dict([('angle', None)])
iev['aperture']['object'] = dict([('pupil', None)])
iev['field']['image'] = dict([('height', None)])
iev['aperture']['image'] = dict([('f/#', None), ('NA', None)])
ifss = SpecSheet('infinite',
imager=imager,
imager_inputs=imager_inputs,
frozen_imager_inputs=[True, True, True, True, False],
etendue_values=iev,
**inputs)
return ifss
else:
print('create_specsheet: conjugate_type not recognized',
conjugate_type)
return None
def __init__(self, conjugate_type,
imager=None, imager_inputs=None, frozen_imager_inputs=None,
etendue_inputs=None, etendue_values=None):
self.conjugate_type = conjugate_type
if imager is None:
imager = IdealImager(None, None, None, None, None)
self.imager = imager
self.imager_inputs = imager_inputs if imager_inputs else {}
self.frozen_imager_inputs = (frozen_imager_inputs
if frozen_imager_inputs
else [False]*5)
self.etendue_inputs = (etendue_inputs if etendue_inputs
else create_etendue_dict())
self.etendue_values = (etendue_values if etendue_values
else create_etendue_dict())
self.partition_defined()
def generate_from_inputs(self, imgr_inputs, etendue_inputs):
""" compute imager and etendue values given input dicts """
max_partition, max_num_inputs = self.partition_defined()
num_imager_inputs = self.partitions['imager']
num_field_inputs = self.partitions['field']
num_aperture_inputs = self.partitions['aperture']
conj_type = self.conjugate_type
imager_inputs = {}
if max_num_inputs <= 1:
# fill in imager_inputs with any previous calculations for m or f
if conj_type == 'finite':
if num_imager_inputs < 2 and self.imager.m is not None:
imager_inputs['m'] = self.imager.m
else:
if num_imager_inputs < 2 and self.imager.f is not None:
imager_inputs['f'] = self.imager.f
# update imager_inputs with user entries
imager_inputs.update(imgr_inputs)
imager_inputs = {
k: v
for (k, v) in imager_inputs.items() if v is not None
}
# calculate an ideal imager for imager_inputs
imager = ideal_imager_setup(**imager_inputs)
# fill in remaining None values with previous imager data
imager = IdealImager(*[
self.imager[i] if p is None else imager[i]
for i, p in enumerate(imager)
])
if conj_type == 'finite':
imager_defined = True if imager.m is not None else False
else:
imager_defined = True if imager.f is not None else False
etendue_values = self.etendue_values
for fa_key, fa_value in etendue_inputs.items():
for oi_key, oi_value in fa_value.items():
if conj_type == 'finite':
conj = 'finite'
elif conj_type == 'afocal':
conj = 'infinite'
elif conj_type == 'infinite':
conj = 'finite' if oi_key == 'image' else conj_type
etendue.fill_in_etendue_data(conj, imager, fa_key,
etendue_inputs[fa_key][oi_key],
etendue_values[fa_key][oi_key])
if imager_defined:
if num_field_inputs >= 1 and num_aperture_inputs >= 1:
# we have enough data to calculate all of the etendue grid
ii = etendue.do_etendue_via_imager(conj_type, imager,
etendue_inputs,
etendue_values)
if ii:
imager_inputs[ii[0]] = ii[1]
imager = ideal_imager_setup(**imager_inputs)
etendue.do_etendue_via_imager(conj_type, imager,
etendue_inputs,
etendue_values)
elif num_field_inputs == 1:
# we have enough data to calculate all of the etendue grid
row = dict2d.row(etendue_inputs, 'field')
obj_img_key = 'object' if len(row['object']) else 'image'
etendue.do_field_via_imager(conj_type, imager, etendue_inputs,
obj_img_key, etendue_values)
elif num_aperture_inputs == 1:
# we have enough data to calculate all of the etendue grid
row = dict2d.row(etendue_inputs, 'aperture')
obj_img_key = 'object' if len(row['object']) else 'image'
etendue.do_aperture_via_imager(conj_type, imager,
etendue_inputs, obj_img_key,
etendue_values)
else: # imager not specified
if num_field_inputs == 2 or num_aperture_inputs == 2:
fld_ape_key = 'field' if num_field_inputs == 2 else 'aperture'
# solve for imager
ii = etendue.do_etendue_to_imager(fld_ape_key, etendue_inputs,
etendue_values)
imager_inputs[ii[0]] = ii[1]
imager = ideal_imager_setup(**imager_inputs)
# update etendue grid
etendue.do_etendue_via_imager(conj_type, imager,
etendue_inputs, etendue_values)
self.imager = imager
self.etendue_values = etendue_values
return imager, etendue_values
def sync_to_restore(self, opt_model):
# imager is exported as a list. convert back to an IdealImager
self.imager = IdealImager(*self.imager)