ChIPS - drawing lines between sets of (x,y) points

What parts of a curve I can change?

Figure 1 shows the default properties of a curve, which is that the points are connected by a solid line and marked by a symbol in the shape of a cross. To find out what attributes you can change, once you have created a curve, you can use the get_curve routine:

chips> print(get_curve())
baddata = 1
depth = 100
err.caplength = 10
err.color = default
err.down = False
err.left = False
err.right = False
err.style = line
err.thickness = 1.0
err.up = False
id = None
limit.length = 0.0500000007451
limit.override = True
line.color = red
line.style = 1
line.thickness = 1.0
stem = None
symbol.angle = 0.0
symbol.color = default
symbol.fill = True
symbol.size = 5
symbol.style = 0

The two lines in bold indicate the attributes of the curve we changed using the set_curve routine (the bold font has been added here for display purposes and does not appear in the actual screen output). Some attribute values can be set as either a string or numeric value; for such attributes the print out will use the numeric value, which is why the symbol.style attribute has a value of 0 and not none.

If you have started the GUI - either with the show_gui command or from the Show GUI entry in the right-mouse-button menu of the ChIPS window, then you can view and modify all the attributes of the objects. For the curve in this plot we would see Figure 4.

Figure 4: The ChIPS GUI

[Version: full-size]

Figure 4: The ChIPS GUI

The object attributes can be changed in the GUI, with the changes being reflected immediately on screen. To change the object being modified, either select the name in the Info frame or double click on the object in the ChIPS window.

Please see the Starting ChIPS thread or ahelp chipsgui for more infomation.

The return value from get_curve can be used in set_curve as an alternative way to change the attributes. For instance, the following code changes the curve in Figure 3 to be drawn in a thick blue line:

chips> ci = get_curve()   
chips> ci.line.thickness = 4
chips> ci.line.color = "blue"
chips> set_curve (ci)

Figure 5: Using get_curve and set_curve

[Version: full-size, PNG]

Figure 5: Using get_curve and set_curve

The set_curve call has changed the curve to be drawn with a blue color and with a thicker line.

Since both changes were made by a single call to set_curve, they will both be removed by a single call to undo:

chips> undo()

The properties of other objects can be found and changed using the get/set routines; for instance get_xaxis, set_xaxis, get_yaxis, set_yaxis, get_plot, and set_plot. It is also possible to change the properties of objects before they are created (using the preference system) or as they are created (by adding the attribute values to the add_<object> calls). These will be described in later threads, and are also demonstrated below (in creating Figure 9 and Figure 6 respectively).

The get_preference routine can be used to find out what the default parameters for an object are: these are the values that will be used the next time an object is created. The return value is a string, and the output below shows the default values for a curve:

chips> print(get_preference("curve"))
curve.stem             : crv
curve.baddata          : omit 
curve.depth            : default
curve.line.color       : default
curve.line.thickness   : 1
curve.line.style       : solid 
curve.symbol.color     : default
curve.symbol.style     : cross
curve.symbol.size      : 5
curve.symbol.angle     : 0
curve.symbol.fill      : true
curve.err.color        : default
curve.err.thickness    : 1
curve.err.style        : line 
curve.err.up           : on
curve.err.down         : on
curve.err.left         : on
curve.err.right        : on
curve.err.caplength    : 10
curve.limit.length     : 0.05
curve.limit.override   : true

What objects have been created?

The info command returns a string that describes what objects have been created:

chips> print(info())
Window [win1]
  Frame [frm1]
    Plot [plot1]   (0.15,0.15)  .. (0.90,0.90)
      Border bottom [bx1]  top [bx2]  left [by1]  right [by2]
      Curve [crv1]
      X Axis [ax1]
      Y Axis [ay1]

This is read as: there is a window called win1, a frame called frm1, a plot called plot1, four borders (called bx1, bx2, by1, by2), X and Y axes called ax1 and ay1 respectively, and a curve called crv1. These objects were all created automatically by the make_figure call. It is possible to create these individually (there are add_<object> calls), and to use different names (e.g. instead of crv1). in later threads.

The indentation in the output of info indicates the hierarchy of the objects; the curve "belongs to" the plot, which itself belongs to a frame. This hierarchy becomes important once you start adding multiple objects (for instance multiple plots), or when you want to delete an item (since everything that belongs to it will also be deleted). For instance, if we delete the plot then the curve will also be deleted but the frame and window will remain (the deletion can be undone to restore the plot):

chips> delete_plot()
chips> print(info())
Window [win1]
  Frame [frm1]

chips> undo()
chips> print(info())
Window [win1]
  Frame [frm1]
    Plot [plot1]   (0.15,0.15)  .. (0.90,0.90)
      Border bottom [bx1]  top [bx2]  left [by1]  right [by2]
      Curve [crv1]
      X Axis [ax1]
      Y Axis [ay1]

This hierarchy is also available in the ChIPS GUI, as shown in Figure 4.

Read in the data

First we use the read_file and copy_colvals routines from Crates to read in the data. The return value from copy_colvals is a NumPy array. We define the x array to be the time, in kiloseconds, since the first entry, and then set up the lng, lat, and alt arrays with the data from the file.

