Esambl.h

Go to the documentation of this file.

#ifndef EST_ASSEMBLE_H
#define EST_ASSEMBLE_H

#include <vector>
#include "GenModel.h"
#include <iostream>
#include <queue>
#include "RNAModel.h"
#include "Coverdepth.h"

//#define NDEBUG

using namespace std;

enum Color { white, black, gray, red };

class Invariant { };

class Valence {
   public:
      Valence() : overlap(0), contain(0) { }
      Valence(int o, int c) : overlap(o), contain(c) { }
      Valence(const Valence &v) : overlap(v.overlap), contain(v.contain) { }
      Valence& operator=(const Valence &v);
      bool operator<(const Valence &v) const;
      bool operator==(const Valence &v) const { 
         return overlap==v.overlap && contain == v.contain; }
      bool operator>(const Valence &v) const;
      void set(int o, int c) { overlap=o; contain=c; }
      friend ostream& operator<<(ostream &ous, const Valence &v) {
         ous << v.overlap << ", " << v.contain; return ous; }
      ostream& show(ostream &ous) const;

      int overlap;
      int contain;
};

class HeadNode : public Valence {
   public:
      HeadNode() : Valence(), idx(0) { }
      HeadNode(int id, int olp, int cont) : Valence(olp, cont), idx(id) { }
      HeadNode(const Valence &v, int id) : Valence(v), idx(id) { }
      HeadNode(const HeadNode &hn) : Valence(hn), idx(hn.idx) { }
      friend ostream& operator<<(ostream &ous, const HeadNode &hn);
      int idx;
};

class GraphNode {
   public:
      GraphNode() 
         : idx(-1), c(white), parent(0), distance(-1),
           val(), inassembly(0) { }
      GraphNode(int id) 
         : idx(id), c(white), parent(0), distance(-1),
           val(), inassembly(0) { }
      GraphNode(int id, int olp, int cont)
         : c(white), parent(0), distance(-1), idx(id), 
           val(olp,cont), inassembly(0) { }
      GraphNode(const GraphNode &gn);
      GraphNode& operator=(const GraphNode &gn);
      bool operator<(const GraphNode &gn) const { return val < gn.val; }
      void setId(int id) { idx=id; }
      void setValence(int o, int c) { val.set(o,c); }
      void setIdValence(int id, int olp, int cont) {
         idx=id; val.set(olp,cont); }
      ostream& show(ostream &ous) const;
      friend ostream& operator<<(ostream &ous, const GraphNode &gn) {
         gn.show(ous); return ous; }
      void setNull() { c=white; parent=0; distance=-1; }
      void setHead();
      void setChildOf(GraphNode* p);
      void setParent(GraphNode* p);
      bool canBeHead() const { return inassembly == 0 && c == white; }

   public:
      Color c;
      GraphNode *parent;
      int distance;
      int idx; // index into the vector where it stored the Noschanins
      Valence val;
      int inassembly; // included in different assemblies
};

class lessGraphNodePtr {
   public:
      bool operator()(const GraphNode* p1, const GraphNode* p2) const {
         return p1->val < p1->val;
      }
};

class ltModptr {
   public:
      bool operator()(const ESTAssembly *m1, const ESTAssembly *m2) const {
         return *m1 < *m2;
      }
};

class Graph {
   public:
      Graph() : vertices(), adjm(), NVQ(), input(), input_count() { }
      Graph(int N) : adjm(N, vector<int>(N)), vertices(N), NVQ(),
         input(), input_count() { }
      Graph(const vector<Alnchain*> &modfrag);
      Graph(const vector<Alnchain*> &modfrag, const vector<int> &modfrag_count)
         : adjm(modfrag.size(), vector<int>(modfrag.size())),
           vertices(modfrag.size()), NVQ(), input(modfrag),
           input_count(modfrag_count)
         { init(modfrag); }

      Graph(const vector<pair<Alnchain*,int> > &modfrag);
      ~Graph();

      int numberOfVertices() const { return adjm.size(); }
      void prepareAssembly();
      int assembleOneRound(Noschain &res, int &count, ostream &ous);
      //int assembleOneRound(Noschain &res, int &count);
      int assembleOneRound(Noschain &res, int &count, Coverdepth* &covd) throw(Invariant);
      /* write result to three output strams to be 
       * bulk-uploaded into the database. this version
       * is not good for debug. I will use a set as output
       * mechanism. */
      //void assemble(const string &gid, const string &gseq,
      //      ostream &ous, ostream &estmod, ostream &estexon, ostream &jgitrack, 
      //      ostream &ousest, ostream &ouspep);
      /* production version, no debug output, and produce 
       * JGI three tables: model, transcript, protein */
      //void assemble(const string &gid, const string &gseq,
      //      ostream &estmod, ostream &estexon, ostream &jgitrack, 
      //      ostream &ousest, ostream &ouspep);
      void assemble(const string &gid, const string &gseq, 
            set<ESTAssembly*, lessByChainDirectionPtr> &allest);
            //set<ESTAssembly*, ltModptr> &allest);
      bool allAssembled() const;
      void showMatrix(ostream &ous) const;
      void showInput(ostream &ous) const;
      friend ostream& operator<<(ostream& ous, const Graph &gr);
      static int getCongregationId() { return congid++; }

   private:
      void init(const vector<Alnchain*> &modfrag);

   public:
      static int congid;
      vector<Alnchain*> input;
      vector<int> input_count;
      vector<GraphNode> vertices;
      vector<vector<int> > adjm; // adjancy matrix
      priority_queue<HeadNode> NVQ;
};

class Graphid {
   public:
      Graphid(const vector<Alnchainid*> &modfrag)
         : input(modfrag), vertices(modfrag.size()), 
            adjm(modfrag.size(), vector<int>(modfrag.size())),
           NVQ() 
         { init(modfrag); }
         //{ Graph::init(static_cast< vector<Alnchain*> >(modfrag)); }
      ~Graphid();
      bool allAssembled() const;
      void prepareAssembly();

      void assemble(const string &gid, const string &gseq, 
            set<ESTAssemblyid*, lessByChainDirectionPtr> &allest) throw (PointOutChain);
      int assembleOneRound(Noschain &res, int &count, Coverdepth* &covd) throw(PointOutChain, Invariant);
      void showMatrix(ostream &ous) const;
      void showInput(ostream &ous) const;
      int numberOfVertices() const { return adjm.size(); }
      friend ostream& operator<<(ostream& ous, const Graph &gr);

      static int getCongregationId() { return congid++; }


   private:
      void init(const vector<Alnchainid*> &modfrag);
      //void prepareAssembly();
      string allInputESTIdsString(const char sep=',') const;
      vector<string> allInputESTIds() const;
      void appendAllESTIds(vector<string> &idv) const;

      void assignESTIds(const set<ESTAssemblyid*, lessByChainDirectionPtr> &estmod) const;

   public:
      static int congid;
      static int genomic_lengthcut;
      vector<Alnchainid*> input;
      vector<GraphNode> vertices;
      vector<vector<int> > adjm; // adjancy matrix
      priority_queue<HeadNode> NVQ;
};

#endif