Пример #1
0
def calculate_energy(top, crd):
    """
  Returns potential energy of top and crd by running sander
  and parsing the sander output.
  """
    top = os.path.abspath(top)
    crd = os.path.abspath(crd)

    util.goto_dir('energy-temp')

    parms = minimization_parms.copy()
    parms.extend({
        'topology': top,
        'input_crds': crd,
        'output_basename': 'energy',
        'n_step_minimization': 0,
        'n_step_steepest_descent': 0
    })
    run(parms)

    blocks = read_minimization_sander_out('energy.sander.out')

    util.goto_dir('..')
    util.clean_fname('energy-temp')

    return blocks[0]['ENERGY']
Пример #2
0
def calculate_energy(top, crd):
  """
  Returns potential energy of top and crd by running sander
  and parsing the sander output.
  """
  top = os.path.abspath(top)
  crd = os.path.abspath(crd)

  util.goto_dir('energy-temp')

  parms = minimization_parms.copy()
  parms.extend({
    'topology': top,
    'input_crds': crd,
    'output_basename': 'energy',
    'n_step_minimization': 0,
    'n_step_steepest_descent': 0})
  run(parms)

  blocks = read_minimization_sander_out('energy.sander.out')

  util.goto_dir('..')
  util.clean_fname('energy-temp')

  return blocks[0]['ENERGY']
Пример #3
0
def get_energy(top, crd):
  "Returns potential energy of top and crd by running sander"
  
  top = os.path.abspath(top)
  crd = os.path.abspath(crd)

  util.goto_dir('energy-temp')

  parms = minimization_parms.copy()
  parms['topology'] = top
  parms['input_crds'] = crd
  parms['output_name'] = 'energy'
  parms['n_step_minimization'] = 0
  parms['n_step_steepest_descent'] = 0

  run(parms)

  lines = open('energy.sander.out').readlines()

  energies = {}
  is_results = False
  for i, line in enumerate(lines):
    if not is_results:
      if '4' in line and 'RESULTS' in line:
        is_results = True
    else:
      if 'NSTEP' in line and 'ENERGY' in line:
        util.goto_dir('..')
        os.system('rm -rf energy-temp')
        return float(lines[i+1].split()[1])

  raise "Can't find energies"
Пример #4
0
def pulse(in_parms, n_step_per_pulse, reset_vel_func):

  config = in_parms['output_name'] + ".config"
  if util.is_same_dict_in_file(in_parms, config):
    print "simulation already run."
    return

  name = in_parms['output_name']
  shutil.copy(in_parms['topology'], name + '.psf')
  if in_parms['constraint_pdb']:
    shutil.copy(in_parms['constraint_pdb'], name + '.constraint')

  n_pulse = in_parms['n_step_dynamics'] // n_step_per_pulse
  n_step_list = [n_step_per_pulse for i in range(n_pulse)]
  n_excess_step = in_parms['n_step_dynamics'] % n_step_per_pulse
  if n_excess_step > 0:
    n_pulse += 1
    n_step_list.append(n_excess_step)

  pulse_in_coor = util.insert_path(in_parms['input_crds'], '..')
  pulse_in_vel = util.insert_path(in_parms['input_vels'], '..')

  stopwatch = util.Timer()

  pulses = ["pulse%d" % i for i in range(n_pulse)]
  for pulse, n_step in zip(pulses, n_step_list):
    util.goto_dir(pulse)

    pulse_parms = copy.deepcopy(in_parms)
    pulse_parms['topology'] = util.insert_path(in_parms['topology'], '..') 
    pulse_parms['n_step_dynamics'] = n_step

    if 'constraint_pdb' in pulse_parms and pulse_parms['constraint_pdb']: 
      pulse_parms['constraint_pdb'] = util.insert_path(in_parms['constraint_pdb'], '..')

    pulse_parms['input_crds'] = pulse_in_coor
    pulse_parms['input_vels'] = pulse_in_vel
    soup = SoupFromRestartFiles(pulse_parms['topology'], 
                              pulse_parms['input_crds'],
                              pulse_parms['input_vels'])
    reset_vel_func(soup)

    pulse_parms['input_vels'] = name + ".in.vel"
    write_soup_to_vel(soup, pulse_parms['input_vels'])

    run(pulse_parms)

    pulse_in_coor = '../%s/%s.coor' % (pulse, name)
    pulse_in_vel = '../%s/%s.vel' % (pulse, name)
    os.chdir('..')
    
  stopwatch.stop()
  open(name + '.time', 'w').write(stopwatch.str())

  merge_simulations(name, pulses)
  for pulse in pulses: os.system('rm -rf %s' % pulse)

  util.write_dict(in_parms, config)
