NMR Restraints Grid

Result table
 (Save to zip file containing files for each block)

image mrblock_id pdb_id cing stage position program type subtype
23814 2jyh cing 1-original 4 XPLOR/CNS protocol structure calculation


0.000000 0.253900 1.00 
0.023571 0.228560 10.00  
0.047143 0.169850 10.00  
0.070714 0.105500 10.00  
0.094286 0.059052        10.00 
0.117860 0.032486 10.00  
0.141430 0.018726 10.00  
0.165000 0.011820 10.00  
0.188570 0.008319 10.00  
0.212140 0.0060478 10.00  
0.235710 0.0042914 10.00  
0.259290 0.0029497 10.00  
0.282860 0.0019576 10.00  
0.306430 0.0013189 10.00  
0.330000 0.0010263 10.00  
xplor.requireVersion("2.18")

numberOfStructures=100
startStructure=0
#!ensembleSize=2          # number of ensemble members
outFilename = "SCRIPT_%d_STRUCTURE_MEMBER.pdb" % numberOfStructures

import protocol
protocol.initRandomSeed()

#
# read in the PSF and initial PDB files
#
protocol.initParams("nucleic")

import psfGen
#psfGen.pdbToPSF("tectoRNA.pdb")
psfGen.pdbToPSF("tectoRNA.pdb")

#swap H2' and H2'' - they are mislabeled in the input pdb and in the NOE tables
# the input pdb and NOE tables should be fixed instead
h2pAtoms = AtomSel("name H2'")
h2ppAtoms = AtomSel("name H2''")
for atom in h2pAtoms:
    atom.setAtomName("H2''")
for atom in h2ppAtoms:
    atom.setAtomName("H2'")

# list of potential terms used in refinement
from potList import PotList
potList = PotList()
crossTerms=PotList('cross terms')


# parameters to ramp up during the simulated annealing protocol
#
from simulationTools import MultRamp, StaticRamp, InitialParams
rampedParams=[]

##
from varTensorTools import create_VarTensor, calcTensor
media={}
for medium in ['phg1']:
    media[medium] = create_VarTensor(medium)
    pass

##

#
# starting coords 
#
#protocol.initCoords("tectoRNA.pdb")
protocol.initCoords("trans-30A-20A-20A-2nd.pdb")    

protocol.covalentMinimize("not resname ANI")


from xplorPot import XplorPot


#planarity restraints
xplor.command("@plane.inp")
potList.append(XplorPot("plan"))

##
##symmetry restraints for the two strands
xplor.command(r"""
ncs restraints
  initialize
   group
         equi ((resid  1:43) )
         equi ((resid 44:86) )
         weight 1.
   end
   ?   {* print the NCS relations when starting *}

end
""")
#crossTerms.append( XplorPot("NCS") )
potList.append( XplorPot("NCS") )
rampedParams.append( StaticRamp("potList['NCS'].setScale(50)") )
#rampedParams.append( MultRamp(2,50.,"potList['NCS'].setScale( VALUE )") )


#initialize the aa-aa positional database
xplor.command("@rna_orient.setup")
potList.append(XplorPot("orie"))
rampedParams.append( StaticRamp("potList['ORIE'].setScale(0.2)") )

#NOE potentials
from noePotTools import create_NOEPot
noePots = PotList("noe")
noe = create_NOEPot("noeAll","noe_noInterMonomer.tbl")
noe.setPotType("hard")
noePots.append(noe)

# need to be satisfied by all structures
noeHB  = create_NOEPot("noeNH","hb.tbl")
noeHB.setPotType("hard")
noeHB.setScale(200)
noePots.append(noeHB)
potList.append(noePots)
rampedParams.append( MultRamp(2,50,"noePots.setScale( VALUE )") )

protocol.initDihedrals("dih.tbl",scale=200)
potList.append(XplorPot("cdih"))

protocol.initRamaDatabase('nucleic')
potList.append(XplorPot("rama") )
rampedParams.append( MultRamp(0.2,0.2,"xplor.command('rama scale VALUE end')"))

# radius of gyration term 
#
protocol.initCollapse("resid 1:86",
                      Rtarget=23.2)
potList.append( XplorPot('COLL') )

import solnXRayPotTools
from solnXRayPotTools import create_solnXRayPot
xray30 = create_solnXRayPot('xray30',"not hydro","tectoRNA_15b.dat",
                            radiusScale=0.97)
xray30.setNormalizeIndex(0)

xray      = xray30

solnXRayPotTools.useGlobs(xray)
xray.setNumAngles(100)

potList.append(xray)
#corrects I(q) to the true Debye result
rampedParams.append( StaticRamp("xray.calcGlobCorrect('n2')") )
rampedParams.append( StaticRamp("xray.setScale(3000)") )
#rampedParams.append( MultRamp(3000,500,"xray.setScale( VALUE )") )


from rdcPotTools import Da_prefactor, create_RDCPot #, scale_toCH

rdcPots = PotList('rdcs')
# weight is the relative weighting of expts, as determined by expt. error
for (name,medium,weight,files) in [
    ('JNH2','phg1',1   ,'rdc.tbl'),
    ]:
    term = create_RDCPot(name,oTensor=media[medium])
    term.setShowAllRestraints(1)
    if type(files)==type('string'):
        files=(files,)
        pass
    for file in files:
        term.addRestraints( open(file).read() )
        pass
    
    term.setScale( weight )
    #term.setAveType("average")
    term.setAveType("sum")
    print name
#    scale_toCH(term) #also sets useDistance
    print term.info()
    print term.gyroA()
    rdcPots.append(term)
    pass


potList.append(rdcPots)
rampedParams.append( MultRamp(0.01,1,"rdcPots.setScale( VALUE )") )


