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.
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.
"License Agreement for mfile" with the Institute of Nuclear Physics, Cologne
J.Theuerkauf, S.Esser, S.Krink, M.Luig, N.Nicolay, O.Stuch, H.Wolters; program Tv; Institute of Nuclear Physics, Cologne.
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'
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.
peaksearch
cut
view
fit
normalization
recalibration
integration
spectrum copy
spectrum create
spectrum delete
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.
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.
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.
--------------------------------------------------------------------------------
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
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).
spectrum activate <n>
spectrum analysator
see Measurement supervising::
spectrum status
spectrum resolution
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 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)).
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
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.
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.
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.
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.
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
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)
It is nearly the same as in VS ...
b: set backgroundmarker
B: fit background
r: set regionmarker
p: set peakmarker
F: fit region
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:
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.
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>.
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
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).
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.
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);
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 ""
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.
wildcard enter *calspc "!r.cal_spc"
This defines a wildcard which may be used for writing calibrated spectra
with
spectrum write *calspc all
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
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.
All commands in the cut menu refer to the activated cut. (see section window status), (see section 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>
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.
fit status full [calibrated | uncalibrated]
fit status short [calibrated | uncalibrated]
center-of-mass
squared-distance
pair
polynom
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 analysator <host name>
Define the host (analysator) to fetch online spectra from.
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
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.
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.
Syntax:
window create fit <name>
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 [<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 <pathname>
Change the reference point of relative filenames to <pathname>:
command-file open <filename>
command-file close
command-file resume
command-file suspend
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-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'.
(see section edit-lock)
input-mode edit
input-mode cursor
keyalias
keyalias <key sequence>
keyalias <key sequence> "key alias definition"
keyunalias <key sequence>
Print a table with ascii codes in various formats: The five columns have the following meaning:
dec hex oct 'symbolic name' key
(see section Wildcards)
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>
The configuration is read from the files
~/.Xresources
~/.Xdefaults app-defaults/Xtv
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
<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
.tvkeys install: /usr/local/lib/tv/: src: ~vs/tv/ultrix/clients/tv/ tvkeys
command files site.rc To have a directory specific configuration, Tv automatically loads the file ./.tvrc .
See section Definition of mfile
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 -------
A cut is something wonderful.
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.
<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
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.