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

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

NCBI C++ ToolKit: src/algo/blast/unit_tests/api/split_query_unit_test.cpp Source File

;

(

= query_info->

; i <= query_info->last_context;

++)

* tot_length =

,

vector<ENa_strand>* strands =

,

retval.reserve(gi_length.size());

BOOST_REQUIRE(strands->size() == gi_length.size());

BOOST_REQUIRE(masks->size() == gi_length.size());

(

= 0;

< gi_length.size();

++) {

loc->

().SetFrom(0);

loc->

().SetTo(gi_length[

].second-1);

retval.push_back(

(loc, &*scope));

*tot_length += gi_length[

].second;

(masks ==

) {

(

= 0;

< masks->size();

++) {

(single_query_masks.size() == 1) {

single_query_masks.front()->GetInterval();

retval[

].mask = m;

kDefaultIntValue = -1;

(m_Config.

()) {

fname(

);

ifstream config_file(fname.c_str());

(m_Config->

()) {

runtime_error(

+

BOOST_REQUIRE(m_Config.

());

BOOST_REQUIRE(seq_blk);

BOOST_REQUIRE(qinfo);

(

= 0; gis[

] != -1;

++) {

queries.push_back(

(loc, scope));

, strand_opt, msgs);

vector< vector<int> >& starting_chunks,

vector< vector<int> >& absolute_contexts,

vector< vector<size_t> >* context_offsets,

vector<ENa_strand>* query_strands =

) {

BOOST_REQUIRE_EQUAL(gi_length.size(), query_strands->size());

BOOST_REQUIRE_EQUAL(num_chunks, nc);

( !query_strands ) {

(

chunk_num = 0; chunk_num < num_chunks; chunk_num++) {

vector<int>& st_chunks = starting_chunks[chunk_num];

(

context_in_chunk = 0;

context_in_chunk < st_chunks.size();

context_in_chunk++) {

os <<

;

os <<

<< chunk_num <<

<< context_in_chunk;

BOOST_REQUIRE_MESSAGE(st_chunks[context_in_chunk]==sc,os.str());

vector<int>& abs_ctxts = absolute_contexts[chunk_num];

(

context_in_chunk = 0;

context_in_chunk < abs_ctxts.size();

context_in_chunk++) {

os <<

;

os <<

<< chunk_num <<

<< context_in_chunk;

BOOST_REQUIRE_MESSAGE(abs_ctxts[context_in_chunk]==abs_ctx,os.str());

( !context_offsets ) {

(

chunk_num = 0; chunk_num < num_chunks; chunk_num++) {

vector<size_t> test_ctx_off =

vector<size_t>& ref_ctx_off = (*context_offsets)[chunk_num];

os <<

<< chunk_num;

BOOST_REQUIRE_MESSAGE(ref_ctx_off.size()==test_ctx_off.size(),os.str());

(

= 0;

< ref_ctx_off.size();

++) {

correction = ref_ctx_off[

];

os <<

<< chunk_num

<<

<<

<<

<< test_ctx_off[

]

<<

<< correction;

BOOST_REQUIRE_MESSAGE(correction==test_ctx_off[

],os.str());

absolute_context =

num_bases2compare =

os <<

<< chunk_num

<<

<<

;

x_CmpSequenceData(&global_seq->

[global_offset],

&chunk_seq->

[chunk_offset],

BOOST_REQUIRE_MESSAGE(rv,os.str());

(

= 0;

<

;

++) {

(global[

] != chunk[

]) {

x_ReadQueryBoundsPerChunk(

, sqb, split_query_vector);

x_ValidateQuerySeqLocsPerChunk(splitter, split_query_vector);

vector< vector<size_t> > queries_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, queries_per_chunk);

x_ValidateQueriesPerChunkAssignment(*sqb, queries_per_chunk);

vector< vector<int> > ctxs_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, ctxs_per_chunk);

x_ValidateQueryContextsPerChunkAssignment(*sqb, ctxs_per_chunk);

vector< vector<size_t> > ctx_offsets_per_chunk;

x_ReadVectorOfVectorsForTest(

,

,

ctx_offsets_per_chunk);

x_ValidateContextOffsetsPerChunkAssignment(*sqb, ctx_offsets_per_chunk);

vector<BlastQueryInfo*> split_query_info;

x_ValidateLocalQueryData(splitter, &*opts, split_query_info);

query_strands =

)

gi_length.push_back(make_pair<int, size_t>(112258880, 362959));

gi_length.push_back(make_pair<int, size_t>(112253843, 221853));

gi_length.push_back(make_pair<int, size_t>(112193060, 194837));

gi_length.push_back(make_pair<int, size_t>(112193059, 204796));

BOOST_REQUIRE_EQUAL(gi_length.size(), query_strands->size());

( !query_strands ) {

x_ReadQueryBoundsPerChunk(

, sqb, split_query_vector);

x_ValidateQuerySeqLocsPerChunk(splitter, split_query_vector);

vector< vector<size_t> > queries_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, queries_per_chunk);

x_ValidateQueriesPerChunkAssignment(*sqb, queries_per_chunk);

vector< vector<int> > ctxs_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, ctxs_per_chunk);

x_ValidateQueryContextsPerChunkAssignment(*sqb, ctxs_per_chunk);

vector< vector<size_t> > ctx_offsets_per_chunk;

x_ReadVectorOfVectorsForTest(

,

,

ctx_offsets_per_chunk);

x_ValidateContextOffsetsPerChunkAssignment(*sqb, ctx_offsets_per_chunk);

vector<BlastQueryInfo*> split_query_info;

x_ValidateLocalQueryData(splitter, &*opts, split_query_info);

kLength = 122347;

CreateSSeqLoc(*

, range, strand));

vector< vector<size_t> > queries_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, queries_per_chunk);

x_ValidateQueriesPerChunkAssignment(*sqb, queries_per_chunk);

vector< vector<int> > ctxs_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, ctxs_per_chunk);

x_ValidateQueryContextsPerChunkAssignment(*sqb, ctxs_per_chunk);

vector< vector<size_t> > ctx_offsets_per_chunk;

x_ReadVectorOfVectorsForTest(

,

,

ctx_offsets_per_chunk);

x_ValidateContextOffsetsPerChunkAssignment(*sqb, ctx_offsets_per_chunk);

vector<BlastQueryInfo*> split_query_info;

x_ValidateLocalQueryData(splitter, &*opts, split_query_info);

query_strands =

)

gi_length.push_back(make_pair<int, size_t>(112817621, 5567));

gi_length.push_back(make_pair<int, size_t>(112585373, 5987));

gi_length.push_back(make_pair<int, size_t>(112585216, 5531));

gi_length.push_back(make_pair<int, size_t>(112585119, 5046));

BOOST_REQUIRE_EQUAL(gi_length.size(), query_strands->size());

( !query_strands ) {

vector< vector<size_t> > queries_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, queries_per_chunk);

x_ValidateQueriesPerChunkAssignment(*sqb, queries_per_chunk);

vector< vector<int> > ctxs_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, ctxs_per_chunk);

x_ValidateQueryContextsPerChunkAssignment(*sqb, ctxs_per_chunk);

vector< vector<size_t> > ctx_offsets_per_chunk;

x_ReadVectorOfVectorsForTest(

,

,

ctx_offsets_per_chunk);

x_ValidateContextOffsetsPerChunkAssignment(*sqb, ctx_offsets_per_chunk);

vector<BlastQueryInfo*> split_query_info;

x_ValidateLocalQueryData(splitter, &*opts, split_query_info);

concatenated_query_length,

BOOST_REQUIRE(chunk_range.

());

(chunk_range.

() > concatenated_query_length) {

chunk_range.

(concatenated_query_length);

split_query_vector.clear();

(kNumChunks == kDefaultIntValue) {

runtime_error(

+

);

(

= 0;

< kNumChunks;

++) {

vector<size_t> kQueryIndices = sqb->GetQueryIndices(

);

BOOST_REQUIRE( !kQueryIndices.empty() );

(vector<size_t>, itr, kQueryIndices) {

<<

<< *itr;

os.str() +

.str());

vector<size_t> query_data;

x_ParseConfigLine(

, query_data);

BOOST_REQUIRE_MESSAGE((

)3==query_data.size(),os.str() +

.str());

sl->

().SetFrom(query_data[0]);

sl->

().SetTo(query_data[1]);

split_query_vector[

]->AddQuery(bsq);

(split_query_vector.empty()) {

os <<

;

BOOST_REQUIRE_MESSAGE(split_query_vector.size()==(

)splitter->

,os.str());

os <<

<<

;

BOOST_REQUIRE_MESSAGE(ref_qvector->

()==test_qvector->

(),os.str());

(

j = 0; j < ref_qvector->

(); j++) {

os <<

<< j <<

<<

<<

<< test_query_range.

() <<

<< ref_query_range.

();

BOOST_REQUIRE_MESSAGE(ref_query_range.

()==test_query_range.

(),os.str());

os <<

<< j <<

<<

<<

<< test_query_range.

() <<

<< ref_query_range.

();

BOOST_REQUIRE_MESSAGE(ref_query_range.

()==test_query_range.

(),os.str());

os <<

<< j <<

<<

<<

vector<BlastQueryInfo*>& retval)

ostringstream os, errors;

(kNumChunks == kDefaultIntValue) {

runtime_error(

+

);

retval.reserve(kNumChunks);

(

= 0;

< kNumChunks;

++) {

os <<

<<

<<

;

(os.str());

errors.str(

);

errors <<

<<

;

(kNumQueries == kDefaultIntValue) {

(

);

errors <<

<<

<< kNumQueries <<

;

BOOST_REQUIRE_MESSAGE(retval[

],errors.str());

errors.str(

);

BOOST_REQUIRE_MESSAGE(retval[

]->first_context >= 0,errors.str());

BOOST_REQUIRE_MESSAGE(retval[

]->last_context >= 0,errors.str());

BOOST_REQUIRE_MESSAGE(retval[

]->first_context <= retval[

]->last_context,errors.str());

(

c = retval[

]->first_context;

c <= retval[

]->last_context;

errors <<

<<

<<

<< c;

retval[

]->contexts[c].query_offset =

, kDefaultIntValue);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].query_offset >= 0,

errors.str() +

);

retval[

]->contexts[c].query_length =

, kDefaultIntValue);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].query_length >= 0,

errors.str() +

);

retval[

]->contexts[c].eff_searchsp =

, kDefaultIntValue);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].eff_searchsp >= 0,

errors.str() +

);

retval[

]->contexts[c].length_adjustment =

, kDefaultIntValue);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].length_adjustment >= 0,

errors.str() +

);

retval[

]->contexts[c].query_index =

, kDefaultIntValue);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].query_index >= 0,

errors.str() +

);

retval[

]->contexts[c].frame =

, kDefaultIntValue);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].frame == 1

