def update_page_name(self):
""" Handles the trait defining a particular page's name being changed.
"""
changed = False
for i, value in enumerate(self._uis):
dock_control, user_object, view_object, monitoring = value
if dock_control.control is not None:
name = None
handler = getattr(self.ui.handler, '%s_%s_page_name' %
(self.object_name, self.name), None)
if handler is not None:
name = handler(self.ui.info, user_object)
if name is None:
name = unicode(
xgetattr(
view_object,
self.factory.page_name[
1:],
u'???'))
changed |= (dock_control.name != name)
dock_control.name = name
if changed:
self.update_layout()
def get_raw_value(self, object):
""" Gets the unformatted value of the column for a specified object.
"""
try:
return xgetattr(self.get_object(object), self.name)
except:
return None
def check_sim_ready(self):
"""Method to update various storage mechanisms for holding trait values for simulations.
Takes user data in table editor and stores it in necessary dictionaries so that
traits can be set and things automatically. Decided to use this over a system
properties because the properties were conflicting with delegation and other stuff.
"""
sim_traits = {}
originals = {}
missing = []
status_message = ''
# Retain a mapping between shortnames (layer1.material) and attr path
# from base_app (layereditor.layer1) etc...
_trait_name_map = dict((s.trait_name, s.trait_name_full)
for s in self.sim_variables)
for obj in self.sim_variables:
obj.inc=self.inc #Ensures proper increments whether adding new objects to the table or just changing global inc
for obj in self.sim_variables:
sim_traits[str(obj.trait_name)]=obj.trait_array #Simulation traits
#^^^ Remove unicode
for key in sim_traits.keys():
_true_trait_val = _trait_name_map[key]
try:
originals[key]=xgetattr(self.base_app, _true_trait_val) #If trait found, store its original values
except (AttributeError, StackError):
missing.append(key) #If not, put it in missing
ready = True
# Are traits missing?
if len(missing) > 0:
status_message='<font color="red"> Could not find required input: </font>'
status_message += ', '.join(missing)
ready = False
# Did user select duplicates of trait names
trait_names = [obj.trait_name for obj in self.sim_variables]
duplicates = set([name for name in trait_names if trait_names.count(name) > 1])
if duplicates:
status_message='<font color="red"> Duplicate simulation input(s) found: </font>'
for trait in duplicates:
status_message += trait + ', '
ready = False
if ready:
status_message='<font color="green"> Simulation ready: all input found</font>'
ready = True
self.ready = ready
self.status_message = status_message.rstrip(',') #<-- trialling commas for list of one element string
self.simulation_traits = sim_traits# Remove unicode
self.missing_traits = missing
self.original_values = originals
self._trait_namemap = _trait_name_map
def get_raw_value(self, object):
""" Gets the unformatted value of the column for a specified object.
"""
try:
return xgetattr(self.get_object(object), self.name)
except Exception as e:
from traitsui.api import raise_to_debug
raise_to_debug()
return None
def target_name(self, object):
""" Returns the target object and name for the column.
"""
object = self.get_object(object)
name = self.name
col = name.rfind(".")
if col < 0:
return (object, name)
return (xgetattr(object, name[:col]), name[col + 1 :])
def target_name(self, object):
""" Returns the target object and name for the column.
"""
object = self.get_object(object)
name = self.name
col = name.rfind('.')
if col < 0:
return (object, name)
return (xgetattr(object, name[:col]), name[col + 1:])
def get_raw_value(self, object):
""" Gets the unformatted value of the column for a specified object.
"""
try:
return xgetattr(self.get_object(object), self.name)
except Exception as e:
from traitsui.api import raise_to_debug
raise_to_debug()
return None
def _selected_changed(self, selected):
"""Handles the **selected** trait being changed."""
for page, ui, _, _ in self._uis:
if ui.info and selected is ui.info.object:
self.control.setCurrentWidget(page)
break
deletable = self.factory.deletable
deletable_trait = self.factory.deletable_trait
if deletable and deletable_trait:
enabled = xgetattr(selected, deletable_trait, True)
self.close_button.setEnabled(enabled)
def get_raw_value ( self, object ):
""" Gets the unformatted value of the column for a specified object.
Overridden here to return the trait name (which is the object's name trait) rather than the
column's name trait.
"""
try:
target, name = self.target_name( object )
return xgetattr( target, name )
except:
return None
def get_raw_value(self, object):
""" Gets the unformatted value of the column for a specified object.
Overridden here to return the trait name (which is the object's name trait) rather than the
column's name trait.
"""
try:
target, name = self.target_name(object)
return xgetattr(target, name)
except:
return None
def _selected_changed(self, selected):
""" Handles the **selected** trait being changed.
"""
for page, ui, _, _ in self._uis:
if ui.info and selected is ui.info.object:
self.control.setCurrentWidget(page)
break
deletable = self.factory.deletable
deletable_trait = self.factory.deletable_trait
if deletable and deletable_trait:
enabled = xgetattr(selected, deletable_trait, True)
self.close_button.setEnabled(enabled)
def target_name ( self, object ):
""" Returns the target object and name for the column.
Overridden here to return the trait name (which is the object's name trait) rather than the
column's name trait.
"""
name = object.name
object = self.get_object( object )
col = name.rfind( '.' )
if col < 0:
return ( object, name )
return ( xgetattr( object, name[ :col ] ), name[ col + 1: ] )
def target_name(self, object):
""" Returns the target object and name for the column.
Overridden here to return the trait name (which is the object's name trait) rather than the
column's name trait.
"""
name = object.name
object = self.get_object(object)
col = name.rfind('.')
if col < 0:
return (object, name)
return (xgetattr(object, name[:col]), name[col + 1:])
def get_value(self, obj):
""" Return the attribute value for the provided object.
Parameters
----------
obj : any
The object that contains the data.
Returns
-------
value : any
The data value contained in the object's attribute.
"""
return xgetattr(obj, self.attr)
def update_page_name ( self, object, name, old, new ):
""" Handles the trait defining a particular page's name being changed.
"""
for i, value in enumerate(self._uis):
page, ui, _, _ = value
if object is ui.info.object:
name = None
handler = getattr(self.ui.handler,
'%s_%s_page_name' % (self.object_name, self.name),
None)
if handler is not None:
name = handler(self.ui.info, object)
if name is None:
name = str(xgetattr(object, self.factory.page_name[1:], '???'))
self.control.setTabText(self.control.indexOf(page), name)
break
def update_page_name ( self, object, name, old, new ):
""" Handles the trait defining a particular page's name being changed.
"""
for i, value in enumerate(self._uis):
page, ui, _, _ = value
if object is ui.info.object:
name = None
handler = getattr(self.ui.handler,
'%s_%s_page_name' % (self.object_name, self.name),
None)
if handler is not None:
name = handler(self.ui.info, object)
if name is None:
name = str(xgetattr(object, self.factory.page_name[1:], '???'))
self.control.setTabText(self.control.indexOf(page), name)
break
def bind(self, binder, context):
the_binder, binder_trait = self._normalize_binder_trait(
binder, self.left, context)
rhs = self.right.strip()
ext_traits = find_ext_attrs(rhs)
if ext_traits == [rhs]:
# Simple case of one attribute.
context_name, xattr = rhs.split('.', 1)
context_obj = context[context_name]
handler = _TraitModified(the_binder, binder_trait).handler
# FIXME: Only check as far down as are HasTraits objects available.
# We would like to be able to include references to methods on
# attributes of HasTraits classes.
# Unfortunately, a valid use case is where a leading object in
# a true trait chain is None.
context_obj.on_trait_change(handler, xattr)
self.pull_handler_data = [(context_obj, handler, xattr)]
# FIXME: do a better check for an event trait
try:
xsetattr(the_binder, binder_trait,
xgetattr(context_obj, xattr))
except AttributeError as e:
if 'event' not in str(e):
raise
elif ext_traits == []:
msg = "No traits found in expression: {0!r}".format(rhs)
raise ValueError(msg)
else:
# Expression.
self.pull_handler_data = []
handler = _EvaluateExpression(the_binder, binder_trait,
context, rhs).handler
for ext_trait in ext_traits:
context_name, xattr = ext_trait.split('.', 1)
if context_name not in context:
# Assume it's a builtin.
continue
context_obj = context[context_name]
context_obj.on_trait_change(handler, xattr)
self.pull_handler_data.append((context_obj, handler, xattr))
# Call the handler once to evaluate and set the value initially.
handler()
def bind(self, binder, context):
the_binder, binder_trait = self._normalize_binder_trait(
binder, self.left, context)
rhs = self.right.strip()
ext_traits = find_ext_attrs(rhs)
if ext_traits == [rhs]:
# Simple case of one attribute.
context_name, xattr = rhs.split('.', 1)
context_obj = context[context_name]
handler = _TraitModified(the_binder, binder_trait).handler
# FIXME: Only check as far down as are HasTraits objects available.
# We would like to be able to include references to methods on
# attributes of HasTraits classes.
# Unfortunately, a valid use case is where a leading object in
# a true trait chain is None.
context_obj.on_trait_change(handler, xattr)
self.pull_handler_data = [(context_obj, handler, xattr)]
# FIXME: do a better check for an event trait
try:
xsetattr(the_binder, binder_trait,
xgetattr(context_obj, xattr))
except AttributeError as e:
if 'event' not in str(e):
raise
elif ext_traits == []:
msg = "No traits found in expression: {0!r}".format(rhs)
raise ValueError(msg)
else:
# Expression.
self.pull_handler_data = []
handler = _EvaluateExpression(the_binder, binder_trait, context,
rhs).handler
for ext_trait in ext_traits:
context_name, xattr = ext_trait.split('.', 1)
if context_name not in context:
# Assume it's a builtin.
continue
context_obj = context[context_name]
context_obj.on_trait_change(handler, xattr)
self.pull_handler_data.append((context_obj, handler, xattr))
# Call the handler once to evaluate and set the value initially.
handler()
def update_page_name ( self ):
""" Handles the trait defining a particular page's name being changed.
"""
changed = False
for i, value in enumerate( self._uis ):
dock_control, user_object, view_object, monitoring = value
if dock_control.control is not None:
name = None
handler = getattr( self.ui.handler, '%s_%s_page_name' %
( self.object_name, self.name ), None )
if handler is not None:
name = handler( self.ui.info, user_object )
if name is None:
name = unicode( xgetattr( view_object,
self.factory.page_name[1:], u'???' ) )
changed |= (dock_control.name != name)
dock_control.name = name
if changed:
self.update_layout()
def _create_page(self, object):
# Create the view for the object:
view_object = object
factory = self.factory
if factory.factory is not None:
view_object = factory.factory(object)
ui = view_object.edit_traits(parent=self.control,
view=factory.view,
kind=factory.ui_kind).set(parent=self.ui)
# Get the name of the page being added to the notebook:
name = ''
monitoring = False
prefix = '%s_%s_page_' % (self.object_name, self.name)
page_name = factory.page_name
if page_name[0:1] == '.':
name = xgetattr(view_object, page_name[1:], None)
monitoring = (name is not None)
if monitoring:
handler_name = None
method = getattr(self.ui.handler, prefix + 'name', None)
if method is not None:
handler_name = method(self.ui.info, object)
if handler_name is not None:
name = handler_name
else:
name = str(name) or '???'
view_object.on_trait_change(self.update_page_name,
page_name[1:],
dispatch='ui')
else:
name = ''
elif page_name != '':
name = page_name
if name == '':
name = user_name_for(view_object.__class__.__name__)
# Make sure the name is not a duplicate:
if not monitoring:
self._pages[name] = count = self._pages.get(name, 0) + 1
if count > 1:
name += (' %d' % count)
# Return the control for the ui, and whether or not its name is being
# monitored:
image = None
method = getattr(self.ui.handler, prefix + 'image', None)
if method is not None:
image = method(self.ui.info, object)
if image is None:
self.control.addTab(ui.control, name)
else:
self.control.addTab(ui.control, image, name)
if self.factory.show_notebook_menu:
newaction = self._context_menu.addAction(name)
newaction.setText(name)
newaction.setCheckable(True)
newaction.setChecked(True)
newaction.triggered.connect(
lambda e, name=name: self._menu_action(e, name=name))
self._action_dict[name] = newaction
self._pagewidgets[name] = ui.control
return (ui, view_object, monitoring)
def get_value(self, obj):
return xgetattr(obj, self.value, None)
def set_value(self, obj, value):
data = xgetattr(obj, self.value, None)
data[self.key] = value
def get_value(self, obj):
data = xgetattr(obj, self.value, None)
return data.get(self.key, None)
def runsim(self):
""" Increments, updates all results. Thre primary storage objects:
staticdict --> Traits that are no altered in simulation.
Includes simulation inputs, spectral parameters and fiber/strata
parameters. In future version, could relax these if needed
to simulation over a fiber parameter like core size.
primarydict --> Results that are to be promoted to top level.
Simparaser will try to show these as a panel.
resultsdict ---> Deep, nested results of layer and optical stack. For
example, could access full optical stack on third increment via:
resultsdict['step3']['optics']['opticalstack']
or a selected material:
resultsdict['step5']['selectedlayer']['material1']['fullmie']
etc...
Simparser should have methods to make these data more accessible.
"""
print('running sim with traits', list(self.simulation_traits.keys()))
# for name brevity
sconfig = self.configure_storage
b_app = self.base_app
# Storage
primarydict = OrderedDict(
) #<-- Keyed by increment, becomes primary panel!
resultsdict = OrderedDict(
) #<-- Keyed by increment, stores deep results, stays as dict
# Traits not involved in simulation. For this sim, includes spectral parameters, fiber/strata params
# at simulation inputs. Later sims may want to simulate over fiber traits (ie fiber diameter changes)
# so would migrate these into resultsdict instead
staticdict = OrderedDict()
staticdict['Layers in Slab'] = len(b_app.stack)
staticdict[
globalparms.
spectralparameters] = b_app.specparms.simulation_requested()
staticdict[
globalparms.strataname] = b_app.fiberparms.simulation_requested()
# Begin iterations
sorted_keys = []
for i in range(self.inc):
for trait in list(self.simulation_traits.keys()):
_true_trait = self._trait_namemap[
trait] #<--- Trait stored in memory (ie b_app.layereditor.layer1...)
xsetattr(b_app, _true_trait, self.simulation_traits[trait]
[i]) #Object, traitname, traitvalue
stepname = 'step_%s' % i
primary_increment = OrderedDict(
) #<--- Toplevel/Summary of just this increment (becomes dataframe)
results_increment = OrderedDict(
) #<--- Deep results of just thsi increment (ie selected_material/layer etc..)
key = '%s_%s' % (str(i), self.key_title)
sorted_keys.append(key)
# Update Optical Stack
b_app.opticstate.update_optical_stack()
# Flatten sim attributes. For example, if attrs selected for Sim are R, A, kz
# kz actually has value in each layer so R, A, kz_1, kz_2, kz_3 is what needs
# to be iterated over.
flat_attributes = []
# How many layers in optical stack
layer_indicies = list(range(len(
b_app.opticstate.ns))) #0,1,2,3,4 for 5 layers etc...
for attr in sconfig.choose_optics:
if attr in b_app.opticstate.optical_stack.minor_axis:
flat_attributes.append(attr)
else:
# http://stackoverflow.com/questions/28031354/match-the-pattern-at-the-end-of-a-string
delim = '_%s' % globalparms._flat_suffix
# ['kz', 'vn', 'ang_prop']
setkeys = set(
name.split(delim)[0]
for name in b_app.opticstate.optical_stack.minor_axis
if delim in name)
if attr in setkeys:
for idx in layer_indicies:
flat_attributes.append(attr + delim +
str(idx)) #kz_L1 etc...)
else:
raise SimError(
'Cannot simulate over optical stack attr "%s" '
' not found in optical stack.' % attr)
# --- PRIMARY RESULTS
# Take parameters from optical stack, put in toplevel via sconfig.choose_optics
if sconfig.averaging in ['Average', 'Both']:
for optical_attr in flat_attributes:
primary_increment['%s_%s' % (optical_attr, 'avg')] = \
b_app.opticstate.compute_average(optical_attr) #<-- IS NUMPY ARRAY, object type
if sconfig.averaging in ['Not Averaged', 'Both']:
for optical_attr in flat_attributes:
# ITERATE OVER ANGLES! SAVE EACH ANGLE
for angle in b_app.opticstate.angles:
primary_increment['%s_%.2f' % (optical_attr, angle)] = \
b_app.opticstate.optical_stack[angle][optical_attr] #<-- Save as what, numpy/pandas?
# User-set dielectric slab quantites to be in primary
for trait in sconfig.additional_list:
traitval = xgetattr(b_app.layereditor, trait)
primary_increment['%s' % trait] = traitval
# --- DEEP RESULTS
# Store full Optical Stack
if sconfig.store_optical_stack:
results_increment[
globalparms.optresponse] = b_app.opticstate.optical_stack
# Save layer/material traits. If None selected, it just skips
if sconfig.choose_layers == 'Selected Layer':
key = 'Layer%s' % (b_app.layereditor.selected_index
) #<-- index of selected layer
results_increment[
key] = self.selected_layer.simulation_requested()
elif sconfig.choose_layers == 'All Layers':
materials_only = False
if sconfig.mater_only == 'Material Data':
materials_only = True
results_increment[
'dielectric_layers'] = b_app.layereditor.simulation_requested(
materials_only)
# resultsdict >> {step1 : {results_of_increment}, ...}
resultsdict[stepname] = results_increment
primarydict[stepname] = primary_increment
print("Iteration\t", i + 1, "\t of \t", self.inc, "\t completed")
# SET STORAGE TRAITS
self.primary = primarydict
self.results = resultsdict
self.static = staticdict
# Prompt user to save?
popup = BasicDialog(
message='Simulation complete. Would you like to save now?')
ui = popup.edit_traits(kind='modal')
if ui.result == True:
self.save(confirmwindow=True)
def check_sim_ready(self):
"""Method to update various storage mechanisms for holding trait values for simulations.
Takes user data in table editor and stores it in necessary dictionaries so that
traits can be set and things automatically. Decided to use this over a system
properties because the properties were conflicting with delegation and other stuff.
"""
sim_traits = {}
originals = {}
missing = []
status_message = ''
# Retain a mapping between shortnames (layer1.material) and attr path
# from base_app (layereditor.layer1) etc...
_trait_name_map = dict(
(s.trait_name, s.trait_name_full) for s in self.sim_variables)
for obj in self.sim_variables:
obj.inc = self.inc #Ensures proper increments whether adding new objects to the table or just changing global inc
for obj in self.sim_variables:
sim_traits[str(
obj.trait_name)] = obj.trait_array #Simulation traits
#^^^ Remove unicode
for key in list(sim_traits.keys()):
_true_trait_val = _trait_name_map[key]
try:
originals[key] = xgetattr(
self.base_app, _true_trait_val
) #If trait found, store its original values
except (AttributeError, StackError):
missing.append(key) #If not, put it in missing
ready = True
# Are traits missing?
if len(missing) > 0:
status_message = '<font color="red"> Could not find required input: </font>'
status_message += ', '.join(missing)
ready = False
# Did user select duplicates of trait names
trait_names = [obj.trait_name for obj in self.sim_variables]
duplicates = set(
[name for name in trait_names if trait_names.count(name) > 1])
if duplicates:
status_message = '<font color="red"> Duplicate simulation input(s) found: </font>'
for trait in duplicates:
status_message += trait + ', '
ready = False
if ready:
status_message = '<font color="green"> Simulation ready: all input found</font>'
ready = True
self.ready = ready
self.status_message = status_message.rstrip(
',') #<-- trialling commas for list of one element string
self.simulation_traits = sim_traits # Remove unicode
self.missing_traits = missing
self.original_values = originals
self._trait_namemap = _trait_name_map
def _create_page(self, object):
# Create the view for the object:
view_object = object
factory = self.factory
if factory.factory is not None:
view_object = factory.factory(object)
ui = view_object.edit_traits(parent=self.control,
view=factory.view,
kind=factory.ui_kind).trait_set(
parent=self.ui)
# Get the name of the page being added to the notebook:
name = ''
monitoring = False
prefix = '%s_%s_page_' % (self.object_name, self.name)
page_name = factory.page_name
if page_name[0:1] == '.':
name = xgetattr(view_object, page_name[1:], None)
monitoring = (name is not None)
if monitoring:
handler_name = None
method = getattr(self.ui.handler, prefix + 'name', None)
if method is not None:
handler_name = method(self.ui.info, object)
if handler_name is not None:
name = handler_name
else:
name = str(name) or '???'
view_object.on_trait_change(self.update_page_name,
page_name[1:], dispatch='ui')
else:
name = ''
elif page_name != '':
name = page_name
if name == '':
name = user_name_for(view_object.__class__.__name__)
# Make sure the name is not a duplicate:
if not monitoring:
self._pages[name] = count = self._pages.get(name, 0) + 1
if count > 1:
name += (' %d' % count)
# Return the control for the ui, and whether or not its name is being
# monitored:
image = None
method = getattr(self.ui.handler, prefix + 'image', None)
if method is not None:
image = method(self.ui.info, object)
if image is None:
self.control.addTab(ui.control, name)
else:
self.control.addTab(ui.control, image, name)
if self.factory.show_notebook_menu:
newaction = self._context_menu.addAction(name)
newaction.setText(name)
newaction.setCheckable(True)
newaction.setChecked(True)
newaction.triggered.connect(
lambda e, name=name: self._menu_action(
e, name=name))
self._action_dict[name] = newaction
self._pagewidgets[name] = ui.control
return (ui, view_object, monitoring)
def runsim(self):
""" Increments, updates all results. Thre primary storage objects:
staticdict --> Traits that are no altered in simulation.
Includes simulation inputs, spectral parameters and fiber/strata
parameters. In future version, could relax these if needed
to simulation over a fiber parameter like core size.
primarydict --> Results that are to be promoted to top level.
Simparaser will try to show these as a panel.
resultsdict ---> Deep, nested results of layer and optical stack. For
example, could access full optical stack on third increment via:
resultsdict['step3']['optics']['opticalstack']
or a selected material:
resultsdict['step5']['selectedlayer']['material1']['fullmie']
etc...
Simparser should have methods to make these data more accessible.
"""
print 'running sim with traits', self.simulation_traits.keys()
# for name brevity
sconfig = self.configure_storage
b_app = self.base_app
# Storage
primarydict = OrderedDict() #<-- Keyed by increment, becomes primary panel!
resultsdict = OrderedDict() #<-- Keyed by increment, stores deep results, stays as dict
# Traits not involved in simulation. For this sim, includes spectral parameters, fiber/strata params
# at simulation inputs. Later sims may want to simulate over fiber traits (ie fiber diameter changes)
# so would migrate these into resultsdict instead
staticdict = OrderedDict()
staticdict['Layers in Slab'] = len(b_app.stack)
staticdict[globalparms.spectralparameters] = b_app.specparms.simulation_requested()
staticdict[globalparms.strataname] = b_app.fiberparms.simulation_requested()
# Begin iterations
sorted_keys = []
for i in range(self.inc):
for trait in self.simulation_traits.keys():
_true_trait = self._trait_namemap[trait]#<--- Trait stored in memory (ie b_app.layereditor.layer1...)
xsetattr(b_app, _true_trait, self.simulation_traits[trait][i]) #Object, traitname, traitvalue
stepname = 'step_%s' % i
primary_increment = OrderedDict() #<--- Toplevel/Summary of just this increment (becomes dataframe)
results_increment = OrderedDict() #<--- Deep results of just thsi increment (ie selected_material/layer etc..)
key = '%s_%s' % (str(i), self.key_title)
sorted_keys.append(key)
# Update Optical Stack
b_app.opticstate.update_optical_stack()
# Flatten sim attributes. For example, if attrs selected for Sim are R, A, kz
# kz actually has value in each layer so R, A, kz_1, kz_2, kz_3 is what needs
# to be iterated over.
flat_attributes = []
# How many layers in optical stack
layer_indicies = range(len(b_app.opticstate.ns)) #0,1,2,3,4 for 5 layers etc...
for attr in sconfig.choose_optics:
if attr in b_app.opticstate.optical_stack.minor_axis:
flat_attributes.append(attr)
else:
# http://stackoverflow.com/questions/28031354/match-the-pattern-at-the-end-of-a-string
delim = '_%s' % globalparms._flat_suffix
# ['kz', 'vn', 'ang_prop']
setkeys = set(name.split(delim)[0] for name in
b_app.opticstate.optical_stack.minor_axis if delim in name)
if attr in setkeys:
for idx in layer_indicies:
flat_attributes.append(attr + delim + str(idx)) #kz_L1 etc...)
else:
raise SimError('Cannot simulate over optical stack attr "%s" '
' not found in optical stack.' % attr)
# --- PRIMARY RESULTS
# Take parameters from optical stack, put in toplevel via sconfig.choose_optics
if sconfig.averaging in ['Average','Both']:
for optical_attr in flat_attributes:
primary_increment['%s_%s' % (optical_attr, 'avg')] = \
b_app.opticstate.compute_average(optical_attr) #<-- IS NUMPY ARRAY, object type
if sconfig.averaging in ['Not Averaged', 'Both']:
for optical_attr in flat_attributes:
# ITERATE OVER ANGLES! SAVE EACH ANGLE
for angle in b_app.opticstate.angles:
primary_increment['%s_%.2f' % (optical_attr, angle)] = \
b_app.opticstate.optical_stack[angle][optical_attr] #<-- Save as what, numpy/pandas?
# User-set dielectric slab quantites to be in primary
for trait in sconfig.additional_list:
traitval = xgetattr(b_app.layereditor, trait)
primary_increment['%s' % trait] = traitval
# --- DEEP RESULTS
# Store full Optical Stack
if sconfig.store_optical_stack:
results_increment[globalparms.optresponse] = b_app.opticstate.optical_stack
# Save layer/material traits. If None selected, it just skips
if sconfig.choose_layers == 'Selected Layer':
key = 'Layer%s' % (b_app.layereditor.selected_index) #<-- index of selected layer
results_increment[key] = self.selected_layer.simulation_requested()
elif sconfig.choose_layers == 'All Layers':
materials_only = False
if sconfig.mater_only == 'Material Data':
materials_only = True
results_increment['dielectric_layers'] = b_app.layereditor.simulation_requested(materials_only)
# resultsdict >> {step1 : {results_of_increment}, ...}
resultsdict[stepname] = results_increment
primarydict[stepname] = primary_increment
print "Iteration\t", i+1, "\t of \t", self.inc, "\t completed"
# SET STORAGE TRAITS
self.primary = primarydict
self.results = resultsdict
self.static = staticdict
# Prompt user to save?
popup = BasicDialog(message='Simulation complete. Would you like to save now?')
ui = popup.edit_traits(kind='modal')
if ui.result == True:
self.save(confirmwindow=True)
def sync_value(
self,
user_name,
editor_name,
mode="both",
is_list=False,
is_event=False,
):
""" Synchronize an editor trait and a user object trait.
Also sets the initial value of the editor trait from the
user object trait (for modes 'from' and 'both'), and the initial
value of the user object trait from the editor trait (for mode
'to'), as long as the relevant traits are not events.
Parameters
----------
user_name : str
The name of the trait to be used on the user object. If empty, no
synchronization will be set up.
editor_name : str
The name of the relevant editor trait.
mode : str, optional; one of 'to', 'from' or 'both'
The direction of synchronization. 'from' means that trait changes
in the user object should be propagated to the editor. 'to' means
that trait changes in the editor should be propagated to the user
object. 'both' means changes should be propagated in both
directions. The default is 'both'.
is_list : bool, optional
If true, synchronization for item events will be set up in
addition to the synchronization for the object itself.
The default is False.
is_event : bool, optional
If true, this method won't attempt to initialize the user
object or editor trait values. The default is False.
"""
if user_name == "":
return
key = "%s:%s" % (user_name, editor_name)
parts = user_name.split(".")
if len(parts) == 1:
user_object = self.context_object
xuser_name = user_name
else:
user_object = self.ui.context[parts[0]]
xuser_name = ".".join(parts[1:])
user_name = parts[-1]
if mode in {"from", "both"}:
self._bind_from(key, user_object, xuser_name, editor_name, is_list)
if not is_event:
# initialize editor value from user value
with self.raise_to_debug():
user_value = xgetattr(user_object, xuser_name)
setattr(self, editor_name, user_value)
if mode in {"to", "both"}:
self._bind_to(key, user_object, xuser_name, editor_name, is_list)
if mode == "to" and not is_event:
# initialize user value from editor value
with self.raise_to_debug():
editor_value = xgetattr(self, editor_name)
xsetattr(user_object, xuser_name, editor_value)
def editor_list_modified(event):
if key not in self._no_trait_update:
with self.no_trait_update(key), self.raise_to_debug():
n = event.index
value = xgetattr(user_object, xuser_name)
value[n:n + len(event.removed)] = event.added
def _create_page ( self, object ):
""" Creates a DockControl for a specified object.
"""
# Create the view for the object:
view_object = object
factory = self.factory
if factory.factory is not None:
view_object = factory.factory( object )
ui = view_object.edit_traits( parent = self.control,
view = factory.view,
kind = factory.ui_kind ).set(
parent = self.ui )
# Get the name of the page being added to the notebook:
name = ''
monitoring = False
prefix = '%s_%s_page_' % ( self.object_name, self.name )
page_name = self.factory.page_name
if page_name[0:1] == '.':
name = xgetattr( view_object, page_name[1:], None )
monitoring = (name is not None)
if monitoring:
handler_name = None
method = getattr( self.ui.handler, prefix + 'name', None )
if method is not None:
handler_name = method( self.ui.info, object )
if handler_name is not None:
name = handler_name
else:
name = unicode( name ) or u'???'
view_object.on_trait_change( self.update_page_name,
page_name[1:], dispatch = 'ui' )
else:
name = ''
elif page_name != '':
name = page_name
if name == '':
name = user_name_for( view_object.__class__.__name__ )
# Make sure the name is not a duplicate:
if not monitoring:
self._pages[ name ] = count = self._pages.get( name, 0 ) + 1
if count > 1:
name += (' %d' % count)
# Return a new DockControl for the ui, and whether or not its name is
# being monitored:
image = None
method = getattr( self.ui.handler, prefix + 'image', None )
if method is not None:
image = method( self.ui.info, object )
dock_control = DockControl( control = ui.control,
id = str( id( ui.control ) ),
name = name,
style = factory.dock_style,
image = image,
export = factory.export,
closeable = factory.deletable,
dockable = DockableListElement(
ui = ui,
editor = self ) )
return ( dock_control, view_object, monitoring )
def _create_page(self, object):
""" Creates a DockControl for a specified object.
"""
# Create the view for the object:
view_object = object
factory = self.factory
if factory.factory is not None:
view_object = factory.factory(object)
ui = view_object.edit_traits(parent=self.control,
view=factory.view,
kind=factory.ui_kind).set(parent=self.ui)
# Get the name of the page being added to the notebook:
name = ''
monitoring = False
prefix = '%s_%s_page_' % (self.object_name, self.name)
page_name = self.factory.page_name
if page_name[0:1] == '.':
name = xgetattr(view_object, page_name[1:], None)
monitoring = (name is not None)
if monitoring:
handler_name = None
method = getattr(self.ui.handler, prefix + 'name', None)
if method is not None:
handler_name = method(self.ui.info, object)
if handler_name is not None:
name = handler_name
else:
name = unicode(name) or u'???'
view_object.on_trait_change(self.update_page_name,
page_name[1:],
dispatch='ui')
else:
name = ''
elif page_name != '':
name = page_name
if name == '':
name = user_name_for(view_object.__class__.__name__)
# Make sure the name is not a duplicate:
if not monitoring:
self._pages[name] = count = self._pages.get(name, 0) + 1
if count > 1:
name += (' %d' % count)
# Return a new DockControl for the ui, and whether or not its name is
# being monitored:
image = None
method = getattr(self.ui.handler, prefix + 'image', None)
if method is not None:
image = method(self.ui.info, object)
dock_control = DockControl(control=ui.control,
id=str(id(ui.control)),
name=name,
style=factory.dock_style,
image=image,
export=factory.export,
closeable=factory.deletable,
dockable=DockableListElement(ui=ui,
editor=self))
return (dock_control, view_object, monitoring)
