示例#1
0
def start():
    check_output('%s qdisc add dev %s root handle %i: htb default %i'\
        % (TC, args.interface, ROOT_Q_HANDLE, DEFAULT_CLASS))

    # make a default class for normal traffic
    check_output('%s class replace dev %s parent %i: classid %i:%i htb rate 1000mbit ceil 1000mbit'\
        % (TC, args.interface, ROOT_Q_HANDLE, ROOT_Q_HANDLE, DEFAULT_CLASS))
示例#2
0
def install_filters(links_file):
    with open(links_file, 'r') as linksf:
        for line in strip_comments(linksf):
            elems = line.split(' ')
            check_output('%s update %s %s -c %i'\
                % (TC_SETUP, elems[0], elems[2], int(elems[1].split('link')[1])))
    linksf.closed
def start_network():
    if network_running():
        logging.getLogger(__name__).info("Some network components already running...")
        stop_network()

    logging.getLogger(__name__).info("Starting simulated network...")

    # Create fake NICs
    logging.getLogger(__name__).info("Creating network interfaces...")
    autogen_click_conf(get_topo_file("servers"), get_topo_file("clients"), get_topo_file("dns"))
    if os.path.isfile(CLICK):
        run_bg("%s %s" % (CLICK, CLICK_CONF))
    else:
        run_bg("%s %s" % (CLICK_LOCAL, CLICK_CONF))

    # Set up traffic shaping
    logging.getLogger(__name__).info("Enabling traffic shaping...")
    try:
        check_output("%s start" % TC_SETUP)
        install_filters(get_topo_file("bottlenecks"))
    except Exception as e:
        logging.getLogger(__name__).error(e)

    # Launch apache instances
    logging.getLogger(__name__).info("Configuring apache...")
    try:
        configure_apache(get_server_ip_list())
        restart_apache()
    except Exception as e:
        logging.getLogger(__name__).error(e)

    logging.getLogger(__name__).info("Network started.")
示例#4
0
def start_network():
    if network_running():
        logging.getLogger(__name__).info('Some network components already running...')
        stop_network()

    logging.getLogger(__name__).info('Starting simulated network...')

    # Create fake NICs
    logging.getLogger(__name__).info('Creating network interfaces...')
    autogen_click_conf(get_topo_file('servers'), get_topo_file('clients'), get_topo_file('dns'))
    run_bg('%s %s' % (CLICK, CLICK_CONF))

    # Set up traffic shaping
    logging.getLogger(__name__).info('Enabling traffic shaping...')
    try:
        check_output('%s start' % TC_SETUP)
        install_filters(get_topo_file('bottlenecks'))
    except Exception as e:
        logging.getLogger(__name__).error(e)

    # Launch apache instances
    logging.getLogger(__name__).info('Configuring apache...')
    try:
        configure_apache(get_server_ip_list())
        restart_apache()
    except Exception as e:
        logging.getLogger(__name__).error(e)


    logging.getLogger(__name__).info('Network started.')
示例#5
0
def stop_network():
    logging.getLogger(__name__).info('Stopping simulated network...')

    # stop apache instances
    logging.getLogger(__name__).info('Stopping apache...')
    try:
        reset_apache(get_server_ip_list())
        restart_apache()
    except Exception as e:
        logging.getLogger(__name__).error(e)

    # Stop traffic shaping
    logging.getLogger(__name__).info('Disabling traffic shaping...')
    try:
        check_output('%s stop' % TC_SETUP)
    except Exception as e:
        logging.getLogger(__name__).error(e)

    # Destroy fake NICs
    logging.getLogger(__name__).info('Destroying network interfaces...')
    try:
        check_both('killall -9 click', shouldPrint=False)
        time.sleep(0.1)
    except:
        pass
    logging.getLogger(__name__).info('Network stopped.')
示例#6
0
 def run_events(self, events_file=None, bg=False):
     cmd = '%s %s run' % (NETSIM, self.topo_dir)
     if events_file:
         cmd += ' -e %s' % events_file
     if bg:
         run_bg(cmd)
     else:
         check_output(cmd)
