src/seekcentral.h

/*****************************************************************************
* This file is provided under the Creative Commons Attribution 3.0 license.
*
* You are free to share, copy, distribute, transmit, or adapt this work
* PROVIDED THAT you attribute the work to the authors listed below.
* For more information, please see the following web page:
* http://creativecommons.org/licenses/by/3.0/
*
* This file is a component of the Sleipnir library for functional genomics,
* authored by:
* Curtis Huttenhower (chuttenh@princeton.edu)
* Mark Schroeder
* Maria D. Chikina
* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
*
* If you use this library, the included executable tools, or any related
* code in your work, please cite the following publication:
* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
* Olga G. Troyanskaya.
* "The Sleipnir library for computational functional genomics"
*****************************************************************************/
#ifndef SEEKCENTRAL_H
#define SEEKCENTRAL_H

#include "seekbasic.h"
#include "seekdataset.h"
#include "seekplatform.h"
#include "seekmap.h"
#include "seekreader.h"
#include "seekquery.h"
#include "seekevaluate.h"
#include "database.h"
#include "datapair.h"
#include "seekweight.h"

namespace Sleipnir {

class CSeekCentral{
public:
    
    enum SearchMode{
        CV=0, 
        EQUAL=1, 
        USE_WEIGHT=2, 
        CV_CUSTOM=3, 
        ORDER_STATISTICS=4, 
        AVERAGE_Z=5 
    };
    
    CSeekCentral();
    
    ~CSeekCentral();

    bool Initialize(
        const vector<CSeekDBSetting*> &vecDBSetting,
        const char *search_dset, const char *query,
        const char* output_dir,
        const utype buffer = 20, const bool to_output_text = false,
        const bool bOutputWeightComponent = false, const bool bSimulateWeight = false,
        const enum CSeekDataset::DistanceMeasure dist_measure = CSeekDataset::Z_SCORE,
        const bool bSubtractAvg = true, const bool bNormPlatform = false,
        const bool bLogit = false, const float fCutOff = -9999, 
        const float fPercentQueryRequired = 0, const float fPercentGenomeRequired = 0,
        const bool bSquareZ = false, const bool bRandom = false, const int iNumRandom = 10,
        gsl_rng *rand = NULL, const bool useNibble = false, const int numThreads = 8);

    bool Initialize(
        const vector<CSeekDBSetting*> &vecDBSetting,
        const utype buffer = 20, const bool to_output_text = false,
        const bool bOutputWeightComponent = false, const bool bSimulateWeight = false,
        const enum CSeekDataset::DistanceMeasure dist_measure = CSeekDataset::Z_SCORE,
        const bool bSubtractAvg = true, const bool bNormPlatform = false,
        const bool bLogit = false, const float fCutOff = -9999, 
        const float fPercentQueryRequired = 0, const float fPercentGenomeRequired = 0,
        const bool bSquareZ = false, const bool bRandom = false, const int iNumRandom = 10,
        gsl_rng *rand = NULL, const bool useNibble = false, const int numThreads = 8);

    bool Initialize(const string &output_dir, const string &query,
        const string &search_dset, CSeekCentral* src, const int iClient,
        const float query_min_required = 0, const float genome_min_required = 0,
        const enum CSeekDataset::DistanceMeasure = CSeekDataset::Z_SCORE,
        const bool bSubtractGeneAvg = true, const bool bNormPlatform = false);

    bool CVSearch(gsl_rng*, const CSeekQuery::PartitionMode&, const utype&, const float&);

    bool CVCustomSearch(const vector< vector<string> > &, gsl_rng*,
        const CSeekQuery::PartitionMode&, const utype&, const float&);

    bool EqualWeightSearch();

    bool WeightSearch(const vector<vector<float> >&);

    bool VarianceWeightSearch();

    bool AverageWeightSearch();

    bool OrderStatistics();

    const vector< vector<AResultFloat> >& GetAllResult()const;

    const vector<CSeekQuery>& GetAllQuery() const;

    const vector<vector<float> > &GetAllWeight() const;

    utype GetGene(const string &strGene) const;

    string GetGene(const utype &geneID) const;

    bool Destruct();

