comparison docs/modules/man3/MolecularDescriptorsGenerator.3 @ 0:4816e4a8ae95 draft default tip

Uploaded

0:4816e4a8ae95

.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.22)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  \*(C+ will
.\" give a nicer C++.  Capital omega is used to do unbreakable dashes and
.\" therefore won't be available.  \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.ie \nF \{\
.    de IX
.    tm Index:\\$1\t\\n%\t"\\$2"
..
.    nr % 0
.    rr F
.\}
.el \{\
.    de IX
..
.\}
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "MOLECULARDESCRIPTORSGENERATOR 1"
.TH MOLECULARDESCRIPTORSGENERATOR 1 "2015-03-29" "perl v5.14.2" "MayaChemTools"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NAME"
MolecularDescriptorsGenerator
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
use MolecularDescriptors::MolecularDescriptorsGenerator;
.PP
use MolecularDescriptors::MolecularDescriptorsGenerator qw(:all);
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
\&\fBMolecularDescriptorsGenerator\fR class provides the following methods:
.PP
new, GenerateDescriptors, GetAvailableClassAndDescriptorNames,
GetAvailableClassNameForDescriptorName, GetAvailableDescriptorClassNames,
GetAvailableDescriptorNames, GetAvailableDescriptorNamesForDescriptorClass,
GetDescriptorClassParameters, GetDescriptorNames, GetDescriptorNamesAndValues,
GetDescriptorValueByName, GetDescriptorValues, GetRuleOf3DescriptorNames,
GetRuleOf5DescriptorNames, IsDescriptorClassNameAvailable,
IsDescriptorNameAvailable, IsDescriptorsGenerationSuccessful,
SetDescriptorClassParameters, SetDescriptorNames, SetMode, SetMolecule,
StringifyMolecularDescriptorsGenerator
.PP
\&\fBMolecularDescriptorsGenerator\fR is derived from is derived from \fBObjectProperty\fR
base class that provides methods not explicitly defined in \fBMolecularDescriptorsGenerator\fR
or \fBObjectProperty\fR classes using Perl's \s-1AUTOLOAD\s0 functionality. These methods are
generated on-the-fly for a specified object property:
.PP
.Vb 3
\&    Set<PropertyName>(<PropertyValue>);
\&    $PropertyValue = Get<PropertyName>();
\&    Delete<PropertyName>();
.Ve
.PP
\&\fBMolecularDescriptorsGenerator\fR is designed to provide a plug-in environment for
molecular descriptors development. The molecular descriptor class modules available
in \fBMolecularDescriptors\fR directory under \fBMayaChemTools/lib\fR directory are
automatically detected and loaded into the system. The descriptor names provided
by each descriptor class module through its \fBGetDescriptorNames\fR function are
retrieved and are made available for calculations of their values for a specified
molecule.
.PP
Any combination of available descriptor names can be specified during calculation
of descriptor values using \fBGenerateDescriptors\fR method. The current release of
MayaChemTools supports generation of four sets of descriptors: All available
descriptors, rule of 5 or 3 descriptors, or a specified set of descriptor names.
.PP
RuleOf5 [ Ref 91 ] descriptor names are: MolecularWeight, HydrogenBondDonors,
HydrogenBondAcceptors, SLogP. RuleOf5 states: MolecularWeight <= 500,
HydrogenBondDonors <= 5, HydrogenBondAcceptors <= 10, and logP <= 5.
.PP
RuleOf3 [ Ref 92 ] descriptor names are: MolecularWeight, RotatableBonds,
HydrogenBondDonors, HydrogenBondAcceptors, SLogP, \s-1TPSA\s0. RuleOf3 states:
MolecularWeight <= 300, RotatableBonds <= 3, HydrogenBondDonors <= 3,
HydrogenBondAcceptors <= 3, logP <= 3, and \s-1TPSA\s0 <= 60.
.PP
Before calculation of a specified set of descriptors by \fBGenerateDescriptors\fR
method, a set of descriptor calculation control parameters for a specific descriptor
class name can be set using \fBSetDescriptorClassParameters\fR method. The specified
control parameter names and values are simply passed on to specified descriptor
class during instantiation of descriptor class object without performing any validation
of parameter names and associated values. It's up to the appropriate descriptor class methods
to validate these parameters and values. In addition to specified parameter names and
values, the parameter hash must also contain descriptor class name as key and
value pair with DescriptorClassName as key with class name as value.
.SS "\s-1METHODS\s0"
.IX Subsection "METHODS"
.IP "\fBnew\fR" 4
.IX Item "new"
.Vb 3
\&    $NewMolecularDescriptorsGenerator = new MolecularDescriptors::
\&                                        MolecularDescriptorsGenerator(
\&                                        %NamesAndValues);
.Ve
.Sp
Using specified \fIMolecularDescriptorsGenerator\fR property names and values hash, \fBnew\fR
method creates a new object and returns a reference to newly created \fBMolecularDescriptorsGenerator\fR
object. By default, the following properties are initialized:
.Sp
.Vb 6
\&    Mode = \*(AqAll\*(Aq
\&    @{$This\->{DescriptorNames}} = ()
\&    %{$This\->{DescriptorClassParameters}} = ()
\&    @{$This\->{DescriptorClassNames}} = ()
\&    %{$This\->{DescriptorClassObjects}} = ()
\&    @{$This\->{DescriptorValues}} = ()
.Ve
.Sp
Examples:
.Sp
.Vb 3
\&    $MolecularDescriptorsGenerator = new MolecularDescriptors::
\&                                     MolecularDescriptorsGenerator(
\&                              \*(AqMolecule\*(Aq => $Molecule);
\&
\&    @DescriptorNames = qw(MolecularWeight HydrogenBondDonors Fsp3Carbons)
\&    $MolecularDescriptorsGenerator = new MolecularDescriptors::
\&                                     MolecularDescriptorsGenerator(
\&                              \*(AqMode\*(Aq => \*(AqSpecify\*(Aq,
\&                              \*(AqDescriptorNames\*(Aq => \e@DescriptorNames);
\&
\&    $MolecularDescriptorsGenerator\->SetDescriptorClassParameters(
\&                              \*(AqDescriptorClassName\*(Aq => \*(AqWeightAndMassDescriptors\*(Aq,
\&                              \*(AqWeightPrecision\*(Aq => 2,
\&                              \*(AqMassPrecision\*(Aq => 2);
\&
\&    $MolecularDescriptorsGenerator\->SetDescriptorClassParameters(
\&                              \*(AqDescriptorClassName\*(Aq => \*(AqHydrogenBondsDescriptors\*(Aq,
\&                              \*(AqHydrogenBondsType\*(Aq => \*(AqHBondsType1\*(Aq);
\&
\&    $MolecularDescriptorsGenerator\->SetMolecule($Molecule);
\&    $MolecularDescriptorsGenerator\->GenerateDescriptors();
\&    print "MolecularDescriptorsGenerator: $MolecularDescriptorsGenerator\en";
.Ve
.IP "\fBGenerateDescriptors\fR" 4
.IX Item "GenerateDescriptors"
.Vb 1
\&    $MolecularDescriptorsGenerator\->GenerateDescriptors();
.Ve
.Sp
Calculates descriptor values for specified descriptors and returns \fIMolecularDescriptorsGenerator\fR.
.Sp
Descriptor class objects are instantiated only once at first invocation. During
subsequent calls to \fBGenerateDescriptors\fR method, descriptor values are
initialized and \fBGenerateDescriptors\fR method provided by descriptor class is
used to calculate descriptor values for specified descriptors.
.IP "\fBGetAvailableClassAndDescriptorNames\fR" 4
.IX Item "GetAvailableClassAndDescriptorNames"
.Vb 5
\&    %ClassAndDescriptorNames = $MolecularDescriptorsGenerator\->
\&                              GetAvailableClassAndDescriptorNames();
\&    %ClassAndDescriptorNames = MolecularDescriptors::
\&                               MolecularDescriptorsGenerator::
\&                               GetAvailableClassAndDescriptorNames();
.Ve
.Sp
Returns available descriptors class and descriptors names as a hash containing key
and value pairs corresponding to class name and an array of descriptor names
available for the class.
.IP "\fBGetAvailableClassNameForDescriptorName\fR" 4
.IX Item "GetAvailableClassNameForDescriptorName"
.Vb 2
\&    $DescriptorClassName = $MolecularDescriptorsGenerator\->
\&                      GetAvailableClassNameForDescriptorName($DescriptorName);
\&
\&    $DescriptorClassName = MolecularDescriptors::MolecularDescriptorsGenerator::
\&                      GetAvailableClassNameForDescriptorName($DescriptorName);
.Ve
.Sp
Returns available descriptor class name for a descriptor name.
.IP "\fBGetAvailableDescriptorClassNames\fR" 4
.IX Item "GetAvailableDescriptorClassNames"
.Vb 1
\&    $Return = $MolecularDescriptorsGenerator\->GetAvailableDescriptorClassNames();
\&
\&    @DescriptorClassNames = $MolecularDescriptorsGenerator\->
\&                              GetAvailableDescriptorClassNames();
\&    @DescriptorClassNames = MolecularDescriptors::
\&                              MolecularDescriptorsGenerator::
\&                              GetAvailableDescriptorClassNames();
.Ve
.Sp
Returns available descriptor class names as an array or number of available descriptor
class names in scalar context.
.IP "\fBGetAvailableDescriptorNames\fR" 4
.IX Item "GetAvailableDescriptorNames"
.Vb 5
\&    @DescriptorNames = $MolecularDescriptorsGenerator\->
\&                              GetAvailableDescriptorNames();
\&    @DescriptorNames = MolecularDescriptors::
\&                              MolecularDescriptorsGenerator::
\&                              GetAvailableDescriptorNames();
.Ve
.Sp
Returns available descriptor names as an array or number of available descriptor
names in scalar context.
.IP "\fBGetAvailableDescriptorNamesForDescriptorClass\fR" 4
.IX Item "GetAvailableDescriptorNamesForDescriptorClass"
.Vb 5
\&    @DescriptorNames = $MolecularDescriptorsGenerator\->
\&          GetAvailableDescriptorNamesForDescriptorClass($DescriptorClassName);
\&    @DescriptorNames = MolecularDescriptors::
\&                       MolecularDescriptorsGenerator::
\&          GetAvailableDescriptorNamesForDescriptorClass($DescriptorClassName);
.Ve
.Sp
Returns available descriptors names for a descriptor class as an array or number
of available descriptor names in scalar context.
.IP "\fBGetDescriptorClassParameters\fR" 4
.IX Item "GetDescriptorClassParameters"
.Vb 5
\&    $DescriptorClassParametersRef = $MolecularDescriptorsGenerator\->
\&                              GetDescriptorClassParameters();
\&    $DescriptorClassParametersRef = MolecularDescriptors::
\&                                    MolecularDescriptorsGenerator::
\&                                    GetDescriptorClassParameters();
.Ve
.Sp
Returns descriptor name parameters as a reference to hash of hashes with hash
keys corresponding to class name and class parameter name with hash value
as class parameter value.
.IP "\fBGetDescriptorNames\fR" 4
.IX Item "GetDescriptorNames"
.Vb 3
\&    @DescriptorNames = $MolecularDescriptorsGenerator\->GetDescriptorNames();
\&    @DescriptorNames = MolecularDescriptors::MolecularDescriptorsGenerator::
\&                       GetDescriptorNames();
.Ve
.Sp
Returns all available descriptor names as an array or number of available descriptors
in scalar context.
.IP "\fBGetDescriptorNamesAndValues\fR" 4
.IX Item "GetDescriptorNamesAndValues"
.Vb 2
\&    %NamesAndValues = $MolecularDescriptorsGenerator\->
\&                              GetDescriptorNamesAndValues();
.Ve
.Sp
Returns calculated molecular descriptor names and values as a hash with descriptor
names and values as hash key and value pairs.
.IP "\fBGetDescriptorValueByName\fR" 4
.IX Item "GetDescriptorValueByName"
.Vb 2
\&    $Value = $MolecularDescriptorsGenerator\->
\&                              GetDescriptorValueByName($Name);
.Ve
.Sp
Returns calculated descriptor values for a specified descriptor name.
.IP "\fBGetDescriptorValues\fR" 4
.IX Item "GetDescriptorValues"
.Vb 1
\&    @DescriptorValues = $MolecularDescriptorsGenerator\->GetDescriptorValues();
.Ve
.Sp
Returns all calculated descriptor values as an array corresponding to specified
descriptor names.
.IP "\fBGetRuleOf3DescriptorNames\fR" 4
.IX Item "GetRuleOf3DescriptorNames"
.Vb 5
\&    @DescriptorNames = $MolecularDescriptorsGenerator\->
\&                       GetRuleOf3DescriptorNames();
\&    @DescriptorNames = MolecularDescriptors::
\&                       MolecularDescriptorsGenerator::
\&                       GetRuleOf3DescriptorNames();
.Ve
.Sp
Returns rule of 3  descriptor names as an array or number of rule of 3 descriptors in scalar
context.
.Sp
RuleOf3 [ Ref 92 ] descriptor names are: MolecularWeight, RotatableBonds,
HydrogenBondDonors, HydrogenBondAcceptors, SLogP, \s-1TPSA\s0. RuleOf3 states:
MolecularWeight <= 300, RotatableBonds <= 3, HydrogenBondDonors <= 3,
HydrogenBondAcceptors <= 3, logP <= 3, and \s-1TPSA\s0 <= 60.
.IP "\fBGetRuleOf5DescriptorNames\fR" 4
.IX Item "GetRuleOf5DescriptorNames"
.Vb 4
\&    @DescriptorNames = $MolecularDescriptorsGenerator\->
\&                              GetRuleOf5DescriptorNames();
\&    @DescriptorNames = $MolecularDescriptorsGenerator::
\&                             GetRuleOf5DescriptorNames();
.Ve
.Sp
Returns rule of 5  descriptor names as an array or number of rule of 4 descriptors in scalar
context.
.Sp
RuleOf5 [ Ref 91 ] descriptor names are: MolecularWeight, HydrogenBondDonors,
HydrogenBondAcceptors, SLogP. RuleOf5 states: MolecularWeight <= 500,
HydrogenBondDonors <= 5, HydrogenBondAcceptors <= 10, and logP <= 5.
.IP "\fBIsDescriptorClassNameAvailable\fR" 4
.IX Item "IsDescriptorClassNameAvailable"
.Vb 5
\&    $Status = $MolecularDescriptorsGenerator\->
\&                              IsDescriptorClassNameAvailable($ClassName);
\&    $Status = MolecularDescriptors::
\&                              MolecularDescriptorsGenerator::
\&                              IsDescriptorClassNameAvailable($ClassName);
.Ve
.Sp
Returns 1 or 0 based on whether specified descriptor class name is available.
.IP "\fBIsDescriptorNameAvailable\fR" 4
.IX Item "IsDescriptorNameAvailable"
.Vb 5
\&    $Status = $MolecularDescriptorsGenerator\->
\&                              IsDescriptorNameAvailable($DescriptorName);
\&    $Status = MolecularDescriptors::
\&                              MolecularDescriptorsGenerator::
\&                              IsDescriptorNameAvailable($DescriptorName);
.Ve
.Sp
Returns 1 or 0 based on whether specified descriptor name is available.
.IP "\fBIsDescriptorsGenerationSuccessful\fR" 4
.IX Item "IsDescriptorsGenerationSuccessful"
.Vb 2
\&    $Status = $MolecularDescriptorsGenerator\->
\&                              IsDescriptorsGenerationSuccessful();
.Ve
.Sp
Returns 1 or 0 based on whether descriptors generation is successful.
.IP "\fBSetDescriptorClassParameters\fR" 4
.IX Item "SetDescriptorClassParameters"
.Vb 2
\&    $MolecularDescriptorsGenerator\->SetDescriptorClassParameters(
\&                              %NamesAndValues);
.Ve
.Sp
Sets descriptor calculation control parameters for a specified descriptor class name
and returns \fIMolecularDescriptorsGenerator\fR.
.Sp
The specified parameter names and values are simply passed on to specified descriptor
class during instantiation of descriptor class object without any performing any validation
of parameter names and associated values. It's up to the appropriate descriptor class methods
to validate these parameters and values.
.Sp
In addition to specified parameter names and values, the parameter hash must also contain
descriptor class name as key and value pair with DescriptorClassName as key with class
name as value.
.IP "\fBSetDescriptorNames\fR" 4
.IX Item "SetDescriptorNames"
.Vb 2
\&    $MolecularDescriptorsGenerator\->SetDescriptorNames(@Names);
\&    $MolecularDescriptorsGenerator\->SetDescriptorNames(\e@Names);
.Ve
.Sp
Sets descriptor names to use for generating descriptor values using an array
or reference to an array and returns \fIMolecularDescriptorsGenerator\fR.
.IP "\fBSetMode\fR" 4
.IX Item "SetMode"
.Vb 1
\&    $MolecularDescriptorsGenerator\->SetMode($Mode);
.Ve
.Sp
Sets descriptors generation mode and returns \fIMolecularDescriptorsGenerator\fR.
Possible \fIMode\fR values: \fIAll, RuleOf5, RuleOf3, Specify\fR.
.IP "\fBSetMolecule\fR" 4
.IX Item "SetMolecule"
.Vb 1
\&    $MolecularDescriptorsGenerator\->SetMolecule($Molecule);
.Ve
.Sp
Sets molecule to use during calculation of molecular descriptors and returns
\&\fIMolecularDescriptorsGenerator\fR.
.IP "\fBStringifyMolecularDescriptorsGenerator\fR" 4
.IX Item "StringifyMolecularDescriptorsGenerator"
.Vb 1
\&    $String = $MolecularDescriptorsGenerator\->StringifyMolecularDescriptorsGenerator();
.Ve
.Sp
Returns a string containing information about \fIMolecularDescriptorsGenerator\fR object.
.SH "AUTHOR"
.IX Header "AUTHOR"
Manish Sud <[e-mail]>
.SH "SEE ALSO"
.IX Header "SEE ALSO"
MolecularDescriptors.pm
.SH "COPYRIGHT"
.IX Header "COPYRIGHT"
Copyright (C) 2015 Manish Sud. All rights reserved.
.PP
This file is part of MayaChemTools.
.PP
MayaChemTools is free software; you can redistribute it and/or modify it under
the terms of the \s-1GNU\s0 Lesser General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at your option)
any later version.