Tv Manual

Small help on help

Copying

Before copying this software of Tv, you must obtain an appropriate license from the authors. To get a license, fill in the attached License Agreement, sign it, and send the original and one copy to the authors at the address found in the Agreement. No fee is charged for Tv licensing by the authors.

All registered users will be informed, if there is a new release of Tv.

License Agreement

The authors (J.Theuerkauf, S.Esser, S.Krink, M.Luig, N.Nicolay, O.Stuch, H.Wolters) at the Institute of Nuclear Physics, Cologne (hereinafter referred to as IKP) grants to the user, a non-transferable and non-exclusive license to copy and use Tv under the following terms and conditions and for the period of time identified in Paragraph 9.

  1. This license agreement grants to the user the right to use Tv within their own home or organization. The user may make copies of Tv for use within their own home or organization, but may not further distribute Tv except as provided in paragraph 4.

  2. The license agreement is only effective in connection with the subsequent listed license agreements:

    "License Agreement for mfile" with the Institute of Nuclear Physics, Cologne

  3. If the use of Tv is connected to any form of publication, the authors of Tv must be cited correctly:

    J.Theuerkauf, S.Esser, S.Krink, M.Luig, N.Nicolay, O.Stuch, H.Wolters; program Tv; Institute of Nuclear Physics, Cologne.

  4. The IKP intends that Tv be widely distributed and used, but in a manner which preserves the quality and integrity of Tv. The user may send a copy of Tv to another home or organization only after either receiving permission from the IKP or after seeing written evidence that the other home or organization has signed this agreement and sent a hard copy of it to the IKP. If the user has made modifications to Tv and wants to distribute that modified copy, the user will first obtain permission from the IKP by written or electronic communication. Any user which has received such a modified copy can pass it on as received, but must receive further permission for further modifications. All modifications to copies of Tv passed on to other homes or organizations shall be clearly and conspicuously indicated in all such copies. Under no other circumstances than provided in this paragraph shall a modified copy of Tv be represented as Tv.

  5. The user will ensure that all their copies of Tv, whether modified or not, carry as the first information item the following copyright notice:

  6. In particular the authors prohibit to use a part of the code or algorithms of this software in other programs without an additionally negotiated license.

  7. Title to and ownership of Tv and its copies shall at all times remain with the IKP and those admitted by the IKP as contributors to the development of Tv. The user will return to the IKP for further distribution modifications to Tv, modifications being understood to mean changes which increase the speed, reliability and existing functionality of the software delivered to the users. The user may make for his own ownership and use enhancements to Tv which add new functionality and applications which employ Tv. Such modules may be returned to the IKP at the option of the user.

  8. Tv is licensed with no warranty of any kind. The IKP will not be responsible for the correction of any bugs or other deficiencies. In no event shall the IKP be liable for any damages of any kind, including special, indirect or consequential damages, arising out of or in connection with the use or performance of Tv.

  9. This license for Tv shall be effective from the date hereof and shall remain in force until the user discontinues use of Tv. In the event the user neglects or fails to perform or observe any obligations under this Agreement, this Agreement and the License granted hereunder shall be immediately terminated and the user shall certify to the IKP in writing that all copies of Tv in whatever form in its possession or under its control have been destroyed.

  10. Requests. Tv is provided by the IKP in a spirit of friendship and cooperation. The IKP asks that people enjoying the use of Tv cooperate in return to help further develop and distribute Tv. Specifically, the IKP would like to know which machines Tv gets used on. A brief notice form is appended to this agreement which the user is requested to send by email or otherwise. Please send in further notifications at reasonable intervals if you increase the number and type of machines on which Tv is loaded. You may send these notices to another user which is cooperating with the IKP for this purpose.

Syntax in this manual

Tv commands are formatted like the following

menu> command <argument1> [<argument2>] <argument3 ...>

menu> command {<argument4> | <arguemnt5>}

The arguments are enclosed in sharp brackets ('<>'), which you should not type in. Arguments enclosed in square brackets ('[]') are optional. Three dots

after a argument name indicate that a list of arguments of this type may follow. The vertical line ('|') in the example above means that you can specify argument4 or argument5 or both (logical 'or'). menu> is the prompt indicating that Tv is willing to accept input and the menu you reside in.

The most important commands may be abbreviated in cursor mode (See....) with one or more keys which is noted in the manual like this:

'keycode'

Main features and concepts

Flashlight

Spectrum analysis

Labels and Markers

Labels and Markers consist of an info string and a position on one axis of a spectrum.

The info string is normally generated automatically be Tv and contains the energy (calibrated or not). Labels allow the user to define an own info string.

The position may be on the x-axis (labels and vertical markers) or on the y-axis (horizontal markers).

The position of the info string on the other axis is calculated by Tv.

Labels

Labels are just graphical objects, which have no meaning to the program .

Markers

Markers are parameters to many functions of Tv.

peaksearch

cut

view

fit

normalization

recalibration

integration

Normalization

(See section window scaling function-y normalization {on|off})

Calibration

Recalibration

Integration

Buffer operations

spectrum copy

spectrum create

spectrum delete

I/O

Commands:

---------

