ppALIGN • 1.0

posterior probabilities for
score based sequence alignments

• Back

ppALIGN API documentation

src/alignoverlap.hpp

/******************************************************************************
    Copyright 2009 Stefan Wolfsheimer & Gregory Nuel.

    This file is part of ppALIGN

    ppALIGN is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    ppALIGN is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with ppALIGN; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*******************************************************************************/

#ifndef _ALIGN_OVERLAP_HPP_
#define _ALIGN_OVERLAP_HPP_
#include "sequence.hpp"
#include "align.hpp"
#include <string>


// 2010-02-17: sw: removed dep. from io part of the library.

class AlignHandler
{
public:
  virtual ~AlignHandler() {}

  virtual void Add(const std::string & generator, 
                   const Align & a) = 0;
};


class AlignStartOverlap : public AlignHandler
{
public:
  void Add(const std::string & generator,
           const Align & a);
  void StreamOut(std::ostream & ost, Pair offset);

  std::map<std::string,std::map<Pair,int> > start_points;
  std::map<std::string,std::map<Pair,int> > end_points;
private:
  void StreamOut(std::ostream & ost,
                 std::map<std::string,std::map<Pair,int> >::const_iterator,
                 std::map<std::string,std::map<Pair,int> >::const_iterator,
                 const Pair & offset) const;

};


class AlignOverlap : public AlignHandler
{
private:

  bool overlap_segments_built;
  struct AlignCol
  {
    AlignCol();
    AlignCol(int i, int j, AlignState s, long col, double prob) ;
    Pair       pair;

    AlignState state;

    bool       overlap;

    
    long       segment;
    long       col;
    double     prob;
  };




public:
  AlignOverlap(const Align & ref,
               Sequence & _seq1,
               Sequence & _seq2);

  void Add(const std::string & generator, 
           const Align & a);
  void StreamOutPartition(std::ostream & ost,Pair seq_offset=Pair(0,0));

  class AlignSegment;

  class AlternativeSegment
  {
  public:
    friend class AlignOverlap;
    friend class AlignSegment;
    Align::const_iterator begin;
    Align::const_iterator end;
    Pair begin_pos;

    void StreamOutQuery(std::ostream & ost) const;
    void StreamOutSubject(std::ostream & ost) const;

    
  private:
    AlternativeSegment(Align::const_iterator b,
                       Align::const_iterator e,
                       const Pair & bp,
                       AlignSegment & seg) ;

    void StreamOut(std::ostream & ost, 
                   const std::string & generator,
                   int n) const;


    inline friend bool operator < (const AlternativeSegment & a, 
                                   const AlternativeSegment & b);
    inline friend bool operator == (const AlternativeSegment & a, 
                                    const AlternativeSegment & b);
    AlignSegment * parent;

  };
  

  typedef std::map<AlternativeSegment,int>::iterator alternative_iterator;

  typedef std::map<AlternativeSegment,int>::const_iterator alternative_const_iterator;
  


  class AlignSegment
  {
  public:
    friend class AlignOverlap;
    friend class AlternativeSegment;
    Pair start_pos;
    
    bool overlap;
    long n_matches,n_insertions,n_deletions;

    void StreamOutQuery(std::ostream & ost);

    void StreamOutSubject(std::ostream & ost);

    void GetAlign(Align & a) const;

    inline alternative_iterator BeginAlternatives(const std::string & generator);

    inline alternative_iterator EndAlternatives(const std::string & generator);


  private:
    AlignSegment(const std::vector<AlignOverlap::AlignCol>::iterator & _begin,
                 const std::vector<AlignOverlap::AlignCol>::iterator & _end,
                 Pair _start_pos,
                 bool _ol,
                 long n_matches,
                 long n_insertions,
                 long n_deletions,
                 AlignOverlap & overlap);
  
    AlignOverlap * parent;

    std::vector<AlignCol>::iterator begin;
    std::vector<AlignCol>::iterator end;

    
    
    std::map<const std::string *,
             std::map<AlternativeSegment,int> >
    alternative_segments;
    
    inline void InsertAlternativeSegment(const std::string * generator,
                                         Align::const_iterator begin,
                                         Align::const_iterator end,
                                         const Pair & begin_pos);
  };
  
  typedef std::vector<AlignSegment>::iterator segment_iterator;

  typedef std::vector<AlignSegment>::const_iterator segment_const_iterator;

  inline segment_iterator BeginSegments();

  inline segment_iterator EndSegments();

  void BuildOverlapSegments() ;
  
private:

  void BuildLookup();


  void HandleAlignment(const Align & a, 
                       const std::string * generator);



  const Align               & ref_align;  
  std::vector<AlignSegment> align_segments;

  long length1,length2;
  const Sequence & seq1;
  const Sequence & seq2;

  Pair pos_begin,pos_end;

  /* a map from sequence position (with respect to pos_begin) 
     to positions in alignments 
     pair of positions in the input sequence 
     if state is a match it points to the last match
     seen so far.
     example a_4  -  - 
                     b_3
     -> state=StateDelete
        pair= Pair(4,3)
  */
  std::vector<std::vector<AlignCol>::iterator> lookup_first;
  std::vector<std::vector<AlignCol>::iterator> lookup_second;
  std::vector<AlignCol> lookup_align;


  std::map<std::string,std::vector<Align > > 
  alternative_alignments;
};



// inline functions 
AlignOverlap::segment_iterator AlignOverlap::BeginSegments()
{
  return align_segments.begin();
}

AlignOverlap::segment_iterator AlignOverlap::EndSegments()
{
  return  align_segments.end();
}


AlignOverlap::alternative_iterator 
AlignOverlap::AlignSegment::BeginAlternatives(const std::string & generator)
{
  std::map<std::string,std::vector<Align> >::const_iterator 
    name_itr = parent->alternative_alignments.find(generator);
  if(name_itr ==  parent->alternative_alignments.end()) 
    {
      std::cerr << "AlignOverlap::AlignSegment::BeginAlternatives: "
                << " generator " << generator << " not found " << std::endl;
      exit(8);
    }
  return alternative_segments[&name_itr->first].begin();
}


AlignOverlap::alternative_iterator 
AlignOverlap::AlignSegment::EndAlternatives(const std::string & generator)
{
  std::map<std::string,std::vector<Align> >::const_iterator 
    name_itr = parent->alternative_alignments.find(generator);
  if(name_itr ==  parent->alternative_alignments.end()) 
    {
      std::cerr << "AlignOverlap::AlignSegment::BeginAlternatives: "
                << " generator " << generator << " not found " << std::endl;
      exit(8);
    }
  return alternative_segments[&name_itr->first].end();
}


#endif 

Design by 1234.info | Modified by Stefan Wolfsheimer | Powered by PHP | XHTML 1.0 | CSS 2.0