CPP_DOC/doxyhtml/blastengine__unit__test_8cpp_source.html

 /*  $Id: blastengine_unit_test.cpp 95563 2021-11-26 14:51:36Z grichenk $

 * ===========================================================================

 *

 *                            PUBLIC DOMAIN NOTICE

 *               National Center for Biotechnology Information

 *

 *  This software/database is a "United States Government Work" under the

 *  terms of the United States Copyright Act.  It was written as part of

 *  the author's official duties as a United States Government employee and

 *  thus cannot be copyrighted.  This software/database is freely available

 *  to the public for use. The National Library of Medicine and the U.S.

 *  Government have not placed any restriction on its use or reproduction.

 *

 *  Although all reasonable efforts have been taken to ensure the accuracy

 *  and reliability of the software and data, the NLM and the U.S.

 *  Government do not and cannot warrant the performance or results that

 *  may be obtained by using this software or data. The NLM and the U.S.

 *  Government disclaim all warranties, express or implied, including

 *  warranties of performance, merchantability or fitness for any particular

 *  purpose.

 *

 *  Please cite the author in any work or product based on this material.

 *

 * ===========================================================================

 *

 * Author:  Tom Madden

 *

 * File Description:

 *   Unit test module to test the code in blast_engine.cpp

 *

 * ===========================================================================

 */

 #include <ncbi_pch.hpp>

 #include <corelib/test_boost.hpp>


 #include <corelib/ncbitime.hpp>

 #include <objmgr/object_manager.hpp>

 #include <objmgr/scope.hpp>

 #include <objtools/data_loaders/genbank/gbloader.hpp>

 #include <objmgr/util/sequence.hpp>


 #include <objects/seqloc/Seq_loc.hpp>

 #include <objects/seqloc/Seq_interval.hpp>

 #include <objects/seqalign/Seq_align.hpp>

 #include <objects/seqalign/Seq_align_set.hpp>

 #include <objects/seqalign/Std_seg.hpp>

 #include <objects/seqalign/Dense_seg.hpp>

 #include <objects/seqalign/Score.hpp>

 #include <serial/serial.hpp>

 #include <serial/iterator.hpp>

 #include <serial/objostr.hpp>


 #include <algo/blast/api/blast_nucl_options.hpp>

 #include <algo/blast/api/disc_nucl_options.hpp>

 #include <algo/blast/api/seqsrc_multiseq.hpp>

 #include <algo/blast/api/seqsrc_seqdb.hpp>

 #include <algo/blast/api/local_blast.hpp>

 #include <algo/blast/api/objmgr_query_data.hpp>

 #include <algo/blast/api/prelim_stage.hpp>

 #include <blast_objmgr_priv.hpp>


 #include <algo/blast/core/blast_options.h>

 #include <algo/blast/core/blast_engine.h>

 #include <algo/blast/core/blast_gapalign.h>

 #include <algo/blast/core/blast_traceback.h>

 #include <algo/blast/core/blast_encoding.h>

 #include <algo/blast/core/blast_setup.h>

 #include <algo/blast/core/blast_hspstream.h>


 #include <algo/blast/api/blast_nucl_options.hpp>


 #include <algo/blast/api/repeats_filter.hpp>


 #include "test_objmgr.hpp"

 #include "blast_test_util.hpp"


 using namespace std;

 using namespace ncbi;

 using namespace ncbi::objects;

 using namespace ncbi::blast;


 struct BlastEngineTestFixture {


     TSeqLocVector m_vQuery;

     TSeqLocVector m_vSubject;


     ~BlastEngineTestFixture() {

         m_vQuery.clear();

         m_vSubject.clear();

     }


     void setupQueryAndSubject(TGi query_gi, TGi subject_gi)

     {

         CRef<CSeq_loc> query_loc(new CSeq_loc());

         query_loc->SetWhole().SetGi(query_gi);

         CScope* query_scope = new CScope(CTestObjMgr::Instance().GetObjMgr());

         query_scope->AddDefaults();

         m_vQuery.push_back(SSeqLoc(query_loc, query_scope));


         CRef<CSeq_loc> subject_loc(new CSeq_loc());

         subject_loc->SetWhole().SetGi(subject_gi);

         CScope* subject_scope = new CScope(CTestObjMgr::Instance().GetObjMgr());

         subject_scope->AddDefaults();

         m_vSubject.push_back(SSeqLoc(subject_loc, subject_scope));

     }

 };


 BOOST_FIXTURE_TEST_SUITE(blastengine, BlastEngineTestFixture)


 void testLongMatchDiagnostics(BlastDiagnostics* diagnostics)

 {

     BlastUngappedStats* ungapped_stats =

         diagnostics->ungapped_stat;

     BlastGappedStats* gapped_stats =

         diagnostics->gapped_stat;


     BOOST_REQUIRE_EQUAL(22670293, (int)ungapped_stats->lookup_hits);

     BOOST_REQUIRE_EQUAL(296326, ungapped_stats->init_extends);

     BOOST_REQUIRE_EQUAL(1258, ungapped_stats->good_init_extends);

     BOOST_REQUIRE_EQUAL(1254, gapped_stats->extensions);

     BOOST_REQUIRE_EQUAL(23, gapped_stats->good_extensions);

 }


 void testShortMatchDiagnostics(BlastDiagnostics* diagnostics)

 {

     BlastUngappedStats* ungapped_stats =

         diagnostics->ungapped_stat;

     BlastGappedStats* gapped_stats =

         diagnostics->gapped_stat;


     BOOST_REQUIRE_EQUAL(1152, (int)ungapped_stats->lookup_hits);

     BOOST_REQUIRE_EQUAL(24, ungapped_stats->init_extends);

     BOOST_REQUIRE_EQUAL(9, ungapped_stats->good_init_extends);

     BOOST_REQUIRE_EQUAL(8, gapped_stats->extensions);

     BOOST_REQUIRE_EQUAL(8, gapped_stats->good_extensions);

 }


 // This test has a very long (26 mb) subject sequence that is broken into

 // chunks in BLAST_SearchEngineCore that are no longer than 5 meg.  This

 // test was written to verify a fix for long sequences. Only preliminary

 // stage of the BLAST search is performed. Also tests that all diagnostic

 // hit counts are set correctly.

 // CBlastPrelimSearch class is used with a BlastSeqSrc constructed from a

 // single sequence. This can be done, because CBlastPrelimSearch requires

 // a database-based BlastSeqSrc only for the Seq-align creation.

 BOOST_AUTO_TEST_CASE(testTBLASTNLongMatchBlastEngine) {

     const Int4 kNumHspsEnd=23;

     const Int8 kEffectiveSearchSpace = 1050668186940LL;

     const TGi kQueryGi = GI_CONST(9790067);

     const TGi kSubjectGi = GI_CONST(30698605);

     const EBlastProgramType kProgramType = eBlastTypeTblastn;

     const EProgram kProgram = eTblastn;


     CRef<CBlastOptionsHandle> opts_handle(

         CBlastOptionsFactory::Create(kProgram));


     setupQueryAndSubject(kQueryGi, kSubjectGi);


     opts_handle->SetEffectiveSearchSpace(kEffectiveSearchSpace);

     opts_handle->SetFilterString("F");

     CRef<CBlastOptions> options(&opts_handle->SetOptions());


     BlastSeqSrc* seq_src = MultiSeqBlastSeqSrcInit(m_vSubject, kProgramType);

     CRef<IQueryFactory> query_factory(new CObjMgr_QueryFactory(m_vQuery));

     CBlastPrelimSearch prelim_search(query_factory, options, seq_src);

     CRef<SInternalData> id(prelim_search.Run());


     testLongMatchDiagnostics(id->m_Diagnostics->GetPointer());


     const int kQueryOffsetFinal[kNumHspsEnd] =

         { 407, 486, 421, 569, 265, 320, 266, 321, 727, 659,

           92, 1, 1, 727, 422, 216, 167, 825, 167, 831, 216, 369, 49 };

     const int kQueryLengthFinal[kNumHspsEnd] =

         { 164, 85, 62, 67, 58, 74, 56, 69, 56, 66, 147, 69,

           73, 61, 40, 26, 35, 54, 35, 48, 21, 69, 22 };

     const int kScoreFinal[kNumHspsEnd] =

         { 368, 199, 160, 104, 99, 95, 94, 92, 94, 89, 108,

           101, 97, 95, 89, 86, 84, 84, 83, 79, 75, 74, 74};

     const double kEvalueFinal[kNumHspsEnd] =

         {1.84467e-35, 4.47098e-34, 4.47098e-34, 4.47098e-34,

          4.23245e-08, 4.23245e-08, 3.29958e-07, 3.29958e-07,

          7.11395e-07, 7.11395e-07, 8.64076e-05, 0.000570668,

          0.001678, 0.00287725, 0.0145032, 0.0325588,

          0.0558201, 0.0558201, 0.0730883, 0.214807, 0.631249,

          0.826482, 0.826482 };


     CBlastHSPResults results

         (prelim_search.ComputeBlastHSPResults

          (id->m_HspStream->GetPointer()));


     BOOST_REQUIRE_EQUAL(1, results->num_queries);

     BOOST_REQUIRE_EQUAL(1, results->hitlist_array[0]->hsplist_count);

     BlastHSPList* hsplist = results->hitlist_array[0]->hsplist_array[0];


     BOOST_REQUIRE_EQUAL(kNumHspsEnd, hsplist->hspcnt);


     // Check that HSPs are sorted by score; then sort HSPs by e-value,

     // to assure the proper order for the following assertions

     BOOST_REQUIRE(Blast_HSPListIsSortedByScore(hsplist));

     Blast_HSPListSortByEvalue(hsplist);


     for (int index=0; index<kNumHspsEnd; index++) {

         BlastHSP* tmp_hsp = hsplist->hsp_array[index];

         BOOST_REQUIRE_EQUAL(kQueryOffsetFinal[index], tmp_hsp->query.offset);

         BOOST_REQUIRE_EQUAL(kQueryLengthFinal[index],

                              tmp_hsp->query.end - tmp_hsp->query.offset);

         BOOST_REQUIRE_EQUAL(kScoreFinal[index], tmp_hsp->score);

         BOOST_REQUIRE(fabs((kEvalueFinal[index]-tmp_hsp->evalue) /

                             kEvalueFinal[index]) < 0.001);

     }


     BlastSeqSrcFree(seq_src);

 }


 // Tests a tblastn search with a short subject sequence. Only preliminary

 // stage of the BLAST search is performed. Checks obtained HSPs and the

 // diagnostic hit counts.

 BOOST_AUTO_TEST_CASE(testTBLASTNShortMatchBlastEngine) {

     const Int4 kNumHspsEnd=8;

     const Int8 kEffectiveSearchSpace = 1050668186940LL;

     const TGi kQueryGi = GI_CONST(9790067);

     const TGi kSubjectGi = GI_CONST(38547463);

     const EBlastProgramType kProgramType = eBlastTypeTblastn;

     const EProgram kProgram = eTblastn;


     setupQueryAndSubject(kQueryGi, kSubjectGi);


     CRef<CBlastOptionsHandle> opts_handle(

         CBlastOptionsFactory::Create(kProgram));


     opts_handle->SetEffectiveSearchSpace(kEffectiveSearchSpace);

     opts_handle->SetFilterString("F");

     CRef<CBlastOptions> options(&opts_handle->SetOptions());


     BlastSeqSrc* seq_src = MultiSeqBlastSeqSrcInit(m_vSubject, kProgramType);

     CRef<IQueryFactory> query_factory(new CObjMgr_QueryFactory(m_vQuery));

     CBlastPrelimSearch prelim_search(query_factory, options, seq_src);

     CRef<SInternalData> id(prelim_search.Run());


     testShortMatchDiagnostics(id->m_Diagnostics->GetPointer());


    const int kQueryOffsetFinal[kNumHspsEnd] = { 98, 425, 320, 340, 823, 675, 247, 103};

    const int kQueryLengthFinal[kNumHspsEnd] = { 223,211,  35,  13,  46,  19,  25,  24};

    const int kScoreFinal[kNumHspsEnd] = {1138, 173, 72, 46, 40, 36, 32, 30};

    const double kEvalueFinal[kNumHspsEnd] =

        {2.52769e-153, 4.98722e-18, 2.4525e-05, 0.0352845, 0.187202, 0.568557, 1.72476, 3.0028};


    CBlastHSPResults results

        (prelim_search.ComputeBlastHSPResults

         (id->m_HspStream->GetPointer()));


    BOOST_REQUIRE_EQUAL(1, results->num_queries);

    BOOST_REQUIRE_EQUAL(1, results->hitlist_array[0]->hsplist_count);

    BlastHSPList* hsplist = results->hitlist_array[0]->hsplist_array[0];


    BOOST_REQUIRE_EQUAL(kNumHspsEnd, hsplist->hspcnt);


    // Check that HSPs are sorted by score; then sort HSPs by e-value,

    // to assure the proper order for the following assertions

    BOOST_REQUIRE(Blast_HSPListIsSortedByScore(hsplist));

    Blast_HSPListSortByEvalue(hsplist);


    for (int index=0; index<kNumHspsEnd; index++)

    {

         BlastHSP* tmp_hsp = hsplist->hsp_array[index];

         BOOST_REQUIRE_EQUAL(kQueryOffsetFinal[index],

                              tmp_hsp->query.offset);

         BOOST_REQUIRE_EQUAL(kQueryLengthFinal[index],

                              tmp_hsp->query.end - tmp_hsp->query.offset);

         BOOST_REQUIRE_EQUAL(kScoreFinal[index], tmp_hsp->score);

         BOOST_REQUIRE(fabs(kEvalueFinal[index]-tmp_hsp->evalue) < 1.0e-10 ||

                       fabs((kEvalueFinal[index]-tmp_hsp->evalue) /

                             kEvalueFinal[index]) < 0.01);

    }

    BlastSeqSrcFree(seq_src);

 }


 // Human against human sequence comparison which includes some repeats

 // and hence has a large number of hits, even with an increased word size.

 BOOST_AUTO_TEST_CASE(testBlastnWithLargeWordSize)

 {

     const TGi kQueryGi = GI_CONST(186279); // Short human sequence with repeats

     const TGi kSubjectGi = GI_CONST(29791382); // Contig from human chromosome 1

     const int kNumHsps = 330;

     const EBlastProgramType kProgramType = eBlastTypeBlastn;


     setupQueryAndSubject(kQueryGi, kSubjectGi);


     BlastSeqSrc* seq_src = MultiSeqBlastSeqSrcInit(m_vSubject, kProgramType);


     CBlastNucleotideOptionsHandle opts_handle;

     opts_handle.SetWordSize(35);

     CRef<CBlastOptions> options(&opts_handle.SetOptions());


     CRef<IQueryFactory> query_factory(new CObjMgr_QueryFactory(m_vQuery));

     CBlastPrelimSearch prelim_search(query_factory, options, seq_src);

     CRef<SInternalData> id(prelim_search.Run());


     CBlastHSPResults results

         (prelim_search.ComputeBlastHSPResults

          (id->m_HspStream->GetPointer()));


     // Check results

     BOOST_REQUIRE_EQUAL(1, results->num_queries);

     BOOST_REQUIRE_EQUAL(1, results->hitlist_array[0]->hsplist_count);

     BlastHSPList* hsplist = results->hitlist_array[0]->hsplist_array[0];


     BOOST_REQUIRE_EQUAL(kNumHsps, hsplist->hspcnt);

     BlastSeqSrcFree(seq_src);

 }


 // Same comparison as in previous test, but with repeats filtering;

 // only 1 HSP is left.

 BOOST_AUTO_TEST_CASE(testBlastnWithRepeatsFiltering)

 {

     const TGi kQueryGi = GI_CONST(186279); // Short human sequence with repeats

     const TGi kSubjectGi = GI_CONST(29791382); // Contig from human chromosome 1

     const int kNumHsps = 3;

     const int kMaskedLength = 389;

     const EBlastProgramType kProgramType = eBlastTypeBlastn;


     setupQueryAndSubject(kQueryGi, kSubjectGi);


     CBlastNucleotideOptionsHandle nucl_handle;

     nucl_handle.SetTraditionalBlastnDefaults();

     nucl_handle.SetEvalueThreshold(1);

     nucl_handle.SetRepeatFiltering(true);


     Blast_FindRepeatFilterLoc(m_vQuery, &nucl_handle);

     CRef<CBlastOptions> options(&nucl_handle.SetOptions());


     Uint4 masked_length = m_vQuery[0].mask->GetPacked_int().GetLength();

     BOOST_REQUIRE_EQUAL(kMaskedLength, (int) masked_length);


     BlastSeqSrc* seq_src = MultiSeqBlastSeqSrcInit(m_vSubject, kProgramType);

     CRef<IQueryFactory> query_factory(new CObjMgr_QueryFactory(m_vQuery));

     CBlastPrelimSearch prelim_search(query_factory, options, seq_src);

     CRef<SInternalData> id(prelim_search.Run());


     CBlastHSPResults results

         (prelim_search.ComputeBlastHSPResults

          (id->m_HspStream->GetPointer()));


     // Check results

     BOOST_REQUIRE_EQUAL(1, results->num_queries);

     BOOST_REQUIRE_EQUAL(1, results->hitlist_array[0]->hsplist_count);

     BlastHSPList* hsplist = results->hitlist_array[0]->hsplist_array[0];


     BOOST_REQUIRE_EQUAL(kNumHsps, hsplist->hspcnt);

     BlastSeqSrcFree(seq_src);

 }


 BOOST_AUTO_TEST_CASE(testDiscMegaBlastPartialRun)

 {

     const TGi kQueryGi = GI_CONST(14702146);

     const string kDbName("data/seqn");

     const size_t kNumHits = 2;

     const TGi kGis[kNumHits] = { GI_CONST(46071158), GI_CONST(46072400) };

     const int kScores[kNumHits] = { 1024, 944 };

     const int kNumIdent[kNumHits] = { 458, 423 };


     CRef<CSeq_loc> query_loc(new CSeq_loc());

     query_loc->SetWhole().SetGi(kQueryGi);

     CScope* query_scope = new CScope(CTestObjMgr::Instance().GetObjMgr());

     query_scope->AddDefaults();

     m_vQuery.push_back(SSeqLoc(query_loc, query_scope));

     CSearchDatabase dbinfo(kDbName, CSearchDatabase::eBlastDbIsNucleotide);


     CDiscNucleotideOptionsHandle opts_handle;


     opts_handle.SetWindowSize(40);

     opts_handle.SetMatchReward(4);

     opts_handle.SetMismatchPenalty(-5);

     opts_handle.SetGapOpeningCost(5);

     opts_handle.SetGapExtensionCost(5);

     opts_handle.SetPercentIdentity(70);

     opts_handle.SetMaskAtHash(false);


     CRef<CBlastOptionsHandle> options(&opts_handle);

     CRef<IQueryFactory> query_factory(new CObjMgr_QueryFactory(m_vQuery));

     CLocalBlast blaster(query_factory, options, dbinfo);

     CSearchResultSet results = *blaster.Run();


     // Check results

     BOOST_REQUIRE_EQUAL((int)1, (int)results.GetNumResults());

     CConstRef<CSeq_align_set> alignment = results[0].GetSeqAlign();

     BOOST_REQUIRE_EQUAL(kNumHits, alignment->Get().size());


     CRef<CSeq_align> first_hit = alignment->Get().front();

     CRef<CSeq_align> second_hit = alignment->Get().back();


     int score;

     BOOST_REQUIRE(first_hit->GetNamedScore("score", score));

     BOOST_REQUIRE_EQUAL(kScores[0], score);

     BOOST_REQUIRE(second_hit->GetNamedScore("score", score));

     BOOST_REQUIRE_EQUAL(kScores[1], score);


     int num_ident;

     BOOST_REQUIRE(first_hit->GetNamedScore("num_ident", num_ident));

     BOOST_REQUIRE_EQUAL(kNumIdent[0], num_ident);

     BOOST_REQUIRE(second_hit->GetNamedScore("num_ident", num_ident));

     BOOST_REQUIRE_EQUAL(kNumIdent[1], num_ident);


     if ( !CSeq_id::PreferAccessionOverGi() ) {

         BOOST_REQUIRE_EQUAL(CSeq_id::e_Gi, first_hit->GetSeq_id(1).Which());

         BOOST_REQUIRE_EQUAL(kGis[0], first_hit->GetSeq_id(1).GetGi());

         BOOST_REQUIRE_EQUAL(CSeq_id::e_Gi, second_hit->GetSeq_id(1).Which());

         BOOST_REQUIRE_EQUAL(kGis[1], second_hit->GetSeq_id(1).GetGi());

     }

     else {

         BOOST_REQUIRE_EQUAL(CSeq_id::e_Ddbj, first_hit->GetSeq_id(1).Which());

         BOOST_REQUIRE_EQUAL("BP722565", first_hit->GetSeq_id(1).GetDdbj().GetAccession());

         BOOST_REQUIRE_EQUAL(1, first_hit->GetSeq_id(1).GetDdbj().GetVersion());

         BOOST_REQUIRE_EQUAL(CSeq_id::e_Ddbj, second_hit->GetSeq_id(1).Which());

         BOOST_REQUIRE_EQUAL("BP723807", second_hit->GetSeq_id(1).GetDdbj().GetAccession());

         BOOST_REQUIRE_EQUAL(1, second_hit->GetSeq_id(1).GetDdbj().GetVersion());

     }

 }


 BOOST_AUTO_TEST_CASE(testBlastpPrelimSearch)

 {

     const string kDbName("data/seqp");

     const TGi kQueryGi1 = GI_CONST(21282798);

     const TGi kQueryGi2 = GI_CONST(129295);

     const int kNumHits = 31;

     const int kNumHitsToCheck = 3;

     const int kIndices[kNumHitsToCheck] = { 1, 4, 8 };

     const int kScores[kNumHitsToCheck] = { 519, 56, 54 };

     const int kOids[kNumHitsToCheck] = { 74, 971, 45 };

     const int kQueryLengths[kNumHitsToCheck] = { 297, 46, 63 };

     const int kSubjectLengths[kNumHitsToCheck] = { 298, 48, 55 };

     const EProgram kProgram = eBlastp;


     CRef<CSeq_loc> query_loc1(new CSeq_loc());

     query_loc1->SetWhole().SetGi(kQueryGi1);

     CScope* query_scope1 = new CScope(CTestObjMgr::Instance().GetObjMgr());

     query_scope1->AddDefaults();

     m_vQuery.push_back(SSeqLoc(query_loc1, query_scope1));

     CRef<CSeq_loc> query_loc2(new CSeq_loc());

     query_loc2->SetWhole().SetGi(kQueryGi2);

     CScope* query_scope2 = new CScope(CTestObjMgr::Instance().GetObjMgr());

     query_scope2->AddDefaults();

     m_vQuery.push_back(SSeqLoc(query_loc2, query_scope2));

     BlastSeqSrc* seq_src = SeqDbBlastSeqSrcInit(kDbName, true, 0, 0);


     CRef<CBlastOptionsHandle> opts_handle(

         CBlastOptionsFactory::Create(kProgram));

     CRef<CBlastOptions> options(&opts_handle->SetOptions());

     options->SetFilterString("L");  /* NCBI_FAKE_WARNING */


     CRef<IQueryFactory> query_factory(new CObjMgr_QueryFactory(m_vQuery));

     CBlastPrelimSearch prelim_search(query_factory, options, seq_src);

     CRef<SInternalData> id(prelim_search.Run());


     BlastSeqSrcFree(seq_src);


     CBlastHSPResults results

         (prelim_search.ComputeBlastHSPResults

          (id->m_HspStream->GetPointer()));

     BOOST_REQUIRE_EQUAL(2, results->num_queries);

     BOOST_REQUIRE_EQUAL(kNumHits, results->hitlist_array[0]->hsplist_count);


     BOOST_REQUIRE_CLOSE(results->hitlist_array[0]->hsplist_array[0]->best_evalue,

          results->hitlist_array[0]->hsplist_array[0]->hsp_array[0]->evalue,

          results->hitlist_array[0]->hsplist_array[0]->hsp_array[0]->evalue/2);


     for (int index = 0; index < kNumHitsToCheck;

          ++index) {

         const int kHitIndex = kIndices[index];

         BlastHSPList* hsp_list =

             results->hitlist_array[0]->hsplist_array[kHitIndex];

         BOOST_REQUIRE_EQUAL(kOids[index], hsp_list->oid);

         BlastHSP* hsp = hsp_list->hsp_array[0];

 // cerr << hsp_list->oid << " " << hsp->score << " " << hsp->num_ident << " " << hsp->query.offset << " " << hsp->query.end << " " << hsp->subject.offset << " " << hsp->subject.end << "\n";

         BOOST_REQUIRE_EQUAL(kScores[index], hsp->score);

         BOOST_REQUIRE_EQUAL(0, hsp->num_ident);

         BOOST_REQUIRE_EQUAL(kQueryLengths[index],

                              hsp->query.end - hsp->query.offset);

         BOOST_REQUIRE_EQUAL(kSubjectLengths[index],

                              hsp->subject.end - hsp->subject.offset);

     }

 }


 BOOST_AUTO_TEST_CASE(testGappedOffsets)

 {

     const unsigned char query[] = {'\016', '\007', '\014', '\024', '\004', '\015', '\011',

                     '\022', '\012', '\016', '\001', '\010', '\007', '\005', '\014', '\023',

                     '\021', '\003', '\016', '\005', '\013', '\006', '\020', '\011', '\006',

                     '\015', '\016', '\004', '\017'};


     const unsigned char subject[] = {'\000', '\000', '\000',

                     '\004', '\015', '\011', '\022', '\012', '\016', '\001', '\010', '\007',

                     '\005', '\014', '\023', '\021', '\003', '\016', '\005', '\013', '\006',

                     '\020', '\011', '\006', '\015', '\016', '\004', '\017'};


      Boolean retval = FALSE;

      BlastScoreBlk *sbp = BlastScoreBlkNew(BLASTAA_SEQ_CODE, 1);

          // generate score options

      BlastScoringOptions *score_options;

      BlastScoringOptionsNew(eBlastTypeBlastp, &score_options);

      BLAST_FillScoringOptions(score_options,

                              eBlastTypeBlastp,

                              FALSE,

                              0,

                              0,

                              NULL,

                              BLAST_GAP_OPEN_PROT,

                              BLAST_GAP_EXTN_PROT);

      Blast_ScoreBlkMatrixInit(eBlastTypeBlastp, score_options, sbp, NULL);

      BlastScoringOptionsFree(score_options);


      Int4 q_offset, s_offset;


      // This one has a mismatch at the beginning of the HSPs.

      BlastHSP* hsp = Blast_HSPNew();

      hsp->query.offset = 0;

      hsp->query.end = 27;

      hsp->subject.offset = 0;

      hsp->subject.end = 26;

      hsp->score = 45;


      retval = BlastGetOffsetsForGappedAlignment(query, subject, sbp, hsp, &q_offset, &s_offset);


      BOOST_REQUIRE_EQUAL(q_offset, 22);

      BOOST_REQUIRE_EQUAL(s_offset, 21);

      BOOST_REQUIRE_EQUAL(retval, true);


      // This one should be OK

      hsp->query.offset = 4;

      hsp->query.end = 27;

      hsp->subject.offset = 3;

      hsp->subject.end = 26;

      hsp->score = 45;


      retval = BlastGetOffsetsForGappedAlignment(query, subject, sbp, hsp, &q_offset, &s_offset);


      BOOST_REQUIRE_EQUAL(q_offset, 18);

      BOOST_REQUIRE_EQUAL(s_offset, 17);

      BOOST_REQUIRE_EQUAL(retval, true);


      // This should have no solution.

      hsp->query.offset = 5;

      hsp->query.end = 20;

      hsp->subject.offset = 11;

      hsp->subject.end = 26;

      hsp->score = 45;


      retval = BlastGetOffsetsForGappedAlignment(query, subject, sbp, hsp, &q_offset, &s_offset);

      BOOST_REQUIRE_EQUAL(retval, false);

 }


 BOOST_AUTO_TEST_SUITE_END()


