moleculeset.h

/****************************************************************************************
                                          moleculeset.h 
                                        -----------------
    copyright            : (C) 2006 Jean-Luc Perret - Pierre Mahé
    email                : jean-luc.perret@unine.ch - pierre.mahe@ensmp.fr
 ***************************************************************************************/

/****************************************************************************************
 *                                                                                      *
 *      This program is free software; you can redistribute it and/or                   *
 *      modify it under the terms of the GNU Lesser General Public                      *
 *      License as published by the Free Software Foundation; either                    *
 *      version 2.1 of the License, or (at your option) any later version.              *
 *                                                                                      *
 *      This program 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               *
 *      Lesser General Public License for more details.                                 *
 *                                                                                      *
 *      You should have received a copy of the GNU Lesser General Public                *
 *      License along with this library; if not, write to the Free Software             *
 *      Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA      *
 *                                                                                      *
 ****************************************************************************************/


#ifndef MOLECULESET_H
#define MOLECULESET_H

#include <vector>
#include <fstream>
#include <sstream>
#include <pthread.h>
#include <math.h>

#include <datacontainer.h>
#include <molecule.h>
//#include <moleculeutils.h>
#include <kcfmolecule.h>
#include <jlpioutils.h>
#include <constant.h>

#define VERBOSECALC 1


class MoleculeSet : public std::vector<Molecule*> {

public:



        MoleculeSet();
        MoleculeSet(const MoleculeSet& aSet);

        ~MoleculeSet();

        int add( MoleculeSet* aSet );

        void addMolecule( Molecule* aMolecule );

        Molecule* addMoleculeCopy( Molecule* aMolecule );

        void deleteAll();






        int addSD( string aFileName, bool genericAtomType = false, long beginMolecule = -1, long endMolecule = -1 );

        int addKCF( string aFileName, long beginMolecule = -1, long endMolecule = -1  );

        Molecule* addSingleMOL( string aMolFile, bool genericAtomType = false );

        Molecule* addSingleKCF( string aMolFile );

        void readMolDirectory( string aPath, bool genericAtomType = false, long beginMolecule = -1, long endMolecule = -1 );

        void readKcfDirectory( string dataDir, long beginMolecule = -1, long endMolecule = -1 );

        void addMutag( string aFileName, string rFileName="", uint numMolToRead = 500 );


        void readActivityFile( string aFileName );

        void readDescriptorFile( string aFileName, string separator = ";" );

        void readGistClassifyFile( string aFileName );

        void readGistActivityFile( string aFileName, string aDescriptor );

        void readGram( string aFileName, vector< vector<double> >* gram );

        void readGramNormal( string aFileName );
        
        void readGramRaw( string aFileName );

        void readPartialCharges(string fileName);









        uint numMolecules(){ return( size() ); }

        Molecule* operator[]( string aName ) throw( CError );

        Molecule* getMolByName( string aName ) throw( CError );

        Molecule* operator[]( int anInd ) throw( CError );

        Molecule* getMolByIndex( int anInd ) throw( CError );


        long getPossibleValuesInIntDescriptor( string aDescriptorName, vector< int >* p );

        double getPq(){ return( pq ); }


        int getConvergenceCondition(){ return( convergenceCondition ); }


        bool nameExists( string aName );

        bool hasActivity(){ return activitySet; }

        void setIntDescriptor( string aName, int aValue );

        void setUniqueMorganIndices();

        void setMorganLabels( int anOrder );

        void setIntDescriptor( string aLabel, string aMolecule, int aValue );

        void setActivity( string aMolecule, float aValue );
  
        void setKashimaKernelParam( double aPq, int aConvergenceCondition, bool skipSkeleton = false );

        void setComparisonSet( MoleculeSet* );
        
        void setMorganChargesLabels(double threshold);







        void selectAll();

        void unSelectAll();

        int select( vector< string >* aSubset );

        int unSelect( vector< string >* aSubset );

        long selectByFloatDescriptor( string aName, float aValue );

        long selectByIntDescriptor( string aName, int aValue );

        long selectByActivity( float aValue );

        long selectHasActivity();

        int selectByMW( float minmw, float maxmw = -1 , bool addMolecularDescriptor = false );

        int selectByNumAtoms( float minNumAtoms, float maxNumAtoms = -1 , bool addMolecularDescriptor = false );

        void sortByDescriptor( string aDescriptorName, int aDescriptorType, bool reverse = false );

        void sortByDescriptor( string aDescriptorName, bool reverse = false );

        void sortByMW();

        void sortByNumAtoms();

        void binClassifyFromDescriptor( string descriptorName, float value, bool smallerOrEqual = true );


        Molecule* findFirstMoleculeWithName( string aName ) throw( CError );


        void removeDuplicates();

        void deleteHiddenAtoms();

        void hideHydrogens();

        void hideSalts( string aReportFileName = "" );

        void restoreHiddenAtoms();

        void addFragmentsToSet( Molecule* aMol, int minAtoms = 1 );

        void pushFragments( Molecule* aMol, int minAtoms = 1 );

        double diversityBaryMean();

        vector<string> atomsLabelsListing();

        vector<string> atomsSymbolsListing();