    int GetMaxGenomeCoverage();

private:
    //network mode
    bool EnableNetwork(const int&);
    bool CheckDatasets(const bool&);

    /* Central search function */
    bool Common(CSeekCentral::SearchMode&, gsl_rng* = NULL,
        const CSeekQuery::PartitionMode* = NULL,
        const utype* = NULL, const float* = NULL,
        const vector< vector<float> >* = NULL,
        const vector< vector<string> >* = NULL);

    bool CheckWeight(const utype &i);
    bool CopyTopGenes(CSeekQuery&, const vector<AResultFloat>&, 
        const utype);
    bool SetQueryScoreNull(const CSeekQuery&);
    bool PrepareQuery(const vector<string>&, CSeekQuery&);
    bool CalculateRestart();
    bool PrepareOneQuery(CSeekQuery &, CSeekIntIntMap &, vector<float>&);
    bool AggregateThreads();
    bool FilterResults(const utype &);
    bool Sort(vector<AResultFloat> &);
    bool Write(const utype &);
    bool Display(CSeekQuery &, vector<AResultFloat>&);

    /* Gene, Dataset, and Platform Mapping*/
    vector<string> m_vecstrGenes;
    vector<string> m_vecstrDatasets;
    vector<string> m_vecstrDP;
    map<string, string> m_mapstrstrDatasetPlatform;
    map<string, utype> m_mapstrintDataset;
    map<string, utype> m_mapstrintGene;
    vector<vector<string> > m_vecstrSearchDatasets;
    vector<CSeekIntIntMap*> m_searchdsetMap;

    /* Datasets */
    vector<CSeekDataset*> m_vc;

    /* Output */
    bool m_bOutputText;

    /* If true, output random case (ie shuffle rankings per dataset)
       iNumRandom: number of repetitions (Oct 26, 2012) */
    bool m_bRandom;
    int m_iNumRandom;
    gsl_rng *m_randRandom;
    /* random dataset weight over all repetitions */
    //vector<vector<float> > m_vecRandWeight; 
    /* random gene scores over all repetitions */
    //vector<vector<float> > m_vecRandScore; 

    /* Gene-gene correlation matrix for all datasets
     Organized per thread */
    utype ***m_rData;

    /* Correlation discretization */
    vector<float> m_quant;

    /* Correlation transformation options */
    bool m_bSubtractGeneAvg;
    bool m_bNormPlatform;
    enum CSeekDataset::DistanceMeasure m_eDistMeasure;
    bool m_bLogit;
    bool m_bSquareZ;

    /* multi-threaded programming */
    float **m_master_rank_threads;
    float **m_sum_weight_threads;
    float **m_sum_sq_weight_threads;
    utype **m_counts_threads;
    vector<utype> *m_rank_normal_threads;
    vector<utype> *m_rank_threads;

    /* Essential search results */
    vector<float> m_master_rank;
    vector<float> m_sum_weight;
    vector<float> m_sum_sq_weight;
    vector<utype> m_counts;

    /* Holds results for all queries */
    vector< vector<float> > m_weight;
    vector< vector<AResultFloat> > m_final;

    /* Query */
    vector< vector<string> > m_vecstrAllQuery;
    vector<CSeekQuery> m_Query;

    /* Platform */
    vector<CSeekPlatform> m_vp;
    map<string, utype> m_mapstriPlatform;
    vector<string> m_vecstrPlatform;

    //CDatabase reference
    vector<CDatabase*> m_vecDB;
    vector<vector<string> > m_vecDBDataset; //A list of dsets in each CDatabase

    size_t m_iDatasets;
    size_t m_iGenes;
    utype m_numThreads;

    utype m_maxNumDB;
    map<utype, vector< vector<string> > > m_mapLoadTime;
    bool DEBUG;

    bool m_bOutputWeightComponent;
    bool m_bSimulateWeight;

    string m_output_dir;
    float m_fScoreCutOff;
    float m_fPercentQueryAfterScoreCutOff;
    float m_fPercentGenomeRequired;

    /* for order statistics, a datasets-by-genes matrix */
    utype **m_rank_d;

    /* for network mode */
    int m_iClient;
    bool m_bEnableNetwork;
    bool m_bSharedDB; //if m_DB is shared between multiple CSeekCentral instances
};





}
#endif