Dense_seg.hpp

Score.hpp
User-defined methods of the data storage class.

Seq_align.hpp

Seq_align_set.hpp

Seq_interval.hpp

Seq_loc.hpp

Std_seg.hpp

kEffectiveSearchSpace
static const Int8 kEffectiveSearchSpace
Definition: alignment_scorer.cpp:76

blast_encoding.h
Declarations of static arrays used to define some NCBI encodings to be used in a toolkit independent ...

blast_engine.h
Function calls to actually perform a BLAST search (high level).

blast_gapalign.h
Structures and functions prototypes used for BLAST gapped extension.

BlastGetOffsetsForGappedAlignment
Boolean BlastGetOffsetsForGappedAlignment(const Uint1 *query, const Uint1 *subject, const BlastScoreBlk *sbp, BlastHSP *hsp, Int4 *q_retval, Int4 *s_retval)
Function to look for the highest scoring window (of size HSP_MAX_WINDOW) in an HSP and return the mid...
Definition: blast_gapalign.c:3248

Blast_HSPListSortByEvalue
void Blast_HSPListSortByEvalue(BlastHSPList *hsp_list)
Sort the HSPs in an HSP list by e-value, with scores and other criteria used to resolve ties.
Definition: blast_hits.c:1437

Blast_HSPNew
BlastHSP * Blast_HSPNew(void)
Allocate and zeros out memory for an HSP structure.
Definition: blast_hits.c:141

