Recipe: BandedWormPairs

created by KarenCH

Profile

• Name: BandedWormPairs
• ID: 100189
• Shared with: Public
• Parent: None
• Children:
  • Banded Worm V2.0
  • Banded Worm Pairs Inf Filt 1.4.7
  • BandedWormPairs No Global Wiggle
• Created on: November 06, 2014 at 01:09 AM UTC
• Updated on: November 06, 2014 at 01:09 AM UTC
• Description:

  Banded worm, with pairs of bands and more random action

Code

------------------------------------------------------------------------------
-- Banded Worm
------------------------------------------------------------------------------
-- Modifies Worm LWS v2 by rav3n_pl
--
-- by KarenCH
------------------------------------------------------------------------------

-- interesting global variables that users might want to modify
PROB_CHOOSE_CONTACTMAP = 0.50
PROB_PUTBAND = 1.0       -- how often do we put bands in our wiggle steps?
PROB_BIS_NOT_BETWEEN = 0.25   -- do we prefer BIS or bands between segs
PROB_2ND_IS_BIS = 0.50
PROB_BETWEEN_USES_ATOM = 0.50  -- between: should wiggled seg have band from non-default atom
BAND_STRENGTH_DEFAULT = 1.0

-- less interesting global variables that users might consider modifying
BIS_LENGTH = 5.0       -- max length of a BIS
SCALE_MAXCI = 1.0
CONTACTMAP_THRESHOLD = 0.96
USENORMALSCORE  = true  -- exploration puzzles would set false
DEBUGRUN                = true   -- mostly goes with DebugPrint, but could get more use later

-- atoms in an amino acid
BETA_CARBON = 5
TERMINAL_BETA = 6
CENTER_CARBON = 2 --this is the default atom for bands to attach to

-- variables users probably don't want to play with
QS_Start = 1
QS_Best = 3

-- variables users really shouldn't play with
PuzzleHasContactMap = false
PuzzleHasLockedSegs = false
EndCalled = false
InitialScore = 0.0
StartTime = 0
CurrentBestScore = 0.0
InitialClashImportance = behavior.GetClashImportance()
NonLockedSegList = {}
segCt = structure.GetCount()
MinUnlockedSeg = 1
MaxUnlockedSeg = segCt
InitialBandCount = 0


------------------------------------------------------------------------------
-- FUNCTIONS
------------------------------------------------------------------------------
function BandedWorm( pattern )
    recentbest.Save( )
    SetCI( 1.0 )
    SaveBest( )
    local ss = getScore()
    for w = 1, #pattern do
        len = pattern[ w ]
        local sw = getScore()
        local swCurr = sw
        print( "Starting BandedWormPairs of len " .. len .. ", score: ".. TrimNum( getScore() ) )
        for s=MinUnlockedSeg, MaxUnlockedSeg - len + 1 do
            selection.DeselectAll()
            selection.SelectRange( s, s + len - 1 )

            if random( ) < PROB_PUTBAND then
                local idx = random( s, s + len - 1 )
                PutSingleRandomBandToSeg( idx, PROB_BIS_NOT_BETWEEN )
                if random( ) < 0.25 then
                local idx2 = random( s, s + len - 1 )
                PutSingleRandomBandToSeg( idx2, PROB_2ND_IS_BIS )
                end
                structure.LocalWiggleSelected( random(2,4) )
                DelBands( )
                structure.WiggleAll( 2 )
            end
            structure.LocalWiggleSelected( 5 )
            local swNew = getScore( )
            local gain = swNew - swCurr
            if gain > 0 then
                structure.LocalWiggleSelected( 20 )
                recentbest.Restore( )
                DelBands( )
                swNew = getScore( )
                gain = swNew - swCurr
                if TrimNum( gain ) > 0 then
                    print( ">>>> At " .. s .. ": Gained ".. TrimNum( gain ) )
                end
                SaveBest( )
                swCurr = swNew
            else
                recentbest.Restore( )
                structure.LocalWiggleSelected( 4 )
            end
            recentbest.Restore( )
            DelBands( )
        end
        print( "Pattern gain: ".. getScore( ) - sw )
        SaveBest( )
    end
    selection.DeselectAll()
    print( "Total BandedWormPairs gain: " .. TrimNum( getScore( ) - ss ) )
end

