Mercurial > repos > deepakjadmin > mayatool3_test3
comparison mayachemtools/docs/modules/man3/MolecularDescriptorsGenerator.3 @ 0:73ae111cf86f draft
Uploaded
author | deepakjadmin |
---|---|
date | Wed, 20 Jan 2016 11:55:01 -0500 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:73ae111cf86f |
---|---|
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 "MOLECULARDESCRIPTORSGENERATOR 1" | |
127 .TH MOLECULARDESCRIPTORSGENERATOR 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 MolecularDescriptorsGenerator | |
134 .SH "SYNOPSIS" | |
135 .IX Header "SYNOPSIS" | |
136 use MolecularDescriptors::MolecularDescriptorsGenerator; | |
137 .PP | |
138 use MolecularDescriptors::MolecularDescriptorsGenerator qw(:all); | |
139 .SH "DESCRIPTION" | |
140 .IX Header "DESCRIPTION" | |
141 \&\fBMolecularDescriptorsGenerator\fR class provides the following methods: | |
142 .PP | |
143 new, GenerateDescriptors, GetAvailableClassAndDescriptorNames, | |
144 GetAvailableClassNameForDescriptorName, GetAvailableDescriptorClassNames, | |
145 GetAvailableDescriptorNames, GetAvailableDescriptorNamesForDescriptorClass, | |
146 GetDescriptorClassParameters, GetDescriptorNames, GetDescriptorNamesAndValues, | |
147 GetDescriptorValueByName, GetDescriptorValues, GetRuleOf3DescriptorNames, | |
148 GetRuleOf5DescriptorNames, IsDescriptorClassNameAvailable, | |
149 IsDescriptorNameAvailable, IsDescriptorsGenerationSuccessful, | |
150 SetDescriptorClassParameters, SetDescriptorNames, SetMode, SetMolecule, | |
151 StringifyMolecularDescriptorsGenerator | |
152 .PP | |
153 \&\fBMolecularDescriptorsGenerator\fR is derived from is derived from \fBObjectProperty\fR | |
154 base class that provides methods not explicitly defined in \fBMolecularDescriptorsGenerator\fR | |
155 or \fBObjectProperty\fR classes using Perl's \s-1AUTOLOAD\s0 functionality. These methods are | |
156 generated on-the-fly for a specified object property: | |
157 .PP | |
158 .Vb 3 | |
159 \& Set<PropertyName>(<PropertyValue>); | |
160 \& $PropertyValue = Get<PropertyName>(); | |
161 \& Delete<PropertyName>(); | |
162 .Ve | |
163 .PP | |
164 \&\fBMolecularDescriptorsGenerator\fR is designed to provide a plug-in environment for | |
165 molecular descriptors development. The molecular descriptor class modules available | |
166 in \fBMolecularDescriptors\fR directory under \fBMayaChemTools/lib\fR directory are | |
167 automatically detected and loaded into the system. The descriptor names provided | |
168 by each descriptor class module through its \fBGetDescriptorNames\fR function are | |
169 retrieved and are made available for calculations of their values for a specified | |
170 molecule. | |
171 .PP | |
172 Any combination of available descriptor names can be specified during calculation | |
173 of descriptor values using \fBGenerateDescriptors\fR method. The current release of | |
174 MayaChemTools supports generation of four sets of descriptors: All available | |
175 descriptors, rule of 5 or 3 descriptors, or a specified set of descriptor names. | |
176 .PP | |
177 RuleOf5 [ Ref 91 ] descriptor names are: MolecularWeight, HydrogenBondDonors, | |
178 HydrogenBondAcceptors, SLogP. RuleOf5 states: MolecularWeight <= 500, | |
179 HydrogenBondDonors <= 5, HydrogenBondAcceptors <= 10, and logP <= 5. | |
180 .PP | |
181 RuleOf3 [ Ref 92 ] descriptor names are: MolecularWeight, RotatableBonds, | |
182 HydrogenBondDonors, HydrogenBondAcceptors, SLogP, \s-1TPSA\s0. RuleOf3 states: | |
183 MolecularWeight <= 300, RotatableBonds <= 3, HydrogenBondDonors <= 3, | |
184 HydrogenBondAcceptors <= 3, logP <= 3, and \s-1TPSA\s0 <= 60. | |
185 .PP | |
186 Before calculation of a specified set of descriptors by \fBGenerateDescriptors\fR | |
187 method, a set of descriptor calculation control parameters for a specific descriptor | |
188 class name can be set using \fBSetDescriptorClassParameters\fR method. The specified | |
189 control parameter names and values are simply passed on to specified descriptor | |
190 class during instantiation of descriptor class object without performing any validation | |
191 of parameter names and associated values. It's up to the appropriate descriptor class methods | |
192 to validate these parameters and values. In addition to specified parameter names and | |
193 values, the parameter hash must also contain descriptor class name as key and | |
194 value pair with DescriptorClassName as key with class name as value. | |
195 .SS "\s-1METHODS\s0" | |
196 .IX Subsection "METHODS" | |
197 .IP "\fBnew\fR" 4 | |
198 .IX Item "new" | |
199 .Vb 3 | |
200 \& $NewMolecularDescriptorsGenerator = new MolecularDescriptors:: | |
201 \& MolecularDescriptorsGenerator( | |
202 \& %NamesAndValues); | |
203 .Ve | |
204 .Sp | |
205 Using specified \fIMolecularDescriptorsGenerator\fR property names and values hash, \fBnew\fR | |
206 method creates a new object and returns a reference to newly created \fBMolecularDescriptorsGenerator\fR | |
207 object. By default, the following properties are initialized: | |
208 .Sp | |
209 .Vb 6 | |
210 \& Mode = \*(AqAll\*(Aq | |
211 \& @{$This\->{DescriptorNames}} = () | |
212 \& %{$This\->{DescriptorClassParameters}} = () | |
213 \& @{$This\->{DescriptorClassNames}} = () | |
214 \& %{$This\->{DescriptorClassObjects}} = () | |
215 \& @{$This\->{DescriptorValues}} = () | |
216 .Ve | |
217 .Sp | |
218 Examples: | |
219 .Sp | |
220 .Vb 3 | |
221 \& $MolecularDescriptorsGenerator = new MolecularDescriptors:: | |
222 \& MolecularDescriptorsGenerator( | |
223 \& \*(AqMolecule\*(Aq => $Molecule); | |
224 \& | |
225 \& @DescriptorNames = qw(MolecularWeight HydrogenBondDonors Fsp3Carbons) | |
226 \& $MolecularDescriptorsGenerator = new MolecularDescriptors:: | |
227 \& MolecularDescriptorsGenerator( | |
228 \& \*(AqMode\*(Aq => \*(AqSpecify\*(Aq, | |
229 \& \*(AqDescriptorNames\*(Aq => \e@DescriptorNames); | |
230 \& | |
231 \& $MolecularDescriptorsGenerator\->SetDescriptorClassParameters( | |
232 \& \*(AqDescriptorClassName\*(Aq => \*(AqWeightAndMassDescriptors\*(Aq, | |
233 \& \*(AqWeightPrecision\*(Aq => 2, | |
234 \& \*(AqMassPrecision\*(Aq => 2); | |
235 \& | |
236 \& $MolecularDescriptorsGenerator\->SetDescriptorClassParameters( | |
237 \& \*(AqDescriptorClassName\*(Aq => \*(AqHydrogenBondsDescriptors\*(Aq, | |
238 \& \*(AqHydrogenBondsType\*(Aq => \*(AqHBondsType1\*(Aq); | |
239 \& | |
240 \& $MolecularDescriptorsGenerator\->SetMolecule($Molecule); | |
241 \& $MolecularDescriptorsGenerator\->GenerateDescriptors(); | |
242 \& print "MolecularDescriptorsGenerator: $MolecularDescriptorsGenerator\en"; | |
243 .Ve | |
244 .IP "\fBGenerateDescriptors\fR" 4 | |
245 .IX Item "GenerateDescriptors" | |
246 .Vb 1 | |
247 \& $MolecularDescriptorsGenerator\->GenerateDescriptors(); | |
248 .Ve | |
249 .Sp | |
250 Calculates descriptor values for specified descriptors and returns \fIMolecularDescriptorsGenerator\fR. | |
251 .Sp | |
252 Descriptor class objects are instantiated only once at first invocation. During | |
253 subsequent calls to \fBGenerateDescriptors\fR method, descriptor values are | |
254 initialized and \fBGenerateDescriptors\fR method provided by descriptor class is | |
255 used to calculate descriptor values for specified descriptors. | |
256 .IP "\fBGetAvailableClassAndDescriptorNames\fR" 4 | |
257 .IX Item "GetAvailableClassAndDescriptorNames" | |
258 .Vb 5 | |
259 \& %ClassAndDescriptorNames = $MolecularDescriptorsGenerator\-> | |
260 \& GetAvailableClassAndDescriptorNames(); | |
261 \& %ClassAndDescriptorNames = MolecularDescriptors:: | |
262 \& MolecularDescriptorsGenerator:: | |
263 \& GetAvailableClassAndDescriptorNames(); | |
264 .Ve | |
265 .Sp | |
266 Returns available descriptors class and descriptors names as a hash containing key | |
267 and value pairs corresponding to class name and an array of descriptor names | |
268 available for the class. | |
269 .IP "\fBGetAvailableClassNameForDescriptorName\fR" 4 | |
270 .IX Item "GetAvailableClassNameForDescriptorName" | |
271 .Vb 2 | |
272 \& $DescriptorClassName = $MolecularDescriptorsGenerator\-> | |
273 \& GetAvailableClassNameForDescriptorName($DescriptorName); | |
274 \& | |
275 \& $DescriptorClassName = MolecularDescriptors::MolecularDescriptorsGenerator:: | |
276 \& GetAvailableClassNameForDescriptorName($DescriptorName); | |
277 .Ve | |
278 .Sp | |
279 Returns available descriptor class name for a descriptor name. | |
280 .IP "\fBGetAvailableDescriptorClassNames\fR" 4 | |
281 .IX Item "GetAvailableDescriptorClassNames" | |
282 .Vb 1 | |
283 \& $Return = $MolecularDescriptorsGenerator\->GetAvailableDescriptorClassNames(); | |
284 \& | |
285 \& @DescriptorClassNames = $MolecularDescriptorsGenerator\-> | |
286 \& GetAvailableDescriptorClassNames(); | |
287 \& @DescriptorClassNames = MolecularDescriptors:: | |
288 \& MolecularDescriptorsGenerator:: | |
289 \& GetAvailableDescriptorClassNames(); | |
290 .Ve | |
291 .Sp | |
292 Returns available descriptor class names as an array or number of available descriptor | |
293 class names in scalar context. | |
294 .IP "\fBGetAvailableDescriptorNames\fR" 4 | |
295 .IX Item "GetAvailableDescriptorNames" | |
296 .Vb 5 | |
297 \& @DescriptorNames = $MolecularDescriptorsGenerator\-> | |
298 \& GetAvailableDescriptorNames(); | |
299 \& @DescriptorNames = MolecularDescriptors:: | |
300 \& MolecularDescriptorsGenerator:: | |
301 \& GetAvailableDescriptorNames(); | |
302 .Ve | |
303 .Sp | |
304 Returns available descriptor names as an array or number of available descriptor | |
305 names in scalar context. | |
306 .IP "\fBGetAvailableDescriptorNamesForDescriptorClass\fR" 4 | |
307 .IX Item "GetAvailableDescriptorNamesForDescriptorClass" | |
308 .Vb 5 | |
309 \& @DescriptorNames = $MolecularDescriptorsGenerator\-> | |
310 \& GetAvailableDescriptorNamesForDescriptorClass($DescriptorClassName); | |
311 \& @DescriptorNames = MolecularDescriptors:: | |
312 \& MolecularDescriptorsGenerator:: | |
313 \& GetAvailableDescriptorNamesForDescriptorClass($DescriptorClassName); | |
314 .Ve | |
315 .Sp | |
316 Returns available descriptors names for a descriptor class as an array or number | |
317 of available descriptor names in scalar context. | |
318 .IP "\fBGetDescriptorClassParameters\fR" 4 | |
319 .IX Item "GetDescriptorClassParameters" | |
320 .Vb 5 | |
321 \& $DescriptorClassParametersRef = $MolecularDescriptorsGenerator\-> | |
322 \& GetDescriptorClassParameters(); | |
323 \& $DescriptorClassParametersRef = MolecularDescriptors:: | |
324 \& MolecularDescriptorsGenerator:: | |
325 \& GetDescriptorClassParameters(); | |
326 .Ve | |
327 .Sp | |
328 Returns descriptor name parameters as a reference to hash of hashes with hash | |
329 keys corresponding to class name and class parameter name with hash value | |
330 as class parameter value. | |
331 .IP "\fBGetDescriptorNames\fR" 4 | |
332 .IX Item "GetDescriptorNames" | |
333 .Vb 3 | |
334 \& @DescriptorNames = $MolecularDescriptorsGenerator\->GetDescriptorNames(); | |
335 \& @DescriptorNames = MolecularDescriptors::MolecularDescriptorsGenerator:: | |
336 \& GetDescriptorNames(); | |
337 .Ve | |
338 .Sp | |
339 Returns all available descriptor names as an array or number of available descriptors | |
340 in scalar context. | |
341 .IP "\fBGetDescriptorNamesAndValues\fR" 4 | |
342 .IX Item "GetDescriptorNamesAndValues" | |
343 .Vb 2 | |
344 \& %NamesAndValues = $MolecularDescriptorsGenerator\-> | |
345 \& GetDescriptorNamesAndValues(); | |
346 .Ve | |
347 .Sp | |
348 Returns calculated molecular descriptor names and values as a hash with descriptor | |
349 names and values as hash key and value pairs. | |
350 .IP "\fBGetDescriptorValueByName\fR" 4 | |
351 .IX Item "GetDescriptorValueByName" | |
352 .Vb 2 | |
353 \& $Value = $MolecularDescriptorsGenerator\-> | |
354 \& GetDescriptorValueByName($Name); | |
355 .Ve | |
356 .Sp | |
357 Returns calculated descriptor values for a specified descriptor name. | |
358 .IP "\fBGetDescriptorValues\fR" 4 | |
359 .IX Item "GetDescriptorValues" | |
360 .Vb 1 | |
361 \& @DescriptorValues = $MolecularDescriptorsGenerator\->GetDescriptorValues(); | |
362 .Ve | |
363 .Sp | |
364 Returns all calculated descriptor values as an array corresponding to specified | |
365 descriptor names. | |
366 .IP "\fBGetRuleOf3DescriptorNames\fR" 4 | |
367 .IX Item "GetRuleOf3DescriptorNames" | |
368 .Vb 5 | |
369 \& @DescriptorNames = $MolecularDescriptorsGenerator\-> | |
370 \& GetRuleOf3DescriptorNames(); | |
371 \& @DescriptorNames = MolecularDescriptors:: | |
372 \& MolecularDescriptorsGenerator:: | |
373 \& GetRuleOf3DescriptorNames(); | |
374 .Ve | |
375 .Sp | |
376 Returns rule of 3 descriptor names as an array or number of rule of 3 descriptors in scalar | |
377 context. | |
378 .Sp | |
379 RuleOf3 [ Ref 92 ] descriptor names are: MolecularWeight, RotatableBonds, | |
380 HydrogenBondDonors, HydrogenBondAcceptors, SLogP, \s-1TPSA\s0. RuleOf3 states: | |
381 MolecularWeight <= 300, RotatableBonds <= 3, HydrogenBondDonors <= 3, | |
382 HydrogenBondAcceptors <= 3, logP <= 3, and \s-1TPSA\s0 <= 60. | |
383 .IP "\fBGetRuleOf5DescriptorNames\fR" 4 | |
384 .IX Item "GetRuleOf5DescriptorNames" | |
385 .Vb 4 | |
386 \& @DescriptorNames = $MolecularDescriptorsGenerator\-> | |
387 \& GetRuleOf5DescriptorNames(); | |
388 \& @DescriptorNames = $MolecularDescriptorsGenerator:: | |
389 \& GetRuleOf5DescriptorNames(); | |
390 .Ve | |
391 .Sp | |
392 Returns rule of 5 descriptor names as an array or number of rule of 4 descriptors in scalar | |
393 context. | |
394 .Sp | |
395 RuleOf5 [ Ref 91 ] descriptor names are: MolecularWeight, HydrogenBondDonors, | |
396 HydrogenBondAcceptors, SLogP. RuleOf5 states: MolecularWeight <= 500, | |
397 HydrogenBondDonors <= 5, HydrogenBondAcceptors <= 10, and logP <= 5. | |
398 .IP "\fBIsDescriptorClassNameAvailable\fR" 4 | |
399 .IX Item "IsDescriptorClassNameAvailable" | |
400 .Vb 5 | |
401 \& $Status = $MolecularDescriptorsGenerator\-> | |
402 \& IsDescriptorClassNameAvailable($ClassName); | |
403 \& $Status = MolecularDescriptors:: | |
404 \& MolecularDescriptorsGenerator:: | |
405 \& IsDescriptorClassNameAvailable($ClassName); | |
406 .Ve | |
407 .Sp | |
408 Returns 1 or 0 based on whether specified descriptor class name is available. | |
409 .IP "\fBIsDescriptorNameAvailable\fR" 4 | |
410 .IX Item "IsDescriptorNameAvailable" | |
411 .Vb 5 | |
412 \& $Status = $MolecularDescriptorsGenerator\-> | |
413 \& IsDescriptorNameAvailable($DescriptorName); | |
414 \& $Status = MolecularDescriptors:: | |
415 \& MolecularDescriptorsGenerator:: | |
416 \& IsDescriptorNameAvailable($DescriptorName); | |
417 .Ve | |
418 .Sp | |
419 Returns 1 or 0 based on whether specified descriptor name is available. | |
420 .IP "\fBIsDescriptorsGenerationSuccessful\fR" 4 | |
421 .IX Item "IsDescriptorsGenerationSuccessful" | |
422 .Vb 2 | |
423 \& $Status = $MolecularDescriptorsGenerator\-> | |
424 \& IsDescriptorsGenerationSuccessful(); | |
425 .Ve | |
426 .Sp | |
427 Returns 1 or 0 based on whether descriptors generation is successful. | |
428 .IP "\fBSetDescriptorClassParameters\fR" 4 | |
429 .IX Item "SetDescriptorClassParameters" | |
430 .Vb 2 | |
431 \& $MolecularDescriptorsGenerator\->SetDescriptorClassParameters( | |
432 \& %NamesAndValues); | |
433 .Ve | |
434 .Sp | |
435 Sets descriptor calculation control parameters for a specified descriptor class name | |
436 and returns \fIMolecularDescriptorsGenerator\fR. | |
437 .Sp | |
438 The specified parameter names and values are simply passed on to specified descriptor | |
439 class during instantiation of descriptor class object without any performing any validation | |
440 of parameter names and associated values. It's up to the appropriate descriptor class methods | |
441 to validate these parameters and values. | |
442 .Sp | |
443 In addition to specified parameter names and values, the parameter hash must also contain | |
444 descriptor class name as key and value pair with DescriptorClassName as key with class | |
445 name as value. | |
446 .IP "\fBSetDescriptorNames\fR" 4 | |
447 .IX Item "SetDescriptorNames" | |
448 .Vb 2 | |
449 \& $MolecularDescriptorsGenerator\->SetDescriptorNames(@Names); | |
450 \& $MolecularDescriptorsGenerator\->SetDescriptorNames(\e@Names); | |
451 .Ve | |
452 .Sp | |
453 Sets descriptor names to use for generating descriptor values using an array | |
454 or reference to an array and returns \fIMolecularDescriptorsGenerator\fR. | |
455 .IP "\fBSetMode\fR" 4 | |
456 .IX Item "SetMode" | |
457 .Vb 1 | |
458 \& $MolecularDescriptorsGenerator\->SetMode($Mode); | |
459 .Ve | |
460 .Sp | |
461 Sets descriptors generation mode and returns \fIMolecularDescriptorsGenerator\fR. | |
462 Possible \fIMode\fR values: \fIAll, RuleOf5, RuleOf3, Specify\fR. | |
463 .IP "\fBSetMolecule\fR" 4 | |
464 .IX Item "SetMolecule" | |
465 .Vb 1 | |
466 \& $MolecularDescriptorsGenerator\->SetMolecule($Molecule); | |
467 .Ve | |
468 .Sp | |
469 Sets molecule to use during calculation of molecular descriptors and returns | |
470 \&\fIMolecularDescriptorsGenerator\fR. | |
471 .IP "\fBStringifyMolecularDescriptorsGenerator\fR" 4 | |
472 .IX Item "StringifyMolecularDescriptorsGenerator" | |
473 .Vb 1 | |
474 \& $String = $MolecularDescriptorsGenerator\->StringifyMolecularDescriptorsGenerator(); | |
475 .Ve | |
476 .Sp | |
477 Returns a string containing information about \fIMolecularDescriptorsGenerator\fR object. | |
478 .SH "AUTHOR" | |
479 .IX Header "AUTHOR" | |
480 Manish Sud <msud@san.rr.com> | |
481 .SH "SEE ALSO" | |
482 .IX Header "SEE ALSO" | |
483 MolecularDescriptors.pm | |
484 .SH "COPYRIGHT" | |
485 .IX Header "COPYRIGHT" | |
486 Copyright (C) 2015 Manish Sud. All rights reserved. | |
487 .PP | |
488 This file is part of MayaChemTools. | |
489 .PP | |
490 MayaChemTools is free software; you can redistribute it and/or modify it under | |
491 the terms of the \s-1GNU\s0 Lesser General Public License as published by the Free | |
492 Software Foundation; either version 3 of the License, or (at your option) | |
493 any later version. |