chips> cr = read_file("pos.dat")
chips> ut = copy_colvals(cr, "utime")
chips> print(ut)
[  1.20138018e+09   1.20138042e+09   1.20138060e+09 ...,   1.20152964e+09
   1.20152976e+09   1.20152988e+09]
chips> x = (ut - ut[0])/1e3
chips> lng = copy_colvals(cr, "longitude")
chips> lat = copy_colvals(cr, "latitude")
chips> alt = copy_colvals(cr, "altitude")

Create the first plot (longitude and latitude)

The first plot contains the longitude and latitude curves, and so is similar in construction to the plots above. The differences are that we explicitly create the plots, using the strip_chart command, and we use arrays, rather than a file name, with the add_curve calls.

chips> clear()
chips> strip_chart(2)
chips> add_curve(x, lat, ["id", "lat"])
chips> add_curve(x, lng, ["id", "lng", "line.color", "steelblue"])
chips> print (info())
Window [win1]
  Frame [frm1]
    Plot [plot1]   (0.15,0.52)  .. (0.90,0.90)
      Border bottom [bx1]  top [bx2]  left [by1]  right [by2]
      X Axis [ax1]
      Y Axis [ay1]
      Curve [lat]
      Curve [lng]
    Plot [plot2]   (0.15,0.15)  .. (0.90,0.52)
      Border bottom [bx1]  top [bx2]  left [by1]  right [by2]
      X Axis [ax1]
      Y Axis [ay1]

Figure 12: First plot (latitude and longitude)

[Version: full-size, PNG]

Figure 12: First plot (latitude and longitude)

The strip_chart call has created two plots arranged vertically, and set up so that the X axes of the two plots are linked together, so that changes to one are automatically reflected in the other plot (which is why the X axis on the bottom plot goes from 0 to 150 to match the data in the top plot).

The result of setting the "id" attribute in the add_curve call can be seen in the output of the info command; instead of crv1 and crv2 the curves have been labeled with meaningful identifiers. They can be used in set_curve calls as shown below:

chips> set_curve("lat", ["symbol.style", "circle"])
chips> undo()

Adding labels to the top plot

The next step is to add labels to identify the two lines. This time we use a different approach to that used in Figure 8, and place the labels in the bottom-left and top-right corners of the plot. To do this we place the labels using the "plot normalized" coordinate system, which ranges from (0,0) at the bottom-left of the plot area to (1,1) at the top-right of the plot. So, the "Latitude" label starts 5% into the plot area along the X axis and 10% along the Y axis, whereas the "Latitude" label is placed so that it ends at a position 95% along the X axis and 90% along the Y axis (the halign and valign attributes control the position of the reference position of the label along the string and the default values of 0 indicate the start of the string; for the latitude label we change this position so that it marks the end of the string). Since the labels are positioned with respect to the plot, and not the data values, they do not move when the Y axis range is changed by the limits call.

chips> add_label(0.05, 0.1, "Latitude", ["id", "lat", "coordsys", PLOT_NORM])

chips> id = ChipsId()
chips> id.coord_sys = PLOT_NORM
chips> li = ChipsLabel()
chips> print (li)
angle = None
color = None
depth = None
font = None
fontstyle = None
halign = None
id = None
size = None
stem = None
valign = None

chips> li.id = "lng"
chips> li.color = "steelblue"
chips> li.halign = 1
chips> li.valign = 1
chips> add_label(id, 0.95, 0.9, "Longitude", li)
chips> limits(Y_AXIS, -180, 180)

The first label - called "lat" - is set use to plot-normalized coordinates using the coordsys attribute.

This example has used another way of controlling the appearance of an object, in this case for the second label - called "lng"; it is closely related to the get_<object> call, since the Chips<Object> call returns the same object but this time with all the fields empty, which means it can be used when you do not have an existing object (in this case label) in the plot. We could have used the following, without the line break, but it does not fit on a single line when this document is printed out:

add_label(0.95, 0.9, "Longitude", ["id", "lng", "coordsys", PLOT_NORM, "color", "steelblue", "halign", 1, "valign", 1])

Figure 13: Adding labels in plot coordinates

[Version: full-size, PNG]

Figure 13: Adding labels in plot coordinates

The labels have been added using a plot-normalized coordinate system rather than the default data coordinate system (as used in Figure 8, for example). They could have been placed using data coordinates in this figure but it is easier to get the relative spacing correct in this example using plot coordinates (i.e. ensure that the gap from the start or end of the label is only 5% of the X axis and 10% of the Y axis).

The id attribute for each label was explicitly given, as it was with the curves, rather than use the default value. Note that the same labels can be used for different object types (here curves and labels). The output of the info command at this point is:

chips> print(info())
Window [win1]
  Frame [frm1]
    Plot [plot1]   (0.15,0.52)  .. (0.90,0.90)
      Border bottom [bx1]  top [bx2]  left [by1]  right [by2]
      X Axis [ax1]
      Y Axis [ay1]
      Curve [lat]
      Curve [lng]
      Label [lat]
      Label [lng]
    Plot [plot2]   (0.15,0.15)  .. (0.90,0.52)
      Border bottom [bx1]  top [bx2]  left [by1]  right [by2]
      X Axis [ax1]
      Y Axis [ay1]

