Index: sansmodels/test/SmearList.py
===================================================================
--- sansmodels/test/SmearList.py	(revision 18e250cb66e3283c50a57dddaf692b17263dd72c)
+++ sansmodels/test/SmearList.py	(revision 0abf7bf37070c95d946c2656a2e3ef5d902d0027)
@@ -1,4 +1,3 @@
 
-from sans.models.ModelFactory import ModelFactory
 from sans.models.BaseComponent import BaseComponent
 import math
@@ -15,5 +14,4 @@
         
         ## Model to smear
-        #self.model = factory.getModel(model_name)
         self.model = model
         ## Standard deviation of the smearing
@@ -53,5 +51,4 @@
             
             # Gaussian function used to weigh points
-            #gaussian = ModelFactory().getModel("Gaussian")
             gaussian = Gaussian()
             gaussian.setParam('sigma', self.sigmas[id])
@@ -162,36 +159,2 @@
         
         return value
-        
-# main
-if __name__ == '__main__':
-    import math
-    if True:
-        cyl = ModelFactory().getModel("CylinderModel")
-        cyl.setParam('length', 2000.0)
-        cyl.setParam('cyl_phi', .45)
-        cyl.setParam('cyl_theta', 2.)
-        #app = Smear(cyl,['cyl_theta', 'cyl_phi'], [.01, .01])
-        #app = Smear(cyl,['cyl_theta', 'cyl_phi'], [2.0, 2.0])
-        #app = Smear(cyl,['cyl_theta'], [2.5])
-        app = Smear(cyl, ['cyl_phi', 'cyl_theta'], [math.pi, math.pi])
-        #app = Smear(cyl,['scale', 'scale'],[.5,1.0])
-        val_no = cyl.run([.001, 1.0])
-        print "Cylinder (no smear) f(.1):", val_no
-        val_sm =  app.run([.001, 1.0])
-        print "Cylinder (smear)    f(.1):", val_sm, app.error, app.error/val_sm
-        print "Cylinder (1D)    f(.1):", cyl.run(.001), cyl.run(.001)/val_sm
-      
-      
-    print "--------------"
-    sinsin = ModelFactory().getModel("SinSin")
-    sinsin.setParam('a', -1.7)
-    sinsin.setParam('b', 5.45)
-    #app = Smear(sinsin, ['A'], [3.1])
-    #app = Smear(sinsin, ['A', 'b'], [math.pi/2.0, .0])
-    app = Smear(sinsin, ['A'], [math.pi/2.0])
-    #app = Smear(cyl,['scale', 'scale'],[.5,1.0])
-    val_no = sinsin.run(1.0)
-    print "SinSin (no smear) :", val_no
-    val_sm =  app.run(1.0)
-    print "SinSin (smear)    : %g +- %g" % (val_sm, app.error)
-      
Index: sansmodels/test/testcase_generator.py
===================================================================
--- sansmodels/test/testcase_generator.py	(revision 18e250cb66e3283c50a57dddaf692b17263dd72c)
+++ 	(revision )
@@ -1,770 +1,0 @@
-"""
-    Random test-case generator for BaseComponents
-    
-"""
-import time
-
-def randomModel():
-    """ Return a random model name """
-    from sans.models.ModelFactory import ModelFactory
-    from random import random
-    from math import floor
-    
-    model_list = ModelFactory().getAllModels()
-    ready = False
-    while not ready:
-        rnd_id = int(floor(random()*len(model_list)))
-        if model_list[rnd_id] not in ["TestSphere2", "DataModel"]:
-            ready = True
-    return model_list[rnd_id]
-
-class ReportCard: # pylint: disable-msg=R0902
-    """ Class to hold test-case results """
-    
-    def __init__(self):
-        """ Initialization """
-        ## Number of test cases
-        self.n_cases = 0
-        ## Number of passed test cases
-        self.n_cases_pass = 0
-        ## Number of Evaluation calls
-        self.n_eval = 0
-        ## Number of passed Evaluation calls
-        self.n_eval_pass = 0
-        ## Number of SetParam calls
-        self.n_set = 0
-        ## Number of passed Set calls
-        self.n_set_pass = 0
-        ## Number of GetParam calls
-        self.n_get = 0
-        ## Number of passed Get calls
-        self.n_get_pass = 0
-        ## Number of load calls
-        self.n_load = 0
-        ## Number of passed Load calls
-        self.n_load_pass = 0
-        ## Number of save calls
-        self.n_save = 0
-        ## Number of passed Save calls
-        self.n_save_pass = 0
-        ## Number of Add calls
-        self.n_add = 0
-        ## Number of passed Add calls
-        self.n_add_pass = 0
-        ## Number of Sub calls
-        self.n_sub = 0
-        ## Number of passed Sub calls
-        self.n_sub_pass = 0
-        ## Number of Div calls
-        self.n_div = 0
-        ## Number of passed Div calls
-        self.n_div_pass = 0
-        ## Number of mul calls
-        self.n_mul = 0
-        ## Number of passed Mul calls
-        self.n_mul_pass = 0
-        ## Test log
-        self.log = ""
-        ## Trace
-        self.trace = ""
-        ## Model tested
-        self.model = ""
-        ## List of all models tested
-        self.modelList = []
-        
-        
-    def __add__(self, other):
-        """ Add two report cards
-            @param other: other report to add
-            @return: updated self
-        """
-        
-        self.n_cases += other.n_cases
-        self.n_cases_pass += other.n_cases_pass
-        self.n_eval += other.n_eval
-        self.n_eval_pass += other.n_eval_pass
-        self.n_set += other.n_set
-        self.n_set_pass += other.n_set_pass
-        self.n_get += other.n_get
-        self.n_get_pass += other.n_get_pass
-        self.n_load += other.n_load
-        self.n_load_pass += other.n_load_pass
-        self.n_save += other.n_save
-        self.n_save_pass += other.n_save_pass
-        self.n_add += other.n_add
-        self.n_add_pass += other.n_add_pass
-        self.n_sub += other.n_sub
-        self.n_sub_pass += other.n_sub_pass
-        self.n_mul += other.n_mul
-        self.n_mul_pass += other.n_mul_pass
-        self.n_div += other.n_div
-        self.n_div_pass += other.n_div_pass
-        if len(other.log)>0:
-            self.log += other.log
-        if len(other.trace)>0:
-            self.trace += other.trace
-            
-        if not other.model in self.modelList:
-            self.modelList.append(other.model)
-            
-        return self
-        
-    def isPassed(self):
-        """ Returns true if no error was found """
-        if self.n_cases_pass < self.n_cases \
-            or self.n_save_pass < self.n_save \
-            or self.n_load_pass < self.n_load \
-            or self.n_set_pass < self.n_set \
-            or self.n_get_pass < self.n_get \
-            or self.n_eval_pass < self.n_eval \
-            or self.n_add_pass < self.n_add \
-            or self.n_sub_pass < self.n_sub \
-            or self.n_mul_pass < self.n_mul \
-            or self.n_div_pass < self.n_div:
-            return False
-        return True
-        
-    def __str__(self):
-        """ String representation of the report card """
-        from sans.models.ModelFactory import ModelFactory
-        
-        rep = "Detailed output:\n"
-        rep += self.log
-        rep += "\n"
-        rep += "Total number of cases: %g\n" % self.n_cases
-        rep += "   Passed:             %g\n" % self.n_cases_pass
-        rep += "\n"
-        self.modelList.sort()
-        rep += "Models tested: %s\n" % self.modelList
-        all_models = ModelFactory().getAllModels()
-        all_models.sort()
-        rep += "\n"
-        rep += "Available models: %s\n" % all_models
-        rep += "\n"
-        rep += "Breakdown:\n"
-        rep += "   Eval:          %g / %g\n" % (self.n_eval_pass, self.n_eval)
-        rep += "   Set:           %g / %g\n" % (self.n_set_pass, self.n_set)
-        rep += "   Get:           %g / %g\n" % (self.n_get_pass, self.n_get)
-        rep += "   Load:          %g / %g\n" % (self.n_load_pass, self.n_load)
-        rep += "   Save:          %g / %g\n" % (self.n_save_pass, self.n_save)
-        rep += "   Add:           %g / %g\n" % (self.n_add_pass, self.n_add)
-        rep += "   Sub:           %g / %g\n" % (self.n_sub_pass, self.n_sub)
-        rep += "   Mul:           %g / %g\n" % (self.n_mul_pass, self.n_mul)
-        rep += "   Div:           %g / %g\n" % (self.n_div_pass, self.n_div)
-        return rep
-    
-        
-
-class TestCaseGenerator:
-    """ Generator for suite of test-cases
-    """
-    
-    def __init__(self):
-        """ Initialization
-        """
-        
-        self.n_tests = 0
-        self.n_passed = 0
-        self.time = 0
-        self.reportCard = ReportCard()
-    
-    def generateFiles(self, number, file_prefix):
-        """ Generate test-case files
-            @param number: number of files to generate
-            @param file_prefix: prefix for the file names
-        """
-        
-        for i in range(number):
-            filename = "%s_%d.xml" % (file_prefix, i)
-            self.generateFileTest(filename)
-            self.n_tests += 1
-            
-    def generateAndRun(self, number):
-        """ Generate test-cases and run them
-            @param number: number of test-cases to generate
-        """
-        start_time = time.time()
-        for i in range(number):
-            textcase = self.generateTest()
-            t = TestCase(text = textcase)
-            passed = t.run()
-            self.reportCard += t.reportCard
-            if not passed:
-                t = time.localtime()
-                xmloutput = open("error_%i-%i-%i-%i-%i-%i_%i.xml" % \
-                 (t[0],t[1],t[2],t[3],t[4],t[5],self.reportCard.n_cases),'w')
-                xmloutput.write(textcase)
-                xmloutput.close()
-
-                
-        self.time += time.time()-start_time
-        print self.reportCard        
-        
-    def generateFileTest(self, filename = "tmp.xml"):
-        """
-            Write a random test-case in an XML file
-            @param filename: name of file to write to
-        """
-        text = self.generateTest()
-        # Write test case in file
-        xmlfile = open(filename,'w')
-        xmlfile.write(text)
-        xmlfile.close()
-    
-    
-    def generateTest(self):
-        """
-            Generate an XML representation of a random test-case
-        """
-        import random
-        
-        #t = TestCase()
-        text = "<?xml version=\"1.0\"?>\n"
-        text  += "<TestCase>\n"
-        stimulus = "eval"
-    
-        loop = True
-        while loop:
-            rnd = random.random()
-            
-            # run 50%
-            if rnd <= 0.5:
-                stimulus = "eval"
-            elif rnd>0.5 and rnd<=0.7:
-                stimulus = "set"
-            elif rnd>0.7 and rnd<=0.72:
-                stimulus = "save"
-            elif rnd>0.72 and rnd<=0.74:
-                stimulus = "load"
-            elif rnd>0.74 and rnd<=0.8:
-                stimulus = "get"
-            elif rnd>0.8 and rnd<=0.81:
-                stimulus = "add"
-            elif rnd>0.81 and rnd<=0.82:
-                stimulus = "div"
-            elif rnd>0.82 and rnd<=0.83:
-                stimulus = "mul"
-            elif rnd>0.83 and rnd<=0.84:
-                stimulus = "sub"
-            else:
-                # just run and quit
-                stimulus = "eval"
-                loop = False
-                
-            text += "  <Stimulus id=\"%s\"/>\n" % stimulus
-        text += "</TestCase>"
-        
-        return text
-    
-        
-class TestCase:
-    """ Test-case class """
-    
-    def __init__(self, filename = None, text = None):
-        """ Initialization
-            @param filename: name of file containing the test case
-        """
-        #from sans.models.ModelFactory import ModelFactory
-        self.filename = filename
-        self.text = text
-        #self.model = ModelFactory().getModel(randomModel())
-        self.model = getRandomModelObject()
-        #self.model = ModelFactory().getModel("SphereModel")
-        self.passed = True
-        self.reportCard = ReportCard()
-        
-    
-    def run(self):
-        """ Read the test case and execute it """
-        from xml.dom.minidom import parse
-        from xml.dom.minidom import parseString
-        
-        # Initialize report
-        self.reportCard = ReportCard()
-        self.reportCard.model = self.model.name
-        self.reportCard.n_cases = 1
-        
-        if not self.text == None:
-            dom = parseString(self.text)
-        elif not self.filename == None:
-            dom = parse(self.filename)
-        else:
-            print "No input to parse"
-            return False
-        
-        if dom.hasChildNodes():
-            for n in dom.childNodes:
-                if n.nodeName == "TestCase":
-                    self.processStimuli(n)
-            
-        # Update report card        
-        if self.passed:
-            self.reportCard.n_cases_pass = 1
-            
-        return self.passed
-                          
-    def processStimuli(self, node):
-        """ Process the stimuli list in the TestCase node 
-            of an XML test-case file
-            @param node: test-case node
-        """
-        import testcase_generator as generator
-        report = ReportCard()
-        report.trace = "%s\n" % self.model.name
-        
-        self.passed = True
-        if node.hasChildNodes():
-            for n in node.childNodes:
-                if n.nodeName == "Stimulus":
-                    
-                    s_type = None
-                    if n.hasAttributes():
-                        # Get stilumus ID
-                        for i in range(len(n.attributes)):
-                            attr_name = n.attributes.item(i).name
-                            if attr_name == "id":
-                                s_type = n.attributes.item(i).nodeValue
-                    if hasattr(generator,"%sStimulus" % s_type):
-                        stimulus = getattr(generator,"%sStimulus" % s_type)
-                        #print s_type, self.model.name
-                        m, res = stimulus(self.model)
-                        #print "     ", m.name
-                        self.model = m
-                        if not res.isPassed():
-                            self.passed = False
-                        
-                        report += res
-                        
-                    else:
-                        print "Stimulus %s not found" % s_type
-                        
-        self.reportCard += report
-        
-        if not self.passed:
-            print "\nFailure:"
-            print report.trace
-        return self.passed
-        
-    
-def evalStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwise
-    """
-    minval = 0.001
-    maxval = 1.0
-    # Call run with random input
-    import random, math
-    input_value = random.random()*(maxval-minval)+minval
-    
-    # Catch division by zero, which can happen
-    # when creating random models
-    try:
-        # Choose whether we want 1D or 2D
-        if random.random()>0.5:
-            output = model.run(input_value)
-        else:
-            output = model.run([input_value, 2*math.pi*random.random()])            
-    except ZeroDivisionError:
-        print "Error evaluating model %s: %g" % (model.name, input_value)
-        output = None
-        
-    #print "Eval: %g" % output
-    
-    # Oracle bit - just check that we have a number...
-    passed = False
-    try:
-        if output != None and math.fabs(output) >= 0: 
-            passed = True
-    except:
-        print "---> Could not compute abs val", output, model.name
-        
-    
-    report = ReportCard()
-    report.n_eval = 1
-    if passed:
-        report.n_eval_pass = 1
-    else:
-        report.log = "Eval: bad output value %s\n" % str(output)
-        
-    report.trace = "Eval(%g) = %s %i\n" % (input_value, str(output), passed)    
-    return model, report
-
-def setStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwize
-    """
-    # Call run with random input
-    import random, math
-    minval = 1
-    maxval = 5
-    
-    # Choose a parameter to change
-    keys = model.getParamList()
-    if len(keys)==0:
-        #print model.name+" has no params"
-        return model, ReportCard()
-    
-    p_len = len(keys)
-    i_param = int(math.floor(random.random()*p_len))
-    p_name  = keys[i_param]
-    
-    # Choose a value
-    # Check for min/max
-    if hasattr(model, "details"):
-        if model.details.has_key(p_name):
-            if model.details[p_name][1] != None:
-                minval = model.details[p_name][1]
-            if model.details[p_name][2] != None:
-                maxval = model.details[p_name][2]
-        elif model.other.details.has_key(p_name):
-            if model.other.details[p_name][1] != None:
-                minval = model.other.details[p_name][1]
-            if model.other.details[p_name][2] != None:
-                maxval = model.other.details[p_name][2]
-        elif model.operateOn.details.has_key(p_name):
-            if model.operateOn.details[p_name][1] != None:
-                minval = model.operateOn.details[p_name][1]
-            if model.operateOn.details[p_name][2] != None:
-                maxval = model.operateOn.details[p_name][2]
-            
-    input_val = random.random()*(maxval-minval)+minval
-    model.setParam(p_name, input_val)
-    
-    # Read back
-    check_val = model.getParam(p_name)
-    #print "Set: %s = %g" % (p_name, check_val)
-    
-    # Oracle bit
-    passed = False
-    if check_val == input_val: 
-        passed = True
-    
-    report = ReportCard()
-    report.n_set = 1
-    if passed:
-        report.n_set_pass = 1
-    else:
-        report.log = "Set: parameter %s not set properly %g <> %g\n" % \
-            (p_name, input_val, check_val)
-        
-    report.trace = "Set %s = %g %i\n" % (p_name, input_val, passed)    
-    return model, report
-
-def getStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwise
-    """
-    import random, math
-    # Choose a parameter to change
-    keys = model.getParamList()
-    if len(keys)==0:
-        #print model.name+" has no params"
-        return model, ReportCard()    
-    
-    p_len = len(keys)
-    i_param = int(math.floor(random.random()*p_len))
-    p_name  = keys[i_param]
-    
-    # Read back
-    check_val = model.getParam(p_name)
-    #print "Get: %s = %g" % (p_name, check_val)
-    
-    # Oracle bit
-    passed = False
-    if math.fabs(check_val) >= 0: 
-        passed = True
-        
-    report = ReportCard()
-    report.n_get = 1
-    if passed:
-        report.n_get_pass = 1
-    else:
-        report.log = "Get: bad value for parameter %s: %g\n" % \
-            (p_name, check_val)
-        
-    report.trace = "Get %s = %g %i\n" % (p_name, check_val, passed)    
-    return model, report
-
-def loadStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwize
-    """
-    from sans.models.ModelIO import ModelIO
-    from sans.models.ModelFactory import ModelFactory
-    factory = ModelFactory()
-    io = ModelIO(factory)
-    
-    # testModel.xml should be in the directory
-    loaded = io.load("load_test_model.xml")
-    value2 = loaded.run(1)
-    
-    # Oracle bit
-    passed = False
-    if not value2 == 0: 
-        passed = True
-        
-    report = ReportCard()
-    report.n_load = 1
-    if passed:
-        report.n_load_pass = 1
-    else:
-        report.log = "Load: bad loaded model\n"
-        
-    report.trace = "Load = %s %i\n" % (loaded.name, passed)    
-    return model, report
-
-def saveStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwize
-    """
-    from sans.models.ModelIO import ModelIO
-    from sans.models.ModelFactory import ModelFactory
-    factory = ModelFactory()
-    io = ModelIO(factory)
-    io.save(model,"testModel.xml")
-    #value = model.run(1)
-
-    # Check it 
-    loaded = io.load("testModel.xml")
-    try:
-        value2 = loaded.run(1)
-    except ZeroDivisionError:
-        value2 = -1
-    
-    # Oracle bit
-    passed = False
-    
-    # The two outputs do not need to be the same
-    # since we do not save the parameters!
-    # If it's the subtraction of two identical models, 
-    # we will also get zero!
-    #if value2 == value: 
-    #    passed = True
-    
-    passed = True
-
-        
-    report = ReportCard()
-    report.n_save = 1
-    if passed:
-        report.n_save_pass = 1
-    else:
-        report.log = "Save: bad output from saved model %g\n" % value2
-        
-    report.trace = "Save %s %i\n" % (model.name, passed)    
-    return model, report
-
-def getRandomModelObject():
-    """
-        Return a random model object
-    """
-    from sans.models.ModelFactory import ModelFactory
-    while True:
-        try:
-            modelname = randomModel()
-            add_model = ModelFactory().getModel(modelname)
-            return add_model
-        except:
-            # Don't complain when a model can't be loaded.
-            # A list of tested models will appear in the 
-            # file report, which can be compared with the 
-            # list of available models, also printed.
-            pass
-            #print "Could not load ", modelname
-    
-
-def addStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwize
-    """
-    #from sans.models.ModelFactory import ModelFactory
-    #factory = ModelFactory()
-    #add_model = factory.getModel("SphereModel")
-    add_model = getRandomModelObject()
-            
-    tmp = model + add_model
-    model = tmp
-    
-    # Oracle bit
-    passed = False
-    
-    try:
-        value2 = model.run(1)
-        value2 = float(value2)
-    except:
-        passed = False
-    
-    # If we made it this far, we have a float
-    passed = True 
-        
-    report = ReportCard()
-    report.n_add = 1
-    if passed:
-        report.n_add_pass = 1
-    else:
-        report.log = "Add: bad output from composite model\n"
-        
-    report.trace = "Div %s %i\n" % (model.name, passed)    
-    return model, report
-
-def subStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwize
-    """
-    from sans.models.ModelFactory import ModelFactory
-    from random import random
-    
-    #factory = ModelFactory()
-    #sub_model = factory.getModel("CylinderModel")
-    #sub_model = factory.getModel(randomModel())
-    sub_model = getRandomModelObject()
-
-    
-    sub_model.params["scale"] = 1.1*random()
-    tmp = model - sub_model
-    
-    # Oracle bit
-    passed = False
-    
-    try:
-        value2 = tmp.run(1.1 * (1.0 + random()))
-        value2 = float(value2)
-    except:
-        value2 = None
-        passed = False
-    
-    # If we made it this far, we have a float
-    passed = True 
-        
-    report = ReportCard()
-    report.n_sub = 1
-    if passed:
-        report.n_sub_pass = 1
-    else:
-        report.log = "Sub: bad output from composite model\n"
-
-    report.trace = "Sub %s (%g - %g = %s) %i\n" % \
-        (model.name, model.run(1), \
-         sub_model.run(1), str(value2), passed)                
-    return tmp, report
-
-def mulStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwize
-    """
-    #from sans.models.ModelFactory import ModelFactory
-    #factory = ModelFactory()
-    #mul_model = factory.getModel("SphereModel")
-    #mul_model = factory.getModel(randomModel())
-    mul_model = getRandomModelObject()
-    tmp = model * mul_model
-    
-    # Oracle bit
-    passed = False
-    
-    from random import random
-    input_val = 1.1 * (1.0 + random())
-    v1 = None
-    v2 = None
-    try:
-        v1 = mul_model.run(input_val)
-        v2 = model.run(input_val)
-        value2 = tmp.run(input_val)
-        value2 = float(value2)
-    except ZeroDivisionError:
-        value2 = None
-    
-    # If we made it this far, we have a float
-    passed = True 
-        
-    report = ReportCard()
-    report.n_mul = 1
-    if passed:
-        report.n_mul_pass = 1
-    else:
-        report.log = "Mul: bad output from composite model\n"
-        
-    report.trace = "Mul %s (%s * %s = %s) %i\n" % \
-      (model.name, str(v1), str(v2), str(value2), passed)                
-    return tmp, report
-
-def divStimulus(model):
-    """ Apply the stimulus to the supplied model object
-        @param model: model to apply the stimulus to
-        @return: True if passed, False otherwise
-    """
-    #from sans.models.ModelFactory import ModelFactory
-    #factory = ModelFactory()
-    #div_model = factory.getModel("SphereModel")
-    #div_model = factory.getModel(randomModel())
-
-    from random import random
-    input_val = 1.5 * random()
-    
-    # Find a model that will not evaluate to zero
-    # at the input value
-    try_again = True
-    while try_again:
-        div_model = getRandomModelObject()
-        try:
-            v2 = div_model.run(input_val)
-            try_again = False
-        except:
-            pass
-        
-    tmp = model / div_model
-    
-    # Oracle bit
-    passed = False
-    
-    v1 = None
-    v2 = None
-    try:
-        
-        # Check individual models against bad combinations,
-        # which happen from time to time given that all 
-        # parameters are random
-        try:
-            v2 = div_model.run(input_val)
-            v1 = model.run(input_val)
-            value2 = tmp.run(input_val)
-            value2 = float(value2)
-        except ZeroDivisionError:
-            value2 = None
-    except:
-        passed = False
-    
-    # If we made it this far, we have a float
-    passed = True 
-        
-    report = ReportCard()
-    report.n_div = 1
-    if passed:
-        report.n_div_pass = 1
-    else:
-        report.log = "Div: bad output from composite model\n"
-        
-    report.trace = "Div %s/%s (%g) = %s / %s = %s %i\n" % \
-      (model.name, div_model.name, input_val, str(v1), str(v2), str(value2), passed)                
-    return tmp, report
-
-if __name__ == '__main__':
-    print "Model operations are no longer supported."
-    print "The TestCase generator for model operation can't be used with this version of sansmodels." 
-    
-    
-    #print randomModel()
-    #g = TestCaseGenerator()
-    #g.generateAndRun(20000)
-    
-    #t = TestCase(filename = "error_1.17721e+009.xml")
-    #print t.run()
-    
Index: sansmodels/test/utest_disperser.py
===================================================================
--- sansmodels/test/utest_disperser.py	(revision 77220eec89191ba4c75296b244ffd100f2ab2263)
+++ sansmodels/test/utest_disperser.py	(revision 0abf7bf37070c95d946c2656a2e3ef5d902d0027)
@@ -15,5 +15,5 @@
 
 from sans.models.sans_extension.c_models import Disperser