function PutSingleRandomBandToSeg( idx, probBis )
    changeSucceeded = false
    local strength = random( 0.5 * BAND_STRENGTH_DEFAULT, 
                                         1.5 * BAND_STRENGTH_DEFAULT,
                                         true )
    local doBIS = random( ) < probBis

    if doBIS then
         changeSucceeded = PutBandInSpace( idx, BIS_LENGTH, strength )
    else
         if SegHasContactData( idx, CONTACTMAP_THRESHOLD ) and 
            random( ) > PROB_CHOOSE_CONTACTMAP 
         then
             local doSidechain = random( ) < PROB_BETWEEN_USES_ATOM
             changeSucceeded = PutSomeContactMapBands( CONTACTMAP_THRESHOLD, strength, 1, doSidechain )
         else
             local atom = PickAtomNumberForBand( idx )
             changeSucceeded = PutBandToRandomSeg( idx, 5, strength, atom )
         end
    end
    return changeSucceeded
end


----------------------------------------------------------------
-- 
----------------    BOILERPLATE    ---------------------
-- 
----------------------------------------------------------------

----------------------------------------------------------------
-- BASIC FUNCTIONALITY
----------------------------------------------------------------
function DebugPrint( str )
    if DEBUGRUN then print( str ) end
end

function TrimNum( val )
    return val - val % 0.001 
end

-- Not for "external" use - call getScore. This could change if customers want 
-- something besides current or recentbest.
function internalGetScore( wantRB )  
    if wantRB == nil then wantRB = false end
    local s=0.0
    if not USENORMALSCORE then
        if wantRB then s = recentbest.GetEnergyScore( )
        else s=current.GetEnergyScore( )
        end
    else
        if wantRB then s = recentbest.GetScore( )
        else s=current.GetScore( )
        end
    end
    return s
end
function getScore( )
    return internalGetScore( false )
end
function getRBScore( )
    return internalGetScore( true )
end

function SaveBest( )
    local score = getScore( )
    if score > CurrentBestScore then
        save.Quicksave( QS_Best )
        CurrentBestScore = score
    end
end

function SetCI( ci )
    behavior.SetClashImportance( SCALE_MAXCI * ci )
end

------------- CONTACTMAP FUNCTIONS ------------
function CheckForContactMap( )
    PuzzleHasContactMap = false
    local saveval = 0.0
    for i=1, segCt-1 do
        for j=i+1, segCt do
            val = contactmap.GetHeat( i, j )
            if saveval  ~= 0.0 and val ~= saveval then
                PuzzleHasContactMap = true
                ContactMapScore = GetContactScore( )
                return   -- all we wanted to know was whether scores exist
            end
            if saveval == 0.0 then saveval = val end
        end
    end
    return
end

function SegHasContactData( segIn, heatThreshold )
    for i = 1, segCt do
        if i < segIn - 1 or i > segIn + 1 then
            if contactmap.GetHeat( segIn, i ) >= heatThreshold then return true end
        end
    end
    return false
end

