Changeset 1138

Timestamp:

Nov 7, 2013 12:12:55 PM (8 years ago)

Author:

toby

Message:

major constraints revision

Location:

trunk

Files:

• GSASII.py (modified) (9 diffs)
• GSASIIIO.py (modified) (6 diffs)
• GSASIIconstrGUI.py (modified) (17 diffs)
• GSASIIgrid.py (modified) (8 diffs)
• GSASIImapvars.py (modified) (10 diffs)
• GSASIIobj.py (modified) (7 diffs)
• GSASIIstrIO.py (modified) (7 diffs)
• GSASIIstrMain.py (modified) (3 diffs)

trunk/GSASII.py

@@ -556 +556 @@
             Id = self.PatternTree.AppendItem(parent=self.root,
                                              text='HKLF '+HistName)
-            self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0,'Dummy':False},rd.RefDict])
+            valuesdict = {
+                'wtFactor':1.0,
+                'Dummy':False,
+                'ranId':ran.randint(0,sys.maxint),
+                }
+            self.PatternTree.SetItemPyData(Id,[valuesdict,rd.RefDict])
             Sub = self.PatternTree.AppendItem(Id,text='Instrument Parameters')
             self.PatternTree.SetItemPyData(Sub,rd.Parameters)
@@ -980 +985 @@
             Tmin = min(rd.powderdata[0])
             Tmax = max(rd.powderdata[0])
