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

Go to the SVN repository for this file.

1 /* $Id: blast_parameters.h 60014 2013-10-17 13:43:48Z madden $
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  * Author: Tom Madden
27  *
28  */
29 
30 /** @file blast_parameters.h
31  * Structure and function definitions for BLAST parameter structures, which are
32  * internal to the CORE of BLAST.
33  *
34  * <pre>
35  * These parameters are normally set by:
36  * 1.) reading the options in blast_options.[ch] to find user preferences
37  * 2.) making intelligent choices based upon the program, user preferences,
38  * and other data such as the sequence's length.
39  *
40  * NOTE: These parameters should be set by calls in algo/blast/core,
41  * preferrably to functions in this file. User preferences should be
42  * controlled by the structures and functions in blast_options.[ch].
43  * The parameter structures belong to algo/blast/core, the options
44  * structures belong to the user.
45  * </pre>
46  */
47 
48 #ifndef ALGO_BLAST_CORE__BLASTPARAMETERS__H
49 #define ALGO_BLAST_CORE__BLASTPARAMETERS__H
50 
59 
60 
61 #ifdef __cplusplus
62 extern "C" {
63 #endif
64 
65 /** Default parameters for linking HSPs */
66 #define BLAST_GAP_PROB 0.5 /**< Gap probability for ungapped search */
67 #define BLAST_GAP_PROB_GAPPED 1.0 /**< Gap probability for gapped search */
68 #define BLAST_GAP_DECAY_RATE 0.5 /**< Gap decay rate for ungapped search */
69 #define BLAST_GAP_DECAY_RATE_GAPPED 0.1/**< Gap decay rate for gapped search */
70 #define BLAST_GAP_SIZE 40 /**< Default gap size */
71 #define BLAST_OVERLAP_SIZE 9 /**< Default overlap size */
72 
73 /** Expect values corresponding to the default cutoff
74  * scores for all ungapped and gapped blastn alignments.
75  */
76 #define CUTOFF_E_BLASTN 0.05 /**< default evalue (blastn) */
77 #define CUTOFF_E_BLASTP 1e-300 /**< default evalue (ungapped blastp) */
78 #define CUTOFF_E_BLASTX 1.0 /**< default evalue (ungapped blastx) */
79 #define CUTOFF_E_TBLASTN 1.0 /**< default evalue (ungapped tblastn) */
80 #define CUTOFF_E_TBLASTX 1e-300/**< default evalue (tblastx) */
81 
82 /** specifies the data structures used for bookkeeping
83  * during computation of ungapped extensions
84  */
85 typedef enum ESeedContainerType {
86  eDiagArray, /**< use diagonal structures with array of last hits
87  and levels. */
88  eDiagHash, /**< use hash table (blastn only) */
89  eMaxContainerType /**< maximum value for this enumeration */
91 
92 /** All the ungapped cutoff values that can change
93  * from context to context
94  */
95 typedef struct BlastUngappedCutoffs {
96  Int4 x_dropoff_init; /**< Raw X-dropoff value specified by the
97  bit score in BlastInitialWordOptions */
98  Int4 x_dropoff; /**< Raw X-dropoff value used in the ungapped extension */
99  Int4 cutoff_score; /**< Cutoff score for saving ungapped hits. */
100  Int4 reduced_nucl_cutoff_score; /**< for blastn, a reduced cutoff score
101  for use with approximate ungapped
102  alignments */
104 
105 /** Parameter block that contains a pointer to BlastInitialWordOptions
106  * and the values derived from it.
107  */
109  BlastInitialWordOptions* options; /**< The original (unparsed) options. */
110 
111  Int4 x_dropoff_max; /**< largest X-drop cutoff across all contexts */
112  Int4 cutoff_score_min; /**< smallest cutoff score across all contexts */
113  BlastUngappedCutoffs *cutoffs; /**< cutoff values (one per context) */
114  ESeedContainerType container_type; /**< How to store offset pairs for initial
115  seeds? */
116  Int4 nucl_score_table[256]; /**< the combined score of all match/mismatch
117  combinations for aligning four bases */
118  Boolean matrix_only_scoring; /**< Use the scoring matrix ( not table )
119  to score ungapped and gapped alignments
120  -RMH- */
121  Boolean ungapped_extension; /**< Should an ungapped extension be
122  performed? */
124 
125 /** Computed values used as parameters for gapped alignments.
126  * Note that currently the value of the X-dropoff parameter
127  * is fixed for all search contexts
128  */
129 typedef struct BlastExtensionParameters {
130  BlastExtensionOptions* options; /**< The original (unparsed) options. */
131  Int4 gap_x_dropoff; /**< X-dropoff value for gapped extension (raw) */
132  Int4 gap_x_dropoff_final;/**< X-dropoff value for the final gapped
133  extension (raw) */
135 
136 /** Parameter block for linking HSPs with sum statistics. */
137 typedef struct BlastLinkHSPParameters {
138  double gap_prob; /**< Probability of decay for linking HSPs */
139  Int4 gap_size; /**< Small gap size for linking HSPs */
140  Int4 overlap_size; /**< Maximal overlap allowed in successive linked
141  HSPs */
142  double gap_decay_rate; /**< Decay rate for linking HSPs and calculating
143  cutoff scores. */
144  Int4 cutoff_small_gap; /**< Cutoff sum score for linked HSPs with small
145  gaps. Small gap calculations are ignored if
146  this value is set to 0. */
147  Int4 cutoff_big_gap; /**< Cutoff sum score for linked HSPs with big gaps. */
148  Int4 longest_intron; /**< Length of a longest intron for uneven gap linking
149  of HSPs. */
151 
152 /** All the gapped cutoff values that can change
153  * from context to context
154  */
155 typedef struct BlastGappedCutoffs {
156  Int4 cutoff_score; /**< Raw cutoff score corresponding to the e-value
157  provided by the user if no sum stats, the lowest score
158  to attempt linking on if sum stats are used. */
159  Int4 cutoff_score_max; /**< Raw cutoff score corresponding to the e-value
160  provided by user, cutoff_score must be <= this. */
162 
163 /** Parameter block that contains a pointer to BlastHitSavingOptions
164  * and the values derived from it.
165  */
166 typedef struct BlastHitSavingParameters {
167  BlastHitSavingOptions* options; /**< The original (unparsed) options. */
168  Int4 cutoff_score_min; /**< smallest cutoff score across all contexts */
169  BlastGappedCutoffs *cutoffs; /**< per-context gapped cutoff information */
170  BlastLinkHSPParameters* link_hsp_params; /**< Parameters for linking HSPs
171  with sum statistics; linking
172  is not done if NULL. */
173  Boolean restricted_align; /**< TRUE if approximate score-only gapped
174  alignment is used */
175  Boolean do_sum_stats; /**< TRUE if sum stats will be used. Can override the
176  do_sum_stats Boolean in the options if criteria for
177  doing sum stats are not met. */
178  Int4 mask_level; /**< Only keep the highest scoring HSP when more than
179  one HSP overlaps the same region of the query by
180  more than or equal to mask_level %. -RMH- */
181  Int4* low_score; /**< lowest ungapped score that can trigger a
182  gapped alignment if the histlist is already full.
183  One value for each query. */
184  double prelim_evalue; /**< evalue for preliminary search (may be higher for CBS). */
186 
187 /** Because approximate gapped alignment adds extra overhead,
188  * it should be avoided if there is no performance benefit
189  * to using it. To be benficial, most score-only gapped alignments
190  * should be the restricted kind, and we can only assure that
191  * if the e-value cutoff is not too generous
192  */
193 #define RESTRICTED_ALIGNMENT_WORST_EVALUE 10.0
194 
195 /** Scoring parameters block
196  * Contains scoring-related information that is actually used
197  * for the blast search
198  */
199 typedef struct BlastScoringParameters {
200  BlastScoringOptions *options; /**< User-provided values for these params */
201  Int2 reward; /**< Reward for a match */
202  Int2 penalty; /**< Penalty for a mismatch */
203  Int4 gap_open; /**< Extra penalty for starting a gap (scaled version) */
204  Int4 gap_extend; /**< Penalty for each gap residue (scaled version) */
205  Int4 shift_pen; /**< Penalty for shifting a frame in out-of-frame
206  gapping (scaled version) */
207  double scale_factor; /**< multiplier for all cutoff scores */
209 
210 /** Parameters for setting up effective lengths and search spaces.
211  * The real database size values to be used for statistical calculations, if
212  * there are no overriding values in options.
213  */
215  BlastEffectiveLengthsOptions* options; /**< User provided values for these
216  parameters */
217  Int8 real_db_length; /**< Total database length to use in search space
218  calculations. */
219  Int4 real_num_seqs; /**< Number of subject sequences to use for search
220  space calculations */
222 
223 /********************************************************************************
224 
225  Functions to create options blocks with default values
226  and free them after use.
227 
228 *********************************************************************************/
229 
230 
231 /** Deallocate memory for BlastInitialWordParameters.
232  * @param parameters Structure to free [in]
233  */
237 
238 /** Allocate memory for BlastInitialWordParameters and set x_dropoff.
239  * Calling BlastInitialWordParametersNew calculates the
240  * raw x_dropoff from the bit x_dropoff and puts it into
241  * the x_dropoff field of BlastInitialWordParameters*.
242  * The container type is also set. For blastn queries over a certain
243  * length eDiagHash is set, otherwise it's eDiagArray.
244  * The extension method is also set via a call to s_GetBestExtensionMethod
245  *
246  * @param program_number Type of BLAST program [in]
247  * @param word_options The initial word options [in]
248  * @param hit_params The hit saving options (needed to calculate cutoff score
249  * for ungapped extensions) [in]
250  * @param lookup_wrap contains lookup table so the proper extension
251  * method can be set [in]
252  * @param sbp Statistical (Karlin-Altschul) information [in]
253  * @param query_info Query information [in]
254  * @param subject_length Average subject sequence length [in]
255  * @param parameters Resulting parameters [out]
256 */
258 Int2
260  const BlastInitialWordOptions* word_options,
261  const BlastHitSavingParameters* hit_params,
262  const LookupTableWrap* lookup_wrap,
263  const BlastScoreBlk* sbp,
264  BlastQueryInfo* query_info,
265  Uint4 subject_length,
266  BlastInitialWordParameters* *parameters);
267 
268 /** Update cutoff scores in BlastInitialWordParameters structure.
269  * @param program_number Type of BLAST program [in]
270  * @param hit_params The hit saving parameters, needed to calculate cutoff
271  * score for ungapped extensions. The HSP linking cutoff
272  * might have to be adjusted here. [in] [out]
273  * @param sbp Statistical (Karlin-Altschul) information [in]
274  * @param query_info Query information [in]
275  * @param subject_length Average subject sequence length [in]
276  * @param parameters Preallocated parameters [in] [out]
277 */
279 Int2
281  const BlastHitSavingParameters* hit_params,
282  const BlastScoreBlk* sbp,
283  BlastQueryInfo* query_info, Uint4 subject_length,
284  BlastInitialWordParameters* parameters);
285 
286 /** Calculate the raw values for the X-dropoff parameters
287  * @param blast_program Program number [in]
288  * @param options Already allocated extension options [in]
289  * @param sbp Structure containing statistical information [in]
290  * @param query_info Query information, needed only for determining the first
291  * context [in]
292  * @param parameters Extension parameters [out]
293  */
296  const BlastExtensionOptions* options,
297  BlastScoreBlk* sbp, BlastQueryInfo* query_info,
298  BlastExtensionParameters* *parameters);
299 
300 /** Deallocate memory for BlastExtensionParameters.
301  * @param parameters Structure to free [in]
302  */
306 
307 /** Deallocate memory for BlastScoringParameters.
308  * @param parameters Structure to free [in]
309  */
312  BlastScoringParameters* parameters);
313 
314 /** Calculate scaled cutoff scores and gap penalties
315  * @param options Already allocated scoring options [in]
316  * @param sbp Structure containing scale factor [in]
317  * @param parameters Scoring parameters [out]
318  */
321  BlastScoreBlk* sbp,
322  BlastScoringParameters* *parameters);
323 
324 /** Deallocate memory for BlastEffectiveLengthsParameters*.
325  * @param parameters Structure to free [in]
326  */
330 
331 /** Allocate memory for BlastEffectiveLengthsParameters
332  * @param options The user provided options [in]
333  * @param db_length The database length [in]
334  * @param num_seqs Number of sequences in database [in]
335  * @param parameters The parameters structure returned [out]
336  */
338 Int2
340  Int8 db_length, Int4 num_seqs,
341  BlastEffectiveLengthsParameters* *parameters);
342 
343 /** Deallocate memory for BlastLinkHSPParameters;
344  * @param parameters Structure to free [in]
345  */
349 
350 /** Initialize the linking HSPs parameters with default values.
351  * @param program_number Type of BLAST program [in]
352  * @param gapped_calculation Is this a gapped search? [in]
353  * @param link_hsp_params Initialized parameters structure [out]
354  */
357  Boolean gapped_calculation,
358  BlastLinkHSPParameters** link_hsp_params);
359 
360 /** Update BlastLinkHSPParameters, using calculated values of other parameters.
361  * @param word_params Initial word parameters [in]
362  * @param hit_params Hit saving parameters, including the link HSP
363  * parameters [in] [out]
364  * @param gapped_calculation Is this a gapped search? [in]
365  */
367 Int2
369  const BlastHitSavingParameters* hit_params,
370  Boolean gapped_calculation);
371 
372 /** Deallocate memory for BlastHitSavingOptions*.
373  * @param parameters Structure to free [in]
374  */
378 
379 /** Allocate memory and initialize the BlastHitSavingParameters structure.
380  * Calculates the (raw) score cutoff given an expect value and puts
381  * it in the "cutoff_score" field of the returned BlastHitSavingParameters*
382  *
383  * @param program_number Number of the BLAST program [in]
384  * @param options The given hit saving options [in]
385  * @param sbp Scoring block, needed for calculating score cutoff from
386  * e-value [in]
387  * @param query_info Query information, needed for calculating score cutoff
388  * from e-value [in]
389  * @param avg_subject_length average length of subject sequence [in]
390  * @param compositionBasedStats follows -t option in blastp [in]
391  * @param parameters Resulting parameters [out]
392  */
395  const BlastHitSavingOptions* options,
396  const BlastScoreBlk* sbp,
397  const BlastQueryInfo* query_info,
398  Int4 avg_subject_length,
399  Int4 compositionBasedStats,
400  BlastHitSavingParameters* *parameters);
401 
402 /** Updates cutoff scores in hit saving parameters.
403  * @param program_number Number of the BLAST program [in]
404  * @param sbp Scoring block, needed for calculating score cutoff from
405  * e-value [in]
406  * @param query_info Query information, needed for calculating score cutoff
407  * from e-value [in]
408  * @param avg_subject_length average length of subject sequence, used in sum_stats
409  * mode [in]
410  * @param compositionBasedStats follows -t option in blastp [in]
411  * @param parameters Preallocated parameters [in] [out]
412  */
415  const BlastScoreBlk* sbp, const BlastQueryInfo* query_info,
416  Int4 avg_subject_length,
417  Int4 compositionBasedStats,
418  BlastHitSavingParameters* parameters);
419 
420 /** Calculates cutoff scores and returns them.
421  * Equations provided by Stephen Altschul.
422  * @param program BLAST program type [in]
423  * @param query_info Query(ies) information [in]
424  * @param sbp Scoring statistical parameters [in]
425  * @param link_hsp_params Parameters for linking HSPs [in] [out]
426  * @param word_params InitialWordParameters (cutoff_score used for small gaps) [in]
427  * @param db_length Total length of database (non-database search if 0) [in]
428  * @param subject_length Length of the subject sequence. [in]
429  *
430 */
432 void
434  const BlastScoreBlk* sbp, BlastLinkHSPParameters* link_hsp_params,
435  const BlastInitialWordParameters* word_params,
436  Int8 db_length, Int4 subject_length);
437 
438 // Routines for debugging parameter settings. -RMH-
441  BlastQueryInfo *query_info );
444  BlastQueryInfo *query_info );
445 void printAllParameters ( BlastHitSavingParameters * hit_params,
446  BlastExtensionParameters *ext_params,
447  BlastInitialWordParameters *word_params,
448  BlastQueryInfo *query_info );
449 
450 #ifdef __cplusplus
451 }
452 #endif
453 #endif /* !ALGO_BLAST_CORE__BLASTPARAMETERS__H */
454 
Defines to provide correct exporting from BLAST DLL in Windows.
#define NCBI_XBLAST_EXPORT
NULL operations for other cases.
Definition: blast_export.h:65
Structures for BLAST messages.
The structures and functions in blast_options.
BlastHitSavingParameters * BlastHitSavingParametersFree(BlastHitSavingParameters *parameters)
Deallocate memory for BlastHitSavingOptions*.
struct BlastUngappedCutoffs BlastUngappedCutoffs
All the ungapped cutoff values that can change from context to context.
Int2 BlastLinkHSPParametersNew(EBlastProgramType program_number, Boolean gapped_calculation, BlastLinkHSPParameters **link_hsp_params)
Initialize the linking HSPs parameters with default values.
BlastEffectiveLengthsParameters * BlastEffectiveLengthsParametersFree(BlastEffectiveLengthsParameters *parameters)
Deallocate memory for BlastEffectiveLengthsParameters*.
struct BlastExtensionParameters BlastExtensionParameters
Computed values used as parameters for gapped alignments.
void printBlastScoringParameters(BlastScoringParameters *params)
Int2 BlastExtensionParametersNew(EBlastProgramType blast_program, const BlastExtensionOptions *options, BlastScoreBlk *sbp, BlastQueryInfo *query_info, BlastExtensionParameters **parameters)
Calculate the raw values for the X-dropoff parameters.
ESeedContainerType
specifies the data structures used for bookkeeping during computation of ungapped extensions
@ eMaxContainerType
maximum value for this enumeration
@ eDiagHash
use hash table (blastn only)
@ eDiagArray
use diagonal structures with array of last hits and levels.
BlastInitialWordParameters * BlastInitialWordParametersFree(BlastInitialWordParameters *parameters)
Deallocate memory for BlastInitialWordParameters.
BlastExtensionParameters * BlastExtensionParametersFree(BlastExtensionParameters *parameters)
Deallocate memory for BlastExtensionParameters.
void printBlastHitSavingParameters(BlastHitSavingParameters *hit_params, BlastQueryInfo *query_info)
struct BlastInitialWordParameters BlastInitialWordParameters
Parameter block that contains a pointer to BlastInitialWordOptions and the values derived from it.
struct BlastGappedCutoffs BlastGappedCutoffs
All the gapped cutoff values that can change from context to context.
Int2 BlastScoringParametersNew(const BlastScoringOptions *options, BlastScoreBlk *sbp, BlastScoringParameters **parameters)
Calculate scaled cutoff scores and gap penalties.
Int2 BlastInitialWordParametersNew(EBlastProgramType program_number, const BlastInitialWordOptions *word_options, const BlastHitSavingParameters *hit_params, const LookupTableWrap *lookup_wrap, const BlastScoreBlk *sbp, BlastQueryInfo *query_info, Uint4 subject_length, BlastInitialWordParameters **parameters)
Allocate memory for BlastInitialWordParameters and set x_dropoff.
struct BlastLinkHSPParameters BlastLinkHSPParameters
Parameter block for linking HSPs with sum statistics.
void printAllParameters(BlastHitSavingParameters *hit_params, BlastExtensionParameters *ext_params, BlastInitialWordParameters *word_params, BlastQueryInfo *query_info)
BlastLinkHSPParameters * BlastLinkHSPParametersFree(BlastLinkHSPParameters *parameters)
Deallocate memory for BlastLinkHSPParameters;.
struct BlastScoringParameters BlastScoringParameters
Scoring parameters block Contains scoring-related information that is actually used for the blast sea...
Int2 BlastHitSavingParametersNew(EBlastProgramType program_number, const BlastHitSavingOptions *options, const BlastScoreBlk *sbp, const BlastQueryInfo *query_info, Int4 avg_subject_length, Int4 compositionBasedStats, BlastHitSavingParameters **parameters)
Allocate memory and initialize the BlastHitSavingParameters structure.
Int2 BlastHitSavingParametersUpdate(EBlastProgramType program_number, const BlastScoreBlk *sbp, const BlastQueryInfo *query_info, Int4 avg_subject_length, Int4 compositionBasedStats, BlastHitSavingParameters *parameters)
Updates cutoff scores in hit saving parameters.
Int2 BlastLinkHSPParametersUpdate(const BlastInitialWordParameters *word_params, const BlastHitSavingParameters *hit_params, Boolean gapped_calculation)
Update BlastLinkHSPParameters, using calculated values of other parameters.
void printBlastInitialWordParamters(BlastInitialWordParameters *word_params, BlastQueryInfo *query_info)
struct BlastHitSavingParameters BlastHitSavingParameters
Parameter block that contains a pointer to BlastHitSavingOptions and the values derived from it.
Int2 BlastInitialWordParametersUpdate(EBlastProgramType program_number, const BlastHitSavingParameters *hit_params, const BlastScoreBlk *sbp, BlastQueryInfo *query_info, Uint4 subject_length, BlastInitialWordParameters *parameters)
Update cutoff scores in BlastInitialWordParameters structure.
void CalculateLinkHSPCutoffs(EBlastProgramType program, BlastQueryInfo *query_info, const BlastScoreBlk *sbp, BlastLinkHSPParameters *link_hsp_params, const BlastInitialWordParameters *word_params, Int8 db_length, Int4 subject_length)
Calculates cutoff scores and returns them.
struct BlastEffectiveLengthsParameters BlastEffectiveLengthsParameters
Parameters for setting up effective lengths and search spaces.
void printBlastExtensionParameters(BlastExtensionParameters *ext_params)
BlastScoringParameters * BlastScoringParametersFree(BlastScoringParameters *parameters)
Deallocate memory for BlastScoringParameters.
Int2 BlastEffectiveLengthsParametersNew(const BlastEffectiveLengthsOptions *options, Int8 db_length, Int4 num_seqs, BlastEffectiveLengthsParameters **parameters)
Allocate memory for BlastEffectiveLengthsParameters.
Definitions for various programs supported by core BLAST.
EBlastProgramType
Defines the engine's notion of the different applications of the BLAST algorithm.
Definition: blast_program.h:72
Definitions and functions associated with the BlastQueryInfo structure.
Definitions and prototypes used by blast_stat.c to calculate BLAST statistics.
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
uint32_t Uint4
4-byte (32-bit) unsigned integer
Definition: ncbitype.h:103
int64_t Int8
8-byte (64-bit) signed integer
Definition: ncbitype.h:104
Wrapper for all lookup tables used in BLAST.
Type and macro definitions from C toolkit that are not defined in C++ toolkit.
Uint1 Boolean
bool replacment for C
Definition: ncbi_std.h:94
Options for setting up effective lengths and search spaces.
Parameters for setting up effective lengths and search spaces.
Int8 real_db_length
Total database length to use in search space calculations.
Int4 real_num_seqs
Number of subject sequences to use for search space calculations.
BlastEffectiveLengthsOptions * options
User provided values for these parameters.
Options used for gapped extension These include: a.
Computed values used as parameters for gapped alignments.
BlastExtensionOptions * options
The original (unparsed) options.
Int4 gap_x_dropoff_final
X-dropoff value for the final gapped extension (raw)
Int4 gap_x_dropoff
X-dropoff value for gapped extension (raw)
All the gapped cutoff values that can change from context to context.
Int4 cutoff_score
Raw cutoff score corresponding to the e-value provided by the user if no sum stats,...
Int4 cutoff_score_max
Raw cutoff score corresponding to the e-value provided by user, cutoff_score must be <= this.
Options used when evaluating and saving hits These include: a.
Parameter block that contains a pointer to BlastHitSavingOptions and the values derived from it.
BlastGappedCutoffs * cutoffs
per-context gapped cutoff information
Int4 mask_level
Only keep the highest scoring HSP when more than one HSP overlaps the same region of the query by mor...
Boolean restricted_align
TRUE if approximate score-only gapped alignment is used.
Int4 cutoff_score_min
smallest cutoff score across all contexts
Boolean do_sum_stats
TRUE if sum stats will be used.
Int4 * low_score
lowest ungapped score that can trigger a gapped alignment if the histlist is already full.
double prelim_evalue
evalue for preliminary search (may be higher for CBS).
BlastLinkHSPParameters * link_hsp_params
Parameters for linking HSPs with sum statistics; linking is not done if NULL.
BlastHitSavingOptions * options
The original (unparsed) options.
Options needed for initial word finding and processing.
Parameter block that contains a pointer to BlastInitialWordOptions and the values derived from it.
BlastUngappedCutoffs * cutoffs
cutoff values (one per context)
Boolean ungapped_extension
Should an ungapped extension be performed?
BlastInitialWordOptions * options
The original (unparsed) options.
Boolean matrix_only_scoring
Use the scoring matrix ( not table ) to score ungapped and gapped alignments -RMH-.
Int4 cutoff_score_min
smallest cutoff score across all contexts
Int4 x_dropoff_max
largest X-drop cutoff across all contexts
ESeedContainerType container_type
How to store offset pairs for initial seeds?
Int4 nucl_score_table[256]
the combined score of all match/mismatch combinations for aligning four bases
Parameter block for linking HSPs with sum statistics.
double gap_decay_rate
Decay rate for linking HSPs and calculating cutoff scores.
double gap_prob
Probability of decay for linking HSPs.
Int4 cutoff_big_gap
Cutoff sum score for linked HSPs with big gaps.
Int4 cutoff_small_gap
Cutoff sum score for linked HSPs with small gaps.
Int4 overlap_size
Maximal overlap allowed in successive linked HSPs.
Int4 longest_intron
Length of a longest intron for uneven gap linking of HSPs.
Int4 gap_size
Small gap size for linking HSPs.
The query related information.
Structure used for scoring calculations.
Definition: blast_stat.h:177
Scoring options block Used to produce the BlastScoreBlk structure This structure may be needed for lo...
Scoring parameters block Contains scoring-related information that is actually used for the blast sea...
double scale_factor
multiplier for all cutoff scores
Int4 gap_extend
Penalty for each gap residue (scaled version)
Int2 penalty
Penalty for a mismatch.
Int4 shift_pen
Penalty for shifting a frame in out-of-frame gapping (scaled version)
Int4 gap_open
Extra penalty for starting a gap (scaled version)
BlastScoringOptions * options
User-provided values for these params.
Int2 reward
Reward for a match.
All the ungapped cutoff values that can change from context to context.
Int4 reduced_nucl_cutoff_score
for blastn, a reduced cutoff score for use with approximate ungapped alignments
Int4 x_dropoff_init
Raw X-dropoff value specified by the bit score in BlastInitialWordOptions.
Int4 cutoff_score
Cutoff score for saving ungapped hits.
Int4 x_dropoff
Raw X-dropoff value used in the ungapped extension.
Wrapper structure for different types of BLAST lookup tables.
Definition: lookup_wrap.h:50
Modified on Tue Apr 16 20:10:16 2024 by modify_doxy.py rev. 669887