NCBI C++ ToolKit
blast_aalookup.h
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: blast_aalookup.h 98954 2023-01-26 13:38:46Z fongah2 $
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  */
26 
27 /** @file blast_aalookup.h
28  * Routines for creating protein BLAST lookup tables.
29  * Contains definitions and prototypes for the lookup
30  * table construction phase of blastp and RPS blast.
31  */
32 
33 #ifndef ALGO_BLAST_CORE__BLAST_AALOOKUP__H
34 #define ALGO_BLAST_CORE__BLAST_AALOOKUP__H
35 
42 
43 #ifdef __cplusplus
44 extern "C" {
45 #endif
46 
47 /* --------------- protein blast defines -----------------------------*/
48 
49 #define AA_HITS_PER_CELL 3 /**< maximum number of hits in one lookup
50  table cell */
51 
52 /** structure defining one cell of the compacted lookup table */
53 typedef struct AaLookupBackboneCell {
54  Int4 num_used; /**< number of hits stored for this cell */
55 
56  union {
57  Int4 overflow_cursor; /**< integer offset into the overflow array
58  where the list of hits for this cell begins */
59  Int4 entries[AA_HITS_PER_CELL]; /**< if the number of hits for this
60  cell is AA_HITS_PER_CELL or less,
61  the hits are all stored directly in
62  the cell */
63  } payload; /**< union that specifies either entries stored right on
64  the backbone if fewer than AA_HITS_PER_CELL are
65  present or a pointer to where the hits are stored
66  (off-backbone). */
68 
69 /** structure defining one cell of the small (i.e., use short) lookup table */
70 typedef struct AaLookupSmallboneCell {
71  Uint2 num_used; /**< number of hits stored for this cell */
72 
73  union {
74  Int4 overflow_cursor; /**< integer offset into the overflow array
75  where the list of hits for this cell begins */
76  Uint2 entries[AA_HITS_PER_CELL]; /**< if the number of hits for this
77  cell is AA_HITS_PER_CELL or less,
78  the hits are all stored directly in
79  the cell */
80  } payload; /**< union that specifies either entries stored right on
81  the backbone if fewer than AA_HITS_PER_CELL are
82  present or a pointer to where the hits are stored
83  (off-backbone). */
85 
86 
87 /** types of cells */
88 typedef enum {
89  eBackbone = 0,
90  eSmallbone = 1
92 
93 /** The basic lookup table structure for blastp searches
94  */
95 typedef struct BlastAaLookupTable {
96  Int4 threshold; /**< the score threshold for neighboring words */
97  Int4 mask; /**< part of index to mask off, that is, top
98  (wordsize*charsize) bits should be discarded. */
99  Int4 charsize; /**< number of bits for a base/residue */
100  Int4 word_length; /**< Length in letters of the full word match
101  required to trigger extension */
102  Int4 lut_word_length; /**< Length in bases of a word indexed by the
103  lookup table */
104  Int4 alphabet_size; /**< number of letters in the alphabet */
105  Int4 backbone_size; /**< number of cells in the backbone */
106  Int4 longest_chain; /**< length of the longest chain on the backbone */
107  Int4 ** thin_backbone; /**< the "thin" backbone. for each index cell,
108  maintain a pointer to a dynamically-allocated
109  chain of hits. */
110  EBoneType bone_type; /**< type of bone used:
111  0: normal backbone (using Int4)
112  1: small backbone (using Uint2)
113  will be determined in Finalize call */
114  void * thick_backbone; /**< may point to BackboneCell, SmallboneCell,
115  or TinyboneCell.
116  the "thick" backbone. after
117  queries are indexed, compact the
118  backbone to put at most
119  AA_HITS_PER_CELL hits on the
120  backbone, otherwise point to
121  some overflow storage */
122  void * overflow; /**< may point to Int4 or Uint2,
123  the overflow array for the compacted
124  lookup table */
125  Int4 overflow_size; /**< Number of elements in the overflow array */
126  PV_ARRAY_TYPE *pv; /**< Presence vector bitfield; bit positions that
127  are set indicate that the corresponding thick
128  backbone cell contains hits */
129  Boolean use_pssm; /**< if TRUE, lookup table construction will assume
130  that the underlying score matrix is position-
131  specific */
132  void *scansub_callback;/**< function for scanning subject sequences */
133 
134  Int4 neighbor_matches; /**< the number of neighboring words found while
135  indexing the queries, used for informational/
136  debugging purposes */
137  Int4 exact_matches; /**< the number of exact matches found while
138  indexing the queries, used for informational/
139  debugging purposes */
141 
142 /** Pack the data structures comprising a protein lookup table
143  * into their final form
144  *
145  * @param lookup the lookup table [in]
146  * @return Zero.
147  */
150 
151 /** Create a new protein lookup table.
152  * @param opt pointer to lookup table options structure [in]
153  * @param lut handle to lookup table structure [in/modified]
154  * @return 0 if successful, nonzero on failure
155  */
158  BlastAaLookupTable* * lut);
159 
160 
161 /** Free the lookup table.
162  * @param lookup The lookup table structure to be freed
163  * @return NULL
164  */
167 
168 /** Index a protein query.
169  *
170  * @param lookup the lookup table [in/modified]
171  * @param matrix the substitution matrix [in]
172  * @param query the array of queries to index
173  * @param unmasked_regions a BlastSeqLoc* which points to a (list of)
174  * integer pair(s) which specify the unmasked region(s)
175  * of the query [in]
176  * @param query_bias number added to each offset put into lookup table
177  * (only used for RPS blast database creation, otherwise 0) [in]
178  */
181  Int4 ** matrix,
183  BlastSeqLoc* unmasked_regions,
184  Int4 query_bias);
185 
186 /* ------------ compressed alphabet protein blast defines ---------------*/
187 
188 /** number of query offsets to store in a backbone cell */
189 #define COMPRESSED_HITS_PER_BACKBONE_CELL 4
190 #define COMPRESSED_HITS_CELL_MASK 0x03
191 
192 /** number of query offsets to store in an overflow cell */
193 #define COMPRESSED_HITS_PER_OVERFLOW_CELL 4
194 
195 /** number of cells in one bank of cells */
196 #define COMPRESSED_OVERFLOW_CELLS_IN_BANK 209710
197 
198 /** The maximum number of banks (usually less than 10 are
199  needed; memory will run out before this is insufficient) */
200 #define COMPRESSED_OVERFLOW_MAX_BANKS 1024
201 
202 /** cell in list for holding query offsets */
203 typedef struct CompressedOverflowCell {
204  struct CompressedOverflowCell* next; /**< pointer to next cell */
205 
206  /** the query offsets stored in the cell */
209 
210 /** "alternative" structure of CompressedLookupBackboneCell storage */
211 typedef struct CompressedMixedOffsets{
212  /** the query offsets stored locally */
214 
215  /** head of linked list of cells of query offsets
216  stored off the backbone */
219 
220 /** structure for hashtable of indexed query offsets */
224  /** structure for holding the list of query offsets */
225  union {
226  /** storage for query offsets local to the backbone cell */
228  /** storage for remote query offsets */
232 
233 /** The lookup table structure for protein searches
234  * using a compressed alphabet
235  */
237  Int4 threshold; /**< the score threshold for neighboring words */
238  Int4 word_length; /**< Length in letters of the full word match
239  required to trigger extension */
240  Int4 alphabet_size; /**< number of letters in the alphabet */
241  Int4 compressed_alphabet_size; /**< letters in the compressed alphabet */
242  Int4 reciprocal_alphabet_size; /**< 2^32 / compressed_alphabet_size */
243  Int4 longest_chain; /**< length of the longest chain on the backbone */
244  Int4 backbone_size; /**< number of cells in the backbone */
245  CompressedLookupBackboneCell * backbone; /**< hashtable for storing
246  indexed query offsets */
247  CompressedOverflowCell ** overflow_banks; /**< array of batches of query
248  offsets that are too numerous to
249  fit in backbone cells */
250  Int4 curr_overflow_cell; /**< occupied cells in the current bank */
251  Int4 curr_overflow_bank; /**< current bank to fill-up */
252  PV_ARRAY_TYPE *pv; /**< Presence vector bitfield; bit positions that
253  are set indicate that the corresponding thick
254  backbone cell contains hits */
255  Int4 pv_array_bts; /**< bit-to-shift value for PV array indicies */
256  Uint1* compress_table; /**< translation table (protein->compressed) */
257  Int4* scaled_compress_table; /**< scaled version of compress_table */
258  void *scansub_callback;/**< function for scanning subject sequences */
259 
260 
261  Int4 neighbor_matches; /**< the number of neighboring words found while
262  indexing the queries, used for informational/
263  debugging purposes */
264  Int4 exact_matches; /**< the number of exact matches found while
265  indexing the queries, used for informational/
266  debugging purposes */
268 
269 /** Create a new compressed protein lookup table.
270  * @param query The query sequence block (if concatenated sequence, the
271  * individual strands/sequences must be separated by a sentinel byte)[in]
272  * @param locations The locations to be included in the lookup table,
273  * e.g. [0,length-1] for full sequence. NULL means no sequence. [in]
274  * @param lut Pointer to the lookup table to be created [out]
275  * @param opt Options for lookup table creation [in]
276  * @param sbp pointer to score matrix information [in]
277  * @return 0 if successful, nonzero on failure
278  */
280  BlastSeqLoc* locations,
282  const LookupTableOptions * opt,
283  BlastScoreBlk *sbp);
284 
285 /** Free the compressed lookup table.
286  * @param lookup The lookup table structure to be freed
287  * @return NULL
288  */
291 
292 /** Convert a word to use a compressed alphabet. The letters
293  * in the word are reversed compared to the original order
294  * @param wordsize Number of consecutive letters in a word [in]
295  * @param compressed_alphabet_size Number of letters in compressed
296  * alphabet [in]
297  * @param word Sequence in "regular" AA alphabet [in]
298  * @param skip If a letter is encountered that cannot be
299  * compressed, the offset from word[] where
300  * index computation can begin again [out]
301  * @param lookup Translation tables etc [in]
302  * @return Index calculated from scratch [out]
303  */
305  const Uint1* word,
306  Int4 compressed_alphabet_size,
307  Int4* skip,
309 {
310  Int4 i;
311  Int4 index = 0;
312  Int4 *scaled_compress_table = lookup->scaled_compress_table;
313 
314  *skip = 0;
315  for(i = 0; i < wordsize; i++) {
316  Int4 ch = scaled_compress_table[word[i]];
317 
318  if (ch < 0){
319  *skip = i + 2;
320  ch = 0;
321  }
322  index = index / compressed_alphabet_size + ch;
323  }
324 
325  return index;
326 }
327 
328 /* ----------------------- rpsblast defines -----------------------------*/
329 
330 #define RPS_HITS_PER_CELL 3 /**< maximum number of hits in an RPS backbone
331  cell; this may be redundant (have the same
332  value as AA_HITS_PER_CELL) but must be
333  separate to guarantee binary compatibility
334  with existing RPS blast databases */
335 
336 /** structure defining one cell of the RPS lookup table */
337 typedef struct RPSBackboneCell {
338  Int4 num_used; /**< number of hits in this cell */
339  Int4 entries[RPS_HITS_PER_CELL]; /**< if the number of hits in this cell
340  is RPS_HITS_PER_CELL or less, all
341  hits go into this array. Otherwise,
342  the first hit in the list goes into
343  element 0 of the array, and element 1
344  contains the byte offset into the
345  overflow array where the list of the
346  remaining hits begins */
348 
349 /** The number of regions into which the concatenated RPS blast
350  database is split via bucket sorting */
351 #define RPS_BUCKET_SIZE 2048
352 
353 
354 /** structure used for bucket sorting offsets retrieved
355  from the RPS blast lookup table. */
356 typedef struct RPSBucket {
357  Int4 num_filled; /**< number of offset pairs currently in bucket */
358  Int4 num_alloc; /**< max number of offset pairs bucket can hold */
359  BlastOffsetPair *offset_pairs; /**< list of offset pairs */
361 
362 /**
363  * The basic lookup table structure for RPS blast searches
364  */
365 typedef struct BlastRPSLookupTable {
366  Int4 wordsize; /**< number of full bytes in a full word */
367  Int4 mask; /**< part of index to mask off, that is,
368  top (wordsize*charsize) bits should be
369  discarded. */
370  Int4 alphabet_size; /**< number of letters in the alphabet */
371  Int4 charsize; /**< number of bits for a base/residue */
372  Int4 backbone_size; /**< number of cells in the backbone */
373  RPSBackboneCell * rps_backbone; /**< the lookup table used for RPS blast */
374  Int4 ** rps_pssm; /**< Pointer to memory-mapped RPS Blast profile file */
375  Int4 * rps_seq_offsets; /**< array of start offsets for each RPS DB seq. */
376  Int4 num_profiles; /**< Number of profiles in RPS database. */
377  Int4 * overflow; /**< the overflow array for the compacted
378  lookup table */
379  Int4 overflow_size;/**< Number of elements in the overflow array */
380  PV_ARRAY_TYPE *pv; /**< Presence vector bitfield; bit positions that
381  are set indicate that the corresponding thick
382  backbone cell contains hits */
383 
384  Int4 num_buckets; /**< number of buckets used to sort offsets
385  retrieved from the lookup table */
386  RPSBucket *bucket_array; /**< list of buckets */
388 
389 /** Create a new RPS blast lookup table.
390  * @param rps_info pointer to structure with RPS setup information [in]
391  * @param lut handle to lookup table [in/modified]
392  * @return 0 if successful, nonzero on failure
393  */
394 
395 Int2 RPSLookupTableNew(const BlastRPSInfo *rps_info,
396  BlastRPSLookupTable* * lut);
397 
398 /** Free the lookup table.
399  * @param lookup The lookup table structure to free; note that
400  * the rps_backbone and rps_seq_offsets fields are not freed
401  * by this call, since they may refer to memory-mapped arrays
402  * @return NULL
403  */
405 
406 #ifdef __cplusplus
407 }
408 #endif
409 
410 #endif /* !ALGO_BLAST_CORE__BLAST_AALOOKUP__H */
static int lookup(const char *name, const struct lookup_int *table)
Definition: attributes.c:50
Int2 RPSLookupTableNew(const BlastRPSInfo *rps_info, BlastRPSLookupTable **lut)
Create a new RPS blast lookup table.
EBoneType
types of cells
@ eBackbone
@ eSmallbone
struct BlastCompressedAaLookupTable BlastCompressedAaLookupTable
The lookup table structure for protein searches using a compressed alphabet.
#define COMPRESSED_HITS_PER_OVERFLOW_CELL
number of query offsets to store in an overflow cell
struct AaLookupSmallboneCell AaLookupSmallboneCell
structure defining one cell of the small (i.e., use short) lookup table
Int4 BlastCompressedAaLookupTableNew(BLAST_SequenceBlk *query, BlastSeqLoc *locations, BlastCompressedAaLookupTable **lut, const LookupTableOptions *opt, BlastScoreBlk *sbp)
Create a new compressed protein lookup table.
struct CompressedLookupBackboneCell CompressedLookupBackboneCell
structure for hashtable of indexed query offsets
BlastCompressedAaLookupTable * BlastCompressedAaLookupTableDestruct(BlastCompressedAaLookupTable *lookup)
Free the compressed lookup table.
BlastAaLookupTable * BlastAaLookupTableDestruct(BlastAaLookupTable *lookup)
Free the lookup table.
#define COMPRESSED_HITS_PER_BACKBONE_CELL
number of query offsets to store in a backbone cell
BlastRPSLookupTable * RPSLookupTableDestruct(BlastRPSLookupTable *lookup)
Free the lookup table.
struct CompressedMixedOffsets CompressedMixedOffsets
"alternative" structure of CompressedLookupBackboneCell storage
void BlastAaLookupIndexQuery(BlastAaLookupTable *lookup, Int4 **matrix, BLAST_SequenceBlk *query, BlastSeqLoc *unmasked_regions, Int4 query_bias)
Index a protein query.
#define AA_HITS_PER_CELL
maximum number of hits in one lookup table cell
struct RPSBucket RPSBucket
structure used for bucket sorting offsets retrieved from the RPS blast lookup table.
struct CompressedOverflowCell CompressedOverflowCell
cell in list for holding query offsets
struct RPSBackboneCell RPSBackboneCell
structure defining one cell of the RPS lookup table
struct BlastAaLookupTable BlastAaLookupTable
The basic lookup table structure for blastp searches.
struct AaLookupBackboneCell AaLookupBackboneCell
structure defining one cell of the compacted lookup table
struct BlastRPSLookupTable BlastRPSLookupTable
The basic lookup table structure for RPS blast searches.
#define RPS_HITS_PER_CELL
maximum number of hits in an RPS backbone cell; this may be redundant (have the same value as AA_HITS...
Int4 BlastAaLookupFinalize(BlastAaLookupTable *lookup, EBoneType bone_type)
Pack the data structures comprising a protein lookup table into their final form.
Int4 BlastAaLookupTableNew(const LookupTableOptions *opt, BlastAaLookupTable **lut)
Create a new protein lookup table.
static NCBI_INLINE Int4 s_ComputeCompressedIndex(Int4 wordsize, const Uint1 *word, Int4 compressed_alphabet_size, Int4 *skip, BlastCompressedAaLookupTable *lookup)
Convert a word to use a compressed alphabet.
Definitions used throughout BLAST.
#define NCBI_XBLAST_EXPORT
NULL operations for other cases.
Definition: blast_export.h:65
Common definitions for protein and nucleotide lookup tables.
#define PV_ARRAY_TYPE
The pv_array 'native' type.
Definition: blast_lookup.h:41
The structures and functions in blast_options.
RPS BLAST structure definitions.
Definitions and prototypes used by blast_stat.c to calculate BLAST statistics.
uint8_t Uint1
1-byte (8-bit) unsigned integer
Definition: ncbitype.h:99
int16_t Int2
2-byte (16-bit) signed integer
Definition: ncbitype.h:100
int32_t Int4
4-byte (32-bit) signed integer
Definition: ncbitype.h:102
uint16_t Uint2
2-byte (16-bit) unsigned integer
Definition: ncbitype.h:101
int i
Type and macro definitions from C toolkit that are not defined in C++ toolkit.
#define NCBI_INLINE
"inline" seems to work on our remaining in-house compilers (WorkShop, Compaq, ICC,...
Definition: ncbi_std.h:81
Uint1 Boolean
bool replacment for C
Definition: ncbi_std.h:94
structure defining one cell of the compacted lookup table
union AaLookupBackboneCell::@3 payload
union that specifies either entries stored right on the backbone if fewer than AA_HITS_PER_CELL are p...
Int4 entries[3]
if the number of hits for this cell is AA_HITS_PER_CELL or less, the hits are all stored directly in ...
Int4 overflow_cursor
integer offset into the overflow array where the list of hits for this cell begins
Int4 num_used
number of hits stored for this cell
structure defining one cell of the small (i.e., use short) lookup table
union AaLookupSmallboneCell::@4 payload
union that specifies either entries stored right on the backbone if fewer than AA_HITS_PER_CELL are p...
Uint2 num_used
number of hits stored for this cell
Int4 overflow_cursor
integer offset into the overflow array where the list of hits for this cell begins
Uint2 entries[3]
if the number of hits for this cell is AA_HITS_PER_CELL or less, the hits are all stored directly in ...
Structure to hold a sequence.
Definition: blast_def.h:242
The basic lookup table structure for blastp searches.
void * thick_backbone
may point to BackboneCell, SmallboneCell, or TinyboneCell.
Int4 mask
part of index to mask off, that is, top (wordsize*charsize) bits should be discarded.
Int4 ** thin_backbone
the "thin" backbone.
Boolean use_pssm
if TRUE, lookup table construction will assume that the underlying score matrix is position- specific
Int4 lut_word_length
Length in bases of a word indexed by the lookup table.
Int4 charsize
number of bits for a base/residue
void * scansub_callback
function for scanning subject sequences
EBoneType bone_type
type of bone used: 0: normal backbone (using Int4) 1: small backbone (using Uint2) will be determined...
PV_ARRAY_TYPE * pv
Presence vector bitfield; bit positions that are set indicate that the corresponding thick backbone c...
Int4 neighbor_matches
the number of neighboring words found while indexing the queries, used for informational/ debugging p...
Int4 threshold
the score threshold for neighboring words
Int4 overflow_size
Number of elements in the overflow array.
Int4 alphabet_size
number of letters in the alphabet
Int4 word_length
Length in letters of the full word match required to trigger extension.
Int4 longest_chain
length of the longest chain on the backbone
void * overflow
may point to Int4 or Uint2, the overflow array for the compacted lookup table
Int4 backbone_size
number of cells in the backbone
Int4 exact_matches
the number of exact matches found while indexing the queries, used for informational/ debugging purpo...
The lookup table structure for protein searches using a compressed alphabet.
Int4 pv_array_bts
bit-to-shift value for PV array indicies
Int4 longest_chain
length of the longest chain on the backbone
void * scansub_callback
function for scanning subject sequences
Int4 threshold
the score threshold for neighboring words
Int4 neighbor_matches
the number of neighboring words found while indexing the queries, used for informational/ debugging p...
Int4 exact_matches
the number of exact matches found while indexing the queries, used for informational/ debugging purpo...
Int4 alphabet_size
number of letters in the alphabet
PV_ARRAY_TYPE * pv
Presence vector bitfield; bit positions that are set indicate that the corresponding thick backbone c...
Int4 reciprocal_alphabet_size
2^32 / compressed_alphabet_size
Uint1 * compress_table
translation table (protein->compressed)
Int4 * scaled_compress_table
scaled version of compress_table
CompressedLookupBackboneCell * backbone
hashtable for storing indexed query offsets
Int4 compressed_alphabet_size
letters in the compressed alphabet
Int4 word_length
Length in letters of the full word match required to trigger extension.
Int4 curr_overflow_bank
current bank to fill-up
Int4 backbone_size
number of cells in the backbone
CompressedOverflowCell ** overflow_banks
array of batches of query offsets that are too numerous to fit in backbone cells
Int4 curr_overflow_cell
occupied cells in the current bank
The RPS engine uses this structure to access all of the RPS blast related data (assumed to be collect...
Definition: blast_rps.h:120
The basic lookup table structure for RPS blast searches.
Int4 * overflow
the overflow array for the compacted lookup table
RPSBucket * bucket_array
list of buckets
Int4 num_buckets
number of buckets used to sort offsets retrieved from the lookup table
RPSBackboneCell * rps_backbone
the lookup table used for RPS blast
Int4 overflow_size
Number of elements in the overflow array.
Int4 mask
part of index to mask off, that is, top (wordsize*charsize) bits should be discarded.
Int4 charsize
number of bits for a base/residue
Int4 alphabet_size
number of letters in the alphabet
Int4 num_profiles
Number of profiles in RPS database.
Int4 wordsize
number of full bytes in a full word
PV_ARRAY_TYPE * pv
Presence vector bitfield; bit positions that are set indicate that the corresponding thick backbone c...
Int4 backbone_size
number of cells in the backbone
Int4 * rps_seq_offsets
array of start offsets for each RPS DB seq.
Int4 ** rps_pssm
Pointer to memory-mapped RPS Blast profile file.
Structure used for scoring calculations.
Definition: blast_stat.h:177
Used to hold a set of positions, mostly used for filtering.
Definition: blast_def.h:204
structure for hashtable of indexed query offsets
Int4 query_offsets[4]
storage for query offsets local to the backbone cell
CompressedMixedOffsets overflow_list
storage for remote query offsets
union CompressedLookupBackboneCell::@5 payload
structure for holding the list of query offsets
"alternative" structure of CompressedLookupBackboneCell storage
Int4 query_offsets[4 -2]
the query offsets stored locally
CompressedOverflowCell * head
head of linked list of cells of query offsets stored off the backbone
cell in list for holding query offsets
struct CompressedOverflowCell * next
pointer to next cell
Int4 query_offsets[4]
the query offsets stored in the cell
Options needed to construct a lookup table Also needed: query sequence and query length.
structure defining one cell of the RPS lookup table
Int4 num_used
number of hits in this cell
Int4 entries[3]
if the number of hits in this cell is RPS_HITS_PER_CELL or less, all hits go into this array.
structure used for bucket sorting offsets retrieved from the RPS blast lookup table.
Int4 num_filled
number of offset pairs currently in bucket
Int4 num_alloc
max number of offset pairs bucket can hold
BlastOffsetPair * offset_pairs
list of offset pairs
static string query
This symbol enables the verbose option in makeblastdb and other BLAST+ search command line applicatio...
Definition: blast_def.h:141
Modified on Tue Feb 27 05:54:56 2024 by modify_doxy.py rev. 669887