[Beg-sysbiol] module code

18 Jun 2007

      Hi,

I'm sending you the adjusted module class (from my ENIGMA software), 
contains corrected code for module visualization (solved scrambling of 
data in separate leaves) as well as for eps figures, amongst others. The 
bayesian stuff is not in this class (results didn't make sense for my 
problem), so probably the best thing to do is to cut and paste relevant 
parts of the code in your code. Some other stuff that you might decide 
(not) to use: yellow-blue color scheme, condition labels, clustering of 
genes and/or conditions with cosine correlation coefficient, definition 
of extra leaf that groups all leaves with condition sets smaller than 3, 
which are excluded from the regulation program (too few datapoints to 
determine sensible regulators), prioritization of potential regulators 
based on whether their binding site is overrepresented in the module 
(provided you have chip data), extra visualization of overrepresented 
TFs, overrepresented GO categories and links to other modules. It is 
very possible that for some of this stuff to work, you need adjustments 
in other classes. Ask me to send them to you, or wait till the ENIGMA 
code is released (1 week). Don't trust the calculatePCCmap() function, 
there might be something wrong with it.

Best,

Steven

-- 
==================================================================
Steven Maere, PhD

Dept. of Plant Systems Biology
Bioinformatics & Evolutionary Genomics research group
VIB / Ghent University
Technologiepark 927
B-9052 Gent	BELGIUM
tel: +32 9 331 3810
fax: +32 9 331 3809
email: stmae@psb.UGent.be
http://www.psb.UGent.be
http://bioinformatics.psb.ugent.be/
==================================================================

/*

 ENIGMA - Expression Network Inference and Gene Module Analysis
 Copyright (C) 2007 Flanders Interuniversitary Intsitute for Biotechnology (VIB)

 This source code is freely distributed under the terms of the
 GNU General Public License. See the files COPYRIGHT and LICENSE
 for details.

 Written by Steven Maere

 */

/*

 LeMoNe - a software to build module networks from expression data 
 Copyright (C) 2005-2006 Flanders Interuniversitary Intsitute for Biotechnology (VIB)

 This source code is freely distributed under the terms of the
 GNU General Public License. See the files COPYRIGHT and LICENSE
 for details.

 Written by Eric Bonnet, Steven Maere, Tom Michoel, Yvan Saeys

 */

package enigma;

import java.util.*;
import java.util.List;
import java.io.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.font.*;
import java.awt.geom.*;
import javax.imageio.*;
import javax.swing.*;
import net.sf.epsgraphics.*;
import cern.jet.stat.*;
import cern.colt.list.*;
import cytoscape.data.annotation.OntologyTerm;

public class Module extends JComponent {

	// FIELDS

	public ModuleNetwork moduleNetwork;

	public int number;

	public String name;

	public HashSet<Gene> Parents = new HashSet<Gene>();

	public HashSet<Gene> Genes = new HashSet<Gene>();
        public ArrayList<Gene> ordenedGenes = new ArrayList<Gene>();
        public HashMap<Gene,Double> TFs = new HashMap<Gene,Double>();
        public LinkedHashMap<OntologyTerm,Double> GO = new LinkedHashMap<OntologyTerm,Double>();
        public HashMap<Condition,Double> Conditions = new HashMap<Condition,Double>();
        public ArrayList<Condition> nonTreeConditions = new ArrayList<Condition>();
        public HashMap<Integer,Condition> numberedConditions = new HashMap<Integer,Condition>();        
	public TreeNode regressionTree; // root node; this is the regulation program
	public TreeNode rightmostNode; // rightmost leaf node (for attaching gene labels in module picture)
        public LinkedHashSet<Module> modLinks = new LinkedHashSet<Module>();
        public HashMap<Gene,HashMap<Gene,Double>> distMap;
        public HashMap<Condition,HashMap<Condition,Double>> condDistMap;        
	public BingoResults bingoResults ;
        public boolean dist = true; //true to use distances to compare genes, false to use correlations

	// CONSTRUCTOR

	public Module() {               
	}

	public Module(int number) {
		this.number = number;
		this.regressionTree = new TreeNode();
	}

        public Module(String name, int number, HashSet Genes){
            this.name = name;
            this.number = number;
            for(Object j: Genes){
                this.Genes.add((Gene) j);
                this.ordenedGenes.add((Gene) j);
            }       
        }

	// METHODS

	/*
	 * This builds a full hierarchical clustering tree of the data in the
	 * module, which can then be converted in a regulation program tree.
	 * 
	 * Usage of TreeNode and LeafDistribution is somewhat different than for
	 * regressionTree: - testGene and splitValue are not set on internal nodes -
	 * internal nodes have a LeafDistribution as well, containing the statistics
	 * of all leaves (=experiments) below it. The data given as input is the
	 * full data matrix, but condSet may limit the set of experiments to be
	 * clustered
	 */

        public void addGene(Gene g){
            Genes.add(g);
            ordenedGenes.add(g);
        }

