ONV 1.0.1__tar.gz → 1.0.4__tar.gz

{onv-1.0.1 → onv-1.0.4}/ONV.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ONV
-Version: 1.0.1
+Version: 1.0.4
 Summary: Package for general NV based simulations
 Author: Oliver Whaites
 Author-email: o.whaites@btinternet.com
@@ -11,5 +11,11 @@ Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: keywords
+Dynamic: summary
 
-A basic package of functions which are commonly used in the simuitons of NV centers fro quantum computing and NMR sensing
+A basic package of functions which are commonly used in the simuitons of NV centers from quantum computing and NMR

{onv-1.0.1 → onv-1.0.4}/ONV.egg-info/SOURCES.txt

@@ -1,4 +1,4 @@
-setup_ONV.py
+setup.py
 ONV.egg-info/PKG-INFO
 ONV.egg-info/SOURCES.txt
 ONV.egg-info/dependency_links.txt
@@ -6,6 +6,8 @@ ONV.egg-info/top_level.txt
 cce/CCE.py
 cce/PCE.py
 cce/__init__.py
+nmr/__init__.py
+nmr/nmr.py
 nv/__init__.py
 nv/nv.py
 p1/__init__.py

{onv-1.0.1 → onv-1.0.4}/ONV.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 cce
+nmr
 nv
 p1
 tools