Finishing off the first plot

We decide to change the spacing of the major and minor tick marks of the Y axis - so that a major tick mark appears every 90 degrees and that there are two minor tick marks between every major one - and add a label to the Y axis.

chips> set_yaxis(["majortick.interval", 90, "minortick.count", 2])
chips> set_plot_ylabel ("Degrees")

Figure 14: Adjusting the y-axis labels

[Version: full-size, PNG]

Figure 14: Adjusting the y-axis labels

The spacing of the major and minor tick marks along the Y axis have been changed to 90 and 30 degrees respectively.

Adding a curve to the second plot

The info output shows that the second plot is called plot2, so we can use the current_plot command to change to this plot. This means that any new objects that are created (and that belong to a plot, such as a curve) will appear in the second plot rather than the first one.

chips> print(info_current())
Window [win1]
  Frame [frm1]
    Plot [plot1]
      X Axis [ax1]
      Y Axis [ay1]
      Curve [lng]
      Label [lng]
    Coord Sys [Data]
    Coord Sys ID [ds2.2.2.12]

chips> current_plot("plot2")
chips> print (info_current())
Window [win1]
  Frame [frm1]
    Plot [plot2]
      X Axis [ax1]
      Y Axis [ay1]
    Coord Sys [Data]
    Coord Sys ID [ds2.2.3.13]

chips> add_curve(x, alt, ["id", "alt"])
chips> log_scale(Y_AXIS)
chips> limits(Y_AXIS, 10000, 200000)

Figure 15: Adding a curve to the second plot

[Version: full-size, PNG]

Figure 15: Adding a curve to the second plot

The altitude versus time data has been added to the second plot, and the Y axis changed to a logarithmic scale using the log_scale command. Note that the limits can be changed after the axis scaling has been changed.

The output of the info_current command was included above to show how it changes when you change to a different object: in this case the "lng" curve and "lng" label were no longer current since they belong to the first plot ("plot1").

Changing the plot sizes

Now that we have added all the curves to the plots we make several final additions and adjustments before printing it out:

• Axis labels are added. Since the X-axis label includes a LaTeX command to indicate the Delta symbol, the string is written as r"\Delta Time (ks)" to avoid Python from incorrectly interpreting the \D as a control character. An alternative would have been to say "\\Delta Time (ks)".

• A label is added to the top-left corner of the plot using the PLOT_NORM coordinate system.

• The adjust_grid_yrelsize command is used to make the plots in the first row twice the size of any other rows (in this case there are only two rows).

chips> set_plot_xlabel(r"\Delta Time (ks)")
chips> set_plot_ylabel("km")
chips> add_label(0.05, 0.9, "Altitude", ["id", "alt",
                 "coordsys", PLOT_NORM, "valign", 1])
chips> adjust_grid_yrelsize (1, 2)
chips> print_window ("plot4", ["fittopage", True])
chips> print_window ("plot4.pdf", ["fittopage", True])
chips> print_window ("plot4.png")
chips> save_state("plot4.state")

Figure 16: The final plot

[Version: full-size, PNG, postscript, PDF]

Figure 16: The final plot

The final version shows the longitude and latitude values in the top plot with the altitude values in the bottom plot, where all values are drawn as a function of time.

How can I use the GUI?

Please see either the GUI section of the "Starting ChIPS" thread or ahelp chipsgui for information on using the new GUI.

How can I overwrite files?

ChIPS has a clobber preference setting which defaults to false; this means that ChIPS will not over-write a file, for example when calling print_window. This preference can be over-ridden temporarily, for instance:

chips> print_window("plot")
chips ERROR: The output file /data/work/plot.ps already exists but export.clobber is set to false
chips> print_window("plot", ["clobber", True])

or, by using set_preference, it can be changed for the whole session:

chips> set_preference("export.clobber", "true")

Note that the save_state command currently does not accept options, so you can not say save_state(file, ["clobber", True]) and will have to either manually delete any existing files or use the set_preference call to change the clobber setting.

Can I save this plot to work on at a later time?

ChIPS allows you to save the current state to a file, so that it can be read in at a later time, even on a different computer. The command save_state will create a ChIPS state file, and has been used with several of the plots in this thread, for example when creating Figure 16:

chips> save_state("plot4.state")

creates the file plot4.state which can be loaded into a ChIPS session (the same one or a different one, even on a completely different machine) by saying

chips> load_state("plot4.state")

The state file support is different in CIAO 4 to that in CIAO 3.4, in particular:

• The file contains all the data that has been plotted, so it does not need access to the original data files. This means you can send a colleague just the state file and they can also work on the plot, or you can copy the state file between desktop and laptop computers without having to also take along the data files.

• The state file records the ChIPS commands used, so you can use undo and redo after loading in the file to move through the command history (although the history buffer is not infinite, so not all commands will be able to be undone).

• The state file is stored in a binary format and so should not be opened in a text editor.

chips> make_script("myplots.py")

unix% chips myplots.py

chips> execfile("myplots.py")