Пример #5
0
def pdb_to_top_and_crds(force_field, pdb, basename, solvent_buffer=10.0): 
  """
  Creates CHARMM .coor and .psf file for NAMD simulation.
  """
  solv_dir = basename + '.solvate'
  save_dir = os.getcwd()

  pdb = os.path.abspath(pdb)

  util.goto_dir(solv_dir)

  # Remove all but protein heavy atoms in a single clean conformation
  stripped_pdb = basename + '.clean.pdb' 
  pdbtext.clean_pdb(pdb, stripped_pdb)

  # Make input script for psfgen
  psfgen_psf = basename+'.psfgen.psf'
  psfgen_pdb = basename+'.psfgen.pdb'
  script = module_load_script 
  script += make_chain_loading_script(stripped_pdb, basename)
  script += make_disulfide_script(stripped_pdb)
  script += write_script 
  script = script % {
    # load the included CHARMM2 atom topologies
    'topology': os.path.join(data.data_dir, 'charmm22.topology'),
    'out_pdb': psfgen_pdb,
    'out_psf': psfgen_psf
  }

  psfgen_in = basename+".psfgen.in"
  open(psfgen_in, "w").write(script)

  data.binary('psfgen', psfgen_in, basename+'.psfgen')
  util.check_output(psfgen_psf)
  util.check_output(psfgen_pdb)

  solvate_psf(psfgen_psf, psfgen_pdb, basename, solvent_buffer)

  psf = basename+'.psf'
  coor = basename+'.coor'
  pdb = basename+'.pdb'
  os.rename(pdb, coor)
  convert_restart_to_pdb(basename, pdb)
  shutil.copy(psf, save_dir)
  shutil.copy(coor, save_dir)
  shutil.copy(pdb, save_dir)
  
  os.chdir(save_dir)

  return psf, coor
Пример #6
0
def systemRefresh():
    """
    Pull the system spices from github and create a new system.tar
    for the clients all to download.
    """
    log('UPDATING SYSTEM SPICE')

    goto_dir(makepath('spicerackclient'))
    command('git', 'pull')
    command('tar', '-cvf', makepath('system.tar)', 'system'))
    goto_dir(makepath(''))
    
    currentversion = dget('systemversion', 0)
    currentversion = 1 + int(currentversion)
    put('systemversion', currentversion)

    filewrite('systemversion.txt', str(currentversion))

    command('tar', '--append', '--file=system.tar', 'systemversion.txt')

    log('UPDATED SYSTEM SPICE TO VERSION: %s' % currentversion)
    return 'success'
