Changeset 17bbadd in sasmodels for sasmodels/generate.py

Timestamp:

Mar 15, 2016 12:47:12 PM (8 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, costrafo411, magnetic_model, release_v0.94, release_v0.95, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

754e27b

Parents:

5ceb7d0

Message:

refactor so all model defintion queries use model_info; better documentation of model_info structure; initial implementation of product model (broken)

File:

• sasmodels/generate.py (modified) (14 diffs)

sasmodels/generate.py

@@ -117 +117 @@
     are added to the beginning of the parameter list.  They will show up
     in the documentation as model parameters, but they are never sent to
-    the kernel functions.
-
-    *category* is the default category for the model.  Models in the
-    *structure-factor* category do not have *scale* and *background*
-    added.
+    the kernel functions.  Note that *effect_radius* and *volfraction*
+    must occur first in structure factor calculations.
+
+    *category* is the default category for the model.  The category is
+    two level structure, with the form "group:section", indicating where
+    in the manual the model will be located.  Models are alphabetical
+    within their section.
 
     *source* is the list of C-99 source files that must be joined to
@@ -157 +159 @@
 
 
-An *info* dictionary is constructed from the kernel meta data and
+An *model_info* dictionary is constructed from the kernel meta data and
 returned to the caller.
 
@@ -190 +192 @@
 
 The function :func:`make` loads the metadata from the module and returns
-the kernel source.  The function :func:`doc` extracts the doc string
+the kernel source.  The function :func:`make_doc` extracts the doc string
 and adds the parameter table to the top.  The function :func:`model_sources`
 returns a list of files required by the model.
@@ -217 +219 @@
 import numpy as np
 
-#__all__ = ["make", "doc", "model_sources", "convert_type"]
+#TODO: determine which functions are useful outside of generate
+#__all__ = ["model_info", "make_doc", "make_source", "convert_type"]
 
 C_KERNEL_TEMPLATE_PATH = joinpath(dirname(__file__), 'kernel_template.c')
@@ -327 +330 @@
     raise ValueError("%r not found in %s" % (filename, search_path))
 
-def model_sources(info):
+def model_sources(model_info):
     """
     Return a list of the sources file paths for the module.
     """
-    search_path = [dirname(info['filename']),
+    search_path = [dirname(model_info['filename']),
                    abspath(joinpath(dirname(__file__), 'models'))]
-    return [_search(search_path, f) for f in info['source']]
+    return [_search(search_path, f) for f in model_info['source']]
 
 # Pragmas for enable OpenCL features.  Be sure to protect them so that they
@@ -391 +394 @@
 
 
-def kernel_name(info, is_2d):
+def kernel_name(model_info, is_2d):
     """
     Name of the exported kernel symbol.
     """
-    return info['name'] + "_" + ("Iqxy" if is_2d else "Iq")
-
+    return model_info['name'] + "_" + ("Iqxy" if is_2d else "Iq")
+
+
+def indent(s, depth):
+    """
+    Indent a string of text with *depth* additional spaces on each line.
+    """
+    spaces = " "*depth
+    sep = "\n" + spaces
+    return spaces + sep.join(s.split("\n"))
+
+
+LOOP_OPEN = """\
+for (int %(name)s_i=0; %(name)s_i < N%(name)s; %(name)s_i++) {
+  const double %(name)s = loops[2*(%(name)s_i%(offset)s)];
+  const double %(name)s_w = loops[2*(%(name)s_i%(offset)s)+1];\
+"""
+def build_polydispersity_loops(pd_pars):
+    """
+    Build polydispersity loops
+
+    Returns loop opening and loop closing
+    """
+    depth = 4
+    offset = ""
+    loop_head = []
+    loop_end = []
+    for name in pd_pars:
+        subst = {'name': name, 'offset': offset}
+        loop_head.append(indent(LOOP_OPEN % subst, depth))
+        loop_end.insert(0, (" "*depth) + "}")
+        offset += '+N' + name
+        depth += 2
+    return "\n".join(loop_head), "\n".join(loop_end)
+
+C_KERNEL_TEMPLATE = None
+def make_source(model_info):
+    """
+    Generate the OpenCL/ctypes kernel from the module info.
+
+    Uses source files found in the given search path.
+    """
+    if callable(model_info['Iq']):
+        return None
+
+    # TODO: need something other than volume to indicate dispersion parameters
+    # No volume normalization despite having a volume parameter.
+    # Thickness is labelled a volume in order to trigger polydispersity.
+    # May want a separate dispersion flag, or perhaps a separate category for
+    # disperse, but not volume.  Volume parameters also use relative values
+    # for the distribution rather than the absolute values used by angular
+    # dispersion.  Need to be careful that necessary parameters are available
+    # for computing volume even if we allow non-disperse volume parameters.
+
+    # Load template
+    global C_KERNEL_TEMPLATE
+    if C_KERNEL_TEMPLATE is None:
+        with open(C_KERNEL_TEMPLATE_PATH) as fid:
+            C_KERNEL_TEMPLATE = fid.read()
+
+    # Load additional sources
+    source = [open(f).read() for f in model_sources(model_info)]
+
+    # Prepare defines
+    defines = []
+    partype = model_info['partype']
+    pd_1d = partype['pd-1d']
+    pd_2d = partype['pd-2d']
+    fixed_1d = partype['fixed-1d']
+    fixed_2d = partype['fixed-1d']
+
+    iq_parameters = [p[0]
+                     for p in model_info['parameters'][2:]  # skip scale, background
+                     if p[0] in set(fixed_1d + pd_1d)]
+    iqxy_parameters = [p[0]
+                       for p in model_info['parameters'][2:]  # skip scale, background
+                       if p[0] in set(fixed_2d + pd_2d)]
+    volume_parameters = [p[0]
+                         for p in model_info['parameters']
+                         if p[4] == 'volume']
+
+    # Fill in defintions for volume parameters
+    if volume_parameters:
+        defines.append(('VOLUME_PARAMETERS',
+                        ','.join(volume_parameters)))
+        defines.append(('VOLUME_WEIGHT_PRODUCT',
+                        '*'.join(p + '_w' for p in volume_parameters)))
+
+    # Generate form_volume function from body only
+    if model_info['form_volume'] is not None:
+        if volume_parameters:
+            vol_par_decl = ', '.join('double ' + p for p in volume_parameters)
+        else:
+            vol_par_decl = 'void'
+        defines.append(('VOLUME_PARAMETER_DECLARATIONS',
+                        vol_par_decl))
+        fn = """\
+double form_volume(VOLUME_PARAMETER_DECLARATIONS);
+double form_volume(VOLUME_PARAMETER_DECLARATIONS) {
+    %(body)s
+}
+""" % {'body':model_info['form_volume']}
+        source.append(fn)
+
+    # Fill in definitions for Iq parameters
+    defines.append(('IQ_KERNEL_NAME', model_info['name'] + '_Iq'))
+    defines.append(('IQ_PARAMETERS', ', '.join(iq_parameters)))
+    if fixed_1d:
+        defines.append(('IQ_FIXED_PARAMETER_DECLARATIONS',
+                        ', \\\n    '.join('const double %s' % p for p in fixed_1d)))
+    if pd_1d:
+        defines.append(('IQ_WEIGHT_PRODUCT',
+                        '*'.join(p + '_w' for p in pd_1d)))
+        defines.append(('IQ_DISPERSION_LENGTH_DECLARATIONS',
+                        ', \\\n    '.join('const int N%s' % p for p in pd_1d)))
+        defines.append(('IQ_DISPERSION_LENGTH_SUM',
+                        '+'.join('N' + p for p in pd_1d)))
+        open_loops, close_loops = build_polydispersity_loops(pd_1d)
+        defines.append(('IQ_OPEN_LOOPS',
+                        open_loops.replace('\n', ' \\\n')))
+        defines.append(('IQ_CLOSE_LOOPS',
+                        close_loops.replace('\n', ' \\\n')))
+    if model_info['Iq'] is not None:
+        defines.append(('IQ_PARAMETER_DECLARATIONS',
+                        ', '.join('double ' + p for p in iq_parameters)))
+        fn = """\
+double Iq(double q, IQ_PARAMETER_DECLARATIONS);
+double Iq(double q, IQ_PARAMETER_DECLARATIONS) {
+    %(body)s
+}
+""" % {'body':model_info['Iq']}
+        source.append(fn)
+
+    # Fill in definitions for Iqxy parameters
+    defines.append(('IQXY_KERNEL_NAME', model_info['name'] + '_Iqxy'))
+    defines.append(('IQXY_PARAMETERS', ', '.join(iqxy_parameters)))
+    if fixed_2d:
+        defines.append(('IQXY_FIXED_PARAMETER_DECLARATIONS',
+                        ', \\\n    '.join('const double %s' % p for p in fixed_2d)))
+    if pd_2d:
+        defines.append(('IQXY_WEIGHT_PRODUCT',
+                        '*'.join(p + '_w' for p in pd_2d)))
+        defines.append(('IQXY_DISPERSION_LENGTH_DECLARATIONS',
+                        ', \\\n    '.join('const int N%s' % p for p in pd_2d)))
+        defines.append(('IQXY_DISPERSION_LENGTH_SUM',
+                        '+'.join('N' + p for p in pd_2d)))
+        open_loops, close_loops = build_polydispersity_loops(pd_2d)
+        defines.append(('IQXY_OPEN_LOOPS',
+                        open_loops.replace('\n', ' \\\n')))
+        defines.append(('IQXY_CLOSE_LOOPS',
+                        close_loops.replace('\n', ' \\\n')))
+    if model_info['Iqxy'] is not None:
+        defines.append(('IQXY_PARAMETER_DECLARATIONS',
+                        ', '.join('double ' + p for p in iqxy_parameters)))
+        fn = """\
+double Iqxy(double qx, double qy, IQXY_PARAMETER_DECLARATIONS);
+double Iqxy(double qx, double qy, IQXY_PARAMETER_DECLARATIONS) {
+    %(body)s
+}
+""" % {'body':model_info['Iqxy']}
+        source.append(fn)
+
+    # Need to know if we have a theta parameter for Iqxy; it is not there
+    # for the magnetic sphere model, for example, which has a magnetic
+    # orientation but no shape orientation.
+    if 'theta' in pd_2d:
+        defines.append(('IQXY_HAS_THETA', '1'))
+
+    #for d in defines: print(d)
+    defines = '\n'.join('#define %s %s' % (k, v) for k, v in defines)
+    sources = '\n\n'.join(source)
+    return C_KERNEL_TEMPLATE % {
+        'DEFINES': defines,
+        'SOURCES': sources,
+        }
 
 def categorize_parameters(pars):
@@ -403 +579 @@
 
     Returns a dictionary of categories.
+
+    Note: these categories are subject to change, depending on the needs of
+    the UI and the needs of the kernel calling function.
+
+    The categories are as follows:
+
+    * *volume* list of volume parameter names
+    * *orientation* list of orientation parameters
+    * *magnetic* list of magnetic parameters
+    * *<empty string>* list of parameters that have no type info
+
+    Each parameter is in one and only one category.
+
+    The following derived categories are created:
+
+    * *fixed-1d* list of non-polydisperse parameters for 1D models
+    * *pd-1d* list of polydisperse parameters for 1D models
+    * *fixed-2d* list of non-polydisperse parameters for 2D models
+    * *pd-d2* list of polydisperse parameters for 2D models
     """
     partype = {
@@ -429 +624 @@
     return partype
 
-def indent(s, depth):
-    """
-    Indent a string of text with *depth* additional spaces on each line.
-    """
-    spaces = " "*depth
-    sep = "\n" + spaces
-    return spaces + sep.join(s.split("\n"))
-
-
-LOOP_OPEN = """\
-for (int %(name)s_i=0; %(name)s_i < N%(name)s; %(name)s_i++) {
-  const double %(name)s = loops[2*(%(name)s_i%(offset)s)];
-  const double %(name)s_w = loops[2*(%(name)s_i%(offset)s)+1];\
-"""
-def build_polydispersity_loops(pd_pars):
-    """
-    Build polydispersity loops
-
-    Returns loop opening and loop closing
-    """
-    depth = 4
-    offset = ""
-    loop_head = []
-    loop_end = []
-    for name in pd_pars:
-        subst = {'name': name, 'offset': offset}
-        loop_head.append(indent(LOOP_OPEN % subst, depth))
-        loop_end.insert(0, (" "*depth) + "}")
-        offset += '+N' + name
-        depth += 2
-    return "\n".join(loop_head), "\n".join(loop_end)
-
-C_KERNEL_TEMPLATE = None
-def make_model(info):
-    """
-    Generate the code for the kernel defined by info, using source files
-    found in the given search path.
-    """
-    # TODO: need something other than volume to indicate dispersion parameters
-    # No volume normalization despite having a volume parameter.
-    # Thickness is labelled a volume in order to trigger polydispersity.
-    # May want a separate dispersion flag, or perhaps a separate category for
-    # disperse, but not volume.  Volume parameters also use relative values
-    # for the distribution rather than the absolute values used by angular
-    # dispersion.  Need to be careful that necessary parameters are available
-    # for computing volume even if we allow non-disperse volume parameters.
-
-    # Load template
-    global C_KERNEL_TEMPLATE
-    if C_KERNEL_TEMPLATE is None:
-        with open(C_KERNEL_TEMPLATE_PATH) as fid:
-            C_KERNEL_TEMPLATE = fid.read()
-
-    # Load additional sources
-    source = [open(f).read() for f in model_sources(info)]
-
-    # Prepare defines
-    defines = []
-    partype = info['partype']
-    pd_1d = partype['pd-1d']
-    pd_2d = partype['pd-2d']
-    fixed_1d = partype['fixed-1d']
-    fixed_2d = partype['fixed-1d']
-
-    iq_parameters = [p[0]
-                     for p in info['parameters'][2:] # skip scale, background
-                     if p[0] in set(fixed_1d + pd_1d)]
-    iqxy_parameters = [p[0]
-                       for p in info['parameters'][2:] # skip scale, background
-                       if p[0] in set(fixed_2d + pd_2d)]
-    volume_parameters = [p[0]
-                         for p in info['parameters']
-                         if p[4] == 'volume']
-
-    # Fill in defintions for volume parameters
-    if volume_parameters:
-        defines.append(('VOLUME_PARAMETERS',
-                        ','.join(volume_parameters)))
-        defines.append(('VOLUME_WEIGHT_PRODUCT',
-                        '*'.join(p + '_w' for p in volume_parameters)))
-
-    # Generate form_volume function from body only
-    if info['form_volume'] is not None:
-        if volume_parameters:
-            vol_par_decl = ', '.join('double ' + p for p in volume_parameters)
-        else:
-            vol_par_decl = 'void'
-        defines.append(('VOLUME_PARAMETER_DECLARATIONS',
-                        vol_par_decl))
-        fn = """\
-double form_volume(VOLUME_PARAMETER_DECLARATIONS);
-double form_volume(VOLUME_PARAMETER_DECLARATIONS) {
-    %(body)s
-}
-""" % {'body':info['form_volume']}
-        source.append(fn)
-
-    # Fill in definitions for Iq parameters
-    defines.append(('IQ_KERNEL_NAME', info['name'] + '_Iq'))
-    defines.append(('IQ_PARAMETERS', ', '.join(iq_parameters)))
-    if fixed_1d:
-        defines.append(('IQ_FIXED_PARAMETER_DECLARATIONS',
-                        ', \\\n    '.join('const double %s' % p for p in fixed_1d)))
-    if pd_1d:
-        defines.append(('IQ_WEIGHT_PRODUCT',
-                        '*'.join(p + '_w' for p in pd_1d)))
-        defines.append(('IQ_DISPERSION_LENGTH_DECLARATIONS',
-                        ', \\\n    '.join('const int N%s' % p for p in pd_1d)))
-        defines.append(('IQ_DISPERSION_LENGTH_SUM',
-                        '+'.join('N' + p for p in pd_1d)))
-        open_loops, close_loops = build_polydispersity_loops(pd_1d)
-        defines.append(('IQ_OPEN_LOOPS',
-                        open_loops.replace('\n', ' \\\n')))
-        defines.append(('IQ_CLOSE_LOOPS',
-                        close_loops.replace('\n', ' \\\n')))
-    if info['Iq'] is not None:
-        defines.append(('IQ_PARAMETER_DECLARATIONS',
-                        ', '.join('double ' + p for p in iq_parameters)))
-        fn = """\
-double Iq(double q, IQ_PARAMETER_DECLARATIONS);
-double Iq(double q, IQ_PARAMETER_DECLARATIONS) {
-    %(body)s
-}
-""" % {'body':info['Iq']}
-        source.append(fn)
-
-    # Fill in definitions for Iqxy parameters
-    defines.append(('IQXY_KERNEL_NAME', info['name'] + '_Iqxy'))
-    defines.append(('IQXY_PARAMETERS', ', '.join(iqxy_parameters)))
-    if fixed_2d:
-        defines.append(('IQXY_FIXED_PARAMETER_DECLARATIONS',
-                        ', \\\n    '.join('const double %s' % p for p in fixed_2d)))
-    if pd_2d:
-        defines.append(('IQXY_WEIGHT_PRODUCT',
-                        '*'.join(p + '_w' for p in pd_2d)))
-        defines.append(('IQXY_DISPERSION_LENGTH_DECLARATIONS',
-                        ', \\\n    '.join('const int N%s' % p for p in pd_2d)))
-        defines.append(('IQXY_DISPERSION_LENGTH_SUM',
-                        '+'.join('N' + p for p in pd_2d)))
-        open_loops, close_loops = build_polydispersity_loops(pd_2d)
-        defines.append(('IQXY_OPEN_LOOPS',
-                        open_loops.replace('\n', ' \\\n')))
-        defines.append(('IQXY_CLOSE_LOOPS',
-                        close_loops.replace('\n', ' \\\n')))
-    if info['Iqxy'] is not None:
-        defines.append(('IQXY_PARAMETER_DECLARATIONS',
-                        ', '.join('double ' + p for p in iqxy_parameters)))
-        fn = """\
-double Iqxy(double qx, double qy, IQXY_PARAMETER_DECLARATIONS);
-double Iqxy(double qx, double qy, IQXY_PARAMETER_DECLARATIONS) {
-    %(body)s
-}
-""" % {'body':info['Iqxy']}
-        source.append(fn)
-
-    # Need to know if we have a theta parameter for Iqxy; it is not there
-    # for the magnetic sphere model, for example, which has a magnetic
-    # orientation but no shape orientation.
-    if 'theta' in pd_2d:
-        defines.append(('IQXY_HAS_THETA', '1'))
-
-    #for d in defines: print(d)
-    defines = '\n'.join('#define %s %s' % (k, v) for k, v in defines)
-    sources = '\n\n'.join(source)
-    return C_KERNEL_TEMPLATE % {
-        'DEFINES': defines,
-        'SOURCES': sources,
-        }
-
-def make_info(kernel_module):
+def process_parameters(model_info):
+    """
+    Process parameter block, precalculating parameter details.
+    """
+    # Fill in the derived attributes
+    model_info['limits'] = dict((p[0], p[3]) for p in model_info['parameters'])
+    model_info['partype'] = categorize_parameters(model_info['parameters'])
+    model_info['defaults'] = dict((p[0], p[2]) for p in model_info['parameters'])
+    if model_info.get('demo', None) is None:
+        model_info['demo'] = model_info['defaults']
+
+def make_model_info(kernel_module):
     """
     Interpret the model definition file, categorizing the parameters.
-    """
+
+    The module can be loaded with a normal python import statement if you
+    know which module you need, or with __import__('sasmodels.model.'+name)
+    if the name is in a string.
+
+    The *model_info* structure contains the following fields:
+
+    * *id* is the id of the kernel
+    * *name* is the display name of the kernel
+    * *title* is a short description of the kernel
+    * *description* is a long description of the kernel (this doesn't seem
+      very useful since the Help button on the model page brings you directly
+      to the documentation page)
+    * *docs* is the docstring from the module.  Use :func:`make_doc` to
+    * *category* specifies the model location in the docs
+    * *parameters* is the model parameter table
+    * *single* is True if the model allows single precision
+    * *defaults* is the *{parameter: value}* table built from the parameter
+      description table.
+    * *limits* is the *{parameter: [min, max]}* table built from the
+      parameter description table.
+    * *partypes* categorizes the model parameters. See
+      :func:`categorize_parameters` for details.
+    * *demo* contains the *{parameter: value}* map used in compare (and maybe
+      for the demo plot, if plots aren't set up to use the default values).
+      If *demo* is not given in the file, then the default values will be used.
+    * *tests* is a set of tests that must pass
+    * *source* is the list of library files to include in the C model build
+    * *Iq*, *Iqxy*, *form_volume*, *ER*, and *VR* are python functions
+      implementing the kernel for the module, or None if they are not
+      defined in python
+    * *oldname* is the model name in pre-4.0 Sasview
+    * *oldpars* is the *{new: old}* parameter translation table
+      from pre-4.0 Sasview
+    * *composition* is None if the model is independent, otherwise it is a
+      tuple with composition type ('product' or 'mixture') and a list of
+      *model_info* blocks for the composition objects.  This allows us to
+      build complete product and mixture models from just the info.
+    """
+    # TODO: maybe turn model_info into a class ModelDefinition
     #print(kernelfile)
     category = getattr(kernel_module, 'category', None)
@@ -608 +684 @@
     # parameters if an explicit demo parameter set has not been specified.
     demo_parameters = getattr(kernel_module, 'demo', None)
-    if demo_parameters is None:
-        demo_parameters = dict((p[0], p[2]) for p in parameters)
     filename = abspath(kernel_module.__file__)
     kernel_id = splitext(basename(filename))[0]
     name = getattr(kernel_module, 'name', None)
+    single = getattr(kernel_module, 'single', True)
     if name is None:
         name = " ".join(w.capitalize() for w in kernel_id.split('_'))
-    info = dict(
+    model_info = dict(
         id=kernel_id,  # string used to load the kernel
         filename=abspath(kernel_module.__file__),
@@ -621 +696 @@
         title=kernel_module.title,
         description=kernel_module.description,
+        docs=kernel_module.__doc__,
         category=category,
         parameters=parameters,
+        composition=None,
+        single=single,
         demo=demo_parameters,
         source=getattr(kernel_module, 'source', []),
-        oldname=kernel_module.oldname,
-        oldpars=kernel_module.oldpars,
+        oldname=getattr(kernel_module, 'oldname', None),
+        oldpars=getattr(kernel_module, 'oldpars', {}),
+        tests=getattr(kernel_module, 'tests', []),
         )
+    process_parameters(model_info)
     # Fill in attributes which default to None
-    info.update((k, getattr(kernel_module, k, None))
-                for k in ('ER', 'VR', 'form_volume', 'Iq', 'Iqxy'))
-    # Fill in the derived attributes
-    info['limits'] = dict((p[0], p[3]) for p in info['parameters'])
-    info['partype'] = categorize_parameters(info['parameters'])
-    info['defaults'] = dict((p[0], p[2]) for p in info['parameters'])
-    return info
-
-def make(kernel_module):
-    """
-    Build an OpenCL/ctypes function from the definition in *kernel_module*.
-
-    The module can be loaded with a normal python import statement if you
-    know which module you need, or with __import__('sasmodels.model.'+name)
-    if the name is in a string.
-    """
-    info = make_info(kernel_module)
-    # Assume if one part of the kernel is python then all parts are.
-    source = make_model(info) if not callable(info['Iq']) else None
-    return source, info
+    model_info.update((k, getattr(kernel_module, k, None))
+                      for k in ('ER', 'VR', 'form_volume', 'Iq', 'Iqxy'))
+    return model_info
 
 section_marker = re.compile(r'\A(?P<first>[%s])(?P=first)*\Z'
@@ -683 +746 @@
     return "\n".join(_convert_section_titles_to_boldface(s.split('\n')))
 
-def doc(kernel_module):
+def make_doc(model_info):
     """
     Return the documentation for the model.
@@ -689 +752 @@
     Iq_units = "The returned value is scaled to units of |cm^-1| |sr^-1|, absolute scale."
     Sq_units = "The returned value is a dimensionless structure factor, $S(q)$."
-    info = make_info(kernel_module)
-    is_Sq = ("structure-factor" in info['category'])
+    is_Sq = ("structure-factor" in model_info['category'])
     #docs = kernel_module.__doc__
-    docs = convert_section_titles_to_boldface(kernel_module.__doc__)
-    subst = dict(id=info['id'].replace('_', '-'),
-                 name=info['name'],
-                 title=info['title'],
-                 parameters=make_partable(info['parameters']),
+    docs = convert_section_titles_to_boldface(model_info['docs'])
+    subst = dict(id=model_info['id'].replace('_', '-'),
+                 name=model_info['name'],
+                 title=model_info['title'],
+                 parameters=make_partable(model_info['parameters']),
                  returns=Sq_units if is_Sq else Iq_units,
                  docs=docs)
@@ -710 +772 @@
     import datetime
     tic = datetime.datetime.now()
-    make(cylinder)
+    make_source(make_model_info(cylinder))
     toc = (datetime.datetime.now() - tic).total_seconds()
     print("time: %g"%toc)
@@ -725 +787 @@
         __import__('sasmodels.models.' + name)
         model = getattr(sasmodels.models, name)
-        source, _ = make(model)
+        model_info = make_model_info(model)
+        source = make_source(model_info)
         print(source)