|
0
|
1 .\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.22)
|
|
|
2 .\"
|
|
|
3 .\" Standard preamble:
|
|
|
4 .\" ========================================================================
|
|
|
5 .de Sp \" Vertical space (when we can't use .PP)
|
|
|
6 .if t .sp .5v
|
|
|
7 .if n .sp
|
|
|
8 ..
|
|
|
9 .de Vb \" Begin verbatim text
|
|
|
10 .ft CW
|
|
|
11 .nf
|
|
|
12 .ne \\$1
|
|
|
13 ..
|
|
|
14 .de Ve \" End verbatim text
|
|
|
15 .ft R
|
|
|
16 .fi
|
|
|
17 ..
|
|
|
18 .\" Set up some character translations and predefined strings. \*(-- will
|
|
|
19 .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
|
|
|
20 .\" double quote, and \*(R" will give a right double quote. \*(C+ will
|
|
|
21 .\" give a nicer C++. Capital omega is used to do unbreakable dashes and
|
|
|
22 .\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
|
|
|
23 .\" nothing in troff, for use with C<>.
|
|
|
24 .tr \(*W-
|
|
|
25 .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
|
|
|
26 .ie n \{\
|
|
|
27 . ds -- \(*W-
|
|
|
28 . ds PI pi
|
|
|
29 . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
|
|
|
30 . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
|
|
|
31 . ds L" ""
|
|
|
32 . ds R" ""
|
|
|
33 . ds C` ""
|
|
|
34 . ds C' ""
|
|
|
35 'br\}
|
|
|
36 .el\{\
|
|
|
37 . ds -- \|\(em\|
|
|
|
38 . ds PI \(*p
|
|
|
39 . ds L" ``
|
|
|
40 . ds R" ''
|
|
|
41 'br\}
|
|
|
42 .\"
|
|
|
43 .\" Escape single quotes in literal strings from groff's Unicode transform.
|
|
|
44 .ie \n(.g .ds Aq \(aq
|
|
|
45 .el .ds Aq '
|
|
|
46 .\"
|
|
|
47 .\" If the F register is turned on, we'll generate index entries on stderr for
|
|
|
48 .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
|
|
|
49 .\" entries marked with X<> in POD. Of course, you'll have to process the
|
|
|
50 .\" output yourself in some meaningful fashion.
|
|
|
51 .ie \nF \{\
|
|
|
52 . de IX
|
|
|
53 . tm Index:\\$1\t\\n%\t"\\$2"
|
|
|
54 ..
|
|
|
55 . nr % 0
|
|
|
56 . rr F
|
|
|
57 .\}
|
|
|
58 .el \{\
|
|
|
59 . de IX
|
|
|
60 ..
|
|
|
61 .\}
|
|
|
62 .\"
|
|
|
63 .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
|
|
|
64 .\" Fear. Run. Save yourself. No user-serviceable parts.
|
|
|
65 . \" fudge factors for nroff and troff
|
|
|
66 .if n \{\
|
|
|
67 . ds #H 0
|
|
|
68 . ds #V .8m
|
|
|
69 . ds #F .3m
|
|
|
70 . ds #[ \f1
|
|
|
71 . ds #] \fP
|
|
|
72 .\}
|
|
|
73 .if t \{\
|
|
|
74 . ds #H ((1u-(\\\\n(.fu%2u))*.13m)
|
|
|
75 . ds #V .6m
|
|
|
76 . ds #F 0
|
|
|
77 . ds #[ \&
|
|
|
78 . ds #] \&
|
|
|
79 .\}
|
|
|
80 . \" simple accents for nroff and troff
|
|
|
81 .if n \{\
|
|
|
82 . ds ' \&
|
|
|
83 . ds ` \&
|
|
|
84 . ds ^ \&
|
|
|
85 . ds , \&
|
|
|
86 . ds ~ ~
|
|
|
87 . ds /
|
|
|
88 .\}
|
|
|
89 .if t \{\
|
|
|
90 . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
|
|
|
91 . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
|
|
|
92 . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
|
|
|
93 . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
|
|
|
94 . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
|
|
|
95 . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
|
|
|
96 .\}
|
|
|
97 . \" troff and (daisy-wheel) nroff accents
|
|
|
98 .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
|
|
|
99 .ds 8 \h'\*(#H'\(*b\h'-\*(#H'
|
|
|
100 .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
|
|
|
101 .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
|
|
|
102 .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
|
|
|
103 .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
|
|
|
104 .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
|
|
|
105 .ds ae a\h'-(\w'a'u*4/10)'e
|
|
|
106 .ds Ae A\h'-(\w'A'u*4/10)'E
|
|
|
107 . \" corrections for vroff
|
|
|
108 .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
|
|
|
109 .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
|
|
|
110 . \" for low resolution devices (crt and lpr)
|
|
|
111 .if \n(.H>23 .if \n(.V>19 \
|
|
|
112 \{\
|
|
|
113 . ds : e
|
|
|
114 . ds 8 ss
|
|
|
115 . ds o a
|
|
|
116 . ds d- d\h'-1'\(ga
|
|
|
117 . ds D- D\h'-1'\(hy
|
|
|
118 . ds th \o'bp'
|
|
|
119 . ds Th \o'LP'
|
|
|
120 . ds ae ae
|
|
|
121 . ds Ae AE
|
|
|
122 .\}
|
|
|
123 .rm #[ #] #H #V #F C
|
|
|
124 .\" ========================================================================
|
|
|
125 .\"
|
|
|
126 .IX Title "MOLECULE 1"
|
|
|
127 .TH MOLECULE 1 "2015-03-29" "perl v5.14.2" "MayaChemTools"
|
|
|
128 .\" For nroff, turn off justification. Always turn off hyphenation; it makes
|
|
|
129 .\" way too many mistakes in technical documents.
|
|
|
130 .if n .ad l
|
|
|
131 .nh
|
|
|
132 .SH "NAME"
|
|
|
133 Molecule \- Molecule class
|
|
|
134 .SH "SYNOPSIS"
|
|
|
135 .IX Header "SYNOPSIS"
|
|
|
136 use Molecule;
|
|
|
137 .PP
|
|
|
138 use Molecule qw(:all);
|
|
|
139 .SH "DESCRIPTION"
|
|
|
140 .IX Header "DESCRIPTION"
|
|
|
141 \&\fBMolecule\fR class provides the following methods:
|
|
|
142 .PP
|
|
|
143 new, AddAtom, AddAtoms, AddBond, AddBonds, AddHydrogens, AddPolarHydrogens,
|
|
|
144 ClearRings, Copy, DeleteAromaticity, DeleteAtom, DeleteAtoms, DeleteBond,
|
|
|
145 DeleteBonds, DeleteHydrogens, DeletePolarHydrogens, DetectAromaticity,
|
|
|
146 DetectRings, FormatElementalCompositionInformation, GetAllAtomPaths,
|
|
|
147 GetAllAtomPathsStartingAt, GetAllAtomPathsStartingAtWithLength,
|
|
|
148 GetAllAtomPathsStartingAtWithLengthUpto, GetAllAtomPathsWithLength,
|
|
|
149 GetAllAtomPathsWithLengthUpto, GetAromaticRings, GetAromaticityModel,
|
|
|
150 GetAtomNeighborhoods, GetAtomNeighborhoodsWithRadiusUpto,
|
|
|
151 GetAtomNeighborhoodsWithSuccessorAtoms,
|
|
|
152 GetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto, GetAtomPathBonds,
|
|
|
153 GetAtomPaths, GetAtomPathsBetween, GetAtomPathsStartingAt,
|
|
|
154 GetAtomPathsStartingAtWithLength, GetAtomPathsStartingAtWithLengthUpto,
|
|
|
155 GetAtomPathsWithLength, GetAtomPathsWithLengthUpto, GetAtoms, GetBonds, GetCharge,
|
|
|
156 GetConnectedComponents, GetConnectedComponentsAtoms, GetDimensionality,
|
|
|
157 GetElementalComposition, GetElementsAndNonElements, GetExactMass, GetFormalCharge,
|
|
|
158 GetFreeRadicalElectrons, GetFusedAndNonFusedRings, GetLargestConnectedComponent,
|
|
|
159 GetLargestConnectedComponentAtoms, GetLargestRing, GetMolecularFormula,
|
|
|
160 GetMolecularWeight, GetNumOfAromaticRings, GetNumOfAtoms, GetNumOfBonds,
|
|
|
161 GetNumOfConnectedComponents, GetNumOfElementsAndNonElements, GetNumOfHeavyAtoms,
|
|
|
162 GetNumOfHydrogenAtoms, GetNumOfMissingHydrogenAtoms, GetNumOfNonHydrogenAtoms,
|
|
|
163 GetNumOfRings, GetNumOfRingsWithEvenSize, GetNumOfRingsWithOddSize,
|
|
|
164 GetNumOfRingsWithSize, GetNumOfRingsWithSizeGreaterThan,
|
|
|
165 GetNumOfRingsWithSizeLessThan, GetRingBonds, GetRingBondsFromRings, GetRings,
|
|
|
166 GetRingsWithEvenSize, GetRingsWithOddSize, GetRingsWithSize,
|
|
|
167 GetRingsWithSizeGreaterThan, GetRingsWithSizeLessThan, GetSizeOfLargestRing,
|
|
|
168 GetSizeOfSmallestRing, GetSmallestRing, GetSpinMultiplicity,
|
|
|
169 GetSupportedAromaticityModels, GetTopologicallySortedAtoms, GetValenceModel,
|
|
|
170 HasAromaticAtomsInRings, HasAromaticAtomsNotInRings, HasAromaticRings, HasAtom,
|
|
|
171 HasBond, HasFusedRings, HasNoRings, HasOnlyOneRing, HasRings, IsAromatic,
|
|
|
172 IsMolecule, IsRingAromatic, IsSupportedAromaticityModel, IsThreeDimensional,
|
|
|
173 IsTwoDimensional, KeepLargestComponent, KekulizeAromaticAtoms, NewAtom, NewBond,
|
|
|
174 SetActiveRings, SetAromaticityModel, SetID, SetValenceModel, StringifyMolecule
|
|
|
175 .PP
|
|
|
176 The following methods can also be used as functions:
|
|
|
177 .PP
|
|
|
178 FormatElementalCompositionInformation, IsMolecule
|
|
|
179 .PP
|
|
|
180 \&\fBMolecule\fR class is derived from \fBObjectProperty\fR base class which provides methods not explicitly
|
|
|
181 defined in \fBMolecule\fR or \fBObjectProperty\fR class using Perl's \s-1AUTOLOAD\s0 functionality. These methods
|
|
|
182 are generated on-the-fly for a specified object property:
|
|
|
183 .PP
|
|
|
184 .Vb 3
|
|
|
185 \& Set<PropertyName>(<PropertyValue>);
|
|
|
186 \& $PropertyValue = Get<PropertyName>();
|
|
|
187 \& Delete<PropertyName>();
|
|
|
188 .Ve
|
|
|
189 .SS "\s-1METHODS\s0"
|
|
|
190 .IX Subsection "METHODS"
|
|
|
191 .IP "\fBnew\fR" 4
|
|
|
192 .IX Item "new"
|
|
|
193 .Vb 1
|
|
|
194 \& $NewMolecule = new Molecule([%PropertyNameAndValues]);
|
|
|
195 .Ve
|
|
|
196 .Sp
|
|
|
197 Using specified \fIAtom\fR property names and values hash, \fBnew\fR method creates a new object
|
|
|
198 and returns a reference to newly created \fBAtom\fR object. By default, the following properties are
|
|
|
199 initialized:
|
|
|
200 .Sp
|
|
|
201 .Vb 2
|
|
|
202 \& ID = SequentialObjectID
|
|
|
203 \& Name = "Molecule <SequentialObjectID>"
|
|
|
204 .Ve
|
|
|
205 .Sp
|
|
|
206 Examples:
|
|
|
207 .Sp
|
|
|
208 .Vb 1
|
|
|
209 \& $Molecule = new Molecule();
|
|
|
210 \&
|
|
|
211 \& $WaterMolecule = new Molecule(\*(AqName\*(Aq => \*(AqWater\*(Aq);
|
|
|
212 \&
|
|
|
213 \& $Oxygen = new Atom(\*(AqAtomSymbol\*(Aq => \*(AqO\*(Aq, \*(AqXYZ\*(Aq => [0, 0, 0]);
|
|
|
214 \& $Hydrogen1 = new Atom(\*(AqAtomSymbol\*(Aq => \*(AqH\*(Aq,
|
|
|
215 \& \*(AqXYZ\*(Aq => [0.7144, 0.4125, 0]);
|
|
|
216 \& $Hydrogen2 = new Atom(\*(AqAtomSymbol\*(Aq => \*(AqH\*(Aq,
|
|
|
217 \& \*(AqXYZ\*(Aq => [1.1208, \-0.2959, 0]);
|
|
|
218 \& $WaterMolecule\->AddAtoms($Oxygen, $Hydrogen1, $Hydrogen2);
|
|
|
219 \&
|
|
|
220 \& $Bond1 = new Bond(\*(AqAtoms\*(Aq => [$Oxygen, $Hydrogen1],
|
|
|
221 \& \*(AqBondOrder\*(Aq => 1);
|
|
|
222 \& $Bond2 = new Bond(\*(AqAtoms\*(Aq => [$Oxygen, $Hydrogen2],
|
|
|
223 \& \*(AqBondOrder\*(Aq => 1);
|
|
|
224 \& $WaterMolecule\->AddBonds($Bond1, $Bond2);
|
|
|
225 .Ve
|
|
|
226 .IP "\fBAddAtom\fR" 4
|
|
|
227 .IX Item "AddAtom"
|
|
|
228 .Vb 1
|
|
|
229 \& $Molecule\->AddAtom($Atom);
|
|
|
230 .Ve
|
|
|
231 .Sp
|
|
|
232 Adds an \fIAtom\fR to a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
233 .IP "\fBAddAtoms\fR" 4
|
|
|
234 .IX Item "AddAtoms"
|
|
|
235 .Vb 1
|
|
|
236 \& $Molecule\->AddAtoms(@Atoms);
|
|
|
237 .Ve
|
|
|
238 .Sp
|
|
|
239 Adds \fIAtoms\fR to a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
240 .IP "\fBAddBond\fR" 4
|
|
|
241 .IX Item "AddBond"
|
|
|
242 .Vb 1
|
|
|
243 \& $Molecule\->AddBond($Bond);
|
|
|
244 .Ve
|
|
|
245 .Sp
|
|
|
246 Adds a \fIBond\fR to a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
247 .IP "\fBAddBonds\fR" 4
|
|
|
248 .IX Item "AddBonds"
|
|
|
249 .Vb 1
|
|
|
250 \& $Molecule\->AddBonds(@Bonds);
|
|
|
251 .Ve
|
|
|
252 .Sp
|
|
|
253 Adds \fIBonds\fR to a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
254 .IP "\fBAddHydrogens\fR" 4
|
|
|
255 .IX Item "AddHydrogens"
|
|
|
256 .Vb 1
|
|
|
257 \& $NumOfHydrogensAdded = $Molecule\->AddHydrogens();
|
|
|
258 .Ve
|
|
|
259 .Sp
|
|
|
260 Adds hydrogens to each atom in a \fIMolecule\fR and returns total number of hydrogens
|
|
|
261 added. The current release of MayaChemTools doesn't assign hydrogen positions.
|
|
|
262 .IP "\fBAddPolarHydrogens\fR" 4
|
|
|
263 .IX Item "AddPolarHydrogens"
|
|
|
264 .Vb 1
|
|
|
265 \& $NumOfHydrogensAdded = $Molecule\->AddPolarHydrogens();
|
|
|
266 .Ve
|
|
|
267 .Sp
|
|
|
268 Adds hydrogens to each polar atom \- N, O, P or S \- in a \fIMolecule\fR and returns total
|
|
|
269 number of polar hydrogens added. The current release of MayaChemTools doesn't
|
|
|
270 assign hydrogen positions.
|
|
|
271 .IP "\fBClearRings\fR" 4
|
|
|
272 .IX Item "ClearRings"
|
|
|
273 .Vb 1
|
|
|
274 \& $Molecule\->ClearRings();
|
|
|
275 .Ve
|
|
|
276 .Sp
|
|
|
277 Deletes all rings associated with \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
278 .IP "\fBCopy\fR" 4
|
|
|
279 .IX Item "Copy"
|
|
|
280 .Vb 1
|
|
|
281 \& $MoleculeCopy = $Molecule\->Copy();
|
|
|
282 .Ve
|
|
|
283 .Sp
|
|
|
284 Copies \fIMolecule\fR and its associated data using \fBStorable::dclone\fR and returns a new
|
|
|
285 \&\fBMolecule\fR object.
|
|
|
286 .IP "\fBDeleteAromaticity\fR" 4
|
|
|
287 .IX Item "DeleteAromaticity"
|
|
|
288 .Vb 1
|
|
|
289 \& $Molecule\->DeleteAromaticity();
|
|
|
290 .Ve
|
|
|
291 .Sp
|
|
|
292 Deletes aromatic property associated with all atoms and bonds in a \fIMolecule\fR and returns
|
|
|
293 \&\fIMolecule\fR.
|
|
|
294 .IP "\fBDeleteAtom\fR" 4
|
|
|
295 .IX Item "DeleteAtom"
|
|
|
296 .Vb 1
|
|
|
297 \& $Molecule\->DeleteAtom($Atom);
|
|
|
298 .Ve
|
|
|
299 .Sp
|
|
|
300 Deletes \fIAtom\fR from a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
301 .IP "\fBDeleteAtoms\fR" 4
|
|
|
302 .IX Item "DeleteAtoms"
|
|
|
303 .Vb 1
|
|
|
304 \& $Molecule\->DeleteAtoms(@Atoms);
|
|
|
305 .Ve
|
|
|
306 .Sp
|
|
|
307 Deletes \fIAtoms\fR from a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
308 .IP "\fBDeleteBond\fR" 4
|
|
|
309 .IX Item "DeleteBond"
|
|
|
310 .Vb 1
|
|
|
311 \& $Molecule\->DeleteBond($Bond);
|
|
|
312 .Ve
|
|
|
313 .Sp
|
|
|
314 Deletes \fIBond\fR from a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
315 .IP "\fBDeleteBonds\fR" 4
|
|
|
316 .IX Item "DeleteBonds"
|
|
|
317 .Vb 1
|
|
|
318 \& $Molecule\->DeleteBonds(@Bonds);
|
|
|
319 .Ve
|
|
|
320 .Sp
|
|
|
321 Deletes \fIBonds\fR from a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
322 .IP "\fBDeleteHydrogens\fR" 4
|
|
|
323 .IX Item "DeleteHydrogens"
|
|
|
324 .Vb 1
|
|
|
325 \& $NumOfHydrogensDeleted = $Molecule\->DeleteHydrogens();
|
|
|
326 .Ve
|
|
|
327 .Sp
|
|
|
328 Removes hydrogens from each atom in a \fIMolecule\fR and returns total number of hydrogens
|
|
|
329 deleted.
|
|
|
330 .IP "\fBDeletePolarHydrogens\fR" 4
|
|
|
331 .IX Item "DeletePolarHydrogens"
|
|
|
332 .Vb 1
|
|
|
333 \& $NumOfHydrogensDeleted = $Molecule\->DeletePolarHydrogens();
|
|
|
334 .Ve
|
|
|
335 .Sp
|
|
|
336 Removes hydrogens to each polar atom \- N, O, P or S \- in a \fIMolecule\fR and returns total
|
|
|
337 number of polar hydrogens deleted.
|
|
|
338 .IP "\fBDetectAromaticity\fR" 4
|
|
|
339 .IX Item "DetectAromaticity"
|
|
|
340 .Vb 1
|
|
|
341 \& $Molecule\->DetectAromaticity();
|
|
|
342 .Ve
|
|
|
343 .Sp
|
|
|
344 Associates \fIAromatic\fR property to atoms and bonds involved in aromatic rings or ring
|
|
|
345 systems in a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
346 .Sp
|
|
|
347 This method assumes the ring detection has already been perfomed using \fBDetectRings\fR.
|
|
|
348 And any existing \fIAromatic\fR property associated with atoms and bonds is deleted before
|
|
|
349 performing aromaticity detection.
|
|
|
350 .Sp
|
|
|
351 What is aromaticity? [ Ref 124 ] It's in the code of the implementer, did you
|
|
|
352 say? Agree. The implementation of aromaticity varies widely across different
|
|
|
353 packages [ Ref 125 ]; additionally, the implementation details are not always
|
|
|
354 completely available, and it's not possible to figure out the exact implementation
|
|
|
355 of aromaticity across various packages. Using the publicly available information,
|
|
|
356 however, one can try to reproduce the available results to the extent possible,
|
|
|
357 along with parameterizing all the control parameters used to implement different
|
|
|
358 aromaticity models, and that's exactly what the current release of MayaChemTools
|
|
|
359 does.
|
|
|
360 .Sp
|
|
|
361 The implementation of aromaticity corresponding to various aromaticity models in
|
|
|
362 MayaChemTools package is driven by an external \s-1CSV\s0 file AromaticityModelsData.csv,
|
|
|
363 which is distributed with the package and is available in lib/data directory. The \s-1CSV\s0
|
|
|
364 files contains names of supported aromaticity models, along with various control
|
|
|
365 parameters and their values. This file is loaded and processed during instantiation
|
|
|
366 of Molecule class and data corresponding to specific aromaticity model are used
|
|
|
367 to detect aromaticity for that model. Any new aromaticity model added to the
|
|
|
368 aromaticity data file, using different combinations of values for existing control
|
|
|
369 parameters, would work without any changes to the code; the addition of any new
|
|
|
370 control parameters, however, requires its implementation in the code used to
|
|
|
371 calculate number of pi electrons available towards delocalization in a ring or ring
|
|
|
372 systems.
|
|
|
373 .Sp
|
|
|
374 The current release of MayaChemTools package supports these aromaticity
|
|
|
375 models: MDLAromaticityModel, TriposAromaticityModel, MMFFAromaticityModel,
|
|
|
376 ChemAxonBasicAromaticityModel, ChemAxonGeneralAromaticityModel,
|
|
|
377 DaylightAromaticityModel, MayaChemToolsAromaticityModel.
|
|
|
378 .Sp
|
|
|
379 The current list of control parameters available to detect aromaticity corresponding
|
|
|
380 to different aromaticity models are: AllowHeteroRingAtoms, HeteroRingAtomsList,
|
|
|
381 AllowExocyclicDoubleBonds, AllowHomoNuclearExocyclicDoubleBonds,
|
|
|
382 AllowElectronegativeRingAtomExocyclicDoubleBonds, AllowRingAtomFormalCharge,
|
|
|
383 AllowHeteroRingAtomFormalCharge, MinimumRingSize. The values for these control
|
|
|
384 parameters are specified in AromaticityModelsData.csv file.
|
|
|
385 .Sp
|
|
|
386 Although definition of aromaticity differs across various aromaticity models, a ring
|
|
|
387 or a ring system containing 4n + 2 pi electrons (Huckel's rule) corresponding to
|
|
|
388 alternate single and double bonds, in general, is considered aromatic.
|
|
|
389 .Sp
|
|
|
390 The available valence free electrons on heterocyclic ring atoms, involved in two single
|
|
|
391 ring bonds, are also allowed to participate in pi electron delocalizaiton for most of
|
|
|
392 the supported aromaticity models.
|
|
|
393 .Sp
|
|
|
394 The presence of exocyclic terminal double bond on ring atoms involved in pi electron
|
|
|
395 delocalization is only allowed for some of the aromaticity models. Additionally, the type
|
|
|
396 atoms involved in exocyclic terminal double bonds may result in making a ring or ring
|
|
|
397 system non-aromatic.
|
|
|
398 .Sp
|
|
|
399 For molecules containing fused rings, each fused ring set is considered as one aromatic
|
|
|
400 system for counting pi electrons to satisfy Huckel's rule; In case of a failure, rings in
|
|
|
401 fused set are treated individually for aromaticity detection. Additionally, non-fused
|
|
|
402 rings are handled on their own during aromaticity detection.
|
|
|
403 .IP "\fBDetectRings\fR" 4
|
|
|
404 .IX Item "DetectRings"
|
|
|
405 .Vb 1
|
|
|
406 \& $Molecule\->DetectRings();
|
|
|
407 .Ve
|
|
|
408 .Sp
|
|
|
409 Detects rings in a \fIMolecule\fR and returns \fIMolecule\fR. Ring detection is performed using
|
|
|
410 \&\fBDetectCycles\fR method avaible in \fBGraph\fR class which in turn uses methods available
|
|
|
411 \&\fBGraph::CyclesDetection\fR class. \fBGraph::CyclesDetection\fR class implements collapsing path graph
|
|
|
412 [Ref 31] methodology to detect all cycles in a graph.
|
|
|
413 .IP "\fBFormatElementalCompositionInformation\fR" 4
|
|
|
414 .IX Item "FormatElementalCompositionInformation"
|
|
|
415 .Vb 6
|
|
|
416 \& $FormattedInfo = $Molecule\->FormatElementalCompositionInformation(
|
|
|
417 \& $ElementsRef, $ElementCompositionRef,
|
|
|
418 \& [$Precision]);
|
|
|
419 \& $FormattedInfo = Molecule::FormatElementalCompositionInformation(
|
|
|
420 \& $ElementsRef, $ElementCompositionRef,
|
|
|
421 \& [$Precision]);
|
|
|
422 .Ve
|
|
|
423 .Sp
|
|
|
424 Using \fIElementsRef\fR and \fIElementCompositionRef\fR arrays referneces containg informatio
|
|
|
425 about elements and their composition, formats elemental composition information and returns
|
|
|
426 a \fIFormattedInfo\fR string. Defaule \fIPrecision\fR value: \fI2\fR.
|
|
|
427 .IP "\fBGetAromaticityModel\fR" 4
|
|
|
428 .IX Item "GetAromaticityModel"
|
|
|
429 .Vb 1
|
|
|
430 \& $AromaticityModel = $Molecule\->GetAromaticityModel();
|
|
|
431 .Ve
|
|
|
432 .Sp
|
|
|
433 Returns name of \fBAromaticityModel\fR set for \fIMolecule\fR corresponding to \fBAromaticityModel\fR
|
|
|
434 property or default model name of \fBMayaChemToolsAromaticityModel\fR.
|
|
|
435 .IP "\fBGetAllAtomPaths\fR" 4
|
|
|
436 .IX Item "GetAllAtomPaths"
|
|
|
437 .Vb 1
|
|
|
438 \& $AtomPathsRef = $Molecule\->GetAllAtomPaths([$AllowCycles]);
|
|
|
439 .Ve
|
|
|
440 .Sp
|
|
|
441 Returns all paths as a reference to an array containing reference to arrays with path
|
|
|
442 \&\fBAtom\fR objects.
|
|
|
443 .Sp
|
|
|
444 Path atoms correspond to to all possible paths for each atom in molecule with all
|
|
|
445 possible lengths and sharing of bonds in paths traversed. By default, rings are
|
|
|
446 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
447 .Sp
|
|
|
448 For molecule without any rings, this method returns the same set of atom paths as
|
|
|
449 \&\fBGetAtomPaths\fR method.
|
|
|
450 .IP "\fBGetAllAtomPathsStartingAt\fR" 4
|
|
|
451 .IX Item "GetAllAtomPathsStartingAt"
|
|
|
452 .Vb 2
|
|
|
453 \& $AtomPathsRef = $Molecule\->GetAllAtomPathsStartingAt($StartAtom,
|
|
|
454 \& [$AllowCycles]);
|
|
|
455 .Ve
|
|
|
456 .Sp
|
|
|
457 Returns all atom paths starting from \fIStartAtom\fR as a reference to an array containing
|
|
|
458 reference to arrays with path \fBAtom\fR objects.
|
|
|
459 .Sp
|
|
|
460 Path atoms atoms correspond to to all possible paths for specified atom in molecule with all
|
|
|
461 possible lengths and sharing of bonds in paths traversed. By default, rings are
|
|
|
462 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
463 .Sp
|
|
|
464 For molecule without any rings, this method returns the same set of atom paths as
|
|
|
465 \&\fBGetAtomPathsStartingAt\fR method.
|
|
|
466 .IP "\fBGetAllAtomPathsStartingAtWithLength\fR" 4
|
|
|
467 .IX Item "GetAllAtomPathsStartingAtWithLength"
|
|
|
468 .Vb 2
|
|
|
469 \& $AtomPathsRef = $Molecule\->GetAllAtomPathsStartingAtWithLength(
|
|
|
470 \& $StartAtom, $Length, [$AllowCycles]);
|
|
|
471 .Ve
|
|
|
472 .Sp
|
|
|
473 Returns all atom paths starting from \fIStartAtom\fR with specified \fILength\fRas a reference
|
|
|
474 to an array containing reference to arrays with path \fBAtom\fR objects.
|
|
|
475 .Sp
|
|
|
476 Path atoms atoms correspond to to all possible paths for specified atom in molecule with all
|
|
|
477 possible lengths and sharing of bonds in paths traversed. By default, rings are
|
|
|
478 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
479 .Sp
|
|
|
480 For molecule without any rings, this method returns the same set of atom paths as
|
|
|
481 \&\fBGetAtomPathsStartingAtWithLength\fR method.
|
|
|
482 .IP "\fBGetAllAtomPathsStartingAtWithLengthUpto\fR" 4
|
|
|
483 .IX Item "GetAllAtomPathsStartingAtWithLengthUpto"
|
|
|
484 .Vb 2
|
|
|
485 \& $AtomPathsRef = $Molecule\->GetAllAtomPathsStartingAtWithLengthUpto(
|
|
|
486 \& $StartAtom, $Length, [$AllowCycles]);
|
|
|
487 .Ve
|
|
|
488 .Sp
|
|
|
489 Returns atom paths starting from \fIStartAtom\fR with length up to \fILength\fR as a reference
|
|
|
490 to an array containing reference to arrays with path \fBAtom\fR objects.
|
|
|
491 .Sp
|
|
|
492 Path atoms atoms correspond to all possible paths for specified atom in molecule with length
|
|
|
493 up to a specified length and sharing of bonds in paths traversed. By default, rings are
|
|
|
494 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
495 .Sp
|
|
|
496 For molecule without any rings, this method returns the same set of atom paths as
|
|
|
497 \&\fIGetAtomPathsStartingAtWithLengthUpto\fR method.
|
|
|
498 .IP "\fBGetAllAtomPathsWithLength\fR" 4
|
|
|
499 .IX Item "GetAllAtomPathsWithLength"
|
|
|
500 .Vb 2
|
|
|
501 \& $AtomPathsRef = $Molecule\->GetAllAtomPathsWithLength($Length,
|
|
|
502 \& [$AllowCycles]);
|
|
|
503 .Ve
|
|
|
504 .Sp
|
|
|
505 Returns all atom paths with specified \fILength\fR as a reference to an array containing
|
|
|
506 reference to arrays with path \fBAtom\fR objects.
|
|
|
507 .Sp
|
|
|
508 Path atoms correspond to to all possible paths for each atom in molecule with length
|
|
|
509 up to a specified length and sharing of bonds in paths traversed. By default, rings are
|
|
|
510 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
511 .Sp
|
|
|
512 For molecule without any rings, this method returns the same set of atom paths as
|
|
|
513 as \fIGetAtomPathsWithLength\fR method.
|
|
|
514 .IP "\fBGetAllAtomPathsWithLengthUpto\fR" 4
|
|
|
515 .IX Item "GetAllAtomPathsWithLengthUpto"
|
|
|
516 .Vb 2
|
|
|
517 \& $AtomPathsRef = $Molecule\->GetAllAtomPathsWithLengthUpto($Length,
|
|
|
518 \& [$AllowCycles]);
|
|
|
519 .Ve
|
|
|
520 .Sp
|
|
|
521 Returns all atom paths with length up to \fILength\fR as a reference to an array containing
|
|
|
522 reference to arrays with path \fBAtom\fR objects.
|
|
|
523 .Sp
|
|
|
524 Path atoms correspond to to all possible paths for each atom in molecule with length
|
|
|
525 up to a specified length and sharing of bonds in paths traversed. By default, rings are
|
|
|
526 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
527 .Sp
|
|
|
528 For molecule without any rings, this method returns the same set of atom paths as
|
|
|
529 as \fIGetAtomPathsWithLengthUpto\fR method.
|
|
|
530 .IP "\fBGetAromaticRings\fR" 4
|
|
|
531 .IX Item "GetAromaticRings"
|
|
|
532 .Vb 1
|
|
|
533 \& @AtomaticRings = $Molecule\->GetAromaticRings();
|
|
|
534 .Ve
|
|
|
535 .Sp
|
|
|
536 Returns aromatic rings as an array containing references to arrays of ring \fIAtom\fR objects
|
|
|
537 in a \fIMolecule\fR.
|
|
|
538 .IP "\fBGetAtomNeighborhoods\fR" 4
|
|
|
539 .IX Item "GetAtomNeighborhoods"
|
|
|
540 .Vb 1
|
|
|
541 \& @Neighborhoods = $Molecule\->GetAtomNeighborhoods($StartAtom);
|
|
|
542 .Ve
|
|
|
543 .Sp
|
|
|
544 Returns atom neighborhoods around a \fIStartAtom\fR as an array containing references
|
|
|
545 to arrays with neighborhood \fIAtom\fR objects at possible radii.
|
|
|
546 .IP "\fBGetAtomNeighborhoodsWithRadiusUpto\fR" 4
|
|
|
547 .IX Item "GetAtomNeighborhoodsWithRadiusUpto"
|
|
|
548 .Vb 2
|
|
|
549 \& @Neighborhoods = $Molecule\->GetAtomNeighborhoodsWithRadiusUpto($StartAtom,
|
|
|
550 \& $Radius);
|
|
|
551 .Ve
|
|
|
552 .Sp
|
|
|
553 Returns atom neighborhoods around a \fIStartAtom\fR as an array containing references
|
|
|
554 to arrays with neighborhood \fIAtom\fR objects up to \fIRadius\fR.
|
|
|
555 .IP "\fBGetAtomNeighborhoodsWithSuccessorAtoms\fR" 4
|
|
|
556 .IX Item "GetAtomNeighborhoodsWithSuccessorAtoms"
|
|
|
557 .Vb 2
|
|
|
558 \& @Neighborhoods = $Molecule\->GetAtomNeighborhoodsWithSuccessorAtoms(
|
|
|
559 \& $StartAtom);
|
|
|
560 .Ve
|
|
|
561 .Sp
|
|
|
562 Returns atom neighborhood around a specified \fIStartAtom\fR, along with their successor
|
|
|
563 connected atoms, collected at all radii as an array containing references to arrays with first
|
|
|
564 value corresponding to neighborhood atom at a specific radius and second value as reference
|
|
|
565 to an array containing its successor connected atoms.
|
|
|
566 .Sp
|
|
|
567 For a neighborhood atom at each radius level, the successor connected atoms correspond to the
|
|
|
568 neighborhood atoms at the next radius level. Consequently, the neighborhood atoms at the last
|
|
|
569 radius level don't contain any successor atoms which fall outside the range of specified radius.
|
|
|
570 .IP "\fBGetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto\fR" 4
|
|
|
571 .IX Item "GetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto"
|
|
|
572 .Vb 2
|
|
|
573 \& @Neighborhoods = $Molecule\->GetAtomNeighborhoodsWithSuccessorAtomsAndRadiusUpto(
|
|
|
574 \& $StartAtom, $Radius);
|
|
|
575 .Ve
|
|
|
576 .Sp
|
|
|
577 Returns atom neighborhood around a specified \fIStartAtom\fR, along with their successor
|
|
|
578 connected atoms, collected upto specified \fIRadiud\fR as an array containing references to arrays
|
|
|
579 with first value corresponding to neighborhood atom at a specific radius and second value as
|
|
|
580 reference to an array containing its successor connected atoms.
|
|
|
581 .Sp
|
|
|
582 For a neighborhood atom at each radius level, the successor connected atoms correspond to the
|
|
|
583 neighborhood atoms at the next radius level. Consequently, the neighborhood atoms at the last
|
|
|
584 radius level don't contain any successor atoms which fall outside the range of specified radius.
|
|
|
585 .IP "\fBGetAtomPathBonds\fR" 4
|
|
|
586 .IX Item "GetAtomPathBonds"
|
|
|
587 .Vb 1
|
|
|
588 \& $Return = $Molecule\->GetAtomPathBonds(@PathAtoms);
|
|
|
589 .Ve
|
|
|
590 .Sp
|
|
|
591 Returns an array containing \fBBond\fR objects corresponding to successive pair of
|
|
|
592 atoms in \fIPathAtoms\fR
|
|
|
593 .IP "\fBGetAtomPaths\fR" 4
|
|
|
594 .IX Item "GetAtomPaths"
|
|
|
595 .Vb 1
|
|
|
596 \& $AtomPathsRef = $Molecule\->GetAtomPaths([$AllowCycles]);
|
|
|
597 .Ve
|
|
|
598 .Sp
|
|
|
599 Returns all paths as a reference to an array containing reference to arrays with path
|
|
|
600 \&\fBAtom\fR objects.
|
|
|
601 .Sp
|
|
|
602 Path atoms correspond to to all possible paths for each atom in molecule with all
|
|
|
603 possible lengths and no sharing of bonds in paths traversed. By default, rings are
|
|
|
604 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
605 .IP "\fBGetAtomPathsBetween\fR" 4
|
|
|
606 .IX Item "GetAtomPathsBetween"
|
|
|
607 .Vb 1
|
|
|
608 \& $AtomPathsRef = $Molecule\->GetAtomPathsBetween($StartAtom, $EndAtom);
|
|
|
609 .Ve
|
|
|
610 .Sp
|
|
|
611 Returns all paths as between \fIStartAtom\fR and \fIEndAtom\fR as a reference to an array
|
|
|
612 containing reference to arrays with path \fBAtom\fR objects.
|
|
|
613 .Sp
|
|
|
614 For molecules with rings, atom paths array contains may contain two paths.
|
|
|
615 .IP "\fBGetAtomPathsStartingAt\fR" 4
|
|
|
616 .IX Item "GetAtomPathsStartingAt"
|
|
|
617 .Vb 1
|
|
|
618 \& $AtomPathsRef = $Molecule\->GetAtomPathsStartingAt($StartAtom, [$AllowCycles]);
|
|
|
619 .Ve
|
|
|
620 .Sp
|
|
|
621 Returns paths starting at \fIStartAtom\fR as a reference to an array containing reference to
|
|
|
622 arrays with path \fBAtom\fR objects.
|
|
|
623 .Sp
|
|
|
624 Path atoms correspond to all possible paths for specified atom in molecule with all
|
|
|
625 possible lengths and no sharing of bonds in paths traversed. By default, rings are
|
|
|
626 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
627 .IP "\fBGetAtomPathsStartingAtWithLength\fR" 4
|
|
|
628 .IX Item "GetAtomPathsStartingAtWithLength"
|
|
|
629 .Vb 2
|
|
|
630 \& $AtomPathsRef = $Molecule\->GetAtomPathsStartingAtWithLength($StartAtom,
|
|
|
631 \& $Length, [$AllowCycles]);
|
|
|
632 .Ve
|
|
|
633 .Sp
|
|
|
634 Returns paths starting at \fIStartAtom\fR with length \fILength\fR as a reference to an array
|
|
|
635 containing reference to arrays with path \fBAtom\fR objects.
|
|
|
636 .Sp
|
|
|
637 Path atoms correspond to all possible paths for specified atom in molecule with length
|
|
|
638 upto a specified length and no sharing of bonds in paths traversed. By default, rings are
|
|
|
639 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
640 .IP "\fBGetAtomPathsStartingAtWithLengthUpto\fR" 4
|
|
|
641 .IX Item "GetAtomPathsStartingAtWithLengthUpto"
|
|
|
642 .Vb 2
|
|
|
643 \& $AtomPathsRef = $Molecule\->GetAtomPathsStartingAtWithLengthUpto($StartAtom,
|
|
|
644 \& $Length, [$AllowCycles]);
|
|
|
645 .Ve
|
|
|
646 .Sp
|
|
|
647 Returns paths starting at \fIStartAtom\fR with length up to \fILength\fR as a reference to an array
|
|
|
648 containing reference to arrays with path \fBAtom\fR objects.
|
|
|
649 .Sp
|
|
|
650 Path atoms correspond to all possible paths for specified atom in molecule with length
|
|
|
651 upto a specified length and no sharing of bonds in paths traversed. By default, rings are
|
|
|
652 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
653 .IP "\fBGetAtomPathsWithLength\fR" 4
|
|
|
654 .IX Item "GetAtomPathsWithLength"
|
|
|
655 .Vb 1
|
|
|
656 \& $AtomPathsRef = $Molecule\->GetAtomPathsWithLength($Length, [$AllowCycles]);
|
|
|
657 .Ve
|
|
|
658 .Sp
|
|
|
659 Returns all paths with specified \fILength\fR as a reference to an array containing reference
|
|
|
660 to arrays with path \fBAtom\fR objects.
|
|
|
661 .Sp
|
|
|
662 Path atoms correspond to all possible paths for each atom in molecule with length
|
|
|
663 upto a specified length and no sharing of bonds in paths traversed. By default, rings are
|
|
|
664 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
665 .IP "\fBGetAtomPathsWithLengthUpto\fR" 4
|
|
|
666 .IX Item "GetAtomPathsWithLengthUpto"
|
|
|
667 .Vb 1
|
|
|
668 \& $AtomPathsRef = $Molecule\->GetAtomPathsWithLengthUpto($Length, [$AllowCycles]);
|
|
|
669 .Ve
|
|
|
670 .Sp
|
|
|
671 Returns all paths with length up to \fILength\fR as a reference to an array containing reference
|
|
|
672 to arrays with path \fBAtom\fR objects.
|
|
|
673 .Sp
|
|
|
674 Path atoms correspond to all possible paths for each atom in molecule with length
|
|
|
675 upto a specified length and no sharing of bonds in paths traversed. By default, rings are
|
|
|
676 included in paths. A path containing a ring is terminated at an atom completing the ring.
|
|
|
677 .IP "\fBGetAtoms\fR" 4
|
|
|
678 .IX Item "GetAtoms"
|
|
|
679 .Vb 2
|
|
|
680 \& @AllAtoms = $Molecule\->GetAtoms();
|
|
|
681 \& @PolarAtoms = $Molecule\->GetAtoms(\*(AqIsPolarAtom\*(Aq);
|
|
|
682 \&
|
|
|
683 \& $NegateMethodResult = 1;
|
|
|
684 \& @NonHydrogenAtoms = $Molecule\->GetAtoms(\*(AqIsHydrogenAtom\*(Aq,
|
|
|
685 \& $NegateMethodResult);
|
|
|
686 \&
|
|
|
687 \& $AtomsCount = $Molecule\->GetAtoms();
|
|
|
688 .Ve
|
|
|
689 .Sp
|
|
|
690 Returns an array of \fIAtoms\fR in a \fIMolecule\fR. In scalar context, it returns number of atoms.
|
|
|
691 Additionally, \fBAtoms\fR array can be filtered by any user specifiable valid \fBAtom\fR class method
|
|
|
692 and the result of the \fBAtom\fR class method used to filter the atoms can also be negated by
|
|
|
693 an optional negate results flag as third parameter.
|
|
|
694 .IP "\fBGetBonds\fR" 4
|
|
|
695 .IX Item "GetBonds"
|
|
|
696 .Vb 2
|
|
|
697 \& @Bonds = $Molecule\->GetBonds();
|
|
|
698 \& $BondsCount = $Molecule\->GetBonds();
|
|
|
699 .Ve
|
|
|
700 .Sp
|
|
|
701 Returns an array of \fIBonds\fR in a \fIMolecule\fR. In scalar context, it returns number of bonds.
|
|
|
702 .IP "\fBGetCharge\fR" 4
|
|
|
703 .IX Item "GetCharge"
|
|
|
704 .Vb 1
|
|
|
705 \& $Charge = $Molecule\->GetCharge();
|
|
|
706 .Ve
|
|
|
707 .Sp
|
|
|
708 Returns net charge on a \fIMolecule\fR using one of the following two methods: explicitly
|
|
|
709 set \fBCharge\fR property or sum of partial atomic charges on each atom.
|
|
|
710 .IP "\fBGetConnectedComponents\fR" 4
|
|
|
711 .IX Item "GetConnectedComponents"
|
|
|
712 .Vb 1
|
|
|
713 \& @ConnectedComponents = $Molecule\->GetConnectedComponents();
|
|
|
714 .Ve
|
|
|
715 .Sp
|
|
|
716 Returns a reference to an array containing \fIMolecule\fR objects corresponding
|
|
|
717 to connected components sorted in decreasing order of component size in a \fIMolecule\fR.
|
|
|
718 .IP "\fBGetConnectedComponentsAtoms\fR" 4
|
|
|
719 .IX Item "GetConnectedComponentsAtoms"
|
|
|
720 .Vb 2
|
|
|
721 \& @ConnectedComponentsAtoms =
|
|
|
722 \& $Molecule\->GetConnectedComponentsAtoms();
|
|
|
723 .Ve
|
|
|
724 .Sp
|
|
|
725 Returns an array containing references to arrays with \fIAtom\fR objects corresponding to
|
|
|
726 atoms of connected components sorted in order of component decreasing size in a
|
|
|
727 \&\fIMolecule\fR.
|
|
|
728 .IP "\fBGetDimensionality\fR" 4
|
|
|
729 .IX Item "GetDimensionality"
|
|
|
730 .Vb 1
|
|
|
731 \& $Dimensionality = $Molecule\->GetDimensionality();
|
|
|
732 .Ve
|
|
|
733 .Sp
|
|
|
734 Returns \fIDimensionality\fR of a \fIMolecule\fR corresponding to explicitly set
|
|
|
735 \&\fIDimensionality\fR property value or by processing atomic.
|
|
|
736 .Sp
|
|
|
737 The \fIDimensionality\fR value from atomic coordinates is calculated as follows:
|
|
|
738 .Sp
|
|
|
739 .Vb 4
|
|
|
740 \& 3D \- Three dimensional: One of X, Y or Z coordinate is non\-zero
|
|
|
741 \& 2D \- Two dimensional: One of X or Y coordinate is non\-zero; All Z
|
|
|
742 \& coordinates are zero
|
|
|
743 \& 0D \- Zero dimensional: All atomic coordinates are zero
|
|
|
744 .Ve
|
|
|
745 .IP "\fBGetElementalComposition\fR" 4
|
|
|
746 .IX Item "GetElementalComposition"
|
|
|
747 .Vb 2
|
|
|
748 \& ($ElementsRef, $CompositionRef) =
|
|
|
749 \& $Molecule\->GetElementalComposition([$IncludeMissingHydrogens]);
|
|
|
750 .Ve
|
|
|
751 .Sp
|
|
|
752 Calculates elemental composition and returns references to arrays containing elements
|
|
|
753 and their percent composition in a \fIMolecule\fR. By default, missing hydrogens are included
|
|
|
754 during the calculation.
|
|
|
755 .IP "\fBGetElementsAndNonElements\fR" 4
|
|
|
756 .IX Item "GetElementsAndNonElements"
|
|
|
757 .Vb 2
|
|
|
758 \& ($ElementsRef, $NonElementsRef) =
|
|
|
759 \& $Molecule\->GetElementsAndNonElements([$IncludeMissingHydrogens]);
|
|
|
760 .Ve
|
|
|
761 .Sp
|
|
|
762 Counts elements and non-elements in a \fIMolecule\fR and returns references to hashes
|
|
|
763 containing element and non-element as hash keys with values corresponding to their
|
|
|
764 count. By default, missing hydrogens are not added to the element hash.
|
|
|
765 .IP "\fBGetExactMass\fR" 4
|
|
|
766 .IX Item "GetExactMass"
|
|
|
767 .Vb 1
|
|
|
768 \& $ExactMass = $Molecule\->GetExactMass();
|
|
|
769 .Ve
|
|
|
770 .Sp
|
|
|
771 Returns exact mass of a \fIMolecule\fR corresponding to sum of exact masses of all
|
|
|
772 the atoms.
|
|
|
773 .IP "\fBGetFormalCharge\fR" 4
|
|
|
774 .IX Item "GetFormalCharge"
|
|
|
775 .Vb 1
|
|
|
776 \& $FormalCharge = $Molecule\->GetFormalCharge();
|
|
|
777 .Ve
|
|
|
778 .Sp
|
|
|
779 Returns net formal charge on a \fIMolecule\fR using one of the following two methods: explicitly
|
|
|
780 set \fBFormalCharge\fR property or sum of formal charges on each atom.
|
|
|
781 .Sp
|
|
|
782 \&\fBFormalCharge\fR is different from \fBCharge\fR property of the molecule which corresponds to
|
|
|
783 sum of partial atomic charges explicitly set for each atom using a specific methodology.
|
|
|
784 .IP "\fBGetFreeRadicalElectrons\fR" 4
|
|
|
785 .IX Item "GetFreeRadicalElectrons"
|
|
|
786 .Vb 1
|
|
|
787 \& $FreeRadicalElectrons = $Molecule\->GetFreeRadicalElectrons();
|
|
|
788 .Ve
|
|
|
789 .Sp
|
|
|
790 Returns total number of free radical electrons available in a \fIMolecule\fR using one of the
|
|
|
791 following two methods: explicitly set \fBFreeRadicalElectrons\fR property or sum of available
|
|
|
792 free radical electrons on each atom.
|
|
|
793 .IP "\fBGetFusedAndNonFusedRings\fR" 4
|
|
|
794 .IX Item "GetFusedAndNonFusedRings"
|
|
|
795 .Vb 2
|
|
|
796 \& ($FusedRingSetRef, $NonFusedRingsRef) =
|
|
|
797 \& $Molecule\->GetFusedAndNonFusedRings();
|
|
|
798 .Ve
|
|
|
799 .Sp
|
|
|
800 Returns references to array of fused ring sets and non-fused rings in a \fIMolecule\fR. Fused ring sets
|
|
|
801 array reference contains refernces to arrays of rings corresponding to ring \fIAtom\fR objects;
|
|
|
802 Non-fused rings array reference contains references to arrays of ring \fIAtom\fR objects.
|
|
|
803 .IP "\fBGetLargestConnectedComponent\fR" 4
|
|
|
804 .IX Item "GetLargestConnectedComponent"
|
|
|
805 .Vb 1
|
|
|
806 \& $ComponentMolecule = $Molecule\->GetLargestConnectedComponent();
|
|
|
807 .Ve
|
|
|
808 .Sp
|
|
|
809 Returns a reference to \fBMolecule\fR object corresponding to a largest connected component
|
|
|
810 in a \fIMolecule\fR.
|
|
|
811 .IP "\fBGetLargestConnectedComponentAtoms\fR" 4
|
|
|
812 .IX Item "GetLargestConnectedComponentAtoms"
|
|
|
813 .Vb 1
|
|
|
814 \& @ComponentAtoms = $Molecule\->GetLargestConnectedComponentAtoms();
|
|
|
815 .Ve
|
|
|
816 .Sp
|
|
|
817 Returns a reference to an array of \fBAtom\fR objects corresponding to a largest connected
|
|
|
818 component in a \fIMolecule\fR.
|
|
|
819 .IP "\fBGetLargestRing\fR" 4
|
|
|
820 .IX Item "GetLargestRing"
|
|
|
821 .Vb 1
|
|
|
822 \& @RingAtoms = $Molecule\->GetLargestRing();
|
|
|
823 .Ve
|
|
|
824 .Sp
|
|
|
825 Returns an array of \fIAtoms\fR objects corresponding to a largest ring in a \fIMolecule\fR.
|
|
|
826 .IP "\fBGetMolecularFormula\fR" 4
|
|
|
827 .IX Item "GetMolecularFormula"
|
|
|
828 .Vb 3
|
|
|
829 \& $FormulaString = $Molecule\->GetMolecularFormula(
|
|
|
830 \& [$IncludeMissingHydrogens,
|
|
|
831 \& $IncludeNonElements]);
|
|
|
832 .Ve
|
|
|
833 .Sp
|
|
|
834 Returns molecular formula of a \fIMolecule\fR by collecting information about all atoms in
|
|
|
835 the molecule and composing the formula using Hills ordering system:
|
|
|
836 .Sp
|
|
|
837 .Vb 4
|
|
|
838 \& o C shows up first and H follows assuming C is present.
|
|
|
839 \& o All other standard elements are sorted alphanumerically.
|
|
|
840 \& o All other non\-stanard atom symbols are also sorted
|
|
|
841 \& alphanumerically and follow standard elements.
|
|
|
842 .Ve
|
|
|
843 .Sp
|
|
|
844 Notes:
|
|
|
845 .Sp
|
|
|
846 .Vb 4
|
|
|
847 \& o By default, missing hydrogens and nonelements are also included.
|
|
|
848 \& o Elements for disconnected fragments are combined into the same
|
|
|
849 \& formula.
|
|
|
850 \& o Formal charge is also used during compoisiton of molecular formula.
|
|
|
851 .Ve
|
|
|
852 .IP "\fBGetMolecularWeight\fR" 4
|
|
|
853 .IX Item "GetMolecularWeight"
|
|
|
854 .Vb 1
|
|
|
855 \& $MolWeight = $Molecule\->GetMolecularWeight();
|
|
|
856 .Ve
|
|
|
857 .Sp
|
|
|
858 Returns molecular weight of a \fIMolecule\fR corresponding to sum of atomic weights of all
|
|
|
859 the atoms.
|
|
|
860 .IP "\fBGetNumOfAromaticRings\fR" 4
|
|
|
861 .IX Item "GetNumOfAromaticRings"
|
|
|
862 .Vb 1
|
|
|
863 \& $NumOfAromaticRings = $Molecule\->GetNumOfAromaticRings();
|
|
|
864 .Ve
|
|
|
865 .Sp
|
|
|
866 Returns number of aromatic rings in a \fIMolecule\fR.
|
|
|
867 .IP "\fBGetNumOfAtoms\fR" 4
|
|
|
868 .IX Item "GetNumOfAtoms"
|
|
|
869 .Vb 1
|
|
|
870 \& $NumOfAtoms = $Molecule\->GetNumOfAtoms();
|
|
|
871 .Ve
|
|
|
872 .Sp
|
|
|
873 Returns number of atoms in a \fIMolecule\fR.
|
|
|
874 .IP "\fBGetNumOfBonds\fR" 4
|
|
|
875 .IX Item "GetNumOfBonds"
|
|
|
876 .Vb 1
|
|
|
877 \& $NumOfBonds = $Molecule\->GetNumOfBonds();
|
|
|
878 .Ve
|
|
|
879 .Sp
|
|
|
880 Returns number of bonds in a \fIMolecule\fR.
|
|
|
881 .IP "\fBGetNumOfConnectedComponents\fR" 4
|
|
|
882 .IX Item "GetNumOfConnectedComponents"
|
|
|
883 .Vb 1
|
|
|
884 \& $NumOfComponents = $Molecule\->GetNumOfConnectedComponents();
|
|
|
885 .Ve
|
|
|
886 .Sp
|
|
|
887 Returns number of connected components in a \fIMolecule\fR.
|
|
|
888 .IP "\fBGetNumOfElementsAndNonElements\fR" 4
|
|
|
889 .IX Item "GetNumOfElementsAndNonElements"
|
|
|
890 .Vb 4
|
|
|
891 \& ($NumOfElements, $NumOfNonElements) = $Molecule\->
|
|
|
892 \& GetNumOfElementsAndNonElements();
|
|
|
893 \& ($NumOfElements, $NumOfNonElements) = $Molecule\->
|
|
|
894 \& GetNumOfElementsAndNonElements($IncludeMissingHydrogens);
|
|
|
895 .Ve
|
|
|
896 .Sp
|
|
|
897 Returns number of elements and non-elements in a \fIMolecule\fR. By default, missing
|
|
|
898 hydrogens are not added to element count.
|
|
|
899 .IP "\fBGetNumOfHeavyAtoms\fR" 4
|
|
|
900 .IX Item "GetNumOfHeavyAtoms"
|
|
|
901 .Vb 1
|
|
|
902 \& $NumOfHeavyAtoms = $Molecule\->GetNumOfHeavyAtoms();
|
|
|
903 .Ve
|
|
|
904 .Sp
|
|
|
905 Returns number of heavy atoms, non-hydrogen atoms, in a \fIMolecule\fR.
|
|
|
906 .IP "\fBGetNumOfHydrogenAtoms\fR" 4
|
|
|
907 .IX Item "GetNumOfHydrogenAtoms"
|
|
|
908 .Vb 1
|
|
|
909 \& $NumOfHydrogenAtoms = $Molecule\->GetNumOfHydrogenAtoms();
|
|
|
910 .Ve
|
|
|
911 .Sp
|
|
|
912 Returns number of hydrogen atoms in a \fIMolecule\fR.
|
|
|
913 .IP "\fBGetNumOfMissingHydrogenAtoms\fR" 4
|
|
|
914 .IX Item "GetNumOfMissingHydrogenAtoms"
|
|
|
915 .Vb 1
|
|
|
916 \& $NumOfMissingHydrogenAtoms = $Molecule\->GetNumOfMissingHydrogenAtoms();
|
|
|
917 .Ve
|
|
|
918 .Sp
|
|
|
919 Returns number of hydrogen atoms in a \fIMolecule\fR.
|
|
|
920 .IP "\fBGetNumOfNonHydrogenAtoms\fR" 4
|
|
|
921 .IX Item "GetNumOfNonHydrogenAtoms"
|
|
|
922 .Vb 1
|
|
|
923 \& $NumOfNonHydrogenAtoms = $Molecule\->GetNumOfNonHydrogenAtoms();
|
|
|
924 .Ve
|
|
|
925 .Sp
|
|
|
926 Returns number of non-hydrogen atoms in a \fIMolecule\fR.
|
|
|
927 .IP "\fBGetNumOfRings\fR" 4
|
|
|
928 .IX Item "GetNumOfRings"
|
|
|
929 .Vb 1
|
|
|
930 \& $RingCount = $Molecule\->GetNumOfRings();
|
|
|
931 .Ve
|
|
|
932 .Sp
|
|
|
933 Returns number of rings in a \fIMolecule\fR.
|
|
|
934 .IP "\fBGetNumOfRingsWithEvenSize\fR" 4
|
|
|
935 .IX Item "GetNumOfRingsWithEvenSize"
|
|
|
936 .Vb 1
|
|
|
937 \& $RingCount = $Molecule\->GetNumOfRingsWithEvenSize();
|
|
|
938 .Ve
|
|
|
939 .Sp
|
|
|
940 Returns number of rings with even size in a \fIMolecule\fR.
|
|
|
941 .IP "\fBGetNumOfRingsWithOddSize\fR" 4
|
|
|
942 .IX Item "GetNumOfRingsWithOddSize"
|
|
|
943 .Vb 1
|
|
|
944 \& $RingCount = $Molecule\->GetNumOfRingsWithOddSize();
|
|
|
945 .Ve
|
|
|
946 .Sp
|
|
|
947 Returns number of rings with odd size in a \fIMolecule\fR.
|
|
|
948 .IP "\fBGetNumOfRingsWithSize\fR" 4
|
|
|
949 .IX Item "GetNumOfRingsWithSize"
|
|
|
950 .Vb 1
|
|
|
951 \& $RingCount = $Molecule\->GetNumOfRingsWithSize($Size);
|
|
|
952 .Ve
|
|
|
953 .Sp
|
|
|
954 Returns number of rings with \fISize\fR in a \fIMolecule\fR.
|
|
|
955 .IP "\fBGetNumOfRingsWithSizeGreaterThan\fR" 4
|
|
|
956 .IX Item "GetNumOfRingsWithSizeGreaterThan"
|
|
|
957 .Vb 1
|
|
|
958 \& $RingCount = $Molecule\->GetNumOfRingsWithSizeGreaterThan($Size);
|
|
|
959 .Ve
|
|
|
960 .Sp
|
|
|
961 Returns number of rings with size greater than \fISize\fR in a \fIMolecule\fR.
|
|
|
962 .IP "\fBGetNumOfRingsWithSizeLessThan\fR" 4
|
|
|
963 .IX Item "GetNumOfRingsWithSizeLessThan"
|
|
|
964 .Vb 1
|
|
|
965 \& $RingCount = $Molecule\->GetNumOfRingsWithSizeLessThan($Size);
|
|
|
966 .Ve
|
|
|
967 .Sp
|
|
|
968 Returns number of rings with size less than \fISize\fR in a \fIMolecule\fR.
|
|
|
969 .IP "\fBGetRingBonds\fR" 4
|
|
|
970 .IX Item "GetRingBonds"
|
|
|
971 .Vb 1
|
|
|
972 \& @RingBonds = $Molecule\->GetRingBonds(@RingAtoms);
|
|
|
973 .Ve
|
|
|
974 .Sp
|
|
|
975 Returns an array of ring \fBBond\fR objects correponding to an array of ring \fIAtoms\fR in a
|
|
|
976 \&\fIMolecule\fR.
|
|
|
977 .IP "\fBGetRingBondsFromRings\fR" 4
|
|
|
978 .IX Item "GetRingBondsFromRings"
|
|
|
979 .Vb 1
|
|
|
980 \& @RingBondsSets = $Molecule\->GetRingBondsFromRings(@RingAtomsSets);
|
|
|
981 .Ve
|
|
|
982 .Sp
|
|
|
983 Returns an array containing references to arrays of ring \fBBond\fR objects for rings specified
|
|
|
984 in an array of references to ring \fIAtom\fR objects.
|
|
|
985 .IP "\fBGetRings\fR" 4
|
|
|
986 .IX Item "GetRings"
|
|
|
987 .Vb 1
|
|
|
988 \& @Rings = $Molecule\->GetRings();
|
|
|
989 .Ve
|
|
|
990 .Sp
|
|
|
991 Returns rings as an array containing references to arrays of ring \fIAtom\fR objects in a \fIMolecule\fR.
|
|
|
992 .IP "\fBGetRingsWithEvenSize\fR" 4
|
|
|
993 .IX Item "GetRingsWithEvenSize"
|
|
|
994 .Vb 1
|
|
|
995 \& @Rings = $Molecule\->GetRingsWithEvenSize();
|
|
|
996 .Ve
|
|
|
997 .Sp
|
|
|
998 Returns even size rings as an array containing references to arrays of ring \fIAtom\fR objects in
|
|
|
999 a \fIMolecule\fR.
|
|
|
1000 .IP "\fBGetRingsWithOddSize\fR" 4
|
|
|
1001 .IX Item "GetRingsWithOddSize"
|
|
|
1002 .Vb 1
|
|
|
1003 \& @Rings = $Molecule\->GetRingsWithOddSize();
|
|
|
1004 .Ve
|
|
|
1005 .Sp
|
|
|
1006 Returns odd size rings as an array containing references to arrays of ring \fIAtom\fR objects in
|
|
|
1007 a \fIMolecule\fR.
|
|
|
1008 .IP "\fBGetRingsWithSize\fR" 4
|
|
|
1009 .IX Item "GetRingsWithSize"
|
|
|
1010 .Vb 1
|
|
|
1011 \& @Rings = $Molecule\->GetRingsWithSize($Size);
|
|
|
1012 .Ve
|
|
|
1013 .Sp
|
|
|
1014 Returns rings with \fISize\fR as an array containing references to arrays of ring \fIAtom\fR objects in
|
|
|
1015 a \fIMolecule\fR.
|
|
|
1016 .IP "\fBGetRingsWithSizeGreaterThan\fR" 4
|
|
|
1017 .IX Item "GetRingsWithSizeGreaterThan"
|
|
|
1018 .Vb 1
|
|
|
1019 \& @Rings = $Molecule\->GetRingsWithSizeGreaterThan($Size);
|
|
|
1020 .Ve
|
|
|
1021 .Sp
|
|
|
1022 Returns rings with size greater than \fISize\fR as an array containing references to arrays of
|
|
|
1023 ring \fIAtom\fR objects in a \fIMolecule\fR.
|
|
|
1024 .IP "\fBGetRingsWithSizeLessThan\fR" 4
|
|
|
1025 .IX Item "GetRingsWithSizeLessThan"
|
|
|
1026 .Vb 1
|
|
|
1027 \& @Rings = $Molecule\->GetRingsWithSizeLessThan($Size);
|
|
|
1028 .Ve
|
|
|
1029 .Sp
|
|
|
1030 Returns rings with size less than \fISize\fR as an array containing references to arrays of
|
|
|
1031 ring \fIAtom\fR objects in a \fIMolecule\fR.
|
|
|
1032 .IP "\fBGetSizeOfLargestRing\fR" 4
|
|
|
1033 .IX Item "GetSizeOfLargestRing"
|
|
|
1034 .Vb 1
|
|
|
1035 \& $Size = $Molecule\->GetSizeOfLargestRing();
|
|
|
1036 .Ve
|
|
|
1037 .Sp
|
|
|
1038 Returns size of the largest ring in a \fIMolecule\fR.
|
|
|
1039 .IP "\fBGetSizeOfSmallestRing\fR" 4
|
|
|
1040 .IX Item "GetSizeOfSmallestRing"
|
|
|
1041 .Vb 1
|
|
|
1042 \& $Size = $Molecule\->GetSizeOfSmallestRing();
|
|
|
1043 .Ve
|
|
|
1044 .Sp
|
|
|
1045 Returns size of the smalles ring in a \fIMolecule\fR.
|
|
|
1046 .IP "\fBGetSmallestRing\fR" 4
|
|
|
1047 .IX Item "GetSmallestRing"
|
|
|
1048 .Vb 1
|
|
|
1049 \& @RingAtoms = $Molecule\->GetSmallestRing();
|
|
|
1050 .Ve
|
|
|
1051 .Sp
|
|
|
1052 Returns an array containing \fIAtom\fR objects corresponding to the smallest ring in
|
|
|
1053 a \fIMolecule\fR.
|
|
|
1054 .IP "\fBGetSpinMultiplicity\fR" 4
|
|
|
1055 .IX Item "GetSpinMultiplicity"
|
|
|
1056 .Vb 1
|
|
|
1057 \& $SpinMultiplicity = $Molecule\->GetSpinMultiplicity();
|
|
|
1058 .Ve
|
|
|
1059 .Sp
|
|
|
1060 Returns net spin multiplicity of a \fIMolecule\fR using one of the following two methods: explicitly
|
|
|
1061 set \fBSpinMultiplicity\fR property or sum of spin multiplicity on each atom.
|
|
|
1062 .IP "\fBGetSupportedAromaticityModels\fR" 4
|
|
|
1063 .IX Item "GetSupportedAromaticityModels"
|
|
|
1064 .Vb 1
|
|
|
1065 \& @SupportedModels = $Molecule\->GetSupportedAromaticityModels();
|
|
|
1066 .Ve
|
|
|
1067 .Sp
|
|
|
1068 Returns an array containing a list of supported aromaticity models.
|
|
|
1069 .IP "\fBGetValenceModel\fR" 4
|
|
|
1070 .IX Item "GetValenceModel"
|
|
|
1071 .Vb 1
|
|
|
1072 \& $ValenceModel = $Molecule\->GetValenceModel();
|
|
|
1073 .Ve
|
|
|
1074 .Sp
|
|
|
1075 Returns valence model for \fIMolecule\fR using one of the following two methods: explicitly
|
|
|
1076 set \fBValenceModel\fR property or defaul value of \fIInternalValenceModel\fR.
|
|
|
1077 .IP "\fBGetTopologicallySortedAtoms\fR" 4
|
|
|
1078 .IX Item "GetTopologicallySortedAtoms"
|
|
|
1079 .Vb 1
|
|
|
1080 \& @SortedAtoms = $Molecule\->GetTopologicallySortedAtoms([$StartAtom]);
|
|
|
1081 .Ve
|
|
|
1082 .Sp
|
|
|
1083 Returns an array of topologically sorted \fIAtom\fR objects starting from \fIStartAtom\fR or
|
|
|
1084 an arbitrary atom in a \fIMolecule\fR.
|
|
|
1085 .IP "\fBHasAromaticRings\fR" 4
|
|
|
1086 .IX Item "HasAromaticRings"
|
|
|
1087 .Vb 1
|
|
|
1088 \& $Status = $Molecule\->HasAromaticRings();
|
|
|
1089 .Ve
|
|
|
1090 .Sp
|
|
|
1091 Returns 1 or 0 based on whether any aromatic ring is present in a \fIMolecule\fR.
|
|
|
1092 .IP "\fBHasAromaticAtomsInRings\fR" 4
|
|
|
1093 .IX Item "HasAromaticAtomsInRings"
|
|
|
1094 .Vb 1
|
|
|
1095 \& $Status = $Molecule\->HasAromaticAtomsInRings();
|
|
|
1096 .Ve
|
|
|
1097 .Sp
|
|
|
1098 Returns 1 or 0 based on whether any aromatic ring atom is present in a \fIMolecule\fR.
|
|
|
1099 .IP "\fBHasAromaticAtomsNotInRings\fR" 4
|
|
|
1100 .IX Item "HasAromaticAtomsNotInRings"
|
|
|
1101 .Vb 1
|
|
|
1102 \& $Status = $Molecule\->HasAromaticAtomsNotInRings();
|
|
|
1103 .Ve
|
|
|
1104 .Sp
|
|
|
1105 Returns 1 or 0 based on whether any non-ring atom is marked aromatic in a \fIMolecule\fR.
|
|
|
1106 .IP "\fBHasAtom\fR" 4
|
|
|
1107 .IX Item "HasAtom"
|
|
|
1108 .Vb 1
|
|
|
1109 \& $Status = $Molecule\->HasAtom($Atom);
|
|
|
1110 .Ve
|
|
|
1111 .Sp
|
|
|
1112 Returns 1 or 0 based on whether \fIAtom\fR is present in a \fIMolecule\fR.
|
|
|
1113 .IP "\fBHasBond\fR" 4
|
|
|
1114 .IX Item "HasBond"
|
|
|
1115 .Vb 1
|
|
|
1116 \& $Status = $Molecule\->HasBond($Bond);
|
|
|
1117 .Ve
|
|
|
1118 .Sp
|
|
|
1119 Returns 1 or 0 based on whether \fIBond\fR is present in a \fIMolecule\fR.
|
|
|
1120 .IP "\fBHasFusedRings\fR" 4
|
|
|
1121 .IX Item "HasFusedRings"
|
|
|
1122 .Vb 1
|
|
|
1123 \& $Status = $Molecule\->HasFusedRings();
|
|
|
1124 .Ve
|
|
|
1125 .Sp
|
|
|
1126 Returns 1 or 0 based on whether any fused rings set is present in a \fIMolecule\fR.
|
|
|
1127 .IP "\fBHasNoRings\fR" 4
|
|
|
1128 .IX Item "HasNoRings"
|
|
|
1129 .Vb 1
|
|
|
1130 \& $Status = $Molecule\->HasNoRings();
|
|
|
1131 .Ve
|
|
|
1132 .Sp
|
|
|
1133 Returns 0 or 1 based on whether any ring is present in a \fIMolecule\fR.
|
|
|
1134 .IP "\fBHasOnlyOneRing\fR" 4
|
|
|
1135 .IX Item "HasOnlyOneRing"
|
|
|
1136 .Vb 1
|
|
|
1137 \& $Status = $Molecule\->HasOnlyOneRing();
|
|
|
1138 .Ve
|
|
|
1139 .Sp
|
|
|
1140 Returns 1 or 0 based on whether only one ring is present in a \fIMolecule\fR.
|
|
|
1141 .IP "\fBHasRings\fR" 4
|
|
|
1142 .IX Item "HasRings"
|
|
|
1143 .Vb 1
|
|
|
1144 \& $Status = $Molecule\->HasRings();
|
|
|
1145 .Ve
|
|
|
1146 .Sp
|
|
|
1147 Returns 1 or 0 based on whether rings are present in a \fIMolecule\fR.
|
|
|
1148 .IP "\fBIsAromatic\fR" 4
|
|
|
1149 .IX Item "IsAromatic"
|
|
|
1150 .Vb 1
|
|
|
1151 \& $Status = $Molecule\->IsAromatic();
|
|
|
1152 .Ve
|
|
|
1153 .Sp
|
|
|
1154 Returns 1 or 0 based on whether \fIMolecule\fR is aromatic.
|
|
|
1155 .IP "\fBIsMolecule\fR" 4
|
|
|
1156 .IX Item "IsMolecule"
|
|
|
1157 .Vb 1
|
|
|
1158 \& $Status = Molecule::IsMolecule();
|
|
|
1159 .Ve
|
|
|
1160 .Sp
|
|
|
1161 Returns 1 or 0 based on whether \fIObject\fR is a \fBMolecule\fR object.
|
|
|
1162 .IP "\fBIsRingAromatic\fR" 4
|
|
|
1163 .IX Item "IsRingAromatic"
|
|
|
1164 .Vb 1
|
|
|
1165 \& $Status = $Molecule\->IsRingAromatic(@RingAtoms);
|
|
|
1166 .Ve
|
|
|
1167 .Sp
|
|
|
1168 Returns 1 or 0 based on whether all \fIRingAtoms\fR are aromatic.
|
|
|
1169 .IP "\fBIsSupportedAromaticityModel\fR" 4
|
|
|
1170 .IX Item "IsSupportedAromaticityModel"
|
|
|
1171 .Vb 2
|
|
|
1172 \& $Status = $Molecule\->IsSupportedAromaticityModel($AromaticityModel);
|
|
|
1173 \& $Status = Molecule::IsSupportedAromaticityModel($AromaticityModel);
|
|
|
1174 .Ve
|
|
|
1175 .Sp
|
|
|
1176 Returns 1 or 0 based on whether specified \fIAromaticityModel\fR is supported.
|
|
|
1177 .IP "\fBIsTwoDimensional\fR" 4
|
|
|
1178 .IX Item "IsTwoDimensional"
|
|
|
1179 .Vb 1
|
|
|
1180 \& $Status = $Molecule\->IsTwoDimensional();
|
|
|
1181 .Ve
|
|
|
1182 .Sp
|
|
|
1183 Returns 1 or 0 based on whether any atom in \fIMolecule\fR has a non-zero value
|
|
|
1184 for X or Y coordinate and all atoms have zero value for Z coordinates.
|
|
|
1185 .IP "\fBIsThreeDimensional\fR" 4
|
|
|
1186 .IX Item "IsThreeDimensional"
|
|
|
1187 .Vb 1
|
|
|
1188 \& $Status = $Molecule\->IsThreeDimensional();
|
|
|
1189 .Ve
|
|
|
1190 .Sp
|
|
|
1191 Returns 1 or 0 based on whether any atom in \fIMolecule\fR has a non-zero value
|
|
|
1192 for Z coordinate.
|
|
|
1193 .IP "\fBKeepLargestComponent\fR" 4
|
|
|
1194 .IX Item "KeepLargestComponent"
|
|
|
1195 .Vb 1
|
|
|
1196 \& $Molecule\->KeepLargestComponent();
|
|
|
1197 .Ve
|
|
|
1198 .Sp
|
|
|
1199 Deletes atoms corresponding to all other connected components Except for the largest
|
|
|
1200 connected component in a \fIMolecule\fR and returns \fIMolecule\fR.
|
|
|
1201 .IP "\fBKekulizeAromaticAtoms\fR" 4
|
|
|
1202 .IX Item "KekulizeAromaticAtoms"
|
|
|
1203 .Vb 1
|
|
|
1204 \& $Status = $Molecule\->KekulizeAromaticAtoms();
|
|
|
1205 .Ve
|
|
|
1206 .Sp
|
|
|
1207 Kekulize marked ring and non-ring aromatic atoms in a molecule and return 1 or 1 based
|
|
|
1208 on whether the kekulization succeeded.
|
|
|
1209 .IP "\fBNewAtom\fR" 4
|
|
|
1210 .IX Item "NewAtom"
|
|
|
1211 .Vb 1
|
|
|
1212 \& $NewAtom = $Molecule\->NewAtom(%AtomPropertyNamesAndValues);
|
|
|
1213 .Ve
|
|
|
1214 .Sp
|
|
|
1215 Creates a new atom using \fIAtomPropertyNamesAndValues\fR, add its to \fIMolecule\fR, and returns
|
|
|
1216 new \fBAtom\fR object.
|
|
|
1217 .IP "\fBNewBond\fR" 4
|
|
|
1218 .IX Item "NewBond"
|
|
|
1219 .Vb 1
|
|
|
1220 \& $NewBond = $Molecule\->NewBond(%BondPropertyNamesAndValues);
|
|
|
1221 .Ve
|
|
|
1222 .Sp
|
|
|
1223 Creates a new bond using \fIAtomPropertyNamesAndValues\fR, add its to \fIMolecule\fR, and returns
|
|
|
1224 new \fBBond\fR object.
|
|
|
1225 .IP "\fBSetActiveRings\fR" 4
|
|
|
1226 .IX Item "SetActiveRings"
|
|
|
1227 .Vb 1
|
|
|
1228 \& $Molecule\->SetActiveRings($RingsType);
|
|
|
1229 .Ve
|
|
|
1230 .Sp
|
|
|
1231 Sets up type of detected ring sets to use during all ring related methods and returns \fIMolecule\fR.
|
|
|
1232 Possible \fIRingType\fR values: \fIIndependent or All\fR. By default, \fIIndependent\fR ring set is used
|
|
|
1233 during all ring methods.
|
|
|
1234 .IP "\fBSetAromaticityModel\fR" 4
|
|
|
1235 .IX Item "SetAromaticityModel"
|
|
|
1236 .Vb 1
|
|
|
1237 \& $Molecule = $Molecule\->SetAromaticityModel($AromaticityModel);
|
|
|
1238 .Ve
|
|
|
1239 .Sp
|
|
|
1240 Sets up \fIAromaticityModel\fR property value for \fIMolecule\fR and retrurns \fIMolecule\fR.
|
|
|
1241 .IP "\fBSetValenceModel\fR" 4
|
|
|
1242 .IX Item "SetValenceModel"
|
|
|
1243 .Vb 1
|
|
|
1244 \& $Molecule = $Molecule\->SetValenceModel(ValenceModel);
|
|
|
1245 .Ve
|
|
|
1246 .Sp
|
|
|
1247 Sets up \fIValenceModel\fR property value for \fIMolecule\fR and retrurns \fIMolecule\fR.
|
|
|
1248 .IP "\fBStringifyMolecule\fR" 4
|
|
|
1249 .IX Item "StringifyMolecule"
|
|
|
1250 .Vb 1
|
|
|
1251 \& $MoleculeString = $Molecule\->StringifyMolecule();
|
|
|
1252 .Ve
|
|
|
1253 .Sp
|
|
|
1254 Returns a string containing information about \fIMolecule\fR object
|
|
|
1255 .SH "AUTHOR"
|
|
|
1256 .IX Header "AUTHOR"
|
|
|
1257 Manish Sud <msud@san.rr.com>
|
|
|
1258 .SH "SEE ALSO"
|
|
|
1259 .IX Header "SEE ALSO"
|
|
|
1260 Atom.pm, Bond.pm, MoleculeFileIO.pm, MolecularFormula.pm
|
|
|
1261 .SH "COPYRIGHT"
|
|
|
1262 .IX Header "COPYRIGHT"
|
|
|
1263 Copyright (C) 2015 Manish Sud. All rights reserved.
|
|
|
1264 .PP
|
|
|
1265 This file is part of MayaChemTools.
|
|
|
1266 .PP
|
|
|
1267 MayaChemTools is free software; you can redistribute it and/or modify it under
|
|
|
1268 the terms of the \s-1GNU\s0 Lesser General Public License as published by the Free
|
|
|
1269 Software Foundation; either version 3 of the License, or (at your option)
|
|
|
1270 any later version.
|