Пример #7
0
def pulse(
    force_field, in_basename, basename, n_step, pulse_fn, 
    n_step_per_pulse=100, restraint_pdb="", restraint_force=None):
  """
  Runs a pulse simulation that uses the restart-file modification
  strategy to manage a steered-molecular dynamics simulation.

  The pulsed approacha pplies external forces in pulses, which is
  practically carried out be running short constant-energy
  simulations and directly modifying the restart velocities
  between each simulation.

  Pulse simulations has certain advantages: for instance, the
  system can respond to the forces between pulses, and the
  incredibly flexibility in applying forces. The disadvantage is
  the costly setup which is hopefully, mitigated by this library.

  Reference: Bosco K. Ho and David A. Agard (2010) "An improved
  strategy for generating forces in steered molecular dynamics:
  the mechanical unfolding of titin, e2lip3 and ubiquitin" PLoS
  ONE 5(9):e13068.
  """

  # Grab the simulation prameters for a constant energy
  # simulation. Constant energy is preferred as we want to ensure
  # energy changes come only from our velocity modification.
  top, crds, vels = get_restart_files(in_basename)
  # use dummy top and crds, which will be overriden 
  overall_config_parms = fetch_simulation_parameters(
      force_field, top, crds, restraint_pdb, 
      'constant_energy', basename, restraint_force)
  overall_config_parms.update({
    'input_md_name': in_basename,
    'input_vels': vels,
    'n_step_dynamics': n_step,
    'n_step_per_snapshot': n_step_per_pulse // 2,
    'n_step_per_pulse': n_step_per_pulse
  }) 

  # Check if the simulation has already run as the config
  # file is not written until the very end
  config = basename + ".config"
  if util.is_same_dict_in_file(overall_config_parms, config):
    print "Skipping: pulsing simulation already run."
    return

  # The overall_config_parms will be written out at the end.
  # We make a copy for internal use
  pulse_parms = copy.deepcopy(overall_config_parms)

  # Calculate steps for each pulse, esp for last step
  n_pulse = pulse_parms['n_step_dynamics'] / n_step_per_pulse
  n_step_list = [n_step_per_pulse for i in range(n_pulse)]
  n_excess_step = pulse_parms['n_step_dynamics'] % n_step_per_pulse
  if n_excess_step > 0:
    n_pulse += 1
    n_step_list.append(n_excess_step)
  
  # Prepare restart files for first step
  pulse_parms['topology'] = os.path.abspath(pulse_parms['topology'])
  in_basename = pulse_parms['input_md_name']
  pulse_parms['input_md_name'] = os.path.abspath(in_basename)

  # Now loop through pulses
  timer = util.Timer()
  save_dir = os.getcwd()
  pulses = ["pulse%d" % i for i in range(n_pulse)]
  for pulse, n_step in zip(pulses, n_step_list):
    print "Pulse: %s/%d" % (pulse, n_pulse)

    os.chdir(save_dir)
    util.goto_dir(pulse)

    pulse_parms['n_step_dynamics'] = n_step

    soup = soup_from_restart_files(pulse_parms['input_md_name'])

    # Apply forces by modifying the velocities directly 
    pulse_fn(soup)

    crds, vels = write_soup_to_crds_and_vels(
        force_field, soup, basename + '.pulse.in')
    pulse_parms['input_crds'] = crds
    pulse_parms['input_vels'] = vels

    run_simulation_with_parameters(pulse_parms)

    # Setup new restart files based on just-finished pulse
    pulse_parms['input_md_name'] = os.path.abspath(basename)

  os.chdir(save_dir)

  merge_simulations(force_field, basename, pulses)

  # cleanup pulses after merging
  util.clean_fname(*pulses)

  # everything worked, no exceptions thrown
  open(basename+'.time', 'w').write(timer.str()+'\n')
  util.write_dict(config, overall_config_parms)