-from sans.models.ModelFactory import ModelFactory
+from sans.models.CylinderModel import CylinderModel
 from sans.models.DisperseModel import DisperseModel
       
@@ -22,5 +22,5 @@
     
     def setUp(self):
-        self.model = ModelFactory().getModel("CylinderModel")
+        self.model = CylinderModel()
         self.model.setParam("cyl_theta", 1.57)
         self.model.setParam("cyl_phi", 0.1)
@@ -84,5 +84,5 @@
     
     def setUp(self):
-        self.model = ModelFactory().getModel("CylinderModel")
+        self.model = CylinderModel()
         self.model.setParam("cyl_theta", 1.57)
         self.model.setParam("cyl_phi", 0.1)
Index: sansmodels/test/utest_models.py
===================================================================
--- sansmodels/test/utest_models.py	(revision 18e250cb66e3283c50a57dddaf692b17263dd72c)
+++ sansmodels/test/utest_models.py	(revision 0abf7bf37070c95d946c2656a2e3ef5d902d0027)
@@ -63,64 +63,5 @@
         self.comp.setParam('cyl_phi', 1*180/math.pi)
         self.assertAlmostEqual(self.comp.run([0.2, 2.5]), 
-                               0.038176446608393366, 4)
-       
-    def testIO(self):
-        from sans.models.ModelFactory import ModelFactory
-        from sans.models.ModelIO import ModelIO
-        factory = ModelFactory()
-        io = ModelIO(factory)
-        io.save(self.comp,"myModel.xml")
-        value = self.comp.run(1)
-        loaded = io.load("myModel.xml")
-        self.assertEqual(value, loaded.run(1))
-        
-    def testIO_add(self):
-        # version 0.5.0: No longer supported
-        return
-        from sans.models.ModelFactory import ModelFactory
-        from sans.models.ModelIO import ModelIO
-        factory = ModelFactory()
-        io = ModelIO(factory)
-        sph = factory.getModel("SphereModel")
-        cyl = factory.getModel("CylinderModel")
-        combo = sph - cyl
-        io.save(combo,"myModel.xml")
-        value = combo.run(1)
-        loaded = io.load("myModel.xml")
-        self.assertEqual(value, loaded.run(1))
-        
-    def testIO_add2(self):
-        # version 0.5.0: No longer supported
-        return
-        from sans.models.ModelFactory import ModelFactory
-        #from sans.models.ModelIO import ModelIO
-        factory = ModelFactory()
-        #io = ModelIO(factory)
-        sph = factory.getModel("SphereModel")
-        cyl = factory.getModel("CylinderModel")
-        sph2 = factory.getModel("SphereModel")
-        combo1 = cyl - sph
-        combo = combo1 / sph2
-        #combo1 = sph
-        #io.save(combo,"myModel.xml")
-        # Just check that we have some output
-        self.assertTrue(math.fabs(combo.run(1))>0)
-        #loaded = io.load("myModel.xml")
-        #self.assertEqual(value, loaded.run(1))
-        
-        
-      
-       
-class TestFactory(unittest.TestCase):
-    """Unit tests for Model Factory"""
-    
-    def setUp(self):
-        from sans.models.ModelFactory import ModelFactory
-        self.comp = ModelFactory().getModel('CylinderModel')
-        
-    def test1D(self):
-        """ Test 1D model of a cylinder """ 
-        self.assertAlmostEqual(self.comp.run(0.2), 0.041761386790780453, 4)
-        
+                               0.038176446608393366, 4) 
  
 class TestGaussian(unittest.TestCase):
Index: sansmodels/test/validate_1D_model.py
===================================================================
--- sansmodels/test/validate_1D_model.py	(revision 18e250cb66e3283c50a57dddaf692b17263dd72c)
+++ sansmodels/test/validate_1D_model.py	(revision 0abf7bf37070c95d946c2656a2e3ef5d902d0027)
@@ -25,5 +25,5 @@
             @param filename: name of the test data set
         """
-        from sans.models.ModelFactory import ModelFactory
+        from sans.models.CylinderModel import CylinderModel
         
         # Read the data file
@@ -46,5 +46,6 @@
                     print "Found class", toks[1]
                     classname = toks[1].lstrip().rstrip()
-                    model_object = ModelFactory().getModel(classname)
+                    exec "from sans.models.%s import %s" % (classname, classname)
+                    exec "model_object = %s()" % classname
                 
                     # Output file for plotting
