Mention aiida-pycce in docs

README.md

@@ -27,3 +27,5 @@ See the `examples` folder for tutorials and scripts of calculations.
 ### Documentation
 
 Full documentation is available online at [Read the Docs](https://pycce.readthedocs.io/en/latest/).
+
+See also [aiida-pycce](https://github.com/MICCoMpy/aiida-pycce), a plugin for running PyCCE in a high-throughput manner using the AiiDA framework.

docs/source/index.rst

@@ -43,23 +43,26 @@ PyCCE: A Python Package for CCE Simulations
 **PyCCE** is an open source Python library to simulate the dynamics of
 a spin qubit interacting with a spin bath using the cluster-correlation expansion (CCE) method.
 
+**PyCCE** supports parallelization through mpi4py, and high-throughput
+workflows through `aiida-pycce <https://github.com/MICCoMpy/aiida-pycce>`_.
 
 Major Updates
 -----------------------------
 
 PyCCE 1.1
 ++++++++++++++++++
-New version of **PyCCE** includes new cluster solvers and a set of little bugfixes. Main changes include
+**PyCCE** 1.1 has been released!
+Main changes include:
 
 * Implementation of the master equation-based CCE approaches.
-    Checkout the :doc:`tutorials/mecce` for examples of the usage.
+    Check out :doc:`tutorials/mecce` for examples of the usage.
 
 * Various optimization and bugfixes.
 
 PyCCE 1.0
 ++++++++++++++++++
-The **PyCCE** 1.0 has been released!
-Main changes from the previous version include:
+**PyCCE** 1.0 has been released!
+Main changes include:
 
 * Support for several central spins with the new class ``CenterArray``!
     Check out a tutorial :doc:`tutorials/second_spin` on how to use the new class to study the decoherence
@@ -75,8 +78,8 @@ Main changes from the previous version include:
 * *EXPERIMENTAL FEATURE*. Added ability to define your own single particle Hamiltonian.
     See ``BathArray.h`` and ``Center.h`` in :doc:`bath` and :doc:`center` respectively for further details.
 
-* Significant overhaul of computational expensive parts of the code with Numba. This makes the first run of
-  **PyCCE** quite slow, but after compilation it should run observably faster.
+* Significant overhaul of computational expensive parts of the code with Numba. This introduces a
+  performance overhead to the first run, but after compilation it should run observably faster.
 
 * Various bug fixes and QoL changes.
 
@@ -89,12 +92,11 @@ The recommended way to install **PyCCE** is to use **pip**::
 
     $ pip install pycce
 
-Otherwise you can install  **PyCCE** directly using the source code.
-First copy the repository to the desired folder::
+Otherwise you can install **PyCCE** directly using the source code.
+First clone the repository::
 
     $ git clone https://github.com/MICCoMpy/PyCCE.git
 
-
 Then, execute **pip** in the folder containing **pyproject.toml**::
 
     $ pip install .
@@ -103,7 +105,7 @@ Requirements
 ----------------
 The following modules are required to run **PyCCE**.
 
-*  `Python <http://www.python.org/>`_ (version >= 3.9).
+* `Python <http://www.python.org/>`_ (version >= 3.9).
 
 * `NumPy <https://numpy.org/>`_ (version >= 1.16).
 
@@ -116,11 +118,11 @@ The following modules are required to run **PyCCE**.
 * `Pandas <https://pandas.pydata.org/>`_.
 
 **PyCCE** inherently supports parallelization with the **mpi4py** package, which requires the installation of MPI.
-However, for serial implementation the **mpi4py** is not required.
+**mpi4py** is not required for serial calculations.
 
 How to cite
 --------------------------
 If you make use of **PyCCE** in a scientific publication, please cite the following paper:
 
-   Mykyta  Onizhuk and Giulia Galli. "PyCCE: A Python Package for Cluster Correlation Expansion Simulations of Spin Qubit Dynamic"
+   Mykyta Onizhuk and Giulia Galli. "PyCCE: A Python Package for Cluster Correlation Expansion Simulations of Spin Qubit Dynamic"
    Adv. Theory Simul. 2021, 2100254 https://onlinelibrary.wiley.com/doi/10.1002/adts.202100254

docs/source/quickstart.rst

@@ -3,7 +3,7 @@ Quick Start
 ===================================================================
 
 The generic workflow of the simulation includes first the generation of the spin bath in the material,
-and second carrying the CCE dynamics calculations for the qubit interacting with this spin bath.
+and second performing the CCE dynamics calculations for the qubit interacting with this spin bath.
 
 Base Units
 -------------------------------------------------------------------
@@ -58,15 +58,15 @@ The simplest example includes the following steps:
    The hyperfine couplings are automatically generated at this step assuming point dipole-dipole interactions
    between central spin and bath spins.
 
-4. Compute the coherence function of the qubit using ``.compute`` method of the ``Simulator`` object with
+4. Compute the coherence function of the qubit using the ``compute`` method of the ``Simulator`` object with
    conventional CCE.
 
    .. literalinclude:: tutorials/nv_simple.py
       :language: python
       :lines: 11, 12
 
-This function outputs Numpy array with the same shape as the ``time_points`` and
+This function outputs a Numpy array with the same shape as the ``time_points`` and
 contains the coherence function computed at each time step.
-By default ``compute`` method uses the conventional CCE to compute the coherence function.
+By default ``compute`` uses the conventional CCE to compute the coherence function.
 
-More detailed examples of **PyCCE** usage are available in the tutorials.
+More detailed examples of using **PyCCE** are available in the tutorials.

docs/source/theory.rst

@@ -67,7 +67,7 @@ Usually, two coherence times are measured to characterize the loss of a qubit co
 :math:`T_2` describes a purely quantum phenomenon - the loss of the phase of the qubit's superposition state.
 
 In the pure dephasing regime (:math:`T_1 >> T_2`) the decoherence of the central spin is completely determined
-by the decay of the off diagonal element of the density matrix of the qubit.
+by the decay of the off-diagonal element of the density matrix of the qubit.
 
 Namely, if the qubit is initially prepared in the
 :math:`\left|{\psi}\right\rangle = \frac{1}{\sqrt{2}}(\left|{0}\right\rangle+e^{i\phi}\left|{1}\right\rangle)` state,
@@ -83,8 +83,7 @@ levels is characterized by the coherence function:
 Where :math:`\hat{\rho}_S(t)` is the density matrix of the central spin and
 :math:`\left|{0}\right\rangle` and :math:`\left|{1}\right\rangle` are qubit levels.
 
-The cluster correlation expansion (CCE) method was first introduced in ref. [#yang2008]_.
-The core idea of the CCE approach is that the spin bath-induced decoherence
+The CCE method was first introduced in ref. [#yang2008]_. The core idea is that the spin bath-induced decoherence
 can be factorized into set of irreducible contributions from the bath spin clusters.
 Written in terms of the coherence function:
 
@@ -121,7 +120,7 @@ in CCE3 - up to triplets of bath spins are included, etc.
 The way the coherence function for each cluster
 is computed slightly varies between depending on whether the conventional or generalized CCE method is used.
 
-In the case of the several central spins, one can apply CCE formalism to compute any off-diagonal element of the
+In the case of several central spins, one can apply the CCE formalism to compute any off-diagonal element of the
 combined density matrix.
 
 Conventional CCE
@@ -146,7 +145,7 @@ the coherence function of the qubit interacting with the cluster :math:`C` is co
 
     L_{C}(t) = Tr[\hat U_C^{(0)}(t)\hat \rho_C \hat U_C^{(1) \dagger}(t)]
 
-Where :math:`\hat U_C^{(\alpha)}(t)` is time propagator defined in terms of the effective Hamiltonian
+Where :math:`\hat U_C^{(\alpha)}(t)` is a time propagator defined in terms of the effective Hamiltonian
 :math:`\hat H_C^{(\alpha)}` and the number of decoupling pulses. Note that :math:`\hat H_C^{(\alpha)}` here includes
 only degrees of freedom of the given cluster.
 

docs/source/tutorial.rst

@@ -1,11 +1,11 @@
 Tutorials
 ===================
 
-The examples below are available as Jupyter notebooks in the Github repository.
+The examples below are available as Jupyter notebooks in the GitHub repository.
 
 .. toctree::
    :maxdepth: 1
-   :caption: Examples of using pyCCE Code
+   :caption: Examples of using PyCCE
 
    tutorials/diamond_nv
    tutorials/sic_vv
@@ -15,18 +15,18 @@ The examples below are available as Jupyter notebooks in the Github repository.
    tutorials/mecce
 
 
-The recommended order of the tutorials is from the top to bottom:
+The recommended order of the tutorials is:
 
-* :doc:`tutorials/diamond_nv` example goes through the :doc:`quickstart` example in more details.
-* :doc:`tutorials/sic_vv` tutorial explores the difference between
+* :doc:`tutorials/diamond_nv` goes through the :doc:`quickstart` example in more details.
+* :doc:`tutorials/sic_vv` explores the difference between
   generalized CCE with and without random bath state sampling.
-  Also, in this example we introduce the way to work with DFT output of hyperfine tensors.
-* :doc:`tutorials/si_shallow` example shows the way to include the custom hyperfine couplings for more
+  Also, in this example we introduce the way to work with hyperfine tensors computed from DFT.
+* :doc:`tutorials/si_shallow` shows how to include custom hyperfine couplings for more
   delocalized defects in semiconductors.
-* :doc:`tutorials/classical_noise` example explains the way to use autocorrelation function of the noise
+* :doc:`tutorials/classical_noise` explains how to use autocorrelation function of the noise
   to predict the decay of the coherence of the NV center in diamond.
-* :doc:`tutorials/second_spin` example goes over the systems with two central spins, either forming a hybrid qubit,
-  or system of two entangled qubits.
-* :doc:`tutorials/mecce` example provides details on the master-eqation based solvers ME-CCE and ME-gCCE.
+* :doc:`tutorials/second_spin` goes over systems with two central spins, either forming a hybrid qubit,
+  or two entangled qubits.
+* :doc:`tutorials/mecce` provides details on the master-eqation based solvers ME-CCE and ME-gCCE.