        public TreeNode avLinkHierarchicalClustering(TreeNode t) {
            if(!t.nodeStatus.equals("leaf")){    
                TreeNode bestTree = new TreeNode();
                //calculateCondEuclDistMap();
                calculateCondCosineCorMap();

                // initialize treeList with the leaves of t
                ArrayList<TreeNode> treeList = new ArrayList<TreeNode>();
                ArrayList<TreeNode> tmp = new ArrayList<TreeNode>();
                t.gatherLeafList(treeList);
                t.gatherLeafList(tmp);

                //remove leafs with less than 3 conditions and put them aside...
                for(TreeNode tr: tmp){
                    if(tr.leafDistribution.condSet.size() < 3){
                        treeList.remove(tr);
                        for(Integer c: tr.leafDistribution.condSet){
                            nonTreeConditions.add(numberedConditions.get(c));
                        }
                    }
                }
		ArrayList<TreeNode> pairTreeList = new ArrayList<TreeNode>();

                if(treeList.size() > 1){
                    // initialize list of pairwise merges
                    for (int i = 0; i < treeList.size(); i++){
                            for (int j = 0; j < i; j++) {
                                    TreeNode tree = new TreeNode();
                                    tree.nodeStatus = "internal";
                                    tree.compareMeans = 2;
                                    tree.leftChild = treeList.get(i);
                                    tree.rightChild = treeList.get(j);
                                    tree.module = this;
                                    for (int s = 0; s < 3; s++){
                                            tree.leafDistribution.statistics[s] = treeList.get(i).leafDistribution.statistics[s]
                                                            + treeList.get(j).leafDistribution.statistics[s];
                                    }
                                    for (int c : tree.leftChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    for (int c : tree.rightChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    pairTreeList.add(tree);
                            }
                    }
                    // merge trees in treeList until one tree is left
                    boolean keep;
                    int cnt;
                    bestTree = new TreeNode();
                    while (treeList.size() > 1) {
                            // find the optimal pair tree
                            bestTree = Collections.min(pairTreeList);

                            // remove children of bestTree from treeList; bestTree will be added at the end
                            treeList.remove(bestTree.leftChild);
                            treeList.remove(bestTree.rightChild);
                            // loop over the pair list and remove trees whose condSet intersects
                            // with the condSet of the highest scoring tree, including the highest one
                            // itself
                            Iterator<TreeNode> it = pairTreeList.iterator();
                            while (it.hasNext()) {
                                    TreeNode tree = it.next();
                                    keep = true;
                                    cnt = 0;
                                    while (keep & cnt < tree.leafDistribution.condSet.size()) {
                                            if (bestTree.leafDistribution.condSet.contains(tree.leafDistribution.condSet.get(cnt))){
                                                    keep = false;
                                            }        
                                            cnt++;
                                    }
                                    if (!keep){
                                            it.remove();
                                    }        
                            }
                            // add new trees which merge the bestTree with the other trees in
                            // treeList;
                            Iterator<TreeNode> it2 = treeList.iterator();
                            while (it2.hasNext()) {
                                    TreeNode ittree = it2.next();
                                    TreeNode tree = new TreeNode();
                                    tree.nodeStatus = "internal";
                                    tree.compareMeans = 2;
                                    tree.leftChild = ittree;
                                    tree.rightChild = bestTree;
                                    tree.module = this;
                                    for (int s = 0; s < 3; s++){
                                            tree.leafDistribution.statistics[s] = tree.leftChild.leafDistribution.statistics[s]
                                                            + tree.rightChild.leafDistribution.statistics[s];
                                    }        
                                    for (Integer c : tree.leftChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    for (Integer c : bestTree.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    pairTreeList.add(tree);
                            }
                            // add bestTree again to treeList
                            treeList.add(bestTree);
                            // set bestTree as parent of its children
                            bestTree.leftChild.parentNode = bestTree;
                            bestTree.rightChild.parentNode = bestTree;
                    }
                }
                else{
                    //no internal nodes, make one leaf node
                    bestTree = new TreeNode();
                    for(TreeNode tr: treeList){
                        bestTree.leafDistribution.condSet.addAll(tr.leafDistribution.condSet);
                    }
                    for(Condition c: this.nonTreeConditions){
                        bestTree.leafDistribution.condSet.add(c.number);
                    }                    
                    bestTree.statistics(this.moduleNetwork.data,this.Genes);
                    bestTree.module = this;
                }
		// 1 tree left, this is the one
		return bestTree;
            }
            else{
                return t;
            }
	}

        //means-based average linkage hierachical clustering of conditions

        public TreeNode meansAvLinkHierarchicalClustering(TreeNode t) {
            if(!t.nodeStatus.equals("leaf")){
                TreeNode bestTree = new TreeNode();

                // initialize treeList with the leaves inferred from hierarchical clustering
                ArrayList<TreeNode> treeList = new ArrayList<TreeNode>();
                ArrayList<TreeNode> tmp = new ArrayList<TreeNode>();
                t.gatherLeafList(treeList);
                t.gatherLeafList(tmp);

                //remove leafs with less than 3 conditions and put them aside...
                for(TreeNode tr: tmp){
                    if(tr.leafDistribution.condSet.size() < 3){
                        treeList.remove(tr);
                        for(Integer c: tr.leafDistribution.condSet){
                            nonTreeConditions.add(numberedConditions.get(c));
                        }
                    }
                }
                ArrayList<TreeNode> pairTreeList = new ArrayList<TreeNode>();

                if(treeList.size() > 1){
                    // initialize list of pairwise merges
                    for (int i = 0; i < treeList.size(); i++){
                            for (int j = 0; j < i; j++) {
                                    TreeNode tree = new TreeNode();
                                    tree.nodeStatus = "internal";
                                    tree.compareMeans = 1;
                                    tree.leftChild = treeList.get(i);
                                    tree.rightChild = treeList.get(j);
                                    for (int s = 0; s < 3; s++){
                                            tree.leafDistribution.statistics[s] = treeList.get(i).leafDistribution.statistics[s]
                                                            + treeList.get(j).leafDistribution.statistics[s];
                                    }
                                    //tree.leafDistribution.bayesianScore();
                                    for (int c : tree.leftChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    for (int c : tree.rightChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    //tree.leafDistribution.bayesianScore();
                                    pairTreeList.add(tree);
                            }
                    }
                    // merge trees in treeList until one tree is left
                    boolean keep;
                    int cnt;

                    while (treeList.size() > 1) {
                            // find the pair tree with the smallest difference in mean expression (compareMeans = true)
                            bestTree = Collections.min(pairTreeList);

                            // remove children of bestTree from treeList; bestTree will be added at the end
                            treeList.remove(bestTree.leftChild);
                            treeList.remove(bestTree.rightChild);
                            // loop over the pair list and remove trees whose condSet intersects
                            // with the condSet of the highest scoring tree, including the highest one
                            // itself
                            Iterator<TreeNode> it = pairTreeList.iterator();
                            while (it.hasNext()) {
                                    TreeNode tree = it.next();
                                    keep = true;
                                    cnt = 0;
                                    while (keep & cnt < tree.leafDistribution.condSet.size()) {
                                            if (bestTree.leafDistribution.condSet
                                                            .contains(tree.leafDistribution.condSet.get(cnt)))
                                                    keep = false;
                                            cnt++;
                                    }
                                    if (!keep)
                                            it.remove();
                            }
                            // add new trees which merge the bestTree with the other trees in
                            // treeList;
                            Iterator<TreeNode> it2 = treeList.iterator();
                            while (it2.hasNext()) {
                                    TreeNode ittree = it2.next();
                                    TreeNode tree = new TreeNode();
                                    tree.nodeStatus = "internal";
                                    tree.compareMeans = 1;
                                    tree.leftChild = ittree;
                                    tree.rightChild = bestTree;
                                    for (int s = 0; s < 3; s++){
                                            tree.leafDistribution.statistics[s] = tree.leftChild.leafDistribution.statistics[s]
                                                            + tree.rightChild.leafDistribution.statistics[s];
                                    }        
                                    //tree.leafDistribution.bayesianScore();
                                    for (Integer c : tree.leftChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    for (Integer c : bestTree.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    //tree.leafDistribution.bayesianScore();
                                    pairTreeList.add(tree);
                            }
                            // add bestTree again to treeList
                            treeList.add(bestTree);
                            // set bestTree as parent of its children
                            bestTree.leftChild.parentNode = bestTree;
                            bestTree.rightChild.parentNode = bestTree;
                            // System.out.println(bestTree.postProb);
                    }
                }
                else{
                    //no internal nodes, make one leaf node
                    bestTree = new TreeNode();
                    for(TreeNode tr: treeList){
                        bestTree.leafDistribution.condSet.addAll(tr.leafDistribution.condSet);
                    }
                    for(Condition c: this.nonTreeConditions){
                        bestTree.leafDistribution.condSet.add(c.number);
                    }                    
                    bestTree.statistics(this.moduleNetwork.data,this.Genes);
                    bestTree.module = this;
                }
                    // 1 tree left, this is the one
                return bestTree;
            }
            else{
                return t;
            }
	}

        public TreeNode avLinkHierarchicalClustering(ArrayList<Integer> condSet, double data[][]) {

                if(condSet.size() > 1){
                    //calculateCondEuclDistMap();
                    calculateCondCosineCorMap();

                    ArrayList<TreeNode> treeList = new ArrayList<TreeNode>();
                    // initialize treeList with just the bare leaves
                    for (int i : condSet) {
                            TreeNode tree = new TreeNode();
                            tree.nodeStatus = "leaf";
                            tree.module = this;
                            tree.leafDistribution.condSet.add(i);
                            for (Gene gene : this.Genes)
                                    if (!Double.isNaN(data[gene.number][i])) {
                                            tree.leafDistribution.statistics[0]++;
                                            tree.leafDistribution.statistics[1] += data[gene.number][i];
                                            tree.leafDistribution.statistics[2] += Math.pow(data[gene.number][i], 2);
                                    }
                            treeList.add(tree);
                    }
                    ArrayList<TreeNode> pairTreeList = new ArrayList<TreeNode>();

                    // initialize list of pairwise merges
                    for (int i = 0; i < treeList.size(); i++){
                            for (int j = 0; j < i; j++) {
                                    TreeNode tree = new TreeNode();
                                    tree.nodeStatus = "internal";
                                    tree.compareMeans = 2;
                                    tree.leftChild = treeList.get(i);
                                    tree.rightChild = treeList.get(j);
                                    tree.module = this;
                                    for (int s = 0; s < 3; s++){
                                            tree.leafDistribution.statistics[s] = treeList.get(i).leafDistribution.statistics[s]
                                                            + treeList.get(j).leafDistribution.statistics[s];
                                    }
                                    for (int c : tree.leftChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    for (int c : tree.rightChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    pairTreeList.add(tree);
                            }
                    }
                    // merge trees in treeList until one tree is left
                    boolean keep;
                    int cnt;
                    TreeNode bestTree = new TreeNode();
                    while (treeList.size() > 1) {
                            // find the optimal pair tree
                            bestTree = Collections.min(pairTreeList);

                            // remove children of bestTree from treeList; bestTree will be added at the end
                            treeList.remove(bestTree.leftChild);
                            treeList.remove(bestTree.rightChild);
                            // loop over the pair list and remove trees whose condSet intersects
                            // with the condSet of the highest scoring tree, including the highest one
                            // itself
                            Iterator<TreeNode> it = pairTreeList.iterator();
                            while (it.hasNext()) {
                                    TreeNode tree = it.next();
                                    keep = true;
                                    cnt = 0;
                                    while (keep & cnt < tree.leafDistribution.condSet.size()) {
                                            if (bestTree.leafDistribution.condSet.contains(tree.leafDistribution.condSet.get(cnt))){
                                                    keep = false;
                                            }        
                                            cnt++;
                                    }
                                    if (!keep){
                                            it.remove();
                                    }        
                            }
                            // add new trees which merge the bestTree with the other trees in
                            // treeList;
                            Iterator<TreeNode> it2 = treeList.iterator();
                            while (it2.hasNext()) {
                                    TreeNode ittree = it2.next();
                                    TreeNode tree = new TreeNode();
                                    tree.nodeStatus = "internal";
                                    tree.compareMeans = 2;
                                    tree.leftChild = ittree;
                                    tree.rightChild = bestTree;
                                    tree.module = this;
                                    for (int s = 0; s < 3; s++){
                                            tree.leafDistribution.statistics[s] = tree.leftChild.leafDistribution.statistics[s]
                                                            + tree.rightChild.leafDistribution.statistics[s];
                                    }        
                                    for (Integer c : tree.leftChild.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    for (Integer c : bestTree.leafDistribution.condSet)
                                            tree.leafDistribution.condSet.add(c);
                                    pairTreeList.add(tree);
                            }
                            // add bestTree again to treeList
                            treeList.add(bestTree);
                            // set bestTree as parent of its children
                            bestTree.leftChild.parentNode = bestTree;
                            bestTree.rightChild.parentNode = bestTree;
                    }
                    // 1 tree left, this is the one
                    return bestTree;
                }
                else{
                    //tree with a single leaf
                    TreeNode bestTree = new TreeNode() ;
                    bestTree.nodeStatus = "leaf";
                    bestTree.module = this;
                    for(Integer i:condSet){
                        bestTree.leafDistribution.condSet.add(i);
                        for (Gene gene : this.Genes){
                                if (!Double.isNaN(data[gene.number][i])) {
                                        bestTree.leafDistribution.statistics[0]++;
                                        bestTree.leafDistribution.statistics[1] += data[gene.number][i];
                                        bestTree.leafDistribution.statistics[2] += Math.pow(data[gene.number][i], 2);
                                }
                        }
                    }
                    return bestTree;
                }
	}

        public void calculatePCCmap(){

            this.dist = false;
            distMap = new HashMap<Gene,HashMap<Gene,Double>>();

            for(Gene t1:this.Genes){
                for(Gene t2:this.Genes){
                    double[] exp1 = new double[this.Conditions.size()];
                    double[] exp2 = new double[this.Conditions.size()];
                    int count = 0 ;
                    for(int i=0; i < this.moduleNetwork.data[t1.number].length;i++){
                        if (this.numberedConditions.keySet().contains(i)){
                            exp1[count] = this.moduleNetwork.data[t1.number][i];
                            exp2[count] = this.moduleNetwork.data[t2.number][i];       
                            count++;
                        }
                    }
                    DoubleArrayList a1 = new DoubleArrayList(exp1);
                    DoubleArrayList a2 = new DoubleArrayList(exp2);
                    double v1;
                    double v2;
                    if(a1.size() > 1){
                        v1 = cern.jet.stat.Descriptive.sampleStandardDeviation(a1.size(), cern.jet.stat.Descriptive.sampleVariance(a1,cern.jet.stat.Descriptive.mean(a1)));
                        v2 = cern.jet.stat.Descriptive.sampleStandardDeviation(a2.size(), cern.jet.stat.Descriptive.sampleVariance(a2,cern.jet.stat.Descriptive.mean(a2)));
                        double pcc = cern.jet.stat.Descriptive.correlation(a1,v1,a2,v2);
                        if(!distMap.containsKey(t1)){
                            distMap.put(t1,new HashMap<Gene,Double>());
                        }
                        distMap.get(t1).put(t2,new Double(pcc));
                    }
                    else{
                        //correlation between genes for single exp doesn't make much sense
                        if(!distMap.containsKey(t1)){
                            distMap.put(t1,new HashMap<Gene,Double>());
                        }
                        distMap.get(t1).put(t2,new Double(0));                    
                    }
                }
            }
        }

        public void calculateEuclDistMap(){

            this.dist = true;
            distMap = new HashMap<Gene,HashMap<Gene,Double>>();

            for(Gene t1:this.Genes){
                for(Gene t2:this.Genes){
                    double[] exp1 = new double[this.Conditions.size()];
                    double[] exp2 = new double[this.Conditions.size()];
                    int count = 0 ;
                    for(int i=0; i < this.moduleNetwork.data[t1.number].length;i++){
                        if (this.numberedConditions.keySet().contains(i)){
                            exp1[count] = this.moduleNetwork.data[t1.number][i];
                            exp2[count] = this.moduleNetwork.data[t2.number][i];       
                            count++;
                        }
                    }
                    double dist = 0;
                    for(int i = 0; i < exp1.length; i++){
                        if(!Double.isNaN(exp1[i]) && !Double.isNaN(exp2[i])){
                            dist += Math.pow(exp1[i]-exp2[i],2);
                        }
                    }
                    dist = Math.sqrt(dist);
                    if(!distMap.containsKey(t1)){
                        distMap.put(t1,new HashMap<Gene,Double>());
                    }
                    distMap.get(t1).put(t2,new Double(dist));   
                }
            }
        }

        public void calculateCosineCorMap(){

            this.dist = false;
            distMap = new HashMap<Gene,HashMap<Gene,Double>>();

            for(Gene t1:this.Genes){
                for(Gene t2:this.Genes){
                    double[] exp1 = new double[this.Conditions.size()];
                    double[] exp2 = new double[this.Conditions.size()];
                    int count = 0 ;
                    for(int i=0; i < this.moduleNetwork.data[t1.number].length;i++){
                        if (this.numberedConditions.keySet().contains(i)){
                            exp1[count] = this.moduleNetwork.data[t1.number][i];
                            exp2[count] = this.moduleNetwork.data[t2.number][i];       
                            count++;
                        }
                    }
                    double corr = 0;
                    double sum1 = 0;
                    double sum2 = 0;
                    for(int i = 0; i < exp1.length; i++){
                        if(!Double.isNaN(exp1[i]) && !Double.isNaN(exp2[i])){
                            corr += exp1[i]*exp2[i];
                            sum1 += Math.pow(exp1[i],2);
                            sum2 += Math.pow(exp2[i],2);
                        }  
                    }
                    if((sum1 != 0) && (sum2 != 0) && (corr != Double.NaN)){
                        corr = corr / (Math.sqrt(sum1)*Math.sqrt(sum2));
                    }
                    else{
                        System.out.println("Error in calculating cosine correlation for module " + this.name);
                    }
                    if(!distMap.containsKey(t1)){
                        distMap.put(t1,new HashMap<Gene,Double>());
                    }
                    distMap.get(t1).put(t2,new Double(corr));   
                }
            }
        }

        public void calculateCondEuclDistMap(){

            condDistMap = new HashMap<Condition,HashMap<Condition,Double>>();
            HashMap<Integer,Gene> numberedGenes = new HashMap<Integer,Gene>();

            for(Gene g: this.Genes){
                numberedGenes.put(g.number,g);
            }

            for(Condition t1:this.Conditions.keySet()){
                for(Condition t2:this.Conditions.keySet()){
                    double[] exp1 = new double[this.Genes.size()];
                    double[] exp2 = new double[this.Genes.size()];
                    int count = 0 ;
                    for(int i=0; i < this.moduleNetwork.data.length;i++){
                        if (numberedGenes.keySet().contains(i)){
                            exp1[count] = this.moduleNetwork.data[i][t1.number];
                            exp2[count] = this.moduleNetwork.data[i][t2.number];       
                            count++;
                        }
                    }
                    double dist = 0;
                    for(int i = 0; i < exp1.length; i++){
                        if(!Double.isNaN(exp1[i]) && !Double.isNaN(exp2[i])){
                            dist += Math.pow(exp1[i]-exp2[i],2);
                        }
                    }
                    dist = Math.sqrt(dist);
                    if(!condDistMap.containsKey(t1)){
                        condDistMap.put(t1,new HashMap<Condition,Double>());
                    }
                    condDistMap.get(t1).put(t2,new Double(dist));   
                }
            }
        }

        public void calculateCondCosineCorMap(){

            condDistMap = new HashMap<Condition,HashMap<Condition,Double>>();
            HashMap<Integer,Gene> numberedGenes = new HashMap<Integer,Gene>();

            for(Gene g: this.Genes){
                numberedGenes.put(g.number,g);
            }

            for(Condition t1:this.Conditions.keySet()){
                for(Condition t2:this.Conditions.keySet()){
                    double[] exp1 = new double[this.Genes.size()];
                    double[] exp2 = new double[this.Genes.size()];
                    int count = 0 ;
                    for(int i=0; i < this.moduleNetwork.data.length;i++){
                        if (numberedGenes.keySet().contains(i)){
                            exp1[count] = this.moduleNetwork.data[i][t1.number];
                            exp2[count] = this.moduleNetwork.data[i][t2.number];       
                            count++;
                        }
                    }
                    double corr = 0;
                    double sum1 = 0;
                    double sum2 = 0;
                    for(int i = 0; i < exp1.length; i++){
                        if(!Double.isNaN(exp1[i]) && !Double.isNaN(exp2[i])){
                            corr += exp1[i]*exp2[i];
                            sum1 += Math.pow(exp1[i],2);
                            sum2 += Math.pow(exp2[i],2);
                        }  
                    }
                    if((sum1 != 0) && (sum2 != 0) && (corr != Double.NaN)){
                        corr = corr / (Math.sqrt(sum1)*Math.sqrt(sum2));
                    }
                    else{
                        System.out.println("Error in calculating cosine correlation for module " + this.name);
                    }
                    if(!condDistMap.containsKey(t1)){
                        condDistMap.put(t1,new HashMap<Condition,Double>());
                    }
                    condDistMap.get(t1).put(t2,new Double(corr));   
                }
            }
        }

        public void calculateMatchSimMap(double pThres){

            this.dist = false;
            distMap = new HashMap<Gene,HashMap<Gene,Double>>();

            for(Gene t1:this.Genes){
                for(Gene t2:this.Genes){
                    double[] exp1 = new double[this.Conditions.size()];
                    double[] exp2 = new double[this.Conditions.size()];
                    double[] p1 = new double[this.Conditions.size()];
                    double[] p2 = new double[this.Conditions.size()];
                    int count = 0 ;
                    for(int i=0; i < this.moduleNetwork.data[t1.number].length;i++){
                        if (this.numberedConditions.keySet().contains(i)){
                            exp1[count] = this.moduleNetwork.data[t1.number][i];
                            exp2[count] = this.moduleNetwork.data[t2.number][i];
                            p1[count] = this.moduleNetwork.pvals[t1.number][i];
                            p2[count] = this.moduleNetwork.pvals[t2.number][i];       
                            count++;
                        }
                    }
                    double match = 0;
                    for(int i = 0; i < exp1.length; i++){
                            if((p1[i]<pThres)&&(p2[i]<pThres)&&(exp1[i]>0)&&(exp2[i]>0)){
                                match++;
                            }
                            else if((p1[i]<pThres)&&(p2[i]<pThres)&&(exp1[i]<0)&&(exp2[i]<0)){
                                match++;
                            }
                    }

                    if(!distMap.containsKey(t1)){
                        distMap.put(t1,new HashMap<Gene,Double>());
                    }
                    distMap.get(t1).put(t2,new Double(match));                     
                }
            }
        }

        public GeneTree clusterGenes(){
            // average linkage clustering of gene profiles
            // initialize list of pairwise merges

            //this.calculatePCCmap();
            //this.calculateEuclDistMap();
            //this.calculateMatchSimMap(0.01);
            this.calculateCosineCorMap();

            ArrayList<GeneTree> treeList = new ArrayList<GeneTree>();
            ArrayList<GeneTree> pairTreeList = new ArrayList<GeneTree>();

            int ind = 0;
            for (Gene i: Genes){
                treeList.add(ind,new GeneTree(i,this,dist));
                ind++;
            }

            for (int i = 0; i < treeList.size(); i++){
                    for (int j = 0; j < i; j++) {
                            HashSet<Gene> geneList = new HashSet<Gene>();
                            geneList.addAll(treeList.get(i).Genes);
                            geneList.addAll(treeList.get(j).Genes);
                            GeneTree tree = new GeneTree(geneList,this,treeList.get(i),treeList.get(j),dist);                            
                            pairTreeList.add(tree);
                    }
            }

            // merge trees in treeList until one tree is left
            boolean keep;
            int cnt;
            GeneTree bestTree = new GeneTree();
            while (treeList.size() > 1) {
                    // find the pair tree with the smallest difference in mean expression (compareMeans = true)
                    bestTree = Collections.min(pairTreeList);

                    // remove children of bestTree from treeList; bestTree will be added at the end
                    treeList.remove(bestTree.leftChild);
                    treeList.remove(bestTree.rightChild);
                    // loop over the pair list and remove trees whose condSet intersects
                    // with the condSet of the highest scoring tree, including the highest one
                    // itself
                    Iterator<GeneTree> it = pairTreeList.iterator();
                    while (it.hasNext()) {
                            GeneTree tree = it.next();
                            keep = true;
                            for(Gene g:tree.Genes) {
                                if (bestTree.Genes.contains(g)){
                                    keep = false;
                                }        
                            }
                            if (!keep){
                                it.remove();
                            }        
                    }
                    // add new trees which merge the bestTree with the other trees in
                    // treeList;
                    Iterator<GeneTree> it2 = treeList.iterator();
                    while (it2.hasNext()) {
                            GeneTree ittree = it2.next();
                            HashSet<Gene> geneList = new HashSet<Gene>();
                            geneList.addAll(bestTree.Genes);
                            geneList.addAll(ittree.Genes);
                            GeneTree tree = new GeneTree(geneList,this,ittree,bestTree,dist);                            
                            pairTreeList.add(tree);
                    }
                    // add bestTree again to treeList
                    treeList.add(bestTree);
                    // set bestTree as parent of its children
                    bestTree.leftChild.parentNode = bestTree;
                    bestTree.rightChild.parentNode = bestTree;
                    // System.out.println(bestTree.postProb);
            }
            // 1 tree left, this is the one
            // construct ordened gene list by depth-first search of bestTree
            this.ordenedGenes = new ArrayList<Gene>();
            ArrayList<GeneTree> ordenedLeafs = new ArrayList<GeneTree>() ;
            bestTree.gatherLeafList(ordenedLeafs);           
            for(int i = 0; i < ordenedLeafs.size(); i++){
                this.ordenedGenes.addAll(ordenedLeafs.get(i).Genes);
            }
            return bestTree;
        }

	// draw module
	public void draw() {     
		// scale factor
		int sc = 4;
		// coordinates of origin
		int x0 = 15;
		int y0 = 10;
		// tree step height
		int h = 18;
		// figure width
                String modName = "Module " + this.number + " : " +  this.name;
                int width = Math.max(3 * x0 + 2*this.Conditions.size() + 5 + 2*this.TFs.keySet().size() + 2 + 2*this.GO.keySet().size() + 2 + 2*this.modLinks.size(),2*modName.length()+10);
		int height;
		int x = x0;
		int ybase = y0;		   

                //figure height
                //find largest GO term
                BufferedImage tmpIm = new BufferedImage(200, 200,BufferedImage.TYPE_INT_BGR);
                Graphics2D tmp = tmpIm.createGraphics();
		tmp.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);
		tmp.scale(sc, sc);
                FontRenderContext frc = tmp.getFontRenderContext();

                int goHeight = 0;
                for(OntologyTerm go: GO.keySet()){
                    int a = Math.round((float) (new Font("SansSerif", Font.BOLD, 2).getStringBounds(go.getName(), frc).getWidth()));
                    if(a > goHeight){
                        goHeight = a;
                    }                    
                }

                //find largest Gene name                
                int nameHeight = 0;
                for(Gene g : this.Genes){
                    //at 30 degree angle...
                    int a = Math.round((float) (new Font("SansSerif", Font.BOLD, 2).getStringBounds(g.name, frc).getWidth() * Math.sqrt(3)/2.0));
                    if(a > goHeight){
                        nameHeight = a;
                    }                    
                }

                int treeHeight = (h + 4) * (this.regressionTree.treeDepth() + 1);

                if(goHeight > treeHeight){
                    treeHeight = goHeight;                    
                }

                //set dimensions

                ybase = y0 + treeHeight;
                height = ybase + 2 * y0 + this.Genes.size()*2 + nameHeight;

		if (this.regressionTree.nodeStatus.equals("leaf")){ // no tree
			this.rightmostNode = this.regressionTree;
		}	
		else {
			//find rightmost node to attach non-tree conditions and gene labels
			TreeNode tempNode = this.regressionTree ;
		 	while(tempNode.rightChild.nodeStatus.equals("internal")){tempNode = tempNode.rightChild;}
			this.rightmostNode = tempNode;		
			// coordinates of root
			x = x0 + 2*this.regressionTree.leftChild.leafDistribution.condSet.size();
		}              

		BufferedImage image = new BufferedImage(sc * width, sc * height,
				BufferedImage.TYPE_INT_BGR);
		Graphics2D g2;
		g2 = image.createGraphics();
		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);
		g2.scale(sc, sc);
		g2.setStroke(new BasicStroke(0.5F));
		if (this.regressionTree.nodeStatus.equals("leaf")) { // no tree
			g2.setPaint(Color.white);
			g2.fillRect(0, 0, width, height);
			// draw data
                        g2.setFont(new Font("SansSerif", Font.BOLD, 4));
                        g2.setPaint(Color.black);
                        g2.drawString(modName , width/2 - 2*modName.length()/2, new Float(y0/2));
			draw1leaf(x0, ybase, this.moduleNetwork.data, g2);
		} else {
			g2.setPaint(Color.white);
			g2.fillRect(0, 0, width, height);
			// draw regression tree
                        g2.setFont(new Font("SansSerif", Font.BOLD, 4));
                        g2.setPaint(Color.black);
                        g2.drawString(modName , width/2 - 2*modName.length()/2, new Float(y0/2));
			drawnode(this.regressionTree, x, y0, h, ybase,this.moduleNetwork.data, g2);
		}
		String filename = "module" + this.number + ".png";
		File outFile = new File(this.moduleNetwork.dataDir, filename);
		try {
			ImageIO.write(image, "png", outFile);
		} catch (IOException e) {
			return;
		}
	}

        // draw eps fig
	public void drawEps() {                         
		// scale factor
		int sc = 4;
		// coordinates of origin
		int x0 = 15;
		int y0 = 10;
		// tree step height
		int h = 18;
		// figure width
		int width = 3 * x0 + 2*this.Conditions.size() + 5 + 2*this.TFs.keySet().size()+ 2 + 2*this.GO.keySet().size() + 2 + 2*this.modLinks.size();
		int height;
		int x = x0;
		int ybase = y0;

                String modName = "Module " + this.number + " : " +  this.name;

                //figure height
                //find largest GO term
                BufferedImage tmpIm = new BufferedImage(200, 200,BufferedImage.TYPE_INT_BGR);
                Graphics2D tmp = tmpIm.createGraphics();
		tmp.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);
		tmp.scale(sc, sc);
                FontRenderContext frc = tmp.getFontRenderContext();

                int goHeight = 0;
                for(OntologyTerm go: GO.keySet()){
                    int a = Math.round((float) (new Font("SansSerif", Font.BOLD, 2).getStringBounds(go.getName(), frc).getWidth()));
                    if(a > goHeight){
                        goHeight = a;
                    }                    
                }

                //find largest Gene name                
                int nameHeight = 0;
                for(Gene g : this.Genes){
                    //at 30 degree angle...
                    int a = Math.round((float) (new Font("SansSerif", Font.BOLD, 2).getStringBounds(g.name, frc).getWidth() * Math.sqrt(3)/2.0));
                    if(a > goHeight){
                        nameHeight = a;
                    }                    
                }

                int treeHeight = (h + 4) * (this.regressionTree.treeDepth() + 1);

                if(goHeight > treeHeight){
                    treeHeight = goHeight;                    
                }

                //set dimensions

                ybase = y0 + treeHeight;
                height = ybase + 2 * y0 + this.Genes.size()*2 + nameHeight;

		if (this.regressionTree.nodeStatus.equals("leaf")){ // no tree
                        this.rightmostNode = this.regressionTree;
                }        
		else {
                        //find rightmost node to attach non-tree conditions and gene labels
			TreeNode tempNode = this.regressionTree ;
		 	while(tempNode.rightChild.nodeStatus.equals("internal")){tempNode = tempNode.rightChild;}
			this.rightmostNode = tempNode;	
			// coordinates of root
			x = x0 + 2*this.regressionTree.leftChild.leafDistribution.condSet.size();
		}
                try{
                    EpsGraphics g2 = new EpsGraphics("module" + this.number + ".eps", new FileOutputStream(new File(this.moduleNetwork.dataDir,"module" + this.number + ".eps")),0,0,sc*width,sc*height,ColorMode.COLOR_CMYK);
                    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                    RenderingHints.VALUE_ANTIALIAS_ON);
                    g2.scale(sc, sc);
                    g2.setStroke(new BasicStroke(0.5F));
                    if (this.regressionTree.nodeStatus.equals("leaf")) { // no tree
                            g2.setPaint(Color.white);
                            g2.fillRect(0, 0, width, height);
                            // draw data
                            g2.setFont(new Font("SansSerif", Font.BOLD, 4));
                            g2.setPaint(Color.black);
                            g2.drawString(modName , width/2 - 2*modName.length()/2, new Float(y0/2));
                            draw1leaf(x0, ybase, this.moduleNetwork.data, g2);
                    } else {
                            g2.setPaint(Color.white);
                            g2.fillRect(0, 0, width, height);
                            // draw regression tree
                            g2.setFont(new Font("SansSerif", Font.BOLD, 4));
                            g2.setPaint(Color.black);
                            g2.drawString(modName , width/2 - 2*modName.length()/2, new Float(y0/2));
                            drawnode(this.regressionTree, x, y0, h, ybase,this.moduleNetwork.data, g2);
                    }
                    g2.close();
                }
                catch(Exception e){
                    System.out.println(e.toString());
                }
	}

	// convert expression value to color
	public Color data2Color(Gene gene, double data) {
		Color col;
		float blueperc, yellowperc;
		blueperc = new Float(gene.upProb(data,this.moduleNetwork.dataMean,this.moduleNetwork.dataSigma));
		yellowperc = new Float(gene.downProb(data,this.moduleNetwork.dataMean,this.moduleNetwork.dataSigma));

		col = new Color(yellowperc, yellowperc, blueperc);

		return col;
	}

	// draw a node
	public void drawnode(TreeNode node, int x, int y, int h, int ybase,
			double[][] data, Graphics2D g) {
		// input:
		// (x,y): start coordinates, h: height of vertical node line,
		// ybase: baseline where leaves begin
		// data: expression data
		// g: graphics in which node is drawn
		if (node.nodeStatus.equals("internal")) {
			// where to start drawing regulator expression values
			int x1 = x - 2*node.leftChild.leafDistribution.condSet.size();
			// draw regulator expression values left of split point
			for (int m = 0; m < node.leftChild.leafDistribution.condSet.size(); m++) {
				int exp = node.leftChild.leafDistribution.condSet.get(m);
				if (!Double.isNaN(data[node.testGene.number][exp])) {
					// convert data value to color
					Color col = data2Color(node.testGene,data[node.testGene.number][exp]);
					g.setPaint(col);
				} else
					// missing value
					g.setPaint(Color.white);
				g.fillRect(x1 + 2*m, y + h - 4, 2, 1);
			}
			// draw regulator expression values right of split point
			for (int m = 0; m < node.rightChild.leafDistribution.condSet.size(); m++) {
				int exp = node.rightChild.leafDistribution.condSet.get(m);
				if (!Double.isNaN(data[node.testGene.number][exp])) {
					// convert data value to color
					Color col = data2Color(node.testGene,data[node.testGene.number][exp]);
					g.setPaint(col);
				} else
					// missing value
					g.setPaint(Color.white);
				g.fillRect(x + 2*m, y + h - 4, 2, 1);
			}
			g.setPaint(Color.black);
			// draw vertical split line
			g.drawLine(x, y, x, y + h);
			// set font for writing regulator name
			g.setFont(new Font("SansSerif", Font.BOLD, 4));
			FontRenderContext frc = g.getFontRenderContext();
			// find dimensions of regulator name
			LineMetrics metrics = g.getFont().getLineMetrics(node.testGene.name, frc);
			float regwidth = (float) g.getFont().getStringBounds(node.testGene.name, frc).getWidth();
			float regheight = (float) g.getFont().getStringBounds(node.testGene.name, frc).getHeight();
			// draw ellipse around regulator name
			Shape r = new Ellipse2D.Double(x - 0.7 * regwidth, y + h - 11 - 1.4
					* regheight + 1.5 * metrics.getDescent(), 1.4 * regwidth,
					1.6 * regheight);
			if (this.TFs.keySet().contains(node.testGene)){
                            if (this.Genes.contains(node.testGene)){
				g.setPaint(Color.orange);
                            }
                            else{
                                g.setPaint(Color.red);
                            }
                        }    
			else if (this.Genes.contains(node.testGene)){
                                g.setPaint(Color.yellow);
                        }
                        else{
				g.setPaint(Color.white);
                        }        
			g.fill(r);
			g.setPaint(Color.black);
			g.draw(r);
			// write regulator name
			g.drawString(node.testGene.name, new Float(x - 0.5 * regwidth),
					new Float(y + h - 11));
			// annotate split with its regulator assignment entropy

			String quality = String.format("(%.2g)", node.entropy);
			g.setFont(new Font("SansSerif", Font.BOLD, 3));
			g.drawString(quality, new Float(x - 2), new Float(y + h + 3));
			// x-coordinate for leftChild
			int xl;
			if (node.leftChild.nodeStatus.equals("internal")) {
				// if child is also internal, start should be in the middle of
				// its own children
				xl = x - 2*node.leftChild.rightChild.leafDistribution.condSet.size();
			} else {
				// if child is leaf, we draw a vertical to the middle of the
				// leaf as well as the leaf data point
				xl = x - 2*node.leftChild.leafDistribution.condSet.size() / 2;
				g.drawLine(xl, y + h, xl, ybase);
				int xl1 = x - 2*node.leftChild.leafDistribution.condSet.size();				
                                				//draw the condition labels
                                for (int m = 0; m < node.leftChild.leafDistribution.condSet.size(); m++) {
                                    int exp = node.leftChild.leafDistribution.condSet.get(m);
                                    Condition c = numberedConditions.get(exp);
                                    g.setFont(new Font("SansSerif", Font.BOLD, 2));
                                    g.setPaint(Color.black);
                                    g.rotate(Math.PI/3,new Float(xl1 + 2*m+1), new Float(ybase + 2*this.Genes.size()+2));
                                    g.drawString(c.name, new Float(xl1 + 2*m+1), new Float(ybase + 2*this.Genes.size()+2));
                                    g.rotate(-Math.PI/3,new Float(xl1 + 2*m+1), new Float(ybase + 2*this.Genes.size()+2));
                                }

				// draw the data points
                                int gn = 0;
                                g.setStroke(new BasicStroke(0.25F));
				for (Gene gene : this.ordenedGenes) {
					for (int m = 0; m < node.leftChild.leafDistribution.condSet.size(); m++) {
						int exp = node.leftChild.leafDistribution.condSet.get(m);
						if (!Double.isNaN(data[gene.number][exp])) {
							// convert data to color
							Color col = data2Color(gene, data[gene.number][exp]);
							g.setPaint(col);
						} else
							// missing value
							g.setPaint(Color.white);
						g.fillRect(xl1 + 2*m, ybase + 2*gn, 2, 2);
                                                g.setPaint(Color.black);                                                
						g.drawRect(xl1 + 2*m, ybase + 2*gn, 2, 2); 
					}
					gn++;
				}
				g.setPaint(Color.black);
				// draw frame around expression values
				//g.drawRect(xl1, ybase, 2*node.leftChild.leafDistribution.condSet.size(), this.Genes.size()*2);
                                g.setStroke(new BasicStroke(0.5F));
			}
			// x-coordinate for rightChild
			int xr;
			if (node.rightChild.nodeStatus.equals("internal"))
				// if child is also internal, start should be in the middle of
				// its own children
				xr = x + 2*node.rightChild.leftChild.leafDistribution.condSet.size();
			else {
				// if child is leaf, we draw a vertical to the middle of the
				// leaf as well as the leaf data point
				xr = x + 2*node.rightChild.leafDistribution.condSet.size() / 2;
				g.drawLine(xr, y + h, xr, ybase);				
				//draw the condition labels
                                for (int m = 0; m < node.rightChild.leafDistribution.condSet.size(); m++) {
                                    int exp = node.rightChild.leafDistribution.condSet.get(m);
                                    Condition c = numberedConditions.get(exp);
                                    g.setFont(new Font("SansSerif", Font.BOLD, 2));
                                    g.setPaint(Color.black);
                                    g.rotate(Math.PI/3,new Float(x + 2*m+1), new Float(ybase + 2*this.Genes.size()+2));
                                    g.drawString(c.name, new Float(x + 2*m+1), new Float(ybase + 2*this.Genes.size()+2));
                                    g.rotate(-Math.PI/3,new Float(x + 2*m+1), new Float(ybase + 2*this.Genes.size()+2));
                                }

                                if(node == this.rightmostNode){
                                        //add labels of non-tree conditions
                                        int N = node.rightChild.leafDistribution.condSet.size();
                                        for (int i = 0; i < this.nonTreeConditions.size(); i++) {
                                            g.setFont(new Font("SansSerif", Font.BOLD, 2));
                                            g.setPaint(Color.black);
                                            g.rotate(Math.PI/3,new Float(x + 2*N +1 + 2*i), new Float(ybase + 2*this.Genes.size()+2));
                                            g.drawString(this.nonTreeConditions.get(i).name, new Float(x + 2*N +1 + 2*i), new Float(ybase + 2*this.Genes.size()+2));
                                            g.rotate(-Math.PI/3,new Float(x + 2*N +1 + 2*i), new Float(ybase + 2*this.Genes.size()+2));    
                                        }

                                        //add names of overrepresented TFs to plot
                                        g.setFont(new Font("SansSerif", Font.BOLD, 2));
                                        g.setPaint(Color.black);
                                        int t=0;
                                        TreeSet<Gene> ordenedTFs = new TreeSet<Gene>((Set<Gene>) this.TFs.keySet());
                                        for(Gene tf: ordenedTFs){                                            
                                            g.rotate(-Math.PI/2,new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size() +2 + 15 + 2*t), new Float(ybase -2));
                                            g.drawString(tf.name, new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+2 + 15 + 2*t), new Float(ybase -2));
                                            g.rotate(Math.PI/2,new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+2 + 15 + 2*t), new Float(ybase -2));
                                            t++;
                                        }

                                        //add names of overrepresented GO cats to plot
                                        g.setFont(new Font("SansSerif", Font.BOLD, 2));
                                        g.setPaint(Color.black);
                                        t=0;
                                        for(OntologyTerm go: GO.keySet()){                                            
                                            g.rotate(-Math.PI/2,new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+ 2*ordenedTFs.size() + 4 + 15 + 2*t), new Float(ybase -2));
                                            g.drawString(go.getName(), new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+ 2*ordenedTFs.size() +4 + 15 + 2*t), new Float(ybase -2));
                                            g.rotate(Math.PI/2,new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+ 2*ordenedTFs.size() +4 + 15 + 2*t), new Float(ybase -2));
                                            t++;
                                        }

                                        //add names of module links to plot
                                        t = 0;
                                        g.setFont(new Font("SansSerif", Font.BOLD, 2));
                                        g.setPaint(Color.black);
                                        for(Module m: modLinks){
                                            g.rotate(-Math.PI/2,new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+ 2*ordenedTFs.size() + 4 + 2*GO.keySet().size() +2 + 15 + 2*t), new Float(ybase -2));
                                            g.drawString(Integer.toString(m.number), new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+ 2*ordenedTFs.size() +4 + 2*GO.keySet().size() +2+ 15 + 2*t), new Float(ybase -2));
                                            g.rotate(Math.PI/2,new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size()+ 2*ordenedTFs.size() +4 + 2*GO.keySet().size() +2+ 15 + 2*t), new Float(ybase -2));
                                            t++;
                                        }

                                }	

                                // draw the data points  
                                g.setStroke(new BasicStroke(0.25F));
                                int gn = 0;
				for (Gene gene : this.ordenedGenes) {
					for (int m = 0; m < node.rightChild.leafDistribution.condSet
							.size(); m++) {
						int exp = node.rightChild.leafDistribution.condSet.get(m);
						if (!Double.isNaN(data[gene.number][exp])) {
							// convert data to color
							Color col = data2Color(gene, data[gene.number][exp]);
							g.setPaint(col);
						} else
							// missing value
							g.setPaint(Color.white);
						g.fillRect(x + 2*m, ybase + 2*gn, 2, 2);
                                                g.setPaint(Color.black);                                                
						g.drawRect(x + 2*m, ybase + 2*gn, 2, 2);                                                
					}
					if(node == this.rightmostNode){
                                                 int N = node.rightChild.leafDistribution.condSet.size();
                                                //draw non-tree condition data points
                                                for (int m = 0; m < this.nonTreeConditions.size(); m++) {
                                                    int exp = this.nonTreeConditions.get(m).number;
                                                    if (!Double.isNaN(data[gene.number][exp])) {
                                                            // convert data to color
                                                            Color col = data2Color(gene, data[gene.number][exp]);
                                                            g.setPaint(col);
                                                    } else
                                                            // missing value
                                                            g.setPaint(Color.white);
                                                    g.fillRect(x + 2*N + 2*m, ybase + 2*gn, 2, 2);
                                                    g.setPaint(Color.black);                                                
                                                    g.drawRect(x + 2*N + 2*m, ybase + 2*gn, 2, 2);                                                
                                                }

                                                // draw line between rightmost leaf and extra conditions
                                                if(this.nonTreeConditions.size() > 0){   
                                                    g.setStroke(new BasicStroke(0.5F));
                                                    g.setPaint(Color.white);
                                                    g.drawLine(x + 2*N, ybase + 2*gn, x + 2*N, ybase + 2*gn + 2);
                                                    g.setPaint(Color.black);
                                                    g.setStroke(new BasicStroke(0.25F));
                                                }    
						//add names of genes to plot
						g.setFont(new Font("SansSerif", Font.BOLD, 2));
						g.setPaint(Color.black);
						g.drawString(gene.name, new Float(x + 2*node.rightChild.leafDistribution.condSet.size() + 2*this.nonTreeConditions.size() +2), new Float(ybase + 2*gn+2));
                                                //add yellow squares for overrepresented TFs
                                                int t = 0;
                                                TreeSet<Gene> ordenedTFs = new TreeSet<Gene>((Set<Gene>) this.TFs.keySet());
                                                for(Gene tf: ordenedTFs){                                                            
                                                    if(this.moduleNetwork.getTFBinding().containsKey(tf) && this.moduleNetwork.getTFBinding().get(tf).containsKey(gene)){
                                                        g.setPaint(Color.yellow);
                                                        g.fillRect(x + 2*node.rightChild.leafDistribution.condSet.size()+ 2*this.nonTreeConditions.size() + 15 + 2*t, ybase + 2*gn, 2, 2);                                                        
                                                    }
                                                    g.setPaint(Color.black);
                                                    g.drawRect(x + 2*node.rightChild.leafDistribution.condSet.size()+ 2*this.nonTreeConditions.size() + 15 + 2*t, ybase + 2*gn, 2, 2);           
                                                    t++;
                                                }

                                                //add orange squares for overrepresented GO cats
                                                t = 0;
                                                for(OntologyTerm go: GO.keySet()){
                                                    boolean ok = false;
                                                    for(OntologyTerm o: gene.GOannotations){
                                                        if(o.equals(go)){
                                                            ok = true;
                                                        }
                                                    }
                                                    if(ok == true){
                                                        g.setPaint(Color.orange);
                                                        g.fillRect(x + 2*node.rightChild.leafDistribution.condSet.size()+ 2*this.nonTreeConditions.size() + 2*ordenedTFs.size() +2 + 15 + 2*t, ybase + 2*gn, 2, 2);                                                        
                                                    }
                                                    g.setPaint(Color.black);
                                                    g.drawRect(x + 2*node.rightChild.leafDistribution.condSet.size()+ 2*this.nonTreeConditions.size() + 2*ordenedTFs.size() +2 + 15 + 2*t, ybase + 2*gn, 2, 2);           
                                                    t++;
                                                }

                                                //add links to other modules
                                                t = 0;
                                                for(Module m: modLinks){
                                                    if(gene.modules.contains(m)){
                                                        g.setPaint(Color.blue);
                                                        g.fillRect(x + 2*node.rightChild.leafDistribution.condSet.size()+ 2*this.nonTreeConditions.size() + 2*ordenedTFs.size() +2 + 2*GO.keySet().size() +2 + 15 + 2*t, ybase + 2*gn, 2, 2);                                                        
                                                    }
                                                    g.setPaint(Color.black);
                                                    g.drawRect(x + 2*node.rightChild.leafDistribution.condSet.size()+ 2*this.nonTreeConditions.size() + 2*ordenedTFs.size() +2 + 2*GO.keySet().size() +2 + 15 + 2*t, ybase + 2*gn, 2, 2);           
                                                    t++;
                                                }
                                        }	
					gn++;
				}
				g.setPaint(Color.black);
				// draw frame around expression values
				//g.drawRect(x, ybase, 2*node.rightChild.leafDistribution.condSet.size(), this.Genes.size()*2);
                                g.setStroke(new BasicStroke(0.5F));
			}
			// draw horizontal line between start coordinates for the children
			g.drawLine(xl, y + h, xr, y + h);
			// draw the children, right one is drawn lower than left one for clarity
			drawnode(node.leftChild, xl, y + h, h, ybase, data, g);
			drawnode(node.rightChild, xr, y + h, h + 4, ybase, data, g);
			// draw line between leaves
			g.setPaint(Color.white);
			g.drawLine(x, ybase, x, ybase + this.Genes.size()*2);
			g.setPaint(Color.black);
		}
	}

	// draw data as one big leaf (for module without parents)
	public void draw1leaf(int x, int y, double[][] data, Graphics2D g) {
		int numCond = this.regressionTree.leafDistribution.condSet.size();
                if(numCond != this.Conditions.size()){
                    System.out.println("Error here");
                }
		int gn = 0;

                for(int i = 0; i < this.regressionTree.leafDistribution.condSet.size();i++){
                    Condition c = this.numberedConditions.get(this.regressionTree.leafDistribution.condSet.get(i));
                    //add names of conditions
                    g.setFont(new Font("SansSerif", Font.BOLD, 2));
                    g.setPaint(Color.black);
                    g.rotate(Math.PI/3,new Float(x + 2*i+1), new Float(y + 2*this.Genes.size()+2));
                    g.drawString(c.name, new Float(x + 2*i+1), new Float(y + 2*this.Genes.size()+2));
                    g.rotate(-Math.PI/3,new Float(x + 2*i+1), new Float(y + 2*this.Genes.size()+2));
                }

                //add names of overrepresented TFs to plot
                g.setFont(new Font("SansSerif", Font.BOLD, 2));
                g.setPaint(Color.black);
                TreeSet<Gene> ordenedTFs = new TreeSet<Gene>((Set<Gene>) this.TFs.keySet());
                int t=0;
                for(Gene tf: ordenedTFs){                                            
                    g.rotate(-Math.PI/2,new Float(x + 2*(numCond+1) + 15 + 2*t), new Float(y -2));
                    g.drawString(tf.name, new Float(x + 2*(numCond+1) + 15 + 2*t), new Float(y -2));
                    g.rotate(Math.PI/2,new Float(x + 2*(numCond+1) + 15 + 2*t), new Float(y -2));
                    t++;
                }                 

                //add names of overrepresented GO cats to plot
                g.setFont(new Font("SansSerif", Font.BOLD, 2));
                g.setPaint(Color.black);
                t=0;
                for(OntologyTerm go: GO.keySet()){                                             
                    g.rotate(-Math.PI/2,new Float(x + 2*(numCond+1) + 2*ordenedTFs.size() + 2 + 15 + 2*t), new Float(y -2));
                    g.drawString(go.getName(), new Float(x + 2*(numCond+1) + 2*ordenedTFs.size() +2 + 15 + 2*t), new Float(y -2));
                    g.rotate(Math.PI/2,new Float(x + 2*(numCond+1) + 2*ordenedTFs.size() +2 + 15 + 2*t), new Float(y -2));
                    t++;
                }

                //add names of module links to plot
                t = 0;
                g.setFont(new Font("SansSerif", Font.BOLD, 2));
                g.setPaint(Color.black);
                for(Module m: modLinks){
                    g.rotate(-Math.PI/2,new Float(x + 2*(numCond+1) + 2*ordenedTFs.size() + 2 + 2*GO.keySet().size() + 2 + 15 + 2*t), new Float(y -2));
                    g.drawString(Integer.toString(m.number), new Float(x + 2*(numCond+1) + 2*ordenedTFs.size() +2 + 2*GO.keySet().size() + 2 + 15 + 2*t), new Float(y -2));
                    g.rotate(Math.PI/2,new Float(x + 2*(numCond+1) + 2*ordenedTFs.size() +2 + 2*GO.keySet().size() + 2 + 15 + 2*t), new Float(y -2));
                    t++;
                }

                g.setStroke(new BasicStroke(0.25F));
		for (Gene gene : this.ordenedGenes) {
			for (int i = 0; i < this.regressionTree.leafDistribution.condSet.size();i++) {
                                int m = this.numberedConditions.get(this.regressionTree.leafDistribution.condSet.get(i)).number;
				if (!Double.isNaN(data[gene.number][m])) {
					// convert data to color
					Color col = data2Color(gene, data[gene.number][m]);
					g.setPaint(col);
				} else
					// missing value
					g.setPaint(Color.white);
				g.fillRect(x + 2*i, y + 2*gn, 2, 2);
                                g.setPaint(Color.black);
				g.drawRect(x + 2*i, y + 2*gn, 2, 2);
			}
			//add name of gene
			g.setFont(new Font("SansSerif", Font.BOLD, 2));
			g.setPaint(Color.black);
			g.drawString(gene.name, new Float(x + 2*(numCond+1)), new Float(y + 2*gn +2));
                        //add yellow squares for overrepresented TFs
                        t=0;
                        for(Gene tf: ordenedTFs){                                                                                
                            if(this.moduleNetwork.getTFBinding().containsKey(tf) && this.moduleNetwork.getTFBinding().get(tf).containsKey(gene)){
                                g.setPaint(Color.yellow);
                                g.fillRect(x + 2*(numCond) + 15 + 2*t, y + 2*gn, 2, 2);                                                        
                            }
                            g.setPaint(Color.black);
                            g.drawRect(x + 2*(numCond) + 15 + 2*t, y + 2*gn, 2, 2);           
                            t++;
                        }
                        //add orange squares for overrepresented GO cats
                        t = 0;
                        for(OntologyTerm go: GO.keySet()){ 
                            //System.out.println(this.name + "\t" + go.getName());
                            boolean ok = false;
                            for(OntologyTerm o: gene.GOannotations){
                                if(o.equals(go)){
                                    //System.out.println(this.name + "\t" + go.getName() + "\t" + o.getName());
                                    ok = true;
                                }
                            }
                            if(ok == true){
                                g.setPaint(Color.orange);
                                g.fillRect(x + 2*(numCond) + 2*ordenedTFs.size() +2 + 15 + 2*t, y + 2*gn, 2, 2);                                                        
                            }
                            g.setPaint(Color.black);
                            g.drawRect(x + 2*(numCond) + 2*ordenedTFs.size() +2 + 15 + 2*t, y + 2*gn, 2, 2);           
                            t++;
                        }
                        //add links to other modules
                        t = 0;
                        for(Module m: modLinks){
                            if(gene.modules.contains(m)){
                                g.setPaint(Color.blue);
                                g.fillRect(x + 2*(numCond) + 2*ordenedTFs.size() +2 + 2*GO.keySet().size() +2 + 15 + 2*t, y + 2*gn, 2, 2);                                                        
                            }
                            g.setPaint(Color.black);
                            g.drawRect(x + 2*(numCond) + 2*ordenedTFs.size() +2 + 2*GO.keySet().size() +2 + 15 + 2*t, y + 2*gn, 2, 2);           
                            t++;
                        }

			gn++;
		}
		g.setPaint(Color.black);
		// draw frame around expression values
		//g.drawRect(x, y, numCond*2, this.Genes.size()*2);
                g.setStroke(new BasicStroke(0.5F));
	}

        public void setTFs(HashMap<Gene,Double> tfs){
            TFs.putAll(tfs);
        }

}