diff --git a/arc/__init__.py b/arc/__init__.py
index a91ac7a..7f06874 100644
--- a/arc/__init__.py
+++ b/arc/__init__.py
@@ -51,6 +51,8 @@
     "C_e",
     "C_m_e",
     "getCitationForARC",
+    "compositeState",
+    "singleAtomState",
 ]
 
 from arc.alkali_atom_functions import (
@@ -60,6 +62,8 @@
     printStateStringLatex,
     printStateLetter,
     formatNumberSI,
+    compositeState,
+    singleAtomState,
 )
 from arc.alkali_atom_data import (
     Hydrogen,
diff --git a/arc/calculations_atom_pairstate.py b/arc/calculations_atom_pairstate.py
index 3406ff4..5b261b3 100644
--- a/arc/calculations_atom_pairstate.py
+++ b/arc/calculations_atom_pairstate.py
@@ -1436,6 +1436,639 @@ def getC6perturbatively(
                 stateCom.conj().dot(interactionMatrix.dot(stateCom.T))[0][0]
             )
         return np.real(value), vectors
+        
+    def _getd(self, l, j, ll, jj, l1, j1, l2, j2):
+        r"""
+        Gets the mj-resolved matrix for the transition weights.
+        Note that this function is slow due to database initialisation.
+        Only use if necessary.
+        
+        Args:
+            l, j (floats) -   atom 1, initial state orbital and total angular momentum
+            ll, jj (floats) - atom 2, initial state orbital and total angular momentum
+            l1, j1 (floats) - atom 1, final state orbital and total angular momentum
+            l2, j2 (floats) - atom 2, final state orbital and total angular momentum
+            
+        Output:
+            d (ndarray) - mj-resolved matrix for transition weights
+        """
+        self.__initializeDatabaseForMemoization()
+        d = self.__getAngularMatrix_M(l, j, ll, jj, l1, j1, l2, j2)
+        self.__closeDatabaseForMemoization()
+        return d
+    
+    
+    def _getAngularBasisRotationMatrix(self, j1,j2):
+        r"""
+        Returns basis rotation matrix when interchanging state of atom1 and atom2, e.g. in hopping process.
+        
+        basis2 = rot * basis1 => rot = basis2 * (basis1)^{-1} = basis2 * (1)^{-1} = basis2
+        
+        Args:
+            j1 (float) - total orbital angular momentum of atom 1, half integer or integer >= 0
+            j2 (float) - total orbital angular momentum of atom 2, half integer or integer >= 0
+            
+        Output:
+            basis2 (ndarray) -  (2*j1+1)*(2*j2+1) \times (2*j1+1)*(2*j2+1) fine-structure (mj)
+                                basis rotation matrix
+        """
+        basis2 = np.zeros((int((2*j1+1)*(2*j2+1)),int((2*j1+1)*(2*j2+1))), dtype=np.complex128)
+        for i, mj2 in enumerate(np.arange(-j2, j2+1, 1)):
+            for j, mj1 in enumerate(np.arange(-j1, j1+1, 1)):
+                basis2[int(i*(2*j1+1)+j),:] = compositeState(singleAtomState(j1,mj1),
+                                                             singleAtomState(j2,mj2)).T
+        return basis2
+    
+    
+    def _ljCoupledCheck(self, l, j, l1, j1, s):
+        # [Karen:] Have not really understood the conditions part of the _isCoupled function
+        # so wrote a new one that enforces the selection rules as stated here for LS coupling:
+        # https://en.wikipedia.org/wiki/Selection_rule
+        # also, have a second look at _isCoupled fct but I think it returns states that are
+        # forbidden for dipole allowed only, even when setting interactionsUpTo=1
+        r"""
+        Checks if a pair of angular momentum quantum numbers (l,j) and (l1, j1) is
+        coupled.
+        
+        Args:
+            l, j (floats) -   angular momentum quantum number of initial state
+            l1, j1 (floats) - angular momentum quantum number of final state
+            s (float) -       spin angular momentum of the atom
+            
+        Output:
+            boolean - True or False
+        """
+        if (not (l == l1 and j == j1)
+            and not(abs(j)<0.1 and abs(j1)<0.1)  # j = 0 and j'=0 always forbiden
+            and not (abs(l)<0.1 and abs(l1)<0.1) # l = 0 and l' = 0 always forbiden
+            and (abs(l-j) < s+0.1) # check for total angular momentum
+            and (abs(l1-j1) < s+0.1)
+                ):
+            # check if the pair is dipole coupled
+            # if so, then all is okay and no further selection rules need be enforced
+            if ((abs(l-l1) == 1)
+                and (abs(j-j1) in [0,1])
+               ):
+                return True
+            # if not dipole coupled, check if quadrupole coupling was allowed
+            # and enforce additional quadrupole selection rules
+            elif ((self.interactionsUpTo == 2)
+                  and (abs(l-l1) in [0,2])
+                  and (abs(j-j1) in [0,1,2])
+                  and not (abs(j)<0.1 and abs(j1-1)<0.1) # j=0 to j1=1 forbidden
+                  and not (abs(j-1)<0.1 and abs(j1)<0.1) # j=1 to j1=0 forbidden
+                  and not (abs(j-0.5)<0.1 and abs(j1-0.5)<0.1) # j=1/2 to j1=1/2 forbidden
+                  and not (abs(l)<0.1 and abs(l1-1)<0.1) # l=0 to l1=1 forbidden
+                  and not (abs(l-1)<0.1 and abs(l1)<0.1) # l=1 to l1=0 forbidden
+                 ):
+                return True
+            else:
+                return False
+        else:
+            return False
+    
+    def _findAllCoupledAngularMomentumStates(self, l, j, s1, ll, jj, s2, stateHopping=False):
+        r"""
+        Finds all second-order coupled angular momentum states for an initial pair
+        configuration (l,j; ll,jj) --> (l1,j1; l2,j2) --> (l',j'; ll',jj').
+        If hopping == False, (l',j'; ll',jj') = (l,j; ll,jj)
+        Elif hopping == True, (l',j'; ll',jj') = (ll,jj; l,j)
+        
+        Args:
+            l, j, s1 (floats) -     angular momentum quantum numbers of first atom
+            ll, jj, s2 (floats) -   angular momentum quantum numbers of second atom
+            hopping (boolean) -     determines whether the final angMomentum configuration
+                                    is equal to the initial one or if the states are
+                                    interchanged between the atoms ('state hopping')
+                                
+        Output:
+            coupledStates (list) -  list of tuples containing the coupled angular
+                                    momentum configurations in the form
+                                    (l,j, ll,jj, l1,j1, l2,j2, l',j', ll',jj')
+        """
+        coupledStates = []
+        
+        # iterate through potential states for atom 1
+        for l1 in range(abs(l-self.interactionsUpTo), l+self.interactionsUpTo+1):
+            for j1 in np.arange(abs(j-self.interactionsUpTo), j+self.interactionsUpTo+1, 1):
+                # check if angular momentum coupling is valid
+                if self._ljCoupledCheck(l,j, l1, j1, s1):
+                    # iterate through potential states for atom 2
+                    for l2 in range(abs(ll-self.interactionsUpTo), ll+self.interactionsUpTo+1):
+                        for j2 in np.arange(abs(jj-self.interactionsUpTo), jj+self.interactionsUpTo+1, 1):
+                            # check if angular momentum coupling is valid
+                            if self._ljCoupledCheck(ll, jj, l2, j2, s2):
+                                j1, j2 = float(j1), float(j2)
+                                # atoms each return into their initial state, respectively
+                                if stateHopping == False:
+                                    # append state to list, finalState=initialState is certainly coupled
+                                    coupledStates.append((l,j, ll,jj, l1,j1, l2,j2, l,j, ll,jj))
+                                # atoms return to swappd states, check if these do couple
+                                elif (stateHopping == True
+                                      #and (abs(j1-jj) <= 1) and (abs(j2-j) <= 1)
+                                      and self._ljCoupledCheck(l1,j1, ll,jj, s1)
+                                      and self._ljCoupledCheck(l2,j2, l,j, s2)
+                                     ):
+                                     # append state to list, final state is swapped w.r.t. initial state
+                                    coupledStates.append((l,j, ll,jj, l1,j1, l2,j2, ll,jj, l,j))
+        return coupledStates
+    
+    def _getC6contributions_lj(self, nRange, energyDelta, stateHopping=False):
+        r"""
+        Returns the interaction strengths for the different
+        (l,j; ll,jj) --> (l1,j1; l2,j2) --> (l',j'; ll',jj') configurations.
+        
+        Args:
+            nRange (int) -  how much below and above the given principal quantum number
+                            of the pair state we should be looking
+            energyDelta (float) -   what is maximum energy difference ( :math:`\Delta E/h` in Hz)
+                                    between the original pair state and the other pair states that
+                                    we are including in the calculation
+            stateHopping (bool) -   whether or not the final state is interchanged ('hopped')
+                                    w.r.t. the initial state
+        Output:
+            ljInteractions (list) - list containing entries of the form
+                                    [(l,j, ll,jj, l1,j1, l2,j2, l',j' ll',jj'), V_{lj}]
+                                    with V_{lj} the interaction strength for the given
+                                    configuration in GHz(um)^6
+        """
+        if self.interactionsUpTo == 2:
+            print("WARNING: The quadrupole interaction currently seems to yield bad results.\n"
+                 "Go back and have a look at this!")
+        ljInteractions = []
+        
+        # find all (l,j; ll,jj) --> (l1,j1; l2,j2) --> (l',j'; ll',jj') pairs
+        coupledStates = self._findAllCoupledAngularMomentumStates(self.l, self.j, self.s1,
+                                                                  self.ll, self.jj, self.s2,
+                                                                  stateHopping=stateHopping)
+        
+        for lj in coupledStates:
+            V_lj = 0
+            # unpack angular momentum info
+            [l1, j1, ll1, jj1, l2, j2, ll2, jj2, l3, j3, ll3, jj3] = list(lj)
+            # iterate through n1 states
+            for n2 in range(max(self.n-nRange,1), self.n+nRange+1):
+                # iterate through n2 states
+                for nn2 in range(max(self.nn-nRange,1), self.nn+nRange+1):
+                    # to check if nVals are okay
+                    nCheck = ((n2 >= self.atom1.groundStateN or [n2, l2, j2] in self.atom1.extraLevels)
+                              and (nn2 >= self.atom2.groundStateN or [nn2, ll2, jj2] in self.atom2.extraLevels))
+                    if stateHopping == True:
+                        nCheck = (nCheck
+                                 and (self.nn >= self.atom1.groundStateN or [self.nn, l3, j3] in self.atom1.extraLevels)
+                                 and (self.n >= self.atom2.groundStateN or [self.n, ll3, jj3] in self.atom2.extraLevels)
+                                 )
+                        
+                    # calculate energy defect
+                    energyDefect= self.__getEnergyDefect(self.n,l1,j1, self.nn,ll1,jj1,
+                                                         n2,l2,j2, nn2,ll2,jj2) / C_h 
+                    energyDefect = energyDefect * 1e-9 # GHz
+                    if (abs(energyDefect) < 1e-10):
+                        print(n2,l2,j2, nn2,ll2,jj2, stateHopping, 'error')
+                        raise ValueError(
+                                "The requested pair-state "
+                                "is dipole coupled resonatly "
+                                "(energy defect = 0) "
+                                "to other pair-states. "
+                                "Aborting pertubative "
+                                "calculation. "
+                                "(This usually happens for "
+                                "high-L states for which "
+                                "identical quantum defects give "
+                                "raise to degeneracies, making "
+                                 "total L ultimately not "
+                                 "conserved quantum number) ")
+                    
+                    # proceed only if energy defect is within limit and nCheck was positive
+                    if ((abs(energyDefect) < energyDelta*10**-9) and (nCheck == True)):
+                        # calculate radial overlaps
+                        couplingStrength1 = (_atomLightAtomCoupling(
+                                                        self.n, l1, j1, self.nn, ll1, jj1,
+                                                        n2, l2, j2, nn2, ll2, jj2,
+                                                        self.atom1, atom2=self.atom2,
+                                                        s=self.s1, s2=self.s2)
+                                                    * (1.0e-9 * (1.e6)**3 / C_h)
+                                             )  # GHz / mum^3
+                        if stateHopping == False:
+                            couplingStrength2 = couplingStrength1
+                        elif stateHopping == True:
+                            couplingStrength2 = (_atomLightAtomCoupling(
+                                                        n2, l2, j2, nn2, ll2, jj2,
+                                                        self.nn, l3, j3, self.n, ll3, jj3,
+                                                        self.atom1, atom2=self.atom2,
+                                                        s=self.s1, s2=self.s2)
+                                                    * (1.0e-9 * (1.e6)**3 / C_h)
+                                             )  # GHz / mum^3
+                            
+                        V_lj += abs(couplingStrength1*couplingStrength2)/energyDefect #GHz um^6
+            ljInteractions.append([*list(lj), V_lj])
+        return ljInteractions
+    
+    def _getPerturbativeC6Matrix_lj(self, ljInteractions):
+        r"""
+        Construct full Imat from lj, V_{lj} information.
+        
+        Args:
+            ljInteractions (list) - list contains entries of the form
+                                    [l,j, ll,jj, l1,j1, l2,j2, l',j', ll',jj', V_{lj}]
+                                    Only those angular channels contained in the list are
+                                    included in the resulting Imat. So make sure you pass
+                                    a complete list to this function.
+                                    
+        Output:
+            Imat (ndarray) -    interaction matrix with mj-basis resolution as reconstructed
+                                from ljInteraction list
+        """
+        # open database
+        self.__initializeDatabaseForMemoization()
+        Imat = 0
+        # iterate through channels
+        for vals in ljInteractions:
+            d1 = self.__getAngularMatrix_M(*vals[0:8])
+            d2 = self.__getAngularMatrix_M(*vals[4:12])
+            # no need to take the hermitian conjugate of d2 here as this code uses the right order
+            # of l,j, l1,j1 as opposed to the original code
+            Imat += vals[-1]*d2.dot(d1)
+        # close database
+        self.__closeDatabaseForMemoization()
+        return np.array(Imat)
+    
+    
+    def _getInteractionMatrix_lj(self, nRange, energyDelta):
+        r"""
+        Small helper function to get the interaction matrix from the d_lj method, used for debugging
+        and double-checking. Can also be used to call the interaction matrix via this method - but only
+        for the case theta = phi = 0. Also, it automatically builds the full Imat from all four blocks
+        if atomState1 != atomState2.
+        
+        Args:
+            nRange (int) -  how much below and above the given principal quantum number
+                            of the pair state we should be looking
+            energyDelta (float) -   what is maximum energy difference ( :math:`\Delta E/h` in Hz)
+                                    between the original pair state and the other pair states that
+                                    we are including in the calculation
+                                    
+        Output:
+            Imat (ndarray) - full interaction matrix calculated via d_lj-method for theta=phi=0.
+        """
+        interaction11 = self._getC6contributions_lj(nRange, energyDelta, stateHopping=False)
+        Imat11 = self._getPerturbativeC6Matrix_lj(interaction11)
+        if (self.n == self.nn and self.l == self.ll and self.j == self.jj and self.s1 == self.s2):
+            return Imat11
+        else:
+            # get rotation matrix for basis changes from [atomState2,atomState1] --> [atomState1,atomState2]
+            basisRotationMatrix12 = self._getAngularBasisRotationMatrix(self.jj,self.j)
+            # get second Imat block
+            interaction21 = self._getC6contributions_lj(nRange, energyDelta, stateHopping=True)
+            Imat21 = self._getPerturbativeC6Matrix_lj(interaction21)
+            #put all together
+            Imat = np.block([[Imat11, basisRotationMatrix12.dot(Imat21.dot(basisRotationMatrix12))],
+                                 [Imat21, basisRotationMatrix12.T.dot(Imat11.dot(basisRotationMatrix12))]
+                                ])
+            return Imat
+        
+        
+    def getC6PerturbativelyAngularChannel(self, theta, phi, nRange, energyDelta,
+                            degeneratePerturbation=False, returnInteractionMatrix=False):
+        # [Karen:] theory part of docstring copied from Nikola's code and amended as required
+        r"""
+        Calculates :math:`C_6` from second order perturbation theory.
+
+        Calculates
+        :math:`C_6=\sum_{\rm r',r''}|\langle {\rm r',r''}|V|\
+        {\rm r1,r2}\rangle|^2/\Delta_{\rm r',r''}`, where
+        :math:`\Delta_{\rm r',r''}\equiv E({\rm r',r''})-E({\rm r1, r2})`
+        When second order perturbation couples to multiple energy degenerate
+        states, users shold use **degenerate perturbation calculations** by
+        setting `degeneratePerturbation=True` .
+
+        This calculation is faster then full diagonalization, but it is valid
+        only far from the so called spaghetti region that occurs when atoms
+        are close to each other. In that region multiple levels are strongly
+        coupled, and one needs to use full diagonalization. In region where
+        perturbative calculation is correct, energy level shift can be
+        obtained as :math:`V(R)=-C_6/R^6`
+
+        Args:
+            theta (float) - azimuthal angular orientation of atomic pair
+                            state in rad
+            phi (float) -   polar angular orientation of atomic pair state
+                            in rad
+            nRange (int) -  how much below and above the given principal quantum
+                            number of the pair state we should be looking
+            energyDelta (float) -   what is maximum energy difference
+                                    ( :math:`\Delta E/h` in Hz)
+                                    between the original pair state and the other
+                                    pair states that we are including in
+                                    calculation
+            degeneratePerturbation (bool) - optional, default False. Should one
+                                            use degenerate perturbation theory. 
+                                            This should be used whenever
+                                            angle between quantisation and
+                                            interatomic axis is non-zero,
+                                            as well as when one considers
+                                            non-stretched states.
+            returnInteractionMatrix (bool) -    optional, default False.
+                                                Option to return the interaction
+                                                matrix V(r)*R^6 in [GHz]
+        Output:
+            C6 (float) -    C6 value in [GHz] for the [n1,l1,j1,mj1; n2,l2,j2,mj2]
+                            state specified in the PairStateInteraction class
+                            initialisation
+            if degeneratePerturbation == False:
+                C6hop (float) - C6 value in [GHz] for the
+                                [n1,l1,j1,mj1; n2,l2,j2,mj2] -> 
+                                [n2,l2,j2,mj2; n1,l1,j1,mj1] state hopping contribution
+            elif degeneratePerturbation == True:
+                C6 (ndarray) -  array of eigenvalues of the full
+                                interaction matrix in [GHz]
+                eigenvectors (ndarray) -    corresponding list of eigenvectors
+                                            :math:`\{m_{j_1}=-j_1, \ldots,
+                                            m_{j_1} = +j1\}\bigotimes \
+                                            \{ m_{j_2}=-j_2, \ldots, m_{j_2} = +j2\}`
+                                            basis
+            if returnInteractionMatrix == True:
+                Imat_rot (ndarray) -    interaction matrix, fine-structure basis resolved
+                                        for atomState1 == atomState2:
+                                        [n1,l1,j1, mj1; n2,l2,j2,mj2] with 
+                                        :math:`\{m_{j_1}=-j_1, \ldots,
+                                        m_{j_1} = +j1\}\bigotimes \
+                                        \{ m_{j_2}=-j_2, \ldots, m_{j_2} = +j2\}`
+                                        for aomState != atomState2:
+                                        first basis above, then basis with the 
+                                        atomStates interchanged.
+        """
+        # [copied WignerD rotation stuff from Nikola's code and amended as required]
+        
+        atomState1 = [self.n, self.l, self.j, self.s1]
+        atomState2 = [self.nn, self.ll, self.jj, self.s2]
+        
+        if degeneratePerturbation == True:
+            degenerateStates = [[self.n, self.l, self.j, self.nn, self.ll, self.jj],
+                                [self.nn, self.ll, self.jj, self.n, self.l, self.j]]
+            
+        # calculate interaction matrix wthout any basis changes (top left, Imat11)
+        interaction11 = self._getC6contributions_lj(nRange, energyDelta, stateHopping=False)
+        Imat11 = self._getPerturbativeC6Matrix_lj(interaction11)
+        
+        if atomState1 != atomState2:
+            # if pair states are not identical, also calculate bottom left Imat (Imat21)
+            interaction21 = self._getC6contributions_lj(nRange, energyDelta, stateHopping=True)
+            Imat21 = self._getPerturbativeC6Matrix_lj(interaction21)
+            # get rotation matrix for basis changes from [atomState2,atomState1] --> [atomState1,atomState2]
+            basisRotationMatrix12 = self._getAngularBasisRotationMatrix(self.jj,self.j)
+            
+        
+        # wigner D matrix allows calculations with arbitrary orientation of
+        # the two atoms
+        wgd = WignerDmatrix(theta, phi)
+        angRotationMatrix = np.kron(wgd.get(atomState1[2]).toarray(),
+                                    wgd.get(atomState2[2]).toarray())
+        if atomState1 != atomState2:
+            angRotationMatrix2 = np.kron(wgd.get(atomState2[2]).toarray(),
+                                         wgd.get(atomState1[2]).toarray())
+                    
+        # rotate Imat's into correct basis for angles theta, phi (angle1, angle2)
+        Imat11_rot = angRotationMatrix.dot(
+            Imat11.dot(angRotationMatrix.conj().T)
+            )
+        if atomState1 != atomState2:
+            Imat21_rot = angRotationMatrix2.dot(
+                Imat21.dot(angRotationMatrix.conj().T)
+                )
+                    
+        # if degeneratePerturbation == False, calculate C6 value for a given mj1,mj2 state
+        if degeneratePerturbation == False:
+            # calculate C6 value for non-hopped case
+            compositeState1 = compositeState(singleAtomState(self.j, self.m1),
+                                             singleAtomState(self.jj, self.m2)).T
+            C6 = np.real(compositeState1.dot(Imat11_rot.dot(compositeState1.T))[0][0])
+            
+            # if atom states are different, also calculate C6 contribution from hopping
+            if atomState1 != atomState2:
+                compositeState2 = compositeState(singleAtomState(self.jj, self.m2),
+                                                 singleAtomState(self.j, self.m1)).T
+                C6hop = np.real(compositeState2.dot(Imat21_rot.dot(compositeState1.T))[0][0])
+                
+                
+                    
+        # if degeneratePerturbation == True, construct full interaction matrix from above two matrices
+        if ((degeneratePerturbation == True) or (returnInteractionMatrix == True)):
+            # construct full Imat
+            if atomState1 == atomState2:
+                Imat_rot = Imat11_rot
+            elif atomState1 != atomState2:
+                # compose resulting interaction marix
+                Imat_rot = np.block([[Imat11_rot, basisRotationMatrix12.dot(Imat21_rot.dot(basisRotationMatrix12))],
+                                 [Imat21_rot, basisRotationMatrix12.T.dot(Imat11_rot.dot(basisRotationMatrix12))]
+                                ])
+                        
+            if degeneratePerturbation == True:
+                # calculate eigenvalues, eigenstates etc
+                eigenvalues, eigenvectors = np.linalg.eigh(Imat_rot)
+                eigenvectors = eigenvectors.T
+        
+        # return function output
+        if (degeneratePerturbation == False) and (returnInteractionMatrix == False):
+            return C6, C6hop
+        elif (degeneratePerturbation == False) and (returnInteractionMatrix == True):
+            return C6, C6hop, Imat_rot
+        elif (degeneratePerturbation == True) and (returnInteractionMatrix == False):
+            return eigenvalues, eigenvectors, degenerateStates
+        elif (degeneratePerturbation == True) and (returnInteractionMatrix == True):
+            return eigenvalues, eigenvectors, degenerateStates, Imat_rot
+        
+        
+    def _calcLJcontribution_allParamsFree(self, pathway, atom1, atom2, nRange, energyDelta, stateHopping, interactionsUpTo=1):
+        r"""
+        Returns the interaction strengths for the different
+        (l,j; ll,jj) --> (l1,j1; l2,j2) --> (l',j'; ll',jj') configurations.
+        
+        Args:
+            pathway (list) -    list containing the lj coupling pathway
+                                [l,j, ll,jj, l1,j1, l2,j2, l',j' ll',jj']
+            atom1 (list) -  infos on init state of atom 1 [n,s, atomType (ARC, e.g. Rubidium())]
+            atom2 (list) -  infos on init state of atom 2 [n,s, atomType]
+            nRange (int) -  how much below and above the given principal quantum number
+                            of the pair state we should be looking
+            energyDelta (float) -   what is maximum energy difference ( :math:`\Delta E/h` in Hz)
+                                    between the original pair state and the other pair states that
+                                    we are including in the calculation
+            stateHopping (bool) -   whether or not the final state is interchanged ('hopped')
+                                    w.r.t. the initial state
+        Output:
+            ljInteractions (list) - list containing entries of the form
+                                    [(l,j, ll,jj, l1,j1, l2,j2, l',j' ll',jj'), V_{lj}]
+                                    with V_{lj} the interaction strength for the given
+                                    configuration in GHz(um)^6
+        """
+        if self.interactionsUpTo == 2:
+            print("WARNING: The quadrupole interaction currently seems to yield bad results.\n"
+                 "Go back and have a look at this!")
+        
+        V_lj = 0
+        # unpack angular momentum info
+        [l1, j1, ll1, jj1, l2, j2, ll2, jj2, l3, j3, ll3, jj3] = list(pathway)
+        # iterate through n1 states
+        for n2 in range(max(atom1[0]-nRange,1), atom1[0]+nRange+1):
+            # iterate through n2 states
+            for nn2 in range(max(atom2[0]-nRange,1), atom2[0]+nRange+1):
+                # to check if nVals are okay
+                nCheck = ((n2 >= atom1[2].groundStateN or [n2, l2, j2] in atom1[2].extraLevels)
+                          and (nn2 >= atom2[2].groundStateN or [nn2, ll2, jj2] in atom2[2].extraLevels))
+                if stateHopping == True:
+                    nCheck = (nCheck
+                              and (atom2[0] >= atom1[2].groundStateN or [atom2[0], ll3, jj3] in atom1[2].extraLevels)
+                               and (atom1[0] >= atom2[2].groundStateN or [atom1[0], l3, j3] in atom2[2].extraLevels)
+                             )
+                        
+                # calculate energy defect
+                energyDefect= self.__getEnergyDefect(atom1[0],l1,j1, atom2[0],ll1,jj1,
+                                                     n2,l2,j2, nn2,ll2,jj2) / C_h 
+                energyDefect = energyDefect * 1e-9 # GHz
+                if (abs(energyDefect) < 1e-10):
+                    print(n2,l2,j2, nn2,ll2,jj2, stateHopping, 'error')
+                    raise ValueError(
+                            "The requested pair-state "
+                            "is dipole coupled resonatly "
+                            "(energy defect = 0) "
+                            "to other pair-states. "
+                            "Aborting pertubative "
+                            "calculation. "
+                            "(This usually happens for "
+                            "high-L states for which "
+                            "identical quantum defects give "
+                            "raise to degeneracies, making "
+                             "total L ultimately not "
+                            "conserved quantum number) ")
+                    
+                # proceed only if energy defect is within limit and nCheck was positive
+                if ((abs(energyDefect) < energyDelta*10**-9) and (nCheck == True)):
+                    # calculate radial overlaps
+                    couplingStrength1 = (_atomLightAtomCoupling(
+                                                    atom1[0], l1, j1, atom2[0], ll1, jj1,
+                                                    n2, l2, j2, nn2, ll2, jj2,
+                                                    atom1[2], atom2=atom2[2],
+                                                    s=atom1[1], s2=atom2[1])
+                                                * (1.0e-9 * (1.e6)**3 / C_h)
+                                         )  # GHz / mum^3
+                    if stateHopping == False:
+                        couplingStrength2 = couplingStrength1
+                    elif stateHopping == True:
+                        couplingStrength2 = (_atomLightAtomCoupling(
+                                                    n2, l2, j2, nn2, ll2, jj2,
+                                                    atom2[0], l3, j3, atom1[0], ll3, jj3,
+                                                    atom2[2], atom2=atom1[2],
+                                                    s=atom2[1], s2=atom1[1])
+                                                * (1.0e-9 * (1.e6)**3 / C_h)
+                                         )  # GHz / mum^3
+                            
+                    V_lj += abs(couplingStrength1*couplingStrength2)/energyDefect #GHz um^6
+        return V_lj
+    
+    
+    def saveLJ(self, filename, nValueRange, atom1Vals, atom2Vals, nRange, energyDelta, stateHopping=False):
+        r"""
+        Saves the V_{lj} values for the atom1 and atom2 pair-interaction. From this file,
+        the full interaction matrix can be reconstructed by feeding the filename into the function
+        generateLJfromFile.
+        
+        Args:
+            filename (str) - name of the file (incl. file type ending) to which data should be saved
+            nValueRange (list) - [nMin, nMax]
+            atom1Vals (list) - [l1, j1, s1, atom1Type (ARC, e.g. Rubidium())]
+            atom2Vals (list) - [l2, j2, s2, atom2Type (ARC, e.g. Rubidium())]
+            nRange (int) -  how much below and above the given principal quantum number
+                            of the pair state we should be looking
+            energyDelta (float) -   what is maximum energy difference ( :math:`\Delta E/h` in Hz)
+                                    between the original pair state and the other pair states that
+                                    we are including in the calculation
+            stateHopping (bool) -   whether or not the final state is interchanged ('hopped')
+                                    w.r.t. the initial state
+        """
+        [l1, j1, s1, atom1] = atom1Vals
+        [l2, j2, s2, atom2] = atom2Vals
+        
+        # get coupling pathways
+        if stateHopping == False:
+            coupledStates = self._findAllCoupledAngularMomentumStates(l1,j1,s1, l2,j2,s2, stateHopping=False)
+        elif stateHopping == True:
+            coupledStates = self._findAllCoupledAngularMomentumStates(l1,j1,s1, l2,j2,s2, stateHopping=True)
+        if coupledStates == []:
+            raise ValueError("No interaction pathways found for the specified conditions.")
+        
+        ljValues = np.zeros(((int(nValueRange[1]-nValueRange[0])+1)**2, 2+len(coupledStates)))
+        # iterate through n1Vals
+        for n1 in range(nValueRange[0], nValueRange[1]+1):
+            i = int(n1-nValueRange[0])
+            # iterate through n2Vals
+            for n2 in range(nValueRange[0], nValueRange[1]+1):
+                j = int(n2-nValueRange[0])
+                vals = []
+                for pathway in coupledStates:
+                    V_lj = self._calcLJcontribution_allParamsFree(pathway, [n1,s1, atom1], [n2,s2, atom2],
+                                                                  nRange, energyDelta, stateHopping,
+                                                                  interactionsUpTo=self.interactionsUpTo)
+                    vals.append(V_lj)
+                ljValues[i*int(nValueRange[1]-nValueRange[0]+1)+j,:] = [n1, n2, *vals]
+        
+        # header, line 1: dictionary with the following infos: 
+        #                           atom1_species, atom2_species, nRange, energyDelta, stateHopping
+        # header, line 2:
+        # header, line 3: 'n1', 'n2', {[l,j, ll,jj, l1,j1, ll1,jj1, l',j', ll',jj']}_i
+        # header, line 4: list with all {lj}_i 's in correct order
+        # header, line 5:
+        header = ("{'atom 1':'"+atom1.elementName+"', 'atom 2':'"+atom2.elementName
+                  +"', 'nRange':'"+str(nRange)+"', 'energyDelta':'"+str(energyDelta)
+                  +"', 'stateHopping':'"+str(stateHopping)+"', 'nValueRange':'"
+                  +str(nValueRange)+"', 'interactionsUpTo':'"+str(self.interactionsUpTo)+"'}\n\n"
+                  +"n1, n2, {[l,j, ll,jj, l1,j1, ll1,jj1, l',j', ll',jj']}_i \n"
+                  +" , ")
+        for i in range(len(coupledStates)):
+            header += ','+str(list(coupledStates[i]))
+        header += '\n'
+            
+        np.savetxt(filename, ljValues, header=header, delimiter=',')
+        print("data was successfully saved to file "+filename+".")
+        
+    
+    def loadLJfromFile(self, filename):
+        r"""
+        Loads the V_{lj} data from the file passed to the function.
+        
+        Args:
+            filename (str) - name of the file (incl. file type ending) which contains the data
+            
+        Output:
+            fileInfos (dict) -  dictionary containing the details of the calculation
+                                and the range of n-values in the file
+                                keywords:   'atom 1', 'atom 2', 'nRange', 'energyDelta',
+                                            'stateHopping', 'nValueRange', 'intractionsUpTo'
+            coupled states (list) - list entries contain the 'pathways' of angular momentum
+                                    coupling for the V_{lj}s in the respective columns in the form
+                                    [l,j, ll,jj, l1,j1, l2,j2, l',j' ll',jj']
+            data (list) -   each list entry is a list, each containing the data [n1, n2, V_{lj}_i]
+                            with the V_{lj}_i in GHz um^6 and arranged in the same order as the
+                            corresponding lj pathway provided with the header
+        """
+        # get header
+        file = open(filename)
+        fileInfos = eval(file.readline()[2:])
+        # fix nValueRange and nRange types (list and int, respectively)
+        fileInfos["nRange"] = int(fileInfos["nRange"])
+        fileInfos["nValueRange"] = [int(x) for x in fileInfos["nValueRange"][1:-1].split(', ')]
+        # skip the next two lines as they contain no valuable information
+        for _ in range(2):
+            next(file)
+        coupledStateString = file.readline()[6:]
+        file.close()
+        # generate the list of coupled states from the string
+        coupledStates = [[float(x) for x in listEntry.split(', ')]
+                         for listEntry in coupledStateString[1:-2].split("],[")]
+        
+        # numpy's loadtxt skips the header and thus reads only the data
+        data = np.loadtxt(filename, delimiter=",")
+        return fileInfos, coupledStates, data
 
     def defineBasis(
         self,
diff --git a/doc/ARC_angularChannels.ipynb b/doc/ARC_angularChannels.ipynb
new file mode 100644
index 0000000..07cf5ec
--- /dev/null
+++ b/doc/ARC_angularChannels.ipynb
@@ -0,0 +1,569 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f2a558a0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from arc import *\n",
+    "from time import time\n",
+    "import numpy as np\n",
+    "from matplotlib.gridspec import GridSpec\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "510b812d",
+   "metadata": {},
+   "source": [
+    "## compare interaction matrices obtained via the different approaches and computation speed for a single C6 calculation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d64429fe",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "abs. difference between C6 value from perturbative and angular channel approach: 0.0\n",
+      "\n",
+      " time requirements in sec.:\n",
+      "\t perturbative: 0.6 \n",
+      "\t angular channels: 0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set atom properties\n",
+    "atom = Cesium()\n",
+    "n, l, j, mj1 = 63, 0, 0.5, 0.5\n",
+    "nn, ll, jj, mj2 = 90, 2, 2.5, 0.5\n",
+    "\n",
+    "# set calculation properties\n",
+    "nrange, dE = 10, 1*1e12\n",
+    "stateHop = False\n",
+    "theta, phi = np.pi/4,np.pi/4\n",
+    "times = []\n",
+    "\n",
+    "# initialise PairStateInteractions class instance\n",
+    "calc = PairStateInteractions(atom, n, l, j, nn, ll, jj, m1=mj1, m2=mj2, interactionsUpTo=1)\n",
+    "\n",
+    "\n",
+    "# calculate via all perturbative approach\n",
+    "times.append(time())\n",
+    "C6_pert = calc.getC6perturbatively(theta, phi, nrange, dE, degeneratePerturbation=False)\n",
+    "times.append(time())\n",
+    "\n",
+    "# calculate same but via angular channel approach\n",
+    "times.append(time())\n",
+    "C6_lj, C6hop_lj = calc.getC6PerturbativelyAngularChannel(theta, phi, nrange, dE, degeneratePerturbation=False)\n",
+    "times.append(time())\n",
+    "\n",
+    "\n",
+    "# print abs. difference\n",
+    "print('abs. difference between C6 value from perturbative and angular channel approach: {:.1f}'.format(np.abs(C6_pert-C6_lj)))\n",
+    "# print timings\n",
+    "print('\\n time requirements in sec.:\\n\\t perturbative: {:.1f} \\n\\t angular channels: {:.1f}'.format(times[1]-times[0], times[3]-times[2]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fdf9514-f6de-4ebb-8825-9c082f638251",
+   "metadata": {},
+   "source": [
+    "## compare calculation speed for one pair state and different set of angles\n",
+    "\n",
+    "The difference in calculation speed is due to the perturbative calculation having to re-run the full computations for all set of angles while the angular channel approach has to compute the angular channel values once and then simply reconstructs C6 value at different interatomic orientations.\n",
+    "\n",
+    "It is even faster to load precalculated angular channel values from file if precalculated data exists, this method is shown further down."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d020fde1-75df-4450-b07a-e52740f51182",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "calculation of 5 values via perturbative approach: 2.8 s\n",
+      "calculation of 501 values via perturbative approach: 3.1 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# set atom properties\n",
+    "atom = Cesium()\n",
+    "n, l, j, mj1 = 63, 0, 0.5, j\n",
+    "nn, ll, jj, mj2 = 90, 2, 2.5, jj\n",
+    "\n",
+    "# set calculation propreties\n",
+    "nrange, dE = 10, 1*1e12\n",
+    "stateHop = False\n",
+    "\n",
+    "# set theta values\n",
+    "theta_pert = np.linspace(0, np.pi/2, 5)\n",
+    "theta_lj = np.linspace(0, np.pi*2, 501)\n",
+    "phi = 0\n",
+    "\n",
+    "# time array\n",
+    "times = []\n",
+    "\n",
+    "# initialise PairStateInteractions class instance\n",
+    "calc = PairStateInteractions(atom, n, l, j, nn, ll, jj, m1=mj1, m2=mj2, interactionsUpTo=1)\n",
+    "\n",
+    "# perturbative calculation\n",
+    "C6_pert = np.zeros_like(theta_pert)\n",
+    "times.append(time())\n",
+    "for i, theta in enumerate(theta_pert):\n",
+    "    C6_pert[i] = calc.getC6perturbatively(theta, phi, nrange, dE, degeneratePerturbation=False)\n",
+    "times.append(time())\n",
+    "print('calculation of {:.0f} values via perturbative approach: {:.1f} s'.format(len(theta_pert), times[1]-times[0]))\n",
+    "\n",
+    "# angular channel code\n",
+    "times.append(time())\n",
+    "C6_lj = calc.getC6Perturbatively_anglePairs([(theta, phi) for theta in theta_lj], nrange, dE, degeneratePerturbation=False, returnInteractionMatrix=False)[0]\n",
+    "times.append(time())\n",
+    "print('calculation of {:.0f} values via perturbative approach: {:.1f} s'.format(len(theta_lj), times[3]-times[2]))\n",
+    "\n",
+    "\n",
+    "# plot\n",
+    "fig = plt.figure(figsize=(3,3))\n",
+    "ax = fig.add_subplot(1,1,1, projection='polar')\n",
+    "\n",
+    "# plot \n",
+    "ax.plot(theta_lj, C6_lj, color='darkgray', linewidth=3, label='ang. channel')\n",
+    "ax.plot(theta_pert, C6_pert, color='black', linestyle='none', marker='x', ms=9, label='perturb.')\n",
+    "ax.legend(bbox_to_anchor=(0,0), loc=3)\n",
+    "ax.set_xticks([0, np.pi/2, np.pi, 3*np.pi/2], ['0', r'$\\pi$/2', r'$\\pi$', r'$3\\pi$/2'])\n",
+    "ax.set_yticks([])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ff157a3-cf91-44e9-9d31-4d9eb4a3475f",
+   "metadata": {},
+   "source": [
+    "## save angular channel values to file and load from file\n",
+    "\n",
+    "These functions allow the user to generate the angular channel precalc files by setting the calculation parameters and calling the function. In case of an update of any atomic properties or functions, such as quantum defect, energy level calculations etc., the user can use these functions to trigger a new calculation of the precalc files themselves.\n",
+    "\n",
+    "The saveLJ function includes a header that stores all relevant file information such as atomic states, calculation settings, angular channels, ...\n",
+    "\n",
+    "The loadLJfromFile function reads out the header as well as the data and provides the information."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0f7a9159-f0bb-4c32-a98f-3ee4b13b6459",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "data was successfully saved to file testdata.txt.\n",
+      "time requirement for calculation of 121 pair state data: 5.9 s.\n",
+      "time taken to load precalculated data: 0.0 s\n",
+      "{'atom 1': 'Rb85', 'atom 2': 'Cs133', 'nRange': 10, 'energyDelta': '1000000000000.0', 'stateHopping': 'False', 'nValueRange': [20, 30], 'interactionsUpTo': '1'}\n",
+      "[[0.0, 0.5, 2.0, 2.5, 1.0, 0.5, 1.0, 1.5, 0.0, 0.5, 2.0, 2.5], [0.0, 0.5, 2.0, 2.5, 1.0, 0.5, 3.0, 2.5, 0.0, 0.5, 2.0, 2.5], [0.0, 0.5, 2.0, 2.5, 1.0, 0.5, 3.0, 3.5, 0.0, 0.5, 2.0, 2.5], [0.0, 0.5, 2.0, 2.5, 1.0, 1.5, 1.0, 1.5, 0.0, 0.5, 2.0, 2.5], [0.0, 0.5, 2.0, 2.5, 1.0, 1.5, 3.0, 2.5, 0.0, 0.5, 2.0, 2.5], [0.0, 0.5, 2.0, 2.5, 1.0, 1.5, 3.0, 3.5, 0.0, 0.5, 2.0, 2.5]]\n",
+      "(11, 11, 8)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0.98, 'Channel no.')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2460x400 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# set all relevant params\n",
+    "filename = 'testdata.txt'\n",
+    "\n",
+    "# atom properties\n",
+    "nMin, nMax = 20, 30\n",
+    "l1, j1, s1 = 0, 0.5, 0.5\n",
+    "l2, j2, s2 = 2, 2.5, 0.5\n",
+    "atom1, atom2 = Rubidium(), Cesium()\n",
+    "\n",
+    "# calculation properties\n",
+    "nRange = 10\n",
+    "energyDelta = 1e12\n",
+    "stateHopping = False\n",
+    "\n",
+    "# initialise calc.class, the initial state parameters do not matter as we will later pass our range of interest to the .saveLJ function\n",
+    "calc = PairStateInteractions(Cesium(), 20, 0,0.5, 20,0,0.5, m1=0.5, m2=0.5, interactionsUpTo=1)\n",
+    "\n",
+    "\n",
+    "\n",
+    "## calculate data and save in file\n",
+    "t1 = time()\n",
+    "calc.saveLJ(filename, [nMin, nMax], [l1, j1, s1, atom1], [l2, j2, s2, atom2], nRange, energyDelta, stateHopping=False)\n",
+    "t2 = time()\n",
+    "print('time requirement for calculation of {:.0f} pair state data: {:.1f} s.'.format((nMax-nMin+1)**2, t2-t1))\n",
+    "\n",
+    "\n",
+    "\n",
+    "## load data from file\n",
+    "t1 = time()\n",
+    "atomInfos, coupledStates, data = calc.loadLJfromFile(filename)\n",
+    "data = np.reshape(data, ((nMax-nMin+1), (nMax-nMin+1), len(coupledStates)+2))\n",
+    "t2 = time()\n",
+    "print('time taken to load precalculated data: {:.1f} s'.format(t2-t1))\n",
+    "\n",
+    "# print file metadata\n",
+    "print(atomInfos)\n",
+    "print(coupledStates)\n",
+    "print(np.shape(data))\n",
+    "\n",
+    "# plot data\n",
+    "fig, ax = plt.subplots(1, len(coupledStates), figsize=(4.1*len(coupledStates),4))\n",
+    "for i, path in enumerate(coupledStates):\n",
+    "    ax[i].imshow(np.log10(np.abs(data[:,:, i+2])), origin='lower', extent=[nMin, nMax, nMin, nMax],\n",
+    "                 vmin=np.min(np.log10(np.abs(data[:,:,2:]))), vmax=np.max(np.log10(np.abs(data[:,:,2:]))))\n",
+    "    ax[i].set_title('#'+str(i+1))\n",
+    "fig.suptitle('Channel no.', fontsize=18)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a1af3a9-4939-427f-9852-029e240aaa47",
+   "metadata": {},
+   "source": [
+    "## look behind the scenes - how does angular channel code work?\n",
+    "Effectively, the angular channel code runs the perturbative calculation to compute the angular channel values once and then implements the angular orientation. One can also do this manually by calculating the angular channel strengths, then calculate the full interaction matrix at theta = 0 and finally rotate the interaction matrix to the actual relative interatomic orientation with Wigner-D matrices.\n",
+    "\n",
+    "In the following, we will go through the whole angular momentum channel procedure in detail to demonstrate the steps that happen behind the scenes in the functions. Note, though, that this only shows the case where the atoms return to their initial state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e7c105f6-3487-4176-8b08-6d84126a6f65",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# set atom properties\n",
+    "atom1, atom2 = Cesium(), Cesium()\n",
+    "n, l, j, mj1, s1 = 63, 0, 0.5, j, 0.5\n",
+    "nn, ll, jj, mj2, s2 = 90, 2, 2.5, jj, 0.5\n",
+    "\n",
+    "# set calculation propreties\n",
+    "nrange, dE = 10, 1*1e12\n",
+    "stateHop = False\n",
+    "\n",
+    "# set angles\n",
+    "theta_lj = np.linspace(0, np.pi*2, 501)\n",
+    "phi = np.pi/4\n",
+    "\n",
+    "# initialise PairStateInteractions class instance\n",
+    "calc = PairStateInteractions(atom, n, l, j, nn, ll, jj, m1=mj1, m2=mj2, interactionsUpTo=1)\n",
+    "\n",
+    "\n",
+    "## find all coupled angular channels\n",
+    "coupledStates = calc._findAllCoupledAngularMomentumStates(l,j,s1, ll,jj,s2, stateHopping=stateHop)\n",
+    "if coupledStates == []:\n",
+    "    raise ValueError(\"No interaction pathways found for the specified conditions.\")\n",
+    "\n",
+    "\n",
+    "## calculate angular channel values, together with channel information\n",
+    "channelData = []\n",
+    "for pathway in coupledStates:\n",
+    "    V_lj = calc._calcLJcontribution_allParamsFree(pathway, [n,s1, atom1], [nn,s2, atom2],\n",
+    "                                                  nrange, dE, stateHop, interactionsUpTo=1)\n",
+    "    channelData.append([*pathway, V_lj])\n",
+    "\n",
+    "    \n",
+    "## for all channels, construct the channel's interaction matrix and sum up to get total Imat\n",
+    "# this can also be done by feeding the channelData list into the _getPerturbativeC6Matrix_lj function\n",
+    "#Imat = calc._getPerturbativeC6Matrix_lj(channelData)\n",
+    "\n",
+    "Imat = 0\n",
+    "# iterate through channels\n",
+    "for vals in channelData:\n",
+    "    # construct mj-resolved transition matrix for first and second dipole transition\n",
+    "    d1 = calc._getd(*vals[0:8])\n",
+    "    d2 = calc._getd(*vals[4:12])\n",
+    "    # construct mj-resolved transition matrix for full process\n",
+    "    D = d2.dot(d1)\n",
+    "    # add channel to overall Imat\n",
+    "    Imat += vals[-1]*D\n",
+    "\n",
+    "\n",
+    "## Now that we have the interaction matrix at theta = 0, rotate to desired angles \n",
+    "## via Wigner matrices and save C6 value from that angle for given (mj1, mj2) pair\n",
+    "\n",
+    "C6 = []\n",
+    "\n",
+    "# get array indexing the 2-atom composite state in (mj1, mj2) basis\n",
+    "compState = compositeState(singleAtomState(j, mj1), singleAtomState(jj, mj2)).T\n",
+    "# alternatively: get index via mjInd = (j+mj1)*(jj+mj2) and then select via index rather than by state mul.\n",
+    "\n",
+    "# iterate through angles\n",
+    "for theta in theta_lj:\n",
+    "    # Wigner D matrix allows calculations with arbitrary orientation of the two atoms\n",
+    "    wgd = WignerDmatrix(theta, phi)\n",
+    "    angRotationMatrix = np.kron(wgd.get(j).toarray(),wgd.get(jj).toarray())\n",
+    "                    \n",
+    "    # rotate Imat's into correct basis for angles theta, phi (angle1, angle2)\n",
+    "    Imat_rot = angRotationMatrix.dot(Imat.dot(angRotationMatrix.conj().T))\n",
+    "\n",
+    "    # get C6 value for the correct initial and final (mj1, mj2) combination\n",
+    "    C6val = np.real(compState.dot(Imat_rot.dot(compState.T)))[0][0]\n",
+    "    C6.append(C6val)\n",
+    "\n",
+    "\n",
+    "## plot results\n",
+    "fig = plt.figure(figsize=(3,3))\n",
+    "ax = fig.add_subplot(1,1,1, projection='polar')\n",
+    "\n",
+    "# plot \n",
+    "ax.plot(theta_lj, C6, color='darkgray', linewidth=3)\n",
+    "ax.set_xticks([0, np.pi/2, np.pi, 3*np.pi/2], ['0', r'$\\pi$/2', r'$\\pi$', r'$3\\pi$/2'])\n",
+    "ax.set_yticks([])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8df6f16-e4f4-4faf-a9b9-a75102ab8a64",
+   "metadata": {},
+   "source": [
+    "## study composition of C6 into angular channels\n",
+    "We will do the same procedure as above, but this time resolve the different angular channels so that one can see how the resulting C6 is composed of a sum of the different angular channels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "94550398-3c7e-4296-b53e-062b1664f50e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "angular channels (l, j, ll, jj each for init, interm. fin) and associated channel value C^(lj)\n",
+      "(0, 0.5, 2, 2.5, 1, 0.5, 1, 1.5, 0, 0.5, 2, 2.5) with C^(lj) = 100.892 GHz um^6\n",
+      "(0, 0.5, 2, 2.5, 1, 0.5, 3, 2.5, 0, 0.5, 2, 2.5) with C^(lj) = 46.497 GHz um^6\n",
+      "(0, 0.5, 2, 2.5, 1, 0.5, 3, 3.5, 0, 0.5, 2, 2.5) with C^(lj) = 46.497 GHz um^6\n",
+      "(0, 0.5, 2, 2.5, 1, 1.5, 1, 1.5, 0, 0.5, 2, 2.5) with C^(lj) = 36.874 GHz um^6\n",
+      "(0, 0.5, 2, 2.5, 1, 1.5, 3, 2.5, 0, 0.5, 2, 2.5) with C^(lj) = -74.288 GHz um^6\n",
+      "(0, 0.5, 2, 2.5, 1, 1.5, 3, 3.5, 0, 0.5, 2, 2.5) with C^(lj) = -74.288 GHz um^6\n",
+      "\n",
+      " max. |C6| value for mj1=0.5 and mj2=2.5 is 1.381 GHz um^6\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 750x350 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# set atom properties\n",
+    "atom1, atom2 = Cesium(), Cesium()\n",
+    "n, l, j, mj1, s1 = 63, 0, 0.5, 0.5, 0.5\n",
+    "nn, ll, jj, mj2, s2 = 90, 2, 2.5, 2.5, 0.5\n",
+    "\n",
+    "# set calculation propreties\n",
+    "nrange, dE = 10, 1*1e12\n",
+    "stateHop = False\n",
+    "\n",
+    "# set angles\n",
+    "theta_lj = np.linspace(0, np.pi*2, 501)\n",
+    "phi = np.pi/4\n",
+    "\n",
+    "# initialise PairStateInteractions class instance\n",
+    "calc = PairStateInteractions(atom, n, l, j, nn, ll, jj, m1=mj1, m2=mj2, interactionsUpTo=1)\n",
+    "\n",
+    "\n",
+    "## find all coupled angular channels\n",
+    "coupledStates = calc._findAllCoupledAngularMomentumStates(l,j,s1, ll,jj,s2, stateHopping=stateHop)\n",
+    "if coupledStates == []:\n",
+    "    raise ValueError(\"No interaction pathways found for the specified conditions.\")\n",
+    "\n",
+    "\n",
+    "## calculate angular channel values, together with channel information\n",
+    "channelData = []\n",
+    "print('angular channels (l, j, ll, jj each for init, interm. fin) and associated channel value C^(lj)')\n",
+    "for pathway in coupledStates:\n",
+    "    V_lj = calc._calcLJcontribution_allParamsFree(pathway, [n,s1, atom1], [nn,s2, atom2],\n",
+    "                                                  nrange, dE, stateHop, interactionsUpTo=1)\n",
+    "    channelData.append([*pathway, V_lj])\n",
+    "    print(pathway, 'with C^(lj) = {:.3f} GHz um^6'.format(V_lj))\n",
+    "\n",
+    "    \n",
+    "## for all channels, construct the channel's own Imat and plot. Later, sum up all channel's Imats to get overall C6, plot\n",
+    "\n",
+    "# create figure and axis instance\n",
+    "fig = plt.figure(figsize=(7.5, 3.5))\n",
+    "gs = GridSpec(1,2, wspace=0.2)\n",
+    "ax = []\n",
+    "for i in range(2):\n",
+    "    ax.append(fig.add_subplot(gs[i], projection='polar'))\n",
+    "\n",
+    "# get array indexing the 2-atom composite state in (mj1, mj2) basis\n",
+    "compState = compositeState(singleAtomState(j, mj1), singleAtomState(jj, mj2)).T\n",
+    "# alternatively: get index via mjInd = (j+mj1)*(jj+mj2) and then select via index rather than by state mul.\n",
+    "\n",
+    "# compute Wigner-D matrices for specified angles to avoid having to compute them multiple times\n",
+    "wigD = np.zeros((int((2*j+1)*(2*jj+1)),int((2*j+1)*(2*jj+1)),len(theta_lj)), dtype=complex)\n",
+    "for i, theta in enumerate(theta_lj):\n",
+    "    wgd = WignerDmatrix(theta, phi)\n",
+    "    wigD[:,:,i] = np.kron(wgd.get(j).toarray(), wgd.get(jj).toarray())\n",
+    "\n",
+    "C62 = np.zeros(len(theta_lj))\n",
+    "\n",
+    "# iterate through channels\n",
+    "for i, vals in enumerate(channelData):\n",
+    "    # construct mj-resolved transition matrix for first and second dipole transition\n",
+    "    d1 = calc._getd(*vals[0:8])\n",
+    "    d2 = calc._getd(*vals[4:12])\n",
+    "    # construct full mj-resolved transition matrix for channel\n",
+    "    Imat_lj = vals[-1]*d2.dot(d1)\n",
+    "    \n",
+    "    C6_lj = np.zeros(len(theta_lj))\n",
+    "    \n",
+    "    # iterate through angles\n",
+    "    for k, theta in enumerate(theta_lj):\n",
+    "        # get correct Wigner-D matrix\n",
+    "        angRotationMatrix = wigD[:,:,k]\n",
+    "                    \n",
+    "        # rotate Imat's into correct basis for angles theta, phi (angle1, angle2)\n",
+    "        Imat_rot = angRotationMatrix.dot(Imat_lj.dot(angRotationMatrix.conj().T))\n",
+    "\n",
+    "        # get C6 value for the correct initial and final (mj1, mj2) combination\n",
+    "        C6val = np.real(compState.dot(Imat_rot.dot(compState.T)))[0][0]\n",
+    "        C6_lj[k] = C6val\n",
+    "\n",
+    "    # plot into polar plot\n",
+    "    ax[0].plot(theta_lj, np.where(C6_lj > 0, C6_lj, np.nan), ls='solid', lw=3, color=(i/len(channelData), 0.3, 1-i/len(channelData))) # >0: solid line\n",
+    "    ax[0].plot(theta_lj, np.where(C6_lj < 0, -C6_lj, np.nan), ls='dashdot', lw=3, color=(i/len(channelData), 0.3, 1-i/len(channelData))) # <0: dashdot\n",
+    "    \n",
+    "    \n",
+    "    #add to overall C6\n",
+    "    C62 += C6_lj\n",
+    "\n",
+    "# print max. C6 value\n",
+    "print('\\n max. |C6| value for mj1={:.1f} and mj2={:.1f} is {:.3f} GHz um^6'.format(mj1, mj2, np.max(np.abs(C6))))\n",
+    "\n",
+    "\n",
+    "## plot overall C6\n",
+    "ax[1].plot(theta_lj, C62, color='darkgray', linewidth=3)\n",
+    "for axis in ax:\n",
+    "    axis.set_xticks([0, np.pi/2, np.pi, 3*np.pi/2], ['0', r'$\\pi$/2', r'$\\pi$', r'$3\\pi$/2'])\n",
+    "    axis.set_yticks([])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5ed7ae7",
+   "metadata": {},
+   "source": [
+    "#### For those who want to play around with angular channels to learn more:\n",
+    "The function _calcLJcontribution_allParamsFree allows the user complete freedom over all parameters that could be varied."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}