Blast_HSPListIsSortedByScore
Boolean Blast_HSPListIsSortedByScore(const BlastHSPList *hsp_list)
Check if HSP list is sorted by score.
Definition: blast_hits.c:1358

blast_hspstream.h
Declaration of ADT to save and retrieve lists of HSPs in the BLAST engine.

blast_nucl_options.hpp
Declares the CBlastNucleotideOptionsHandle class.

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

blast_options.h
The structures and functions in blast_options.

BLAST_GAP_OPEN_PROT
#define BLAST_GAP_OPEN_PROT
Protein gap costs are the defaults for the BLOSUM62 scoring matrix.
Definition: blast_options.h:84

BLAST_FillScoringOptions
Int2 BLAST_FillScoringOptions(BlastScoringOptions *options, EBlastProgramType program, Boolean greedy_extension, Int4 penalty, Int4 reward, const char *matrix, Int4 gap_open, Int4 gap_extend)
Fill non-default values in the BlastScoringOptions structure.
Definition: blast_options.c:823

BLAST_GAP_EXTN_PROT
#define BLAST_GAP_EXTN_PROT
cost to extend a gap.
Definition: blast_options.h:92

BlastScoringOptionsNew
Int2 BlastScoringOptionsNew(EBlastProgramType program, BlastScoringOptions **options)
Allocate memory for BlastScoringOptions and fill with default values.
Definition: blast_options.c:788