def execute_event(event):
    logging.getLogger(__name__).info("Updating link:  %s" % " ".join(event))
    try:
        check_output("%s update -c %i -b %s -l %s" % (TC_SETUP, int(event[1].split("link")[1]), event[2], event[3]))

        if args.log:
            with open(args.log, "a") as logfile:
                logfile.write("%f %s %s %s\n" % (time.time(), event[1], bw_to_kbps(event[2]), lat_to_ms(event[3])))
            logfile.closed
    except Exception as e:
        logging.getLogger(__name__).error(e)
示例#8
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
示例#9
0
def read_top(top):
  """
  Returns a list of (mass, charge, chain_id) for the atoms 
  in the topology file.
  """
  util.check_output(top)
  lines = open(top).readlines()

  atoms = []
  is_chain_topologies = False
  chain=" "
  top_dir = os.path.dirname(top)
  for l in lines:
    if not is_chain_topologies:
      if 'chain topologies' in l:
        is_chain_topologies = True
      continue
    if l.startswith("#include"):
      itp = l.split()[1][1:-1]
      itp = os.path.join(top_dir, itp)
      if os.path.isfile(itp):
        full_chain_name = os.path.splitext(itp)[0]
        chain = full_chain_name.split('_')[-1]
        these_atoms = read_top(itp, chain)
        atoms.extend(these_atoms)
    if l.startswith(";"):
      break

  is_atoms = False
  qtot = None
  for l in lines:
    if not is_atoms:
      if '[ atoms ]' in l:
        is_atoms = True
      continue
    if l.startswith('['):
      break
    if l.startswith(";"):
      continue    
    if not l.strip():
      continue
    words = l.split()
    n = int(words[0])
    res_num = int(words[2])
    res_type = words[3]
    q = float(words[6])
    mass = float(words[7])
    atoms.append((mass, q, chain))

  return atoms
示例#10
0
def update():
    # Figure out which traffic class we're updating
    if args.traffic_class:
        traffic_class = args.traffic_class
    elif args.ip_pair:
        traffic_class = class_for_ip_pair(args.ip_pair)
    else:
        traffic_class = DEFAULT_CLASS

    # Update the queues for the traffic class with the new BW/latency
    check_output('%s class replace dev %s parent %i: classid %i:%i htb rate %s ceil %s'\
        % (TC, args.interface, ROOT_Q_HANDLE, ROOT_Q_HANDLE, traffic_class,\
        args.bandwidth, args.bandwidth))
    check_output('%s qdisc replace dev %s parent %i:%i handle %i: netem delay %s'\
        % (TC, args.interface, ROOT_Q_HANDLE, traffic_class, traffic_class,\
        args.latency))

    # Update the rules mapping IP address pairs to the traffic class
    if args.ip_pair:
        U32='%s filter replace dev %s protocol ip parent %i: prio 1 u32'\
            % (TC, args.interface, ROOT_Q_HANDLE)
        check_output('%s match ip dst %s match ip src %s flowid %i:%i'
            % (U32, args.ip_pair[0], args.ip_pair[1], ROOT_Q_HANDLE, traffic_class))
        check_output('%s match ip dst %s match ip src %s flowid %i:%i'
            % (U32, args.ip_pair[1], args.ip_pair[0], ROOT_Q_HANDLE, traffic_class))
示例#11
0
def solvate_psf(in_psf, in_pdb, basename, solvent_buffer=10.0):
  """
  Uses VMD to add explicit waters to a .psf topology file
  """
  parms = {
    'in_psf': in_psf,
    'in_pdb': in_pdb,
    'name': basename,
    'solvent_buffer': solvent_buffer,
  }
  tcl = basename + '.vmd.tcl'
  open(tcl, 'w').write(solvate_vmd_script % parms)
  data.binary('vmd', '-dispdev text -eofexit', basename+'.vmd', tcl)
  util.check_output(basename+'.vmd.pdb')
  util.check_output(basename+'.pdb')
