Package chemaxon.marvin.calculations

Class logPPlugin

  • All Implemented Interfaces:
    chemaxon.license.Licensable
    @PublicAPI
public class logPPlugin
extends CalculatorPlugin
    Plugin class for logP calculation. Both the incremental logP values for atoms and the overal logP value for the molecule can be calculated by this plugin.

    Reference:

    1. J.Chem.Inf.Comput.Sci. 1989, 29, 163-172

    API usage example: 

        // fill parameters
    Properties params = new Properties();
    params.put("type", "logP");

    // create plugin
    logPPlugin plugin = new logPPlugin();
    
    // set logP calculation method
    plugin.setlogPMethod(logPPlugin.METHOD_WEIGHTED);
    
    // set method weights
    plugin.setWeightOfMethods(1, 2, 1, 0);

    // set parameters
    plugin.setCloridIonConcentration(0.2);
    plugin.setNaKIonConcentration(0.2);

    // set result types
    plugin.setUserTypes("logPTrue,logPMicro");

    // for each input molecule run the calculation and display the results
    System.out.println("molecule\tlogP");
    MolImporter mi = new MolImporter("targets.sdf")));
    Molecule target = null;
    while ((target = mi.read()) != null) {

        // set the input molecule
        plugin.setMolecule(target);

        // run the calculation
        plugin.run();

        // get the overal logP value
        double logp = plugin.getlogPTrue(); 
        double logpm = plugin.getlogPMicro();

        System.out.println("True logP : "+logp);
        System.out.println("Micro logP: "+logpm);
        System.out.println();
    }  
    mi.close();

    For concurrent plugin example applications using ChemAxon's concurrent framework, refer to the Concurrent plugin examples.

    • Constructor Detail

      • logPPlugin

        public logPPlugin()
        Constructor. Creates the logP calculator object.

    • Method Detail

      • setParameters

        public void setParameters​(Properties params)
                   throws PluginException
        Sets the input parameters for the plugin. logP parameters and value ranges:
        • precision: 0-8 or inf (number of displayed fractional digits, inf for unrounded value)
        • anion: Cl- ion concentration (default: 0.1)
        • kation: Na+ plus K+ ion concentration (default: 0.1)
        • type: increments,logP,logPTrue,logPMicro,logPNonionic,logDpI (logP means all of, logPTrue means the most typical of logPMicro,logPNonionic,logDpI which exists for the input molecule)
        • h: true or false (display increments on implicit H atoms)
        • majortautomer: true or false (take major tautomeric form)
        • method: vg, klop, phys, user, weighted
        Overrides:
        setParameters in class CalculatorPlugin
        Parameters:
        params - is the parameter table
        Throws:
        PluginException - on error

      • setCloridIonConcentration

        public void setCloridIonConcentration​(double c)
        Sets the Cl- concentration (default: 0.1).
        Parameters:
        c - is the concentration

      • setNaKIonConcentration

        public void setNaKIonConcentration​(double c)
        Sets the Na+, K+ concentration (default: 0.1).
        Parameters:
        c - is the concentration

      • setConsiderTautomerization

        public void setConsiderTautomerization​(boolean considerTautomerization)
        Sets to consider tautomerization. Default: false.
        Parameters:
        considerTautomerization - the calculation will consider tautomerization and resonance if set (true)
        Since:
        Marvin 5.4

      • setTakeMajorTatomericForm

        @Deprecated
