class FitRecipe(_fitrecipe_interface, RecipeOrganizer): """FitRecipe class. Attributes name -- A name for this FitRecipe. fithooks -- List of FitHook instances that can pass information out of the system during a refinement. By default, the is populated by a PrintFitHook instance. _constraints -- A dictionary of Constraints, indexed by the constrained Parameter. Constraints can be added using the 'constrain' method. _oconstraints -- An ordered list of the constraints from this and all sub-components. _calculators -- A managed dictionary of Calculators. _contributions -- A managed OrderedDict of FitContributions. _parameters -- A managed OrderedDict of parameters (in this case the parameters are varied). _parsets -- A managed dictionary of ParameterSets. _eqfactory -- A diffpy.srfit.equation.builder.EquationFactory instance that is used to create constraints and restraints from string _restraintlist -- A list of restraints from this and all sub-components. _restraints -- A set of Restraints. Restraints can be added using the 'restrain' or 'confine' methods. _ready -- A flag indicating if all attributes are ready for the calculation. _tagmanager -- A TagManager instance for managing tags on Parameters. _weights -- List of weighing factors for each FitContribution. The weights are multiplied by the residual of the FitContribution when determining the overall residual. _fixedtag -- "__fixed", used for tagging variables as fixed. Don't use this tag unless you want issues. Properties names -- Variable names (read only). See getNames. values -- Variable values (read only). See getValues. fixednames -- Names of the fixed refinable variables (read only). fixedvalues -- Values of the fixed refinable variables (read only). bounds -- Bounds on parameters (read only). See getBounds. bounds2 -- Bounds on parameters (read only). See getBounds2. """ fixednames = property(lambda self: [ v.name for v in self._parameters.values() if not (self.isFree(v) or self.isConstrained(v)) ], doc='names of the fixed refinable variables') fixedvalues = property(lambda self: array([ v.value for v in self._parameters.values() if not (self.isFree(v) or self.isConstrained(v)) ]), doc='values of the fixed refinable variables') bounds = property(lambda self: self.getBounds()) bounds2 = property(lambda self: self.getBounds2()) def __init__(self, name="fit"): """Initialization.""" RecipeOrganizer.__init__(self, name) self.fithooks = [] self.pushFitHook(PrintFitHook()) self._restraintlist = [] self._oconstraints = [] self._ready = False self._fixedtag = "__fixed" self._weights = [] self._tagmanager = TagManager() self._parsets = {} self._manage(self._parsets) self._contributions = OrderedDict() self._manage(self._contributions) return def pushFitHook(self, fithook, index=None): """Add a FitHook to be called within the residual method. The hook is an object for reporting updates, or more fundamentally, passing information out of the system during a refinement. See the diffpy.srfit.fitbase.fithook.FitHook class for the required interface. Added FitHooks will be called sequentially during refinement. fithook -- FitHook instance to add to the sequence index -- Index for inserting fithook into the list of fit hooks. If this is None (default), the fithook is added to the end. """ if index is None: index = len(self.fithooks) self.fithooks.insert(index, fithook) # Make sure the added FitHook gets its reset method called. self._updateConfiguration() return def popFitHook(self, fithook=None, index=-1): """Remove a FitHook by index or reference. fithook -- FitHook instance to remove from the sequence. If this is None (default), default to index. index -- Index of FitHook instance to remove (default -1). Raises ValueError if fithook is not None, but is not present in the sequence. Raises IndexError if the sequence is empty or index is out of range. """ if fithook is not None: self.fithooks.remove(fithook) return self.fithook.remove(index) return def getFitHooks(self): """Get the sequence of FitHook instances.""" return self.fithooks[:] def clearFitHooks(self): """Clear the FitHook sequence.""" del self.fithooks[:] return def addContribution(self, con, weight=1.0): """Add a FitContribution to the FitRecipe. con -- The FitContribution to be stored. Raises ValueError if the FitContribution has no name Raises ValueError if the FitContribution has the same name as some other managed object. """ self._addObject(con, self._contributions, True) self._weights.append(weight) return def setWeight(self, con, weight): """Set the weight of a FitContribution.""" idx = self._contributions.values().index(con) self._weights[idx] = weight return def addParameterSet(self, parset): """Add a ParameterSet to the hierarchy. parset -- The ParameterSet to be stored. Raises ValueError if the ParameterSet has no name. Raises ValueError if the ParameterSet has the same name as some other managed object. """ self._addObject(parset, self._parsets, True) return def removeParameterSet(self, parset): """Remove a ParameterSet from the hierarchy. Raises ValueError if parset is not managed by this object. """ self._removeObject(parset, self._parsets) return def residual(self, p=[]): """Calculate the vector residual to be optimized. Arguments p -- The list of current variable values, provided in the same order as the '_parameters' list. If p is an empty iterable (default), then it is assumed that the parameters have already been updated in some other way, and the explicit update within this function is skipped. The residual is by default the weighted concatenation of each FitContribution's residual, plus the value of each restraint. The array returned, denoted chiv, is such that dot(chiv, chiv) = chi^2 + restraints. """ # Prepare, if necessary self._prepare() for fithook in self.fithooks: fithook.precall(self) # Update the variable parameters. self._applyValues(p) # Update the constraints. These are ordered such that the list only # needs to be cycled once. for con in self._oconstraints: con.update() # Calculate the bare chiv chiv = concatenate([ wi * ci.residual().flatten() for wi, ci in zip(self._weights, self._contributions.values()) ]) # Calculate the point-average chi^2 w = dot(chiv, chiv) / len(chiv) # Now we must append the restraints penalties = [sqrt(res.penalty(w)) for res in self._restraintlist] chiv = concatenate([chiv, penalties]) for fithook in self.fithooks: fithook.postcall(self, chiv) return chiv def scalarResidual(self, p=[]): """Calculate the scalar residual to be optimized. Arguments p -- The list of current variable values, provided in the same order as the '_parameters' list. If p is an empty iterable (default), then it is assumed that the parameters have already been updated in some other way, and the explicit update within this function is skipped. The residual is by default the weighted concatenation of each FitContribution's residual, plus the value of each restraint. The array returned, denoted chiv, is such that dot(chiv, chiv) = chi^2 + restraints. """ chiv = self.residual(p) return dot(chiv, chiv) def __call__(self, p=[]): """Same as scalarResidual method.""" return self.scalarResidual(p) def _prepare(self): """Prepare for the residual calculation, if necessary. This will prepare the data attributes to be used in the residual calculation. This updates the local restraints with those of the contributions. Raises AttributeError if there are variables without a value. """ # Only prepare if the configuration has changed within the recipe # hierarchy. if self._ready: return # Inform the fit hooks that we're updating things for fithook in self.fithooks: fithook.reset(self) # Check Profiles self.__verifyProfiles() # Check parameters self.__verifyParameters() # Update constraints and restraints. self.__collectConstraintsAndRestraints() # We do this here so that the calculations that take place during the # validation use the most current values of the parameters. In most # cases, this will save us from recalculating them later. for con in self._oconstraints: con.update() # Validate! self._validate() self._ready = True return def __verifyProfiles(self): """Verify that each FitContribution has a Profile.""" # Check for profile values for con in self._contributions.values(): if con.profile is None: m = "FitContribution '%s' does not have a Profile" % con.name raise AttributeError(m) if con.profile.x is None or\ con.profile.y is None or\ con.profile.dy is None: m = "Profile for '%s' is missing data" % con.name raise AttributeError(m) return def __verifyParameters(self): """Verify that all Parameters have values.""" # Get all parameters with a value of None badpars = [] for par in self.iterPars(): try: par.getValue() except ValueError: badpars.append(par) # Get the bad names badnames = [] for par in badpars: objlist = self._locateManagedObject(par) names = [obj.name for obj in objlist] badnames.append(".".join(names)) # Construct an error message, if necessary m = "" if len(badnames) == 1: m = "%s is not defined or needs an initial value" % badnames[0] elif len(badnames) > 0: s1 = ",".join(badnames[:-1]) s2 = badnames[-1] m = "%s and %s are not defined or need initial values" % (s1, s2) if m: raise AttributeError(m) return def __collectConstraintsAndRestraints(self): """Collect the Constraints and Restraints from subobjects.""" from itertools import chain from functools import cmp_to_key rset = set(self._restraints) cdict = {} for org in chain(self._contributions.values(), self._parsets.values()): rset.update(org._getRestraints()) cdict.update(org._getConstraints()) cdict.update(self._constraints) # The order of the restraint list does not matter self._restraintlist = list(rset) # Reorder the constraints. Constraints are ordered such that a given # constraint is placed before its dependencies. self._oconstraints = list(cdict.values()) # Create a depth-1 map of the constraint dependencies depmap = {} for con in self._oconstraints: depmap[con] = set() # Now check the constraint's equation for constrained arguments for arg in con.eq.args: if arg in cdict: depmap[con].add(cdict[arg]) # Turn the dependency map into multi-level map. def _extendDeps(con): deps = set(depmap[con]) for dep in depmap[con]: deps.update(_extendDeps(dep)) return deps for con in depmap: depmap[con] = _extendDeps(con) # Now sort the constraints based on the dependency map. def cmp(x, y): # x == y if neither of them have dependencies if not depmap[x] and not depmap[y]: return 0 # x > y if y is a dependency of x # x > y if y has no dependencies if y in depmap[x] or not depmap[y]: return 1 # x < y if x is a dependency of y # x < y if x has no dependencies if x in depmap[y] or not depmap[x]: return -1 # If there are dependencies, but there is no relationship, the # constraints are equivalent return 0 self._oconstraints.sort(key=cmp_to_key(cmp)) return # Variable manipulation def addVar(self, par, value=None, name=None, fixed=False, tag=None, tags=[]): """Add a variable to be refined. par -- A Parameter that will be varied during a fit. value -- An initial value for the variable. If this is None (default), then the current value of par will be used. name -- A name for this variable. If name is None (default), then the name of the parameter will be used. fixed -- Fix the variable so that it does not vary (default False). tag -- A tag for the variable. This can be used to retrieve, fix or free variables by tag (default None). Note that a variable is automatically tagged with its name and "all". tags -- A list of tags (default []). Both tag and tags can be applied. Returns the ParameterProxy (variable) for the passed Parameter. Raises ValueError if the name of the variable is already taken by another managed object. Raises ValueError if par is constant. Raises ValueError if par is constrained. """ name = name or par.name if par.const: raise ValueError("The parameter '%s' is constant" % par) if par.constrained: raise ValueError("The parameter '%s' is constrained" % par) var = ParameterProxy(name, par) if value is not None: var.setValue(value) self._addParameter(var) if fixed: self.fix(var) # Tag with passed tags and by name self._tagmanager.tag(var, var.name) self._tagmanager.tag(var, "all") self._tagmanager.tag(var, *tags) if tag is not None: self._tagmanager.tag(var, tag) return var def delVar(self, var): """Remove a variable. Note that constraints and restraints involving the variable are not modified. var -- A variable of the FitRecipe. Raises ValueError if var is not part of the FitRecipe. """ self._removeParameter(var) self._tagmanager.untag(var) return def __delattr__(self, name): if name in self._parameters: self.delVar(self._parameters[name]) return super(FitRecipe, self).__delattr__(name) return def newVar(self, name, value=None, fixed=False, tag=None, tags=[]): """Create a new variable of the fit. This method lets new variables be created that are not tied to a Parameter. Orphan variables may cause a fit to fail, depending on the optimization routine, and therefore should only be created to be used in contraint or restraint equations. name -- The name of the variable. The variable will be able to be used by this name in restraint and constraint equations. value -- An initial value for the variable. If this is None (default), then the variable will be given the value of the first non-None-valued Parameter constrained to it. If this fails, an error will be thrown when 'residual' is called. fixed -- Fix the variable so that it does not vary (default False). The variable will still be managed by the FitRecipe. tag -- A tag for the variable. This can be used to fix and free variables by tag (default None). Note that a variable is automatically tagged with its name and "all". tags -- A list of tags (default []). Both tag and tags can be applied. Returns the new variable (Parameter instance). """ # This will fix the Parameter var = self._newParameter(name, value) # We may explicitly free it if not fixed: self.free(var) # Tag with passed tags self._tagmanager.tag(var, *tags) if tag is not None: self._tagmanager.tag(var, tag) return var def _newParameter(self, name, value, check=True): """Overloaded to tag variables. See RecipeOrganizer._newParameter """ par = RecipeOrganizer._newParameter(self, name, value, check) # tag this self._tagmanager.tag(par, par.name) self._tagmanager.tag(par, "all") self.fix(par.name) return par def __getVarAndCheck(self, var): """Get the actual variable from var var -- A variable of the FitRecipe, or the name of a variable. Returns the variable or None if the variable cannot be found in the _parameters list. """ if isinstance(var, six.string_types): var = self._parameters.get(var) if var not in self._parameters.values(): raise ValueError("Passed variable is not part of the FitRecipe") return var def __getVarsFromArgs(self, *args, **kw): """Get a list of variables from passed arguments. This method accepts string or variable arguments. An argument of "all" selects all variables. Keyword arguments must be parameter names, followed by a value to assign to the fixed variable. This method is used by the fix and free methods. Raises ValueError if an unknown variable, name or tag is passed, or if a tag is passed in a keyword. """ # Process args. Each variable is tagged with its name, so this is easy. strargs = set( [arg for arg in args if isinstance(arg, six.string_types)]) varargs = set(args) - strargs # Check that the tags are valid alltags = set(self._tagmanager.alltags()) badtags = strargs - alltags if badtags: names = ",".join(badtags) raise ValueError("Variables or tags cannot be found (%s)" % names) # Check that variables are valid allvars = set(self._parameters.values()) badvars = varargs - allvars if badvars: names = ",".join(v.name for v in badvars) raise ValueError("Variables cannot be found (%s)" % names) # Make sure that we only have parameters in kw kwnames = set(kw.keys()) allnames = set(self._parameters.keys()) badkw = kwnames - allnames if badkw: names = ",".join(badkw) raise ValueError("Tags cannot be passed as keywords (%s)" % names) # Now get all the objects referred to in the arguments. varargs |= self._tagmanager.union(*strargs) varargs |= self._tagmanager.union(*kw.keys()) return varargs def fix(self, *args, **kw): """Fix a parameter by reference, name or tag. A fixed variable is not refined. Variables are free by default. This method accepts string or variable arguments. An argument of "all" selects all variables. Keyword arguments must be parameter names, followed by a value to assign to the fixed variable. Raises ValueError if an unknown Parameter, name or tag is passed, or if a tag is passed in a keyword. """ # Check the inputs and get the variables from them varargs = self.__getVarsFromArgs(*args, **kw) # Fix all of these for var in varargs: self._tagmanager.tag(var, self._fixedtag) # Set the kw values for name, val in kw.items(): self.get(name).value = val return def free(self, *args, **kw): """Free a parameter by reference, name or tag. A free variable is refined. Variables are free by default. Constrained variables are not free. This method accepts string or variable arguments. An argument of "all" selects all variables. Keyword arguments must be parameter names, followed by a value to assign to the fixed variable. Raises ValueError if an unknown Parameter, name or tag is passed, or if a tag is passed in a keyword. """ # Check the inputs and get the variables from them varargs = self.__getVarsFromArgs(*args, **kw) # Free all of these for var in varargs: if not var.constrained: self._tagmanager.untag(var, self._fixedtag) # Set the kw values for name, val in kw.items(): self.get(name).value = val return def isFree(self, var): """Check if a variable is fixed.""" return (not self._tagmanager.hasTags(var, self._fixedtag)) def unconstrain(self, *pars): """Unconstrain a Parameter. This removes any constraints on a Parameter. If the Parameter is also a variable of the recipe, it will be freed as well. *pars -- The names of Parameters or Parameters to unconstrain. Raises ValueError if the Parameter is not constrained. """ update = False for par in pars: if isinstance(par, six.string_types): name = par par = self.get(name) if par is None: raise ValueError("The parameter cannot be found") if par in self._constraints: self._constraints[par].unconstrain() del self._constraints[par] update = True if par in self._parameters.values(): self._tagmanager.untag(par, self._fixedtag) if update: # Our configuration changed self._updateConfiguration() return def constrain(self, par, con, ns={}): """Constrain a parameter to an equation. Note that only one constraint can exist on a Parameter at a time. This is overloaded to set the value of con if it represents a variable and its current value is None. A constrained variable will be set as fixed. par -- The Parameter to constrain. con -- A string representation of the constraint equation or a Parameter to constrain to. A constraint equation must consist of numpy operators and "known" Parameters. Parameters are known if they are in the ns argument, or if they are managed by this object. ns -- A dictionary of Parameters, indexed by name, that are used in the eqstr, but not part of this object (default {}). Raises ValueError if ns uses a name that is already used for a variable. Raises ValueError if eqstr depends on a Parameter that is not part of the FitRecipe and that is not defined in ns. Raises ValueError if par is marked as constant. """ if isinstance(par, six.string_types): name = par par = self.get(name) if par is None: par = ns.get(name) if par is None: raise ValueError("The parameter '%s' cannot be found" % name) if con in self._parameters.keys(): con = self._parameters[con] if par.const: raise ValueError("The parameter '%s' is constant" % par) # This will pass the value of a constrained parameter to the initial # value of a parameter constraint. if con in self._parameters.values(): val = con.getValue() if val is None: val = par.getValue() con.setValue(val) if par in self._parameters.values(): self.fix(par) RecipeOrganizer.constrain(self, par, con, ns) return def getValues(self): """Get the current values of the variables in a list.""" return array( [v.value for v in self._parameters.values() if self.isFree(v)]) def getNames(self): """Get the names of the variables in a list.""" return [v.name for v in self._parameters.values() if self.isFree(v)] def getBounds(self): """Get the bounds on variables in a list. Returns a list of (lb, ub) pairs, where lb is the lower bound and ub is the upper bound. """ return [v.bounds for v in self._parameters.values() if self.isFree(v)] def getBounds2(self): """Get the bounds on variables in two lists. Returns lower- and upper-bound lists of variable bounds. """ bounds = self.getBounds() lb = array([b[0] for b in bounds]) ub = array([b[1] for b in bounds]) return lb, ub def boundsToRestraints(self, sig=1, scaled=False): """Turn all bounded parameters into restraints. The bounds become limits on the restraint. sig -- The uncertainty on the bounds (scalar or iterable, default 1). scaled -- Scale the restraints, see restrain. """ pars = self._parameters.values() if not hasattr(sig, "__iter__"): sig = [sig] * len(pars) for par, x in zip(pars, sig): self.restrain(par, par.bounds[0], par.bounds[1], sig=x, scaled=scaled) return def _applyValues(self, p): """Apply variable values to the variables.""" if len(p) == 0: return vargen = (v for v in self._parameters.values() if self.isFree(v)) for var, pval in zip(vargen, p): var.setValue(pval) return def _updateConfiguration(self): """Notify RecipeContainers in hierarchy of configuration change.""" self._ready = False return
class FitRecipe(_fitrecipe_interface, RecipeOrganizer): """FitRecipe class. Attributes name -- A name for this FitRecipe. fithooks -- List of FitHook instances that can pass information out of the system during a refinement. By default, the is populated by a PrintFitHook instance. _constraints -- A dictionary of Constraints, indexed by the constrained Parameter. Constraints can be added using the 'constrain' method. _oconstraints -- An ordered list of the constraints from this and all sub-components. _calculators -- A managed dictionary of Calculators. _contributions -- A managed OrderedDict of FitContributions. _parameters -- A managed OrderedDict of parameters (in this case the parameters are varied). _parsets -- A managed dictionary of ParameterSets. _eqfactory -- A diffpy.srfit.equation.builder.EquationFactory instance that is used to create constraints and restraints from string _restraintlist -- A list of restraints from this and all sub-components. _restraints -- A set of Restraints. Restraints can be added using the 'restrain' or 'confine' methods. _ready -- A flag indicating if all attributes are ready for the calculation. _tagmanager -- A TagManager instance for managing tags on Parameters. _weights -- List of weighing factors for each FitContribution. The weights are multiplied by the residual of the FitContribution when determining the overall residual. _fixedtag -- "__fixed", used for tagging variables as fixed. Don't use this tag unless you want issues. Properties names -- Variable names (read only). See getNames. values -- Variable values (read only). See getValues. fixednames -- Names of the fixed refinable variables (read only). fixedvalues -- Values of the fixed refinable variables (read only). bounds -- Bounds on parameters (read only). See getBounds. bounds2 -- Bounds on parameters (read only). See getBounds2. """ fixednames = property(lambda self: [v.name for v in self._parameters.values() if not (self.isFree(v) or self.isConstrained(v))], doc='names of the fixed refinable variables') fixedvalues = property(lambda self: array([v.value for v in self._parameters.values() if not (self.isFree(v) or self.isConstrained(v))]), doc='values of the fixed refinable variables') bounds = property(lambda self: self.getBounds()) bounds2 = property(lambda self: self.getBounds2()) def __init__(self, name = "fit"): """Initialization.""" RecipeOrganizer.__init__(self, name) self.fithooks = [] self.pushFitHook(PrintFitHook()) self._restraintlist = [] self._oconstraints = [] self._ready = False self._fixedtag = "__fixed" self._weights = [] self._tagmanager = TagManager() self._parsets = {} self._manage(self._parsets) self._contributions = OrderedDict() self._manage(self._contributions) return def pushFitHook(self, fithook, index = None): """Add a FitHook to be called within the residual method. The hook is an object for reporting updates, or more fundamentally, passing information out of the system during a refinement. See the diffpy.srfit.fitbase.fithook.FitHook class for the required interface. Added FitHooks will be called sequentially during refinement. fithook -- FitHook instance to add to the sequence index -- Index for inserting fithook into the list of fit hooks. If this is None (default), the fithook is added to the end. """ if index is None: index = len(self.fithooks) self.fithooks.insert(index, fithook) # Make sure the added FitHook gets its reset method called. self._updateConfiguration() return def popFitHook(self, fithook = None, index = -1): """Remove a FitHook by index or reference. fithook -- FitHook instance to remove from the sequence. If this is None (default), default to index. index -- Index of FitHook instance to remove (default -1). Raises ValueError if fithook is not None, but is not present in the sequence. Raises IndexError if the sequence is empty or index is out of range. """ if fithook is not None: self.fithooks.remove(fithook) return self.fithook.remove(index) return def getFitHooks(self): """Get the sequence of FitHook instances.""" return self.fithooks[:] def clearFitHooks(self): """Clear the FitHook sequence.""" del self.fithooks[:] return def addContribution(self, con, weight = 1.0): """Add a FitContribution to the FitRecipe. con -- The FitContribution to be stored. Raises ValueError if the FitContribution has no name Raises ValueError if the FitContribution has the same name as some other managed object. """ self._addObject(con, self._contributions, True) self._weights.append(weight) return def setWeight(self, con, weight): """Set the weight of a FitContribution.""" idx = self._contributions.values().index(con) self._weights[idx] = weight return def addParameterSet(self, parset): """Add a ParameterSet to the hierarchy. parset -- The ParameterSet to be stored. Raises ValueError if the ParameterSet has no name. Raises ValueError if the ParameterSet has the same name as some other managed object. """ self._addObject(parset, self._parsets, True) return def removeParameterSet(self, parset): """Remove a ParameterSet from the hierarchy. Raises ValueError if parset is not managed by this object. """ self._removeObject(parset, self._parsets) return def residual(self, p = []): """Calculate the vector residual to be optimized. Arguments p -- The list of current variable values, provided in the same order as the '_parameters' list. If p is an empty iterable (default), then it is assumed that the parameters have already been updated in some other way, and the explicit update within this function is skipped. The residual is by default the weighted concatenation of each FitContribution's residual, plus the value of each restraint. The array returned, denoted chiv, is such that dot(chiv, chiv) = chi^2 + restraints. """ # Prepare, if necessary self._prepare() for fithook in self.fithooks: fithook.precall(self) # Update the variable parameters. self._applyValues(p) # Update the constraints. These are ordered such that the list only # needs to be cycled once. for con in self._oconstraints: con.update() # Calculate the bare chiv chiv = concatenate([ wi * ci.residual().flatten() for wi, ci in zip(self._weights, self._contributions.values())]) # Calculate the point-average chi^2 w = dot(chiv, chiv)/len(chiv) # Now we must append the restraints penalties = [ sqrt(res.penalty(w)) for res in self._restraintlist ] chiv = concatenate( [ chiv, penalties ] ) for fithook in self.fithooks: fithook.postcall(self, chiv) return chiv def scalarResidual(self, p = []): """Calculate the scalar residual to be optimized. Arguments p -- The list of current variable values, provided in the same order as the '_parameters' list. If p is an empty iterable (default), then it is assumed that the parameters have already been updated in some other way, and the explicit update within this function is skipped. The residual is by default the weighted concatenation of each FitContribution's residual, plus the value of each restraint. The array returned, denoted chiv, is such that dot(chiv, chiv) = chi^2 + restraints. """ chiv = self.residual(p) return dot(chiv, chiv) def __call__(self, p = []): """Same as scalarResidual method.""" return self.scalarResidual(p) def _prepare(self): """Prepare for the residual calculation, if necessary. This will prepare the data attributes to be used in the residual calculation. This updates the local restraints with those of the contributions. Raises AttributeError if there are variables without a value. """ # Only prepare if the configuration has changed within the recipe # hierarchy. if self._ready: return # Inform the fit hooks that we're updating things for fithook in self.fithooks: fithook.reset(self) # Check Profiles self.__verifyProfiles() # Check parameters self.__verifyParameters() # Update constraints and restraints. self.__collectConstraintsAndRestraints() # We do this here so that the calculations that take place during the # validation use the most current values of the parameters. In most # cases, this will save us from recalculating them later. for con in self._oconstraints: con.update() # Validate! self._validate() self._ready = True return def __verifyProfiles(self): """Verify that each FitContribution has a Profile.""" # Check for profile values for con in self._contributions.values(): if con.profile is None: m = "FitContribution '%s' does not have a Profile"%con.name raise AttributeError(m) if con.profile.x is None or\ con.profile.y is None or\ con.profile.dy is None: m = "Profile for '%s' is missing data"%con.name raise AttributeError(m) return def __verifyParameters(self): """Verify that all Parameters have values.""" # Get all parameters with a value of None badpars = [] for par in self.iterPars(): try: par.getValue() except ValueError: badpars.append(par) # Get the bad names badnames = [] for par in badpars: objlist = self._locateManagedObject(par) names = [obj.name for obj in objlist] badnames.append( ".".join(names) ) # Construct an error message, if necessary m = "" if len(badnames) == 1: m = "%s is not defined or needs an initial value" % badnames[0] elif len(badnames) > 0: s1 = ",".join(badnames[:-1]) s2 = badnames[-1] m = "%s and %s are not defined or need initial values" % (s1, s2) if m: raise AttributeError(m) return def __collectConstraintsAndRestraints(self): """Collect the Constraints and Restraints from subobjects.""" from itertools import chain from functools import cmp_to_key rset = set(self._restraints) cdict = {} for org in chain(self._contributions.values(), self._parsets.values()): rset.update( org._getRestraints() ) cdict.update( org._getConstraints() ) cdict.update(self._constraints) # The order of the restraint list does not matter self._restraintlist = list(rset) # Reorder the constraints. Constraints are ordered such that a given # constraint is placed before its dependencies. self._oconstraints = list(cdict.values()) # Create a depth-1 map of the constraint dependencies depmap = {} for con in self._oconstraints: depmap[con] = set() # Now check the constraint's equation for constrained arguments for arg in con.eq.args: if arg in cdict: depmap[con].add( cdict[arg] ) # Turn the dependency map into multi-level map. def _extendDeps(con): deps = set(depmap[con]) for dep in depmap[con]: deps.update(_extendDeps(dep)) return deps for con in depmap: depmap[con] = _extendDeps(con) # Now sort the constraints based on the dependency map. def cmp(x, y): # x == y if neither of them have dependencies if not depmap[x] and not depmap[y]: return 0 # x > y if y is a dependency of x # x > y if y has no dependencies if y in depmap[x] or not depmap[y]: return 1 # x < y if x is a dependency of y # x < y if x has no dependencies if x in depmap[y] or not depmap[x]: return -1 # If there are dependencies, but there is no relationship, the # constraints are equivalent return 0 self._oconstraints.sort(key=cmp_to_key(cmp)) return # Variable manipulation def addVar(self, par, value = None, name = None, fixed = False, tag = None, tags = []): """Add a variable to be refined. par -- A Parameter that will be varied during a fit. value -- An initial value for the variable. If this is None (default), then the current value of par will be used. name -- A name for this variable. If name is None (default), then the name of the parameter will be used. fixed -- Fix the variable so that it does not vary (default False). tag -- A tag for the variable. This can be used to retrieve, fix or free variables by tag (default None). Note that a variable is automatically tagged with its name and "all". tags -- A list of tags (default []). Both tag and tags can be applied. Returns the ParameterProxy (variable) for the passed Parameter. Raises ValueError if the name of the variable is already taken by another managed object. Raises ValueError if par is constant. Raises ValueError if par is constrained. """ name = name or par.name if par.const: raise ValueError("The parameter '%s' is constant"%par) if par.constrained: raise ValueError("The parameter '%s' is constrained"%par) var = ParameterProxy(name, par) if value is not None: var.setValue(value) self._addParameter(var) if fixed: self.fix(var) # Tag with passed tags and by name self._tagmanager.tag(var, var.name) self._tagmanager.tag(var, "all") self._tagmanager.tag(var, *tags) if tag is not None: self._tagmanager.tag(var, tag) return var def delVar(self, var): """Remove a variable. Note that constraints and restraints involving the variable are not modified. var -- A variable of the FitRecipe. Raises ValueError if var is not part of the FitRecipe. """ self._removeParameter(var) self._tagmanager.untag(var) return def __delattr__(self, name): if name in self._parameters: self.delVar( self._parameters[name] ) return super(FitRecipe, self).__delattr__(name) return def newVar(self, name, value = None, fixed = False, tag = None, tags = []): """Create a new variable of the fit. This method lets new variables be created that are not tied to a Parameter. Orphan variables may cause a fit to fail, depending on the optimization routine, and therefore should only be created to be used in contraint or restraint equations. name -- The name of the variable. The variable will be able to be used by this name in restraint and constraint equations. value -- An initial value for the variable. If this is None (default), then the variable will be given the value of the first non-None-valued Parameter constrained to it. If this fails, an error will be thrown when 'residual' is called. fixed -- Fix the variable so that it does not vary (default False). The variable will still be managed by the FitRecipe. tag -- A tag for the variable. This can be used to fix and free variables by tag (default None). Note that a variable is automatically tagged with its name and "all". tags -- A list of tags (default []). Both tag and tags can be applied. Returns the new variable (Parameter instance). """ # This will fix the Parameter var = self._newParameter(name, value) # We may explicitly free it if not fixed: self.free(var) # Tag with passed tags self._tagmanager.tag(var, *tags) if tag is not None: self._tagmanager.tag(var, tag) return var def _newParameter(self, name, value, check=True): """Overloaded to tag variables. See RecipeOrganizer._newParameter """ par = RecipeOrganizer._newParameter(self, name, value, check) # tag this self._tagmanager.tag(par, par.name) self._tagmanager.tag(par, "all") self.fix(par.name) return par def __getVarAndCheck(self, var): """Get the actual variable from var var -- A variable of the FitRecipe, or the name of a variable. Returns the variable or None if the variable cannot be found in the _parameters list. """ if isinstance(var, six.string_types): var = self._parameters.get(var) if var not in self._parameters.values(): raise ValueError("Passed variable is not part of the FitRecipe") return var def __getVarsFromArgs(self, *args, **kw): """Get a list of variables from passed arguments. This method accepts string or variable arguments. An argument of "all" selects all variables. Keyword arguments must be parameter names, followed by a value to assign to the fixed variable. This method is used by the fix and free methods. Raises ValueError if an unknown variable, name or tag is passed, or if a tag is passed in a keyword. """ # Process args. Each variable is tagged with its name, so this is easy. strargs = set([arg for arg in args if isinstance(arg, six.string_types)]) varargs = set(args) - strargs # Check that the tags are valid alltags = set(self._tagmanager.alltags()) badtags = strargs - alltags if badtags: names = ",".join(badtags) raise ValueError("Variables or tags cannot be found (%s)"% names) # Check that variables are valid allvars = set(self._parameters.values()) badvars = varargs - allvars if badvars: names = ",".join(v.name for v in badvars) raise ValueError("Variables cannot be found (%s)"% names) # Make sure that we only have parameters in kw kwnames = set(kw.keys()) allnames = set(self._parameters.keys()) badkw = kwnames - allnames if badkw: names = ",".join(badkw) raise ValueError("Tags cannot be passed as keywords (%s)"% names) # Now get all the objects referred to in the arguments. varargs |= self._tagmanager.union(*strargs) varargs |= self._tagmanager.union(*kw.keys()) return varargs def fix(self, *args, **kw): """Fix a parameter by reference, name or tag. A fixed variable is not refined. Variables are free by default. This method accepts string or variable arguments. An argument of "all" selects all variables. Keyword arguments must be parameter names, followed by a value to assign to the fixed variable. Raises ValueError if an unknown Parameter, name or tag is passed, or if a tag is passed in a keyword. """ # Check the inputs and get the variables from them varargs = self.__getVarsFromArgs(*args, **kw) # Fix all of these for var in varargs: self._tagmanager.tag(var, self._fixedtag) # Set the kw values for name, val in kw.items(): self.get(name).value = val return def free(self, *args, **kw): """Free a parameter by reference, name or tag. A free variable is refined. Variables are free by default. Constrained variables are not free. This method accepts string or variable arguments. An argument of "all" selects all variables. Keyword arguments must be parameter names, followed by a value to assign to the fixed variable. Raises ValueError if an unknown Parameter, name or tag is passed, or if a tag is passed in a keyword. """ # Check the inputs and get the variables from them varargs = self.__getVarsFromArgs(*args, **kw) # Free all of these for var in varargs: if not var.constrained: self._tagmanager.untag(var, self._fixedtag) # Set the kw values for name, val in kw.items(): self.get(name).value = val return def isFree(self, var): """Check if a variable is fixed.""" return (not self._tagmanager.hasTags(var, self._fixedtag)) def unconstrain(self, *pars): """Unconstrain a Parameter. This removes any constraints on a Parameter. If the Parameter is also a variable of the recipe, it will be freed as well. *pars -- The names of Parameters or Parameters to unconstrain. Raises ValueError if the Parameter is not constrained. """ update = False for par in pars: if isinstance(par, six.string_types): name = par par = self.get(name) if par is None: raise ValueError("The parameter cannot be found") if par in self._constraints: self._constraints[par].unconstrain() del self._constraints[par] update = True if par in self._parameters.values(): self._tagmanager.untag(par, self._fixedtag) if update: # Our configuration changed self._updateConfiguration() return def constrain(self, par, con, ns = {}): """Constrain a parameter to an equation. Note that only one constraint can exist on a Parameter at a time. This is overloaded to set the value of con if it represents a variable and its current value is None. A constrained variable will be set as fixed. par -- The Parameter to constrain. con -- A string representation of the constraint equation or a Parameter to constrain to. A constraint equation must consist of numpy operators and "known" Parameters. Parameters are known if they are in the ns argument, or if they are managed by this object. ns -- A dictionary of Parameters, indexed by name, that are used in the eqstr, but not part of this object (default {}). Raises ValueError if ns uses a name that is already used for a variable. Raises ValueError if eqstr depends on a Parameter that is not part of the FitRecipe and that is not defined in ns. Raises ValueError if par is marked as constant. """ if isinstance(par, six.string_types): name = par par = self.get(name) if par is None: par = ns.get(name) if par is None: raise ValueError("The parameter '%s' cannot be found"%name) if con in self._parameters.keys(): con = self._parameters[con] if par.const: raise ValueError("The parameter '%s' is constant"%par) # This will pass the value of a constrained parameter to the initial # value of a parameter constraint. if con in self._parameters.values(): val = con.getValue() if val is None: val = par.getValue() con.setValue(val) if par in self._parameters.values(): self.fix(par) RecipeOrganizer.constrain(self, par, con, ns) return def getValues(self): """Get the current values of the variables in a list.""" return array([v.value for v in self._parameters.values() if self.isFree(v)]) def getNames(self): """Get the names of the variables in a list.""" return [v.name for v in self._parameters.values() if self.isFree(v)] def getBounds(self): """Get the bounds on variables in a list. Returns a list of (lb, ub) pairs, where lb is the lower bound and ub is the upper bound. """ return [v.bounds for v in self._parameters.values() if self.isFree(v)] def getBounds2(self): """Get the bounds on variables in two lists. Returns lower- and upper-bound lists of variable bounds. """ bounds = self.getBounds() lb = array([b[0] for b in bounds]) ub = array([b[1] for b in bounds]) return lb, ub def boundsToRestraints(self, sig = 1, scaled = False): """Turn all bounded parameters into restraints. The bounds become limits on the restraint. sig -- The uncertainty on the bounds (scalar or iterable, default 1). scaled -- Scale the restraints, see restrain. """ pars = self._parameters.values() if not hasattr(sig, "__iter__"): sig = [sig] * len(pars) for par, x in zip(pars, sig): self.restrain(par, par.bounds[0], par.bounds[1], sig = x, scaled = scaled) return def _applyValues(self, p): """Apply variable values to the variables.""" if len(p) == 0: return vargen = (v for v in self._parameters.values() if self.isFree(v)) for var, pval in zip(vargen, p): var.setValue(pval) return def _updateConfiguration(self): """Notify RecipeContainers in hierarchy of configuration change.""" self._ready = False return