Example #1
0
 def printPKA(self):
     """ 
     Prints the result for current configuration (determinants + summary)
     """ 
     output.printPKASection(self)
Example #2
0
 def printPKA(self):
     """ 
     Prints the result for current configuration (determinants + summary)
     """
     output.printPKASection(self)
Example #3
0
    def calculateAveragePKA(self, version=None, options=None):
        """ 
        Calculates the pKa values of each configuration and averages them
        """ 
        # initializing dictionaries for making averages, key = 'residue.label'
        pkas         = {}
        Nmass        = {}
        Emass        = {}
        Nlocl        = {}
        Elocl        = {}
        determinants = {}
        number_of_configurations = len(self.configurations)
        # setting up list for 'propka1 pka residues'
        pka_residues = []
        for resName in lib.residueList("propka1"):
          pka_residues.extend(self.residue_dictionary[resName])
        # initializing dictionaries for making averages, key = 'configuration label'
        for residue in pka_residues:
          key = residue.label
          pkas[key]  = {}
          Nmass[key] = {}
          Emass[key] = {}
          Nlocl[key] = {}
          Elocl[key] = {}
          # initializing dictionary for making averages, key = 'determinant.label'
          determinants[key] = [{}, {}, {}]

        # perform pKa calulation on each configuration and add pKa properties to dictionaries
        for key in self.configurations:
          self.setConfiguration(key=key, options=options)
          self.calculateConfigurationPKA(version=version, options=options)
          # printing out the pKa section for this configuration
          if options.verbose == True:
              output.printPKASection(self)

          # transferring property to right dictionary
          for residue in pka_residues:
            residue_key = residue.label
            pkas[residue_key][key]  = residue.pKa_pro
            Nmass[residue_key][key] = residue.Nmass
            Emass[residue_key][key] = residue.Emass
            Nlocl[residue_key][key] = residue.Nlocl
            Elocl[residue_key][key] = residue.Elocl
            for type in range(3):
              for determinant in residue.determinants[type]:
                if determinant.label in determinants[residue_key][type]:
                  determinants[residue_key][type][determinant.label] += determinant.value
                else:
                  determinants[residue_key][type][determinant.label]  = determinant.value

        # print each configuration-pKa in nice matrix
        residue_list   =    self.residue_dictionary["ASP"]
        residue_list.extend(self.residue_dictionary["GLU"])
        str = "%4s" % ("Res#")
        for residue in residue_list:
          str += "%6d" % (residue.resNumb)
        pka_print(str)
        index = 0
        for key in self.configurations:
          str = "%4s:" % (key)
          for residue in residue_list:
            reskey = residue.label
            str += "%6.2lf" % (pkas[reskey][key])
            #str += "%6.2lf" % (Emass[reskey][key])
            #str += "%6.2lf" % (Elocl[reskey][key])
          pka_print(str)

        # get the average pKa properties by dividing the sum with number of configurations, len(configuration keys)
        from determinants import Determinant
        for residue in pka_residues:
          residue_key = residue.label
          sum_pka = 0.00; sum_Nmass = 0.00; sum_Emass = 0.00; sum_Nlocl = 0.00; sum_Elocl = 0.00
          for key in pkas[residue_key].keys():
            sum_pka   += pkas[residue_key][key]
            sum_Nmass += Nmass[residue_key][key]
            sum_Emass += Emass[residue_key][key]
            sum_Nlocl += Nlocl[residue_key][key]
            sum_Elocl += Elocl[residue_key][key]
          residue.pKa_pro = sum_pka/len( pkas[residue_key].keys() )
          residue.Nmass   = sum_Nmass/len( pkas[residue_key].keys() )
          residue.Emass   = sum_Emass/len( pkas[residue_key].keys() )
          residue.Nlocl   = sum_Nlocl/len( pkas[residue_key].keys() )
          residue.Elocl   = sum_Elocl/len( pkas[residue_key].keys() )
          residue.determinants = [[], [], []]
          for type in range(3):
            for key in determinants[residue_key][type].keys():
              value = determinants[residue_key][type][key] / len( pkas[residue_key].keys() )
              if abs(value) > 0.005:  # <-- removing determinant that appears as 0.00
                newDeterminant = Determinant(key, value)
                residue.determinants[type].append(newDeterminant)

        return
