aton 0.2.4__tar.gz → 0.3.0__tar.gz

{aton-0.2.4 → aton-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aton
-Version: 0.2.4
+Version: 0.3.0
 Summary: The Ab-iniTiO & Neutron research toolbox, or ATON, provides powerful and comprehensive tools for cutting-edge materials research, focused on (but not limited to) neutron science.
 Author: Pablo Gila-Herranz
 Author-email: pgila001@ikasle.ehu.eus

{aton-0.2.4 → aton-0.3.0}/aton/_version.py

@@ -10,5 +10,5 @@ https://semver.org/
 
 """
 
-__version__ = 'v0.2.4'
+__version__ = 'v0.3.0'
 

{aton-0.2.4 → aton-0.3.0}/aton/qrotor/__init__.py

@@ -97,25 +97,33 @@ qr.plot.energies(system)
 
 ## Tunnel splittings and excitations
 
-By default, energy eigenvalues are assumed to present triplet degeneracy,
-see [A. J. Horsewill, Progress in Nuclear Magnetic Resonance Spectroscopy 35, 359–389 (1999)](https://doi.org/10.1016/S0079-6565(99)00016-3).
-If this is not the case, check `aton.qrotor.solve.excitations()`.
-
-When the quantum System is solved, tunnel splittings and excitations are also calculated:
+When the quantum System is solved, tunnel splittings,
+excitations and energy level degeneracy
+below the potential maximum are also calculated:
 
 ```python
 system.solve()
 system.splittings
 system.excitations
+system.deg
 ```
 
-To export the tunnel splittings of several calculations to a CSV file:
+To export the energies and the tunnel splittings of several calculations to a CSV file:
 
 ```python
 calculations = [system1, system2, system3]
-qr.systems.splittings(calculations)
+qr.systems.save_energies(calculations)
+qr.systems.save_splittings(calculations)
 ```
 
+Excitations are calculated using the mean for each energy level
+with respect to the ground state.
+Tunnel splittings for each level are calculated as the difference between A and E,
+considering the mean of the eigenvalues for each sublevel.
+See [R. M. Dimeo, American Journal of Physics 71, 885–893 (2003)](https://doi.org/10.1119/1.1538575)
+and [A. J. Horsewill, Progress in Nuclear Magnetic Resonance Spectroscopy 35, 359–389 (1999)](https://doi.org/10.1016/S0079-6565(99)00016-3)
+for further reference.
+
 
 Check the API documentation for more details.
 

{aton-0.2.4 → aton-0.3.0}/aton/qrotor/plot.py

@@ -151,7 +151,7 @@ def reduced_energies(
 
     systems.as_list(data)
     title = title if title else (data[0].comment if data[0].comment else 'Reduced energies')
-    number_of_levels = data[0].E_levels
+    number_of_levels = data[0].searched_E
     x = []
     for system in data:
         potential_max_B = system.potential_max / system.B
@@ -198,7 +198,7 @@ def wavefunction(
     Specific wavefunctions can be overlapped with `overlap` as a list with the target indexes.
     The `overlap` value can also be the max number of wavefunctions to add.
     All found wavefunctions can be added together with `overlap = True`;
-    but note that this overlap is limited by the number of System.E_levels,
+    but note that this overlap is limited by the number of System.searched_E,
     that must be specified before solving the system.
     Setting `overlap` will ignore the `levels` argument.
 
@@ -258,7 +258,7 @@ def convergence(data:list) -> None:
     gridsizes = [system.gridsize for system in data]
     runtimes = [system.runtime for system in data]
     deviations = []  # List of lists, containing all eigenvalue deviations for every system
-    E_levels = data[0].E_levels
+    searched_E = data[0].searched_E
     for system in data:
         deviation_list = []
         for i, eigenvalue in enumerate(system.eigenvalues):
@@ -277,8 +277,8 @@ def convergence(data:list) -> None:
     ax2.set_ylabel('Runtime / s')
     ax2.set_yscale('log')
     ax2.plot(gridsizes, runtimes, color='tab:grey', label='Runtime', linestyle='--')
-    colors = plt.cm.viridis(np.linspace(0, 1, E_levels))  # Should be E_levels-1 but we want to avoid lighter colors
-    for i in range(E_levels-1):
+    colors = plt.cm.viridis(np.linspace(0, 1, searched_E))  # Should be searched_E-1 but we want to avoid lighter colors
+    for i in range(searched_E-1):
         if i % 2 == 0:  # Ignore even numbers, since those levels are degenerated.
             continue
         ax1.plot(gridsizes, [dev[i] for dev in deviations], label=f'$E_{{{int((i+1)/2)}}}$', color=colors[i])

aton-0.3.0/aton/qrotor/solve.py

@@ -0,0 +1,255 @@
+"""
+# Description
+
+This module is used to solve any given quantum system.
+
+Although the functions of this module can be used independently,
+it is highly recommended to use the `System.solve()` method instead,
+which does all the solving automatically (see `aton.qrotor.system.System.solve()`).
+This documentation page is left for reference and for advanced users.
+
+
+# Index
+
+| | |
+| --- | --- |
+| `energies()`              | Solve the quantum system, including eigenvalues and eigenvectors |
+| `potential()`             | Solve the potential values of the system |
+| `schrodinger()`           | Solve the Schrödiger equation for the system |
+| `hamiltonian_matrix()`    | Calculate the hamiltonian matrix of the system |
+| `laplacian_matrix()`      | Calculate the second derivative matrix for a given grid |
+| `excitations()`           | Get excitation levels and tunnel splitting energies |
+| `E_levels`                | Group a list of degenerated eigenvalues by energy levels |
+
+---
+"""
+
+
+from .system import System
+from .potential import solve as solve_potential
+from .potential import interpolate
+import time
+import numpy as np
+from scipy import sparse
+import aton
+from aton._version import __version__
+
+
+def energies(system:System, filename:str=None) -> System:
+    """Solves the quantum `system`.
+
+    This includes solving the potential, the eigenvalues and the eigenvectors.
+
+    The resulting System object is saved with pickle to `filename` if specified.
+    """
+    if not any(system.grid):
+        system.set_grid()
+    system = potential(system)
+    system = schrodinger(system)
+    if filename:
+        aton.st.file.save(system, filename)
+    return system
+
+
+def potential(system:System) -> System:
+    """Solves the potential values of the `system`.
+
+    It interpolates the potential if `system.gridsize` is larger than the current grid.
+    It solves the potential according to the potential name,
+    by calling `aton.qrotor.potential.solve()`.
+    Then it applies extra operations, such as removing the potential offset
+    if `system.correct_potential_offset = True`.
+    """
+    if system.gridsize and any(system.grid):
+        if system.gridsize > len(system.grid):
+            system = interpolate(system)
+    V = solve_potential(system)
+    if system.correct_potential_offset is True:
+        offset = min(V)
+        V = V - offset
+        system.potential_offset = offset
+    system.potential_values = V
+    return system
+
+
+def schrodinger(system:System) -> System:
+    """Solves the Schrödinger equation for a given `system`.
+    
+    Uses ARPACK in shift-inverse mode to solve the hamiltonian sparse matrix.
+    """
+    time_start = time.time()
+    V = system.potential_values
+    H = hamiltonian_matrix(system)
+    print('Solving Schrodinger equation...')
+    # Solve eigenvalues with ARPACK in shift-inverse mode, with a sparse matrix
+    eigenvalues, eigenvectors = sparse.linalg.eigsh(H, system.searched_E, which='LM', sigma=0, maxiter=10000)
+    if any(eigenvalues) is None:
+        print('WARNING:  Not all eigenvalues were found.\n')
+    else: print('Done.')
+    system.version = __version__
+    system.runtime = time.time() - time_start
+    system.eigenvalues = eigenvalues
+    system.potential_max = max(V)
+    system.potential_min = min(V)
+    system.energy_barrier = max(V) - min(eigenvalues)
+    # Solve excitations and tunnel splittings, assuming triplet degeneracy
+    system = excitations(system)
+    # Do we really need to save eigenvectors?
+    if system.save_eigenvectors == True:
+        system.eigenvectors = np.transpose(eigenvectors)
+    return system
+
+
+def hamiltonian_matrix(system:System):
+    """Calculates the Hamiltonian sparse matrix for a given `system`."""
+    print(f'Creating Hamiltonian matrix of size {system.gridsize}...')
+    V = system.potential_values.tolist()
+    potential = sparse.diags(V, format='lil')
+    B = system.B
+    x = system.grid
+    H = -B * laplacian_matrix(x) + potential
+    return H
+
+
+def laplacian_matrix(grid):
+    """Calculates the Laplacian (second derivative) matrix for a given `grid`."""
+    x = grid
+    diagonals = [-2*np.ones(len(x)), np.ones(len(x)), np.ones(len(x))]
+    laplacian_matrix = sparse.spdiags(diagonals, [0, -1, 1], format='lil')
+    # Periodic boundary conditions
+    laplacian_matrix[0, -1] = 1
+    laplacian_matrix[-1, 0] = 1
+    dx = x[1] - x[0]
+    laplacian_matrix /= dx**2
+    return laplacian_matrix
+
+
+def excitations(system: System) -> System:
+    """Calculate the excitation levels and the tunnel splitting energies of a system.
+
+    Automatically detects degenerated energy levels by looking at significant jumps
+    between consecutive eigenvalues. Within each level, finds two subgroups
+    to calculate tunnel splittings. Stops when energies reach the maximum potential.
+
+    Excitations are calculated as the energy difference between the mean energy of the
+    ground state level and the mean energy of each excited level.
+
+    Tunnel splittings are calculated as the difference between the medians of
+    the two subgroups within each degenerate level.
+    """
+    # Get eigenvalues, stop before any possible None value
+    eigenvalues = system.eigenvalues
+    if not isinstance(eigenvalues, (list, np.ndarray)) or len(eigenvalues) == 0:
+        return system
+    if None in eigenvalues:
+        none_index = eigenvalues.tolist().index(None)
+        eigenvalues = eigenvalues[:none_index]
+    if len(eigenvalues) < 3:
+        return system
+    # Group degenerated eigenvalues into energy levels
+    levels, degeneracy = E_levels(eigenvalues, system.potential_max)
+    system.E_levels = levels
+    system.deg = degeneracy
+    # Calculate excitations and splittings
+    ground_energy = np.mean(levels[0])  # Mean of ground state level
+    excitations = []
+    tunnel_splittings = []
+    for level in levels:
+        level_mean = np.mean(level)
+        excitations.append(level_mean - ground_energy)
+        # Get the tunnel splitting within the level
+        if len(level) > 1:
+            # Find the largest gap within the level to split into two subgroups
+            internal_gaps = np.diff(level)
+            split_idx = np.argmax(internal_gaps) + 1
+            # Split into two subgroups
+            subgroup1 = level[:split_idx]
+            subgroup2 = level[split_idx:]
+            # Medians of subgroups
+            median1 = np.median(subgroup1)
+            median2 = np.median(subgroup2)
+            # Tunnel splitting is the difference between medians
+            tunnel_splittings.append(abs(median2 - median1))
+        else:
+            tunnel_splittings.append(0)
+    system.excitations = excitations[1:]  # Exclude ground state
+    system.splittings = tunnel_splittings
+    return system
+
+
+def E_levels(eigenvalues, vmax:float=None) -> list:
+    """Group a list of degenerated eigenvalues by energy levels.
+
+    Automatically detects degenerated energy levels by
+    looking at significant jumps between consecutive eigenvalues.
+
+    An optional `vmax` can be specified,
+    to avoid including too many eigenvalues
+    above a certain potential maximum.
+    Only two more eigenvalues are considered after `vmax`,
+    to properly detect energy levels around the maximum.
+
+    Example:
+    ```python
+    levels, deg = qr.solve.E_levels(array([1.1, 1.2, 1.3, 5.4, 5.5, 5.6]))
+    levels  # [array([1.1, 1.2, 1.3]), array([5.4, 5.5, 5.6])]
+    deg  # 3
+    ```
+    """
+    if vmax:  # Include all eigenvalues below Vmax plus 3 more eigenvalues
+        index_first_above_Vmax = np.where(eigenvalues > vmax)[0][0]
+        eigenvalues = eigenvalues[:(index_first_above_Vmax + 2)]
+    # Group degenerated eigenvalues into energy levels
+    for scale in np.arange(2, 4, 0.25):  # First search going to bigger scales
+        levels, degeneracy = _get_E_levels_by_gap(eigenvalues, scale)
+        if (degeneracy > 1) and (degeneracy % 1 == 0):
+            break
+        else:
+            levels, degeneracy = None, None
+    if not degeneracy:  # If it didn't work, search with tighter values
+        for scale in np.arange(0.75, 2, 0.25):
+            levels, degeneracy = _get_E_levels_by_gap(eigenvalues, scale)
+            if (degeneracy > 1) and (degeneracy % 1 == 0):
+                break
+    if not (degeneracy > 1) and not (degeneracy % 1) == 0:
+        return levels, degeneracy  # I give up
+    # Correct the last two levels
+    if len(levels) >= 2 and len(levels[-2]) != degeneracy:
+        levels[-2] = np.concatenate((levels[-2], levels[-1]))
+        levels.pop(-1)
+    # Split last level into groups of size = degeneracy
+    last_level = levels[-1]
+    additional_levels = len(last_level) // degeneracy
+    if additional_levels > 0:
+        # Replace last level with list of complete degeneracy groups
+        complete_groups = [last_level[i:i+degeneracy] for i in range(0, additional_levels*degeneracy, degeneracy)]
+        levels.pop(-1)  # Remove original last level
+        levels.extend(complete_groups)  # Add all complete groups
+    else:
+        levels.pop(-1)  # Remove incomplete last level
+    return levels, degeneracy
+
+
+def _get_E_levels_by_gap(eigenvalues, scale:float=2) -> tuple:
+    """Split a list of eigenvalues into energy levels by looking at gaps.
+    
+    If the gap is bigger than the average gap times `scale`, it is considered a new level.
+
+    Returns a tuple with the estimated levels and the average degeneracy.
+    The last two levels are not taken into account to estimate the degeneracy.
+    """
+    # Find gaps between consecutive eigenvalues
+    gaps = np.diff(eigenvalues)
+    # Use mean gap times scale as threshold to distinguish energy levels
+    med_gap = np.mean(gaps)
+    level_breaks = np.where(gaps > scale * med_gap)[0] + 1
+    levels = np.split(eigenvalues, level_breaks)
+    # Calculate average degeneracy excluding last two levels if possible
+    if len(levels) > 2:
+        avg_degeneracy = float(np.mean([len(level) for level in levels[:-2]]))
+    else:
+        avg_degeneracy = float(len(levels[0]))
+    if avg_degeneracy % 1 == 0:
+        avg_degeneracy = int(avg_degeneracy)
+    return levels, avg_degeneracy
+

{aton-0.2.4 → aton-0.3.0}/aton/qrotor/system.py

@@ -25,7 +25,7 @@ class System:
             self,
             comment: str = None,
             group: str = 'CH3',
-            E_levels: int = 15,
+            searched_E: int = 21,
             correct_potential_offset: bool = True,
             save_eigenvectors: bool = True,
             gridsize: int = 200000,
@@ -43,8 +43,8 @@ class System:
         self.group: str = group
         """Chemical group, methyl or amine: `'CH3'`, `'CD3'`, `'NH3'`, `'ND3'`."""
         self.set_group(group)  # Normalise the group name, and set the value of B
-        self.E_levels: int = E_levels
-        """Number of energy levels to be studied."""
+        self.searched_E: int = searched_E
+        """Number of energy eigenvalues to be searched."""
         self.correct_potential_offset: bool = correct_potential_offset
         """Correct the potential offset as `V - min(V)` or not."""
         self.save_eigenvectors: bool = save_eigenvectors
@@ -82,19 +82,28 @@ class System:
         self.potential_max: float = None
         """`max(V)`"""
         # Energies
-        self.eigenvalues = []
-        """Calculated eigenvalues of the system. Should be in meV."""
         self.eigenvectors = []
         """Eigenvectors, if `save_eigenvectors` is True. Beware of the file size."""
+        self.eigenvalues = []
+        """Calculated eigenvalues of the system. In meV."""
+        self.E_levels: list = []
+        """List of `eigenvalues` grouped by energy levels, found below `potential_max`."""
+        self.deg: float = None
+        """Estimated degeneracy of the `E_levels` found below `potential_max`."""
+        self.excitations: list = []
+        """Torsional excitations, as the difference between each energy level with respect to the ground state.
+
+        Considers the means between degenerated eigenvalues for all energy levels below `potential_max`.
+        """
+        self.splittings: list = []
+        """Tunnel splitting energies, for every degenerated energy level.
+        
+        Calculated for all `E_levels` as the difference between
+        the mean of the eigenvalues from A and the mean of the eigenvalues from E,
+        see [R. M. Dimeo, American Journal of Physics 71, 885–893 (2003)](https://doi.org/10.1119/1.1538575).
+        """
         self.energy_barrier: float = None
         """Activation energy or energy barrier, from the ground torsional state to the top of the potential barrier, `max(V) - min(eigenvalues)`"""
-        self.excitations: list = None
-        """Torsional excitations, as eigenvalues with respect to the ground state.
-
-        Considers the lowest eigenvalue from each degenerated energy level.
-        """
-        self.splittings: list = None
-        """Tunnel splitting energies, for every degenerated energy level."""
         self.runtime: float = None
         """Time taken to solve the eigenvalues."""
 
@@ -113,8 +122,8 @@ class System:
     def change_phase(self, phase:float, calculate:bool=True):
         """Apply a phase shift to the grid and potential values.
 
-        The `phase` should be a multiple of $\pi$ (e.g., 3/2 for $3\pi/2$).
-        The resulting grid will be expressed between $-2\pi$ and $2\pi$.
+        The `phase` should be a multiple of $\\pi$ (e.g., 3/2 for $3\\pi/2$).
+        The resulting grid will be expressed between $-2\\pi$ and $2\\pi$.
 
         The System is solved immediately after the phase change.
         This last step ensures that all eigenvalues and wavefunctions are correct.

{aton-0.2.4 → aton-0.3.0}/aton/qrotor/systems.py

@@ -2,6 +2,7 @@
 # Description
 
 This module contains utility functions to handle multiple `aton.qrotor.system` calculations.
+These are commonly used as a list of `System` objects.
 
 
 # Index
@@ -9,14 +10,15 @@ This module contains utility functions to handle multiple `aton.qrotor.system` c
 | | |
 | --- | --- |
 | `as_list()`          | Ensures that a list only contains System objects |
+| `save_energies()`    | Save the energy eigenvalues for all systems to a CSV |
+| `save_splittings()`  | Save the tunnel splitting energies for all systems to a CSV |
 | `get_energies()`     | Get the eigenvalues from all systems |
 | `get_gridsizes()`    | Get all gridsizes |
 | `get_runtimes()`     | Get all runtimes |
 | `get_groups()`       | Get the chemical groups in use |
+| `get_ideal_E()`      | Calculate the ideal energy for a specified level |
 | `sort_by_gridsize()` | Sort systems by gridsize |
 | `reduce_size()`      | Discard data that takes too much space |
-| `get_ideal_E()`      | Calculate the ideal energy for a specified level |
-| `splittings()`       | Get the first tunnel splitting energies for all systems |
 
 ---
 """
@@ -45,8 +47,88 @@ def as_list(systems) -> None:
     return systems
 
 
+def save_energies(
+        systems:list,
+        comment:str='',
+        filepath:str='eigenvalues.csv',
+        ) -> pd.DataFrame:
+    """Save the energy eigenvalues for all `systems` to a eigenvalues.csv file.
+
+    Returns a Pandas Dataset with `System.comment` columns and `System.eigenvalues` values.
+
+    The output file can be changed with `filepath`,
+    or set to null to avoid saving the dataset.
+    A `comment` can be included at the top of the file.
+    Note that `System.comment` must not include commas (`,`).
+    """
+    as_list(systems)
+    version = systems[0].version
+    E = {}
+    # Find max length of eigenvalues
+    max_len = max((len(s.eigenvalues) if s.eigenvalues is not None else 0) for s in systems)
+    for s in systems:
+        if s.eigenvalues is not None:
+            # Filter out None values and replace with NaN
+            valid_eigenvalues = [float('nan') if e is None else e for e in s.eigenvalues]
+            padded_eigenvalues = valid_eigenvalues + [float('nan')] * (max_len - len(s.eigenvalues))
+        else:
+            padded_eigenvalues = [float('nan')] * max_len
+        E[s.comment] = padded_eigenvalues
+    df = pd.DataFrame(E)
+    if not filepath:
+        return df
+    # Else save to file
+    df.to_csv(filepath, sep=',', index=False)
+    # Include a comment at the top of the file
+    file_comment = f'# {comment}\n' if comment else f''
+    file_comment += f'# Energy eigenvalues\n'
+    file_comment += f'# Calculated with ATON {version}\n'
+    file_comment += f'# https://pablogila.github.io/ATON\n#'
+    txt.edit.insert_at(filepath, file_comment, 0)
+    print(f'Energy eigenvalues saved to {filepath}')
+    return df
+
+
+def save_splittings(
+    systems:list,
+    comment:str='',
+    filepath:str='tunnel_splittings.csv',
+    ) -> pd.DataFrame:
+    """Save the tunnel splitting energies for all `systems` to a tunnel_splittings.csv file.
+
+    Returns a Pandas Dataset with `System.comment` columns and `System.splittings` values.
+
+    The output file can be changed with `filepath`,
+    or set to null to avoid saving the dataset.
+    A `comment` can be included at the top of the file.
+    Note that `System.comment` must not include commas (`,`).
+    Different splitting lengths across systems are allowed - missing values will be NaN.
+    """
+    as_list(systems)
+    version = systems[0].version
+    tunnelling_E = {}
+    # Find max length of splittings
+    max_len = max(len(s.splittings) for s in systems)
+    for s in systems:  # Pad shorter splittings with NaN
+        padded_splittings = s.splittings + [float('nan')] * (max_len - len(s.splittings))
+        tunnelling_E[s.comment] = padded_splittings
+    df = pd.DataFrame(tunnelling_E)
+    if not filepath:
+        return df
+    # Else save to file
+    df.to_csv(filepath, sep=',', index=False)
+    # Include a comment at the top of the file 
+    file_comment = f'# {comment}\n' if comment else f''
+    file_comment += f'# Tunnel splitting energies\n'
+    file_comment += f'# Calculated with ATON {version}\n'
+    file_comment += f'# https://pablogila.github.io/ATON\n#'
+    txt.edit.insert_at(filepath, file_comment, 0)
+    print(f'Tunnel splitting energies saved to {filepath}')
+    return df
+
+
 def get_energies(systems:list) -> list:
-    """Get a list with all eigenvalues from all systems.
+    """Get a list with all lists of eigenvalues from all systems.
 
     If no eigenvalues are present for a particular system, appends None.
     """
@@ -100,25 +182,6 @@ def get_groups(systems:list) -> list:
     return groups
 
 
-def sort_by_gridsize(systems:list) -> list:
-    """Sorts a list of System objects by `System.gridsize`."""
-    as_list(systems)
-    systems = sorted(systems, key=lambda sys: sys.gridsize)
-    return systems
-
-
-def reduce_size(systems:list) -> list:
-    """Discard data that takes too much space.
-
-    Removes eigenvectors, potential values and grids,
-    for all System values inside the `systems` list.
-    """
-    as_list(systems)
-    for dataset in systems:
-        dataset = dataset.reduce_size()
-    return systems
-
-
 def get_ideal_E(E_level:int) -> int:
     """Calculates the ideal energy for a specified `E_level`.
 
@@ -133,36 +196,21 @@ def get_ideal_E(E_level:int) -> int:
     return ideal_E
 
 
-def splittings(
-        systems:list,
-        comment:str='',
-        filepath:str='tunnel_splittings.csv',
-        ) -> pd.DataFrame:
-    """Save the tunnel splitting energies for all `systems` to a tunnel_splittings.csv file.
+def sort_by_gridsize(systems:list) -> list:
+    """Sorts a list of System objects by `System.gridsize`."""
+    as_list(systems)
+    systems = sorted(systems, key=lambda sys: sys.gridsize)
+    return systems
 
-    Returns a Pandas Dataset with `System.comment` columns and `System.splittings` values.
 
-    The output file can be changed with `filepath`,
-    or set to null to avoid saving the dataset.
-    A `comment` can be included at the top of the file.
-    Note that `System.comment` must not include commas (`,`).
+def reduce_size(systems:list) -> list:
+    """Discard data that takes too much space.
+
+    Removes eigenvectors, potential values and grids,
+    for all System values inside the `systems` list.
     """
     as_list(systems)
-    version = systems[0].version
-    tunnelling_E = {}
-    for s in systems:
-        tunnelling_E[s.comment] = s.splittings
-    df = pd.DataFrame(tunnelling_E)
-    if not filepath:
-        return df
-    # Else save to file
-    df.to_csv(filepath, sep=',', index=False)
-    # Include a comment at the top of the file
-    file_comment = f'# {comment}\n' if comment else f''
-    file_comment += f'# Tunnel splitting energies\n'
-    file_comment += f'# Calculated with ATON {version}\n'
-    file_comment += f'# https://pablogila.github.io/ATON\n#'
-    txt.edit.insert_at(filepath, file_comment, 0)
-    print(f'Tunnel splitting energies saved to {filepath}')
-    return df
+    for dataset in systems:
+        dataset = dataset.reduce_size()
+    return systems
 

{aton-0.2.4 → aton-0.3.0}/aton.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: aton
-Version: 0.2.4
+Version: 0.3.0
 Summary: The Ab-iniTiO & Neutron research toolbox, or ATON, provides powerful and comprehensive tools for cutting-edge materials research, focused on (but not limited to) neutron science.
 Author: Pablo Gila-Herranz
 Author-email: pgila001@ikasle.ehu.eus

{aton-0.2.4 → aton-0.3.0}/tests/test_qrotor.py

@@ -3,6 +3,7 @@ import aton.interface as interface
 import aton.txt.extract as extract
 import aton.st.file as file
 import numpy as np
+import warnings
 
 
 folder = 'tests/samples/'
@@ -87,4 +88,6 @@ def test_phase():
     sys.change_phase(-1)
     assert round(sys.grid[0], 2) == round(-np.pi/2, 2)
     assert round(sys.potential_values[0], 2) == 0.5
+    # Were eigenvalues calculated?
+    assert len(sys.eigenvalues) > 0
 

aton-0.2.4/aton/qrotor/solve.py

@@ -1,172 +0,0 @@
-"""
-# Description
-
-This module is used to solve any given quantum system.
-
-Although the functions of this module can be used independently,
-it is highly recommended to use the `System.solve()` method instead,
-which does all the solving automatically (see `aton.qrotor.system.System.solve()`).
-However, advanced users might want to use some of these functions independently;
-for example, if your system energy levels are not degenerated in triplets,
-you might want to use `excitations()` to solve the energy excitations and tunnel splittings with the proper degeneracy.
-
-
-# Index
-
-| | |
-| --- | --- |
-| `energies()`              | Solve the quantum system, including eigenvalues and eigenvectors |
-| `potential()`             | Solve the potential values of the system |
-| `schrodinger()`           | Solve the Schrödiger equation for the system |
-| `hamiltonian_matrix()`    | Calculate the hamiltonian matrix of the system |
-| `laplacian_matrix()`      | Calculate the second derivative matrix for a given grid |
-| `excitations()`           | Get excitation levels and tunnel splitting energies for a set of eigenvalues |
-
----
-"""
-
-
-from .system import System
-from .potential import solve as solve_potential
-from .potential import interpolate
-import time
-import numpy as np
-from scipy import sparse
-import aton
-from aton._version import __version__
-
-
-def energies(system:System, filename:str=None) -> System:
-    """Solves the quantum `system`.
-
-    This includes solving the potential, the eigenvalues and the eigenvectors.
-
-    The resulting System object is saved with pickle to `filename` if specified.
-    """
-    if not any(system.grid):
-        system.set_grid()
-    system = potential(system)
-    system = schrodinger(system)
-    if filename:
-        aton.st.file.save(system, filename)
-    return system
-
-
-def potential(system:System) -> System:
-    """Solves the potential values of the `system`.
-
-    It interpolates the potential if `system.gridsize` is larger than the current grid.
-    It solves the potential according to the potential name,
-    by calling `aton.qrotor.potential.solve()`.
-    Then it applies extra operations, such as removing the potential offset
-    if `system.correct_potential_offset = True`.
-    """
-    if system.gridsize and any(system.grid):
-        if system.gridsize > len(system.grid):
-            system = interpolate(system)
-    V = solve_potential(system)
-    if system.correct_potential_offset is True:
-        offset = min(V)
-        V = V - offset
-        system.potential_offset = offset
-    system.potential_values = V
-    return system
-
-
-def schrodinger(system:System) -> System:
-    """Solves the Schrödinger equation for a given `system`.
-    
-    Uses ARPACK in shift-inverse mode to solve the hamiltonian sparse matrix.
-    """
-    time_start = time.time()
-    V = system.potential_values
-    H = hamiltonian_matrix(system)
-    print('Solving Schrodinger equation...')
-    # Solve eigenvalues with ARPACK in shift-inverse mode, with a sparse matrix
-    eigenvalues, eigenvectors = sparse.linalg.eigsh(H, system.E_levels, which='LM', sigma=0, maxiter=10000)
-    if any(eigenvalues) is None:
-        print('WARNING:  Not all eigenvalues were found.\n')
-    else: print('Done.')
-    system.version = __version__
-    system.runtime = time.time() - time_start
-    system.eigenvalues = eigenvalues
-    system.potential_max = max(V)
-    system.potential_min = min(V)
-    system.energy_barrier = max(V) - min(eigenvalues)
-    # Solve excitations and tunnel splittings, assuming triplet degeneracy
-    system = excitations(system, deg=3)
-    # Do we really need to save eigenvectors?
-    if system.save_eigenvectors == True:
-        system.eigenvectors = np.transpose(eigenvectors)
-    return system
-
-
-def hamiltonian_matrix(system:System):
-    """Calculates the Hamiltonian sparse matrix for a given `system`."""
-    print(f'Creating Hamiltonian matrix of size {system.gridsize}...')
-    V = system.potential_values.tolist()
-    potential = sparse.diags(V, format='lil')
-    B = system.B
-    x = system.grid
-    H = -B * laplacian_matrix(x) + potential
-    return H
-
-
-def laplacian_matrix(grid):
-    """Calculates the Laplacian (second derivative) matrix for a given `grid`."""
-    x = grid
-    diagonals = [-2*np.ones(len(x)), np.ones(len(x)), np.ones(len(x))]
-    laplacian_matrix = sparse.spdiags(diagonals, [0, -1, 1], format='lil')
-    # Periodic boundary conditions
-    laplacian_matrix[0, -1] = 1
-    laplacian_matrix[-1, 0] = 1
-    dx = x[1] - x[0]
-    laplacian_matrix /= dx**2
-    return laplacian_matrix
-
-
-def excitations(
-        system:System,
-        deg:int=3,
-        ) -> tuple:
-    """Calculate the excitation levels and the tunnel splitting energies of a system.
-
-    Stops the calculation when energies reach the maximum potential.
-    Assumes that eigenvalues are degenerated in triplets;
-    this degeneracy can be specified with `deg`.
-    """
-    eigenvalues = system.eigenvalues
-    V_max = system.potential_max
-    ground_energy = min(eigenvalues)
-    excitations = []
-    tunnel_splittings = []
-    i = 0
-    while (i + deg-1) <= len(eigenvalues):
-        # Get the eigenvalues corresponding to this triplet (or whatever degeneracy)
-        i_max = i + deg  # Index indicating the end of this triplet
-        triplet = eigenvalues[i:i_max]
-        # Check that we are still below the potential max
-        if any(triplet) > V_max:
-            break
-        # Check that all eigenvalues are valid, and not None
-        if any(triplet) is None:
-            break
-        # Get the excitation energy, by comparing with the ground state
-        if i != 0:  # Skip the ground energy level
-            excitations.append(min(triplet) - ground_energy)
-        # Check the energy differences inside each triplet (or whatever degeneracy)
-        E_diff = []
-        for j in range(deg-1):  # 0, 1 (not 2)
-            E_0 = triplet[j]
-            E_1 = triplet[j+1]
-            diff = E_1 - E_0
-            E_diff.append(diff)
-        # Get the maximum energy difference inside the triplet, which is the tunnel splitting
-        tunnel_splittings.append(max(E_diff))
-        # Move to the next triplet
-        i += deg
-    # Set the energy excitations and tunnel splittings
-    system.excitations = excitations
-    system.splittings = tunnel_splittings
-    return system
-