gain.h

/**************************************************************************
 * Copyright (c) 2001-2012 T. M. Murali                                   *
 * Copyright (c) 2006-2007, 2010-2012 David Badger                        *
 * Copyright (c) 2011-2012 Christopher L. Poirel                          *
 * Copyright (c) 2011 Phillip Whisenhunt                                  *
 * Copyright (c) 2010 Jacqueline Addesa                                   *
 *                                                                        *
 * 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/>.      *
 *                                                                        *
 **************************************************************************/

// Purpose: class declaration my MyGainGraph. this class exists
// solely to implement a gain network algorithm on a graph.


#ifndef _GAIN_H
#define _GAIN_H

#include <map>

#include "constants.h"
// Test for GCC >= 4.3. from http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html. See definition of GCC_VERSION macro in libutil/constants.h
#if GCC_VERSION > 40300
// see http://gcc.gnu.org/gcc-4.3/changes.html
#include <tr1/unordered_set>
#else
#include <ext/hash_map>
#endif


#include "boost/filesystem/path.hpp"
#include "boost/filesystem/operations.hpp" // includes boost/filesystem/path.hpp
#include "boost/filesystem/fstream.hpp"    // ditto

using namespace std;

#include "old-annotations.h"
#include "GO.h"
#include "gain-opts.h"
#include "gain-state.h"
#include "graph.h"
#include "point.h"
#include "reporter.h"

typedef MyGainAnnotationType MyGainOrfState;

enum MyGainUpdateType {GAIN_UPDATE_IMMEDIATE};

// the innermost map maps from the strings "annotated" and
// "negative" to the list of proteins that should be censored.
//
// the vector containing the innermost maps loops over the number of folds.
//
// the outermost map has keys that are the goids.

//typedef map< string, vector< map< string, vector< string > > > > MyGainFoldInfo;

typedef map< string, vector< vector< vector< string > > > > MyGainFoldInfo;

// the innermost map maps from the MyGainAnnotationType
// (ANNOTATED_STATE and NOT_ANNOTATED_STATE) to the set of proteins
// that should be censored one by one
//
// the outermost map has keys that are the goids.
typedef map< string, map< MyGainAnnotationType, set< string > > > MyGainLOOCVInfo;

// various parameters controlling the Gain net.
struct MyGainParams
{
private:

  // all the options.
  gengetopt_args_info _options;

  // i slowly want to make all variables private.


  // --experiment-name. the name of the gene expression experiment.
  string _experimentName;

  // -f, --functions-file
  string _annotationsFile;

  // -g, --go-file
  string _goFile;

  // -G, --group-functions-method, the method by which to group functions.
  string _groupFunctionsMethodString;
  bool _groupFunctionsByDepth;
  bool _groupFunctionsByParent;


//  map< GOFunction*, MyHistogram > _functionEdgeProbabilities;
  map< BioFunction, MyHistogram > _functionEdgeProbabilities;

  // --hipr-directory
  string _hiprDirectory;


  // -i, --interactions-file. there can be multiple interaction files.
  vector< string > _flnFiles;

  //  --integrate. type of data integration.
  string _dataIntegrationType;

  // --maximum-go-depth.
  unsigned int _maximumGoDepth;

  // --minimum-go-depth.
  unsigned int _minimumGoDepth;

  // --maximum-annotated-genes.
  unsigned int _maximumAnnotatedGenes;

  // --minimum-annotated-genes.
  unsigned int _minimumAnnotatedGenes;

  // --num-rounds
  unsigned int _numRounds;


  // --number-runs
  unsigned int _numRuns;

  // --only-category
  set< string > _onlyFunctionCategories;

  // --only-functions
  string _onlyFunctionsFile;

  // -- original-annotations. are the GO annotations transitively closed? no, if this variable is true.
  bool _originalAnnotations;

  // --output-directory
  string _outputDirectory;

  string _outputFilePrefix;

  // --ova
  set< string > _ovaAlgorithms;

  // --ovn
  set< string > _ovnAlgorithms;

  // --predictions-file
  string _predictionsFile;


  // SVM related options.
  string _libSVMDirectory, _SVMLightDirectory;
  string _libSVMTrainOptions, _libSVMTestOptions,
    _SVMLightTrainOptions,_SVMLightTestOptions;


  // --treewidth.
  bool _computeTreewidth;

  // --validate
  string _validationAnnotationsFile;


public:
  // streams.

