iHdZddlZddlZddlZddlmZddlm Z ddl m Z ddl m Z ddlmZdd lmZmZd d lmZGd d eZdZejededddddZejedddddZdS)a Principal Component Analysis (PCA) --- :mod:`MDAnalysis.analysis.pca` ===================================================================== :Authors: John Detlefs :Year: 2016 :Copyright: Lesser GNU Public License v2.1+ .. versionadded:: 0.16.0 This module contains the linear dimensions reduction method Principal Component Analysis (PCA). PCA sorts a simulation into 3N directions of descending variance, with N being the number of atoms. These directions are called the principal components. The dimensions to be analyzed are reduced by only looking at a few projections of the first principal components. To learn how to run a Principal Component Analysis, please refer to the :ref:`PCA-tutorial`. The PCA problem is solved by solving the eigenvalue problem of the covariance matrix, a :math:`3N \times 3N` matrix where the element :math:`(i, j)` is the covariance between coordinates :math:`i` and :math:`j`. The principal components are the eigenvectors of this matrix. For each eigenvector, its eigenvalue is the variance that the eigenvector explains. Stored in :attr:`PCA.results.cumulated_variance`, a ratio for each number of eigenvectors up to index :math:`i` is provided to quickly find out how many principal components are needed to explain the amount of variance reflected by those :math:`i` eigenvectors. For most data, :attr:`PCA.results.cumulated_variance` will be approximately equal to one for some :math:`n` that is significantly smaller than the total number of components. These are the components of interest given by Principal Component Analysis. From here, we can project a trajectory onto these principal components and attempt to retrieve some structure from our high dimensional data. For a basic introduction to the module, the :ref:`PCA-tutorial` shows how to perform Principal Component Analysis. .. _PCA-tutorial: PCA Tutorial ------------ The example uses files provided as part of the MDAnalysis test suite (in the variables :data:`~MDAnalysis.tests.datafiles.PSF` and :data:`~MDAnalysis.tests.datafiles.DCD`). This tutorial shows how to use the PCA class. First load all modules and test data:: import MDAnalysis as mda import MDAnalysis.analysis.pca as pca from MDAnalysis.tests.datafiles import PSF, DCD Given a universe containing trajectory data we can perform Principal Component Analysis by using the class :class:`PCA` and retrieving the principal components.:: u = mda.Universe(PSF, DCD) PSF_pca = pca.PCA(u, select='backbone') PSF_pca.run() Inspect the components to determine the principal components you would like to retain. The choice is arbitrary, but I will stop when 95 percent of the variance is explained by the components. This cumulated variance by the components is conveniently stored in the one-dimensional array attribute :attr:`PCA.results.cumulated_variance`. The value at the ith index of :attr:`PCA.results.cumulated_variance` is the sum of the variances from 0 to i.:: n_pcs = np.where(PSF_pca.results.cumulated_variance > 0.95)[0][0] atomgroup = u.select_atoms('backbone') pca_space = PSF_pca.transform(atomgroup, n_components=n_pcs) From here, inspection of the ``pca_space`` and conclusions to be drawn from the data are left to the user. Classes and Functions --------------------- .. autoclass:: PCA :members: :inherited-members: .. autofunction:: cosine_content .. autofunction:: rmsip .. autofunction:: cumulative_overlap N)tqdm)Universe)_fit_to) ProgressBar)util)dueDoi) AnalysisBaseceZdZdZdZ dfd ZdZdZdZe d Z e d Z e d Z e d Z e jd Z ddZddZejededddddZejedddddZxZS)PCAaPrincipal component analysis on an MD trajectory. After initializing and calling method with a universe or an atom group, principal components ordering the atom coordinate data by decreasing variance will be available for analysis. As an example::: pca = PCA(universe, select='backbone').run() pca_space = pca.transform(universe.select_atoms('backbone'), 3) generates the principal components of the backbone of the atomgroup and then transforms those atomgroup coordinates by the direction of those variances. Please refer to the :ref:`PCA-tutorial` for more detailed instructions. When using mean selections, the first frame of the selected trajectory slice is used as a reference. Parameters ---------- universe : Universe Universe select : string, optional A valid selection statement for choosing a subset of atoms from the atomgroup. align : boolean, optional If True, the trajectory will be aligned to a reference structure. mean : array_like, optional Optional reference positions to be be used as the mean of the covariance matrix. n_components : int, optional The number of principal components to be saved, default saves all principal components verbose : bool (optional) Show detailed progress of the calculation if set to ``True``. Attributes ---------- results.p_components: array, (n_atoms * 3, n_components) Principal components of the feature space, representing the directions of maximum variance in the data. The column vector p_components[:, i] is the eigenvector corresponding to the variance[i]. .. versionadded:: 2.0.0 p_components: array, (n_atoms * 3, n_components) Alias to the :attr:`results.p_components`. .. deprecated:: 2.0.0 Will be removed in MDAnalysis 3.0.0. Please use :attr:`results.p_components` instead. results.variance : array (n_components, ) Raw variance explained by each eigenvector of the covariance matrix. .. versionadded:: 2.0.0 variance : array (n_components, ) Alias to the :attr:`results.variance`. .. deprecated:: 2.0.0 Will be removed in MDAnalysis 3.0.0. Please use :attr:`results.variance` instead. results.cumulated_variance : array, (n_components, ) Percentage of variance explained by the selected components and the sum of the components preceding it. If a subset of components is not chosen then all components are stored and the cumulated variance will converge to 1. .. versionadded:: 2.0.0 cumulated_variance : array, (n_components, ) Alias to the :attr:`results.cumulated_variance`. .. deprecated:: 2.0.0 Will be removed in MDAnalysis 3.0.0. Please use :attr:`results.cumulated_variance` instead. Notes ----- Computation can be sped up by supplying precalculated mean positions. .. versionchanged:: 0.19.0 The start frame is used when performing selections and calculating mean positions. Previously the 0th frame was always used. .. versionchanged:: 1.0.0 ``n_components`` now limits the correct axis of ``p_components``. ``cumulated_variance`` now accurately represents the contribution of each principal component and does not change when ``n_components`` is given. If ``n_components`` is not None or is less than the number of ``p_components``, ``cumulated_variance`` will not sum to 1. ``align=True`` now correctly aligns the trajectory and computes the correct means and covariance matrix. .. versionchanged:: 2.0.0 ``mean_atoms`` removed, as this did not reliably contain the mean positions. ``mean`` input now accepts coordinate arrays instead of atomgroup. :attr:`p_components`, :attr:`variance` and :attr:`cumulated_variance` are now stored in a :class:`MDAnalysis.analysis.base.Results` instance. .. versionchanged:: 2.8.0 ``self.run()`` can now appropriately use ``frames`` parameter (bug described by #4425 and fixed by #4423). Previously, behaviour was to manually iterate through ``self._trajectory``, which would incorrectly handle cases where the ``frame`` argument was passed. FallNc tt|j|jfi|||_||_d|_||_||_||_ dS)NF) superr__init__ trajectory_ualign _calculated _n_components_select_mean)selfuniverseselectrmean n_componentskwargs __class__s a/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/analysis/pca.pyrz PCA.__init__s_ "c4!("5@@@@@  )  c|jd|j|j|_|j|j|_|jj|_|j(tj |jdf|_ d|_ nxtj |j|_ |j jd|jkr8td|j|j jdd|_ |jdkrtd|jdz}tj ||f|_|jj|_|j|_|xj|jzc_|j rt/|j|jd D]o}|jrL|j}t5|jj|z |j|j||j \}}|xj |jjz c_ p|xj |jzc_ tj|j |_dS) NrTzVNumber of atoms in reference ({}) does not match number of atoms in the selection ({})Fr zINo covariance information can be gathered from asingle trajectory frame. zMean Calculation)verbosedesc mobile_comref_com)_sliced_trajectoryr select_atomsr _reference_atomsn_atoms_n_atomsrnpzerosr _calc_meanasarrayshape ValueErrorformatn_framescov positions_ref_atom_positionscenter_of_geometry_ref_cogr_verboserrravel_xmean)rn_dimts mobile_cog mobile_atomsold_rmsds r!_preparez PCA._prepare s) ""'..t|<<g**4<88  + : $-!344DI"DOO 4:..DIyq!T]22 %%+VDM49?1;M%N%N $DO =A  -  !8UEN++#'?#< ::<<    DM1  ? '!' ' 3 3 :!%!?!?!A!AJ-4 - :0 #- $ ...*L( T[22 II &IIhty)) r"c|jrf|j}t|jj|z |j|j||j\}}|j}n|jj}||jz}|xj tj |ddtj f|ddtj fj z c_ dS)Nr')rr-r;rr9r:r<r>r?r8r0dotnewaxisT)rrBrCrDxs r! _single_framezPCA._single_frame=s : .7799J%, % 2( % &&& "L(&,,..AA %++--A T[ BF1QQQ ]+Qqqq"*}-=-?@@@r"c |xj|jdz zc_tj|j\}}tj|ddd}|||_|dd|f|_d|_|j |_ dS)Nr T) r8r7r0linalgeigargsort _variance _p_componentsrrr)re_valse_vectssort_idxs r! _concludez PCA._concludeNs DMA%%)--11:f%%ddd+)$QQQ[1 .r"cRd}tj|t|jjS)NzThe `p_components` attribute was deprecated in MDAnalysis 2.0.0 and will be removed in MDAnalysis 3.0.0. Please use `results.p_components` instead.)warningswarnDeprecationWarningresults p_componentsrwmsgs r!r\zPCA.p_componentsWs, 9  d.///|((r"cRd}tj|t|jjS)NzThe `variance` attribute was deprecated in MDAnalysis 2.0.0 and will be removed in MDAnalysis 3.0.0. Please use `results.variance` instead.)rXrYrZr[variancer]s r!r`z PCA.varianceas, 5  d.///|$$r"cRd}tj|t|jjS)NzThe `cumulated_variance` attribute was deprecated in MDAnalysis 2.0.0 and will be removed in MDAnalysis 3.0.0. Please use `results.cumulated_variance` instead.)rXrYrZr[cumulated_variancer]s r!rbzPCA.cumulated_varianceks, ?  d.///|..r"c|jSN)r)rs r!rzPCA.n_componentsus !!r"cD|jr|t|j}|jd||j_t j|jt j|jz d||j_|j ddd|f|j_ ||_ dSrd) rlenrQr[r`r0cumsumsumrbrRr\r)rns r!rzPCA.n_componentsys   By''$(N2A2$6DL ! $.))BF4>,B,BBqb/DL +)-(:111bqb5(ADL %r"c d|jstdt|tr|j}|j|jkr-td|j|j|jj |j k stj d|j j}||||\}}}t!t#|||}||n|jjjd} t+j|| f} t/t1||||| t!||||D]O\} } |j|jz } t+j| |jddd| f| | <P| S)aApply the dimensionality reduction on a trajectory Parameters ---------- atomgroup : AtomGroup or Universe The AtomGroup or Universe containing atoms to be PCA transformed. n_components : int, optional The number of components to be projected onto. The default ``None`` maps onto all components. start : int, optional The frame to start on for the PCA transform. The default ``None`` becomes 0, the first frame index. stop : int, optional Frame index to stop PCA transform. The default ``None`` becomes the total number of frames in the trajectory. Iteration stops *before* this frame number, which means that the trajectory would be read until the end. step : int, optional Include every `step` frames in the PCA transform. If set to ``None`` (the default) then every frame is analyzed (i.e., same as ``step=1``). verbose : bool, optional ``verbose = True`` option displays a progress bar for the iterations of transform. ``verbose = False`` disables the progress bar, just returns the pca_space array when the calculations are finished. Returns ------- pca_space : array, shape (n_frames, n_components) .. versionchanged:: 0.19.0 Transform now requires that :meth:`run` has been called before, otherwise a :exc:`ValueError` is raised. .. versionchanged:: 2.8.0 Transform now has shows a tqdm progressbar, which can be toggled on with ``verbose = True``, or off with ``verbose = False`` z,Call run() on the PCA before using transformz8PCA has been fit for{} atoms. Your atomgrouphas {} atomsz2Atom types do not match with types used to fit PCANr )disabletotal)rr5 isinstanceratomsr/r.r6r-typesrrXrYrrcheck_slice_indicesrfranger[r\r4r0r1r enumerater9r>r?rGrR)r atomgrouprstartstopstepr%trajr7dimrGirAxyzs r! transformz PCA.transforms` MKLL L i * * (!I =I- - -%vdmY5FGG   !Y_499;; P MN O O O!, 44UD$GGtTuUD$//00' L*03 h#'' d5d?+ , ,Kd5d?+,,    > >EAr %++-- ;CVC!3AAAttG!<==CFF r"c jstd|td| j}t j|j|jkrtdt jj|std j stdj j j z t jj jd\}}t j gt }j D]M}|t j||jkd } t j||j j| z }Nt jt j j j| )t jjjjd   fd } | S) aComputes a function to project structures onto selected PCs Applies Inverse-PCA transform to the PCA atomgroup. Optionally, calculates one displacement vector per residue to extrapolate the transform to atoms not in the PCA atomgroup. Parameters ---------- components : int, array, optional Components to be projected onto. The default ``None`` maps onto all components. group : AtomGroup, optional The AtomGroup containing atoms to be projected. The projection applies to whole residues in ``group``. The atoms in the PCA class are not affected by this argument. The default ``None`` does not extrapolate the projection to non-PCA atoms. anchor : string, optional The string to select the PCA atom whose displacement vector is applied to non-PCA atoms in a residue. The ``anchor`` selection is applied to ``group``.The resulting atomselection must have exactly one PCA atom in each residue of ``group``. The default ``None`` does not extrapolate the projection to non-PCA atoms. Returns ------- function The resulting function f(ts) takes as input a :class:`~MDAnalysis.coordinates.timestep.Timestep` ts, and returns ts with the projected structure .. warning:: The transformation function takes a :class:`Timestep` as input because this is required for :ref:`transformations`. However, the inverse-PCA transformation is applied on the atoms of the Universe that was used for the PCA. It is *expected* that the `ts` is from the same Universe but this is currently not checked. Notes ----- When the PCA class is run for an atomgroup, the principal components are cached. The trajectory can then be projected onto one or more of these principal components. Since the principal components are sorted in the order of decreasing explained variance, the first few components capture the essential molecular motion. If N is the number of atoms in the PCA group, each component has the length 3N. A PCA score :math:`w\_i`, along component :math:`u\_i`, is calculated for a set of coordinates :math:`(r(t))` of the same atoms. The PCA scores are then used to transform the structure, :math:`(r(t))` at a timestep, back to the original space. .. math:: w_{i}(t) = ({\textbf r}(t) - \bar{{\textbf r}}) \cdot {\textbf u}_i \\ {\textbf r'}(t) = (w_{i}(t) \cdot {\textbf u}_i^T) + \bar{{\textbf r}} For each residue, the projection can be extended to atoms that were not part of PCA by applying the displacement vector of a PCA atom to all the atoms in the residue. This could be useful to preserve the bond distance between a PCA atom and other non-PCA atoms in a residue. If there are r residues and n non-PCA atoms in total, the displacement vector has the size 3r. This needs to be broadcasted to a size 3n. An extrapolation trick is used to shape the array, since going over each residue for each frame can be expensive. Non-PCA atoms' displacement vector is calculated with fancy indexing on the anchors' displacement vector. `index_extrapolate` saves which atoms belong to which anchors. If there are two non-PCA atoms in the first anchor's residue and three in the second anchor's residue, `index_extrapolate` is [0, 0, 1, 1, 1] Examples -------- Run PCA class before using this function. For backbone PCA, run:: pca = PCA(universe, select='backbone').run() Obtain a transformation function to project the backbone trajectory onto the first principal component:: project = pca.project_single_frame(components=0) To project onto the first two components, run:: project = pca.project_single_frame(components=[0,1]) Alternatively, the transformation can be applied to PCA atoms and extrapolated to other atoms according to the CA atom's translation in each residue:: all = u.select_atoms('all') project = pca.project_single_frame(components=0, group=all, anchor='name CA') Finally, apply the transformation function to a timestep:: project(u.trajectory.ts) or apply the projection to the universe:: u.trajectory.add_transformations(project) .. versionadded:: 2.2.0 z'Call run() on the PCA before projectingNz2'anchor' cannot be 'None' if 'group' is not 'None'z(More than one 'anchor' found in residuesz0Some residues in 'group' do not have an 'anchor'z(Some 'anchors' are not part of PCA classT) return_counts)dtyperr c j}jjjz }t jt jt j|jddfjddfjjzdj_xjj|z z c_|S)zProjects a timestepN)rMr$) r9r-r>r?r0reshaperGrRrI) rAanchors_coords_oldrzanchors componentsgroupindex_extrapolatenon_pcars r!wrappedz)PCA.project_single_frame..wrappedws %,%6"+'--//$+=C$&JFsD$6qqq*}$EFF*111j=9;k "  % %DK ! !!g&7:L&L%&!!Ir")rr5r+ resindicesr0uniquesizeisinrissubsetr-residuesrnarrayintwhereresindexappendr.repeataranger[r\r4)rrranchoranchors_res_idspca_res_indicespca_res_counts non_pca_atomsresn_commonrrrrs``` @@@r!project_single_framezPCA.project_single_frames` HFGG G  ~ M((00G%0Oy))./2FFF !KLLL75+_==AACC  K##DK00 M !KLLLn*T[8G.0i &d/// +O^HRs333M~  )H_ <==!# !39#4x#?!! !#  '-/00-!!   4<#<#B1#EFFJ          .r"?10.1002/(SICI)1097-0134(19990901)36:4<419::AID-PROT5>3.0.CO;2-U10.1529/biophysj.104.052449RMSIPMDAnalysis.analysis.pca descriptionpathc> |jj}n#t$rtdwxYw |jj}nI#t$r<t |t |rtdtdwxYwt |j|j|S)aCompute the root mean square inner product between subspaces. This is only symmetric if the number of components is the same for both instances. The RMSIP effectively measures how correlated the vectors of this instance are to those of ``other``. Please cite [Amadei1999]_ and [Leo-Macias2004]_ if you use this function. Parameters ---------- other : :class:`~MDAnalysis.analysis.pca.PCA` Another PCA class. This must have already been run. n_components : int or tuple of ints, optional number of components to compute for the inner products. ``None`` computes all of them. Returns ------- float: Root mean square inner product of the selected subspaces. 0 indicates that they are mutually orthogonal, whereas 1 indicates that they are identical. Examples -------- .. testsetup:: >>> import MDAnalysis as mda >>> import MDAnalysis.analysis.pca as pca >>> from MDAnalysis.tests.datafiles import PSF, DCD >>> u = mda.Universe(PSF, DCD) You can compare the RMSIP between different intervals of the same trajectory. For example, to compare similarity within the top three principal components: .. doctest:: >>> first_interval = pca.PCA(u, select="backbone").run(start=0, stop=25) >>> second_interval = pca.PCA(u, select="backbone").run(start=25, stop=50) >>> last_interval = pca.PCA(u, select="backbone").run(start=75) >>> round(first_interval.rmsip(second_interval, n_components=3), 6) 0.381476 >>> round(first_interval.rmsip(last_interval, n_components=3), 6) 0.174782 See also -------- :func:`~MDAnalysis.analysis.pca.rmsip` .. versionadded:: 1.0.0 z(Call run() on the PCA before using rmsipz.Call run() on the other PCA before using rmsipother must be another PCA class)r)r[r\AttributeErrorr5rmtypermsiprI)rotherrabs r!rz PCA.rmsips| I )AA I I IGHH H I D *AA D D D%d,, D D!!BCCC  DQS!#L9999 ) :AB10.1016/j.str.2007.12.011Cumulative overlaprc@ |jj}n#t$rtdwxYw |jj}nI#t$r<t |t |rtdtdwxYwt |j|j||S)a)Compute the cumulative overlap of a vector in a subspace. This is not symmetric. The cumulative overlap measures the overlap of the chosen vector in this instance, in the ``other`` subspace. Please cite [Yang2008]_ if you use this function. Parameters ---------- other : :class:`~MDAnalysis.analysis.pca.PCA` Another PCA class. This must have already been run. i : int, optional The index of eigenvector to be analysed. n_components : int, optional number of components in ``other`` to compute for the cumulative overlap. ``None`` computes all of them. Returns ------- float: Cumulative overlap of the chosen vector in this instance to the ``other`` subspace. 0 indicates that they are mutually orthogonal, whereas 1 indicates that they are identical. See also -------- :func:`~MDAnalysis.analysis.pca.cumulative_overlap` .. versionadded:: 1.0.0 z5Call run() on the PCA before using cumulative_overlapz;Call run() on the other PCA before using cumulative_overlapr)ryr)r[r\rr5rmrcumulative_overlaprI)rrryrrrs r!rzPCA.cumulative_overlapsL  )AA   G    D *AA D D D%d,, D Q!!BCCC  D"!#qsalKKKKr)rFNN)NNNNF)NNNrdrN)__name__ __module__ __qualname____doc__%_analysis_algorithm_is_parallelizablerrErKrVpropertyr\r`rbrsetterr{rr dciter rr __classcell__)r s@r!rrsll\-2)   (2*2*2*hAAA"///))X)%%X%//X/""X"     TTTTlssssjSY  MNN  )** &  G:G:G:  G:RSY  '((( & 2L2L2L  2L2L2L2L2Lr"rcztjt|}t|}tjtj|z|dzz|z }d|z t j||dd|fzdzzt j|dd|fdzz S)a[Measure the cosine content of the PCA projection. The cosine content of pca projections can be used as an indicator if a simulation is converged. Values close to 1 are an indicator that the simulation isn't converged. For values below 0.7 no statement can be made. If you use this function please cite :footcite:p:`BerkHess2002`. Parameters ---------- pca_space : array, shape (number of frames, number of components) The PCA space to be analyzed. i : int The index of the pca_component projection to be analyzed. Returns ------- A float reflecting the cosine content of the ith projection in the PCA space. The output is bounded by 0 and 1, with 1 reflecting an agreement with cosine while 0 reflects complete disagreement. References ---------- .. footbibliography:: r g@Nr)r0rrfcospiscipy integratesimpson) pca_spacerytrIrs r!cosine_contentrs8 #i..!!A IA &a!e$q( ) )C q ? " "3111a4#8 9 9a ? @ / ! !)AAAqD/Q"6 7 7 8r"rrrrrctj|}t|dkr |dx}}n(t|dkr|\}}ntd|t|}|t|}t j|d||d|jdz}||z }|dzS)a+ Compute the root mean square inner product between subspaces. This is only symmetric if the number of components is the same for ``a`` and ``b``. The RMSIP effectively measures how correlated the vectors of ``a`` are to those of ``b``. Please cite [Amadei1999]_ and [Leo-Macias2004]_ if you use this function. Parameters ---------- a : array, shape (n_components, n_features) The first subspace. Must have the same number of features as ``b``. If you are using the results of :class:`~MDAnalysis.analysis.pca.PCA`, this is the TRANSPOSE of ``p_components`` (i.e. ``p_components.T``). b : array, shape (n_components, n_features) The second subspace. Must have the same number of features as ``a``. If you are using the results of :class:`~MDAnalysis.analysis.pca.PCA`, this is the TRANSPOSE of ``p_components`` (i.e. ``p_components.T``). n_components : int or tuple of ints, optional number of components to compute for the inner products. ``None`` computes all of them. Returns ------- float: Root mean square inner product of the selected subspaces. 0 indicates that they are mutually orthogonal, whereas 1 indicates that they are identical. Examples -------- .. testsetup:: >>> import MDAnalysis as mda >>> import MDAnalysis.analysis.pca as pca >>> from MDAnalysis.tests.datafiles import PSF, DCD >>> u = mda.Universe(PSF, DCD) You can compare the RMSIP between different intervals of the same trajectory. For example, to compare similarity within the top three principal components: .. doctest:: >>> first_interval = pca.PCA(u, select="backbone").run(start=0, stop=25) >>> second_interval = pca.PCA(u, select="backbone").run(start=25, stop=50) >>> last_interval = pca.PCA(u, select="backbone").run(start=75) >>> round(pca.rmsip(first_interval.results.p_components.T, ... second_interval.results.p_components.T, ... n_components=3), 6) 0.381476 >>> round(pca.rmsip(first_interval.results.p_components.T, ... last_interval.results.p_components.T, ... n_components=3), 6) 0.174782 .. versionadded:: 1.0.0 r rrz)Too many values provided for n_componentsN?)r asiterablerfr5r0matmulrIrh)rrrn_an_bsipmsips r!rr?sH?<00L <A O#cc \  a  SSDEEE {!ff {!ff )AdsdGQttWY ' '1 ,C 7799s?D 9r"rrct|jt|jkr|tjddf}||tjddf}|dzdz}|t|}|d|}|dzddz}tjtj||j||zz }|dzdzS)aRCompute the cumulative overlap of a vector in a subspace. This is not symmetric. The cumulative overlap measures the overlap of the chosen vector in ``a``, in the ``b`` subspace. Please cite [Yang2008]_ if you use this function. Parameters ---------- a : array, shape (n_components, n_features) or vector, length n_features The first subspace containing the vector of interest. Alternatively, the actual vector. Must have the same number of features as ``b``. b : array, shape (n_components, n_features) The second subspace. Must have the same number of features as ``a``. i : int, optional The index of eigenvector to be analysed. n_components : int, optional number of components in ``b`` to compute for the cumulative overlap. ``None`` computes all of them. Returns ------- float: Cumulative overlap of the chosen vector in ``a`` to the ``b`` subspace. 0 indicates that they are mutually orthogonal, whereas 1 indicates that they are identical. .. versionadded:: 1.0.0 Nrrr )axis)rfr4r0rHrhabsrrI)rrryrvecvec_normb_normsos r!rrsJ 17||c!'ll"" bj!!!m  A$rz111} CQ||~~$H1vv  -<-A!tjjaj  C'G ryac""##w'9:A qD::<<3 r"rdr)rrXnumpyr0scipy.integrater tqdm.autor MDAnalysisrMDAnalysis.analysis.alignrMDAnalysis.lib.logrlibrr r baser rrrrrr"r!rs0\\z------******R LR LR LR LR L,R LR LR Lj###L CIJJC%&& "  MMM  M` C#$$$ " ---  ---r"