Changeset 564 for branches

Timestamp:

09/20/12 10:20:03 (4 years ago)

Author:

mmckerns

Message:

cone plotter now a more generic script, takes commandline input;
replaces selected coords with values, instead of values always along same axis

File:

• branches/UQ/math/legacy/plot_data.py (modified) (7 diffs)

branches/UQ/math/legacy/plot_data.py

@@ -1 +1 @@
 #!/usr/bin/env python
+__doc__ = """
+support_hypercube_scenario.py [options] filename datafile
+
+generate scenario support plots from file written with 'write_support_file'
+and a dataset file
+
+The options "bounds", "axes", and "iters" all take indicator strings.
+The bounds should be given as a quoted list of tuples.  For example, using
+bounds = "[(.062,.125),(0,30),(2300,3200)]" will set the lower and upper bounds
+for x to be (.062,.125), y to be (0,30), and z to be (2300,3200). Similarly,
+axes also accepts a quoted list of tuples; however, for axes, the first tuple
+indicates which parameters are along the x direction, the second tuple for
+the y direction, and the third tuple for the z direction. Thus, axes =
+"[(2,3),(6,7),(10,11)]" would set the 2nd and 3rd parameters along x. Iters,
+however, accepts a list of strings instead of a list of tuples. For example,
+iters = "[':']" will plot all iters in a single plot. Alternatively,
+iters = "[':2','2:']" will split the iters into two plots, while
+iters = "['0']" will only plot the first iteration.
+
+The option "label" takes a list of strings. For example, label = "['x','y','']"
+will place 'x' on the x-axis, 'y' on the y-axis, and nothing on the z-axis.
+LaTeX is also accepted. For example, label = "[r'$ h $',r'$ {\alpha}$',r'$ v$']"
+will label the axes with standard LaTeX math formatting. Note that the leading
+space is required, while the trailing space aligns the text with the axis
+instead of the plot frame.
+
+Required Inputs:
+  filename            name of the python convergence logfile (e.g. paramlog.py)
+  datafile            name of the dataset textfile (e.g. StAlDataset.txt)
+"""
 ZERO = 1.0e-6  # zero-ish
 
@@ -67 +97 @@
 
 #### plotting the cones ####
-def plot_cones(ax, data, slope, bounds, color='0.75'):
+def plot_cones(ax, data, slope, bounds, color='0.75', axis=-1):
   """plot double cones for a given dataset
 
@@ -75 +105 @@
   bounds -- list of tuples of bounds for the plot; (lower,upper) for each axis
   color -- string name (or rbg value) of color to use for datapoints
-"""
+  axis -- the axis of the cone
+"""
+  # adjust slope, bounds, and data so cone axis is last 
+  slope = swap(slope, axis) 
+  bounds = swap(bounds, axis) 
+  data = [swap(pt,axis) for pt in data]
   cone = cone_builder(slope, bounds)
   # plot the upper and lower cone
@@ -81 +116 @@
     _cone = cone(datapt, top=True)
     if _cone:
-      X,Z,Y = _cone
+      X,Z,Y = swap(_cone, xs) # 'unswap' the axes
       ax.plot_surface(X, Z,Y, rstride=1, cstride=1, color=color) 
     _cone = cone(datapt, top=False)
     if _cone:
-      X,Z,Y = _cone
+      X,Z,Y = swap(_cone, xs) # 'unswap' the axes
       ax.plot_surface(X, Z,Y, rstride=1, cstride=1, color=color)
   return ax
 
-def plot_data(ax, data, bounds, color='red'):
+def plot_data(ax, data, bounds, color='red', axis=-1):
   """plot datapoints for a given dataset
 
@@ -96 +131 @@
   bounds -- list of tuples of bounds for the plot; (lower,upper) for each axis
   color -- string name (or rbg value) of color to use for datapoints
