MayaChemTools

   1 #!/usr/bin/perl -w
   2 #
   3 # File: CalculatePhysicochemicalProperties.pl
   4 # Author: Manish Sud <msud@san.rr.com>
   5 #
   6 # Copyright (C) 2018 Manish Sud. All rights reserved.
   7 #
   8 # This file is part of MayaChemTools.
   9 #
  10 # MayaChemTools is free software; you can redistribute it and/or modify it under
  11 # the terms of the GNU Lesser General Public License as published by the Free
  12 # Software Foundation; either version 3 of the License, or (at your option) any
  13 # later version.
  14 #
  15 # MayaChemTools is distributed in the hope that it will be useful, but without
  16 # any warranty; without even the implied warranty of merchantability of fitness
  17 # for a particular purpose.  See the GNU Lesser General Public License for more
  18 # details.
  19 #
  20 # You should have received a copy of the GNU Lesser General Public License
  21 # along with MayaChemTools; if not, see <http://www.gnu.org/licenses/> or
  22 # write to the Free Software Foundation Inc., 59 Temple Place, Suite 330,
  23 # Boston, MA, 02111-1307, USA.
  24 #
  25 
  26 use strict;
  27 use FindBin; use lib "$FindBin::Bin/../lib";
  28 use Getopt::Long;
  29 use File::Basename;
  30 use Text::ParseWords;
  31 use Benchmark;
  32 use FileUtil;
  33 use TextUtil;
  34 use SDFileUtil;
  35 use MoleculeFileIO;
  36 use Molecule;
  37 use AtomTypes::AtomicInvariantsAtomTypes;
  38 use AtomTypes::FunctionalClassAtomTypes;
  39 use MolecularDescriptors::MolecularDescriptorsGenerator;
  40 
  41 my($ScriptName, %Options, $StartTime, $EndTime, $TotalTime);
  42 
  43 # Autoflush STDOUT
  44 $| = 1;
  45 
  46 # Starting message...
  47 $ScriptName = basename($0);
  48 print "\n$ScriptName: Starting...\n\n";
  49 $StartTime = new Benchmark;
  50 
  51 # Get the options and setup script...
  52 SetupScriptUsage();
  53 if ($Options{help} || @ARGV < 1) {
  54   die GetUsageFromPod("$FindBin::Bin/$ScriptName");
  55 }
  56 
  57 my(@SDFilesList);
  58 @SDFilesList = ExpandFileNames(\@ARGV, "sdf sd");
  59 
  60 # Process options...
  61 print "Processing options...\n";
  62 my(%OptionsInfo);
  63 ProcessOptions();
  64 
  65 # Setup information about input files...
  66 print "Checking input SD file(s)...\n";
  67 my(%SDFilesInfo);
  68 RetrieveSDFilesInfo();
  69 
  70 # Process input files..
  71 my($FileIndex);
  72 if (@SDFilesList > 1) {
  73   print "\nProcessing SD files...\n";
  74 }
  75 for $FileIndex (0 .. $#SDFilesList) {
  76   if ($SDFilesInfo{FileOkay}[$FileIndex]) {
  77     print "\nProcessing file $SDFilesList[$FileIndex]...\n";
  78     CalculatePhysicochemicalProperties($FileIndex);
  79   }
  80 }
  81 print "\n$ScriptName:Done...\n\n";
  82 
  83 $EndTime = new Benchmark;
  84 $TotalTime = timediff ($EndTime, $StartTime);
  85 print "Total time: ", timestr($TotalTime), "\n";
  86 
  87 ###############################################################################
  88 
  89 # Calculate physicochemical properties for a SD file...
  90 #
  91 sub CalculatePhysicochemicalProperties {
  92   my($FileIndex) = @_;
  93   my($CmpdCount, $IgnoredCmpdCount, $RuleOf5ViolationsCount, $RuleOf3ViolationsCount, $SDFile, $MoleculeFileIO, $Molecule, $MolecularDescriptorsGenerator, $PhysicochemicalPropertiesDataRef, $NewSDFileRef, $NewTextFileRef);
  94 
  95   $SDFile = $SDFilesList[$FileIndex];
  96 
  97   # Setup output files...
  98   $NewSDFileRef = ''; $NewTextFileRef = '';
  99   ($NewSDFileRef, $NewTextFileRef) = SetupAndOpenOutputFiles($FileIndex);
 100 
 101   # Setup molecular descriptor generator to calculate property values for specifed
 102   # property names...
 103   $MolecularDescriptorsGenerator = SetupMolecularDescriptorsGenerator();
 104 
 105   ($CmpdCount, $IgnoredCmpdCount, $RuleOf5ViolationsCount, $RuleOf3ViolationsCount) = ('0') x 4;
 106 
 107   $MoleculeFileIO = new MoleculeFileIO('Name' => $SDFile);
 108   $MoleculeFileIO->Open();
 109 
 110   COMPOUND: while ($Molecule = $MoleculeFileIO->ReadMolecule()) {
 111     $CmpdCount++;
 112 
 113     # Filter compound data before calculating physiochemical properties...
 114     if ($OptionsInfo{Filter}) {
 115       if (CheckAndFilterCompound($CmpdCount, $Molecule)) {
 116         $IgnoredCmpdCount++;
 117         next COMPOUND;
 118       }
 119     }
 120 
 121     # Calculate properties...
 122     $PhysicochemicalPropertiesDataRef = CalculateMoleculeProperties($MolecularDescriptorsGenerator, $Molecule);
 123 
 124     if (!defined($PhysicochemicalPropertiesDataRef)) {
 125       $IgnoredCmpdCount++;
 126       ProcessIgnoredCompound('PropertiesCalculationFailed', $CmpdCount, $Molecule);
 127       next COMPOUND;
 128     }
 129 
 130     # Calculate any rule violations...
 131     if ($OptionsInfo{RuleOf5Violations} && $PhysicochemicalPropertiesDataRef->{RuleOf5Violations}) {
 132       $RuleOf5ViolationsCount++;
 133     }
 134 
 135     if ($OptionsInfo{RuleOf3Violations} && $PhysicochemicalPropertiesDataRef->{RuleOf3Violations}) {
 136       $RuleOf3ViolationsCount++;
 137     }
 138 
 139     # Write out calculate properties...
 140     WriteDataToOutputFiles($FileIndex, $CmpdCount, $Molecule, $PhysicochemicalPropertiesDataRef, $NewSDFileRef, $NewTextFileRef);
 141   }
 142   $MoleculeFileIO->Close();
 143 
 144   if ($OptionsInfo{SDOutput} && $NewSDFileRef) {
 145     close $NewSDFileRef;
 146   }
 147   if ($OptionsInfo{TextOutput} && $NewTextFileRef) {
 148     close $NewTextFileRef;
 149   }
 150 
 151   WriteCalculationSummaryStatistics($CmpdCount, $IgnoredCmpdCount, $RuleOf5ViolationsCount, $RuleOf3ViolationsCount);
 152 }
 153 
 154 # Process compound being ignored due to problems in physicochemical properties calculation...
 155 #
 156 sub ProcessIgnoredCompound {
 157   my($Mode, $CmpdCount, $Molecule) = @_;
 158   my($CmpdID, $DataFieldLabelAndValuesRef);
 159 
 160   $DataFieldLabelAndValuesRef = $Molecule->GetDataFieldLabelAndValues();
 161   $CmpdID = SetupCmpdIDForTextFiles($CmpdCount, $Molecule, $DataFieldLabelAndValuesRef);
 162 
 163   MODE: {
 164     if ($Mode =~ /^ContainsNonElementalData$/i) {
 165       warn "\nWarning: Ignoring compound record number $CmpdCount with ID $CmpdID: Compound contains atom data corresponding to non-elemental atom symbol(s)...\n\n";
 166       next MODE;
 167     }
 168 
 169     if ($Mode =~ /^ContainsNoElementalData$/i) {
 170       warn "\nWarning: Ignoring compound record number $CmpdCount with ID $CmpdID: Compound contains no atom data...\n\n";
 171       next MODE;
 172     }
 173 
 174     if ($Mode =~ /^PropertiesCalculationFailed$/i) {
 175       warn "\nWarning: Ignoring compound record number $CmpdCount with ID $CmpdID: Physicochemical properties calculation didn't succeed...\n\n";
 176       next MODE;
 177     }
 178     warn "\nWarning: Ignoring compound record number $CmpdCount with ID $CmpdID: Physicochemical properties calculation didn't succeed...\n\n";
 179   }
 180 }
 181 
 182 # Check and filter compounds....
 183 #
 184 sub CheckAndFilterCompound {
 185   my($CmpdCount, $Molecule) = @_;
 186   my($ElementCount, $NonElementCount);
 187 
 188   ($ElementCount, $NonElementCount) = $Molecule->GetNumOfElementsAndNonElements();
 189 
 190   if ($NonElementCount) {
 191     ProcessIgnoredCompound('ContainsNonElementalData', $CmpdCount, $Molecule);
 192     return 1;
 193   }
 194 
 195   if (!$ElementCount) {
 196     ProcessIgnoredCompound('ContainsNoElementalData', $CmpdCount, $Molecule);
 197     return 1;
 198   }
 199 
 200   return 0;
 201 }
 202 
 203 # Write out compounds physicochemical properties calculation summary statistics...
 204 #
 205 sub WriteCalculationSummaryStatistics {
 206   my($CmpdCount, $IgnoredCmpdCount, $RuleOf5ViolationsCount, $RuleOf3ViolationsCount) = @_;
 207   my($ProcessedCmpdCount);
 208 
 209   $ProcessedCmpdCount = $CmpdCount - $IgnoredCmpdCount;
 210 
 211   print "\nNumber of compounds: $CmpdCount\n";
 212   print "Number of compounds processed successfully during physicochemical properties calculation: $ProcessedCmpdCount\n";
 213   print "Number of compounds ignored during physicochemical properties calculation: $IgnoredCmpdCount\n";
 214 
 215   if ($OptionsInfo{RuleOf5Violations}) {
 216     print "Number of compounds with one or more RuleOf5 violations: $RuleOf5ViolationsCount\n";
 217   }
 218 
 219   if ($OptionsInfo{RuleOf3Violations}) {
 220     print "Number of compounds with one or more RuleOf3 violations: $RuleOf3ViolationsCount\n";
 221   }
 222 
 223 }
 224 
 225 # Open output files...
 226 #
 227 sub SetupAndOpenOutputFiles {
 228   my($FileIndex) = @_;
 229   my($NewSDFile, $NewTextFile, $NewSDFileRef, $NewTextFileRef);
 230 
 231   $NewSDFileRef = '';
 232   $NewTextFileRef = '';
 233 
 234   if ($OptionsInfo{SDOutput}) {
 235     $NewSDFile = $SDFilesInfo{SDOutFileNames}[$FileIndex];
 236     print "Generating SD file $NewSDFile...\n";
 237     open NEWSDFILE, ">$NewSDFile" or die "Error: Couldn't open $NewSDFile: $! \n";
 238     $NewSDFileRef = \*NEWSDFILE;
 239   }
 240   if ($OptionsInfo{TextOutput}) {
 241     $NewTextFile = $SDFilesInfo{TextOutFileNames}[$FileIndex];
 242     print "Generating text file $NewTextFile...\n";
 243     open NEWTEXTFILE, ">$NewTextFile" or die "Error: Couldn't open $NewTextFile: $! \n";
 244     WriteTextFileCoulmnLabels($FileIndex, \*NEWTEXTFILE);
 245     $NewTextFileRef = \*NEWTEXTFILE;
 246   }
 247   return ($NewSDFileRef, $NewTextFileRef);
 248 }
 249 
 250 # Write calculated physicochemical properties and other data to appropriate output files...
 251 #
 252 sub WriteDataToOutputFiles {
 253   my($FileIndex, $CmpdCount, $Molecule, $PhysicochemicalPropertiesDataRef, $NewSDFileRef, $NewTextFileRef) = @_;
 254   my($PropertyName, $PropertyValue);
 255 
 256   if ($OptionsInfo{SDOutput}) {
 257     # Retrieve input compound string used to create molecule and write it out
 258     # without last line containing a delimiter...
 259     my($CmpdString);
 260     $CmpdString = $Molecule->GetInputMoleculeString();
 261     $CmpdString =~ s/\$\$\$\$$//;
 262     print $NewSDFileRef "$CmpdString";
 263 
 264     # Write out calculated physicochemical properties data...
 265     for $PropertyName (@{$OptionsInfo{SpecifiedPropertyNames}}) {
 266       $PropertyValue = $PhysicochemicalPropertiesDataRef->{$PropertyName};
 267       print $NewSDFileRef  ">  <$PropertyName>\n$PropertyValue\n\n";
 268     }
 269 
 270     # Write out RuleOf5 violations for molecule....
 271     if ($OptionsInfo{RuleOf5Violations}) {
 272       $PropertyValue = $PhysicochemicalPropertiesDataRef->{RuleOf5Violations};
 273       print $NewSDFileRef  ">  <RuleOf5Violations>\n$PropertyValue\n\n";
 274     }
 275 
 276     # Write out RuleOf3 violations for molecule....
 277     if ($OptionsInfo{RuleOf3Violations}) {
 278       $PropertyValue = $PhysicochemicalPropertiesDataRef->{RuleOf3Violations};
 279       print $NewSDFileRef  ">  <RuleOf3Violations>\n$PropertyValue\n\n";
 280     }
 281 
 282     # Write out delimiter...
 283     print $NewSDFileRef "\$\$\$\$\n";
 284   }
 285 
 286   if ($OptionsInfo{TextOutput}) {
 287     my($Line, $DataFieldLabelAndValuesRef, $DataFieldLabel, $DataFieldValue, @LineWords,);
 288 
 289     $DataFieldLabelAndValuesRef = $Molecule->GetDataFieldLabelAndValues();
 290     @LineWords = ();
 291     if ($OptionsInfo{DataFieldsMode} =~ /^CompoundID$/i) {
 292       push @LineWords, SetupCmpdIDForTextFiles($CmpdCount, $Molecule, $DataFieldLabelAndValuesRef);
 293     }
 294     elsif ($OptionsInfo{DataFieldsMode} =~ /^All$/i) {
 295       @LineWords = map { exists $DataFieldLabelAndValuesRef->{$_} ? $DataFieldLabelAndValuesRef->{$_} : ''} @{$SDFilesInfo{AllDataFieldsRef}[$FileIndex]};
 296     }
 297     elsif ($OptionsInfo{DataFieldsMode} =~ /^Common$/i) {
 298       @LineWords = map { exists $DataFieldLabelAndValuesRef->{$_} ? $DataFieldLabelAndValuesRef->{$_} : ''} @{$SDFilesInfo{CommonDataFieldsRef}[$FileIndex]};
 299     }
 300     elsif ($OptionsInfo{DataFieldsMode} =~ /^Specify$/i) {
 301       @LineWords = map { exists $DataFieldLabelAndValuesRef->{$_} ? $DataFieldLabelAndValuesRef->{$_} : ''} @{$OptionsInfo{SpecifiedDataFields}};
 302     }
 303 
 304     # Append calculated physicochemical properties data...
 305     for $PropertyName (@{$OptionsInfo{SpecifiedPropertyNames}}) {
 306       $PropertyValue = $PhysicochemicalPropertiesDataRef->{$PropertyName};
 307       push @LineWords, $PropertyValue;
 308     }
 309 
 310     # Write out RuleOf5 violations for molecule....
 311     if ($OptionsInfo{RuleOf5Violations}) {
 312       $PropertyValue = $PhysicochemicalPropertiesDataRef->{RuleOf5Violations};
 313       push @LineWords, $PropertyValue;
 314     }
 315 
 316     # Write out RuleOf3 violations for molecule....
 317     if ($OptionsInfo{RuleOf3Violations}) {
 318       $PropertyValue = $PhysicochemicalPropertiesDataRef->{RuleOf3Violations};
 319       push @LineWords, $PropertyValue;
 320     }
 321 
 322     $Line = JoinWords(\@LineWords, $OptionsInfo{OutDelim}, $OptionsInfo{OutQuote});
 323     print $NewTextFileRef "$Line\n";
 324   }
 325 }
 326 
 327 # Write out approriate column labels to text file...
 328 sub WriteTextFileCoulmnLabels {
 329   my($FileIndex, $NewTextFileRef) = @_;
 330   my($Line, @LineWords);
 331 
 332   @LineWords = ();
 333   if ($OptionsInfo{DataFieldsMode} =~ /^All$/i) {
 334     push @LineWords, @{$SDFilesInfo{AllDataFieldsRef}[$FileIndex]};
 335   }
 336   elsif ($OptionsInfo{DataFieldsMode} =~ /^Common$/i) {
 337     push @LineWords, @{$SDFilesInfo{CommonDataFieldsRef}[$FileIndex]};
 338   }
 339   elsif ($OptionsInfo{DataFieldsMode} =~ /^Specify$/i) {
 340     push @LineWords, @{$OptionsInfo{SpecifiedDataFields}};
 341   }
 342   elsif ($OptionsInfo{DataFieldsMode} =~ /^CompoundID$/i) {
 343     push @LineWords, $OptionsInfo{CompoundIDLabel};
 344   }
 345   my($SpecifiedPropertyName);
 346 
 347   # Append physicochemical properties column labels...
 348   push @LineWords,  @{$OptionsInfo{SpecifiedPropertyNames}};
 349 
 350   # Write out RuleOf5 violations label...
 351   if ($OptionsInfo{RuleOf5Violations}) {
 352     push @LineWords, 'RuleOf5Violations';
 353   }
 354 
 355   # Write out RuleOf3 violations label...
 356   if ($OptionsInfo{RuleOf3Violations}) {
 357     push @LineWords, 'RuleOf3Violations';
 358   }
 359 
 360   $Line = JoinWords(\@LineWords, $OptionsInfo{OutDelim}, $OptionsInfo{OutQuote});
 361   print $NewTextFileRef "$Line\n";
 362 }
 363 
 364 # Generate compound ID for text files..
 365 #
 366 sub SetupCmpdIDForTextFiles {
 367   my($CmpdCount, $Molecule, $DataFieldLabelAndValuesRef) = @_;
 368   my($CmpdID);
 369 
 370   $CmpdID = '';
 371   if ($OptionsInfo{CompoundIDMode} =~ /^MolNameOrLabelPrefix$/i) {
 372     my($MolName);
 373     $MolName = $Molecule->GetName();
 374     $CmpdID = $MolName ? $MolName : "$OptionsInfo{CompoundID}${CmpdCount}";
 375   }
 376   elsif ($OptionsInfo{CompoundIDMode} =~ /^LabelPrefix$/i) {
 377     $CmpdID = "$OptionsInfo{CompoundID}${CmpdCount}";
 378   }
 379   elsif ($OptionsInfo{CompoundIDMode} =~ /^DataField$/i) {
 380     my($SpecifiedDataField);
 381     $SpecifiedDataField = $OptionsInfo{CompoundID};
 382     $CmpdID = exists $DataFieldLabelAndValuesRef->{$SpecifiedDataField} ? $DataFieldLabelAndValuesRef->{$SpecifiedDataField} : '';
 383   }
 384   elsif ($OptionsInfo{CompoundIDMode} =~ /^MolName$/i) {
 385     $CmpdID = $Molecule->GetName();
 386   }
 387   return $CmpdID;
 388 }
 389 
 390 # Calculate physicochemical properties for molecule...
 391 #
 392 sub CalculateMoleculeProperties {
 393   my($MolecularDescriptorsGenerator, $Molecule) = @_;
 394   my($PropertyName, $PropertyValue, $MolecularDescriptorsObject, %CalculatedPhysicochemicalProperties);
 395 
 396   %CalculatedPhysicochemicalProperties = ();
 397 
 398   if ($OptionsInfo{KeepLargestComponent}) {
 399     $Molecule->KeepLargestComponent();
 400   }
 401 
 402   if (!$Molecule->DetectRings()) {
 403     return undef;
 404   }
 405   $Molecule->SetAromaticityModel($OptionsInfo{AromaticityModel});
 406   $Molecule->DetectAromaticity();
 407 
 408   if ($OptionsInfo{AddHydrogens}) {
 409     $Molecule->AddHydrogens();
 410   }
 411 
 412   # Calculate physicochemical properties...
 413   $MolecularDescriptorsGenerator->SetMolecule($Molecule);
 414   $MolecularDescriptorsGenerator->GenerateDescriptors();
 415 
 416   if (!$MolecularDescriptorsGenerator->IsDescriptorsGenerationSuccessful()) {
 417     return undef;
 418   }
 419 
 420   %CalculatedPhysicochemicalProperties = $MolecularDescriptorsGenerator->GetDescriptorNamesAndValues();
 421 
 422   # Count RuleOf3 violations...
 423   if ($OptionsInfo{RuleOf3Violations}) {
 424     CalculateRuleViolationsCount('RuleOf3Violations', \%CalculatedPhysicochemicalProperties);
 425   }
 426 
 427   # Count RuleOf5 violations...
 428   if ($OptionsInfo{RuleOf5Violations}) {
 429     CalculateRuleViolationsCount('RuleOf5Violations', \%CalculatedPhysicochemicalProperties);
 430   }
 431 
 432   return \%CalculatedPhysicochemicalProperties;
 433 }
 434 
 435 # Setup molecular descriptor generator to calculate property values for specifed
 436 # property names...
 437 #
 438 sub SetupMolecularDescriptorsGenerator {
 439   my($PropertyName, $MolecularDescriptorsGenerator);
 440 
 441   $MolecularDescriptorsGenerator = new MolecularDescriptors::MolecularDescriptorsGenerator('Mode' => 'Specify', 'DescriptorNames' => \@{$OptionsInfo{SpecifiedPropertyNames}});
 442 
 443   # Setup molecular desciptor calculation parameters...
 444   if (exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('MolecularWeight')}) || exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('ExactMass')}) ) {
 445     $MolecularDescriptorsGenerator->SetDescriptorClassParameters('DescriptorClassName' => 'WeightAndMassDescriptors', %{$OptionsInfo{PrecisionParametersMap}});
 446   }
 447 
 448   if (exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('RotatableBonds')})) {
 449     $MolecularDescriptorsGenerator->SetDescriptorClassParameters('DescriptorClassName' => 'RotatableBondsDescriptors', %{$OptionsInfo{RotatableBondsParametersMap}});
 450   }
 451 
 452   if (exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('HydrogenBondDonors')}) || exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('HydrogenBondAcceptors')}) ) {
 453     $MolecularDescriptorsGenerator->SetDescriptorClassParameters('DescriptorClassName' => 'HydrogenBondsDescriptors', 'HydrogenBondsType' => $OptionsInfo{HydrogenBonds});
 454   }
 455 
 456   if (exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('TPSA')})) {
 457     $MolecularDescriptorsGenerator->SetDescriptorClassParameters('DescriptorClassName' => 'TPSADescriptors', %{$OptionsInfo{TPSAParametersMap}});
 458   }
 459 
 460   if (exists($OptionsInfo{SpecifiedPropertyNamesMap}{lc('MolecularComplexity')})) {
 461     $MolecularDescriptorsGenerator->SetDescriptorClassParameters('DescriptorClassName' => 'MolecularComplexityDescriptors', %{$OptionsInfo{MolecularComplexityParametersMap}});
 462   }
 463 
 464   return $MolecularDescriptorsGenerator;
 465 }
 466 
 467 # Calculate RuleOf3 or RuleOf5 violations count...
 468 #
 469 sub CalculateRuleViolationsCount {
 470   my($RuleViolationsType, $CalculatedPropertiesMapRef) = @_;
 471   my($RuleViolationsCount, $PropertyName);
 472 
 473   $RuleViolationsCount = 0;
 474 
 475   RULEVIOLATIONSTYPE: {
 476     if ($RuleViolationsType =~ /^RuleOf3Violations$/i) {
 477       for $PropertyName (@{$OptionsInfo{RuleOf3PropertyNames}}) {
 478         if ($CalculatedPropertiesMapRef->{$PropertyName} > $OptionsInfo{RuleOf3MaxPropertyValuesMap}{$PropertyName}) {
 479           $RuleViolationsCount++;
 480         }
 481       }
 482       last RULEVIOLATIONSTYPE;
 483     }
 484 
 485     if ($RuleViolationsType =~ /^RuleOf5Violations$/i) {
 486       for $PropertyName (@{$OptionsInfo{RuleOf5PropertyNames}}) {
 487         if ($CalculatedPropertiesMapRef->{$PropertyName} > $OptionsInfo{RuleOf5MaxPropertyValuesMap}{$PropertyName}) {
 488           $RuleViolationsCount++;
 489         }
 490       }
 491       last RULEVIOLATIONSTYPE;
 492     }
 493 
 494     die "Warning: Unknown rule violation type: $RuleViolationsType...";
 495   }
 496 
 497   # Set rule violation count...
 498   $CalculatedPropertiesMapRef->{$RuleViolationsType} = $RuleViolationsCount;
 499 
 500 }
 501 
 502 # Retrieve information about SD files...
 503 #
 504 sub RetrieveSDFilesInfo {
 505   my($SDFile, $Index, $FileDir, $FileExt, $FileName, $OutFileRoot, $TextOutFileExt, $SDOutFileExt, $NewSDFileName, $NewTextFileName, $CheckDataField, $CollectDataFields, $AllDataFieldsRef, $CommonDataFieldsRef);
 506 
 507   %SDFilesInfo = ();
 508   @{$SDFilesInfo{FileOkay}} = ();
 509   @{$SDFilesInfo{OutFileRoot}} = ();
 510   @{$SDFilesInfo{SDOutFileNames}} = ();
 511   @{$SDFilesInfo{TextOutFileNames}} = ();
 512   @{$SDFilesInfo{AllDataFieldsRef}} = ();
 513   @{$SDFilesInfo{CommonDataFieldsRef}} = ();
 514 
 515   $CheckDataField = ($OptionsInfo{TextOutput} && ($OptionsInfo{DataFieldsMode} =~ /^CompoundID$/i) && ($OptionsInfo{CompoundIDMode} =~ /^DataField$/i)) ? 1 : 0;
 516   $CollectDataFields = ($OptionsInfo{TextOutput} && ($OptionsInfo{DataFieldsMode} =~ /^(All|Common)$/i)) ? 1 : 0;
 517 
 518   FILELIST: for $Index (0 .. $#SDFilesList) {
 519     $SDFile = $SDFilesList[$Index];
 520 
 521     $SDFilesInfo{FileOkay}[$Index] = 0;
 522     $SDFilesInfo{OutFileRoot}[$Index] = '';
 523     $SDFilesInfo{SDOutFileNames}[$Index] = '';
 524     $SDFilesInfo{TextOutFileNames}[$Index] = '';
 525 
 526     $SDFile = $SDFilesList[$Index];
 527     if (!(-e $SDFile)) {
 528       warn "Warning: Ignoring file $SDFile: It doesn't exist\n";
 529       next FILELIST;
 530     }
 531     if (!CheckFileType($SDFile, "sd sdf")) {
 532       warn "Warning: Ignoring file $SDFile: It's not a SD file\n";
 533       next FILELIST;
 534     }
 535 
 536     if ($CheckDataField) {
 537       # Make sure data field exists in SD file..
 538       my($CmpdString, $SpecifiedDataField, @CmpdLines, %DataFieldValues);
 539 
 540       @CmpdLines = ();
 541       open SDFILE, "$SDFile" or die "Error: Couldn't open $SDFile: $! \n";
 542       $CmpdString = ReadCmpdString(\*SDFILE);
 543       close SDFILE;
 544       @CmpdLines = split "\n", $CmpdString;
 545       %DataFieldValues = GetCmpdDataHeaderLabelsAndValues(\@CmpdLines);
 546       $SpecifiedDataField = $OptionsInfo{CompoundID};
 547       if (!exists $DataFieldValues{$SpecifiedDataField}) {
 548         warn "Warning: Ignoring file $SDFile: Data field value, $SpecifiedDataField, using  \"--CompoundID\" option in \"DataField\" \"--CompoundIDMode\" doesn't exist\n";
 549         next FILELIST;
 550       }
 551     }
 552 
 553     $AllDataFieldsRef = '';
 554     $CommonDataFieldsRef = '';
 555     if ($CollectDataFields) {
 556       my($CmpdCount);
 557       open SDFILE, "$SDFile" or die "Error: Couldn't open $SDFile: $! \n";
 558       ($CmpdCount, $AllDataFieldsRef, $CommonDataFieldsRef) = GetAllAndCommonCmpdDataHeaderLabels(\*SDFILE);
 559       close SDFILE;
 560     }
 561 
 562     # Setup output file names...
 563     $FileDir = ""; $FileName = ""; $FileExt = "";
 564     ($FileDir, $FileName, $FileExt) = ParseFileName($SDFile);
 565 
 566     $TextOutFileExt = "csv";
 567     if ($Options{outdelim} =~ /^tab$/i) {
 568       $TextOutFileExt = "tsv";
 569     }
 570     $SDOutFileExt = $FileExt;
 571 
 572     if ($OptionsInfo{OutFileRoot} && (@SDFilesList == 1)) {
 573       my ($RootFileDir, $RootFileName, $RootFileExt) = ParseFileName($OptionsInfo{OutFileRoot});
 574       if ($RootFileName && $RootFileExt) {
 575         $FileName = $RootFileName;
 576       }
 577       else {
 578         $FileName = $OptionsInfo{OutFileRoot};
 579       }
 580       $OutFileRoot = $FileName;
 581     }
 582     else {
 583       $OutFileRoot = "${FileName}PhysicochemicalProperties";
 584     }
 585 
 586     $NewSDFileName = "${OutFileRoot}.${SDOutFileExt}";
 587     $NewTextFileName = "${OutFileRoot}.${TextOutFileExt}";
 588 
 589     if ($OptionsInfo{SDOutput}) {
 590       if ($SDFile =~ /$NewSDFileName/i) {
 591         warn "Warning: Ignoring input file $SDFile: Same output, $NewSDFileName, and input file names.\n";
 592         print "Specify a different name using \"-r --root\" option or use default name.\n";
 593         next FILELIST;
 594       }
 595     }
 596 
 597     if (!$OptionsInfo{OverwriteFiles}) {
 598       # Check SD and text outout files...
 599       if ($OptionsInfo{SDOutput}) {
 600         if (-e $NewSDFileName) {
 601           warn "Warning: Ignoring file $SDFile: The file $NewSDFileName already exists\n";
 602           next FILELIST;
 603         }
 604       }
 605       if ($OptionsInfo{TextOutput}) {
 606         if (-e $NewTextFileName) {
 607           warn "Warning: Ignoring file $SDFile: The file $NewTextFileName already exists\n";
 608           next FILELIST;
 609         }
 610       }
 611     }
 612 
 613     $SDFilesInfo{FileOkay}[$Index] = 1;
 614 
 615     $SDFilesInfo{OutFileRoot}[$Index] = $OutFileRoot;
 616     $SDFilesInfo{SDOutFileNames}[$Index] = $NewSDFileName;
 617     $SDFilesInfo{TextOutFileNames}[$Index] = $NewTextFileName;
 618 
 619     $SDFilesInfo{AllDataFieldsRef}[$Index] = $AllDataFieldsRef;
 620     $SDFilesInfo{CommonDataFieldsRef}[$Index] = $CommonDataFieldsRef;
 621   }
 622 }
 623 
 624 # Process option values...
 625 sub ProcessOptions {
 626   %OptionsInfo = ();
 627 
 628   $OptionsInfo{AromaticityModel} = $Options{aromaticitymodel};
 629 
 630   # Process property name related options...
 631   ProcessPropertyNamesOption();
 632 
 633   # Setup RuleOf3 and RuleOf5 violation calculations...
 634   $OptionsInfo{RuleOf3Violations} = ($Options{ruleof3violations} =~ /^Yes$/i) ? 1 : 0;
 635   $OptionsInfo{RuleOf5Violations} = ($Options{ruleof5violations} =~ /^Yes$/i) ? 1 : 0;
 636 
 637   $OptionsInfo{CompoundIDMode} = $Options{compoundidmode};
 638   $OptionsInfo{CompoundIDLabel} = $Options{compoundidlabel};
 639   $OptionsInfo{DataFieldsMode} = $Options{datafieldsmode};
 640 
 641   my(@SpecifiedDataFields);
 642   @SpecifiedDataFields = ();
 643 
 644   @{$OptionsInfo{SpecifiedDataFields}} = ();
 645   $OptionsInfo{CompoundID} = '';
 646 
 647   if ($Options{datafieldsmode} =~ /^CompoundID$/i) {
 648     if ($Options{compoundidmode} =~ /^DataField$/i) {
 649       if (!$Options{compoundid}) {
 650         die "Error: You must specify a value for \"--CompoundID\" option in \"DataField\" \"--CompoundIDMode\". \n";
 651       }
 652       $OptionsInfo{CompoundID} = $Options{compoundid};
 653     }
 654     elsif ($Options{compoundidmode} =~ /^(LabelPrefix|MolNameOrLabelPrefix)$/i) {
 655       $OptionsInfo{CompoundID} = $Options{compoundid} ? $Options{compoundid} : 'Cmpd';
 656     }
 657   }
 658   elsif ($Options{datafieldsmode} =~ /^Specify$/i) {
 659     if (!$Options{datafields}) {
 660       die "Error: You must specify a value for \"--DataFields\" option in \"Specify\" \"-d, --DataFieldsMode\". \n";
 661     }
 662     @SpecifiedDataFields = split /\,/, $Options{datafields};
 663     push @{$OptionsInfo{SpecifiedDataFields}}, @SpecifiedDataFields;
 664   }
 665 
 666   # Types of hydrogen bonds...
 667   $OptionsInfo{HydrogenBonds} = $Options{hydrogenbonds};
 668 
 669   # Process precision value parameters...
 670   ProcessPrecisionOption();
 671 
 672   # Process rotatable bonds parameters...
 673   ProcessRotatableBondsOption();
 674 
 675   # Process TPSA parameters...
 676   ProcessTPSAOption();
 677 
 678   # Process molecular complexity parameters...
 679   ProcessMolecularComplexityOption();
 680 
 681   $OptionsInfo{Filter} = ($Options{filter} =~ /^Yes$/i) ? 1 : 0;
 682 
 683   $OptionsInfo{KeepLargestComponent} = ($Options{keeplargestcomponent} =~ /^Yes$/i) ? 1 : 0;
 684 
 685   $OptionsInfo{Output} = $Options{output};
 686   $OptionsInfo{SDOutput} = ($Options{output} =~ /^(SD|Both)$/i) ? 1 : 0;
 687   $OptionsInfo{TextOutput} = ($Options{output} =~ /^(Text|Both)$/i) ? 1 : 0;
 688 
 689   $OptionsInfo{OutDelim} = ($Options{outdelim} =~ /tab/i ) ? "\t" : (($Options{outdelim} =~ /semicolon/i) ? "\;" : "\,");
 690   $OptionsInfo{OutQuote} = ($Options{quote} =~ /^Yes$/i) ? 1 : 0;
 691 
 692   $OptionsInfo{OverwriteFiles} = $Options{overwrite} ? 1 : 0;
 693   $OptionsInfo{OutFileRoot} = $Options{root} ? $Options{root} : 0;
 694 }
 695 
 696 # Process property name related options...
 697 #
 698 sub ProcessPropertyNamesOption {
 699 
 700   # Setup supported physicochemical properties...
 701   my($SupportedProperty);
 702 
 703   @{$OptionsInfo{SupportedPropertyNames}} = ();
 704   %{$OptionsInfo{SupportedPropertyNamesMap}} = ();
 705 
 706   @{$OptionsInfo{RuleOf5PropertyNames}} = ();
 707   %{$OptionsInfo{RuleOf5MaxPropertyValuesMap}} = ();
 708 
 709   @{$OptionsInfo{RuleOf3PropertyNames}} = ();
 710   %{$OptionsInfo{RuleOf3MaxPropertyValuesMap}} = ();
 711 
 712   @{$OptionsInfo{DefaultPropertyNames}} = ();
 713 
 714   @{$OptionsInfo{SupportedPropertyNames}} = qw(MolecularWeight ExactMass HeavyAtoms Rings AromaticRings MolecularVolume RotatableBonds HydrogenBondDonors HydrogenBondAcceptors SLogP SMR TPSA Fsp3Carbons Sp3Carbons MolecularComplexity);
 715 
 716   @{$OptionsInfo{RuleOf5PropertyNames}} = qw(MolecularWeight HydrogenBondDonors HydrogenBondAcceptors SLogP);
 717   %{$OptionsInfo{RuleOf5MaxPropertyValuesMap}} = ('MolecularWeight' => 500, 'HydrogenBondDonors' => 5, 'HydrogenBondAcceptors' => 10,  'SLogP' => 5);
 718 
 719   @{$OptionsInfo{RuleOf3PropertyNames}} = qw(MolecularWeight RotatableBonds HydrogenBondDonors HydrogenBondAcceptors SLogP TPSA);
 720   %{$OptionsInfo{RuleOf3MaxPropertyValuesMap}} = ('MolecularWeight' => 300, 'RotatableBonds' => 3, 'HydrogenBondDonors' => 3, 'HydrogenBondAcceptors' => 3, 'SLogP' => 3, 'TPSA' => 60);
 721 
 722   @{$OptionsInfo{DefaultPropertyNames}} = qw(MolecularWeight HeavyAtoms MolecularVolume RotatableBonds HydrogenBondDonors HydrogenBondAcceptors SLogP TPSA);
 723 
 724   for $SupportedProperty (@{$OptionsInfo{SupportedPropertyNames}}) {
 725     $OptionsInfo{SupportedPropertyNamesMap}{lc($SupportedProperty)} = $SupportedProperty;
 726   }
 727 
 728   # Process specified properties....
 729   my($SpecifiedPropertyName, @SpecifiedPropertyNames, %SpecifiedPropertyNamesMap);
 730 
 731   @SpecifiedPropertyNames = ();
 732   %SpecifiedPropertyNamesMap = ();
 733 
 734   @{$OptionsInfo{SpecifiedPropertyNames}} = ();
 735   %{$OptionsInfo{SpecifiedPropertyNamesMap}} = ();
 736 
 737   if ($Options{mode} =~ /^All$/i) {
 738     @SpecifiedPropertyNames = @{$OptionsInfo{SupportedPropertyNames}};
 739   }
 740   elsif ($Options{mode} =~ /^RuleOf5$/i) {
 741     @SpecifiedPropertyNames = @{$OptionsInfo{RuleOf5PropertyNames}};
 742   }
 743   elsif ($Options{mode} =~ /^RuleOf3$/i) {
 744     @SpecifiedPropertyNames = @{$OptionsInfo{RuleOf3PropertyNames}};
 745   }
 746   elsif (IsEmpty($Options{mode})) {
 747     @SpecifiedPropertyNames = @{$OptionsInfo{DefaultPropertyNames}};
 748   }
 749   else {
 750     # Comma delimited lisr of specified property names...
 751     my($Mode, $PropertyName, @PropertyNames, @UnsupportedPropertyNames);
 752 
 753     $Mode = $Options{mode};
 754     $Mode =~ s/ //g;
 755 
 756     @PropertyNames = split ",", $Mode;
 757     @UnsupportedPropertyNames = ();
 758 
 759     for $PropertyName (@PropertyNames) {
 760       if (exists($OptionsInfo{SupportedPropertyNamesMap}{lc($PropertyName)})) {
 761         push @SpecifiedPropertyNames, $PropertyName;
 762       }
 763       else {
 764         push @UnsupportedPropertyNames, $PropertyName;
 765       }
 766     }
 767     if (@UnsupportedPropertyNames) {
 768       if (@UnsupportedPropertyNames > 1) {
 769         warn "Error: The physicochemical property names specified - ", JoinWords(\@UnsupportedPropertyNames, ", ", 0)," - for option \"-m --mode\" are not valid.\n";
 770       }
 771       else {
 772         warn "Error: The physicochemical property name specified, @UnsupportedPropertyNames , for option \"-m --mode\" is not valid.\n";
 773       }
 774       die "Allowed values:", JoinWords(\@{$OptionsInfo{SupportedPropertyNames}}, ", ", 0), "\n";
 775     }
 776     if (!@SpecifiedPropertyNames) {
 777       die "Error: No valid physicochemical property names specified for option \"-m --mode\".\n";
 778     }
 779   }
 780 
 781   # Set up specified property names map...
 782   PROPERTY: for $SpecifiedPropertyName (@SpecifiedPropertyNames) {
 783     if (exists $SpecifiedPropertyNamesMap{lc($SpecifiedPropertyName)}) {
 784       warn "Warning: The physicochemical property name, $SpecifiedPropertyName, is specified multiple times as value of option \"-m --mode\" .\n";
 785       next PROPERTY;
 786     }
 787     # Canonical specified property name...
 788     $SpecifiedPropertyNamesMap{lc($SpecifiedPropertyName)} = $OptionsInfo{SupportedPropertyNamesMap}{lc($SpecifiedPropertyName)};
 789   }
 790 
 791   # Make sure for calculation of  RuleOf3Violations, all appropriate property names are specified...
 792   if ($Options{ruleof3violations} =~ /^Yes$/i && $Options{mode} =~ /^RuleOf5$/i) {
 793     die "Error: The value specified, $Options{ruleof3violations}, for  \"--RuleOf3Violations\" option in \"RuleOf5\" \"-m --Mode\" is not valid. You must specify RuleOf3 value for \"-m --Mode\" to calculate RuleOf3 violations.\n";
 794   }
 795 
 796   if ($Options{ruleof3violations} =~ /^Yes$/i) {
 797     my($RuleOf3PropertyName, @MissingRuleOf3Names);
 798 
 799     @MissingRuleOf3Names = ();
 800     PROPERTY: for $RuleOf3PropertyName (@{$OptionsInfo{RuleOf3PropertyNames}}) {
 801       if (exists $SpecifiedPropertyNamesMap{lc($RuleOf3PropertyName)}) {
 802         next PROPERTY;
 803       }
 804       push @MissingRuleOf3Names, $RuleOf3PropertyName;
 805 
 806       # Add property name to specified properties names list and map...
 807       push @SpecifiedPropertyNames, $RuleOf3PropertyName;
 808       $SpecifiedPropertyNamesMap{lc($RuleOf3PropertyName)} = $OptionsInfo{SupportedPropertyNamesMap}{lc($RuleOf3PropertyName)};
 809     }
 810     if (@MissingRuleOf3Names) {
 811       warn "Warning: The following physicochemical property names not specified in \"-m --Mode\" option are required for calculating RuleOf3Violations and have been added to the list of property names: @MissingRuleOf3Names\n";
 812     }
 813   }
 814 
 815   # Make sure for calculation of  RuleOf5Violations, all appropriate property names are specified...
 816   if ($Options{ruleof5violations} =~ /^Yes$/i && $Options{mode} =~ /^RuleOf3$/i) {
 817     die "Error: The value specified, $Options{ruleof5violations}, for  \"--RuleOf5Violations\" option in \"RuleOf3\" \"-m --Mode\" is not valid. You must specify RuleOf5 value for \"-m --Mode\" to calculate RuleOf5 violations.\n";
 818   }
 819 
 820   if ($Options{ruleof5violations} =~ /^Yes$/i) {
 821     my($RuleOf5PropertyName, @MissingRuleOf5Names);
 822 
 823     @MissingRuleOf5Names = ();
 824     PROPERTY: for $RuleOf5PropertyName (@{$OptionsInfo{RuleOf5PropertyNames}}) {
 825       if (exists $SpecifiedPropertyNamesMap{lc($RuleOf5PropertyName)}) {
 826         next PROPERTY;
 827       }
 828       push @MissingRuleOf5Names, $RuleOf5PropertyName;
 829 
 830       # Add property name to specified properties names list and map...
 831       push @SpecifiedPropertyNames, $RuleOf5PropertyName;
 832       $SpecifiedPropertyNamesMap{lc($RuleOf5PropertyName)} = $OptionsInfo{SupportedPropertyNamesMap}{lc($RuleOf5PropertyName)};
 833     }
 834     if (@MissingRuleOf5Names) {
 835       warn "Warning: The following physicochemical property names not specified in \"-m --Mode\" option are required for calculating RuleOf5Violations and have been added to the list of property names: @MissingRuleOf5Names\n";
 836     }
 837   }
 838   $OptionsInfo{Mode} = $Options{mode};
 839 
 840   # Setup canonical specified property names corresponding to supported names in mixed case...
 841   my(@SpecifiedCanonicalPropertyNames);
 842 
 843   @SpecifiedCanonicalPropertyNames = ();
 844   for $SpecifiedPropertyName (@SpecifiedPropertyNames) {
 845     push @SpecifiedCanonicalPropertyNames, $SpecifiedPropertyNamesMap{lc($SpecifiedPropertyName)};
 846   }
 847   @{$OptionsInfo{SpecifiedPropertyNames}} = @SpecifiedCanonicalPropertyNames;
 848   %{$OptionsInfo{SpecifiedPropertyNamesMap}} = %SpecifiedPropertyNamesMap;
 849 
 850   # Based on specified property names, figure out whether hydrogens need to be added before
 851   # calculation of properties...
 852   #
 853   $OptionsInfo{AddHydrogens} = 0;
 854   if (exists($SpecifiedPropertyNamesMap{lc('MolecularVolume')}) || exists($SpecifiedPropertyNamesMap{lc('SLogP')}) || exists($SpecifiedPropertyNamesMap{lc('SMR')})) {
 855     $OptionsInfo{AddHydrogens} = 1;
 856   }
 857 }
 858 
 859 # Process precision option...
 860 #
 861 sub ProcessPrecisionOption {
 862   my($ParameterName, $ParameterValue, %PrecisionParametersMap, %PrecisionParameterNamesMap);
 863 
 864   %{$OptionsInfo{PrecisionParametersMap}} = ();
 865 
 866   %PrecisionParametersMap = ('WeightPrecision' => 2, 'MassPrecision' => 4);
 867   %PrecisionParameterNamesMap = ('molecularweight' => 'WeightPrecision', 'exactmass' => 'MassPrecision');
 868 
 869   if ($Options{precision}) {
 870     # Process specified values...
 871     my($Index, $SpecifiedPrecision, @SpecifiedPrecisionValuePairs);
 872 
 873     $SpecifiedPrecision = $Options{precision};
 874     $SpecifiedPrecision =~ s/ //g;
 875     @SpecifiedPrecisionValuePairs = split ",", $SpecifiedPrecision;
 876     if (@SpecifiedPrecisionValuePairs % 2) {
 877       die "Error: Invalid number of values specified using \"--Precision\" option: It must contain even number of values.\n";
 878     }
 879     for ($Index = 0; (($Index + 1) < @SpecifiedPrecisionValuePairs); $Index += 2 ) {
 880       $ParameterName = $SpecifiedPrecisionValuePairs[$Index];
 881       $ParameterValue = $SpecifiedPrecisionValuePairs[$Index + 1];
 882       if (!exists $PrecisionParameterNamesMap{lc($ParameterName)}) {
 883         die "Error: The precision parameter name specified, $ParameterName, for option \"--Precision\" is not valid.\n";
 884       }
 885       if (!IsPositiveInteger($ParameterValue)) {
 886         die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--Precision\" is not valid. Allowed values: positive integer. \n";
 887       }
 888       $ParameterName = $PrecisionParameterNamesMap{lc($ParameterName)};
 889       $PrecisionParametersMap{$ParameterName} = $ParameterValue;
 890     }
 891   }
 892   $OptionsInfo{Precision} = $Options{precision};
 893   %{$OptionsInfo{PrecisionParametersMap}} = %PrecisionParametersMap;
 894 }
 895 
 896 # Process rotatable bonds option...
 897 sub ProcessRotatableBondsOption {
 898   my($ParameterName, $ParameterValue, %RotatableBondsParametersMap, %RotatableBondsParameterNamesMap);
 899 
 900   %{$OptionsInfo{RotatableBondsParametersMap}} = ();
 901   %RotatableBondsParametersMap = ('IgnoreTerminalBonds' => 1, 'IgnoreBondsToTripleBonds' => 1, 'IgnoreAmideBonds' => 1, 'IgnoreThioamideBonds' => 1, 'IgnoreSulfonamideBonds' => 1);
 902 
 903   for $ParameterName (keys %RotatableBondsParametersMap) {
 904     $RotatableBondsParameterNamesMap{lc($ParameterName)} = $ParameterName;
 905   }
 906 
 907   if ($Options{rotatablebonds}) {
 908     # Process specified values...
 909     my($Index, $SpecifiedRotatableBonds, @SpecifiedRotatableBondsValuePairs);
 910 
 911     $SpecifiedRotatableBonds = $Options{rotatablebonds};
 912     $SpecifiedRotatableBonds =~ s/ //g;
 913     @SpecifiedRotatableBondsValuePairs = split ",", $SpecifiedRotatableBonds;
 914     if (@SpecifiedRotatableBondsValuePairs % 2) {
 915       die "Error: Invalid number of values specified using \"--RotatableBonds\" option: It must contain even number of values.\n";
 916     }
 917     for ($Index = 0; (($Index + 1) < @SpecifiedRotatableBondsValuePairs); $Index += 2 ) {
 918       $ParameterName = $SpecifiedRotatableBondsValuePairs[$Index];
 919       $ParameterValue = $SpecifiedRotatableBondsValuePairs[$Index + 1];
 920       if (!exists $RotatableBondsParameterNamesMap{lc($ParameterName)}) {
 921         die "Error: The rotatable bonds parameter name specified, $ParameterName, for option \"--RotatableBonds\" is not valid.\n";
 922       }
 923       if ($ParameterValue !~ /^(Yes|No)$/i) {
 924         die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--RotatableBonds\" is not valid. Allowed values: Yes or No. \n";
 925       }
 926       $ParameterName = $RotatableBondsParameterNamesMap{lc($ParameterName)};
 927       $ParameterValue = ($ParameterValue =~ /^Yes$/i) ? 1 : 0;
 928       $RotatableBondsParametersMap{$ParameterName} = $ParameterValue;
 929     }
 930   }
 931   $OptionsInfo{RotatableBonds} = $Options{rotatablebonds};
 932   %{$OptionsInfo{RotatableBondsParametersMap}} = %RotatableBondsParametersMap;
 933 }
 934 
 935 # Process TPSA option...
 936 #
 937 sub ProcessTPSAOption {
 938   my($ParameterName, $ParameterValue, %TPSAParametersMap, %TPSAParameterNamesMap);
 939 
 940   %{$OptionsInfo{TPSAParametersMap}} = ();
 941 
 942   %TPSAParametersMap = ('IgnorePhosphorus' => 1, 'IgnoreSulfur' => 1);
 943   for $ParameterName (keys %TPSAParametersMap) {
 944     $TPSAParameterNamesMap{lc($ParameterName)} = $ParameterName;
 945   }
 946 
 947   if ($Options{tpsa}) {
 948     # Process specified values...
 949     my($Index, $SpecifiedTPSA, @SpecifiedTPSAValuePairs);
 950 
 951     $SpecifiedTPSA = $Options{tpsa};
 952     $SpecifiedTPSA =~ s/ //g;
 953     @SpecifiedTPSAValuePairs = split ",", $SpecifiedTPSA;
 954     if (@SpecifiedTPSAValuePairs % 2) {
 955       die "Error: Invalid number of values specified using \"--TPSA\" option: It must contain even number of values.\n";
 956     }
 957     for ($Index = 0; (($Index + 1) < @SpecifiedTPSAValuePairs); $Index += 2 ) {
 958       $ParameterName = $SpecifiedTPSAValuePairs[$Index];
 959       $ParameterValue = $SpecifiedTPSAValuePairs[$Index + 1];
 960       if (!exists $TPSAParameterNamesMap{lc($ParameterName)}) {
 961         die "Error: The TPSA parameter name specified, $ParameterName, for option \"--TPSA\" is not valid.\n";
 962       }
 963       if ($ParameterValue !~ /^(Yes|No)$/i) {
 964         die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--TPSA\" is not valid. Allowed values: Yes or No. \n";
 965       }
 966       $ParameterName = $TPSAParameterNamesMap{lc($ParameterName)};
 967       $ParameterValue = ($ParameterValue =~ /^Yes$/i) ? 1 : 0;
 968       $TPSAParametersMap{$ParameterName} = $ParameterValue;
 969     }
 970   }
 971   $OptionsInfo{TPSA} = $Options{tpsa};
 972   %{$OptionsInfo{TPSAParametersMap}} = %TPSAParametersMap;
 973 }
 974 
 975 # Process molecular complexity parameters...
 976 #
 977 sub ProcessMolecularComplexityOption {
 978   my($MolecularComplexityType, $ParameterName, $ParameterValue, @ParameterNames, @ParameterValues, @AtomIdentifierTypeParameters, %ComplexityParametersMap, %ComplexityParameterNamesMap);
 979 
 980   %{$OptionsInfo{MolecularComplexityParametersMap}} = ();
 981 
 982   %ComplexityParametersMap = ('MolecularComplexityType' => '', 'AtomIdentifierType' => '',
 983                               'AtomicInvariantsToUse' => '', 'FunctionalClassesToUse' => '',
 984                               'MACCSKeysSize' => '166', 'NeighborhoodRadius' => '2',
 985                               'MinPathLength' => '1', 'MaxPathLength' => '8', 'UseBondSymbols' => '1',
 986                               'MinDistance' => '1', 'MaxDistance' => '10', 'UseTriangleInequality' => '',
 987                               'DistanceBinSize' => '2', 'NormalizationMethodology' => 'None');
 988 
 989   %ComplexityParameterNamesMap = ();
 990   for $ParameterName (keys %ComplexityParametersMap) {
 991     $ComplexityParameterNamesMap{lc($ParameterName)} = $ParameterName;
 992   }
 993 
 994   if ($Options{molecularcomplexity}) {
 995     # Process specified values...
 996     my($Index, $SpecifiedComplexity, @SpecifiedComplexityValuePairs);
 997 
 998     $SpecifiedComplexity = $Options{molecularcomplexity};
 999 
1000     @SpecifiedComplexityValuePairs = split ",", $SpecifiedComplexity;
1001     if (@SpecifiedComplexityValuePairs % 2) {
1002       die "Error: Invalid number of values specified using \"--MolecularComplexity\" option: It must contain even number of values.\n";
1003     }
1004 
1005     for ($Index = 0; (($Index + 1) < @SpecifiedComplexityValuePairs); $Index += 2 ) {
1006       $ParameterName = $SpecifiedComplexityValuePairs[$Index];
1007       $ParameterValue = $SpecifiedComplexityValuePairs[$Index + 1];
1008 
1009       $ParameterName = RemoveLeadingAndTrailingWhiteSpaces($ParameterName);
1010       $ParameterValue = RemoveLeadingAndTrailingWhiteSpaces($ParameterValue);
1011 
1012       if (!exists $ComplexityParameterNamesMap{lc($ParameterName)}) {
1013         die "Error: The molecular complexity parameter name specified, $ParameterName, for option \"--MolecularComplexity\" is not valid.\n";
1014       }
1015       $ParameterName = $ComplexityParameterNamesMap{lc($ParameterName)};
1016 
1017       if ($ParameterName =~ /^AtomicInvariantsToUse$/i) {
1018         my($AtomSymbolFound);
1019 
1020         $AtomSymbolFound = 0;
1021         @ParameterValues = split(' ', $ParameterValue);
1022         for $ParameterValue (@ParameterValues) {
1023           if (!AtomTypes::AtomicInvariantsAtomTypes::IsAtomicInvariantAvailable($ParameterValue)) {
1024             die "Error: The atomic invariant specified, $ParameterValue, for  AtomicInvariantsToUse in option \"--MolecularComplexity\" is not valid.\n";
1025           }
1026           if ($ParameterValue =~ /^(AS|AtomSymbol)$/i) {
1027             $AtomSymbolFound = 1;
1028           }
1029         }
1030         if (!$AtomSymbolFound) {
1031           die "Error: The atomic invariants specified using AtomicInvariantsToUse in option \"--MolecularComplexity\" is not valid: AtomicInvariant atom symbol, AS or AtomSymbol, must be specified.\n";
1032         }
1033         $ParameterValue = JoinWords(\@ParameterValues, ",", 0);
1034       }
1035       elsif ($ParameterName =~ /^FunctionalClassesToUse$/i) {
1036         @ParameterValues = split(' ', $ParameterValue);
1037         for $ParameterValue (@ParameterValues) {
1038           if (!AtomTypes::FunctionalClassAtomTypes::IsFunctionalClassAvailable($ParameterValue)) {
1039             die "Error: The functional class specified, $ParameterValue, for  FunctionalClassesToUse in option \"--MolecularComplexity\" is not valid.\n";
1040           }
1041         }
1042         $ParameterValue = JoinWords(\@ParameterValues, ",", 0);
1043       }
1044       else {
1045         if ($ParameterValue =~ / /) {
1046           $ParameterValue =~ s/ //g;
1047         }
1048         if ($ParameterValue =~ /^(Yes|No)$/i) {
1049           $ParameterValue = ($ParameterValue =~ /^Yes$/i) ? 1 : 0;
1050         }
1051       }
1052 
1053       if ($ParameterName =~ /^MolecularComplexityType$/i) {
1054         if ($ParameterValue !~ /^(AtomTypesFingerprints|ExtendedConnectivityFingerprints|MACCSKeys|PathLengthFingerprints|TopologicalAtomPairsFingerprints|TopologicalAtomTripletsFingerprints|TopologicalAtomTorsionsFingerprints|TopologicalPharmacophoreAtomPairsFingerprints|TopologicalPharmacophoreAtomTripletsFingerprints)$/i) {
1055           die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--MolecularComplexity\" is not valid. Allowed values: AtomTypesFingerprints, ExtendedConnectivityFingerprints, MACCSKeys, PathLengthFingerprints, TopologicalAtomPairsFingerprints, TopologicalAtomTripletsFingerprints, TopologicalAtomTorsionsFingerprints, TopologicalPharmacophoreAtomPairsFingerprints, or TopologicalPharmacophoreAtomTripletsFingerprints..\n";
1056         }
1057       }
1058       elsif ($ParameterName =~ /^AtomIdentifierType$/i) {
1059         if ($ParameterValue !~ /^(AtomicInvariantsAtomTypes|FunctionalClassAtomTypes|DREIDINGAtomTypes|EStateAtomTypes|MMFF94AtomTypes|SLogPAtomTypes|SYBYLAtomTypes|TPSAAtomTypes|UFFAtomTypes)$/i) {
1060           die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--MolecularComplexity\" is not valid. Supported atom identifier types in current release of MayaChemTools: AtomicInvariantsAtomTypes, FunctionalClassAtomTypes, DREIDINGAtomTypes, EStateAtomTypes, MMFF94AtomTypes, SLogPAtomTypes, SYBYLAtomTypes, TPSAAtomTypes and UFFAtomTypes.\n";
1061         }
1062       }
1063       elsif ($ParameterName =~ /^(MACCSKeysSize|MinPathLength|MaxPathLength|MinDistance|MaxDistance|DistanceBinSize)$/i) {
1064         if (!IsPositiveInteger($ParameterValue)) {
1065           die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--MolecularComplexity\" is not valid. Allowed values: positive integer. \n";
1066         }
1067       }
1068       elsif ($ParameterName =~ /^NeighborhoodRadius$/i) {
1069         if (!(IsInteger($ParameterValue) && $ParameterValue >=0)) {
1070           die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--MolecularComplexity\" is not valid. Allowed values: 0 or positive integer. \n";
1071         }
1072       }
1073       elsif ($ParameterName =~ /^NormalizationMethodology$/i) {
1074         if ($ParameterValue !~ /^(None|ByHeavyAtomsCount|ByPossibleKeysCount)$/i) {
1075           die "Error: The parameter value specified, $ParameterValue, for parameter name, $ParameterName in option \"--MolecularComplexity\" is not valid. Allowed values: None, ByHeavyAtomsCount, or ByPossibleKeysCount\n";
1076         }
1077       }
1078       $ComplexityParametersMap{$ParameterName} = $ParameterValue;
1079     }
1080 
1081     if ($ComplexityParametersMap{MACCSKeysSize} !~ /^(166|322)$/i) {
1082       die "Error: The parameter value specified, $ComplexityParametersMap{MACCSKeysSize}, for parameter name, MACCSKeysSize in option \"--MolecularComplexity\" is not valid. Allowed values: 166 or 322\n";
1083     }
1084     if ($ComplexityParametersMap{MinPathLength} > $ComplexityParametersMap{MaxPathLength}) {
1085       die "Error: The parameter value specified for MinPathLength, $ComplexityParametersMap{MinPathLength}, must be <= MaxPathLength, $ComplexityParametersMap{MaxPathLength} ...\n";
1086     }
1087     if ($ComplexityParametersMap{MinDistance} > $ComplexityParametersMap{MaxDistance}) {
1088       die "Error: The parameter value specified for MinDistance, $ComplexityParametersMap{MinDistance}, must be <= MaxDistance, $ComplexityParametersMap{MaxDistance} ...\n";
1089     }
1090   }
1091 
1092   # Set default parameter values...
1093 
1094   if (IsEmpty($ComplexityParametersMap{MolecularComplexityType})) {
1095     $ComplexityParametersMap{MolecularComplexityType} = 'MACCSKeys';
1096   }
1097   $MolecularComplexityType = $ComplexityParametersMap{MolecularComplexityType};
1098 
1099 
1100   if (IsEmpty($ComplexityParametersMap{AtomIdentifierType})) {
1101     $ComplexityParametersMap{AtomIdentifierType} = ($MolecularComplexityType =~ /^(TopologicalPharmacophoreAtomPairsFingerprints|TopologicalPharmacophoreAtomTripletsFingerprints)$/i) ? "FunctionalClassAtomTypes" : "AtomicInvariantsAtomTypes";
1102   }
1103 
1104   if (IsEmpty($ComplexityParametersMap{AtomicInvariantsToUse})) {
1105     my($AtomicInvariantsToUse);
1106 
1107     if ($MolecularComplexityType =~ /^(AtomTypesFingerprints|TopologicalAtomPairsFingerprints|TopologicalAtomTripletsFingerprints|TopologicalAtomTorsionsFingerprints)$/i) {
1108       $AtomicInvariantsToUse = "AS,X,BO,H,FC";
1109     }
1110     elsif ($MolecularComplexityType =~ /^ExtendedConnectivityFingerprints$/i) {
1111       $AtomicInvariantsToUse = "AS,X,BO,H,FC,MN";
1112     }
1113     else {
1114       $AtomicInvariantsToUse = "AS";
1115     }
1116     $ComplexityParametersMap{AtomicInvariantsToUse} = $AtomicInvariantsToUse;
1117   }
1118 
1119   if (IsEmpty($ComplexityParametersMap{FunctionalClassesToUse})) {
1120     my($FunctionalClassesToUse);
1121 
1122     if ($MolecularComplexityType =~ /^TopologicalPharmacophoreAtomPairsFingerprints$/i) {
1123       $FunctionalClassesToUse = "HBD,HBA,PI,NI,H";
1124     }
1125     elsif ($MolecularComplexityType =~ /^TopologicalPharmacophoreAtomTripletsFingerprints$/i) {
1126       $FunctionalClassesToUse = "HBD,HBA,PI,NI,H,Ar";
1127     }
1128     else {
1129       $FunctionalClassesToUse = "HBD,HBA,PI,NI,H,Ar,Hal";
1130     }
1131     $ComplexityParametersMap{FunctionalClassesToUse} = $FunctionalClassesToUse;
1132   }
1133 
1134   my(@AtomicInvariantsToUse);
1135   @AtomicInvariantsToUse = split ',', $ComplexityParametersMap{AtomicInvariantsToUse};
1136   $ComplexityParametersMap{AtomicInvariantsToUse} = \@AtomicInvariantsToUse;
1137 
1138   my(@FunctionalClassesToUse);
1139   @FunctionalClassesToUse = split ',', $ComplexityParametersMap{FunctionalClassesToUse};
1140   $ComplexityParametersMap{FunctionalClassesToUse} = \@FunctionalClassesToUse;
1141 
1142   if (IsEmpty($ComplexityParametersMap{UseTriangleInequality})) {
1143     $ComplexityParametersMap{UseTriangleInequality} = 0;
1144     if ($MolecularComplexityType =~ /^TopologicalPharmacophoreAtomTripletsFingerprints$/i) {
1145       $ComplexityParametersMap{UseTriangleInequality} = 1;
1146     }
1147   }
1148 
1149   if ($MolecularComplexityType =~ /^(TopologicalPharmacophoreAtomPairsFingerprints|TopologicalPharmacophoreAtomTripletsFingerprints)$/i) {
1150     if ($ComplexityParametersMap{AtomIdentifierType} !~ /^FunctionalClassAtomTypes$/i) {
1151       die "Error: The parameter value specified for AtomIdentifierType, $ComplexityParametersMap{AtomIdentifierType}, in option \"--MolecularComplexity\" is not valid for MolecularComplexityType, $MolecularComplexityType: Allowed value: FunctionalClassAtomTypes...\n";
1152     }
1153   }
1154 
1155   # Set up approprate paremeter names for specified molecular complexity...
1156 
1157   @ParameterNames = ();
1158   push @ParameterNames, 'MolecularComplexityType';
1159 
1160   @AtomIdentifierTypeParameters = ();
1161   push @AtomIdentifierTypeParameters, 'AtomIdentifierType';
1162   if ($ComplexityParametersMap{AtomIdentifierType} =~ /^AtomicInvariantsAtomTypes$/i) {
1163     push @AtomIdentifierTypeParameters, 'AtomicInvariantsToUse';
1164   }
1165   elsif ($ComplexityParametersMap{AtomIdentifierType} =~ /^FunctionalClassAtomTypes$/i) {
1166     push @AtomIdentifierTypeParameters, 'FunctionalClassesToUse';
1167   }
1168 
1169   COMPLEXITYTYPE: {
1170     if ($MolecularComplexityType =~ /^AtomTypesFingerprints$/i) {
1171       push @ParameterNames, @AtomIdentifierTypeParameters;
1172       last COMPLEXITYTYPE;
1173     }
1174     if ($MolecularComplexityType =~ /^ExtendedConnectivityFingerprints$/i) {
1175       push @ParameterNames, @AtomIdentifierTypeParameters;
1176       push @ParameterNames, ('NeighborhoodRadius', 'NormalizationMethodology');
1177       last COMPLEXITYTYPE;
1178     }
1179     if ($MolecularComplexityType =~ /^MACCSKeys$/i) {
1180       push @ParameterNames, 'MACCSKeysSize';
1181       last COMPLEXITYTYPE;
1182     }
1183     if ($MolecularComplexityType =~ /^PathLengthFingerprints$/i) {
1184       push @ParameterNames, @AtomIdentifierTypeParameters;
1185       push @ParameterNames, ('MinPathLength', 'MaxPathLength', 'UseBondSymbols');
1186       last COMPLEXITYTYPE;
1187     }
1188     if ($MolecularComplexityType =~ /^TopologicalAtomPairsFingerprints$/i) {
1189       push @ParameterNames, @AtomIdentifierTypeParameters;
1190       push @ParameterNames, ('MinDistance', 'MaxDistance');
1191       last COMPLEXITYTYPE;
1192     }
1193     if ($MolecularComplexityType =~ /^TopologicalAtomTripletsFingerprints$/i) {
1194       push @ParameterNames, @AtomIdentifierTypeParameters;
1195       push @ParameterNames, ('MinDistance', 'MaxDistance', 'UseTriangleInequality');
1196       last COMPLEXITYTYPE;
1197     }
1198     if ($MolecularComplexityType =~ /^TopologicalAtomTorsionsFingerprints$/i) {
1199       push @ParameterNames, @AtomIdentifierTypeParameters;
1200       last COMPLEXITYTYPE;
1201     }
1202     if ($MolecularComplexityType =~ /^TopologicalPharmacophoreAtomPairsFingerprints$/i) {
1203       push @ParameterNames, ('AtomIdentifierType', 'FunctionalClassesToUse', 'MinDistance', 'MaxDistance', 'NormalizationMethodology');
1204       last COMPLEXITYTYPE;
1205     }
1206     if ($MolecularComplexityType =~ /^TopologicalPharmacophoreAtomTripletsFingerprints$/i) {
1207       push @ParameterNames, ('AtomIdentifierType', 'FunctionalClassesToUse', 'MinDistance', 'MaxDistance', 'UseTriangleInequality', 'NormalizationMethodology', 'DistanceBinSize');
1208       last COMPLEXITYTYPE;
1209     }
1210     die "Error: The parameter value specified, $ParameterValue, for parameter name MolecularComplexityType using \"--MolecularComplexity\" is not valid.\n";
1211   }
1212 
1213   $OptionsInfo{MolecularComplexity} = $Options{molecularcomplexity};
1214 
1215   %{$OptionsInfo{MolecularComplexityParametersMap}} = ();
1216   for $ParameterName (@ParameterNames) {
1217     $ParameterValue = $ComplexityParametersMap{$ParameterName};
1218     $OptionsInfo{MolecularComplexityParametersMap}{$ParameterName} = $ParameterValue;
1219   }
1220 }
1221 
1222 # Setup script usage  and retrieve command line arguments specified using various options...
1223 sub SetupScriptUsage {
1224 
1225   # Retrieve all the options...
1226   %Options = ();
1227 
1228   $Options{aromaticitymodel} = 'MayaChemToolsAromaticityModel';
1229 
1230   $Options{compoundidmode} = 'LabelPrefix';
1231   $Options{compoundidlabel} = 'CompoundID';
1232   $Options{datafieldsmode} = 'CompoundID';
1233 
1234   $Options{filter} = 'Yes';
1235 
1236   $Options{hydrogenbonds} = 'HBondsType2';
1237 
1238   $Options{keeplargestcomponent} = 'Yes';
1239 
1240   # Default mode values are set later...
1241   $Options{mode} = '';
1242 
1243   # Default moelcular complexity values are set later...
1244   $Options{molecularcomplexity} = '';
1245 
1246   # Default precision values are set later...
1247   $Options{precision} = '';
1248 
1249   $Options{output} = 'text';
1250   $Options{outdelim} = 'comma';
1251   $Options{quote} = 'yes';
1252 
1253   # Default rotatable bond parameter values are set later...
1254   $Options{rotatablebonds} = '';
1255 
1256   $Options{ruleof3violations} = 'No';
1257   $Options{ruleof5violations} = 'No';
1258 
1259   # Default TPSA paramater values are set later...
1260   $Options{tpsa} = '';
1261 
1262   if (!GetOptions(\%Options, "aromaticitymodel=s", "compoundid=s", "compoundidlabel=s", "compoundidmode=s", "datafields=s", "datafieldsmode|d=s", "filter|f=s", "help|h", "hydrogenbonds=s", "keeplargestcomponent|k=s", "mode|m=s", "molecularcomplexity=s", "outdelim=s", "output=s", "overwrite|o", "precision=s", "rotatablebonds=s", "ruleof3violations=s", "ruleof5violations=s", "quote|q=s", "root|r=s", "tpsa=s", "workingdir|w=s")) {
1263     die "\nTo get a list of valid options and their values, use \"$ScriptName -h\" or\n\"perl -S $ScriptName -h\" command and try again...\n";
1264   }
1265   if ($Options{workingdir}) {
1266     if (! -d $Options{workingdir}) {
1267       die "Error: The value specified, $Options{workingdir}, for option \"-w --workingdir\" is not a directory name.\n";
1268     }
1269     chdir $Options{workingdir} or die "Error: Couldn't chdir $Options{workingdir}: $! \n";
1270   }
1271   if (!Molecule::IsSupportedAromaticityModel($Options{aromaticitymodel})) {
1272     my(@SupportedModels) = Molecule::GetSupportedAromaticityModels();
1273     die "Error: The value specified, $Options{aromaticitymodel}, for option \"--AromaticityModel\" is not valid. Supported aromaticity models in current release of MayaChemTools: @SupportedModels\n";
1274   }
1275   if ($Options{compoundidmode} !~ /^(DataField|MolName|LabelPrefix|MolNameOrLabelPrefix)$/i) {
1276     die "Error: The value specified, $Options{compoundidmode}, for option \"--CompoundIDMode\" is not valid. Allowed values: DataField, MolName, LabelPrefix or MolNameOrLabelPrefix\n";
1277   }
1278   if ($Options{datafieldsmode} !~ /^(All|Common|Specify|CompoundID)$/i) {
1279     die "Error: The value specified, $Options{datafieldsmode}, for option \"-d, --DataFieldsMode\" is not valid. Allowed values: All, Common, Specify or CompoundID\n";
1280   }
1281   if ($Options{filter} !~ /^(Yes|No)$/i) {
1282     die "Error: The value specified, $Options{filter}, for option \"-f, --Filter\" is not valid. Allowed values: Yes or No\n";
1283   }
1284   if ($Options{hydrogenbonds} !~ /^(HBondsType1|HydrogenBondsType1|HBondsType2|HydrogenBondsType2)$/i) {
1285     die "Error: The value specified, $Options{hydrogenbonds}, for option \"--HydrogenBonds\" is not valid. Allowed values: HBondsType1, HydrogenBondsType1, HBondsType2, HydrogenBondsType2\n";
1286   }
1287   if ($Options{keeplargestcomponent} !~ /^(Yes|No)$/i) {
1288     die "Error: The value specified, $Options{keeplargestcomponent}, for option \"-k, --KeepLargestComponent\" is not valid. Allowed values: Yes or No\n";
1289   }
1290   if ($Options{output} !~ /^(SD|text|both)$/i) {
1291     die "Error: The value specified, $Options{output}, for option \"--output\" is not valid. Allowed values: SD, text, or both\n";
1292   }
1293   if ($Options{outdelim} !~ /^(comma|semicolon|tab)$/i) {
1294     die "Error: The value specified, $Options{outdelim}, for option \"--outdelim\" is not valid. Allowed values: comma, tab, or semicolon\n";
1295   }
1296   if ($Options{quote} !~ /^(Yes|No)$/i) {
1297     die "Error: The value specified, $Options{quote}, for option \"-q --quote\" is not valid. Allowed values: Yes or No\n";
1298   }
1299   if ($Options{ruleof3violations} !~ /^(Yes|No)$/i) {
1300     die "Error: The value specified, $Options{ruleof3violations}, for option \"--RuleOf3Violations\" is not valid. Allowed values: Yes or No\n";
1301   }
1302   if ($Options{ruleof5violations} !~ /^(Yes|No)$/i) {
1303     die "Error: The value specified, $Options{ruleof5violations}, for option \"--RuleOf5Violations\" is not valid. Allowed values: Yes or No\n";
1304   }
1305 }
1306