-            self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0,'Dummy':False},rd.powderdata])
+            valuesdict = {
+                'wtFactor':1.0,
+                'Dummy':False,
+                'ranId':ran.randint(0,sys.maxint),
+                }
+            rd.Sample['ranId'] = valuesdict['ranId'] # this should be removed someday
+            self.PatternTree.SetItemPyData(Id,[valuesdict,rd.powderdata])
             self.PatternTree.SetItemPyData(
                 self.PatternTree.AppendItem(Id,text='Comments'),
@@ -1093 +1104 @@
         Id = self.PatternTree.AppendItem(parent=self.root,
                                          text='PWDR '+inp[0])
-        self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0,'Dummy':True},rd.powderdata])
+        valuesdict = {
+            'wtFactor':1.0,
+            'Dummy':True,
+            'ranId':ran.randint(0,sys.maxint),
+            }
+        self.PatternTree.SetItemPyData(Id,[valuesdict,rd.powderdata])
         self.PatternTree.SetItemPyData(
             self.PatternTree.AppendItem(Id,text='Comments'),
@@ -1737 +1753 @@
         def GetData(self):
             return self.data
-            
-    class ConstraintDialog(wx.Dialog):
-        '''Window to edit Constraint values
-        '''
-        def __init__(self,parent,title,text,data,separator='*'):
-            wx.Dialog.__init__(self,parent,-1,title, 
-                pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
-            self.data = data
-            panel = wx.Panel(self)
-            mainSizer = wx.BoxSizer(wx.VERTICAL)
-            topLabl = wx.StaticText(panel,-1,text)
-            mainSizer.Add((10,10),1)
-            mainSizer.Add(topLabl,0,wx.ALIGN_CENTER_VERTICAL|wx.LEFT,10)
-            mainSizer.Add((10,10),1)
-            dataGridSizer = wx.FlexGridSizer(rows=len(data),cols=2,hgap=2,vgap=2)
-            for id,item in enumerate(self.data[:-1]):
-                lbl = item[1]
-                if lbl[-1] != '=': lbl += ' ' + separator + ' '
-                name = wx.StaticText(panel,-1,lbl,size=wx.Size(200,20),
-                                     style=wx.ALIGN_RIGHT)
-                scale = wx.TextCtrl(panel,id,'%.3f'%(item[0]),style=wx.TE_PROCESS_ENTER)
-                scale.Bind(wx.EVT_TEXT_ENTER,self.OnScaleChange)
-                scale.Bind(wx.EVT_KILL_FOCUS,self.OnScaleChange)
-                dataGridSizer.Add(name,0,wx.LEFT,10)
-                dataGridSizer.Add(scale,0,wx.RIGHT,10)
-            mainSizer.Add(dataGridSizer,0,wx.EXPAND)
-            OkBtn = wx.Button(panel,-1,"Ok")
-            OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
-            cancelBtn = wx.Button(panel,-1,"Cancel")
-            cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
-            btnSizer = wx.BoxSizer(wx.HORIZONTAL)
-            btnSizer.Add((20,20),1)
-            btnSizer.Add(OkBtn)
-            btnSizer.Add((20,20),1)
-            btnSizer.Add(cancelBtn)
-            btnSizer.Add((20,20),1)
-            
-            mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
-            panel.SetSizer(mainSizer)
-            panel.Fit()
-            self.Fit()
-            self.CenterOnParent()
-            
-        def OnNameChange(self,event):
-            self.data[-1] = self.name.GetValue() 
-            
-        def OnScaleChange(self,event):
-            id = event.GetId()
-            value = self.FindWindowById(id).GetValue()
-            try:
-                self.data[id][0] = float(value)
-                self.FindWindowById(id).SetValue('%.3f'%(self.data[id][0]))
-            except ValueError:
-                if value and '-' not in value[0]:
-                    print 'bad input - numbers only'
-                    self.FindWindowById(id).SetValue('0.000')
-            
-        def OnOk(self,event):
-            parent = self.GetParent()
-            parent.Raise()
-            self.EndModal(wx.ID_OK)              
-            
-        def OnCancel(self,event):
-            parent = self.GetParent()
-            parent.Raise()
-            self.EndModal(wx.ID_CANCEL)              
-            
-        def GetData(self):
-            return self.data
-            
+                        
     def OnPwdrSum(self,event):
         'Sum together powder data(?)'
@@ -1886 +1833 @@
                     if Id:
                         Sample = G2pdG.SetDefaultSample()
-                        self.PatternTree.SetItemPyData(Id,[{'wtFactor':1.0,'Dummy':False},[np.array(Xsum),np.array(Ysum),np.array(Wsum),
+                        valuesdict = {
+                            'wtFactor':1.0,
+                            'Dummy':False,
+                            'ranId':ran.randint(0,sys.maxint),
+                            }
+                        self.PatternTree.SetItemPyData(Id,[valuesdict,[np.array(Xsum),np.array(Ysum),np.array(Wsum),
                             np.array(YCsum),np.array(YBsum),np.array(YDsum)]])
                         self.PatternTree.SetItemPyData(self.PatternTree.AppendItem(Id,text='Comments'),Comments)                    
@@ -2457 +2409 @@
         PWDRdata['Sample Parameters'] = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PWDRname,'Sample Parameters'))
         PWDRdata['Reflection Lists'] = self.PatternTree.GetItemPyData(G2gd.GetPatternTreeItemId(self,PWDRname,'Reflection Lists'))
-        if 'ranId' not in PWDRdata['Sample Parameters']:
-            PWDRdata['Sample Parameters']['ranId'] = ran.randint(0,sys.maxint)
-        PWDRdata['ranId'] = PWDRdata['Sample Parameters']['ranId']
+        if 'ranId' not in PWDRdata:  # patch, add a random Id
+            PWDRdata['ranId'] = ran.randint(0,sys.maxint)
+        if 'ranId' not in PWDRdata['Sample Parameters']:  # I hope this becomes obsolete at some point
+            PWDRdata['Sample Parameters']['ranId'] = PWDRdata['ranId']
         return PWDRdata
 
@@ -2483 +2436 @@
         
     def GetPhaseData(self):
-        '''Returns a list of defined phases. Used only in GSASIIgrid
-        Note routine :meth:`GSASIIstruct.GetPhaseData` also exists.
+        '''Returns a dict with defined phases. 
+        Note routine :func:`GSASIIstrIO.GetPhaseData` also exists to
+        get same info from GPX file.
         '''
         phaseData = {}
@@ -2490 +2444 @@
             sub = G2gd.GetPatternTreeItemId(self,self.root,'Phases')
         else:
-            print 'no phases to be refined'
-            return
+            print 'no phases found in GetPhaseData'
+            sub = None
         if sub:
             item, cookie = self.PatternTree.GetFirstChild(sub)
@@ -2500 +2454 @@
                     phaseData[phaseName]['ranId'] = ran.randint(0,sys.maxint)          
                 item, cookie = self.PatternTree.GetNextChild(sub, cookie)
-        return phaseData                
+        return phaseData
+
+    def GetPhaseNames(self):
+        '''Returns a list of defined phases. 
+        Note routine :func:`GSASIIstrIO.GetPhaseNames` also exists to
+        get same info from GPX file.
+        '''
+        phaseNames = []
+        if G2gd.GetPatternTreeItemId(self,self.root,'Phases'):
+            sub = G2gd.GetPatternTreeItemId(self,self.root,'Phases')
+        else:
+            print 'no phases found in GetPhaseNames'
+            sub = None
+        if sub:
+            item, cookie = self.PatternTree.GetFirstChild(sub)
+            while item:
+                phase = self.PatternTree.GetItemText(item)
+                phaseNames.append(phase)
+                item, cookie = self.PatternTree.GetNextChild(sub, cookie)
+        return phaseNames
+    
+    def GetHistogramNames(self,hType):
+        """ Returns a list of histogram names found in the GSASII data tree
+        Note routine :func:`GSASIIstrIO.GetHistogramNames` also exists to
+        get same info from GPX file.
+        
+        :param str hType: list of histogram types
+        :return: list of histogram names
+        
+        """
+        HistogramNames = []
+        if self.PatternTree.GetCount():
+            item, cookie = self.PatternTree.GetFirstChild(self.root)
+            while item:
+                name = self.PatternTree.GetItemText(item)
+                if name[:4] in hType:
+                    HistogramNames.append(name)        
+                item, cookie = self.PatternTree.GetNextChild(self.root, cookie)                
+
+        return HistogramNames
+
                     
     def GetUsedHistogramsAndPhasesfromTree(self):
         ''' Returns all histograms that are found in any phase
-        and any phase that uses a histogram
-        :returns: two dicts:
+        and any phase that uses a histogram.
+        This also assigns numbers to used phases and histograms by the
+        order they appear in the file. 
+        Note routine :func:`GSASIIstrIO.GetUsedHistogramsAndPhasesfromTree` also exists to
+        get same info from GPX file.
+
+        :returns: (Histograms,Phases)
 
             * Histograms = dictionary of histograms as {name:data,...}
             * Phases = dictionary of phases that use histograms
         '''
-        phaseData = self.GetPhaseData()
-        if not phaseData:
-            return {},{}
         Histograms = {}
         Phases = {}
+        phaseNames = self.GetPhaseNames()
+        phaseData = self.GetPhaseData()
+        histoList = self.GetHistogramNames(['PWDR','HKLF'])
+
         for phase in phaseData:
             Phase = phaseData[phase]
             if Phase['Histograms']:
                 if phase not in Phases:
+                    pId = phaseNames.index(phase)
+                    Phase['pId'] = pId
                     Phases[phase] = Phase
                 for hist in Phase['Histograms']:
-                    if hist not in Histograms:
+                    if 'Use' not in Phase['Histograms'][hist]:      #patch: add Use flag as True
+                        Phase['Histograms'][hist]['Use'] = True         
+                    if hist not in Histograms and Phase['Histograms'][hist]['Use']:
                         item = G2gd.GetPatternTreeItemId(self,self.root,hist)
-                        if 'PWDR' in hist[:4]: 
-                            Histograms[hist] = self.GetPWDRdatafromTree(item)
-                        elif 'HKLF' in hist[:4]:
-                            Histograms[hist] = self.GetHKLFdatafromTree(item)
-                        #future restraint, etc. histograms here 
+                        if item:
+                            if 'PWDR' in hist[:4]: 
+                                Histograms[hist] = self.GetPWDRdatafromTree(item)
+                            elif 'HKLF' in hist[:4]:
+                                Histograms[hist] = self.GetHKLFdatafromTree(item)
+                            hId = histoList.index(hist)
+                            Histograms[hist]['hId'] = hId
+                        else: # would happen if a referenced histogram were renamed or deleted
+                            print('For phase "'+str(phase)+
+                                  '" unresolved reference to histogram "'+str(hist)+'"')
         return Histograms,Phases
         

trunk/GSASIIIO.py

@@ -715 +715 @@
 #    
 def ProjFileOpen(G2frame):
-    'Read a GSAS-II project file'
+    'Read a GSAS-II project file and load into the G2 data tree'
     file = open(G2frame.GSASprojectfile,'rb')
     print 'load from file: ',G2frame.GSASprojectfile
@@ -731 +731 @@
             Id = G2frame.PatternTree.AppendItem(parent=G2frame.root,text=datum[0])
             if 'PWDR' in datum[0]:                
-                G2frame.PatternTree.SetItemPyData(Id,datum[1][:3])     #temp. trim off junk
+                if 'ranId' not in datum[1][0]: # patch: add random Id if not present
+                    datum[1][0]['ranId'] = ran.randint(0,sys.maxint)
+                G2frame.PatternTree.SetItemPyData(Id,datum[1][:3])  #temp. trim off junk (patch?)
+            elif datum[0].startswith('HKLF'): 
+                if 'ranId' not in datum[1][0]: # patch: add random Id if not present
+                    datum[1][0]['ranId'] = ran.randint(0,sys.maxint)
+                G2frame.PatternTree.SetItemPyData(Id,datum[1])
             else:
                 G2frame.PatternTree.SetItemPyData(Id,datum[1])
@@ -751 +757 @@
                     G2frame.imageDefault = Data                
         file.close()
-        print 'project load successful'
+        print('project load successful')
         G2frame.NewPlot = True
     except:
@@ -783 +789 @@
         finally:
             wx.EndBusyCursor()
-        print 'project save successful'
+        print('project save successful')
 
 def SaveIntegration(G2frame,PickId,data):
@@ -847 +853 @@
             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Index Peak List'),[])
             G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Unit Cells List'),[])
-            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Reflection Lists'),{})             
-        G2frame.PatternTree.SetItemPyData(Id,[[''],[np.array(X),np.array(Y),np.array(W),np.zeros(N),np.zeros(N),np.zeros(N)]])
+            G2frame.PatternTree.SetItemPyData(G2frame.PatternTree.AppendItem(Id,text='Reflection Lists'),{})
+            valuesdict = {
+                'wtFactor':1.0,
+                'Dummy':False,
+                'ranId':ran.randint(0,sys.maxint),
+                }
+        G2frame.PatternTree.SetItemPyData(
+            Id,[valuesdict,
+                [np.array(X),np.array(Y),np.array(W),np.zeros(N),np.zeros(N),np.zeros(N)]])
     G2frame.PatternTree.SelectItem(Id)
     G2frame.PatternTree.Expand(Id)
@@ -1978 +1991 @@
             # old GPX file from before pre-constraint varyList is saved
             print ' *** Old refinement: Please use Calculate/Refine to redo  ***'
-            raise Exception(' *** CIF creation aborted ***')
+            raise Exception(' *** Export aborted ***')
         else:
             varyList = list(varyList)

trunk/GSASIIconstrGUI.py

@@ -18 +18 @@
 import wx
 import wx.grid as wg
+import wx.lib.scrolledpanel as wxscroll
 import time
 import random as ran
@@ -31 +32 @@
 import GSASIIgrid as G2gd
 import GSASIIplot as G2plt
+import GSASIIobj as G2obj
 VERY_LIGHT_GREY = wx.Colour(235,235,235)
 
@@ -95 +97 @@
         parent.Raise()
         self.EndModal(wx.ID_CANCEL)
+
+class ConstraintDialog(wx.Dialog):
+    '''Window to edit Constraint values
+    '''
+    def __init__(self,parent,title,text,data,separator='*',varname="",varyflag=False):
+        wx.Dialog.__init__(self,parent,-1,'Edit '+title, 
+            pos=wx.DefaultPosition,style=wx.DEFAULT_DIALOG_STYLE)
+        self.data = data[:]
+        self.newvar = [varname,varyflag]
+        panel = wx.Panel(self)
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        topLabl = wx.StaticText(panel,-1,text)
+        mainSizer.Add((10,10),1)
+        mainSizer.Add(topLabl,0,wx.ALIGN_CENTER_VERTICAL|wx.LEFT,10)
+        mainSizer.Add((10,10),1)
+        dataGridSizer = wx.FlexGridSizer(rows=len(data),cols=3,hgap=2,vgap=2)
+        self.OkBtn = wx.Button(panel,wx.ID_OK)
+        for id in range(len(self.data)):
+            lbl1 = lbl = str(self.data[id][1])
+            if lbl[-1] != '=': lbl1 = lbl + ' ' + separator + ' '
+            name = wx.StaticText(panel,wx.ID_ANY,lbl1,
+                                 style=wx.ALIGN_RIGHT)
+            scale = G2gd.ValidatedTxtCtrl(panel,self.data[id],0,
+                                          typeHint=float,
+                                          OKcontrol=self.DisableOK)
+            dataGridSizer.Add(name,0,wx.LEFT|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL,5)
+            dataGridSizer.Add(scale,0,wx.RIGHT,3)
+            if ':' in lbl:
+                dataGridSizer.Add(
+                    wx.StaticText(panel,-1,G2obj.fmtVarDescr(lbl)),
+                    0,wx.RIGHT|wx.ALIGN_CENTER_VERTICAL,3)
+            else:
+                dataGridSizer.Add((-1,-1))
+        if title == 'New Variable':
+            name = wx.StaticText(panel,wx.ID_ANY,"New variable's\nname (optional)",
+                                 style=wx.ALIGN_CENTER)
+            scale = G2gd.ValidatedTxtCtrl(panel,self.newvar,0,
+                                          typeHint=str,notBlank=False)
+            dataGridSizer.Add(name,0,wx.LEFT|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL,5)
+            dataGridSizer.Add(scale,0,wx.RIGHT|wx.ALIGN_CENTER_VERTICAL,3)
+            self.refine = wx.CheckBox(panel,label='Refine?')
+            self.refine.SetValue(self.newvar[1]==True)
+            self.refine.Bind(wx.EVT_CHECKBOX, self.OnCheckBox)
+            dataGridSizer.Add(self.refine,0,wx.RIGHT|wx.ALIGN_CENTER_VERTICAL,3)
+            
+        mainSizer.Add(dataGridSizer,0,wx.EXPAND)
+        self.OkBtn.Bind(wx.EVT_BUTTON, self.OnOk)
+        self.OkBtn.SetDefault()
+        cancelBtn = wx.Button(panel,wx.ID_CANCEL)
+        cancelBtn.Bind(wx.EVT_BUTTON, self.OnCancel)
+        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+        btnSizer.Add((20,20),1)
+        btnSizer.Add(self.OkBtn)
+        btnSizer.Add((20,20),1)
+        btnSizer.Add(cancelBtn)
+        btnSizer.Add((20,20),1)
+
+        mainSizer.Add(btnSizer,0,wx.EXPAND|wx.BOTTOM|wx.TOP, 10)
+        panel.SetSizer(mainSizer)
+        panel.Fit()
+        self.Fit()
+        self.CenterOnParent()
+        
+    def DisableOK(self,setting):
+        if setting:
+            self.OkBtn.Enable()
+        else:
+            self.OkBtn.Disable()
+
+    def OnCheckBox(self,event):
+        self.newvar[1] = self.refine.GetValue()
+
+    def OnOk(self,event):
+        parent = self.GetParent()
+        parent.Raise()
+        self.EndModal(wx.ID_OK)              
+
+    def OnCancel(self,event):
+        parent = self.GetParent()
+        parent.Raise()
+        self.EndModal(wx.ID_CANCEL)              
+
+    def GetData(self):
+        return self.data
         
 ################################################################################
@@ -108 +194 @@
     if 'Global' not in data:                                            #patch
         data['Global'] = []
-    Histograms,Phases = G2frame.GetUsedHistogramsAndPhasesfromTree()
-    rigidbodyDict = G2frame.PatternTree.GetItemPyData(   
+    # DEBUG code ########################################
+    #import GSASIIconstrGUI
+    #reload(GSASIIconstrGUI)
+    #reload(G2obj)
+    #reload(G2stIO)
+    #import GSASIIstrMain
+    #reload(GSASIIstrMain)    
+    #reload(G2mv)
+    #reload(G2gd)
+    ###################################################
+    Histograms,Phases = G2obj.IndexAllIds(G2frame)
+    ##################################################################################
+    # patch: convert old-style (str) variables in constraints to G2VarObj objects
+    for key,value in data.items():
+        j = 0
+        for cons in value:
+            #print cons             # DEBUG
+            for i in range(len(cons[:-3])):
+                if type(cons[i][1]) is str:
+                    cons[i][1] = G2obj.G2VarObj(cons[i][1])
+                    j += 1
+        if j:
+            print str(key) + ': '+str(j)+' variable(s) strings converted to objects'
+    ##################################################################################
+    rigidbodyDict = G2frame.PatternTree.GetItemPyData(
         G2gd.GetPatternTreeItemId(G2frame,G2frame.root,'Rigid bodies'))
     rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
@@ -152 +261 @@
     histList.sort()
     Indx = {}
-    scope = {}                          #filled out later
     G2frame.Page = [0,'phs']
-    
-    def GetPHlegends(Phases,Histograms):
-        plegend = '\n In p::name'
-        hlegend = '\n In :h:name'
-        phlegend = '\n In p:h:name'
-        glegend = '\n In ::name'
-        for phase in Phases:
-            plegend += '\n p:: = '+str(Phases[phase]['pId'])+':: for '+phase
-            count = 0
-            for histogram in Phases[phase]['Histograms']:
-                if count < 3:
-                    phlegend += '\n p:h: = '+str(Phases[phase]['pId'])+':'+str(Histograms[histogram]['hId'])+': for '+phase+' in '+histogram
-                else:
-                    phlegend += '\n ... etc.'
-                    break
-                count += 1
-        count = 0
-        for histogram in Histograms:
-            if count < 3:
-                hlegend += '\n :h: = :'+str(Histograms[histogram]['hId'])+': for '+histogram
-            else:
-                hlegend += '\n ... etc.'
-                break
-            count += 1
-        return plegend,hlegend,phlegend,glegend
         
     def FindEquivVarb(name,nameList):
+        'Creates a list of variables appropriate to constrain with name'
         outList = []
         phlist = []
@@ -205 +289 @@
             if keys[2] in namelist and item != name:
                 outList.append(item)
-        if items[1]:
-            for key in phlist:
-                outList.append(key+':all:'+items[2])
         return outList
         
     def SelectVarbs(page,FrstVarb,varList,legend,constType):
-        '''Select variables used in Constraints after one variable has
-        been selected which determines the appropriate variables to be
-        used here. Then creates the constraint and adds it to the
-        constraints list.
-        Called from OnAddEquivalence, OnAddFunction & OnAddConstraint
+        '''Select variables used in constraints after one variable has
+        been selected. This routine determines the appropriate variables to be
+        used based on the one that has been selected and asks for more to be added.
+
+        It then creates the constraint and adds it to the constraints list.
+        
+        Called from OnAddEquivalence, OnAddFunction & OnAddConstraint (all but
+        OnAddHold)
+
+        :param list page: defines calling page -- type of variables to be used
+        :parm GSASIIobj.G2VarObj FrstVarb: reference to first selected variable
+        :param list varList: list of other appropriate variables to select from
+        :param str legend: header for selection dialog
+        :param str constType: type of constraint to be generated
+        :returns: a constraint, as defined in
+          :ref:`GSASIIobj <Constraint_definitions_table>`
         '''
-        #future -  add 'all:all:name', '0:all:name', etc. to the varList
+        atchoice = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
+        meaning = G2obj.getDescr(FrstVarb.name)
+        if not meaning:
+            meaning = "(no definition found!)"
+        l = str(FrstVarb).split(':')
+        # make lists of phases & histograms to iterate over
+        phaselist = [l[0]]
+        if l[0]:
+            phaselbl = ['phase #'+l[0]]
+            if len(Phases) > 1:
+                phaselist += ['all'] 
+                phaselbl += ['all phases']
+        else:
+            phaselbl = ['']
+        histlist = [l[1]]
+        if l[1]:
+            histlbl = ['histogram #'+l[1]]
+            if len(Histograms) > 1:
+                histlist += ['all']
+                histlbl += ['all histograms']
+                typ = Histograms[G2obj.LookupHistName(l[1])[0]]['Instrument Parameters'][0]['Type'][1]
+                i = 0
+                for hist in Histograms:
+                    if Histograms[hist]['Instrument Parameters'][0]['Type'][1] == typ: i += 1
+                if i > 1:
+                    histlist += ['all='+typ]
+                    histlbl += ['all '+typ+' histograms']
+        else:
+            histlbl = ['']
+        # make a list of equivalent parameter names
+        nameList = [FrstVarb.name]
+        for var in varList:
+            nam = var.split(":")[2]
+            if nam not in nameList: nameList += [nam]
+        # add "wild-card" names to the list of variables
         if page[1] == 'phs':
-            atchoice = [item+' for '+phaseAtNames[item] for item in varList]
-            if 'RB' not in FrstVarb:
-                atchoice += [FrstVarb+' for all']
-                atchoice += [FrstVarb+' for all '+atype for atype in TypeList]
-            dlg = wx.MultiChoiceDialog(G2frame,'Select more variables:'+legend,
-                'Constrain '+FrstVarb+' and...',atchoice)
+            if 'RB' in FrstVarb.name:
+                pass
+            elif FrstVarb.atom is None:
+                for nam in nameList:
+                    for ph,plbl in zip(phaselist,phaselbl):
+                        if plbl: plbl = 'For ' + plbl
+                        var = ph+"::"+nam
+                        if var == str(FrstVarb) or var in varList: continue
+                        varList += [var]
+                        atchoice += ['('+var+') '+plbl+": "+meaning]
+            else:
+                for nam in nameList:
+                    for ph,plbl in zip(phaselist,phaselbl):
+                        if plbl: plbl = ' in ' + plbl
+                        for atype in ['']+TypeList:
+                            if atype:
+                                albl = "For "+atype+" atoms"
+                                akey = "all="+atype                        
+                            else:
+                                albl = "For all atoms"
+                                akey = "all"
+                            var = ph+"::"+nam+":"+akey
+                            if var == str(FrstVarb) or var in varList: continue
+                            varList += [var]
+                            atchoice += ['('+var+') '+albl+plbl+": "+meaning]
+        elif page[1] == 'hap':
+            for nam in nameList:
+                for ph,plbl in zip(phaselist,phaselbl):
+                    if plbl: plbl = 'For ' + plbl
+                    for hst,hlbl in zip(histlist,histlbl):
+                        if hlbl:
+                            if plbl:
+                                hlbl = ' in ' + hlbl
+                            else:
+                                hlbl = 'For ' + hlbl                                
+                            var = ph+":"+hst+":"+nam
+                            if var == str(FrstVarb) or var in varList: continue
+                            varList += [var]
+                            atchoice += ['('+var+') '+plbl+hlbl+": "+meaning]
+        elif page[1] == 'hst':
+            for nam in nameList:
+                for hst,hlbl in zip(histlist,histlbl):
+                    if hlbl:
+                        hlbl = 'For ' + hlbl                                
+                        var = ":"+hst+":"+nam
+                        if var == str(FrstVarb) or var in varList: continue
+                        varList += [var]
+                        atchoice += ['('+var+') '+hlbl+": "+meaning]
+        elif page[1] == 'glb':
+            pass
         else:
-            dlg = wx.MultiChoiceDialog(G2frame,'Select more variables:'+legend,
-                'Constrain '+FrstVarb+' and...',varList)
-        varbs = [FrstVarb,]
-        if dlg.ShowModal() == wx.ID_OK:
-            sel = dlg.GetSelections()
-            try:
-                for x in sel:
-                    if ':all:' in varList[x]:       #a histogram 'all' - supercedes any individual selection
-                        varbs = [FrstVarb,]
-                        items = varList[x].split(':')
-                        for item in varList:
-                            if items[0] == item.split(':')[0] and ':all:' not in item:
-                                varbs.append(item)
-                        break
-                    else:
-                        varbs.append(varList[x])
-            except IndexError:      # one of the 'all' chosen - supercedes any individual selection
-                varbs = [FrstVarb,]
-                Atypes = []
-                for x in sel:
-                    item = atchoice[x]
-                    if 'all' in item:
-                        Atypes.append(item.split('all')[1].strip())
-                if '' in Atypes:
-                    varbs += varList
+            raise Exception, 'Unknown constraint page '+ page[1]                    
+        if len(atchoice):
+            dlg = wx.MultiChoiceDialog(
+                G2frame.dataFrame,legend,
+                'Constrain '+str(FrstVarb)+' with...',atchoice)
+            dlg.SetSize((625,250))
+            dlg.CenterOnParent()
+            res = dlg.ShowModal()
+            Selections = dlg.GetSelections()[:]
+            dlg.Destroy()
+            if res != wx.ID_OK: return []
+            if len(Selections) == 0:
+                dlg = wx.MessageDialog(
+                    G2frame.dataFrame,
+                    'No variables were selected to include with '+str(FrstVarb),
+                    'No variables')
+                dlg.CenterOnParent()
+                dlg.ShowModal()
+                dlg.Destroy()
+                return []
+        else:
+            dlg = wx.MessageDialog(
+                G2frame.dataFrame,
+                'There are no appropriate variables to include with '+str(FrstVarb),
+                'No variables')
+            dlg.CenterOnParent()
+            dlg.ShowModal()
+            dlg.Destroy()
+            return []
+        # now process the variables provided by the user
+        varbs = [str(FrstVarb),] # list of selected variables
+        for sel in Selections:
+            var = varList[sel]
+            # phase(s) included
+            l = var.split(':')
+            if l[0] == "all":
+                phlist = [str(Phases[phase]['pId']) for phase in Phases]
+            else:
+                phlist = [l[0]]
+            # histogram(s) included
+            if l[1] == "all":
+                hstlist = [str(Histograms[hist]['hId']) for hist in Histograms]
+            elif '=' in l[1]:
+                htyp = l[1].split('=')[1]
+                hstlist = [str(Histograms[hist]['hId']) for hist in Histograms if 
+                           Histograms[hist]['Instrument Parameters'][0]['Type'][1] == htyp]
+            else:
+                hstlist = [l[1]]
+            if len(l) == 3:
+                for ph in phlist:
+                    for hst in hstlist:
+                        var = ph + ":" + hst + ":" + l[2]
+                        if var in varbs: continue
+                        varbs.append(var)
+            else: # constraints with atoms
+                if l[3] == "all":
+                    for ph in phlist:
+                        key = G2obj.LookupPhaseName(l[0])[0]
+                        for hst in hstlist: # should be blank
+                            for iatm,at in enumerate(Phases[key]['Atoms']):
+                                var = ph + ":" + hst + ":" + l[2] + ":" + str(iatm)
+                                if var in varbs: continue
+                                varbs.append(var)
+                elif '=' in l[3]:
+                    for ph in phlist:
+                        key = G2obj.LookupPhaseName(l[0])[0]
+                        cx,ct,cs,cia = Phases[key]['General']['AtomPtrs']
+                        for hst in hstlist: # should be blank
+                            atyp = l[3].split('=')[1]
+                            for iatm,at in enumerate(Phases[key]['Atoms']):
+                                if at[ct] != atyp: continue
+                                var = ph + ":" + hst + ":" + l[2] + ":" + str(iatm)
+                                if var in varbs: continue
+                                varbs.append(var)
                 else:
-                    for item in varList:
-                        if phaseAtTypes[item] in Atypes:
-                            varbs.append(item)  
-        dlg.Destroy()
-        if len(varbs) > 1:
+                    for ph in phlist:
+                        key = G2obj.LookupPhaseName(l[0])[0]
+                        for hst in hstlist: # should be blank
+                            var = ph + ":" + hst + ":" + l[2] + ":" + l[3]
+                            if var in varbs: continue
+                            varbs.append(var)
+        if len(varbs) >= 1 or 'constraint' in constType:
+            constr = [[1.0,FrstVarb]]
+            for item in varbs[1:]:
+                constr += [[1.0,G2obj.G2VarObj(item)]]
             if 'equivalence' in constType:
-                constr = [[1.0,FrstVarb]]
-                for item in varbs[1:]:
-                    constr += [[1.0,item]]
-                return [constr+[None,None,'e']]      # list of equivalent variables & mults
+                return [constr+[None,None,'e']]
             elif 'function' in constType:
-                constr = map(list,zip([1.0 for i in range(len(varbs))],varbs))
-                return [constr+[None,False,'f']]         #just one constraint
-            else:       #'constraint'
-                constr = map(list,zip([1.0 for i in range(len(varbs))],varbs))
-                return [constr+[1.0,None,'c']]          #just one constraint - default sum to one
+                return [constr+[None,False,'f']]
+            elif 'constraint' in constType:
+                return [constr+[1.0,None,'c']]
+            else:
+                raise Exception,'Unknown constraint type: '+str(constType)
+        else:
+            dlg = wx.MessageDialog(
+                G2frame.dataFrame,
+                'There are no selected variables to include with '+str(FrstVarb),
+                'No variables')
+            dlg.CenterOnParent()
+            dlg.ShowModal()
+            dlg.Destroy()
         return []
 
@@ -277 +506 @@
         Since the varylist is not available, no warning messages
         should be generated.
-        Returns True if constraint should be added
+
+        :returns: True if constraint should be added
         '''
         allcons = []
@@ -303 +533 @@
         Since the varylist is not available, no warning messages
         should be generated.
-        Returns True if the edit should be retained
+        
+        :returns: True if the edit should be retained
         '''
         allcons = []
@@ -322 +553 @@
         return True
              
+    def PageSelection(page):
+        'Decode page reference'
+        if page[1] == "phs":
+            vartype = "phase"
+            varList = phaseList
+            constrDictEnt = 'Phase'
+        elif page[1] == "hap":
+            vartype = "Histogram*Phase"
+            varList = hapList
+            constrDictEnt = 'HAP'
+        elif page[1] == "hst":
+            vartype = "Histogram"
+            varList = histList
+            constrDictEnt = 'Hist'
+        elif page[1] == "glb":
+            vartype = "Global"
+            varList = globalList
+            constrDictEnt = 'Global'
+        else:
+            raise Exception,'Should not happen!'
+        return vartype,varList,constrDictEnt
+
     def OnAddHold(event):
-        '''add a Hold constraint'''
-        for phase in Phases:
-            Phase = Phases[phase]
-            Atoms = Phase['Atoms']
-        constr = []
+        '''Create a new Hold constraint
+
+        Hold constraints allows the user to select one variable (the list of available
+        variables depends on which tab is currently active). 
+        '''
         page = G2frame.Page
-        choice = scope[page[1]]
-        if page[1] == 'phs':
-            atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
-        else:    
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
+        vartype,varList,constrDictEnt = PageSelection(page)
+        title1 = "Hold "+vartype+" variable"
+        if not varList:
+            G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
+                                parent=G2frame.dataFrame)
+            return
+        varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
+        legend = "Select variables to hold (Will not be varied, even if vary flag is set)"
+        dlg = G2gd.G2MultiChoiceDialog(
+            G2frame.dataFrame,
+            legend,title1,varListlbl,toggle=False,size=(625,250))
+        dlg.CenterOnParent()
         if dlg.ShowModal() == wx.ID_OK:
-            sel = dlg.GetSelection()
-            FrstVarb = choice[2][sel]
-            newcons = [[[0.0,FrstVarb],None,None,'h']]
-            if CheckAddedConstraint(newcons):
-                data[choice[3]] += newcons
+            for sel in dlg.GetSelections():
+                Varb = varList[sel]
+                VarObj = G2obj.G2VarObj(Varb)
+                newcons = [[[0.0,VarObj],None,None,'h']]
+                if CheckAddedConstraint(newcons):
+                    data[constrDictEnt] += newcons
         dlg.Destroy()
-        choice[4]()
+        OnPageChanged(None)
         
     def OnAddEquivalence(event):
         '''add an Equivalence constraint'''
-        constr = []
         page = G2frame.Page
-        choice = scope[page[1]]
-        if page[1] == 'phs':
-            atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
-        else:    
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
-        if dlg.ShowModal() == wx.ID_OK:
-            sel = dlg.GetSelection()
-            FrstVarb = choice[2][sel]
-            moreVarb = FindEquivVarb(FrstVarb,choice[2])
-            newcons = SelectVarbs(page,FrstVarb,moreVarb,choice[1],'equivalence')
-            if len(newcons) > 0:
-                if CheckAddedConstraint(newcons):
-                    data[choice[3]] += newcons
-        dlg.Destroy()
-        choice[4]()
+        vartype,varList,constrDictEnt = PageSelection(page)
+        title1 = "Setup equivalent "+vartype+" variables"
+        title2 = "Select additional "+vartype+" variable(s) to be equivalent with "
+        if not varList:
+            G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
+                                parent=G2frame.dataFrame)
+            return
+        varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
+        legend = "Select variables to make equivalent (only one of the variables will be varied when all are set to be varied)"
+        GetAddVars(page,title1,title2,varList,varListlbl,constrDictEnt,'equivalence')
    
     def OnAddFunction(event):
         '''add a Function (new variable) constraint'''
-        constr = []
         page = G2frame.Page
-        choice = scope[page[1]]
-        if page[1] == 'phs':
-            atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
-        else:    
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
-        if dlg.ShowModal() == wx.ID_OK:
-            sel = dlg.GetSelection()
-            FrstVarb = choice[2][sel]
-            moreVarb = FindEquivVarb(FrstVarb,choice[2])
-            newcons = SelectVarbs(page,FrstVarb,moreVarb,choice[1],'function')
-            if len(newcons) > 0:
-                if CheckAddedConstraint(newcons):
-                    data[choice[3]] += newcons
-        dlg.Destroy()
-        choice[4]()
+        vartype,varList,constrDictEnt = PageSelection(page)
+        title1 = "Setup new variable based on "+vartype+" variables"
+        title2 = "Include additional "+vartype+" variable(s) to be included with "
+        if not varList:
+            G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
+                                parent=G2frame.dataFrame)
+            return
+        varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
+        legend = "Select variables to include in a new variable (the new variable will be varied when all included variables are varied)"
+        GetAddVars(page,title1,title2,varList,varListlbl,constrDictEnt,'function')
                         
     def OnAddConstraint(event):
         '''add a constraint equation to the constraints list'''
