Recipe: HBond Buster

created by Enzyme

Profile

• Name: HBond Buster
• ID: 101005
• Shared with: Public
• Parent: None
• Children:
  • HBond Buster ci 0.5
  • HBond Buster Fast Helix
  • HBond Buster no mutate
• Created on: May 17, 2015 at 01:59 AM UTC
• Updated on: May 17, 2015 at 01:59 AM UTC
• Description:

  cycles through all rotamer positions of selected segments

Code

--Foldit **************
Foldit = {
    ["absolutebest"] = absolutebest,
    ["band"] = band,
    ["behavior"] = behavior,
    ["contactmap"] = contactmap,
    ["creditbest"] = creditbest,
    ["current"] = current,
    ["dialog"] = dialog,
    ["freeze"] = freeze,
    ["puzzle"] = puzzle,
    ["recentbest"] = recentbest,
    ["recipe"] = recipe,
    ["rotamer"] = rotamer,
    ["save"] = save,
    ["scoreboard"] = scoreboard,
    ["selection"] = selection,
    ["structure"] = structure,
    ["ui"] = ui,
    ["undo"] = undo,
    ["user"] = user
    }
Foldit.LoadModule = function()
    absolutebest = Foldit.absolutebest
    band = Foldit.band
    behavior = Foldit.behavior
    contactmap = Foldit.contactmap
    creditbest = Foldit.creditbest
    current = Foldit.current
    dialog = Foldit.dialog
    freeze = Foldit.freeze
    puzzle = Foldit.puzzle
    recentbest = Foldit.recentbest
    recipe = Foldit.recipe
    rotamer = Foldit.rotamer
    save = Foldit.save
    scoreboard = Foldit.scoreboard
    selection = Foldit.selection
    structure = Foldit.structure
    ui = Foldit.ui
    undo = Foldit.undo
    user = Foldit.user
    Foldit.IsLoaded = true
    return
    end
Foldit.LoadModule()

--DBug **************
DBug = Foldit
DBug.LoadModule = function()
    absolutebest = DBug.absolutebest
    band = DBug.band
    behavior = DBug.behavior
    contactmap = DBug.contactmap
    creditbest = DBug.creditbest
    current = DBug.current
    dialog = DBug.dialog
    freeze = DBug.freeze
    puzzle = DBug.puzzle
    recentbest = DBug.recentbest
    recipe = DBug.recipe
    rotamer = DBug.rotamer
    save = DBug.save
    scoreboard = DBug.scoreboard
    selection = DBug.selection
    structure = DBug.structure
    ui = DBug.ui
    undo = DBug.undo
    user = DBug.user
    DBug.IsLoaded = true
    return
    end
DBug.LoadModule()
    
--AFK **************
AFK = DBug
AFK.structure.Count = Foldit.structure.GetCount()
AFK.selection.GetSelectedSegments = function()
    local selectedSegments = {
        ["Count"] = selection.GetCount()}
    for segmentIndex = 1, AFK.structure.Count do
        selectedSegments[segmentIndex] = selection.IsSelected(segmentIndex)
        end
    return selectedSegments
    end
AFK.LoadModule = function()
    absolutebest = AFK.absolutebest
    band = AFK.band
    behavior = AFK.behavior
    contactmap = AFK.contactmap
    creditbest = AFK.creditbest
    current = AFK.current
    dialog = AFK.dialog
    freeze = AFK.freeze
    puzzle = AFK.puzzle
    recentbest = AFK.recentbest
    recipe = AFK.recipe
    rotamer = AFK.rotamer
    save = AFK.save
    scoreboard = AFK.scoreboard
    selection = AFK.selection
    structure = AFK.structure
    ui = AFK.ui
    undo = AFK.undo
    user = AFK.user
    AFK.IsLoaded = true
end
AFK.LoadModule()