  // print CV results here.
  ofstream cvStream;
  ofstream ecwCVStream;
  // print detailed CV results here.
  ofstream detailedCVStream;
  // the weights of the edges in an FLN.
  ofstream edgeWeightsStream;

  // universe of genes for which i can make predictions. this file is
  // useful in eval-gain.
  ofstream geneUniverseStream;

  // CV results per depth/cutoff/etc.
  ofstream groupedCVStream;
  ofstream groupedEcwCVStream;

  // invocation information.
  ofstream invocationStream;

  // generic information.
  ofstream logStream;
  // print predictions here.
  ofstream predictionsStream;

  // where are the propagation diagrams?
  ofstream propagationDiagramsStream;

  // results of the sanity check.
  ofstream sanityCheckStream;

  // various stats about predictions.
  ofstream statsStream;

  // a convenience variable to simplify the code for opening and
  // closing all the above streams.
  map< string, ofstream* > outputStreams;
  // the name of the file to dump the invocation to. I need the file
  // name rather than the ofstream because of the way
  // cmdline_parser_file_save() works.
  string _invocationFile;



  // if false, the state of a node be ANNOTATED_STATE or
  // NOT_ANNOTATED_STATE. if true, HYPOTHETICAL_STATE is also ok.
  bool allowZeroStates;
  // value that determines that state a node. if the input to the node
  // is < gainThreshold, the node is in NOT_ANNOTATED_STATE. if
  // the input is > gainThreshold, the node is in ANNOTATED_STATE.
  // if the input = gainThreshold, then the node could be in
  // ANNOTATED_STATE or HYPOTHETICAL_STATE. the computeState()
  // function says what i do.
  MyNT gainThreshold;
  // did the user provide this on the command line?
  bool gainThresholdUserInput;
  // did the user provide this on the command line?
  bool gainThresholdRangeUserInput;

  // name of the file containing gene expression data.
  string geneExpressionFile;

  // stuff to ignore.
  set< string > ignoredThings, ignoredEvidenceCodes;



  // use GE correlations directly as edge weights.
  bool justUseCorrelations;


  // should i update a node as soon as i realise its state has changed
  // or wait till i have gone over all the iterations and pick the
  // best node or a random one to change the state of.
  MyGainUpdateType updateType;
  // divide the input to a node by its degree.
  bool useDegree;
  // what maximum distance should be a node be to be considered a neighbour?
  unsigned int localRuleDistance;

  // compute p-values for the functional assignments. currently (apr
  // 23, 2004), do so by random assignments.
  bool computePvalues;


  // check to see if there is propagation in the gain net. print
  // some output to indicate so.
  bool checkPropagation;
  // it is useful to store whether i am cross-validating or not. for
  // example, i use this info to control some printing in
  // MyGainGraph::runGainNet().
  bool crossValidate;

  // file that contains cross-validation info.
  string crossValidationFile;
  // variables to store info in crossValidationFile.

  // am i doing leave-one-out cross-validation? true iff fracCrossValidate is 0.
  bool leaveOneOutCrossValidate;


  // fraction of nodes to cross validate for each function. this
  // parameter is set when i do not want to do leave-one-out
  // cross-validation.
//  float fracCrossValidate;

  // the number of nodes to cross validate for each function.
//  unsigned
  int foldCrossValidate;
  MyGainFoldInfo foldInfo;
  MyGainLOOCVInfo loocvInfo;


  // not based on a command-line parameter. this variable is a sneaky way of passing the frequency of the "current" function from one method to another.
  MyNT functionFrequency;

  bool printAllStates;

  // allows the state of +1 nodes to change.
  bool unclampPositives;
  // allows the state of -1 nodes to change.
  bool unclampNegatives;

  // allows the frequency of the function to influence the weight of a +1 or -1 node
  bool useStateWeights;


  // creates files for visualisation.
  bool visualisePredictions;
  bool visualiseCrossValidation;
  bool visualiseCut;

  // forces GAIN to do only predictions or only cross-validation
  bool onlyPredictions;
  bool onlyCrossVal;

  bool weightEdgeTypesCutoff;
  string cutoffsFile;
  bool weightEdgeTypesDepth;
  bool weightEdgeTypesJaccard;

  bool groupEdgeTypes;
  string edgeTypeGroupsFile;
  bool useCustomRNGSeed;
  int customRNGSeed;

