Mercurial > repos > deepakjadmin > mayatool3_test2

comparison lib/PeriodicTable.pm @ 0:4816e4a8ae95 draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded
author deepakjadmin
date Wed, 20 Jan 2016 09:23:18 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4816e4a8ae95
1 package PeriodicTable;
2 #
3 # $RCSfile: PeriodicTable.pm,v $
4 # $Date: 2015/02/28 20:47:18 $
5 # $Revision: 1.37 $
6 #
7 # Author: Manish Sud <msud@san.rr.com>
8 #
9 # Copyright (C) 2015 Manish Sud. All rights reserved.
10 #
11 # This file is part of MayaChemTools.
12 #
13 # MayaChemTools is free software; you can redistribute it and/or modify it under
14 # the terms of the GNU Lesser General Public License as published by the Free
15 # Software Foundation; either version 3 of the License, or (at your option) any
16 # later version.
17 #
18 # MayaChemTools is distributed in the hope that it will be useful, but without
19 # any warranty; without even the implied warranty of merchantability of fitness
20 # for a particular purpose. See the GNU Lesser General Public License for more
21 # details.
22 #
23 # You should have received a copy of the GNU Lesser General Public License
24 # along with MayaChemTools; if not, see <http://www.gnu.org/licenses/> or
25 # write to the Free Software Foundation Inc., 59 Temple Place, Suite 330,
26 # Boston, MA, 02111-1307, USA.
27 #
28
29 use strict;
30 use Carp;
31 use Text::ParseWords;
32 use TextUtil;
33 use FileUtil;
34
35 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
36
37 @ISA = qw(Exporter);
38 @EXPORT = qw();
39 @EXPORT_OK = qw(GetElements GetElementsByGroupName GetElementsByGroupNumber GetElementsByAmericanStyleGroupLabel GetElementsByEuropeanStyleGroupLabel GetElementsByPeriodNumber GetElementMostAbundantNaturalIsotopeData GetElementNaturalIsotopeCount GetElementNaturalIsotopesData GetElementNaturalIsotopeAbundance GetElementMostAbundantNaturalIsotopeMass GetElementMostAbundantNaturalIsotopeMassNumber GetElementNaturalIsotopeMass GetElementPropertiesData GetElementPropertiesNames GetElementPropertiesNamesAndUnits GetElementPropertyUnits GetIUPACGroupNumberFromAmericanStyleGroupLabel GetIUPACGroupNumberFromEuropeanStyleGroupLabel IsElement IsElementNaturalIsotopeMassNumber IsElementProperty);
40
41 %EXPORT_TAGS = (all => [@EXPORT, @EXPORT_OK]);
42
43 #
44 # Load atomic properties and isotope data for elements...
45 #
46 my(%ElementDataMap, %ElementIsotopeDataMap, %ElementSymbolMap, @ElementPropertyNames, %ElementPropertyNamesMap, %ElementIsotopeDerivedDataMap);
47 _LoadPeriodicTableElementData();
48
49 #
50 # Get a list of all known element symbols...
51 #
52 sub GetElements {
53 my($AtomicNumber, @ElementSymbols);
54
55 @ElementSymbols = ();
56 for $AtomicNumber (sort {$a <=> $b} keys %ElementDataMap) {
57 push @ElementSymbols, $ElementDataMap{$AtomicNumber}{ElementSymbol};
58 }
59 return (wantarray ? @ElementSymbols : \@ElementSymbols);
60 }
61
62 #
63 # Get element symbols of elements with a specific group name. Valid group
64 # names are: Alkali metals, Alkaline earth metals, Coinage metals, Pnictogens,
65 # Chalcogens, Halogens, Noble gases; Additionally, usage of Lanthanides (Lanthanoids)
66 # and Actinides (Actinoids) is also supported.
67 #
68 sub GetElementsByGroupName {
69 my($SpecifiedGroupName) = @_;
70 my($AtomicNumber, @ElementSymbols, $GroupName);
71
72 if (IsEmpty($SpecifiedGroupName)) {
73 return (wantarray ? () : undef);
74 }
75 if ($SpecifiedGroupName =~ /Lanthanide/i) {
76 $SpecifiedGroupName = 'Lanthanoids';
77 }
78 elsif ($SpecifiedGroupName =~ /Actinide/i) {
79 $SpecifiedGroupName = 'Actinoids';
80 }
81 @ElementSymbols = ();
82 for $AtomicNumber (sort {$a <=> $b} keys %ElementDataMap) {
83 $GroupName = $ElementDataMap{$AtomicNumber}{GroupName};
84 if ($SpecifiedGroupName =~ /$GroupName/i ) {
85 push @ElementSymbols, $ElementDataMap{$AtomicNumber}{ElementSymbol};
86 }
87 }
88 return (wantarray ? @ElementSymbols : \@ElementSymbols);
89 }
90
91 #
92 # Get element symbols of elements in a specific IUPAC group number.
93 # A reference to an array containing element symbols is returned.
94 #
95 sub GetElementsByGroupNumber {
96 my($GroupNumber) = @_;
97 my($AtomicNumber, @ElementSymbols);
98
99 if (!IsInteger($GroupNumber)) {
100 return (wantarray ? () : undef);
101 }
102
103 @ElementSymbols = ();
104 for $AtomicNumber (sort {$a <=> $b} keys %ElementDataMap) {
105 if ($GroupNumber eq $ElementDataMap{$AtomicNumber}{GroupNumber}) {
106 push @ElementSymbols, $ElementDataMap{$AtomicNumber}{ElementSymbol};
107 }
108 }
109 return (wantarray ? @ElementSymbols : \@ElementSymbols);
110 }
111
112 #
113 # Get element symbols of elements in a specific American style group label.
114 # A reference to an array containing element symbols is returned.
115 #
116 sub GetElementsByAmericanStyleGroupLabel {
117 my($GroupLabel) = @_;
118
119 return _GetElementsByGroupLabel($GroupLabel, 'AmericanStyle');
120 }
121
122 #
123 # Get element symbols of elements in a specific European style group label.
124 # A reference to an array containing element symbols is returned.
125 #
126 sub GetElementsByEuropeanStyleGroupLabel {
127 my($GroupLabel) = @_;
128
129 return _GetElementsByGroupLabel($GroupLabel, 'EuropeanStyle');
130 }
131
132 #
133 # Get IUPAC group number from American style group label. A comma delimited
134 # string is returned for group VIII or VIIIB.
135 #
136 sub GetIUPACGroupNumberFromAmericanStyleGroupLabel {
137 my($GroupLabel) = @_;
138 my($GroupNumber);
139
140 if (IsEmpty($GroupLabel)) {
141 return undef;
142 }
143 $GroupNumber = "";
144 SWITCH: {
145 if ($GroupLabel =~ /^IA$/) { $GroupNumber = 1; last SWITCH;}
146 if ($GroupLabel =~ /^IIA$/) { $GroupNumber = 2; last SWITCH;}
147 if ($GroupLabel =~ /^IIIB$/) { $GroupNumber = 3; last SWITCH;}
148 if ($GroupLabel =~ /^IVB$/) { $GroupNumber = 4; last SWITCH;}
149 if ($GroupLabel =~ /^VB$/) { $GroupNumber = 5; last SWITCH;}
150 if ($GroupLabel =~ /^VIB$/) { $GroupNumber = 6; last SWITCH;}
151 if ($GroupLabel =~ /^VIIB$/) { $GroupNumber = 7; last SWITCH;}
152 if ($GroupLabel =~ /^(VIII|VIIIB)$/) { $GroupNumber = '8,9,10'; last SWITCH;}
153 if ($GroupLabel =~ /^IB$/) { $GroupNumber = 11; last SWITCH;}
154 if ($GroupLabel =~ /^IIB$/) { $GroupNumber = 12; last SWITCH;}
155 if ($GroupLabel =~ /^IIIA$/) { $GroupNumber = 13; last SWITCH;}
156 if ($GroupLabel =~ /^IVA$/) { $GroupNumber = 14; last SWITCH;}
157 if ($GroupLabel =~ /^VA$/) { $GroupNumber = 15; last SWITCH;}
158 if ($GroupLabel =~ /^VIA$/) { $GroupNumber = 16; last SWITCH;}
159 if ($GroupLabel =~ /^VIIA$/) { $GroupNumber = 17; last SWITCH;}
160 if ($GroupLabel =~ /^VIIIA$/) { $GroupNumber = 18; last SWITCH;}
161 $GroupNumber = "";
162 }
163 if (!$GroupNumber) {
164 return undef;
165 }
166 return $GroupNumber;
167 }
168
169 #
170 # Get IUPAC group number from European style group label. A comma delimited
171 # string is returned for group VIII or VIIIA
172 #
173 sub GetIUPACGroupNumberFromEuropeanStyleGroupLabel {
174 my($GroupLabel) = @_;
175 my($GroupNumber);
176
177 if (IsEmpty($GroupLabel)) {
178 return undef;
179 }
180 $GroupNumber = "";
181 SWITCH: {
182 if ($GroupLabel =~ /^IA$/) { $GroupNumber = 1; last SWITCH;}
183 if ($GroupLabel =~ /^IIA$/) { $GroupNumber = 2; last SWITCH;}
184 if ($GroupLabel =~ /^IIIA$/) { $GroupNumber = 3; last SWITCH;}
185 if ($GroupLabel =~ /^IVA$/) { $GroupNumber = 4; last SWITCH;}
186 if ($GroupLabel =~ /^VA$/) { $GroupNumber = 5; last SWITCH;}
187 if ($GroupLabel =~ /^VIA$/) { $GroupNumber = 6; last SWITCH;}
188 if ($GroupLabel =~ /^VIIA$/) { $GroupNumber = 7; last SWITCH;}
189 if ($GroupLabel =~ /^(VIII|VIIIA)$/) { $GroupNumber = '8,9,10'; last SWITCH;}
190 if ($GroupLabel =~ /^IB$/) { $GroupNumber = 11; last SWITCH;}
191 if ($GroupLabel =~ /^IIB$/) { $GroupNumber = 12; last SWITCH;}
192 if ($GroupLabel =~ /^IIIB$/) { $GroupNumber = 13; last SWITCH;}
193 if ($GroupLabel =~ /^IVB$/) { $GroupNumber = 14; last SWITCH;}
194 if ($GroupLabel =~ /^VB$/) { $GroupNumber = 15; last SWITCH;}
195 if ($GroupLabel =~ /^VIB$/) { $GroupNumber = 16; last SWITCH;}
196 if ($GroupLabel =~ /^VIIB$/) { $GroupNumber = 17; last SWITCH;}
197 if ($GroupLabel =~ /^VIIIB$/) { $GroupNumber = 18; last SWITCH;}
198 $GroupNumber = "";
199 }
200 if (!$GroupNumber) {
201 return undef;
202 }
203 return $GroupNumber;
204 }
205
206 #
207 # Get element symbols of elements in a specific period number.
208 # A reference to an array containing element symbols is returned.
209 #
210 sub GetElementsByPeriodNumber {
211 my($SpecifiedPeriodNumber) = @_;
212 my($AtomicNumber, $PeriodNumber, @ElementSymbols);
213
214 if (!IsInteger($SpecifiedPeriodNumber)) {
215 return (wantarray ? () : undef);
216 }
217
218 @ElementSymbols = ();
219 for $AtomicNumber (sort {$a <=> $b} keys %ElementDataMap) {
220 $PeriodNumber = $ElementDataMap{$AtomicNumber}{PeriodNumber};
221 if ($PeriodNumber =~ /\(/) {
222 # Lanthanides and Actinides...
223 ($PeriodNumber) = split /\(/, $PeriodNumber;
224 }
225 if ($PeriodNumber == $SpecifiedPeriodNumber) {
226 push @ElementSymbols, $ElementDataMap{$AtomicNumber}{ElementSymbol};
227 }
228 }
229 return (wantarray ? @ElementSymbols : \@ElementSymbols);
230 }
231
232 #
233 # Get data for most abundant isotope of an element using element symbol or atomic number.
234 #
235 sub GetElementMostAbundantNaturalIsotopeData {
236 my($ElementID) = @_;
237 my($AtomicNumber);
238
239 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
240 return (wantarray ? () : undef);
241 }
242
243 my(@IsotopeData, $IsotopeSymbol, $MassNumber, $RelativeAtomicMass, $NaturalAbundance);
244 $MassNumber = $ElementIsotopeDerivedDataMap{$AtomicNumber}{MostAbundantMassNumber};
245 $IsotopeSymbol = $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{IsotopeSymbol};
246 $RelativeAtomicMass = $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{RelativeAtomicMass};
247 $NaturalAbundance = $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{NaturalAbundance};
248 @IsotopeData = ();
249 @IsotopeData = ($AtomicNumber, $IsotopeSymbol, $MassNumber, $RelativeAtomicMass, $NaturalAbundance);
250
251 return (wantarray ? @IsotopeData : \@IsotopeData);
252
253 }
254 #
255 # Get natural isotope count for an element...
256 #
257 sub GetElementNaturalIsotopeCount {
258 my($ElementID) = @_;
259 my($AtomicNumber);
260
261 if ($AtomicNumber = _ValidateElementID($ElementID)) {
262 return $ElementIsotopeDerivedDataMap{$AtomicNumber}{IsotopeCount};
263 }
264 else {
265 return undef;
266 }
267 }
268
269 #
270 # Get all available isotope data for an element using element symbol or atomic number or
271 # data for a specific mass number using one of these two invocation methods:
272 #
273 # $HashRef = GetElementNaturalIsotopesData($ElementID);
274 #
275 # $HashRef = GetElementNaturalIsotopesData($ElementID, $MassNumber);
276 #
277 # In the first mode, a reference to a two-dimensional hash array is return where first
278 # and second dimension keys correspond to mass number and isotope data labels.
279 #
280 # And in the second mode, a refernce to one-dimensional hash array is returned with
281 # keys and values corresponding to isotope data label and values.
282 #
283 sub GetElementNaturalIsotopesData {
284 my($ElementID, $MassNumber, $InvocationMode, $AtomicNumber);
285
286 if (@_ == 2) {
287 ($ElementID, $MassNumber) = @_;
288 $InvocationMode = 2;
289 }
290 else {
291 ($ElementID) = @_;
292 $InvocationMode = 1;
293 }
294 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
295 return undef;
296 }
297 if ($InvocationMode == 1) {
298 return \%{$ElementIsotopeDataMap{$AtomicNumber}};
299 }
300 elsif ($InvocationMode == 2) {
301 if (exists $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}) {
302 return \%{$ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}};
303 }
304 else {
305 return undef;
306 }
307 }
308 else {
309 return undef;
310 }
311 }
312
313 #
314 # Get relative atomic mass for an element with specfic mass number.
315 #
316 sub GetElementNaturalIsotopeMass {
317 my($ElementID, $MassNumber) = @_;
318 my($AtomicNumber);
319
320 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
321 return undef;
322 }
323 if (exists $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}) {
324 return $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{RelativeAtomicMass};
325 }
326 else {
327 return undef;
328 }
329 }
330
331 #
332 # Get relative atomic mass of most abundant isotope for an element...
333 #
334 sub GetElementMostAbundantNaturalIsotopeMass {
335 my($ElementID) = @_;
336 my($AtomicNumber);
337
338 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
339 return undef;
340 }
341 my($MassNumber, $RelativeAtomicMass);
342
343 $MassNumber = $ElementIsotopeDerivedDataMap{$AtomicNumber}{MostAbundantMassNumber};
344 $RelativeAtomicMass = $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{RelativeAtomicMass};
345
346 return $RelativeAtomicMass;
347 }
348
349 #
350 # Get mass number of most abundant isotope for an element...
351 #
352 sub GetElementMostAbundantNaturalIsotopeMassNumber {
353 my($ElementID) = @_;
354 my($AtomicNumber);
355
356 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
357 return undef;
358 }
359 my($MassNumber);
360
361 $MassNumber = $ElementIsotopeDerivedDataMap{$AtomicNumber}{MostAbundantMassNumber};
362
363 return $MassNumber;
364 }
365 #
366 # Get % natural abundance of natural isotope for an element with specfic mass number.
367 #
368 sub GetElementNaturalIsotopeAbundance {
369 my($ElementID, $MassNumber) = @_;
370 my($AtomicNumber);
371
372 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
373 return undef;
374 }
375 if (exists $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}) {
376 return $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{NaturalAbundance};
377 }
378 else {
379 return undef;
380 }
381 }
382
383 #
384 # Get all available properties data for an element using element symbol or atomic number.
385 # A reference to a hash array is returned with keys and values representing property
386 # name and its values respectively.
387 #
388 sub GetElementPropertiesData {
389 my($ElementID) = @_;
390 my($AtomicNumber);
391
392 if ($AtomicNumber = _ValidateElementID($ElementID)) {
393 return \%{$ElementDataMap{$AtomicNumber}};
394 }
395 else {
396 return undef;
397 }
398 }
399
400 #
401 # Get names of all available element properties. A reference to an array containing
402 # names of all available properties is returned.
403 #
404 sub GetElementPropertiesNames {
405 my($Mode);
406 my($PropertyName, @PropertyNames);
407
408 $Mode = 'ByGroup';
409 if (@_ == 1) {
410 ($Mode) = @_;
411 }
412
413 @PropertyNames = ();
414 if ($Mode =~ /^Alphabetical$/i) {
415 # AtomicNumber, ElementSymbol and ElementName are always listed first...
416 push @PropertyNames, qw(AtomicNumber ElementSymbol ElementName);
417 for $PropertyName (sort keys %ElementPropertyNamesMap) {
418 if ($PropertyName !~ /^(AtomicNumber|ElementSymbol|ElementName)$/i) {
419 push @PropertyNames, $PropertyName;
420 }
421 }
422 }
423 else {
424 push @PropertyNames, @ElementPropertyNames;
425 }
426 return (wantarray ? @PropertyNames : \@PropertyNames);
427 }
428
429 #
430 # Get names and units of all available element properties...
431 # A reference to a hash array is returned with keys and values representing property
432 # name and its units respectively. Names with no units contains empty strings as hash
433 # values.
434 #
435 sub GetElementPropertiesNamesAndUnits {
436
437 return \%ElementPropertyNamesMap;
438 }
439
440 #
441 # Get units for a specific element property. An empty string is returned for a property
442 # with no units.
443 #
444 sub GetElementPropertyUnits {
445 my($PropertyName) = @_;
446 my($PropertyUnits);
447
448 $PropertyUnits = (exists($ElementPropertyNamesMap{$PropertyName})) ? $ElementPropertyNamesMap{$PropertyName} : undef;
449
450 return $PropertyUnits;
451 }
452
453 #
454 # Is it a known element? Input is either an element symol or a atomic number.
455 #
456 sub IsElement {
457 my($ElementID) = @_;
458 my($Status);
459
460 $Status = (_ValidateElementID($ElementID)) ? 1 : 0;
461
462 return $Status;
463 }
464
465 #
466 # Is it a valid mass number for an element? Element ID is either an element symol or a atomic number.
467 #
468 sub IsElementNaturalIsotopeMassNumber {
469 my($ElementID, $MassNumber) = @_;
470 my($AtomicNumber, $Status);
471
472 $Status = 0;
473 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
474 return $Status;
475 }
476 if (exists $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}) {
477 $Status = 1;
478 }
479
480 return $Status;
481 }
482
483 #
484 # Is it an available element property?
485 #
486 sub IsElementProperty {
487 my($PropertyName) = @_;
488 my($Status);
489
490 $Status = (exists($ElementPropertyNamesMap{$PropertyName})) ? 1 : 0;
491
492 return $Status;
493 }
494
495 #
496 # Implents GetElement<PropertyName> for a valid proprty name.
497 #
498 sub AUTOLOAD {
499 my($ElementID) = @_;
500 my($FunctionName, $PropertyName, $PropertyValue, $AtomicNumber);
501
502 $PropertyValue = undef;
503
504 use vars qw($AUTOLOAD);
505 $FunctionName = $AUTOLOAD;
506 $FunctionName =~ s/.*:://;
507
508 # Only Get<PropertyName> functions are supported...
509 if ($FunctionName !~ /^GetElement/) {
510 croak "Error: Function, PeriodicTable::$FunctionName, is not supported by AUTOLOAD in PeriodicTable module: Only GetElement<PropertyName> functions are implemented...";
511 }
512
513 $PropertyName = $FunctionName;
514 $PropertyName =~ s/^GetElement//;
515 if (!exists $ElementPropertyNamesMap{$PropertyName}) {
516 croak "Error: Function, PeriodicTable::$FunctionName, is not supported by AUTOLOAD in PeriodicTable module: Unknown element property name, $PropertyName, specified...";
517 }
518
519 if (!($AtomicNumber = _ValidateElementID($ElementID))) {
520 return undef;
521 }
522 $PropertyValue = $ElementDataMap{$AtomicNumber}{$PropertyName};
523 return $PropertyValue;
524 }
525
526 #
527 # Get elements labels for group name specified using American or European style...
528 #
529 sub _GetElementsByGroupLabel {
530 my($GroupLabel, $LabelStyle) = @_;
531 my($GroupNumber);
532
533 if ($LabelStyle =~ /^AmericanStyle$/i) {
534 $GroupNumber = GetIUPACGroupNumberFromAmericanStyleGroupLabel($GroupLabel);
535 }
536 elsif ($LabelStyle =~ /^EuropeanStyle$/i) {
537 $GroupNumber = GetIUPACGroupNumberFromEuropeanStyleGroupLabel($GroupLabel);
538 }
539
540 if (IsEmpty($GroupNumber)) {
541 return (wantarray ? () : undef);
542 }
543
544 my($AtomicNumber, @GroupElements, @ElementSymbols);
545 @ElementSymbols = ();
546 if ($GroupNumber =~ /\,/) {
547 my(@GroupNumbers);
548
549 @GroupNumbers = split /\,/, $GroupNumber;
550 for $GroupNumber (@GroupNumbers) {
551 @GroupElements = GetElementsByGroupNumber($GroupNumber);
552 push @ElementSymbols, @GroupElements;
553 }
554 }
555 else {
556 @GroupElements = GetElementsByGroupNumber($GroupNumber);
557 push @ElementSymbols, @GroupElements;
558 }
559 return (wantarray ? @ElementSymbols : \@ElementSymbols);
560 }
561
562 #
563 # Load PeriodicTableElementData.csv and PeriodicTableIsotopeData.csv files from
564 # <MayaChemTools>/lib directory...
565 #
566 sub _LoadPeriodicTableElementData {
567 my($ElementDataFile, $ElementIsotopeDataFile, $MayaChemToolsLibDir);
568
569 $MayaChemToolsLibDir = GetMayaChemToolsLibDirName();
570
571 $ElementDataFile = "$MayaChemToolsLibDir" . "/data/PeriodicTableElementData.csv";
572 $ElementIsotopeDataFile = "$MayaChemToolsLibDir" . "/data/PeriodicTableIsotopeData.csv";
573
574 if (! -e "$ElementDataFile") {
575 croak "Error: MayaChemTools package file, $ElementDataFile, is missing: Possible installation problems...";
576 }
577 if (! -e "$ElementIsotopeDataFile") {
578 croak "Error: MayaChemTools package file, $ElementIsotopeDataFile, is missing: Possible installation problems...";
579 }
580
581 _LoadElementData($ElementDataFile);
582 _LoadElementIsotopeData($ElementIsotopeDataFile);
583 }
584
585 #
586 # Load PeriodicTableElementData.csv file from <MayaChemTools>/lib directory...
587 #
588 sub _LoadElementData {
589 my($ElementDataFile) = @_;
590
591 %ElementDataMap = ();
592 @ElementPropertyNames = ();
593 %ElementPropertyNamesMap = ();
594 %ElementSymbolMap = ();
595
596 # Load atomic properties data for all elements...
597 #
598 # File Format:
599 #"AtomicNumber","ElementSymbol","ElementName","AtomicWeight","GroupNumber","GroupName","PeriodNumber","Block","GroundStateConfiguration","ValenceElectrons","GroundStateLevel","StandardState","CommonValences","LowestCommonValence","HighestCommonValence","CommonOxidationNumbers","LowestCommonOxidationNumber","HighestCommonOxidationNumber","BondLength(pm)","AtomicRadiusEmpirical(pm)","AtomicRadiusCalculated(pm)","CovalentRadiusEmpirical(pm)","VanderWaalsRadius(pm)","ElectronAffinity(kJ mol-1)","FirstIonizationEnergy(kJ mol-1)","PaulingElectronegativity(Pauling units)","SandersonElectronegativity(Pauling units)","AllredRochowElectronegativity(Pauling units)","MullikenJaffeElectronegativity(Pauling units)","AllenElectronegativity(Pauling units)","DensityOfSolid(kg m-3)","MolarVolume(cm3)","VelocityOfSound(m s-1)","YoungsModulus(GPa)","RigidityModulus(GPa)","BulkModulus(GPa)","PoissonsRatio(No units)","MineralHardness(No units)","BrinellHardness(MN m-2)","VickersHardness(MN m-2)","ElectricalResistivity(10-8 omega m)","Reflectivity(%)","RefractiveIndex(No units)","MeltingPoint(Celsius)","BoilingPoint(Celsius)","CriticalTemperature(Celsius)","SuperconductionTemperature(Celsius)","ThermalConductivity(W m-1 K-1)","CoefficientOfLinearExpansion(K-1 x 10^6)","EnthalpyOfFusion(kJ mol-1)","EnthalpyOfVaporization(kJ mol-1)","EnthalpyOfAtmization(kJ mol-1)","Color","Classification","DiscoveredBy","DiscoveredAt","DiscoveredWhen","OriginOfName"
600 #
601 #
602 my($AtomicNumber, $ElementSymbol, $Line, $NumOfCols, $InDelim, $Index, $Name, $Value, $Units, @LineWords, @ColLabels);
603
604 $InDelim = "\,";
605 open ELEMENTDATAFILE, "$ElementDataFile" or croak "Couldn't open $ElementDataFile: $! ...";
606
607 # Skip lines up to column labels...
608 LINE: while ($Line = GetTextLine(\*ELEMENTDATAFILE)) {
609 if ($Line !~ /^#/) {
610 last LINE;
611 }
612 }
613 @ColLabels= quotewords($InDelim, 0, $Line);
614 $NumOfCols = @ColLabels;
615
616 # Extract property names from column labels - and unit names where appropriate...
617 @ElementPropertyNames = ();
618 for $Index (0 .. $#ColLabels) {
619 $Name = $ColLabels[$Index];
620 $Units = "";
621 if ($Name =~ /\(/) {
622 ($Name, $Units) = split /\(/, $Name;
623 $Units =~ s/\)//g;
624 }
625 push @ElementPropertyNames, $Name;
626
627 # Store element names and units...
628 $ElementPropertyNamesMap{$Name} = $Units;
629 }
630
631 # Process element data...
632 LINE: while ($Line = GetTextLine(\*ELEMENTDATAFILE)) {
633 if ($Line =~ /^#/) {
634 next LINE;
635 }
636 @LineWords = ();
637 @LineWords = quotewords($InDelim, 0, $Line);
638 if (@LineWords != $NumOfCols) {
639 croak "Error: The number of data fields, @LineWords, in $ElementDataFile must be $NumOfCols.\nLine: $Line...";
640 }
641 $AtomicNumber = $LineWords[0]; $ElementSymbol = $LineWords[1];
642 if (exists $ElementDataMap{$AtomicNumber}) {
643 carp "Warning: Ignoring data for element $ElementSymbol: It has already been loaded.\nLine: $Line....";
644 next LINE;
645 }
646
647 # Store all the values...
648 %{$ElementDataMap{$AtomicNumber}} = ();
649 for $Index (0 .. $#LineWords) {
650 $Name = $ElementPropertyNames[$Index];
651 $Value = $LineWords[$Index];
652 $ElementDataMap{$AtomicNumber}{$Name} = $Value;
653 }
654 }
655 close ELEMENTDATAFILE;
656
657 # Setup the element symbol map as well...
658 _SetupElementSymbolMap();
659 }
660
661 #
662 # Load PeriodicTableIsotopeData.csv files from <MayaChemTools>/lib directory...
663 #
664 sub _LoadElementIsotopeData {
665 my($ElementIsotopeDataFile) = @_;
666
667 %ElementIsotopeDataMap = ();
668 %ElementIsotopeDerivedDataMap = ();
669
670 # Load isotope data for all elements...
671 #
672 # File format:
673 # "Atomic Number","Isotope Symbol","Mass Number","Relative Atomic Mass","% Natural Abundnace"
674 #
675 # Empty values for "Relative Atomic Mass" and "% Natural Abundnace" imply absence of any
676 # naturally occuring isotopes for the element.
677 #
678 my($InDelim, $Line, $NumOfCols, @ColLabels, @LineWords);
679
680 $InDelim = "\,";
681 open ISOTOPEDATAFILE, "$ElementIsotopeDataFile" or croak "Couldn't open $ElementIsotopeDataFile: $! ...";
682
683 # Skip lines up to column labels...
684 LINE: while ($Line = GetTextLine(\*ISOTOPEDATAFILE)) {
685 if ($Line !~ /^#/) {
686 last LINE;
687 }
688 }
689 @ColLabels= quotewords($InDelim, 0, $Line);
690 $NumOfCols = @ColLabels;
691
692 my($AtomicNumber, $IsotopeSymbol, $MassNumber, $RelativeAtomicMass, $NaturalAbundance, %ZeroNaturalAbundanceMap);
693 %ZeroNaturalAbundanceMap = ();
694
695 # Process element data...
696 LINE: while ($Line = GetTextLine(\*ISOTOPEDATAFILE)) {
697 if ($Line =~ /^#/) {
698 next LINE;
699 }
700 @LineWords = ();
701 @LineWords = quotewords($InDelim, 0, $Line);
702 if (@LineWords != $NumOfCols) {
703 croak "Error: The number of data fields, @LineWords, in $ElementIsotopeDataFile must be $NumOfCols.\nLine: $Line...";
704 }
705 ($AtomicNumber, $IsotopeSymbol, $MassNumber, $RelativeAtomicMass, $NaturalAbundance) = @LineWords;
706 if (exists $ZeroNaturalAbundanceMap{$AtomicNumber}) {
707 # Only one isotope data line allowed for elements with no natural isotopes...
708 carp "Warning: Ignoring isotope data for element with atomic number $AtomicNumber: Only one data line allowed for an element with no natural isotopes.\nLine: $Line...";
709 next LINE;
710 }
711 if (IsEmpty($NaturalAbundance)) {
712 $RelativeAtomicMass = 0;
713 $NaturalAbundance = 0;
714 $ZeroNaturalAbundanceMap{$AtomicNumber} = 1;
715 }
716 if (exists $ElementIsotopeDataMap{$AtomicNumber}) {
717 # Additional data for an existing element...
718 if (exists $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}) {
719 carp "Warning: Ignoring isotope data for element with atomic number $AtomicNumber: It has already been loaded.\nLine: $Line...";
720 next LINE;
721 }
722 }
723 else {
724 # Data for a new element...
725 %{$ElementIsotopeDataMap{$AtomicNumber}} = ();
726 }
727 %{$ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}} = ();
728 $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{IsotopeSymbol} = $IsotopeSymbol;
729 $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{RelativeAtomicMass} = $RelativeAtomicMass;
730 $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{NaturalAbundance} = $NaturalAbundance;
731 }
732 close ISOTOPEDATAFILE;
733
734 _SetupElementIsotopeDerivedDataMap();
735 }
736
737 #
738 # Map mass number of most abundant isotope for each element; additionally,
739 # count number of isotopes as well.
740 #
741 sub _SetupElementIsotopeDerivedDataMap {
742 my($AtomicNumber, $MassNumber, $NaturalAbundance, $MostNaturalAbundance, $MostAbundantMassNumber, $IsotopeCount);
743
744 %ElementIsotopeDerivedDataMap = ();
745
746 for $AtomicNumber (sort {$a <=> $b} keys %ElementIsotopeDataMap) {
747 $IsotopeCount = 0;
748 $MostAbundantMassNumber = 0;
749 $MostNaturalAbundance = 0;
750 MASSNUMBER: for $MassNumber (sort {$a <=> $b} keys %{$ElementIsotopeDataMap{$AtomicNumber}}) {
751 $NaturalAbundance = $ElementIsotopeDataMap{$AtomicNumber}{$MassNumber}{NaturalAbundance};
752 if (IsEmpty($NaturalAbundance)) {
753 # No natural isotopes available...
754 $MostAbundantMassNumber = $MassNumber;
755 last MASSNUMBER;
756 }
757 if ($NaturalAbundance == 0) {
758 # Not a natural isotope; Listed in periodic table data file to support non-natural
759 # elements such as T. It's not included in natural isotope count...
760 next MASSNUMBER;
761 }
762 $IsotopeCount++;
763 if ($NaturalAbundance > $MostNaturalAbundance) {
764 $MostAbundantMassNumber = $MassNumber;
765 $MostNaturalAbundance = $NaturalAbundance;
766 }
767 }
768 %{$ElementIsotopeDerivedDataMap{$AtomicNumber}} = ();
769 $ElementIsotopeDerivedDataMap{$AtomicNumber}{IsotopeCount} = $IsotopeCount;
770 $ElementIsotopeDerivedDataMap{$AtomicNumber}{MostAbundantMassNumber} = $MostAbundantMassNumber;
771 }
772 }
773
774 #
775 # Setup element symbol map...
776 #
777 sub _SetupElementSymbolMap {
778 my($AtomicNumber, $ElementSymbol);
779
780 %ElementSymbolMap = ();
781
782 for $AtomicNumber (keys %ElementDataMap) {
783 $ElementSymbol = $ElementDataMap{$AtomicNumber}{ElementSymbol};
784 $ElementSymbolMap{$ElementSymbol} = $AtomicNumber;
785 }
786 }
787
788 # Validate element ID...
789 sub _ValidateElementID {
790 my($ElementID) = @_;
791 my($ElementSymbol, $AtomicNumber);
792
793 if ($ElementID =~ /[^0-9]/) {
794 # Assume atomic symbol...
795 $ElementSymbol = $ElementID;
796 if (exists $ElementSymbolMap{$ElementSymbol}) {
797 $AtomicNumber = $ElementSymbolMap{$ElementSymbol};
798 }
799 else {
800 return undef;
801 }
802 }
803 else {
804 # Assume atomic number...
805 $AtomicNumber = $ElementID;
806 if (!exists $ElementDataMap{$AtomicNumber}) {
807 return undef;
808 }
809 }
810 return $AtomicNumber;
811 }
812
813 1;
814
815 __END__
816
817 =head1 NAME
818
819 PeriodicTable
820
821 =head1 SYNOPSIS
822
823 use PeriodicTable;
824
825 use PeriodicTable qw(:all);
826
827 =head1 DESCRIPTION
828
829 B<PeriodicTable> module provides the following functions:
830
831 GetElementMostAbundantNaturalIsotopeData,
832 GetElementMostAbundantNaturalIsotopeMass,
833 GetElementMostAbundantNaturalIsotopeMassNumber, GetElementNaturalIsotopeAbundance,
834 GetElementNaturalIsotopeCount, GetElementNaturalIsotopeMass,
835 GetElementNaturalIsotopesData, GetElementPropertiesData,
836 GetElementPropertiesNames, GetElementPropertiesNamesAndUnits,
837 GetElementPropertyUnits, GetElements, GetElementsByAmericanStyleGroupLabel,
838 GetElementsByEuropeanStyleGroupLabel, GetElementsByGroupName,
839 GetElementsByGroupNumber, GetElementsByPeriodNumber,
840 GetIUPACGroupNumberFromAmericanStyleGroupLabel,
841 GetIUPACGroupNumberFromEuropeanStyleGroupLabel, IsElement,
842 IsElementNaturalIsotopeMassNumber, IsElementProperty
843
844 =head1 METHODS
845
846 =over 4
847
848 =item B<GetElements>
849
850 @ElementSymbols = GetElements();
851 $ElementSymbolsRef = GetElements();
852
853 Returns an array or a reference to an array of known element symbols
854
855 =item B<GetElementsByGroupName>
856
857 @ElementSymbols = GetElementsByGroupName($GroupName);
858 $ElementSymbolsRef = GetElementsByGroupName($GroupName);
859
860 Returns an array or a reference to an array of element symbols for a specified I<GroupName>.
861 Supported I<GroupName> values are: I<Alkali metals, Alkaline earth metals, Coinage metals, Pnictogens,
862 Chalcogens, Halogens, Noble gases>; Additionally, usage of I<Lanthanides> (Lanthanoids)
863 and I<Actinides> (Actinoids) is also supported.
864
865 =item B<GetElementsByGroupNumber>
866
867 @ElementSymbols = GetElementsByGroupNumber($GroupNumber);
868 $ElementSymbolsRef = GetElementsByGroupNumber($GroupNumber);
869
870 Returns an array or a reference to an array of element symbols for a specified I<GroupNumber>
871
872 =item B<GetElementsByAmericanStyleGroupLabel>
873
874 @ElementSymbols = GetElementsByAmericanStyleGroupLabel($GroupLabel);
875 $ElementSymbolsRef = GetElementsByAmericanStyleGroupLabel($GroupLabel);
876
877 Returns an array or a reference to an array of element symbols for a specified American
878 style I<GroupLabel>. Valid values for Amercian style group labels: I<IA to VIIIA, IB to VIIIB, VIII>.
879
880 =item B<GetElementsByEuropeanStyleGroupLabel>
881
882 @ElementSymbols = GetElementsByEuropeanStyleGroupLabel($GroupLabel);
883 $ElementSymbolsRef = GetElementsByEuropeanStyleGroupLabel($GroupLabel);
884
885 Returns an array or a reference to an array of element symbols for a specified European
886 style I<GroupLabel>. Valid values for European style group labels: I<IA to VIIIA, IB to VIIIB, VIII>.
887
888 =item B<GetElementsByPeriodNumber>
889
890 @ElementSymbols = GetElementsByPeriodNumber($PeriodNumber);
891 $ElementSymbolsRef = GetElementsByPeriodNumber($PeriodNumber);
892
893 Returns an array or a reference to an array of element symbols for a specified I<PeriodNumber>.
894
895 =item B<GetElementMostAbundantNaturalIsotopeData>
896
897 @IsotopeData = GetElementMostAbundantNaturalIsotopeData(
898 $ElementID);
899 $IsotopeDataRef = GetElementMostAbundantNaturalIsotopeData(
900 $ElementID);
901
902 Returns an array or reference to an array containing data for most abundant isotope of
903 an element specfied by element symbol or atomic number. Isotope data arrays contain these
904 values: I<AtomicNumber, IsotopeSymbol, MassNumber, RelativeAtomicMass, and NaturalAbundance>.
905
906 =item B<GetElementMostAbundantNaturalIsotopeMassNumber>
907
908 $MassNumber = GetElementMostAbundantNaturalIsotopeMassNumber($ElementID);
909
910 Returns mass number of most abundant natural isotope of an element specfied by element
911 symbol or atomic number
912
913 =item B<GetElementNaturalIsotopeCount>
914
915 $IsotopeCount = GetElementNaturalIsotopeCount($ElementID);
916
917 Returns natural isotope count for an element specfied by element symbol or
918 atomic number
919
920 =item B<GetElementNaturalIsotopesData>
921
922 $DataHashRef = GetElementNaturalIsotopesData($ElementID,
923 [$MassNumber]);
924
925 Reurns a reference to a hash containingall available isotope data for an element specified
926 using element symbol or aromic number; an optional mass number indicates retrieve data
927 for a specific isotope
928
929 =item B<GetElementNaturalIsotopeAbundance>
930
931 $Abundance = GetElementNaturalIsotopeAbundance($ElementID,
932 $MassNumber);
933
934 Returns percent abundance of natural isotope for an element with specfic mass
935 number.
936
937 =item B<GetElementMostAbundantNaturalIsotopeMass>
938
939 $RelativeAtomicMass = GetElementMostAbundantNaturalIsotopeMass(
940 $ElementID);
941
942 Returns relative atomic mass of most abundant isotope for an element specified using
943 element symbol or aromic number.
944
945 =item B<GetElementNaturalIsotopeMass>
946
947 $RelativeAtomicMass = GetElementNaturalIsotopeMass($ElementID,
948 $MassNumber);
949
950 Returns relative atomic mass of an element with specfic mass number.
951
952 =item B<GetElementPropertiesData>
953
954 $PropertyDataHashRef = GetElementPropertiesData($ElementID);
955
956 Returns a reference to a hash containing all available properties data for an element
957 specified using element symbol or atomic number.
958
959 =item B<GetElementPropertyName>
960
961 $PropertyValue = GetElement<PropertyName>($ElementID);
962
963 Returns value of an element for a element specified using element symbol or atomic number.
964
965 These functions are not defined in this modules; these are implemented on-the-fly using
966 Perl's AUTOLOAD funcionality.
967
968 Here is the list of known element I<property names>: AllenElectronegativity,
969 AllredRochowElectronegativity, AtomicNumber, AtomicRadiusCalculated,
970 AtomicRadiusEmpirical, AtomicWeight, Block, BoilingPoint, BondLength,
971 BrinellHardness, BulkModulus, Classification, CoefficientOfLinearExpansion, Color,
972 CommonValences, LowestCommonValence, HighestCommonValence,
973 CommonOxidationNumbers, LowestCommonOxidationNumber, HighestCommonOxidationNumber,
974 CovalentRadiusEmpirical, CriticalTemperature, DensityOfSolid, DiscoveredAt, DiscoveredBy,
975 DiscoveredWhen, ElectricalResistivity, ElectronAffinity, ElementName, ElementSymbol, EnthalpyOfAtmization,
976 EnthalpyOfFusion, EnthalpyOfVaporization, FirstIonizationEnergy, GroundStateConfiguration, GroundStateLevel,
977 GroupName, GroupNumber, NaturalIsotopeData, MeltingPoint, MineralHardness, MolarVolume,
978 MullikenJaffeElectronegativity, OriginOfName, PaulingElectronegativity, PeriodNumber, PoissonsRatio,
979 Reflectivity, RefractiveIndex, RigidityModulus, SandersonElectronegativity, StandardState,
980 SuperconductionTemperature, ThermalConductivity, VanderWaalsRadius, VelocityOfSound, VickersHardness,
981 YoungsModulus.
982
983 =item B<GetElementPropertiesNames>
984
985 @PropertyNames = GetElementPropertiesNames([$Mode]);
986 $PropertyNamesRef = GetElementPropertiesNames([$Mode]);
987
988 Returns names of all available element properties. Optional mode parameter controls
989 grouping of property names; Possible values: I<ByGroup or Alphabetical>. Default:
990 I<ByGroup>.
991
992 =item B<GetElementPropertiesNamesAndUnits>
993
994 $NameUnitsHashRef = GetElementPropertiesNamesAndUnits();
995
996 Returns a reference to a hash of property names and units of all available element
997 properties. Names with no units contains empty strings.
998
999 =item B<GetElementPropertyUnits>
1000
1001 $Units = GetElementPropertyUnits($PropertyName);
1002
1003 Returns units for a specific element property name. An empty string is returned for
1004 a property with no units.
1005
1006 =item B<GetIUPACGroupNumberFromAmericanStyleGroupLabel>
1007
1008 $GroupNumber = GetIUPACGroupNumberFromAmericanStyleGroupLabel(
1009 $GroupLabel);
1010
1011 Returns IUPAC group numbers of a specific American style group label. A comma delimited
1012 string is returned for group VIII or VIIIB.
1013
1014 =item B<GetIUPACGroupNumberFromEuropeanStyleGroupLabel>
1015
1016 $GroupNumber = GetIUPACGroupNumberFromEuropeanStyleGroupLabel(
1017 $GroupLabel);
1018
1019 Returns IUPAC group numbers of a specific European style group label. A comma delimited
1020 string is returned for group VIII or VIIIA.
1021
1022 =item B<IsElement>
1023
1024 $Status = IsElement($ElementID);
1025
1026 Returns 1 or 0 based on whether it's a known element symbol or atomic number.
1027
1028 =item B<IsElementNaturalIsotopeMassNumber>
1029
1030 $Status = IsElementNaturalIsotopeMassNumber($ElementID, $MassNumber);
1031
1032 Returns 1 or 0 based on whether it's a valid mass number for an element symbol
1033 or atomic number.
1034
1035 =item B<IsElementProperty>
1036
1037 $Status = IsElementProperty($PropertyName);
1038
1039 Returns 1 or 0 based on whether it's a valid property name.
1040
1041 =back
1042
1043 =head1 AUTHOR
1044
1045 Manish Sud <msud@san.rr.com>
1046
1047 =head1 SEE ALSO
1048
1049 AminoAcids.pm, NucleicAcids.pm
1050
1051 =head1 COPYRIGHT
1052
1053 Copyright (C) 2015 Manish Sud. All rights reserved.
1054
1055 This file is part of MayaChemTools.
1056
1057 MayaChemTools is free software; you can redistribute it and/or modify it under
1058 the terms of the GNU Lesser General Public License as published by the Free
1059 Software Foundation; either version 3 of the License, or (at your option)
1060 any later version.
1061
1062 =cut