idZddlZddlZddlZddlmZddlm Z m Z ddl m Z ddl mZmZmZejdZdd Zd ZGd d e ZGdde ZdS)u Calculating root mean square quantities --- :mod:`MDAnalysis.analysis.rms` ========================================================================== :Author: Oliver Beckstein, David L. Dotson, John Detlefs :Year: 2016 :Copyright: Lesser GNU Public License v2.1+ .. versionadded:: 0.7.7 .. versionchanged:: 0.11.0 Added :class:`RMSF` analysis. .. versionchanged:: 0.16.0 Refactored RMSD to fit AnalysisBase API The module contains code to analyze root mean square quantities such as the coordinat root mean square distance (:class:`RMSD`) or the per-residue root mean square fluctuations (:class:`RMSF`). This module uses the fast QCP algorithm [Theobald2005]_ to calculate the root mean square distance (RMSD) between two coordinate sets (as implemented in :func:`MDAnalysis.lib.qcprot.CalcRMSDRotationalMatrix`). When using this module in published work please cite [Theobald2005]_. See Also -------- :mod:`MDAnalysis.analysis.align` aligning structures based on RMSD :mod:`MDAnalysis.lib.qcprot` implements the fast RMSD algorithm. Example applications -------------------- Calculating RMSD for multiple domains ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In this example we will globally fit a protein to a reference structure and investigate the relative movements of domains by computing the RMSD of the domains to the reference. The example is a DIMS trajectory of adenylate kinase, which samples a large closed-to-open transition. The protein consists of the CORE, LID, and NMP domain. * superimpose on the closed structure (frame 0 of the trajectory), using backbone atoms * calculate the backbone RMSD and RMSD for CORE, LID, NMP (backbone atoms) The trajectory is included with the test data files. The data in :attr:`RMSD.results.rmsd` is plotted with :func:`matplotlib.pyplot.plot` (see Figure :ref:`RMSD plot figure `):: import MDAnalysis from MDAnalysis.tests.datafiles import PSF,DCD,CRD u = MDAnalysis.Universe(PSF,DCD) ref = MDAnalysis.Universe(PSF,DCD) # reference closed AdK (1AKE) (with the default ref_frame=0) #ref = MDAnalysis.Universe(PSF,CRD) # reference open AdK (4AKE) import MDAnalysis.analysis.rms R = MDAnalysis.analysis.rms.RMSD(u, ref, select="backbone", # superimpose on whole backbone of the whole protein groupselections=["backbone and (resid 1-29 or resid 60-121 or resid 160-214)", # CORE "backbone and resid 122-159", # LID "backbone and resid 30-59"]) # NMP R.run() import matplotlib.pyplot as plt rmsd = R.results.rmsd.T # transpose makes it easier for plotting time = rmsd[1] fig = plt.figure(figsize=(4,4)) ax = fig.add_subplot(111) ax.plot(time, rmsd[2], 'k-', label="all") ax.plot(time, rmsd[3], 'k--', label="CORE") ax.plot(time, rmsd[4], 'r--', label="LID") ax.plot(time, rmsd[5], 'b--', label="NMP") ax.legend(loc="best") ax.set_xlabel("time (ps)") ax.set_ylabel(r"RMSD ($\AA$)") fig.savefig("rmsd_all_CORE_LID_NMP_ref1AKE.pdf") .. _figure-RMSD: .. figure:: /images/RSMD_plot.png :scale: 50 % :alt: RMSD plot RMSD plot for backbone and CORE, LID, NMP domain of the protein. Functions --------- .. autofunction:: rmsd Analysis classes ---------------- .. autoclass:: RMSD :members: :inherited-members: .. attribute:: results.rmsd Contains the time series of the RMSD as an N×3 :class:`numpy.ndarray` array with content ``[[frame, time (ps), RMSD (A)], [...], ...]``. .. versionadded:: 2.0.0 .. attribute:: rmsd Alias to the :attr:`results.rmsd` attribute. .. deprecated:: 2.0.0 Will be removed in MDAnalysis 3.0.0. Please use :attr:`results.rmsd` instead. .. autoclass:: RMSF :members: :inherited-members: .. attribute:: results.rmsf Results are stored in this N-length :class:`numpy.ndarray` array, giving RMSFs for each of the given atoms. .. versionadded:: 2.0.0 .. attribute:: rmsf Alias to the :attr:`results.rmsf` attribute. .. deprecated:: 2.0.0 Will be removed in MDAnalysis 3.0.0. Please use :attr:`results.rmsf` instead. N)qcprot) AnalysisBase ResultsGroup)SelectionError) asiterableiterable get_weightszMDAnalysis.analysis.rmsdFc8tj|tj}tj|tj}|jd}|j|jkrt d|s|r4|tj|d|z }|tj|d|z }|dt |t |krt dtj|tjtj|z }|rtj |||d|S|Ftj tj |ddtj f||z dzz|z Stj tj ||z dz|z S)a Returns RMSD between two coordinate sets `a` and `b`. `a` and `b` are arrays of the coordinates of N atoms of shape :math:`N times 3` as generated by, e.g., :meth:`MDAnalysis.core.groups.AtomGroup.positions`. Note ---- If you use trajectory data from simulations performed under **periodic boundary conditions** then you *must make your molecules whole* before performing RMSD calculations so that the centers of mass of the mobile and reference structure are properly superimposed. Parameters ---------- a : array_like coordinates to align to `b` b : array_like coordinates to align to (same shape as `a`) weights : array_like (optional) 1D array with weights, use to compute weighted average center : bool (optional) subtract center of geometry before calculation. With weights given compute weighted average as center. superposition : bool (optional) perform a rotational and translational superposition with the fast QCP algorithm [Theobald2005]_ before calculating the RMSD; implies ``center=True``. Returns ------- rmsd : float RMSD between `a` and `b` Notes ----- The RMSD :math:`\rho(t)` as a function of time is calculated as .. math:: \rho(t) = \sqrt{\frac{1}{N} \sum_{i=1}^N w_i \left(\mathbf{x}_i(t) - \mathbf{x}_i^{\text{ref}}\right)^2} It is the Euclidean distance in configuration space of the current configuration (possibly after optimal translation and rotation) from a reference configuration divided by :math:`1/\sqrt{N}` where :math:`N` is the number of coordinates. The weights :math:`w_i` are calculated from the input weights `weights` :math:`w'_i` as relative to the mean: .. math:: w_i = \frac{w'_i}{\langle w' \rangle} Example ------- >>> import MDAnalysis as mda >>> from MDAnalysis.analysis.rms import rmsd >>> from MDAnalysis.tests.datafiles import PSF, DCD >>> u = mda.Universe(PSF, DCD) >>> bb = u.select_atoms('backbone') >>> A = bb.positions.copy() # coordinates of first frame >>> _ = u.trajectory[-1] # forward to last frame >>> B = bb.positions.copy() # coordinates of last frame >>> rmsd(A, B, center=True) 6.838544558398293 .. versionchanged:: 0.8.1 *center* keyword added .. versionchanged:: 0.14.0 *superposition* keyword added dtyperza and b must have same shape)axisweightsNz(weights must have same length as a and br) npasarrayfloat64shape ValueErroraveragelenmeanqcpCalcRMSDRotationalMatrixsqrtsumnewaxis)abrcenter superpositionNs a/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/analysis/rms.pyrmsdr#s}^ 1BJ'''A 1BJ'''A  Aw!'788877  11g666 6  11g666 6 w<<3q66 ! !GHH H*WBJ777"'':J:JJ5+Aq!T7CCC  726'!!!RZ-"8QUqL"IJJQNOO O7261q5Q,//!344 4ct|tr t|t|d}nt|tur1 |d|dd}ns#t$rt ddwxYwt|t ur0 |d|dn-#t $rt d dwxYwtd t|d|d<t|d|d<|S) aMReturn a canonical selection dictionary. Parameters ---------- select : str or tuple or dict - `str` -> Any valid string selection - `dict` -> ``{'mobile':sel1, 'reference':sel2}`` - `tuple` -> ``(sel1, sel2)`` Returns ------- dict selections for 'reference' and 'mobile'. Values are guarenteed to be iterable (so that one can provide selections to retain order) Notes ----- The dictionary input for `select` can be generated by :func:`fasta2select` based on a ClustalW_ or STAMP_ sequence alignment.  referencemobiler)r(r'z=select must contain two selection strings (reference, mobile)Nr(r'zIselect dictionary must contain entries for keys 'mobile' and 'reference'.z2'select' must be either a string, 2-tuple, or dict) isinstancestrtypetuple IndexErrordictKeyError TypeErrorr)selects r"process_selectionr3sB.&#N"6{{c&kkBB f    &q q BBFF   &   f    8   ;      ,   LMMM!&"233F8$VK%899F; Ms AA:B%%CcteZdZdZdZedZ dfd Zd Zd Z d Z e d Z xZ S)RMSDaClass to perform RMSD analysis on a trajectory. The RMSD will be computed for two groups of atoms and all frames in the trajectory belonging to `atomgroup`. The groups of atoms are obtained by applying the selection selection `select` to the changing `atomgroup` and the fixed `reference`. Note ---- If you use trajectory data from simulations performed under **periodic boundary conditions** then you *must make your molecules whole* before performing RMSD calculations so that the centers of mass of the selected and reference structure are properly superimposed. Run the analysis with :meth:`RMSD.run`, which stores the results in the array :attr:`RMSD.results.rmsd`. .. versionchanged:: 1.0.0 ``save()`` method was removed, use ``np.savetxt()`` on :attr:`RMSD.results.rmsd` instead. .. versionchanged:: 2.0.0 :attr:`rmsd` results are now stored in a :class:`MDAnalysis.analysis.base.Results` instance. .. versionchanged:: 2.8.0 introduced :meth:`get_supported_backends` allowing for parallel execution on ``multiprocessing`` and ``dask`` backends. TcdS)N)serialmultiprocessingdaskclss r"get_supported_backendszRMSD.get_supported_backendsps   r$NallF皙?rc  & ttj|jjfi| |_||nj_t|}| d|Dng_|_ |_ |_ |_ jj |d_jj |d_t!jt!jkrSdjjjj} t&| t+| t&dt!jt/jjjjjz j k} t/j| rt&dt9jjD]}\} } | j| jkrht&d| j| j| j | j| j!| j| j| j | j| j! ~d j }t&|t+|~ fd jD_"tGt9jj"D]\}\}}t!|dt!|dkrrt&d t+d ||d|dt!|dt!|dt/j$d t/j$df}d}tKj rg}j D]I}tK|r#|&t!|4|&dJt/j'|j(dkrtS|t/j*|j$|vrtS|tKj s j dkrtWjj j rt!j t!jkrtYdt9j j"jD]w\}}} tK|s|dkrtW|d|3#tZ$r6}t]|t_|d|dzzd}~wwxYwdSdS)aParameters ---------- atomgroup : AtomGroup or Universe Group of atoms for which the RMSD is calculated. If a trajectory is associated with the atoms then the computation iterates over the trajectory. reference : AtomGroup or Universe (optional) Group of reference atoms; if ``None`` then the current frame of `atomgroup` is used. select : str or dict or tuple (optional) The selection to operate on; can be one of: 1. any valid selection string for :meth:`~MDAnalysis.core.groups.AtomGroup.select_atoms` that produces identical selections in `atomgroup` and `reference`; or 2. a dictionary ``{'mobile': sel1, 'reference': sel2}`` where *sel1* and *sel2* are valid selection strings that are applied to `atomgroup` and `reference` respectively (the :func:`MDAnalysis.analysis.align.fasta2select` function returns such a dictionary based on a ClustalW_ or STAMP_ sequence alignment); or 3. a tuple ``(sel1, sel2)`` When using 2. or 3. with *sel1* and *sel2* then these selection strings are applied to `atomgroup` and `reference` respectively and should generate *groups of equivalent atoms*. *sel1* and *sel2* can each also be a *list of selection strings* to generate a :class:`~MDAnalysis.core.groups.AtomGroup` with defined atom order as described under :ref:`ordered-selections-label`). groupselections : list (optional) A list of selections as described for `select`, with the difference that these selections are *always applied to the full universes*, i.e., ``atomgroup.universe.select_atoms(sel1)`` and ``reference.universe.select_atoms(sel2)``. Each selection describes additional RMSDs to be computed *after the structures have been superimposed* according to `select`. No additional fitting is performed.The output contains one additional column for each selection. .. Note:: Experimental feature. Only limited error checking implemented. weights : {"mass", ``None``} or array_like (optional) 1. "mass" will use masses as weights for both `select` and `groupselections`. 2. ``None`` will weigh each atom equally for both `select` and `groupselections`. 3. If 1D float array of the same length as `atomgroup` is provided, use each element of the `array_like` as a weight for the corresponding atom in `select`, and assumes ``None`` for `groupselections`. weights_groupselections : False or list of {"mass", ``None`` or array_like} (optional) 1. ``False`` will apply imposed weights to `groupselections` from ``weights`` option if ``weights`` is either ``"mass"`` or ``None``. Otherwise will assume a list of length equal to length of `groupselections` filled with ``None`` values. 2. A list of {"mass", ``None`` or array_like} with the length of `groupselections` will apply the weights to `groupselections` correspondingly. tol_mass : float (optional) Reject match if the atomic masses for matched atoms differ by more than `tol_mass`. ref_frame : int (optional) frame index to select frame from `reference` verbose : bool (optional) Show detailed progress of the calculation if set to ``True``; the default is ``False``. Raises ------ SelectionError If the selections from `atomgroup` and `reference` do not match. TypeError If `weights` or `weights_groupselections` is not of the appropriate type; see also :func:`MDAnalysis.lib.util.get_weights` ValueError If `weights` are not compatible with `atomgroup` (not the same length) or if it is not a 1D array (see :func:`MDAnalysis.lib.util.get_weights`). A :exc:`ValueError` is also raised if the length of `weights_groupselections` are not compatible with `groupselections`. Notes ----- The root mean square deviation :math:`\rho(t)` of a group of :math:`N` atoms relative to a reference structure as a function of time is calculated as .. math:: \rho(t) = \sqrt{\frac{1}{N} \sum_{i=1}^N w_i \left(\mathbf{x}_i(t) - \mathbf{x}_i^{\text{ref}}\right)^2} The weights :math:`w_i` are calculated from the input weights `weights` :math:`w'_i` as relative to the mean of the input weights: .. math:: w_i = \frac{w'_i}{\langle w' \rangle} The selected coordinates from `atomgroup` are optimally superimposed (translation and rotation) on the `reference` coordinates at each time step as to minimize the RMSD. Douglas Theobald's fast QCP algorithm [Theobald2005]_ is used for the rotational superposition and to calculate the RMSD (see :mod:`MDAnalysis.lib.qcprot` for implementation details). The class runs various checks on the input to ensure that the two atom groups can be compared. This includes a comparison of atom masses (i.e., only the positions of atoms of the same mass will be considered to be correct for comparison). If masses should not be checked, just set `tol_mass` to a large value such as 1000. .. _ClustalW: http://www.clustal.org/ .. _STAMP: http://www.compbio.dundee.ac.uk/manuals/stamp.4.2/ See Also -------- rmsd .. versionadded:: 0.7.7 .. versionchanged:: 0.8 `groupselections` added .. versionchanged:: 0.16.0 Flexible weighting scheme with new `weights` keyword. .. deprecated:: 0.16.0 Instead of ``mass_weighted=True`` (removal in 0.17.0) use new ``weights='mass'``; refactored to fit with AnalysisBase API .. versionchanged:: 0.17.0 removed deprecated `mass_weighted` keyword; `groupselections` are *not* rotationally superimposed any more. .. versionchanged:: 1.0.0 `filename` keyword was removed. Nc,g|]}t|Sr:)r3).0ss r" z!RMSD.__init__..s! ; ; ;a q ! ! ; ; ;r$r'r(zkReference and trajectory atom selections do not contain the same number of atoms: N_ref={0:d}, N_traj={1:d}z RMS calculation for {0:d} atoms.zAtoms: reference | mobilezV{0!s:>4} {1:3d} {2!s:>3} {3!s:>3} {4:6.3f}| {5!s:>4} {6:3d} {7!s:>3} {8!s:>3}{9:6.3f}z\Inconsistent selections, masses differ by more than{0:f}; mis-matching atomsare shown above.czg|]7}jjj|djjj|dd8S)r'r(r&)r'universe select_atoms atomgrouprBrCselfs r"rDz!RMSD.__init__..Usd' ' '  BT^4A{^?$.1>( L   ' ' ' r$zSelectionError: Group SelectionzGroup selection {0}: {1} | {2}: Reference and trajectory atom selections do not contain the same number of atoms: N_ref={3}, N_traj={4}rint64ztweights should only be 'mass', None or 1D float array.For weights on groupselections, use **weight_groupselections**r)masszLLength of weights_groupselections is not equal to length of groupselections z happens in selection %s)0superr5__init__rF trajectoryrHr'r3groupselectionsrtol_mass ref_frameweights_groupselectionsrG ref_atoms mobile_atomsrformatn_atomslogger exceptionrinforabsolutemassesanyerrorzipnamesegidresidresnamerL_groupselections_atoms enumerater r appenduniquesizer1arrayr r Exceptionr,r+)rJrHr'r2rPrrSrQrRkwargserrmass_mismatchesaraterrmsgigroupselatomsacceptable_dtypesmsg element_lenselement selectione __class__s` r"rNz RMSD.__init__xsp #dD"9#5#@KKFKKK"&/&;"6*** < ;? ; ; ; ;     "'>$44f[6IJ7DN79IJ t~  #d&7"8"8 8 8,,2FN*D,=,E--    S ! ! ! %% % 1 8 8T^9L9L M M    K.1B1II K Km   6/ " " ) LL4 5 5 5dnd.?@@  B7bg%%LL##)6HHJGGHHJGG $ $"##)6$-#8#8  LL  (( (  ' ' ' ' )' ' ' #%. $d&A B B% %    FLS%5?##s5+='>'>>>  !BCCC$,,2FK(H E+.//E(O,, --   ? Xi00"(72C2CD - DL ! ! %L< + +G$$+ ''G 5555 ''****y&&+a//nn$x  &.???nn$ DL ! ! 9T\V%;%; )4< 8 8 8  ' 4/00C8L4M4MMM 1.1,+$..  ) ((>Gv,=,=#E(OW=== !$q''A4y7JJK    s +U  V 1VV cRjj_jsTt js#jgt jz_ndgt jz_ttjj D]\}\}}t|dkr|dj j|<|Stjj|tjtjj|z j|<t#jj_t#jj_jtjjtjtjjz _tjjtjtjjz _jjjjj} jjjjjj_jjjz _j rfdjD_jjj|n#jjj|wxYwj tj_!j rFtj"dtj_#j#$dd_%nd_#tj"j&dt j zfj'_(jj) tj_*dS)NrLr(r c~g|]9}jj|djtj:S)r')r'rG positionsastyperrrIs r"rDz!RMSD._prepare..sO666  43{^#FF2:$6$6 666r$ )+rUrW_n_atomsrSr rrrPrer_rdr+r\rrrrr weights_selectrT weights_refr'rFrOtsframerRr_ref_comr}_ref_coordinates_groupselections_ref_coords64r~_ref_coordinates64zeros_rotreshape_Rn_framesresultsr#copy_mobile_coordinates64)rJrqrrs current_frames` r"_preparez RMSD._preparesm)1 +   15 ~(AA0,,15v(990,)2 ,d.I J J) )  B B $F$We7||v%%7 N # .t~ > > N11$2BCCDM$(N$">rz"J"J  &  "*555DIi''1--DGGDIH ]AD$? @ @@ A   &*%6%@%E%E%G%G%N%N J& & """s A8JJ-c:tdtjiS)Nr#)lookup)rndarray_vstackrJs r"_get_aggregatorzRMSD._get_aggregatorsFL,G#HIIIIr$cL|j|jtj}|jj|jdd<|xj|zc_|jj |j j f|j j |jddf<|jrKt!j|j|j|j|j|j|j j |jdf<|jdd|jddddf<|jjddxx|zcc<t j|jj|j|jjdd<|jxj|jz c_t3t5|j|jdD]I\}\}}t||dj|j|dz dd|j j |j|f<JdSt!j|j|j|jd|j|j j |jdf<dS)Nrrr(F)rrr )rUrrr~rrr}r_tsr _trajectorytimerr# _frame_indexrdrrrrrrrdotrrer_rrS)rJ mobile_comrqrefposrss r" _single_framezRMSD._single_framesW&--d.ABBII J  )-(9(C"111% ""j0"" HN   !4  $+RaR/0  &6 ,+.MI'  L d/2 3!I--a33DGAAAqqqDM H qqq ! ! !Z / ! ! !%'F48+=tw$G$GDH qqq ! H  $- /  ,56/ ,,  '@D(O- 8!D "' @@@ !$"3V";<<  $,+.M'  L d/2 3 3 3r$cRd}tj|t|jjS)NzThe `rmsd` attribute was deprecated in MDAnalysis 2.0.0 and will be removed in MDAnalysis 3.0.0. Please use `results.rmsd` instead.)warningswarnDeprecationWarningrr#rJwmsgs r"r#z RMSD.rmsd1, &  d.///|  r$)Nr>NNFr?r)__name__ __module__ __qualname____doc__%_analysis_algorithm_is_parallelizable classmethodr=rNrrrpropertyr# __classcell__rzs@r"r5r5Os<-1)  [  %bbbbbbH L L L \JJJBBBH!!X!!!!!r$r5c`eZdZdZedZfdZdZdZdZ e dZ xZ S)RMSFaCalculate RMSF of given atoms across a trajectory. Note ---- No RMSD-superposition is performed; it is assumed that the user is providing a trajectory where the protein of interest has been structurally aligned to a reference structure (see the Examples section below). The protein also has be whole because periodic boundaries are not taken into account. Run the analysis with :meth:`RMSF.run`, which stores the results in the array :attr:`RMSF.results.rmsf`. cdS)N)r7r:r;s r"r=zRMSF.get_supported_backendsMs{r$c ltt|j|jjfi|||_dS)aParameters ---------- atomgroup : AtomGroup Atoms for which RMSF is calculated verbose : bool (optional) Show detailed progress of the calculation if set to ``True``; the default is ``False``. Raises ------ ValueError raised if negative values are calculated, which indicates that a numerical overflow or underflow occured Notes ----- The root mean square fluctuation of an atom :math:`i` is computed as the time average .. math:: \rho_i = \sqrt{\left\langle (\mathbf{x}_i - \langle\mathbf{x}_i\rangle)^2 \right\rangle} No mass weighting is performed. This method implements an algorithm for computing sums of squares while avoiding overflows and underflows :footcite:p:`Welford1962`. Examples -------- In this example we calculate the residue RMSF fluctuations by analyzing the :math:`\text{C}_\alpha` atoms. First we need to fit the trajectory to the average structure as a reference. That requires calculating the average structure first. Because we need to analyze and manipulate the same trajectory multiple times, we are going to load it into memory using the :mod:`~MDAnalysis.coordinates.MemoryReader`. (If your trajectory does not fit into memory, you will need to :ref:`write out intermediate trajectories ` to disk or :ref:`generate an in-memory universe ` that only contains, say, the protein):: import MDAnalysis as mda from MDAnalysis.analysis import align from MDAnalysis.tests.datafiles import TPR, XTC u = mda.Universe(TPR, XTC, in_memory=True) protein = u.select_atoms("protein") # 1) the current trajectory contains a protein split across # periodic boundaries, so we first make the protein whole and # center it in the box using on-the-fly transformations import MDAnalysis.transformations as trans not_protein = u.select_atoms('not protein') transforms = [trans.unwrap(protein), trans.center_in_box(protein, wrap=True), trans.wrap(not_protein)] u.trajectory.add_transformations(*transforms) # 2) fit to the initial frame to get a better average structure # (the trajectory is changed in memory) prealigner = align.AlignTraj(u, u, select="protein and name CA", in_memory=True).run() # 3) reference = average structure ref_coordinates = u.trajectory.timeseries(asel=protein).mean(axis=1) # make a reference structure (need to reshape into a 1-frame # "trajectory") reference = mda.Merge(protein).load_new(ref_coordinates[:, None, :], order="afc") We created a new universe ``reference`` that contains a single frame with the averaged coordinates of the protein. Now we need to fit the whole trajectory to the reference by minimizing the RMSD. We use :class:`MDAnalysis.analysis.align.AlignTraj`:: aligner = align.AlignTraj(u, reference, select="protein and name CA", in_memory=True).run() The trajectory is now fitted to the reference (the RMSD is stored as `aligner.results.rmsd` for further inspection). Now we can calculate the RMSF:: from MDAnalysis.analysis.rms import RMSF calphas = protein.select_atoms("name CA") rmsfer = RMSF(calphas, verbose=True).run() and plot:: import matplotlib.pyplot as plt plt.plot(calphas.resnums, rmsfer.results.rmsf) References ---------- .. footbibliography:: .. versionadded:: 0.11.0 .. versionchanged:: 0.16.0 refactored to fit with AnalysisBase API .. deprecated:: 0.16.0 the keyword argument `quiet` is deprecated in favor of `verbose`. .. versionchanged:: 0.17.0 removed unused keyword `weights` .. versionchanged:: 1.0.0 Support for the ``start``, ``stop``, and ``step`` keywords has been removed. These should instead be passed to :meth:`RMSF.run`. N)rMrrNrFrOrH)rJrHrkrzs r"rNz RMSF.__init__Qs<p #dD"9#5#@KKFKKK"r$ctj|jjdf|_|j|_dS)Nr)rrrHrW sumsquaresrrrs r"rz RMSF._prepares6(DN$:A#>??O((** r$c|j}|xj||dzz |jj|jz dzzz c_||jz|jjz|dzz |_dS)Ng?rr))rrrHr}rrJks r"rzRMSF._single_framesf   ASM N $ty 0 . ]T^%==!a%H r$c|j}tj|jd|dzz |j_|jjdkstddS)Nr))rrz9Some RMSF values negative; overflow or underflow occurred) rrrrrrrmsfr>rrs r" _concludezRMSF._concludesy  GDO$7$7Q$7$?$?1q5$IJJ  !Q&++-- *   r$cRd}tj|t|jjS)NzThe `rmsf` attribute was deprecated in MDAnalysis 2.0.0 and will be removed in MDAnalysis 3.0.0. Please use `results.rmsd` instead.)rrrrrrs r"rz RMSF.rmsfrr$) rrrrrr=rNrrrrrrrs@r"rr<s [y#y#y#y#y#v+++III!!X!!!!!r$r)NFF)rnumpyrloggingrlibrr analysis.baserr exceptionsrlib.utilrr r getLoggerrXr#r3r5rr:r$r"rs;.LLZ66666666''''''8888888888  5 6 6h5h5h5h5V///dj!j!j!j!j!<j!j!j!Zm!m!m!m!m!<m!m!m!m!m!r$