  string edgeWeightingScheme;

public:
  MyGainParams();

  virtual ~MyGainParams()
    {}

  string getAnnotationsFile() const
    {
      return(_annotationsFile);
    }

  // --no-true-path-rule-downward
  bool getApplyTruePathRuleDownward() const
    {
      // the option is true if the true path rule should NOT be applied downward.
      return(!_options.no_true_path_rule_downward_given);
    }

  string getGOFile() const
    {
      return(_goFile);
    }

  vector< string > getFLNFiles() const
    {
      return(_flnFiles);
    }




  string getDataIntegrationType() const
    {
      return(_dataIntegrationType);
    }


  unsigned int getMaximumGoDepth() const
    {
      return(_maximumGoDepth);
    }

  unsigned int getMinimumGoDepth() const
    {
      return(_minimumGoDepth);
    }

  unsigned int getMaximumAnnotatedGenes() const
    {
      return(_maximumAnnotatedGenes);
    }

  unsigned int getMinimumAnnotatedGenes() const
    {
      return(_minimumAnnotatedGenes);
    }

  bool getDoNotReduce() const
    {
      return(runAnyOneVersusNoneAlgorithm() || _options.no_reduce_flag);
    }


  unsigned int getNumRounds() const
    {
      return(_numRounds);
    }

  unsigned int getNumRuns() const
    {
      return(_numRuns);
    }


  bool getAnnotationsAreOriginal() const
    {
      return(_originalAnnotations);
    }


  string getExperimentName() const
    {
      return(_experimentName);
    }

  // -G, --group-functions-method.
  void setGroupFunctionsMethod(string method)
    {
      _groupFunctionsMethodString = method;
      _groupFunctionsByParent = false;
      _groupFunctionsByDepth = false;
      if ("depth" == method)
        {
          _groupFunctionsByDepth = true;
        }
      else if ("parent" == method)
        {
          _groupFunctionsByParent = true;
        }
      else
        {
          cerr << "Unknown method \"" << method << "\" for grouping functions. Using the default method of grouping by depth." << endl;
          _groupFunctionsByDepth = true;
          _groupFunctionsMethodString = "depth";
        }
    }

  bool getGroupFunctionsMethodIsParent() const
    {
      return(_groupFunctionsByParent);
    }
  bool getGroupFunctionsMethodIsDepth() const
    {
      return(_groupFunctionsByDepth);
    }

  string getGroupFunctionsMethod() const
    {
      return(_groupFunctionsMethodString);
    }

  //  void setFunctionEdgeProbabilities(const map< GOFunction*, MyHistogram > &hists)
  void setFunctionEdgeProbabilities(const map< BioFunction, MyHistogram > &hists)
    {
      _functionEdgeProbabilities = hists;
    }

  // --hipr-directory

  // --min-confidence
  MyNT getMinimumConfidence() const
    {
      return(_options.min_confidence_arg);
    }

  MyNT getOneVersusNoneSinkSourceArtificialEdgeWeight() const
    {
      return(_options.ovn_sinksource_edge_weight_arg);
    }


  // --only-category

  bool processCategory(string cat) const
    {
      return((0 == _onlyFunctionCategories.size())
             || (_onlyFunctionCategories.end() != _onlyFunctionCategories.find(cat)));
    }

  // --output-directory

  string getOutputDirectory() const
    {
      return(_outputDirectory);
    }
  
  string getOutputFileName(string name, string dir = "") const;

  const set< string > *getEvidenceCodesToIgnore() const
    {
      return(&ignoredEvidenceCodes);
    }

  void printInvocation();

  bool getPrintDetailedCVResults() const
    {
      return(_options.detailed_cross_validation_results_given);
    }

  bool getRunGraphviz() const
    {
      return(!_options.no_graphviz_given);
    }

  bool getPerformSanityCheck() const
    {
      return(_options.sanity_check_given);
    }




  string getVisualiseParamsFile() const
    {
      if (_options.visualise_params_file_given)
        return(_options.visualise_params_file_arg);
      // the default is to assume a file called "params.txt" in the current directory.
      return("params.txt");
    }

  int getNumPredictionsToPrintPerFunction() const
    {
      return(_options.num_print_predictions_arg);
    }

  bool runAnyOneVersusNoneAlgorithm() const;

  bool runOneVersusAllAlgorithm(string algorithm) const;