BlastScoringOptionsFree
BlastScoringOptions * BlastScoringOptionsFree(BlastScoringOptions *options)
Deallocate memory for BlastScoringOptions.
Definition: blast_options.c:774

EBlastProgramType
EBlastProgramType
Defines the engine's notion of the different applications of the BLAST algorithm.
Definition: blast_program.h:72

eBlastTypeBlastn
@ eBlastTypeBlastn
Definition: blast_program.h:74

eBlastTypeTblastn
@ eBlastTypeTblastn
Definition: blast_program.h:77

eBlastTypeBlastp
@ eBlastTypeBlastp
Definition: blast_program.h:73

BlastSeqSrcFree
BlastSeqSrc * BlastSeqSrcFree(BlastSeqSrc *seq_src)
Frees the BlastSeqSrc structure by invoking the destructor function set by the user-defined construct...
Definition: blast_seqsrc.c:112

blast_setup.h
Utilities initialize/setup BLAST.

Blast_ScoreBlkMatrixInit
Int2 Blast_ScoreBlkMatrixInit(EBlastProgramType program_number, const BlastScoringOptions *scoring_options, BlastScoreBlk *sbp, GET_MATRIX_PATH get_path)
Initializes the substitution matrix in the BlastScoreBlk according to the scoring options specified.
Definition: blast_setup.c:330

