An Integrated Framework Advancing Membrane Protein Modeling and Design

Membrane proteins are critical functional molecules in the human body, constituting more than 30% of open reading frames in the human genome. Unfortunately, a myriad of difficulties in overexpression and reconstitution into membrane mimetics severely limit our ability to determine their structures. Computational tools are therefore instrumental to membrane protein structure prediction, consequently increasing our understanding of membrane protein function and their role in disease. Here, we describe a general framework facilitating membrane protein modeling and design that combines the scientific principles for membrane protein modeling with the flexible software architecture of Rosetta3. This new framework, called RosettaMP, provides a general membrane representation that interfaces with scoring, conformational sampling, and mutation routines that can be easily combined to create new protocols. To demonstrate the capabilities of this implementation, we developed four proof-of-concept applications for (1) prediction of free energy changes upon mutation; (2) high-resolution structural refinement; (3) protein-protein docking; and (4) assembly of symmetric protein complexes, all in the membrane environment. Preliminary data show that these algorithms can produce meaningful scores and structures. The data also suggest needed improvements to both sampling routines and score functions. Importantly, the applications collectively demonstrate the potential of combining the flexible nature of RosettaMP with the power of Rosetta algorithms to facilitate membrane protein modeling and design.


RosettaMP design relies on object-oriented programming concepts
Today, robust algorithms are not the only requirement for high-level scientific software. Software designs must incorporate features for multiple tasks within a single platform. Several tools have already benefited from this integrative approach, including the Integrative Modeling Platform [1], Chimera visualization toolset [2], Biopython package [3], Phenix [4] and the Rosetta software suite [5]. Each of these platforms houses an architecture that permits the user to interchange components, thereby creating a new set of complex tools for biomolecular modeling, design, and visualization. This flexible and expansive nature of software enables these computational tools to answer a broader range of scientific questions than ever before.

Object-oriented design principles in RosettaMP
To create an integrated environment for membrane protein modeling, we applied object-oriented programming concepts [6] to the design of RosettaMP. Specifically, we relied on the concepts below to extend the existing architecture Rosetta3 [7]: • Cohesion: The methods and data in a single object should represent a single concept in detail • Extension (Inheritance): Create an object that is a subtype of a parent object. This new object inherits parent methods and data, as well as defining its own features • Containment (Encapsulation): Store a new object (or multiple of that object) as data in an existing object • Template: Define an abstract class that defines data to be filled (the template). During creation, fill the data depending on what is being represented. • Composite: Represent that objects stored in the parent object have a part-to-whole relationship • Mediation: Track another objects for updates Each principle described aided the extension of the scoring and sampling infrastructure in Rosetta3, as well as creating new objects for representing biomolecules in the membrane. Principles applied to the design of each object (or set of objects) in RosettaMP are listed in Table  A.

Membrane EnergyMethods
Individual membrane-specific scoring terms Inheritance

Membrane Movers
Sample conformations with respect to the position and orientation of the membrane bilayer

Inheritance
The object-oriented architecture of the ScoreFunction, EnergyMethod hierarchy and Movers have been previously described in [7]. Because the membrane representation objects are completely new, we describe the architecture of these objects in Fig. A.

Fig. A: Detailed architecture of the membrane representation used in the framework
The object-oriented architecture of the membrane representation is described with Unified Modeling Language (UML). Each box describes an individual object. The top field specifies the object name, the middle field specifies data stored by the object, and the bottom field describes methods in that object. Filled diamond arrows denote one object is contained in the other. Open diamond arrows denote n objects are contained in the parent object.

Expanding Rosetta's residue type library to include a Membrane Residue
The Rosetta database includes an extensive library of residues: the individual chemical building blocks that make up a biomolecule [7,8]. The wide range of chemical building blocks, ranging from canonical amino acids to small molecules, is described by encapsulating a ResidueType template object in the Residue object. A ResidueType defines properties specific to that residue, and can be added to Rosetta by including a new Residue parameter file to the database. The parameter file for the membrane residue is described in Fig. B The residue parameter file for the centroid MEM residue can be found in: Rosetta/database/chemical/residue_type_sets/centroid/residue_types/membrane/ MEM.params The residue parameter file for the full atom MEM residue can be found in: Rosetta/database/chemical/residue_type_sets/fa_standard/residue_types/ membrane/MEM.params