  bool runOneVersusNoneAlgorithm(string algorithm) const;


  string getPredictionsFile() const
    {
      return(_predictionsFile);
    }


  string getValidationAnnotationsFile() const
    {
      return(_validationAnnotationsFile);

    }

  // SVM related options.

  string getLibSVMDirectory() const
    {
      return(_libSVMDirectory);
    }

  string getSVMLightDirectory() const
    {
      return(_SVMLightDirectory);
    }

  string getLibSVMTrainOptions() const
    {
      return(_libSVMTrainOptions);
    }

  string getLibSVMTestOptions() const
    {
      return(_libSVMTestOptions);
    }

  string getSVMLightTrainOptions() const
    {
      return(_SVMLightTrainOptions);
    }

  string getSVMLightTestOptions() const
    {
      return(_SVMLightTestOptions);
    }

  // --treewidth.
  bool getComputeTreewidth() const
    {
      return(_computeTreewidth);
    }

  // --weight-evidence-codes
  bool getWeightEvidenceCodes() const
    {
      return(NULL != _options.weight_evidence_codes_arg);
    }

  string getEvidenceCodeWeightsFile() const
    {
      return(_options.weight_evidence_codes_arg);
    }

  void setParameters(gengetopt_args_info &gainOptions);


private:
  void _openOutputFiles();

};


struct MyGainOrf
{

private:

  // what is the distinction between all these states? realState is
  // the *real* state of the orf. it will never change. initialState
  // is the initial state of the orf, at the beginning of
  // runGainNet(). for hypothetical proteins, realState always
  // equals initialState. the equality holds for all other proteins
  // too, except for those that are being cross-validated. for them
  // initialState will be HYPOTHETICAL_STATE. currentState is the
  // current state in runGainNet() and previousState is the
  // previous value of currentState (the value before currentState
  // changed or the value of initialState).

public:

  void print(ostream &ostr) const;

};

typedef  map< MyNodeId, MyGainStateInfo< MyGainState< MyGainTriStateType > > > MyNodeStatesType;

// tell doxygen to skip
struct annotationtype_category_group_interactiontype_weight_index{};
template< typename GroupType > struct SetOfEdgeTypeWeights
{
        public:

                struct MyEdgeTypeWeight
                {
                        public:

                                string annotationType; // description of annotation set used to calculate weight
                                string category;
                                GroupType group; // e.g. depth/cutoff value
                                string interactionType;
                                MyNT weight;

                                MyEdgeTypeWeight(string annotationType, string category, GroupType group, string interactionType, MyNT weight)
                                        : annotationType(annotationType), category(category), group(group), interactionType(interactionType), weight(weight) {}
                };

                typedef multi_index_container
                <
                        MyEdgeTypeWeight,
                        indexed_by
                        <
                                ordered_unique
                                <
                                        tag< annotationtype_category_group_interactiontype_weight_index >,
                                        composite_key
                                        <
                                                MyEdgeTypeWeight,
                                                member< MyEdgeTypeWeight, string, &MyEdgeTypeWeight::annotationType >,
                                                member< MyEdgeTypeWeight, string, &MyEdgeTypeWeight::category >,
                                                member< MyEdgeTypeWeight, GroupType, &MyEdgeTypeWeight::group >,
                                                member< MyEdgeTypeWeight, string, &MyEdgeTypeWeight::interactionType >,
                                                member< MyEdgeTypeWeight, MyNT, &MyEdgeTypeWeight::weight >
                                        >
                                >
                        >
                > type;
};

// tell doxygen to skip
struct annotationtype_category_group_nodeid_index{};
template< typename GroupType > struct SetOfGroupedNodes
{
        public:

                struct MyGroupedNode
                {
                        public:

                                string annotationType; // description of annotation set used to calculate weight
                                string category;
                                GroupType group; // e.g. depth/cutoff value
                                string nodeId;

                                MyGroupedNode(string annotationType, string category, GroupType group, string nodeId)
                                        : annotationType(annotationType), category(category), group(group), nodeId(nodeId) {}
                };

                typedef multi_index_container
                <
                        MyGroupedNode,
                        indexed_by
                        <
                                ordered_unique
                                <
                                        tag< annotationtype_category_group_nodeid_index >,
                                        composite_key
                                        <
                                                MyGroupedNode,
                                                member< MyGroupedNode, string, &MyGroupedNode::annotationType >,
                                                member< MyGroupedNode, string, &MyGroupedNode::category >,
                                                member< MyGroupedNode, GroupType, &MyGroupedNode::group >,
                                                member< MyGroupedNode, string, &MyGroupedNode::nodeId >
                                        >
                                >
                        >
                > type;
};