+  axis -- the axis of the cone
 """
   strict = True # always respect the bounds
@@ -125 +161 @@
   return ax
 
-def reduce_dimension(axis, coords, values, slope, bounds):
+def label_axes(ax, labels):
+  """ label plots with given string labels
+
+  ax -- matplotlib 'Axes3D' plot object
+  labels -- list of string labels for the plot
+"""
+  ax.set_xlabel(labels[0])
+  ax.set_zlabel(labels[1])
+  ax.set_ylabel(labels[2]) # cone "center" axis
+  return ax
+
+def get_coords(data, replace=None):
   """ replace one coordiate axis in a 3-D data set with 'data values'
   (i.e. replace an 'x' axis with the 'y' values of the data)
 
-  axis -- selected coordinate axis (an int) to replace with 'y' values
-  coords -- list of datapoint coordinates, where coordinates are 3-tuples
-  values -- list of datapoint values, where values are floats
-  slope -- slope multiplier for cone on the X,Y,Z axes
-  bounds -- list of tuples of bounds for the plot; (lower,upper) for each axis
-
-NOTE: for the axis indicated by 'axis', replace
-   - selected axis bounds with Y-bounds
-   - selected coords with values
-   - selected slope with 1.0
+  data -- dataset object, where coordinates are 3-tuples and values are floats
+  replace -- selected axis (an int) to plot values NOT coords
   """
-  if axis not in range(len(bounds[:-1])):  # don't replace an axis
-    return coords, slope[:-1], bounds[:-1] 
-  xs = axis
-  bounds = bounds[:xs] + bounds[xs+1:]
-  slope = slope[:xs] + slope[xs+1:]
-  coords = [coords[i][:xs] + coords[i][xs+1:] + [values[i]] \
-                             for i in range(len(coords))]
-  return coords, slope, bounds
-
-
-if __name__ == '__main__':
-  ### FLAGS ############
-  # get selected data set (filename)
-  # get lower and upper bounds for plot view
-  # get selected (1 or 2) axes to plot  #FIXME: need to enable 2-D plots
-  ######################
-  from legacydata import load_dataset
-  data = load_dataset('StAlDataset.txt')
-  w_lower = [0.0]; Y_lower = [0.0]
-  w_upper = [1.0]; Y_upper = [40.0] # was 100
-  h_lower = [0.062]; a_lower = [0.0];  v_lower = [2300.0]
-  h_upper = [0.125]; a_upper = [30.0]; v_upper = [3200.0]
-  axis_to_replace = xs = 0    #XXX: select axis NOT to plot here
-
-  # temporarily 'inflate' bounds and slopes to include values
-  lb = h_lower + a_lower + v_lower + Y_lower
-  ub = h_upper + a_upper + v_upper + Y_upper
-  bounds = zip(lb,ub)
-  slope = data.lipschitz + [1.0]
+  slope = data.lipschitz
   coords = data.coords
   values = data.values
-  # replace selected coords axis; 'reduce' the size of bounds and slopes
-  coords, slope, bounds = reduce_dimension(xs, coords, values, slope, bounds)
-
+  if replace not in range(len(slope)):  # don't replace an axis
+    return coords, slope
+  slope = slope[:replace] + [1.0] + slope[replace+1:]
+  coords = [coords[i][:replace] + [values[i]] + coords[i][replace+1:] \
+                              for i in range(len(coords))]
+  return coords, slope
+
+def reduce(alist, axis=-1):
+  """ reduce a n-member list to a (n-1)-member list
+
+  alist -- a list
+  axis -- selected member (an int) to remove
+  """
+  if axis not in range(len(alist[:-1])):  # reduce the last axis
+    return alist[:-1] 
+  return alist[:axis] + alist[axis+1:]
+
+def swap(alist, axis=-1):
+  if axis not in range(len(alist)):  # don't swap an axis
+    return alist 
+  return alist[:axis] + alist[axis+1:] + alist[axis:axis+1]
+
+
+if __name__ == '__main__':
+  #FIXME: need to enable 2-D plots
+
+  #XXX: note that 'argparse' is new as of python2.7
+  from optparse import OptionParser
+  parser = OptionParser(usage=__doc__)
+  parser.add_option("-b","--bounds",action="store",dest="bounds",\
+                    metavar="STR",default="[(0,1),(0,1),(0,1)]",
+                    help="indicator string to set hypercube bounds")
+# parser.add_option("-x","--axes",action="store",dest="xyz",\
+#                   metavar="STR",default="[(0,),(1,),(2,)]",
+#                   help="indicator string to assign parameter to axis")
+  parser.add_option("-l","--label",action="store",dest="label",\
+                    metavar="STR",default="['','','']",
+                    help="string to assign label to axis")
+  parser.add_option("-r","--replace",action="store",dest="replace",\
+                    metavar="INT",default=None,
+                    help="id # of axis to plot values NOT coords")
+  parsed_opts, parsed_args = parser.parse_args()
+
+# try:  # get the name of the parameter log file
+#   file = parsed_args[0]
+#   import re
+#   file = re.sub('\.py*.$', '', file)  #XXX: strip off .py* extension
+# except:
+#   raise IOError, "please provide log file name"
+# try:  # read standard logfile
+#   from mystic.munge import logfile_reader, raw_to_support
+#   _step, params, _cost = logfile_reader(file)
+#   params, _cost = raw_to_support(params, _cost)
+# except:
+#   exec "from %s import params" % file
+#   #exec "from %s import meta" % file
+#   # would be nice to use meta = ['wx','wx2','x','x2','wy',...]
+
+  try:  # get the name of the dataset file
+    file = parsed_args[0]
+    from legacydata import load_dataset
+    data = load_dataset(file)
+  except:
+    raise IOError, "please provide dataset file name"
+
+  try: # select the bounds
+    bounds = eval(parsed_opts.bounds)  # format is "[(60,105),(0,30),(2.1,2.8)]"
+  except:
+    bounds = [(0,1),(0,1),(0,1)]
+
+  try: # select labels for the axes
+    label = eval(parsed_opts.label)  # format is "['x','y','z']"
+  except:
+    label = ['','','']
+
+  try: # select which axis to plot 'values' on
+    xs = int(parsed_opts.replace)
+  except:
+    xs = None # don't plot values; plot values on 'x' axis with xs = 0
+
+  # ensure all terms of bounds and xyz are tuples
+  for bound in bounds:
+    if not isinstance(bound, tuple):
+      raise TypeError, "bounds should be tuples of (lower_bound,upper_bound)"
+# for i in range(len(xyz)):
+#   if isinstance(xyz[i], int):
+#     xyz[i] = (xyz[i],)
+#   elif not isinstance(xyz[i], tuple):
+#     raise TypeError, "xyz should be tuples of (param1,param2,param3,...)"
+
+  # get coords (and values) for selected axes
+  coords, slope = get_coords(data, xs)  #FIXME: requires Y-value to be last
   print "bounds: %s" % bounds
   print "slope: %s" % slope
  #print "coords: %s" % coords
+
+  # use the default bounds where not specified
+  bounds = [list(i) for i in bounds]
+  for i in range(len(bounds)):
+    if bounds[i][0] is None: bounds[i][0] = 0
+    if bounds[i][1] is None: bounds[i][1] = 1
 
   import matplotlib 
@@ -184 +290 @@
   ax = Axes3D(fig)#,aspect='equal') 
   if xs in range(len(bounds)):  # we are replacing an axis
-    plot_cones(ax, coords, slope, bounds)
-  plot_data(ax, coords, bounds)
+    plot_cones(ax, coords, slope, bounds, axis=xs)
+  plot_data(ax, coords, bounds, axis=xs)
  #clip_axes(ax, bounds)
+  label_axes(ax, label)
   plt.show()