Plotting Packages for Fortran

Inspecting TSI Graphics and SuperPlot

By Jörg Langowski, MacTech Magazine Regular Contributing Author

Sorry to say for you C++ and Forth lovers, my desk recently gets swamped with goodies from both main players in the Macintosh Fortran game. Absoft has just sent a big parcel with version 3.2 of MacFortran II. Now, the deadline is again approaching in giant leaps, and I have no time to review it for this column; but I promise you a detailed overview in the next one. Here I’ll only mention that Absoft Fortran’s Macintosh run time environment - one of the main shortcomings of previous versions - has finally been improved. Apple Events are supported, as is publish/subscribe, you can use multiple windows, change fonts, change menus, etc. Just from looking at the manual it seems that they offer as many possibilities as LS Fortran, if not more. First tests with the Linpack benchmark indicate that the speed it still about the same (on my old MacII), which means the usual 20-30% faster than LS Fortran (I guess the compiler that makes my MacII turn as fast as a Cray still has to be invented). So stay tuned for a review.

TSI Graphics

Unless you are content with interfacing your Fortran output to a spreadsheet (you saw in the last column how that goes), you might have struggled with writing your own code for graphing the results of a Fortran program. If you have done that, you know how much time you can waste reinventing the wheel. Because there are good plotting libraries around, and one of them is TSI Graphics (Techno-Sciences Inc., 10001 Derekwood Lane, Suite 204, Lanham, MD 20706; phone (301) 577-6000). Language Systems is promoting this package, which works with their Fortran and contains some very powerful tools.

TSI Graphics does several things that are quite tedious to implement if you do it on your own. First of all, it creates one or several - automatically updated - graphics windows. Each window can contain several plot regions in which to display your data. The beautiful thing is that plots created using the TSI plotting routines are automatically adjusted to fit into the active plot area, so you don’t have to worry about setting the length of an axis, the rectangle of a frame, etc. If you have written code that plots correctly in a certain region, the plot will still have the same aspect when you resize the plot area.

The types of plots that are possible are line, bar, pie, X-Y, contour, and 3D mesh surface plots. You can add error bars to plots, create cumulative plots from groups of data, of course use linear or logarithmic scales, set the ranges of the plot axes automatically, label the plot with text in the font, size and style you want, print the plot or save it to a file, and plot in any color (using your own color tables). In fact, you have most of the functions available that a good data graphing program will give you, including the possibility to offset slices of a pie chart to emphasize them. I found one important feature missing - you cannot draw dashed or dotted lines, or change the line thickness. For the rest of us who does not have color printers available, this would be a very important addition - the only way you can distinguish line plots on a black-and-white printer so far is by adding symbols to data points. Adding different line styles to version 2.0 is strongly suggested.

Let us now see how TSI graphics does its work. For the example program, I have chosen the contour plot and the 3D mesh plot, both things you wouldn’t wish you had to write your own code for. We create a 2-dimensional data array and display it both ways in one window, using two different plot areas. The function we plot is

z = 10.0 * exp (-r/5.) * sin(r/2.) *  cos(2.*atan2(x,y))

where r is the distance from the origin x=0, y=0. The output of the program (see listing) is shown in Figure 1.

Fig. 1: Output of the plot program

How is TSI Graphics used? The example shows that you first call a setup routine, InitGraphicsPackage(), set the size of the output window, and then, after creating the data, call the actual plotting routine DrawInNewWindow. This last routine takes one parameter, a pointer to a subroutine that does the drawing. All this happens in the main Fortran program; as you know if you are familiar with the LS Fortran environment, the main program is often used only for setup purposes. After the main program has exited, the run time environment lets you call subroutines to do the actual work by connecting them to menu items. TSI Graphics works closely connected to this LS Fortran run time environment and hooks itself into the main event loop (at least I think so, I haven’t analyzed the code), so that update events to the graphics window are intercepted and the drawing subroutine is called, even after the main program has exited.

This gives you the advantage that you can easily write very modular code. You define your graphics window(s) with the associated drawing routines and your menus with the routines that do the calculation in the main program, and then exit to the run time environment. Then you can initiate your calculations from the menus, change the data that is to be plotted, and have the graphics window automatically update itself (assuming you have written the plotting subroutine so that it takes into account the changed data correctly). Even if you resize the graphics window, all plot areas will be recalculated to fit into the new window.

Look at the example again: all drawing is done through the routine CreatePlot, which receives its parameters through a common block (you can’t pass subroutines with parameters as arguments to other subroutines in Fortran). The first part of the drawing routine creates the 3D mesh plot. Two plotting areas are defined in the window: the two calls to SetPercentPlotRegion define the left and right halves of the window as plotting areas 1 and 2. The coordinates of the areas are given in percent of the total window height and width. We then set the plotting area to 1 (the left half), and inset the plot by 10% from each side of the area (the call to SetPlotRatio). The rectangle to be displayed in the mesh plot goes from -10 to +10 in both x and y directions (the call to Set3DViewingRect), and we look at this rectangle from a certain point in space (the call to Set3DEyePosition). After these setup calls, we are ready to call MeshPlot, which gives us the complicated plot that you see in the left half of the figure, and label it with some text.

The contour plot is then created by the second half of the program. We set the new plotting area, define the x and y scaling (both from -15 to 15), and draw axes on all four sides of the plot. Then we call ContourPlot and are done! You see the result in the right half of the figure. Quite impressive, and I challenge you to write such a routine yourself, you’ll spend a lot of time on it.

SuperPlot