Membrane score functions
A low-and high-resolution score function were introduced as part of the original RosettaMembrane implementation [9][10][11]. To make these score functions compatible with RosettaMP, we created a new set of EnergyMethod objects for each score term. Each score term preserves the scientific integrity of the original energy function, while also relying on the membrane representation in RosettaMP for scoring.
The low-resolution and high-resolution terms use different representations of the membrane during scoring. At the low-resolution stage, the membrane comprises of five discrete layers to describe the hydrophobic core, interface, and solvent regions [9]. In contrast, the full-atom energy uses the implicit membrane model (IMM1) described by Lazaridis [12] to describe a continuous dielectric gradient from the hydrophobic core to solvent region. This membrane model includes a hydrophobic layer, transition region, and soluble region.
The functional form of each term supported by RosettaMP is shown Table B.
aa= amino acid type L = layer in the membrane B = burial state in the protein [9] mp_pair i,j = residue indices aa= amino acid type d = distance between residues L = layer in the membrane !! ! i = residue (centroid) index sh = shell radius, 6 Å or 12 Å nb = number of neighboring residues within a shell P compact = probability in compact structure assembled from fragments P random = probability in random structure from fragments [9,13] mp_nonhelix ! !"!!!"#$ = !10 * 1 !"!(−12 < ! < 12)!and!(!! ≠ H) 0 !"#! ! i = residue index z = residue depth in membrane ss = secondary structure type (Helix (H), Strand (S) or Coil (C)) where T is the membrane thickness ∆! ! !"# = free energy of an isolated atom in the membrane N atom = number of atoms in the molecule [10,12] fa_mpsolv i,j = atom indices d = distance between atoms r = sum of van der Waals radii V = atomic volume = correlation length ∆! !"## = solvation free energy of the free (isolated) atom N atom = number of atoms in residue i N atoms = number of atoms in each residue j within 12 Å of atom i [10,12] fa_mpenv_ smooth centroid term with the same functional form as the centroid term mp_env; this term is derived from a full-atom representation and can only be used in full-atom mode [11] hbond nb = number of neighboring residues within a shell !′ = depth of atom pairs in the membrane W hbond = global weight optimized by sequence recovery and decoy features ! !"# !!"#$ (!, Ψ, Θ) = orientation dependent hydrogen bonding energy ! !"#$%& !!"#$ !, !" = membrane dependent hydrogen bonding weight [10,14] ! ! ! describes the transition between the phases and is defined as ! ! ! = !′ ! (1 + !′ ! ) with n controlling the steepness of the transition.
For scoring in the membrane environment, each application relies on a different combination of terms and weights. The MPrelax and MPddG protocols use the standard set of weights for the high-resolution membrane energy function. The MPddG with pH scoring, MPdock and MPsymdock application uses a special weights set. All weights used in this manuscript are described in Tables C and D. The standard weights set for the low-resolution membrane score function can be found in: Rosetta/main/database/scoring/weights/mpframework_cen_2006.wts The original high-resolution membrane score function can be found in: Rosetta/main/database/scoring/weights/mpframework_fa_2007.wts This is superseded by the standard weight set for the high-resolution membrane score function, also used for MP_Relax and MP_ddG, which can be found in:

Model preparation
For cases in each application, The structure each protein was downloaded from the Protein Databank of Transmembrane Proteins website (PDBTM: http://pdbtm.enzim.hu/) [15]. Protein structures from this database are transformed into a reference membrane coordinate frameproviding a consistent set of models with starting orientations in the bilayer. PDB files were cleaned and renumbered using the clean_pdb.py script in the Rosetta/tools/protein_tools/scripts directory. Spanfiles were generated using the span_from_pdb application described below.

MPddG: Prediction of free energy changes (∆∆G) in the membrane
MPddG combines the RosettaMP framework with a fixed-backbone ∆∆G prediction protocol, similar to the method described in Kellogg et al. [16]. For each ∆∆G prediction, side-chain conformations for residues within 8 Å of the mutant position are sampled and the ∆∆G is taken as the difference in Rosetta Energy Units (REU) between the mutant and native conformation.

Contributing Rosetta energies to predicted ∆∆G values
We investigated the contribution of each energy term to the overall ∆∆G by taking the difference in individual scores between the mutant and native conformation. Data for mutations in OmpLA and OmpA are shown in Table E and F respectively. In both tables, scores are colored using a blue to red gradient, where blue indicates a favorable score (∆∆G < 0) and red indicates an unfavorable score (∆∆G > 0). In each row, the most saturated values are the minimum and maximum values. Energies with no contribution to the ∆∆G were excluded from both tables. These are the disulfide bonding energies (dslf_ss_dih, dslf_ca_dih, dslf_cs_ang, and dslf_ss_dst), hydrogen bonding energies (hbond_sr_bb, hbond_lr_bb, hbond_bb_sc, and hbond_sc) and omega dihedral energy (omega). The role of structural features in predicted ∆∆G values is also described in Fig mutation  total  fa_atr  fa_rep  fa_intra_  rep  fa_elec  pro_close  fa_mpsolv  rama  fa_dun  p_aa_pp  ref  fa_mpenv  fa_mpenv_  The effects of the side chains for arginine/lysine, serine/threonine and the aromatic residues are shown in the figures below.

Fig. C: Close-up view of the arginine and lysine side chains and their neighboring residues
The amine charges at the end of the arginine side chain reach further towards the interface region than for lysine, therefore resulting in a smaller penalty of insertion.

Fig. D: Close-up view of the threonine and serine side chains and their neighboring residues
The threonine hydroxyl group is closer to the neighboring leucine 225, leading to a larger van der Waals repulsive score and thus a larger ∆∆G. The hydroxyl group in serine is further away from this leucine, influencing both the attractive and repulsive scores only marginally, leading to a smaller predicted ∆∆G compared to threonine.

Fig. E: Close-up view of the aromatic side chains and their neighboring residues
Phenylalanine and tryptophan both have distances in the 4 Å range to the neighboring leucine 197. Tryptophan has smaller distances due to the additional benzene ring that clashes with the leucine and leads to larger differences in attractive and repulsive scores.  Mutations are grouped by amino acid type (from top to bottom): tryptophan, tyrosine and phenylalanine. Positive values (red) indicate the native aromatic residue is favored and negative values (blue) indicate alanine is favored. In most cases, a loss of van der Waals attractive energy (fa_atr) is seen when aromatics are substituted with alanine. The knowledge-based membrane environment energies (fa_mpenv_smooth) also classifies mutation to alanine to be unfavorable, consistent with the published values. However, the Lazaridis membrane environment and solvation energies predict mutations to be favorable, indicating that improvements to the implicit membrane model are needed to accurately represent aromatics at the interface.

Detailed methods and command lines
∆∆G values were predicted using the predict_ddG.py python script in the protocol capture in supporting information S2.
The following command line and options were used for prediction of ∆∆G values for mutations in the protein OmpLA: ./predict_ddG.py -in_pdb inputs/1qd6_tr_C.pdb # Input PDB file -in_span inputs/1qd6_tr_C.span # Input spanfile -out ddGs_ompLA.txt # Output filename with predicted ddGs -res 181 # Pose residue number to mutate -repack_radius 8.0 # Repack all residues within X # Angstroms of the mutant position Using this command line, the script will predict the ∆∆G values of mutation from alanine to all canonical residues.
Correlation plots were generated using the data from the output file containing predicted ∆∆G values (ddGs_ompLA.txt). Tables describing the contribution of individual terms were created from the output score breakdown files.
The following command line and options were used for prediction of ∆∆G values for mutations in the protein OmpA. Including the -mut option defines the specific mutant of interest: ./predict_ddG.py -in_pdb inputs/1qjp_tr.pdb # Input PDB file -in_span inputs/1qjp_tr.span # Input spanfile -out ddGs_ompLA.txt # Output filename with predicted ddGs -res 181 # Pose residue number to mutate -mut A # Mutate position to alanine -repack_radius 8.0 # Repack all residues within 8 # Angstroms of the mutant position Correlation plots were generated using the data from the output file containing predicted ∆∆G values. Tables describing contribution of individual terms were created from the output score breakdown files.

MPrelax: High-resolution membrane protein refinement
The MPrelax application described here simultaneously refines the structure and optimizes the membrane position and orientation.

Additional test cases
MPrelax was tested on a set of four membrane protein structures: meta-rhodopsin II (main text) and three additional cases described here. A diverse set of protein structures was selected to probe strengths and weaknesses in the refinement protocol. The cases are described in reference to Fig. F (A) Membrane methyltransferase, monomer, crystal structure (PDB 4a2n) with five transmembrane helices. Three of five helices are significantly longer than the membrane thickness, suggesting a wider range of possible membrane embeddings along the z-axis. (B) Histidine kinase receptor QseC, monomer, NMR structure (PDB 2kse) with two transmembrane helices. (C) Disulfide bonding protein B, monomer, NMR structure (PDB 2leg) with four transmembrane helices. The predicted transmembrane spans are shorter than the hydrophobic thickness, increasing conformational space for the membrane embedding.
The structure also contains a long loop region at the membrane interface.
Each protein structure was refined using the original membrane relax protocol described in Barth, 2007 [10] and the new MPrelax protocol to compare performance. 1000 refined models were generated for each simulation. The complete set of results is shown in Fig. F RosettaMP samples lower scoring models for meta-rhodopsin II (PDB 3pxo), membrane methyltransferase (PDB 4a2n) and histidine kinase receptor QseC (PDB 2kse). In contrast, the original RosettaMembrane protocol (Barth, 2007) leads to lower scores for disulfide bonding protein B (PDB 2leg). These preliminary data suggest that the minimization routine for optimizing the membrane position improves refinement of proteins that completely span the hydrophobic thickness of the membrane; however, requires improvement for proteins that do not fully span the membrane.

Origin of differences between RosettaMembrane (Barth, 2007) and RosettaMP refinement
To further investigate differences between the original RosettaMembrane (Barth, 2007) and RosettaMP relax protocols, the five lowest scoring models from both runs were compared using individual Rosetta energies, shown in Table G     Rosetta scores for the top five scoring models from RosettaMembrane (Barth, 2007) and RosettaMP relax are decomposed into individual weighted score terms (weights in Table D). Both protocols sample models within similar RMSD ranges (Fig. G) suggesting differences are attributed to different positions and orientations (embedding) of proteins in the membrane. In Tables G-J we show all score terms dependent on membrane embedding: Lazaridis membrane environment (fa_mpenv), Lazaridis membrane solvation (fa_mpsolv), knowledge-based membrane environment (fa_mpenv_smooth), and hydrogen bonding energies (hbond_sc, hbond_bb_sc, hbond_lr_bb, hbond_sr_bb).
(A) Scores for short-range and long-range backbone-backbone hydrogen bonds (hbond_sr_bb and hbond_lr_bb) are consistently lower for RosettaMP models. Since both models contain similar numbers of hydrogen bonds, lower scores are attributed to improved positioning of hydrogen bonds in the membrane. RosettaMP models also have lower knowledge-based membrane environment scores, further indicating membrane embedding is improved in these models. (C) Lazaridis membrane environment and solvation energies are consistently higher in models refined by RosettaMP. This protein does not fully span the membrane, complicating the task of simultaneously embedding and refining a protein with a moveable membrane. These data suggest the fixed membrane used in Barth, 2007 is still better for such cases, pointing to needed improvements in the minimization routine used by RosettaMP.

Detailed methods and command lines
Refinement with the original membrane relax application as described in [10] was performed with the following application and options. Here, 3PXO is used as an example protein: Note, the weights file, membrane_highres_Menv_smooth is the original implementation of the high resolution membrane score function [10].
To compute the RMSD between the native and refined models, we used the score_jd2 application with the following options: Because the Rosetta Relax will not automatically compute the RMSD between the native structure and refined model, the following application and options were used to compute the RMSD between the native and refined models: Rosetta/main/source/bin/score_jd2.linuxgccrelease -in:file:s 3PXO_models_list # List of refined models -in:file:native 3PXO_native.pdb # Native structure for RMSD calculation -score:weights mpframework_smooth_fa_2012 # Use hi-res membrane score function -in:membrane # Input is a membrane protein -mp:setup:membrane_rsd 100 # Read membrane residue at position 100 -mp:setup:spanfiles 3PXO.span # Input spanfile -mp:scoring:hbond # Turn on membrane hydrogen bonding -packing:pack_missing_sidechains 0 # Wait to pack sidechains until # membrane is present Score vs. RMSD plots were generated using the output score file from the re-scoring step.
RMSDs are calculated with respect to the backbone atoms of the native structure. Score density plots were also generated from this output file.

Refinement of Metarhodopsin II (PDB 3pxo) with Retinal
A structure of meta-rhodopsin II crystallized in complex with retinal is available (RET; PDB 3pxo) [21]. To test the performance of MPrelax on this protein-ligand complex, we created an additional mover that accommodates the ligand in the membrane FoldTree. This mover, AddMPLigandMover, attaches the ligand to the protein by jump, preserving the membrane jump. All stages of refinement are identical except that no rotamers are sampled for the ligand.
In the presence of Retinal, MPrelax samples a broader range of protein conformations than without it (Fig. G); between 1.0-5.0 Å RMSD to the crystal structure, compared to only 1.0-2.5 Å without the ligand. The lowest scoring refined model in the presence of the ligand has a smaller RMSD to the crystal structure, at 1.3 Å compared to 1.6 Å without the ligand. Because the original membrane relax protocol [10] does not accommodate ligands, we were unable to compare the performance of these methods. While this preliminary data is encouraging, some protocol enhancements that need to be explored include combining RosettaLigand [22] with RosettaMP to sample flexible ligand conformations, and benchmarking a score function in the membrane environment that includes ligands. The Rosetta script for refinement of a protein-ligand complex is presented below. The additional mover, AddMPLigandMover, accommodates the ligand in the membrane FoldTree and requires two arguments: (1) sequence position of the ligand in the PDB file, and (2) a residue in the binding pocket close to the ligand.

MPdock: Membrane protein-protein docking
This protocol combines the RosettaDock algorithm with the membrane energy function and adapted initial sampling to model the structure of protein-protein complexes in the membrane.

Additional test cases
The membrane protein-protein docking protocol was tested on a set of 5 membrane protein complexes: Vitamin B12 importer (PDB 2qi9) discussed in the main text and four cases discussed below. For each protein, 10 locally refined models and 1000 docked models were generated during the simulation. Results for each protein are shown in Fig. H (A) Glycophorin A, homodimer, NMR structure (PDB 1afo) with one transmembrane helix per subunit. Docking partners are chain A and B. Since this is an NMR structure and Rosetta's energy function is parameterized on crystal structures, it is expected that the lowest scoring models have higher RMSDs than models compared to the crystal structure. MPdock samples two conformations: models around 1 Å and 5 Å RMSD, the latter with more favorable interface scores, suggesting needed improvements to the scorefunction.

Detailed methods and command lines
Additional model preparation: To allow the use of the two-body docking algorithm, chains from the extra-membrane region were removed, as were additional chains that would interfere with the docking algorithm.
The prepack protocol was run with the following application and options. Here, 1afo is used as an example protein: Additionally, the 'native' structures were refined to compare both sampling and scoring of the membrane protein-protein docking protocol to these models. 10 models were created using the options: Score vs. RMSD plots were generated from the output score files. RMSDs were 'ligand' RMSDs as computed in the third column in the score file, which were computed only over the movable partner in the complex.

Application MPsymdock: Assembly of symmetric membrane protein complexes
The MPsymdock protocol combines the symmetric docking protocol (RosettaSymDock) with RosettaMP to predict structures of symmetric complexes in the membrane environment.

Additional test cases
MPsymdock protocol was tested on a set of four membrane protein complexes with C n symmetry, where n is the number of subunits in the complex: the KcsA Potassium channel (PDB 1bl8) and three additional cases discussed here. Each native protein complex was first refined using the membrane relax protocol. The lowest scoring refined native was then setup for assembly and 1000 docked models were generated.
(A) Glycophorin A, homo-dimer, NMR structure (PDB 1afo). For the starting structure, we used model 1 of the NMR structure from the PDBTM [15]. Symmetric assembly of this dimer, which we also attempted in asymmetric docking, creates low-energy structures with similar helix crossing angles as in the experimental structure. The RMSD of this structure is 6 Å, due to deviations in the comparison of the extra-membrane loops, which also complicate the detection of symmetry in generating the starting structure. The full set of 20 models in the NMR structure show broad diversity in the tail location, indicating that the NMR constraints do not fully specify the position. (B) Human Leukotriene C4 Synthase, homo-trimer, crystal structure (PDB 2uuh).
MPsymdock is not able to find the correct interface; instead the individual subunits rotate by about 90° along the membrane normal. In contrast to the native structure, the extramembrane helices in the model are bent towards each other with steric clashes preventing the formation of a native-like interface. (C) Mechanosensitive channel of large conductance (MscL), homo-pentamer, crystal structure (PDB 2oar). The helices in each subunit form a claw-like interface with the neighboring subunits (i.e. a domain swap). These intertwined interfaces are challenging to form given the restricted rotation in symmetry. In practice, clashes in the model force the docking algorithm to separate the subunits, away from the experimentally determined conformation.

Detailed methods and command lines
To resolve initial clashes in the crystal structure, the native was refined using the MPrelax application described above. The following application and flags were used. Here, 1afo is used as an example: Rosetta/main/source/bin/rosetta_scripts.linuxgccrelease -parser:protocol membrane_relax.xml # Path to Rosetta script (above) -in:file:s 1afo_native.pdb # Input PDB file -nstruct 10 # Generate 10 models -mp:setup:spanfiles 1afo.span # Input spanfile -mp:scoring:hbond # Turn on membrane hydrogen bonding -relax:jump_move true # Allow jumps to move during relax -packing:pack_missing_sidechains 0 # Wait to pack sidechains until # membrane is present 10 refined native complexes were generated and the model with the lowest total Rosetta score was used as the starting structure for symmetric docking. From this starting structure, a symmetry definition file describing the arrangement of subunits around the C symmetry axis and input structure containing the asymmetric subunit was generated with the following script and options: Rosetta/main/source/src/apps/public/symmetry/make_symmdef_file.pl > 1afo.c2.symm -p 1afo_native.pdb # Refined input symmetric complex -a A # Chain to use as the master subunit -b B:2 # 1st child subunit (B) and number of # subunits in the symmetric complex (2) It is important to note that this script requires all chains be of equal length. The output file contains the symmetry definition required for symmetric modeling in Rosetta.
Because the starting structure was already transformed into the membrane coordinate frame, spanfiles were generated using the span_from_pdb application described below. Predicted TM spans are only provided as input for the asymmetric starting unit.
The following application and flags were used to generate models of the symmetric complex: Rosetta/main/source/bin/membrane_symdocking.linuxgccrelease -in:file:s 1afo_input.pdb # Asymmetric input structure -in:file:native 1afo_tr_native.pdb # Native structure for RMSD calculation -nstruct 1000 # Generate 1000 models -mp:setup:spanfiles 1afo.span # TM spans for asymm unit -mp:scoring:hbond # Turn on membrane hydrogen bonding -symmetry:symmetry_definition 1afo.c2.symm # Symmetry definition file -symmetry:initialize_rigid_body_dofs # Sample configurations during assembly -packing:pack_missing_sidechains 0 # Wait to pack sidechains until # membrane is present -docking:dock_lowres_filter 5.0 10.0 # Change filters required for a low # resolution model to advance to # high-res stage. Vdw score < 5.0 and # interchain contact score < 10.0 Score vs. RMSD plots were generated from the output score file. RMSDs of the assembled complex are computed with respect to the backbone atoms of the native structure.

Membrane visualization
The PyMOL viewer extension for membrane proteins can be used with any Rosetta modeling application. In addition, we provide a standalone application useful for visualizing sets of output Rosetta models. This application, view_membrane_protein, will read an input PDB file or list of PDBs, initialize an implicit membrane at the default or user-specified position, and display the structures with the membrane planes in PyMOL.
An example of this visualization is shown in Fig. J.

Detailed command lines
The following application and options can be used for standalone membrane protein visualization. Here, 1afo is used as an example protein with 1afo_list being a file containing all models for visualization. This application recognizes the membrane residue in the output model PDB file unless center and normal are specified by the user as described below.
Rosetta/main/source/bin/view_membrane_protein.linuxgccrelease -in:file:l 1afo_list # List of input models -mp:setup:spanfiles 1AFO_AB.span # Input spanfile -mp:setup:center 0 0 0 # (Optional) Specify membrane center -mp:setup:normal 0 0 1 # (Optional) Specify membrane normal To visualize a simulation, start a new PyMOL session. In the PyMOL window, initialize the PyMOLMover by running the script PyMOLPyrosettaServer.py. A message will appear in the PyMOL Terminal indicating the server has been initialized successfully. Finally, from the regular terminal, run the standalone Rosetta application with the flags above.