        vector<int> bondsListing();

        void noTottersTransform();
        
        void threeDtransform(int nBins, double distMin, double distMax);

        void minMaxDistances(double *distMin, double* distMax);







        void gramCompute(
                double aPq,
                double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2,
                                         double(*pt2AtomKernel)(Atom*, Atom*),
                                         double(*pt2BondKernel)(Bond*, Bond*), int, int ),
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*),
                int aParameter = 1000,
                string aReportFileName = "",
                int nbThreadsWanted = 1,
                bool silentMode = false,
                bool filterTotters = false);

        void gramCompute(
                MoleculeSet* anotherSet,
                double aPq,
                double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2,
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*), int, int ),
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*),
                int aParameter = 1000,
                string aReportFileName = "",
                int nbThreadsWanted = 1,
                bool silentMode = false, 
                bool filterTotters = false);

        void gramCompute(
                double aPq,
                double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2,
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*), int, int ),
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*),
                int parameter1 = 1000,
                int parameter2 = 1,
                string aReportFileName = "",
                int nbThreadsWanted = 1,
                bool silentMode = false, 
                bool filterTotters = false);

        void gramCompute(
                MoleculeSet* anotherSet,
                double aPq,
                double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2,
                                         double(*pt2AtomKernel)(Atom*, Atom*),
                                         double(*pt2BondKernel)(Bond*, Bond*), int, int ),
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*),
                int parameter1 = 1000,
                int parameter2 = 1,
                string aReportFileName = "",
                int nbThreadsWanted = 1,
                bool silentMode = false, 
                bool filterTotters = false);

        void gramCompute3D( 
                         double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2, 
                                                  double(*pt2AtomKernel)(Atom*, Atom*), 
                                                  double(*pt2BondKernel)(float,float,float), float), 
                         double(*pt2AtomKernel)(Atom*, Atom*), 
                         double(*pt2BondKernel)(float, float, float),
                         float edgeKernelparameter, 
                         bool silentMode );

        void gramCompute3D( 
                           MoleculeSet* anotherSet,
                           double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2, 
                                                    double(*pt2AtomKernel)(Atom*, Atom*), 
                                                    double(*pt2BondKernel)(float,float,float), float), 
                           double(*pt2AtomKernel)(Atom*, Atom*), 
                           double(*pt2BondKernel)(float, float, float),
                           float edgeKernelparameter, 
                           bool silentMode );

        void kernelCompute(
                Molecule* aMol,
                double(*pt2GraphKernel)( Molecule* mol1, Molecule* mol2, double(*pt2AtomKernel)(Atom*, Atom*), double(*pt2BondKernel)(Bond*, Bond*), int, int ),
                double(*pt2AtomKernel)(Atom*, Atom*),
                double(*pt2BondKernel)(Bond*, Bond*),
                vector<double>* resultsRaw,
                vector<double>* resultsNormal,
                int convergenceCondition = 1000,
                int parameter2 = 1,
                bool silentMode = false
        );


        void resetGramMatrix();

        void resetSelfKernels();

        void initializeGram( double value );

        void initializeSelfKernel( double value );

        void normalizeGram();

        void normalizeGram_raw();
        
        void normalizeTanimoto();

        void normalizeTanimoto_raw();   
        void normalizeTanimotoMinMax();

        void addToGram( int row, int col, double value );

        void addToGramNormal( int row, int col, double value );

        void substractToGram( int row, int col, double value );

        double getGramValue( int row, int col );











        void writeActivityFile( string aFilename, bool addActivityExtension = true, string activityDescriptor = ACTIVITY );

        void writeGramMatrix( string aFileName, bool normal = false, bool self = false, bool silentMode = false );

        void writeSelfKernelList( string aFilename, bool silentMode = false );

        void writeSD( string aFileName, bool selectedOnly = false );

        void writeSubsetSD( string aFileName, vector<string>* anOrder );

        void writeSubsetKCF( string aFileName, vector<string>* anOrder );

        void writeKCF( string aFileName, bool selectedOnly = false );

        string toString( bool selectedOnly = false );
        string toStringShort();

        string toStringLong();


        void describe( bool selectedOnly = false );

        void describeShort();

        void describeLong();


        void writeDescriptors( string aFileName, bool selectedOnly = false ) throw( CError ) ;

        long writeMolToDir( string aDirName, bool selectedOnly = false );

        long writeDotsToDir( string aDirectory, bool selectedOnly = false, bool perretLabels = false  );





// DEPRECATED FUNCTIONS : 
//void addMolecule( Molecule* aMolecule, bool updateGram = true );

//void pop_back();
//void normalizeGram_self();
//void normalizeGram_test();
//void setSelfGram();
        


protected: // Protected attributes

        MoleculeSet* comparisonSet;

        vector< vector<double> >* gram;

        vector< vector<double> >* gramNormal;

        bool gramCalculated;

        double pq;

        int convergenceCondition;

        int subsetStart;

        int subsetSize;

        bool activitySet;


        void setSortDescriptor( string aName, int aType, bool reverse = false ) throw( CError );

        string getSortDescriptorName();


        //vector<Molecule*> molecules;


};

#endif

---