Command-line Options Research Articles

MLatom 3: A Platform for Machine Learning-Enhanced Computational Chemistry Simulations and Workflows.

Machine learning (ML) is increasingly becoming a common tool in computational chemistry. At the same time, the rapid development of ML methods requires a flexible software framework for designing custom workflows. MLatom 3 is a program package designed to leverage the power of ML to enhance typical computational chemistry simulations and to create complex workflows. This open-source package provides plenty of choice to the users who can run simulations with the command-line options, input files, or with scripts using MLatom as a Python package, both on their computers and on the online XACS cloud computing service at XACScloud.com. Computational chemists can calculate energies and thermochemical properties, optimize geometries, run molecular and quantum dynamics, and simulate (ro)vibrational, one-photon UV/vis absorption, and two-photon absorption spectra with ML, quantum mechanical, and combined models. The users can choose from an extensive library of methods containing pretrained ML models and quantum mechanical approximations such as AIQM1 approaching coupled-cluster accuracy. The developers can build their own models using various ML algorithms. The great flexibility of MLatom is largely due to the extensive use of the interfaces to many state-of-the-art software packages and libraries.

VASPKIT: A user-friendly interface facilitating high-throughput computing and analysis using VASP code

We present the VASPKIT, a command-line program that aims at providing a robust and user-friendly interface to perform high-throughput analysis of a variety of material properties from the raw data produced by the VASP code. It consists of mainly the pre- and post-processing modules. The former module is designed to prepare and manipulate input files such as the necessary input files generation, symmetry analysis, supercell transformation, k-path generation for a given crystal structure. The latter module is designed to extract and analyze the raw data about elastic mechanics, electronic structure, charge density, electrostatic potential, linear optical coefficients, wave function plots in real space, etc. This program can run conveniently in either interactive user interface or command line mode. The command-line options allow the user to perform high-throughput calculations together with bash scripts. This article gives an overview of the program structure and presents illustrative examples for some of its usages. The program can run on Linux, macOS, and Windows platforms. The executable versions of VASPKIT and the related examples and tutorials are available on its official website vaspkit.com. Program summaryProgram title: VASPKITCPC Library link to program files:https://doi.org/10.17632/v3bvcypg9v.1Licensing provisions: GPLv3Programming language: Fortran, PythonNature of problem: This program has the purpose of providing a powerful and user-friendly interface to perform high-throughput calculations together with the widely-used VASP code.Solution method: VASPKIT can extract, calculate and even plot the mechanical, electronic, optical and magnetic properties from density functional calculations together with bash and python scripts. It can run in either interactive user interface or command line mode.

PoseFilter: a PyMOL plugin for filtering and analyzing small molecule docking in symmetric binding sites.

'PoseFilter' is a PyMOL plugin that assists in analyses and filtering of docked poses. PoseFilter enables automatic detection of symmetric poses from docking outputs and can be accessed using both graphical user interface and command-line options within the PyMOL program. Two methods of analyses, root mean square deviations and interaction fingerprints, are available from this plugin. The capabilities of the plugin are demonstrated using docking outputs from different oligomeric protein-ligand complexes. The plugin can be downloaded from the GitHub page, https://github.com/skalyaanamoorthy/PoseFilter. Supplementary data are available at Bioinformatics online.

Composable block solvers for the four-field double porosity/permeability model

The objective of this paper is twofold. First, we propose two composable block solver methodologies to solve the discrete systems that arise from finite element discretizations of the double porosity/permeability (DPP) model. The DPP model, which is a four-field mathematical model, describes the flow of a single-phase incompressible fluid in a porous medium with two distinct pore-networks and with a possibility of mass transfer between them. Using the composable solvers feature available in PETSc and the finite element libraries available under the Firedrake Project, we illustrate two different ways by which one can effectively precondition these large systems of equations. Second, we employ the recently developed performance model called the Time-Accuracy-Size (TAS) spectrum to demonstrate that the proposed composable block solvers are scalable in both the parallel and algorithmic sense. Moreover, we utilize this spectrum analysis to compare the performance of three different finite element discretizations (classical mixed formulation with H(div) elements, stabilized continuous Galerkin mixed formulation, and stabilized discontinuous Galerkin mixed formulation) for the DPP model. Our performance spectrum analysis demonstrates that the composable block solvers are fine choices for any of these three finite element discretizations. Sample computer codes are provided to illustrate how one can easily implement the proposed block solver methodologies through PETSc command line options.