Another philosophy for displaying data is followed by a plotting package that is compatible with both Language Systems and Absoft Fortran: SuperPlot. It is available through SuperSoft, 498 E Robin Rd., Orem, UT 84057, (801) 225-4356. SuperPlot is at an intermediate position between choosing a separate graphing program like Excel for displaying the Fortran data, and an integrated plotting library like TSI Graphics. When you link the SuperPlot routines into your Fortran application, the program behaves as if you had a complete 2D plotting application embedded within your program. When you invoke SuperPlot it replaces the application’s menu bar with one of its own and, once the plot has been drawn, it allows you to edit, save or print the graph, change the axis scaling, line size and styles, add arrows or text, etc. You have to select “Quit to application” from SuperPlot’s menu bar to return control to the FORTRAN program. Multiple calls to SuperPlot can be made from a single program and up to 10 sets of data may be overlaid on the same graph.

In my opinion, SuperPlot is not so much for writing Fortran programs for general distribution (except if you write a general-purpose graphing program, in which case SuperPlot has already done most of the job), but for the research/engineering type user who has to display data from a program and wants to do so without having to save the data first, open a graphics program, read the data in, create the graph etc. If you write a program in which a graphics window is an integral part of the application and the graphics output needs to be updated without user intervention, you need TSI Graphics. Also, the contour and 3D mesh plot options are very powerful and not available in SuperPlot. On the other hand, for creating nicely-looking black and white graphs, SuperPlot is much superior (of course it can do color, too), allowing you to do dashed lines of varying thickness and easily change the plot style without having to recompile the Fortran program.

Next month - a review of Absoft Fortran (as promised), and more.

Example: Window with double plot area, containing a contour and a 3D mesh 
plot

      Program JLDemo
      External CreatePlot
      INTEGER maxContourX, maxContourY
      REAL XYZdata(31,31)
      integer contourColors(128)
      Common /theData/ XYZdata, contourcolors 

!Initialize TSI Graphics
      Call InitGraphicsPackage()

!Create data and load into XYZdata array
      CALL createData(XYZdata)

!Change Output window 
   Call SetOutputGraphWindowSize (20,20,600,300)
   
!Create a graphics window and hook up our subroutine
      Call DrawInNewWindow(CreatePlot)

!Move the FORTRAN text window off-screen
      Call MoveOutWindow(10,800,200,900)

!Exit and let the FORTRAN menus take over
      End
   
   
      Subroutine CreatePlot
   include 'tsiconstants.fi'
      INTEGER i
      REAL XYZdata(31,31)
      integer contourColors(128)
      Common /theData/ XYZdata, contourcolors 

!Set the contour colors
      DO i = 1, 128
        contourColors(i) = mod(i, 7)
      END DO


!Define two plot windows for the contour plot 
!and the 3D plot
      CALL SetPercentPlotRegion(1, 0.02,0.05, 0.48,0.95)
      CALL SetPercentPlotRegion(2, 0.52,0.05, 0.97,0.95)

!3D mesh plot
      CALL ChangePlotRegion(1)
      CALL SetPlotRatio(1, 0.1, 0.1, 0.1, 0.1)

!Set the size of the viewing rectangle
      Call Set3DViewingRect(-10.0,-10.0,10.0,10.0)

!Set the view point location
      Call Set3DEyePosition(15.0, 7.5, -10.0)

!Create the plot using a blue outline and yellow fill
      Call SetColor(blue)
      Call MeshPlot(XYZdata, 31, 31, -15., -15., 
 1.0, 1.0, yellow)

!  Switch to black and label the mesh using 
!18pt Palatino Bold-Italic
      Call SetColor(black)
      Call SetTextStyle('Palatino', 1+2, 0, 12)
      Call LabelGraph(500.0, 900.0, 
 'exp(r/5)sin(r/2)cos(2*phi)', 1, 0)

!Select region for the contour plot
      CALL ChangePlotRegion(2)
      CALL SetPlotRatio(2, 0.1, 0.1, 0.1, 0.1)

!Set plotting range scale 
      CALL SetXYPlottingRange( -15.0, -15.0, 15.0, 15.0)

!Change to black and draw axes
      CALL SetColor(black)

!Manually draw and label the lower pair of axes
      CALL SetXYIntercepts(-15.0,-15.0)
      CALL DrawYAxis(0.5,1)
      CALL LabelYAxis(10, 1)
      CALL DrawXAxis(0.5,1)
      CALL LabelXAxis(10,1)

!Manually draw and label the upper pair of axes
      CALL SetXYIntercepts(15.0,15.0)
      CALL DrawYAxis(0.5,0)
      CALL LabelYAxis(10,0)
      CALL DrawXAxis(0.5,0)
      CALL LabelXAxis(10,0)

!Border the plot area
      CALL BorderPlotRegion(black)
   
!Plot the data
      CALL ContourPlot(XYZdata,31,31,-15.0,-15.0, 
 1.0,1.0, 1.0,contourColors)

      Return
      END


      SUBROUTINE CreateData(XYZdata)
      INTEGER i,j
      REAL x,y,z,r
      REAL XYZdata(31,31)

!The subroutine for creating the data
      DO i = 1, 31
         x = REAL(i-16)
         DO j = 1, 31
             y = REAL(j-16)
  r = sqrt(x*x+y*y)
             z = 10.0 * exp (-r/5.) * sin(r/2.) *  
 cos(2.*atan2(x,y)) 
             XYZdata(i,j) = z
         END DO
      END DO
      END