-        constr = []
         page = G2frame.Page
-        choice = scope[page[1]]
-        if page[1] == 'phs':
-            atchoice = [item+' for '+phaseAtNames[item] for item in choice[2]]
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],atchoice)
-        else:    
-            dlg = wx.SingleChoiceDialog(G2frame,'Select 1st variable:'+choice[1],choice[0],choice[2])
+        vartype,varList,constrDictEnt = PageSelection(page)
+        title1 = "Setup constraint on "+vartype+" variables"
+        title2 = "Select additional "+vartype+" variable(s) to include in constraint with "
+        if not varList:
+            G2frame.ErrorDialog('No variables','There are no variables of type '+vartype,
+                                parent=G2frame.dataFrame)
+            return
+        varListlbl = ["("+i+") "+G2obj.fmtVarDescr(i) for i in varList]
+        legend = "Select variables to include in a constraint equation (the values will be constrainted to equal a specified constant)"
+        GetAddVars(page,title1,title2,varList,varListlbl,constrDictEnt,'constraint')
+
+    def GetAddVars(page,title1,title2,varList,varListlbl,constrDictEnt,constType):
+        '''Get the variables to be added for OnAddEquivalence, OnAddFunction,
+        and OnAddConstraint. Then create and check the constraint.
+        '''
+        dlg = wx.SingleChoiceDialog(G2frame.dataFrame,'Select 1st variable:',title1,varListlbl)
+        dlg.SetSize((625,250))
+        dlg.CenterOnParent()
         if dlg.ShowModal() == wx.ID_OK:
             sel = dlg.GetSelection()