class MyGainGraph : public MyGraph
{
public:
  // typedefs. i guess typedefs are not inherited.
//   typedef MyGraph::MyConstNodeIterator MyConstNodeIterator;
//   typedef MyGraph::MyConstEdgeIterator MyConstEdgeIterator;


  // i don't think i need this right now, at least not until MyGainNode is fully defined.
//  typedef MyGainNode Node;

  MyGainGraph()
      : MyGraph(), useDegree(false), _minThreshold(0), _maxThreshold(0), _threshold(0),
        _calculated_threshold(false), _reporter()
    {}

  MyGainGraph(string infile, string type, string outputDir, string commandLine, MyNT minEdgeWeight = 0)
      : MyGraph(infile, type, minEdgeWeight),
        useDegree(false), _minThreshold(0), _maxThreshold(0), _threshold(0),
        _calculated_threshold(false), _reporter(outputDir, commandLine)
    {}


  virtual ~MyGainGraph()
    {}

  // set and get for whether i should use degree in calculating
  // energies or not.
  void setUseDegree(bool ud)
    {
      useDegree = ud;
         setNodeWeights();
    }

  void resetThreshold() {
          this->_calculated_threshold=false;
  }

  // set the weights of the nodes based on their degrees.
  void setNodeWeights();

//  void assignInitialStates(MyProteinFunctionType &proteinFunctions,

  // for each state, count the #nodes in *this annotated with that state.

  // params is not const because the propagationDiagramsStream in it will get output.

  // print the neighbourhood of a node. states cannot be const because i
  // need to access states using the [] operator.
//  void printNeighbours(ostream &ostr,  MyNodeStatesType &states, const MyNode &node);
  // not using const MyNode& node because of problems with MyNode::ConstIncidentEdgeIterator

  // can't be const because i add info to reporter stored in *this.
  unsigned int printStates(ofstream &ostr,  const MyNodeStatesType &states,
                   string currentFunc, string algorithm = "Hopfield",
                   bool printAll = false);


  void reduce2(ostream &hopstr, map< MyNodeId, MyGainTriStateType > &nodeStates,
               const MyGainParams &params, MyGainGraph &reducedGraph,
               MyNodeIdSet &unpredictableNodes);

  // i know that all nodes in subgraph are either in state "state" or
  // HYPOTHETICAL_STATE. annotate all the corresponding nodes in *this
  // in HYPOTHETICAL_STATE with state "state."

  // perform some simple checks to see what the final states of the
  // some of the nodes will be.

//  template< typename InputFunction >


  // just set edge weights based on correlations in the gene expression data set.
  void setEdgeWeightsCorrelations(ostream &fstr, const MyPointSet &geData);


  // compute dense functions, i.e., functions whose annotated genes
  // induce dense subgraphs in the invocant.
  void computeDenseFunctions(ostream *fstr,
                             MyAnnotations &annotations,
                             GeneOntology &go,
                             map< string, MyGraph > &denseFunctionSubgraphs);

  // convert edge weights to probabilities based on p-value of each
  // edge's correlation in the histogram of all pairs of
  // correlations. return the mapping from edge weights to
  // probabilities in a histogram.
  void computeProbabilitiesFromEdgeWeights(ostream &fstr, const MyPointSet &geData,
                                           string experimentName,
                                           MyHistogram  &edgeWeightsToProbabilities);

  // for each group of functions with a depth, compute mapping from
  // correlations to probabilities of shared function.
  void computeEdgeProbabilitiesPerDepth(
    MyGainParams &params,
    const map< unsigned int, set< GOFunction * > > &functionsByDepth,
    MyAnnotations &annotations,
//    map< GOFunction*, MyHistogram > &probabilities
    map< BioFunction, MyHistogram > &probabilities
    );


  // For each group of functions with the same parent in the GO DAG,
  // convert edge weights to probabilities based on which edges have
  // both endpoints sharing a function. return the mapping from
  // edge weights to probabilities in a histogram.
  void computeEdgeProbabilitiesPerParent(MyGainParams &params, GeneOntology &go,
                                         MyAnnotations &annotations,
//                                         map< GOFunction*, MyHistogram > &probs);
                                         map< BioFunction, MyHistogram > &probs);