示例#12
0
    def _regenerate_dependency_cache(self):
        """Regenerate the Maven dependencies for this project.
        This normally happens when the cached dependencies are determined to be stale."""
        # Bootstrap with our skeleton environment
        shutil.copytree(os.path.join(os.path.dirname(__file__), "skeleton"), self.__cached_project_root)

        # Use skeleton environment Maven to copy dependencies into output dir
        cmd = ". %s; which mvn" % os.path.join(self.__cached_project_root, "environment.source")
        logger.info("Detecting environment mvn via `%s`", cmd)
        env_mvn = util.check_output(cmd, shell=True, cwd=self.__cached_project_root)
        if env_mvn.endswith("\n"):
            env_mvn = env_mvn[:-1]

        env_mvn = env_mvn + " " + self.__maven_flags

        cached_m2_repo = os.path.join(self.__cached_project_root, Packager._MAVEN_REL_ROOT)
        settings_xml = os.path.join(self.__cached_project_root, "settings.xml")

        # copy-dependencies
        copy_deps_flags = ""
        if self.__maven_repo is not None:
            copy_deps_flags += "-Dmaven.repo.local=%s" % self.__maven_repo

        quiet_flag = "-q"
        if self.__verbose:
            quiet_flag = ""

        cmd = """%s --settings %s %s dependency:copy-dependencies -Dmdep.useRepositoryLayout=true -Dmdep.copyPom -DoutputDirectory=%s %s"""
        cmd = cmd % (env_mvn, settings_xml, quiet_flag, cached_m2_repo, copy_deps_flags)
        Packager.__shell(cmd, self.__project_root)

        # mvn test without running tests
        cmd = """%s --settings %s %s -Dmaven.repo.local=%s -Dmaven.artifact.threads=100 surefire:test -DskipTests"""
        cmd = cmd % (env_mvn, settings_xml, quiet_flag, cached_m2_repo)
        Packager.__shell(cmd, self.__project_root)
示例#13
0
def run(in_parms):
  """
  Runs a NAMD simulation using the PDBREMIX in_parms dictionary.
  """
  parms = copy.deepcopy(in_parms)
  name = parms['output_basename']

  # load the included CHARMM2 energy parameters
  parms['parameter'] = os.path.join(data.data_dir, 'charmm22.parameter')
  parms['psf_type'] =  'paraTypeCharmm on'

  # copy over input xsc and topology files (same basename)
  xsc = parms['topology'].replace('.psf', '.xsc')
  if os.path.isfile(xsc):
    shutil.copy(xsc, name + '.in.xsc')
    parms['xsc'] = name + '.in.xsc'
  else:
    parms['xsc'] = ''
  shutil.copy(parms['topology'], name + '.psf')
  parms['topology'] = name + '.psf'

  # copy over coordinates
  shutil.copy(parms['input_crds'], name + '.in.coor')
  parms['input_crds'] = name + '.in.coor'

  # copy over velocities
  if 'input_vels' in parms and parms['input_vels']:
    shutil.copy(parms['input_vels'], name + '.in.vel')
    parms['input_vels'] = name + '.in.vel'
  else:
    parms['input_vels'] = ''

  # copy over restraint coordinates
  if 'restraint_pdb' in parms and parms['restraint_pdb']:
    shutil.copy(parms['restraint_pdb'], name + '.restraint.coor')
    parms['restraint_pdb'] = name + '.restraint.coor'
  else:
    parms['restraint_pdb'] = ''
    
  namd_in = name + ".namd2.in"
  open(namd_in, "w").write(make_namd_input_file(parms))
  
  data.binary('namd2', namd_in, name + '.namd2')

  top, crds, vels = get_restart_files(name)
  util.check_output(top)
  util.check_output(crds)
示例#14
0
 def execute(self):        
     try:
         self._output = util.check_output(self._command_line(), shell=True)
         self.reset()
     except subprocess.CalledProcessError as e:
         print e
         return False
     return True