from rdcPotTools import Da_prefactor

print "factor:", Da_prefactor['CH'] / Da_prefactor["NH"]
for medium in media.values():
    calcTensor(medium)
    print "medium: ", medium.instanceName(), \
          "Da: ",medium.Da(), "Rh: ",medium.Rh()
    pass

##let's try fixing Da, Rh:
#for (medium,Da,Rh) in (('bic1',-16,.26),
#                       ('bic2',-26.6,0.09),
for (medium, Da, Rh) in (('phg1',35.04,0.6),):  
#                       ('phg2',-16.5,0.06),
#                       ('phg3',-20.0,0.06)):
    medium = media[medium]
    medium.setDa(Da)
    medium.setRh(Rh)
    pass


protocol.initNBond(cutnb=4.5)
potList.append( XplorPot("VDW") )
rampedParams.append( MultRamp(0.9,0.78,
                              "xplor.command('param nbonds repel VALUE end end')") )
rampedParams.append( MultRamp(.004,4,
                              "xplor.command('param nbonds rcon VALUE end end')") )

for name in ("bond","angl","impr"):
    potList.append( XplorPot(name) )
    pass
rampedParams.append( MultRamp(0.4,1.0,"potList['ANGL'].setScale(VALUE)"))
rampedParams.append( MultRamp(0.1,1.0,"potList['IMPR'].setScale(VALUE)"))


from ivm import IVM

#for most of calculation: fix Da and rhombicity
for medium in ('phg1',): media[medium].setFreedom("fixDa, fixRh")


dyn = IVM()
protocol.initDynamics(dyn,potList=potList)
dyn.group('segid A')
dyn.group('segid B')
#dyn.fix('segid A')
#dyn.hinge('full','segid A')
dyn.hinge('translate','segid A')
dyn.hinge('translate','segid B')
protocol.torsionTopology(dyn,oTensors=media.values())

#
#
# Give atoms uniform weights, except for the anisotropy axis
from atomAction import SetProperty
AtomSel("not resname ANI").apply( SetProperty("mass",100.) )
import varTensorTools
varTensorTools.massSetup(media.values(),300)
AtomSel("all            ").apply( SetProperty("fric",10.) )


##
## minc used for final cartesian minimization
##

#allow Da and Rh to vary during final minimization
for medium in ('phg1',): media[medium].setFreedom("fixDa, fixRh")

from selectTools import IVM_groupRigidSidechain
minc = IVM()
dyn.group('segid A')
dyn.group('segid B')
#dyn.fix('segid A')
#dyn.hinge('full','segid A')
dyn.hinge('translate','segid A')
dyn.hinge('translate','segid B')
protocol.initMinimize(minc,potList=potList)
IVM_groupRigidSidechain(minc)
protocol.cartesianTopology(minc,"not resname ANI",media.values())
varTensorTools.topologySetup(minc,media.values())

init_t = 3000
annealTime=0.2     #time to integrate at a given annealing temp.
annealSteps=0    #max num steps to be taken during a single annealing temp.


from simulationTools import AnnealIVM
dyn.group('segid A')
dyn.group('segid B')
#dyn.fix('segid A')
#dyn.hinge('full','segid A')
dyn.hinge('translate','segid A')
dyn.hinge('translate','segid B')
anneal= AnnealIVM(initTemp =init_t,
                  finalTemp=25,
                  tempStep =25,
                  #!ivm=DynMin(dyn),
                  ivm=dyn,
                  rampedParams = rampedParams)
    

from simulationTools import testGradient
#testGradient(potList,eachTerm=1)

from pdbTool import PDBTool
def calcOneStructure(loopInfo):

    # initialize parameters for high temp dynamics.
    InitialParams( rampedParams )

    # high temperature bit - using only P-P nonbonded terms
    protocol.initNBond(repel=1.2,
                       cutnb=100,
                       tolerance=45,
                       selStr="name P")
    protocol.initDynamics(dyn,
                          initVelocities=1,
                          bathTemp=init_t,
                          potList=potList,
                          numSteps=5000,
                          finalTime=10)
    dyn.run()
    protocol.initNBond() #reset to include all atoms

    # initialize integrator for simulated annealing
    #
    protocol.initDynamics(dyn,
                          potList=potList,
                          numSteps=100,       #at each temp: 100 steps or
                          finalTime=.2 ,       # .2ps, whichever is less
                          printInterval=100)

    # perform simulated annealing
    #
    anneal.run()
              
    #
    # torsion angle minimization
    #
    protocol.initMinimize(dyn)
    dyn.run()

    ##
    ##all atom minimization
    ##
    minc.run()
    dyn.group('segid A')
    dyn.group('segid B')
#    dyn.fix('segid A')
#    dyn.hinge('full','segid B')
    dyn.hinge('translate','segid A')
    dyn.hinge('translate','segid B')


    #
    # perform analysis and write structure
    loopInfo.writeStructure(potList,crossTerms)
    
    pass


from simulationTools import StructureLoop, FinalParams
StructureLoop(numStructures=numberOfStructures,
              startStructure=startStructure,
              structLoopAction=calcOneStructure,
              pdbTemplate=outFilename,
              genViolationStats=1,
              averageTopFraction=0.5,
              averagePotList=potList,
              averageCrossTerms=crossTerms,
              averageContext=FinalParams(rampedParams),
              averageFilename="ave.pdb",
              averageFitSel="not hydro and not resname ANI",
              averageCompSel="not hydro and not resname ANI"       ).run()



Please acknowledge these references in publications where the data from this site have been utilized.

Contact the webmaster for help, if required. Thursday, March 28, 2024 10:27:30 AM GMT (wattos1)