TntWiki
TNT stands for "Tree Analysis Using New Technology". It is a parsimony phylogenetics program that allows very fast searches of huge numbers of cladograms.
I (Nick Matzke) am currently working on an R package I am calling TNTR. It will include basic functions for reading/writing data and trees from R to TNT, and parsing the TNT outputs. Although I am really a Bayesian, when working with morphology datasets and their various coding issues, it can be extremely useful to quickly estimate parsimony trees. Examples include: finding coding mistakes, finding starting trees, and finding parts of the tree with no morphological support at all. And, parsimony is an important way to "look at what the character data are doing", which is easily lost in complex Bayesian analyses.
Unfortunately, TNTwiki — the old help wiki (original / Wayback Machine partial archive) — has apparently permanently died. This is something of a crisis for anyone less than an expert user, as the TNT command structure is very obscure, and the wiki was almost the only online help. I will attempt to re-create the basics of the help at TNTwiki. Feel free to add to it (you may have to email me to get access to PhyloWiki).
Another problem was the loss of many of the TNT scripts found in the TNT script archive. Many of them were used in publications that referred to TNTwiki as the permanent archive. I am attempting to repair this in TNT scripts, below.
(Please send me scripts if you find missing ones, or if you have new ones you would like to archive. This wiki is hosted by wikidot, a major wiki server, and it is a free Educational-Resource account, so it should be pretty permanent. Remember, if you post scripts, (a) other people might use them and cite you, and (b) more importantly, you will be able to find it yourself when you've moved computers 5 years from now.)
Other sources of TNT help:
- TNTwiki at tnt.insectmuseum.org (down since Fall 2014)
- Wayback Machine partial archive of TNTwiki
- Main TNT homepage: http://www.lillo.org.ar/phylogeny/tnt/
- TNT BugFixes file: http://www.zmuc.dk/public/phylogeny/TNT/BugFixes.htm
- Goloboff workshop slides: http://docslide.net/documents/quantitative-clad-is-tics.html
- Goloboff paper: PA Goloboff, JS Farris, KC Nixon (2008). "TNT, a free program for phylogenetic analysis." Cladistics, 24(5), 774-786, October 2008. Online July 11 2008. Journal link: http://onlinelibrary.wiley.com/doi/10.1111/j.1096-0031.2008.00217.x/abstract DOI link: http://dx.doi.org/10.1111/j.1096-0031.2008.00217.x Google Scholar: https://scholar.google.com/scholar?q=TNT%2C+a+free+program+for+phylogenetic+analysis&btnG=&hl=en&as_sdt=0%2C5
- TNT Google Group: https://groups.google.com/forum/#!forum/tnt-tree-analysis-using-new-technology
- Parsimony analysis in TNT using the command line version by Alexander Schmidt-Lebuhn.
- TNT and Ubuntu by Matthew Vavrek; contains useful basics and also Bremer supports etc.
List of TNT command-line commands
tnt*>help;
For help on command "xxxx" enter "help xxxx"
For help on ALL commands, enter "help*"
For help with scripting language, enter "help+"
Enter "help [ topic ]" for possible help topics.
COMMANDS:
agroup alltrees ancstates apo bbreak beep best
bground blength blocks break bsupport ccode cdir
change chkmoves chomo ckeep cls clbuffer cnames
collapse comcomp condense constrain costs cscores cstree
dmerge drift edit echo export fit fillsank
force freqdifs help hold hybrid ienum incltax
info lintrees log keep length lmark lmrealign
lquote majority map minmax mixtrees mono mrp
mult mxram mxproc naked nelsen nstates outgroup
procedure pause pcrprune pfijo piwe pruncom prunmajor
prunnelsen pruntax ptnt qcollapse qnelsen quote quit
randtrees ratchet rcompl rdir rebuild recons report
reroot resample resols rfreqs riddup rseed run
save screen scores shpcomp sectsch shortread silent
slfwt slaveproc smatrix sort sprdiff subopt svtxt
system tables tagset taxcode taxlabels taxonomy taxname
tchoose tcomp tequal tfuse tgroup thanks timeout
tnodes tplot tread tsave tshrink tsize ttags
txtsize tzert view vversion warn watch xcomp
xgroup xinact xmult xperm xpiwe xread xwipe
unique unshared usminmax zzz
The file tnt.htm from the TNT download
This "tnt.htm" file is included in the TNT download. It is a help file, but incomplete by itself; but it can help on some issues, so it might as well be in put online for google-tasticness. I have put the text here: tnt_htm
See the original file, inside the download, for original formatting etc.
TNT scripts
Some other scripts are available in the TNT download, also here: http://www.lillo.org.ar/phylogeny/tnt/scripts/ . A link to the same (I think; it doesn't load for me at the moment) is/was http://www.zmuc.dk/public/phylogeny/TNT/scripts/.
I have uploaded them here as a backup, quoting whatever description/authorship was available in the script.
See also: General_Documentation.pdf, for general documentation on TNT scripting.
| title | usage/function/purpose | script file(right-click, save as) |
| Bremer support | Calculates Bremer support. Easy to use given its nice interactive window. | Bremer.run |
| Partitioned Bremer support | Calculates partitioned Bremer support. By Carlos Peña. | pbsup.run |
| aquickie | A script to perform a simple one-shot analysis, ideal for new or lazy TNT users . This runs a simple analysis with a search for most parsimonious trees (or asks whether you want to do a consensus estimation, if the data set is large), then calculates group supports using resampling. | Aquickie.run |
| stats | Calculates RI and CI. [NOTE added by Nick Matzke: Stats.run seems to crash if you have more than about 400 trees in memory. i.e. after "hold 400; mult 100 =tbr drift ;" works, but after "hold 500;" it doesn't.] | Stats.run |
| TTS | Calculates the number of three-taxon statements implied by the first tree that are true on the second tree. | TTS.run |
| Term lengths | This script finds the taxa which increase tree length the most (reporting ties when they exist). | Term_lengths.run |
| RF_Distances | This script calculates the Robinson-Foulds distance between two trees given as arguments | RF_Distances.run |
| Implied_weighting | This script defines a (user-defined) number of K, under implied weighting (IW), that produce even intervals of fit/distortions, analyzes the matrix under IW using these values of K, and make some comparisons between the results obtained under different K-values (to evaluate stability of results across evenly differing analytical conditions). More details in Mirande (2009) | Implied_w.run |
| LandschW | This script allows to run searches considering (exclusively) landmark data. It generates a Wagner tree (RAS) and swaps it using TBR. It receives only one argument, that is the level of thoroughness of the analysis ( 0 is the lowest, 4 is the highest). If no argument is given the script will run a seach departing from a single Wagner tree and considering the current settings for landmark optimization. (This scripts replaces the original script landsch.run where each run departed for a random tree) | LandschW.run |
| Landcombsch | This script allows running tree searches combining landmark data with other sources of evidence. Each replicate starts from a Wagner tree (RAS)followed by TBR. Only a single optimal tree is kept in memory. You should specify one argument: 1st = strength of the search (modifies the number of replicates and precision in landmark optimization(0: lowest (fast) , 4: highest (slow). Default = 0) | Landcombsch.run |
| export_tps | This script export to TPS format the landmark coordinates of terminals and inner nodes of the first tree in memory. It produces one file for each lm configuration. Besides it generates a tree drawing with the numbers of the inner nodes corresponding to the names given in the TPS file | Export_tps.run |
| mytaxo | This is the script used in Goloboff et al., 2009. See paper for details of usage. The script checks groups (calculating their fit on multiple trees), also finding taxa to prune to improve groups. First argument is max. depht, second argument is group to improve (both are optional). It stores taxa to prune in group 31 (if doing only a group, it stores taxa to cut to improve that group, to the level specified) | Mytaxo.run |
| colorgroups | This is the script used in Goloboff et al., 2009. The script colorgroups.run (for Windows only) will take a list of taxa and automatically produce color diagrams displaying the groups. If you wish to use the same color code for several separate groups, you can separate the groups to be given similar color with a plus and a colon, and the groups to be given different colors with blank spaces; for example: colorgroups _Araneae_+:_Nematoda_ _Diptera_+:_Porifera_ will give spiders and nematodes one color, and sponges and flies another. The figures produced with this script can be exported as metafiles. | Colorgroups.run |
| blens | This macro plots phylograms | blens.run Blens_tntwiki.run |
| dohi | This is the script used in Goloboff et al., 2009. It takes as argument the name of a group, so that: dohi _Mammalia_ will find the group in the tree most similar to "Mammalia", and display it on screen (counting the number of non-members included, and of members excluded). | Dohi.run |
| blockboot | performs Siddall's (2010) partition bootstrap | Blockboot.run |
| blockjak | performs Siddall's (2010) partition jackknife | blockjak.run |
| Codonweight | allows reweighting of 1st, 2nd and 3rd positions for a scope of characters | Codonweight.run |
| ILD | Incongruence Length Difference Test of Farris et al 1995 | Ild.run |
| deactmiss | Deactivate taxa with a given amount of missing data | Deactmiss.run |
| excludemiss | Excludes characters that are missing for a given percentage of taxa | Excludemiss.run |
| forall | Finds all files (recursively traveling subdirectories) which match a file name. | forall.run |
| example | An example script/template that can be copy pasted for other scripts presented here. | none |
| (NEW) templetontest | "This TNT script implements the Templeton Test from: Templeton AR 1983, Evolution 37(2): 221-244" — by Alexander Schmidt-Lebuhn. See script for further notes. | templetontest.run |
| (NEW) Incongruence Length-Difference (ILD) test | Ross Mounce contributes two versions of the ILD script. For further notes see this discussion thread on the TNT Google Group. | Ild.run, ildtnt.run |
| (NEW) MSM.run | "This script calculates the modified MSM (MSM*, Manhattan Stratigraphic Measure; Pol and Norell, 2001) and GER (Gap Excess Ratio) Wills, 1999) on the trees in memory using the Sankoff age character (detailed in file dataMSM.TNT)." See script for further notes. Example files (for dataMSM.TNT etc.) are available in the zipfiles for Pol and Norell 2001, Pol and Norell 2006, which I have attached. | MSM.run Pol_Norell_2001_stratigraphic_fit_MSM.zip Pol_Norell_2006_TNT_age_uncertainty.zip |
Here are the additional scripts from the TNT download.
Original source: http://www.lillo.org.ar/phylogeny/tnt/scripts/
| title | usage/function/purpose | script file(right-click, save as) |
| combosearch.run | "This script contains instructions to run very large data sets." | combosearch.run |
| delcor.run | "Please note !! There is an update for this script: http://www.zmuc.dk/public/phylogeny/TNT/scripts/xdelcor.run . That script is better at handling large data sets with very numerous reconstructions (and can also save the arrays of increments/decrements to a file, so that testing with different options can be done without having to generate again all possible reconstructions for each of the characters). It requires a version of TNT for March, 2010, or later. The present script is this note aside exactly the same one as used by Giannini & Goloboff (2010), and is preserved as such for documentation purposes." | delcor.run |
| hybtree.run | "This scripts merges two trees (mixing groups of as even a size as possible). Must specify two trees to use as source for new tree." | hybtree.run |
| landmark_search.run | "This is a very simple search routine, which takes a tree (given as first argument) and starts TBR swapping from it. This saves a single tree. If implied weighting is on, or discrete characters are included, that should work ok. Note that the settings for landmark optimization (determined with the "lmark" command, see "help lmark;") are those at the time of calling the file." | landmark_search.run |
| mergetags.run | "This script merges tags in two files. Each of the files must contain tags in parenthetical notation (saved with 'save*.,'). Must give name of files to merge as arguments. The labels for both trees are shown, separated by a slash., note that the labels are inverted (first label shown corresponds to second tree). The second tree is plotted., when the second tree has a group not present in the first, the second label (corresponding to first tree) is indicated as '?'." | mergetags.run |
| partbremers.run | "This script first calculates strict consensus for the entire data set, and then calculates the bremer support for each partition of the data set. You have to give the name of the data set as argument. Once the script finishes running (it may take a while), then you process the results by calling (on the Windows version) the file procbremers.run. The search is sufficient for a data set with 300-500 taxa., change it in case you feel the search is inadequate!" | partbremers.run |
| procbremers.run | "[T]his script processes results produced by the script partbremers.run —it shows the bremer supports for each group in the consensus, for each partition, in a friendly way. Before running this script, you have to run partbremers.run, place all the resulting files in the current folder, read the data set (make sure you make space for long taxon names), and call this script." | procbremers.run |
| psecboot.run | Sectorial bootstrap, run in parallel? "Five arguments and a preexisting tree (in parenthetical notation) needed for this script: 1 - data set (name only, extension must be '.tnt'). Tree file *must* have the same name, but extension '.tre' (iif there are multiple trees, tree 0 will be used. Results are saved to file with the same name, but extension '.sup'. 2 - nchunks in parallel 3 - number of cycles in parallel 4 - nchunks in first round of parallel 5 - nchunks in last round of parallel" | psecboot.run |
| secboot.run | Sectorial bootstrap, run serially? "This script runs (serially) a sectorial approximmation [sic] of supports, for large data sets. It automatically breaks the tree in chunks of 200-166 nodes. The groups are those in a tree found by a quick search (see below). You have to give the name of the data set as first argument (name only, extension *must* be '.tnt'). Results are written to screen (or log file, iif opened before running this routine), and saved to a file with the same name as the data set but extension '.sup'." | secboot.run |
| supwt.run | "This macro performs the support weighting of Farris (2001)" | supwt.run |
| Term_lengths.run | "This script finds the taxa which increase tree length the most (reporting ties when they exist). You must specify which tree to use (as first arg.)" | Term_lengths.run |
| tosvg.run | "A simple macro to transform a TNT tree into a vectorial graphic (SVG). [I]t can be read with any web browser (except… that one) (written by J. Salvador Arias, 2010)" | tosvg.run |
| xdelcor.run | "This script is a refinement of the original script of Giannini & Goloboff (2010), delcor.run. It is intended for use in large data sets where there are too many reconstructions to be handled by the original script. This version also adds the option of saving the reconstructions for later use (so that they do not have to be generated again), and the option of using fewer significant digits and/or averages for the terminal taxa (which may speed up enumeration of reconstructions). The original script is retained for documentation purposes." | xdelcor.run |
| xmultloop.run | "This macro repeats the xmult command, fusing with previous results every time." | xmultloop.run |
Help on each TNT command
AGROUP
define groups of taxa. Syntax is as in "tgroup" (but options
"len", "nod", "siz", or "mono" not allowed, and
"agroup !;" saves only active taxa).
ALLTREES
generate all trees for active taxa
ANCSTATES
N define character(s) N as ancestral. Ancestral
states correspond to those of current outgroup
APO
N plot synapomorphies for tree(s) N
[N plot synapomorphies common to tree(s) N
- list instead of plotting on tree
[-N/L list synapomorphies common to tree(s) N, node(s) L
BBREAK
Perform branch-swapping, using pre-existing trees as starting point.
Use "bbreak=options;" (change settings and run) or "bbreak:options;"
(change settings, don't run). This swaps according to current settings
of suboptimal, constraints, and collapsing.
Basic options are:
tbr use TBR
spr use SPR
[no]fillonly swap until tree-buffer is filled, and then stop.
[no]mulpars save multiple trees.
Fine-tuning options are:
[no]safe The "safe" option uses a slower (but safer) method for
updating buffers when finding a better tree under TBR
(default is "nosafe").
[no]skipspr skips the SPR phase on a single tree when doing multiple
RAS+TBR saving several trees per replication; "skipspr"
is useful in conjunction with "nosafe", but not so much
with "safe" because then the initial portion of TBR
(when better trees are being found often) gets slowed down
and SPR doesn't. The "nosafe" option only makes a
difference for very large data sets; note that "skipspr"
modifies the behaviour of both "mult" and "xmult".
[no]int N There are two options, "int 1" and "int 2" (both options
identify most relevant characters for a series of swaps,
option 2 also reorders characters to try to save time).
These options useful only for large matrices (>10,000) with
large numbers of characters; otherwise they tend to produce
slower swapping.
[no]randclip randomize clipping sequence (with current random seed).
[no]xbit On 64-bit systems, the (default) "xbit" option turns on
optimization using 64 bits, when possible. This tends to
be 20-25% faster.
[no]preproc with "preproc" the program tries to identify and effect
first the clippings that would improve the tree the most;
this has effect only on "mult" searches with hold=1 (and
only when skipping the SPR phase), and TBR swapping from
existing trees with mulpars off. This may save a little
time in the initial stages of the search for very large
data sets, although the end gain is small.
clusters N use node-clusters of N nodes. As the data set becomes
larger, clusters of more nodes produce faster TBR-swapping.
When using clusters also for wagner trees, the same size as
defined here is used.
BEEP
= beep on errors and warning messages
- don't (default)
BEST
filter trees, discarding suboptimal
N keep trees up to N steps (weighted) worse than best
- invert the selection criterion
[ discard trees not fulfilling constraints of monophyly
] discard trees fulfilling them
* collapse the trees before comparing
BGROUND
as first argument when calling TNT, it tells it to run in background.
Files recognized while in background:
stop_tnt_PID if file exists, interrupts (as if pressing <esc>).
Note that if program is in a "wait" loop, then this
(just like <esc>) interrupts the wait and programs
continues with instructions subsequent to the "wait"
(unless "execute_tnt_PID" exists, case in which,
TNT switches immediately to that file). Thus, if the
program is in a "wait" loop, stop_tnt_PID may have
to be created a second time for immediate exit.
pause_tnt_PID if file exists, TNT is paused (as if pressing "p").
When TNT paused, removing file resumes work.
execute_tnt_PID when TNT finishes current set of instructions (or
when interrupted with stop_tnt_PID), uses contents
of file as new set of instructions (moving already
executed instructions to file ".tntexec_N_PID", where
N increases as TNT continues being reset). This is
not recognized by slaves, and works only after normal
termination (if in backgrond, errors cause an exit).
Except for "execute_tnt_PID", file contents are irrelevant; TNT only
checks existence of the file itself.
BLENGTH
N; show table with branch lengths for tree(s) N
*N; same, using a tree diagram
> N/L for continuous characters, show maximum increase in value
for each branch, for tree(s) N, char(s) L. If a branch
always decreases, show minimum decrease. From command
line, '[' can be used instead; this can be used together
with '<' (see below)
< N/L for continuous characters, show maximum decrease, as for '>'.
If a branch always increases, show minimum increase. From
command line, ']' can be used instead.
BLOCKS
J K L Define blocks to start at character(s) J K L
; Show current blocks
*; Save curent blocks
= J K deactivate all characters and taxa not in blocks
J K (if list preceded by "&", only shared taxa
remain active)
BREAK
= enable breaks with <esc>, pauses with 'p' (default). During
searches, pressing 'm' will stop the search and move on
(executing the rest of commands from file or console).
- don't
/ copy text (ending with semicolon) to display as warning if
calculations are interrupted ("yes" interrupts anyway)
By default, interruption produces no queries
BSUPPORT
Calculate bremer supports, using trees currently in memory.
N/L use tree(s) N, pruning taxon (taxa) L, and display results
Other options:
=N collapse groups with support < N
* save tree as last tree in memory
[ use relative (instead of absolute) supports
] use relative supports, using only trees within absolute support
!N calculate supports by TBR-swapping, for groups in tree N. If
N preceded by '+' then it adds to the cost of loosing a group
in a tree the score-difference for the tree itself (=more
accurate; default is more conservative). Using '!!' instead
of just '!', no groups in reference tree are collapsed.
&X combine absolute (A) and relative (R) bremer supports,
to approximmate results of resampling with P(del)=X, with
Comb = ( R x (1-X) ) ^ ( 1/A ).
CCODE
! re-sets ccode to the one defined in the data file
Other than that, sets character codes. Specifiers are:
+ make following character(s) additive (this means "ordered", Goloboff et al. 2008 p. 7 -- NJM)
- " " " non-additive (this means "unordered", Goloboff et al. 2008 p. 7 -- NJM)
[ " " " active
] " " " inactive
( " " " Sankoff
) " " " non-Sankoff
/N apply weight N to following character(s)
=N apply N additional steps to following character(s)
CDIR
change directory
CHANGE
L/N/X Y ; report min-max. changes from state(s) X to state(s) Y
for tree(s) L, char(s). N. Can use names or numbers, and
enclose multiple states/names in brackets. From 01 to 23
counts all changes from either 0 or 1 to either 2 or 3.
[ L/N/X Y same, but displays min/max. changes tree by tree
] L/N/X Y same, but displays results character by character
CHKMOVES
Check moves that produce trees of equal score (or within specified
suboptimal difference), and report number of moves for each node.
This helps to quickly identify taxa that decrease resolution of the
consensus (or supports).
Arguments:
[ sort by distance, instead of number of moves
& sort by rerooting depth
* don't list or sort, just show moves on tree diagram
Options [, & or * can be followed by list of trees to process
(default=all), and this can be followed by the minimum value to
report (as /N; this is optional; default minimum is 1). The
list (or the specification for the minimum value) can be followed
by ">N" (or "<N"), where N is the number of group to which
the taxa with value equal or greater than the minimum will be
added (or removed from). In the case of internal nodes, all the
descendants of the node are added to (removed from) the group
specified. Note that when sorting by rerooting depth, the taxa
that belong to the rerooted clade are added/removed. If macro
is ON, then using "=A" will store in array of name/number A,
the number/distance/depth for each node of the tree (a single tree
must be specified in this case); this can be used together with
">N" or "<N".
CHOMO
N show homoplasy (=extra steps) for tree(s) N
CKEEP
set current ccode as default
CLS
Clear screen
CLBUFFER
; clear text buffer
* clear command buffer
CNAMES
Name character(s) / state(s):
cname
{N1 charname state0 state1 state2 ... n ;
{N2 charname state0 state1 state2 ... n ;
{N3 charname state0 state1 state2 ... n ;
;
*; save character names
!; save character names (active chars. only)
+N rename char. N: charname state0 ... n
COLLAPSE
N; set level of tree-collapsing to N
0 no collapsing
1 if some optimization implies support, keep branch ("rule 3")
(this is the default in PAUP*)
2 if ancestor and descendant state sets differ, keep branch
(this is equivalent to "amb-" of Nona/Pee-Wee)
3 collapse branch if some optimization lacks support
(this is the default of Nona/Pee-Wee: "rule 1")
4 rule 4 of Coddington and Scharff
5 Collapse using SPR
6 Collapse using TBR
+ collapse trees temporarily for consensus calculations (default)
- don't
[ after a search, automatically condense trees
] don't ( default)
Alternatively, the options can be given as strings: none, rule 1, amb,
rule 3, rule 4 , spr, tbr, [no]auto, [no]tempcollapse.
COMCOMP
Calculate combinable component (=Bremer ) consensus tree
N/L display consensus for tree(s) N, excluding taxon (taxa) L
*N/L same, but keep consensus as last tree in memory
CONDENSE
N collapse branches for tree(s) N, according to settings of "collapse".
[N same, reinforcing constraints of monophyly (i.e. keeping constrained
groups, even if unsupported).
N/L collapse branches for tree(s) N, ignoring taxa L.
/T N collapse set of node(s) N, for tree T. Using "*" instead of T,
it collapses nodes of tag-tree (retaining the rest of labels); if
"=xxx;" is used instead of a node list, then it collapses all
the internal nodes labeled as "xxx".
CONSTRAIN
= Re-inforce constraints for mono- and non-monophyly
- don't (default)
COSTS
N = x>y z Define transformation costs for character(s) N to be z from all
states in x to all states in y. Can use square brackets to
enclose multiple states (e.g. [012]>3 is from either 0 or 1 or
2 to 3). Using / instead of > defines costs as symmetrical.
The symbol ? means every possible state.
*; save all costs.
-; save costs, for active chars. only.
[; save costs in TNT format (default)
]; save costs in SPA format
<; don't allow using sankoff (saves small amount of memory)
>; allow using it (=default)
CSCORES
N/L report length/fit for character(s) L on tree(s) N
!N/L same, optimizing polytomies as "soft"
CSTREE
N = [cst] read character state tree (=costs) for char(s) N.
Type cst after a carriage return, with symbols /\-| and X.
+; optimize character state trees by decomposing them in binary
variables; this is faster, and means that under implied weights
the fit for the character is the sum of the fits of the
individual variables.
-; optimize character state trees as wholes; under implied weights,
the fit for the character is calculated using the homoplasy for
the entire character, which may differ from the "+" option.
DMERGE
dmerge OUT =DIR IN1 IN2 merges files in1 and in2 (from directory dir)
dmerge*; merges characters with identical names
DRIFT
Do tree-drifting, from trees in memory. Options are:
iterations number of cycles (=iterations) to do
numsubs N number of replacements (i.e. accepted tree
rearrangements) to do in perturbation phase
xfactor makes acceptance of suboptimal trees less likely
[no]autoconst N number of constrained cycles
[no]giveup N max. percentage of full swap to do in perturbation
phase. This is an int, so 99 means don't give up
fitdiff max. difference in absolute fit
rfitdiff max. difference in relative fit
findscore N stop drifting when score N hit
[no]equals alternate perturbed and unperturbed drift cycles
[no]fuse NxR every N iterations, do R rounds of fusing to the
N trees
[no]dumpfuse if fusing fails to produce a better tree, [don't]
dump all the suboptimal trees
flat N run the first N iterations using the relative
fit difference defined with rflat
rflat N max. difference in relative fit difference
for initial iterations
flatnumsubs N number of replacements to do for initial iterations
[no]pert never accept suboptimal rearrangements (i.e. "drift"
only wanders around in the island)
Options set with "drift:[options];" or "drift=[options];" (first case
case changes settings only, second case runs). Using "drift:;" current
settings are displayed
EDIT
X Y edit node Y of tree X. Then, J L sends J to node L. If J is an
an ancestor of L, reroots clade J on L. /N collapses node N (this
can be given as a list, with nodes separated by '+').
ECHO
= echo each command
- don't echo
[ if log file opened and taking commands from console,
echo console input to log file
] don't
EXPORT
export data in NEXUS format. If filename followed by "+",
copies everything to the end of the NEXUS file, until a semi-
colon is found (use it to embedd PAUP* or TNT commands in
the file). TNT commands can be included at the end of the
file, preceded by "begin tnt."
Possible arguments (before file name):
* trees as well
+ step-matrices as well
- trees only (including tree-tags, if defined)
> tree-tags only, as branch lengths
< tree-tags only, as branch labels
[ save as dna
] save as standard
! save as Fasta instead of Nexus (!! skips gaps)
FIT
N report total fit, for tree(s) N. It is measured with a convex
increasing function, to be minimized
!N same, optimizing polytomies as "soft"
*N report total fit (measured with a concave decreasing function, to
be maximized; the equivalent of what PAUP* and Pee-Wee report)
FILLSANK
= complete polymorphic cells for Sankoff characters
- don't (default)
FORCE
; report present constraints
] de-activate constraints
= followed by a tree, use groups in tree (&N uses tree N)
/ followed by a tree, use tree as skeleton tree (&N uses tree N)
(if outgroup is excluded, it acts as a "convexity" constraint)
: same as /, but for negative constraints
+ positive constraints: [ a b c (d e) ] ( taxa d and e float;
if outgroup is floating, acts as a "convexity" constraint)
- same as +, but negative
>N taxon(taxa) N floating for all positive constraints
<N same, for all negative constraints
* report number corresponding to each constraint
FREQDIFS
Calculate frequency difference tree (FDT)
=N use N as cutoff
N/L display FDT for tree(s) N, excluding taxon (taxa) L
[J]N/L calculate frequency differences for each group of
tree J, on tree(s) N, pruning taxon (taxa) L
(J)N/L same, but display results as table
*N/L same, but keep FDT as last tree in memory
HELP
; display list of commands
* display options for all commands
xxx display options for command xxx (equivalent to xxx ?)
HOLD
N set tree buffer to keep up to N trees
+N increase max. trees to number of trees in memory + N (++ = 1 )
-N decrease max. trees to number of trees in memory - N (-- = 1 )
HYBRID
hybridize/complete trees. This exchanges non-identical groups
pruning unshared taxa, so that resulting tree is incomplete.
This is meant to be used in cases where tree-fusing (which
exchanges only identical groups) cannot improve the tree,
by virtue of the trees being too different (i.e. very poorly
structured data), but it outperforms tree-fusing rarely.
X Y/Z exchange a chunk (with no more than Z unshared taxa)
between trees X and Y, then complete trees and swap.
Note that X Y may be a scope (or a tree-group) containing
two trees.
-X Y/Z same, but don't complete or swap trees
+N if tree N is incomplete, sequentially add missing taxa
*N same, but also swap (TBR, nomulpars)
IENUM
Do implicit enumeration (=results guaranteed to be optimal;
feasible only for small data sets)
Options:
& when there are N most parsimonious trees, but maxtrees
is set to a smaller number, take a (pseudo)random sample
of the N trees, such that each tree has a prob. of about
maxtrees/N to be sampled. Works better as maxtrees/N is
closer to 1.
- deactivate a bounding method speeding up many well-
structured data sets (usually produces slower searches)
INCLTAX
[N report which taxa are included in tree(s) N (default)
]N report which taxa are excluded from tree(s) N
INFO
+ report which character(s) are informative (default)
- " " " are uninformative
LINTREES
= draw trees in Linux format (default)
- don't
* use command-recalling
LOG
xxx open log file xxx (use "stdout" if redirecting output)
+xxx open in append mode
/ close current log file
KEEP
N keep no more than N trees, discard the rest
LENGTH
N report total length, for tree(s) N
!N same, optimizing polytomies as "soft"
LMARK
Map and handle settings for 2D and 3D data (landmarks)
Options:
ambig specify which points to choose in the case of ambiguity
(rarely needed, as ambiguity is uncommon). Examples:
ambig YxZ C chooses maximum y first, if ambiguity
remains minimum x, and if ambiguity remains
maximum z (ambiguities in unspecified
coordinates are solved randomly), for
character(s) C.
ambig * C choose randomly.
ambig ; display current setting.
cells N divide grid in N cells
connect define connections between points for display (windows only)
factors define factors for the individual landmarks. These are then
used *instead* of the factors determined automatically.
Syntax is: factors =F C/L, which uses factor F for character(s)
C, landmark(s) L (if no C or L specified, it's all C or L;
if F is "*" then automatic factors are used for C/L).
Note: factors are used only when implied weighting is off!
With implied weighting OFF, factors multiply the score.
With implied weighting ON, factors are always unity.
[no]gwts set type of implied weighting to [not] global. Global calculates
the score by summing the steps beyond minimum, for all landmarks
in the character. Non-global calculates the score for a character
with N landmarks using the steps beyond minimum for each landmark
and dividing by 1/N. Score is always E/(K+E), where E = steps
beyond minimum, and K = concavity constant. See also below,
under "usmin".
[no]inscale [don't] weight individual landmarks so that the contribution
of each landmark within a character is similar (i.e. give
landmarks with a larger range a lower weight) (default = don't).
Note that any of the two choices makes the contribution of a
landmark character (unless modified with "lmark wts") similar
to that of a step in a discrete character, by weighting based
on the range of the landmarks and the number of landmarks.
[no]iter in addition to sankoff approximmation, iterate exact calculation
of geometric medians. For dichotomies, this uses an exact
solution for the Fermat point (ancestor-left-right descendant),
with functions written by S. Catalano with collaboration from
P. Goloboff. For polytomies, a heuristic approximmation of
the geometric median is used.
list list character types. Default is listing dimensionality of
each character. List - lists only one-dimensional characters;
list + does the opossite; list N lists all characters of N
dimensions.
[no]lowmem use low memory calculations (possibly slower)
lscores N/C/L report individual landmark scores in tree(s) N, character(s)
C, landmark(s) L (default=all).
map N/C map character(s) C on tree(s) N
maxiters N C iterate up to N times, cut when improvement below C
maxprec N skip characters with range (max. dist) below N
multimap show ambiguity in point mapping. Syntax is :
multimap R T C L
where R=replications, T=tree, C=character, and L=landmark.
Variability indicates either ambiguity in optimization (if
settings exhaustive) or errors in optimization algorithms
(if settings superficial).
nest N W nest sankoff approximmation N times, with a Window of W cells
option display all current settings for landmark optimization
precision report expected precision of individual points under sankoff
approximmation
rescale multiply each value by a factor. Note this modifies the matrix
in memory. Syntax is:
rescale =F C/L
where F=factor (if F is "*", then it uses current factors for
each landmark), C=character(s), L=landmark(s).
shake N in first sankoff approximmation, slightly distort grid N times
[no]showhtus [don't] show HTU's coordinates after mapping (default = don't)
[no]shrink shrink grid if there are outliers (useful for low cell values,
8 or less, probably won't help for cells > 10).
swap XY swap values of XY (or XZ, YZ)
[no]skip during the first sankoff approximmation, try to quickly identify
cells not needed (may save some time).
[no]termpoints make sure the first Sankoff matrix contains terminal points.
With "termpoints -" no grid is used, only the points of terminal
taxa; "termpoints +" reconnects the use of grid.
usmin set (or display) current minima for implied weighting. Default
is maximum span of Steiner tree for any triplet of taxa. This
quickly sets an upper bound for the actual minimum, but may
overestimate it. The user can set a different value (e.g. with a
search for each individual landmark. Syntax is:
usmin =M C/L
where M=minimum (if M is "*", then it uses default), C=character(s),
L=landmark(s).
wts define weights for the individual landmarks. These are then
*combined* with the factors determined automatically.
Syntax is: wts =W C/L which gives weight W to character(s)
C, landmark(s) L (if no C or L specified, it's all C or L;
if W is "*" then unit weights are used for C/L).
Note: landmark wts cannot be used with implied weighting and
"gwts" (they are just ignored).
LMREALIGN
Realign specified landmark configurations (=characters)
Keep in mind that the realignment modifies the matrix held in memory,
so that it is not possible to go back to the original coordinates
except by re-reading the data file.
Twopoint (p1 p2)/C align character(s) C using baseline registration considering
landmarks p1 and p2 as reference. Valid only for 2D
characters.
Rftra [N]/C align character(s) C in all taxa against taxon N using a
repeated medians procedure (Siegel & Benson 1982). Valid only
for 2D characters.
Pairlin [N]/C align character(s) C in all taxa against taxon N minimizing
the sum of linear distances.
Tree T cycles Y level L/C align character C on tree T using a tree-based alignment with
parsimony as optimality criterion (Catalano & Goloboff in press)
Y= number of cycles of improvement/perturbation
L= thoroughness in improvement step (0-4)
Currently implemented for 2D landmarks. Working on 3D implementation.
Random N rotate/traslate all configurations at random. Does N cycles of random
changes to the alignment. Useful for exploring the data and the
effectiveness of alignment algorithms.
! Adjust size (Option valid only for Rftra and Pairlin)
NOTE: the code for aligning was written by Santiago A. Catalano in collaboration
with P. Goloboff.
LQUOTE
= set literal quotes on (see "quote")
- set literal quotes off (see "quote")
[ within "quote" read &N as ASCII character N
] don't
MAJORITY
Calculate majority rule tree (MRT)
=N use N as cutoff
N/L display MRT for tree(s) N, excluding taxon (taxa) L
[J]N/L calculate frequencies for each group of tree J,
on tree(s) N, pruning taxon (taxa) L
(J)N/L same, but display results as table
*N/L same, but keep MRT as last tree in memory
MAP
N/L map character(s) L on tree(s) N
- show optimization for character(s) L on tree(s) N, as a text list
: show down-pass state sets instead of final
[ state super-sets for character(s) L on consensus for tree(s) N
MINMAX
; show minimum-maximum possible steps for each (active) character
- same, considering only active taxa
* combine minimum/maximum in a single table
+ show minimum-maximum for continuous character(s)
MIXTREES
N/L combine trees N (with different sets of taxa), excluding taxon
(taxa) L. Combines only uncontradicted groups. Using =J it does
J different input orders. Using =[J k] it recalculates consensus
every k randomizations, until stability is reached J times.
*N/L save the tree as last memory tree ( default = show)
MONO
N check whether tree(s) N satisfy constraints
-N check whether tree(s) N violate constraints
* same, but reporting group by group
MRP
Create matrix representing trees in memory
MULT
do N random addition sequences, followed by rearrangements.
Options are:
wagner no branch-swapping
spr use SPR branch swapping
tbr use TBR branch swapping
[no]keepall keep the trees from all replications
replic N do N replications
hold N save up to N trees per replication (only if swapping)
[no]ratchet do ratchet as well (settings with "ratchet" command)
[no]drift do drift as well (settings with "drift" command)
[no]wclus N after adding N taxa to the wagner tree, start using
node clusters (of size defined with "bbreak:clus SIZE").
Useful only for very large data sets (several K-taxa).
outfreq N frequency for which reports are produced during branch
swapping (default is every N=10 clips, but for large data
sets this implies reports take too long to be produced).
ras use randomized addition sequences for Wagner trees
[default, works best for most data sets]
cas N use closest-addition sequence for Wagner trees (ties in
the addition sequence broken randomly), looking ahead up
N taxa (no N = all taxa). Tends to work best on data sets
with a lot of incongruence.
fas N as previous one, but using furthest addition sequence
ias N as previous one, but select first those taxa which make
the largest number of characters informative (N.B. only
additive/nonadditive characters considered for this; the
other character types have no influence on the sequence).
Tends to work best on data sets with many missing entries
and non-overlapping blocks of data.
sas N as previous one, but select first those taxa with the
largest difference in score for best/worst locations (N.B.
all character types are considered). Works best for the
same data sets as the previous one ("ias"), but it is
more thorough and slower
Usage: "mult:options;" changes settings only; "mult=options;" runs
as well. Entering "mult:;" current settings are reported. Setting
the type of addition sequence also determines the sequence to be used
in other commands (e.g. "xmult", "pfijo"). The insertion sequence
is always random for "cas", "sas", and "fas"; it can be changed (see
under "rseed") to be random or non-random for "ras" and "ias"
MXRAM
N Use N Mbytes of RAM. The default is 16 MB.
Must be changed before reading the data, or the
data will be lost.
; report amount of free RAM
MXPROC
N allow up to N nested input files (default=10)
NAKED
= show tree diagrams without numbers (default)
- with
] draw trees in narrow format
[ in default (=wide) format
NELSEN
Calculate strict consensus tree
N/L display consensus for tree(s) N, excluding taxon (taxa) L
*N/L same, but keep consensus as last tree in memory
N/L/P display consensus for tree(s) N, excluding taxon (taxa) L,
and indicate placement of taxon (taxa) P (P may refer to
node numbers in the consensus)
< always use low-memory algorithm (sometimes, faster)
> use low memory algorithm only when memory is low
Note that settings established with ">" and "<" also
affect the "tcomp" command.
NSTATES
N set maximum number of states in matrices to be subsquently read to N
Note that 8 or fewer states is stored as char, 9 to 16 as Tint
and 17 to 32 as Fint. Maximum number allowed for discrete data
is 32 states. Letters A-J are states 10-31.
Using the strings "DNA," "PROT," or "NUM," determines
whether data are read as dna, amino-acids, or alpha-numeric. The
string NUM must be followed by the number of states; DNA or PROT
automatically set number of states to 8 or 32. Under DNA or PROT,
IUPAC one-letter codes represent nucleotides or amino-acids.
For DNA, AGCT are states 0123 respectively; for proteins,
A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y,U are states 0-20.
Strings "GAPS" and "NOGAPS" determine whether gaps are read
as fifth state or missing (respectively).
* resets all characters as alphanumeric; subsequent
merging of data sets with different data sets becomes easier if all
data sets are saved as alpha-numeric
& like previous one, but sets all characters to type DNA.
min deletes uninformative states for non-additive characters, so that
each character has as few distinct states as possible
xmin for non-additive characters with polymorphisms, calculate minimum
possible numbers of steps (and thus, informativeness and homoplasy)
using exact algorithms (=default; these may be time consuming for many
states and many polymorphisms). With "noxmin", a heuristic is used
to determine minima (it may underestimate minimum).
/ followed by the strings "DNA," "PROT," or "NUM," determines
how to read states in commands that refer to states (i.e. cost, or
change commands). This does not alter the matrix itself.
OUTGROUP
N make taxon N the outgroup (default = 0 )
[XXX if taxonomy has been defined, make group "XXX" the
"taxonomic outgroup". This is a possibly multi-taxon
outgroup, which may be used to root the trees after
searches, or with the "reroot[" option. In case the
taxonomic outgroup does not exist in the tree, the closest
group is used (if nothing resembling the ingroup/outgroup
partition exists, then a note is displayed, and the tree is
left rooted on the regular outgroup). If the name "XXX" is
ommitted, then the taxonomic outgroup is guessed form the
taxonomy. To have TNT reroot the trees after a search, use
"!" before the category name (default is rerooting trees
onyl when a "reroot[;" command is issued).
Note that if you have some Sankoff characters with asymmetrical
transformation costs, or have the "piwe+" option in effect,
then it is possible that using the taxonomic outgroup may
alter tree scores.
PROCEDURE
Redirect input
XXX; take commands from file XXX
/; close input file (include at end of file)
&XXX read Fasta file XXX. It must be aligned. If not, all
sequences can be "equalized" to N characters, by adding
gaps at the end, if & is followed by =N (alternatively,
=N can be placed at the beggining of the file.
Note that input may also be redirected automatically (almost
within any context) using "@@filename tagname;" (reading is
from point marked with "label tagname" on, with end of
automatic redirection indicated with @@; if a dash, -, is used
instead of tagname, the file is done from the begginning)
PAUSE
= enable pauses on output
- don't (default)
PCRPRUNE
Improve consensus by Iterative PCR (Pol & Escapa, 2009).
N/L\U improve consensus of tree(s) N, excluding taxa
in list L, but never removing taxa in U.
List of trees may be preceded by:
=C maximum number of taxa to cut at a time (default=all)
:K assign a cost of K (0-100) to taxon remotion (higher
K's require more nodes gained for a taxon removal to
be accepted as "improvement"; default=0.5)
>N only show prunings which improve N nodes or more
(for strict consensus only, not for majority)
[N] improve only node N of consensus (for strict
consensus only, not for majority)
and if followed by ">N", all the prunes are added to taxon-group
number N (note that this option requires an explicit tree list, for
otherwise it would be interpreted as the option to only show prunings
which improve N nodes; see above).
The consensus types can be indicated in parentheses, also before
tree-list:
(majority F) heuristically try to improve majority rule tree,
considering that triplets occurring in frequency F
or higher are "compatible" (50<=F<=100, default=50)
(nelsen) improve strict consensus tree (=default)
PFIJO
Run pinon fijo (a search algorithm useful for very large data sets).
The algorithm creates reduced data sets from sectors in the tree
(but instead of using the htu's, as in sectsch, it uses, with a certain
probability, the down-pass states of the descendants of an internal node).
The states for the basal node --which produce exact score evaluations for
the reduced data set-- have the highest probability of being chosen, and
descendant nodes have subsequently smaller probabilities. The outgroup
node for the reduced data set is chosen from one of the terminals outside
the group (randomly chosen). The reduced data set is analyzed by means of
three RAS+TBR, then fusing these three trees with the original one.
Typically, this produces a tree different from the original one, which
is suboptimal for the complete data set (i.e. some HTU's are not
represented by their down-pass states, the root states are different),
and this perturbated tree is then used for TBR and three cycles of
mild tree-drifting. Optionally, the trees produced can be fused every
certain number of rounds. This is a sort of ratchet, where the
perturbation is provided, not by character reweighting, but instead
by choosing subsets of taxa.
The sectors chosen are large, exclusive sectors (size chosen so that
it is below or above two sectors for the sector size to be 500; this
size can be changed, with "chunksize" --see syntax below); the actual
selections depend on the current random seed.
The probabbility of choosing HTU states is determined by making an
upward list of the L nodes descended from the HTU, generating a random
number R (0-99), and based on the user-set constant K, converting into an
integer i the expression ( L * (1000 - (10*K) ) / ( (100 - (10*K)) + R ).
Then, the down-pass states (or observed states, if a terminal) of the ith
element in the list of descendants is chosen to represent the HTU states.
Syntax is:
pfijo N = [options] ;
If the '=' is replaced by ':', then only settings are changed.
N is the tree from which pfijo is to be started (if no N is specified,
each of the trees in memory is sequentially subjected to pinon fijo).
Options are:
phtu K Change probability of HTU substitution. K is a real number
0<0<100, with larger values making more probable that the actual
HTU states are chosen, i.e. lower values perturbate more strongly;
(default K=95)
numsels N number of cycles to do (default N=30)
[no]goback if new tree, after global TBR and drift, is worse than
starting tree, go back to starting tree (default = don't go back)
[no]keepall save trees as cycles proceed, or save only best trees
(default: save)
autofuse N R every N cycles, fuse (R rounds) the trees produced.
drift N F R after perturbation, do N cycles of drifting, with a fit
difference F, and a relative fit difference R (default is
drift 3 3 0.1)
chunksize N select sectors of approximmate size N
slack N use an extra N percent memory to create reduced data sets
PIWE
- set implied weighting off (=default )
=N; set it on, with weighting constant N (0 < N <= 1000)
:N set weighting constant only
[ followed by a list of weights, sets relative weights for
implied weighting (starting from 0 extra steps). Followed
by a semicolon, displays current relative implied weights
]; deactivates user-defined implied weights
+N use auto-weighted optimization instead of implied weights, with
weighting constant N. This does implied weighting at the level
of character-state transformations; it can be very time-consuming
for data sets with many taxa and/or states.
& when using multiple concavities, show k values for individual
characters (if not using a user-defined weighting function),
or the "shift" (for a character with shift S, the cost of adding
one step to N steps of homoplasy is the same as the cost of adding
a step to a character with S.N steps with the user-defined weighting
function. If a list L of characters is given after after "&, then
the relative cost of adding a step to a different numbers of extra
steps (as in "piwe[;"), for the characters in L.
PRUNCOM
Find pruned combinable component consensus. Syntax as in
"prunnelsen" --options + and ! not allowed.
PRUNMAJOR
Use a quick-and-dirty heuristic to identify taxa to prune
in order to improve majority rule or frequency difference
trees. It checks by reference to specific groups (i.e. groups
present in a reference tree). General syntax is (defaults in
square brackets):
prunmaj T N1 N2 N3 .. Nn / S / L \ U ;
where T is number of reference tree [mandatory], N1-Nn are node numbers
[all], S is the set of trees to consider [all], L is the list of taxa
to exclude [none], and U is the list of taxa that cannot be excluded
from the tree (=Untouchable).
Additional arguments that can precede number of reference tree:
&P group proportion [0.333]. Set only, don't run.
[X Y cost of removal inside (X) and outside (Y) [1,1]. Set only,
don't run.
+ show pruns for each node of tree T [don't].
=N show the best N values [1].
* try to improve frequency differences, rather than
just frequencies.
It is possible to add/remove taxa from taxon-groups, as final
arguments:
>G add taxa with best N values to group G.
<G ditto, removing.
The values are presented with an arbitrary rescaling between 0 and
1, with taxa having higher scores expected (recall this is a heuristic!)
to improve results the most.
PRUNNELSEN
=P N/L Show pruned trees with up to P taxa pruned (default=1)
for consensus of tree(s) N, excluding taxon (taxa) L.
Checks whether additinal groups appear. If you wish to
force inclusion of some taxa (terminals only), list them
at the end as "\L".
[J] same, but only for node J of consensus
& show list of prunings that improve consensus
* store prunings that improve consensus (pruned
taxa are placed at the base of the tree)
>N show only prunings that improve more than N nodes
+ calculate agreement subtree (cannot be used with
=, [N], or >, but can be used together with * or &).
Agreement subtrees maximize number of shared taxa,
not number of shared groups (although both are the
same for binary input trees)
! approximate calculation of agreement subtree (for
binary input trees only). If used alone quickest,
if used with + intermediate. Saves or lists a single
tree.
PRUNTAX
N/L prunes taxon (taxa) L from tree(s) N. If symbol
"!" is used as taxon list, it prunes all inactive
taxa. If "*" is used instead of tree list, then it
prunes taxa from tag-tree; using "=xxx;" instead of
taxon list, then it prunes all terminal branches labeled
as "xxx".
PTNT
manage runs in parallel (parallel versions only). Keep in mind that
versions for 16383 taxa or less can't communicate with versions for more
than 16383 taxa (mixing 32-bit and 64-bit versions should be ok).
again re-send instructions to slaves, without re-sending data. With
this, it is possible to save communication time. Syntax is:
ptnt again jobname tasklist /trees N S /deltrees /swap N
= ...new slave commands...; return;
if no tasklist is given, all the tasks of jobname are re-set;
if no "trees" selection is specified (and "swap" isn't
specified), then no trees are sent; if "deltrees" is
indicated, the trees in slave(s) are deleted.
If "swap N" is specified, then it swaps tree N (deleting any
preexisting trees in the task); if several trees are to be
swapped in parallel, it is best to use "again" instead of
"begin" for each one, since "again" doesn't require that
the data be re-sent to the task(s) ("begin" does!).
Using "..." as instructions, then the previous instructions
for the slave are repeated.
begin begin a job. Up to 32 jobs can be running at the same time;
every job can have up to 1000 tasks. Syntax is:
begin name numt hosts = tnt commands ; return
name is the name by which the job is identified, numt the
number of copies of the process to run, hosts is a list of
the hosts in which to run (can be the names used by PVM, or
the numbers; current host is identified as "myself" and
host of parent process (if it exists) is identified as
"parent" (this makes scripts more portable; also, in the
list of hosts, the machine where the master TNT runs is
always number 0, and the machine where a slave itself runs
is always number 1 within that slave); "master" identifies
the master node (i.e. where TNT was started). When no list
of hosts is given, if the executing process is the master,
all hosts but the current one are used, or, if the process is
a slave, all hosts but the one where parent process runs. If
neither numtasks nor hostlist are given, one task per available
slave host is used (except for exclusive sectors, which spawns
as many tasks as selections). If you wish to specify the
number of tasks to be spawned in a host (or group of hosts),
include the number of tasks in parenthesis right after the
name of the host (or group of hosts, i.e. before the closing
braces). If several numbers of tasks are specified, the last
one takes effect (no number = 1). Current (or reduced) data are
automatically passed to each of the daughter processes (each
of which has a different random seed). The '=' symbol can be
preceded by one or several slashes ('/') indicating:
ram N N: RAM to be used in each slave, in MBytes
By default, TNT instructs each slave to allocate
an amount of RAM that should be sufficient for
most operations on the current data set.
ram xN slaves use N times default RAM
trees N S send N trees randomly picked from the total S
to each slave; using '.' instead of N, divides
S in equal parts
trees * distribute trees groups, sending task i all the
trees in group i
sector N S random selections of size N from tree set S
(as many selections as tasks; every task gets
a sector from a tree randomly picked out of S)
sector*N T create N exclusive sectors from tree T
(size set to taxa/N, tasks set to N).
If "*" followed by "-", allow looser
(partly randomized) selections. If a list
of sectors follows N (within square brackets),
then only those sectors are effectively launched.
When only some sectors were launched, and results
are recovered/spied, two copies of the best tree
in each slave (with the rest of tree polytomized)
are placed in tree-group "TreeSector_i_xxx"
(where i, task number, and xxx, job name). This
can be used to re-insert the resolution for the
sector into the main tree, or combining the
results for successive sector analyses, using
the "freqdifs" command (i.e. two copies of the
reduced tree and a single copy of the original
one, produce the replacement; make sure you
turn temporary tree-collapsing off for this).
Note: under "sec:chkroot" the number of sectors
created by this options is determined at run-time;
use the "treeparts" expression to find in
advance how many.
sector d N X select nodes around node N (of tree specified
with "/trees"), up to X branches away from N.
sector !N >X <Y T select node N of tree T and immediate
descendants; if a descendant has a polytomy
greater than Y, or smaller than X, it is used
as such; otherwise, the immediate descendants
of the node are used (this avoids creating HTU's
from poorly, or unresolved clades). To create
the HTU-s, the tree is dichotomized if needed.
swap N perform TBR-swapping in parallel, on tree N.
When done, task 0 has the final tree (which,
if no errors occur, is TBR-optimal). If some
error occurs (e.g. machine where process 0,
which is the leader, dies), then the tree is
lost. This works best when trees are closest
to optimal (i.e. communication time is required
only when a better tree is found by some task).
When using "swap", instructions to slave tasks
are ignored (tasks only swap tree, and return).
Options: -N doesn't sort swaps; +N uses process
as controller (controller doesn't swap)
dskdata read data from disk, not from PVM (data must
have been set before, with "ptnt setdata").
If several "trees" selections are indicated, selection i is
guaranteed to have at least Ni trees taken out of each set Si;
up to 8 tree selections per job can be indicated. If the sets
for each selection i are disjoint, total number of trees sent
to each slave will be the summation of the individual Ni's;
otherwise, it may be less.
A slave may begin other parallel jobs; if it does so,
giving "..." as list of TNT commands simply copies commands
for the current job (use this caution: there must be a way to
eventually stop slaves from spawning further jobs, e.g. with
the "plevel" expression --the number of parents). User
variables are interpreted on local host when using single
quotes ('0') and on slave host when using double quotes ("0").
String "return" must be followed by keywords "[no]trees",
"text", "value N" or "tgroups" (if exclusive sector
selection, options "polytree" and "nopolytree" determine
whether polytomized tree is sent back; otherwise polytomized
tree is sent only if initial score bettered/matched).
cleansig remove any signals with info from slaves that may have
been left over by the last "wait". It may be necessary
if "goto" or "again" are to be applied to a job that
had finished running, and the job is to be "waited"
again. It is also advisable to run this (with "again") on
slaves interrupted (=stopped) while doing parallel TBR
and about to be reused for further parallel TBR.
close kill all active jobs and disengage TNT from PVM. With this,
PVM can be halted and TNT continues running normally. If PVM
is halted and TNT is in parallel mode, TNT is killed.
cmdname define name of command to be displayed by parent process
(copies until a semicolon found; "-" undefines).
commtime set communication time (periodicity of signaling).
encode set type of encoding for communication with slaves. Options
are "raw" and "default" (for single/several machine
architectures). Must be set in slave processes too. The
default is using the current status, but this may create
problems if a homogeneous cluster becomes heterogeneous
(or viceversa) in the middle of a run.
get [!] get results from job(s). Job(s) must have finished running
(or have been stopped (with "ptnt stop job;"). If jobs
have not finished, "get" waits for the last one to finish
(or untill timed-out). Alternatively, if using "!" as
first argument to "get", slaves are stopped right away
(with the default stopping signal, see below). If get is
being executed in the master, it can be stopped pressing <esc>
(which calls the error handler, clearing all input buffers),
or pressing '.' (period, which skips the get but continues
normally with the rest of operations. If a single job is
being retrieved, maxtrees is reset automatically (if needed);
if several jobs are retrieved at the same time, maxtrees
is not reset (excess trees are lost).
goto N similar to skipto, but if "tagset N;" already executed,
rewinds instructions.
gwait () monitor, and when condition fulfilled, stop jobs and get'em.
(note: gwait never resets maxtrees; excess trees are lost).
hgroup define group(s) of hosts (syntax as in "tgroup")
hosts list available hosts
hpause pause all slave tasks working in given host(s).
hresume resume all slave tasks working in given host(s).
kill kill job(s); no results returned.
load show host usage
mnemonic when possible, remember values read in last ptnt wait (then
subsequent accesses to number of trees, scores, etc., in
slaves, take no time; note however that the values may not
be current anymore). If memory is reassigned (e.g. max.
trees is changed), then values are forgotten. Mnemonic is
turned on/off with +/-.
pause pause job(s); releases CPU time (but not RAM) on slaves
Can pause individual tasks (say, 0,3)for job jobname
using "ptnt pause jobname = 0 3;". If master is running
in the background, all jobs can be paused by creating a
file "pause_tnt_ID" (where ID is the number of process
id of master) in the working directory (using "stop_tnt_ID"
instead, all jobs are stopped)
reset reset job list (no active job can be running). Memory
requirements on TNT are eased if this is done often.
resume resume job(s) that are paused (automatic with "get").
Can resume individual tasks (say, 0,3)for job jobname
using "ptnt resume jobname = 0 3;".
setdata write data file (.tnt_tmpfile) in specified hosts(s)
(can indicate other directory, in square brackets, after
list of hosts; in such a case, then before launching jobs
you have to tell TNT where the directory is, with
"ptnt setdata = dirname;"). After setting disk data,
subsequently started jobs can read the data from disk
instead of having PVM transfer the data (which is time
and memory consuming), using the "dskdata" option.
setram N instead of master assigning RAM to slaves (based on
current settings), assign a fixed amount of N (MBytes)
skipto N skip instructions, in job/slave(s) specified, to the point
marked with "tagset N;" (if already there, ignored). The
slave cannot find a tag within a loop, and must still
be executing instructions (skipto is ignored if slave
is already on "return" stage, i.e. the last tag).
spy get trees from job(s), but let the jobs continue running.
If a single job is being specified, a list of tasks(s)
can be specified as well (after a forward slash). Note:
this only gets the trees from immediate slaves (not their
children or grandchildren). Maxtrees reset automatically
(as in get), only when a single job is being spied.
status report status of all active jobs.
stop [s] stop job(s); returns results so far.
Optionally, stopping signal can be determined inside
square brackets: wait, loops, search, or all. Wait stops
the monitoring for slaves (present and future), but not
calculations or searches themselves. Loops lets presently
executed loops to continue, but subsequent ones are stopped.
Search assumes the timeout for present and subsequent
searches to be always met; it doesn't stop other calculations
(such as consensus calculations). All stops calculations,
searches, monitoring (wait), and loops. The default
stopping signal (which is the one get ! uses) has a different
effect depending on what the slave is doing; if monitoring,
(with pt wait) the monitoring is interrupted and subsequent
instructions (like searches) are performed; if searching,
the search is interrupted and the slave returns right away.
tagset N define tag to be N (useful within slaves, to coordinate
tasks; see under help+attag, and above, under "skipto" and
and "goto"). This is also a plain command. Truncations of
tagset are recognized to set values, but skipto/goto only
recognize the entire string.
timeout set timeout (in secs.) to wait for slaves to return results
with "get". Default is no timeout (=0), but this may cause
fault-intolerance (i.e. TNT may freeze if a slave host died).
wait () monitor specified jobs (until condition indicated inside paren-
theses is met). Numbers of trees, replications, tasks left,
&cetera, are accessed periodically (then, evaluated faster if
TNT is monitoring; otherwise, unless "mnemonic" is on,
signals requesting values must be sent to slaves, and
parent must await for response). If no condition is specified
it waits for all tasks to finish. A timeout can be specified,
before the parentheses, inside square brackets; if timeout
is met, wait exits even if condition is not fulfilled
(but then waitsuccess=0).
QCOLLAPSE
= quick pre-collapsing during searches under mulpars (default)
- no quick pre-collapsing
QNELSEN
Estimate consensus. Options are: replications N, select N, strictperc N,
majorcut N. Search commands given in square brackets. Taxon exclusion with
"/" followed by list of taxa to exclude (from consensus; not from searches)
For each search, trees are collapsed according to current criterion. Option
"allow" works as in the resample command. When majorcut=100, then
the strict consensus for all replications is calculated.
QUOTE
copy from input to output until a semicolon is found
(if literal quotes is off, start on a new line, otherwise
new lines on output reflect new lines on input)
QUIT
quit the program
RANDTREES
N J K create N random trees, by adding taxa at each pre-existing
branch with same probability, probability J of collapsing
the new node, with up to K-furcations (default J = 0 )
/ randomize tree order
* randomly resolve non-binary trees
RATCHET
Ratchet, from trees in memory. Options are:
iter N number of iterations
[no]equal periodic rounds with original weights [not]
numsubs N number of replacements (i.e. accepted tree
rearrangements) to do in perturbation phase
upfactor N probability of upweighting a character
downfact N same, for downweighting
[no]autoconst N number of auto-constrained cycles
[no]giveup N percentage of full swap to complete during perturbation
findscore N if score N or better found, stop
[no]fuse NxR every N iterations, do R rounds of fusing to the N
trees
[no]dumpfuse if fusing fails to produce a better tree, [don't]
dump all the suboptimal trees
[no]tradrat [don't] run the original ratchet (i.e. noequal,
during perturbation swap to completion and don't
accept equally good rearrangements).
Options are set with "ratchet:[options];" or "ratchet=[options];"
(first case changes settings only, second case runs as well). With
"ratchet:;" current settings are displayed
RCOMPL
B Identify sequences that seem reverse-complemented in block
list B (only DNA blocks are processed; blocks with non-DNA
characters are skipped). The command calculates the edit cost
(Needleman-Wunsch) of the sequences as they are (A), and with
one of the sequences reverse-complemented (R). If A < R, then
both sequences are considered to point in the same direction
[if (R-A)/A < 0.2, then TNT considers that no decision as to
direction can be made]. If A > R, then it is assumed that one
of the sequences is reverse-complemented [again, only when
(A-R)/R > 0.2]. Using ">G" after the list of blocks, all
sequences (=taxa) that seem reverse-complemented are added
to taxon-group G.
RDIR
xxx set path for "run" files
REBUILD
Do a ratchet-like search, with perturbation provided by randomly pruning
taxa from current tree, re-inserting sequentially, and swapping with TBR.
This command is useful for very poorly structured data sets (e.g. random);
similar to the "*" option of the "hybrid" command, looped many times.
The number of nodes deleted can be a fixed proportion ("pclip") or an
absolute number ("clip"), of terminals or clades of a specified "size".
This is done repeatedly (as in the ratchet); optionally, it is possible to
use the (best) results of the cycles as input for tree-hybridization (with
settings from "tfuse" command). One of the best trees produced by
hybridization is then used to continue the rebuilding.
Options (possibly preceded by "no"):
clip J-K at every cycle, clip a number of nodes between J and K. If
this not specified (or 0), then it uses "pclip".
pclip N at every cycle, clip N% of the terminals or nodes.
size N maximum size of clade to clip (default=1). If N > 2, then
(by default, see "ancfirst" option), clades are re-inserted
back before their descendants. If this set to 0, then it
uses "psize".
psize N maximum size, as proportion (%) of number of taxa.
cycles N do N cycles of rebuilding.
reset N+S every N cycles that fail to produce a tree as good as best
tree found so far (plus S, if specified), reset tree to
best tree found so far and continue rebuilding from that one.
Default = "noreset".
hybrid N hybridize, N times, the best S trees produced by rebuilding
(S=sample size, determined with "sample"). Each round of
hybridization will use the results from as many cycles as
specified with "cycles". Default = "nohybrid".
sample N pass to the hybridizer the best N trees produced by rebuilding
ancfirst If clipping clades of more than 2 terminals, reinsert ancestors
before descendants. Default = yes.
keepall keep all trees produced by rebuilding, instead of best ones.
dump after hybridization, if too many trees match best score, retain
a small sample (10% of sample size), so that trees from new
cycles of rebuilding can be saved for subsequent hybridization.
With "no", hybridization becomes easily stalled by using a
fixed set of near-optimal trees. Default = yes.
Options are set with "rebuild:[options];" or "rebuild=[options];"
(first case changes settings only, second case runs as well). With
"rebuild:;" current settings are displayed.
RECONS
N/L; most parsimonious reconstructions for character(s) L, tree(s) N
REPORT
= report status of time-consuming operations
- don't (default)
+S/R/T; during searches, record status every S seconds, R replications,
or T trees swapped (no record = 0 )
[ with the +S option, also record progress bar when running
in background, every S seconds
] don't (default)
REROOT
N re-root tree(s) N, using current outgroup
[N re-root tree(s) N, using taxonomic outgroup (see "outgroup")
* also re-root tag-tree. The tags for groups which become paraphyletic
are assigned to the (now monophyletic) complement group (i.e. tags
remain in the same taxon partitions).
=P re-root tree(s) (and tree-tag, if using '*') on point P
(if rerooting several trees, and P is an internal node,
this may imply different rootings for different trees).
RESAMPLE
Resample matrix, and calculate group supports.
Usage: "resample options [ search commands ];" Options are:
jak use normal jacknifing (i.e. independent deletion)
sym use symmetric resampling, with p(up)=p(del)
boot use normal bootstrapping
poisson use Poisson-modified bootstrapping
probability N change probability for "jak" or "sym"
replications N number of replications
cut N cutoff frequency or support
slope summarize results with frequency slopes
gc summarize results with frequency differences
frequency summarize results with absolute frequencies
from N calculate support for groups in tree N
savetrees save consensus for each replication
allow during each replication, allow execution of
(almost) all commands, including dangerous ones.
This option should be used sparingly and only when
you really know what you're doing!
zerowt if doing symmetric resampling, eliminated (give
weight 0) to downweighted characters (=default);
otherwise, divide their weight by 2 (uncontra-
dicted groups appear in all replicates)
sibyl perform a backwards-jacknife; if used, this
must precede all other arguments. See below
for details.
errcount N valid only under sibyl. This counts the
proportion of groups (out of the total
supported groups) in the reduced data set
that are not supported in the complete data
set (wrong groups) and the proportion of groups
(out of the total) in reference tree N (presu-
mably, consensus of optimal trees for the
complete data set) that are not supported by
the reduced data set (mist groups).
Taxa can be excluded from consensus calculations, using "/" followed
by the list of taxa to exclude. All options are persistent, except
taxon exclusion and "from"
The backwards jacknife is not a measure of support, but provides
instead a sort of stability test. It deletes characters (under
independent character removal, with p(del)=0.33); for each case,
runs the data (as indicated within square brackets) and count the
number of groups supported by the reduced data set that are present
in all previously existing trees ("supported") or present in some
but not all existing trees ("compatible"). Divide that number by
the total number of groups supported in the reduced data set, or by
the total number of groups that _could_ be supported in the reduced
data set (i.e. nr. of taxa-2 , "normalized"). The existing trees must
be provided by the user, and should correspond to a set of optimal
trees under current settings. Other than search commands, only the
number of replications can be changed, and taxa can be disregarded.
RESOLS
N/L; show resolutions of polytomies in consensus of tree(s) N,
excluding taxon (taxa) L
[J] same, only for node J of consensus
& list resolutions
RFREQS
[T] N/L show frequency of approximmate recovery of groups
from reference tree T, in tree(s) N, excluding taxon
(taxa) L. For each group of T and each tree, it calculates
the "similarity" S to most similar group of tree, with
S defined as B/(B+(AxWa)+(RxWr)), where B=number of taxa
in both groups, or in neither (whichever is smallest),
A=number of taxa added to group, R=number of taxa
removed from group (Wa and Wr are weight factors to make
removal/addition more costly, set with "prunmaj")
If group adds/removes more than a certain proportion of
taxa (default is 0.333) then S=0.
RIDDUP
; deactivate duplicate taxa (according to current
character activities) and prune trees
*; same, but leave two identical taxa active and in
trees (takes into account zero-length branches)
- reactivate and reinsert duplicate inactive taxa
/ reinsert duplicates into tree-tags
RSEED
N set random seed as N ( 0 = time ; default = 1 )
+N increase random seed by N
*; set a new random seed, at random
[; in wagner trees, randomize insertion sequence
]; in wagner trees, try insertions for new taxa from
top to bottom or from bottom up (=default)
> in wagner trees, also randomize outgroup. This
cannot be done when there are constraints or
asymmetric Sankoff characters (randomization is
skipped). Note that some "xmult" options use
internal constraints (and then skip randomization)
< in wagner trees, outgroup is always the first taxon
placed in the tree (=default)
:N; in multiple randomizations, instead of making sure
that each new seed is different from the ones used
before, increase the seed by N. This may save time
in very extensive randomizations (where checking
previous seeds takes time). When N=0, checks previous
seeds (this the default).
! use quick approximation for randomization (faster)
- use careful randomizations (slower, more random; default)
RUN
xxx arg1 arg2 ... argN;
parses file xxx, replacing %i by arg i
(max. args. = 32, arg 0 is file name)
SAVE
save trees to file (previously opened with "tsave")
N save tree(s) N.
/ save last tree in memory
* save tree-tags in parenthetical notation
(tree-file must be parenthetical)
- save trees numbering only active taxa
(in combination with xread-, saves reduced
trees).
SCREEN
NxL use screen of N lines and L rows
SCORES
N calculate tree-scores (length or fit), for tree(s) N
!N same, optimizing polytomies as "soft"
SHPCOMP
Comparisons of tree-shapes. Work in progress.
SECTSCH
Do sectorial-search, starting from pre-existing trees. Options are:
For determining choice of sectors:
rss do random sector selections
css do constraint-based selections
[no]xss N+R do N exclusive (i.e. non-overlapping) sector selections,
covering all tree, and analyze each; repeat process R
times or rounds (after the last one, do global TBR).
If R is followed by -G, then global TBR is done every
G rounds (and after last one). Using B-E instead of N
division starts at B and ends at E (increasing or
decreasing, depending on whether E>B or B>E)
dss N D select nodes around node N, up to D (=diameter) branches
away from N, and analyze sector. This requires specification
of a tree; it never swaps at the end (as in noglobal)
[no]xeven for exclusive sectors, [don't] use sectors of as even
a size as possible (uneven sectors make it more likely
to find better trees if using several rounds
minsize N minimum size for random selections
maxsize N maximum size for random selections
minfork N minimum fork for constraint-based selections
maxfork N maximum fork for constraint-based selections
increase N factor to increase size if enough selections of current
size completed. New size is S = S + ( ( S * N ) / 100 )
selfact N factor to determine (under random selections) maximum number
of selections of size S, for T (active) taxa. Maximum
number, M, is determined as M = ( T * 100 ) / ( N * S ).
Alternatively, using "selfact = X Y Z" uses X for the
first selection, Y for the second, and so on (up to 30
values can be defined)
moveon N if N selections fail to produce a better score, move on
rounds N for constraint-based selections, cycle N times over groups
For determining analysis:
global N for smaller selections, do global TBR every N replacements
dglobal N same, for larger selections (i.e. under drift and combined)
noglobal never swap globally.
[no]equals accept equally good subtrees
[no]fuse N when analyzing small sector (below drift size), keep
all trees and fuse (N rounds). Note: for sectors above
drift size, the autofuse option of drift applies.
godrift N sector size above which tree-drifting (not RAS+TBR) is used
drift N for drifted sectors, use N cycles of drift
gocomb N for sector of size N or more, use combined analyses
(RAS+drift+fuse). If N is smaller than the size to
use drift, drift is not done. Number C of drift cycles
for each start is determined with drift C, number F of
fuses is determined with fuse F.
starts N for sectors below minsize, number of randaddseqs plus TBR
combstarts N for sectors above size for combined analyses, use N starts
(if first N yield same score, stop, else do N more starts)
findscore N stop drifting on tree if score N found
[no]keepall keep only the best trees [don't]
General options:
[no]safesank for sankoff characters, use strict checking (=default)
to identify uninformative characters for reduced data set
(looser checking may produce small speedups, but may miss
better trees for complex transformation costs).
slack N make N percent extra memory for searches (prevents
memory errors during runs
[no]xbuf if memory is available, use independent matrix-buffer
for analysis of sectors (=faster updates, significant
time saved for small sectors in large data sets).
recurse N allow sectorial searches to recurse up to N levels
tree N select sectors for tree N (instead of all trees)
track allow tracking nodes between big tree and reduced
tree (valid only for sectorial searches with user
instructions). This is to be used in combination
with macro expressions "nodtosect", "biginsect"
chkroot for XSS searches only, make sure the base of tree (which
often may be unselected) is included as well; this may
actually use one more selection than requested.
and "bignotsect". A slave running a sector (see
under "ptnt") always allows tracking.
Options are set with "sectsch:options;" or "sectsch=options;" (using
":" only settings are changed; "=" runs as well). With "sect:;"
current settings are displayed.
It is also possible to determine specifically how to search for
each sector generated, including the commands to search within square
brackets (including sectsch itself, possibly with user instructions as well).
Maximum level of recursion has to be determined with "sectsch: recurse N;"
before reading data set. When using user instructions for each sector,
any settings changed for analyzing a subproblem will remain changed after
concluding analysis of the sector (the only exception to this is settings
for sectsch itself).
SHORTREAD
xxx read trees (compact) from file xxx
=N xxx same, but place them in group N
>N xxx same, but add them to group N
SILENT
Control output to xxx:
=xxx; no output to xxx.
-xxx; output to xxx.
"xxx" can be "all," "file," "console," or "buffer."
SLFWT
Set parameters for auto-weighted optimizations (defaults in
square brackets):
exops N for characters with more than N states,
pre-check transformations and forbid those
not occurying under a lineal optimization. [5]
timeout N use no more than N seconds to calculate
optimization for any given character. [3600]
tolerance N accept reconstructions that differ from
optimal in N units of score. [0.0000001]
[no]polymorph during optimization, [don't] consider polymorphic
taxa as having a missing entry (=faster). [don't]
errmargin N during searches, re-check trees that are within
N units of fit above best score. [0.5]
[no]autotune N during searches, compare estimated and actual
scores of new trees, updating error margin
With N=1 (=level 1), error margin is changed only
within a given swapping cycle; with N=2, error
margin is retained after swapping [level 1].
maxtbr N during searches using TBR, reroot clipped clade
no more than N nodes away from original rooting
(maxtbr 0 = SPR). [5]
setlim N restrictpossible state-sets during optimization
for characters with N states or more. [4]
maxdist N M when restricting possible state sets, use union
of states in branches up to N nodes away above a
node, and M nodes below. [6-3]
[no]useminset when restricting possible state sets, use a set
corresponding to optimization under prior costs
(very fast, very prone to errors. [don't]
maxrepeat N when N successive branches have the same (unique)
state, consider them as fixed. [8]
[no]quickrat under this criterion, producing very few optimal
trees, ratchet and drifting tend to find (and
thus swap) the same tree many times; with this
option, when the tree resulting from the perturbation
phase of ratchet/drifting has the same score as the
best tree(s) found so far, the tree is not swapped
(this is applied only when auto-wt is ON). [yes]
backbuf N back up N pre-existing trees during swapping;
in case a tree is re-found, swapping is interrupted
(prevents cycling due to score miscalculation;
0 is no buffering). [0]
[no]verbose as characters are optimized, report progress.
SLAVEPROC
reserved for use by parent process, in parallel TNT
SMATRIX
=N (name) [costs]
defines a step-matrix. Syntax for costs is as in
"cost" command. N must be a number 0-31. Name is optional.
+name N
apply step matrix of specified name to character(s) N
; show defined step matrices
* save them (to read, must set "nstates / num;")
SORT
N sort tree(s) N, from best to worst
=nodes instead of sorting by score, sort by number of nodes
=size sort by number of taxa
=mono sort by number of violated constraints
SPRDIFF
J K NxS estimate number of SPR-swaps required to convert tree
J into tree K. The method used is heuristic, depending
on random seed. It does N replications, and reports
best estimation (if no N specified, then N=10); each of
the replications uses a "stratification" of up to S
levels (default S=0). Depending on the tree topologies,
the stratified procedure (more time-consuming) produces
better estimations. Using N+S instead of NxS, stratified
and regular procedures are alternated (keeping the best
overall values at the end). If one (or both) of the
trees have polytomies, then the distance is calculated
(by default, see below) between the closest dichotomous
resolution(s). The "similarity" is number of moves
divided by number of taxa - 3 (i.e. max. possible moves).
*J K NxS estimate SPR-swaps and show moves on tree diagrams
[K; count moves as weighted, with a move to D nodes away
costing D/(K+D). As K decreases, approaching 0, all
moves cost the same; as K gets larger, longer moves are
more costly. For reporting values, they're rescaled so
that the farthest possible move (nt-3) has a cost of 1.
Note that "[K;" only sets the value and type of compa-
risons to do in subsequent calls to "sprdiff" (or calls
to relevant macro expressions), without running.
Similarity is also obtained by dividing from number of
taxa minus 3 (i.e. max. possible number of farthest
possible moves, each of cost 1). The distance D of a
move equals degree of the polytmoy created when consen-
sing the trees before and after the move, minus 2.
]; in subsequent calls to "sprdiff", count raw moves.
It is also possible to search for SPR paths such that no move
has a node connecting to one of its ancestors (if the SPR path
is to be interpreted as indicating horizontal gene transfer,
such moves constitute a physical impossibility). For this, use
": noviol;" as argument ("viol" would allow such moves).
If you wish to count the moves needed to resolved/collapse
the polytomies of the tree(s), if any, then use ": poly;"
(keep in mind that this count is approximate!); default is
": nopoly;".
SUBOPT
NxR set suboptimal to N, relative suboptimal to R (note: relative
suboptimal is measured against tree being swapped, not against
best tree(s) found). Values of suboptimal used for subsequent
searches, or when collapsing trees with SPR or TBR.
SVTXT
J K save text-buffer lines J to L to output file (default = all)
SYSTEM
xxx<enter> run xxx in system
TABLES
= use optional table format
- use default table format
/N use N significant digits for floating point values (default=2)
TAGSET
N; set tag to N (parallel versions only)
TAXCODE
-N; de-activate taxon with number/name N (no N: show inactive taxa)
+N; activate (no N: show active taxa)
TAXLABELS
N report name of taxon N
xxx report number of taxon named xxx
TAXONOMY
Handle taxonomy contained in the taxon names, in GB->TNT format
(i.e. symbol "@" followed by the categories, separated by under-
scores).
= for subsequently read data sets, incorporate taxonomy
- don't [ =default, uses less RAM ]
; if taxonomy has been incorporated, display it as a tree
/ display taxonomy as an indented list
+ store taxonomic tree as last tree in RAM
*T label branches of tree(s) T which correspond to a taxonomic
group; extraneous taxa added to the group are indicated
as "+", taxa excluded as "-". The criterion for
choosing closest group in tree (if any) is determined as
for "prunmajor" and "rfreqs" commands. The tree list can
be followed by a list of categories, in the following format:
/L X-idae Z-idae
processes X-idae and Z-idae (with L levels within)
If L is followed by ">N", only subgroups of size N
or more are further subdivided
\L B-morphae
processes the subdivisions of B-morphae, up to L levels
below B-morphae. If L is followed by ">N", only groups
of size N or more are further subdivided
=xxx
processes all the taxonomy categories containing "xxx";
if you want to make sure that "xxx" occurs at the end
of the category, add an underscore (i.e. "xxx_").
The options "/", "\", and "=" can be combined.
&T as previous one, but results are output as a list. The tree list
may be optionally followed by a list of the categories to report
(default=all; note categories are referred to by name, not number,
since numbering is only internal to TNT; the numbering follows
that on the taxonomic tree). The command may end with "> A S",
where A and S are numbers of taxon-groups where to place taxa
added to the group, or subtracted from the group respectively, that
need to be removed to make the group monophyletic. Note that if the
symbol "&" is immediately followed by "?", then TNT asks
confirmation before placing taxa in groups.
| similar to previous one, but only reports best/worst cases (instead
of reporting tree-by-tree stats), and output list is indented.
<T shrinks the groups specified as in previous one (a single tree must be
specified in this case)
:T color tree-branches for specified groups, on tree(s) T
For each tree colored, the colors are stored in tree-tags, which
can be saved in SVG format with "ttag & filename colors"
Each group to color can be given as:
/X-idae Z-idae /A-idae /B-morphae
colors X-idae and Z-idae as state 0, A-idae as 1, and so on
(the option to include a number of sublevels is ignored here,
you must use "\" instead)
\L B-morphae
colors the subdivisions of B-morphae, up to L levels below
B-morphae, each with a different color. If L is followed by
">N", only groups of size N or more are further subdivided
=xxx
colors all the taxonomy categories containing "xxx",
each with a different color
The options "/", "\", and "=" can also be combined.
TAXNAME
= when referring to terminal nodes, use names
- don't (=default)
/XXX N rename taxa N as XXX (if XXX is *, rename at random;
if XXX is > or <, switches name to upper or lower
case, respectively).
+N allow taxon names of length N
[N on output, truncate taxon names to N letters. Use "!" to
truncate to species only (i.e. to "@" or cuadruple-underscore)
] don't
:T =G re-locate list of taxa T in taxonomic group G. This changes taxon
names and re-processses taxonomy. Optionally, group G may be
followed by "+ _Supergroup_Group_Subgroup" --case in which
the specified categories are added to the newly located taxa;
or it may followed by "=C" or ">C", case in which all
categories beyond "C" in the relocated taxa are preserved
(exclusive, or inclusive, respectively). The latter amounts
to transferring an entire group (with its sub-classification)
to a different higher group.
TCHOOSE
N select tree N (use scopes, + and -)
/ select last memory tree, discard the rest
TCOMP
M N/L show groups in tree M absent from N, excluding taxon (taxa) L
*M N/L same, keeping tree as last memory tree
[ show only compatible groups
] show only contradictory groups
=N/M/L calculate RI resulting from mapping the MRP of each tree
in set N onto each tree of set M, excluding taxon (taxa) L.
Note this is NOT equivalent to =M/N/L (RI is asymmetric).
&M N/L plot tree N, showing for each group the equivalent group in
tree M (if none, "X").
! T/L report PCR values (Pol & Escapa, 2009) for tree(s) T, taxa L.
if "=N" precedes list of taxa, then it reports worst N
values. Using ">G" at the end, it puts listed taxa in
taxon-group G.
Note that the "=" and "&" options allow for taxon exclusion, but
never use temporary collapsing of unsupported groups.
TEQUAL
Show duplicate trees
TFUSE
/S C T; create a new tree from trees S ("source") and T ("target")
inserting clade C of tree S into equivalent position of tree T
(clade C must be present in both trees; trees must be complete
and binary)
N combine set of trees N, and add resulting trees to existing set of
trees.
Options (possibly preceded by "no" and defaults in parentheses):
For tree-fusing:
[no]equals accept exchanges of equal score (don't)
[no]beststart use best tree to start (use it)
[no]choose choose only those exchanges that improve best score
found so far (don't)
[no]repeat for every individual fuse, re-fuse trees until
no exchanges improve it
[no]swap after exchanging clades, do TBR swap (swap)
minfork N if node is less than an N-polytomy in consensus of
both trees, skip exchanges (3)
rounds N use N rounds (5)
[no]keepall keep all trees found instead of best only (all)
[no]xroot N for each fuse, try N different (random) rootings
(N=0 is the default; it uses only outgroup as root)
For tree-hybridization:
[no]hybrid N*R/S instead of tree-fusing, use hybridization (as in
"hybrid" command). Hybridize randomly chosen pairs
of trees, N times, for each round R. Every round uses
the best S trees from previous round to continue hybri-
dizing. Defaults: N 1000, R 1, S 50 (S = 0 uses as many
trees as initially input, when doing several rounds.
Works better than fusing for very unstructured data sets
(e.g. random).
[no]autostop N if N successive rounds of hybridization fail to improve
score, stop (default = 3).
[no]replace if hybridizing two trees produces a better tree, then
replace source tree(s) with the better tree(s)
(default = yes).
[no]clog N If initial tree set increased to contain N times more
trees than the initial input, retain best 1/N trees
(default = 15).
For selecting type of genetic algorithm:
[no]picktype N calculate a score for the expected outcome of fusing;
this score counts the proportion of groups that could
be exchanged between different pairs of trees in the
input trees (when few or no groups can be exchanged,
as is often the case for random data sets, tree-fusing
produces very poor results). If the score so calculated
is above N, use fusing, if below, use hybridization.
The default is "nopicktype"; if "picktype" specified
without a number, it uses the default threshold (1.5)
Large thresholds preferentially choose hybridization,
and viceversa.
Options are set with "tfuse:options;" or "tfuse=options;" (using
":" only settings are changed; "=" runs as well). With "tfuse:;"
current settings are displayed.
TGROUP
Define group(s) of trees
Usage:
"tgroup =N (xxx) J [K L M] len=X nod=X siz=X mono *R;"
places in group number N, optionally named "xxx," the tree(s)
subsequently specified with J (tree(s) number J), or in group(s)
K and L and M, or having a length, number of resolved nodes, or
terminals included, equal to X, or satisfying constraints, or R
trees chosen at random. Symbol = can be replaced by > or < in
the case of len, nod, or siz. If the =N is replaced by >N or <N,
subsequently specified trees are added or removed from group N.
Several =N (or >N or <N) can follow a command; every one takes
into account previous ones. Subsequent to definitions of tree groups,
group(s) of trees can be identified within scopes by referring to them
enclosing the group number/name in curly braces. By default, trees
read or calculated are placed automatically in groups; this can be
toggled with "tgroup/;". To undefine group N, use "tgroup -N;".
Saving current groups is done with "tgroup*;". The default
maximum number of tree groups (32) can be set to N with "tgroup+N;"
(this must be done prior to reading the data). Whether newly
read or created trees are automatically added to tree groups is
toggled with / (default is on), or set to a specific value with
"tgroup [no]auto".
THANKS
show acknowledgments
TIMEOUT
set timeout for searches (hh:mm:ss)
In Linux versions: if running in the background, creating a
file "stop_tnt_ID" in the working directory automatically
sets the timeout for searches to 1 sec., thus interrupting
all searches.
TNODES
N count nodes in tree(s) N
TPLOT
N show tree(s) N.
*N show tree(s) N in parenthetical notation.
/ show only last tree in memory
+ draw trees more symmetrically (they're taller!)
- draw trees with default format
If + or - are followed by + or - this turns on (+)
or off (-) whether second heaviest clade is drawn
first in polytomies.
TREAD
read tree(s) in parenthetical notation; semicolon ends;
'*' separates trees. Using "=N" (or ">N") as first argument, the
trees are placed in (or added to) group N.
The tree-definition can be done using taxon names or numbers
(if using a name, the first taxon matching the name is used).
Alternatively, a string followed by three periods (no spaces in
in between) will place in the corresponding location all taxa
whose name matches the string provided. Also, using @T N will
place all the taxa that belong to node N of tree T in the corres-
ponding location. Using a + instead of the @, the sub-tree N
of tree T is copied (and then this is just one node, so make
sure you don't enclose +T N within parentheses, which causes an
error).
TSAVE
open tree files (with + at the end, append)
xxx open in compact (default) mode
*xxx open in parentethical notation, using taxon names
or numbers (see under "taxname")
/ close tree file
!t xxx autosave results to file, every t seconds (t can be given
as hh:mm:ss). For maximum safety, results alternatively saved
to files xxx-1 and xxx-2 (if power fails when saving, the
previous one remains).
TSHRINK
Define groups of terminals to shrink tree. Usage: tshrink =N name list ;
Replacing N by "+" names next available group of taxa. Symbols
"]" and "[" deactivate/activate subsequently specified shrinks;
symbol "-" undefines them. "Tshrink*" saves subsequently specified
tree(s) in parenthetical notation, but shrinking internal nodes.
Shrinks may use a lot of memory (specially in large data sets). If
you want memory for shrinks to not be allocated, use "tshrink !;"
before reading the data set ("tshrink +" will allocate the memory).
TSIZE
N count number of taxa included in tree(s) N
TTAGS
; show tree tag(s).
= store tree tags for subsequent tree printing command(s)
(first tree printing command sets the target tree)
( synonym of "="
) stop storing tags (but don't erase them)
- clear all existing tags
+N txt write txt to node N of target tree
<N erase (i.e. reduce to a minimum) tree-tag for node N
*N set tree N as target tree (no labels written). Using
"!" instead of "*N" the last tree is used
/; save tags in a readable form
[ separate tags in new lines, using "\" as separator
for each legend (only in graphic trees)
] don't
&xxx save tree-tags as tree diagram, in SVG (Scalable Vector
Graphics, XML) format, to file "xxx". File name
may be followed by:
blength N branch span (width)
bheight N branch height
thickness N branch thickness N
colors save as colors. In this case, the color
is determined by the first digit in the tree-
legend; more than a single digit (or a non-digit)
colors the branch as gray (=ambiguous). A text
can also be displayed, if the color code is
followed by a forward slash and text.
fontsize N use a font size of N
pendwidth N use a font of stroke N (=boldness)
txtsep N if using multi-line legends, separate lines
by N points
legup N raise branch legnds by N points
The resulting SVG file can be opened with any appropriate program
(including most web browsers: Firefox, Opera, Safari, Chrome).
Color codes (from 0 to 9) are red, blue, green, cyan, brown, pink
orange, purple, magenta, and yellow. Instead of these color codes,
it is also possible to indicate RGB codes (in parentheses, separated
by commas, optionally followed by a fourth number indicating branch
thickness before closing the parenthesis).
NB: thanks to Salvador Arias for showing me the SVG format!
NB2: If you wish to display a text in a specific color (with 0-9, IUPAC
codes for DNA, or RGB codes), then precede the text by a forward
slash and precede the slash by the color code.
TXTSIZE
N set size of display buffer to N Kb
; report buffer usage
= set buffer to compressed mode (slower viewing; default)
- set buffer to uncompressed mode (faster viewing)
/ report approx. amount of disk space needed for text buffer
TZERT
X Y insert groups of tree X onto tree Y
VIEW
xxx view file xxx
+ auto-view text-buffer on
- auto-view text-buffer off
; view text-buffer (text-buffer has all the output). Arrow keys
move buffer. Pressing ":" followed by a string, the string
is searched in the text-buffer (& repeats).
While in viewer:
- up one line
+ down one line
o up one screen
p down one screen
e end
h home
l left half a screen
r right half a screen
ESC exit buffer viewer
See also txtsize, svtxt.
VVERSION
show version
WARN
= issue warnings
- don't (default)
WATCH
= time execution of commands
- don't (default)
[ in addition to time, measure RAM (bytes) used by each command
] don't (default)
XCOMP
N compare fit, character by character, between reference tree and
tree(s) N. Must have defined a tree as reference, with "xcomp =X."
XGROUP
define character group(s). Syntax is as in "tgroup" (but options "len",
"nod", "siz", or "mono" are not allowed, option "/" automatically
creates a group with each data block, and "xgroup !;" saves only)
active characters)
XINACT
Deactivate all uninformative characters in matrix
XMULT
Run multiple replications, using sectorial searches, drifting, ratchet
and fusing combined. Options are:
hits N produce N hits to best length and stop
replications N for each hit, search initially with N replications
[no]targetscore N search until score N found (only with fusing)
[no]update do not update targetscore
[no]giveupscore N give up search as soon as score N found
[no]rss use random sectorial searches (settings with
sectsch:options)
[no]css use constraint sectorial searches (settings with
sectsch:options)
[no]xss use exclusive sectorial searches (settings with
sectsch:options)
[no]fuse use fusing (settings with tfuse:options)
[no]gfuse N every N hits, fuse all trees (=score check)
[no]dumpfuse if fusing fails to produce trees of target score,
dump the trees produced by fusing (may prevent
"clogging" of subsequent fuses by keeping only the
most distinct trees)
[no]rebuild N use N cycles of rebuilding (other settings with
"rebuild: options;").
[no]drift N use N cycles of drifting (settings with drif:options)
[no]ratchet N use N cycles of ratchet (settings with rat:options)
hold N for ratchet, drifting, or rebuilding, save up to N
trees per initial replication (default = 1).
[no]autoconst N use consensus of previous run and initial stages of
current as constraint for initial stages. 1=previous
and wagner, 2=previous and SPR, 3=previous and TBR.
The first replication of a new hit is never
constrained (i.e. hits are totally independent).
Note that level=2 defaults to 1 when "skipspr"
is on.
[no]xmix after unsuccesful fusing, start a new set of
replications as autoconstrained (otherwise, don't)
[no]prvmix if trees existed in memory before running xmult, use
last one to autoconstrain first xmult replication
[no]consense N consense untill consensus is stabilized N times
conbase N base hits to check for consensus stabilizations
(larger numbers make more reliable estimations)
confactor N factor to increase number of hits to check consensus
stabilization (10-100, larger numbers: more reliable)
conmax N maximum new hits to recheck consensus (default=12)
[no]keepall keep trees from all replications. This has a different
meaning when "hits" is 1 (=default) and when "hits" >1.
When "hits" = 1, it is trees from each of the RAS + TBR +
SS or DFT or RAT, in addition to the trees resulting from
fusing those. When "hits" > 1, then it means the trees
resulting from fusing the initial starting trees for each
of starting points. Thus, to find N trees, each resulting
from S starting points (RAS+TBR+etc) and fusing, use
"xmult = hit N noupdate rep S keepall".
[no]retouch N before trying new replications, repeat sectorial
search and ratchet/drifting
level N set level of search (0-10). Use 0-2 for easy data
sets, 2-5 for medium, above 5 for difficult
chklevel N check search parameters during run, every N hits.
The parameters are increased or decreased, starting
from user settings. If N is preceded by +F (between
0 and 2), the entire level is changed by F. If N is
preceded by -, user settings are starting point
[no]multiply after hitting target score, find additional trees by
fusing suboptimal with optimal trees (default = yes).
[no]verbose produce verbose reports
[no]hybrid use hybridization; this can be used jointly with
tree-fusing. Number of hybridizations, rounds, sample
size, and unsuccesful rounds to stop, are set with
the "tfuse" command. When combined with "picktype",
a number x F can follow "hybrid" --this is the factor
to multiply the number of replications if "hybrid" is
chosen instead of "fuse". Fusing normally needs fewer
trees as input (it is for more structured data sets), but
when "pick" is used, genetic algorithm is determined at
run time, thus user cant't predict ahead of time which
genetic algorithm will be used. As example, with "pick
hybrid x4 repl 5", if fusing is picked, then it will use
(initially, at least) 5 replications for fusing; if
hybridization is picked, then it will use 20 replications.
[no]picktype N use either fusing or hybridization, choosing with
threshold N (see under "tfuse"). This uses only one
type of genetic algorithm; if you want both to be used,
just set them both. If using "verbose", then choice is
indicated on screen.
[no]hfuse N every N hits to minimum length, hybridize all resulting
trees as an extra check for optimality.
ras,cas,ias, select type of addition sequence for the Wagner trees (if
sas,fas not specified, the one last used with "mult" is used).
Options are set with "xmult:options;" or "xmult=options;" (using
":" only settings are changed; "=" runs as well). With "xmult:;"
current settings are displayed. If consensing, / followed by a taxon list
removes the specified taxa from the consensus (this must follow all the
other options). If css, rss, and xss are specified css is done first,
then rss, and xss last. Rebuilding, ratchet, and drifting (in that order)
always follow sectorial searches. Global hybridization and/or tree-fusing
are done last (although they may be done as part of rebuilding, ratchet,
or drifting).
XPERM
N/L; permute states within character(s) N, for taxa L
-; undo last permutation
XPIWE
Handle options for extended implied weighting
- set extended options OFF
= use extended implied weight (use character sets for constant
or "set weighting", and/or different weighting strengths for
different characters). Character sets defined with "xpiwe[" are
weighted using average homoplasy in the set. For a set of N
characters with total homoplasy H, the score for the set is
(H/N)
N * ---------
(H/N) + k
Sets defined with "xpiwe/" have constant weight. Note that set
weighting is peculiar in making parsimony-uninformative characters
relevant to the analysis; for set weighting, when user-defined
weighting functions are in effect, TNT needs to extrapolate costs
(since it uses average numbers of steps). When combining different
weighting strengths in an analysis, the fitting function for all
characters is rescaled so that the first extra step (i.e. no
homoplasy) costs the same for all characters.
NOTE: extended implied weighting is valid only under "piwe=",
not "piwe+", and to apply it you must read the data with
implied weights turned ON.
/ define a set of characters with constant weight. Usage is:
/NxF L, where L is the list of characters for which every step
costs the same as F times the cost of adding 1 step to a
character with N extra steps (under the "base" concavity,
or the user-defined weighting function).
[L define a set of characters (L) for homogeneous "set weighting".
If L is (optionally) followed by "=N", then the set L is
divided in subsets or "chunks" of N consecutive characters
each. If L is followed instead by "/" and a partition
(e.g. in the form "12:3" or "1:2:3") then the first,
second, and third positions within list L are grouped. Not
specifying 1, 2 or 3 leaves those positions outside the subset(s).
NOTE: when user-weighting function are in effect, weighting-sets
require calculating fit for fractional (i.e. non-discrete)
numbers of extra-steps; this is done by interpolating (on
the fitting function assembled from the user-defined cost
function) using the same interpolator of the macro expression
"intpol".
] like previous one, but it does all data blocks automatically
(e.g. "xpiwe]/12:3;" creates a set for 1st and 2nd position,
and another with 3d, for each of the data blocks, while
"xpiwe]=10;" divides each of the data blocks in chunks of
10 characters each)
* write to log file the list of characters in weighting sets,
and the list of characters with fixed weights, in a format
readable by TNT
&L report status of weighting sets for tree(s) in list L. If list
preceded by strings "steps", "score", "homoplasy", or
"size", then it reports the corresponding value (default is
"size"). Under different concavities, you can also report
the concavity values of each set ("kvalue") or cost of adding
a step to an average character in the set ("cost")
!L remove characters in list L from weighting sets and from the set of
characters with fixed weight.
( handle implied weighting with different concavities for different
characters. The symbol "(" can be followed either by "*" or by
a list L of characters. The "*" (see below) determines different
weighting strengths based on numbers of missing entries; with a
list L, the user defines the concavity for the characters
specified in L. N.B.: the values of concavities (or the cost
of adding steps for the different characters) are shown by the
"piwe&" command, not by this one.
(* Option:
This option is intended to address the problem that characters
with many missing entries cannot have much homplasy, and thus
normally have high implied weights during analyses. With
"( *P <M /K", missing entries are assumed to have (for the
purpose of calculating fit differences) a proportion P of the
homoplasy which occurs in observed entries . Thus, if P is 1
and half the cells in a character are missing entries, the cost
of adding a step to a character with H extra steps is (approxi-
mmately) the same as the cost of adding a step to a character
with 2H steps. If no P is specified, the default (0.5) is
used. The approximmation used with the default weighting
function is based on using different K values, given that for
the standard weighting function, the cost of adding a step to
a character with N extra steps, under K1, is approximmately the
same as adding a step to a character with N.K1/K2 extra steps
under concavity K2. Thus, characters with more missing entries
get lower K values (i.e. they decrease their influence more
quickly as homoplasy increases, but are equally influential in
the absence of homoplasy). M determines the maximum acceptable
ratio between K1/K2 (1<=M). If no M is specified, the default
(5) is used. The value K determines the "base" concavity (i.e.
the concavity for a character with no missing entries); if "/K"
not included, general concavity is used. Note that P=0 or M=1
are equivalent to standard implied weighting. If weighting sets
have been defined (with the "xpiwe[" or "xpiwe]" options), TNT
will honor those sets (extrapolating from the average homoplasy
in the observed entries to the total missing entries in the set).
When a user-defined weighting function is in effect, then the
K values are used as factors for extrapolation to missing entries
(a character with concavity K, under general concavity G, is
considered to have G/K times the homoplasy observed in the
non-missing entries). Remember, this means that the cost of
adding a step to a character with S steps is the same as the cost
of adding a step to a character with G/K times the observed
homoplasy, not G/K times the step cost! The interpolator uses
the cost function defined by the user (not the fit function
assembled from it; note that the two options might produce
slightly different results).
(L Option:
with "(L /K", all the characters in list L get concavity K.
Initial concavities can be set with the previous option, and
then modified with this one (case in which TNT will honor the
last set of concavity values determined by the user). Keep in
mind that if weighting sets have been defined, all the
characters in a set must have the same concavity! When user-
defined weighting functions are in effect, k is used (as in the
previous option) as a factor to extrapolate.
) use a single concavity (or user-defined weighting function) for
all characters.
XREAD
Read data; Hennig86/NONA format. Interleaved: each block preceded by "&"
and block options within square brackets. Block options are:
continuous continuous
dna DNA data
proteins aminoacid data
numeric alphanumeric data
landmark 2D,3D read two- or three-dimensional data (landmark coords.)
Each "character" can consist of several points; use
"|" to separate characters, and ? for missing.
gaps/nogaps read gaps as fifth state / missing
trimhead if data are DNA or AA, and gap is fifth state,
make all leading gaps missing entries
trimtail likewise, for trailing gaps
match N consider names of similarity N, as the same
the same taxon (with 1 identical)
verbose give stats for each block
Editing data:
=C T S set states for taxon T, character C, to set S.
If T is within square brackets, then it can be
a list of taxa.
=!C T S same, but do not re-check minima-maxima (saves
time, but unless "xread ==;" is used, subsequent
optimizations may be wrong. Use with caution!)
== check informativeness for all characters (=undoes
possible side-effects of previous one).
Saving data:
* all chars. (followed by "*" also saves char. settings)
- only active (followed by "*" also saves char. settings)
[ only active, randomizing order of characters (=mangling)
!T/C save only taxon names and chars. (no xread, no ccode),
for taxon list T, character list C (default=all).
If list T preceded by "(N)" (where N is a tree-number),
then T may contain a list of HTU's for tree number N.
Generating data:
/C T N; random data with C characters and T taxa (each of N states
equiprobable at each cell)
+T P C N; Neyman/Jukes-Cantor data, using tree T as model, probability
of stasis P, C characters, and N states. If P = 0 , then it
assigns branch lengths at random. If "T P" is replaced by
"!", then branch-lengths in tree-tags are used (and tag-tree
is used as model tree).
>T P N L as previous one, but L is the list of characters to generate.
("T P" can also be replaced by "!").
XWIPE
Remove data set from memory (allows changing settings)
UNIQUE
discard duplicate trees (without collapsing)
* collapse first and then discard duplicates
UNSHARED
= prune unshared taxa from trees when calculating consensus (default)
- don't
USMINMAX
N =M set minimum number of steps for (sankoff) character(s) N to M
(if 0, turns user-minimum off for the character(s) specified).
+N set maximum number of states for all sankoff character(s) N to M
(in optimization, try those states even if absent in terminals).
This does NOT apply to sankoff characters which correspond to a
character-state tree, which always use the actual maximum.
ZZZ
Go to sleep!! (=quit)
BANDB
Generate all trees, and execute [commands] for each one
Syntax is:
bandb [ commands ] ; stop
The trees generated include intermediate trees; the generated
tree is always the last one in memory (if no trees existed when
bandb started, then tree 0). The tree can be modified or copied
onto other trees with [commands]. After bandb finishes, it leaves
a polytomous tree as tree 0 if bandb started without trees, or as
the Nth tree if N trees were in memory (this is done so that
tree-numbers continue being the same as within bandb).
Within bandb, the following commands are recognized:
cutbranch don't continue descending into search tree
continue skip subsequent instructions for this tree
endbranch interrupt process
When running bandb, variables percswap, bbfull, and bbtax
are recognized.
COMBINE
Enter a loop, enumerating combinations. Syntax is:
combine X min/max varname ... endcomb
which enumerates the combination of min out of X elements,
then min+1 out of X, min+2 out of X, ... max out of X. If
"/max" is ommited, then max = min. The elements are written
to variable "varname" (must be an array), and listsize equals
number of elements minus 1 (keep in mind that listsize can be
subsequently modified within the loop, make sure to store value
at the beggining of loop if this is so).
Note: maximum possible recursion of "combine" is the same as
for "travtree" and "iterrecs".
CONTINUE
skip to next loop iteration
COPYTREE
X Y; copy tree X to tree Y (if no Y is specified, tree
X is added as last memory tree). If the first tree is
specified as *, then the constraint tree is copied; if
as +, then tagged tree is copied.
Note: with the "[" option, if taxonomy is enabled,
and a tagged tree exists, then the tags in tag-tree are
copied onto the taxonomy; this options also modifies
taxon names, so as to contain taxonomy (at least, within
available space for taxon names). Note that this option
will collapse untagged nodes in the tagged tree (since
they represent no category).
CHKBREAK
Check for user interrupt
CUTBRANCH
in bandb, don't descend into search tree
ELSE
execute subsequent block of instructions when preceding IF not fulfilled
END
finish an IF block
ENDBRANCH
terminate bandb
ENDLOOP
terminate loop
ENDSWAP
terminate swapping
ERRMSG
xxx; call error handler with error xxx
FORFILES
Loop, for all filenames matching a given string, executing command(s).
Syntax is:
forfiles fname ... command(s)... stop
this will run "command(s)" for all file(s) matching "fname".
Within "forfiles", the string "killfiles" interrupts subsequent
iterations, and "proc/;" terminates current iteration.
The current file is retrieved with "$curfile"; "curisdir" indicates
whether current file is a directory. If you need to indicate spaces
within "fname", use the "^" symbol (just like file names in other
contexts). Note that file names containing symbols used as sigils
for scripting (symbols ', ", $, or #) are skipped.
GOTO
fname L [args]; goto file "fname", and start parsing from
point labeled L (with "label L;")
=fname; define "fname" as default target
-; undefine default target
[fname L; define "fname" and "L" as the file
and label to parse AFTER an error/break.
This is intended mostly to allow writing
exit codes for graceful script termination.
HIFILE
Handle input files (for parsing).
=N; set maximum number of open input files to N.
open xxx open file xxx (can open several at a time; last)
one is set as "active" file).
active xxx set file xxx as active file.
list list open input files.
close [xxx ] close file xxx (if unspecified, close
active input file).
skip [xxx ] N skip N bytes (default=1) from file xxx (if
unspecified, active file).
skipline [xxx ] N skip N lines from file xxx (if unspecified,
active file).
seek [xxx ] C N read from file xxx (if unspecified, active
file), until character C found (&N=ASCII N),
N times.
skips [xxx ] N skip N strings from file xxx (if unspecified,
active file).
seeks [xxx ] S N find string S in file xxx (if unspecified,
active file), N times.
Note that "open" and "active" (which must be given a file
name) do not use square brackets around file name, while the
other options (for which file name is optional), require brackets.
Except for setting maximum number of input files, the other options
can be combined together (a semicolon ends execution of hifile).
See also expressions hifline, hifchar, hifstring, hifnumber, hifeof.
IF
Take decisions. Expressions are as in C, but with
precedence always evaluated from left to right, for
all operations/comparisons. Use parentheses to change
precedences. Operators: + - * / and bitwise AND/OR/XOR (&|^)
Comparisons (==, !=, >, <, >=, <=) take on value 0 or 1.
Use && and || for logical AND/OR, and ! for negation.
Every IF must be matched by either END or ELSE.
ITERRECS
Loop over reconstructions of a character, writing states to an
array. Syntax is:
iterrecs T C rayname (actions) ; endrecs
For every reconstruction of character C on tree T, this stores
the values on array "rayname" and executes action(s).
Within iterrecs, 'rayname[N]' automatically returns number of
state (as a number, not as a bit set; this is different from
the "states" expression). If name of array is preceded by &,
then in case a cell (=node) in the array is different from
"missing", it considers only reconstructions having that
state at that node (if the value is positive or 0), or only
reconstructions not having that state (if the value is negative;
to forbid state 0, set the value to a negative number between
0 and -1, which gets rounded as "-0"). Note that states can
be forbidden only for discrete characters.
When reconstructions are too numerous, it is possible to take
a random sample of no more than N reconstructions (where each
reconstruction is equally likely to be sampled), using "/N"
before the name of the array.
If character C is continuous, it can be followed by "*D",
where D is the increase between reconstructions (otherwise,
the interval limits are used). Using "+" instead, the values
written in the array are the (signed) differences between ancestor
and descendant for each node (as in blength > or <).
Within iterrecs, the string "killrecs" interrupts execution,
and expression "recsteps" returns the cost of the reconstruction
(if forcing states, this may be larger than minimum length).
The command iterrecs can be nested (maximum level of nesting can
be set with iterrecs = N; default is 5). Nesting iterrecs may
require that "mxproc" is reset as well.
KILLFILES
Skip subsequent iterations of "forfiles" command
LABEL
N; mark point as label (see "goto").
LOOP
Do a loop, of the form:
loop X+Z Y (actions) stop
this repeats (actions) from X to Y, increasing (or
decreasing) by Z (default Z = 1). The expression "#N"
is replaced by the value corresponding to Nth loop. An
alternative syntax is:
loop = loopname X+Z Y (actions) stop
case in which "#loopname" is equivalent to the value of
current iteration. The default maximum number of nested
loops allowed is 15, but it can be changed with macro* to
any number.
MACFLOAT
Determine floating-point options for macro language
=; floating point calculations enabled
-; use only integer calculations (saves memory space, not speed)
N; if floating point enabled, uses N decimal digits when printing
floats (0 uses no digits; equivalent to integer only, but
uses more memory)
e; if floating point enabled, use exponential notation
*; if floating point enabled, use default printing mode
MACRO
= activate macro language
- deactivate
*K N re-set max. number of loops as K, user variables as N
[N re-set memory to be used by macro language as N (KB)
+ in macros, read taxon/character names as numbers
! don't read taxon/character names as numbers
prot N set protection level for macros as N
0 no protection
1 check whether accesses to arrays are within dimensions
2 prevent re-assembling of multidimensional arrays by user
MACREPORT
= inform results of comparisons/assignments during macros (=debugging)
- don't (default)
MACSEED
N set seed for random number generator for macros
MAKETABLE
Followed by number/name of one-dimensional array, displays in a table
the values for the array (copying everything from the array name to a
semicolon into the table title). If title preceded by "=N", then it
displays up to N values in the table. Using '*' as first argument,
it displays two arrays in a combined table. Maketable is illegal when
macro protection is off; combined tables are illegal when floating
point is enabled. Only values >= 0 can be displayed. In double
tables, if one array has more values than the other, the invalid cells
are displayed as "0."
Maketable can also be used to copy values from tables to arrays:
with "maketable + varname;" subsequent invocations of any command
which writes (single valued) tables will store the values in array
"varname". Variable "listsize" contains number of values written
to array minus 1. Use "maketable -;" to subsequently turn this off.
PRIVATE
N; keep N variables (besides named ones) as private
PROGRESS
create/update progress bar. Usage: progress j k text, where
j= done, k= to do, text= everything until a semicolon is
found. Always must close progress bar with "progress/;"
Report can be "refreshed" with "progress=;".
RECURSE
recursively call the input file being parsed (arguments
to "recurse" are passed to the input file)
RESETSWAP
save current rearrangement and re-start swapping
(valid only within tsprit or tbrit commands)
RESETTIME
re-set time for macros
RETURN
N; set value of internal variable "exstatus" to N
SAFE
xxx N ; string xxx can be "vars,", "loops,", or "ram"; it checks
whether N variables, loops, or bytes for macro are free, and
reports an error otherwise
SET
Set value of user variables
N set value of variable N to subsequent expression.
N $ set variable N as string (semicolon ends).
Fixed strings (output only): $dataset, $taxon N,
$character N, $state N S, $block N, $agroup N,
$tgroup N, $xgroup N, $bitset N, $dnabitset N,
$taxonomy N, $curfile, $ttag N, $hifstring, $curwd
and $host N.
+ when converting strings (with $varname), add a blank
at the end.
- don't.
SETARRAY
J,...,K,L XXX
set all cells of variable XXX, of dimensions Jx...xLxK (expression
must be followed by Jx...xKxL values, ending with a semicolon)
SETLOOP
N; reset loop to N
SLAVEGET
Get variables from slaves. Syntax is:
slaveget [ J T ] mmm ttt ;
this copies the results from variable ttt in task T of job J
onto variable mmm of master. If no task is specified, the
values from ttt on task i are copied onto mmm[i] (or the
corresponding section of mmm, if subindices had been indicated
for mmm itself, case in which in the number of dimensions
in mmm and ttt must match. In the subindices of ttt, user
variables enclosed in single quotes (') are interpreted locally,
in double quotes ("), interpreted in slave.
SLAVESET
[J T] set variable in slave T of job J (syntax as in set;
no T = all tasks of job J). User-variables enclosed in
single quotes (') are interpreted locally, in double
quotes ("), interpreted in slave.
SPRIT
"sprit N (commands) stop" does SPR to tree N, executing "commands"
for each rearrangement (see also resetswap, endswap)
TBRIT
"tbrit N (commands) stop" does TBR to tree N, executing "commands"
for each rearrangement (see also resetswap, endswap, continue)
TRAVTREE
Loop, travelling a specified tree, T. Syntax is:
travtree type T N varname (actions) ; endtrav
in every cycle, the number of node visited is written onto
the specified variable. Type can be one of four:
up travels tree in an unpward pass, from node N; if "up"
is followed by the string "terms" it also does terminals,
otherwise it doesn't
down travels in a down pass, towards node N, terminals never
included
below travels from node N towards root
path travels from nodes N1 to N2 (two nodes instead of one
must be specified for "path")
des visits all immediate descendants of node N
The variable can be preceded by a minus sign (-), case in which
node N itself is not included in the list. Within travtree,
the command "killtrav" ends current travelling, and (in the
case of up-passes) the command "skipdes" excludes all the
descendants of current node from the loop.
Note that the order in which nodes are travelled in scripting
commands may not agree with the sequence with which nodes are
plotted in tree diagrams. If you want to make sure that scripts
use the same sequence as in plotting, turn this option ON with
"travtree +" (OFF with "-").
VAR
N; report name and value of variable N (no N = all vars.)
/N; same, using bits (up to 30)
= N XXX; name variable number N as "XXX." Replacing the N by a '+'
names the next variable. Variables cannot be renamed, but
variables named within a file can be denamed with '-'. This
allows variables to behave as "static" within a file. If
several variables have identical names, using the name
accesses the last one named (e.g. in the current file).
: name variables, using a looser format than with =. All that
is neded here is a list of names (and their dimensions).
-N; dename all variables above N (no N = all variables named from
within the current input file.
N; if N is defined as an array, report all the values in the array
N*; same, saving in "setarray" format (readable by the program)
+ display a (very simple) graph with the values of two arrays.
Syntax is:
var + X [ minx maxx] Y [ miny maxy ] array_A array_B ;
X is the number of spaces to use on X-axis, Y is number of
lines to use on Y-axis; minx and maxy are starting and end
points of X axis, likewise for Y (if unspecified, min/max
values in the array are used). Array_A and array_B are names
of (one-dimensional) arrays; the graph plots array_B[i]
against array_A[i]; if array_A doesn't have the same number
of values as array_B, then the minimum number is
used; if array_B is not specified, then the graph plots
array_A[i] against i (for each of the values in array_A).
&X Y linear regression of variables X and Y (must be arrays). If
*W follows Y, then weights in W are used. Weights must be
between 0 and 1 (if some weights exceed unity, all weights
are rescaled; having a point of weight W is equivalent to
having W points with those coordinates instead of one). If
a number N follows after the arrays, then only the first
N values of the arrays are considered in the regression.
| File name | File type | Size | |
|---|---|---|---|
| Aquickie.run | ASCII English text | 10.23 kB | Info |
| blens.run | ISO-8859 text | 1.13 kB | Info |
| Blens_tntwiki.run | ISO-8859 text | 1.13 kB | Info |
| Blockboot.run | ASCII C program text | 2.54 kB | Info |
| Bremer.run | ASCII C program text | 17.78 kB | Info |
| ccor.run | ASCII English text | 31.71 kB | Info |
| Colorgroups.run | ASCII English text | 1.1 kB | Info |
| combosearch.run | ASCII English text | 9.53 kB | Info |
| delcor.run | ASCII English text | 42.56 kB | Info |
| Dohi.run | ASCII C program text | 2.03 kB | Info |
| Export_tps.run | ASCII English text | 1.38 kB | Info |
| hybtree.run | ASCII English text | 2.8 kB | Info |
| Ild.run | ISO-8859 English text | 2.4 kB | Info |
| ildtnt.run | ASCII English text | 3.45 kB | Info |
| Implied_w.run | ASCII English text | 2.7 kB | Info |
| landmark_search.run | ASCII English text | 1.2 kB | Info |
| mergetags.run | ASCII English text | 929 Bytes | Info |
| MSM.run | ASCII C program text | 7.73 kB | Info |
| Mytaxo.run | ASCII English text | 8.47 kB | Info |
| partbremers.run | ASCII English text | 2.41 kB | Info |
| pbsup.run | ASCII English text | 4.52 kB | Info |
| Pol_Norell_2001_stratigraphic_fit_MSM.zip | Zip archive data | 418.13 kB | Info |
| Pol_Norell_2006_TNT_age_uncertainty.zip | Zip archive data | 428.72 kB | Info |
| procbremers.run | ASCII English text | 2.49 kB | Info |
| psecboot.run | ASCII English text | 6.19 kB | Info |
| RF_distances.run | ASCII text | 355 Bytes | Info |
| secboot.run | ASCII English text | 4.77 kB | Info |
| Stats.run | ASCII text | 484 Bytes | Info |
| supwt.run | ASCII English text | 5.79 kB | Info |
| templetontest.run | ASCII English text | 241.78 kB | Info |
| Term_lengths.run | ASCII English text | 1.01 kB | Info |
| tosvg.run | ASCII English text | 5.36 kB | Info |
| TTS.run | ASCII English text | 1.12 kB | Info |
| xdelcor.run | ASCII English text | 42.76 kB | Info |
| xmultloop.run | ASCII text | 1.1 kB | Info |