BlastScoreBlkNew
BlastScoreBlk * BlastScoreBlkNew(Uint1 alphabet, Int4 number_of_contexts)
Allocates and initializes BlastScoreBlk.
Definition: blast_stat.c:884

blast_traceback.h
Functions to do gapped alignment with traceback.

EProgram
EProgram
This enumeration is to evolve into a task/program specific list that specifies sets of default parame...
Definition: blast_types.hpp:56

eBlastp
@ eBlastp
Protein-Protein.
Definition: blast_types.hpp:59

eTblastn
@ eTblastn
Protein-Translated nucl.
Definition: blast_types.hpp:61

testLongMatchDiagnostics
void testLongMatchDiagnostics(BlastDiagnostics *diagnostics)
Definition: blastengine_unit_test.cpp:110

testShortMatchDiagnostics
void testShortMatchDiagnostics(BlastDiagnostics *diagnostics)
Definition: blastengine_unit_test.cpp:124

BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testTBLASTNLongMatchBlastEngine)
Definition: blastengine_unit_test.cpp:148

BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END() static int s_GetSegmentFlags(const CBioseq &bioseq)
Definition: blastinput_unit_test.cpp:2852

CBlastHSPResults
Wrapper class for BlastHSPResults .
Definition: blast_aux.hpp:343