|| retval[

]->contexts[c].frame == 2

|| retval[

]->contexts[c].frame == 3

|| retval[

]->contexts[c].frame == -1

|| retval[

]->contexts[c].frame == -2

|| retval[

]->contexts[c].frame == -3

|| retval[

]->contexts[c].frame == 0,

errors.str() +

);

retval[

]->contexts[c].is_valid =

,

);

BOOST_REQUIRE_MESSAGE(retval[

]->contexts[c].

,

errors.str() +

);

* data_to_read,

vector< vector<T> >& retval)

(kNumChunks == kDefaultIntValue) {

runtime_error(

+

);

retval.resize(kNumChunks);

(

= 0;

< kNumChunks;

++) {

os <<

<<

<< data_to_read;

x_ParseConfigLine(

, retval[

]);

vector<string> tokens;

retval.reserve(tokens.size());

(vector<string>, token, tokens) {

(

= 0;

< kNumChunks;

++) {

x_ComputeQueryChunkBounds(expected_chunk_range,

,

kQuerySize, kQueryChunkOverlapSize);

BOOST_REQUIRE_EQUAL(expected_chunk_range.

(),

BOOST_REQUIRE_EQUAL(expected_chunk_range.

(),

BOOST_REQUIRE_EQUAL(expected_chunk_range.

(), chunk_start);

BOOST_REQUIRE_EQUAL(expected_chunk_range.

(), chunk_end);

chunk_length = chunk_end - chunk_start;

BOOST_REQUIRE_EQUAL(chunk_length,

vector< vector<size_t> >&

BOOST_REQUIRE_EQUAL(kNumChunks, queries_per_chunk.size());

(

= 0;

< kNumChunks;

++) {

os <<

<<

<<

;

BOOST_REQUIRE_MESSAGE(queries_per_chunk[

].

()==data2test.size(),os.str());

(

j = 0; j < data2test.size(); j++) {

os <<

<<

<<

<< j;

BOOST_REQUIRE_MESSAGE(queries_per_chunk[

][j]==data2test[j],os.str());

vector< vector<int> >&

BOOST_REQUIRE_EQUAL(kNumChunks, contexts_per_chunk.size());

(

= 0;

< kNumChunks;

++) {

os <<

<<

<<

;

BOOST_REQUIRE_MESSAGE(contexts_per_chunk[

].

()==data2test.size(),os.str());

(

j = 0; j < data2test.size(); j++) {

os <<

<<

<<

<< j;

BOOST_REQUIRE_MESSAGE(contexts_per_chunk[

][j]==data2test[j],os.str());

vector< vector<size_t> >&

contexts_offsets_per_chunk)

BOOST_REQUIRE_EQUAL(kNumChunks, contexts_offsets_per_chunk.size());

(

= 0;

< kNumChunks;

++) {

os <<

<<

<<

;

BOOST_REQUIRE_MESSAGE(contexts_offsets_per_chunk[

].

()==data2test.size(),os.str());

(

j = 0; j < data2test.size(); j++) {

os <<

<<

<<

<< j <<

<< data2test[j]

<<

<< contexts_offsets_per_chunk[

][j];

BOOST_REQUIRE_MESSAGE(contexts_offsets_per_chunk[

][j]==data2test[j],os.str());

os <<

<< chunk_num <<

;

BOOST_REQUIRE_MESSAGE(reference->

==

->first_context,os.str());

os <<

<< chunk_num <<

;

BOOST_REQUIRE_MESSAGE(reference->

==

->last_context,os.str());

os <<

<< chunk_num <<

;

BOOST_REQUIRE_MESSAGE(reference->

==

->num_queries,os.str());

os <<

<< chunk_num <<

;

BOOST_REQUIRE_MESSAGE(reference->

==

->max_length,os.str());

os <<

<< chunk_num <<

;

BOOST_REQUIRE_MESSAGE(reference->

==

->pattern_info,os.str());

ctx <= reference->last_context;

os <<

<< chunk_num <<

<<

;

os.str() +

);

os.str() +

);

os.str() +

);

os.str() +

);

os.str() +

);

os.str() +

);

vector<BlastQueryInfo*>

split_query_info_structs)

BOOST_REQUIRE(options);

BOOST_REQUIRE_EQUAL(kNumChunks, split_query_info_structs.size());

(

= 0;

< kNumChunks;

++) {

os <<

<<

<<

;

BOOST_REQUIRE_MESSAGE(qf.

(),os.str() +

);

BOOST_REQUIRE_MESSAGE(qd.

(),os.str() +

);

os <<

;

vector<Int4> query_indices_expected;

query_indices_expected.push_back(45);

query_indices_expected.push_back(0);

query_indices_expected.push_back(7);

(vector<Int4>, qi, query_indices_expected) {

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE_EQUAL((

)0, rv);

(

= 0; query_indices[

] !=

;

++) {

BOOST_REQUIRE_EQUAL(query_indices_expected[

],

(

)query_indices[

]);

(query_indices);

num_query_contexts = 0;

&num_query_contexts);

BOOST_REQUIRE_EQUAL((

)0, rv);

(

= 0;

< num_query_contexts;

++) {

BOOST_REQUIRE_EQUAL(query_indices_expected[

], query_contexts[

]);

(query_contexts);

num_queries(0);

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE_EQUAL(query_indices_expected.size(), num_queries);

map.resize(kNumChunks);

query_index = 0;

(

chunk_num = 0; chunk_num < kNumChunks; chunk_num++) {

kQueriesPerChunk(random.

(1, 365));

(

= 0;

< kQueriesPerChunk;

++) {

map[chunk_num].push_back(query_index++);

(

chunk_num = 0; chunk_num < map.size(); chunk_num++) {

(vector<Uint4>, qi, map[chunk_num]) {

BOOST_REQUIRE_EQUAL((

)0, rv);

(

chunk_num = 0; chunk_num < kNumChunks; chunk_num++) {

vector<Uint4> query_indices_expected = map[chunk_num];

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE(query_indices !=

);

(

= 0;

< query_indices_expected.size();

++) {

BOOST_REQUIRE_EQUAL(query_indices_expected[

],

query_indices[

]);

(query_indices);

num_queries(0);

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE_EQUAL(query_indices_expected.size(), num_queries);

kNumChunks = 3;

map.resize(kNumChunks);

map[0].push_back(0);

map[0].push_back(1);

map[1].push_back(2);

map[2].push_back(3);

(

chunk_num = 0; chunk_num < map.size(); chunk_num++) {

(vector<Uint4>, qi, map[chunk_num]) {

BOOST_REQUIRE_EQUAL((

)0, rv);

(

chunk_num = 0; chunk_num < kNumChunks; chunk_num++) {

vector<Uint4> query_indices_expected = map[chunk_num];

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE(query_indices !=

);

(

= 0;

< query_indices_expected.size();

++) {

BOOST_REQUIRE_EQUAL(query_indices_expected[

],

query_indices[

]);

(query_indices);

num_queries(0);

BOOST_REQUIRE_EQUAL((

)0, rv);

BOOST_REQUIRE_EQUAL(query_indices_expected.size(), num_queries);

(

);

(

);

(

);

(

);

(

);

(

);

(

);

vector<ENa_strand> query_strands;

query_strands.reserve(4);

QuerySplitter_BlastnMultiQueryMultiChunk(

,

(

);

(

);

(

);

(

);

(

);

(

);

(

);

vector<ENa_strand> query_strands;

query_strands.reserve(4);

(

);

kLength = 33423;

BOOST_REQUIRE_EQUAL(m_Config->GetInt(

,

,

x_ReadQueryBoundsPerChunk(

, sqb, split_query_vector);

x_ValidateQuerySeqLocsPerChunk(splitter, split_query_vector);

kNumChunks = (size_t)m_Config->GetInt(

,

BOOST_REQUIRE_EQUAL(kNumChunks, sqb->

());

vector< vector<size_t> > queries_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, queries_per_chunk);

x_ValidateQueriesPerChunkAssignment(*sqb, queries_per_chunk);

vector< vector<int> > ctxs_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, ctxs_per_chunk);

x_ValidateQueryContextsPerChunkAssignment(*sqb, ctxs_per_chunk);

vector< vector<size_t> > ctx_offsets_per_chunk;

x_ReadVectorOfVectorsForTest(

,

,

ctx_offsets_per_chunk);

x_ValidateContextOffsetsPerChunkAssignment(*sqb, ctx_offsets_per_chunk);

vector<BlastQueryInfo*> split_query_info;

x_ValidateLocalQueryData(splitter, &*opts, split_query_info);

(

);

gi_length.push_back(make_pair<int, size_t>(33624848, 6883));

gi_length.push_back(make_pair<int, size_t>(4758794, 6669));

gi_length.push_back(make_pair<int, size_t>(66821305, 6061));

gi_length.push_back(make_pair<int, size_t>(109075552, 5007));

BOOST_REQUIRE_EQUAL(m_Config->GetInt(

,

,

x_ReadQueryBoundsPerChunk(

, sqb, split_query_vector);

x_ValidateQuerySeqLocsPerChunk(splitter, split_query_vector);

kNumChunks = (size_t)m_Config->GetInt(

,

BOOST_REQUIRE_EQUAL(kNumChunks, sqb->

());

vector< vector<size_t> > queries_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, queries_per_chunk);

x_ValidateQueriesPerChunkAssignment(*sqb, queries_per_chunk);

vector< vector<int> > ctxs_per_chunk;

x_ReadVectorOfVectorsForTest(

,

, ctxs_per_chunk);

x_ValidateQueryContextsPerChunkAssignment(*sqb, ctxs_per_chunk);

vector< vector<size_t> > ctx_offsets_per_chunk;

x_ReadVectorOfVectorsForTest(

,

,

ctx_offsets_per_chunk);

x_ValidateContextOffsetsPerChunkAssignment(*sqb, ctx_offsets_per_chunk);

vector<BlastQueryInfo*> split_query_info;

x_ValidateLocalQueryData(splitter, &*opts, split_query_info);

(

);

gi_length.push_back(make_pair<int, size_t>(107784911, 1000));

gi_length.push_back(make_pair<int, size_t>(115354032, 250));

gi_length.push_back(make_pair<int, size_t>(115381005, 2551));

num_chunks = 9;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(107784911, 1000));

gi_length.push_back(make_pair<int, size_t>(115354032, 250));

gi_length.push_back(make_pair<int, size_t>(115381005, 2551));

num_chunks = 9;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(107784911, 1000));

gi_length.push_back(make_pair<int, size_t>(115354032, 250));

gi_length.push_back(make_pair<int, size_t>(115381005, 2551));

num_chunks = 9;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(116001669, 33));

num_chunks = 3;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(116001673, 34));

num_chunks = 3;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(116001668, 35));

kNumChunks = m_Config->GetInt(

,

,

vector< vector<int> > starting_chunks(kNumChunks);

vector< vector<int> > absolute_contexts(kNumChunks);

vector< vector<size_t> > context_offset_corrections(kNumChunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(107784911, 1000));

gi_length.push_back(make_pair<int, size_t>(115354032, 250));

gi_length.push_back(make_pair<int, size_t>(115381005, 2551));

num_chunks = 10;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(107784911, 1000));

gi_length.push_back(make_pair<int, size_t>(115354032, 250));

gi_length.push_back(make_pair<int, size_t>(115381005, 2551));

num_chunks = 10;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

gi_length.push_back(make_pair<int, size_t>(107784911, 1000));

gi_length.push_back(make_pair<int, size_t>(115354032, 250));

gi_length.push_back(make_pair<int, size_t>(115381005, 2551));

num_chunks = 10;

vector< vector<int> > starting_chunks(num_chunks);

vector< vector<int> > absolute_contexts(num_chunks);

vector< vector<size_t> > context_offset_corrections(num_chunks);

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

x_ReadVectorOfVectorsForTest(

,

,

context_offset_corrections);

starting_chunks, absolute_contexts,

&context_offset_corrections,

(

);

kNumChunks = m_Config->GetInt(

,

,

BOOST_REQUIRE_EQUAL(

, splitter->

());

BOOST_REQUIRE_EQUAL(m_Config->GetInt(

,

,

BOOST_REQUIRE_EQUAL(

, splitter->

());

BOOST_REQUIRE_EQUAL(kNumChunks, sqb->

());

BOOST_REQUIRE(

);

}

(

runtime_error&) {

BOOST_REQUIRE(

);

BOOST_REQUIRE_EQUAL(qf, chunk_query_factory);

gi_length.push_back(make_pair<int, size_t>(95116755, 35000));

gi_length.push_back(make_pair<int, size_t>(112123020, 35580));

kNumChunks(2);

BOOST_REQUIRE(

);

}

(

out_of_range& ) {

BOOST_REQUIRE(

);

BOOST_REQUIRE(chunk_0 != qf);

BOOST_REQUIRE(chunk_1 != qf);

BOOST_REQUIRE(chunk_0.

());

BOOST_REQUIRE(chunk_1.

());

BOOST_REQUIRE_EQUAL(1055, retval);

BOOST_REQUIRE_EQUAL(1, retval);

BOOST_REQUIRE_EQUAL(3, retval);

BOOST_REQUIRE_EQUAL(2, retval);

Auxiliary functions for BLAST.

#define sfree(x)

Safe free a pointer: belongs to a higher level header.

Definitions which are dependant on the NCBI C++ Object Manager.

Declares the CBlastOptionsHandle and CBlastOptionsFactory classes.

EBlastProgramType

Defines the engine's notion of the different applications of the BLAST algorithm.

BlastQueryInfo * BlastQueryInfoFree(BlastQueryInfo *query_info)

Deallocate memory for query information structure.

BlastQueryInfo * BlastQueryInfoNew(EBlastProgramType program, int num_queries)

Allocate memory for query information structure.

EProgram

This enumeration is to evolve into a task/program specific list that specifies sets of default parame...

@ eTblastx

Translated nucl-Translated nucl.

@ eBlastn

Nucl-Nucl (traditional blastn)

@ eBlastp

Protein-Protein.

@ eBlastx

Translated nucl-Protein.

BOOST_AUTO_TEST_SUITE_END() static int s_GetSegmentFlags(const CBioseq &bioseq)

ncbi::TMaskedQueryRegions mask

CAutoEnvironmentVariable –.

Defines BLAST error codes (user errors included)

Encapsulates ALL the BLAST algorithm's options.

size_type Size() const

Returns the number of queries found in this query vector.

CConstRef< objects::CSeq_loc > GetQuerySeqLoc(size_type i) const

Get the query Seq-loc for a query by index.

Auxiliary class to provide convenient and efficient access to conversions between contexts local to q...

NCBI C++ Object Manager dependant implementation of IQueryFactory.

Class responsible for splitting query sequences and providing data to the BLAST search class to searc...

static CRef< CScope > NewScope(bool with_defaults=true)

Return a new scope, possibly (by default) with default loaders, which will include the Genbank loader...

Wrapper class around SSplitQueryBlk structure.

CRef< CNcbiRegistry > m_Config

This represents the split_query.ini configuration file.

void QuerySplitter_BlastxSingleQueryMultiChunk(const string &kTestName, ENa_strand strand)

void x_ValidateQueryContextsPerChunkAssignment(const CSplitQueryBlk &sqb, const vector< vector< int > > &contexts_per_chunk)

Validates the query contexts assigned to all the chunks.

void x_ValidateLocalQueryData(CRef< CQuerySplitter > splitter, const CBlastOptions *options, vector< BlastQueryInfo * > split_query_info_structs)

Validate the local query data for all chunks, comparing data produced by the CQuerySplitter object an...

void x_ReadVectorOfVectorsForTest(const string &kTestName, const char *data_to_read, vector< vector< T > > &retval)

This method reads entries in the config file of the format ChunkNX, here N is the chunk number and X ...

~CSplitQueryTestFixture()

void x_ValidateChunkBounds(size_t kChunkSize, size_t kQuerySize, const CSplitQueryBlk &sqb, EBlastProgramType p)

Auxiliary method to validate the chunk bounds calculated by the CSplitQueryBlk object and the x_Compu...

void x_ReadQueryBoundsPerChunk(const string &kTestName, CConstRef< CSplitQueryBlk > sqb, CQuerySplitter::TSplitQueryVector &split_query_vector)

This function reads values in the split_query.ini file with the format ChunkNQueryM (where N is the c...

void x_ValidateQueryInfoForChunk(const BlastQueryInfo *reference, const BlastQueryInfo *test, size_t chunk_num)

Validate the query info structure generated (test) against the expected one (reference) (N....

void x_TestCContextTranslator(TGiLengthVector &gi_length, size_t chunk_size, size_t num_chunks, blast::EProgram program, vector< vector< int > > &starting_chunks, vector< vector< int > > &absolute_contexts, vector< vector< size_t > > *context_offsets, ENa_strand strand, vector< ENa_strand > *query_strands=NULL)

void x_ValidateQueriesPerChunkAssignment(const CSplitQueryBlk &sqb, const vector< vector< size_t > > &queries_per_chunk)

Validates the query sequences (by index) assigned to all the chunks This compares the data calculated...

void QuerySplitter_BlastnSingleQueryMultiChunk(const string &kTestName, ENa_strand strand)

void x_ParseConfigLine(const string &input, vector< T > &retval)

Tokenizes a string containing comma-separated values into a vector of values.

void x_PrepareBlastQueryStructures(TIntId gis[], EProgram program, BLAST_SequenceBlk **seq_blk, BlastQueryInfo **qinfo, ENa_strand *strand=NULL)

Populate a BLAST_SequenceBlk and BlastQueryInfo structures out of an array of GIs.

void QuerySplitter_BlastxMultiQueryMultiChunk(const string &kTestName, ENa_strand strand, vector< ENa_strand > *query_strands=NULL)

bool x_CmpSequenceData(const Uint1 *global, const Uint1 *chunk, size_t len)

Auxiliary function that compares bytes of sequence data to validate the context offset corrections.

void x_ComputeQueryChunkBounds(TChunkRange &chunk_range, size_t chunk_size, size_t concatenated_query_length, size_t overlap)

Incrementally compute the query chunk bounds.

void x_ReadSplitQueryInfoForTest(const string &kTestName, EBlastProgramType program, vector< BlastQueryInfo * > &retval)

Reads data to populate multiple BlastQueryInfo structures.

void x_ValidateQuerySeqLocsPerChunk(CRef< CQuerySplitter > splitter, const CQuerySplitter::TSplitQueryVector &split_query_vector)

Compare the query data (start, stop, strand) for each chunk computed by the splitter vs.

void x_ValidateContextOffsetsPerChunkAssignment(const CSplitQueryBlk &sqb, const vector< vector< size_t > > &contexts_offsets_per_chunk)

Validates the context offsets assigned to all the chunks.

void QuerySplitter_BlastnMultiQueryMultiChunk(const string &kTestName, ENa_strand strand, vector< ENa_strand > *query_strands=NULL)

static CTestObjMgr & Instance()

Collection of masked regions for a single query sequence.

typedef for the messages for an entire BLAST search, which could be comprised of multiple query seque...

static const int chunk_size

static bool is_valid(const char *num, int type, CONV_RESULT *cr)

std::ofstream out("events_result.xml")

main entry point for tests

#define test(a, b, c, d, e)

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

size_t SplitQuery_GetOverlapChunkSize(EBlastProgramType program)

Size of the region that overlaps in between each query chunk.

void SetStrandOption(objects::ENa_strand s)

size_t GetChunkSize() const

Returns the number of bases/residues that make up a query chunk.

TChunkRange GetChunkBounds(size_t chunk_num) const

Get the boundaries of a chunk in the concatenated query.

SSplitQueryBlk * GetCStruct() const

Returns the C structure managed by objects of this class.

vector< CRef< CBlastQueryVector > > TSplitQueryVector

Definition of a vector of CBlastQueryVectors, each element corresponds to a query chunk.

bool IsQuerySplit() const

Determines whether the query sequence(s) are split or not.

size_t GetNumQueriesForChunk(size_t chunk_num) const

Get the number of queries in a given chunk.

size_t GetNumChunks() const

Retrieve the number of chunks.

int GetAbsoluteContext(size_t chunk_num, Int4 context_in_chunk) const

Get the context number in the absolute (i.e.

void SetupQueries(TSeqLocVector &queries, BlastQueryInfo *qinfo, BLAST_SequenceBlk **seqblk, EBlastProgramType prog, objects::ENa_strand strand_opt, TSearchMessages &messages)

Populates BLAST_SequenceBlk with sequence data for use in CORE BLAST.

objects::ENa_strand GetStrandOption() const

virtual BLAST_SequenceBlk * GetSequenceBlk()=0

Accessor for the BLAST_SequenceBlk structure.

CRef< ILocalQueryData > MakeLocalQueryData(const CBlastOptions *opts)

Creates and caches an ILocalQueryData.

static CBlastOptionsHandle * Create(EProgram program, EAPILocality locality=CBlastOptions::eLocal)

Creates an options handle object configured with default options for the requested program,...

CBlastOptions & SetOptions()

Returns a reference to the internal options class which this object is a handle for.

Uint4 m_NumChunks

Number of chunks, if this is 1, no splitting occurs.

EBlastProgramType EProgramToEBlastProgramType(EProgram p)

Convert EProgram to EBlastProgramType.

size_t SplitQuery_GetChunkSize(EProgram program)

Returns the optimal chunk size for a given task.

EBlastProgramType GetProgramType() const

Returns the CORE BLAST notion of program type.

virtual BlastQueryInfo * GetQueryInfo()=0

Accessor for the BlastQueryInfo structure.

const CBlastOptions & GetOptions() const

Return the object which this object is a handle for.

CRef< IQueryFactory > GetQueryFactoryForChunk(Uint4 chunk_num)

Returns a IQueryFactory suitable to be executed by a BLAST search class.

virtual size_t GetNumQueries()=0

Get the number of queries.

void SetupQueryInfo(TSeqLocVector &queries, EBlastProgramType prog, objects::ENa_strand strand_opt, BlastQueryInfo **qinfo)

Allocates the query information structure and fills the context offsets, in case of multiple queries,...

vector< size_t > GetQueryIndices(size_t chunk_num) const

Get the indices of the queries contained in a given chunk.

CRef< CSplitQueryBlk > Split()

Split the query sequence(s)

int GetStartingChunk(size_t curr_chunk, Int4 context_in_chunk) const

Get the chunk number where context_in_chunk starts (i.e.

vector< int > GetQueryContexts(size_t chunk_num) const

Get the contexts of the queries contained in a given chunk.

Uint4 SplitQuery_CalculateNumChunks(EBlastProgramType program, size_t *chunk_size, size_t concatenated_query_length, size_t num_queries)

Calculate the number of chunks that a query will be split into based upon query length,...

size_t GetSumOfSequenceLengths()

Compute the sum of all the sequence's lengths.

Uint4 GetNumberOfChunks() const

Returns the number of chunks the query/queries will be split into.

CRef< CSplitQueryBlk > m_SplitBlk

Split query block structure.

vector< size_t > GetContextOffsets(size_t chunk_num) const

Get the context offsets (corrections) of the queries contained in a given chunk.

TSplitQueryVector m_SplitQueriesInChunk

Vector of split queries.

#define GI_FROM(T, value)

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void SetPacked_int(TPacked_int &v)

ENa_strand GetStrand(void) const

Get the location's strand.

void SetId(CSeq_id &id)

set the 'id' field in all parts of this location

TRange GetTotalRange(void) const

void SetStrand(ENa_strand strand)

Set the strand for all of the location's ranges.

void AddDefaults(TPriority pri=kPriority_Default)

Add default data loaders from object manager.

void Reset(void)

Reset reference object.

bool NotEmpty(void) const THROWS_NONE

Check if CRef is not empty – pointing to an object and has a non-null value.

bool Empty(void) const THROWS_NONE

Check if CRef is empty – not pointing to any object, which means having a null value.

uint8_t Uint1

1-byte (8-bit) unsigned integer

int16_t Int2

2-byte (16-bit) signed integer

int32_t Int4

4-byte (32-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

Uint4 TValue

Type of the generated integer value and/or the seed value.

TValue GetRand(void)

Get the next random number in the interval [0..GetMax()] (inclusive)

position_type GetLength(void) const

TThisType & SetFrom(position_type from)

bool NotEmpty(void) const

TThisType & SetToOpen(position_type toOpen)

position_type GetToOpen(void) const

position_type GetFrom(void) const

static TThisType GetEmpty(void)

TThisType & SetLength(position_type length)

int TFlags

Binary OR of "EFlags".

virtual bool GetBool(const string &section, const string &name, bool default_value, TFlags flags=0, EErrAction err_action=eThrow) const

Get boolean value of specified parameter name.

virtual const string & Get(const string &section, const string &name, TFlags flags=0) const

Get the parameter value.

virtual int GetInt(const string &section, const string &name, int default_value, TFlags flags=0, EErrAction err_action=eThrow) const

Get integer value of specified parameter name.

bool Empty(TFlags flags=fAllLayers) const

Verify if Registry is empty.

@ fTruncate

Leading, trailing blanks can be truncated.

@ fNoOverride

Cannot change existing value.

@ fTransient

Transient – not saved by default.

@ fNotJustCore

Include auxiliary subregistries.

static string SizetToString(size_t value, TNumToStringFlags flags=0, int base=10)

Convert size_t to string.

static int StringToInt(const CTempString str, TStringToNumFlags flags=0, int base=10)

Convert string to int.

static list< string > & Split(const CTempString str, const CTempString delim, list< string > &arr, TSplitFlags flags=0, vector< SIZE_TYPE > *token_pos=NULL)

Split a string using specified delimiters.

static string TruncateSpaces(const string &str, ETrunc where=eTrunc_Both)

Truncate whitespace in a string.

@ fConvErr_NoThrow

Do not throw an exception on error.

TTo GetTo(void) const

Get the To member data.

TFrom GetFrom(void) const

Get the From member data.

ENa_strand

strand of nucleic acid

bool IsPacked_int(void) const

Check if variant Packed_int is selected.

bool IsInt(void) const

Check if variant Int is selected.

@ eNa_strand_both

in forward orientation

@ e_Gi

GenInfo Integrated Database.

unsigned int

A callback function used to compare two keys in a database.

Main class to perform a BLAST search on the local machine.

const struct ncbi::grid::netcache::search::fields::SIZE size

Magic spell ;-) needed for some weird compilers... very empiric.

const GenericPointer< typename T::ValueType > T2 value

#define UINT4_MAX

largest number represented by unsigned int.

NOTE: This file contains work in progress and the APIs are likely to change, please do not rely on th...

vector< TMaskedQueryRegions > TSeqLocInfoVector

Collection of masked regions for all queries in a BLAST search.

static SLJIT_INLINE sljit_ins msg(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

Int2 SplitQueryBlk_GetQueryIndicesForChunk(const SSplitQueryBlk *squery_blk, Uint4 chunk_num, Uint4 **query_indices)

Retrieve an array of query indices for the requested chunk.

Int2 SplitQueryBlk_GetQueryContextsForChunk(const SSplitQueryBlk *squery_blk, Uint4 chunk_num, Int4 **query_contexts, Uint4 *num_query_contexts)

Retrieve an array of query contexts for the requested chunk.

Int2 SplitQueryBlk_AddQueryToChunk(SSplitQueryBlk *squery_blk, Uint4 query_index, Uint4 chunk_num)

Add a query index to a given chunk.

Int2 SplitQueryBlk_GetNumQueriesForChunk(const SSplitQueryBlk *squery_blk, Uint4 chunk_num, size_t *num_queries)

Retrieve the number of queries that correspond to chunk number chunk_num.

Int2 SplitQueryBlk_AddContextToChunk(SSplitQueryBlk *squery_blk, Int4 ctx_index, Uint4 chunk_num)

Add a query context index to a given chunk.

const Int4 kInvalidContext

Value to represent an invalid context.

const Int2 kBadParameter

Invalid parameter used in a function call.

Declares CQuerySplitter, a class to split the query sequence(s)

Auxiliary functions and classes to assist in query splitting.

static void s_ConvertToBlastQueries(const TGiLengthVector &gi_length, TSeqLocVector &retval, size_t *tot_length=NULL, vector< ENa_strand > *strands=NULL, const TSeqLocInfoVector *masks=NULL)

Convert a vector of GIs with its lengths into a TSeqLocVector.

static void s_CalculateMaxLength(BlastQueryInfo *query_info)

Calculate and assign the maximum length field in the BlastQueryInfo structure.

vector< TGiLenPair > TGiLengthVector

Vector containing pairs of gis and their length.

pair< TIntId, size_t > TGiLenPair

Pair for gis and their length (in that order)

BOOST_AUTO_TEST_CASE(SplitQueriesIn1Chunk)

vector< vector< Uint4 > > TSplitQueryChunkMap

vector< SSeqLoc > TSeqLocVector

Vector of sequence locations.

Structure to hold a sequence.

Uint1 * sequence

Sequence used for search (could be translation).

Int4 query_length

Length of this query, strand or frame.

Boolean is_valid

Determine if this context is valid or not.

Int4 query_offset

Offset of this query, strand or frame in the concatenated super-query.

Int8 eff_searchsp

Effective search space for this context.

Int4 query_index

Index of query (same for all frames)

Int1 frame

Frame number (-1, -2, -3, 0, 1, 2, or 3)

The query related information.

Int4 first_context

Index of the first element of the context array.

BlastContextInfo * contexts

Information per context.

int num_queries

Number of query sequences.

struct SPHIQueryInfo * pattern_info

Counts of PHI BLAST pattern occurrences, used in PHI BLAST only.

Int4 last_context

Index of the last element of the context array.

Uint4 max_length

Length of the longest among the concatenated queries.

Structure to represent a single sequence to be fed to BLAST.

Utility stuff for more convenient using of Boost.Test library.

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