models.py @ 686fd10

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 686fd10 was 415fb82, checked in by krzywon, 10 years ago
Fixed the perspectives loading error. Cleaned up the sasview.log by removing any extra linefeeds/carraige returns and added a start session and end session message.
Property mode set to `100644`
File size: 52.5 KB

Rev	Line
[415fb82]	1	"""
	2	Utilities to manage models
	3	"""
	4	import wx
	5	import imp
	6	import os
	7	import sys
	8	import os.path
	9	# Time is needed by the log method
	10	import time
	11	import logging
	12	import py_compile
	13	import shutil
	14	# Explicitly import from the pluginmodel module so that py2exe
	15	# places it in the distribution. The Model1DPlugin class is used
	16	# as the base class of plug-in models.
	17	from sas.models.pluginmodel import Model1DPlugin
	18	from sas.guiframe.CategoryInstaller import CategoryInstaller
	19
	20	PLUGIN_DIR = 'plugin_models'
	21
	22	def get_model_python_path():
	23	"""
	24	Returns the python path for a model
	25	"""
	26	return os.path.dirname(__file__)
	27
	28
	29	def log(message):
	30	"""
	31	Log a message in a file located in the user's home directory
	32	"""
	33	dir = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR)
	34	out = open(os.path.join(dir, "plugins.log"), 'a')
	35	out.write("%10g: %s\n" % (time.clock(), message))
	36	out.close()
	37
	38
	39	def _check_plugin(model, name):
	40	"""
	41	Do some checking before model adding plugins in the list
	42
	43	:param model: class model to add into the plugin list
	44	:param name:name of the module plugin
	45
	46	:return model: model if valid model or None if not valid
	47
	48	"""
	49	#Check if the plugin is of type Model1DPlugin
	50	if not issubclass(model, Model1DPlugin):
	51	msg = "Plugin %s must be of type Model1DPlugin \n" % str(name)
	52	log(msg)
	53	return None
	54	if model.__name__ != "Model":
	55	msg = "Plugin %s class name must be Model \n" % str(name)
	56	log(msg)
	57	return None
	58	try:
	59	new_instance = model()
	60	except:
	61	msg = "Plugin %s error in __init__ \n\t: %s %s\n" % (str(name),
	62	str(sys.exc_type),
	63	sys.exc_info()[1])
	64	log(msg)
	65	return None
	66
	67	if hasattr(new_instance, "function"):
	68	try:
	69	value = new_instance.function()
	70	except:
	71	msg = "Plugin %s: error writing function \n\t :%s %s\n " % \
	72	(str(name), str(sys.exc_type), sys.exc_info()[1])
	73	log(msg)
	74	return None
	75	else:
	76	msg = "Plugin %s needs a method called function \n" % str(name)
	77	log(msg)
	78	return None
	79	return model
	80
	81
	82	def find_plugins_dir():
	83	"""
	84	Find path of the plugins directory.
	85	The plugin directory is located in the user's home directory.
	86	"""
	87	dir = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR)
	88
	89	# If the plugin directory doesn't exist, create it
	90	if not os.path.isdir(dir):
	91	os.makedirs(dir)
	92
	93	# Find paths needed
	94	try:
	95	# For source
	96	if os.path.isdir(os.path.dirname(__file__)):
	97	p_dir = os.path.join(os.path.dirname(__file__), PLUGIN_DIR)
	98	else:
	99	raise
	100	except:
	101	# Check for data path next to exe/zip file.
	102	#Look for maximum n_dir up of the current dir to find plugins dir
	103	n_dir = 12
	104	p_dir = None
	105	f_dir = os.path.join(os.path.dirname(__file__))
	106	for i in range(n_dir):
	107	if i > 1:
	108	f_dir, _ = os.path.split(f_dir)
	109	plugin_path = os.path.join(f_dir, PLUGIN_DIR)
	110	if os.path.isdir(plugin_path):
	111	p_dir = plugin_path
	112	break
	113	if not p_dir:
	114	raise
	115	# Place example user models as needed
	116	if os.path.isdir(p_dir):
	117	for file in os.listdir(p_dir):
	118	file_path = os.path.join(p_dir, file)
	119	if os.path.isfile(file_path):
	120	if file.split(".")[-1] == 'py' and\
	121	file.split(".")[0] != '__init__':
	122	if not os.path.isfile(os.path.join(dir, file)):
	123	shutil.copy(file_path, dir)
	124
	125	return dir
	126
	127
	128	class ReportProblem:
	129	"""
	130	Class to check for problems with specific values
	131	"""
	132	def __nonzero__(self):
	133	type, value, traceback = sys.exc_info()
	134	if type is not None and issubclass(type, py_compile.PyCompileError):
	135	print "Problem with", repr(value)
	136	raise type, value, traceback
	137	return 1
	138
	139	report_problem = ReportProblem()
	140
	141
	142	def compile_file(dir):
	143	"""
	144	Compile a py file
	145	"""
	146	try:
	147	import compileall
	148	compileall.compile_dir(dir=dir, ddir=dir, force=1,
	149	quiet=report_problem)
	150	except:
	151	return sys.exc_info()[1]
	152	return None
	153
	154
	155	def _findModels(dir):
	156	"""
	157	"""
	158	# List of plugin objects
	159	plugins = {}
	160	dir = find_plugins_dir()
	161	# Go through files in plug-in directory
	162	#always recompile the folder plugin
	163	if not os.path.isdir(dir):
	164	msg = "SasView couldn't locate Model plugin folder."
	165	msg += """ "%s" does not exist""" % dir
	166	logging.warning(msg)
	167	return plugins
	168	else:
	169	log("looking for models in: %s" % str(dir))
	170	compile_file(dir)
	171	logging.info("plugin model dir: %s" % str(dir))
	172	try:
	173	list = os.listdir(dir)
	174	for item in list:
	175	toks = os.path.splitext(os.path.basename(item))
	176	if toks[1] == '.py' and not toks[0] == '__init__':
	177	name = toks[0]
	178
	179	path = [os.path.abspath(dir)]
	180	file = None
	181	try:
	182	(file, path, info) = imp.find_module(name, path)
	183	module = imp.load_module(name, file, item, info)
	184	if hasattr(module, "Model"):
	185	try:
	186	if _check_plugin(module.Model, name) != None:
	187	plugins[name] = module.Model
	188	except:
	189	msg = "Error accessing Model"
	190	msg += "in %s\n %s %s\n" % (name,
	191	str(sys.exc_type),
	192	sys.exc_info()[1])
	193	log(msg)
	194	except:
	195	msg = "Error accessing Model"
	196	msg += " in %s\n %s %s \n" % (name,
	197	str(sys.exc_type),
	198	sys.exc_info()[1])
	199	log(msg)
	200	finally:
	201
	202	if not file == None:
	203	file.close()
	204	except:
	205	# Don't deal with bad plug-in imports. Just skip.
	206	msg = "Could not import model plugin: %s" % sys.exc_info()[1]
	207	log(msg)
	208	return plugins
	209
	210
	211	class ModelList(object):
	212	"""
	213	Contains dictionary of model and their type
	214	"""
	215	def __init__(self):
	216	"""
	217	"""
	218	self.mydict = {}
	219
	220	def set_list(self, name, mylist):
	221	"""
	222	:param name: the type of the list
	223	:param mylist: the list to add
	224
	225	"""
	226	if name not in self.mydict.keys():
	227	self.reset_list(name, mylist)
	228
	229	def reset_list(self, name, mylist):
	230	"""
	231	:param name: the type of the list
	232	:param mylist: the list to add
	233	"""
	234	self.mydict[name] = mylist
	235
	236	def get_list(self):
	237	"""
	238	return all the list stored in a dictionary object
	239	"""
	240	return self.mydict
	241
	242
	243	class ModelManagerBase:
	244	"""
	245	Base class for the model manager
	246	"""
	247	## external dict for models
	248	model_combobox = ModelList()
	249	## Dictionary of form factor models
	250	form_factor_dict = {}
	251	## dictionary of structure factor models
	252	struct_factor_dict = {}
	253	##list of shape models -- this is superseded by categories
	254	# shape_list = []
	255	## shape independent model list-- this is superseded by categories
	256	# shape_indep_list = []
	257	##list of structure factors
	258	struct_list = []
	259	##list of model allowing multiplication by a structure factor
	260	multiplication_factor = []
	261	##list of multifunctional shapes (i.e. that have user defined number of levels
	262	multi_func_list = []
	263	## list of added models -- currently python models found in the plugin dir.
	264	plugins = []
	265	## Event owner (guiframe)
	266	event_owner = None
	267	last_time_dir_modified = 0
	268
	269	def __init__(self):
	270	"""
	271	"""
	272	self.model_dictionary = {}
	273	self.stored_plugins = {}
	274	self._getModelList()
	275
	276	def findModels(self):
	277	"""
	278	find plugin model in directory of plugin .recompile all file
	279	in the directory if file were modified
	280	"""
	281	temp = {}
	282	if self.is_changed():
	283	return _findModels(dir)
	284	logging.info("plugin model : %s" % str(temp))
	285	return temp
	286
	287	def _getModelList(self):
	288	"""
	289	List of models we want to make available by default
	290	for this application
	291
	292	:return: the next free event ID following the new menu events
	293
	294	"""
	295
	296	## NOTE: as of April 26, 2014, as part of first pass on fixing categories,
	297	## all the appends to shape_list or shape_independent_list are
	298	## commented out. They should be possible to remove. They are in
	299	## fact a "category" of model whereas the other list are actually
	300	## "attributes" of a model. In other words is it a structure factor
	301	## that can be used against a form factor, is it a form factor that is
	302	## knows how to be multiplied by a structure factor, does it have user
	303	## defined number of parameters, etc.
	304	##
	305	## We hope this whole list will be superseded by the new C models
	306	## structure where each model will provide a method to interrogate it
	307	## about its "attributes" -- then this long list becomes a loop reading
	308	## each model in the category list to populate the "attribute"lists.
	309	## We should also refactor the whole category vs attribute list
	310	## structure when doing this as now the attribute lists think they are
	311	## also category lists.
	312	##
	313	## -PDB April 26, 2014
	314
	315	# regular model names only
	316	base_message = "Unable to load model {0}"
	317	try:
	318	self.model_name_list = []
	319	from sas.models.SphereModel import SphereModel
	320	self.model_dictionary[SphereModel.__name__] = SphereModel
	321	# self.shape_list.append(SphereModel)
	322	self.multiplication_factor.append(SphereModel)
	323	self.model_name_list.append(SphereModel.__name__)
	324	except:
	325	logging.error(base_message.format(SphereModel.__name__))
	326
	327	try:
	328	from sas.models.BinaryHSModel import BinaryHSModel
	329	self.model_dictionary[BinaryHSModel.__name__] = BinaryHSModel
	330	# self.shape_list.append(BinaryHSModel)
	331	self.model_name_list.append(BinaryHSModel.__name__)
	332	except:
	333	logging.error(base_message.format(BinaryHSModel.__name__))
	334
	335	try:
	336	from sas.models.FuzzySphereModel import FuzzySphereModel
	337	self.model_dictionary[FuzzySphereModel.__name__] = FuzzySphereModel
	338	# self.shape_list.append(FuzzySphereModel)
	339	self.multiplication_factor.append(FuzzySphereModel)
	340	self.model_name_list.append(FuzzySphereModel.__name__)
	341	except:
	342	logging.error(base_message.format(FuzzySphereModel.__name__))
	343
	344	try:
	345	from sas.models.RaspBerryModel import RaspBerryModel
	346	self.model_dictionary[RaspBerryModel.__name__] = RaspBerryModel
	347	# self.shape_list.append(RaspBerryModel)
	348	self.model_name_list.append(RaspBerryModel.__name__)
	349	except:
	350	logging.error(base_message.format(RaspBerryModel.__name__))
	351
	352	try:
	353	from sas.models.CoreShellModel import CoreShellModel
	354
	355	self.model_dictionary[CoreShellModel.__name__] = CoreShellModel
	356	# self.shape_list.append(CoreShellModel)
	357	self.multiplication_factor.append(CoreShellModel)
	358	self.model_name_list.append(CoreShellModel.__name__)
	359	except:
	360	logging.error(base_message.format(CoreShellModel.__name__))
	361
	362	try:
	363	from sas.models.Core2ndMomentModel import Core2ndMomentModel
	364	self.model_dictionary[Core2ndMomentModel.__name__] = Core2ndMomentModel
	365	# self.shape_list.append(Core2ndMomentModel)
	366	self.model_name_list.append(Core2ndMomentModel.__name__)
	367	except:
	368	logging.error(base_message.format(Core2ndMomentModel.__name__))
	369
	370	try:
	371	from sas.models.CoreMultiShellModel import CoreMultiShellModel
	372	self.model_dictionary[CoreMultiShellModel.__name__] = CoreMultiShellModel
	373	# self.shape_list.append(CoreMultiShellModel)
	374	self.multiplication_factor.append(CoreMultiShellModel)
	375	self.multi_func_list.append(CoreMultiShellModel)
	376	except:
	377	logging.error(base_message.format(CoreMultiShellModel.__name__))
	378
	379	try:
	380	from sas.models.VesicleModel import VesicleModel
	381	self.model_dictionary[VesicleModel.__name__] = VesicleModel
	382	# self.shape_list.append(VesicleModel)
	383	self.multiplication_factor.append(VesicleModel)
	384	self.model_name_list.append(VesicleModel.__name__)
	385	except:
	386	logging.error(base_message.format(VesicleModel.__name__))
	387
	388	try:
	389	from sas.models.MultiShellModel import MultiShellModel
	390	self.model_dictionary[MultiShellModel.__name__] = MultiShellModel
	391	# self.shape_list.append(MultiShellModel)
	392	self.multiplication_factor.append(MultiShellModel)
	393	self.model_name_list.append(MultiShellModel.__name__)
	394	except:
	395	logging.error(base_message.format(MultiShellModel.__name__))
	396
	397	try:
	398	from sas.models.OnionExpShellModel import OnionExpShellModel
	399	self.model_dictionary[OnionExpShellModel.__name__] = OnionExpShellModel
	400	# self.shape_list.append(OnionExpShellModel)
	401	self.multiplication_factor.append(OnionExpShellModel)
	402	self.multi_func_list.append(OnionExpShellModel)
	403	except:
	404	logging.error(base_message.format(OnionExpShellModel.__name__))
	405
	406	try:
	407	from sas.models.SphericalSLDModel import SphericalSLDModel
	408
	409	self.model_dictionary[SphericalSLDModel.__name__] = SphericalSLDModel
	410	# self.shape_list.append(SphericalSLDModel)
	411	self.multiplication_factor.append(SphericalSLDModel)
	412	self.multi_func_list.append(SphericalSLDModel)
	413	except:
	414	logging.error(base_message.format(SphericalSLDModel.__name__))
	415
	416	try:
	417	from sas.models.LinearPearlsModel import LinearPearlsModel
	418
	419	self.model_dictionary[LinearPearlsModel.__name__] = LinearPearlsModel
	420	# self.shape_list.append(LinearPearlsModel)
	421	self.model_name_list.append(LinearPearlsModel.__name__)
	422	except:
	423	logging.error(base_message.format(LinearPearlsModel.__name__))
	424
	425	try:
	426	from sas.models.PearlNecklaceModel import PearlNecklaceModel
	427
	428	self.model_dictionary[PearlNecklaceModel.__name__] = PearlNecklaceModel
	429	# self.shape_list.append(PearlNecklaceModel)
	430	self.model_name_list.append(PearlNecklaceModel.__name__)
	431	except:
	432	logging.error(base_message.format(PearlNecklaceModel.__name__))
	433
	434	try:
	435	from sas.models.CylinderModel import CylinderModel
	436
	437	self.model_dictionary[CylinderModel.__name__] = CylinderModel
	438	# self.shape_list.append(CylinderModel)
	439	self.multiplication_factor.append(CylinderModel)
	440	self.model_name_list.append(CylinderModel.__name__)
	441	except:
	442	logging.error(base_message.format(CylinderModel.__name__))
	443
	444	try:
	445	from sas.models.CoreShellCylinderModel import CoreShellCylinderModel
	446
	447	self.model_dictionary[CoreShellCylinderModel.__name__] = CoreShellCylinderModel
	448	# self.shape_list.append(CoreShellCylinderModel)
	449	self.multiplication_factor.append(CoreShellCylinderModel)
	450	self.model_name_list.append(CoreShellCylinderModel.__name__)
	451	except:
	452	logging.error(base_message.format(CoreShellCylinderModel.__name__))
	453
	454	try:
	455	from sas.models.CoreShellBicelleModel import CoreShellBicelleModel
	456
	457	self.model_dictionary[CoreShellBicelleModel.__name__] = CoreShellBicelleModel
	458	# self.shape_list.append(CoreShellBicelleModel)
	459	self.multiplication_factor.append(CoreShellBicelleModel)
	460	self.model_name_list.append(CoreShellBicelleModel.__name__)
	461	except:
	462	logging.error(base_message.format(CoreShellBicelleModel.__name__))
	463
	464	try:
	465	from sas.models.HollowCylinderModel import HollowCylinderModel
	466
	467	self.model_dictionary[HollowCylinderModel.__name__] = HollowCylinderModel
	468	# self.shape_list.append(HollowCylinderModel)
	469	self.multiplication_factor.append(HollowCylinderModel)
	470	self.model_name_list.append(HollowCylinderModel.__name__)
	471	except:
	472	logging.error(base_message.format(HollowCylinderModel.__name__))
	473
	474	try:
	475	from sas.models.FlexibleCylinderModel import FlexibleCylinderModel
	476
	477	self.model_dictionary[FlexibleCylinderModel.__name__] = FlexibleCylinderModel
	478	# self.shape_list.append(FlexibleCylinderModel)
	479	self.model_name_list.append(FlexibleCylinderModel.__name__)
	480	except:
	481	logging.error(base_message.format(FlexibleCylinderModel.__name__))
	482
	483	try:
	484	from sas.models.FlexCylEllipXModel import FlexCylEllipXModel
	485
	486	self.model_dictionary[FlexCylEllipXModel.__name__] = FlexCylEllipXModel
	487	# self.shape_list.append(FlexCylEllipXModel)
	488	self.model_name_list.append(FlexCylEllipXModel.__name__)
	489	except:
	490	logging.error(base_message.format(FlexCylEllipXModel.__name__))
	491
	492	try:
	493	from sas.models.StackedDisksModel import StackedDisksModel
	494
	495	self.model_dictionary[StackedDisksModel.__name__] = StackedDisksModel
	496	# self.shape_list.append(StackedDisksModel)
	497	self.multiplication_factor.append(StackedDisksModel)
	498	self.model_name_list.append(StackedDisksModel.__name__)
	499	except:
	500	logging.error(base_message.format(StackedDisksModel.__name__))
	501
	502	try:
	503	from sas.models.ParallelepipedModel import ParallelepipedModel
	504
	505	self.model_dictionary[ParallelepipedModel.__name__] = ParallelepipedModel
	506	# self.shape_list.append(ParallelepipedModel)
	507	self.multiplication_factor.append(ParallelepipedModel)
	508	self.model_name_list.append(ParallelepipedModel.__name__)
	509	except:
	510	logging.error(base_message.format(ParallelepipedModel.__name__))
	511
	512	try:
	513	from sas.models.CSParallelepipedModel import CSParallelepipedModel
	514
	515	self.model_dictionary[CSParallelepipedModel.__name__] = CSParallelepipedModel
	516	# self.shape_list.append(CSParallelepipedModel)
	517	self.multiplication_factor.append(CSParallelepipedModel)
	518	self.model_name_list.append(CSParallelepipedModel.__name__)
	519	except:
	520	logging.error(base_message.format(CSParallelepipedModel.__name__))
	521
	522	try:
	523	from sas.models.EllipticalCylinderModel import EllipticalCylinderModel
	524
	525	self.model_dictionary[EllipticalCylinderModel.__name__] = EllipticalCylinderModel
	526	# self.shape_list.append(EllipticalCylinderModel)
	527	self.multiplication_factor.append(EllipticalCylinderModel)
	528	self.model_name_list.append(EllipticalCylinderModel.__name__)
	529	except:
	530	logging.error(base_message.format(EllipticalCylinderModel.__name__))
	531
	532	try:
	533	from sas.models.CappedCylinderModel import CappedCylinderModel
	534
	535	self.model_dictionary[CappedCylinderModel.__name__] = CappedCylinderModel
	536	# self.shape_list.append(CappedCylinderModel)
	537	self.model_name_list.append(CappedCylinderModel.__name__)
	538	except:
	539	logging.error(base_message.format(CappedCylinderModel.__name__))
	540
	541	try:
	542	from sas.models.EllipsoidModel import EllipsoidModel
	543
	544	self.model_dictionary[EllipsoidModel.__name__] = EllipsoidModel
	545	# self.shape_list.append(EllipsoidModel)
	546	self.multiplication_factor.append(EllipsoidModel)
	547	self.model_name_list.append(EllipsoidModel.__name__)
	548	except:
	549	logging.error(base_message.format(EllipsoidModel.__name__))
	550
	551	try:
	552	from sas.models.CoreShellEllipsoidModel import CoreShellEllipsoidModel
	553
	554	self.model_dictionary[CoreShellEllipsoidModel.__name__] = CoreShellEllipsoidModel
	555	# self.shape_list.append(CoreShellEllipsoidModel)
	556	self.multiplication_factor.append(CoreShellEllipsoidModel)
	557	self.model_name_list.append(CoreShellEllipsoidModel.__name__)
	558	except:
	559	logging.error(base_message.format(CoreShellEllipsoidModel.__name__))
	560
	561	try:
	562	from sas.models.CoreShellEllipsoidXTModel import CoreShellEllipsoidXTModel
	563
	564	self.model_dictionary[CoreShellEllipsoidXTModel.__name__] = CoreShellEllipsoidXTModel
	565	# self.shape_list.append(CoreShellEllipsoidXTModel)
	566	self.multiplication_factor.append(CoreShellEllipsoidXTModel)
	567	self.model_name_list.append(CoreShellEllipsoidXTModel.__name__)
	568	except:
	569	logging.error(base_message.format(CoreShellEllipsoidXTModel.__name__))
	570
	571	try:
	572	from sas.models.TriaxialEllipsoidModel import TriaxialEllipsoidModel
	573
	574	self.model_dictionary[TriaxialEllipsoidModel.__name__] = TriaxialEllipsoidModel
	575	# self.shape_list.append(TriaxialEllipsoidModel)
	576	self.multiplication_factor.append(TriaxialEllipsoidModel)
	577	self.model_name_list.append(TriaxialEllipsoidModel.__name__)
	578	except:
	579	logging.error(base_message.format(TriaxialEllipsoidModel.__name__))
	580
	581	try:
	582	from sas.models.LamellarModel import LamellarModel
	583
	584	self.model_dictionary[LamellarModel.__name__] = LamellarModel
	585	# self.shape_list.append(LamellarModel)
	586	self.model_name_list.append(LamellarModel.__name__)
	587	except:
	588	logging.error(base_message.format(LamellarModel.__name__))
	589
	590	try:
	591	from sas.models.LamellarFFHGModel import LamellarFFHGModel
	592
	593	self.model_dictionary[LamellarFFHGModel.__name__] = LamellarFFHGModel
	594	# self.shape_list.append(LamellarFFHGModel)
	595	self.model_name_list.append(LamellarFFHGModel.__name__)
	596	except:
	597	logging.error(base_message.format(LamellarFFHGModel.__name__))
	598
	599	try:
	600	from sas.models.LamellarPSModel import LamellarPSModel
	601
	602	self.model_dictionary[LamellarPSModel.__name__] = LamellarPSModel
	603	# self.shape_list.append(LamellarPSModel)
	604	self.model_name_list.append(LamellarPSModel.__name__)
	605	except:
	606	logging.error(base_message.format(LamellarPSModel.__name__))
	607
	608	try:
	609	from sas.models.LamellarPSHGModel import LamellarPSHGModel
	610
	611	self.model_dictionary[LamellarPSHGModel.__name__] = LamellarPSHGModel
	612	# self.shape_list.append(LamellarPSHGModel)
	613	self.model_name_list.append(LamellarPSHGModel.__name__)
	614	except:
	615	logging.error(base_message.format(LamellarPSHGModel.__name__))
	616
	617	try:
	618	from sas.models.LamellarPCrystalModel import LamellarPCrystalModel
	619
	620	self.model_dictionary[LamellarPCrystalModel.__name__] = LamellarPCrystalModel
	621	# self.shape_list.append(LamellarPCrystalModel)
	622	self.model_name_list.append(LamellarPCrystalModel.__name__)
	623	except:
	624	logging.error(base_message.format(LamellarPCrystalModel.__name__))
	625
	626	try:
	627	from sas.models.SCCrystalModel import SCCrystalModel
	628
	629	self.model_dictionary[SCCrystalModel.__name__] = SCCrystalModel
	630	# self.shape_list.append(SCCrystalModel)
	631	self.model_name_list.append(SCCrystalModel.__name__)
	632	except:
	633	logging.error(base_message.format(SCCrystalModel.__name__))
	634
	635	try:
	636	from sas.models.FCCrystalModel import FCCrystalModel
	637
	638	self.model_dictionary[FCCrystalModel.__name__] = FCCrystalModel
	639	# self.shape_list.append(FCCrystalModel)
	640	self.model_name_list.append(FCCrystalModel.__name__)
	641	except:
	642	logging.error(base_message.format(FCCrystalModel.__name__))
	643
	644	try:
	645	from sas.models.BCCrystalModel import BCCrystalModel
	646
	647	self.model_dictionary[BCCrystalModel.__name__] = BCCrystalModel
	648	# self.shape_list.append(BCCrystalModel)
	649	self.model_name_list.append(BCCrystalModel.__name__)
	650	except:
	651	logging.error(base_message.format(BCCrystalModel.__name__))
	652
	653
	654	## Structure factor
	655	try:
	656	from sas.models.SquareWellStructure import SquareWellStructure
	657
	658	self.model_dictionary[SquareWellStructure.__name__] = SquareWellStructure
	659	self.struct_list.append(SquareWellStructure)
	660	self.model_name_list.append(SquareWellStructure.__name__)
	661	except:
	662	logging.error(base_message.format(SquareWellStructure.__name__))
	663
	664	try:
	665	from sas.models.HardsphereStructure import HardsphereStructure
	666
	667	self.model_dictionary[HardsphereStructure.__name__] = HardsphereStructure
	668	self.struct_list.append(HardsphereStructure)
	669	self.model_name_list.append(HardsphereStructure.__name__)
	670	except:
	671	logging.error(base_message.format(HardsphereStructure.__name__))
	672
	673	try:
	674	from sas.models.StickyHSStructure import StickyHSStructure
	675
	676	self.model_dictionary[StickyHSStructure.__name__] = StickyHSStructure
	677	self.struct_list.append(StickyHSStructure)
	678	self.model_name_list.append(StickyHSStructure.__name__)
	679	except:
	680	logging.error(base_message.format(StickyHSStructure.__name__))
	681
	682	try:
	683	from sas.models.HayterMSAStructure import HayterMSAStructure
	684
	685	self.model_dictionary[HayterMSAStructure.__name__] = HayterMSAStructure
	686	self.struct_list.append(HayterMSAStructure)
	687	self.model_name_list.append(HayterMSAStructure.__name__)
	688	except:
	689	logging.error(base_message.format(HayterMSAStructure.__name__))
	690
	691
	692
	693	##shape-independent models
	694	try:
	695	from sas.models.PowerLawAbsModel import PowerLawAbsModel
	696
	697	self.model_dictionary[PowerLawAbsModel.__name__] = PowerLawAbsModel
	698	# self.shape_indep_list.append(PowerLawAbsModel)
	699	self.model_name_list.append(PowerLawAbsModel.__name__)
	700	except:
	701	logging.error(base_message.format(PowerLawAbsModel.__name__))
	702
	703	try:
	704	from sas.models.BEPolyelectrolyte import BEPolyelectrolyte
	705
	706	self.model_dictionary[BEPolyelectrolyte.__name__] = BEPolyelectrolyte
	707	# self.shape_indep_list.append(BEPolyelectrolyte)
	708	self.model_name_list.append(BEPolyelectrolyte.__name__)
	709	self.form_factor_dict[str(wx.NewId())] = [SphereModel]
	710	except:
	711	logging.error(base_message.format(BEPolyelectrolyte.__name__))
	712
	713	try:
	714	from sas.models.BroadPeakModel import BroadPeakModel
	715
	716	self.model_dictionary[BroadPeakModel.__name__] = BroadPeakModel
	717	# self.shape_indep_list.append(BroadPeakModel)
	718	self.model_name_list.append(BroadPeakModel.__name__)
	719	except:
	720	logging.error(base_message.format(BroadPeakModel.__name__))
	721
	722	try:
	723	from sas.models.CorrLengthModel import CorrLengthModel
	724
	725	self.model_dictionary[CorrLengthModel.__name__] = CorrLengthModel
	726	# self.shape_indep_list.append(CorrLengthModel)
	727	self.model_name_list.append(CorrLengthModel.__name__)
	728	except:
	729	logging.error(base_message.format(CorrLengthModel.__name__))
	730
	731	try:
	732	from sas.models.DABModel import DABModel
	733
	734	self.model_dictionary[DABModel.__name__] = DABModel
	735	# self.shape_indep_list.append(DABModel)
	736	self.model_name_list.append(DABModel.__name__)
	737	except:
	738	logging.error(base_message.format(DABModel.__name__))
	739
	740	try:
	741	from sas.models.DebyeModel import DebyeModel
	742
	743	self.model_dictionary[DebyeModel.__name__] = DebyeModel
	744	# self.shape_indep_list.append(DebyeModel)
	745	self.model_name_list.append(DebyeModel.__name__)
	746	except:
	747	logging.error(base_message.format(DebyeModel.__name__))
	748
	749	try:
	750	from sas.models.FractalModel import FractalModel
	751
	752	self.model_dictionary[FractalModel.__name__] = FractalModel
	753	# self.shape_indep_list.append(FractalModel)
	754	self.model_name_list.append(FractalModel.__name__)
	755	except:
	756	logging.error(base_message.format(FractalModel.__name__))
	757
	758	try:
	759	from sas.models.FractalCoreShellModel import FractalCoreShellModel
	760
	761	self.model_dictionary[FractalCoreShellModel.__name__] = FractalCoreShellModel
	762	# self.shape_indep_list.append(FractalCoreShellModel)
	763	self.model_name_list.append(FractalCoreShellModel.__name__)
	764	except:
	765	logging.error(base_message.format(FractalCoreShellModel.__name__))
	766
	767	try:
	768	from sas.models.GaussLorentzGelModel import GaussLorentzGelModel
	769
	770	self.model_dictionary[GaussLorentzGelModel.__name__] = GaussLorentzGelModel
	771	# self.shape_indep_list.append(GaussLorentzGelModel)
	772	self.model_name_list.append(GaussLorentzGelModel.__name__)
	773	except:
	774	logging.error(base_message.format(GaussLorentzGelModel.__name__))
	775
	776	try:
	777	from sas.models.GuinierModel import GuinierModel
	778
	779	self.model_dictionary[GuinierModel.__name__] = GuinierModel
	780	# self.shape_indep_list.append(GuinierModel)
	781	self.model_name_list.append(GuinierModel.__name__)
	782	except:
	783	logging.error(base_message.format(GuinierModel.__name__))
	784
	785	try:
	786	from sas.models.GuinierPorodModel import GuinierPorodModel
	787
	788	self.model_dictionary[GuinierPorodModel.__name__] = GuinierPorodModel
	789	# self.shape_indep_list.append(GuinierPorodModel)
	790	self.model_name_list.append(GuinierPorodModel.__name__)
	791	except:
	792	logging.error(base_message.format(GuinierPorodModel.__name__))
	793
	794	try:
	795	from sas.models.LorentzModel import LorentzModel
	796
	797	self.model_dictionary[LorentzModel.__name__] = LorentzModel
	798	# self.shape_indep_list.append(LorentzModel)
	799	self.model_name_list.append(LorentzModel.__name__)
	800	except:
	801	logging.error(base_message.format(LorentzModel.__name__))
	802
	803	try:
	804	from sas.models.MassFractalModel import MassFractalModel
	805
	806	self.model_dictionary[MassFractalModel.__name__] = MassFractalModel
	807	# self.shape_indep_list.append(MassFractalModel)
	808	self.model_name_list.append(MassFractalModel.__name__)
	809	except:
	810	logging.error(base_message.format(MassFractalModel.__name__))
	811
	812	try:
	813	from sas.models.MassSurfaceFractal import MassSurfaceFractal
	814
	815	self.model_dictionary[MassSurfaceFractal.__name__] = MassSurfaceFractal
	816	# self.shape_indep_list.append(MassSurfaceFractal)
	817	self.model_name_list.append(MassSurfaceFractal.__name__)
	818	except:
	819	logging.error(base_message.format(MassSurfaceFractal.__name__))
	820
	821	try:
	822	from sas.models.PeakGaussModel import PeakGaussModel
	823
	824	self.model_dictionary[PeakGaussModel.__name__] = PeakGaussModel
	825	# self.shape_indep_list.append(PeakGaussModel)
	826	self.model_name_list.append(PeakGaussModel.__name__)
	827	except:
	828	logging.error(base_message.format(PeakGaussModel.__name__))
	829
	830	try:
	831	from sas.models.PeakLorentzModel import PeakLorentzModel
	832
	833	self.model_dictionary[PeakLorentzModel.__name__] = PeakLorentzModel
	834	# self.shape_indep_list.append(PeakLorentzModel)
	835	self.model_name_list.append(PeakLorentzModel.__name__)
	836	except:
	837	logging.error(base_message.format(PeakLorentzModel.__name__))
	838
	839	try:
	840	from sas.models.Poly_GaussCoil import Poly_GaussCoil
	841
	842	self.model_dictionary[Poly_GaussCoil.__name__] = Poly_GaussCoil
	843	# self.shape_indep_list.append(Poly_GaussCoil)
	844	self.model_name_list.append(Poly_GaussCoil.__name__)
	845	except:
	846	logging.error(base_message.format(Poly_GaussCoil.__name__))
	847
	848	try:
	849	from sas.models.PolymerExclVolume import PolymerExclVolume
	850
	851	self.model_dictionary[PolymerExclVolume.__name__] = PolymerExclVolume
	852	# self.shape_indep_list.append(PolymerExclVolume)
	853	self.model_name_list.append(PolymerExclVolume.__name__)
	854	except:
	855	logging.error(base_message.format(PolymerExclVolume.__name__))
	856
	857	try:
	858	from sas.models.PorodModel import PorodModel
	859
	860	self.model_dictionary[PorodModel.__name__] = PorodModel
	861	# self.shape_indep_list.append(PorodModel)
	862	self.model_name_list.append(PorodModel.__name__)
	863	except:
	864	logging.error(base_message.format(PorodModel.__name__))
	865
	866	try:
	867	from sas.models.RPA10Model import RPA10Model
	868
	869	self.model_dictionary[RPA10Model.__name__] = RPA10Model
	870	# self.shape_indep_list.append(RPA10Model)
	871	self.multi_func_list.append(RPA10Model)
	872	except:
	873	logging.error(base_message.format(RPA10Model.__name__))
	874
	875	try:
	876	from sas.models.StarPolymer import StarPolymer
	877
	878	self.model_dictionary[StarPolymer.__name__] = StarPolymer
	879	# self.shape_indep_list.append(StarPolymer)
	880	self.model_name_list.append(StarPolymer.__name__)
	881	except:
	882	logging.error(base_message.format(StarPolymer.__name__))
	883
	884	try:
	885	from sas.models.SurfaceFractalModel import SurfaceFractalModel
	886
	887	self.model_dictionary[SurfaceFractalModel.__name__] = SurfaceFractalModel
	888	# self.shape_indep_list.append(SurfaceFractalModel)
	889	self.model_name_list.append(SurfaceFractalModel.__name__)
	890	except:
	891	logging.error(base_message.format(SurfaceFractalModel.__name__))
	892
	893	try:
	894	from sas.models.TeubnerStreyModel import TeubnerStreyModel
	895
	896	self.model_dictionary[TeubnerStreyModel.__name__] = TeubnerStreyModel
	897	# self.shape_indep_list.append(TeubnerStreyModel)
	898	self.model_name_list.append(TeubnerStreyModel.__name__)
	899	except:
	900	logging.error(base_message.format(TeubnerStreyModel.__name__))
	901
	902	try:
	903	from sas.models.TwoLorentzianModel import TwoLorentzianModel
	904
	905	self.model_dictionary[TwoLorentzianModel.__name__] = TwoLorentzianModel
	906	# self.shape_indep_list.append(TwoLorentzianModel)
	907	self.model_name_list.append(TwoLorentzianModel.__name__)
	908	except:
	909	logging.error(base_message.format(TwoLorentzianModel.__name__))
	910
	911	try:
	912	from sas.models.TwoPowerLawModel import TwoPowerLawModel
	913
	914	self.model_dictionary[TwoPowerLawModel.__name__] = TwoPowerLawModel
	915	# self.shape_indep_list.append(TwoPowerLawModel)
	916	self.model_name_list.append(TwoPowerLawModel.__name__)
	917	except:
	918	logging.error(base_message.format(TwoPowerLawModel.__name__))
	919
	920	try:
	921	from sas.models.UnifiedPowerRgModel import UnifiedPowerRgModel
	922
	923	self.model_dictionary[UnifiedPowerRgModel.__name__] = UnifiedPowerRgModel
	924	# self.shape_indep_list.append(UnifiedPowerRgModel)
	925	self.multi_func_list.append(UnifiedPowerRgModel)
	926	except:
	927	logging.error(base_message.format(UnifiedPowerRgModel.__name__))
	928
	929	try:
	930	from sas.models.LineModel import LineModel
	931
	932	self.model_dictionary[LineModel.__name__] = LineModel
	933	# self.shape_indep_list.append(LineModel)
	934	self.model_name_list.append(LineModel.__name__)
	935	except:
	936	logging.error(base_message.format(LineModel.__name__))
	937
	938	try:
	939	from sas.models.ReflectivityModel import ReflectivityModel
	940
	941	self.model_dictionary[ReflectivityModel.__name__] = ReflectivityModel
	942	# self.shape_indep_list.append(ReflectivityModel)
	943	self.multi_func_list.append(ReflectivityModel)
	944	except:
	945	logging.error(base_message.format(ReflectivityModel.__name__))
	946
	947	try:
	948	from sas.models.ReflectivityIIModel import ReflectivityIIModel
	949
	950	self.model_dictionary[ReflectivityIIModel.__name__] = ReflectivityIIModel
	951	# self.shape_indep_list.append(ReflectivityIIModel)
	952	self.multi_func_list.append(ReflectivityIIModel)
	953	except:
	954	logging.error(base_message.format(ReflectivityIIModel.__name__))
	955
	956	try:
	957	from sas.models.GelFitModel import GelFitModel
	958
	959	self.model_dictionary[GelFitModel.__name__] = GelFitModel
	960	# self.shape_indep_list.append(GelFitModel)
	961	self.model_name_list.append(GelFitModel.__name__)
	962	except:
	963	logging.error(base_message.format(GelFitModel.__name__))
	964
	965	try:
	966	from sas.models.PringlesModel import PringlesModel
	967
	968	self.model_dictionary[PringlesModel.__name__] = PringlesModel
	969	# self.shape_indep_list.append(PringlesModel)
	970	self.model_name_list.append(PringlesModel.__name__)
	971	except:
	972	logging.error(base_message.format(PringlesModel.__name__))
	973
	974	try:
	975	from sas.models.RectangularPrismModel import RectangularPrismModel
	976
	977	self.model_dictionary[RectangularPrismModel.__name__] = RectangularPrismModel
	978	# self.shape_list.append(RectangularPrismModel)
	979	self.multiplication_factor.append(RectangularPrismModel)
	980	self.model_name_list.append(RectangularPrismModel.__name__)
	981	except:
	982	logging.error(base_message.format(RectangularPrismModel.__name__))
	983
	984	try:
	985	from sas.models.RectangularHollowPrismInfThinWallsModel import RectangularHollowPrismInfThinWallsModel
	986
	987	self.model_dictionary[RectangularHollowPrismInfThinWallsModel.__name__] = RectangularHollowPrismInfThinWallsModel
	988	# self.shape_list.append(RectangularHollowPrismInfThinWallsModel)
	989	self.multiplication_factor.append(RectangularHollowPrismInfThinWallsModel)
	990	self.model_name_list.append(RectangularHollowPrismInfThinWallsModel.__name__)
	991	except:
	992	logging.error(base_message.format(RectangularHollowPrismInfThinWallsModel.__name__))
	993
	994	try:
	995	from sas.models.RectangularHollowPrismModel import RectangularHollowPrismModel
	996
	997	self.model_dictionary[RectangularHollowPrismModel.__name__] = RectangularHollowPrismModel
	998	# self.shape_list.append(RectangularHollowPrismModel)
	999	self.multiplication_factor.append(RectangularHollowPrismModel)
	1000	self.model_name_list.append(RectangularHollowPrismModel.__name__)
	1001	except:
	1002	logging.error(base_message.format(RectangularHollowPrismModel.__name__))
	1003
	1004	try:
	1005	from sas.models.MicelleSphCoreModel import MicelleSphCoreModel
	1006
	1007	self.model_dictionary[MicelleSphCoreModel.__name__] = MicelleSphCoreModel
	1008	# self.shape_list.append(MicelleSphCoreModel)
	1009	self.multiplication_factor.append(MicelleSphCoreModel)
	1010	self.model_name_list.append(MicelleSphCoreModel.__name__)
	1011	except:
	1012	logging.error(base_message.format(MicelleSphCoreModel.__name__))
	1013
	1014
	1015
	1016	#from sas.models.FractalO_Z import FractalO_Z
	1017	#self.model_dictionary[FractalO_Z.__name__] = FractalO_Z
	1018	#self.shape_indep_list.append(FractalO_Z)
	1019	#self.model_name_list.append(FractalO_Z.__name__)
	1020
	1021	#Looking for plugins
	1022	self.stored_plugins = self.findModels()
	1023	self.plugins = self.stored_plugins.values()
	1024	for name, plug in self.stored_plugins.iteritems():
	1025	self.model_dictionary[name] = plug
	1026
	1027	self._get_multifunc_models()
	1028
	1029	return 0
	1030
	1031	def is_changed(self):
	1032	"""
	1033	check the last time the plugin dir has changed and return true
	1034	is the directory was modified else return false
	1035	"""
	1036	is_modified = False
	1037	plugin_dir = find_plugins_dir()
	1038	if os.path.isdir(plugin_dir):
	1039	temp = os.path.getmtime(plugin_dir)
	1040	if self.last_time_dir_modified != temp:
	1041	is_modified = True
	1042	self.last_time_dir_modified = temp
	1043
	1044	return is_modified
	1045
	1046	def update(self):
	1047	"""
	1048	return a dictionary of model if
	1049	new models were added else return empty dictionary
	1050	"""
	1051	new_plugins = self.findModels()
	1052	if len(new_plugins) > 0:
	1053	for name, plug in new_plugins.iteritems():
	1054	if name not in self.stored_plugins.keys():
	1055	self.stored_plugins[name] = plug
	1056	self.plugins.append(plug)
	1057	self.model_dictionary[name] = plug
	1058	self.model_combobox.set_list("Customized Models", self.plugins)
	1059	return self.model_combobox.get_list()
	1060	else:
	1061	return {}
	1062
	1063	def pulgins_reset(self):
	1064	"""
	1065	return a dictionary of model
	1066	"""
	1067	self.plugins = []
	1068	new_plugins = _findModels(dir)
	1069	for name, plug in new_plugins.iteritems():
	1070	for stored_name, _ in self.stored_plugins.iteritems():
	1071	if name == stored_name:
	1072	del self.stored_plugins[name]
	1073	del self.model_dictionary[name]
	1074	break
	1075	self.stored_plugins[name] = plug
	1076	self.plugins.append(plug)
	1077	self.model_dictionary[name] = plug
	1078
	1079	self.model_combobox.reset_list("Customized Models", self.plugins)
	1080	return self.model_combobox.get_list()
	1081
	1082	## I believe the next four methods are for the old form factor GUI
	1083	## where the dropdown showed a list of categories which then rolled out
	1084	## in a second dropdown to the side. Some testing shows they indeed no longer
	1085	## seem to be called. If no problems are found during testing of release we
	1086	## can remove this huge chunck of stuff.
	1087	##
	1088	## -PDB April 26, 2014
	1089
	1090	# def populate_menu(self, modelmenu, event_owner):
	1091	# """
	1092	# Populate a menu with our models
	1093	#
	1094	# :param id: first menu event ID to use when binding the menu events
	1095	# :param modelmenu: wx.Menu object to populate
	1096	# :param event_owner: wx object to bind the menu events to
	1097	#
	1098	# :return: the next free event ID following the new menu events
	1099	#
	1100	# """
	1101	#
	1102	## Fill model lists
	1103	# self._getModelList()
	1104	## store reference to model menu of guiframe
	1105	# self.modelmenu = modelmenu
	1106	## guiframe reference
	1107	# self.event_owner = event_owner
	1108
	1109	# shape_submenu = wx.Menu()
	1110	# shape_indep_submenu = wx.Menu()
	1111	# structure_factor = wx.Menu()
	1112	# added_models = wx.Menu()
	1113	# multip_models = wx.Menu()
	1114	## create menu with shape
	1115	# self._fill_simple_menu(menuinfo=["Shapes",
	1116	# shape_submenu,
	1117	# " simple shape"],
	1118	# list1=self.shape_list)
	1119
	1120	# self._fill_simple_menu(menuinfo=["Shape-Independent",
	1121	# shape_indep_submenu,
	1122	# "List of shape-independent models"],
	1123	# list1=self.shape_indep_list)
	1124
	1125	# self._fill_simple_menu(menuinfo=["Structure Factors",
	1126	# structure_factor,
	1127	# "List of Structure factors models"],
	1128	# list1=self.struct_list)
	1129
	1130	# self._fill_plugin_menu(menuinfo=["Customized Models", added_models,
	1131	# "List of additional models"],
	1132	# list1=self.plugins)
	1133
	1134	# self._fill_menu(menuinfo=["P(Q)*S(Q)", multip_models,
	1135	# "mulplication of 2 models"],
	1136	# list1=self.multiplication_factor,
	1137	# list2=self.struct_list)
	1138	# return 0
	1139
	1140	# def _fill_plugin_menu(self, menuinfo, list1):
	1141	# """
	1142	# fill the plugin menu with costumized models
	1143	# """
	1144	# print ("got to fill plugin menu")
	1145	# if len(list1) == 0:
	1146	# id = wx.NewId()
	1147	# msg = "No model available check plugins.log for errors to fix problem"
	1148	# menuinfo[1].Append(int(id), "Empty", msg)
	1149	# self._fill_simple_menu(menuinfo, list1)
	1150
	1151	# def _fill_simple_menu(self, menuinfo, list1):
	1152	# """
	1153	# Fill the menu with list item
	1154	#
	1155	# :param modelmenu: the menu to fill
	1156	# :param menuinfo: submenu item for the first column of this modelmenu
	1157	# with info.Should be a list :
	1158	# [name(string) , menu(wx.menu), help(string)]
	1159	# :param list1: contains item (form factor )to fill modelmenu second column
	1160	#
	1161	# """
	1162	# if len(list1) > 0:
	1163	# self.model_combobox.set_list(menuinfo[0], list1)
	1164
	1165	# for item in list1:
	1166	# try:
	1167	# id = wx.NewId()
	1168	# struct_factor = item()
	1169	# struct_name = struct_factor.__class__.__name__
	1170	# if hasattr(struct_factor, "name"):
	1171	# struct_name = struct_factor.name
	1172	#
	1173	# menuinfo[1].Append(int(id), struct_name, struct_name)
	1174	# if not item in self.struct_factor_dict.itervalues():
	1175	# self.struct_factor_dict[str(id)] = item
	1176	# wx.EVT_MENU(self.event_owner, int(id), self._on_model)
	1177	# except:
	1178	# msg = "Error Occured: %s" % sys.exc_value
	1179	# wx.PostEvent(self.event_owner, StatusEvent(status=msg))
	1180	#
	1181	# id = wx.NewId()
	1182	# self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
	1183	#
	1184	# def _fill_menu(self, menuinfo, list1, list2):
	1185	# """
	1186	# Fill the menu with list item
	1187	#
	1188	# :param menuinfo: submenu item for the first column of this modelmenu
	1189	# with info.Should be a list :
	1190	# [name(string) , menu(wx.menu), help(string)]
	1191	# :param list1: contains item (form factor )to fill modelmenu second column
	1192	# :param list2: contains item (Structure factor )to fill modelmenu
	1193	# third column
	1194	#
	1195	# """
	1196	# if len(list1) > 0:
	1197	# self.model_combobox.set_list(menuinfo[0], list1)
	1198	#
	1199	# for item in list1:
	1200	# form_factor = item()
	1201	# form_name = form_factor.__class__.__name__
	1202	# if hasattr(form_factor, "name"):
	1203	# form_name = form_factor.name
	1204	# ### store form factor to return to other users
	1205	# newmenu = wx.Menu()
	1206	# if len(list2) > 0:
	1207	# for model in list2:
	1208	# id = wx.NewId()
	1209	# struct_factor = model()
	1210	# name = struct_factor.__class__.__name__
	1211	# if hasattr(struct_factor, "name"):
	1212	# name = struct_factor.name
	1213	# newmenu.Append(id, name, name)
	1214	# wx.EVT_MENU(self.event_owner, int(id), self._on_model)
	1215	# ## save form_fact and struct_fact
	1216	# self.form_factor_dict[int(id)] = [form_factor,
	1217	# struct_factor]
	1218	#
	1219	# form_id = wx.NewId()
	1220	# menuinfo[1].AppendMenu(int(form_id), form_name,
	1221	# newmenu, menuinfo[2])
	1222	# id = wx.NewId()
	1223	# self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
	1224
	1225	def _on_model(self, evt):
	1226	"""
	1227	React to a model menu event
	1228
	1229	:param event: wx menu event
	1230
	1231	"""
	1232	if int(evt.GetId()) in self.form_factor_dict.keys():
	1233	from sas.models.MultiplicationModel import MultiplicationModel
	1234	self.model_dictionary[MultiplicationModel.__name__] = MultiplicationModel
	1235	model1, model2 = self.form_factor_dict[int(evt.GetId())]
	1236	model = MultiplicationModel(model1, model2)
	1237	else:
	1238	model = self.struct_factor_dict[str(evt.GetId())]()
	1239
	1240	#TODO: investigate why the following two lines were left in the code
	1241	# even though the ModelEvent class doesn't exist
	1242	#evt = ModelEvent(model=model)
	1243	#wx.PostEvent(self.event_owner, evt)
	1244
	1245	def _get_multifunc_models(self):
	1246	"""
	1247	Get the multifunctional models
	1248	"""
	1249	for item in self.plugins:
	1250	try:
	1251	# check the multiplicity if any
	1252	if item.multiplicity_info[0] > 1:
	1253	self.multi_func_list.append(item)
	1254	except:
	1255	# pass to other items
	1256	pass
	1257
	1258	def get_model_list(self):
	1259	"""
	1260	return dictionary of models for fitpanel use
	1261
	1262	"""
	1263	## Model_list now only contains attribute lists not category list.
	1264	## Eventually this should be in one master list -- read in category
	1265	## list then pull those models that exist and get attributes then add
	1266	## to list ..and if model does not exist remove from list as now
	1267	## and update json file.
	1268	##
	1269	## -PDB April 26, 2014
	1270
	1271	# self.model_combobox.set_list("Shapes", self.shape_list)
	1272	# self.model_combobox.set_list("Shape-Independent",
	1273	# self.shape_indep_list)
	1274	self.model_combobox.set_list("Structure Factors", self.struct_list)
	1275	self.model_combobox.set_list("Customized Models", self.plugins)
	1276	self.model_combobox.set_list("P(Q)*S(Q)", self.multiplication_factor)
	1277	self.model_combobox.set_list("multiplication",
	1278	self.multiplication_factor)
	1279	self.model_combobox.set_list("Multi-Functions", self.multi_func_list)
	1280	return self.model_combobox.get_list()
	1281
	1282	def get_model_name_list(self):
	1283	"""
	1284	return regular model name list
	1285	"""
	1286	return self.model_name_list
	1287
	1288	def get_model_dictionary(self):
	1289	"""
	1290	return dictionary linking model names to objects
	1291	"""
	1292	return self.model_dictionary
	1293
	1294
	1295	class ModelManager(object):
	1296	"""
	1297	implement model
	1298	"""
	1299	__modelmanager = ModelManagerBase()
	1300	cat_model_list = [model_name for model_name \
	1301	in __modelmanager.model_dictionary.keys() \
	1302	if model_name not in __modelmanager.stored_plugins.keys()]
	1303
	1304	CategoryInstaller.check_install(model_list=cat_model_list)
	1305	def findModels(self):
	1306	return self.__modelmanager.findModels()
	1307
	1308	def _getModelList(self):
	1309	return self.__modelmanager._getModelList()
	1310
	1311	def is_changed(self):
	1312	return self.__modelmanager.is_changed()
	1313
	1314	def update(self):
	1315	return self.__modelmanager.update()
	1316
	1317	def pulgins_reset(self):
	1318	return self.__modelmanager.pulgins_reset()
	1319
	1320	def populate_menu(self, modelmenu, event_owner):
	1321	return self.__modelmanager.populate_menu(modelmenu, event_owner)
	1322
	1323	def _on_model(self, evt):
	1324	return self.__modelmanager._on_model(evt)
	1325
	1326	def _get_multifunc_models(self):
	1327	return self.__modelmanager._get_multifunc_models()
	1328
	1329	def get_model_list(self):
	1330	return self.__modelmanager.get_model_list()
	1331
	1332	def get_model_name_list(self):
	1333	return self.__modelmanager.get_model_name_list()
	1334
	1335	def get_model_dictionary(self):
	1336	return self.__modelmanager.get_model_dictionary()

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/src/sas/perspectives/fitting/models.py @ 686fd10

Download in other formats: