address some comments

desc/objectives/_bootstrap.py

@@ -68,15 +68,15 @@ class BootstrapRedlConsistency(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
     """

desc/objectives/_coils.py

@@ -61,15 +61,15 @@ class _CoilObjective(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -271,15 +271,15 @@ class CoilLength(_CoilObjective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -411,15 +411,15 @@ class CoilCurvature(_CoilObjective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -546,15 +546,15 @@ class CoilTorsion(_CoilObjective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -681,15 +681,15 @@ class CoilCurrentLength(CoilLength):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -824,15 +824,15 @@ class CoilSetMinDistance(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -1013,15 +1013,15 @@ class PlasmaCoilSetMinDistance(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -1258,15 +1258,15 @@ class QuadraticFlux(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
     """
@@ -1482,15 +1482,15 @@ class ToroidalFlux(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 

desc/objectives/_equilibrium.py

@@ -65,15 +65,15 @@ class ForceBalance(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
     """
@@ -251,15 +251,15 @@ class ForceBalanceAnisotropic(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -424,15 +424,15 @@ class RadialForceBalance(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -597,15 +597,15 @@ class HelicalForceBalance(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -768,15 +768,15 @@ class Energy(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``
 
 
@@ -950,15 +950,15 @@ class CurrentDensity(_Objective):
         Name of the objective function.
     jac_chunk_size : int, optional
         Will calculate the Jacobian for this objective ``jac_chunk_size``
-        columns at a time, instead of all at once.  The memory usage of the
+        columns at a time, instead of all at once. The memory usage of the
         Jacobian calculation is roughly ``memory usage = m0 + m1*jac_chunk_size``:
-        the higher the chunk size, the less memory the Jacobian calculation
+        the smaller the chunk size, the less memory the Jacobian calculation
         will require (with some baseline memory usage). The time to compute the
         Jacobian is roughly ``t=t0 +t1/jac_chunk_size``, so the larger the
         ``jac_chunk_size``, the faster the calculation takes, at the cost of
         requiring more memory. A ``jac_chunk_size`` of 1 corresponds to the least
-        memory intensive,  but slowest method of calculating the Jacobian.
-        If None, it will default to the largest possible
+        memory intensive, but slowest method of calculating the Jacobian.
+        If None, it will default to a conservative default
         `jac_chunk_size` i.e. ``np.ceil(dim_x/4)``