CBlastNucleotideOptionsHandle
Handle to the nucleotide-nucleotide options to the BLAST algorithm.
Definition: blast_nucl_options.hpp:60

CBlastPrelimSearch
Search class to perform the preliminary stage of the BLAST search.
Definition: prelim_stage.hpp:55

CConstRef< CSeq_align_set >

CDiscNucleotideOptionsHandle
Handle to the nucleotide-nucleotide options to the discontiguous BLAST algorithm.
Definition: disc_nucl_options.hpp:56

CLocalBlast
Class to perform a BLAST search on local BLAST databases Note that PHI-BLAST can be run using this cl...
Definition: local_blast.hpp:62

CObjMgr_QueryFactory
NCBI C++ Object Manager dependant implementation of IQueryFactory.
Definition: objmgr_query_data.hpp:51

CRef< CSeq_loc >

CScope
CScope –.
Definition: scope.hpp:92

CSearchDatabase
Blast Search Subject.
Definition: uniform_search.hpp:109

CSearchResultSet
Search Results for All Queries.
Definition: blast_results.hpp:307

CSeq_align::GetSeq_id
const CSeq_id & GetSeq_id(TDim row) const
Get seq-id (the first one if segments have different ids).
Definition: Seq_align.cpp:317

CSeq_align::GetNamedScore
bool GetNamedScore(const string &id, int &score) const
Get score.
Definition: Seq_align.cpp:563

CStrictId< SStrictId_Gi, SStrictId_Gi::TId >

CTestObjMgr::Instance
static CTestObjMgr & Instance()
Definition: test_objmgr.cpp:69

disc_nucl_options.hpp
Declares the CDiscNucleotideOptionsHandle class.

gbloader.hpp

CBlastOptionsHandle::SetEvalueThreshold
void SetEvalueThreshold(double eval)
Sets EvalueThreshold.
Definition: blast_options_handle.hpp:250

CBlastNucleotideOptionsHandle::SetMatchReward
void SetMatchReward(int r)
Sets MatchReward.
Definition: blast_nucl_options.hpp:186

CBlastPrelimSearch::Run
CRef< SInternalData > Run()
Borrow the internal data and results results.
Definition: prelim_stage.cpp:206