示例#15
0
def soup_from_top_gro(top, gro, skip_solvent=False):
  """
  Returns a Soup built from GROMACS restart files.
  If skip_solvent=True, will skip all solvent molecules.
  """
  util.check_output(top)
  util.check_output(gro)

  soup = pdbatoms.Soup()
  soup.remaining_text = ""
  soup.n_remaining_text = 0

  atoms = []

  # Read from .gro because .top does not contain water
  # residue information, which is "inferred"
  lines = open(gro, 'r').readlines()
  for i_line, line in enumerate(lines[2:-1]):
    atom = AtomFromGroLine(line)
    if skip_solvent and atom.res_type == "SOL":
      soup.remaining_text = "".join(lines[i_line+2:-1])
      soup.n_remaining_text = len(lines[i_line+2:-1])
      break
    atoms.append(atom)
  soup.box = [float(w) for w in lines[-1].split()]

  for atom, (mass, q, chain_id) in zip(atoms, read_top(top)):
    atom.mass = mass
    atom.charge = q

  curr_res_num = -1
  for a in atoms:
    if curr_res_num != a.res_num:
      res = pdbatoms.Residue(
          a.res_type, a.chain_id, a.res_num)
      soup.append_residue(res.copy())
      curr_res_num = a.res_num
    soup.insert_atom(-1, a)

  convert_to_pdb_atom_names(soup)
  protein.find_chains(soup)

  return soup
示例#16
0
def link_jars(libs, directory):
  makedirs(directory)
  cp = check_output(['buck', 'audit', 'classpath'] + libs)
  for j in cp.strip().splitlines():
    if j not in jars:
      jars.add(j)
      n = path.basename(j)
      if j.startswith('buck-out/gen/gerrit-'):
        n = j.split('/')[2] + '-' + n
      symlink(path.join(root, j), path.join(directory, n))
示例#17
0
def make_restraint_script(pdb, force=100.0):
  """
  Generates sander input fragment that specifies the atoms
  that will be restrained.

  The function reads a PDB file that was generated from the 
  topology functions above, and uses the B-factor field B>0 to 
  determine which atom is to be restrained. The atoms will
  be restrained by a spring of force in kcal/mol/angs**2 
  """
  util.check_output(pdb)
  script = "Restrained atoms from %s\n" % pdb
  script += "%s\n" % force
  script += restraint_script
  for i, atom in enumerate(pdbatoms.read_pdb(pdb)):
    if atom.bfactor > 0.0:
      script += "ATOM %d %d\n" % (i+1, i+1)
  script += "END\n"
  script += "END\n"
  return script
示例#18
0
def show():
    print '=============== Queue Disciplines ==============='
    check_output('%s -s qdisc show dev %s' % (TC, args.interface))
    print '\n================ Traffic Classes ================'
    check_output('%s -s class show dev %s' % (TC, args.interface))
    print '\n==================== Filters ===================='
    check_output('%s -s filter show dev %s' % (TC, args.interface))
示例#19
0
    def build_from_project(project_root):
        retcode = subprocess.call("git show-ref --quiet", shell=True, cwd=project_root)
        if retcode != 0:
            raise Exception("Directory %s is not a git repository" % project_root)

        grind_git_hash = util.check_output("git show-ref --head -s HEAD", shell=True, cwd=os.path.dirname(__file__))
        if grind_git_hash.endswith("\n"):
            grind_git_hash = grind_git_hash[:-1]
        git_hash = util.check_output("git show-ref --head -s HEAD", shell=True, cwd=project_root)
        if git_hash.endswith("\n"):
            git_hash = git_hash[:-1]
        git_branch = "(no branch)"
        try:
            git_branch = util.check_output("git symbolic-ref HEAD", shell=True, cwd=project_root)
        except:
            # Ignore an error here, can happen if we're on a detached HEAD
            pass
        if git_branch.endswith("\n"):
            git_branch = git_branch[:-1]
        # Hash the deps file to look for changes
        deps_checksum = None
        return Manifest(grind_git_hash, os.path.normpath(project_root), git_branch, git_hash, datetime.datetime.now(), deps_checksum)