Example #4
0
    def calculateAveragePKA(self, version=None, options=None):
        """ 
        Calculates the pKa values of each configuration and averages them
        """
        # initializing dictionaries for making averages, key = 'residue.label'
        pkas = {}
        Nmass = {}
        Emass = {}
        Nlocl = {}
        Elocl = {}
        determinants = {}
        number_of_configurations = len(self.configurations)
        # setting up list for 'propka1 pka residues'
        pka_residues = []
        for resName in lib.residueList("propka1"):
            pka_residues.extend(self.residue_dictionary[resName])
        # initializing dictionaries for making averages, key = 'configuration label'
        for residue in pka_residues:
            key = residue.label
            pkas[key] = {}
            Nmass[key] = {}
            Emass[key] = {}
            Nlocl[key] = {}
            Elocl[key] = {}
            # initializing dictionary for making averages, key = 'determinant.label'
            determinants[key] = [{}, {}, {}]

        # perform pKa calulation on each configuration and add pKa properties to dictionaries
        for key in self.configurations:
            self.setConfiguration(key=key, options=options)
            self.calculateConfigurationPKA(version=version, options=options)
            # printing out the pKa section for this configuration
            if options.verbose == True:
                output.printPKASection(self)

            # transferring property to right dictionary
            for residue in pka_residues:
                residue_key = residue.label
                pkas[residue_key][key] = residue.pKa_pro
                Nmass[residue_key][key] = residue.Nmass
                Emass[residue_key][key] = residue.Emass
                Nlocl[residue_key][key] = residue.Nlocl
                Elocl[residue_key][key] = residue.Elocl
                for type in range(3):
                    for determinant in residue.determinants[type]:
                        if determinant.label in determinants[residue_key][
                                type]:
                            determinants[residue_key][type][
                                determinant.label] += determinant.value
                        else:
                            determinants[residue_key][type][
                                determinant.label] = determinant.value

        # print each configuration-pKa in nice matrix
        residue_list = self.residue_dictionary["ASP"]
        residue_list.extend(self.residue_dictionary["GLU"])
        str = "%4s" % ("Res#")
        for residue in residue_list:
            str += "%6d" % (residue.resNumb)
        pka_print(str)
        index = 0
        for key in self.configurations:
            str = "%4s:" % (key)
            for residue in residue_list:
                reskey = residue.label
                str += "%6.2lf" % (pkas[reskey][key])
                #str += "%6.2lf" % (Emass[reskey][key])
                #str += "%6.2lf" % (Elocl[reskey][key])
            pka_print(str)

        # get the average pKa properties by dividing the sum with number of configurations, len(configuration keys)
        from determinants import Determinant
        for residue in pka_residues:
            residue_key = residue.label
            sum_pka = 0.00
            sum_Nmass = 0.00
            sum_Emass = 0.00
            sum_Nlocl = 0.00
            sum_Elocl = 0.00
            for key in pkas[residue_key].keys():
                sum_pka += pkas[residue_key][key]
                sum_Nmass += Nmass[residue_key][key]
                sum_Emass += Emass[residue_key][key]
                sum_Nlocl += Nlocl[residue_key][key]
                sum_Elocl += Elocl[residue_key][key]
            residue.pKa_pro = sum_pka / len(pkas[residue_key].keys())
            residue.Nmass = sum_Nmass / len(pkas[residue_key].keys())
            residue.Emass = sum_Emass / len(pkas[residue_key].keys())
            residue.Nlocl = sum_Nlocl / len(pkas[residue_key].keys())
            residue.Elocl = sum_Elocl / len(pkas[residue_key].keys())
            residue.determinants = [[], [], []]
            for type in range(3):
                for key in determinants[residue_key][type].keys():
                    value = determinants[residue_key][type][key] / len(
                        pkas[residue_key].keys())
                    if abs(
                            value
                    ) > 0.005:  # <-- removing determinant that appears as 0.00
                        newDeterminant = Determinant(key, value)
                        residue.determinants[type].append(newDeterminant)

        return