blast_aux.cpp
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:13k
源码类别:

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: blast_aux.cpp,v $
  4.  * PRODUCTION Revision 1000.6  2004/06/01 18:05:38  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.40
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. /*  $Id: blast_aux.cpp,v 1000.6 2004/06/01 18:05:38 gouriano Exp $
  10. * ===========================================================================
  11. *
  12. *                            PUBLIC DOMAIN NOTICE
  13. *               National Center for Biotechnology Information
  14. *
  15. *  This software/database is a "United States Government Work" under the
  16. *  terms of the United States Copyright Act.  It was written as part of
  17. *  the author's official duties as a United States Government employee and
  18. *  thus cannot be copyrighted.  This software/database is freely available
  19. *  to the public for use. The National Library of Medicine and the U.S.
  20. *  Government have not placed any restriction on its use or reproduction.
  21. *
  22. *  Although all reasonable efforts have been taken to ensure the accuracy
  23. *  and reliability of the software and data, the NLM and the U.S.
  24. *  Government do not and cannot warrant the performance or results that
  25. *  may be obtained by using this software or data. The NLM and the U.S.
  26. *  Government disclaim all warranties, express or implied, including
  27. *  warranties of performance, merchantability or fitness for any particular
  28. *  purpose.
  29. *
  30. *  Please cite the author in any work or product based on this material.
  31. *
  32. * ===========================================================================
  33. *
  34. * Author:  Christiam Camacho
  35. *
  36. */
  37. /// @file blast_aux.cpp
  38. /// Implements C++ wrapper classes for structures in algo/blast/core as well as
  39. /// some auxiliary functions to convert CSeq_loc to/from BlastMask structures.
  40. #include <ncbi_pch.hpp>
  41. #include <objects/seqloc/Seq_interval.hpp>
  42. #include <objects/seqloc/Seq_point.hpp>
  43. #include <objmgr/util/sequence.hpp>
  44. #include <algo/blast/api/blast_aux.hpp>
  45. /** @addtogroup AlgoBlast
  46.  *
  47.  * @{
  48.  */
  49. BEGIN_NCBI_SCOPE
  50. BEGIN_SCOPE(blast)
  51. USING_SCOPE(objects);
  52. void
  53. CQuerySetUpOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/)
  54.     const
  55. {
  56.     ddc.SetFrame("CQuerySetUpOptions");
  57.     if (!m_Ptr)
  58.         return;
  59.     ddc.Log("filter_string", m_Ptr->filter_string);
  60.     ddc.Log("strand_option", m_Ptr->strand_option);
  61.     ddc.Log("genetic_code", m_Ptr->genetic_code);
  62. }
  63. void
  64. CBLAST_SequenceBlk::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  65. {
  66. ddc.SetFrame("CBLAST_SequenceBlk");
  67.     if (!m_Ptr)
  68.         return;
  69.     ddc.Log("sequence", m_Ptr->sequence);
  70.     ddc.Log("sequence_start", m_Ptr->sequence_start);
  71.     ddc.Log("sequence_allocated", m_Ptr->sequence_allocated);
  72.     ddc.Log("sequence_start_allocated", m_Ptr->sequence_start_allocated);
  73.     ddc.Log("length", m_Ptr->length);
  74. }
  75. void
  76. CBlastQueryInfo::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  77. {
  78. ddc.SetFrame("CBlastQueryInfo");
  79.     if (!m_Ptr)
  80.         return;
  81. }
  82. void
  83. CLookupTableOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  84. {
  85. ddc.SetFrame("CLookupTableOptions");
  86.     if (!m_Ptr)
  87.         return;
  88.     ddc.Log("threshold", m_Ptr->threshold);
  89.     ddc.Log("lut_type", m_Ptr->lut_type);
  90.     ddc.Log("word_size", m_Ptr->word_size);
  91.     ddc.Log("alphabet_size", m_Ptr->alphabet_size);
  92.     ddc.Log("mb_template_length", m_Ptr->mb_template_length);
  93.     ddc.Log("mb_template_type", m_Ptr->mb_template_type);
  94.     ddc.Log("max_positions", m_Ptr->max_positions);
  95.     ddc.Log("scan_step", m_Ptr->scan_step);
  96. }
  97. void
  98. CLookupTableWrap::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  99. {
  100. ddc.SetFrame("CLookupTableWrap");
  101.     if (!m_Ptr)
  102.         return;
  103. }
  104. void
  105. CBlastInitialWordOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  106. {
  107. ddc.SetFrame("BlastInitialWordOptions");
  108.     if (!m_Ptr)
  109.         return;
  110.     ddc.Log("window_size", m_Ptr->window_size);
  111.     ddc.Log("container_type", m_Ptr->container_type);
  112.     ddc.Log("extension_method", m_Ptr->extension_method);
  113.     ddc.Log("variable_wordsize", m_Ptr->variable_wordsize);
  114.     ddc.Log("ungapped_extension", m_Ptr->ungapped_extension);
  115.     ddc.Log("x_dropoff", m_Ptr->x_dropoff);
  116. }
  117. void
  118. CBlastInitialWordParameters::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  119. {
  120. ddc.SetFrame("CBlastInitialWordParameters");
  121.     if (!m_Ptr)
  122.         return;
  123. }
  124. void
  125. CBlast_ExtendWord::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  126. {
  127. ddc.SetFrame("CBlast_ExtendWord");
  128.     if (!m_Ptr)
  129.         return;
  130. }
  131. void
  132. CBlastExtensionOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  133. {
  134. ddc.SetFrame("CBlastExtensionOptions");
  135.     if (!m_Ptr)
  136.         return;
  137.     ddc.Log("gap_x_dropoff", m_Ptr->gap_x_dropoff);
  138.     ddc.Log("gap_x_dropoff_final", m_Ptr->gap_x_dropoff_final);
  139.     ddc.Log("gap_trigger", m_Ptr->gap_trigger);
  140.     ddc.Log("ePrelimGapExt", m_Ptr->ePrelimGapExt);
  141.     ddc.Log("eTbackExt", m_Ptr->eTbackExt);
  142. }
  143. void
  144. CBlastExtensionParameters::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  145. {
  146. ddc.SetFrame("CBlastExtensionParameters");
  147.     if (!m_Ptr)
  148.         return;
  149. }
  150. void
  151. CBlastHitSavingOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  152. {
  153. ddc.SetFrame("CBlastHitSavingOptions");
  154.     if (!m_Ptr)
  155.         return;
  156.     ddc.Log("hitlist_size", m_Ptr->hitlist_size);
  157.     ddc.Log("hsp_num_max", m_Ptr->hsp_num_max);
  158.     ddc.Log("total_hsp_limit", m_Ptr->total_hsp_limit);
  159.     ddc.Log("hsp_range_max", m_Ptr->hsp_range_max);
  160.     ddc.Log("perform_culling", m_Ptr->perform_culling);
  161.     ddc.Log("required_start", m_Ptr->required_start);
  162.     ddc.Log("required_end", m_Ptr->required_end);
  163.     ddc.Log("expect_value", m_Ptr->expect_value);
  164.     ddc.Log("original_expect_value", m_Ptr->original_expect_value);
  165.     ddc.Log("cutoff_score", m_Ptr->cutoff_score);
  166.     ddc.Log("percent_identity", m_Ptr->percent_identity);
  167.     ddc.Log("do_sum_stats", m_Ptr->do_sum_stats);
  168.     ddc.Log("longest_longron", m_Ptr->longest_intron);
  169.     ddc.Log("is_neighboring", m_Ptr->is_neighboring);
  170. }
  171. void
  172. CBlastHitSavingParameters::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  173. {
  174. ddc.SetFrame("CBlastHitSavingParameters");
  175.     if (!m_Ptr)
  176.         return;
  177. }
  178. void
  179. CPSIBlastOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  180. {
  181. ddc.SetFrame("CPSIBlastOptions");
  182.     if (!m_Ptr)
  183.         return;
  184. }
  185. void
  186. CBlastGapAlignStruct::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  187. {
  188. ddc.SetFrame("CBlastGapAlignStruct");
  189.     if (!m_Ptr)
  190.         return;
  191. }
  192. void
  193. CBlastEffectiveLengthsOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  194. {
  195. ddc.SetFrame("CBlastEffectiveLengthsOptions");
  196.     if (!m_Ptr)
  197.         return;
  198.     ddc.Log("db_length", (unsigned long)m_Ptr->db_length); // Int8
  199.     ddc.Log("dbseq_num", m_Ptr->dbseq_num);
  200.     ddc.Log("searchsp_eff", (unsigned long)m_Ptr->searchsp_eff); // Int8
  201.     ddc.Log("use_real_db_size", m_Ptr->use_real_db_size);
  202. }
  203. void
  204. CBlastScoringOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  205. {
  206. ddc.SetFrame("CBlastScoringOptions");
  207.     if (!m_Ptr)
  208.         return;
  209.     ddc.Log("matrix", m_Ptr->matrix);
  210.     ddc.Log("matrix_path", m_Ptr->matrix_path);
  211.     ddc.Log("reward", m_Ptr->reward);
  212.     ddc.Log("penalty", m_Ptr->penalty);
  213.     ddc.Log("gapped_calculation", m_Ptr->gapped_calculation);
  214.     ddc.Log("gap_open", m_Ptr->gap_open);
  215.     ddc.Log("gap_extend", m_Ptr->gap_extend);
  216.     ddc.Log("shift_pen", m_Ptr->shift_pen);
  217.     ddc.Log("decline_align", m_Ptr->decline_align);
  218.     ddc.Log("is_ooframe", m_Ptr->is_ooframe);
  219. }
  220. void
  221. CBlastDatabaseOptions::DebugDump(CDebugDumpContext ddc, unsigned int /*depth*/) const
  222. {
  223. ddc.SetFrame("CBlastDatabaseOptions");
  224.     if (!m_Ptr)
  225.         return;
  226. }
  227. BlastMaskLoc*
  228. CSeqLoc2BlastMaskLoc(const CSeq_loc &slp, int index)
  229. {
  230.     if (slp.IsNull())
  231.         return NULL;
  232.     _ASSERT(slp.IsInt() || slp.IsPacked_int() || slp.IsMix());
  233.     BlastSeqLoc* bsl = NULL,* curr = NULL,* tail = NULL;
  234.     BlastMaskLoc* mask = NULL;
  235.     if (slp.IsInt()) {
  236.         bsl = 
  237.             BlastSeqLocNew(slp.GetInt().GetFrom(), slp.GetInt().GetTo());
  238.     } else if (slp.IsPacked_int()) {
  239.         ITERATE(list< CRef<CSeq_interval> >, itr, 
  240.                 slp.GetPacked_int().Get()) {
  241.             curr = BlastSeqLocNew((*itr)->GetFrom(), (*itr)->GetTo());
  242.             if (!bsl) {
  243.                 bsl = tail = curr;
  244.             } else {
  245.                 tail->next = curr;
  246.                 tail = tail->next;
  247.             }
  248.         }
  249.     } else if (slp.IsMix()) {
  250.         ITERATE(CSeq_loc_mix::Tdata, itr, slp.GetMix().Get()) {
  251.             if ((*itr)->IsInt()) {
  252.                 curr = BlastSeqLocNew((*itr)->GetInt().GetFrom(), 
  253.                                       (*itr)->GetInt().GetTo());
  254.             } else if ((*itr)->IsPnt()) {
  255.                 curr = BlastSeqLocNew((*itr)->GetPnt().GetPoint(), 
  256.                                       (*itr)->GetPnt().GetPoint());
  257.             }
  258.             if (!bsl) {
  259.                 bsl = tail = curr;
  260.             } else {
  261.                 tail->next = curr;
  262.                 tail = tail->next;
  263.             }
  264.         }
  265.     }
  266.     mask = (BlastMaskLoc*) calloc(1, sizeof(BlastMaskLoc));
  267.     mask->index = index;
  268.     mask->loc_list = (ListNode *) bsl;
  269.     return mask;
  270. }
  271. void BlastMaskLocDNAToProtein(BlastMaskLoc** mask_ptr, const CSeq_loc &seqloc, 
  272.                            CScope* scope)
  273. {
  274.    BlastMaskLoc* last_mask = NULL,* head_mask = NULL,* mask_loc; 
  275.    Int4 dna_length;
  276.    BlastSeqLoc* dna_loc,* prot_loc_head,* prot_loc_last;
  277.    SSeqRange* dip;
  278.    Int4 context;
  279.    Int2 frame;
  280.    Int4 from, to;
  281.    if (!mask_ptr)
  282.       return;
  283.    mask_loc = *mask_ptr;
  284.    if (!mask_loc) 
  285.       return;
  286.    dna_length = sequence::GetLength(seqloc, scope);
  287.    /* Reproduce this mask for all 6 frames, with translated 
  288.       coordinates */
  289.    for (context = 0; context < NUM_FRAMES; ++context) {
  290.        if (!last_mask) {
  291.            head_mask = last_mask = (BlastMaskLoc *) calloc(1, sizeof(BlastMaskLoc));
  292.        } else {
  293.            last_mask->next = (BlastMaskLoc *) calloc(1, sizeof(BlastMaskLoc));
  294.            last_mask = last_mask->next;
  295.        }
  296.          
  297.        last_mask->index = NUM_FRAMES * mask_loc->index + context;
  298.        prot_loc_last = prot_loc_head = NULL;
  299.        
  300.        frame = BLAST_ContextToFrame(blast_type_blastx, context);
  301.        
  302.        for (dna_loc = mask_loc->loc_list; dna_loc; 
  303.             dna_loc = dna_loc->next) {
  304.            dip = (SSeqRange*) dna_loc->ptr;
  305.            if (frame < 0) {
  306.                from = (dna_length + frame - dip->right)/CODON_LENGTH;
  307.                to = (dna_length + frame - dip->left)/CODON_LENGTH;
  308.            } else {
  309.                from = (dip->left - frame + 1)/CODON_LENGTH;
  310.                to = (dip->right - frame + 1)/CODON_LENGTH;
  311.            }
  312.            if (!prot_loc_last) {
  313.                prot_loc_head = prot_loc_last = BlastSeqLocNew(from, to);
  314.            } else { 
  315.                prot_loc_last->next = BlastSeqLocNew(from, to);
  316.                prot_loc_last = prot_loc_last->next; 
  317.            }
  318.        }
  319.        last_mask->loc_list = prot_loc_head;
  320.    }
  321.    /* Free the mask with nucleotide coordinates */
  322.    BlastMaskLocFree(mask_loc);
  323.    /* Return the new mask with protein coordinates */
  324.    *mask_ptr = head_mask;
  325. }
  326. void BlastMaskLocProteinToDNA(BlastMaskLoc** mask_ptr, TSeqLocVector &slp)
  327. {
  328.    BlastMaskLoc* mask_loc;
  329.    BlastSeqLoc* loc;
  330.    SSeqRange* dip;
  331.    Int4 dna_length;
  332.    Int2 frame;
  333.    Int4 from, to;
  334.    if (!mask_ptr) 
  335.       // Nothing to do - just return
  336.       return;
  337.    for (mask_loc = *mask_ptr; mask_loc; mask_loc = mask_loc->next) {
  338.       dna_length = 
  339.          sequence::GetLength(*slp[mask_loc->index/NUM_FRAMES].seqloc, 
  340.                              slp[mask_loc->index/NUM_FRAMES].scope);
  341.       frame = BLAST_ContextToFrame(blast_type_blastx, 
  342.                                    mask_loc->index % NUM_FRAMES);
  343.       
  344.       for (loc = mask_loc->loc_list; loc; loc = loc->next) {
  345.          dip = (SSeqRange*) loc->ptr;
  346.          if (frame < 0) {
  347.             to = dna_length - CODON_LENGTH*dip->left + frame;
  348.             from = dna_length - CODON_LENGTH*dip->right + frame + 1;
  349.          } else {
  350.             from = CODON_LENGTH*dip->left + frame - 1;
  351.             to = CODON_LENGTH*dip->right + frame - 1;
  352.          }
  353.          dip->left = from;
  354.          dip->right = to;
  355.       }
  356.    }
  357. }
  358. END_SCOPE(blast)
  359. END_NCBI_SCOPE
  360. /* @} */
  361. /*
  362.  * ===========================================================================
  363.  *
  364.  * $Log: blast_aux.cpp,v $
  365.  * Revision 1000.6  2004/06/01 18:05:38  gouriano
  366.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.40
  367.  *
  368.  * Revision 1.40  2004/05/21 21:41:02  gorelenk
  369.  * Added PCH ncbi_pch.hpp
  370.  *
  371.  * Revision 1.39  2004/05/17 15:33:14  madden
  372.  * Int algorithm_type replaced with enum EBlastPrelimGapExt
  373.  *
  374.  * Revision 1.38  2004/05/14 16:01:10  madden
  375.  * Rename BLAST_ExtendWord to Blast_ExtendWord in order to fix conflicts with C toolkit
  376.  *
  377.  * Revision 1.37  2004/04/05 16:09:27  camacho
  378.  * Rename DoubleInt -> SSeqRange
  379.  *
  380.  * Revision 1.36  2004/03/19 19:22:55  camacho
  381.  * Move to doxygen group AlgoBlast, add missing CVS logs at EOF
  382.  *
  383.  *
  384.  * ===========================================================================
  385.  */