  // convert edge weights to probabilities based on which edges have
  // both endpoints sharing a function in functionVector. return the
  // mapping from edge weights to probabilities in a histogram.
  void computeProbabilitiesFromEdgeWeights(
    ostream &fstr,
    // no const because of MyAnnotations::haveSameFunction()
    //const
    MyAnnotations &annotations,
    const vector< BioFunction > *functionVector,
    MyHistogram  &edgeWeightsToProbabilities
    );

  // set edge weights based on mapping from correlations to
  // probabilities in edgeWeightsToProbabilities.
  void setEdgeWeights(ostream &fstr,
                      const MyHistogram  &edgeWeightsToProbabilities
                      );


  // compute the input to a node from its neighbours. the input is the
  // sum of weighted states of the node's neighbours.
  MyNT computeInput(string nodeId, MyNodeStatesType &nodeStates) const;
  // compute the maximum possible input to a node from its neighbours,
  // by assuming that each neighbour is annotated and the edge weight
  // is 1.
  // compute the maximum input to a node from its neighbours, by
  // assuming that each hypothetical neighbour is in ANNOTATED_STATE.
  // compute the minimum input to a node from its neighbours. just the
  // opposite of computeMaximumInput()
  // compute the output of a node from its neighbours. the output is the
  // sum of weighted states of the node's neighbours.
  // for each orf, compute the probability with which it is in the state.


  MyNT computeEnergy(MyNodeStatesType &nodeStates);
  MyNT computeChangeInEnergy(MyNodeStatesType &nodeStates,
                             string changedNodeId);

  // print the file in DIMACS format. see
  // ftp://dimacs.rutgers.edu/pub/netflow/general-info/specs.tex for
  // the specifications.
  //
  // not making the method const because of a problem with MyNode::ConstEdgeIterator.
  void printDimacs(string filename, MyNodeStatesType &nodeStates, string format);// const;
  void runMinCut(string outfile, MyNodeStatesType &nodeStates, const MyGainParams &params);
//  void explainCrossValidationResults(MyNodeStatesType &states);


  // i dont' think this method is used anywhere.
// methods related to reporting results.
  // void printResults(MyGainParams &gainParams) {
  //   if (!gainParams.onlyPredictions)
  //     // don't print (or overwrite) CV results if i only computed
  //     // predictions.
  //     {
  //       _reporter.printDetailedCVResults(gainParams.detailedCVStream);
#ifdef USE_CVRESULT
  //       _reporter.printCVResults(gainParams.cvStream);
#endif // USE_CVRESULT
  //     }

  //   if (!gainParams.onlyCrossVal)
  //     // don't print (or overwrite) predictions if i only computed CV
  //     // results.
  //     _reporter.printPredictions(gainParams.predictionsStream);
  // }



  // void addCV(string function, int tp, int tn, int fp, int fn,MyNT threshold,
  //            string algo) {
  //   _reporter.addCV(function,tp,tn,fp,fn,threshold, algo);
  // }

  // detailed CV info for a single gene/function pair

        void computeEdgeTypeWeightsByCutoffFromSharedFunctionRatio(MyAnnotations &annotations, GeneOntology &go, MyGainParams &gainParams);
        void computeEdgeTypeWeightsByDepthFromSharedFunctionRatio(MyAnnotations &annotations, GeneOntology &go, MyGainParams &gainParams);
        void computeEdgeTypeWeightsJaccard(ostream &logStream,  MyAnnotations &annotations);

        void assignEdgeWeightFromDepth(const MyGainParams &gainParams, string annotationType, string category, unsigned int depth, MyEdge &edge);

private:

  void _parseDimacsOutput(string filename, set< MyNodeId > &sinkSideNodes) const;
  void _setStates(MyNodeStatesType &nodeStates,
                  const set< MyNodeId > &sinkSideNodes) const;


private:

  // divide inputs and outputs by node degrees.
  bool useDegree;
  MyNT _minThreshold, _maxThreshold, _threshold;
  bool _calculated_threshold;

  Reporter _reporter;

  SetOfEdgeTypeWeights< unsigned int >::type _depthEdgeTypeWeights;
  SetOfGroupedNodes< unsigned int >::type _depthGroupedNodes;

};



#endif // _GAIN_H