MAW: MINOS Analysis Workstation

Overview

The program maw is an integration of reco_minos into paw with the access to ADAMO available to tip. Like paw, maw uses KUIP for command parsing and menu building, so most of the available commands are familiar. What is added is the ability to call routines specific to MINOS. As well as direct access to the available routines, the user can modify internal control flags via KUIP commands.

If this functionality isn't sufficient, there is also the ability to use COMIS (interpreted FORTRAN) to add code to the user hooks.

The program and support routines are built in the $RECOPATH area. Those using the $LABYRINTH will find the executable in $LABYRINTH_BIN.

Using MAW

Commands under maw are like those under paw; KUIP will help the user navigate the command tree.

A proto-typical maw session might look like the following:

* load some COMIS routines * do this before anything so we can attach comis hooks for/call my_file.f(1) * one time initialization reco_init * read a FFREAD data file read_ffr ! ! my_ffr_file.ffr * reset some of the flags setreco redigit 1 setreco smearfls 1 setreco xyuv 0 setreco faceon 0 * twiddle with the event display controls setmhpd usecol 0 * post-FFR, pre-file processing reco_hist * open a MINOS gaf file open_gaf gm_56110_1_av4.fz_gaf * process two events process 2 * draw the XYUV event display xyuv * search for event # 8 lookfor 8 * draw the face-on display faceon * skip some events skip 5 * process some more events process 2 xyuv * rewind the MINOS gaf file rewind_gaf skip 6 process 1 * close the MINOS gaf file; open another close_gaf open_gaf gm_56110_2_av4.fz_gaf process 3 xyuv * exit MAW exit

As usual comment lines originate with a '*'.

Using COMIS under MAW

Hooks are available for calling interpreted FORTRAN-like COMIS code under the control of maw.

Fortran hook calls COMIS hook

reco_init_usr reco_init_comis

reco_hist_usr reco_hist_comis

reco_notevt_usr reco_notevt_comis

reco_new_run_usr reco_new_run_comis

reco_event_usr reco_event_comis

reco_end_run_usr reco_end_run_comis

reco_finish_usr reco_finish_comis

mhpd_faceon_user mhpd_faceon_comis

mhpd_xyuv_user mhpd_xyuv_comis

Fortran hook	calls	COMIS hook
`reco_init_usr`		`reco_init_comis`
`reco_hist_usr`		`reco_hist_comis`
`reco_notevt_usr`		`reco_notevt_comis`
`reco_new_run_usr`		`reco_new_run_comis`
`reco_event_usr`		`reco_event_comis`
`reco_end_run_usr`		`reco_end_run_comis`
`reco_finish_usr`		`reco_finish_comis`

`mhpd_faceon_user`		`mhpd_faceon_comis`
`mhpd_xyuv_user`		`mhpd_xyuv_comis`

COMIS routines look like FORTRAN with a few minor exceptions. The only critical issues are the access to common blocks and external functions/subroutines.

Unless you are very careful about filename case, I suggest that all your COMIS routines uses lowercase (including the extension ".f"). By default, on Unix machines, KUIP will convert filenames to lowercase. You can toggle this using the KUIP command filecase KEEP, but be careful.

COMIS source files are pseudo-compiled by using the KUIP command

    RECO> for/call my_file.f(args)

This loads all the subroutines and functions given in the file my_file.f, but attempts to actually call only the routine named by the file (without the suffix). This provides a convenient means of loading several routines but calling none. If the file my_file.f looks like:

subroutine my_file(iarg1) implicit none integer iarg1 integer isaved1 common /mycom/ isaved1 print *,' loading the routines in my_file ',iarg1 isaved1 = iarg1 return end subroutine reco_event_comis implicit none integer isaved1 common /mycom/ isaved1 include '$LABYRINTH_INC/FLSDigit.inc' include '$LABYRINTH_INC/partap.inc' integer k,indx_corrsum real maxpe, sumpe if (isaved1.eq.1 .or. isaved1.eq.2) then maxpe = 0.0 do k = 1, COUTAB(FLSDigit) call FETTAB(FLSDigit,ID,k) if (isaved1.eq.1) then sumpe = FLSDigit_RawA + FLSDigit_RawB else sumpe = FLSDigit_CorrSum endif maxpe = max(maxpe,sumpe) enddo if (isaved1.eq.1) then print *,' max(RawSum) ',maxpe else print *,' max(CorrSum) ',maxpe endif elseif (isaved1.eq.3) then indx_corrsum = GETIND(FLSDigit,'CorrSum') call FETTAB(FLSDigit,indx_corrsum,COUTAB(FLSDigit)) print *,' max(CorrSum) ',FLSDigit_CorrSum else print *,'RECO_EVENT_COMIS: isaved1 = ',isaved1 endif return end

The command for/call my_file.f(1) calls only the routine my_file (which would then store "1" in isaved1 for future use); but it loads in the hook routine that will get called as each event is processed.

As can be seen above the syntax for using include files is slightly different. There must be no "#" (bad things happen if you forget, so don't). The name of the file must also be enclosed in single quotes (') and not double quotes ("). By hacking one of the COMIS routines, I did enhance the processing of the include files so that they could be specified using Unix environment variables (eg. $LABYRINTH_INC) as part of the path.
A list of compiled/linked routines must be made available to COMIS in order for them to be called by the interpreted routines. Some of the reco_minos routines are available; $RECOPATH/mawlib/recoext_sub.F is the routine that declares them. The available CERNLIB routines can be listed using help for/call. A complete list can be generated with the following commands:
```
      RECO> COMIS
       PAW     
      CS> !show routines
        List of currently defined routines:
         .... long list follows ...
      CS> quit
      RECO>
    
```
A list of common blocks to be shared between compiled and interpreted code must be presented to COMIS. Most of the reco_minos ADAMO data structures are available, as are some of the non-ADAMO commons. $RECOPATH/mawlib/recoext_win.F makes the ADAMO window commons available; $RECOPATH/mawlib/recoext_com.F does the same for the miscellaneous other commons. A complete list can be generated with the following commands:
```
      RECO> COMIS
       PAW     
      CS> !show commons
        List of currently defined routines:
         .... long list follows ...
      CS> quit
      RECO>
    
```

Known deficiencies

The interface between TIP access to gafs and that of reco_minos is different. So a GAF file opened by the commands in the TIP command menus GAF/.. can not be accessed by commands in the RECO menu tree and vice versa.

The commonly used command set is now ambiguous. Generally, what is desired is graph/set which sets HPLOT and HIGZ parameters. Attempting to simply type set will fail; users must modify their kumac macro files to use graph/set. I know it's a pain, but it is near impossible to hack it out.

$THESEUS/Makefile not yet updated to build user versions of maw

rhatcher@fnal.gov