Пример #8
0
def pdb_to_top_and_crds(force_field, pdb, basename, solvent_buffer=10):
    """
  Converts a PDB file into GROMACS topology and coordinate files,
  and fully converted PDB file. These constitute the restart files
  of a GROMACS simulation.
  """
    util.check_files(pdb)
    full_pdb = os.path.abspath(pdb)
    save_dir = os.getcwd()

    # All intermediate files placed into a subdirectory
    util.goto_dir(basename + '.solvate')

    # Remove all but protein heavy atoms in a single clean conformation
    pdb = basename + '.clean.pdb'
    pdbtext.clean_pdb(full_pdb, pdb)

    # Generate protein topology in pdb2gmx_gro using pdb2gmx
    pdb2gmx_gro = basename + '.pdb2gmx.gro'
    top = basename + '.top'
    itp = basename + '_posre.itp'
    # Choose force field based on GROMACS version
    if 'GROMACS4.5' in force_field:
        ff = 'amber99'
    elif 'GROMACS4.0' in force_field:
        ff = 'G43a1'
    else:
        raise ValueError, "Couldn't work out pdb2gmx for " + force_field
    args = '-ignh -ff %s -water spc -missing -f %s -o %s -p %s -i %s -chainsep id_or_ter -merge all' \
            % (ff, pdb, pdb2gmx_gro, top, itp)
    data.binary('pdb2gmx', args, basename + '.pdb2gmx')
    util.check_files(pdb2gmx_gro)

    # Now add a box with editconf
    box_gro = basename + '.box.gro'
    solvent_buffer_in_nm = solvent_buffer / 10.0
    data.binary(
        'editconf',
        '-f %s -o %s -c -d %f -bt cubic' \
            % (pdb2gmx_gro, box_gro, solvent_buffer_in_nm),
        basename+'.box')
    util.check_files(box_gro)

    # Given box dimensions, can now populate with explict waters
    solvated_gro = basename + '.solvated.gro'
    data.binary(
        'genbox',
        '-cp %s -cs spc216.gro -o %s -p %s' \
            % (box_gro, solvated_gro, top),
         '%s.solvated' % basename)
    util.check_files(solvated_gro)

    # Neutralize with counterions using genion to place ions
    # based on energy parameters processed by grompp
    gro = basename + '.gro'
    neutralize_system_with_salt(top, solvated_gro, basename, force_field)
    util.check_files(gro)

    # Make a reference PDB file from restart files for viewing and restraints
    convert_restart_to_pdb(basename, basename + '.pdb')

    # Copy finished restart files back into original directory
    fnames = util.re_glob(
        '*',
        os.path.basename(basename) + r'[^\.]*\.(pdb|itp|gro|mdp|top)$')
    for fname in fnames:
        shutil.copy(fname, save_dir)

    # Cleanup
    delete_backup_files(basename)
    os.chdir(save_dir)

    return top, gro
Пример #9
0
def pdb_to_top_and_crds(force_field, pdb, basename, solvent_buffer=10):
  """
  Converts a PDB file into GROMACS topology and coordinate files,
  and fully converted PDB file. These constitute the restart files
  of a GROMACS simulation.
  """
  util.check_files(pdb)
  full_pdb = os.path.abspath(pdb)
  save_dir = os.getcwd()

  # All intermediate files placed into a subdirectory
  util.goto_dir(basename + '.solvate')

  # Remove all but protein heavy atoms in a single clean conformation
  pdb = basename + '.clean.pdb'
  pdbtext.clean_pdb(full_pdb, pdb)

  # Generate protein topology in pdb2gmx_gro using pdb2gmx
  pdb2gmx_gro = basename + '.pdb2gmx.gro'
  top = basename + '.top'
  itp = basename + '_posre.itp'
  # Choose force field based on GROMACS version
  if 'GROMACS4.5' in force_field:
    ff = 'amber99' 
  elif 'GROMACS4.0' in force_field:
    ff = 'G43a1' 
  else:
    raise ValueError, "Couldn't work out pdb2gmx for " + force_field
  args = '-ignh -ff %s -water spc -missing -f %s -o %s -p %s -i %s -chainsep id_or_ter -merge all' \
          % (ff, pdb, pdb2gmx_gro, top, itp)
  data.binary('pdb2gmx', args, basename+'.pdb2gmx')
  util.check_files(pdb2gmx_gro)

  # Now add a box with editconf
  box_gro = basename + '.box.gro'
  solvent_buffer_in_nm = solvent_buffer/10.0 
  data.binary(
      'editconf', 
      '-f %s -o %s -c -d %f -bt cubic' \
          % (pdb2gmx_gro, box_gro, solvent_buffer_in_nm),
      basename+'.box')
  util.check_files(box_gro)

  # Given box dimensions, can now populate with explict waters
  solvated_gro = basename + '.solvated.gro'
  data.binary(
      'genbox',
      '-cp %s -cs spc216.gro -o %s -p %s' \
          % (box_gro, solvated_gro, top),
       '%s.solvated' % basename)
  util.check_files(solvated_gro)

  # Neutralize with counterions using genion to place ions 
  # based on energy parameters processed by grompp 
  gro = basename + '.gro'
  neutralize_system_with_salt(top, solvated_gro, basename, force_field)
  util.check_files(gro)

  # Make a reference PDB file from restart files for viewing and restraints
  convert_restart_to_pdb(basename, basename+'.pdb')

  # Copy finished restart files back into original directory
  fnames = util.re_glob(
      '*', os.path.basename(basename) + r'[^\.]*\.(pdb|itp|gro|mdp|top)$')
  for fname in fnames:
    shutil.copy(fname, save_dir)

  # Cleanup
  delete_backup_files(basename)
  os.chdir(save_dir)

  return top, gro