BpWrapper: BioPerl-based sequence and tree utilities for rapid prototyping of bioinformatics pipelines

BackgroundAutomated bioinformatics workflows are more robust, easier to maintain, and results more reproducible when built with command-line utilities than with custom-coded scripts. Command-line utilities further benefit by relieving bioinformatics developers to learn the use of, or to interact directly with, biological software libraries. There is however a lack of command-line utilities that leverage popular Open Source biological software toolkits such as BioPerl (http://bioperl.org) to make many of the well-designed, robust, and routinely used biological classes available for a wider base of end users.ResultsDesigned as standard utilities for UNIX-family operating systems, BpWrapper makes functionality of some of the most popular BioPerl modules readily accessible on the command line to novice as well as to experienced bioinformatics practitioners. The initial release of BpWrapper includes four utilities with concise command-line user interfaces, bioseq, bioaln, biotree, and biopop, specialized for manipulation of molecular sequences, sequence alignments, phylogenetic trees, and DNA polymorphisms, respectively. Over a hundred methods are currently available as command-line options and new methods are easily incorporated. Performance of BpWrapper utilities lags that of precompiled utilities while equivalent to that of other utilities based on BioPerl. BpWrapper has been tested on BioPerl Release 1.6, Perl versions 5.10.1 to 5.25.10, and operating systems including Apple macOS, Microsoft Windows, and GNU/Linux. Release code is available from the Comprehensive Perl Archive Network (CPAN) at https://metacpan.org/pod/Bio::BPWrapper. Source code is available on GitHub at https://github.com/bioperl/p5-bpwrapper.ConclusionsBpWrapper improves on existing sequence utilities by following the design principles of Unix text utilities such including a concise user interface, extensive command-line options, and standard input/output for serialized operations. Further, dozens of novel methods for manipulation of sequences, alignments, and phylogenetic trees, unavailable in existing utilities (e.g., EMBOSS, Newick Utilities, and FAST), are provided. Bioinformaticians should find BpWrapper useful for rapid prototyping of workflows on the command-line without creating custom scripts for comparative genomics and other bioinformatics applications.

The missing link: explaining ELF static linking, semantically

Beneath the surface, software usually depends on complex linker behaviour to work as intended. Even linking <pre>hello_world.c</pre> is surprisingly involved, and systems software such as <pre>libc</pre> and operating system kernels rely on a host of linker features. But linking is poorly understood by working programmers and has largely been neglected by language researchers. In this paper we survey the many use-cases that linkers support and the poorly specified linker speak by which they are controlled: metadata in object files, command-line options, and linker-script language. We provide the first validated formalisation of a realistic executable and linkable format (ELF), and capture aspects of the Application Binary Interfaces for four mainstream platforms (AArch64, AMD64, Power64, and IA32). Using these, we develop an executable specification of static linking, covering (among other things) enough to link small C programs (we use the example of bzip2) into a correctly running executable. We provide our specification in Lem and Isabelle/HOL forms. This is the first formal specification of mainstream linking. We have used the Isabelle/HOL version to prove a sample correctness property for one case of AMD64 ABI relocation, demonstrating that the specification supports formal proof, and as a first step towards the much more ambitious goal of verified linking. Our work should enable several novel strands of research, including linker-aware verified compilation and program analysis, and better languages for controlling linking.

Development and Application of a Fully Blind Flexible Peptide-protein Docking Protocol, pepATTRACT

Peptide-mediated interactions are involved in many signaling and regulatory pathways as well as the DNA replication machinery and are linked to many pathological disorders. Many research groups are currently working towards a more detailed understanding of these important interactions by characterizing the 3D complex structures with experimental methods like X-ray crystallography and NMR. However, for a large number of peptide-protein complexes such atomistic structural information is lacking to date. Computational peptide docking methods can yield information complementary to experimental information by predicting the protein-peptide complex structure from the 3D structure of the protein and the peptide sequence. This approach can also be used to study interactions between folded and disordered proteins/protein regions (e.g., the interactions of the disordered regions in tumor suppressor p53 with its different partners). Here, we describe the development and usage of the fully blind, flexible peptide-protein docking protocol pepATTRACT. The ATTRACT docking engine is implemented as a suite of command line tools and options that can be combined at will. Therefore, ATTRACT protocols like pepATTRACT are typically invoked via a custom, hand-written shell script. Although this approach is very flexible, it limits the accessibility of ATTRACT to expert users only. To make pepATTRACT easily accessible to non-expert users, we created a web-interface which helps the user set up a peptide docking protocol by editing parameters in a web browser (www.attract.ph.tum.de/peptide.html). pepATTRACT docking scripts can then executed on the user's local machine, once the ATTRACT software has been installed. Here, we describe all the steps necessary for setting up a pepATTRACT docking run via the web-interface including installation of the ATTRACT software.

Short Read Alignment Using SOAP2.

Next-generation sequencing (NGS) technologies have rapidly evolved in the last 5 years, leading to the generation of millions of short reads in a single run. Consequently, various sequence alignment algorithms have been developed to compare these reads to an appropriate reference in order to perform important downstream analysis. SOAP2 from the SOAP series is one of the most commonly used alignment programs to handle NGS data, and it efficiently does so using low computer memory usage and fast alignment speed. This chapter describes the protocol used to align short reads to a reference genome using SOAP2, and highlights the significance of using the in-built command-line options to tune the behavior of the algorithm according to the inputs and the desired results.

MEG]PLS: A pipeline for MEG data analysis and partial least squares statistics