-            FrstVarb = choice[2][sel]
-            moreVarb = FindEquivVarb(FrstVarb,choice[2])
-            newcons = SelectVarbs(page,FrstVarb,moreVarb,choice[1],'constraint')
+            FrstVarb = varList[sel]
+            VarObj = G2obj.G2VarObj(FrstVarb)
+            moreVarb = FindEquivVarb(FrstVarb,varList)
+            newcons = SelectVarbs(page,VarObj,moreVarb,title2+FrstVarb,constType)
             if len(newcons) > 0:
                 if CheckAddedConstraint(newcons):
-                    data[choice[3]] += newcons
+                    data[constrDictEnt] += newcons
         dlg.Destroy()
-        choice[4]()
+        OnPageChanged(None)
                         
-    def ConstSizer(name,pageDisplay):
-        '''This creates a sizer displaying all of the constraints entered
+    def MakeConstraintsSizer(name,pageDisplay):
+        '''Creates a sizer displaying all of the constraints entered of
+        the specified type.
+
+        :param str name: the type of constraints to be displayed ('HAP',
+          'Hist', 'Phase', or 'Global')
+        :param wx.Panel pageDisplay: parent panel for sizer
+        :returns: wx.Sizer created by method
         '''
-        constSizer = wx.FlexGridSizer(1,4,0,0)
+        constSizer = wx.FlexGridSizer(1,5,0,0)
         maxlen = 70 # characters before wrapping a constraint
         for Id,item in enumerate(data[name]):
+            helptext = ""
             eqString = ['',]
-            if item[-1] == 'h':
-                constSizer.Add((5,5),0)              # blank space for edit button
-                typeString = ' FIXED   '
-                eqString[-1] = item[0][1]+'   '
-            elif isinstance(item[-1],str):
+            if item[-1] == 'h': # Hold on variable
+                constSizer.Add((-1,-1),0)              # blank space for edit button
+                typeString = 'FIXED'
+                var = str(item[0][1])
+                varMean = G2obj.fmtVarDescr(var)
+                eqString[-1] =  var +'   '
+                helptext = "Prevents variable:\n"+ var + " ("+ varMean + ")\nfrom being changed"
+            elif isinstance(item[-1],str): # not true on original-style (2011?) constraints
                 constEdit = wx.Button(pageDisplay,-1,'Edit',style=wx.BU_EXACTFIT)
                 constEdit.Bind(wx.EVT_BUTTON,OnConstEdit)
-                constSizer.Add(constEdit)            # edit button
+                constSizer.Add(constEdit,0,wx.LEFT|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_CENTER,1)            # edit button
                 Indx[constEdit.GetId()] = [Id,name]
                 if item[-1] == 'f':
+                    helptext = "A new variable is created from a linear combination of the following variables:"
                     for term in item[:-3]:
+                        var = str(term[1])
                         if len(eqString[-1]) > maxlen:
                             eqString.append(' ')
@@ -434 +704 @@
                                 eqString[-1] += ' - '
                                 m = abs(m)
-                        eqString[-1] += '%.3f*%s '%(m,term[1])
-                    typeString = ' NEWVAR  '
+                        eqString[-1] += '%.3f*%s '%(m,var)
+                        varMean = G2obj.fmtVarDescr(var)
+                        helptext += "\n" + var + " ("+ varMean + ")"
+                    typeString = 'NEWVAR'
                     eqString[-1] += ' = New Variable   '
                 elif item[-1] == 'c':
+                    helptext = "The following variables constrained to equal a constant:"
                     for term in item[:-3]:
+                        var = str(term[1])
                         if len(eqString[-1]) > maxlen:
                             eqString.append(' ')
@@ -446 +720 @@
                             else:
                                 eqString[-1] += ' - '
-                        eqString[-1] += '%.3f*%s '%(abs(term[0]),term[1])
-                    typeString = ' CONSTR  '
+                        eqString[-1] += '%.3f*%s '%(abs(term[0]),var)
+                        varMean = G2obj.fmtVarDescr(var)
+                        helptext += "\n" + var + " ("+ varMean + ")"
+                    typeString = 'CONST'
                     eqString[-1] += ' = %.3f'%(item[-3])+'  '
                 elif item[-1] == 'e':
+                    helptext = "The following variables are set to be equivalent, noting multipliers:"
                     for term in item[:-3]:
+                        var = str(term[1])
                         if term[0] == 0: term[0] = 1.0
                         if len(eqString[-1]) > maxlen:
                             eqString.append(' ')
                         if eqString[-1] == '':
-                            eqString[-1] += '%s '%(term[1])
+                            eqString[-1] += var+' '
                             first = term[0]
                         else:
-                            eqString[-1] += ' = %.3f*%s '%(first/term[0],term[1])
-                    typeString = ' EQUIV   '
+                            eqString[-1] += ' = %.3f*%s '%(first/term[0],var)
+                        varMean = G2obj.fmtVarDescr(var)
+                        helptext += "\n" + var + " ("+ varMean + ")"
+                    typeString = 'EQUIV'
                 else:
                     print 'Unexpected constraint',item
+                
             else:
                 print 'Removing old-style constraints'
@@ -469 +750 @@
             constDel.Bind(wx.EVT_BUTTON,OnConstDel)
             Indx[constDel.GetId()] = [Id,name]
-            constSizer.Add(constDel)             # delete button
-            constSizer.Add(wx.StaticText(pageDisplay,-1,typeString),0,wx.ALIGN_CENTER_VERTICAL)
-            EqSizer = wx.BoxSizer(wx.VERTICAL)
-            for s in eqString:
-                EqSizer.Add(wx.StaticText(pageDisplay,-1,s),0,wx.ALIGN_CENTER_VERTICAL)
-            constSizer.Add(EqSizer,0,wx.ALIGN_CENTER_VERTICAL)
-            # if item[-1] == 'f':
-            #     constRef = wx.CheckBox(pageDisplay,-1,label=' Refine?') 
-            #     constRef.SetValue(item[-2])
-            #     constRef.Bind(wx.EVT_CHECKBOX,OnConstRef)
-            #     Indx[constRef.GetId()] = item
-            #     constSizer.Add(constRef)
-            # else:
-            #     constSizer.Add((5,5),0)
+            constSizer.Add(constDel,0,wx.LEFT|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_CENTER,1)             # delete button
+            if helptext:
+                ch = G2gd.HelpButton(pageDisplay,helptext)
+                constSizer.Add(ch,0,wx.LEFT|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_CENTER,1)
+            else:
+                constSizer.Add((-1,-1))                
+            constSizer.Add(wx.StaticText(pageDisplay,-1,typeString),0,wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_CENTER|wx.RIGHT|wx.LEFT,3)
+            if len(eqString) > 1:
+                Eq = wx.BoxSizer(wx.VERTICAL)
+                for s in eqString:
+                    Eq.Add(wx.StaticText(pageDisplay,-1,s),0,wx.ALIGN_CENTER_VERTICAL)
+            else:
+                Eq = wx.StaticText(pageDisplay,-1,eqString[0])
+            constSizer.Add(Eq,1,wx.ALIGN_CENTER_VERTICAL)
         return constSizer
                 
-    # def OnConstRef(event):
-    #     Obj = event.GetEventObject()
-    #     Indx[Obj.GetId()][-2] = Obj.GetValue()
-        
     def OnConstDel(event):
+        'Delete a constraint'
         Obj = event.GetEventObject()
         Id,name = Indx[Obj.GetId()]
@@ -496 +774 @@
         
     def OnConstEdit(event):
-        '''Called to edit an individual contraint by the Edit button'''
+        '''Called to edit an individual contraint in response to a
+        click on its Edit button
+        '''
         Obj = event.GetEventObject()
         Id,name = Indx[Obj.GetId()]
-        sep = '*'
         if data[name][Id][-1] == 'f':
-            items = data[name][Id][:-3]+[[],]
+            items = data[name][Id][:-3]
             constType = 'New Variable'
+            if data[name][Id][-3]:
+                varname = data[name][Id][-3]
+            else:
+                varname = ""
             lbl = 'Enter value for each term in constraint; sum = new variable'
+            dlg = ConstraintDialog(G2frame.dataFrame,constType,lbl,items,
+                                   varname=varname,varyflag=data[name][Id][-2])
         elif data[name][Id][-1] == 'c':
             items = data[name][Id][:-3]+[
-                [data[name][Id][-3],'fixed value ='],[]]
+                [data[name][Id][-3],'fixed value =']]
             constType = 'Constraint'
             lbl = 'Edit value for each term in constant constraint sum'
+            dlg = ConstraintDialog(G2frame.dataFrame,constType,lbl,items)
         elif data[name][Id][-1] == 'e':
-            items = data[name][Id][:-3]+[[],]
+            items = data[name][Id][:-3]
             constType = 'Equivalence'
             lbl = 'The following terms are set to be equal:'
-            sep = '/'
+            dlg = ConstraintDialog(G2frame.dataFrame,constType,lbl,items,'/')
         else:
             return
-        dlg = G2frame.ConstraintDialog(G2frame.dataFrame,constType,lbl,items,sep)
         try:
+            prev = data[name][Id][:]
             if dlg.ShowModal() == wx.ID_OK:
-                prev = data[name][Id]
                 result = dlg.GetData()
+                for i in range(len(data[name][Id][:-3])):
+                    data[name][Id][i][0] = result[i][0]
                 if data[name][Id][-1] == 'c':
-                    data[name][Id][:-3] = result[:-2]
-                    data[name][Id][-3] = result[-2][0]
-                else:
-                    data[name][Id][:-3] = result[:-1]
+                    data[name][Id][-3] = str(result[-1][0])
+                elif data[name][Id][-1] == 'f':
+                    # process the variable name to put in global form (::var)
+                    varname = str(dlg.newvar[0]).strip().replace(' ','_')
+                    if varname.startswith('::'):
+                        varname = varname[2:]
+                    varname = varname.replace(':',';')
+                    if varname:
+                        data[name][Id][-3] = '::' + varname
+                    else:
+                        data[name][Id][-3] = ''
+                    data[name][Id][-2] = dlg.newvar[1]
                 if not CheckChangedConstraint():
                     data[name][Id] = prev
@@ -534 +829 @@
             dlg.Destroy()            
         OnPageChanged(None)                     
-    
-    def UpdateHAPConstr():
-        '''Responds to press on Histogram/Phase Constraints tab,
-        shows constraints in data window'''
-        HAPConstr.DestroyChildren()
-        HAPDisplay = wx.Panel(HAPConstr)
-        HAPSizer = wx.BoxSizer(wx.VERTICAL)
-        HAPSizer.Add((5,5),0)
-        HAPSizer.Add(ConstSizer('HAP',HAPDisplay))
-        HAPDisplay.SetSizer(HAPSizer,True)
-        Size = HAPSizer.GetMinSize()
-        Size[0] += 40
-        Size[1] = max(Size[1],250) + 20
-        HAPDisplay.SetSize(Size)
-        # scroll bar not working, at least not on Mac
-        HAPConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
-        Size[1] = min(Size[1],250)
-        G2frame.dataFrame.setSizePosLeft(Size)
-        
-    def UpdateHistConstr():
-        '''Responds to press on Histogram Constraints tab,
-        shows constraints in data window'''
-        HistConstr.DestroyChildren()
-        HistDisplay = wx.Panel(HistConstr)
-        HistSizer = wx.BoxSizer(wx.VERTICAL)
-        HistSizer.Add((5,5),0)        
-        HistSizer.Add(ConstSizer('Hist',HistDisplay))
-        HistDisplay.SetSizer(HistSizer,True)
-        Size = HistSizer.GetMinSize()
-        Size[0] += 40
-        Size[1] = max(Size[1],250) + 20
-        HistDisplay.SetSize(Size)
-        HistConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
-        Size[1] = min(Size[1],250)
-        G2frame.dataFrame.setSizePosLeft(Size)
-        
-    def UpdatePhaseConstr():
-        '''Responds to press on Phase Constraint tab,
-        shows constraints in data window'''
-        PhaseConstr.DestroyChildren()
-        PhaseDisplay = wx.Panel(PhaseConstr)
-        PhaseSizer = wx.BoxSizer(wx.VERTICAL)
-        PhaseSizer.Add((5,5),0)        
-        PhaseSizer.Add(ConstSizer('Phase',PhaseDisplay))
-        PhaseDisplay.SetSizer(PhaseSizer,True)
-        Size = PhaseSizer.GetMinSize()
-        Size[0] += 40
-        Size[1] = max(Size[1],250) + 20
-        PhaseDisplay.SetSize(Size)
-        PhaseConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
-        Size[1] = min(Size[1],250)
-        G2frame.dataFrame.setSizePosLeft(Size)
-
-    def UpdateGlobalConstr():
-        '''Responds to press on Global Constraint tab,
-        shows constraints in data window'''
-        GlobalConstr.DestroyChildren()
-        GlobalDisplay = wx.Panel(GlobalConstr)
-        GlobalSizer = wx.BoxSizer(wx.VERTICAL)
-        GlobalSizer.Add((5,5),0)        
-        GlobalSizer.Add(ConstSizer('Global',GlobalDisplay))
-        GlobalDisplay.SetSizer(GlobalSizer,True)
-        Size = GlobalSizer.GetMinSize()
-        Size[0] += 40
-        Size[1] = max(Size[1],250) + 20
-        GlobalDisplay.SetSize(Size)
-        GlobalConstr.SetScrollbars(10,10,Size[0]/10-4,Size[1]/10-1)
-        Size[1] = min(Size[1],250)
-        G2frame.dataFrame.setSizePosLeft(Size)
-    
+   
+    def UpdateConstraintPanel(panel,typ):
+        '''Update the contents of the selected Constraint
+        notebook tab. Called in :func:`OnPageChanged`
+        '''
+        if panel.GetSizer(): panel.GetSizer().Clear(True) # N.B. don't use panel.DestroyChildren()
+        # because it deletes scrollbars on Mac
+        Siz = wx.BoxSizer(wx.VERTICAL)
+        Siz.Add((5,5),0)
+        Siz.Add(MakeConstraintsSizer(typ,panel))
+        panel.SetSizer(Siz,True)
+        G2frame.dataFrame.SetSize((500,250)) # set frame size here
+        panel.SetAutoLayout(1)
+        panel.SetupScrolling()
+
     def OnPageChanged(event):
+        '''Called when a tab is pressed or when a "select tab" menu button is
+        used (see RaisePage), or to refresh the current tab contents (event=None)
+        '''
         if event:       #page change event!
             page = event.GetSelection()
-        else:
+        else: # called directly, get current page
             page = G2frame.dataDisplay.GetSelection()
         oldPage = G2frame.dataDisplay.ChangeSelection(page)
@@ -613 +856 @@
         if text == 'Histogram/Phase constraints':
             G2frame.Page = [page,'hap']
-            UpdateHAPConstr()
+            UpdateConstraintPanel(HAPConstr,'HAP')
         elif text == 'Histogram constraints':
             G2frame.Page = [page,'hst']
-            UpdateHistConstr()
+            UpdateConstraintPanel(HistConstr,'Hist')
         elif text == 'Phase constraints':
             G2frame.Page = [page,'phs']
-            UpdatePhaseConstr()
+            UpdateConstraintPanel(PhaseConstr,'Phase')
         elif text == 'Global constraints':
             G2frame.Page = [page,'glb']
-            UpdateGlobalConstr()
-            
+            UpdateConstraintPanel(GlobalConstr,'Global')
+
+    def RaisePage(event):
+        'Respond to a "select tab" menu button'
+        try:
+            i = (G2gd.wxID_CONSPHASE,
+                 G2gd.wxID_CONSHAP,
+                 G2gd.wxID_CONSHIST,
+                 G2gd.wxID_CONSGLOBAL).index(event.GetId())
+            G2frame.dataDisplay.SetSelection(i)
+            OnPageChanged(None)
+        except ValueError:
+            print('Unexpected event in RaisePage')
 
     def SetStatusLine(text):
         Status.SetStatusText(text)                                      
         
-    plegend,hlegend,phlegend,glegend = GetPHlegends(Phases,Histograms)
-    scope = {'hst':['Histogram contraints:',hlegend,histList,'Hist',UpdateHistConstr],
-        'hap':['Histogram * Phase contraints:',phlegend,hapList,'HAP',UpdateHAPConstr],
-        'phs':['Phase contraints:',plegend,phaseList,'Phase',UpdatePhaseConstr],
-        'glb':['Global constraints:',glegend,globalList,'Global',UpdateGlobalConstr]}
     if G2frame.dataDisplay:
         G2frame.dataDisplay.Destroy()
@@ -646 +895 @@
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddEquivalence, id=G2gd.wxID_EQUIVADD)
     G2frame.dataFrame.Bind(wx.EVT_MENU, OnAddHold, id=G2gd.wxID_HOLDADD)
-    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame,size=G2frame.dataFrame.GetClientSize())
-    
-    PhaseConstr = wx.ScrolledWindow(G2frame.dataDisplay)
+    # tab commands
+    for id in (G2gd.wxID_CONSPHASE,
+               G2gd.wxID_CONSHAP,
+               G2gd.wxID_CONSHIST,
+               G2gd.wxID_CONSGLOBAL):
+        G2frame.dataFrame.Bind(wx.EVT_MENU, RaisePage,id=id)
+
+    G2frame.dataDisplay = G2gd.GSNoteBook(parent=G2frame.dataFrame)
+    # note that order of pages is hard-coded in RaisePage
+    wxstyle = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER
+    PhaseConstr = wxscroll.ScrolledPanel(G2frame.dataDisplay, wx.ID_ANY,style=wxstyle)
     G2frame.dataDisplay.AddPage(PhaseConstr,'Phase constraints')
-    HAPConstr = wx.ScrolledWindow(G2frame.dataDisplay)
+    HAPConstr = wxscroll.ScrolledPanel(G2frame.dataDisplay, wx.ID_ANY,style=wxstyle)
     G2frame.dataDisplay.AddPage(HAPConstr,'Histogram/Phase constraints')
-    HistConstr = wx.ScrolledWindow(G2frame.dataDisplay)
+    HistConstr = wxscroll.ScrolledPanel(G2frame.dataDisplay, wx.ID_ANY,style=wxstyle)
     G2frame.dataDisplay.AddPage(HistConstr,'Histogram constraints')
-    GlobalConstr = wx.ScrolledWindow(G2frame.dataDisplay)
-    G2frame.dataDisplay.AddPage(GlobalConstr,'Global constraints')    
-    UpdatePhaseConstr()
-
+    GlobalConstr = wxscroll.ScrolledPanel(G2frame.dataDisplay, wx.ID_ANY,style=wxstyle)
+    G2frame.dataDisplay.AddPage(GlobalConstr,'Global constraints')
+    OnPageChanged(None) # show initial page
     G2frame.dataDisplay.Bind(wx.aui.EVT_AUINOTEBOOK_PAGE_CHANGED, OnPageChanged)
     # validate all the constrants -- should not see any errors here normally
@@ -856 +1112 @@
             while 'ATOM' not in txtStr[:6] and 'HETATM' not in txtStr[:6]:
                 txtStr = text.readline()
-                print txtStr
+                #print txtStr
         items = txtStr.split()
         while len(items):

trunk/GSASIIgrid.py

@@ -118 +118 @@
 
 [ wxID_CONSTRAINTADD,wxID_EQUIVADD,wxID_HOLDADD,wxID_FUNCTADD,
-] = [wx.NewId() for item in range(4)]
+  wxID_CONSPHASE, wxID_CONSHIST, wxID_CONSHAP, wxID_CONSGLOBAL,
+] = [wx.NewId() for item in range(8)]
 
 [ wxID_RESTRAINTADD, wxID_RESTSELPHASE,wxID_RESTDELETE, wxID_RESRCHANGEVAL, 
@@ -279 +280 @@
             else:
                 self.invalid = False
+                self.Bind(wx.EVT_CHAR,self._GetStringValue)
         elif val is None:
             raise Exception,("ValidatedTxtCtrl error: value of "+str(key)+
@@ -360 +362 @@
         elif self.OKcontrol and previousInvalid:
             self.OKcontrol(True)
+        # always store the result
+        if self.CIFinput: # for CIF make results ASCII
+            self.result[self.key] = val.encode('ascii','replace') 
+        else:
+            self.result[self.key] = val
+
+    def _GetStringValue(self,event):
+        '''Get string input and store.
+        '''
+        event.Skip() # process keystroke
+        wx.CallAfter(self._SaveStringValue)
+        
+    def _SaveStringValue(self):
+        val = self.GetValue().strip()
         # always store the result
         if self.CIFinput: # for CIF make results ASCII
@@ -1321 +1337 @@
     :param str header: Title to place on window frame 
     :param list ChoiceList: a list of choices where one will be selected
+    :param bool toggle: If True (default) the toggle and select all buttons
+      are displayed
 
     :param kw: optional keyword parameters for the wx.Dialog may
-      be included such as Size [which defaults to `(320,310)`] and
-      Style (which defaults to `wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.CENTRE| wx.OK | wx.CANCEL`);
+      be included such as size [which defaults to `(320,310)`] and
+      style (which defaults to `wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.CENTRE| wx.OK | wx.CANCEL`);
       note that `wx.OK` and `wx.CANCEL` controls
       the presence of the eponymous buttons in the dialog.
     :returns: the name of the created dialog  
     '''
