Changeset e5ea2d0 in sasview


Ignore:
Timestamp:
Mar 16, 2016 11:24:07 AM (9 years ago)
Author:
ajj
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
a301204
Parents:
f66d9d1 (diff), 55c7d4b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into sasmodels-integration

Files:
11 edited

Legend:

Unmodified
Added
Removed

  • docs/sphinx-docs/build_sphinx.py

    r2fb09c4 rba31ed1  
    3232SPHINX_SOURCE = os.path.join(CURRENT_SCRIPT_DIR, "source") 
    3333SPHINX_SOURCE_API = os.path.join(SPHINX_SOURCE, "dev", "api") 
    34 SPHINX_SOURCE_GUIFRAME = os.path.join(SPHINX_SOURCE, "user", "guiframe") 
     34SPHINX_SOURCE_GUIFRAME = os.path.join(SPHINX_SOURCE, "user", "sasgui", "guiframe") 
    3535SPHINX_SOURCE_MODELS = os.path.join(SPHINX_SOURCE, "user", "models") 
    36 SPHINX_SOURCE_PERSPECTIVES = os.path.join(SPHINX_SOURCE, "user", "perspectives") 
     36SPHINX_SOURCE_PERSPECTIVES = os.path.join(SPHINX_SOURCE, "user", "sasgui", "perspectives") 
    3737SPHINX_SOURCE_TEST = os.path.join(SPHINX_SOURCE, "test") 
    3838 

  • docs/sphinx-docs/source/user/user.rst

    r2e5ca08 re0bbb7c  
    66.. toctree:: 
    77   :maxdepth: 1 
     8 
     9   Model Documentation <models/model_functions> 
     10 
     11   Data Formats <sasgui/guiframe/data_formats_help> 
    812    
    9    Model Documentation <models/model_functions> 
     13   Loading Data <sasgui/guiframe/data_explorer_help> 
    1014    
    11    Data Formats <guiframe/data_formats_help> 
     15   Plotting Data/Models <sasgui/guiframe/graph_help> 
    1216    
    13    Loading Data <guiframe/data_explorer_help> 
     17   Fitting Perspective <sasgui/perspectives/fitting/fitting> 
    1418    
    15    Plotting Data/Models <guiframe/graph_help> 
     19   P(r) Inversion Perspective <sasgui/perspectives/pr/pr_help> 
    1620    
    17    Fitting Perspective <perspectives/fitting/fitting> 
     21   Invariant Calculation Perspective <sasgui/perspectives/invariant/invariant_help> 
    1822    
    19    P(r) Inversion Perspective <perspectives/pr/pr_help> 
     23   Data Operations Tool <sasgui/perspectives/calculator/data_operator_help> 
     24       
     25   Density/Volume Calculator Tool <sasgui/perspectives/calculator/density_calculator_help> 
    2026    
    21    Invariant Calculation Perspective <perspectives/invariant/invariant_help> 
     27   Generic SANS Calculator Tool <sasgui/perspectives/calculator/sas_calculator_help> 
    2228    
    23    Data Operations Tool <perspectives/calculator/data_operator_help> 
    24        
    25    Density/Volume Calculator Tool <perspectives/calculator/density_calculator_help> 
     29   Image Viewer Tool <sasgui/perspectives/calculator/image_viewer_help> 
    2630    
    27    Generic SANS Calculator Tool <perspectives/calculator/sas_calculator_help> 
     31   Kiessig Thickness Calculator Tool <sasgui/perspectives/calculator/kiessig_calculator_help> 
    2832    
    29    Image Viewer Tool <perspectives/calculator/image_viewer_help> 
    30        
    31    Kiessig Thickness Calculator Tool <perspectives/calculator/kiessig_calculator_help> 
     33   SLD Calculator Tool <sasgui/perspectives/calculator/sld_calculator_help> 
    3234    
    33    SLD Calculator Tool <perspectives/calculator/sld_calculator_help> 
     35   Slit Size Calculator Tool <sasgui/perspectives/calculator/slit_calculator_help> 
    3436    
    35    Slit Size Calculator Tool <perspectives/calculator/slit_calculator_help> 
     37   Q Resolution Estimator Tool <sasgui/perspectives/calculator/resolution_calculator_help> 
    3638    
    37    Q Resolution Estimator Tool <perspectives/calculator/resolution_calculator_help> 
    38     
    39    Python Shell Tool <perspectives/calculator/python_shell_help> 
    40     
     39   Python Shell Tool <sasgui/perspectives/calculator/python_shell_help> 
     40 
    4141   Test Data <../test/testdata_help.rst> 

  • sasview/setup_mac.py

    rd85c194 r55c7d4b  
    4747 
    4848#CANSAxml reader data files 
    49 RESOURCES_FILES.append(os.path.join(sas.dataloader.readers.get_data_path(),'defaults.json')) 
     49RESOURCES_FILES.append(os.path.join(sas.sascalc.dataloader.readers.get_data_path(),'defaults.json')) 
    5050 
    5151# Locate libxml2 library 

  • setup.py

    • Property mode changed from 100644 to 100755
    r50a77df re5ea2d0  
    164164packages.append("sas") 
    165165 
    166 # sas.invariant 
    167 package_dir["sas.invariant"] = os.path.join("src", "sas", "sascalc", "invariant") 
    168 packages.extend(["sas.invariant"]) 
     166# sas module 
     167package_dir["sas.sasgui"] = os.path.join("src", "sas", "sasgui") 
     168packages.append("sas.sasgui") 
     169 
     170# sas module 
     171package_dir["sas.sascalc"] = os.path.join("src", "sas", "sascalc") 
     172packages.append("sas.sascalc") 
     173 
     174# sas.sascalc.invariant 
     175package_dir["sas.sascalc.invariant"] = os.path.join("src", "sas", "sascalc", "invariant") 
     176packages.extend(["sas.sascalc.invariant"]) 
    169177 
    170178# sas.sasgui.guiframe 
    … …  
    181189        package_dir[package_name] = os.path.join(guiframe_path, "local_perspectives", d) 
    182190 
    183 # sas.dataloader 
    184 package_dir["sas.dataloader"] = os.path.join("src", "sas", "sascalc", "dataloader") 
    185 package_data["sas.dataloader.readers"] = ['defaults.json','schema/*.xsd'] 
    186 packages.extend(["sas.dataloader","sas.dataloader.readers","sas.dataloader.readers.schema"]) 
    187  
    188 # sas.calculator 
    189 package_dir["sas.calculator"] =os.path.join("src", "sas", "sascalc", "calculator") 
     191# sas.sascalc.dataloader 
     192package_dir["sas.sascalc.dataloader"] = os.path.join("src", "sas", "sascalc", "dataloader") 
     193package_data["sas.sascalc.dataloader.readers"] = ['defaults.json','schema/*.xsd'] 
     194packages.extend(["sas.sascalc.dataloader","sas.sascalc.dataloader.readers","sas.sascalc.dataloader.readers.schema"]) 
     195 
     196# sas.sascalc.calculator 
     197package_dir["sas.sascalc.calculator"] =os.path.join("src", "sas", "sascalc", "calculator") 
    190198packages.extend(["sas.sascalc.calculator"]) 
    191199     
    … …  
    227235     
    228236# Data util 
    229 package_dir["data_util"] = os.path.join("src", "sas", "sascalc", "data_util") 
     237package_dir["sas.sascalc.data_util"] = os.path.join("src", "sas", "sascalc", "data_util") 
    230238packages.append("sas.sascalc.data_util") 
    231239 

  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    rd85c194 r45d90b9  
    149149        # Generic values for the cansas file based on the version 
    150150        cansas_defaults = CANSAS_NS.get(self.cansas_version, "1.0") 
    151         schema_path = "{0}/sas/dataloader/readers/schema/{1}".format\ 
     151        schema_path = "{0}/sas/sascalc/dataloader/readers/schema/{1}".format\ 
    152152                (base, cansas_defaults.get("schema")).replace("\\", "/") 
    153153 
    … …  
    10051005        mod = mod_name.split("sas/") 
    10061006        mod_name = mod[1] 
    1007         if mod_name != "dataloader/readers/cansas_reader": 
     1007        if mod_name != "sascalc/dataloader/readers/cansas_reader": 
    10081008            string = self.to_string(doc, pretty_print=False) 
    10091009            doc = parseString(string) 

  • .gitignore

    rbc873053 r02098e3  
    1313.pydevproject 
    1414.vagrant 
     15.idea 
     16build 
     17dist 
     18sasview.egg-info 
     19sasview.egg-info 
     20 
    1521.mplconfig 
     22doctrees 
     23html 
     24build 
    1625 
    1726/setup.cfg 
    1827 
    1928/dist 
    20 /build 
     29**/build 
    2130sasview.egg-info 
    2231sasview-install 
    … …  
    4150/test/sasdataloader/test/plugins.zip 
    4251/test/sasdataloader/test/test_log.txt 
     52 

  • run.py

    rb699768 r50a77df  
    104104    addpath(joinpath(root, 'src')) 
    105105 
     106    # sasmodels on the path 
     107    addpath(joinpath(root, '../sasmodels/')) 
     108 
    106109    # Import the sasview package from root/sasview as sas.sasview.  It would 
    107110    # be better to just store the package in src/sas/sasview. 

  • src/sas/models/dispersion_models.py

    rfd5ac0d r0e4e554  
    154154        c_models.set_dispersion_weights(self.cdisp, values, weights) 
    155155         
    156 models = {"gaussian":GaussianDispersion,  "rectangula":RectangleDispersion, 
     156models = {"gaussian":GaussianDispersion,  "rectangular":RectangleDispersion, 
    157157          "array":ArrayDispersion, "schulz":SchulzDispersion,  
    158158          "lognormal":LogNormalDispersion}        

  • src/sas/sasgui/perspectives/fitting/basepage.py

    rd85c194 r50a77df  
    5757    ## Title to appear on top of the window 
    5858    window_caption = "Fit Page " 
     59 
    5960    # These two buttons have specific IDs since they seem to be created more 
    6061    # frequently than they need to.  In particular, set_dispers_sizer() is 
    … …  
    13791380            if disp.__class__.__name__ == 'str': 
    13801381                disp_model = None 
    1381                 com_str = "from sas.models.dispersion_models " 
     1382                com_str = "from sasmodels.weights " 
    13821383                com_str += "import %s as disp_func \ndisp_model = disp_func()" 
    13831384                exec com_str % disp 
    … …  
    19441945            name = model.__class__.__name__ 
    19451946            if models.__name__ != "NoStructure": 
    1946                 if hasattr(model, "name"): 
     1947                if hasattr(model, "oldname"): 
     1948                    name = model.oldname 
     1949                elif hasattr(model, "name"): 
    19471950                    name = model.name 
    19481951                mlist.append((name, models)) 
    … …  
    24582461        self.values = {} 
    24592462        self.weights = {} 
    2460  
    2461         from sas.models.dispersion_models import GaussianDispersion 
     2463       
     2464        #from sas.models.dispersion_models import GaussianDispersion 
     2465        from sasmodels.weights import GaussianDispersion 
    24622466        if len(self.disp_cb_dict) == 0: 
    24632467            self.save_current_state() 
    … …  
    35873591        cat_tip = "Modify model categories \n" 
    35883592        cat_tip += "(also accessible from the menu bar)." 
    3589         show_cat_button.SetToolTip(wx.ToolTip(cat_tip)) 
     3593        show_cat_button.SetToolTip( wx.ToolTip(cat_tip) ) 
    35903594        show_cat_button.Bind(wx.EVT_BUTTON, self._on_modify_cat) 
    35913595        sizer_cat_box.Add(self.categorybox, 1, wx.RIGHT, 3) 
    3592         sizer_cat_box.Add((10, 10)) 
     3596        sizer_cat_box.Add((10,10)) 
    35933597        sizer_cat_box.Add(show_cat_button) 
    35943598        #self.shape_rbutton.SetValue(True) 
    3595  
     3599       
    35963600        sizer_radiobutton = wx.GridSizer(2, 2, 5, 5) 
    35973601        #sizer_radiobutton.Add(self.shape_rbutton) 
    35983602        #sizer_radiobutton.Add(self.shape_indep_rbutton) 
    3599         sizer_radiobutton.Add((5, 5)) 
     3603        sizer_radiobutton.Add((5,5)) 
    36003604        sizer_radiobutton.Add(self.model_view, 1, wx.RIGHT, 5) 
    36013605        #sizer_radiobutton.Add(self.plugin_rbutton) 

  • src/sas/sasgui/perspectives/fitting/fitpanel.py

    rd85c194 rf66d9d1  
    120120        """ 
    121121        """ 
    122         temp = self.menu_mng.pulgins_reset() 
     122        temp = self.menu_mng.plugins_reset() 
    123123        if len(temp): 
    124124            self.model_list_box = temp 

  • src/sas/sasgui/perspectives/fitting/models.py

    r4ee041f rf66d9d1  
    66import os 
    77import sys 
     8import math 
    89import os.path 
    910# Time is needed by the log method 
    … …  
    1213import py_compile 
    1314import shutil 
     15from sas.sasgui.guiframe.events import StatusEvent 
    1416# Explicitly import from the pluginmodel module so that py2exe 
    1517# places it in the distribution. The Model1DPlugin class is used 
    1618# as the base class of plug-in models. 
    1719from sas.models.pluginmodel import Model1DPlugin 
     20from sas.models.BaseComponent import BaseComponent 
    1821from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller 
     22from sasmodels.sasview_model import make_class 
     23import sasmodels.core 
     24 
    1925 
    2026PLUGIN_DIR = 'plugin_models' 
    … …  
    251257    ## dictionary of structure factor models 
    252258    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 = [] 
    257259    ##list of structure factors 
    258260    struct_list = [] 
    … …  
    294296        """ 
    295297 
    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  
    315298        # regular model names only 
    316299        base_message = "Unable to load model {0}" 
    317300        self.model_name_list = [] 
    318         try: 
    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.BarBellModel import BarBellModel 
    534  
    535             self.model_dictionary[BarBellModel.__name__] = BarBellModel 
    536             #       self.shape_list.append(BarBellModel) 
    537             self.model_name_list.append(BarBellModel.__name__) 
    538         except: 
    539             logging.error(base_message.format(BarBellModel.__name__)) 
    540  
    541         try: 
    542             from sas.models.CappedCylinderModel import CappedCylinderModel 
    543  
    544             self.model_dictionary[CappedCylinderModel.__name__] = CappedCylinderModel 
    545             #       self.shape_list.append(CappedCylinderModel) 
    546             self.model_name_list.append(CappedCylinderModel.__name__) 
    547         except: 
    548             logging.error(base_message.format(CappedCylinderModel.__name__)) 
    549  
    550         try: 
    551             from sas.models.EllipsoidModel import EllipsoidModel 
    552  
    553             self.model_dictionary[EllipsoidModel.__name__] = EllipsoidModel 
    554             #        self.shape_list.append(EllipsoidModel) 
    555             self.multiplication_factor.append(EllipsoidModel) 
    556             self.model_name_list.append(EllipsoidModel.__name__) 
    557         except: 
    558             logging.error(base_message.format(EllipsoidModel.__name__)) 
    559  
    560         try: 
    561             from sas.models.CoreShellEllipsoidModel import CoreShellEllipsoidModel 
    562  
    563             self.model_dictionary[CoreShellEllipsoidModel.__name__] = CoreShellEllipsoidModel 
    564             #        self.shape_list.append(CoreShellEllipsoidModel) 
    565             self.multiplication_factor.append(CoreShellEllipsoidModel) 
    566             self.model_name_list.append(CoreShellEllipsoidModel.__name__) 
    567         except: 
    568             logging.error(base_message.format(CoreShellEllipsoidModel.__name__)) 
    569  
    570         try: 
    571             from sas.models.CoreShellEllipsoidXTModel import CoreShellEllipsoidXTModel 
    572  
    573             self.model_dictionary[CoreShellEllipsoidXTModel.__name__] = CoreShellEllipsoidXTModel 
    574             #        self.shape_list.append(CoreShellEllipsoidXTModel) 
    575             self.multiplication_factor.append(CoreShellEllipsoidXTModel) 
    576             self.model_name_list.append(CoreShellEllipsoidXTModel.__name__) 
    577         except: 
    578             logging.error(base_message.format(CoreShellEllipsoidXTModel.__name__)) 
    579  
    580         try: 
    581             from sas.models.TriaxialEllipsoidModel import TriaxialEllipsoidModel 
    582  
    583             self.model_dictionary[TriaxialEllipsoidModel.__name__] = TriaxialEllipsoidModel 
    584             #        self.shape_list.append(TriaxialEllipsoidModel) 
    585             self.multiplication_factor.append(TriaxialEllipsoidModel) 
    586             self.model_name_list.append(TriaxialEllipsoidModel.__name__) 
    587         except: 
    588             logging.error(base_message.format(TriaxialEllipsoidModel.__name__)) 
    589  
    590         try: 
    591             from sas.models.LamellarModel import LamellarModel 
    592  
    593             self.model_dictionary[LamellarModel.__name__] = LamellarModel 
    594             #        self.shape_list.append(LamellarModel) 
    595             self.model_name_list.append(LamellarModel.__name__) 
    596         except: 
    597             logging.error(base_message.format(LamellarModel.__name__)) 
    598  
    599         try: 
    600             from sas.models.LamellarFFHGModel import LamellarFFHGModel 
    601  
    602             self.model_dictionary[LamellarFFHGModel.__name__] = LamellarFFHGModel 
    603             #        self.shape_list.append(LamellarFFHGModel) 
    604             self.model_name_list.append(LamellarFFHGModel.__name__) 
    605         except: 
    606             logging.error(base_message.format(LamellarFFHGModel.__name__)) 
    607  
    608         try: 
    609             from sas.models.LamellarPSModel import LamellarPSModel 
    610  
    611             self.model_dictionary[LamellarPSModel.__name__] = LamellarPSModel 
    612             #        self.shape_list.append(LamellarPSModel) 
    613             self.model_name_list.append(LamellarPSModel.__name__) 
    614         except: 
    615             logging.error(base_message.format(LamellarPSModel.__name__)) 
    616  
    617         try: 
    618             from sas.models.LamellarPSHGModel import LamellarPSHGModel 
    619  
    620             self.model_dictionary[LamellarPSHGModel.__name__] = LamellarPSHGModel 
    621             #        self.shape_list.append(LamellarPSHGModel) 
    622             self.model_name_list.append(LamellarPSHGModel.__name__) 
    623         except: 
    624             logging.error(base_message.format(LamellarPSHGModel.__name__)) 
    625  
    626         try: 
    627             from sas.models.LamellarPCrystalModel import LamellarPCrystalModel 
    628  
    629             self.model_dictionary[LamellarPCrystalModel.__name__] = LamellarPCrystalModel 
    630             #        self.shape_list.append(LamellarPCrystalModel) 
    631             self.model_name_list.append(LamellarPCrystalModel.__name__) 
    632         except: 
    633             logging.error(base_message.format(LamellarPCrystalModel.__name__)) 
    634  
    635         try: 
    636             from sas.models.SCCrystalModel import SCCrystalModel 
    637  
    638             self.model_dictionary[SCCrystalModel.__name__] = SCCrystalModel 
    639             #        self.shape_list.append(SCCrystalModel) 
    640             self.model_name_list.append(SCCrystalModel.__name__) 
    641         except: 
    642             logging.error(base_message.format(SCCrystalModel.__name__)) 
    643              
    644         try: 
    645             from sas.models.FCCrystalModel import FCCrystalModel 
    646  
    647             self.model_dictionary[FCCrystalModel.__name__] = FCCrystalModel 
    648             #        self.shape_list.append(FCCrystalModel) 
    649             self.model_name_list.append(FCCrystalModel.__name__) 
    650         except: 
    651             logging.error(base_message.format(FCCrystalModel.__name__)) 
    652  
    653         try: 
    654             from sas.models.BCCrystalModel import BCCrystalModel 
    655  
    656             self.model_dictionary[BCCrystalModel.__name__] = BCCrystalModel 
    657             #        self.shape_list.append(BCCrystalModel) 
    658             self.model_name_list.append(BCCrystalModel.__name__) 
    659         except: 
    660             logging.error(base_message.format(BCCrystalModel.__name__)) 
    661  
    662  
    663         ## Structure factor 
    664         try: 
    665             from sas.models.SquareWellStructure import SquareWellStructure 
    666  
    667             self.model_dictionary[SquareWellStructure.__name__] = SquareWellStructure 
    668             self.struct_list.append(SquareWellStructure) 
    669             self.model_name_list.append(SquareWellStructure.__name__) 
    670         except: 
    671             logging.error(base_message.format(SquareWellStructure.__name__)) 
    672  
    673         try: 
    674             from sas.models.HardsphereStructure import HardsphereStructure 
    675  
    676             self.model_dictionary[HardsphereStructure.__name__] = HardsphereStructure 
    677             self.struct_list.append(HardsphereStructure) 
    678             self.model_name_list.append(HardsphereStructure.__name__) 
    679         except: 
    680             logging.error(base_message.format(HardsphereStructure.__name__)) 
    681  
    682         try: 
    683             from sas.models.StickyHSStructure import StickyHSStructure 
    684  
    685             self.model_dictionary[StickyHSStructure.__name__] = StickyHSStructure 
    686             self.struct_list.append(StickyHSStructure) 
    687             self.model_name_list.append(StickyHSStructure.__name__) 
    688         except: 
    689             logging.error(base_message.format(StickyHSStructure.__name__)) 
    690  
    691         try: 
    692             from sas.models.HayterMSAStructure import HayterMSAStructure 
    693  
    694             self.model_dictionary[HayterMSAStructure.__name__] = HayterMSAStructure 
    695             self.struct_list.append(HayterMSAStructure) 
    696             self.model_name_list.append(HayterMSAStructure.__name__) 
    697         except: 
    698             logging.error(base_message.format(HayterMSAStructure.__name__)) 
    699  
    700  
    701  
    702         ##shape-independent models 
    703         try: 
    704             from sas.models.PowerLawAbsModel import PowerLawAbsModel 
    705  
    706             self.model_dictionary[PowerLawAbsModel.__name__] = PowerLawAbsModel 
    707             #        self.shape_indep_list.append(PowerLawAbsModel) 
    708             self.model_name_list.append(PowerLawAbsModel.__name__) 
    709         except: 
    710             logging.error(base_message.format(PowerLawAbsModel.__name__)) 
    711  
    712         try: 
    713             from sas.models.BEPolyelectrolyte import BEPolyelectrolyte 
    714  
    715             self.model_dictionary[BEPolyelectrolyte.__name__] = BEPolyelectrolyte 
    716             #        self.shape_indep_list.append(BEPolyelectrolyte) 
    717             self.model_name_list.append(BEPolyelectrolyte.__name__) 
    718             self.form_factor_dict[str(wx.NewId())] = [SphereModel] 
    719         except: 
    720             logging.error(base_message.format(BEPolyelectrolyte.__name__)) 
    721  
    722         try: 
    723             from sas.models.BroadPeakModel import BroadPeakModel 
    724  
    725             self.model_dictionary[BroadPeakModel.__name__] = BroadPeakModel 
    726             #        self.shape_indep_list.append(BroadPeakModel) 
    727             self.model_name_list.append(BroadPeakModel.__name__) 
    728         except: 
    729             logging.error(base_message.format(BroadPeakModel.__name__)) 
    730  
    731         try: 
    732             from sas.models.CorrLengthModel import CorrLengthModel 
    733  
    734             self.model_dictionary[CorrLengthModel.__name__] = CorrLengthModel 
    735             #        self.shape_indep_list.append(CorrLengthModel) 
    736             self.model_name_list.append(CorrLengthModel.__name__) 
    737         except: 
    738             logging.error(base_message.format(CorrLengthModel.__name__)) 
    739  
    740         try: 
    741             from sas.models.DABModel import DABModel 
    742  
    743             self.model_dictionary[DABModel.__name__] = DABModel 
    744             #        self.shape_indep_list.append(DABModel) 
    745             self.model_name_list.append(DABModel.__name__) 
    746         except: 
    747             logging.error(base_message.format(DABModel.__name__)) 
    748  
    749         try: 
    750             from sas.models.DebyeModel import DebyeModel 
    751  
    752             self.model_dictionary[DebyeModel.__name__] = DebyeModel 
    753             #        self.shape_indep_list.append(DebyeModel) 
    754             self.model_name_list.append(DebyeModel.__name__) 
    755         except: 
    756             logging.error(base_message.format(DebyeModel.__name__)) 
    757  
    758         try: 
    759             from sas.models.FractalModel import FractalModel 
    760  
    761             self.model_dictionary[FractalModel.__name__] = FractalModel 
    762             #        self.shape_indep_list.append(FractalModel) 
    763             self.model_name_list.append(FractalModel.__name__) 
    764         except: 
    765             logging.error(base_message.format(FractalModel.__name__)) 
    766  
    767         try: 
    768             from sas.models.FractalCoreShellModel import FractalCoreShellModel 
    769  
    770             self.model_dictionary[FractalCoreShellModel.__name__] = FractalCoreShellModel 
    771             #        self.shape_indep_list.append(FractalCoreShellModel) 
    772             self.model_name_list.append(FractalCoreShellModel.__name__) 
    773         except: 
    774             logging.error(base_message.format(FractalCoreShellModel.__name__)) 
    775  
    776         try: 
    777             from sas.models.GaussLorentzGelModel import GaussLorentzGelModel 
    778  
    779             self.model_dictionary[GaussLorentzGelModel.__name__] = GaussLorentzGelModel 
    780             #        self.shape_indep_list.append(GaussLorentzGelModel) 
    781             self.model_name_list.append(GaussLorentzGelModel.__name__) 
    782         except: 
    783             logging.error(base_message.format(GaussLorentzGelModel.__name__)) 
    784  
    785         try: 
    786             from sas.models.GuinierModel import GuinierModel 
    787  
    788             self.model_dictionary[GuinierModel.__name__] = GuinierModel 
    789             #        self.shape_indep_list.append(GuinierModel) 
    790             self.model_name_list.append(GuinierModel.__name__) 
    791         except: 
    792             logging.error(base_message.format(GuinierModel.__name__)) 
    793  
    794         try: 
    795             from sas.models.GuinierPorodModel import GuinierPorodModel 
    796  
    797             self.model_dictionary[GuinierPorodModel.__name__] = GuinierPorodModel 
    798             #        self.shape_indep_list.append(GuinierPorodModel) 
    799             self.model_name_list.append(GuinierPorodModel.__name__) 
    800         except: 
    801             logging.error(base_message.format(GuinierPorodModel.__name__)) 
    802  
    803         try: 
    804             from sas.models.LorentzModel import LorentzModel 
    805  
    806             self.model_dictionary[LorentzModel.__name__] = LorentzModel 
    807             #        self.shape_indep_list.append(LorentzModel) 
    808             self.model_name_list.append(LorentzModel.__name__) 
    809         except: 
    810             logging.error(base_message.format(LorentzModel.__name__)) 
    811  
    812         try: 
    813             from sas.models.MassFractalModel import MassFractalModel 
    814  
    815             self.model_dictionary[MassFractalModel.__name__] = MassFractalModel 
    816             #        self.shape_indep_list.append(MassFractalModel) 
    817             self.model_name_list.append(MassFractalModel.__name__) 
    818         except: 
    819             logging.error(base_message.format(MassFractalModel.__name__)) 
    820  
    821         try: 
    822             from sas.models.MassSurfaceFractal import MassSurfaceFractal 
    823  
    824             self.model_dictionary[MassSurfaceFractal.__name__] = MassSurfaceFractal 
    825             #        self.shape_indep_list.append(MassSurfaceFractal) 
    826             self.model_name_list.append(MassSurfaceFractal.__name__) 
    827         except: 
    828             logging.error(base_message.format(MassSurfaceFractal.__name__)) 
    829  
    830         try: 
    831             from sas.models.PeakGaussModel import PeakGaussModel 
    832  
    833             self.model_dictionary[PeakGaussModel.__name__] = PeakGaussModel 
    834             #        self.shape_indep_list.append(PeakGaussModel) 
    835             self.model_name_list.append(PeakGaussModel.__name__) 
    836         except: 
    837             logging.error(base_message.format(PeakGaussModel.__name__)) 
    838  
    839         try: 
    840             from sas.models.PeakLorentzModel import PeakLorentzModel 
    841  
    842             self.model_dictionary[PeakLorentzModel.__name__] = PeakLorentzModel 
    843             #        self.shape_indep_list.append(PeakLorentzModel) 
    844             self.model_name_list.append(PeakLorentzModel.__name__) 
    845         except: 
    846             logging.error(base_message.format(PeakLorentzModel.__name__)) 
    847  
    848         try: 
    849             from sas.models.Poly_GaussCoil import Poly_GaussCoil 
    850  
    851             self.model_dictionary[Poly_GaussCoil.__name__] = Poly_GaussCoil 
    852             #        self.shape_indep_list.append(Poly_GaussCoil) 
    853             self.model_name_list.append(Poly_GaussCoil.__name__) 
    854         except: 
    855             logging.error(base_message.format(Poly_GaussCoil.__name__)) 
    856  
    857         try: 
    858             from sas.models.PolymerExclVolume import PolymerExclVolume 
    859  
    860             self.model_dictionary[PolymerExclVolume.__name__] = PolymerExclVolume 
    861             #        self.shape_indep_list.append(PolymerExclVolume) 
    862             self.model_name_list.append(PolymerExclVolume.__name__) 
    863         except: 
    864             logging.error(base_message.format(PolymerExclVolume.__name__)) 
    865  
    866         try: 
    867             from sas.models.PorodModel import PorodModel 
    868  
    869             self.model_dictionary[PorodModel.__name__] = PorodModel 
    870             #        self.shape_indep_list.append(PorodModel) 
    871             self.model_name_list.append(PorodModel.__name__) 
    872         except: 
    873             logging.error(base_message.format(PorodModel.__name__)) 
    874  
    875         try: 
    876             from sas.models.RPA10Model import RPA10Model 
    877  
    878             self.model_dictionary[RPA10Model.__name__] = RPA10Model 
    879             #        self.shape_indep_list.append(RPA10Model) 
    880             self.multi_func_list.append(RPA10Model) 
    881         except: 
    882             logging.error(base_message.format(RPA10Model.__name__)) 
    883  
    884         try: 
    885             from sas.models.StarPolymer import StarPolymer 
    886  
    887             self.model_dictionary[StarPolymer.__name__] = StarPolymer 
    888             #        self.shape_indep_list.append(StarPolymer) 
    889             self.model_name_list.append(StarPolymer.__name__) 
    890         except: 
    891             logging.error(base_message.format(StarPolymer.__name__)) 
    892  
    893         try: 
    894             from sas.models.SurfaceFractalModel import SurfaceFractalModel 
    895  
    896             self.model_dictionary[SurfaceFractalModel.__name__] = SurfaceFractalModel 
    897             #        self.shape_indep_list.append(SurfaceFractalModel) 
    898             self.model_name_list.append(SurfaceFractalModel.__name__) 
    899         except: 
    900             logging.error(base_message.format(SurfaceFractalModel.__name__)) 
    901  
    902         try: 
    903             from sas.models.TeubnerStreyModel import TeubnerStreyModel 
    904  
    905             self.model_dictionary[TeubnerStreyModel.__name__] = TeubnerStreyModel 
    906             #        self.shape_indep_list.append(TeubnerStreyModel) 
    907             self.model_name_list.append(TeubnerStreyModel.__name__) 
    908         except: 
    909             logging.error(base_message.format(TeubnerStreyModel.__name__)) 
    910  
    911         try: 
    912             from sas.models.TwoLorentzianModel import TwoLorentzianModel 
    913  
    914             self.model_dictionary[TwoLorentzianModel.__name__] = TwoLorentzianModel 
    915             #        self.shape_indep_list.append(TwoLorentzianModel) 
    916             self.model_name_list.append(TwoLorentzianModel.__name__) 
    917         except: 
    918             logging.error(base_message.format(TwoLorentzianModel.__name__)) 
    919  
    920         try: 
    921             from sas.models.TwoPowerLawModel import TwoPowerLawModel 
    922  
    923             self.model_dictionary[TwoPowerLawModel.__name__] = TwoPowerLawModel 
    924             #        self.shape_indep_list.append(TwoPowerLawModel) 
    925             self.model_name_list.append(TwoPowerLawModel.__name__) 
    926         except: 
    927             logging.error(base_message.format(TwoPowerLawModel.__name__)) 
    928  
    929         try: 
    930             from sas.models.UnifiedPowerRgModel import UnifiedPowerRgModel 
    931  
    932             self.model_dictionary[UnifiedPowerRgModel.__name__] = UnifiedPowerRgModel 
    933             #        self.shape_indep_list.append(UnifiedPowerRgModel) 
    934             self.multi_func_list.append(UnifiedPowerRgModel) 
    935         except: 
    936             logging.error(base_message.format(UnifiedPowerRgModel.__name__)) 
    937  
    938         try: 
    939             from sas.models.LineModel import LineModel 
    940  
    941             self.model_dictionary[LineModel.__name__] = LineModel 
    942             #        self.shape_indep_list.append(LineModel) 
    943             self.model_name_list.append(LineModel.__name__) 
    944         except: 
    945             logging.error(base_message.format(LineModel.__name__)) 
    946  
    947         try: 
    948             from sas.models.ReflectivityModel import ReflectivityModel 
    949  
    950             self.model_dictionary[ReflectivityModel.__name__] = ReflectivityModel 
    951             #        self.shape_indep_list.append(ReflectivityModel) 
    952             self.multi_func_list.append(ReflectivityModel) 
    953         except: 
    954             logging.error(base_message.format(ReflectivityModel.__name__)) 
    955  
    956         try: 
    957             from sas.models.ReflectivityIIModel import ReflectivityIIModel 
    958  
    959             self.model_dictionary[ReflectivityIIModel.__name__] = ReflectivityIIModel 
    960             #        self.shape_indep_list.append(ReflectivityIIModel) 
    961             self.multi_func_list.append(ReflectivityIIModel) 
    962         except: 
    963             logging.error(base_message.format(ReflectivityIIModel.__name__)) 
    964  
    965         try: 
    966             from sas.models.GelFitModel import GelFitModel 
    967  
    968             self.model_dictionary[GelFitModel.__name__] = GelFitModel 
    969             #        self.shape_indep_list.append(GelFitModel) 
    970             self.model_name_list.append(GelFitModel.__name__) 
    971         except: 
    972             logging.error(base_message.format(GelFitModel.__name__)) 
    973  
    974         try: 
    975             from sas.models.PringlesModel import PringlesModel 
    976  
    977             self.model_dictionary[PringlesModel.__name__] = PringlesModel 
    978             #        self.shape_indep_list.append(PringlesModel) 
    979             self.model_name_list.append(PringlesModel.__name__) 
    980         except: 
    981             logging.error(base_message.format(PringlesModel.__name__)) 
    982  
    983         try: 
    984             from sas.models.RectangularPrismModel import RectangularPrismModel 
    985  
    986             self.model_dictionary[RectangularPrismModel.__name__] = RectangularPrismModel 
    987             #        self.shape_list.append(RectangularPrismModel) 
    988             self.multiplication_factor.append(RectangularPrismModel) 
    989             self.model_name_list.append(RectangularPrismModel.__name__) 
    990         except: 
    991             logging.error(base_message.format(RectangularPrismModel.__name__)) 
    992  
    993         try: 
    994             from sas.models.RectangularHollowPrismInfThinWallsModel import RectangularHollowPrismInfThinWallsModel 
    995  
    996             self.model_dictionary[RectangularHollowPrismInfThinWallsModel.__name__] = RectangularHollowPrismInfThinWallsModel 
    997             #        self.shape_list.append(RectangularHollowPrismInfThinWallsModel) 
    998             self.multiplication_factor.append(RectangularHollowPrismInfThinWallsModel) 
    999             self.model_name_list.append(RectangularHollowPrismInfThinWallsModel.__name__) 
    1000         except: 
    1001             logging.error(base_message.format(RectangularHollowPrismInfThinWallsModel.__name__)) 
    1002  
    1003         try: 
    1004             from sas.models.RectangularHollowPrismModel import RectangularHollowPrismModel 
    1005  
    1006             self.model_dictionary[RectangularHollowPrismModel.__name__] = RectangularHollowPrismModel 
    1007             #        self.shape_list.append(RectangularHollowPrismModel) 
    1008             self.multiplication_factor.append(RectangularHollowPrismModel) 
    1009             self.model_name_list.append(RectangularHollowPrismModel.__name__) 
    1010         except: 
    1011             logging.error(base_message.format(RectangularHollowPrismModel.__name__)) 
    1012  
    1013         try: 
    1014             from sas.models.MicelleSphCoreModel import MicelleSphCoreModel 
    1015  
    1016             self.model_dictionary[MicelleSphCoreModel.__name__] = MicelleSphCoreModel 
    1017             #        self.shape_list.append(MicelleSphCoreModel) 
    1018             self.multiplication_factor.append(MicelleSphCoreModel) 
    1019             self.model_name_list.append(MicelleSphCoreModel.__name__) 
    1020         except: 
    1021             logging.error(base_message.format(MicelleSphCoreModel.__name__)) 
    1022  
    1023  
    1024  
    1025         #from sas.models.FractalO_Z import FractalO_Z 
    1026         #self.model_dictionary[FractalO_Z.__name__] = FractalO_Z 
    1027         #self.shape_indep_list.append(FractalO_Z) 
    1028         #self.model_name_list.append(FractalO_Z.__name__) 
     301 
     302        #Build list automagically from sasmodels package 
     303        for mod_name in sasmodels.core.list_models(): 
     304            mod_def = sasmodels.core.load_model_info(mod_name) 
     305            self.model_dictionary[mod_def['oldname']] = make_class(mod_def,dtype=None,namestyle='oldname') 
     306            self.model_name_list.append(mod_def['oldname']) 
     307            if mod_def['structure_factor'] == True: 
     308                self.struct_list.append(self.model_dictionary[mod_def['oldname']]) 
     309            if mod_def['variant_info'] is not None: 
     310                self.multi_func_list.append(self.model_dictionary[mod_def['oldname']]) 
     311            if mod_def['ER'] is not None: 
     312                self.multiplication_factor.append(self.model_dictionary[mod_def['oldname']]) 
    1029313 
    1030314        #Looking for plugins 
    … …  
    1070354            return {} 
    1071355 
    1072     def pulgins_reset(self): 
     356    def plugins_reset(self): 
    1073357        """ 
    1074358        return a dictionary of model 
    … …  
    1077361        new_plugins = _findModels(dir) 
    1078362        for name, plug in  new_plugins.iteritems(): 
    1079             for stored_name, _ in self.stored_plugins.iteritems(): 
     363            for stored_name, stored_plug in self.stored_plugins.iteritems(): 
    1080364                if name == stored_name: 
    1081365                    del self.stored_plugins[name] 
    … …  
    1089373        return self.model_combobox.get_list() 
    1090374 
    1091 ##   I believe the next four methods are for the old form factor GUI 
    1092 ##   where the dropdown showed a list of categories which then rolled out 
    1093 ##   in a second dropdown to the side. Some testing shows they indeed no longer 
    1094 ##   seem to be called.  If no problems are found during testing of release we 
    1095 ##   can remove this huge chunck of stuff. 
    1096 ## 
    1097 ##   -PDB  April 26, 2014 
    1098  
    1099 #   def populate_menu(self, modelmenu, event_owner): 
    1100 #       """ 
    1101 #       Populate a menu with our models 
    1102 #        
    1103 #       :param id: first menu event ID to use when binding the menu events 
    1104 #       :param modelmenu: wx.Menu object to populate 
    1105 #       :param event_owner: wx object to bind the menu events to 
    1106 #        
    1107 #       :return: the next free event ID following the new menu events 
    1108 #        
    1109 #       """ 
    1110 #  
    1111         ## Fill model lists 
    1112 #        self._getModelList() 
    1113         ## store reference to model menu of guiframe 
    1114 #        self.modelmenu = modelmenu 
    1115         ## guiframe reference 
    1116 #        self.event_owner = event_owner 
    1117  
    1118 #        shape_submenu = wx.Menu() 
    1119 #        shape_indep_submenu = wx.Menu() 
    1120 #        structure_factor = wx.Menu() 
    1121 #        added_models = wx.Menu() 
    1122 #        multip_models = wx.Menu() 
    1123         ## create menu with shape 
    1124 #        self._fill_simple_menu(menuinfo=["Shapes", 
    1125 #                                         shape_submenu, 
    1126 #                                         " simple shape"], 
    1127 #                         list1=self.shape_list) 
    1128  
    1129 #        self._fill_simple_menu(menuinfo=["Shape-Independent", 
    1130 #                                         shape_indep_submenu, 
    1131 #                                         "List of shape-independent models"], 
    1132 #                         list1=self.shape_indep_list) 
    1133  
    1134 #        self._fill_simple_menu(menuinfo=["Structure Factors", 
    1135 #                                         structure_factor, 
    1136 #                                         "List of Structure factors models"], 
    1137 #                                list1=self.struct_list) 
    1138  
    1139 #        self._fill_plugin_menu(menuinfo=["Customized Models", added_models, 
    1140 #                                            "List of additional models"], 
    1141 #                                 list1=self.plugins) 
    1142  
    1143 #        self._fill_menu(menuinfo=["P(Q)*S(Q)", multip_models, 
    1144 #                                  "mulplication of 2 models"], 
    1145 #                                   list1=self.multiplication_factor, 
    1146 #                                   list2=self.struct_list) 
    1147 #        return 0 
    1148  
    1149 #    def _fill_plugin_menu(self, menuinfo, list1): 
    1150 #        """ 
    1151 #        fill the plugin menu with costumized models 
    1152 #        """ 
    1153 #        print ("got to fill plugin menu") 
    1154 #        if len(list1) == 0: 
    1155 #            id = wx.NewId() 
    1156 #            msg = "No model available check plugins.log for errors to fix problem" 
    1157 #            menuinfo[1].Append(int(id), "Empty", msg) 
    1158 #        self._fill_simple_menu(menuinfo, list1) 
    1159  
    1160 #   def _fill_simple_menu(self, menuinfo, list1): 
    1161 #       """ 
    1162 #       Fill the menu with list item 
    1163 #        
    1164 #       :param modelmenu: the menu to fill 
    1165 #       :param menuinfo: submenu item for the first column of this modelmenu 
    1166 #                        with info.Should be a list : 
    1167 #                        [name(string) , menu(wx.menu), help(string)] 
    1168 #       :param list1: contains item (form factor )to fill modelmenu second column 
    1169 #        
    1170 #       """ 
    1171 #       if len(list1) > 0: 
    1172 #           self.model_combobox.set_list(menuinfo[0], list1) 
    1173  
    1174 #            for item in list1: 
    1175 #                try: 
    1176 #                    id = wx.NewId() 
    1177 #                    struct_factor = item() 
    1178 #                    struct_name = struct_factor.__class__.__name__ 
    1179 #                    if hasattr(struct_factor, "name"): 
    1180 #                        struct_name = struct_factor.name 
    1181 #                         
    1182 #                    menuinfo[1].Append(int(id), struct_name, struct_name) 
    1183 #                    if not  item in self.struct_factor_dict.itervalues(): 
    1184 #                        self.struct_factor_dict[str(id)] = item 
    1185 #                    wx.EVT_MENU(self.event_owner, int(id), self._on_model) 
    1186 #                except: 
    1187 #                    msg = "Error Occured: %s" % sys.exc_value 
    1188 #                    wx.PostEvent(self.event_owner, StatusEvent(status=msg)) 
    1189 #                 
    1190 #        id = wx.NewId() 
    1191 #        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2]) 
    1192 #         
    1193 #    def _fill_menu(self, menuinfo, list1, list2): 
    1194 #        """ 
    1195 #        Fill the menu with list item 
    1196 #         
    1197 #        :param menuinfo: submenu item for the first column of this modelmenu 
    1198 #                         with info.Should be a list : 
    1199 #                         [name(string) , menu(wx.menu), help(string)] 
    1200 #        :param list1: contains item (form factor )to fill modelmenu second column 
    1201 #        :param list2: contains item (Structure factor )to fill modelmenu 
    1202 #                third column 
    1203 #                 
    1204 #        """ 
    1205 #        if len(list1) > 0: 
    1206 #            self.model_combobox.set_list(menuinfo[0], list1) 
    1207 #             
    1208 #            for item in list1: 
    1209 #                form_factor = item() 
    1210 #                form_name = form_factor.__class__.__name__ 
    1211 #                if hasattr(form_factor, "name"): 
    1212 #                    form_name = form_factor.name 
    1213 #                ### store form factor to return to other users 
    1214 #                newmenu = wx.Menu() 
    1215 #                if len(list2) > 0: 
    1216 #                    for model  in list2: 
    1217 #                        id = wx.NewId() 
    1218 #                        struct_factor = model() 
    1219 #                        name = struct_factor.__class__.__name__ 
    1220 #                        if hasattr(struct_factor, "name"): 
    1221 #                            name = struct_factor.name 
    1222 #                        newmenu.Append(id, name, name) 
    1223 #                        wx.EVT_MENU(self.event_owner, int(id), self._on_model) 
    1224 #                        ## save form_fact and struct_fact 
    1225 #                        self.form_factor_dict[int(id)] = [form_factor, 
    1226 #                                                          struct_factor] 
    1227 #                         
    1228 #                form_id = wx.NewId() 
    1229 #                menuinfo[1].AppendMenu(int(form_id), form_name, 
    1230 #                                       newmenu, menuinfo[2]) 
    1231 #        id = wx.NewId() 
    1232 #        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2]) 
    1233  
    1234375    def _on_model(self, evt): 
    1235376        """ 
    … …  
    1247388            model = self.struct_factor_dict[str(evt.GetId())]() 
    1248389 
    1249         #TODO: investigate why the following two lines were left in the code 
    1250         #      even though the ModelEvent class doesn't exist 
    1251         #evt = ModelEvent(model=model) 
    1252         #wx.PostEvent(self.event_owner, evt) 
    1253390 
    1254391    def _get_multifunc_models(self): 
    … …  
    1324461        return self.__modelmanager.update() 
    1325462 
    1326     def pulgins_reset(self): 
    1327         return self.__modelmanager.pulgins_reset() 
     463    def plugins_reset(self): 
     464        return self.__modelmanager.plugins_reset() 
    1328465 
    1329466    def populate_menu(self, modelmenu, event_owner): 
Note: See TracChangeset for help on using the changeset viewer.