1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
\section{Hints and Suggestions for Using the Interfaces}
\subsection{Tips for Using Geomview}\index{Geomview}
In order to use DsTool Tk's three dimensional viewing capabilities,
you need to have access to Geomview. For information on using Geomview,
see the documentation accompanying it. This section gives
some tips which are specific to Geomview's interaction with DsTool.
In order to use Geomview effectively with DsTool, you need to know how
DsTool interacts with Geomview. Geomview is used for two purposes in
DsTool: plotting and viewing three dimensional data, and doing animations.
For three dimensional viewing, data previously computed by DsTool
is sent to Geomview, where the user can view and manipulate the data.
For animations, the data is sent to Geomview as it is computed, so
that the animation can take place in real time.
Here are some other helpful tips:
\begin{enumerate}
%\item Geomview originally consists of three panels: the main command
% window, the Tools window, and the Camera window. The main command
% window gives a list of Targets (objects which are viewed with the
% camera), External modules which can be brought up, as well as the
% menus for options controlling aspects of viewing. The Tools window
% contains a set of commands which can be used to manipulate objects
% or change the view of objects in the Camera window. The commands
% in the Tool window manipulate the target that is highlighted in
% the main window's target list, and listed in the Target entry field
% in the Tools window. The Camera window
% is the view of the images in the target list.
\item You can scale the individual axes of a target sent to Geomview
from DsTool using the external module ``Transformer''\index{Geomview, Transformer module}.
This module allows you to scale axes individually, or in groups. This
feature comes in handy when you have data that has widely varying
scales. While DsTool automatically compensates for these cases,
Geomview does not.
% The Transformer module is part of Geomview \mbox{1.5.0},
% but only for SGI platforms. An X windows version does not exist.
%\item When rotating things, the faster you move the cursor, the faster
% Geomview will rotate the object. So be careful to move slowly if
% you want to be able to see what's going on. Also, on slower machines,
% this becomes more important, since the animation becomes choppy as it
% gets faster.
\item There are two basic types of animations\index{animation, types} that are done with Geomview.
The first type involves sending transformation matrices from DsTool to
Geomview at each time step of an integration to change the position of
the objects. The second type involves replacing the objects in Geomview with
new ones at each time step. Due to the large amounts
of data being passed from DsTool to Geomview, animations can be very slow,
even for the first type. Therefore, when doing animations, you might want to
lower the number of time steps taken or choose a faster integrator.
\item You can delete trajectories or other data objects by using the
``Delete'' function (on the edit menu), but this option will delete
only the target which is highlighted in the target menu. This target
is also listed in the Target field of the Tools window. Selecting
Delete when the target is ``World'' will delete everything.
Deleting selected targets can be useful when
for example you want to view the (un)stable manifold of a single
fixed point. Since DsTool sends the
computed stable and unstable manifolds of the fixed points
individually, you can delete the ones you aren't interested in seeing.
Alternately, you can delete the manifolds in DsTool before sending
them to Geomview.
%\item The ``L'' (for look) feature is very helpful in returning the object
% back to the center of the Camera. However, the look feature only
% refers to the target which is highlighted. That is, if you choose
% a given trajectory, you can pick it out with the look feature.
\item You can overlay plots of variables\index{overlaying plots} by using the 3-D View window
and Geomview. For example, if you want to overlay plots of x vs.~t,
y vs.~t and z vs.~t, you can do this by the following procedure:
First, send to Geomview (via the 3-D View window) the plot x vs.~t vs.~0.
Then copy the resulting Geomview target by selecting the Copy
option from the Edit menu button. Next, send to Geomview
the plot y vs.~t vs.~0. Again, copy this resulting target.
Finally, send to Geomview the plot z vs.~t vs.~0.
The resulting plot in Geomview will be the overlay of the three plots.
If you fail to copy any of the targets, they will be erased. This is
because DsTool sends trajectory objects to Geomview using the
name ``Traj.n.m'', where $n$ is the flow number, and $m$ is the
trajectory number. Since we're only using one trajectory to generate
all three plots, DsTool sends the data to the same target name each
time, writing over the previous data in that target.
% If you fail to copy any of the targets, they
% will be erased, since DsTool sends trajectories to Geomview using the
% same target name each time. Since we are using one data set,
% previous plots will be overwritten when we send the next plot.
% You won't be able to rescale things (or
% will you?) individually, but at least you can see what's going
% on.
%\item By default, you use the rotate function, but you can zoom in, and
% translate the object, and all sorts of stuff. It's pretty darn
% self-explanatory.
\end{enumerate}
\subsection{Tips for the Tcl/Tk Interface in DsTool}\index{Tcl/Tk, interface}
DsTool's interface is written in Tcl/Tk. In addition to providing
an easy-to-use graphics interface framework, Tcl/Tk
is a scripting language, and you can run DsTool entirely by entering
commands at the prompt \unix{\%DsTool}. Some other useful tips follow:
\begin{enumerate}
\item Enter the command \unix{end\_wait} if DsTool grabs the input and
does not relinquish it. Typically, during computations, DsTool
disables mouse input and returns control to the mouse when
the computation is finished. If an unexpected error occurs
in the computation,
control might not be properly restored. The command \unix{end\_wait}
typed at the DsTool command prompt should return control to
the mouse.\index{restoring mouse input}\index{mouse, restoring input from}
%\item You can change the background color of a 2-D or 1-D View window by
% the command: .twoD{\em n}.c configure -bg {\em color}
% where {\em n} is the number of the window in question (this number
% appears in the title of the window), and {\em color} is the desired
% color. You can use any color name recognized by Tcl/Tk. A complete
% list appears in the file \unix{\$DSTOOL/doc/misc/rgb.txt}. You can
% also input colors
% by hexidecimal rgb values, using \eg {\em color} == \#ff0000 (red)
\item You can modify the default window colors and fonts
in DsTool by following the instructions for
adding custom Tcl/Tk code to your own version of DsTool. See the
accompanying documentation in \unix{\$DSTOOL/my\_dstool/README}\index{customization}
for more information. The procedure essentially
involves adding one line of code, and compiling your own
version of DsTool.
\item While you can run DsTool entirely from the keyboard, it is not
recommended that you do so. Typically, a button press will call
``tcl\_to\_pm'' to update the Postmaster, then ``pm EXEC'' to
perform the computation by calling a C routine, and finally ``pm\_to\_tcl''
to update the interface. However, it may perform
other tasks as well. For example, the ``Forwards'' button on the
Continuation window checks to see if the number of active parameters
selected is the correct number before proceeding. If you insist on
running DsTool by typing from the prompt, you should use the procedures
that Tcl/Tk calls when a button is pressed, instead of calling the
Postmaster routines directly.
For example, to replicate a press of the ``Forwards'' button on the Orbits
window, instead of typing \unix{pm EXEC Flow.Forwards}, type
\unix{orbits(forwards)}.
In addition, if you change an entry in a field, you should follow it with
a call of ``tcl\_to\_pm'' to update the Postmaster. Similarly, if you
change a Postmaster entry,
you should follow it with a call of ``pm\_to\_tcl'', to update the interface.
\item One efficient way to automate long calculations is by writing Tcl
scripts\index{Tcl/Tk, scripts}. You can run scripts by entering the command
``source {\em filename}'' at the prompt. As with the previous note,
you should be careful when writing scripts to make sure that you are
computing the quantities that you wish to compute.
\end{enumerate}
|