SeqDbBlastSeqSrcInit
BlastSeqSrc * SeqDbBlastSeqSrcInit(const string &dbname, bool is_prot, Uint4 first_seq=0, Uint4 last_seq=0, Int4 mask_algo_id=-1, ESubjectMaskingType mask_type=eNoSubjMasking)
Initialize the sequence source structure.
Definition: seqsrc_seqdb.cpp:764

CBlastOptionsHandle::SetEffectiveSearchSpace
void SetEffectiveSearchSpace(Int8 eff)
Sets EffectiveSearchSpace.
Definition: blast_options_handle.hpp:323

CLocalBlast::Run
CRef< CSearchResultSet > Run()
Executes the search.
Definition: local_blast.cpp:167

CBlastOptionsFactory::Create
static CBlastOptionsHandle * Create(EProgram program, EAPILocality locality=CBlastOptions::eLocal)
Creates an options handle object configured with default options for the requested program,...
Definition: blast_options_handle.cpp:110

CBlastOptionsHandle::SetOptions
CBlastOptions & SetOptions()
Returns a reference to the internal options class which this object is a handle for.
Definition: blast_options_handle.hpp:169

CBlastNucleotideOptionsHandle::SetTraditionalBlastnDefaults
void SetTraditionalBlastnDefaults()
Sets TraditionalBlastnDefaults.
Definition: blast_nucl_options.cpp:70

CBlastNucleotideOptionsHandle::SetMismatchPenalty
void SetMismatchPenalty(int p)
Sets MismatchPenalty.
Definition: blast_nucl_options.hpp:192

MultiSeqBlastSeqSrcInit
BlastSeqSrc * MultiSeqBlastSeqSrcInit(TSeqLocVector &seq_vector, EBlastProgramType program, bool dbscan_mode=false)
Initialize the sequence source structure.
Definition: seqsrc_multiseq.cpp:555

BLASTAA_SEQ_CODE
#define BLASTAA_SEQ_CODE
== Seq_code_ncbistdaa
Definition: blast_encoding.h:98

CBlastOptionsHandle::SetWindowSize
void SetWindowSize(int ws)
Sets WindowSize.
Definition: blast_options_handle.hpp:184

CBlastNucleotideOptionsHandle::SetRepeatFiltering
void SetRepeatFiltering(bool val)
Enable repeat filtering.
Definition: blast_nucl_options.hpp:130

CBlastOptions::SetFilterString
void SetFilterString(const char *f, bool clear=true)
Definition: blast_options_cxx.cpp:1042

Blast_FindRepeatFilterLoc
void Blast_FindRepeatFilterLoc(TSeqLocVector &query_loc, const CBlastOptionsHandle *opts_handle)
Finds repeats locations for a given set of sequences.
Definition: repeats_filter_cxx.cpp:329

CBlastNucleotideOptionsHandle::SetGapExtensionCost
void SetGapExtensionCost(int e)
Sets GapExtensionCost.
Definition: blast_nucl_options.hpp:210

CBlastOptionsHandle::SetMaskAtHash
void SetMaskAtHash(bool m=true)
Sets MaskAtHash.
Definition: blast_options_handle.hpp:201

CBlastOptionsHandle::SetFilterString
void SetFilterString(const char *f, bool clear=true)
Sets FilterString.
Definition: blast_options_handle.cpp:104

CBlastNucleotideOptionsHandle::SetWordSize
void SetWordSize(int ws)
Sets WordSize.
Definition: blast_nucl_options.hpp:86

SInternalData::m_Diagnostics
CRef< TBlastDiagnostics > m_Diagnostics
Diagnostic output from preliminary and traceback stages.
Definition: setup_factory.hpp:332

CBlastOptionsHandle::SetPercentIdentity
void SetPercentIdentity(double p)
Sets PercentIdentity.
Definition: blast_options_handle.hpp:261

CBlastNucleotideOptionsHandle::SetGapOpeningCost
void SetGapOpeningCost(int g)
Sets GapOpeningCost.
Definition: blast_nucl_options.hpp:204

SInternalData::m_HspStream
CRef< TBlastHSPStream > m_HspStream
HSP output of the preliminary stage goes here.
Definition: setup_factory.hpp:335

CBlastPrelimSearch::ComputeBlastHSPResults
BlastHSPResults * ComputeBlastHSPResults(BlastHSPStream *stream, Uint4 max_num_hsps=0, bool *rm_hsps=NULL, vector< bool > *rm_hsps_info=NULL) const
Return HSPs in a structure other than the HSPStream? Provide conversion? How to combine this with CBl...
Definition: prelim_stage.cpp:331

CSearchDatabase::eBlastDbIsNucleotide
@ eBlastDbIsNucleotide
nucleotide
Definition: uniform_search.hpp:117

GI_CONST
#define GI_CONST(gi)
Definition: ncbimisc.hpp:1087

NULL
#define NULL
Definition: ncbistd.hpp:225

CSeq_id::PreferAccessionOverGi
static bool PreferAccessionOverGi(void)
Check if the option to prefer accession.version over GI is enabled (SeqId/PreferAccessionOverGi or SE...
Definition: Seq_id.cpp:3404

CSeq_loc::SetWhole
void SetWhole(TWhole &v)
Definition: Seq_loc.hpp:982

CScope::AddDefaults
void AddDefaults(TPriority pri=kPriority_Default)
Add default data loaders from object manager.
Definition: scope.cpp:504

Int4
int32_t Int4
4-byte (32-bit) signed integer
Definition: ncbitype.h:102

Uint4
uint32_t Uint4
4-byte (32-bit) unsigned integer
Definition: ncbitype.h:103

Int8
int64_t Int8
8-byte (64-bit) signed integer
Definition: ncbitype.h:104

CSeq_align_set_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Seq_align_set_.hpp:166

CSeq_id_Base::Which
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_id_.hpp:746

CSeq_id_Base::GetGi
TGi GetGi(void) const
Get the variant data.
Definition: Seq_id_.hpp:889

CTextseq_id_Base::GetVersion
TVersion GetVersion(void) const
Get the Version member data.
Definition: Textseq_id_.hpp:441

CSeq_id_Base::GetDdbj
const TDdbj & GetDdbj(void) const
Get the variant data.
Definition: Seq_id_.cpp:391

CTextseq_id_Base::GetAccession
const TAccession & GetAccession(void) const
Get the Accession member data.
Definition: Textseq_id_.hpp:340

CSeq_id_Base::e_Ddbj
@ e_Ddbj
DDBJ.
Definition: Seq_id_.hpp:107

CSeq_id_Base::e_Gi
@ e_Gi
GenInfo Integrated Database.
Definition: Seq_id_.hpp:106

iterator.hpp

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

ncbi::blast
Definition: blast_test_util.hpp:69

ncbi::objects
Definition: blast_test_util.hpp:62

ncbi
Magic spell ;-) needed for some weird compilers... very empiric.
Definition: netcache_search.hpp:39