{onv-1.0.1 → onv-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ONV
-Version: 1.0.1
+Version: 1.0.4
 Summary: Package for general NV based simulations
 Author: Oliver Whaites
 Author-email: o.whaites@btinternet.com
@@ -11,5 +11,11 @@ Classifier: Programming Language :: Python :: 2
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: keywords
+Dynamic: summary
 
-A basic package of functions which are commonly used in the simuitons of NV centers fro quantum computing and NMR sensing
+A basic package of functions which are commonly used in the simuitons of NV centers from quantum computing and NMR

{onv-1.0.1 → onv-1.0.4}/cce/CCE.py

@@ -99,7 +99,7 @@ def CCE1(spins,couplings,ts,params = nv.params(),pbar = True,NV_state = 'Xp',mea
     operators, params = nv.generate_operators([0], [0],params = params, NV_state = NV_state,NV_sub = NV_sub)
 
 
-    Dir += '{}_data/1_spin/'.format(cluster)
+    Dir = '{}_data/1_spin/'.format(cluster)
 
 
     # PCE4 = pd.DataFrame(columns = ['P3'], index = taus*1e6)
@@ -108,7 +108,7 @@ def CCE1(spins,couplings,ts,params = nv.params(),pbar = True,NV_state = 'Xp',mea
     
         
     if path.exists(Dir + filename):
-        done = pd.read_csv(Dir + filename,index_col = 0).values.tolist()
+        done = pd.read_csv(Dir + filename,index_col = 0)['0'].values.tolist()
         
     else: done = []
     done = []

onv-1.0.4/nmr/__init__.py

@@ -0,0 +1 @@
+from .nmr import nv_bubble

onv-1.0.4/nmr/nmr.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Jul 15 15:07:41 2024
+
+@author: ollywhaites
+"""
+from sys import path
+path.append('/Users/ollywhaites/Documents/Documents/PhD/Python/Libraries/')
+
+import numpy as np
+import NV_Library as nv
+import qutip
+
+import matplotlib.pyplot as plt
+
+
+
+options = qutip.solver.Options()
+options.store_states = True 
+
+"""
+
+"""
+
+
+
+class nv_bubble:
+    
+    
+    
+    def __init__(self,seed,d = 7e-9,rho = 670,b = 7.7e-9,species = 'H',params = nv.params(),alpha = np.radians(45)):   
+        
+        np.random.seed(seed)
+        
+        N = int(4*rho*(b*1e9)**3)
+        #N = 1
+        
+        X = b*(-1 + 2*np.random.random(N))
+        Y = b*(-1 + 2*np.random.random(N))
+        Z = d + b*np.random.random(N)
+
+     
+        A = [nv.hyperfine(nv.y_rotation(np.array([x,y,z]),alpha),params = params,species = species) for x,y,z in zip(X,Y,Z)]
+        
+        phi = 2*np.pi*np.random.random(N)
+        theta = np.arccos(2*np.random.random(N) - 1)
+        #theta = 2*np.random.random(N)
+        
+        self.positions = np.array([Z,Y,Z]).T
+        self.coupings = A
+        self.states = np.array([theta,phi]).T
+        self.spins = N
+        
+        self.depth = d
+        self.ppm = rho
+        self.species = species
+        self.bubble_radius = b
+        self.params = params
+        self.nv_angle = alpha
+    
+        np.random.seed(None)
+        
+    def find_classical(self):
+        
+        params = self.params
+        species = self.species
+        
+        x = self.positions.T[0]
+        y = self.positions.T[1]
+        z = self.positions.T[2]
+        
+        theta = self.states.T[0]
+        
+        r = np.sqrt(x**2 + y**2 + z**2)
+        
+        a0 = 3*params['mu_red']*params['gamma_%s'%species]*params['h']*np.cos(theta)*(3*z*z - r**2)/(4*np.pi*r**5)
+        a = abs(3*params['mu_red']*params['gamma_%s'%species]*params['h']*np.sin(theta)*np.sqrt((z*x)**2 + (z*y)**2)/(4*np.pi*r**5))
+        phi1 = np.arctan2(y,x)
+        
+        self.class_field = np.array([a0,a,phi1]).T
+        self.find_mag()
+        
+        
+    def find_mag(self):
+        
+        class_field = self.class_field
+        a0 = class_field.T[0]
+        a = class_field.T[1]
+        phi = class_field.T[2]
+        
+        mag_theta = np.arctan(a.sum()/a0.sum())
+        B = np.sqrt(a.sum()**2 + a0.sum()**2)
+        
+        self.mag_theta = mag_theta
+        self.B = B
+        self.mag_phi = phi.sum()
+        
+        
+        
+    def plot_xy(self,b,d,params,species,fig,ax):
+        
+        
+        X = np.linspace(-b,b,100)
+        Y = np.linspace(-b,b,100)
+        Z = d
+        
+        x,y = np.meshgrid(X,Y)
+        AXY = []
+        for x1,y1 in zip(x,y):
+            AXYtemp = []
+            for x2,y2 in zip(x1,y1):
+        
+                xn,yn,zn = nv.y_rotation(np.array([x2,y2,Z]), self.nv_angle,passive = True)
+        
+            #xn,yn,zn = np.meshgrid(Xn,Yn,Zn)
+                r = np.sqrt(xn**2 + yn**2 + zn**2)
+        
+        
+                aXY =  abs(3*params['mu_red']*params['gamma_%s'%species]*params['h']/(4*np.pi*r**5)*np.sqrt((zn*xn)**2 + (zn*yn)**2))
+                AXYtemp.append(aXY)
+                
+            AXY.append(AXYtemp)
+        
+        ax.contourf(x*1e9,y*1e9,np.array(AXY))
+        
+        ax.set_ylabel('y (nm)',fontsize = 12)
+        ax.set_xlabel('x (nm)',fontsize = 12)
+        
+    def plot_xz(self,b,d,params,species,fig,ax):
+        
+        X = np.linspace(-b,b,100)
+        Y = 0
+        Z = np.linspace(d,d + b,100)
+        
+        x,z = np.meshgrid(X,Z)
+        AXZ = []
+        for x1,z1 in zip(x,z):
+            AXZtemp = []
+            for x2,z2 in zip(x1,z1):
+        
+                xn,yn,zn = nv.y_rotation(np.array([x2,Y,z2]), self.nv_angle,passive = True)
+        
+            #xn,yn,zn = np.meshgrid(Xn,Yn,Zn)
+                r = np.sqrt(xn**2 + yn**2 + zn**2)
+        
+        
+                aXZ =  abs(3*params['mu_red']*params['gamma_%s'%species]*params['h']/(4*np.pi*r**5)*np.sqrt((zn*xn)**2 + (zn*yn)**2))
+                AXZtemp.append(aXZ)
+                
+            AXZ.append(AXZtemp)
+        
+        ax.contourf(x*1e9,z*1e9,np.array(AXZ))
+        
+        B = self.B
+        theta  = self.mag_theta
+        
+        vec = [np.sin(theta),0,np.cos(theta)]
+        vecNew = nv.y_rotation(np.array(vec), -self.nv_angle,passive = True)
+        
+        #ax.plot([b/2,b*vecNew[0]/4],[d + b/2,d + b/2 +  b*vecNew[2]/4],color = 'k')
+        ax.arrow(0, d*1e9 + b*1e9/2, vecNew[0]*(B/(self.spins*1e-10))*(b*1e9/4),vecNew[2]*(B/(self.spins*1e-10))*(b*1e9/4),
+                  head_width=b*1e9/70,
+                  length_includes_head=True,
+                  head_length=b*1e9/70,
+                  color = 'w',
+                  lw = 3)
+        
+        ax.text(0, d*1e9 + b*1e9/2,r'$\mathbf{M}$',fontsize = 12,color = 'w',va = 'top')
+        
+        ax.set_ylabel('z (nm)',fontsize = 12)
+        ax.set_xlabel('x (nm)',fontsize = 12)
+        
+    def plot_bubble(self):
+        
+        b = self.bubble_radius
+        d = self.depth
+        
+        params = self.params
+        species = self.species
+        
+        fig,axes = plt.subplots(1,2,figsize = [9,4],dpi = 200)
+        
+        self.plot_xy(b,d,params,species,fig,axes[0])
+        self.plot_xz(b,d,params,species,fig,axes[1])
+        
+        
+        
+        
+
+def generate_bubble(d = 7e-9,rho = 670,b = 7.7e-9,species = 'H',params = nv.params(),ts = np.linspace(0,5e-6,100)):
+    
+    
+    
+    N = 4*rho*(b*1e9)**3
+    
+    x = -b + 2*b*np.random.random(int(N))
+    y = -b + 2*b*np.random.random(int(N))
+    z = d + b*np.random.random(int(N))
+    
+
+    r = np.sqrt(x**2 + y**2 + z**2)
+    
+    a = abs(3*params['mu_red']*params['gamma_%s'%species]*params['h']/(4*np.pi*r**5)*np.sqrt((z*x)**2 + (z*y)**2))
+    phi1 = np.arctan2(y,x)
+    
+    phi = 2*np.pi*np.random.random(int(N))
+    theta = np.arccos(2*np.random.random(int(N)) - 1)
+    
+    omegaL = 2*np.pi*params['B0']*params['gamma_%s'%species]
+    
+    B = 0
+    B2 = 0
+    for ai,t,p,p1 in zip(a,theta,phi,phi1):
+        B += ai*np.sin(t)*np.cos(omegaL*ts + (p - p1))
+        B2 += ai*np.sin(t)*np.cos(omegaL*ts - (p + p1))
+
+    return B, B2
+
+
+
+def generate_mag_bubble(b_rms = 4e-9,species = 'H',params = nv.params(),seed_b = None,seed_theta = None,seed_phi = None):
+    
+    np.random.seed(seed_phi)
+    phi = 2*np.pi*np.random.random()
+    
+    np.random.seed(seed_theta)
+    theta = np.arccos(2*np.random.random() - 1)
+    
+    np.random.seed(seed_b)
+    #b = np.random.normal(0,b_rms)
+    b = 500e-9
+    
+
+    return b,theta,phi
+
+
+def hahn(operators,args,H,t_lim = [0,2e-6],s = 200):
+    
+    
+    t0 = t_lim[0]
+    tf = t_lim[1]
+    
+    UY = (-1j*np.pi*operators['Sy']/2).expm()
+    UX = (-1j*np.pi*operators['Sx']/2).expm()
+    
+    rho = UY*operators['rho']*UY.dag()
+    
+    
+    output = qutip.mesolve(H,rho,np.linspace(t0,(t0 + tf)/2,s),e_ops = [operators['Sx']],args = args,options = options)
+    rho = output.states[-1]
+    
+    rho = (UY*UY)*rho*(UY*UY).dag()
+    
+    #args['phi'] = phi0 + args['nu']
+    output = qutip.mesolve(H,rho,np.linspace((t0 + tf)/2,tf,s),e_ops = [operators['Sx']],args = args,options = options)
+    rho = output.states[-1]
+    
+    #args['phi'] = phi0 + 2*args['nu']*tau
+
+    rho = UX*rho*UX.dag()
+    
+    coh = (rho*operators['Sz']).tr()
+    
+    return coh, rho
+
+def hahn_test(operators,args,H0,M,tau,s = 100):
+    
+    
+    dt = tau/s
+    
+    UY = (-1j*np.pi*operators['Sy']/2).expm()
+    UX = (-1j*np.pi*operators['Sx']/2).expm()
+    
+    rho = UY*operators['rho']*UY.dag()
+    
+    rho,M = evolve(H0,M,rho,dt,s, args)
+    
+    rho = (UY*UY)*rho*(UY*UY).dag()
+    
+    #args['phi'] = phi0 + args['nu']
+    rho,M = evolve(H0,M,rho,dt,s, args)
+    
+    #args['phi'] = phi0 + 2*args['nu']*tau
+
+    rho = UX*rho*UX.dag()
+    
+    
+    return rho, M
+
+
+def class_field(M,args):
+
+    return M[0]
+    
+    
+
+def evolve(H0,M,rho,dt,N, args):
+    
+    #evolve state
+    for n in range(N):
+        
+        U0 = (-1j*class_field(M,args)*H0*dt).expm()
+        
+        rho = U0*rho*U0.dag()
+        
+        M = nv.xy_rotation(M,args['Omega']*dt,args['phase'])
+        M = nv.z_rotation(M,args['nu']*dt)
+        
+        
+    return rho, M
+
+
+
+
+
+        
+    
+    
+    

{onv-1.0.1 → onv-1.0.4}/nv/nv.py

@@ -70,6 +70,7 @@ def params():
     params['Omega'] = np.pi/params['Tp']
     params['tau'] = 0#the wait time of the pulse protocol
     params['t_ev'] = 0
+    params['tau_offset'] = 0
     params['delta'] = 0#any pulse error introduced
     params['protocol'] = 'CPMG'
     params['pulse_profile'] = 'inst'
@@ -180,6 +181,7 @@ def xy_rotation(vec,theta,phase):
                   [uz*ux*(1 - c) - uy*s,uz*uy*(1 - c) + ux*s,c + uz**2*(1 - c)]])
     
     return R.dot(vec)  
+
   
 # a function which changes the basis of the lattice coordinates to one in line with NV-axis
 def change_basis(vec):
@@ -238,12 +240,13 @@ def hyperfine(r,params = params(),species = 'C'):
 
 
 #returns the density matrix for a qubit up state 
-def rhoU():
+def rhoU(params = params(), species = 'C'):
+    
     
     return qutip.Qobj([[1,0],[0,0]]);
 
 #returns the density matrix for a qubit down state 
-def rhoD():
+def rhoD(params = params(), species = 'C'):
     
     return  qutip.Qobj([[0,0],[0,1]]);
 
@@ -263,6 +266,8 @@ def rhoT(params = params(), species = 'C'):
     s = species_spin[species]
     
     r =(-(params['h']*params[f'gamma_{species}']*params['B0']*Iz(s))/(2*np.pi*params['k_B']*params['Temp'])).expm();
+    
+    r = qutip.identity(s)
 
     return r/r.tr()
 #returns the density matrix for a qubit in a thermal state
@@ -500,7 +505,8 @@ def generate_operators(Az, Ax,species = None, params = params(), NV_state = 'up'
 
     NV_dict = {'-':qubit_Szm(),
                '+':qubit_Szp(),
-               '+-':qubit_Szm() + qubit_Szp()}
+               '+-':qubit_Szm() + qubit_Szp(),
+               '1/2':(1/2)*qutip.Qobj([[1,0],[0,-1]])}
     
     dict_operators = {}
     #compute the number of nuclei in the system
@@ -574,7 +580,8 @@ def generate_operators(Az, Ax,species = None, params = params(), NV_state = 'up'
       
     dict_operators['H0'] = H0;
     
-      
+    dict_operators['UX'] = (-1j*dict_operators['Sx']*np.pi).expm()
+    dict_operators['UY'] = (-1j*dict_operators['Sy']*np.pi).expm()  
     
     return dict_operators,params
 
@@ -618,13 +625,14 @@ def add_N14(operators,params,couplings,TN = 3):
     
     params['N_nuc'] += 1
     
-    r0 = qutip.Qobj([[1,0,0],[0,1,0],[0,0,1]])
+    r0 = qutip.Qobj([[1,0,0],[0,0,0],[0,0,0]])
     #r0 = (-state_3_Sz()/TN).expm()
+    #r0 = rhoT(params = params, species = '14N')
 
     
     operators['rho0'] = qutip.tensor(operators['rho0'],r0/r0.tr())
     
-    Az = -2*np.pi*2.164689e6
+    Az = -2*np.pi*2.162e6
     Ax = -2*np.pi*2.632e6
     
     omega = np.sqrt((params['B0']*2*np.pi*params['gamma_N'] + Az/2)**2 + (Ax/2)**2)
@@ -634,7 +642,7 @@ def add_N14(operators,params,couplings,TN = 3):
     #                   'Az': Az,
     #                   'omega': omega},ignore_index = True)
     
-    couplings = pd.concat([couplings, pd.DataFrame([{'Species': 'N',
+    couplings = pd.concat([couplings, pd.DataFrame([{'Species': '14N',
                       'Ax': Ax,
                       'Az': Az,
                       'omega': omega}],index = [0])],ignore_index = True)
@@ -687,7 +695,7 @@ def generate_H0(operators,couplings,params):
     
     operators['H0'] = H0;
     
-    
+
 
     return operators
 
@@ -785,8 +793,11 @@ def inst_pulse(operators,params,rot = np.pi):
     Omega = (abs(rot + delta))/Tp
         
     
-    UX = (-1j*(np.sign(rot)*Omega*operators['Sx'])*Tp).expm();
-    UY = (-1j*(np.sign(rot)*Omega*operators['Sy'])*Tp).expm();
+    #UX = (-1j*(np.sign(rot)*Omega*operators['Sx'])*Tp).expm();
+    #UY = (-1j*(np.sign(rot)*Omega*operators['Sy'])*Tp).expm();
+    
+    UX = operators['UX']
+    UY = operators['UY']
     
     return UX, UY
 
@@ -1073,7 +1084,7 @@ def CPMG(operators, params,measure):
     tau = params['tau'];
     profile = params['pulse_profile']
     
-    params['t_ev'] = tau/2
+    params['t_ev'] = tau
     
     if params['decoherence'] == False:
     
@@ -1100,6 +1111,75 @@ def CPMG(operators, params,measure):
         
     else: raise Exception('Invalid value for params["decoherence"]. Must be bool not {params["decoherence"]}.')
         
+ 
+# a function which takes a free evolution operator and pulse operators and returns a packet of CPMG. Note that UX must be a pi/2 pulse
+def Hahn(operators, params,measure):
+    
+    """
+    a function which constructs the pulse packet for a Hahn sequence using free evolution 
+    and pi/2 pulses. pulse errors, delta, may be included as Tp = (np.pi + delta)/2.
+    Hahn sequence here is U0*UX*U0
+    
+    Parameters
+    ----------
+    
+        operators: a dict of operators for the system which can be retrieved using the 
+                generate operators function
+        params: dict of system parameters which define the protocol. Can be found 
+                using the params() function
+        inst: bool to determine whether pulses are instantaneous. Default is False
+        
+        
+    returns
+    -------
+    
+        U: Qobj for the CPMG pulse packet
+    """
+    
+    tau = params['tau'];
+    dtau = params['tau_offset']
+    profile = params['pulse_profile']
+    
+    params['t_ev'] = tau
+    
+    if params['decoherence'] == False:
+    
+        if dtau == 0:
+            U0 = (-1j*operators['H0']*params['t_ev']).expm();
+            
+            
+            UX, UY = pulse_profiles[profile](operators,params,rot = np.pi)
+                
+            
+            U = (U0*UX*U0)**params['Np']
+        
+            rho = U*operators['rho0']*U.dag();
+            
+            coh = (operators['S%s'%measure]*rho).tr().real
+            
+        else:
+            U01 = (-1j*operators['H0']*(params['t_ev'] + dtau)).expm();
+            U02 = (-1j*operators['H0']*(params['t_ev'] - dtau)).expm();
+            
+            
+            UX, UY = pulse_profiles[profile](operators,params,rot = np.pi)
+                
+            
+            U = (U02*UX*U01)**params['Np']
+        
+            rho = U*operators['rho0']*U.dag();
+            
+            coh = (operators['S%s'%measure]*rho).tr().real
+            
+        
+        return coh,rho, U
+    
+    elif params['decoherence'] == False:
+        raise Exception('Decoherence has not been initialised with this pulse protocol.')
+        
+        
+        
+    else: raise Exception('Invalid value for params["decoherence"]. Must be bool not {params["decoherence"]}.')
         
 
 # a function which takes a free evolution operator and pulse operators and returns a packet of CPMG. Note that UX must be a pi/2 pulse
@@ -1130,7 +1210,7 @@ def spin_locking(operators, params,measure):
     tau = params['tau'];
 
     
-    params['t_ev'] = tau/2
+    params['t_ev'] = tau
 
         
     if params['decoherence'] == False:
@@ -1467,7 +1547,8 @@ def pulse_NV(operators,params,measure = 'x'):
                       'Free':Free,
                       'spin_locking':spin_locking,
                       'Ramsey': Ramsey,
-                      'PMC': PMC};
+                      'PMC': PMC,
+                      'Hahn':Hahn};
     
     
     
@@ -1888,7 +1969,7 @@ def plot_D_pol_N(P_df,fig_size = [7,4],fig = None, ax = None, plot_avg = True,ti
 FLOQUET
 """
     
-def floquet_spectrum(operators,params,taus, bound = 1,tan2 = False,inst = True):
+def floquet_spectrum(operators,params,species,taus, bound = 1,tan2 = False):
         
     """
     A function which takes the free Hamiltonian of a system and a partiuclar pulse
@@ -1914,34 +1995,40 @@ def floquet_spectrum(operators,params,taus, bound = 1,tan2 = False,inst = True):
     N_nuc = params['N_nuc'];
     protocol = params['protocol']
     
+    if species == None:
+        species = []
+        for i in range(params['N_nuc']):
+            species.append('C')
+    print(species)
+    species.insert(0, 'NV')
     
     ''' find the unperturbed starting floquet states '''
     params['tau'] = 1e-9;
     
-    U_ini =  protocols_dict[protocol](operators,params,inst);
+    _,_,U_ini =  protocols_dict[protocol](operators,params,measure = 'z');
     lbda, vecOld = U_ini.eigenstates(sort = 'low');
     
-    
+    space_size = np.array([species_spin[s] for s in species])
     
     
     ''' initialise arrays '''
     E = []
     Vec = []
     wind = [];
-    for i in range(2**(N_nuc + 1)):
+    for i in range(space_size.prod()):
         
         E.append([]);
         Vec.append([])
         wind.append(0);
 
     ''' run through tau array and find all floquet phases and states '''   
-    for j in pb.progressbar(range(len(taus))):
+    for j in tqdm(range(len(taus))):
         
         states = []
         params['tau'] = taus[j]
         
 
-        U = protocols_dict[protocol](operators,params,inst);
+        _,_,U = protocols_dict[protocol](operators,params,measure = 'z');
         
         lbda,vectemp = U.eigenstates(sort = 'low');
         
@@ -1997,7 +2084,7 @@ def floquet_spectrum(operators,params,taus, bound = 1,tan2 = False,inst = True):
             vecNew[states[n]] = vectemp[n] 
         vecOld = vecNew;
         
-        return E,Vec
+    return E,Vec
     
 
     

{onv-1.0.1 → onv-1.0.4}/p1/p1.py

@@ -80,25 +80,32 @@ def construct_H0(operators,params,spins,bath,Tin):
         if Tin == True:
             AN = find_axisCoup(Adiag,axis = bath.loc[i]['JT_axis'].iloc[1])[2]
             
-            Hi += (params['D']*operators['Iz'][2*k + 0] + 2*np.pi*params['gamma_e']*params['B0']*operators['Iz'][2*k + 0] + 2*np.pi*params['gamma_N']*params['B0']*operators['Iz'][2*k + 1] 
-                   + (AN[2]*operators['Iz'][2*k  + 1] + AN[0]*operators['Ix'][2*k  + 1] + AN[1]*operators['Iy'][2*k  + 1])*operators['Iz'][2*k + 0]
+            Hi += (params['D']*operators['Iz'][2*k + 0] + 0*2*np.pi*params['gamma_N']*params['B0']*operators['Iz'][2*k + 1] 
+                   + 0*(AN[2]*operators['Iz'][2*k  + 1] + AN[0]*operators['Ix'][2*k  + 1] + AN[1]*operators['Iy'][2*k  + 1])*operators['Iz'][2*k + 0]
                    #+ tensor_prod(operators,2*k  + 1,2*k + 1,PN)
                    + 2*np.pi*1e3*(bath.loc[i]['Az'].iloc[1]*operators['Iz'][2*k  + 0])*operators['Sz']
                    + params['Omega_RF']*(np.sin(params['RF_phase'])*operators['Ix'][2*k  + 0] + np.cos(params['RF_phase'])*operators['Iy'][2*k  + 0])
-                   + params['Omega_N']*(np.sin(params['N_phase'])*operators['Ix'][2*k  + 1] + np.cos(params['N_phase'])*operators['Iy'][2*k  + 1]))
-            
+                   #+ params['Omega_N']*(np.sin(params['N_phase'])*operators['Ix'][2*k  + 1] + np.cos(params['N_phase'])*operators['Iy'][2*k  + 1]))
+            )
         elif Tin == False:
-            AN = find_axisCoup(Adiag,axis = bath.loc[i]['JT_axis'].iloc[1])
+            #AN = find_axisCoup(Adiag,axis = bath.loc[i]['JT_axis'].iloc[1])
+            AN = find_axisCoup(Adiag,axis = bath.loc[i]['JT_axis'].iloc[1])[2]
               
             Hi += (2*np.pi*params['gamma_e']*params['B0']*operators['Iz'][2*k + 0]  + 2*np.pi*params['gamma_N']*params['B0']*operators['Iz'][2*k + 1] 
-                   + tensor_prod(operators,2*k  + 0,2*k + 1,AN)
-                   #+ (AN[2]*operators['Iz'][2*k  + 1] + AN[0]*operators['Ix'][2*k  + 1] + AN[1]*operators['Iy'][2*k  + 1])*operators['Iz'][2*k + 0]
-                   + tensor_prod(operators,2*k  + 1,2*k + 1,PN)
+                   + (AN[2]*operators['Iz'][2*k  + 1] + AN[0]*operators['Ix'][2*k  + 1] + AN[1]*operators['Iy'][2*k  + 1])*operators['Iz'][2*k + 0]
+                   #+ tensor_prod(operators,2*k  + 1,2*k + 1,PN)
                    + 2*np.pi*1e3*(bath.loc[i]['Az'].iloc[1]*operators['Iz'][2*k  + 0])*operators['Sz']
-                   #+ 2*np.pi*1e3*(bath.loc[i]['Az'].iloc[1]*operators['Iz'][2*k  + 0] + bath.loc[i]['Ax'].iloc[1]*operators['Ix'][2*k  + 0] + bath.loc[i]['Ay'].iloc[1]*operators['Iy'][2*k  + 0])*operators['Sz']
-                   #+ 2*params['Omega']*(np.sin(params['omega_RF']*params['t'] - params['RF_phase'])*operators['Ix'][2*k  + 0]))
                    )
             
+            # Hi += (2*np.pi*params['gamma_e']*params['B0']*operators['Iz'][2*k + 0]  + 2*np.pi*params['gamma_N']*params['B0']*operators['Iz'][2*k + 1] 
+            #        + tensor_prod(operators,2*k  + 0,2*k + 1,AN)
+            #        #+ (AN[2]*operators['Iz'][2*k  + 1] + AN[0]*operators['Ix'][2*k  + 1] + AN[1]*operators['Iy'][2*k  + 1])*operators['Iz'][2*k + 0]
+            #        + tensor_prod(operators,2*k  + 1,2*k + 1,PN)
+            #        + 2*np.pi*1e3*(bath.loc[i]['Az'].iloc[1]*operators['Iz'][2*k  + 0])*operators['Sz']
+            #        #+ 2*np.pi*1e3*(bath.loc[i]['Az'].iloc[1]*operators['Iz'][2*k  + 0] + bath.loc[i]['Ax'].iloc[1]*operators['Ix'][2*k  + 0] + bath.loc[i]['Ay'].iloc[1]*operators['Iy'][2*k  + 0])*operators['Sz']
+            #        #+ 2*params['Omega']*(np.sin(params['omega_RF']*params['t'] - params['RF_phase'])*operators['Ix'][2*k  + 0]))
+            #        )
+            
 
         for j in spins[k + 1:]:
 
@@ -108,6 +115,8 @@ def construct_H0(operators,params,spins,bath,Tin):
             
             
             Cij = 2*np.pi*nv.cc_coupling(r1,r2,params = params,species = 'e')
+            #Cij = 2*np.pi*2e6
+            
             
             Hij += Cij*(operators['Iz'][2*k  + 0]*operators['Iz'][2*k + 2] - (1/2)*(operators['Ix'][2*k  + 0]*operators['Ix'][2*k + 2] + operators['Iy'][2*k  + 0]*operators['Iy'][2*k + 2]))
 
@@ -162,47 +171,47 @@ def LG4(operators,params,bath,spins,Tin):
 def LG(operators,params,bath,spins,Tin):
 
     operators,params = construct_H0(operators,params,spins,bath,Tin)
-    rho,coh, U = nv.pulse_NV(operators,params,measure = 'x',)
+    coh,rho, U = nv.pulse_NV(operators,params,measure = 'x',)
     
-    return U
+    return U,rho,coh
 
 def LG_pulse(operators,params,bath,spins,Tin):
 
-    D = params['D']
     OmRF = params['Omega_RF']
-    OmN = params['Omega_N']
-    Om = params['Omega']
-    alpha = params['RF_phase']  
+    protocol = params['protocol']
     t_ev = params['t_ev']
+    shift = params['Tp_RF'] if protocol == 'Hahn' else 0
     
 
-    params['D'] = 0
-    params['Omega_RF'] = OmRF
-    params['Omega_N'] = 0
-    params['RF_phase'] = alpha
-    
+
+    params['Omega_RF'] = 0
+    params['t_ev'] = t_ev + shift/2
     
+    params['tau_offset'] = shift/2
+
     operators,params = construct_H0(operators,params,spins,bath,Tin)
-    _,_, U0 = nv.pulse_NV(operators,params,measure = 'x',)
+    _,_, U01 = nv.pulse_NV(operators,params,measure = 'x',)
     
+    params['tau_offset'] = -shift/2
+
+    operators,params = construct_H0(operators,params,spins,bath,Tin)
+    _,_, U02 = nv.pulse_NV(operators,params,measure = 'x',)
     
-    params['D'] = 0
-    params['Omega_RF'] = 0
-    params['Omega_N'] = OmN
-    params['Omega'] = 0
-    params['RF_phase'] = alpha + np.pi/2
     
+
+    params['Omega_RF'] = OmRF
+    params['protocol'] = 'Free'
     params['t_ev'] = params['Tp_RF']
-    params['t_ev'] = np.pi/params['Omega_N'] if params['Omega_N'] != 0 else 0
+
     
     operators,params = construct_H0(operators,params,spins,bath,Tin)
     _,_, UX = nv.pulse_NV(operators,params,measure = 'x',)
     
-    params['Omega'] = Om
-    params['RF_phase'] = alpha
+    params['protocol'] = protocol
     params['t_ev'] = t_ev
+    params['tau_offset'] = 0
     
-    return U0*UX*U0
+    return U02*UX*U01
 
 RF_protocols = {'LG': LG,
                 'LG4': LG4,
@@ -210,6 +219,6 @@ RF_protocols = {'LG': LG,
 
 def find_U(operators,params,bath,spins,Tin):
     
-    U = RF_protocols[params['RF_protocol']](operators,params,bath,spins,Tin)
+    U, rho, coh = RF_protocols[params['RF_protocol']](operators,params,bath,spins,Tin)
     
-    return U
+    return U, rho, 2*coh

onv-1.0.1/setup_ONV.py → onv-1.0.4/setup.py

@@ -1,8 +1,8 @@
 from setuptools import setup, find_packages
 
-VERSION = '1.0.1'
+VERSION = '1.0.4'
 DESCRIPTION = 'Package for general NV based simulations'
-LONG_DESCRIPTION = 'A basic package of functions which are commonly used in the simuitons of NV centers fro quantum computing and NMR sensing'
+LONG_DESCRIPTION = 'A basic package of functions which are commonly used in the simuitons of NV centers from quantum computing and NMR'
 
 setup(
       name = 'ONV',
@@ -12,6 +12,7 @@ setup(
       description = DESCRIPTION,
       long_description = LONG_DESCRIPTION,
       packages = find_packages(),
+      py_modules=['nv','cce','p1','nmr','tools'],
       install_requires = [],
       
       keywords = ['NV'],

onv-1.0.4/tools/__init__.py

@@ -0,0 +1 @@
+from .plot_tools import add_arrow, add_text, colorline, make_segments

onv-1.0.1/tools/__init__.py

@@ -1 +0,0 @@
-from plot_tools import add_arrow, add_text, colorline, make_segments