active-networks.h

/**************************************************************************
 * Copyright (c) 2005-2011 T. M. Murali                                   *
 * Copyright (c) 2009-2011 Christopher L. Poirel                          *
 * Copyright (c) 2011 Christopher D. Lasher                               *
 * Copyright (c) 2010 Jacqueline Addesa                                   *
 * Copyright (c) 2003-2005 Deept Kumar                                    *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm 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 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm 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 Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

#ifndef _ACTIVE_NETWORKS_H
#define _ACTIVE_NETWORKS_H

#ifdef HAVE_CONFIG_H
#    include "config.h"
#endif

#ifdef CTEMPLATE

#include "boost/multi_index_container.hpp"
#include "boost/multi_index/member.hpp"
#include <boost/multi_index/mem_fun.hpp>
#include "boost/multi_index/ordered_index.hpp"
#include <boost/multi_index/composite_key.hpp>

using boost::multi_index_container;
using namespace boost::multi_index;

#include "google/template.h"
using google::Template;
using google::TemplateDictionary;
using google::STRIP_WHITESPACE;
#endif


#include "old-annotations.h"
#include "enrichment.h"
#include "itemset.h"
#include "graph.h"
#include "enrichment-algorithm.h"

// for MyPointSet (to store GE data).
#include "point.h"

typedef MyPointSet GEData;
typedef MySetOfPointSets GEDataSets;

//#include "NetMan.h"

inline void _computeComplement2(vector< unsigned int > &binaryVector)
{
  for (unsigned int i = 0; i < binaryVector.size(); i++)
    binaryVector[i] = 1 - binaryVector[i];
}


class ActiveNetwork : public MyGraph
{
private:
  vector< string > _conditions;
  // the records for edge functions that are enriched
  vector< EnrichmentRecord< string, string > > _edgeEnrichmentRecords;
  // convenience variable that stores for each edge, which functions
  // annotating that nodes are enriched in the ActiveNetwork. this
  // data is useful in _print_greg_nodes().
  map< string , vector< string > > _enrichedFunctionsByEdge;

  // the most specific enriched functions (for GO functions).
  set< string > _mostSpecificEnrichedFunctions;

  // the records for node functions that are enriched
  vector< EnrichmentRecord< string, string > > _nodeEnrichmentRecords;
  // convenience variable that stores for each node, which functions
  // annotating that nodes are enriched in the ActiveNetwork. this
  // data is useful in _print_greg_nodes().
  map< MyNodeId , vector< string > > _enrichedFunctionsByNode;

  // the first string is the type of
//  map< MyFunctionCategoryType, vector< EnrichmentRecord< MyNodeId, string > > enrichments;

  MyNT _pvalue;

  // file containing layout image.
  string _wwwLayoutFile;
  // file containing client-side image map for layout image.
  string _wwwMapFile;

public:
  ActiveNetwork()
      : _conditions(), _edgeEnrichmentRecords(), _enrichedFunctionsByEdge(),
        _mostSpecificEnrichedFunctions(),
        _nodeEnrichmentRecords(), _enrichedFunctionsByNode(), _pvalue(-1),
        _wwwLayoutFile(), _wwwMapFile()
    {}

  ActiveNetwork(const MyGraph &graph)
      : MyGraph(graph), _conditions(), _edgeEnrichmentRecords(), _enrichedFunctionsByEdge(),
        _mostSpecificEnrichedFunctions(),
        _nodeEnrichmentRecords(), _enrichedFunctionsByNode(), _pvalue(-1),
        _wwwLayoutFile(), _wwwMapFile()
    {}

  ActiveNetwork(const Itemset &itemset, unsigned int index);

  void addCondition(string cond)
    {
      _conditions.push_back(cond);
    }
  void getConditions(vector< string > &conds) const
    {
      conds = _conditions;
    }
  unsigned int numConditions() const
    {

      return(_conditions.size());
    }

  void setPvalue(MyNT val)
    {
      _pvalue = val;
    }

  MyNT getPvalue() const
    {
      return(_pvalue);
    }


  void clearEdgeEnrichments();

  void computeEdgeEnrichments(const MyAnnotations& annotations);

  void computeEdgeEnrichments(map< string, Enrichment< string, string > >&annotations);


  void clearNodeEnrichments();


  void computeNodeEnrichments(map< string, Enrichment< string, string > >&annotations);

  void computeNodeWeights(const GEData &gedata);


#ifdef CTEMPLATE























  void layout(string layoutDirectory, string wwwParamsDirectory,
              string nodeUrl = "",
              const map< string, set< string > > *nodeAliases = NULL,
              MyGraph *superGraph = NULL,
              const map< string, set< string > > *layoutConstraints = NULL
              );
#endif


#ifdef CTEMPLATE
  void layoutNodeAnnotation(string layoutDirectory, string wwwParamsDirectory,
                            const MyAnnotations &annotations,
                            string nodeAnnotationToLayout,
                            string nodeUrl = "",
                            const map< string, set< string > > *nodeAliases = NULL,
                            MyGraph *superGraph = NULL,
                            const set< ActiveNetwork* > *otherActiveNetworks = NULL,
                            // const set< string > *nodeAnnotationsToLayout
                            // const GEData *geData = NULL
                            const GEDataSets *geDataSets = NULL,
                            TemplateDictionary *efDict = NULL
                            );
#endif

  void printConditions(ostream &ostr) const;


  void printEdgesItemset(ostream &itemsetStream, string id);



  void printEdgeEnrichments(//const MyAnnotations& annotations,
    ostream &fstr);

  void printEdgeEnrichedFunctions(ostream &ostr);



  void printNodeEnrichments(//const MyAnnotations& annotations,
    ostream &fstr, const GeneOntology *goDag = NULL);


  void printItemset(ostream &ostr) const;


  void printNodeEnrichedFunctions(ostream &ostr);

  void printStatistics(ostream &ostr);

  void printStatisticsComponents(ostream &ostr);


#ifdef CTEMPLATE

  string printWWW(string wwwDirectory, string wwwParamsDirectory, string nodeURL,
                const map< string, set< string > > *nodeAliases);
#endif


  void expand(const GEData &expression, MyNT correlationThreshold, bool trivialExpand = true);

  void expand(ActiveNetwork &expanded, const GEData &expression, MyNT correlationThreshold)
    {
      expanded = *this;
      expanded.expand(expression, correlationThreshold);
    }

  void read(string anetString);


  void setEnrichedFunctionsByEdge(map< string, vector< string > > &efeMap)
    {
      _enrichedFunctionsByEdge = efeMap;
    }

  void setPerNodeEnrichedFunctions(map< MyNodeId, vector< string > > &efnMap)
    {
      _enrichedFunctionsByNode = efnMap;
    }


  void setNodeEnrichedFunctions(vector< EnrichmentRecord< string, string > > &efMap)
    {
      _nodeEnrichmentRecords = efMap;
    }


  void updateNodeEnrichmentsMap(map< string, map< string, MyNT > > &functionsToANs,
                                const GeneOntology *goDag = NULL);

};

struct NetworkLegoInActiveNetwork
{
public:
  // these need to be public for .
  string _nlId;
  string _anId;
  MyNT _weight;

public:
  NetworkLegoInActiveNetwork(string nl, string an, MyNT w)
      : _nlId(nl), _anId(an), _weight(w)
    {}

  bool operator<(const NetworkLegoInActiveNetwork &other) const
    {
      if (_nlId != other._nlId)
        return(_nlId < other._nlId);
      else if (_anId != other._anId)
        return(_anId < other._anId);
      else
        return(_weight < other._weight);
    }


};

struct nlid_anid_index {};
struct nlid_index {};
struct anid_index {};

typedef multi_index_container<
  NetworkLegoInActiveNetwork,
  indexed_by<

    // define multi-column primary key. There can be only one instance
    // of any (network lego, active network) pair.
    ordered_unique<
    tag< nlid_anid_index >,
    composite_key<
      NetworkLegoInActiveNetwork,
      member< NetworkLegoInActiveNetwork, string, &NetworkLegoInActiveNetwork::_nlId>,
      member< NetworkLegoInActiveNetwork, string, &NetworkLegoInActiveNetwork::_anId>
      >
    >,

    // sort by less<string> on _nlId
    ordered_non_unique< tag< nlid_index >,
                        member< NetworkLegoInActiveNetwork, string,
                                &NetworkLegoInActiveNetwork::_nlId > >,

    // sort on _anId
    ordered_non_unique< tag< anid_index >,
                        member< NetworkLegoInActiveNetwork, string,
                                &NetworkLegoInActiveNetwork::_anId > >
    > // matches indexed_by
  > NetworkLegosInActiveNetworksMapping;



// forward declaration.
class SetOfNetworkLegos;


class SetOfActiveNetworks
{
  // WHAT AN UGLY HACK! without this,
  // SetOfNetworkLegos::computeStability() does not compile eventhough
  // SetOfNetworkLegos is a sub-class of SetOfActiveNetworks.
  friend class SetOfNetworkLegos;

protected:

  vector< ActiveNetwork > _anets;
  // for each active network id, store which index of _anets contains
  // that active network.
  map< string, unsigned int > _anetIdToIndex;
  ActiveNetwork _combinedAnet;

  map< MyEdge, MyNT > _edgeCentralities;
  map< MyNodeId, MyNT > _nodeCentralities;
  map< MyNodeId, vector< MyGraph * > > _nodeCounts;

public:

  SetOfActiveNetworks()
      : _anets(), _anetIdToIndex(), _combinedAnet(),
        _edgeCentralities(), _nodeCentralities(),
        _nodeCounts()
    {}

  virtual ~SetOfActiveNetworks()
    {}

  void add(ActiveNetwork &anet)
    {
//      _anets.insert(anet);
      _anets.push_back(anet);
      // update _anetIdToIndex.
      _anetIdToIndex[anet.getName()] = _anets.size() - 1;
    }

  void add(vector< ActiveNetwork >& nets)
    {
      unsigned int size = _anets.size();
      _anets.insert(_anets.end(), nets.begin(), nets.end());
      // update _anetIdToIndex.
      for (unsigned int i = size; i < _anets.size(); i++)
        _anetIdToIndex[_anets[i].getName()] = i;
    }

  void add(Itemset &itemset, unsigned int index)
    {
      _anets.push_back(ActiveNetwork(itemset, index));
      // update _anetIdToIndex.
      _anetIdToIndex[_anets.back().getName()] = _anets.size() - 1;
    }

  void add(vector< Itemset > &itemsets)
    {
      unsigned int index = 1;
      vector< Itemset >::iterator iitr;
      for (iitr = itemsets.begin(); iitr != itemsets.end(); iitr++)
        {
          _anets.push_back(ActiveNetwork(*iitr, index++));
          // update _anetIdToIndex.
          _anetIdToIndex[_anets.back().getName()] = _anets.size() - 1;
        }
    }

  void addCondition(string condition)
    {
      vector< ActiveNetwork >::iterator aitr;
      for (aitr = _anets.begin(); aitr != _anets.end(); aitr++)
        aitr->addCondition(condition);
    }

  virtual void compareNetworkLegosToActiveNetworks()
    {
      cerr << "SetOfActiveNetworks::compareNetworkLegosToActiveNetworks() should never be invoked. Hit the maintainer on the head until he/she fixes this awful bug." << endl;
      exit(-1);
    }

  void computeBinaryMatrix(vector< vector< unsigned int > > &binaryMatrix,
                           map< unsigned int, string > &rowNames,
                           map< unsigned int, string > &columnNames,
                           bool addComplements = false,
                           set< unsigned int > *complementRows = NULL);

  void computeEdgeBetweenessCentrality();

  void clearEdgeEnrichments();

  void computeEdgeEnrichments(const MyAnnotations &annotations);

  void computeEdgeSimilarityGraph(MyGraph &graph) const;


  void clearNodeEnrichments();


  void computeNodeWeights(const GEData &gedata);

  MyNT computeMostSimilarEdges(const MyGraph & other, unsigned int &bestIndex) const;

  MyNT computeMostSimilarNodes(const MyGraph & other, unsigned int &bestIndex) const;


//  void computeNetworkLegos();


  void computeNodeBetweenessCentrality();

  void computeNodeCounts();

  void computeNodeSimilarityGraph(MyGraph &graph) const;

  void computePvalues(const MyHistogram &histogram);


  void computeSNetwork();


  void computeUnion(string name, ActiveNetwork &unionActiveNetwork)
    {
      computeUnion(name);
      unionActiveNetwork = _combinedAnet;
    }
  void computeUnion(string name);

  void expand(const GEData &expression, string id,  MyNT correlationThreshold);


  vector< ActiveNetwork > getActiveNetworks()
    {
      return _anets;
    }


  void getUnion(ActiveNetwork &unionActiveNetwork)
    {
      unionActiveNetwork = _combinedAnet;
    }

  unsigned int getNumActiveNetworks() const
    {
      return(_anets.size());
    }

#ifdef CTEMPLATE





























  void layout(string directory, string wwwParamsDir,
              const MyAnnotations &annotations,
              const GeneOntology &go,
              string nodeUrl = "",
              const map< string, set< string > > *nodeAliases = NULL,
              MyGraph *superGraph = NULL,
              const map< string, set< string > > *layoutConstraints = NULL,
              const GEDataSets *geDataSets = NULL,
              const map< string, set< string > > *conditionGroups = NULL
              // const vector< GEData > *geData = NULL,
              // const map< string, unsigned int > *classToIndex = NULL
              );
#endif


  void printConditions(ostream &conditionStream);
  void printEdges(ostream &edgeStream);
  void printEdgeBetweenessCentrality(ostream &edgeCentralityStream);
  void printEdgesItemset(ostream &itemsetStream, string id);


  void printEdgeTypeCounts(ostream &edgeTypesCountStream);

  void printEdgeEnrichments(ostream &edgeEnrichmentStream,
                            ostream &edgeEnrichedFunctionStream);

  void printEdgeWeightsHistograms(ostream &edgeWeightsHistogramStream, string fileName);


  void printNodeEnrichments(ostream &nodeEnrichmentStream,
                            ostream &nodeEnrichedFunctionStream,
                            GeneOntology *go);

  void processNodeEnrichments(ostream &processNodeEnrichmentsStream, const GeneOntology *go);


  void printNodes(ostream &nodeStream);
  void printNodeBetweenessCentrality(ostream &nodeCentralityStream);

  void printNodeWeightsHistograms(ostream &nodeWeightsHistogramStream, string fileName);

  void printStatistics(ostream &statStream);

#ifdef CTEMPLATE

  void printWWW(string directory, string wwwParamsDir,
                string nodeUrl = "",
                const map< string, set< string > > *nodeAliases = NULL);
#endif

  void read(const vector< string > &activeNetworkFiles);

  void read(string activeNetworkFile);

  void readEdges(string edgesFile);

  virtual void readMappingFromNetworkLegosToActiveNetworks(string nlsToRNsFile)
    {
      cerr << "SetOfActiveNetworks::readMappingFromNetworkLegosToActiveNetworks() should never be invoked. Ask the maintainer to fix this awful bug." << endl;
      exit(-1);
    }


  void readNodeEnrichedFunctions(string nodeEnrichedFunctionsFile);

  void readNodeEnrichments(string nodeEnrichmentsFile);

  void readNodes(string nodesFile, MyGraph &superGraph);
};



#endif // _ACTIVE_NETWORKS_H