Пример #10
0
def spiceMerge(spices, username):
    """
    Manages the merger of a spice into the development repository.

    @param spices: list of (spicename, dirname)
    """
    log('[spicemanager] In func:spiceMerge')
    goto_dir(makepath('spicerackdev'))
    command('git', 'pull')
    goto_dir(makepath(''))

    spice_to_metadata = {}
    for dirname in spices:
        data = jsonload(makepath('spicerackdev', dirname, 'metadata.json'))
        spicename = data['name']
        if 'spicename' not in data:
            data['spicename'] = spicename
        if 'width' not in data:
            data['width'] = 0
            data['height'] = 0
            data['dependencies'] = []

        Statsd.increment('spices.spicerackdev.%s' % spicename.replace(' ', '-'))

        mid = get('spice-id:%s' % spicename.replace(' ', '-'))
        if mid is None:
            mid = str(uuid.uuid4())
            put('spice-id:%s' % spicename.replace(' ', '-'), mid)

        log('[spicemanager] Processing %s %s' % (spicename, mid))

        version = 1 + int(dget('version:%s' % mid, 0))
        put('version:%s' % mid, version)
        log('[spicemanager] Version: %s' % version)

        spice_to_metadata[mid] = {
            'spicename' : data['spicename'],
            'gituser' : username,
            'author' : data['author'],
            'tagline' : data['description'],
            'description' : data['description'],
            'version' : version,
            'hotkey' : False,
            'main' : data['main'],
            'width' : data['width'],
            'height' : data['height'],
            'dependencies' : data['dependencies']
            }

        put('metadata:%s' % mid, spice_to_metadata[mid])
        
        jsondump(makepath('spicerackdev', dirname, 'metadata.json'), spice_to_metadata[mid])
                   
        # Tar the spice directory into /spices/{mid}.tar.gz
        command('tar', '-cvf', makepath('spices', '%s.tar.gz' % mid), makepath('spicerackdev', dirname))

        # Copy the icon file into /icons
        iconpath = makepath('spicerackdev', dirname, 'icon.png')
        command('cp', '-f', iconpath, makepath('icons', '%s.png' % mid))
        
        iconpath = makepath(dirname, 'icon.png')
        if not os.path.exists(iconpath):
            command('tar', '-cvf', makepath('spices', '%s.tar.gz' % mid), makepath('spicerackdev', dirname))
        else:
            iconpath = iconpath.strip('icon.png')
            command('tar',
                    '-cvf',
                    makepath('spices', '%s.tar.gz' % mid),
                    makepath('spicerackdev', dirname),
                    '--directory=%s' % iconpath,
                    'icon.png')

        goto_dir(makepath('spicerackdev'))
        command('git', 'stash')
        goto_dir(makepath(''))

        heroku_metadata = {
            'spicename' : data['spicename'],
            'gituser' : username,
            'author' : data['author'],
            'tagline' : data['description'],
            'description' : data['description'],
            'version' : version,
            'hotkey' : False,
            'main' : data['main']
            }

        log('HEROKU: %s %s', type(heroku_metadata), heroku_metadata)
        for key, val in heroku_metadata.iteritems():
            log('KEY %s VAL %s %s', key, type(val), val)

        resp, content = send_post({str(mid) : heroku_metadata}, '/spices/refresh')
        log('[spicemanager] Heroku response: %s' % str(resp))

    return 'success'