示例#20
0
def disulfide_script_and_rename_cysteines(in_pdb, out_pdb):
  """
  Returns the tleap script for disulfide bonds in the in_pdb file.

  This function opens in_pdb in a Soup, and searches for
  CYS residues where the SG-SG distance < 3 angs. These residues
  are then renamed to CYX and written to out_pdb. The disulfide bonds
  are then returned in a .tleap script fragment.
  """
  soup = pdbatoms.Soup(in_pdb)
  script = " # disulfide bonds\n"
  n = len(soup.residues())
  for i in range(n):
    for j in range(i+1, n):
      if soup.residue(i).type in 'CYS' and soup.residue(j).type in 'CYS':
        p1 = soup.residue(i).atom('SG').pos
        p2 = soup.residue(j).atom('SG').pos
        if v3.distance(p1, p2) < 3.0:
          soup.residue(i).set_type('CYX')
          soup.residue(j).set_type('CYX')
          script += "bond pdb.%d.SG pdb.%d.SG\n" % (i+1, j+1)
  soup.write_pdb(out_pdb)
  util.check_output(out_pdb)
  return script
示例#21
0
def get_rev(repo, rev):
    validate_rev(rev)
    return check_output(["git", "-C", repo, "rev-parse", rev],
                        stdin=DEVNULL).decode(PREFERREDENCODING).strip()
示例#22
0
    cmd = mvn(args.a) + [
        'deploy:deploy-file',
        '-DrepositoryId=%s' % args.repository,
        '-Durl=%s' % args.url,
    ] + common
else:
    print("unknown action -a %s" % args.a, file=stderr)
    exit(1)

for spec in args.s:
    artifact, packaging_type, src = spec.split(':')
    cmds = cmd + [
        '-DartifactId=%s' % artifact,
        '-Dpackaging=%s' % packaging_type,
        '-Dfile=%s' % src,
    ]
    try:
        check_output(cmds)
    except Exception as e:
        cmds_str = ' '.join(pipes.quote(c) for c in cmds)
        print("%s command failed: `%s`: %s" % (args.a, cmds_str, e),
              file=stderr)
        exit(1)

with open(args.o, 'w') as fd:
    if args.repository:
        print('Repository: %s' % args.repository, file=fd)
    if args.url:
        print('URL: %s' % args.url, file=fd)
    print('Version: %s' % args.v, file=fd)
示例#23
0
def install_filters(links_file):
    with open(links_file, "r") as linksf:
        for line in strip_comments(linksf):
            elems = line.split(" ")
            check_output("%s update %s %s -c %i" % (TC_SETUP, elems[0], elems[2], int(elems[1].split("link")[1])))
    linksf.closed
示例#24
0
def restart_apache_script(script):
    check_output('%s restart' % script, shouldPrint=False)
示例#25
0
def restart_apache_binary(bin):
    check_output('%s -k restart' % bin, shouldPrint=True)
示例#26
0
jar = ['-Dpackaging=jar']
src = ['-Dpackaging=java-source']

cmd = {
  'deploy': ['mvn',
             'deploy:deploy-file',
             '-DrepositoryId=gerrit-api-repository',
             '-Durl=%s' % URL],
  'install': ['mvn',
              'install:install-file'],
  }