function InitializeContactMapSegList( heatThreshold )
    HasContactMapSegList = {}
    for i = 1, segCt do
         if SegHasContactData( i, heatThreshold ) then 
             HasContactMapSegList[ #HasContactMapSegList + 1 ] = i 
        end
    end
end

function GetContactScore( )
    if not PuzzleHasContactMap then return 0 end
    local sum = 0.0
    local segCt = structure.GetCount( )
    for i = 1,segCt-1 do
        for j = i + 1, segCt do
            if contactmap.IsContact( i, j ) then sum = sum + contactmap.GetHeat( i, j ) end
         end
    end
    return sum
end

----------------------- MATHY STUFF -----------------------
function seedRandom()
    seed=os.time( )/math.abs( getScore( ) )
    seed=seed%0.001
    seed=1/seed
    while seed<10000000 do seed=seed*1000 end
    seed=seed-seed%1
    DebugPrint( "Seed is: "..seed )
    math.randomseed( seed )

    -- throw away a couple of randoms
    math.random( )
    math.random( )
end

function random( n1,n2, forceFloat ) --random function returns int or float depends on input vars
    if forceFloat == nil then forceFloat = false end
    if n1==nil then 
        return math.random()
    else
        if n2==nil then
            if n1 == 0 then return 0 end -- a random number between 0 and 0 is 0
            if n1%1==0 then -- can't test for "forceFloat", so caller must beware
                return math.random( n1) --integer
            else
                return math.random( ) * n1 --float
            end
        else
            if n1%1==0 and n2%1==0 and not forceFloat then
                return math.random( n1, n2 ) --integer between 
            else
                return math.random( ) * (n2 - n1) + n1 --float between
            end
        end
    end
end

function randomSeg( )
    return random( segCt )
end

function randomThetaPhi()
    return   math.acos( random( -1.0, 1.0, true ) ),  random( 2 * math.pi )
end

function randomizeIndexList( idxList )
    for i=1, #idxList do
        j = random( #idxList )
        if j ~= i then
            idxList[i], idxList[j] = idxList[j], idxList[i]
        end
    end
end

-- for branched aas, simply picks one (longer, one with donor/acceptor tip, or if no difference then either)
function GetAtomOfTip( aa )
    if aa == "a" then return 10
    elseif aa == "c" then return 10
    elseif aa == "d" then return 8
    elseif aa == "e" then return 9
    elseif aa == "f" then return 20
    elseif aa == "g" then return 0 -- glycine has no tip. just use a backbone atom
    elseif aa == "h" then return 17
    elseif aa == "i" then return 18
    elseif aa == "k" then return 9
    elseif aa == "l" then return 16
    elseif aa == "m" then return 17
    elseif aa == "n" then return 14
    elseif aa == "p" then return 13
    elseif aa == "q" then return 9
    elseif aa == "r" then return 22
    elseif aa == "s" then return 11
    elseif aa == "t" then return 6
    elseif aa == "v" then return 13
    elseif aa == "w" then return 24
    elseif aa == "y" then return 12
    else return 0
    end
end

function GetTipAtomOfSeg( idx )
    return GetAtomOfTip( structure.GetAminoAcid( idx ))
end

function PickAtomNumberForBand( idx )
    if not BAND_TO_SIDECHAINS then return CENTER_CARBON end

    local r = random( 1, 3 )   -- consider adjusting probability?
    if r == 1 then
        return BETA_CARBON
    elseif r == 2 then
        return GetTipAtomOfSeg( idx )
    else
        return CENTER_CARBON
    end
end

function IsUnlockedSeg( seg1 )
   return not structure.IsLocked( seg1 )
end

function FindAllMovableSegs( )
    for i=1, segCt do
        if structure.IsLocked( i ) then 
            PuzzleHasLockedSegs = true
        else
            NonLockedSegList[ #NonLockedSegList + 1] = i
        end
    end

    if PuzzleHasLockedSegs then
        for i=1, segCt do
            if IsUnlockedSeg( i ) then 
                MinUnlockedSeg = i
                break
            end
        end
        for i=segCt, 1, -1 do
            if IsUnlockedSeg( i ) then 
                MaxUnlockedSeg = i
                break
            end
        end
    end

    return false
end

----------------------- BANDY STUFF -----------------------
function DelBands( )
    band.DeleteAll( )
end

function BandBetweenSegsWithParameters( seg1, seg2, strength, goalLength, atom1, atom2 )
    if not ( IsUnlockedSeg( seg1 ) or IsUnlockedSeg( seg2 ) ) then return false end
    if atom1 == nil then atom1 = CENTER_CARBON end
    if atom2 == nil then atom2 = CENTER_CARBON end

    local bIdx = band.AddBetweenSegments( seg1, seg2, atom1, atom2 )
    if bIdx ~= band.GetCount( ) then 
        DebugPrint( "failed to add band from "..seg1.." to "..seg2)
        return false 
    end
    if bIdx <= InitialBandCount then return true end -- don't change user-supplied bands

    if goalLength ~= nil then 
        band.SetGoalLength( bIdx, goalLength ) 
    end
    if strength ~= nil and strength > 0.0 then 
        band.SetStrength( bIdx, strength )
    end
    return true
end

function BandInSpaceWithParameters( seg, segFini, segInit, rho, theta, phi, strength, goalLength )
    if not ( IsUnlockedSeg( seg) ) then return false end

    local bIdx = band.Add( seg, segFini, segInit, rho, theta, phi )
    if bIdx ~= band.GetCount( ) then return false end
    if bIdx <= InitialBandCount then return true end -- don't change user-supplied bands

    if goalLength ~= nil then 
        band.SetGoalLength( bIdx, goalLength ) 
    end
    if strength ~= nil and strength ~= 0.0 then 
        band.SetStrength( bIdx, strength ) 
    end
    return true
end

function PutBandInSpace( idx, maxRho, strength )
    -- trying to do tips is too weird, so we omit the capability
    local idx2, idx3
    if idx < segCt then
        idx2 = idx + 1
    else
        idx2 = idx - 2
    end
    if idx > 1 then
        idx3 = idx - 1
    else
        idx3 = idx + 2
    end

    -- random point in sphere of radius maxRho
    local theta, phi = randomThetaPhi( )
    local rho = (maxRho * random()^(1/3)) + 0.001
    return BandInSpaceWithParameters( idx, idx2, idx3, rho, theta, phi, strength )
end

function PutBandToRandomSeg( idx, minGap, strength, atom )
    needNew = true
    local failedTries = 0
    while ( needNew and failedTries < 30 ) do
        idx2 = randomSeg( )  -- ok if this one isn't movable (we assume idx is movable)
        if idx2 > idx + minGap or idx2 < idx - minGap then 
            needNew = false 
            break
        else
            failedTries = failedTries + 1
        end
    end
    if not needNew then
        return BandBetweenSegsWithParameters( idx, idx2, strength, nil, atom, nil )
    end
    return false
end

function PutSomeContactMapBands( heatThreshold, strength, ctBands, doSidechains )
    changeSucceeded = false
    local hotList = {}
    for i = 1, segCt-2 do
        for j = i+2, segCt do
            local heat = contactmap.GetHeat(i, j)
            if heat >= heatThreshold and not contactmap.IsContact( i , j ) then
                hotList[ #hotList + 1] = { i, j, heat }
            end
        end
    end

    randomizeIndexList( hotList )
    for i=1, math.min( ctBands, #hotList ) do
        local atom1 = nil
        local atom2 = nil
        if BAND_TO_SIDECHAINS and doSidechains then
            atom1 = PickAtomNumberForBand( hotList[i][1] )
            atom2 = PickAtomNumberForBand( hotList[i][2] )
        end
        local ch = BandBetweenSegsWithParameters( hotList[i][1], hotList[i][2], strength, nil, doTip1, doTip2 ) 
        changeSucceeded = ch or changeSucceeded
    end
    return changeSucceeded
end

--------------------------------------------------------------------------
-- SETUP, CLEANUP, and MAIN
--------------------------------------------------------------------------
function CleanPuzzleState( )
    SetCI( 1.0 )
    selection.DeselectAll()
    DelBands()
end

function PrintState( )
    local gain = getScore() - InitialScore
    if gain < 0.001 then 
        print( " No change" )
    else
        print( " Startscore: "..TrimNum( InitialScore ))
        print( " Score: "..TrimNum( getScore() ) )
        print( " Total gain: "..TrimNum( gain ))
    end
    print( " Run time: "..os.time() - StartTime)
end

function End( errstr )
    if EndCalled then return end    -- no infinite recursion please
    EndCalled = true

    print( "" )
    if errstr ~= nil then
        if string.find( errstr, "Cancelled" ) then
            print( "User cancel" )
        else
            print( errstr )
        end
    end

    save.Quickload( QS_Best )
    PrintState( )
    CleanPuzzleState( )
end

function InitializePuzzleState( )
    seedRandom( )
    InitialScore = getScore( )
    CurrentBestScore = InitialScore
    StartTime = os.time()
    save.Quicksave( QS_Start )
    save.Quicksave( QS_Best )
    InitialClashImportance = behavior.GetClashImportance()
    SCALE_MAXCI = InitialClashImportance
    FindAllMovableSegs( )
    CheckForContactMap()
    if PuzzleHasContactMap then InitializeContactMapSegList( CONTACTMAP_THRESHOLD ) end
end

function main( )
    InitializePuzzleState( )

    local gain = 0.0
    repeat
        local score = getScore( )
        pattern={ 2,5,11,3,13,4,7,1,6 }
        BandedWorm( pattern )
        gain = getScore( ) - score
    until gain < 0.01
    End( )
end

xpcall( main, End )

Comments

[spmm]

I have noticed the earlier banded worm crashing on windows and mac - this one is doing it as well. Crashing foldit client.

[LociOiling]

Banded Worm and Banded Worm Pairs have crashed with the "angle range error" that hits in some puzzles.

These cases are difficult to reproduce. The script may continue normally when restarted at the point of failure, only to crash again later.

See feedback: https://fold.it/portal/node/1998668