public void setTakeMajorTatomericForm​(boolean takeMajorTautomericForm)
        Deprecated.
        Use setConsiderTautomerization(boolean)
        Sets to use major tautomeric form in calculation. Default: false.
        Parameters:
        takeMajorTautomericForm - the calculation will be performed on the major tutomeric form of the input molecule if set (true)
        Since:
        Marvin 5.0

      • setUserTypes

        public void setUserTypes​(String chtypes)
                  throws PluginException
        Sets user types. Possible types: logP,logPTrue,logPMicro,logPNonionic,logDpI (logP means all of, logPTrue means the most typical of logPMicro,logPNonionic,logDpI which exists for the input molecule) multiple values should be separated by "," (e.g.: "logPTrue,logPNonionic,logDpI").
        Parameters:
        chtypes - is the type string
        Throws:
        PluginException - for invalid type

      • checkMolecule

        public void checkMolecule​(Molecule mol)
                   throws PluginException
        Checks the input molecule. Throws exception if the molecule is RxnMolecule, if the molecule contains R-groups or if the molecule consists of more than one fragments.
        Overrides:
        checkMolecule in class CalculatorPlugin
        Parameters:
        mol - is the input molecule
        Throws:
        PluginException - with error message for the user if the molecule is refused

      • setlogPMethod

        public void setlogPMethod​(chemaxon.marvin.calculations.LogPMethod method)
        Sets the logP calculation method. The available methods are:
        • LogPMethod.CONSENSUS
        • LogPMethod.CHEMAXON
        • LogPMethod.USER_DEFINED
        The default is LogPMethod.CONSENSUS.
        Parameters:
        method - is the logP calculation method
        Since:
        Marvin 15.4.13

      • getTrainingIds

        public static String[] getTrainingIds()
        Returns the id's of available logP trainings.
        Returns:
        the id's of available logP trainings
        Since:
        Marvin 5.4

      • setTraining

        public void setTraining​(String trainingId)
                 throws PluginException
        Sets the user defined training.
        Parameters:
        trainingId - the training id
        Throws:
        PluginException - if training id is invalid, or parameter file for training cannot be loaded
        Since:
        Marvin 5.4

      • getErrorMessage

        public String getErrorMessage()
        Returns the calculation error information message if run() returned false (calculation error): hydrogen valence error.
        Overrides:
        getErrorMessage in class CalculatorPlugin
        Returns:
        the calculation error information message

      • getlogPMicro

        public double getlogPMicro()
        Returns the micro logP value. The logP calculation should be run beforehand by run().
        Returns:
        the micro logP value

      • getlogPNonionic

        public double getlogPNonionic()
        Returns the logP value for the non-ionic form. The logP calculation should be run beforehand by run().
        Returns:
        the nonionic logP value

      • getlogDpI

        public double getlogDpI()
        Returns the logD value at pI. The logP calculation should be run beforehand by run().
        Returns:
        the logDpI value

      • getlogPTrue

        public double getlogPTrue()
        Returns the most typical logP among logD at pI, micro logP and nonionic logP.
        Returns:
        the most typical logP value

      • getAtomlogPIncrement

        public double getAtomlogPIncrement​(int index)
        Returns the logP increment for the specified atom.
        Parameters:
        index - is the atom index
        Returns:
        the logP increment

      • getAtomlogPHIncrement

        @Deprecated
public double getAtomlogPHIncrement​(int index)
        Deprecated.
        Increments of implicit H-s are not calculated. Returns the same value as getAtomlogPIncrement(int)
        Returns the sum of the implicit H logP increments for the specified atom.
        Parameters:
        index - is the atom index
        Returns:
        the logP increment sum

      • getStructurallogPIncrement

        public double getStructurallogPIncrement()
        Returns the structural logP increment. The sum of atomic increments and structural increment is the predicted logP.
        Returns:
        the structural logP increment
        Since:
        Marvin 5.4

      • getResultTypes

        public Object[] getResultTypes()
        Returns the result types. Possible result types: "logPTrue" (most typical logP) "logPMicro", "logPNonionic", "logDpI", "increments".
        Overrides:
        getResultTypes in class CalculatorPlugin
        Returns:
        the result types

      • getUserTypes

        public Object[] getUserTypes()
        Returns the user defined result types. Possible result types: "logP" (all of micro logP, nonionic logP and logD at pI), "logPTrue" (most typical logP), "logPMicro", "logPNonionic", "logDpI", "increments".
        Returns:
        the result types

      • getTypeString

        public String getTypeString​(Object type)
        Returns a string representation of the given type.
        Overrides:
        getTypeString in class CalculatorPlugin
        Parameters:
        type - is the type object
        Returns:
        the type string

      • getResultCount

        public int getResultCount​(Object type)
        Returns the number of result items for the given result key. logP returns the atom count for types "increments" 1 otherwise.
        Overrides:
        getResultCount in class CalculatorPlugin
        Parameters:
        type - is the result type
        Returns:
        the number of result items
        See Also:
        getResultTypes()

      • getResult

        public Object getResult​(Object type,
                        int index)
                 throws PluginException
        Returns the result item for the specified key and index. logP returns the required logP value as a Double object.
        Overrides:
        getResult in class CalculatorPlugin
        Parameters:
        type - is the result type
        index - is the result index
        Returns:
        the result item for the specified key and index
        Throws:
        PluginException - if the result cannot be returned
        See Also:
        getResultTypes()

      • getStandardError

        public double getStandardError​(Object type,
                               int index)

      • getResultAsString

        public String getResultAsString​(Object type,
                                int index,
                                Object result)
                         throws PluginException
        Returns the specified result in String format. logP returns the rounded logP value in string format: the value is rounded using the 'precision' input parameter that determines the number of fractional digits displayed.
        Overrides:
        getResultAsString in class CalculatorPlugin
        Parameters:
        type - is the result type
        index - is the result index
        result - is the result item
        Returns:
        the specified result in String format
        Throws:
        PluginException - if an invalid result item is given

      • standardize

        public void standardize​(Molecule mol)
        Standardizes the molecule. This is done by performing the transformations necessary to run the plugin (e.g. aromatize, dehydrogenize, bring nitro groups to common form). Apart from the default standardization (aromatize and nitro) removes explicit hydrogens. Does AROM_BASIC aromatization.
        Overrides:
        standardize in class CalculatorPlugin
        Parameters:
        mol - is the molecule to be standardized

      • needError

        public boolean needError()