spectrum read <filename['format]> {<buffer index ...> | all | shown | activ>}

spectrum get <filename['format] ...>

spectrum write [<filename['format]> | <wildcard>] [<buffer index ...> | [all] | shown | activ]

spectrum format {input | output} <format>

--------------------------------------------------------------------------------

The commands read and get load spectra into Tv. The difference is that read loads one spectra file into one or more buffers you have to specify, whereas get loads one or more spectrum files each into only one buffer automatically selected by Tv. <filename> may contain the special characters '*' and '?' which are interpreted as it is done by /bin/ls .

Tv performs I/O operations using mfile see section Definition of mfile. It recognizes the spectrum file format automatically, if the file has a mfile header. Otherwise Tv tries to guess the correct format.

spectrum get s.spc

tv> spectrum ./s.spc'8k.lc:2 read to #0

Tv has read the file ./s.spc to buffer #0 using the format 8k.lc:2

To force Tv to use a certain format, you have to specify it like in the above example:

spectrum get s.spc'8k.le2

You may load up to <ns> spectra into Tv. This number may be specified in the command line see section Command line options. The default value is 6.

I/O with multiple spectra

There are two ways of i/o-ing multiple spectra: First the see section Ls-file mechanism, which allows you to i/o (and other operations) spectra listed in a special file (the ls-file), and see section Multiple spectra i/o using wildcard.

Arithmetic operations

Commands:

---------

spectrum add <destination buffer index> [<filename ...> | <source buffer index ...> | all | shown | activ]

spectrum subtract <destination buffer index> [<filename ...> | <source buffer index ...> | all | shown | activ]

spectrum multiply <factor>

Note: If there is a position calibration for all spectra involved, it will be applied before the operation. If you want the spectra being added or subtracted uncalibrated you have to unload the calibration for at least one spectrum.

--------------------------------------------------------------------------------

Ls-file mechanism

A ls-file contains filenames of spectra you want to perform the following actions upon:

(Note: If there is a position calibration for all spectra involved, it will be applied before the operations 'add' and 'subtract'. If you want the spectra being added or subtracted uncalibrated you have to unload the calibration for at least one spectrum.)

A Ls-file is an ASCII file, you may generate in a unix shell with

% ls <pattern> > ls-file.

To use it in Tv it must be first opened with

spectrum ls-file open <filename>.

To access the spectra named in the ls-file, the above mentioned actions have the following options:

You may set the pointer position in the ls-file to <number> with

spectrum ls-file position <number>.

Example ------

The command

spectrum ls-file get ++

performs the formerly known VS-command mget ++ .

spectrum ls-file list {<ls filename> | + | ++ | - | -- | <line-idx>}

spectrum ls-file close

Syntax of all ls-file commands: see section spectrum ls-file

Logic operations

Commands:

---------

spectrum maximum <buffer index ...> {active | all | shown | visible}

spectrum minimum <buffer index ...> {active | all | shown | visible}

--------------------------------------------------------------------------------

These two operations combine at least 2 spectra. For each channel the maximum (minimum) value found in all specified spectra will be written to the first specified spectrum buffer. This gives you a kind of logical operation: spectrum maximum corresponds to a logical OR, spectrum minimum to a logical AND.

All spectra must have the same resolution (Change with see section spectrum resolution).

Misc

spectrum activate <n>

spectrum analysator

see Measurement supervising::

spectrum status

spectrum resolution

Display

Window types

Tv uses the X11 graphic widget GOW (SEE...) to display spectra. There are several types of windows suited for special purposes. First there is the basic window type simple (see section window create simple) similar to the VS window. All graphical Tv features are available in this window type.

The remaining window types are composed of two or more subwindows. The window type fit (see section window create fit) provides besides the normal spectra subwindow a second subwindow containing the residuum of the fit. The window type cut (see section window create cut) shows in a small subwindow the position of the cut marker in a total view of the projection.

The [x,y]paned type windows are composed of one or more simple type windows (panes). Each single pane may contain an arbitrary amount of spectra. All panes share a common status line (see section window create). This window type provides a y-scale per pane and a total of 2 x-scales. In a (simple) paned type window the x-scales are independend. The upper scale belongs to the first spectrum shown and the lower to the last. So with more than two panes, you have to live with some spectra without scale. In a xpaned or ypaned type window, the x-scales are coupled to all spectra shown. So if you set x-view marker in one pane and expand (see below), the spectra in all paned will be displayed using the same x section. In a ypaned type window even all y-scales are coupled.

The mouse

The mouse is used to change the visible section of the spectrum. Therefor you set so called viewport marker with mouse clicks.

With the cursor in the actual graphic part of the window bordered by the scales (cross hair cursor) the left mouse button (button #1) sets a markerand the right button (button #3) expands the region between that mark and the current cursor position.

The mid button (button #2) works slightly different: The marker set by the left button divides the window in two parts and pressing the mid button expands that part the cursor is in. You may set a vertical marker (single click button #1), a horizontal marker (double click button #1) or a corner marker (triple click button #1 (check it out ...it's possible !!!!)). A corner marker is a combination of a vertical and a horizontal marker and defines a corner of a rectangle. Leaving the window cancels all viewport marker already set.

With the cursor on the scales (gumby cursor) the left mouse button shifts the displayed spectra to the left and the right button to the right.

The configuration of the mouse buttons is defined in the file Xtv (See section Configuration files).

The x- and y-position of the cursor is displayed in the status bar of the window the cursor is in. If a calibration is loaded, the x-position is displayed both calibrated and uncalibrated (in parenthesis)).

Plot

Commands:

---------

window create <window type> plot [<optional arguments>]

window plot format <format> <format arguments...>

window plot create <output file format>

--------------------------------------------------------------------------------

im wesentlichen hardcopy

unix-plot

xfig

postscript

Fit and integration

The quantitative analysis of spectra is interested in position, volume, or shape of the observed lines. It must comprise a proper description of the background. Since the background has a more global structure whereas the lines in a gamma spectrum are local structures the former can be usually approximated by a polynom, e.g. a straight line. In contrast, particle spectra contain very broad lines. Therefore it is neccessary to use a more physical description of the background which is provided by an exponential term beside the polynom (see section Fit function background definition). This background function may be useful in the upper part of a Ge-Detector spectrum too since the exponential term reproduces approximately the detector efficiency.

For the further analysis of the lines three methods are available:

Available background- and peakfunctions are:

The results of peaksearch and fit for each spectrum are merged into the peaklist (see section fit peaklist). Here all fitted peaks are displayed whereas peaks found by the peaksearch are only shown when they are not situated in any fitted region.

Integration

The main advantage of integration is that no hypothesis on the line shape is neccessary. Tv calculates volume, center of mass, width (corrected by a factor 2*sqrt(2*ln(2)) to obtain the FWHM), and skewness. If there exists a valid background fit tv takes this into account and calculates background corrected values too. If background regions are defined but not fitted tv determines the mean background amplitude and uses this for background correction. The integration results depend increasingly from volume to skewness on a good description of the background. Applications for the integration are gamma spectra where line shapes are not well determined, or time spectra where the assymmetry (skewness) can be used for life time analysis.

The main disadvantage of integration is that only well separated lines can be evaluated in this way. Otherwise it is neccessary to make asumptions on the line shape and to use a fit for decomposition of the overlapping lines. Furthermore it is connected with some effort to integrate a larger number of lines.

Peaksearch

To obtain easily a survey of the lines in a spectrum tv supplies an automatic peaksearch. As fit function a simple gaussian with a constant background is used, where the width of the gaussian must be determined by a width calibration. A simple algorithm fits the two amplitudes of gaussian and background at each channel. Then the probability integral is evaluated if it exceeds a given limit (default 99.99 %). In this case the position is iterated to a precision of 1/10 channel and the peak is added to a list. A typical application for the peak search was the analysis of gate spectra created from a matrix. Meanwhile the high peak density even in these spectra normally leads to huge numbers of multipletts. Therefore each result must be checked if it is a multiplett in which case a decomposition by a fit must be done. Since the fit function of the peak search is only a crude approximation and facing the effort of the result checking it is recommendable to invest this effort directly in an analysis of the spectrum by fitting.

The peaksearch takes place in the region defined by the peaksearch markers or these are not set in the whole spectrum.

Decomposition by a fit

For the decomposition of multipletts or the determination of line shape parameters only a fit can be used. For these goals an adequate description of the observed line shapes is neccessary. Otherwise it is impossible to find the correct number of overlapping lines respectivly to obtain a good description of the spectrum. tv uses currently a modified gaussian with left tail, right tail, and an underlying step. Parameters are position, volume, and width (FWHM) of the gaussian, a left and a right tail parameter, and finally width and height of the step (see section Fit function peak definition). These 6 parameters are associated with each fitted peak. To reduce the number of parameters it is possible to use calibrations for single parameters or to correlate them, e.g. equal left tails. Step and tail parameters sometimes can be dropped. The background parameters can be fitted simultaneously with the peaks or can be fixed in advance by a fit in separate background regions.

A critical decision is the choice of the optimization procedure for the parameters. It is assumed that the optimal fit function gives the expectation value for the contents of each fitted channel. Since the measured contents follow some probability distribution for each channel the probability of the measured value with respect to the expected function value is known. For a certain set of parameters a total probability can be calculated as product of these channel probabilities. The optimal set of parameter is assumed to be most likely. It can be obtained by searching the maximum of this probability product in dependence of the free parameters (maximum likelihood).

Normally a Gaussian distribution is assumed for the channel contents. In this case maximum likelihood is equivalent to the commonly used chi-square minimization (pxref{Fit measure definition dy-chi-square}). Unfortunately this is not applicable if the expectation values for the contents of single channels are of the order of 1. In this case the contents follow only a Poisson distribution. The resulting problem is evident since apparently the fit function systematically underestimates the contents of the spectrum. This depends not on the integral of the fitted data but only on the amplitudes, i.e. it does not matter how large the fitted region is.

To overcome this defect in tv beside the chi-square minimization furthermore the maximization of a Poisson distribution is implemented (pxref{Fit measure definition poisson}). Which leads always to correct results as long as it deals with simply incremented or added spectra. For subtraction or normalization the variance of Poisson distributed data is no longer well defined. Therefore in subtracted or normalized spectra this optimization method is not applicable. In contrast the for Gaussian distributed data these operations are possible.

Summarizing, the advantage of maximizing the Poisson distribution is the validity of the results even for low statistics, the advantage of the chi-square minimization lies in the applicability to spectra which have been subject to more complex modifications. But at least none of both gives correct results if one for example subtracts low statistics gate spectra.

Fit function background definition

There are two alternative functions to approximate the background:

The background in a gamma spectrum has a more global structure in comparison to the lines. It usually can be described by a polynom, e.g. a straight line. Since particle spectra contain very broad lines a polynomial approximation of the background is not sufficient. A more physical description of the background is provided by an exponential term beside the polynom. This extended background function may be useful in the upper part of a Ge-Detector spectrum too where the exponential term reproduces approximately the detector efficiency.

Fit function background definition polynom

  BG(x)= SUM(n=0..degree, Bn * (x-x0)**n)

      Bn  :  background coefficient (parameter)

      x0  :  offset for numerical optimization during fit


Fit function background definition exponential


  BG(x)= SUM(n=0..degree, Bn * (x-x0)**n) + FAC * exp(-(x-x0) * EXP

      Bn  :  background coefficient (parameter)

      x0  :  offset for numerical optimization during fit

      FAC :  factor of exponential term

      EXP :  scaling of exponential term

Fit function peak definition

There are two alternative parametrizations for the peaks:

Both have proven to yield comparable results. The latter reduces the correlation between step and tails since the erf step approximates the asymptotic value quite fast in comparison with the arctan. Furthermore the step width of the erf can be fixed to 1.0 (in units of sigma) which reduces the number of parameters by one. Finally the latter function is analytically integrable whereas the integration of the former has to be done numerical.

In both functions the volume but not the amplitude of the peaks is fitted. The volume is the parameter of interest normally and in this way it is not neccessary to integrate the resulting function and to estimate the error bars of the obtained volume.

Fit function definition continuous-exp-tail/arctan-step

  F(x) =  BG(x) + SUM(i=0..peaknumber, PEAKi(x))

    BG(x)   : background function (see section Fit function background definition)

peak function of i-th peak

  PEAKi(x)= Vi / NORMi * (GAUSMi(x-Pi) + STEPi(x-Pi))

      Pi    :  position of i-th peak (parameter)

      Vi    :  volume of i-th peak (parameter)

      NORMi :  numeric INTEGRAL(GAUSMi)

modified gauss function of i-th peak

                / exp(SLi / Si**2 * (dx + SLi/2)  for dx<SLi
  GAUSMi(dx)=  < exp(-dx**2 / (2 * Si**2))          for SLi<dx<SRi
                \ exp(-SRi / Si**2 * (dx - SRi/2) for SRi<dx

    dx    :  x - Pi

    Si    :  sigma of gaussian part of i-th peak (parameter)

    SLi   :  TLi * Si**ELi

    SRi   :  TRi * Si**ERi

    TLi   :  left tail of i-th peak (parameter)

    TRi   :  right tail of i-th peak (parameter)

    ELi   :  exponent of sigma-weight of TLi [0..2]

    ERi   :  exponent of sigma-weight of TRi [0..2]

step function of i-th peak

  STEPi(dx)= SHi * (pi/2 + arctan(SWi * dx / (Si * sqrt(2))))

    SHi   :  step height of i-th peak (parameter)

    SWi   :  step width of i-th peak (parameter)


Fit function definition additive-tail/erf-step

  F(x) =  BG(x) + SUM(i=0..peaknumber, PEAKi(x))

  BG(x)   : background function (see section Fit function background definition)

peak function of i-th peak

  PEAKi(x)= Vi / NORMi

            * (  (1 + TAILi(x-Pi)) * GAUSSi(x-Pi)))

               + STEPi(x-Pi)))  )

    Pi    :  position of i-th peak (parameter)

    Vi    :  volume of i-th peak (parameter)

    NORMi :  Si * (SQRT(2 * PI) + TLi + TRi)



gauss function of i-th peak

  GAUSSi(dx)= exp(-dx**2 / (2 * Si**2))

    Si    :  sigma of gaussian part of i-th peak (parameter)



additional tail factor of i-th peak

              / TLi * (|dx| / Si)**ELi / (FACFAC(ELi)  for dx<0
  TAILi(dx)= <
              \ TRi * (|dx| / Si)**ERi / (FACFAC(ERi)  for dx>=0

    TLi   :  left tail of i-th peak (parameter)

    TRi   :  right tail of i-th peak (parameter)

    ELi   :  exponent of left tail [2..16]

    ERi   :  exponent of right tail [2..16]

for simplification of integral

              / (n-1)!!                 for n= 3,5,7,...
  FACFAC(n)= <
              \ (n-1)!! * sqrt(pi / 2)  for n= 2,4,6,...


step function of i-th peak

  STEPi(dx)= 1/2 * SHi * (1 - erf(dx / (SWi * Si * sqrt(2))))

    SHi   :  step height of i-th peak (parameter)

    SWi   :  step width of i-th peak (parameter)

Fitting

It is nearly the same as in VS ...

b: set backgroundmarker

B: fit background

r: set regionmarker

p: set peakmarker

F: fit region

Peaksearching

Matrix analysis

Setup

Attachments

To cut a matrix you need at least a matrix, a set of markers and a spectrum buffer, where to put the cut spectrum.

In Tv you can handle an arbitrary number of matrices, projections, spectra and cuts (sets of markers). Therefore you have per default <ns> = 6 buffers (for changing See section Command line options) for storing matrices, spectra, cuts and directories. Their names are composed of the first character of the buffer type and the buffer number (e.g. the cut buffers are named c0,...,c5). A cut consists of gates and the attached matrix (m<n>), a directory buffer (d<n>) and a spectra buffer (s<n>). Each matrix has a spectrum buffer associated, which contains the projection and where the gates are normally set.

If you create a cut (see section cut create) the associated gates will be applied to the attached matrix and the cut spectrum will be written to the attached spectrum buffer. If you save a cut the cut spectrum will be written into the attached directory. So in the main the directory buffer is just an abbreviation of the cut path name, but it has some additional features. (see section cut directory)

The default attachments are:

Changing the attachments

All changes are for the active cut, so you have to set it first.

cut activate <n>

(Many commands in the cut menu refer to the activated cut, which always exists but might be the wrong one)

You may change the associations with the command

cut attach [matrix <n>] [spectra <n>] [directory <n>]

The projection attached to a matrix may be changed

cut matrix attach-projection <m> <s>

where <m> is the matrix number and <s> is the spectrum buffer, which should contain the projection.

Filling the attachments with sense

Up to now you have only connections between rather abstract buffers of any kind. Finally you have

to open a matrix with

cut matrix open <pathname>

load a projection spectrum <filename> in buffer <n> with

spectrum read <n> <filename>.

and define the pathname of the cut directory with

cut directory open <pathname>.

Example setup

cut activate 0

cut attach matrix 0

cut matrix attach-projection 0

cut attach spectrum 4

cut attach directory 4

cut directory open 4 /home/really/cool/cool.cutdir

cut matrix open 0 /home/really/cool/cool.mtx

spectrum read /home/really/cool/cool.pry 0

Fast setup

To shorten the above mentioned procedure, use

cut environment <pathname>.

Suppose <pathname> is /home/really/cool . In this case Tv will do the following:

cut matrix open /home/really/cool/cool.mtx

spectrum read <n> /home/really/cool/cool.pry

(where <n> is the buffer assigned to the matrix assigned to the active cut)

cut directory open /home/really/cool/cool.cutdir

You may want to note, that you have to set the substitution to ??? (see section Wildcards).

Creating cuts

To create a cut you have to define a working set of gates with

cut marker cut enter or 'c'.

The first two marker define the a positive gate, whereas the following marker pairs are interpreted as background gates.

To do the cut type

cut create or 'C'

The gates of the working set will be copied into the active cut, the cut spectrum will be saved in the attached spectrum buffer and displayed, if the spectrum buffer is mapped to a window.

You may use the same working set to create a cut in a different matrix by first activating another cut with the desired matrix associated.

To do a new cut, you have to delete the cut gates with

cut marker cut delete or '-C'.

The command

cut use <n>

will copy the cut markers cut <n> into the working set. So you can use the gates of a former cut and apply them to another matrix.

Cut I/O

Cut hotkey summary

Comparing matrices

Tv supports the comparision of currently 2 matrices by making cuts with the same cut marker in both matrices.

@cmpmat <directory 1> <directory 2>

This opens the appropriate matrices and projections located in <directory 1> and <directory 2> (see section Definition of environment). The two windows "comparison" and "projections" are created. In "projections" you may set the cut marker ('c' in cursor mode) and create cuts in both matrices ('C'). The cuts are displayed in the window "comparison", where you may switch to the desired cut spectra with the key 'n' plus buffer number(s) (See...).

window delete projections

window delete comparison

cut activate 0;

cut attach matrix 0 directory 0;

cut matrix attach-projection 0;

cut attach spectrum 4

cut activate 1;

cut attach matrix 1 directory 1;

cut matrix attach-projection 1;

cut attach spectrum 5

window create simple projections;

window setup keyboard-focus projections;

window show spectrum 0 1;

window create simple comparison;

window setup keyboard-focus comparison;

window show spectrum 4 5;

window setup keyboard-focus none;

keyalias "C" "cut activate 0; cut create cut; cut activate 1; cut create cut;";

cut activate 0;

cut environment $(1);

cut activate 1;

cut environment $(2);

Preparing a 2d-fit with Mafia

Batchjobs

Measurement supervising

contact zum analysator see spectrum analysator

spectrum analysator <hostname>

sucht filename(ohne pfad) aufm analysator

on fehler: denkta dass es n normales spectrum waer : ./filname

normalmode spectrum analysator ""

Wildcards

Wildcard concept

Tv supports a wildcard mechanism for standard filenames.

For instance if you want to analyse a matrix, the command cut env path (see section Fast setup) uses standard filenames for matrix, projection and cut directories. They may be listed with wildcard status. The table being displayed gives the rules how argument filenames (here: path) will be translated into real filenames.

Consider the following table entry:

*mtx :: !f/!t.mtx

The filename for matrices (*mtx) will be composed of the full absolute pathname of path (!f), a slash (/), path (!t) and an extension (.mtx). So if you type cut env cool while being in the directory /home/really, the matrix name will be

/home/really/cool/cool.mtx.

*fit :: !h/!t.fit

*cal :: !r.cal

*plt :: !r.xfig

*rcl :: !r.rcl

*mtx :: !f/!t.mtx

*prospc :: !f/!t.pry

*procal :: !f/!t.pry.cal

*cutdir :: !f/!t.cutdir

*cutcal :: !f/!t.cut.cal

*cutgat :: !f/!t.gate

*cutspc :: !f/!t.cut

*cutspcgat :: !f/!t.gt

*cutspcbg :: !f/!t.bg

*cutspccl :: !f/!t.cl

*cutspccr :: !f/!t.c

The ! mark is the escape symbol for the following replacement commands and the example path is /home/really/cool/cool.mtx

You may add a second step in creating the real filename using the special character "\":

While being in the directory /home/really and typing cut env cool.me.down

*mtx :: !f/!t\!r.mtx

will result in a matrix filename of /home/really/cool.me.down/cool.me.mtx. The operator on right hand of "\" takes the result of the whole expression on the left hand of "\" as in input.

To change the wildcard settings use the command wildcard enter <wildcard name> <wildcard expression>. wildcard name should contain the leading asterix (*). Be sure to encapsulate the wildcard expression in double quotes.

Multiple spectra i/o using wildcard

wildcard enter *calspc "!r.cal_spc" This defines a wildcard which may be used for writing calibrated spectra with spectrum write *calspc all

Getting started

Two windows appear on your screen from outer space. They are named tv and tv-root.

tv is composed of three subwindows: The buffer list shows the relation between the spectra you have loaded (named after their filenames) and the buffer number. You need to know the latter to act upon a spectrum. tvkeys shows the keys you have pressed in cursor mode. In the remaining subwindow all the commands you type in with the cursor in any tv window are echoed. They will be inserted at the position of the blinking cursor. When you hit CR, Tv will try to execute the whole line. Furthermore you may edit the contents of this textwindow as it is the standard Xaw-textwidget. Commands in Tv are mostly object oriented, e. g. you have to put the object you want to act upon in front of the action.

tv-root is the main graphic window. Per default all spectra you load are getting displayed in this window.

To see tv-root changing from its virgin state type spectrum get <filename> at the command prompt. If your spectra files are not located in the directory you have started Tv from, it may be convenient to either cd to this directory from within the program (type cd <pathname>). A scale and the spectrum you specified are drawn into tv-root and a message like this:

spectrum ./<filename>'<format> read to #<buffer number>

is printed in the command window.

(For more details on the file format See section Definition of mfile)

- placement

User interface

To enter a command in Tv the mouse pointer has to be in any Tv window. The keyboard input is echoed in the text window at the position of the cursor. Pressing CR will start the command line interpreter to process the whole line the cursor is in.

A command is composed of one or more words. The command structure is object-oriented, so you have to enter the object (argument) before the action.

For instance to load ("get" for historical reasons) a spectrum, type:

tv> spectrum get <filename>

The single command words may be entered all in one line finished by CR or in subsequent lines each finished by CR.

calibration

calibration copy

calibration delete

calibration enter

calibration read

calibration list

calibration write

cut

All commands in the cut menu refer to the activated cut. (see section window status), (see section cut activate)

cut activate

For you can have multiple cuts in Tv it is convenient to have one special (activated) cut, so that all commands refering to one cut take the active cut for an argument.

cut activate : Show active cut.

cut activate <n> : Activate cut #<n>

cut attach

This command is used to change the association between the available object buffers (see section Matrix analysis).

cut attach [matrix <n>] [spectra <n>] [directory <n>]

where <m>, <d> and <sb> are the buffer indices.

cut create

cut directory

cut environment

cut list

cut marker

cut marker bg-gate

cut marker cut

cut marker gate

cut matrix

cut read

cut rm

cut status

cut scale

cut use-marker

cut write

cut weight

fit

fit activate

fit background-create

fit region-create

fit integration-create

fit delete

fit function

fit marker

fit measure

fit open

fit parameter.

fit peaklist

fit print

fit psearch

fit read

fit recover-backup

fit restore

fit result-file

fit list

fit status

fit status full

fit status full [calibrated | uncalibrated]

fit status short

fit status short [calibrated | uncalibrated]

fit scale

fit store

fit use-fitdata

fit write

label

label cut

label fit

label peaklist

label user

normalization

normalization marker

normalization off

normalization scale

normalization status

normalization type

recalibration

recalibration append

recalibration create

recalibration delete

recalibration marker

recalibration list

recalibration read

recalibration type

center-of-mass

squared-distance

pair

polynom

recalibration write

spectrum

spectrum ls-file

Commands:

---------

spectrum ls-file add <dest-idx> { <filename> | + | ++ | - | -- | <line-idx> }

spectrum ls-file close

spectrum ls-file commandget <command-filename> { <filename> | + | ++ | - | -- | <line-idx> }

spectrum ls-file open <filename>

spectrum ls-file get { <ls-filename> | + | ++ | - | -- | <line-idx> }

spectrum ls-file position <number>

spectrum ls-file list {<ls filename> | + | ++ | - | -- | <line-idx>}

spectrum ls-file subtract <dest-idx> { <filename> | + | ++ | - | -- | <line-idx> }

(see section Ls-file mechanism)

--------------------------------------------------------------------------------

spectrum activate

spectrum add

spectrum analysator

spectrum analysator <host name>

Define the host (analysator) to fetch online spectra from.

spectrum copy

spectrum create

spectrum delete

spectrum enter

spectrum format

spectrum get

spectrum maximum

spectrum minimum

spectrum multiply

spectrum offset

spectrum read

spectrum resolution

spectrum status

spectrum subtract

spectrum update

spectrum write

window

window create

Create windows of the specified types. The new window will appear with a geometry defined in ??? and will contain all spectra. It may be referenced by name. At the top of each window is the status line. In the leftmost field the name of the subwindow containing the cursor is printed. This is helpful, if the window is composed of more than one subwindow. The next field in the status line has the format

s<n0> c<n1>(<n2>) d<n3> m<n4>(<n5>)

\noindent where

\noindent To change this relation see section cut attach

\noindent The last field shows the \noindent The below mentioned window types provide features suited for certain operations

window create simple

Syntax:

window create simple <name>

This is the basic graphic window type. It provides scales for x- and y-axis, a graphic cursor and an status line at the top and may contain up to MAX spectra.

window create cut

Syntax:

window create cut <name>

This window type is suited for cutting a matrix. Beside of the basic window features (see section window create simple) it supplies a resizeable projection subwindow.

window create fit

Syntax:

window create fit <name>

window create paned

window create xpaned

window create ypaned

window delete

window hide

window list

window marker

window plot

window raise

window redisplay

window scaling

window scaling function-y

window scaling modification-y

window scaling scale-x

window setup

window show

window status

window view

Miscellaneous

exit

ReadMe

This is tv version 1.1 created 1993/09/17 14:53:34 tv: program version 1.1 (c) (1992-1994), J.Theuerkauf, S.Albers, S.Esser, S.Krink, M.Luig, N.Nicolay, O.Stuch, R.Wirowski, H.Wolters, Institute of Nuclear Physics, University of Cologne. All rights reserved. Copying of this Software is authorized to users who have executed the true and proper "License Agreement for TV" with the Institute of Nuclear Physics, University of Cologne Especially the program may be used free of charge, provided that the following conditions are met:

- There is no warranty of any kind for all parts of the code.

- If the use of the program is connected to any form of publication, the authors must be cited correctly:

> J.Theuerkauf, S.Albers, S.Esser, S.Krink, M.Luig, N.Nicolay,

> O.Stuch, R.Wirowski, H.Wolters; program tv (version 1.1).

- The authors prohibit, that any unauthorized person give away or sell copies of this software. Copies are given by the authors under the following postal address: Universitaet zu Koeln, Zuelpicherstr. 77, D-50937 Koeln, Fed. Rep. of Germany; or under the email address: postmaster@ikp.uni-koeln.de.

usage: tv <options> the following options are available:

-? or -help : display this message

-shm : use shared memory spectra

-src : ignore 'site.tvrc'

-rc : ignore '.tvrc'

-v : print information on version

-s <ns> : set number of spectra buffer to <ns>

-res <mr> : set maximal spectra resolution to <mr>

-e <string> : execute command string <string>

which

which [<configuration filename>]

Tv looks for configuration files (see section Configuration files) in various directories. which without arguments displays the search path for configuration files. which with <configuration filename> as argument prints out which configuration file found in the search path is used by Tv.

cd

cd <pathname>

Change the reference point of relative filenames to <pathname>:

command-file

command-file open <filename>

command-file close

command-file resume

command-file suspend

graphic

graphic resume

graphic resume-forced

graphic suspend

You may switch off the graphical output to speed up things (e.g. automatical time shifting of projections). For use in nested command files, suspend and resume have to be used pairwise. So if you have done suspend <n> times you have to resume the graphic <n> times. To force the resumption of the graphic, use resume-forced. This will reset the suspend counter.

edit-lock

edit-lock

edit-unlock

Commands in cursor mode may need alphanumerical input, which is normally not possible. edit-lock escapes from cursor mode till the next 'RET' (not 'ENTER') or edit-unlock. You may perfom a <carriage return> with 'ENTER'.

edit-unlock

(see section edit-lock)

input-mode

input-mode edit

input-mode cursor

keyalias

keyalias

keyalias <key sequence>

keyalias <key sequence> "key alias definition"

keyunalias

keyunalias <key sequence>

keytable

keytable activate

keytable ascii

Print a table with ascii codes in various formats: The five columns have the following meaning:

dec hex oct 'symbolic name' key

keytable create

keytable delete

keytable list

keytable read

keytable status

keytable write

precision

protocol

protocol command

protocol session

protocol standard-output

wildcard

(see section Wildcards)

Configuration

Command line options

usage: tv <options> the following options are available:

-? or -help : display this message

-shm : use shared memory spectra

-rc : ignore '.tvrc'

-v : print information on version

-s <ns> : set number of spectra buffer to <ns>

-res <mr> : set maximal spectra resolution to <mr>

-e <string> : execute command string <string>

Configuration files

X resources

The configuration is read from the files

~/.Xresources

~/.Xdefaults app-defaults/Xtv

Sample Xtv file

Xtv*xrdb-class: CLASS

Xtv*xrdb-planes: PLANES

Xtv*Font: -misc-*-bold-r-*-*-13-*-*-*-*-80-*-*

Xtv*allowResize: True

Xtv*Linewidth: 0

Xtv*monochrome*Foreground: white

Xtv*monochrome*Background: black

Xtv*gray*Foreground: white

Xtv*gray*Background: black

Xtv*colored*Foreground: yellow

Xtv*colored*Background: black

tv.geometry: 650x300-0-0

Xtv*geometry: 500x500-0+0

Xtv*NumGCs: 16

Xtv.comparison.geometry: 500x500+0+0

Xtv.comparison*colored*spectrum.foreground0: yellow

Xtv.comparison*colored*spectrum.foreground1: magenta

Xtv.projections.geometry: 500x500-0+0

Xtv.projections*colored*spectrum.foreground4: yellow

Xtv.projections*colored*spectrum.foreground5: magenta

Xtv*cut*XFrame: 1

Xtv*cut*YFrame: 1

Xtv*plot.geometry: 500x500+0+0

Xtv*plot*XFrame: 3

Xtv*plot*YFrame: 9

Xtv*plot*Font: fixed

Xtv*GowFrameWidget.Font: fixed

Xtv*unix.geometry: 900x900+0+0

Xtv*unix*XFrame: 6

Xtv*unix*YFrame: 6

Xtv*unix*Font: fixed

Xtv*unix*LineSpace: 1.3

Xtv*unix*VLabel.labelDistance: 1.0

Xtv*unix*labelLine: 1.2

Xtv*unix*ticLabel: 5.0

Xtv*unix*ticTic: 0.5

Xtv*unix*ticLong: 0.9

Xtv*unix*ticMedium: 0.6

Xtv*unix*ticShort: 0.3

Xtv*unix*ticSpace: 1.2

Xtv*unix*spectrum.linestyle4: shortdashed

Xtv*unix*spectrum.unixLinestyle4: shortdashed

Xtv*xfig.geometry: 500x500+0+0

Xtv*xfig*XFrame: 3

Xtv*xfig*YFrame: 9

Xtv*xfig*Font: fixed

Xtv*XfigFontsize: 20

Xtv*UnixFontsize: 20

Xtv*UnixFontname: times-roman

Xtv*UnixLinestyle: solid

Xtv*UnixColor: 0,0,0

Xtv*XFrame: 2

Xtv*YFrame: 3

Xtv*ticLong: 0.6

Xtv*ticMedium: 0.4

Xtv*ticShort: 0.2

Xtv*ticSpace: 0.75

Xtv*ticLabel: 3.0

Xtv*ticTic: 0.3

Xtv*VLabel.labelDistance: 2.0

Xtv*VLabel.labelLine: 1.0

Xtv*VLabel.topSpectrum: True

Xtv*VLabel.channelRadius: 2

Xtv*VLabel.libraryRadius: 1.0

Xtv*GowFrameWidget.cursor: gumby

Xtv*Paned.gripCursor: sb_v_double_arrow

Xtv*GowCutWidget.gripCursor: dot

Xtv*GowCutWidget.adjustCursor: bottom_left_corner

!special named widgets

Xtv*fit.geometry: 780x570+0+0

Xtv*cut.geometry: 300x300-0-0

Xtv*pro.geometry: 100x100-0-0

Xtv*xpane.eometry: 300x300+0-0

!Xtv*pane-1*compressMode: firstfound

Xtv*fit.height: 200

Xtv*residuum.height: 100

Xtv*residuum.skipAdjust: True

Xtv*CrossFraction: 0.01

Xtv*bin-list.vBarPosition: bottom

Xtv*bin-list.upperFraction: 0.00

Xtv*bin-list.lowerFraction: 0.99

Xtv*fit-region.vBarPosition: top

Xtv*fit-region.upperFraction: 0.02

Xtv*fit-region.lowerFraction: 0.02

Xtv*bg-region.vBarPosition: bottom

Xtv*bg-region.upperFraction: 0.02

Xtv*bg-region.lowerFraction: 0.02

Xtv*peaklist-label.topSpectrum: true

Xtv*peaklist-label.upperFraction: 0.01

Xtv*peaklist-label.lowerFraction: 0.01

Xtv*fit-label.topSpectrum: false

Xtv*fit-label.upperFraction: 0.01

Xtv*fit-label.lowerFraction: 0.01

Xtv*peak-label.topSpectrum: false

Xtv*peak-label.upperFraction: 0.01

Xtv*peak-label.lowerFraction: 0.01

Xtv*fit-bg-marker.vBarPosition: bottom

Xtv*fit-bg-marker.upperFraction: 0.03

Xtv*fit-bg-marker.lowerFraction: 0.03

Xtv*fit-region-marker.vBarPosition: top

Xtv*fit-region-marker.upperFraction: 0.02

Xtv*fit-region-marker.lowerFraction: 0.02

Xtv*fit-bin-marker.vBarPosition: bottom

Xtv*fit-bin-marker.upperFraction: 0.00

Xtv*fit-bin-marker.lowerFraction: 0.99

Xtv*vertical-marker.vBarPosition: none

Xtv*vertical-marker.upperFraction: 0.02

Xtv*vertical-marker.lowerFraction: 0.02

Xtv*gate-marker.vBarPosition: top

Xtv*gate-marker.upperFraction: 0.03

Xtv*gate-marker.lowerFraction: 0.03

Xtv*bg-gate-marker.vBarPosition: bottom

Xtv*bg-gate-marker.upperFraction: 0.03

Xtv*bg-gate-marker.lowerFraction: 0.03

Xtv*cut-gate.vBarPosition: top

Xtv*cut-gate.upperFraction: 0.03

Xtv*cut-gate.lowerFraction: 0.03

Xtv*cut-bg-gate.vBarPosition: bottom

Xtv*cut-bg-gate.upperFraction: 0.03

Xtv*cut-bg-gate.lowerFraction: 0.03

Xtv*gray*BorderColor: gray75

Xtv*gray*grip.foreground: white

Xtv*gray*grip.background: white

Xtv*monochrome*BorderColor: white

Xtv*monochrome*grip.foreground: white

Xtv*monochrome*grip.background: white

Xtv*colored*BorderColor: gray75

Xtv*colored*grip.foreground: white

Xtv*colored*grip.background: white

Xtv*borderWidth: 1

Xtv*io.grip.height: 1

Xtv*io.grip.width: 1

Xtv*io.gripIndent: 0

Xtv*io.status.vSpace: 0

Xtv*io.status.hSpace: 0

Xtv*io.status.allowResize: True

Xtv*paned-status.position.label: ??? ???

Xtv*paned-status.vSpace: 0

Xtv*paned-status.hSpace: 0

Xtv*paned-status.allowResize: False

!#

!# children of Paned

!#

Xtv*monochrome*GowVsWidget.cursorForeground: white

Xtv*monochrome*GowVsWidget.cursorBackground: black

Xtv*gray*GowVsWidget.cursorForeground: white

Xtv*gray*GowVsWidget.cursorBackground: black

Xtv*colored*GowVsWidget.cursorForeground: yellow

Xtv*colored*GowVsWidget.cursorBackground: black

Xtv*GowVsWidget.height: 100

Xtv*GowVsWidget.cursor: pirate

Xtv*GowVsWidget.cursorLinestyle: solid

Xtv*GowVsWidget.cursorLinewidth: 0

Xtv*GowVsWidget.xClipMin: 0.0

Xtv*GowVsWidget.xClipMax: 0.0

Xtv*GowVsWidget.yClipMin: 0.02

Xtv*GowVsWidget.yClipMax: 0.15

!#

!# viewport modifications by mouse buttons do not affect the actual input text

!# (Shift <Btn> is normally used by the window manager)

!# mouse leaving window cancels pending expand

!#

!# center(x|y|xy)

!# expand(), expand-x(), expand-xy(), expand-y(), cancel-expand()

!# full(x|y|xy)

!# scalereset(x|y|xy)

!# shift(<x-percent> <y-percent>)

!# stretch(<log2(xfac)> <log2(yfac)>)

!# execute-string("<commandstring>")

!# execute-keysequence(), cancel-keysequence()

!# cancel-keyrequest()

!#

Xtv*GowFrameWidget.Translations: #override \n\

!<Btn1Down>(1): full(y) shift(-70.0 0.0) \n\

!<Btn3Down>(1): full(y) shift(70.0 0.0)

Xtv*GowVsWidget.Translations: #override \n\

!<Btn1Down>(1): expand-x() \n\

!<Btn1Down>(2): expand-y() \n\

!<Btn1Down>(3): expand-xy() \n\

!<Btn1Down>(4): cancel-expand() \n\

!Ctrl<Btn1Down>(1): full(y) \n\

!Ctrl<Btn1Down>(2): full(xy) \n\

!Ctrl<Btn1Down>(3): full(x) \n\

!Ctrl<Btn1Down>(4): scalereset(xy) \n\

!<Btn2Down>: expand-to-limit() \n\

!<Btn3Down>: expand() \n\

!Ctrl<Btn3Down>: cancel-expand() scalereset(xy) \n\

<Leave>: cancel-expand() \n\

Shift Ctrl<Btn1Down>: full(y) shift(-70.0 0.0) \n\

Shift Ctrl<Btn2Down>: full(y) center(x) \n\

Shift Ctrl<Btn3Down>: full(y) shift(70.0 0.0) \n\

Ctrl<Key>G: cancel-keysequence() cancel-keyrequest() cancel-expand()\n\

<Key>Escape: execute-string("tv> input-mode edit;\n") \n\

<Key>: execute-keysequence()

Xtv*spectralist.Translations: #replace

Xtv*spectralist.internalHeight: 0

Xtv*spectralist.internalWidth: 0

Xtv*spectralist-view.allowVert: False

Xtv*spectralist-view.allowResize: True

Xtv*spectralist-view.skipAdjust: False

!Xtv*io.skipAdjust: True

!Xtv*io.view.height: 100

!Xtv*io.allowResize: True

Xtv*io*borderWidth: 1

Xtv*io*text*search*scrollVertical: False

Xtv*io*text*search*scrollHorizontal: False

Xtv*io*text*search*resize: True

!#

!# two optional scrollbars for text widget:

!#

!# athena viewport widget is not able to trace the position of insertion point

!#

Xtv*io*allowHoriz: False

Xtv*io*useBottom: True

Xtv*io*allowVert: False

Xtv*io*useRight: False

Xtv*io*forceBars: True

!#

!# athena text widget forces visibility of insertion point on keyboard

!# events but the position of the last line is sometimes below window ...

!#

Xtv*io*text*scrollVertical: always

Xtv*io*text*scrollHorizontal: never

Xtv*io*text*resize: never

Xtv*io*text*displayCaret: True

Xtv*io*text*wrap: word

Xtv*monochrome*io*text*background: white

Xtv*monochrome*io*text*foreground: black

Xtv*gray*io*text*background: white

Xtv*gray*io*text*foreground: black

Xtv*colored*io*text*background: wheat

Xtv*colored*io*text*foreground: DarkGreen

Xtv*io*text*Translations: #override \n\

Ctrl<Key>G: cancel-keysequence() cancel-keyrequest() \n\

<Key>Escape: execute-string("tv> input-mode cursor;\n") \n\

<Key>Return: execute-command() edit-unlock() \n\

<Key>Linefeed: execute-command() \n\

<Key>KP_Enter: execute-command() \n\

Ctrl<Key>J: execute-command() \n\

Ctrl<Key>M: execute-command() \n\

Ctrl<Key>O: execute-command() \n\

Ctrl<Key>C: end-of-file() \

newline() \

insert-char() \

execute-command()

Xtv*Spectrum.lineSpace: 1.1

!Xtv*spectrum.foreground0: white

!Xtv*spectrum.background0: black

!Xtv*spectrum.linewidth0: 0

!Xtv*fit-function.foreground0: white

!Xtv*bg-function.foreground0: white

Xtv*monochrome*spectrum.Foreground: white

!Xtv*monochrome*spectrum.Linewidth: 1

Xtv*monochrome*spectrum.linewidth0: 0

Xtv*monochrome*spectrum.linewidth7: 0

!Xtv*monochrome*spectrum.linestyle0: solid

!Xtv*monochrome*spectrum.linestyle1: longdashed

!Xtv*monochrome*spectrum.linestyle2: disconnected

!Xtv*monochrome*spectrum.linestyle3: dotdashed

!Xtv*monochrome*spectrum.linestyle4: dotted

!Xtv*monochrome*spectrum.linestyle5: shortdashed

!Xtv*monochrome*spectrum.linestyle6: odddashed

!Xtv*monochrome*spectrum.linestyle7: solid

Xtv*gray*spectrum.Foreground: white

!Xtv*gray*spectrum.Linewidth: 1

!Xtv*gray*spectrum.linewidth0: 0

!Xtv*gray*spectrum.linewidth7: 0

!Xtv*gray*spectrum.linestyle0: solid

!Xtv*gray*spectrum.linestyle1: longdashed

!Xtv*gray*spectrum.linestyle2: disconnected

!Xtv*gray*spectrum.linestyle3: dotdashed

!Xtv*gray*spectrum.linestyle4: dotted

!Xtv*gray*spectrum.linestyle5: shortdashed

!Xtv*gray*spectrum.linestyle6: odddashed

!Xtv*gray*spectrum.linestyle7: solid

Xtv*colored*spectrum.foreground0: yellow

Xtv*colored*spectrum.background0: red

Xtv*colored*fit-function.foreground0: gold

Xtv*colored*bg-function.foreground0: green

Xtv*colored*foreground0: yellow

Xtv*colored*foreground1: magenta

Xtv*colored*foreground2: red

Xtv*colored*foreground3: blue

Xtv*colored*foreground4: white

Xtv*colored*foreground5: wheat

Xtv*colored*foreground6: cyan

Xtv*colored*foreground7: pink

X widget hierachy

<application>				Xtv(application)
   <*** color ***>			Paned(widget)
      *** standard status ***

      <application>-root		GowFrameWidget(widget)
	 <application>-root-sheet	GowVsWidget(widget)
	    *** standard GowVsWidget ***


      "spectralist-view"		Viewport(widget)
	 "spectralist"			List(widget)
      "io"				Paned(widget)
	 "status"			Box(widget)
	    "keysequence"		Label(widget)
	 "view"				Viewport(widget)
	    "text"			Text(Widget)

   <simple>				TopLevelShell(widget)
      <*** color ***>			Paned(widget)
	 *** standard status ***

	 <simple>			GowFrameWidget(widget)
	    <simple>-sheet		GowVsWidget(widget)
	       *** standard GowVsWidget ***

   <fit>				TopLevelShell(widget)
      <*** color ***>			Paned(widget)
	 *** standard status ***

	 <fit>-fit			GowFrameWidget(widget)
	    <simple>-sheet		GowVsWidget(widget)
	       *** standard GowVsWidget ***

	 <fit>-residuum			GowFrameWidget(widget)
	    <fit>-residuum-sheet	GowVsWidget(widget)
	       "residuum"		Residuum(object)

   <cut>				TopLevelShell(widget)
      <*** color ***>			Paned(widget)
	 *** standard status ***

	 "cut"				GowCutWidget(widget)
	    <cut>-cut			GowFrameWidget(widget)
	       <simple>-sheet		GowVsWidget(widget)
		  *** standard GowVsWidget ***

	    <cut>-projection		GowFrameWidget(widget)
	       <cut>-projection-sheet	GowVsWidget(widget)
		  *** standard GowVsWidget ***

   <paned>				TopLevelShell(widget)
      <*** color ***>			Paned(widget)
	 *** standard status ***

	 "pane"-<index>			GowFrameWidget(widget)
	    "pane"-<index>-sheet	GowVsWidget(widget)
	       *** standard GowVsWidget ***



*** standard status ***:
	"paned-status"			Box(widget)
	   "focus"			Label(widget)
	   "activ"			Label(widget)
	   "full"			Label(widget)
	   "position"			Label(widget)

*** standard GowVsWidget ***:
	<name>				GowVsWidget(widget)
	   "bin-list"			VMark(object)
	   "cut-gate"			VMark(object)
	   "cut-bg-gate"		VMark(object)
	   "cut-label"			VLabel(object)
	   "decomposition"		Decomposition(object)
	   "fit-function"		Fitfunction(object)
	   "fit-region"			VMark(object)
	   "bg-function"		Fitfunction(object)
	   "bg-region"			VMark(object)
	   "fit-label"			VLabel(object)
	   "peak-label"			VLabel(object)
	   "user-label"			VLabel(object)
	   "position-label"		VLabel(object)
	   "horizontal-marker"		HMark(object)
	   "vertical-marker"		VMark(object)
	   "recalibration-marker"	VMark(object)
	   "gate-marker"		VMark(object)
	   "bg-gate-marker"		VMark(object)
	   "fit-bg-marker"		VMark(object)
	   "fit-region-marker"		VMark(object)
	   "fit-bin-marker"		VMark(object)
	   "integration-marker"		VMark(object)
	   "peak-search-marker"		VMark(object)
	   "normalization-marker"	VMark(object)
	   "normalization-bg-marker"	VMark(object)
	   "range-marker"		VMark(object)
	   "peaklist-label"		VLabel(object)
	   "peaklist-function"		Peaklistfunction(object)
	   "spectrum"			Spectrum(object)

GowCutWidget:
	heightRatio		HeightRatio	float
	widthToHeight		WidthToHeight	float
GowFrameWidget:
	bottomFrame		XFrame		int
	topFrame		XFrame		int
	leftFrame		YFrame		int
	rightFrame		YFrame		int
	ticLabel		TicLabel	float
	ticTic			TicTic		float
	ticLong			TicLong		float
	ticMedium		TicMedium	float
	ticShort		TicShort	float
	ticSpace		TicSpace	float
GowVsWidget:
	cursorLinestyle		CursorLinestyle	<*** linestyle ***>
	cursorLinewidth		CursorLinewidth	int
	xClipMin		Clip		float
	xClipMax		Clip		float
	yClipMin		Clip		float
	yClipMax		Clip		float

VLabel:
	labelLine		LabelLine	float
	labelDistance		LabelDistance	float
	topSpectrum		TopSpectrum	boolean
	channelRadius		ChannelRadius	int
	libraryRadius		LibraryRadius	float
Mark:
	crossFraction		CrossFraction	float
	upperFraction		UpperFraction	float
	lowerFraction		LowerFraction	float
VMark:
	vBarPosition		VBarPosition	bottom,top,none
Residuum:
	normalized		Normalized	boolean
Spectrum:
	compressMode		CompressMode	firstfound,minmax
	lineSpace		LineSpace	float

Values of <*** color ***>:
	"monochrome", "gray" or "colored".

Values of <*** linestyle ***>:
	solid		----------------------

	longdashed	-------____-------____

	disconnected	-______-______-______-

	dotdashed	-----__-__-----__-__--

	dotted		-___-___-___-___-___-_

	shortdashed	----____----____----__

	odddashed	--___-__--_--___-__--

Graphic context resources:
	numGCs			NumGCs
X11-resources:
	font<i>			Font		<name>
	foreground<i>		Foreground	<color>
	background<i>		Background	<color>
	linestyle<i>		Linestyle	<*** linestyle ***>
	linewidth<i>		Linewidth	int
unix-plot-resources:
	unixFontname<i>		UnixFontname	<name>
	unixFontsize<i>		UnixFontsize	int
	unixColor<i>		UnixColor	<int>,<int>,<int>
	unixLinestyle<i>	UnixLinestyle	<*** linestyle ***>
xfig-resources:
	xfigFont<i>		XfigFont	int
	xfigFontsize<i>		XfigFontsize	int
	xfigColor<i>		XfigColor	int
	xfigLinestyle<i>	XfigLinestyle	<*** linestyle ***>
	xfigLinewidth<i>	XfigLinewidth	int
	xfigFillstyle<i>	XfigFillstyle	int

Keytables

.tvkeys install: /usr/local/lib/tv/: src: ~vs/tv/ultrix/clients/tv/ tvkeys

Commandfiles

command files site.rc To have a directory specific configuration, Tv automatically loads the file ./.tvrc .

File formats

See section Definition of mfile

Vs compatibility

For all those being Vs-burdened: A Vs-to-Tv-command translation table.

get ---> spectrum get.......................see section spectrum get

mget --> spectrum ls-file get.......see section spectrum ls-file

tri mat env -> cut env

Keytable translations ---------------------

RET (cursor mode) --> ESC

To load an alias set which should give a little bit of the old-fashioned vs-flair, type \@vs.tvrc.

Caveats -------

Definitions

Definition of cut

A cut is something wonderful.

Definition of mfile

Mfile is a library developed by se@ikp.uni-koeln.de for system independent reading and writing of n-dimensional spectra (n < 4). It provides a compressed spectra file format called lc (line compressed). The compression algorithm codes the differences of subsequent channels in ca. 4 bits.

File formats

<levels>.<lines>.<columns>.<element format>:[<version>]

Known <element formats> are (taken from mfile.h):

lc line compressed

le2 2 byte low endian (VAX, DEC (mips), Intel)

le4 4 byte low endian (VAX, DEC (mips), Intel)

he2 2 byte high endian (HP, Motorola)

he4 4 byte high endian (HP, Motorola)

lf4 low endian 4 byte IEEE float

lf8 low endian 8 byte IEEE float

hf4 high endian 4 byte IEEE float

hf8 high endian 8 byte IEEE float

le2s signed LE2

he2s signed HE2 matrix file

vaxf VAX F format 4 byte float

vaxg VAX G format 8 byte float

mate PC-Mate spectra format

txt ASCII spectra, Integer or Double

trixi trixi save_matrix format

le2t triagonal LE2

le4t triagonal LE4

he2t triagonal HE2

he4t triagonal HE4

Endian determines byte order = he (high endian) oder le (low endian)

1k.2k.4k.he4

means a cube with 1024 levels, 2048 lines and 4096 columns with 4-byte elements ( total size = 35 GB ) coded in high endian format .

possible abbrevs : k = kilo m = mega

Definition of environment

The cut environment defines a file structure that simplifies the analysis of matrices in that way that you need only to specify one name (<pathname>) to access the matrix, its projection and the cuts made in the matrix.

Suppose <pathname> is /home/really/cool. In this case, the matrix file has to be /home/really/cool/cool.mtx and the projection file is /home/really/cool/cool.pry. The cuts are stored in directories named by the center energy of the cut window and a version number: _<cut energy>_<version number>_

E.g. a cut with a center energy of 500 keV will be put in /home/really/cool/cool.cutdir/_500_0_/ (version number is 0). The cut spectrum is stored in a file named <cut energy>_<version number>_CUT and the position of the window marker in the file <cut energy>_<version number>_WD. So the two files in the example will be /home/really/cool/cool.cutdir/_500_0_/500_0_CUT and /home/really/cool/cool.cutdir/_500_0_/500_0_WD. All the directories are created and deleted automatically by Tv.

Concept Index

l

  • Label

    m

  • Marker
  • Multiple spectra i/o using wildcard

    n

  • Normalization

    p

  • Plot

    s

  • spectrum get

    w

  • Wildcards