JAS is installed in /CSC/apps/staff/tjohnson/JAS. To run JAS all you need to do is to execute the command:
/CSC/apps/staff/tjohnson/JAS/jas
This will start JAS 2.2.1. Of course you can create a shortcut to this script in your ~/scripts directory to make it possible to start jas without remembering the whole path.
There are two versions of the Java JDK (Java Developer Kit) installed on the CSC computers, and the jas script will use whichever one is found first in your PATH. To check which version of Java you are using issue the command:
java -version
This is installed in /usr/local/bin/java, and will be in your PATH by default. This is an older but very stable and fast implementation of Java for Linux. JAS works well with JDK 1.1.8, with the exception of printing. If you want to produce high quality printed plots from JAS you must use JDK 1.3
This is installed in /opt/IBMJava2-13/bin/java. This is a newer version of Java but it is slightly less mature and still has a few problems. The most important problem as far as this school is concerned is that it is incompatible with the FVWM2 window manager, which is the default window manager on the CSC computers. If you wish to use JDK 1.3 and you are using the default window manager, you must log off and select either gnome or KDE as your window manager. If you do not do this you will see a number of very strange effects when running JAS, such as blank or semi-blank windows, popup menus with window manager decorations, etc.
The official tutorial for the CSC, described below, shows only how to use JAS to view histograms created in Geant4. This makes sense since the OO Design and Implementation course covers Geant4 and JAS, however this tutorial shows only a very small fraction of the capabilities of JAS itself, and only involves writing C++ code, not Java code. If you are interested and have time I would encourage you to look at the tutorial built into JAS itself. I will be happy to help you with both this official tutorial and any other questions you may have about using JAS or Java.
This tutorial shows how to use JAS to control Geant4, and to view histograms created by a Geant4 job. Before starting this tutorial you must have succeeded in starting JAS and you must have succeeded in building and running Geant4 according to the Geant4 tutorial.
For this will tutorial we will use a simple prototype of a mechanism for creating JAS histograms from C++ and for controlling a Geant4 job from JAS. The code for the Geant4-JAS interface is stored in:
/CSC/apps/staff/tjohnson/JASG4
To set up your environment to run this tutorial, you will need to execute the one of the following commands (depending if you are using bash (the default) or csh).
source /CSC/apps/staff/tjohnson/JASG4/setup.sh
or
source /CSC/apps/staff/tjohnson/JASG4/setup.csh
This sets a few environment variables required for compiling and linking to the JASG4 and Java libraries.
Before starting on the real tutorial, try running the following very simple program which will illustrate the (currently very trivial) C++ interface to JAS histograms, and make sure that everything is working as expected.
SHORTCUT 1!!! Instead of compiling and linking this program yourself, you can just run the program by typing: /CSC/apps/staff/tjohnson/JASG4/test Then skip to End ShortCut 1 |
#include <jni.h>
#include <string.h>
#include <stdlib.h>
#include "JHistogram1D.hh"
#include "JHistogramFactory.hh"
int main(int argc, char** argv)
{
JHistogramFactory factory;
JHistogram1D* hist = factory.create1DHistogram("test");
for (int i=0; i<1000; i++)
{
hist->fill(i);
}
return 0;
}
This test program simply creates a JHistogramFactory object, and uses it to create a one dimensional histogram, which is then filled with very boring data. The default constructor of JHistogramFactory causes it to wait for a connection from JAS rather than exiting at the end of the main routine.
Use cut and paste to paste the code above into your editor and save it in a file test.cc
Compile this routine and link it with the following command:
gcc
-I${JDK}/include/linux -I${JDK}/include -I${JASG4} test.cc
-L${JASG4} -L${JDK}/jre/bin/classic -lJASG4 -ljvm
This command is rather long but it simply compiles and links the test program with the JASG4 and Java libraries.
End ShortCut 1 |
Running the program should produce output similar to this:
Installed RMIWebServer at http://137.138.191.203:1058/ Created RMI registry Server bound in RMI registry as /JDSServer Monitor bound in RMI registry as /JDSServer/Monitor
This indicates that the program is waiting for an RMI connection from JAS. (RMI stands for Remote Method Invocation - and is the OO network protocol supported by Java. It is similar to (and interoperable with) CORBA).
Now start JAS, and use the "Reconnect" item in the "File" menu to connect to your program. Assuming your are running JAS on the same machine as your program, you can just type localhost as the name of the machine to connect to.
In the next screen choose your job from the list (it will probably by the only entry)
Once you have connected you should be able to see an icon corresponding to your histogram in the tree on the left hand side of the JAS window (you may have to double click on items higher in the tree to find your histogram icon). Double clicking on the histogram icon (or right clicking and choosing Show from the popup menu) should display your (rather uninteresting) histogram in the window on the right hand side. You can do things such as re-bin the histogram (using the slider in the toolbar below the menu), change the axis limits, title, etc., since you have a live two-way connection to the histogram stored in your running test program.
If this worked OK you can disconnect from your program (use the File, Disconnect menu item) and then kill your test program using CTRL+C and proceed to the next part of the tutorial.
Before starting this part of the exercise you must have a working version of Geant4. If you completed yesterdays exercises feel free to use your own version, otherwise you can use the solution from yesterdays examples, by issuing the following commands:
cp -r /CSC2/apps/staff/gcosmo/work $HOME cd $HOME/work/CSC gmake rehash
Now you should be able to modify the Geant 4 job example you previously created to use the JASG4 interface. There are several steps involved, each of which is described in more detail below.
Simply issue the following commands to copy the predefined G4UIJAS class into your Geant4 source tree.
cp $JASG4/G4UIJAS.cc src cp $JASG4/G4UIJAS.hh include
The G4UIJAS class defines a Geant4 SessionManager, which allows Geant4 to be controlled by JAS.
|
SHORTCUT 2!!! Instead of typing all the modifications in steps 2-7 yourself, there is a solG4JAS subdirectory in the /CSC2/apps/staff/gcosmo/work directory that contains the files you need to modify. You can copy these across to replace the files in your work directory. |
You will need to create your JHistogramFactory object, as in the test case above. You will need to create it above where you create you EventAction class, since you will need to pass a pointer to the JHistogramFactory to your EventAction class.
You will of course also need to modify the constructor of your EventAction class to accept the pointer.
Your EventAction routine now gets passed a pointer to the JHistogramFactory, so you can use that to create new histograms. Use the create1DHistogram method as in the test program above. Since you will need the pointers to your histograms in other methods of your EventAction class you will need to store them in member variables of the EventAction class. Sensible things to histogram would include the number of hits in each tracking chamber, and the energy deposited in the calorimeter.
In the EndOfEventAction method of your EventAction class, fill the histograms you created in Step 3, using the fill method of JHistogram1D.
In order for JAS to be able to control Geant4, you must use the G4UIJAS session manager instead of the normal G4UIterminal. To do this replace the old session manager in your main routine with the G4UIJAS session manager. You must pass a pointer to the JHistogramFactory you created earlier to the G4UIJAS constructor. A possible example of how to do this is:
//G4UIterminal session manager no longer used //G4UIsession* session = new G4UIterminal(new G4UItcsh); // Create a G4UIJAS session -- this allows JAS to control G4 G4UIsession* session = new G4UIJAS(&factory); session->SessionStart(); delete session;
You are nearly done, the last thing to do is to compile and link your modified programs. Add the following lines to your makefile, before the line that includes binmake.gmk
CPPFLAGS += -I$(JASG4) -I$(JDK)/include -I$(JDK)/include/linux EXTRALIBS += -L$(JASG4) -lJASG4 -L$(JDK)/jre/bin/classic -ljvm
As with the command to build the test program this simply tells Geant4 where to find the JASG4 and Java libraries and include files.
End ShortCut 2 |
Once you have successfully linked your program you are ready to proceed to....
Once you have succeeded in compiling and linking your modified example program, you should run the executable with no arguments (i.e. no .mac file). After initialization you should see a message:
G4UIJAS -------- Waiting for commands from JAS
This indicates the G4 is waiting for you to connect to it with JAS and send it commands. Start JAS and use the "File, Reconnect" menu to connect to your job (as you did with the Test program).
After you have connected, choose the "Job, Load Plugin" from the menu to bring up the load plugin dialog, type in JASG4Plugin and press "OK".
This will dynamically load the client code for controlling G4 into JAS. (If your JAS client was running on a different computer from G4, or if your jas command was issued from a command prompt where your had not set the CLASSPATH to point to the JASG4 directory, then the code will be transparently sent across the network connection from the G4 job to the jas client).
Now you should see a new item in the JAS menu bar, labeled Geant 4. There are several items in this menu:
Start your G4 job running by choosing the "Beam On" command. Now look at the tree on the left hand side of your JAS client (labeled G4Job). By drilling down in here you should find your histograms, and by double clicking on the Histograms you should be able to see the results. If you view histograms while G4 is running you should be able to see the histograms updating in real time.
If all went well you should get a display something like this:
The JASG4 interface described here is just a prototype at present, although as you have hopefully discovered, it is possible to use it even now. The plan is to provide full access to JAS histograms from C++ code via an interface called AIDA. (The AIDA interface is designed to allow programs to talk to several different histogram implementations without any need to change the user code). In addition we hope to be able to improve the functionality of the JAS/G4 interface so that it provides full access to the Geant4 command line interface. It will hopefully also be possible in future to view Geant4 events from JAS and to use the Java editor/compiler built into JAS to dynamically create histograms without having to modify/recompile/link Geant4.
Tony Johnson - Last modified: Saturday, September 23, 2000