--SkyNet **************
SkyNet = AFK
SkyNet.rotamer.BruteForce = function(doWiggle, AnalysisLevel, allowNonBondingAminoAcids)
    recentbest.Restore()
    band.DeleteAll()
    behavior.SetClashImportance(1)
    local startScore = current.GetEnergyScore()
    local highScore = current.GetEnergyScore()
    print("\nstartScore="..highScore)
    
    local doWiggle = doWiggle
    if(doWiggle ~= true) then
        doWiggle = false
    else
        print("doWiggle="..tostring(doWiggle))
        end
    
    local AnalysisLevel = AnalysisLevel
    if(type(AnalysisLevel) ~= "number") then
        AnalysisLevel = 0
    else
        print("AnalysisLevel="..tostring(AnalysisLevel))
        end
    
    if(selection.GetCount() == 0) then
        selection.SelectAll()
        end
    local selectedSegments = selection.GetSelectedSegments()
    local originalSelectedSegments = selection.GetSelectedSegments()
    print("selectedSegments.Count="..selectedSegments.Count)
    selection.DeselectAll()
    
    local segmentScores = {}
    for segmentIndex = 1, structure.Count do
        segmentScores[segmentIndex] = current.GetSegmentEnergyScore(segmentIndex)
        end
        
    local primaryStructures = {"d","e","h","k","n","q","r","s","t","w","y"}
    local allowNonBondingAminoAcids = allowNonBondingAminoAcids
    if(allowNonBondingAminoAcids ~= false) then
        allowNonBondingAminoAcids = true
        primaryStructures = {"a","d","e","f","g","h","i","k","l","m","n","p","q","r","s","t","v","w","y"}
        else
            print("allowNonBondingAminoAcids="..tostring(allowNonBondingAminoAcids))
        end
        
    while selectedSegments.Count > 0 do
        for segmentIndex = 1, structure.Count do
            if(selectedSegments[segmentIndex] == true) then
                highScore = current.GetEnergyScore()
                for i = 1, #primaryStructures do
                    if(structure.CanMutate(segmentIndex, primaryStructures[i])) then
                        structure.SetAminoAcid(segmentIndex, primaryStructures[i])
                        local newScore = current.GetEnergyScore()
                        if(newScore > highScore) then
                            print(segmentIndex.." "..structure.GetAminoAcid(segmentIndex).." "..newScore)
                            highScore = current.GetEnergyScore()
                            if(AnalysisLevel > 0) then
                                for newSegmentIndex = 1, structure.Count do
                                    newSegmentScores[newSegmentIndex] = current.GetSegmentEnergyScore(newSegmentIndex)
                                    if(newSegmentScores[newSegmentIndex] ~= SegmentScores[newSegmentIndex]) then
                                        print(        newSegmentIndex.." "..SegmentScores[newSegmentIndex].." "..newSegmentScores[newSegmentIndex])
                                        SegmentScores[newSegmentIndex] = newSegmentScores[newSegmentIndex]
                                        selectedSegments[newSegmentIndex] = true
                                        end
                                    end
                                end
                            end
                        local rotamerCount = rotamer.GetCount(segmentIndex)
                        if(rotamerCount > 0) then
                            for position = 1, rotamerCount do
                                if(structure.CanMutate(segmentIndex, primaryStructures[i])) then
                                    structure.SetAminoAcid(segmentIndex, primaryStructures[i])
                                    if(position <= rotamer.GetCount(segmentIndex)) then
                                        rotamer.SetRotamer(segmentIndex, position)
                                        if(doWiggle == true) then
                                            selection.Select(segmentIndex)
                                            structure.WiggleSelected(12, true)
                                            selection.Deselect(segmentIndex)
                                            end
                                        end
                                    newScore = current.GetEnergyScore()
                                    if(newScore > highScore) then
                                        print(segmentIndex.." "..structure.GetAminoAcid(segmentIndex).." "..position.." "..newScore)
                                        highScore = current.GetEnergyScore()
                                        if(AnalysisLevel > 0) then
                                            for newSegmentIndex = 1, structure.Count do
                                                newSegmentScores[newSegmentIndex] = current.GetSegmentEnergyScore(newSegmentIndex)
                                                if(newSegmentScores[newSegmentIndex] ~= SegmentScores[newSegmentIndex]) then
                                                    SegmentScores[newSegmentIndex] = newSegmentScores[newSegmentIndex]
                                                    selectedSegments[newSegmentIndex] = true
                                                    end
                                                end
                                            end
                                        end
                                    end
                                recentbest.Restore()
                                end
                            end
                        end
                    recentbest.Restore()
                    end
                end
            selectedSegments[segmentIndex] = false
            selectedSegments.Count = selectedSegments.Count - 1
            segmentIndex = structure.Count + 1
            end
        end
    for segmentIndex = 1, structure.Count do
        if(originalSelectedSegments[segmentIndex] == true) then
            selection.Select(segmentIndex)
            end
        end
    end
SkyNet.LoadModule = function()
    absolutebest = SkyNet.absolutebest
    band = SkyNet.band
    behavior = SkyNet.behavior
    contactmap = SkyNet.contactmap
    creditbest = SkyNet.creditbest
    current = SkyNet.current
    dialog = SkyNet.dialog
    freeze = SkyNet.freeze
    puzzle = SkyNet.puzzle
    recentbest = SkyNet.recentbest
    recipe = SkyNet.recipe
    rotamer = SkyNet.rotamer
    save = SkyNet.save
    scoreboard = SkyNet.scoreboard
    selection = SkyNet.selection
    structure = SkyNet.structure
    ui = SkyNet.ui
    undo = SkyNet.undo
    user = SkyNet.user
    SkyNet.IsLoaded = true
end
SkyNet.LoadModule()

--Current Functions **************
print("H-Bond Buster")
recentbest.Save()
oldScore = 0
currentScore = current.GetEnergyScore()
if(currentScore > 2) then
    while oldScore + 1 < currentScore do
        oldScore = current.GetEnergyScore()
        rotamer.BruteForce()
        currentScore = current.GetEnergyScore()
        end
    oldScore = 0
    currentScore = current.GetEnergyScore()
    while oldScore + 1 < currentScore do
        oldScore = current.GetEnergyScore()
        rotamer.BruteForce(true)
        currentScore = current.GetEnergyScore()
        end
    end
print("Script Finished")

Comments

[Enzyme2]

A long running script which should return very similar results to the series of scripts I have been running for this puzzle.

selecting segments before running should perform the function on only the selected segments and will greatly reduce runtime.

Near the end of the script are 2 sections. The second section enables the "doWiggle" attribute. This is an extremely long running script which can take several days to finish if it is run on the entire puzzle. It will appear as "doWiggle=true" under "startScore=" in the output.

[JeNNeR]

You use inside severe wrapped cycle the function CanMutate.
WHY? If they can, it never changed thru the puzzle.
Better of way is to do the following:
Take all (or selected) segments, run ONE TIME this function, and forget segments with returned value = .F.
Then check, do you have a segments for work with, and (if you have) work with it.
??? - profit. (And NO CALL INSIDE DEEP CYCLE!!!)

Piiz %)