The emphasis of modern neurobiological theories has recently shifted from the independent function of brain areas to their interactions in the context of whole-brain networks. As a result, neuroimaging methods and analyses have also increasingly focused on network discovery. Magnetoencephalography (MEG) is a neuroimaging modality that captures neural activity with a high degree of temporal specificity, providing detailed, time varying maps of neural activity. Partial least squares (PLS) analysis is a multivariate framework that can be used to isolate distributed spatiotemporal patterns of neural activity that differentiate groups or cognitive tasks, to relate neural activity to behavior, and to capture large-scale network interactions. Here we introduce [MEG]PLS, a MATLAB-based platform that streamlines MEG data preprocessing, source reconstruction and PLS analysis in a single unified framework. [MEG]PLS facilitates MRI preprocessing, including segmentation and coregistration, MEG preprocessing, including filtering, epoching, and artifact correction, MEG sensor analysis, in both time and frequency domains, MEG source analysis, including multiple head models and beamforming algorithms, and combines these with a suite of PLS analyses. The pipeline is open-source and modular, utilizing functions from FieldTrip (Donders, NL), AFNI (NIMH, USA), SPM8 (UCL, UK) and PLScmd (Baycrest, CAN), which are extensively supported and continually developed by their respective communities. [MEG]PLS is flexible, providing both a graphical user interface and command-line options, depending on the needs of the user. A visualization suite allows multiple types of data and analyses to be displayed and includes 4-D montage functionality. [MEG]PLS is freely available under the GNU public license (http://meg-pls.weebly.com).

Atomsk: A tool for manipulating and converting atomic data files

We present a libre, Open Source command-line program named Atomsk, that aims at creating and manipulating atomic systems for the purposes of ab initio calculations, classical atomistic calculations, and visualization, in the areas of computational physics and chemistry. The program can run on GNU/Linux, Apple Mac OS X, and Microsoft Windows platforms. Many file formats are supported, allowing for easy conversion of atomic configuration files. The command-line options allow to construct supercells, insert point defects (vacancies, interstitials), line defects (dislocations, cracks), plane defects (stacking faults), as well as other transformations. Several options can be applied consecutively, allowing for a comprehensive workflow from a unit cell to the final atomic system. Some modes allow to construct complex structures, or to perform specific analysis of atomic systems. Program summaryProgram title: AtomskCatalogue identifier: AEXM_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEXM_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU/GPL version 3 or any later versionNo. of lines in distributed program, including test data, etc.: 61,450No. of bytes in distributed program, including test data, etc.: 539,898Distribution format: tar.gzProgramming language: Fortran 90.Computer: All computers with a Fortran compiler supporting at least Fortran 90.Operating system: All operating systems with such a compiler. Some of the Makefiles and scripts depend on a Unix-like system and need modification under Windows.RAM: Typically 32 bytes × N, where N is the number of particles.Classification: 4.14, 7.1.External routines: LAPACKNature of problem: Atomistic simulations require the generation of atomic data files. Few software are available to construct atomic systems containing dislocations, especially in anisotropic media.Solution method: Atomsk is a unified program that allows to generate, convert and transform atomic systems for the purposes of ab initio calculations, classical atomistic simulations, or visualization. It supports many lattice types, all atom chemical species, and supports systems described with the ionic core–shell model. It allows to construct dislocations and analyze them, and perform post-treatment of simulation output files.Restrictions: no support for molecular bonds; limit of 2 billions particles.Unusual features: dislocations in anisotropic media; computation of the Nye tensor; generation of polycrystal from any type of lattice; support for ionic core–shell models and analysis of electric polarization.Additional comments: the program and its documentation are available at: http://atomsk.univ-lille1.frRunning time: spans from a fraction of a second to several minutes depending on the number of particles in the atomic system, the mode, and the machine performance.

MCF: A tool to find multi-scale community profiles in biological networks

Recent developments of complex graph clustering methods have implicated the practical applications with biological networks in different settings. Multi-scale Community Finder (MCF) is a tool to profile network communities (i.e., clusters of nodes) with the control of community sizes. The controlling parameter is referred to as the scale of the network community profile. MCF is able to find communities in all major types of networks including directed, signed, bipartite, and multi-slice networks. The fast computation promotes the practicability of the tool for large-scaled analysis (e.g., protein–protein interaction and gene co-expression networks). MCF is distributed as an open-source C++ package for academic use with both command line and user interface options, and can be downloaded at http://bsdxd.cpsc.ucalgary.ca/MCF. Detailed user manual and sample data sets are also available at the project website.

EASER: Ensembl Easy Sequence Retriever

The rapid advances in genome sequencing technologies have increased the pace at which biological sequence databases are becoming available to the broad scientific community. Thus, obtaining and preparing an appropriate sequence dataset is a crucial first step for all types of genomic analyses. Here, we present a script that can widely facilitate the easy, fast, and effortless downloading and preparation of a proper biological sequence dataset for various genomics studies. This script retrieves Ensembl defined genomic features, associated with a given Ensembl identifier. Coding (CDS) and genomic sequences can be easily retrieved based on a selected relationship from a set of relationship types, either considering all available organisms or a user specified subset of organisms. The script is very user-friendly and by default starts with an interactive mode if no command-line options are specified.

Passing in Command Line Arguments and Parallel Cluster/Multicore Batching in R with batch.

It is often useful to rerun a command line R script with some slight change in the parameters used to run it - a new set of parameters for a simulation, a different dataset to process, etc. The R package batch provides a means to pass in multiple command line options, including vectors of values in the usual R format, easily into R. The same script can be setup to run things in parallel via different command line arguments. The R package batch also provides a means to simplify this parallel batching by allowing one to use R and an R-like syntax for arguments to spread a script across a cluster or local multicore/multiprocessor computer, with automated syntax for several popular cluster types. Finally it provides a means to aggregate the results together of multiple processes run on a cluster.

Challenges and solutions in replicability and provenance tracking for simulation projects

Reproducibility of experiments, one of the foundation stones of science, ought to be easy in computational neuroscience, given that computers are deterministic, and do not suffer from the problems of inter-subject and trial-to-trial variability that make reproduction of biological experiments more challenging. In general, however, it is not easy, neither for the gold-standard case of reproduction by an independent researcher using independent code [1], nor for the much simpler case of an individual scientist or team being able to replicate their own results some months or years later. For this second case, the reasons include the complexity of our code and our computing environments, and the difficulty of capturing every essential piece of information needed to reproduce a computational experiment using existing tools such as spreadsheets, version control systems and paper notebooks. In other areas of science, particularly in applied science laboratories with high-throughput, highly-standardised procedures, electronic lab notebooks are in widespread use, but none of these tools seem to be well suited for tracking simulation experiments. In developing something like an electronic lab notebook for computational science, there are a number of challenges:(i) different researchers have very different ways of working and different workflows: command line, GUI, batch-jobs (e.g. in supercomputer environments), or any combination of these; (ii) some projects are essentially solo endeavours, others collaborative projects, possibly distributed geographically; (iii) as much as possible should be recorded automatically; if it is left to the researcher to record critical details there is a risk that some details will be missed or left out, particularly under pressure of deadlines. I present here a tool, Sumatra, for simulation project management and for automated recording of detailed provenance information: (i) the code that was run, (ii) any parameter files and command line options, (iii) the platform on which the code was run. Sumatra consists of a core library, implemented as a Python package, Sumatra, together with a series of interfaces that build on top of this: a command-line interface, a web interface, and a desktop interface. Each of these interfaces enables (i) launching simulations with automated recording of provenance information; and (ii) managing a simulation project: browsing, viewing, deleting simulations. Alternatively, modellers can use the Sumatra package directly in their own code, to enable provenance recording, then simply launch simulations in their usual way. Sumatra is distributed as open-source software (http://neuralensemble.org/sumatra/), so its functionality can be incorporated in other tools, and developed using a community model: anyone is welcome to get involved with its development.

The missing graphical user interface for genomics

The Galaxy package empowers regular users to perform rich DNA sequence analysis through a much-needed and user-friendly graphical web interface.See research article http://genomebiology.com/2010/11/8/R86Research highlightWith the advent of affordable and high-throughput DNA sequencing, sequencing is becoming an essential component in nearly every genetics lab. These data are being generated to probe sequence variations, to understand transcribed, regulated or methylated DNA elements, and to explore a host of other biological features across the tree of life and across a range of environments and conditions. Given this deluge of data, novices and experts alike are facing the daunting challenge of trying to analyze the raw sequence data computationally. With so many tools available and so many assays to analyze, how can one be expected to stay current with the state of the art? How can one be expected to learn to use each tool and construct robust end-to-end analysis pipelines, all while ensuring that input formats, command-line options, sequence databases and program libraries are set correctly? Finally, once the analysis is complete, how does one ensure the results are reproducible and transparent for others to scrutinize and study?In an article published in Genome Biology, Jeremy Goecks, Anton Nekrutenko, James Taylor and the rest of the Galaxy Team (Goecks et al. [1]) make a great advance towards resolving these critical questions with the latest update to their Galaxy Project. The ambitious goal of Galaxy is to empower regular users to carry out their own computational analysis without having to be an expert in computational biology or computer science. Galaxy adds a desperately needed graphical user interface to genomics research, making data analysis universally accessible in a web browser, and freeing users from the minutiae of archaic command-line parameters, data formats and scripting languages. Data inputs and computational steps are selected from dynamic graphical menus, and the results are displayed in intuitive plots and summaries that encourage interactive workflows and the exploration of hypotheses. The underlying data analysis tools can be almost any piece of software, written in any language, but all their complexity is neatly hidden inside of Galaxy, allowing users to focus on scientific rather than technical questions.

Seqphase: a web tool for interconverting phase input/output files and fasta sequence alignments

The program phase is widely used for Bayesian inference of haplotypes from diploid genotypes; however, manually creating phase input files from sequence alignments is an error-prone and time-consuming process, especially when dealing with numerous variable sites and/or individuals. Here, a web tool called seqphase is presented that generates phase input files from fasta sequence alignments and converts phase output files back into fasta. During the production of the phase input file, several consistency checks are performed on the dataset and suitable command line options to be used for the actual phase data analysis are suggested. seqphase was written in perl and is freely accessible over the Internet at the address http://www.mnhn.fr/jfflot/seqphase.

ModuleMaster: A new tool to decipher transcriptional regulatory networks

In this article we present ModuleMaster, a novel application for finding cis-regulatory modules (CRMs) in sets of co-expressed genes. The application comes with a newly developed method which not only considers transcription factor binding information but also multivariate functional relationships between regulators and target genes to improve the detection of CRMs. Given only the results of a microarray and a subsequent clustering experiment, the program includes all necessary data and algorithms to perform every step to find CRMs. This workbench possesses an easy-to-use graphical user interface, together with job-processing and command-line options, making ModuleMaster a sophisticated program for large-scale batch processing. The detected CRMs can be visualized and evaluated in various ways, i.e., generating GraphML- and R-based whole regulatory network visualizations or generating SBML files for subsequent analytical processing and dynamic modeling. ModuleMaster is freely available to academics as a webstart application and for download at http://www.ra.cs.uni-tuebingen.de/software/ModuleMaster/, including comprehensive documentation.

RedMD—Reduced molecular dynamics package

We developed a software package (RedMD) to perform molecular dynamics simulations and normal mode analysis of reduced models of proteins, nucleic acids, and their complexes. With RedMD one can perform molecular dynamics simulations in a microcanonical ensemble, with Berendsen and Langevin thermostats, and with Brownian dynamics. We provide force field and topology generators which are based on the one-bead per residue/nucleotide elastic network model and its extensions. The user can change the force field parameters with the command line options that are passed to generators. Also, the generators can be modified, for example, to add new potential energy functions. Normal mode analysis tool is available for elastic or anisotropic network models. The program is written in C and C++ languages and the structure/topology of a molecule is based on an XML format. OpenMP technology for shared-memory architectures was used for code parallelization. The code is distributed under GNU public licence and available at http://bionano.icm.edu.pl/software/.

SeqMap: mapping massive amount of oligonucleotides to the genome

SeqMap is a tool for mapping large amount of short sequences to the genome. It is designed for finding all the places in a reference genome where each sequence may come from. This task is essential to the analysis of data from ultra high-throughput sequencing machines. With a carefully designed index-filtering algorithm and an efficient implementation, SeqMap can map tens of millions of short sequences to a genome of several billions of nucleotides. Multiple substitutions and insertions/deletions of the nucleotide bases in the sequences can be tolerated and therefore detected. SeqMap supports FASTA input format and various output formats, and provides command line options for tuning almost every aspect of the mapping process. A typical mapping can be done in a few hours on a desktop PC. Parallel use of SeqMap on a cluster is also very straightforward.

Assembling Genomic DNA Sequences with PHRAP

The PHRAP assembly program provides rapid comparison, alignment, and assembly of large sets of DNA sequences. PHRAP compares sequences by searching for pairs of perfectly matching "words" or sequence regions that meet certain criteria. If a match is found, PHRAP then tries to extend the alignment into overlapping sections called contigs. PHRAP uses quality values produced by the PHRED basecaller to strike a balance between tolerance of discrepancies and prevention of stacking repeat sequences. The PHRAP assembly algorithm is generally used as part of the PHRED/PHRAP/Consed software suite for sequence analysis. This unit presents instructions for basic usage of the PHRAP assembler, including preparation of the input files (Support Protocols 1 and 2) and explanation of output files (Basic Protocols 1 and 2). Several command line options for changing the PHRAP assembly parameters are also discussed (Basic Protocol 3).