try:
  check_output(cmd[action] +
               plugin +
               common +
               jar +
               ['-Dfile=%s' % plugin_jar])
  check_output(cmd[action] +
               plugin +
               common +
               src +
               ['-Dfile=%s' % plugin_src])
  check_output(cmd[action] +
               extension +
               common +
               jar +
               ['-Dfile=%s' % extension_jar])
  check_output(cmd[action] +
               extension +
               common +
示例#27
0
def run(in_parms):
  """
  Run a GROMACS simulations using the PDBREMIX parms dictionary.
  """
  parms = copy.deepcopy(in_parms)
  basename = parms['output_basename']

  # Copies across topology and related *.itp files, with appropriate
  # filename renaming in #includes
  top = basename + '.top'
  in_top = parms['topology']
  shutil.copy(in_top, top)
  in_name = os.path.basename(in_top).replace('.top', '')
  in_dir = os.path.dirname(in_top)
  file_tag = "%s/%s_*itp" % (in_dir, in_name)
  new_files = [top]
  for f in glob.glob(file_tag):
    new_f = os.path.basename(f)
    new_f = new_f.replace(in_name, basename)
    shutil.copy(f, new_f)
    new_files.append(new_f)
  for f in new_files:
    replace_include_file(f, in_name + "_", basename + "_")

  # Copy over input coordinates/velocities
  in_gro = basename + '.in.gro'
  shutil.copy(parms['input_crds'], in_gro)

  # Generates a postiional-restraint topology file
  if parms['restraint_pdb']:
    # 1kcal*mol*A**-2 = 4.184 kJ*mol*(0.1 nm)**-2 
    kcalmolang2_to_kJmolnm2 = 400.184
    open(basename + '_posre.itp', 'w').write(
        make_restraint_itp(
            parms['restraint_pdb'], 
            parms['restraint_force'] * kcalmolang2_to_kJmolnm2))

  # Generate .mdp file based on parms
  in_mdp = basename + '.grompp.mdp'
  open(in_mdp, 'w').write(make_mdp(parms))

  # Now run .grompp to generate this .tpr file 
  tpr = basename + '.tpr'
  # .mdp to save complete set of parameters
  mdp = basename + '.mdrun.mdp'
  data.binary(
      'grompp',
      '-f %s -po %s -c %s -p %s -o %s' \
          % (in_mdp, mdp, in_gro, top, tpr),
      basename + '.grompp')
  util.check_files(tpr)

  # Run simulation with the .tpr file
  data.binary(
      'mdrun',
      '-v -deffnm %s' % (basename),
      basename + '.mdrun')
  top, crds, vels = get_restart_files(basename)
  util.check_output(top)
  util.check_output(crds)
  
  # Cleanup
  delete_backup_files(basename)
示例#28
0
def run(in_parms):
  """
  Run a AMBER simulations using the PDBREMIX in_parms dictionary.
  """
  parms = copy.deepcopy(in_parms)
  basename = parms['output_basename']

  # Copies across topology file
  input_top = parms['topology'] 
  util.check_files(input_top)
  new_top = basename + '.top'
  shutil.copy(input_top, new_top)

  # Copies over coordinate/velocity files
  input_crd = parms['input_crds']
  util.check_files(input_crd)
  if input_crd.endswith('.crd'): 
    new_crd = basename + '.in.crd'
  else:
    new_crd = basename + '.in.rst'
  shutil.copy(input_crd, new_crd)
  
  # Decide on type of output coordinate/velocity file
  if 'n_step_minimization' in parms:
    rst = basename + ".crd"
  else:
    rst = basename + ".rst"

  # Construct the long list of arguments for sander
  trj = basename + ".trj"
  vel_trj = basename + ".vel.trj"
  ene = basename + ".ene"
  inf = basename + ".inf"
  sander_out = basename + ".sander.out"
  sander_in = basename + ".sander.in"
  args = "-O -i %s -o %s -p %s -c %s -r %s -x %s -v %s -e %s -inf %s" \
          % (sander_in, sander_out, new_top, new_crd, rst, trj, vel_trj, ene, inf)

  # Make the input script
  script = make_sander_input_file(parms)

  # If positional restraints
  if parms['restraint_pdb']:
    # Generate the AMBER .crd file that stores the constrained coordinates
    pdb = parms['restraint_pdb']
    soup = pdbatoms.Soup(pdb)
    ref_crd = basename + '.restraint.crd'
    write_soup_to_rst(soup, ref_crd)
    util.check_output(ref_crd)
    # Add the restraints .crd to the SANDER arguments
    args += " -ref %s" % ref_crd
    # Add the restraint forces and atom indices to the SANDER input file
    script += make_restraint_script(pdb, parms['restraint_force'])

  open(sander_in, "w").write(script)

  # Run the simulation
  data.binary('sander', args, basename)

  # Check if output is okay
  util.check_output(sander_out, ['FATAL'])
  top, crds, vels = get_restart_files(basename)
  util.check_output(top)
  util.check_output(crds)
示例#29
0
def run_tleap(
    force_field, pdb, name, solvent_buffer=0.0, excess_charge=0): 
  """
  Generates AMBER topology and coordinate files from PDB.

  Depending on whether excess_charge is non-zero, will also generate
  counterions. If solvent_buffer is non-zero, will generate explicit
  waters, otherwise, no waters generated. No waters is used for
  implicit solvent simulations.
  """

  util.check_output(pdb)

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

  # The restart files to be generated
  top = name + '.top'
  crd = name + '.crd'

  # Dictionary to substitute into tleap scripts
  params = { 
    'top': top, 
    'crd': crd, 
    'pdb': tleap_pdb,
    'data_dir':data.data_dir,
    'solvent_buffer': solvent_buffer,
  }

  # use best force-field for the 2 versions of AMBER author has tested
  if 'AMBER11' in force_field:
    params['amber_ff'] = "leaprc.ff99SB"
  elif 'AMBER14' in force_field:
    params['amber_ff'] = "leaprc.ff14SB"
  elif 'AMBER8' in force_field:
    params['amber_ff'] = "leaprc.ff96"
  else:
    raise Exception("Don't know which version of AMBER(8|11|14) to use.")

  # make the tleap input script
  script = force_field_script
  # check for a few non-standard residue that have been included 
  residues = [r.type for r in pdbatoms.Soup(tleap_pdb).residues()]
  if 'PHD' in residues:
    leaprc = open("%s/phd.leaprc" % data.data_dir).read()
    script += leaprc
  if 'ZNB' in residues:
    leaprc = open("%s/znb.leaprc" % data.data_dir).read()
    script += leaprc
  script += "pdb = loadpdb %(pdb)s\n"
  script += disulfide_script_and_rename_cysteines(tleap_pdb, tleap_pdb)
  if 'GBSA' not in force_field:
    # Add explicit waters as not GBSA implicit solvent
    if excess_charge != 0:
      # Add script to add counterions, must specify + or -
      if excess_charge > 0:
        script += "addions pdb Cl- 0\n"
      else:
        script += "addions pdb Na+ 0\n"
    solvent_buffer = 10
    params['solvent_buffer'] = solvent_buffer
    script += explicit_water_box_script
  script += save_and_quit_script
  script = script % params

  # Now write script to input file
  tleap_in = name + ".tleap.in"
  open(tleap_in, "w").write(script)

  # Now run tleap with tleap_in
  data.binary('tleap', "-f "+tleap_in, name+'.tleap')

  # Check output is okay
  if os.path.isfile('leap.log'):
    os.rename('leap.log', name + '.tleap.log')
  util.check_output(name+'.tleap.log', ['FATAL'])
  util.check_output(top)
  util.check_output(crd)

  return top, crd
示例#30
0
def restart_apache_script(script):
    check_output('%s restart' % script, shouldPrint=False)
示例#31
0
def get_file_contents(repo, rev, path):
    validate_rev(rev)
    return check_output(["git", "-C", repo, "show", rev + ":" + path],
                        stdin=DEVNULL)
示例#32
0
elif 'deploy' == args.a:
  cmd = mvn(args.a) + [
    'deploy:deploy-file',
    '-DrepositoryId=%s' % args.repository,
    '-Durl=%s' % args.url,
  ] + common
else:
  print("unknown action -a %s" % args.a, file=stderr)
  exit(1)

for spec in args.s:
  artifact, packaging_type, src = spec.split(':')
  cmds = cmd + [
    '-DartifactId=%s' % artifact,
    '-Dpackaging=%s' % packaging_type,
    '-Dfile=%s' % src,
  ]
  try:
    check_output(cmds)
  except Exception as e:
    cmds_str = ' '.join(pipes.quote(c) for c in cmds)
    print("%s command failed: `%s`: %s" % (args.a, cmds_str, e), file=stderr)
    exit(1)

with open(args.o, 'w') as fd:
  if args.repository:
    print('Repository: %s' % args.repository, file=fd)
  if args.url:
    print('URL: %s' % args.url, file=fd)
  print('Version: %s' % args.v, file=fd)
示例#33
0
def restart_apache_binary(bin):
    check_output('%s -k restart' % bin, shouldPrint=True)