QSARData.h

Go to the documentation of this file.

/* QSARData.h
 * 
 * Copyright (C) 2009 Marcel Schumann
 * 
 * This file is part of QuEasy -- A Toolbox for Automated QSAR Model
 * Construction and Validation.
 * QuEasy 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.
 * 
 * QuEasy 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 this program; if not, see <http://www.gnu.org/licenses/>.
 */

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// 

#ifndef QSARH
#define QSARH

#include <iostream>
#include <BALL/KERNEL/system.h>
#include <BALL/FORMAT/SDFile.h>
#include <BALL/FORMAT/PDBFile.h>
#include <BALL/FORMAT/HINFile.h>
#include <BALL/FORMAT/MOLFile.h>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <math.h>
#include <sstream>
#include <fstream>
#include <limits>
#include <fstream>
#include <BALL/QSAR/simpleDescriptors.h>
#include <BALL/QSAR/connectivityDescriptors.h>
#include <BALL/QSAR/partialChargeDescriptors.h>
#include <BALL/QSAR/surfaceDescriptors.h>
#include <BALL/COMMON/exception.h>
#include <string.h>

#ifndef STATISTICS
#include <BALL/QSAR/statistics.h>
#endif

#ifndef QSAR_EXCEPTION
#include <BALL/QSAR/exception.h>
#endif

#include <gsl/gsl_randist.h>
#include <gsl/gsl_cdf.h>

#include <BALL/CONCEPT/timeStamp.h>

// #ifndef MODEL
// #include "Model.h"
// #endif

namespace BALL
{
  namespace QSAR
  {
    typedef vector<double> Column;
    typedef vector<Column> VMatrix;
    
    class BALL_EXPORT QSARData 
    {
      public:
        
        QSARData();
        
        ~QSARData();
        
        bool isDataCentered() const;
        
        bool isResponseCentered() const;
          
        vector<String>* readPropertyNames(String sd_file);

        void readSDFile(const char* file);
        
        void readSDFile(const char* file, std::multiset<int>& act, bool useExDesc=1, bool append=0, bool translate_class_labels=0);
  
        void calculateBALLDescriptors(Molecule& m);
          
        void displayMatrix();
        
        void centerData(bool center_Y=0);
  
        void scaleAllDescriptors();
        
        unsigned int getNoSubstances() const;
        
        unsigned int getNoDescriptors() const;
        
        void readCSVFile(const char* file, int no_y, bool xlabels, bool ylabels, const char* sep=",", bool appendDescriptors=0, bool translate_class_labels=0);
  
        void manipulateY(vector<String> v);
  
        void manipulateY(String v);
        
        void discretizeY(vector<double> thresholds);
        
        void transformX(vector<String> v);
        
        vector<QSARData*> partitionInputData(int p);
        
        void saveToFile(string filename) const;
        
        void readFromFile(string filename);
        
        vector<QSARData*> generateExternalSet(double fraction) const;

        vector<QSARData*> evenSplit(int no_test_splits, int current_test_split_id, int response_id=0) const;
        
        vector<double>* getSubstance(int s) const;
        
        vector<double>* getActivity(int s) const;
        
        unsigned int getNoResponseVariables() const;
        
        const vector<string>* getSubstanceNames() const;
        
        bool checkforDiscreteY() const;
        
        
        bool checkforDiscreteY(const char* file, std::multiset<int>& activity_IDs) const;
        
        void setDataFolder(const char* folder);
        
        void removeHighlyCorrelatedCompounds(double& compound_cor_threshold, double& feature_cor_threshold);
        
        void getSimilarDescriptors(int descriptor_ID, double correlation, std::list<std::pair<uint,String> >& similar_descriptor_IDs) const;
        
        
      protected:
        
        void setDescriptorNames(const Molecule& m, std::multiset<int>& activity_IDs, bool useExDesc=1);
        
        void removeInvalidDescriptors(std::multiset<int>& invalidDescriptors);
        
        void removeInvalidSubstances(std::multiset<int>& inv);
        
        void readMatrix(VMatrix& mat, std::ifstream& in, char seperator, unsigned int lines, unsigned int col);
        
        void checkActivityIDs(std::multiset<int>& act, int no_properties);
        
        void insertSubstance(const QSARData* source, int s, bool backtransformation=0);
        
        void printMatrix(const VMatrix& mat, std::ostream& out) const;
        
        VMatrix descriptor_matrix_;
        
        VMatrix Y_;
        
        VMatrix descriptor_transformations_;
        
        VMatrix y_transformations_;
      
        vector<string> column_names_;
  
        vector<string> substance_names_;
  
        std::multiset<int> invalidDescriptors_;
        
        std::multiset<int> invalidSubstances_;
        
        String data_folder_;
        
        std::map<String,int> class_names_;

        
        
        friend class ClassificationValidation;
        friend class RegressionValidation;
        friend class Validation;
        friend class Model;
        friend class FitModel;
        friend class FeatureSelection;
  
    };

  }
}

#endif // QSARH

---