-    def __init__(self,parent, title, header, ChoiceList, **kw):
+    def __init__(self,parent, title, header, ChoiceList, toggle=True, **kw):
         # process keyword parameters, notably Style
         options = {'size':(320,310), # default Frame keywords
@@ -1355 +1373 @@
         Sizer.Add((-1,10))
         # set/toggle buttons
-        bSizer = wx.BoxSizer(wx.VERTICAL)
-        setBut = wx.Button(self,wx.ID_ANY,'Set All')
-        setBut.Bind(wx.EVT_BUTTON,self._SetAll)
-        bSizer.Add(setBut,0,wx.ALIGN_CENTER)
-        bSizer.Add((-1,5))
-        togBut = wx.Button(self,wx.ID_ANY,'Toggle All')
-        togBut.Bind(wx.EVT_BUTTON,self._ToggleAll)
-        bSizer.Add(togBut,0,wx.ALIGN_CENTER)
-        Sizer.Add(bSizer,0,wx.LEFT,12)
+        if toggle:
+            bSizer = wx.BoxSizer(wx.VERTICAL)
+            setBut = wx.Button(self,wx.ID_ANY,'Set All')
+            setBut.Bind(wx.EVT_BUTTON,self._SetAll)
+            bSizer.Add(setBut,0,wx.ALIGN_CENTER)
+            bSizer.Add((-1,5))
+            togBut = wx.Button(self,wx.ID_ANY,'Toggle All')
+            togBut.Bind(wx.EVT_BUTTON,self._ToggleAll)
+            bSizer.Add(togBut,0,wx.ALIGN_CENTER)
+            Sizer.Add(bSizer,0,wx.LEFT,12)
         # OK/Cancel buttons
         btnsizer = wx.StdDialogButtonSizer()
@@ -1852 +1871 @@
 
 ################################################################################
+class HelpButton(wx.Button):
+    '''Create a help button that displays help information.
+    The text is displayed in a modal message window.
+
+    TODO: it might be nice if it were non-modal: e.g. it stays around until
+    the parent is deleted or the user closes it, but this did not work for
+    me. 
+
+    :param parent: the panel which will be the parent of the button
+    :param str msg: the help text to be displayed
+    '''
+    def __init__(self,parent,msg):
+        if sys.platform == "darwin": 
+            wx.Button.__init__(self,parent,wx.ID_HELP)
+        else:
+            wx.Button.__init__(self,parent,wx.ID_ANY,'?',style=wx.BU_EXACTFIT)
+        self.Bind(wx.EVT_BUTTON,self._onPress)
+        self.msg=msg
+        self.parent = parent
+    def _onPress(self,event):
+        'Respond to a button press by displaying the requested text'
+        dlg = wx.MessageDialog(self.parent,self.msg,'Help info',wx.OK)
+        dlg.ShowModal()
+        dlg.Destroy()
+################################################################################
 class MyHtmlPanel(wx.Panel):
     '''Defines a panel to display HTML help information, as an alternative to
@@ -1988 +2032 @@
         self.ConstraintMenu = wx.MenuBar()
         self.PrefillDataMenu(self.ConstraintMenu,helpType='Constraints')
+        self.ConstraintTab = wx.Menu(title='')
+        self.ConstraintMenu.Append(menu=self.ConstraintTab, title='Select tab')
+        for id,txt in (
+            (wxID_CONSPHASE,'Phase'),
+            (wxID_CONSHAP,'Histogram/Phase'),
+            (wxID_CONSHIST,'Histogram'),
+            (wxID_CONSGLOBAL,'Global')):
+            self.ConstraintTab.Append(
+                id=id, kind=wx.ITEM_NORMAL,text=txt,
+                help='Select '+txt+' constraint editing tab')
         self.ConstraintEdit = wx.Menu(title='')
         self.ConstraintMenu.Append(menu=self.ConstraintEdit, title='Edit')
@@ -1998 +2052 @@
         self.ConstraintEdit.Append(id=wxID_FUNCTADD, kind=wx.ITEM_NORMAL,text='Add New Var',
             help='Add variable composed of existing parameter')
+
+        # item = self.ConstraintEdit.Append(id=wx.ID_ANY,kind=wx.ITEM_NORMAL,text='Update GUI')
+        # def UpdateGSASIIconstrGUI(event):
+        #     import GSASIIconstrGUI
+        #     reload(GSASIIconstrGUI)
+        #     import GSASIIobj
+        #     reload(GSASIIobj)
+        # self.Bind(wx.EVT_MENU,UpdateGSASIIconstrGUI,id=item.GetId())
+
         self.PostfillDataMenu()
         

trunk/GSASIImapvars.py

@@ -221 +221 @@
 
 # prefix for parameter names
-paramPrefix = "::constr:"
+paramPrefix = "::constr;"
 consNum = 0 # number of the next constraint to be created
 
@@ -248 +248 @@
     :returns: two lists of lists:
     
-      * a list of grouped contraints where each constraint grouped containts a list of indices for constraint constrDict entries
+      * a list of grouped contraints where each constraint grouped containts a list
+        of indices for constraint constrDict entries
       * a list containing lists of parameter names contained in each group
       
@@ -284 +285 @@
     :param list varyList: a list of parameters names that will be varied
 
-    :param dict constrDict: a list of dicts defining relationships/constraints (as defined in :func:`GroupConstraints`)
-
-    :param list fixedList: a list of values specifying a fixed value for each dict in constrDict. Values are
-      either strings that can be converted to floats or None if the constraint defines a new parameter rather
+    :param dict constrDict: a list of dicts defining relationships/constraints
+      (as created in :func:`GSASIIstrIO.ProcessConstraints` and
+      documented in :func:`GroupConstraints`)
+
+    :param list fixedList: a list of values specifying a fixed value for each
+      dict in constrDict. Values are either strings that can be converted to
+      floats or ``None`` if the constraint defines a new parameter rather
       than a constant.
 
@@ -491 +495 @@
     conflicts or inconsistencies in parameter/variable definitions.
 
-    :param list groups: a list of grouped contraints where each constraint grouped containts a list of
-      indices for constraint constrDict entries, created in :func:`GroupConstraints` (returned as 1st value)
-
-    :param list parmlist: a list containing lists of parameter names contained in each group,
+    :param list groups: a list of grouped contraints where each constraint
+      grouped containts a list of indices for constraint constrDict entries,
       created in :func:`GroupConstraints` (returned as 1st value)
 
-    :param list varyList: a list of parameters names (strings of form ``<ph>:<hst>:<nam>``) that will be varied
+    :param list parmlist: a list containing lists of parameter names
+      contained in each group, created in :func:`GroupConstraints`
+      (returned as 2nd value)
+
+    :param list varyList: a list of parameters names (strings of form
+      ``<ph>:<hst>:<nam>``) that will be varied
     
-    :param dict constrDict: a list of dicts defining relationships/constraints (as defined in :func:`GroupConstraints`)
-
-    :param list fixedList: a list of values specifying a fixed value for each dict in constrDict. Values are
-      either strings that can be converted to floats, float values or None if the constraint defines a new
-      parameter
+    :param dict constrDict: a list of dicts defining relationships/constraints
+      (as defined in :func:`GroupConstraints`)
+
+    :param list fixedList: a list of values specifying a fixed value for each
+      dict in constrDict. Values are either strings that can be converted to
+      floats, float values or None if the constraint defines a new parameter.
       
-    :param dict constrDict: a list of dicts defining relationships/constraints
+    :param dict constrDict: a list of dicts defining relationships/constraints.
 
     '''
@@ -537 +545 @@
                 if mv not in indepVarList: indepVarList.append(mv)
                 for v,m in zip(varlist,invmultarr):
-                    #if len(s): s += '  & '
-                    #s += str(v)
-                    #if m != 1:
-                    #    s += " / " + str(m[0])                        
                     if m == 0: zeromult = True
                     if v in varyList:
@@ -551 +555 @@
                     else:
                         depVarList.append(v)
-                #print str(mv) + ' is equivalent to parameter(s): '+s
             if varied > 0 and varied != len(varlist)+1:
                 msg += "\nNot all variables refined in equivalence:\n\t"
@@ -587 +590 @@
         msg += '\t'+ s + '\n'
     equivVarList = list(set(indepVarList).union(set(depVarList)))
-    #print 'equivVarList',equivVarList
-#    inboth = set(fixedVarList).intersection(set(equivVarList))
-#    if len(inboth) > 0:
-#        msg += "\nError! The following variables are used in both Equivalence and Fixed constraints:\n"
-#        s = ''
-#        for var in sorted(inboth):
-#            if s != "": s+= ", "
-#            s += str(var)
-#        msg += '\t'+ s + '\n'
-#
+
     # scan through parameters in each relationship. Are all varied? If only some are
     # varied, create an error message. 
@@ -616 +610 @@
                     msg += '\nError: parameter '+var+" is Fixed and used in a constraint:\n\t"
                     msg += _FormatConstraint(constrDict[rel],fixedList[rel])+"\n"
-#                if var in equivVarList:
-#                    msg += '\nError: parameter '+var+" is Equivalenced and used in a constraint:\n\t"
-#                    msg += _FormatConstraint(constrDict[rel],fixedList[rel])+"\n"
             if varied > 0 and varied != len(constrDict[rel]):
                 msg += "\nNot all variables refined in constraint:\n\t"
@@ -656 +647 @@
             varied = 0
             notvaried = ''
-            if len(group) > 0:
+            if len(group) > 0: # get the original equation reference
                 rel = group.pop(0)
+                if debug:
+                    print rel
+                    print fixedList[rel]
+                    print constrDict[rel]
                 fixedval = fixedList[rel]
                 for var in constrDict[rel]:
@@ -696 +691 @@
     if debug: # on debug, show what is parsed & generated, semi-readable
         print 50*'-'
-        for group,varlist,multarr,inv,mapvar in zip(groups,parmlist,arrayList,invarrayList,indParmList):
-            print '\n*** relation(s) in group:',group,'\tvars in group:',varlist
-            print 'new parameters:', mapvar
-            print 'Input relationship matrix'
-            print multarr[:len(group)]
-            added = len(group) - len(varlist)
-            if added < 0:
-                print 'added relationship rows'
-                print multarr[added:]
-            print 'Inverse relationship matrix'
-            print inv
+        print VarRemapShow(varyList)
 
 def StoreEquivalence(independentVar,dependentList):

trunk/GSASIIobj.py

@@ -26 +26 @@
 Note that the contents of each dict item is a List where each element in the
 list is a :ref:`constraint definition objects <Constraint_definitions_table>`.
+The constraints in this form are converted in
+:func:`GSASIIstrIO.ProcessConstraints` to the form used in :mod:`GSASIImapvars`
 
 The keys in the Constraints dict are:
@@ -54 +56 @@
    single: Data object descriptions; Constraint Definition
 
-Each constraint is defined as a list using a series of terms of form
-
-::
-
-[[<mult1>, <var1>], [<mult2>, <var2>],..., <fixed val>, <vary flag>, <cons type>]
-
-Where the variable pair list item containing two values [<mult>, <var>], 
+Each constraint is defined as an item in a list. Each constraint is of form::
+
+[[<mult1>, <var1>], [<mult2>, <var2>],..., <fixedval>, <varyflag>, <constype>]
+
+Where the variable pair list item containing two values [<mult>, <var>], where: 
 
   * <mult> is a multiplier for the constraint (float)
-  * <var> is the name of the variable (str) (or to be implemented a :class:`VarName` object.)
+  * <var> a :class:`G2VarObj` object (previously a str variable name of form
+      'p:h:name[:at]')
 
 Note that the last three items in the list play a special role:
 
- * <fixed val> is the fixed value for a constraint equation or is None
- * <vary flag> is True, False or None and is intended to use to indicate if new variables
+ * <fixedval> is the fixed value for a `constant equation` (``constype=c``)
+   constraint or is None. For a `New variable` (``constype=f``) constraint,
+   a variable name can be specified as a str (but this is not yet used). 
+ * <varyflag> is True or False for `New variable` (``constype=f``) constraints
+   or is None. This will be implemented in the future to indicate if these variables
    should be refined.
- * <cons type> is one of four letters, 'e', 'c', 'h', 'f' that determines the type of constraint.
+ * <constype> is one of four letters, 'e', 'c', 'h', 'f' that determines the type of constraint:
 
     * 'e' defines a set of equivalent variables. Only the first variable is refined (if the
       appropriate refine flag is set) and and all other equivalent variables in the list
-      are generated from that variable. The vary flag for those variables is ignored.
-    * 'c' defines a constraint equation of form, :math:`m_1 \\times var_1 + m_2 \\times var_2 + ... = c`
-    * 'h' defines a variable to hold (not vary). Any variable on this list is not varied, even if its refinement
-      flag is set. This is of particular value when needing to hold one or more variables in a set such as
+      are generated from that variable, using the appropriate multipliers. 
+    * 'c' defines a constraint equation of form,
+      :math:`m_1 \\times var_1 + m_2 \\times var_2 + ... = c`
+    * 'h' defines a variable to hold (not vary). Any variable on this list is not varied,
+      even if its refinement flag is set. Only one [mult,var] pair is allowed in a hold
+      constraint and the mult value is ignored.
+      This is of particular value when needing to hold one or more variables where a
+      single flag controls a set of variables such as, coordinates, 
       the reciprocal metric tensor or anisotropic displacement parameter. 
-    * 'f' defines a relationship to define a new variable according to relationship 
+    * 'f' defines a new variable (function) according to relationship 
       :math:`newvar = m_1 \\times var_1 + m_2 \\times var_2 + ...`
 
@@ -594 +602 @@
   key                      sub-key        explanation
 ======================  ===============  ====================================================
-Data
-                                          A dict that contains the 
+Data                          \           A dict that contains the 
                                           reflection table,
                                           as described in the
@@ -625 +632 @@
 hId                           \           The number assigned to the histogram when
                                           the project is loaded or edited (can change)
+ranId                         \           A random number id for the histogram
+                                          that does not change
 ======================  ===============  ====================================================
 
@@ -662 +671 @@
 
 '''
+import random as ran
+import sys
 import GSASIIpath
+import GSASIImath as G2mth
+
 GSASIIpath.SetVersionNumber("$Revision$")
-
-def LoadHistogramIDs(histList,idList):
-    '''Save the Id values for a series of histograms'''
-    VarName.IDdict['hists'] = {}
-    for h,i in zip(histList,idList):
-        VarName.IDdict['hists'][i] = h
-
-def LoadPhaseIDs(self):
-    pass
-
-class VarName(object):
-    '''Defines a GSAS-II variable either using the phase/atom/histogram
-    unique Id numbers or using a character string that specifies
-    variables by phase/atom/histogram number (which can change).
-    Note that :func:`LoadID` should be used to (re)load the current Ids
-    before creating or later using the VarName object.
-
-    A :class:`VarName` object can be created with a single parameter:
+PhaseIdLookup = {}
+'''dict listing phase name and random Id keyed by sequential phase index as a str;
+best to access this using :func:`LookupPhaseName`
+'''
+PhaseRanIdLookup = {}
+'''dict listing phase sequential index keyed by phase random Id;
+best to access this using :func:`LookupPhaseId`
+'''
+HistIdLookup = {}
+'''dict listing histogram name and random Id, keyed by sequential histogram index as a str;
+best to access this using :func:`LookupHistName`
+'''
+HistRanIdLookup = {}
+'''dict listing histogram sequential index keyed by histogram random Id;
+best to access this using :func:`LookupHistId`
+'''
+AtomIdLookup = {}
+'''dict listing for each phase index as a str, the atom label and atom random Id,
+keyed by atom sequential index as a str;
+best to access this using :func:`LookupAtomLabel`
+'''
+AtomRanIdLookup = {}
+'''dict listing for each phase the atom sequential index keyed by atom random Id;
+best to access this using :func:`LookupAtomId`
+'''
+ShortPhaseNames = {}
+'''a dict containing a possibly shortened and when non-unique numbered
+version of the phase name. Keyed by the phase sequential index.
+'''
+ShortHistNames = {}
+'''a dict containing a possibly shortened and when non-unique numbered
+version of the histogram name. Keyed by the histogram sequential index.
+'''
+
+VarDesc = {}
+''' This dictionary lists descriptions for GSAS-II variables,
+as set in :func:`CompileVarDesc`. See that function for a description
+for how keys and values are written.
+'''
+
+reVarDesc = {}
+''' This dictionary lists descriptions for GSAS-II variables with
+the same values as :attr:`VarDesc` except that keys have been compiled as
+regular expressions. Initialized in :func:`CompileVarDesc`.
+'''
+
+def IndexAllIds(G2frame=None,Histograms=None,Phases=None):
+    '''Scan through the used phases & histograms and create an index
+    to the random numbers of phases, histograms and atoms. While doing this,
+    confirm that assigned random numbers are unique -- just in case lightning
+    strikes twice in the same place.
+
+    Note: this code assumes that the atom random Id (ranId) is the last 
+    element each atom record.
+
+    TODO: do we need a lookup for rigid body variables?
+    '''
+    if G2frame:
+        Histograms,phaseDict = G2frame.GetUsedHistogramsAndPhasesfromTree()
+    else:
+        Histograms,phaseDict = Histograms,Phases
+    # process phases and atoms
+    PhaseIdLookup.clear()
+    PhaseRanIdLookup.clear()    
+    AtomIdLookup.clear()
+    AtomRanIdLookup.clear()
+    ShortPhaseNames.clear()
+    for Phase in phaseDict:
+        cx,ct,cs,cia = phaseDict[Phase]['General']['AtomPtrs']
+        ranId = phaseDict[Phase]['ranId'] 
+        while ranId in PhaseRanIdLookup:
+            # Found duplicate random Id! note and reassign
+            print ("\n\n*** Phase "+str(Phase)+" has repeated ranId. Fixing.\n")
+            phaseDict[Phase]['ranId'] = ranId = ran.randint(0,sys.maxint)
+        pId = str(phaseDict[Phase]['pId'])
+        PhaseIdLookup[pId] = (Phase,ranId)
+        PhaseRanIdLookup[ranId] = pId
+        shortname = Phase[:10]
+        while shortname in ShortPhaseNames.values():
+            shortname = Phase[:8] + ' ('+ pId + ')'
+        ShortPhaseNames[pId] = shortname
+        AtomIdLookup[pId] = {}
+        AtomRanIdLookup[pId] = {}
+        for iatm,at in enumerate(phaseDict[Phase]['Atoms']):
+            ranId = at[-1]
+            while ranId in AtomRanIdLookup[pId]: # check for dups
+                print ("\n\n*** Phase "+str(Phase)+" atom "+str(iatm)+" has repeated ranId. Fixing.\n")
+                at[-1] = ranId = ran.randint(0,sys.maxint)
+            AtomRanIdLookup[pId][ranId] = str(iatm)
+            if phaseDict[Phase]['General']['Type'] == 'macromolecular':
+                label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
+            else:
+                label = at[ct-1]
+            AtomIdLookup[pId][str(iatm)] = (label,ranId)
+    # process histograms
+    HistIdLookup.clear()
+    HistRanIdLookup.clear()
+    ShortHistNames.clear()
+    for hist in Histograms:
+        ranId = Histograms[hist]['ranId']
+        while ranId in HistRanIdLookup:
+            # Found duplicate random Id! note and reassign
+            print ("\n\n*** Histogram "+str(hist)+" has repeated ranId. Fixing.\n")
+            Histograms[hist]['ranId'] = ranId = ran.randint(0,sys.maxint)
+        hId = str(Histograms[hist]['hId'])
+        HistIdLookup[hId] = (hist,ranId)
+        HistRanIdLookup[ranId] = hId
+        shortname = hist[:15]
+        while shortname in ShortHistNames.values():
+            shortname = hist[:11] + ' ('+ hId + ')'
+        ShortHistNames[hId] = shortname
+
+    return Histograms,phaseDict
+
+def LookupAtomId(pId,ranId):
+    '''Get the atom number from a phase and atom random Id
+
+    :param int/str pId: the sequential number of the phase
+    :param int ranId: the random Id assigned to an atom
+
+    :returns: the index number of the atom (str)
+    '''
+    if not AtomRanIdLookup:
+        raise Exception,'Error: LookupAtomId called before IndexAllIds was run'
+    if pId is None or pId == '':
+        raise KeyError,'Error: phase is invalid (None or blank)'
+    pId = str(pId)
+    if pId not in AtomRanIdLookup:
+        raise KeyError,'Error: LookupAtomId does not have phase '+pId
+    if ranId not in AtomRanIdLookup[pId]:
+        raise KeyError,'Error: LookupAtomId, ranId '+str(ranId)+' not in AtomRanIdLookup['+pId+']'
+    return AtomRanIdLookup[pId][ranId]
+
+def LookupAtomLabel(pId,index):
+    '''Get the atom label from a phase and atom index number
+
+    :param int/str pId: the sequential number of the phase
+    :param int index: the index of the atom in the list of atoms
+
+    :returns: the label for the atom (str) and the random Id of the atom (int)
+    '''
+    if not AtomIdLookup:
+        raise Exception,'Error: LookupAtomLabel called before IndexAllIds was run'
+    if pId is None or pId == '':
+        raise KeyError,'Error: phase is invalid (None or blank)'
+    pId = str(pId)
+    if pId not in AtomIdLookup:
+        raise KeyError,'Error: LookupAtomLabel does not have phase '+pId
+    if index not in AtomIdLookup[pId]:
+        raise KeyError,'Error: LookupAtomLabel, ranId '+str(index)+' not in AtomRanIdLookup['+pId+']'
+    return AtomIdLookup[pId][index]
+
+def LookupPhaseId(ranId):
+    '''Get the phase number and name from a phase random Id
+
+    :param int ranId: the random Id assigned to a phase
+    :returns: the sequential Id (pId) number for the phase (str)
+    '''
+    if not PhaseRanIdLookup:
+        raise Exception,'Error: LookupPhaseId called before IndexAllIds was run'
+    if ranId not in PhaseRanIdLookup:
+        raise KeyError,'Error: LookupPhaseId does not have ranId '+str(ranId)
+    return PhaseRanIdLookup[ranId]
+
+def LookupPhaseName(pId):
+    '''Get the phase number and name from a phase Id
+
+    :param int/str pId: the sequential assigned to a phase
+    :returns:  (phase,ranId) where phase is the name of the phase (str)
+      and ranId is the random # id for the phase (int)
+    '''
+    if not PhaseIdLookup:
+        raise Exception,'Error: LookupPhaseName called before IndexAllIds was run'
+    if pId is None or pId == '':
+        raise KeyError,'Error: phase is invalid (None or blank)'
+    pId = str(pId)
+    if pId not in PhaseIdLookup:
+        raise KeyError,'Error: LookupPhaseName does not have index '+pId
+    return PhaseIdLookup[pId]
+
+def LookupHistId(ranId):
+    '''Get the histogram number and name from a histogram random Id
+
+    :param int ranId: the random Id assigned to a histogram
+    :returns: the sequential Id (hId) number for the histogram (str)
+    '''
+    if not HistRanIdLookup:
+        raise Exception,'Error: LookupHistId called before IndexAllIds was run'
+    if ranId not in HistRanIdLookup:
+        raise KeyError,'Error: LookupHistId does not have ranId '+str(ranId)
+    return HistRanIdLookup[ranId]
+
+def LookupHistName(hId):
+    '''Get the histogram number and name from a histogram Id
+
+    :param int/str hId: the sequential assigned to a histogram
+    :returns:  (hist,ranId) where hist is the name of the histogram (str)
+      and ranId is the random # id for the histogram (int)
+    '''
+    if not HistIdLookup:
+        raise Exception,'Error: LookupHistName called before IndexAllIds was run'
+    if hId is None or hId == '':
+        raise KeyError,'Error: histogram is invalid (None or blank)'
+    hId = str(hId)
+    if hId not in HistIdLookup:
+        raise KeyError,'Error: LookupHistName does not have index '+hId
+    return HistIdLookup[hId]
+
+def fmtVarDescr(varname):
+    '''Return a string with a more complete description for a GSAS-II variable 
+
+    TODO: This will not handle rigid body parameters yet
+
+    :param str name: A full G2 variable name with 2 or 3
+       colons (<p>:<h>:name[:<a>])
+       
+    :returns: a string with the description
+    '''
     
-    :param str varname: a single value can be used to create a :class:`VarName`
-      object. The string must be of form "p:h:var" or "p:h:var:a", where
-
-     * p is the phase number (which may be left blank); 
-     * h is the histogram number (which may be left blank); 
-     * a is the atom number (which may be left blank in which case the third colon is omitted).
-
-    Alternately, a :class:`VarName` object can be created with exactly four positional parameters:
-
-    :param int phasenum: The number for the phase
-    :param int histnum: The number for the histogram
-    :param str varname: a single value can be used to create a :class:`VarName`
-    :param int atomnum: The number for the atom
+    l = getVarDescr(varname)
+    if not l:
+        return "invalid variable name ("+str(varname)+")!"
+
+    if not l[4]:
+        l[4] = "(variable needs a definition!)"
+
+    s = ""
+    if l[0] is not None and l[1] is not None: # HAP: keep short
+        lbl = ShortPhaseNames.get(l[0],'? #'+str(l[0]))
+        hlbl = ShortHistNames.get(l[1],'? #'+str(l[1]))
+        if hlbl[:4] == 'HKLF':
+            hlbl = 'Xtl='+hlbl[5:]
+        elif hlbl[:4] == 'PWDR':
+            hlbl = 'Pwd='+hlbl[5:]
+        else:
+            hlbl = 'Hist='+hlbl
+        s = "Ph="+str(lbl)+" * "+str(hlbl)+": "
+    elif l[3] is not None: # atom parameter, 
+        lbl = ShortPhaseNames.get(l[0],'phase?')
+        try:
+            albl = LookupAtomLabel(l[0],l[3])[0]
+        except KeyError:
+            albl = 'Atom?'
+        s = "Atom "+str(albl)+" in "+str(lbl)+": "
+    elif l[0] is not None:
+        lbl = ShortPhaseNames.get(l[0],'phase?')
+        s = "Phase "+str(lbl)+": "
+    elif l[1] is not None:
+        hlbl = ShortHistNames.get(l[1],'? #'+str(l[1]))
+        if hlbl[:4] == 'HKLF':
+            hlbl = 'Xtl='+hlbl[5:]
+        elif hlbl[:4] == 'PWDR':
+            hlbl = 'Pwd='+hlbl[5:]
+        else:
+            hlbl = 'Hist='+hlbl
+        s = str(hlbl)+": "    
+    if not s:
+        s = 'Global: '
+    s += l[4]
+    return s
+
+def getVarDescr(varname):
+    '''Return a short description for a GSAS-II variable 
+
+    :param str name: A full G2 variable name with 2 or 3
+       colons (<p>:<h>:name[:<a>])
+      
+    :returns: a five element list as [`p`,`h`,`name`,`a`,`description`],
+      where `p`, `h`, `a` are str values or `None`, for the phase number,
+      the histogram number and the atom number; `name` will always be
+      an str; and `description` is str or `None`.
+      If the variable name is incorrectly formed (for example, wrong
+      number of colons), `None` is returned instead of a list.
+    '''
+    l = varname.split(':')
+    if len(l) == 3:
+        l += [None]
+    if len(l) != 4:
+        return None
+    for i in (0,1,3):
+        if l[i] == "":
+            l[i] = None
+    l += [getDescr(l[2])]
+    return l
     
+def CompileVarDesc():
+    '''Set the values in the variable description lookup table (:attr:`VarDesc`)
+    into :attr:`reVarDesc`. This is called in :func:`getDescr` so the initialization
+    is always done before use.
+
+    Note that keys may contain regular expressions, where '[xyz]'
+    matches 'x' 'y' or 'z' (equivalently '[x-z]' describes this as range of values).
+    '.*' matches any string. For example::
+
+    'AUiso':'Atomic isotropic displacement parameter',
+
+    will match variable ``'p::AUiso:a'``.
+    If parentheses are used in the key, the contents of those parentheses can be
+    used in the value, such as::
+
+    'AU([123][123])':'Atomic anisotropic displacement parameter U\\1',
+
+    will match ``AU11``, ``AU23``,.. and `U11`, `U23` etc will be displayed
+    in the value when used.
+    
     '''
     import re
-    IDdict = {}
-    IDdict['phases'] = {}
-    IDdict['hists'] = {}
-    IDdict['atoms'] = {}
-    # This dictionary lists descriptions for GSAS-II variables.
-    # Note that keys may contain regular expressions, where '[xyz]'
-    # matches 'x' 'y' or 'z' (equivalently '[x-z]' describes this as range of values).
-    # '.*' matches any string
-    VarDesc = {
+    if reVarDesc: return # already done
+    for key,value in {
         # Phase vars (p::<var>)
-        'A[0-5]' : 'Reciprocal metric tensor component',
+        'A([0-5])' : 'Reciprocal metric tensor component \\1',
         'Vol' : 'Unit cell volume????',
         # Atom vars (p::<var>:a)
-        'dA[xyz]' : 'change to atomic position',
+        'dA([xyz])' : 'change to atomic position \\1',
         'AUiso':'Atomic isotropic displacement parameter',
-        'AU[123][123]':'Atomic anisotropic displacement parameter',
-        'AFrac': 'Atomic occupancy parameter',
+        'AU([123][123])':'Atomic anisotropic displacement parameter U\\1',
+        'Afrac': 'Atomic occupancy parameter',
         # Hist & Phase (HAP) vars (p:h:<var>)
-        'Bab[AU]': 'Babinet solvent scattering coef.',
-        'D[123][123]' : 'Anisotropic strain coef.',
+        'Bab([AU])': 'Babinet solvent scattering coef. \\1',
+        'D([123][123])' : 'Anisotropic strain coef. \\1',
         'Extinction' : 'Extinction coef.',
         'MD' : 'March-Dollase coef.',
@@ -727 +1005 @@
         #Histogram vars (:h:<var>)
         'Absorption' : 'Absorption coef.',
-        'Displace[XY]' : 'Debye-Scherrer sample displacement',
+        'Displace([XY])' : 'Debye-Scherrer sample displacement \\1',
         'Lam' : 'Wavelength',
-        'Polariz' : 'Polarization correction',
+        'Polariz\.' : 'Polarization correction',
         'SH/L' : 'FCJ peak asymmetry correction',
         'Scale' : 'Histogram scale factor',
-        '[UVW]' : 'Gaussian instrument broadening',
-        '[XY]' : 'Cauchy instrument broadening',
+        '([UVW])' : 'Gaussian instrument broadening \\1',
+        '([XY])' : 'Cauchy instrument broadening \\1',
         'Zero' : 'Debye-Scherrer zero correction',
         'nDebye' : 'Debye model background corr. terms',
-        'nPeaks' : 'Fixed peak  background corr. terms',
+        'nPeaks' : 'Fixed peak background corr. terms',
         # Global vars (::<var>)
-        }
+        }.items():
+        VarDesc[key] = value
+        reVarDesc[re.compile(key)] = value
+
+def getDescr(name):
+    '''Return a short description for a GSAS-II variable 
+
+    :param str name: The descriptive part of the variable name without colons (:)
+      
+    :returns: a short description or None if not found
+    '''
+
+    CompileVarDesc() # compile the regular expressions, if needed
+    for key in reVarDesc:
+        m = key.match(name)
+        if m:
+            return m.expand(reVarDesc[key])
+    return None
+
+def _lookup(dic,key):
+    '''Lookup a key in a dictionary, where None returns an empty string
+    but an unmatched key returns a question mark. Used in :class:`G2VarObj`
+    '''
+    if key is None:
+        return ""
+    else:
+        return dic.get(key,'?')
+
+class G2VarObj(object):
+    '''Defines a GSAS-II variable either using the phase/atom/histogram
+    unique Id numbers or using a character string that specifies
+    variables by phase/atom/histogram number (which can change).
+    Note that :func:`LoadID` should be used to (re)load the current Ids
+    before creating or later using the G2VarObj object.
+
+    A :class:`G2VarObj` object can be created with a single parameter:
+    
+    :param str varname: a single value can be used to create a :class:`G2VarObj`
+      object. The string must be of form "p:h:var" or "p:h:var:a", where
+
+     * p is the phase number (which may be left blank); 
+     * h is the histogram number (which may be left blank); 
+     * a is the atom number (which may be left blank in which case the third colon is omitted).
+
+    Alternately, a :class:`G2VarObj` object can be created with exactly four positional parameters:
+
+    :param str/int phasenum: The number for the phase
+    :param str/int histnum: The number for the histogram
+    :param str varname: a single value can be used to create a :class:`G2VarObj`
+    :param str/int atomnum: The number for the atom
+    
+    '''
+    IDdict = {}
+    IDdict['phases'] = {}
+    IDdict['hists'] = {}
+    IDdict['atoms'] = {}
     def __init__(self,*args):
         self.phase = None
@@ -746 +1079 @@
         if len(args) == 1:
             lst = args[0].split(':')
-            raise Exception, "Need to look up IDs"
-            self.phase = lst[0]
-            self.histogram = lst[1]
+            self.phase = PhaseIdLookup.get(lst[0],[None,None])[1]
+            self.histogram = HistIdLookup.get(lst[1],[None,None])[1]
             self.name = lst[2]
             if len(lst) > 3:
-                self.atom = lst[3]
+                self.atom = AtomIdLookup[lst[0]].get(lst[3],[None,None])[1]
         elif len(args) == 4:
-            self.phase = args[0]
-            self.histogram = args[1]
+            self.phase = PhaseIdLookup.get(str(args[0]),[None,None])[1]
+            self.histogram = HistIdLookup.get(str(args[1]),[None,None])[1]
             self.name = args[2]
-            self.atom = args[3]
+            self.atom = AtomIdLookup[args[0]].get(str(args[3]),[None,None])[1]
         else:
             raise Exception,"Incorrectly called GSAS-II parameter name"
 
+        #print "DEBUG: created ",self.phase,self.histogram,self.name,self.atom
+
     def __str__(self):
-        return self.name()
-
-    def name(self):
-        '''Formats the GSAS-II variable name as a "traditional" string (p:h:<var>:a)
+        return self.varname()
+
+    def varname(self):
+        '''Formats the GSAS-II variable name as a "traditional" GSAS-II variable 
+        string (p:h:<var>:a) or (p:h:<var>)
 
         :returns: the variable name as a str
         '''
-        def _fmt(val):
-            if val is None:
-                return ""
-            return str(val)
-        return _fmt(self.phase) + ":" + _fmt(self.histogram) + _fmt(self.name) + _fmt(self.atom)
-
+        ph = _lookup(PhaseRanIdLookup,self.phase)
+        hist = _lookup(HistRanIdLookup,self.histogram)
+        s = (ph + ":" + hist + ":" + 
+             str(self.name))
+        if self.atom:
+            if ph in AtomRanIdLookup:
+                s += ":" + AtomRanIdLookup[ph].get(self.atom,'?')
+            else:
+                s += ":?"
+        return s
+    
     def __repr__(self):
         '''Return the detailed contents of the object
         '''
-        s = ""
-        if self.phase:
-            s += "Phase: " + str(self.phase) + "; "
-
-        if self.histogram:
-            s += "Histogram: " + str(self.histogram) + "; "
-            
-        if self.name:
-            s += "Variable name: " + str(self.name) + "; "
-
-        if self.atom:
-            s += "Atom number: " + str(self.atom) + "; "
-
-        return s+"("+self.name()+")"
-
-    def getDescr(self):
-        '''Return a short description for a GSAS-II variable 
-
-        :returns: a short description or 'no definition' if not found
-        '''
-        # iterating over uncompiled regular expressions is not terribly fast,
-        # but this routine should not need to be all that speedy
-        for key in self.VarDesc:
-            if re.match(key, self.name):
-                return self.VarDesc[key]
-        return 'no definition'
-
-    def getDescr(self):
-        '''Return a short description for a GSAS-II variable 
-
-        :returns: a short description or 'no definition' if not found
-        '''
-        # iterating over uncompiled regular expressions is not terribly fast,
-        # but this routine should not need to be all that speedy
-        for key in self.VarDesc:
-            if re.match(key, self.name):
-                return self.VarDesc[key]
-        return 'no definition'
-
-    def fullDescr(self):
-        '''Return a longer description for a GSAS-II variable 
-
-        :returns: a short description or 'no definition' if not found
-        '''
-        # iterating over uncompiled regular expressions is not terribly fast,
-        # but this routine should not need to be all that speedy
-        str = self.name()
-        
-        for key in self.VarDesc:
-            if re.match(key, self.name):
-                return self.VarDesc[key]
-        return 'no definition'
-
+        s = "<"
+        if self.phase is not None:
+            ph =  _lookup(PhaseRanIdLookup,self.phase)
+            s += "Phase: rId=" + str(self.phase) + " (#"+ ph + "); "
+        if self.histogram is not None:
+            hist = _lookup(HistRanIdLookup,self.histogram)
+            s += "Histogram: rId=" + str(self.histogram) + " (#"+ hist + "); "
+        if self.atom is not None:
+            s += "Atom rId=" + str(self.atom)
+            if ph in AtomRanIdLookup:
+                s += " (#" + AtomRanIdLookup[ph].get(self.atom,'?') + "); "
+            else:
+                s += " (#? -- no such phase!); "
+        s += 'Variable name="' + str(self.name) + '">'
+        return s+"("+self.varname()+")"
+
+    def __eq__(self, other):
+        if type(other) is type(self):
+            return (self.phase == other.phase and
+                    self.histogram == other.histogram and
+                    self.name == other.name and
+                    self.atom == other.atom)
+        return False
 
     def _show(self):

trunk/GSASIIstrIO.py

@@ -29 +29 @@
 import GSASIIlattice as G2lat
 import GSASIIspc as G2spc
+import GSASIIobj as G2obj
 import GSASIImapvars as G2mv
 import GSASIImath as G2mth
@@ -79 +80 @@
     constDict,fixedList,ignored = ProcessConstraints(constList)
     if ignored:
-        print ignored,'old-style Constraints were rejected'
+        print ignored,'Constraints were rejected. Was a constrained phase, histogram or atom deleted?'
     return constDict,fixedList
     
 def ProcessConstraints(constList):
     """Interpret the constraints in the constList input into a dictionary, etc.
+    All :class:`GSASIIobj.G2VarObj` objects are mapped to the appropriate
+    phase/hist/atoms based on the object internals (random Ids). If this can't be
+    done (if a phase has been deleted, etc.), the variable is ignored.
+    If the constraint cannot be used due to too many dropped variables,
+    it is counted as ignored.
     
     :param list constList: a list of lists where each item in the outer list
-      specifies a constraint of some form. The last item in each inner list
-      determines which of the four constraints types has been input:
-
-        * h (hold): a single variable that will not be varied. It
-          will be removed from the varyList later.
-        * c (constraint): specifies a linear relationship that
-          can be varied as a new grouped variable
-          a fixed value.
-        * f (fixed): specifies a linear relationship that is assigned
-          a fixed value.
-        * e (equivalence): specifies a series of variables where the
-          first variable in the last can be used to generate the
-          values for all the remaining variables.
+      specifies a constraint of some form, as described in the :mod:`GSASIIobj`
+      :ref:`Constraint definition <Constraint_definitions_table>`.
 
     :returns:  a tuple of (constDict,fixedList,ignored) where:
       
-      * constDict (list) contains the constraint relationships
+      * constDict (list of dicts) contains the constraint relationships
       * fixedList (list) contains the fixed values for type
         of constraint.
       * ignored (int) counts the number of invalid constraint items
         (should always be zero!)
-
     """
     constDict = []
@@ -116 +110 @@
             # process a hold
             fixedList.append('0')
-            constDict.append({item[0][1]:0.0})
+            var = str(item[0][1])
+            if '?' not in var:
+                constDict.append({var:0.0})
+            else:
+                ignored += 1
         elif item[-1] == 'f':
             # process a new variable
             fixedList.append(None)
-            constDict.append({})
+            D = {}
+            varyFlag = item[-2]
+            name = item[-3]
             for term in item[:-3]:
-                constDict[-1][term[1]] = term[0]
+                var = str(term[1])
+                if '?' not in var:
+                    D[var] = term[0]
+            if len(D) > 1:
+                # add extra dict terms for input variable name and vary flag
+                #if name is not None:
+                #    D['_name'] = name
+                #D['_vary'] = varyFlag == True # force to bool
+                constDict.append(D)
+            else:
+                ignored += 1
             #constFlag[-1] = ['Vary']
         elif item[-1] == 'c': 
             # process a contraint relationship
-            fixedList.append(str(item[-3]))
-            constDict.append({})
+            D = {}
             for term in item[:-3]:
-                constDict[-1][term[1]] = term[0]
-            #constFlag[-1] = ['VaryFree']
+                var = str(term[1])
+                if '?' not in var:
+                    D[var] = term[0]
+            if len(D) >= 1:
+                fixedList.append(str(item[-3]))
+                constDict.append(D)
+            else:
+                ignored += 1
         elif item[-1] == 'e':
             # process an equivalence
@@ -137 +152 @@
             for term in item[:-3]:
                 if term[0] == 0: term[0] = 1.0
+                var = str(term[1])
+                if '?' in var: continue
                 if firstmult is None:
-                    firstmult,firstvar = term
+                    firstmult = term[0]
+                    firstvar = var
                 else:
-                    eqlist.append([term[1],firstmult/term[0]])
-            G2mv.StoreEquivalence(firstvar,eqlist)
+                    eqlist.append([var,firstmult/term[0]])
+            if len(eqlist) > 0:
+                G2mv.StoreEquivalence(firstvar,eqlist)
+            else:
+                ignored += 1
         else:
             ignored += 1
@@ -156 +177 @@
     if not Histograms:
         return 'Error: no diffraction data',''
+    G2obj.IndexAllIds(Histograms=Histograms,Phases=Phases)
     rigidbodyDict = GetRigidBodies(GPXfile)
     rbIds = rigidbodyDict.get('RBIds',{'Vector':[],'Residue':[]})
@@ -335 +357 @@
 def GetUsedHistogramsAndPhases(GPXfile):
     ''' Returns all histograms that are found in any phase
-    and any phase that uses a histogram
+    and any phase that uses a histogram. This also
+    assigns numbers to used phases and histograms by the
+    order they appear in the file. 
 
     :param str GPXfile: full .gpx file name
-    :return: (Histograms,Phases)
+    :returns: (Histograms,Phases)
 
      * Histograms = dictionary of histograms as {name:data,...}
@@ -363 +387 @@
                     Phase['Histograms'][hist]['Use'] = True         
                 if hist not in Histograms and Phase['Histograms'][hist]['Use']:
-                    Histograms[hist] = allHistograms[hist]
-                    hId = histoList.index(hist)
-                    Histograms[hist]['hId'] = hId
+                    try:
+                        Histograms[hist] = allHistograms[hist]
+                        hId = histoList.index(hist)
+                        Histograms[hist]['hId'] = hId
+                    except KeyError: # would happen if a referenced histogram were
+                        # renamed or deleted
+                        print('For phase "'+str(phase)+
+                              '" unresolved reference to histogram "'+str(hist)+'"')
     return Histograms,Phases
     

trunk/GSASIIstrMain.py

@@ -58 +58 @@
     calcControls = {}
     calcControls.update(Controls)            
-    constrDict,fixedList = G2stIO.GetConstraints(GPXfile)
+    constrDict,fixedList = G2stIO.GetConstraints(GPXfile) # better to pass in Histograms,Phases
     restraintDict = G2stIO.GetRestraints(GPXfile)
     Histograms,Phases = G2stIO.GetUsedHistogramsAndPhases(GPXfile)
+    G2obj.IndexAllIds(Histograms=Histograms,Phases=Phases)
     if not Phases:
         print ' *** ERROR - you have no phases! ***'
@@ -91 +92 @@
     try:
         groups,parmlist = G2mv.GroupConstraints(constrDict)
+        #G2mv.debug = True # DEBUG
         G2mv.GenerateConstraints(groups,parmlist,varyList,constrDict,fixedList)
+        #G2mv.debug = False # DEBUG
     except:
         print ' *** ERROR - your constraints are internally inconsistent ***'
@@ -98 +101 @@
         if warnmsg: print 'Warnings',warnmsg
         raise Exception(' *** Refine aborted ***')
+    #raise Exception(' *** Refine DEBUG ***') # DEBUG
     # # check to see which generated parameters are fully varied
     # msg = G2mv.SetVaryFlags(varyList)