Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/dbindex__search_8cpp_source.html below:

NCBI C++ ToolKit: src/algo/blast/dbindex/dbindex_search.cpp Source File

( ... ) {

= 0; }

);

hkey_width,

hkey_width,

*

,

pos_( start ), stop_( stop ), nmer_( 0 ), count_( 0 ),

hkey_width_( hkey_width )

std::vector< SSeedRoot >

;

: num_subjects_( num_subjects ), subj_roots_len_bits_( 7 ),

roots_( 0 ), rinfo_( 0 ), total_( 0 )

<

NHITS >

: qoff_( qoff ), soff_( soff ), len_(

), qright_( qright )

: qoff_( qoff ), soff_( soff ), len_(

), qright_( qright ),

<

NHITS >

std::list< TTrackedSeed >

;

TSeeds::iterator

;

<

NHITS >

{ it_ = seeds_.begin(); }

<

NHITS >

(

.len_ > 0 ) {

std::pair< TSeqNum, TSeqPos > mapval =

subject_map_->MapSubjOff( lid_, soff );

( hitlist == 0 ) {

chunk = subject_map_->MapLId2Chunk( lid_, mapval.first );

cerr <<

<< qoff <<

<< mapval.second <<

<<

.len_ <<

<< chunk <<

;

<

NHITS >

{ seeds_.insert( it_,

); }

<

NHITS >

( it_ != seeds_.begin() ) {

tmp_it = it_; tmp_it--;

bs_soff_corr = tmp_it->soff_ + step;

( bs_soff_corr ==

.soff_ ) {

(

.qright_ < tmp_it->qright_ ) {

( tmp_it->len_ > 0 ) {

tmp_it->len_ -= (tmp_it->qright_ -

.qright_ );

( tmp_it->len_ < word_size ) {

seeds_.erase( tmp_it );

tmp_it->qright_ =

.qright_;

}

(

.len_ >= word_size ) {

seeds_.insert( it_,

);

}

(

.len_ >= word_size ) {

seeds_.insert( it_,

);

<

NHITS >

:

( subject_map )

EvalAndUpdate(

TTrackedSeed &

);

( TSeeds::const_iterator cit = this->seeds_.begin();

cit != this->seeds_.end(); ++cit ) {

( this->it_ != this->seeds_.end() ) {

it_soff_corr = this->it_->soff_ + step;

( it_soff_corr >

.soff_ ) {

( this->it_->qright_ <

.qoff_ ) {

SaveSeed( *this->it_ );

this->it_ = this->seeds_.erase( this->it_ );

( it_soff_corr ==

.soff_ ) {

:

( subject_map ),

window_( options.two_hits ),

contig_len_( 2*options.word_size ),

word_size_( options.word_size ),

stride_( subject_map.GetStride() )

EvalAndUpdate( TTrackedSeed &

);

CheckAndSaveSeed(

TTrackedSeed &

);

( (

.second_hit_ > 0 &&

.qright_ <=

.second_hit_ +

.len_ + window_ ) ||

.len_ >= contig_len_ ) {

( TSeeds::const_iterator cit = this->seeds_.begin();

cit != this->seeds_.end(); ++cit ) {

CheckAndSaveSeed( *cit );

( this->it_ != this->seeds_.end() ) {

it_soff_corr = this->it_->soff_ + step;

( it_soff_corr >

.soff_ )

;

( this->it_->qright_ +

.len_ + window_ + 3*stride_

CheckAndSaveSeed( *this->it_ );

this->it_ = this->seeds_.erase( this->it_ );

( this->it_->qright_ <

.qoff_ ) {

( CheckAndSaveSeed( *this->it_ ) ) {

this->it_ = this->seeds_.erase( this->it_ );

( it_soff_corr ==

.soff_ &&

this->it_->len_ > 0 ) {

.second_hit_ = this->it_->qright_;

{ ++this->it_; }

( it_soff_corr ==

.soff_ )

;

<

LEGACY,

NHITS,

derived_t >

<

LEGACY,

NHITS,

derived_t >

: index_impl_( index_impl ), query_(

), locs_( locs ),

options_( options ), subject_( 0 ), subj_end_off_( 0 ),

roots_( index_impl_.NumSubjects() ),

code_bits_(

( index_impl.GetSubjectMap().GetStride() ) ),

min_offset_(

( index_impl.GetSubjectMap().GetStride() ) )

(

TTrackedSeedsSet::size_type

= 0;

<

.size(); ++

) {

<

LEGACY,

NHITS,

derived_t >

hkey_width = index_impl_.hkey_width();

* sstart = index_impl_.GetSeqStoreBase() + subj_start_;

* spos = sstart + (

.soff_ - (hkey_width - 1))/

;

* qstart = query_->sequence;

* qpos = qstart +

.qoff_ - (hkey_width - 1);

incomplete = (

.soff_ - (hkey_width - 1))%

;

nmax = nmax < options_.word_size - hkey_width ?

nmax :

(options_.word_size - hkey_width);

( nmax > 0 && incomplete > 0 && qpos > qstart ) {

sbyte = (((*spos)>>(2*(

- incomplete--)))&0x3);

( *--qpos != sbyte )

;

nmax = (nmax < (

)(qpos - qstart))

? nmax : (

)(qpos - qstart);

nmax = (nmax < (

)(

*(spos - sstart)))

? nmax : (

)(

*(spos - sstart));

( nmax >=

) {

sbyte = *spos--;

(

);

( ;

<

; ++

) {

qbyte = qbyte + ((*--qpos)<<(2*

));

(

)

;

( sbyte != qbyte ){

( nmax > 0 ) {

sbyte = (((*spos)>>(2*(

++)))&0x3);

( sbyte != *--qpos )

;

<

LEGACY,

NHITS,

derived_t >

* sbase = index_impl_.GetSeqStoreBase();

* send = sbase + subj_end_;

* spos = sbase + subj_start_ +

.soff_/

;

* qend = query_->sequence + qstop_;

* qpos = query_->sequence +

.qoff_ + 1;

incomplete =

.soff_%

;

( nmax > 0 && (++incomplete)%

!= 0 && qpos < qend ) {

sbyte = (((*spos)>>(6 - 2*incomplete))&0x3);

( *qpos++ != sbyte )

;

nmax = (nmax < (

)(qend - qpos)) ?

nmax : (

)(qend - qpos);

nmax = (nmax <= (send - spos)*

) ?

( nmax >=

) {

sbyte = *spos++;

(

);

(

= 0;

<

; ++

) {

qbyte = (qbyte<<2) + *qpos++;

(

)

;

( sbyte != qbyte ) {

= 2*(

- 1);

( nmax-- > 0 ) {

sbyte = (((*spos)>>

)&0x3);

( sbyte != *qpos++ )

;

<

LEGACY,

NHITS,

derived_t >

subj_seeds.EvalAndUpdate(

);

( nmaxleft > 0 ) {

ExtendLeft(

, nmaxleft - 1 );

( nmaxright > 0 ) {

ExtendRight(

, nmaxright - 1 );

ExtendRight(

);

( nmaxleft > 0 &&

.len_ < options_.word_size ) {

subj_seeds.AppendSimple(

);

subj_seeds.Append(

, options_.word_size );

<

LEGACY,

NHITS,

derived_t >

( subj_seeds.EvalAndUpdate(

) ) {

ExtendRight(

);

(

.len_ >= options_.word_size )

subj_seeds.AppendSimple(

);

<

LEGACY,

NHITS,

derived_t >

( qoff_ != root->

) {

qoff_ = root->

;

}

( root->

>= min_offset_ &&

root->

< soff_ ) {

( root->

< min_offset_ ) {

boundary = (root++)->soff_;

ProcessBoundaryOffset( root->

-

(min_offset_), boundary );

soff_ = root->

;

ProcessOffset( root->

-

(min_offset_) );

soff_ = root->

;

<

LEGACY,

NHITS,

derived_t >

num_subjects = index_impl_.NumSubjects() - 1;

( subject_ = 0; subject_ < num_subjects; ++subject_ ) {

->SetSubjInfo();

( rinfo.

> 0 ) {

* roots = roots_.GetSubjRoots( subject_ );

(

j = 0; j < rinfo.

; ) {

j += ProcessRoot( seeds, roots + j );

( TRoots::size_type j = 0;

j += ProcessRoot( seeds, roots + j );

<

LEGACY,

NHITS,

derived_t >

index_impl_.hkey_width(), query_->sequence, qstart_, qstop_ );

( nmer_it.

() ) {

index_impl_.OffsetIterator(

nmer_it.

(), options_.word_size ) );

qoff_ = nmer_it.

();

( off_it.More() ) {

( off_it.Next() ) {

(

< min_offset_ ) {

real_offset = off_it.Offset();

soff =

->DecodeOffset( real_offset );

roots_.Add2(

,

, subject_ );

= { qoff_, soff, qstart_, qstop_ };

roots_.Add(

, subject_ );

( roots_.Overflow() ) {

qstart_ = old_qstart;

<

LEGACY,

NHITS,

derived_t >

( curloc != 0 ) {

( curloc->

!= 0 ) {

qstart_ = curloc->

->

;

qstop_ = curloc->

->

+ 1;

curloc = curloc->

;

index_impl_.StopSeq() - index_impl_.StartSeq() ) );

(

TTrackedSeedsSet::size_type

= 0, k = 1;

< seeds_.size(); ++

) {

seeds_[

].Finalize();

(

j = 0; j < nchunks; ++j ) {

(

)(k++), seeds_[

].GetHitList( j ) );

<

LEGACY,

NHITS >

<

LEGACY,

NHITS >

:

< LEGACY, NHITS, CSearch< LEGACY, NHITS > >

:

( index_impl,

, locs, options )

std::pair< TSeqNum, TSeqPos > decoded =

decoded.second;

( search_options.

== 0 )

Ungapped extension structures that are common to nucleotide and protein extension routines.

BlastInitHitList * BLAST_InitHitListNew(void)

Allocate memory for the BlastInitHitList structure.

Boolean BLAST_SaveInitialHit(BlastInitHitList *init_hitlist, Int4 q_off, Int4 s_off, BlastUngappedData *ungapped_data)

Save the initial hit data into the initial hit list structure.

Structures and functions prototypes used for BLAST gapped extension.

Structures and API used for saving BLAST hits.

This class represents a set of seeds obtained by searching all subjects represented by the index.

Implementation of the BLAST database index.

TOffsetData::TIterator TOffsetIterator

const TSubjectMap & GetSubjectMap() const

Get the subject map instance from the index object.

TSeqNum NumSubjects() const

Get the total number of logical sequences in the index.

Base class providing high level interface to index objects.

CConstRef< CSearchResults > Search(const BLAST_SequenceBlk *query, const BlastSeqLoc *locs, const SSearchOptions &search_options)

Search the index.

SIndexHeader header_

The index header structure.

static const unsigned long CR

Letters per byte in the sequence store.

Type used to iterate over the consecutive Nmer values of the query sequence.

bool Next()

Advance the iterator.

TWord nmer_

Nmer value reported by Nmer().

bool state_

false, if the end of the sequence has been reached.

TSeqPos stop_

One past the last position in the query.

TSeqPos pos_

Position returned by Pos().

unsigned long hkey_width_

Hash key width (in base pairs).

TSeqPos count_

Auxiliary member used to determine the next valid position.

TWord hkey_mask_

Hash key mask.

TSeqPos Pos() const

Get the current position in the query sequence.

TWord Nmer() const

Get the Nmer value corresponding to the current state of the iterator object.

const Uint1 * query_

The query data (BLASTNA encoded).

CNmerIterator(unsigned long hkey_width, const Uint1 *query, TSeqPos start, TSeqPos stop)

Object constructor.

unsigned long min_offset_

Minumum offset used by the index.

void ProcessBoundaryOffset(TWord offset, TWord bounds)

Process a seed candidate that is close to the masked out or ambigous region of the subject.

void SearchInt()

Helper method to search a particular segment of the query.

const BlastSeqLoc * locs_

Set of query locations to search.

std::vector< TTrackedSeeds > TTrackedSeedsSet

Representation of the set of currently tracked seeds for all subject sequences.

TWord subj_start_

Start position of subject_.

TWord subj_start_off_

Start offset of subject_.

STrackedSeed< NHITS > TTrackedSeed

Alias for convenience.

const BLAST_SequenceBlk * query_

The query sequence encoded in BLASTNA.

TWord subj_end_

One past the end position of subject_.

CSeedRoots roots_

Collection of initial soff/qoff pairs.

void ProcessOffset(TWord offset)

Process a regular seed candidate.

CConstRef< CDbIndex::CSearchResults > operator()()

Performs the search.

unsigned long ProcessRoot(TTrackedSeeds &seeds, const SSeedRoot *root)

Process a single root.

TTrackedSeedsSet seeds_

The set of currently tracked seeds.

TSeqNum subject_

Logical id of the subject sequence containing the offset value currently being considered.

TSeqPos qoff_

Current query offset.

const TIndex_Impl & index_impl_

The index implementation object.

CTrackedSeeds< NHITS > TTrackedSeeds

void ExtendRight(TTrackedSeed &seed, TSeqPos nmax=~(TSeqPos) 0) const

Extend a seed candidate to the right.

TSearchOptions options_

Search options.

TSeqPos soff_

Current subject offset.

void ComputeSeeds()

Compute the seeds after all roots are collected.

CSearch_Base(const TIndex_Impl &index_impl, const BLAST_SequenceBlk *query, const BlastSeqLoc *locs, const TSearchOptions &options)

Object constructor.

TSeqPos qstart_

Start of the current query segment.

TSeqPos qstop_

One past the end of the current query segment.

CDbIndex_Impl< LEGACY > TIndex_Impl

TIndex_Impl::TSubjectMap TSubjectMap

void ExtendLeft(TTrackedSeed &seed, TSeqPos nmax=~(TSeqPos) 0) const

Extend a seed candidate to the left.

unsigned long code_bits_

Number of bits to represent special offset prefix.

TWord subj_end_off_

End offset of subject_.

CDbIndex::SSearchOptions TSearchOptions

Alias for convenience.

TBase::TIndex_Impl TIndex_Impl

CSearch(const TIndex_Impl &index_impl, const BLAST_SequenceBlk *query, const BlastSeqLoc *locs, const TSearchOptions &options)

Object constructor.

CSearch_Base< LEGACY, NHITS, CSearch > TBase

TSeqPos DecodeOffset(TWord offset)

Decode offset value into subject position.

void SetSubjInfo()

Set the parameters of the current subject sequence.

TBase::TSearchOptions TSearchOptions

Seed roots container for all subjects.

CSeedRoots(TSeqNum num_subjects=0)

Object constructor.

unsigned long total_

Currenr total number of elements.

void Add(const SSeedRoot &root, TSeqNum subject)

Append a normal (non boundary) root to the container.

unsigned long subj_roots_len_bits_

Log_2 of n_subj_roots_.

~CSeedRoots()

Object destructor.

void Allocate()

Reallocate all the storage.

void Reset()

Reinitialize the structure.

static const unsigned long LIMIT_ROOTS

Max number of roots before triggering overflow.

void Add2(const SSeedRoot &root1, const SSeedRoot &root2, TSeqNum subject)

Append a boundary root (both parts) to the container.

bool Overflow() const

Check if the max number of elements is reached.

const SSubjRootsInfo & GetSubjInfo(TSeqNum subject) const

Get the set of roots for a particular subject.

SSubjRootsInfo * rinfo_

Array of root information structures for each subject.

SSubjRootsInfo::TRoots TRoots

Alias type for convenience.

SSeedRoot * roots_

Roots array preallocated for all subjects.

void CleanUp()

Clean up all the dynamically allocated memory.

TSeqNum num_subjects_

Number of subjects in the index.

static const unsigned long TOTAL_CACHE

Assumption on the amound of cache in the system.

const SSeedRoot * GetSubjRoots(TSeqNum subject) const

Return the preallocated array of roots for a particular subject.

unsigned long n_subj_roots_

Space is preallocated for this number of roots per subject.

unsigned long total_roots_

Max number of roots in preallocated storage.

Type representing subject map data.

TSeqNum GetNumChunks(TSeqNum lid) const

Get number of chunks combined into a given logical sequence.

std::pair< TSeqNum, TSeqPos > DecodeOffset(TWord offset) const

Decode offset.

const TWord * GetSubjectMap() const

Provides a mapping from real subject ids and chunk numbers to internal logical subject ids.

void SetSubjInfo(TSeqNum subj, TWord &start, TWord &end) const

Return the subject information based on the given logical subject id.

CTrackedSeeds(const TSubjectMap &subject_map, const CDbIndex::SSearchOptions &options)

Object constructor.

TBase::TSubjectMap TSubjectMap

TBase::TTrackedSeed TTrackedSeed

CTrackedSeeds(const CTrackedSeeds &rhs)

Object copy constructor.

CTrackedSeeds_Base< ONE_HIT > TBase

unsigned long word_size_

Target word size.

CTrackedSeeds_Base< TWO_HIT > TBase

TBase::TTrackedSeed TTrackedSeed

TBase::TSubjectMap TSubjectMap

unsigned long contig_len_

Min continuous length to save unconditionally.

unsigned long window_

Window for two-hit based search.

CTrackedSeeds(const TSubjectMap &subject_map, const CDbIndex::SSearchOptions &options)

Object constructor.

unsigned long stride_

Stride value used by the index.

Representation of a collection of tacked seeds for a specific subject sequence.

TSeeds seeds_

List of seed candidates.

TIter it_

Iterator pointing to the tracked seed that is about to be inspected.

STrackedSeed< NHITS > TTrackedSeed

BlastInitHitList * GetHitList(TSeqNum num) const

Get the list of saved seeds.

const TSubjectMap * subject_map_

The subject map object.

CTrackedSeeds_Base(const TSubjectMap &subject_map)

Object constructor.

void AppendSimple(const TTrackedSeed &seed)

Add a seed to the set of tracked seeds.

TSeqNum lid_

Logical sequence number.

void SetLId(TSeqNum lid)

Set the correspondence between this object and a logical sequence.

CTrackedSeeds_Base(const CTrackedSeeds_Base &rhs)

Object copy constructor.

void Append(const TTrackedSeed &seed, unsigned long word_size)

Add a seed to the set of tracked seeds.

THitLists hitlists_

The result sets (one per chunk).

std::vector< BlastInitHitList * > THitLists

std::list< TTrackedSeed > TSeeds

void SaveSeed(const TTrackedSeed &seed)

Save the tracked seed for reporting in the search result set.

void Reset()

Prepare for processing of the next query position.

CTrackedSeeds functionality that is different depending on whether a one-hit or two-hit based search ...

static const char * bounds[]

const unsigned long TWO_HIT

Use two-hit search.

unsigned long GetMinOffset(unsigned long stride)

Compute the minimum offset value needed encode offsets based on stride.

const unsigned long ONE_HIT

Use one-hit search (normal).

unsigned long GetCodeBits(unsigned long stride)

Compute the number of bits to encode special offsets based on stride.

static const unsigned long CR

CMemoryFile * MapFile(const std::string &fname)

Memory map a file and return a pointer to the mapped area.

CDbIndex::TSeqNum TSeqNum

Forwarding declarations for convenience.

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int32_t Int4

4-byte (32-bit) signed integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

static const sljit_gpr r1

static const sljit_gpr r2

Structure to hold a sequence.

Structure to hold all initial HSPs for a given subject sequence.

Used to hold a set of positions, mostly used for filtering.

SSeqRange * ssr

location data on the sequence.

struct BlastSeqLoc * next

next in linked list

Simple record type used to specify index search parameters.

unsigned long two_hits

Window for two-hit method (see megablast docs).

Representation of a seed root.

TSeqPos qstop_

1 + end of the corresponding query interval.

TSeqPos qstart_

Start of the corresponding query interval.

TSeqPos soff_

Corresponding subject offset.

TSeqPos qoff_

Query offset.

Int4 left

left endpoint of range (zero based)

Int4 right

right endpoint of range (zero based)

SSeedRoot container for one subject.

TRoots * extra_roots_

Storage for extra roots.

void CleanUp()

Clean up extra allocated memory.

unsigned int len_

Current number of stored roots.

std::vector< SSeedRoot > TRoots

Container implementation type.

TSeqPos qoff_

Query offset of the seed's origin.

TSeqPos qright_

Offset of the rightmost position of the seed in the query.

STrackedSeed(TSeqPos qoff, TSeqPos soff, TSeqPos len, TSeqPos qright)

Instance constructor.

TSeqPos len_

Length of the seed.

TSeqPos soff_

Subject offset of the seed's origin.

TSeqPos second_hit_

Right end of the first hit.

TSeqPos qoff_

Query offset of the seed's origin.

TSeqPos soff_

Subject offset of the seed's origin.

TSeqPos qright_

Offset of the rightmost position of the seed in the query.

TSeqPos len_

Length of the seed.

STrackedSeed(TSeqPos qoff, TSeqPos soff, TSeqPos len, TSeqPos qright)

Instance constructor.

Representation of a seed being tracked by the search algorithm.

static Uint4 letter(char c)

static bool ambig(char c)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4