QSARData.h

Go to the documentation of this file.

// -*- 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 <cstring>

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

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

#include <BALL/CONCEPT/timeStamp.h>

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

namespace BALL
{
  class MolecularSimilarity;

  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 readSDFile(const char* file, std::set<String>& activity_names, bool useExDesc=1, bool append=0, bool translate_class_labels=0, bool calc_phychem_properties=1, bool calc_topological_properties=1);
          
        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(std::vector<String> v);
  
        void manipulateY(String v);
        
        void discretizeY(std::vector<double> thresholds);
        
        void transformX(std::vector<String> v);
        
        std::vector<QSARData*> partitionInputData(int p);
        
        void saveToFile(string filename) const;
        
        void readFromFile(string filename);
        
        std::vector<QSARData*> generateExternalSet(double fraction) const;

        std::vector<QSARData*> evenSplit(int no_test_splits, int current_test_split_id, int response_id=0) const;
        
        std::vector<double>* getSubstance(int s) const;
        
        std::vector<double>* getActivity(int s) const;
        
        unsigned int getNoResponseVariables() const;
        
        const std::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 calculateBALLDescriptors(Molecule& m);

        void calculateTopologicalDescriptors(Molecule& mol, MolecularSimilarity& molsim, const std::map<String,int>& descriptor_map);

        void setDescriptorNames(const Molecule& m, std::multiset<int>& activity_IDs, bool useExDesc=1, bool resize=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