Mercurial > repos > dawe > srf2fastq
view srf2fastq/io_lib-1.12.2/docs/ZTR_format @ 0:d901c9f41a6a default tip
Migrated tool version 1.0.1 from old tool shed archive to new tool shed repository
| author | dawe |
|---|---|
| date | Tue, 07 Jun 2011 17:48:05 -0400 |
| parents | |
| children |
line wrap: on
line source
Notes: 28th May 2008 For version 2.0 consider the following: 1) Remove defunct or useless chunk types and compression formats. 2) Rationalise inconsitent behaviour (eg endianness on zlib chunk). 3) Support split header/data formats for SRF 4) Formalise meta-data use better. 5) More pie-in-the-sky ideas? What we've described so far could easily be said to be v1.4. It's backwards compatible and fairly minor is change. If we truely want to go for version 2 then taking the chance to remove all those niggles that we've kept purely for backwards compatibility would be good. In more detail: 1) Removal of RLE and floating point chebyshev polynomials. Mark XRLE as deprecated? We may wish to add an extra option to XRLE2 to indicate the repeat count before specifying the remaining run-length. This breaks the format though. (Or add XRLE3 to allow such control?) 2) Strange things I can see are: 2.1) All chunks use big-endian data except for zlib which has a little-endian length. 2.2) The order that data is stored in differs per chunk type. For trace data we store all As, then all Cs, all Gs and finally all Ts. For confidence values we store called first followed by remaining. Both SMP4 and CNF4 essentially hold 1 piece of data per base type per base position, it's just the word size and packing order that differs. This means TSHIFT and QSHIFT compression types are tied very much to trace and quality value chunks, rather than being generic transforms. Maybe we should always have the same encoding order and some standard compression/transformations to reorder as desired. An example: All data related per call is stored in the natural order produced. (eg as utilised in CNF1, BPOS). All data related per base-type per call is stored in the order produced: A, C, G, T for the first base position, A, C, G, T for the second position, and so on. Then we have standard filters that can swap between ACGTACGTACGT... and AAA...CCC...GGG...TTT... or to <called><non-called * 3>... order (which requires a BASE chunk present to encode/decode). We'd have 1, 2 and 4 byte variants of such filters. They do not need to understand the nature of the data they're manipulating, just the word size and a predetermined order to shuffle the data around in. For CNF4 a combination of {ACGT}* to {<called><non-called*3>}* followed by {ACGT}* to A*C*G*T* ordering would end up with all <called> followed by all 3 remaining non-called. Ie as it is now (which we then promptly "undo" in solexa data by using TSHIFT).a 3) I'm wondering if there's mileage here in having negative lengths to indicate constant data + variable data further on. Eg length -10 means the next 10 bytes are the start of the data for this chunk. Some stage later we'll read a 4-byte length followed by the remaining data for this chunk. Rationale: often we end up with many identical bytes at the start of a chunk. For example, we take a solexa trace (0 0 value...), run it through TSHIFT (80 0 0 0 previous data => 80 0 0 0 0 0 value ...) and then through STHUFF (77 80(eg) data), but data is the compressed stream always starting with 80 0 0 0 0 0 so typically it's always the same starting string. Tested on an SRF file I see SMP4 always starting with the same 9 bytes of data, BASE starting with the same 3 bytes and CNF4 always starting with the same 7 bytes. Hence we'd have lengths -9, -3 and -7 in the chunk headers and move that common data to the header block too. That's approx 3% of the size of our SRF file. 4) I propose *all* chunks have some standard meta-data fields available for use. These can be: 4.1) GROUP - all chunks sharing the same GROUP value are considered as being related to one another. This provides a mechanism for multiple base-call, base position and confidence value chunks while still knowing which confidence values belong to which call. It also allows for multiple SAMP chunks (instead of the SMP4 chunk) to be collated together if desired. I don't expect many ZTR files to contain calls from multiple base-callers, but it's maybe a nice extension and seems quite a simple/clean use of meta-data. 4.2) ENCODING - the default encoding for the chunk data is as described in the chunk. We may however wish to override this and, for example, store SMP4 data as 32-bit floating point values instead of 16-bit integers. This specifies that. Question: do we want this available universally everywhere? If not, we should at least use the same meta-data keyword for all occurrences. 4.3) TRANSFORM - a simple transformation description. This is essentially a mini-formula. It replaces the OFFS meta-data used in SMP4 which is simply a transform of X+value. 5) There are more generic ways to save storage by removing redundancy. Most probably they're not worth it, but I list them here for discussion still. 5.1) Use 7-bit variable sized encodings for values instead of fixed 32-bit sizes. Eg instead of storing 1000 as 0x3*0x100 + 0xe8 (00 00 03 e8) we could store it as 0x7*0x80 + 0x68 (80|07 68). The logic here being setting the top bit implies this isn't the final value and more data follows. It allows for variable sized fields so that small numbers take up fewer bytes. The same can be applied to data in SRF structs too. Realistically it saves 2 bytes per record in SRF and an unknown amount for ZTR - estimated 8 or so (3 for cnf4/base and 2 for smp4). It's only 1.5% saving though in total. 5.2) A general purpose dictionary system. Instead of attempting to move headers to one area and data somewhere else, possibly also taking common portions of data and putting that somewhere too, we could provide a dictionary system whereby we previously remove redundancy by replacing all occurrences of a particular byte pattern with a new shorter code. (We'd need an escape mechanism for when it occurs by chance.) The dictionary can then be specified in it's own chunk which is stored in the header portion. This then works for portions of chunk header (eg if the meta-data changes) rather than full headers, where the data blocks always start with the same text, or where we want to have sensible names in text fields but don't like them taking up too much space. It's maybe a bit messy though and complex to implement, plus it's unknown how big an impact having to escape accidental dictionary codes from appearing in real data. The more formal way of removing redundancy is probably better. 5.3) Lossy compression. I believe there's still room for this, although it needs careful thought. The floating point format really isn't an ideal way to do it though, so I'd much rather have an encoding system that uses N*log(signal/M+1) plus a sign bit, stored in integers. As we store data in integers the value of N combined with the maximum value for log(signal/M+1) gives us the number of bits we wish to encode to. Essentially we're storing the log value to a fixed point precision. The value of M dictates the slope of the errors we get from logging. It's hard to describe, but basically as signal gets larger our average error in storing the signal also gets larger. That's true for floating point values too as there's a fixed number of bits and they're being used to represent larger and larger values, meaning the resolution drops. I have various test code and graphs showing error profiles for logs vs fixed point vs floating point. Logs or fixed point are nearly always preferable to a floating point format for size vs accuracy. ----------------------------------------------------------------------------- CHANGE (since 1.2): SAMP and SMP4 now has meta data fields indicating the zero base-line. CLARIFICATION The specification now explicitly states that trace samples are unsigned, although the new OFFS meta-data can be used to turn these into signed values. CLARIFICATION We explicitly state that multiple TEXT chunks maybe present in the ZTR file and will be concatenated together. Also the trailing (nul) byte is now optional. CHANGE Added CSET (character set) meta-data for BASEs so ABI SOLID encoding can be used. This removes the requirement of IUPAC characters only. CHANGE Added XRLE2, QSHIFT, TSHIFT and STHUFF compression types. INCOMPATIBLE CHANGE: I propose for this version to make all meta-data adhere to a specific format rather than adhoc. It'll consist of zero or more copies of 'identifier nul value nul'. See the format below for details. The only use of meta-data in 1.2 was for SAMP (not SMP4) chunks to indicate the channel the data came from. From now on file readers will need to check the version number in the header to determine how to parse the SAMP meta-data. [Search for "FIXME" for my comments / questions to be answered. They elaborate on the summary below and provide more context.] QUESTION1: Should we adapt ZTR to not be so inefficient with regards to tiny chunks. Specifically a 5 byte chunk size, 4 byte meta-data size (normally zero anyway) and 4 byte data length is all wasteful. These combined comprise 5-10% of the total SRF size. Note that changing this would break backwards compatibility. QUESTION2: Do I need a means to specify the "default meta-data". Specifically if we have lots of SAMP chunks (for example) and every single one is stating that the zero "offset" value is 32768 then we may want a mechanism of specifying that the default OFFS value is 32768 for all subsequent SAMP chunks. One possible way to do this is to have a new chunk type which sets the default. Eg for the SAMP chunk we could define a SaMP chunk to modify the default for SAMP. This seems oddly named, but it's utilising the bit5 of the 2nd byte which so far has been reserved as zero. (In the first byte bit 5 set => private namespace and not part of the public spec.) For now I'm just ignoring this issue though. QUESTION3: I've defined new transforms named TSHIFT and QSHIFT specifically designed for adjusting the layout of CND4 and SMP4 chunk types to an order more amenable for compression by interlaced deflate. They do the job, but I'm wondering if it's better to simply redefine the input data to be a more consistent ordering so that we can define more general purpose transforms rather than one dedicated to the original trace layout and one for the quality layout. I'm ignoring this for now as it would break backwards compatibility. QUESTION4: For the OFFS meta-data in SMP4 and SAMP chunks I have a 16-bit offset to specify the zero position. Ie OFFS of 10000 means a sample of 9000 becomes -1000 after processing. Should it be a signed or unsigned 16-bit value. Signed means we could encode values ranging from 10000 to 70000 by specify OFFS as -10000. Should it be 32-bit instead? Should we have OFFI and OFFF for integer and floating point equivalents? QUESTION5: For region encoding where should the region name belong - the meta-data section or the REGION_LIST TEXT identifier? It's currently in both places. My gut instinct tells me it belongs in the meta-data for the REGION_LIST chunk itself. QUESTION6: Can we have clarification on what the region code types mean, specifically "tech read". QUESTION7: Should we add SAMP/SMP4 meta-data indicating a down-scale factor? For 454 data this could be 100, so we know value 123 is really 1.23. Note this is maybe better implemented below using fixed-point precision. QUESTION8: How do we deal with floating point values? I think the chunk meta-data should detail the format of the data block itself (as it is strictly speaking data about the data so it fits there well). A lack of meta data should imply the usual unsigned 16-bit quantities. There's two main ways to encode fractions: Floating point where we have a mantissa and an exponent. - See http://en.wikipedia.org/wiki/IEEE_floating-point_standard - large dynamic range - fixed number of significant bits - varying "resolution". Ie can represent tiny differences between two very small floating point numbers, but not between two very large floating point numbers. Fixed point where we have a fixed number of bits for the component before and after the decimal point. - See http://en.wikipedia.org/wiki/Q_%28number_format%29 - constant resolution - effectively used by SFF (specified to 2 decimal places) - easy to treat as integers so can be fast and dealt with by small embedded CPUs without FPUs. Floating point maybe appropriate as effectively it's the same as logging your signals and storing those. It offers large dynamic range so can cope with abnormally large values (at the expense of precision) while retaining lots of variation at the low end to distinguish small values. However it's CPU intensive to cope with anything other than the CPU provided 32-bit and 64-bit floating point formats. Single precision 32-bit floats in IEEE-754 have: 1 bit (31): Sign 8 bits (23-30): Exponent (bias 127, so stroring 100 => -27) 23 bits (0-22): Mantissa Effectively we store any binary value as a normalised expression: <exponent> 1.<mantissa> * 2 Eg 1732.5: => 11011000100.1 (binary) => 1.10110001001 (binary) * 2^10 Exponent+127 => 137 => 10001001 (binary) sign exponent mantissa 0 10001001 10110001001000000000000 (17325 => 0x43ad => 0x0010001110101101 However we probably want 16-bit and 24-bit floating point types for efficiencies sake. Do we go with some fixed predefined floating point formats for 8-bit, 16-bit, 24-bit and 32-bit layouts (with 32-bit being identical to IEEE754) or do we allow for specification of the mantissa and exponent Eg FLOAT=23.8, FLOAT=17.6 or FLOAT=5.2 in the meta-data block? FLOAT=17.6 (24-bit) gives ranges +/- 8.6*10^9 FLOAT=5.2 (8-bit) gives ranges +/- 64 (I think). Alternatively if we restrict ourselves to only using the most significant 14 bits of the mantissa then storing as standard 32-bit floats implies 1 in every 4 bytes is zero. This may provide for a very crude, but fast way to implement reduced size floating point values - ie FLOAT=15.8 (24-bit signed). For fixed point (as in SFF values) there's already a draft standard for implementation in C (ISO/IEC TR 18037:2004). One benefit of fixed point over floating point is speed of implementation. Fixed point numbers can just be dealt with as integers. Eg subtracting two fixed point 16-bit values can be done in integers using a-b and the result is the same as if we'd done all the bit twiddling and maths directly simulating a real fixed-point unit. My gut feeling is that we'd want to explicitly declare the number of bits for integral and fractional components in the meta-data block. Comments? James PS. The latest (only minor tweaks from before) ZTR draft spec follows. 1.3 draft 3 (19 Oct 2007) ZTR SPEC v1.3 ============= Header ====== The header consists of an 8 byte magic number (see below), followed by a 1-byte major version number and 1-byte minor version number. Changes in minor numbers should not cause problems for parsers. It indicates a change in chunk types (different contents), but the file format is the same. The major number is reserved for any incompatible file format changes (which hopefully should be never). /* The header */ typedef struct { unsigned char magic[8]; /* 0xae5a54520d0a1a0a (b.e.) */ unsigned char version_major; /* 1 */ unsigned char version_minor; /* 3 */ } ztr_header_t; /* The ZTR magic numbers */ #define ZTR_MAGIC "\256ZTR\r\n\032\n" #define ZTR_VERSION_MAJOR 1 #define ZTR_VERSION_MINOR 3 So the total header will consist of: Byte number 0 1 2 3 4 5 6 7 8 9 +--+--+--+--+--+--+--+--+--+--+ Hex values |ae 5a 54 52 0d 0a 1a 0a|01 03| +--+--+--+--+--+--+--+--+--+--+ Chunk format ============ The basic structure of a ZTR file is (header,chunk*) - ie header followed by zero or more chunks. Each chunk consists of a type, some meta-data and some data, along with the lengths of both the meta-data and data. Byte number 0 1 2 3 4 5 6 7 8 9 +--+--+--+--+----+----+----+---+--+ - +--+--+--+--+--+-- - --+ Hex values | type |meta-data length | meta-data |data length| data .. | +--+--+--+--+----+----+----+---+--+ - +--+--+--+--+--+-- - --+ FIXME: For very short reads this is a large overhead. We have 8 bytes of length information (of which typically only 1-2 are non-zero) and 4 bytes for type (which typically only has one of 4-5 values). This means about 10 bytes wasted per chunk, or maybe 5-10% of the total file size. Changing this would be a radical departure from ZTR; is it justified given the savings? (est. 4.8% for 74bp reads, 8.4% for 27bp reads). One idea if to consider a ZTR file (the non "block" components at least) to be a series of huffman codes, by default all 8-bit long and matching their ASCII codes. Then a dedicated chunk could be used to adjust these default codes. It's therefore backwards compatible, but is that also overkill? (NB, this looks like it'd save 6% on the overall file size.) Ie in C: typedef struct { uint4 type; /* chunk type (b.e.) */ uint4 mdlength; /* length of meta-data field (b.e.) */ char *mdata; /* meta data */ uint4 dlength; /* length of data field (b.e.) */ char *data; /* a format byte and the data itself */ } ztr_chunk_t; All 2 and 4-byte integer values are stored in big endian format. The meta-data is uncompressed (and so it does not start with a format byte). From version 1.3 onwards meta-data is defined to be in key value pairs adhering to the same structure defined in the TEXT chunk ("key\0value\0"). Exceptions are made for this only for purposes of backwards compatibility in the SAMP chunk type. The contents of the meta-data is chunk specific, and many chunk types will have no meta-data. In this case the meta-data length field will be zero and this will be followed immediately by the data-length field. Ie all meta-data adheres to the following structure: Meta-data: (version 1.3 onwards only) +- - -+--+- - -+--+- -+- - -+--+- - -+--+ Hex values | ident | 0| value | 0| - | ident | 0| value | 0| +- - -+--+- - -+--+- -+- - -+--+- - -+--+ FIXME: Can we have specify the meta-data once per ZTR file and omit it in subsequent chunks? Eg a blank chunk with meta-data only in the header. Chunks in the body then specify meta-data length as 0xFFFFFFFF as an indicator meaning "use the last meta-data defined for this chunk type". Useful when split in two, as in SRF? Note that this means both ident and values must not themselves contain the zero byte (a nul character), hence we generally store ident-value pairs in ASCII string forms. The data length ("dlength") is the length in bytes of the entire 'data' block, including the format information held within it. The first byte of the data consists of a format byte. The most basic format is zero - indicating that the data is "as is"; it's the real thing. Other formats exist in order to encode various filtering and compression techniques. The information encoded in the next bytes will depend on the format byte. RAW (#0) - no formatting -------- Byte number 0 1 2 N +--+--+-- - --+ Hex values | 0| raw data | +--+--+-- - --+ Raw data has no compression or filtering. It just contains the unprocessed data. It consists of a one byte header (0) indicating raw format followed by N bytes of data. RLE (#1) - simple run-length encoding ------- Byte number 0 1 2 3 4 5 6 7 8 N +--+----+----+-----+-----+-------+--+--+--+-- - --+--+--+ Hex values | 1| Uncompressed length | guard | run length encoded data| +--+----+----+-----+-----+-------+--+--+--+-- - --+--+--+ Run length encoding replaces stretches of N identical bytes (with value V) with the guard byte G followed by N and V. All other byte values are stored as normal, except for occurrences of the guard byte, which is stored as G 0. For example with a guard value of 8: Input data: 20 9 9 9 9 9 10 9 8 7 Output data: 1 (rle format) 0 0 0 10 (original length) 8 (guard) 20 8 5 9 10 9 8 0 7 (rle data) ZLIB (#2) - see RFC 1950 --------- Byte number 0 1 2 3 4 5 6 7 N +--+----+----+-----+-----+--+--+--+-- - --+ Hex values | 2| Uncompressed length | Zlib encoded data| +--+----+----+-----+-----+--+--+--+-- - --+ This uses the zlib code to compress a data stream. The ZLIB data may itself be encoded using a variety of methods (LZ77, Huffman), but zlib will automatically determine the format itself. Often using zlib mode Z_HUFFMAN_ONLY will provide best compression when combined with other filtering techniques. XRLE (#3) - multi-byte run-length encoding --------- Byte number 0 1 2 3 4 5 N +--+------+-------+--+--+--+-- - --+--+--+ Hex values | 3| size | guard | run length encoded data| +--+------+-------+--+--+--+-- - --+--+--+ Much standard RLE, but this mechanism has a byte to specify the length of the data item we compare to check for runs. It is not restricted to spotted runs aligned on 'size' byte boundaries either. No uncompressed length is encoded here as technically this is not required (although it does make decoding a bit slower). The compressed length alone is sufficient to work out the uncompressed length after decompressing. Guard bytes in the input stream are 'escaped' by the replacing the guard byte followed by zero. Guard bytes in a parameterised run (ie X copies of Y where Y contains the guard) do not need to be 'escaped' Input data: 10 12 12 13 12 13 12 13 12 13 14 Output data: 3 (xrle format) 2 (size of blocks to compare) 12 (guard, 12 is a bad choice but illustrative) 10 12 0 12 4 12 13 14 (rle data) XRLE2 (#4) - word aligned multi-byte run-length encoding ---------- Version 1.3 onwards Byte number 0 1 RSZ multiple of RSZ +--+-----+---------+-- - - - - - - - - - ---+ Hex values | 4| RSZ | padding | run length encoded data| +--+-----+---------+-- - - - - - - - - - ---+ This achieves the same goal as XRLE, but is designed to maintain data aligned to specific 'record size' boundaries. This sometimes has benefits over XRLE in that subsequent a interlaced deflate entropy encoding may work better on record-aligned data streams. The first byte holds the format (#4) while the record size (RSZ) is held in the second byte. In order to ensure the entire block of data is aligned on 'RSZ' bounaries RSZ-2 padding bytes are written out before the data itself starts. The contents of these bytes can be anything. Unlike XRLE it also does not use an explicit guard byte. If we term a 'word' to be a block of data of size RSZ, then whenever we read a word which is identical to the last word written then we write out that word (so we have two consecutive words in the output data) followed by a counter of how many additional copies of that word are found, up to 255. This counter consists of 1 byte indicating the number of additional copies of the word followed by RSZ-1 padding bytes to maintain word alignment. While the contents of these padding bytes may be anything, it is suggested that they adhere to same value distribution as observed elsewhere in the data block in order to keep the data entropy low. (For example repeating the previous bytes from 'word' will do.) Example: Input data: taken in pairs: 1 0 2 2 2 2 3 1 3 1 3 1 2 4 2 4 2 4 2 3 Output data: 4 2 (xrle2 format, rec size 2) 1 0 ("1 0" from input) 2 2 2 2 0 2 ("2 2" x 2) 3 1 3 1 1 1 ("3 1" x 3) 2 4 2 4 1 4 ("2 4" x 3) 2 3 ("2 3") DELTA1 (#64) - 8-bit delta ------------ Byte number 0 1 2 N +--+-------------+-- - --+ Hex values |40| Delta level | data | +--+-------------+-- - --+ This technique replaces successive bytes with their differences. The level indicates how many rounds of differencing to apply, which should be between 1 and 3. For determining the first difference we compare against zero. All differences are internally performed using unsigned values with automatic an wrap-around (taking the bottom 8-bits). Hence 2-1 is 1 and 1-2 is 255. For example, with level set to 1: Input data: 10 20 10 200 190 5 Output data: 1 (delta1 format) 1 (level) 10 10 246 190 246 71 (delta data) For level set to 2: Input data: 10 20 10 200 190 5 Output data: 1 (delta1 format) 2 (level) 10 0 236 200 56 81 (delta data) DELTA2 (#65) - 16-bit delta ------------ Byte number 0 1 2 N +--+-------------+-- - --+ Hex values |41| Delta level | data | +--+-------------+-- - --+ This format is as data format 64 except that the input data is read in 2-byte values, so we take the difference between successive 16-bit numbers. For example "0x10 0x20 0x30 0x10" (4 8-bit numbers; 2 16-bit numbers) yields "0x10 0x20 0x1f 0xf0". All 16-bit input data is assumed to be aligned to the start of the buffer and is assumed to be in big-endian format. DELTA2 (#66) - 32-bit delta ------------ Byte number 0 1 2 3 4 N +--+-------------+--+--+-- - --+ Hex values |42| Delta level | 0| 0| data | +--+-------------+--+--+-- - --+ This format is as data formats 64 and 65 except that the input data is read in 4-byte values, so we take the difference between successive 32-bit numbers. Two padding bytes (2 and 3) should always be set to zero. Their purpose is to make sure that the compressed block is still aligned on a 4-byte boundary (hence making it easy to pass straight into the 32to8 filter). Data format 67-69/0x43-0x45 - reserved --------------------------- At present these are reserved for dynamic differencing where the 'level' field varies - applying the appropriate level for each section of data. Experimental at present... 16TO8 (#70) - 16 to 8 bit conversion ----------- Byte number 0 +--+-- - --+ Hex values |46| data | +--+-- - --+ This method assumes that the input data is a series of big endian 2-byte signed integer values. If the value is in the range of -127 to +127 inclusive then it is written as a single signed byte in the output stream, otherwise we write out -128 followed by the 2-byte value (in big endian format). This method works well following one of the delta techniques as most of the 16-bit values are typically then small enough to fit in one byte. Example input data: 0 10 0 5 -1 -5 0 200 -4 -32 (bytes) (As 16-bit big-endian values: 10 5 -5 200 -800) Output data: 70 (16-to-8 format) 10 5 -5 -128 0 200 -128 -4 -32 32TO8 (#71) - 32 to 8 bit conversion ----------- Byte number 0 +--+-- - --+ Hex values |47| data | +--+-- - --+ This format is similar to format 16TO8, but we are reducing 32-bit numbers (big endian) to 8-bit numbers. FOLLOW1 (#72) - "follow" predictor ------------- Byte number 0 1 FF 100 101 N +--+-- - - - --+-- - --+ Hex values |48| follow bytes | data | +--+-- - - - --+-- - --+ For each symbol we compute the most frequent symbol following it. This is stored in the "follow bytes" block (256 bytes). The first character in the data block is stored as-is. Then for each subsequent character we store the difference between the predicted character value (obtained by using follow[previous_character]) and the real value. This is a very crude, but fast, method of removing some residual non-randomness in the input data and so will reduce the data entropy. It is best to use this prior to entropy encoding (such as huffman encoding). CHEB445 (#73) - floating point 16-bit chebyshev polynomial predictor ------------- Version 1.1 only. Deprecated: replaced by format 74 in Version 1.2. WARNING: This method was experimental and have been replaced with an integer equivalent. The floating point method may give system specific results. Byte number 0 1 2 N +--+--+-- - --+ Hex values |49| 0| data | +--+--+-- - --+ This method takes big-endian 16-bit data and attempts to curve-fit it using chebyshev polynomials. The exact method employed uses the 4 preceeding values to calculate chebyshev polynomials with 5 coefficents. Of these 5 coefficients only 4 are used to predict the next value. Then we store the difference between the predicted value and the real value. This procedure is repeated throughout each 16-bit value in the data. The first four 16-bit values are stored with a simple 1-level 16-bit delta function. Reversing the predictor follows the same procedure, except now adding the differences between stored value and predicted value to get the real value. ICHEB (#74) - integer based 16-bit chebyshev polynomial predictor ----------- Version 1.2 onwards This replaces the floating point CHEB445 format in ZTR v1.1. Byte number 0 1 2 N +--+--+-- - --+ Hex values |4A| 0| data | +--+--+-- - --+ This method takes big-endian 16-bit data and attempts to curve-fit it using chebyshev polynomials. The exact method employed uses the 4 preceeding values to calculate chebyshev polynomials with 5 coefficents. Of these 5 coefficients only 4 are used to predict the next value. Then we store the difference between the predicted value and the real value. This procedure is repeated throughout each 16-bit value in the data. The first four 16-bit values are stored with a simple 1-level 16-bit delta function. Reversing the predictor follows the same procedure, except now adding the differences between stored value and predicted value to get the real value. STHUFF (#77) - Interlaced Deflate ------------ Version 1.3 onwards Byte number 0 1 2 N +--+--+-- - - - - - --+-- - - --+ Hex values |4D| C| huffman codes | data | +--+--+-- - - - - - --+-- - - --+ This compresses data using huffman encoding using the Deflate algorithm for storing the codes and data. It is analogous to using zlib with the Z_HUFFMAN_ONLY strategy and a negative window size. However it has a few tweaks for optimal compression of very small data sets. See RFC 1951 for details of Deflate. If the following text is in decrepancy with RFC 1951 then the RFC takes priority. The following is included as additional explanatory material only. Huffman compression works by replacing each character (or 'symbol') with a string of bits. Common symbols have are encoded using few bits and rare symbols need a longer string of bits. The net effect is that the overall number of bits needed to store a message is reduced. To uncompress a compressed data stream it is necessary to know which symbols are present and what their bit-strings are. For brevity this is achieved by storing only the lengths of the bit-string for each symbol and generating bit-strings from the lengths. As long as the same canonical algorithm is used in both the encoder and decoder then knowing the lengths alone is sufficient. Knowledge of this algorithm is required for uncompressing the data, so it is defined as follows: 1. Sort symbols by the length of their bit-strings, smallest first. The collating order for symbols sharing the same length is defined as ASCII values 0 to 255 inclusive followed by the EOF symbol. 2. X = 0 3. For all bit lengths 'L' from 1 to 24 inclusive: For all Symbols of bit length 'L', sorted as above: Code(Symbol) = least significant 'L' bits of X X = X + 1 End loop X = X * 2 End loop This is the same algorithm utilised in the Deflate algorithm (RFC 1951). For example compressing "abracadabra" gives: /\ 0 1 Symbol bit-length Code(X) / \ ------------------------------- a /\ a 1 0 0 / \ b 3 4 100 0 1 c 3 5 101 / \ r 3 6 110 / \ d 4 14 1110 /\ /\ EOF 4 15 1111 0 1 0 1 / \ / \ which in turn leads to 28 bits b c r /\ of output: 0 1 / \ 0100110010101110010011001111 d EOF (ab r ac ad ab r aEOF) In the data format defined above, 'C' is a code-set number. If it is zero the the huffman codes to uncompress 'data' are stored in the following bytes using the same format describe in the DFLH chunk type below, otherwise no huffman codes are stored and a predefined set of huffman codes are used being either defined in a preceeding DFLH chunk (for 128 <= 'C' <= 255) or statically defined in this document (for 1 <= 'C' <= 127). Immediately following this is the compressed bit-stream itself. The statically defined huffman code-sets are as follows. The symbols are listed below as their printable ASCII character or hash followed by a number, so A and #65 are the same symbol. We use the algorithm described above to turn these bit-lengths into actual huffman codes. C=1: CODE_DNA Length Symbols ---------------- 2 A C T 3 G 4 N 5 #0 6 EOF 13 #1 to #6 inclusive 14 #7 to #255 except where already listed above C=2: CODE_DNA_AMBIG (DNA with IUPAC ambiguity codes) Length Symbols ---------------- 2 A C T 3 G 4 N 7 #0 #45 8 B D H K M R S V W Y 11 EOF 14 #226 15 #1 to #255 except where already listed above C=3: CODE_ENGLISH (English text) Length Symbols ---------------- 3 #32 e 4 a i n o s t 5 d h l r u 6 #10 #13 #44 c f g m p w y 7 #46 b v 8 #34 I k 9 #45 A N T 10 #39 #59 #63 B C E H M S W x 11 #33 0 1 F G 15 #0 to #255 except where already listed above It is recommended that this compression format is used only for small data sizes and ZLIB is used for larger (a few K and above) data. QSHIFT (#79) - 4-byte quality reorder ------------ Version 1.3 onwards This reorders the quality signal to be 4-tuples of the quality for the called base followed by the quality of the other 3 base types in the order they appear in a,c,g,t (minus the called base). The purpose is to allow a 4-byte interlaced deflate algorithm to operate efficiently. TSHIFT (#70) - 8-byte trace reorder ------------ Version 1.3 onwards This reorders the trace signal to be 4-tuples of the 16-bit trace signals for the called base followed by the signal from the other 3 base types in the order they appear in a,c,g,t (minus the called base). The purpose is to allow a 8-byte interlaced deflate algorithm to operate efficiently. FIXME: QSHIFT and TSHIFT could be general purpose byte rearrangements without any knowledge of the data type they're holding. They need the input data to be consistently ordered and not the large differences we see between quality and trace right now. Version 1.3 onwards Chunk types =========== As described above, each chunk has a type. The format of the data contained in the chunk data field (when written in format 0) is described below. Note that no chunks are mandatory. It is valid to have no chunks at all. However some chunk types may depend on the existance of others. This will be indicated below, where applicable. Each chunk type is stored as a 4-byte value. Bit 5 of the first byte is used to indicate whether the chunk type is part of the public ZTR spec (bit 5 of first byte == 0) or is a private/custom type (bit 5 of first byte == 1). Bit 5 of the remaining 3 bytes is reserved - they must always be set to zero. Practically speaking this means that public chunk types consist entirely of upper case letters (eg TEXT) whereas private chunk types start with a lowercase letter (eg tEXT). Note that in this example TEXT and tEXT are completely independent types and they may have no more relationship with each other than (for example) TEXT and BPOS types. It is valid to have multiples of some chunks (eg text chunks), but not for others (such as base calls). The order of chunks does not matter unless explicitly specified. A chunk may have meta-data associated with it. This is data about the data chunk. For example the data chunk could be a series of 16-bit trace samples, while the meta-data could be a label attached to that trace (to distinguish trace A from traces C, G and T). Meta-data is typically very small and so it is never need be compressed in any of the public chunk types (although meta-data is specific to each chunk type and so it would be valid to have private chunks with compressed meta-data if desirable). The first byte of each chunk data when uncompressed must be zero, indicating raw format. If, having read the chunk data, this is not the case then the chunk needs decompressing or reverse filtering until the first byte is zero. There may be a few padding bytes between the format byte and the first element of real data in the chunk. This is to make file processing simpler when the chunk data consists of 16 or 32-bit words; the padding bytes ensure that the data is aligned to the appropriate word size. Any padding bytes required will be listed in the appopriate chunk definition below. The following lists the chunk types available in 32-bit big-endian format. In all cases the data is presented in the uncompressed form, starting with the raw format byte and any appropriate padding. SAMP ---- Or Meta-data: (version 1.2 and before) Byte number 0 1 2 3 +--+--+--+--+ Hex values | data name | +--+--+--+--+ Data: Byte number 0 1 2 3 4 5 6 7 N +--+--+--+--+--+--+--+--+- -+ Hex values | 0| 0| data| data| data| - | +--+--+--+--+--+--+--+--+- -+ This encodes a series of 16-bit unsigned trace samples. The first data byte is the format (raw); the second data byte is present for padding purposes only. After that comes a series of 16-bit big-endian values. Although stored as unsigned, a baseline value can be specified which is should then be subtracted from all values to generated signed data if required. By default the baseline is zero. Valid identifiers for the meta-data (version 1.3 onwards) are: Ident Value(s) --------------------------------------------------------------------- TYPE "A", "C", "G", "T", "PYNO" or "PYRW" OFFS 16-bit signed integer representing the 'zero' position, in ASCII. [ FIXME: signed or unsigned? Signed means we couldn't store data in the range from -48K to +16K. Unsigned means we couldn't store data in the range 10K to 70K. What's most useful? Or should OFFS be 32-bit instead? ] Versions prior to 1.3 specified meta-data consisted of a single 4-byte block containing a 4-byte name associated with the trace. If a type-name is shorter than 4 bytes then it should be right padded with nul characters to 4 bytes. For sequencing traces the four lanes representig A, C, G and T signals have names "A\0\0\0", "C\0\0\0", "G\0\0\0" and "T\0\0\0". PYNO and PYRW refer to normalised and raw pyrogram data (eg from 454 instruments). At present other names are not reserved, but it is recommended that (for consistency with elsewhere) you label private trace arrays with names starting in a lowercase letter (specifically, bit 5 is 1). For the purposes of backwards compatibility, readers should check the version number in the ZTR header to determine whether the old or new style meta-data formatting is in use. For sequencing traces it is expected that there will be four SAMP chunks, although the order is not specified. SMP4 ---- Meta-data: optional - see below Data: Byte number 0 1 2 3 4 5 6 7 N +--+--+--+--+--+--+--+--+- -+ Hex values | 0| 0| data| data| data| - | +--+--+--+--+--+--+--+--+- -+ As per SAMP, this encodes a series of unsigned 16-bit trace values, to be base-line corrected by the OFFS meta-data value as appropriate. The first byte is 0 (raw format). Next is a single padding byte (also 0). Then follows a series of 2-byte big-endian trace samples for the "A" trace, followed by a series of 2-byte big-endian traces samples for the "C" trace, also followed by the "G" and "T" traces (in that order). The assumption is made that there is the same number of data points for all traces and hence the length of each trace is simply the number of data elements divided by four. Experimentation has shown that this gives around 3% saving over 4 separate SAMP chunks, but it lacks in flexibility. Valid identifiers for the meta-data are: Ident Value(s) --------------------------------------------------------------------- OFFS 16-bit signed integer representing the 'zero' position TYPE The type of data-set encoded. Values can be: "PROC" - processed data for viewing, also the default when no type field is found. "SLXI" - Illumina GA raw intensities (.int.txt files) "SLXN" - Illumina GA noise intensities (.nse.txt files) BASE ---- Meta-data: optional - see below Data: Byte number 0 1 2 3 N +--+--+--+-- - --+ Hex values | 0| base calls | +--+--+--+-- - --+ The first byte is 0 (raw format). This is followed by the base calls in ASCII format (one base per byte). By default it is assumed that all base calls are stored using the IUPAC characters[1]. Valid identifiers for the meta-data are: Ident Meaning Value(s) --------------------------------------------------------------------- CSET Character-set 'I' (ASCII #73) => IUPAC ("ACGTUMRWSYKVHDBN") '0' (ASCII #49) => ABI SOLiD ("0123N") BPOS ---- Meta-data: none present Data: Byte number 0 1 2 3 4 5 6 7 +--+--+--+--+--+--+--+--+- -+--+--+--+--+ Hex values | 0| padding| data | - | data | +--+--+--+--+--+--+--+--+- -+--+--+--+--+ This chunk contains the mapping of base call (BASE) numbers to sample (SAMP) numbers; it defines the position of each base call in the trace data. The position here is defined as the numbering of the 16-bit positions held in the SAMP array, counting zero as the first value. The format is 0 (raw format) followed by three padding bytes (all 0). Next follows a series of 4-byte big-endian numbers specifying the position of each base call as an index into the sample arrays (when considered as a 2-byte array with the format header stripped off). Excluding the format and padding bytes, the number of 4-byte elements should be identical to the number of base calls. All sample numbers are counted from zero. No sample number in BPOS should be beyond the end of the SAMP arrays (although it should not be assumed that the SAMP chunks will be before this chunk). Note that the BPOS elements may not be totally in sorted order as the base calls may be shifted relative to one another due to compressions. CNF1 ---- Meta-data: optional - see below Data: Byte number 0 1 N +--+--+-- - --+--+ Hex values | 0| call confidence | +--+--+-- - --+--+ (N == number of bases in BASE chunk) Valid identifiers for the meta-data are: Ident Value(s) Meaning --------------------------------------------------------------------- SCALE PH Phred-scaled confidence values. (Default). i.e. for a call with probability p: -10*log10(1-p) LO Log-odds scaled values. ie: 10*log10(p/(1-p)) The first byte of this chunk is 0 (raw format). This is then followed by a series signed 8-bit confidence values for the called bases. Either phred or log-odds (as used by the Illumina GA) scale ranges are appropriate. CNF4 ---- Meta-data: optional - see below Data: Byte number 0 1 N 4N +--+--+-- - --+--+----- - -----+ Hex values | 0| call confidence | A/C/G/T conf | +--+--+-- - --+--+----- - -----+ (N == number of bases in BASE chunk) Valid identifiers for the meta-data are: Ident Value(s) Meaning --------------------------------------------------------------------- SCALE PH Phred-scaled confidence values. i.e. for a call with probability p: -10*log10(1-p) (NB: default, but often inappropriate.) LO Log-odds scaled values. ie: 10*log10(p/(1-p)) The first byte of this chunk is 0 (raw format). This is then followed by a series signed 8-bit confidence values for the called base. Next comes all the remaining confidence values for A, C, G and T excluding those that have already been written (ie the called base). So for a sequence AGT we would store confidences A1 G2 T3 C1 G1 T1 A2 C2 T2 A3 C3 G3. The purpose of this is to group the (likely) highest confidence value (those for the called base) at the start of the chunk followed by the remaining values. Hence if phred confidence values are written in a CNF4 chunk the first quarter of chunk will consist of phred confidence values and the last three quarters will (assuming no ambiguous base calls) consist entirely of zeros. For the purposes of storage the confidence value for a base call that is not A, C, G or T (in any case) is stored as if the base call was T. If only one confidence value exists per base then either the phred or log-odds scales work well. The first N bytes will be the called bases and the remaining 3*N will be zero (optimal for run-length-encoding), but consider using the CNF1 chunk type instead in this situation. If all 4 base types have their own confidence value then the log-odds scale will work well. In this case the phred scale is an inappropriate choice as it cannot encode both very likely and very unlikely events. Note: if this chunk exists it must exist after a BASE chunk. TEXT ---- Meta-data: none present Data: 0 +--+- - -+--+- - -+--+- -+- - -+--+- - -+--+-----+ Hex values | 0| ident | 0| value | 0| - | ident | 0| value | 0| (0) | +--+- - -+--+- - -+--+- -+- - -+--+- - -+--+-----+ This contains a series of "identifier\0value\0" pairs. The identifiers and values may be any length and may contain any data except the nul character. The nul character marks the end of the identifier or the end of the value. Multiple identifier-value pairs are allowable. Prior to version 1.3 a double nul character marked the end of the list (labeled "(0)" above), but from version 1.3 the end of the list may also be marked by the end of chunk. Identifiers starting with bit 5 clear (uppercase) are part of the public ZTR spec. Any public identifier not listed as part of this spec should be considered as reserved. Identifiers that have bit 6 set (lowercase) are for private use and no restriction is placed on these. Multiple TEXT chunks may exist within the ZTR file. If so they are considered to be concatenated together. See below for the text identifier list. CLIP ---- Meta-data: none present Data: Byte number 0 1 2 3 4 5 6 7 8 +--+--+--+--+--+--+--+--+--+ Hex values | 0| left clip | right clip| +--+--+--+--+--+--+--+--+--+ This contains suggested quality clip points. These are stored as zero (raw data) followed by a 4-byte big endian value for the left clip point and a 4-byte big endian value for the right clip point. Clip points are defined in units of base calls, starting from 0. (Q: is that correct!?) CR32 ---- Meta-data: none present Data: Byte number 0 1 2 3 4 +--+--+--+--+--+ Hex values | 0| CRC-32 | +--+--+--+--+--+ This chunk is always just 4 bytes of data containing a CRC-32 checksum, computed according to the widely used ANSI X3.66 standard. If present, the checksum will be a check of all of the data since the last CR32 chunk. This will include checking the header if this is the first CR32 chunk, and including the previous CRC32 chunk if it is not. Obviously the checksum will not include checks on this CR32 chunk. COMM ---- Meta-data: none present Data: Byte number 0 1 N +--+-- - --+ Hex values | 0| free text | +--+-- - --+ This allows arbitrary textual data to be added. It does not require a identifier-value pairing or any nul termination. DFLH ---- Meta-data: none present Data: Byte number 0 1 N +--+--+-- - - - - - - - - - - --+ Hex values | 0| C| Deflate format data ... | +--+--+-- - - - - - - - - - - --+ 'C' is the code-set number referred to within that compression method. It should be 128 onwards and is used to distinguish between multiple huffman tables. It is used in conjunction with the data compression format 77 ("Deflate"). Following this is data in the Deflate format (RFC 1951). This should consist of the header for a single block using dynamic huffman with the BFINAL (last block) flag set. In Deflate streams the end of the huffman codes and the start of the compressed data stream itself may occur part way through a byte. Therefore the last byte of the this block is bitwise ORed with the first byte of the data stream compressed referring back to this code-set number. Therefore all unused bits in the last byte of this block should be set to zero. Likewise if the data bit-stream in this block ends on an exact byte boundary then an additional blank byte must be added to ensure the ORing method above still works. DFLC ---- Meta-data: none present Data: Byte number 0 +--+---+- - - - ---+--+-- - - - - - - - - - - - --+ Hex values | 0| C |code-order |FF| Deflate dynamic codes ... | +--+---+- - - - ---+--+-- - - - - - - - - - - - --+ Multi-context Deflate compression codes defined for use by data format 78 (HUFF_MULTI). This is like the DFLH format, except it encodes multiple huffman trees instead of a single tree along with the order in which the multiple trees should be used (the "code-order"). 'C' is the code-set number referred to within that compression method. It should be 128 onwards and is used to distinguish between multiple huffman tables. The code-order is a run-length encoded series of 8-bit numbers indicating which huffman code set should be used for which byte. For each byte in the input stream the HUFF_MULTI method selects the appropriate huffman code by using indexing code-order with the input data position modulo the number of values in code-order. Following this is data in the Deflate format (RFC 1951). This should consist of the header component for a single block using dynamic huffman with the BFINAL (last block) flag set, up to and including the HDIST+1 code lengths for the distance alphabet. This will then be immediately followed by the next set of huffman codes, and so on until all index values containing within the code-order have been accounted for. In Deflate streams the end of the huffman codes and the start of the compressed data stream itself may occur part way through a byte. Therefore the last byte of the this block is bitwise ORed with the first byte of the data stream compressed referring back to this code-set number. Therefore all unused bits in the last byte of this block should be set to zero. Likewise if the data bit-stream in this block ends on an exact byte boundary then an additional blank byte must be added to ensure the ORing method above still works. For example, compression of 16-bit data is sometimes best achieved by producing one set of huffman codes for the top 8 bits and another set for the bottom 8 bits, rather than mixing these together by treating the 16-bit data as a series of 8-bit quantities. In this case our code-order would consist of just two entries; (0, 1). Alternatively we may have 4 1-byte confidence values stored per base in the order of the confidence of the base-called base type first followed by the 3 remaining confidence values. We observe that compressing byte 0, 4, 8, 12, ... as one set and bytes 1,2,3, 5,6,7, ... as another set yields higher compression ratios. In this case the code-order would consist of 4 entries; (0, 1, 1, 1). REGN ---- Meta-data: optional - see below Data: Byte number 0 1 2 3 4 5 6 7 8 +--+---+---+---+---+---+---+---+---+ Hex values | 0| 1st boundary | 2nd boundary | ... +--+---+---+---+---+---+---+---+---+ This chunk is used to break a trace down into a series of segments. We store the boundary between segments, so the list above will contain one less boundary than there are segments with the first segment implicitly starting from the first base and the last segment implictly extending to the last base. Each 4-byte unsigned value indicates a position within the sequence or trace counting from 0 as the first element and marking the first base of the next region. For example three regions of DNA may be: 0 1 2 3 4 5 6 7 8 9 10 11 12 T A C G G A T T C G A A C |<-reg. 1->| |<--reg. 2--->| |<-reg. 3->| This would give the 1st boundary as 4 and the 2nd boundary as 9. The lack of a REGN chunk implies one single region extending from the first to last base in the sequence. Valid identifiers for the meta-data are: Ident Meaning Value(s) --------------------------------------------------------------------- COORD Coordinate system 'T' = trace coordinates 'B' = base coordinations (default) NAME Region names A semicolon separated list of "name:code" pairs. Eg primer1:T;read1:P;primer2:T;read2:P [FIXME: NAME identifier here is the same as the REGION_LIST TEXT identifier. We need to decide where it belongs and pick one. If we can get a way to specify the default meta-data contents then logically speaking the best place to store this is in the meta-data along side the chunk data itself.] The NAME identifier is used to attach a meaning to the regions described in the data chunk. It consists of a semi-colon separated list of names or name:code pairs. The codes, if present are a single character from the predefined list below and are separated from the name by a colon. Code Meaning --------------------------------------- T Tech read (e.g. primer, linker) B Bio read I Inverted read D Duplicate read P Paired read FIXME: I don't like the above meanings. They don't, well, "mean" much to me! What's a tech read? Text Identifiers ================ These are for use in the TEXT segments. None are required, but if any of these identifiers are present they must confirm to the description below. Much (currently all) of this list has been taken from the NCBI Trace Archive [2] documentation. It is duplicated here as the ZTR spec is not tied to the same revision schedules as the NCBI trace archive (although it is intended that any suitable updates to the trace archive should be mirrored in this ZTR spec). The Trace Archive specifies a maximum length of values. The ZTR spec does not have length limitations, but for compatibility these sizes should still be observed. The Trace Archive also states some identifiers are mandatory; these are marked by asterisks below. These identifiers are not mandatory in the ZTR spec (but clearly they need to exist if the data is to be submitted to the NCBI). Finally, some fields are not appropriate for use in the ZTR spec, such as BASE_FILE (the name of a file containing the base calls). Such fields are included only for compatibility with the Trace Arhive. It is not expected that use of ZTR would allow for the base calls to be read from an external file instead of the ZTR BASE chunk. [ Quoted from TraceArchiveRFC v1.17 ] Identifier Size Meaning Example value(s) ---------- ----- ---------------------------- ----------------- TRACE_NAME * 250 name of the trace HBBBA1U2211 as used at the center unique within the center but not among centers. SUBMISSION_TYPE * - type of submission CENTER_NAME * 100 name of center BCM CENTER_PROJECT 200 internal project name HBBB used within the center TRACE_FILE * 200 file name of the trace ./traces/TRACE001.scf relative to the top of the volume. TRACE_FORMAT * 20 format of the tracefile SOURCE_TYPE * - source of the read INFO_FILE 200 file name of the info file INFO_FILE_FORMAT 20 BASE_FILE 200 file name of the base calls QUAL_FILE 200 file name of the base calls TRACE_DIRECTION - direction of the read TRACE_END - end of the template PRIMER 200 primer sequence PRIMER_CODE which primer was used STRATEGY - sequencing strategy TRACE_TYPE_CODE - purpose of trace PROGRAM_ID 100 creator of trace file phred-0.990722.h program-version TEMPLATE_ID 20 used for read pairing HBBBA2211 CHEMISTRY_CODE - code of the chemistry (see below) ITERATION - attempt/redo 1 (int 1 to 255) CLIP_QUALITY_LEFT left clip of the read in bp due to quality CLIP_QUALITY_RIGHT right " " " " " CLIP_VECTOR_LEFT left clip of the read in bp due to vector CLIP_VECTOR_RIGHT right " " " " " SVECTOR_CODE 40 sequencing vector used (in table) SVECTOR_ACCESSION 40 sequencing vector used (in table) CVECTOR_CODE 40 clone vector used (in table) CVECTOR_ACCESSION 40 clone vector used (in table) INSERT_SIZE - expected size of insert 2000,10000 in base pairs (bp) (int 1 to 2^32) PLATE_ID 32 plate id at the center WELL_ID well 1-384 SPECIES_CODE * - code for species SUBSPECIES_ID 40 name of the subspecies Is this the same as strain CHROMOSOME 8 name of the chromosome ChrX, Chr01, Chr09 LIBRARY_ID 30 the source library of the clone CLONE_ID 30 clone id RPCI11-1234 ACCESSION 30 NCBI accession number AC00001 PICK_GROUP_ID 30 an id to group traces picked at the same time. PREP_GROUP_ID 30 an id to group traces prepared at the same time RUN_MACHINE_ID 30 id of sequencing machine RUN_MACHINE_TYPE 30 type/model of machine RUN_LANE 30 lane or capillary of the trace RUN_DATE - date of run RUN_GROUP_ID 30 an identifier to group traces run on the same machine [ End of quote from TraceArchiveRFC ] More detailed information on the format of these values should be obtained from the Trace Archive RFC [2]. In addition to the above the following TEXT identifiers have meaning specific to the ZTR format: Identifier Meaning Example value(s) ---------- ---------------------------- ------------------------------- REGION_LIST A semi-colon separated list primer1:T;read1:P identifying regions of a trace. See the REGN chunk Region 1;Region 2;Region 3 definition for details. FIXME: Should this simply be the meta-data associated with the REGN chunk? References ========== [1] IUPAC: http://www.chem.qmw.ac.uk/iubmb/misc/naseq.html [2] http://www.ncbi.nlm.nih.gov/Traces/TraceArchiveRFC.html [3] J.Bonfield and R.Staden, "ZTR: a new format for DNA sequence trace data". Bioinformatics Vol. 18 no. 1 2002. FIXME: As an aside, not doing the final entropy encoding steps (zlib, deflate, etc) and just using bzip2 on an entire SRF archive yields a considerable saving. On tests it varied between 23% (27bp reads) and 13% (74bp reads) smaller than the Deflate compressed data. Unfortunately it pretty much removes all chance of random access in the data unless I can get a working FM-Index implementation (which is very unlikely in a short time). This makes it appropriate for transmission perhaps, but not for indexing and querying random sequences. A substantial chunk (5-9%) of this saving comes from the repeated ZTR block types (names like "BASE", "CNF4" and common components like 0x00000000 for the meta-data size). The remainder probably comes from similarities between one ZTR file and another.