NCBI C++ ToolKit
blast.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /*
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 offical 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 
28 File name: blast.cpp
29 
30 Author: Jason Papadopoulos
31 
32 Contents: Find local alignments between sequences
33 
34 ******************************************************************************/
35 
36 #include <ncbi_pch.hpp>
37 #include <util/range_coll.hpp>
38 #include <objmgr/util/sequence.hpp>
46 #include <algo/cobalt/cobalt.hpp>
47 
48 /// @file blast.cpp
49 /// Find local alignments between sequences
50 
52 BEGIN_SCOPE(cobalt)
53 
54 USING_SCOPE(blast);
56 
57 /// Create a new query sequence that is a subset of a previous
58 /// query sequence
59 /// @param loc_list List of previously generated sequence fragments [in/out]
60 /// @param query Sequence that contains the current fragment [in]
61 /// @param from Start offset of fragment [in]
62 /// @param to End offset of fragment [in]
63 /// @param seg_list List of simplified representations of
64 /// previous fragments [in/out]
65 /// @param query_index Ordinal ID of 'query'
66 ///
67 void
68 CMultiAligner::x_AddNewSegment(vector< CRef<objects::CSeq_loc> >& loc_list,
70  TOffset from, TOffset to,
71  vector<SSegmentLoc>& seg_list,
72  int query_index)
73 {
74  // Note that all offsets are zero-based
75 
76  CRef<CSeq_loc> seqloc(new CSeq_loc());
77  seqloc->SetInt().SetFrom(from);
78  seqloc->SetInt().SetTo(to);
79  seqloc->SetInt().SetStrand(eNa_strand_unknown);
80  seqloc->SetInt().SetId().Assign(sequence::GetId(*query, m_Scope));
81  loc_list.push_back(seqloc);
82 
83  seg_list.push_back(SSegmentLoc(query_index, from, to));
84 }
85 
86 /// Turn all fragments of selected query sequence not already covered by
87 /// a domain hit into a separate query sequence, used as input
88 /// to a blast search
89 /// @param blastp_indices Indices of query sequences selected for blastp
90 /// search [in]
91 /// @param filler_locs List of generated sequences [out]
92 /// @param filler_segs Simplified representation of filler_locs [out]
93 ///
94 void
95 CMultiAligner::x_MakeFillerBlocks(const vector<int>& blastp_indices,
96  vector< CRef<objects::CSeq_loc> >& filler_locs,
97  vector<SSegmentLoc>& filler_segs)
98 {
99  int num_queries = m_QueryData.size();
100  vector<CRangeCollection<TOffset> > sorted_segs(num_queries);
101 
102  // Merge the offset ranges of all the current domain hits
103 
104  for (int i = 0; i < m_CombinedHits.Size(); i++) {
105  CHit *hit = m_CombinedHits.GetHit(i);
106  _ASSERT(hit->HasSubHits());
107 
108  ITERATE(CHit::TSubHit, subitr, hit->GetSubHit()) {
109  CHit *subhit = *subitr;
110  sorted_segs[hit->m_SeqIndex1].CombineWith(
111  static_cast<CRange<TOffset> >(subhit->m_SeqRange1));
112  sorted_segs[hit->m_SeqIndex2].CombineWith(
113  static_cast<CRange<TOffset> >(subhit->m_SeqRange2));
114  }
115  }
116 
117  // For each query sequence, mark off the regions
118  // not covered by a domain hit
119 
120  ITERATE(vector<int>, it, blastp_indices) {
121  int i = *it;
122 
123  CRangeCollection<TOffset>& collection(sorted_segs[i]);
124  TOffset seg_start = 0;
125 
126  // Note that fragments of size less than kMinHitSize
127  // are ignored
128 
129  ITERATE(CRangeCollection<TOffset>, itr, collection) {
130  if (itr->GetFrom() - seg_start > CHit::kMinHitSize) {
131  x_AddNewSegment(filler_locs, m_tQueries[i], seg_start,
132  itr->GetFrom() - 1, filler_segs, i);
133  }
134  seg_start = itr->GetToOpen();
135  }
136 
137  // Handle the last fragment; this could actually
138  // envelop the entire sequence
139 
140  int seq_length = sequence::GetLength(*m_tQueries[i], m_Scope);
141 
142  if (seq_length - seg_start > CHit::kMinHitSize) {
143  x_AddNewSegment(filler_locs, m_tQueries[i], seg_start,
144  seq_length - 1, filler_segs, i);
145  }
146  }
147 
148  if (m_Options->GetVerbose()) {
149  printf("Filler Segments:\n");
150  for (int i = 0; i < (int)filler_segs.size(); i++) {
151  printf("query %d %4d - %4d\n",
152  filler_segs[i].seq_index,
153  filler_segs[i].GetFrom(),
154  filler_segs[i].GetTo());
155  }
156  printf("\n\n");
157  }
158 }
159 
160 /// Run blastp, aligning the collection of filler fragments
161 /// against the entire input dataset
162 /// @param queries List of queries selected for blastp alignment [in]
163 /// @param indices List of indices of each selected query in the queries
164 /// array [in]
165 /// @param filler_locs List of generated sequences [in]
166 /// @param filler_segs Simplified representation of filler_locs [in]
167 ///
168 void
170  const vector<int>& indices,
171  vector< CRef<CSeq_loc> >& filler_locs,
172  vector<SSegmentLoc>& filler_segs)
173 {
174  const int kBlastBatchSize = 10000;
175  size_t num_full_queries = indices.size();
176 
177  if (filler_locs.empty())
178  return;
179 
180  // Set the blast options
181 
182  double blastp_evalue = m_Options->GetBlastpEvalue();
184  // deliberately set the cutoff e-value too high
185  blastp_opts->SetEvalueThreshold(max(blastp_evalue, 10.0));
186  //blastp_opts.SetGappedMode(false);
187  blastp_opts->SetSegFiltering(false);
188 
189  // use blast on one batch of filler segments at a time
190 
191  int batch_start = 0;
192  while (batch_start < (int)filler_locs.size()) {
193 
194  TSeqLocVector curr_batch;
195  int batch_size = 0;
196 
197  for (int i = batch_start; i < (int)filler_locs.size(); i++) {
198  const CSeq_loc& curr_loc = *filler_locs[i];
199  int fragment_size = curr_loc.GetInt().GetTo() -
200  curr_loc.GetInt().GetFrom() + 1;
201  if (batch_size + fragment_size >= kBlastBatchSize && batch_size > 0)
202  break;
203 
204  curr_batch.push_back(SSeqLoc(*filler_locs[i], *m_Scope));
205  batch_size += fragment_size;
206  }
207 
208  CBl2Seq blaster(curr_batch, queries, *blastp_opts);
209  TSeqAlignVector v = blaster.Run();
210 
211  // check for interrupt
214  "Alignment interrupted");
215  }
216 
217  // Convert each resulting HSP into a CHit object
218 
219  // iterate over query sequence fragments for the current batch
220 
221  for (int i = 0; i < (int)curr_batch.size(); i++) {
222 
223  int list1_oid = filler_segs[batch_start + i].seq_index;
224 
225  for (size_t j = 0; j < num_full_queries; j++) {
226 
227  // skip hits that map to the same query sequence
228 
229  if (list1_oid == indices[j])
230  continue;
231 
232  // iterate over hitlists
233 
235  v[i * num_full_queries + j]->Get()) {
236 
237  // iterate over hits
238 
239  const CSeq_align& s = **itr;
240 
242  // Dense-seg (1 hit)
243 
244  const CDense_seg& denseg = s.GetSegs().GetDenseg();
245  int align_score = 0;
246  double evalue = 0;
247 
248  ITERATE(CSeq_align::TScore, score_itr, s.GetScore()) {
249  const CScore& curr_score = **score_itr;
250  if (curr_score.GetId().GetStr() == "score")
251  align_score = curr_score.GetValue().GetInt();
252  else if (curr_score.GetId().GetStr() == "e_value")
253  evalue = curr_score.GetValue().GetReal();
254  }
255 
256  // check if the hit is worth saving
257  if (evalue > blastp_evalue)
258  continue;
259 
260  m_LocalHits.AddToHitList(new CHit(list1_oid, indices[j],
261  align_score, denseg));
262  }
263  else if (s.GetSegs().Which() ==
265  // Dense-diag (all hits)
266 
268  s.GetSegs().GetDendiag()) {
269  const CDense_diag& dendiag = **diag_itr;
270  int align_score = 0;
271  double evalue = 0;
272 
273  // compute the score of the hit
274 
275  ITERATE(CDense_diag::TScores, score_itr,
276  dendiag.GetScores()) {
277  const CScore& curr_score = **score_itr;
278  if (curr_score.GetId().GetStr() == "score") {
279  align_score =
280  curr_score.GetValue().GetInt();
281  }
282  else if (curr_score.GetId().GetStr() ==
283  "e_value") {
284  evalue = curr_score.GetValue().GetReal();
285  }
286  }
287 
288  // check if the hit is worth saving
289  if (evalue > blastp_evalue)
290  continue;
291 
292  m_LocalHits.AddToHitList(new CHit(list1_oid,
293  indices[j], align_score, dendiag));
294  }
295  }
296  }
297  }
298  }
299 
300  // proceed to net batch of sequence fragments
301  batch_start += curr_batch.size();
302  }
303 }
304 
305 void
307  const vector<int>& indices)
308 {
310 
311  // Clear off previous state if it exists
312 
314  if (m_DomainHits.Empty()) {
315 
317 
318  // Initialize the profile columns of the input sequences
319 
321  }
322 
323  // Produce another set of queries that consist of the 'filler'
324  // in the input data, i.e. all stretches of all sequences not
325  // covered by at least one domain hit. Then align all the
326  // filler regions against each other and add any new HSPs to
327  // 'results'
328 
329  vector< CRef<objects::CSeq_loc> > filler_locs;
330  vector<SSegmentLoc> filler_segs;
331  x_MakeFillerBlocks(indices, filler_locs, filler_segs);
332  x_AlignFillerBlocks(queries, indices, filler_locs, filler_segs);
333 
334  //-------------------------------------------------------
335  if (m_Options->GetVerbose()) {
336  printf("blastp hits:\n");
337  for (int i = 0; i < m_LocalHits.Size(); i++) {
338  CHit *hit = m_LocalHits.GetHit(i);
339  printf("query %d %4d - %4d query %d %4d - %4d score %d\n",
340  hit->m_SeqIndex1,
341  hit->m_SeqRange1.GetFrom(),
342  hit->m_SeqRange1.GetTo(),
343  hit->m_SeqIndex2,
344  hit->m_SeqRange2.GetFrom(),
345  hit->m_SeqRange2.GetTo(),
346  hit->m_Score);
347  }
348  printf("\n\n");
349  }
350  //-------------------------------------------------------
351 
353 }
354 
355 
356 
357 unique_ptr< vector<int> > CMultiAligner::x_AlignClusterQueries(
358  const TPhyTreeNode* node)
359 {
360  // Traverse cluster tree
361 
362  // if leaf node, then create one-element list of node id
363  if (node->IsLeaf()) {
364  unique_ptr< vector<int> > result(new vector<int>());
365  result->push_back(node->GetValue().GetId());
366  return result;
367  }
368 
369  // Traverse left and right subtree and gather node ids in the subtrees
371 
372  unique_ptr< vector<int> > left_inds = x_AlignClusterQueries(*child);
373  child++;
374 
375  _ASSERT(*child);
376  unique_ptr< vector<int> > right_inds = x_AlignClusterQueries(*child);
377  child++;
378  _ASSERT(child == node->SubNodeEnd());
379 
380  // Get most similar sequences from different subtrees
382 
383  int left = -1, right = -1;
384  double dist = 0.0;
385  for (size_t i=0;i < left_inds->size();i++) {
386  for (size_t j=0;j < right_inds->size();j++) {
387  if (dist > dmat((*left_inds)[i], (*right_inds)[j]) || left < 0) {
388  left = (*left_inds)[i];
389  right = (*right_inds)[j];
390  dist = dmat(left, right);
391  }
392  }
393  }
394  _ASSERT(left != right);
395 
396  // Align the found pair of sequences - one from each subtree
397  double blastp_evalue = m_Options->GetBlastpEvalue();
399  // deliberately set the cutoff e-value too high
400  blastp_opts->SetEvalueThreshold(max(blastp_evalue, 10.0));
401  blastp_opts->SetSegFiltering(false);
402 
403  SSeqLoc left_query(*m_tQueries[left], *m_Scope);
404  SSeqLoc right_query(*m_tQueries[right], *m_Scope);
405 
406  CBl2Seq blaster(left_query, right_query, *blastp_opts);
407  CRef<CSearchResultSet> v = blaster.RunEx();
408 
409  // Add hit to hitlist
410  ITERATE(CSeq_align_set::Tdata, itr, v->GetResults(0, 0).GetSeqAlign()->Get()) {
411 
412  // iterate over hits
413 
414  const CSeq_align& s = **itr;
415 
417  // Dense-seg (1 hit)
418 
419  const CDense_seg& denseg = s.GetSegs().GetDenseg();
420  int align_score = 0;
421  double evalue = 0;
422 
423  ITERATE(CSeq_align::TScore, score_itr, s.GetScore()) {
424  const CScore& curr_score = **score_itr;
425  if (curr_score.GetId().GetStr() == "score")
426  align_score = curr_score.GetValue().GetInt();
427  else if (curr_score.GetId().GetStr() == "e_value")
428  evalue = curr_score.GetValue().GetReal();
429  }
430 
431  // check if the hit is worth saving
432  if (evalue > blastp_evalue)
433  continue;
434 
435  m_LocalInClusterHits.AddToHitList(new CHit(left, right, align_score,
436  denseg));
437  }
438  else if (s.GetSegs().Which() == CSeq_align::C_Segs::e_Dendiag) {
439  // Dense-diag (all hits)
440 
442  s.GetSegs().GetDendiag()) {
443  const CDense_diag& dendiag = **diag_itr;
444  int align_score = 0;
445  double evalue = 0;
446 
447  // compute the score of the hit
448 
449  ITERATE(CDense_diag::TScores, score_itr, dendiag.GetScores()) {
450  const CScore& curr_score = **score_itr;
451  if (curr_score.GetId().GetStr() == "score") {
452  align_score =
453  curr_score.GetValue().GetInt();
454  }
455  else if (curr_score.GetId().GetStr() ==
456  "e_value") {
457  evalue = curr_score.GetValue().GetReal();
458  }
459  }
460 
461  // check if the hit is worth saving
462  if (evalue > blastp_evalue)
463  continue;
464 
465  m_LocalInClusterHits.AddToHitList(new CHit(left, right,
466  align_score, dendiag));
467  }
468  }
469  }
470 
471 
472  // Return sequences from this subtree
473  ITERATE(vector<int>, it, *right_inds) {
474  left_inds->push_back(*it);
475  }
476  return left_inds;
477 }
478 
479 
480 
482  const vector<TPhyTreeNode*>& cluster_trees)
483 {
485 
486  // Traverse cluster trees and find local constraints for each left and
487  // right subtree of each substree
488  ITERATE(vector<TPhyTreeNode*>, it, cluster_trees) {
489  // NULL trees denore one-element clusters, nothing to do in such cases
490  if (*it) {
492  }
493  }
494 
495  //-------------------------------------------------------
496  if (m_Options->GetVerbose()) {
497  printf("in-cluster blastp hits:\n");
498  for (int i = 0; i < m_LocalInClusterHits.Size(); i++) {
500  printf("query %d %4d - %4d query %d %4d - %4d score %d\n",
501  hit->m_SeqIndex1,
502  hit->m_SeqRange1.GetFrom(),
503  hit->m_SeqRange1.GetTo(),
504  hit->m_SeqIndex2,
505  hit->m_SeqRange2.GetFrom(),
506  hit->m_SeqRange2.GetTo(),
507  hit->m_Score);
508  }
509  printf("\n\n");
510  }
511  //-------------------------------------------------------
512 }
513 
514 
515 
516 END_SCOPE(cobalt)
static CRef< CScope > m_Scope
User-defined methods of the data storage class.
int TOffset
Basic data type for offsets into a sequence.
Definition: base.hpp:49
Declares the CBl2Seq (BLAST 2 Sequences) class.
USING_SCOPE(blast)
Declares the CBlastProteinOptionsHandle class.
vector< CRef< objects::CSeq_align_set > > TSeqAlignVector
Vector of Seq-align-sets.
Runs the BLAST algorithm between 2 sequences.
Definition: bl2seq.hpp:58
Handle to the protein-protein options to the BLAST algorithm.
const TDistMatrix & GetDistMatrix(void) const
Get distance matrix.
Definition: clusterer.cpp:118
void Append(CHitList &hitlist)
Append one hitlist to another.
Definition: hitlist.cpp:385
int Size() const
Retrieve number of hits in list.
Definition: hitlist.hpp:75
void PurgeAllHits()
Delete all hits unconditionally.
Definition: hitlist.hpp:148
bool Empty()
Determine whether a list contains no hits.
Definition: hitlist.hpp:79
CHit * GetHit(int index)
Retrieve a hit from the hitlist.
Definition: hitlist.hpp:93
void AddToHitList(CHit *hit)
Append a hit to the hitlist.
Definition: hitlist.hpp:84
A generalized representation of a pairwise alignment.
Definition: hit.hpp:86
TSubHit & GetSubHit()
Retrieve a list of subhits.
Definition: hit.hpp:185
int m_Score
Score of alignment.
Definition: hit.hpp:104
int m_SeqIndex1
Numerical identifier for first sequence in alignment.
Definition: hit.hpp:97
int m_SeqIndex2
Numerical identifier for second sequence in alignment.
Definition: hit.hpp:101
TRange m_SeqRange1
The range of offsets on the first sequence.
Definition: hit.hpp:107
static const int kMinHitSize
Not always used, but useful to avoid extremely small hits.
Definition: hit.hpp:90
TRange m_SeqRange2
The range of offsets on the second sequence.
Definition: hit.hpp:110
bool HasSubHits()
Query if a CHit has a hierarchy of subhits available.
Definition: hit.hpp:195
vector< CHit * > TSubHit
Hits can be grouped hierarchically.
Definition: hit.hpp:93
double GetBlastpEvalue(void) const
Get e-value for accepting Blastp hits.
Definition: options.hpp:540
bool GetVerbose(void) const
Get verbose mode.
Definition: options.hpp:691
Simultaneously align multiple protein sequences.
Definition: cobalt.hpp:69
SProgress m_ProgressMonitor
Definition: cobalt.hpp:737
CRef< objects::CScope > m_Scope
Definition: cobalt.hpp:689
void x_FindLocalInClusterHits(const vector< TPhyTreeNode * > &cluster_trees)
Run blast on sequences from each cluster subtree.
Definition: blast.cpp:481
vector< CRef< objects::CSeq_loc > > m_tQueries
Definition: cobalt.hpp:688
CHitList m_CombinedHits
Definition: cobalt.hpp:718
CHitList m_LocalInClusterHits
Definition: cobalt.hpp:720
void x_AlignFillerBlocks(const blast::TSeqLocVector &queries, const vector< int > &indices, vector< CRef< objects::CSeq_loc > > &filler_locs, vector< SSegmentLoc > &filler_segs)
Run blastp, aligning the collection of filler fragments against the entire input dataset.
Definition: blast.cpp:169
void x_FindLocalHits(const blast::TSeqLocVector &queries, const vector< int > &indices)
Run blast on selected input sequences and postprocess the results.
Definition: blast.cpp:306
@ eInterrupt
Alignment interruped through callback function.
Definition: cobalt.hpp:83
vector< CSequence > m_QueryData
Definition: cobalt.hpp:691
void x_AssignDefaultResFreqs()
Definition: rps.cpp:603
CClusterer m_Clusterer
Definition: cobalt.hpp:712
CHitList m_DomainHits
Definition: cobalt.hpp:716
CConstRef< CMultiAlignerOptions > m_Options
Definition: cobalt.hpp:686
void x_AddNewSegment(vector< CRef< objects::CSeq_loc > > &loc_list, const CRef< objects::CSeq_loc > &query, TOffset from, TOffset to, vector< SSegmentLoc > &seg_list, int query_index)
Create a new query sequence that is a subset of a previous query sequence.
Definition: blast.cpp:68
void x_MakeFillerBlocks(const vector< int > &indices, vector< CRef< objects::CSeq_loc > > &filler_locs, vector< SSegmentLoc > &filler_segs)
Turn all fragments of selected query sequence not already covered by a domain hit into a separate que...
Definition: blast.cpp:95
@ eLocalHitsSearch
Definition: cobalt.hpp:94
FInterruptFn m_Interrupt
Definition: cobalt.hpp:736
unique_ptr< vector< int > > x_AlignClusterQueries(const TPhyTreeNode *node)
Definition: blast.cpp:357
CHitList m_LocalHits
Definition: cobalt.hpp:717
CRef –.
Definition: ncbiobj.hpp:618
Definition: Score.hpp:57
definition of a Culling tree
Definition: ncbi_tree.hpp:100
Interface for CMultiAligner.
CConstRef< objects::CSeq_align_set > GetSeqAlign() const
Accessor for the Seq-align results.
virtual TSeqAlignVector Run()
Perform BLAST search Assuming N queries and M subjects, the structure of the returned vector is as fo...
Definition: bl2seq.cpp:173
CRef< CSearchResultSet > RunEx()
Performs the same functionality as Run(), but it returns a different data type.
Definition: bl2seq.cpp:196
CSearchResults & GetResults(size_type qi, size_type si)
Retrieve results for a query-subject pair contained by this object.
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
Definition: ncbimisc.hpp:815
#define NCBI_THROW(exception_class, err_code, message)
Generic macro to throw an exception, given the exception class, error code and message string.
Definition: ncbiexpt.hpp:704
void SetInt(TInt &v)
Definition: Seq_loc.hpp:983
const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)
If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...
TSeqPos GetLength(const CSeq_id &id, CScope *scope)
Get sequence length if scope not null, else return max possible TSeqPos.
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define END_SCOPE(ns)
End the previously defined scope.
Definition: ncbistl.hpp:75
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
#define BEGIN_SCOPE(ns)
Define a new scope.
Definition: ncbistl.hpp:72
TNodeList_CI SubNodeBegin(void) const
Return first const iterator on subnode list.
Definition: ncbi_tree.hpp:160
TNodeList::const_iterator TNodeList_CI
Definition: ncbi_tree.hpp:110
bool IsLeaf() const
Report whether this is a leaf node.
Definition: ncbi_tree.hpp:296
TNodeList_CI SubNodeEnd(void) const
Return last const iterator on subnode list.
Definition: ncbi_tree.hpp:166
const TValue & GetValue(void) const
Return node's value.
Definition: ncbi_tree.hpp:184
TTo GetTo(void) const
Get the To member data.
Definition: Range_.hpp:269
TFrom GetFrom(void) const
Get the From member data.
Definition: Range_.hpp:222
const TStr & GetStr(void) const
Get the variant data.
Definition: Object_id_.hpp:297
const TDenseg & GetDenseg(void) const
Get the variant data.
Definition: Seq_align_.cpp:153
const TScores & GetScores(void) const
Get the Scores member data.
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_align_.hpp:691
vector< CRef< CScore > > TScore
Definition: Seq_align_.hpp:398
TInt GetInt(void) const
Get the variant data.
Definition: Score_.hpp:411
const TDendiag & GetDendiag(void) const
Get the variant data.
Definition: Seq_align_.hpp:726
const TValue & GetValue(void) const
Get the Value member data.
Definition: Score_.hpp:465
vector< CRef< CScore > > TScores
Definition: Dense_diag_.hpp:97
list< CRef< CSeq_align > > Tdata
const TScore & GetScore(void) const
Get the Score member data.
Definition: Seq_align_.hpp:896
TReal GetReal(void) const
Get the variant data.
Definition: Score_.hpp:384
list< CRef< CDense_diag > > TDendiag
Definition: Seq_align_.hpp:194
const TId & GetId(void) const
Get the Id member data.
Definition: Score_.hpp:444
const TSegs & GetSegs(void) const
Get the Segs member data.
Definition: Seq_align_.hpp:921
TFrom GetFrom(void) const
Get the From member data.
TTo GetTo(void) const
Get the To member data.
const TInt & GetInt(void) const
Get the variant data.
Definition: Seq_loc_.cpp:194
@ eNa_strand_unknown
Definition: Na_strand_.hpp:65
unsigned int
A callback function used to compare two keys in a database.
Definition: types.hpp:1210
int i
const TYPE & Get(const CNamedParameterList *param)
T max(T x_, T y_)
vector< SSeqLoc > TSeqLocVector
Vector of sequence locations.
Definition: sseqloc.hpp:129
EAlignmentStage stage
Definition: cobalt.hpp:103
Structure to represent a single sequence to be fed to BLAST.
Definition: sseqloc.hpp:47
static string query
#define _ASSERT
else result
Definition: token2.c:20
#define const
Definition: zconf.h:232
Modified on Mon Jul 15 05:34:00 2024 by modify_doxy.py rev. 669887