moleculeutils.h

/****************************************************************************************
                                          moleculeutils.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 MOLECULEUTILS_H
#define MOLECULEUTILS_H

//#include <vector>
#include <istream>
#include <locale>
#include <string>
#include <iomanip>

//#include <stringutils.h>
//#include <molecule.h>
#include <moleculeset.h>
//#include <atom.h>

#define FINDENTRY 0
#define READINGNODES 1
#define READINGEDGES 2
#define READINGUNKNOWN 3


using namespace std;


class MoleculeUtils {

public:





        static void readMDLCtabBlock(
                Molecule& aMolecule,
                ifstream& inFile,
                bool genericAtomTypeFlag = false
                ) throw( CError );

        static void readMDLHeaderBlock(
                Molecule& aMolecule,
                ifstream& inFile,
                string aName = "COMMENT"
                ) throw( CError );

        static void readMDLNSDBlock( Molecule& aMolecule, ifstream& inFile ) throw( CError );

        static void skipMDLEntry( Molecule& aMolecule, ifstream& inFile ) throw( CError );

        static void writeMDLHeaderBlock( Molecule& aMolecule, ofstream& outFile );

        static void writeMDLCtabBlock( Molecule& aMolecule, ofstream& outFile );

        static void writeMDLNSDBlock( Molecule& aMolecule, ofstream& outFile );

        static void writeKCF( Molecule& aMolecule, ofstream& outFile );

        static void writeKCFNSDBlock( Molecule& aMolecule, ofstream& outFile );

        static bool readKCFMolecule( KCFMolecule& aMolecule, ifstream& inFile ) throw( CError );


        static void writeDOTGraph( Molecule& aMolecule, ofstream& outFile, bool perretabels = false );







        static double moleculeKernel(
                Molecule* mol1,
                Molecule* mol2,
                double (*pt2AtomKernel)(Atom*, Atom*) = &atomKernelSymbol,
                double (*pt2BondKernel)(Bond*, Bond*) = &bondKernelType,
                int convergenceCondition = 1000, int parameter2 = 1
                );

        static double powerKernelUntilN( Molecule* mol1, Molecule* mol2, double (*pt2AtomKernel)( Atom*, Atom* ), double (*pt2BondKernel)(Bond*, Bond*), int maxPower, int minLength = 1 ) throw( CError );

        static double powerKernelOrderN( Molecule* mol1, Molecule* mol2, double (*pt2AtomKernel)( Atom*, Atom* ), double (*pt2BondKernel)(Bond*, Bond*), int anOrder, int parameter2 = 1 ) throw( CError );

        static double powerKernelConverge( Molecule* mol1, Molecule* mol2, double (*pt2AtomKernel)( Atom*, Atom* ), double (*pt2BondKernel)(Bond*, Bond*), int converge, int parameter2 = 1 ) throw( CError );

        static vector< vector<double> >* rlk(
                vector< vector<double> >* r,
                vector< vector<double> >* rwork,
                vector< vector<double> >* rstart,
                Molecule* mol1,
                Molecule* mol2,
                int convergenceCondition,
                int parameter2,
                double (*pt2AtomKernel)(Atom*, Atom*),
                double (*pt2BondKernel)(Bond*, Bond*),
                int depth
                );
        
        static bool converge(
                vector< vector<double> >* r1,
                vector< vector<double> >* r2,
                Molecule* mol1,
                Molecule* mol2,
                int convergenceCondition
                );

        static double atomKernelSymbol( Atom* a1, Atom* a2 );

        static double atomKernelMorganLabel( Atom* a1, Atom* a2 );

        static double atomKernelPerretLabel( Atom* a1, Atom* a2 );

        static double atomKernelPerretLabelExternalMatrix( Atom* a1, Atom* a2 );


        static double atomKernelExternalMatrix( Atom* a1, Atom* a2 );

        static double atomKernelLabel( Atom* a1, Atom* a2 );


        static double bondKernelType( Bond* b1, Bond* b2 );

        static double bondKernelPerretLabelStrict( Bond* b1, Bond* b2 );

        static double bondKernelPerretLabel( Bond* b1, Bond* b2 );


        static double bondKernelRotable( Bond* b1, Bond* b2 );







        static double threeDkernel(
                                   Molecule* mol1, Molecule* mol2,
                                   double (*pt2AtomKernel)( Atom*, Atom*),
                                   double (*pt2BondKernel)(float, float, float),
                                   float edgeKernelParameter );

        static double threeDedgeKernelRBF( float dist1, float dist2 , float param );

        static double threeDedgeKernelTriangle( float dist1, float dist2 , float param );








        static string getRingString( Bond* aBond ) throw( CError );

        static void describeMap( map<Atom*, float>* aMap );

        static void substractSet( vector<Atom*>* full, vector<Atom*>* exclude, vector<Atom*>* result);

        static bool atomVectorHas( vector<Atom*>* atomVector, Atom* anAtom );

        static void mergeSet( vector<Atom*>* v1, vector<Atom*>* v2, vector<Atom*>* result);
        
        static void mergeBondSet( vector<Bond*>* v1, vector<Bond*>* v2, vector<Bond*>* result);
        
        static void selectRingMemberBonds( vector<Bond*>* v1, vector<Atom*>* a, vector<Bond*>* v2 );




        //MoleculeUtils();
        //~MoleculeUtils();

};

#endif

---