fabs
#define fabs(v)
Definition: ncbi_dispd.c:46

ncbi_pch.hpp

Boolean
Uint1 Boolean
bool replacment for C
Definition: ncbi_std.h:94

FALSE
#define FALSE
bool replacment for C indicating false.
Definition: ncbi_std.h:101

ncbitime.hpp
Defines: CTimeFormat - storage class for time format.

object_manager.hpp
The Object manager core.

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

objostr.hpp

blast_test_util.hpp
Utilities to develop and debug unit tests for BLAST.

results
static int * results[]
Definition: pcre2posix_test.c:111

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

repeats_filter.hpp
C++ implementation of repeats filtering for C++ BLAST.

scope.hpp

seqsrc_multiseq.hpp
Implementation of the BlastSeqSrc interface for a vector of sequence locations.

seqsrc_seqdb.hpp
Implementation of the BlastSeqSrc interface using the C++ BLAST databases API.

sequence.hpp

serial.hpp

TSeqLocVector
vector< SSeqLoc > TSeqLocVector
Vector of sequence locations.
Definition: sseqloc.hpp:129

BlastDiagnostics
Return statistics from the BLAST search.
Definition: blast_diagnostics.h:82

BlastDiagnostics::ungapped_stat
BlastUngappedStats * ungapped_stat
Ungapped extension counts.
Definition: blast_diagnostics.h:83

BlastDiagnostics::gapped_stat
BlastGappedStats * gapped_stat
Gapped extension counts.
Definition: blast_diagnostics.h:84

BlastEngineTestFixture
Definition: blastengine_unit_test.cpp:82

BlastEngineTestFixture::setupQueryAndSubject
void setupQueryAndSubject(TGi query_gi, TGi subject_gi)
Definition: blastengine_unit_test.cpp:92

BlastEngineTestFixture::m_vSubject
TSeqLocVector m_vSubject
Definition: blastengine_unit_test.cpp:85

BlastEngineTestFixture::m_vQuery
TSeqLocVector m_vQuery
Definition: blastengine_unit_test.cpp:84

BlastEngineTestFixture::~BlastEngineTestFixture
~BlastEngineTestFixture()
Definition: blastengine_unit_test.cpp:87

BlastGappedStats
Structure containing hit counts from the gapped stage of a BLAST search.
Definition: blast_diagnostics.h:70

BlastGappedStats::good_extensions
Int4 good_extensions
Number of HSPs below the e-value threshold after gapped extension.
Definition: blast_diagnostics.h:75

BlastGappedStats::extensions
Int4 extensions
Total number of gapped extensions performed.
Definition: blast_diagnostics.h:74

BlastHSPList
The structure to hold all HSPs for a given sequence after the gapped alignment.
Definition: blast_hits.h:153

BlastHSPList::oid
Int4 oid
The ordinal id of the subject sequence this HSP list is for.
Definition: blast_hits.h:154

BlastHSPList::hspcnt
Int4 hspcnt
Number of HSPs saved.
Definition: blast_hits.h:158

BlastHSPList::hsp_array
BlastHSP ** hsp_array
Array of pointers to individual HSPs.
Definition: blast_hits.h:157

BlastHSP
Structure holding all information about an HSP.
Definition: blast_hits.h:126

BlastHSP::evalue
double evalue
This HSP's e-value.
Definition: blast_hits.h:130

BlastHSP::num_ident
Int4 num_ident
Number of identical base pairs in this HSP.
Definition: blast_hits.h:128

BlastHSP::query
BlastSeg query
Query sequence info.
Definition: blast_hits.h:131

BlastHSP::subject
BlastSeg subject
Subject sequence info.
Definition: blast_hits.h:132

BlastHSP::score
Int4 score
This HSP's raw score.
Definition: blast_hits.h:127

BlastScoreBlk
Structure used for scoring calculations.
Definition: blast_stat.h:177

BlastScoringOptions
Scoring options block Used to produce the BlastScoreBlk structure This structure may be needed for lo...
Definition: blast_options.h:461

BlastSeg::end
Int4 end
End of hsp.
Definition: blast_hits.h:99

BlastSeg::offset
Int4 offset
Start of hsp.
Definition: blast_hits.h:98

BlastSeqSrc
Complete type definition of Blast Sequence Source ADT.
Definition: blast_seqsrc.c:43

BlastUngappedStats
Structure containing hit counts from the ungapped stage of a BLAST search.
Definition: blast_diagnostics.h:57

BlastUngappedStats::lookup_hits
Int8 lookup_hits
Number of successful lookup table hits.
Definition: blast_diagnostics.h:58

BlastUngappedStats::init_extends
Int4 init_extends
Number of initial words found and extended.
Definition: blast_diagnostics.h:61

BlastUngappedStats::good_init_extends
Int4 good_init_extends
Number of successful initial extensions, i.e.
Definition: blast_diagnostics.h:62

SSeqLoc
Structure to represent a single sequence to be fed to BLAST.
Definition: sseqloc.hpp:47

subject
static string subject
Definition: struct_dp_demo.cpp:88

query
static string query
Definition: struct_dp_demo.cpp:88

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

test_objmgr.hpp