dipolmol 1.1.1__tar.gz

dipolmol-1.1.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: dipolmol
+Version: 1.1.1
+Summary: DiPolMol: tools for calculating molecular dipole moments, polarisabilities, and Hamiltonians
+License: MIT
+Keywords: quantum physics,molecular physics,dipole moment,polarizability,AMO physics,CaF
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: scipy>=1.9
+Requires-Dist: sympy>=1.11
+Requires-Dist: matplotlib>=3.6
+
+DiPolMol-Py
+===========
+A Python package to calculate the rotational and hyperfine structure of doublet-Sigma molecules (e.g., CaF, BaF, SrF) in the presence of external fields.
+
+DiPolMol-Py is licensed under a BSD 3 clause license, a copy can be found `See the [LICENSE](LICENSE) file'.
+If you use our work for academic purposes you can cite us using:
+
+ B.Humphreys *et al.* DiPolMol-Py: A Python package for calculations for $^{2}{\Sigma}$ ground-state molecules (https://arxiv.org/pdf/2503.21663).
+
+Installation
+----------
+
+run: pip install dipolmol
+
+This installs the latest stable release and all required dependencies.
+
+Package structure
+-------------
+**Programme Files:**
+
+*Hamiltonian* – used to build the required Hamiltonian using matrix representation, including the field-free Hamiltonian and in the presence of magnetic, dc electric and off-resonant light fields.
+
+*Calculate* – uses the eigenstates and eigenenergies found from diagonalising the Hamiltonian to run various calculations. Can be used to identify quantum numbers of eigenstates, calculate transition dipole moments and polarisabilities.
+
+*Constants* – includes all known  constants for CaF, BaF and SrF.
+
+**Examples:**
+
+There are three example files for calculating the energy structure in the presence of a magnetic, off-resonant light and electric field (*example_Bfield, example_ac_Efield, example_dc_Efield*). 
+
+There are two files to calculate the electric and magnetic moments of states (*example_electric_moment, example_magnetic_moment*). 
+
+We provide *example_polarisability* to calculate the polarisability for a given wavelength and polarisation of light. 
+
+Finally, *example_tdm* can be used to calculate the transition dipole moment.
+
+Example
+-------
+.. code-block:: python
+
+	import numpy as np
+	import dipolmol.hamiltonian as hamiltonian
+	import dipolmol.calculate as calc
+	from dipolmol.constants import SrF
+	
+	Nmax=4 #Identify the maximum N 
+	H0,H_B,H_dc,H_ac 
+		= hamiltonian.build
+			(Nmax,SrF,zeeman=True,Edc=False
+              ,Eac=False) 
+
+	B = np.linspace(0,100,5000)*1e-4 #Tesla
+	
+	H = H_0[..., None] + H_B[..., None]*B
+	H = H.transpose(2,0,1)
+	
+	energies, states, label_list = 
+       calc.solve(H, Nmax, SrF,label=True, B)
+
+Resulting plot of above code
+
+.. image:: Images/zeeman_SrF_plot.png
+  :width: 400
+  :alt: Resulting plot of above example
+
+For more examples of usage, see the ``./Examples`` module.

dipolmol-1.1.1/README.md

@@ -0,0 +1,66 @@
+DiPolMol-Py
+===========
+A Python package to calculate the rotational and hyperfine structure of doublet-Sigma molecules (e.g., CaF, BaF, SrF) in the presence of external fields.
+
+DiPolMol-Py is licensed under a BSD 3 clause license, a copy can be found `See the [LICENSE](LICENSE) file'.
+If you use our work for academic purposes you can cite us using:
+
+ B.Humphreys *et al.* DiPolMol-Py: A Python package for calculations for $^{2}{\Sigma}$ ground-state molecules (https://arxiv.org/pdf/2503.21663).
+
+Installation
+----------
+
+run: pip install dipolmol
+
+This installs the latest stable release and all required dependencies.
+
+Package structure
+-------------
+**Programme Files:**
+
+*Hamiltonian* – used to build the required Hamiltonian using matrix representation, including the field-free Hamiltonian and in the presence of magnetic, dc electric and off-resonant light fields.
+
+*Calculate* – uses the eigenstates and eigenenergies found from diagonalising the Hamiltonian to run various calculations. Can be used to identify quantum numbers of eigenstates, calculate transition dipole moments and polarisabilities.
+
+*Constants* – includes all known  constants for CaF, BaF and SrF.
+
+**Examples:**
+
+There are three example files for calculating the energy structure in the presence of a magnetic, off-resonant light and electric field (*example_Bfield, example_ac_Efield, example_dc_Efield*). 
+
+There are two files to calculate the electric and magnetic moments of states (*example_electric_moment, example_magnetic_moment*). 
+
+We provide *example_polarisability* to calculate the polarisability for a given wavelength and polarisation of light. 
+
+Finally, *example_tdm* can be used to calculate the transition dipole moment.
+
+Example
+-------
+.. code-block:: python
+
+	import numpy as np
+	import dipolmol.hamiltonian as hamiltonian
+	import dipolmol.calculate as calc
+	from dipolmol.constants import SrF
+	
+	Nmax=4 #Identify the maximum N 
+	H0,H_B,H_dc,H_ac 
+		= hamiltonian.build
+			(Nmax,SrF,zeeman=True,Edc=False
+              ,Eac=False) 
+
+	B = np.linspace(0,100,5000)*1e-4 #Tesla
+	
+	H = H_0[..., None] + H_B[..., None]*B
+	H = H.transpose(2,0,1)
+	
+	energies, states, label_list = 
+       calc.solve(H, Nmax, SrF,label=True, B)
+
+Resulting plot of above code
+
+.. image:: Images/zeeman_SrF_plot.png
+  :width: 400
+  :alt: Resulting plot of above example
+
+For more examples of usage, see the ``./Examples`` module.

dipolmol-1.1.1/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dipolmol"
+version = "1.1.1"
+description = "DiPolMol: tools for calculating molecular dipole moments, polarisabilities, and Hamiltonians"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+
+
+keywords = [
+  "quantum physics",
+  "molecular physics",
+  "dipole moment",
+  "polarizability",
+  "AMO physics",
+  "CaF"
+]
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+
+dependencies = [
+  "numpy>=1.23",
+  "scipy>=1.9",
+  "sympy>=1.11",
+  "matplotlib>=3.6",
+]
+
+# ---------------- setuptools config ---------------- #
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

dipolmol-1.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dipolmol-1.1.1/src/dipolmol/calculate.py

@@ -0,0 +1,405 @@
+from . import hamiltonian as hamiltonian
+from .constants import CaF
+
+import numpy as np
+import scipy.constants
+from sympy.physics.wigner import wigner_3j as sympy_wig_3j
+from sympy.physics.wigner import wigner_6j as sympy_wig_6j
+import matplotlib.pyplot as plt
+###############################################################################
+# Start by definining a bunch of constants that are needed for the code       #
+###############################################################################
+
+'''
+    Important note!
+
+    All units in this code are SI i.e. elements in the Hamiltonian have units
+    of Joules. Outputs will be on the order of 1e-30
+
+'''
+
+h = scipy.constants.h
+muN = scipy.constants.physical_constants['nuclear magneton'][0]
+bohr = scipy.constants.physical_constants['Bohr radius'][0]
+epsilon_0 = scipy.constants.epsilon_0
+c = scipy.constants.c
+
+#Defining Wigner symbols to ensure on float errors
+def wigner_3j(a, b, c, d, e, f):
+    a = float(a)
+    b = float(b)
+    c = float(c)
+    d = float(d)
+    e = float(e)
+    f = float(f)
+    return sympy_wig_3j(a,b,c,d,e,f)
+
+def wigner_6j(a, b, c, d, e, f):
+    a = float(a)
+    b = float(b)
+    c = float(c)
+    d = float(d)
+    e = float(e)
+    f = float(f)
+    return sympy_wig_6j(a,b,c,d,e,f)
+
+#Frequencies of each vibrational transition needed for polarisability calculation
+def XXfreq(v1,v2,consts):
+    f = 100*c*(consts['XT'][v2]+2*consts['XB'][v2] - consts['XT'][v1]) 
+    return f
+def XAfreq(Xv,Av,Omega,consts):
+    f = 100*c*(consts['AT'][Av]+consts['AA'][Av]*(Omega-1) - consts['XT'][Xv])
+    return f
+def XBfreq(Xv,Bv,consts):
+    f = 100*c*consts['BT'][Bv] - consts['XT'][Xv]
+    return f
+
+
+
+
+def alpha_012(l, consts):
+    '''Calculates the polarisability of the X(v=0) state for a given wavelength l.
+    
+    Args: 
+        l (float): Wavelength at which to calculate the polarisability at. (m)
+        consts (dict): Dictionary of constants for the molecule to be calculated.
+        
+    Returns:
+        alpha (list): List containing alpha_0, alpha_1 and alpha_2, the scalar, vector 
+        and tensor components of molecular polarisability respectively.'''
+        
+    f=c/(l*10**-9)
+    XXmu = consts['d0']
+    XXvibmu = consts['XXvibmu']
+    XAmu = consts['XAmu']
+    XBmu = consts['XBmu']
+    XAfc = consts['XAfc']
+    XBfc = consts['XBfc']
+    #There are three alpha terms: alpha parallel (Sigma overlap) and alpha perpendicular (Pi overlap for both Omega values)
+    parallel_terms = [[XXfreq(0,0,consts),XXmu],[XXfreq(0,1,consts),XXvibmu],[XBfreq(0, 0,consts),XBmu*(XBfc[0][0]**0.5)]]
+    perp_terms1 = [[XAfreq(0,0,0.5,consts), XAmu*(XAfc[0][0]**0.5)],[XAfreq(0,1,0.5,consts), XAmu*(XAfc[0][1]**0.5)]]
+    perp_terms3 = [[XAfreq(0,0,1.5,consts), XAmu*(XAfc[0][0]**0.5)],[XAfreq(0,1,1.5,consts), XAmu*(XAfc[0][1]**0.5)]]
+    a_par = 0
+    a_perp1 = 0
+    a_perp3 = 0
+    for i in range(len(parallel_terms)):
+        a_par += 1/h*(1/(parallel_terms[i][0]+f)+1/(parallel_terms[i][0]-f))*parallel_terms[i][1]**2
+    for i in range(len(perp_terms1)):
+        a_perp1 += 1/h*(1/(perp_terms1[i][0]+f)+1/(perp_terms1[i][0]-f))*perp_terms1[i][1]**2
+        a_perp3 += 1/h*(1/(perp_terms3[i][0]+f)+1/(perp_terms3[i][0]-f))*perp_terms3[i][1]**2
+    alpha_0 = 1/3*(a_par+a_perp1+a_perp3)*10**4/(2*c*epsilon_0)*10**-4
+    alpha_1 = 1/2*(f/XAfreq(0,0,0.5,consts)*a_perp1-f/XAfreq(0,0,1.5,consts)*a_perp3)*10**4/(2*c*epsilon_0)*10**-4
+    alpha_2 = 1/3*(2*a_par - a_perp1 - a_perp3)*10**4/(2*c*epsilon_0)*10**-4
+    return [alpha_0,alpha_1, alpha_2]
+
+
+def dipole(Nmax,Consts,M):
+    ''' Generates the induced dipole moment operator for a Rigid rotor.
+    Expanded to cover state vectors in the uncoupled hyperfine basis.
+
+    Args:
+        Nmax (int): maximum rotational states.
+        Consts (dict): Dictionary of constants for the molecule to be calculated.
+        M (float): index indicating the helicity of the dipole field. -1 = S+, 0 = Pi, +1 = S-
+
+    Returns:
+        Dmat (np.ndarray): - dipole matrix
+    '''
+
+
+    I = Consts['I']
+    S = Consts['S']
+    Ishape = int(2*I+1)
+    Sshape = int(2*S+1)
+    shape = np.sum(np.array([2*x+1 for x in range(0,Nmax+1)]))
+    dmat = np.zeros((shape,shape),dtype= complex)
+    dmat = (np.kron(dmat,np.kron(np.identity(Ishape),
+                                                    np.identity(Sshape))))
+    i=0
+    j=0
+    
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    for N2 in range(0,Nmax+1):
+                        for J2 in np.arange(np.abs(N2-S),(N2+S+1),1):
+                            for F2 in np.arange(J2-I,(J2+I+1),1):
+                                for mF2 in np.arange(-F2,+(F2+1),1):
+                                    dmat[i,j] = np.round((-1+0j)**(F2-mF2+J1+J2+F1+N2+1))*\
+                                        ((2*F1+1)*(2*F2+1)*(2*J1+1)*(2*J2+1))**0.5*((2*N1+1)*(2*N2+1))**0.5*(-1)**N2*wigner_3j(N2,1,N1,0,0,0)*\
+                                           wigner_3j(F2,1,F1,-mF2,M,mF1)*wigner_6j(J1,F1,I,F2,J2,1)*wigner_6j(N1,J1,0.5,J2,N2,1)
+                                    
+                                    i+=1
+                    i=0
+                    j+=1
+
+    
+    return dmat
+
+    
+def transition_dipole_moment(Nmax,Consts,M,states,gs,locs=None):
+    ''' Function to calculate the Transition Dipole Moment between a state gs
+    and a range of states. Returns the TDM in units of the permanent dipole
+    moment (d0).
+
+    Args:
+        Nmax (int): Maximum rotational quantum number in original calculations
+        Consts (dict): Dictionary of constants for the molecule to be calculated
+        M (float): Helicity of Transition, -1 = S+, 0 = Pi, +1 = S-
+        States (np.ndarray): matrix for eigenstates of problem output from np.linalg.eig
+        gs (int): index of ground state.
+
+    kwargs:
+        locs (list of ints): optional argument to calculate for subset of States, should be an
+                array-like.
+
+    Returns:
+        TDM (list of floats): transition dipole moment between gs and States.
+    
+    '''
+    states = states[0]
+    dipole_op = dipole(Nmax,Consts,M)
+
+    gs = np.conj(states[:,gs])
+    if locs != None :
+        states =  states[:,locs]
+
+    tdm =  np.einsum('i,ij,jk->k',gs,dipole_op,states).real
+
+    return tdm
+
+
+def magnetic_moment(States, Nmax, Consts):
+    '''Returns the magnetic moments of each eigenstate.
+    
+    Args:
+        States (np.ndarray): matrix for eigenstates of problem output from np.linalg.eig
+        Nmax (int): Maximum rotational quantum number in original calculations
+        Consts (dict): Dictionary of constants for the molecule to be calculated
+        
+    Returns:
+        mu (list of floats): magnetic moment for each eigenstate in States.
+        
+    '''
+    
+    muz = -1*hamiltonian.H_zee(Nmax,Consts,Consts['I'],Consts['S'])
+    
+    mu =np.einsum('ijk,jl,ilk->ik',
+            np.conjugate(States),muz,
+            States)
+    return mu
+
+
+def electric_moment(States, Nmax, Consts):
+    '''Returns the electric dipole moments of each eigenstate
+    
+    Args:
+        States (np.ndarray): matrix for eigenstates of problem output from np.linalg.eig
+        Nmax (int): Maximum rotational quantum number in original calculations
+        Consts (dict): Dictionary of constants for the molecule to be calculated
+        
+    Returns:
+        d (list of floats): electric dipole moment for each eigenstate in States
+    '''
+    
+    dz = -1*hamiltonian.H_dc(Nmax,Consts,Consts['I'],Consts['S'])
+    
+    d =np.einsum('ijk,jl,ilk->ik',
+            np.conjugate(States),dz,
+            States)
+    return d
+
+
+
+def sort_smooth(energy, states):
+    ''' Sort states to remove false avoided crossings.
+    This is a function to ensure that all eigenstates plotted change
+    adiabatically, it does this by assuming that step to step the eigenstates
+    should vary by only a small amount (i.e. that the  step size is fine) and
+    arranging states to maximise the overlap one step to the next.
+    
+    Args:
+        Energy (np.ndarray) : np.ndarray containing the eigenergies, as from np.linalg.eig
+        States (np.ndarray): np.ndarray containing the states, in the same order as Energy
+    Returns:
+        Energy (np.ndarray) : np.ndarray containing the eigenergies, as from np.linalg.eig
+        States (np.ndarray): np.ndarray containing the states, in the same order as Energy E[x,i] -> States[x,:,i]
+    '''
+    ls = np.arange(states.shape[2],dtype="int") #from 0 to number of states
+    
+    number_iterations = len(energy[:,0]) #ie the number of B field values
+    
+    for i in range(2, number_iterations): 
+        '''
+        This loop sorts the eigenstates such that they maintain some
+        continuity. Each eigenstate should be chosen to maximise the overlap
+        with the previous.
+        '''
+        #calculate the overlap of the ith and jth eigenstates
+        overlaps = np.einsum('ij,ik->jk',
+                                np.conjugate(states[i-1,:,:]),states[i,:,:])     
+        orig2 = states[i,:,:].copy() 
+        orig1 = energy[i,:].copy()
+        #insert location of maximums into array ls
+        np.argmax(np.abs(overlaps),axis=1,out=ls)
+        
+        for k in range(states.shape[2]): 
+            l = ls[k] 
+            if l!=k:
+                energy[i,k] = orig1[l].copy()
+                states[i,:,k] = orig2[:,l].copy()
+    return energy, states
+
+
+
+
+
+def label_FmF_states(States, Nmax, consts, B):
+    """
+    Function that takes the array of eigenstates as generated from the hamiltonian 
+    (and processed with sort_smooth to avoid false avoided crossings) and assigns 
+    each an (N, F, mF) label.
+    
+    Inputs:
+        States (np.ndarray) : np.ndarray containing the eigenstates, as from np.linalg.eig
+        Nmax (int) : Maximum N state to consider in the calculations
+        B (int/float/list/array) : Magnetic field values used to calculate the eigenstates
+        consts (dict): Dictionary of constants for the molecule to be calculated
+        
+    Returns:
+        FmF_labels or F_labels (list): list of [N, F, mF] or [N, F] labels, one for each of the eigenstates in the input
+    """
+    
+    S = consts['S']
+    I= consts['I']
+    
+    #initialise error counters to 0
+    zeromagfielderror = 0
+    F_error = 0
+    mF_error = 0
+    
+    startingstateindex = 0
+    
+    #check the B fields input by the user, select a non-zero B field to label at
+    if type(B) == float or type(B) == int:
+        States = States[0]
+        if B == 0:
+            zeromagfielderror += 1
+    else:
+        if B[0] != 0:
+            States = States[0]  
+        else:
+            if len(States) > 1:
+                States = States[1] 
+                startingstateindex += 1
+            else:
+                States = States[0]
+                zeromagfielderror += 1
+
+    
+
+    #generate a list of the possible (N, J, F, mF) states 
+    statelist = []
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    state = [N1, J1, F1, mF1]
+                    statelist.append(state)
+    
+    FmF_labels = []
+    F_labels = []
+    
+    #now match the (N,J,F,mF) labels with the eigenstates
+    for i in range(len(States)): #For each of the eigenstates
+        statebreakdown = []
+        for n in range(len(States)): #loop through each value in the eigenstate
+            if np.round(States[:,i][n],1) != 0: #consider the non-zero coeff
+                statebreakdown.append(statelist[n]) 
+                #following can be useful to check states
+                #print(f'{States[:,i][n]} coeff of {statelist[n]}' )
+                
+        #Confirming consistency in the F,mF labelling of the states
+        if len(statebreakdown) > 1: #only do this if there are multiple (F,mF) states to consider
+            avgF = np.mean(statebreakdown, axis=0)[2]
+            avgmF = np.mean(statebreakdown, axis=0)[3]
+            
+            if avgF != statebreakdown[0][2] or statebreakdown[0][2] != statebreakdown[1][2]:
+                F_error += 1
+                
+            if avgmF != statebreakdown[0][3] or statebreakdown[0][3] != statebreakdown[1][3]:
+                mF_error += 1
+                F_labels.append([int(statebreakdown[0][0]), int(statebreakdown[0][2])])
+                
+            if avgF == statebreakdown[0][2] and statebreakdown[0][2] == statebreakdown[1][2] and avgmF == statebreakdown[0][3] and statebreakdown[0][3] == statebreakdown[1][3]:
+                FmF_labels.append([int(statebreakdown[0][0]), int(statebreakdown[0][2]), int(statebreakdown[0][3])])
+                F_labels.append([int(statebreakdown[0][0]), int(statebreakdown[0][2])])
+                
+        else: #if we are only considering one state
+            FmF_labels.append([int(statebreakdown[0][0]), int(statebreakdown[0][2]), int(statebreakdown[0][3])])
+            F_labels.append([int(statebreakdown[0][0]), int(statebreakdown[0][2])])
+    
+    
+    #Various error messages 
+    if zeromagfielderror != 0:
+        if mF_error != 0 and F_error == 0:
+            print('mF labelling failed as attempted to label at zero magnetic field: please input a non-zero magnetic field. Returning N,F labels instead.')
+        if F_error != 0:
+            print('mF, F labelling failed as attempted to label at too high a magnetic field: please input a smaller starting magnetic field value.')
+    else:
+        if F_error != 0:
+            if startingstateindex == 0:
+                print('mF, F labelling failed as attempted to label at too high a magnetic field: please input a smaller starting magnetic field value.')
+            else:
+                print('mF, F labelling failed as attempted to label at too high a magnetic field: please reduce the spacing between your input magnetic field values. Alternatively, start plotting at a small, non-zero magnetic field.')
+        if mF_error != 0 and F_error ==0:
+            if startingstateindex == 0:
+                print('mF labelling failed as attempted to label at too high a magnetic field: please input a smaller starting magnetic field value. Returning N,F labels instead.')
+            else:
+                print('mF labelling failed as attempted to label at too high a magnetic field: please reduce the spacing between your input magnetic field values. Alternatively, start plotting at a small, non-zero magnetic field. Returning N,F labels instead.')
+       
+    
+    if F_error == 0 and mF_error == 0:
+        return FmF_labels
+    if F_error == 0 and mF_error != 0:
+        return F_labels
+    if F_error != 0:
+        return None
+
+
+
+
+def solve(H, Nmax, consts, label, B=None):
+    """Function that combines the diagonalisation of the Hamiltonian generated by the
+    hamiltonian.build method, and the sorting of the states performed by the 
+    calculate.sort_smooth function. Generates the sorted set of eigenstates and 
+    eigenenergies for the given Hamiltonian.
+    
+    Inputs:
+        H (np.ndarray): Hamiltonian to generate the eigenstates and eigenenergies for,
+                        as generated by hamiltonian.build method.
+        Nmax (int): Maximum rotational state to consider in the calculations.
+        consts (dict): Dictionary of constants for the molecule to be calculated
+        B (list/array): Magnetic field values used to calculate the eigenstates
+        label (boolean): If True, return the F, mF state labels for the eigenstates
+    """
+    #generate the eigenenergies and eigenstates
+    energies, states = np.linalg.eigh(H)
+    #apply sort_smooth to the eigenstates to maintain consistency with the labelling
+    energies, states = sort_smooth(energies, states)	
+    
+    if label:
+        if type(B) == float or type(B) == int or type(B) == list or type(B) == np.ndarray:
+            #ie if a suitable type of B value is provided
+            label_list = label_FmF_states(states, Nmax, consts, B)
+        
+            return energies, states, label_list  
+        
+        else:
+            print('Please provide magnetic field value(s) to label at.')
+            return energies, states, None
+            
+        
+    else:
+        return energies, states

dipolmol-1.1.1/src/dipolmol/constants.py

@@ -0,0 +1,106 @@
+import scipy.constants
+import numpy as np
+
+###############################################################################
+# Molecular Constants
+###############################################################################
+#Here are some starting dictionaries for various molecules. 
+#References given, but check up to date if precision needed!
+e = scipy.constants.e
+h = scipy.constants.h
+muN = scipy.constants.physical_constants['nuclear magneton'][0]
+muB = scipy.constants.physical_constants['Bohr magneton'][0]
+bohr = scipy.constants.physical_constants['Bohr radius'][0]
+eps0 = scipy.constants.epsilon_0
+a0 = scipy.constants.physical_constants['atomic unit of length'][0]
+c = scipy.constants.c
+DebyeSI = 3.33564e-30
+inv_cm_to_Hz = 100*c
+
+CaF = {"I":0.5,
+       "S":0.5,
+       "d0": 1.02041*10**-29,#3.07*DebyeSI,
+       "Brot":10267.5387*10**6*h,
+       "Drot":0.01406*10**6*h,
+       "gamma": 39.65891*10**6*h,
+       "b" : 109.1839*10**6*h,
+       "c": 40.119*10**6*h,
+       "CC": 28.76*10**3*h,
+       "MuS": 2.002*muB,
+       "MuL": -1.86*10**-3*muB, #10.1103/PhysRevLett.124.063001
+       "MuN": 5.585*muN,
+       "MuR": -5.13*10**-5*muB, #10.1103/PhysRevLett.124.063001
+       "alpha_0":1.4*10**-3*h, #h*Hz/(W/m^2) at 780 nm calculated in Caldwell2020 https://arxiv.org/abs/1910.10689 NB these are alpha/2ce_0
+       "alpha_1":3*10**-5*h,
+       "alpha_2":-8*10**-4*h,
+       "Beta":0,#angle of polarisation for polarisability function
+       #Transition dipole moments
+       "XXvibmu" : 0.0999*e*a0, #
+       "XAmu" : 2.03*1e-29,#2.3439*e*a0, #P. J. Dagdigian, H. W. Cruse, and R. N. Zare, J. Chem. Phys. 60, 2330 (1974).
+       "XBmu" : 1.71*e*a0, #   P. J. Dagdigian, H. W. Cruse, and R. N. Zare, J. Chem. Phys. 60, 2330 (1974).
+       #FC factors from M. Pelegrini, C. S. Vivacqua, O. Roberto-Neto, F. R. Ornellas, and F. B. Machado.  Braz. J. Phys. 35.4 A (2005), pp. 950–956. X-A
+       # X-B M. Dulick, P. F. Bernath, and R. W. Field. Can. J. Phys. 58.5 (1980), pp. 703–712.
+       "XAfc" : [[0.964,0.036,0],[0.035,0.895,0.07],[0.001,0.065,0.83]],
+       "XBfc" : [[9.992*10**-1,7.27*10**-4,3.809*10**-5],[7.396*10**-4,9.973*10**-1,1.814*10**-3],[2.473*10**-5,1.873*10**-3,9.945*10**-1]],
+       #Terms for vibrational transitions [v=0,1,2] Journal of Molecular Spectroscopy 197, 289–296 (1999)
+       #Only need for v=0 in X and B, and then V=0,1 in A
+       #In cm^-1
+       "XT" : np.array([0,582.8478,1159.9473]), #electronic splitting
+       "XB" : np.array([0.34248818,0.34005359, 0.33762897]),#rotational constants
+       "AT" : np.array([16529.653,17118.103,17700.49]), #electronic splitting
+       "AA" : np.array([71.491, 71.614, 71.737]), #Lambda doubling
+       "BT" : np.array([18832.031, 19398.254, 19958.276]), #electronic splitting
+       "BB" : np.array([0.341058, 0.338469, 0.335903]), # rotational constants
+       }
+
+BaF = {"I":0.5,
+       "S":0.5,
+       "d0": 1.05739e-29,#3.17*DebyeSI,
+       "Brot":6473.9586572e6*h,# from PRA 94, 063415 (2016) https://journals.aps.org/pra/pdf/10.1103/PhysRevA.94.063415
+       "Drot":5.5296816e3*h,#1085*10**7*29979.2458*h,
+       "gamma": 80.95547199999999e6*h,
+       "b" : 63.509e6*h,
+       "c": 8.224e6*h,
+       "CC": 0,
+       "MuS": 2.002*muB,
+       "MuL": -0.028*muB,#Where did I get this?
+       "MuN": 5.585*muN,
+       "MuR" : 0,
+       #"alpha_0":,
+       #"alpha_1":,
+       #"alpha_2":,
+       "Beta":0 #angle of polarisation for polarisability function
+       }
+
+
+SrF = {"I": 0.5,
+       "S": 0.5,
+       "d0": 3.4963*DebyeSI,
+       "Brot": 7487.6*10**6*h,
+       "Drot":0.0075*10**6*h,
+       "gamma": 74.795*10**6*h,
+       "b" : 97.0827*10**6*h,
+       "c":30.2675*10**6*h,
+       "CC": 0.0023*10**6*h,
+       "MuS": 2.002*muB, # g_s * muB
+       "MuN": 5.585*muN,
+       "MuL": -4.97*10**-3*muB, #10.1103/PhysRevLett.124.063001
+       "MuR": -4.77*10**-5*muB, #10.1103/PhysRevLett.124.063001
+       "Beta":0, #angle of polarisation for polarisability function
+       #Transition dipole moments
+       "XXvibmu" : 0.0999*e*a0, #MISSING
+       "XAmu" : 2.45*e*a0, #P. J. Dagdigian, H. W. Cruse, and R. N. Zare, J. Chem. Phys. 60, 2330 (1974).
+       "XBmu" : 1.94*e*a0, #   Berg, L. E. et al. Chem. Phys. Lett. 248, (1996)
+       #FC factors from Hao et al. J. Chem. Phys. 151, 034302 (2019)
+       "XAfc" : [[0.9789,0.02054,4*10**-4],[0.02102,0.9377,0.03969],[2.72*10**-5,4.158*10**-2,8.978*10**-1]],
+       "XBfc" : [[9.961*10**-1,3.866*10**-3,3.604*10**-6],[3.856*10**-3,9.881*10**-1,8*10**-3],[1.343*10**-5,7.959*10**-3,9.796*10**-1]],
+       #Terms for vibrational transitions [v=0,1,2] - for v=0 find in J. Barry thesis table 2.6
+       "XT" : np.array([0,0,0])*inv_cm_to_Hz, #electronic splitting
+       "XB" : np.array([7.4876,7.44123,7.395])*10**9,#rotational constants J. Barry thesis table 2.8
+       
+       "AT" : np.array([15072.09,0,0])*inv_cm_to_Hz, #electronic splitting
+       "AA" : np.array([281.46138,0,0])*inv_cm_to_Hz, #Lambda doubling
+       
+       "BT" : np.array([17267.41,0,0])*inv_cm_to_Hz, #electronic splitting
+       "BB" : np.array([0.249396,0,0])*inv_cm_to_Hz, # rotational constants
+       }

dipolmol-1.1.1/src/dipolmol/hamiltonian.py

@@ -0,0 +1,422 @@
+import numpy as np
+from sympy.physics.wigner import wigner_3j as sympy_wig_3j
+from sympy.physics.wigner import wigner_6j as sympy_wig_6j
+
+from sympy import KroneckerDelta
+from scipy.linalg import block_diag
+import scipy.constants
+from scipy.special import sph_harm
+import matplotlib.pyplot as plt
+'''
+This module contains the main code to calculate the hyperfine structure of
+singlet -sigma molecules. In usual circumstances most of the functions within
+are not user-oriented.
+
+Example:
+    Basic usage of this module is for accessing the eigenstates and
+    eigenvalues of the molecule in question. This is most easily done
+    by combining this module with the user's favourite linear algebra module.
+    For instance to find the zero-field hyperfine states of Molecule::
+
+        $ from diatom import Hamiltonian
+        $ from np import linalg as la
+        $ H0,Hz,HDC,HAC = Hamiltonian.Build_Hamiltonians(5,Molecule)
+        $ ev,es = la.eigh(H0)
+'''
+
+
+###############################################################################
+# Start by definining constants that are needed for the code                  #
+###############################################################################
+
+'''
+    Important note!
+
+    All units in this code are SI i.e. elements in the Hamiltonian have units
+    of Joules. Outputs will be on the order of 1e-30
+
+'''
+
+h = scipy.constants.h
+muN = scipy.constants.physical_constants['nuclear magneton'][0]
+bohr = scipy.constants.physical_constants['Bohr radius'][0]
+eps0 = scipy.constants.epsilon_0
+c = scipy.constants.c
+pi = np.pi
+
+DebyeSI = 3.33564e-30
+""" Conversion factor from debyes to J/V/m """
+
+###############################################################################
+# Functions for the calculations to use                                       #
+###############################################################################
+
+def wigner_3j(a, b, c, d, e, f):
+    a = float(a)
+    b = float(b)
+    c = float(c)
+    d = float(d)
+    e = float(e)
+    f = float(f)
+    return sympy_wig_3j(a,b,c,d,e,f)
+
+def wigner_6j(a, b, c, d, e, f):
+    a = float(a)
+    b = float(b)
+    c = float(c)
+    d = float(d)
+    e = float(e)
+    f = float(f)
+    return sympy_wig_6j(a,b,c,d,e,f)
+
+def wigner_D(l, m, alpha, beta, gamma):
+    ''' The Wigner D matrix with labels l and m.
+
+    Calculates the Wigner D Matrix for the given Alpha,beta,gamma in radians.
+    The wigner-D matrices represent rotations of angular momentum operators.
+    The indices l and m determine the value of the matrix.
+    The second index (m') is always zero.
+
+    The input angles are the x-z-x euler angles
+
+    Args:
+        l (int) : order of wigner Matrix
+        m (float): first index of Wigner Matrix
+        alpha,beta,gamma (float) : x,z,x Euler angles in radians
+    Returns:
+        D (float) : Value of the wigner-D matrix
+    '''
+    prefactor = np.sqrt((4*np.pi)/(2*l+1))
+    function = np.conj(sph_harm(m,l,alpha,beta))
+    return prefactor*function
+
+
+def H_rot(Nmax,consts,I,S):
+    ''' Calculates <N,J,F,mF| H_rot |N',J',F', mF'>. The rotational hamiltonian H_rot
+        is diagonal in this basis, and this function iterates over N, J, F, mF, N',
+        J', F', mF' to build a matrix and evaluate the diagonal elements.
+        This function is based off Jesus Aldegunde's FORTRAN 77 code. 
+    
+        Args:
+            Nmax (int): Maximum rotational quantum number to calculate.
+            I (float): Nuclear spin. We only consider molecules where one consistuent
+                       atom has no nuclear spin, so this is the non zero I of the other.
+            S (float): Electronic spin.
+            consts (dict): Dictionary of constants for the molecule to be calculated.
+    
+        Returns:
+            H (np.ndarray): Hamiltonian in joules
+     '''
+    Ishape = int(2*I+1)
+    Sshape = int(2*S+1)
+    shape = np.sum(np.array([2*x+1 for x in range(0,Nmax+1)]))
+    H_ROT = np.zeros((shape,shape), dtype= complex)
+    H_ROT = (np.kron(H_ROT,np.kron(np.identity(Ishape),
+                                                    np.identity(Sshape))))
+    
+    i=0
+    j=0
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    for N2 in range(0,Nmax+1):
+                        for J2 in np.arange(np.abs(N2-S),(N2+S+1),1):
+                            for F2 in np.arange(J2-I,(J2+I+1),1):
+                                for mF2 in np.arange(-F2,+(F2+1),1):
+                                    
+                                    
+                                    H_ROT[i,j]= consts['Brot']*(N1*(N1+1))*KroneckerDelta(N1,N2)*\
+                                        KroneckerDelta(J1,J2)*KroneckerDelta(F1,F2)*KroneckerDelta(mF1,mF2)+\
+                                            consts['Drot']*(N1*(N1+1))**2*KroneckerDelta(N1,N2)*\
+                                                KroneckerDelta(J1,J2)*KroneckerDelta(F1,F2)*KroneckerDelta(mF1,mF2)
+                                                
+                                            
+                                    i+=1
+                    i=0
+                    j+=1
+                    
+    #final check for NaN errors, mostly this is due to division by zero or
+    # multiplication by a small prefactor. it is safe to set these terms to 0
+    H_ROT[np.isnan(H_ROT)] =0
+
+    #return the matrix, in the full coupled basis.
+
+    return H_ROT
+
+
+def H_hf(Nmax,consts,I,S):
+    ''' Calculates <N,J,F,mF| H_hf |N',J',F', mF'> by iterating over N, J, F, mF, N',
+        J', F', mF' to build a matrix and evaluate the elements.
+        This function is based off Jesus Aldegunde's FORTRAN 77 code. 
+    
+        Args:
+    
+            Nmax (int) - maximum rotational quantum number to calculate
+            I (float): Nuclear spin. We only consider molecules where one consistuent
+                       atom has no nuclear spin, so this is the non zero I of the other.
+            S (float): Electronic spin.
+            consts (dict): Dictionary of constants for the molecule to be calculated.
+    
+        Returns:
+            H (np.ndarray): Hamiltonian in joules
+     '''
+     
+    Ishape = int(2*I+1)
+    Sshape = int(2*S+1)
+    shape = np.sum(np.array([2*x+1 for x in range(0,Nmax+1)]))
+    H_HF = np.zeros((shape,shape),dtype= complex)
+    H_HF = (np.kron(H_HF,np.kron(np.identity(Ishape),
+                                                    np.identity(Sshape))))
+    
+    i=0
+    j=0
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    for N2 in range(0,Nmax+1):
+                        for J2 in np.arange(np.abs(N2-S),(N2+S+1),1):
+                            for F2 in np.arange(J2-I,(J2+I+1),1):
+                                for mF2 in np.arange(-F2,+(F2+1),1):
+                                    H_HF[i,j]= consts['gamma']/2*(J1*(J1+1)-N1*(N1+1)-S*(S+1))*KroneckerDelta(N1,N2)*\
+                                        KroneckerDelta(J1,J2)*KroneckerDelta(F1,F2)*KroneckerDelta(mF1,mF2)+\
+                                            (consts['b']+consts['c']/3)*(np.round((-1+0j)**(J1+J2+F1+N1),0)*\
+                                                KroneckerDelta(N1,N2)*KroneckerDelta(F1,F2)*KroneckerDelta(mF1,mF2)*\
+                                                    3/2*((2*J2+1)*(2*J1+1))**0.5*wigner_6j(F1,0.5,J2,1,J1,0.5)*\
+                                                        wigner_6j(0.5, J2, N1, J1, 0.5, 1)) +\
+                                                10**0.5*consts['c']*np.round((-1+0j)**(J1+F1+N2+0.5),0)*KroneckerDelta(F1,F2)*KroneckerDelta(mF1,mF2)*\
+                                                    ((2*N2+1)*(2*N1+1)*(2*J2+1)*(2*J1+1))**0.5*wigner_6j(F1,0.5,J2,1,J1,0.5)*\
+                                                        wigner_6j(J2,J1,1,0.5,1.5,N1)*wigner_6j(N1,N2,2,0.5,1.5,J2)*wigner_3j(N2,2,N1,0,0,0)+\
+                                                            consts['CC']*KroneckerDelta(N1,N2)*KroneckerDelta(F1,F2)*KroneckerDelta(mF1,mF2)*\
+                                                                np.round((-1+0j)**(2*J1+N2+F2),0)*(3/2)**0.5*((2*J2+1)*(2*J1+1)*N1*(N1+1)*(2*N1+1))**0.5*\
+                                                                    wigner_6j(F1,0.5,J2,1,J1,0.5)*wigner_6j(N2,J2,0.5,J1,N1,1)
+                                                
+                                            
+                                    i+=1
+                    i=0
+                    j+=1
+                    
+    #final check for NaN errors, mostly this is due to division by zero or
+    # multiplication by a small prefactor. it is safe to set these terms to 0
+    H_HF[np.isnan(H_HF)] =0
+
+    #return the matrix, in the full coupled basis.
+    return H_HF
+
+def H_dc(Nmax,consts,I,S):
+    ''' Calculates the effect of the anisotropic DC light shift for a rigid-rotor
+        like molecule, , <N,J,F,mF| H_dc |N',J',F', mF'>.
+    
+        This function  based on Jesus Aldegunde's FORTRAN 77 code and iterates 
+        over N, J, F, mF, N', J', F', mF' to build a matrix and evaluate the elements. 
+    
+        Args:
+            Nmax (int) - maximum rotational quantum number to calculate
+            I (float): Nuclear spin. We only consider molecules where one consistuent
+                       atom has no nuclear spin, so this is the non zero I of the other.
+            S (float): Electronic spin.
+            constst (dict): Dictionary of constants for the molecule to be calculated.
+    
+        Returns:
+            H (np.ndarray): Hamiltonian in joules
+     '''
+     
+    Ishape = int(2*I+1)
+    Sshape = int(2*S+1)
+    shape = np.sum(np.array([2*x+1 for x in range(0,Nmax+1)]))
+    HDC = np.zeros((shape,shape),dtype= complex)
+    HDC = (np.kron(HDC,np.kron(np.identity(Ishape),
+                                                    np.identity(Sshape))))
+    i=0
+    j=0
+    
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    for N2 in range(0,Nmax+1):
+                        for J2 in np.arange(np.abs(N2-S),(N2+S+1),1):
+                            for F2 in np.arange(J2-I,(J2+I+1),1):
+                                for mF2 in np.arange(-F2,+(F2+1),1):
+                                    HDC[i,j] = -1*consts['d0']*np.round((-1+0j)**(F2-mF2+J1+J2+F1+N2+1))*\
+                                        ((2*F1+1)*(2*F2+1)*(2*J1+1)*(2*J2+1))**0.5*((2*N1+1)*(2*N2+1))**0.5*(-1)**N2*wigner_3j(N2,1,N1,0,0,0)*\
+                                           wigner_3j(F2,1,F1,-mF2,0,mF1)*wigner_6j(J1,F1,I,F2,J2,1)*wigner_6j(N1,J1,0.5,J2,N2,1)
+                                    
+                                    i+=1
+                    i=0
+                    j+=1
+    #final check for NaN errors, mostly this is due to division by zero or 
+    # multiplication by a small prefactor. it is safe to set these terms to 0
+    HDC[np.isnan(HDC)] =0
+
+    #return the matrix, in the full coupled basis.
+    return HDC
+
+def H_ac(Nmax,consts,I,S):
+    ''' Calculates the effect of the anisotropic light shift for a rigid-rotor
+        like molecule, , <N,J,F,mF| H_ac |N',J',F', mF'>.
+    
+        This function  based on Jesus Aldegunde's FORTRAN 77 code and iterates 
+        over N, J, F, mF, N', J', F', mF' to build a matrix and evaluate the elements. 
+    
+        Args:
+    
+            Nmax (int) - maximum rotational quantum number to calculate
+            I (float): Nuclear spin. We only consider molecules where one consistuent
+                       atom has no nuclear spin, so this is the non zero I of the other.
+            S (float): Electronic spin.
+            constst (dict): Dictionary of constants for the molecule to be calculated.
+    
+        Returns:
+            H (np.ndarray): Hamiltonian in joules
+     '''
+    Ishape = int(2*I+1)
+    Sshape = int(2*S+1)
+    shape = np.sum(np.array([2*x+1 for x in range(0,Nmax+1)]))
+    HAC = np.zeros((shape,shape),dtype= complex)
+    HAC = (np.kron(HAC,np.kron(np.identity(Ishape),
+                                                    np.identity(Sshape))))
+    i=0
+    j=0
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    for N2 in range(0,Nmax+1):
+                        for J2 in np.arange(np.abs(N2-S),(N2+S+1),1):
+                            for F2 in np.arange(J2-I,(J2+I+1),1):
+                                for mF2 in np.arange(-F2,+(F2+1),1):
+                                    M=mF2-mF1  
+                                    HAC[i,j]= -1*consts['alpha_2']*\
+                                        (wigner_D(2,M,0,consts['Beta'],0)*\
+                                         ((-1)**(N1+N2)+1)*np.round((-1+0j)**(F2-mF2+F1-J2+J1+I+0.5),0)*((2*F1+1)*(2*F2+1))**0.5*\
+                                                ((2*N1+1)*(2*N2+1)*(2*J1+1)*(2*J2+1))**0.5*wigner_6j(J2,F2,I,F1,J1,2)*\
+                                                wigner_3j(F2,2,F1,-mF2,M,mF1)*wigner_3j(J1,0.5,N1,-0.5,0.5,0)*\
+                                                wigner_3j(J2,0.5,N2,-0.5,0.5,0)*wigner_3j(J2,2,J1,-0.5,0,0.5)) -\
+                                        consts['alpha_1']*(wigner_D(2,M,0,consts['Beta'],0)*((-1)**(N1+N2)+1)*np.round((-1+0j)**(F2-mF2+F1-J2+J1+I+0.5),0)*\
+                                                        ((2*F1+1)*(2*F2+1))**0.5*((2*N1+1)*(2*N2+1)*(2*J1+1)*(2*J2+1))**0.5*\
+                                                        wigner_6j(J2,F2,I,F1,J1,1)*wigner_3j(F2,1,F1,-mF2,M,mF1)*wigner_3j(J1,0.5,N1,-0.5,0.5,0)*\
+                                                    wigner_3j(J2,0.5,N2,-0.5,0.5,0)*wigner_3j(J2,1,J1,-0.5,0,0.5)) -\
+                                            consts['alpha_0']*(((-1)**(N1+N2)+1)*np.round((-1+0j)**(F2-mF2+F1-J2+J1+I+0.5),0)*\
+                                                    ((2*F1+1)*(2*F2+1))**0.5*((2*N1+1)*(2*N2+1)*(2*J1+1)*(2*J2+1))**0.5*\
+                                                    wigner_6j(J2,F2,I,F1,J1,0)*wigner_3j(F2,0,F1,-mF2,M,mF1)*wigner_3j(J1,0.5,N1,-0.5,0.5,0)*\
+                                                wigner_3j(J2,0.5,N2,-0.5,0.5,0)*wigner_3j(J2,0,J1,-0.5,0,0.5))                                            
+                                    i+=1
+                    i=0
+                    j+=1
+                    
+    #final check for NaN errors, mostly this is due to division by zero or
+    # multiplication by a small prefactor. it is safe to set these terms to 0
+    HAC[np.isnan(HAC)] =0
+
+    #return the matrix, in the full coupled basis.
+    return HAC
+
+def H_B(Nmax,consts,I,S):
+    ''' Calculates the Zeeman shift for a molecule in a magnetic field, <N,J,F,mF| H_zee |N',J',F', mF'>
+    
+        This function  based on Jesus Aldegunde's FORTRAN 77 code and iterates 
+        over N, J, F, mF, N', J', F', mF' to build a matrix and evaluate the elements. 
+    
+        Args:
+    
+            Nmax (int) - maximum rotational quantum number to calculate
+            I (float): Nuclear spin. We only consider molecules where one consistuent
+                       atom has no nuclear spin, so this is the non zero I of the other.
+            S (float): Electronic spin.
+            constst (dict): Dictionary of constants for the molecule to be calculated.
+    
+        Returns:
+            H (np.ndarray): Hamiltonian in joules
+     '''
+    Ishape = int(2*I+1)
+    Sshape = int(2*S+1)
+    shape = np.sum(np.array([2*x+1 for x in range(0,Nmax+1)]))
+    HB = np.zeros((shape,shape),dtype= complex)
+    HB = (np.kron(HB,np.kron(np.identity(Ishape),
+                                                    np.identity(Sshape))))
+    
+    i=0
+    j=0
+    for N1 in range(0,Nmax+1):
+        for J1 in np.arange(np.abs(N1-S),(N1+S+1),1):
+            for F1 in np.arange(J1-I,(J1+I+1),1):
+                for mF1 in np.arange(-F1,(F1+1),1):
+                    for N2 in range(0,Nmax+1):
+                        for J2 in np.arange(np.abs(N2-S),(N2+S+1),1):
+                            for F2 in np.arange(J2-I,(J2+I+1),1):
+                                for mF2 in np.arange(-F2,+(F2+1),1):
+                                    
+                                    
+                                    HB[i,j]= (consts['MuS']+consts['MuL'])*((-1+0j)**(F2-mF2+2*J2+F1+N1+1)*KroneckerDelta(N1,N2)*\
+                                                    (3/2*(2*F1+1)*(2*F2+1)*(2*J1+1)*(2*J2+1))**0.5*\
+                                                        wigner_6j(J1,F1,0.5,F2,J2,1)*wigner_6j(0.5,J2,N1,J1,0.5,1)*\
+                                                            wigner_3j(F2,1,F1,-mF2,0,mF1)) +\
+                                        consts['MuL']*(np.round((-1+0j)**(F1+F2-mF2+2*J2+N1+N2+0.5),0)*\
+                                            ((2*F1+1)*(2*F2+1)*(2*J1+1)*(2*J2+1)*(2*N1+1)*(2*N2+1))**0.5*\
+                                                wigner_3j(F2,1,F1,-mF2,0,mF1)*wigner_6j(J1,F1,I,F2,J2,1)*\
+                                                    np.sum((-1)**(O)*\
+                                                              wigner_3j(J2,1,J1,-O,0,O)*wigner_3j(J2,S,N2,O,-O,0)*\
+                                                                  wigner_3j(J1,S,N1,O,-O,0)*O for O in [-0.5,0.5]))+\
+                                            consts['MuR']*((-1+0j)**(F1-mF1+J1+J2+F1+N1+3)*\
+                                                            ((2*F1+1)*(2*F2+1)*(2*J1+1)*(2*J2+1))**0.5*\
+                                                                wigner_6j(J1,F1,0.5,F2,J2,1)*wigner_6j(N1,J1,0.5,J2,N2,1)*\
+                                                                    wigner_3j(F1,1,F2,-mF1,0,mF2)) +\
+                                            consts['MuN']*((-1+0j)**(2*F1-mF1+J1+3/2)*\
+                                                            (3/2*(2*F1+1)*(2*F2+1))**0.5*KroneckerDelta(J1,J2)\
+                                                                *wigner_6j(0.5,F2,J2,F1,0.5,1)*\
+                                                                    wigner_3j(F1,1,F2,-mF1,0,mF2))
+                                            
+                                    i+=1
+                    i=0
+                    j+=1
+    #final check for NaN errors, mostly this is due to division by zero or
+    # multiplication by a small prefactor. it is safe to set these terms to 0
+    HB[np.isnan(HB)] =0
+
+    #return the matrix, in the full coupled basis.
+
+    return HB
+
+
+
+# This is the main build function and one that the user will actually have to use.
+def build(Nmax,constants,zeeman=False,Edc=False,ac=False):
+    ''' Return the hyperfine hamiltonian.
+
+        This function builds the hamiltonian matrices for evaluation so that
+        the user doesn't have to rebuild them every time and we can benefit from
+        np's ability to do distributed multiplication.
+
+        Args:
+            Nmax (int) - Maximum rotational level to include
+            Constants (Dictionary) - Dictionary of constants for the molecule to be calculated.
+            B,EDC,AC (Boolean) - Switches for turning off parts of the total Hamiltonian.
+                                      This can save significant time on calculations where DC 
+                                      and AC fields are not required due to nested for loops
+
+        Returns:
+            H0,HB,HDC,HAC (np.ndarray): Each of the terms in the Hamiltonian.
+    '''
+    
+    I = constants['I']
+    S = constants['S']
+
+
+    H0 = H_rot(Nmax, constants, I, S) + H_hf(Nmax,constants,I,S) 
+    if zeeman:
+        HB = H_B(Nmax,constants,I,S)
+    else:
+        HB =0.
+    if Edc:
+        Hdc = H_dc(Nmax,constants,I,S)
+    else:
+        Hdc =0.
+    if ac:
+        Hac = H_ac(Nmax,constants,I,S) 
+    else:
+        Hac =0.
+    return H0,HB,Hdc,Hac
+
+

dipolmol-1.1.1/src/dipolmol.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: dipolmol
+Version: 1.1.1
+Summary: DiPolMol: tools for calculating molecular dipole moments, polarisabilities, and Hamiltonians
+License: MIT
+Keywords: quantum physics,molecular physics,dipole moment,polarizability,AMO physics,CaF
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: scipy>=1.9
+Requires-Dist: sympy>=1.11
+Requires-Dist: matplotlib>=3.6
+
+DiPolMol-Py
+===========
+A Python package to calculate the rotational and hyperfine structure of doublet-Sigma molecules (e.g., CaF, BaF, SrF) in the presence of external fields.
+
+DiPolMol-Py is licensed under a BSD 3 clause license, a copy can be found `See the [LICENSE](LICENSE) file'.
+If you use our work for academic purposes you can cite us using:
+
+ B.Humphreys *et al.* DiPolMol-Py: A Python package for calculations for $^{2}{\Sigma}$ ground-state molecules (https://arxiv.org/pdf/2503.21663).
+
+Installation
+----------
+
+run: pip install dipolmol
+
+This installs the latest stable release and all required dependencies.
+
+Package structure
+-------------
+**Programme Files:**
+
+*Hamiltonian* – used to build the required Hamiltonian using matrix representation, including the field-free Hamiltonian and in the presence of magnetic, dc electric and off-resonant light fields.
+
+*Calculate* – uses the eigenstates and eigenenergies found from diagonalising the Hamiltonian to run various calculations. Can be used to identify quantum numbers of eigenstates, calculate transition dipole moments and polarisabilities.
+
+*Constants* – includes all known  constants for CaF, BaF and SrF.
+
+**Examples:**
+
+There are three example files for calculating the energy structure in the presence of a magnetic, off-resonant light and electric field (*example_Bfield, example_ac_Efield, example_dc_Efield*). 
+
+There are two files to calculate the electric and magnetic moments of states (*example_electric_moment, example_magnetic_moment*). 
+
+We provide *example_polarisability* to calculate the polarisability for a given wavelength and polarisation of light. 
+
+Finally, *example_tdm* can be used to calculate the transition dipole moment.
+
+Example
+-------
+.. code-block:: python
+
+	import numpy as np
+	import dipolmol.hamiltonian as hamiltonian
+	import dipolmol.calculate as calc
+	from dipolmol.constants import SrF
+	
+	Nmax=4 #Identify the maximum N 
+	H0,H_B,H_dc,H_ac 
+		= hamiltonian.build
+			(Nmax,SrF,zeeman=True,Edc=False
+              ,Eac=False) 
+
+	B = np.linspace(0,100,5000)*1e-4 #Tesla
+	
+	H = H_0[..., None] + H_B[..., None]*B
+	H = H.transpose(2,0,1)
+	
+	energies, states, label_list = 
+       calc.solve(H, Nmax, SrF,label=True, B)
+
+Resulting plot of above code
+
+.. image:: Images/zeeman_SrF_plot.png
+  :width: 400
+  :alt: Resulting plot of above example
+
+For more examples of usage, see the ``./Examples`` module.

dipolmol-1.1.1/src/dipolmol.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/dipolmol/__init__.py
+src/dipolmol/calculate.py
+src/dipolmol/constants.py
+src/dipolmol/hamiltonian.py
+src/dipolmol.egg-info/PKG-INFO
+src/dipolmol.egg-info/SOURCES.txt
+src/dipolmol.egg-info/dependency_links.txt
+src/dipolmol.egg-info/requires.txt
+src/dipolmol.egg-info/top_level.txt

dipolmol-1.1.1/src/dipolmol.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dipolmol-1.1.1/src/dipolmol.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.23
+scipy>=1.9
+sympy>=1.11
+matplotlib>=3.6

dipolmol-1.1.1/src/dipolmol.egg-info/top_level.txt

@@ -0,0 +1 @@
+dipolmol