hello!I am confused about how to realize Real-time data storage，we do like this:

from artiq.experiment import *
import numpy as np
import os
import time

class Run2(EnvExperiment):
"""test zeeman2.3"""
def build(self):

    self.setattr_device("core")
    self.setattr_device("ttl0")
    self.setattr_device("ttl1")
    self.setattr_device("ttl2")
    self.setattr_device("ttl4")
    self.setattr_device("ttl6")
    self.setattr_device("ttl8")
    self.setattr_device("ttl10")
    self.setattr_device("ttl12")
    self.setattr_device("ttl14")
    self.setattr_device("ttl16")
    self.setattr_device("ttl18")
    self.setattr_device("ttl20")
    self.setattr_device("ttl22")
    self.setattr_device("ttl24")
    self.setattr_device("ttl26")
    self.setattr_device("ttl28")
    self.setattr_device("ttl30")
    self.setattr_device("ttl32")
    self.setattr_device("urukul2_ch1")
    self.setattr_device("urukul2_ch2")
    self.setattr_device("urukul2_cpld")#定义设备
    
def prepare(self):

    self.parameter=self.get_dataset("para")
    #self.Rabi_Start=self.get_dataset("Run_Uint.Rabi.Start")
    #self.Rabi_End=self.get_datase================================================m'm'm'm'm'm'm'm'm'm'm'm'm'm'm'm'm'm'mt("Run_Uint.Rabi.End")
    #.Rabi_Step=self.get_dataset("Run_Uint.Rabi.Step")
    self.Zeeman_Frequency=self.get_dataset("Run_Uint.Zeeman.Start")
    self.Zeeman_Frequency_End=self.get_dataset("Run_Uint.Zeeman.End")
    self.Zeeman_Frequency_Step=self.get_dataset("Run_Uint.Zeeman.Step")
    #self.Zeeman_Repeat=self.get_dataset("Run_Uint.Zeeman.Repeat")
    #self.Zeeman_Threshould=self.get_dataset("Run_Uint.Zeeman.Threshould")
    #self.Rabi_Threshould=self.get_dataset("Run_Uint.Rabi.Threshould")

    #self.Preparation_Frequency=self.get_dataset("Run_Uint.Preparation.Frequency")
    #self.Preparation_Attenuation=self.get_dataset("Run_Uint.Preparation.Attenuation")
    #self.Zeeman_Attenuation=self.get_dataset("Run_Uint.Zeeman.Attenuation")

    self.length=int((self.Zeeman_Frequency_End-self.Zeeman_Frequency)/(self.Zeeman_Frequency_Step/1000))+1
    
    
@kernel
def run(self):
    print(66)
    self.core.reset()

    #刷新时间轴防止报错
    delay(2*ms)
    self.urukul2_cpld.init()
    self.urukul2_ch2.init()
    self.urukul2_ch1.init()
    self.urukul2_ch2.sw.on()#控制729的三种光频率与三种功率
    self.urukul2_ch1.sw.on()
    self.ttl2.input()
    self.ttl1.input()
    self.ttl0.input()
    self.ttl4.output()
    self.ttl6.output()
    self.ttl8.output()
    self.ttl10.output()
    self.ttl18.output()
    self.ttl12.output()
    self.ttl14.output()
    self.ttl16.output()
    self.ttl20.output()
    self.ttl22.output()
    delay(50*ms)

    print("ok1")



    #self.urukul0_ch0.set(self.Preparation_Frequency*MHz)             #设置729态制备频率
    #self.urukul0_ch0.set_att(self.Preparation_Attenuation)              #设置729态制备功率
    #self.urukul0_ch1.set_att(self.Zeeman_Attenuation)                   #设置729扫Zeeman功率

    #delay(50*ms)

    if self.parameter==2:
        self.length=int((self.Zeeman_Frequency_End-

self.Zeeman_Frequency)/(self.Zeeman_Frequency_Step/1000))

        self.set_dataset("FrequncyList", np.full(self.length, np.nan), broadcast=True)
        self.set_dataset("D_List", np.full(self.length, np.nan), broadcast=True)
        
        self.set_dataset("Data", np.full(self.length, np.nan), broadcast=True)
        
        delay(15*ms)
        
        print(self.Zeeman_Frequency)
        print(self.Zeeman_Frequency_End)
        print(self.Zeeman_Frequency_Step/1000)
        
        

        t=0
        
        while self.Zeeman_Frequency<self.Zeeman_Frequency_End:
            
            #print(self.Zeeman_Frequency)
            
            delay(200*ms)
            self.urukul2_ch1.set(self.Zeeman_Frequency*MHz)
            self.urukul2_ch1.set_att(4.0)
            delay(5*ms)
            a=0
            delay(5*ms)
            
            #print(1)
            for i in range(1000):
                #try:
                    
                print('ok')
                t_end=self.ttl1.gate_rising(20*ms)#从当前时刻开始记录上升沿，直到括号内的时间为止。
                t_edge=self.ttl1.timestamp_mu(t_end) 
                
                
                    #rtio = self.core.get_rtio_counter_mu()
                    #now = now_mu()
                    #print(rtio-now)
                if t_edge>0:#如果探测到触发信号的上
                
                    at_mu(t_edge)
                    delay(7*ms)
                    print(t_edge)
                    
                    self.ttl20.off()#打开397Double pass                            
                    self.ttl4.off()#打开大功率AOM
                    self.ttl8.on()#打开397-Z-小功率-Doppler cooling
                    self.ttl10.on()#关闭397-x&y-Doppler cooling
                    delay(2*ms)
                    self.ttl20.on()#关闭397Double pass 
                    self.ttl8.off()#打开397-z-大功率-态探测
                    self.ttl6.on()#关闭854Double pass
                    self.ttl22.on()#关闭854小功率
                    self.ttl18.off()#打开729Double Pass的AOM
                    delay(2*ms)
                    self.ttl18.on()#关闭729Double Pass的AOM
                    self.ttl20.off()#打开397Double Pass的AOM
                    self.ttl10.off()#打开397--x&y的AOM 
                    
                                           
                    gate_end_mu = self.ttl0.gate_rising(5700*us)
                        #记录探测时长内的上升沿并计数
                    delay(3.5*ms)
                    num_rising_edges=self.ttl0.count(gate_end_mu)
                    
                    self.set_dataset("Photon_Count",num_rising_edges, broadcast=True)
                    
                    self.ttl6.off()#打开854-Double pass
                    self.ttl22.off()#打开854大功率

                 
                    if num_rising_edges>0:
                        a+=1
                   
                    #self.core.reset()
                    #self.core.wait_until_mu(now_mu())
                    
                    delay(1*ms)


                #except RTIOUnderflow:
        #时间溢出报错时会打印"Error for time"
                    #print("Error for time")
                    
            self.ttl20.off()#打开397Double pass 
            self.ttl10.off()#打开397--x&y的AOM         
            self.ttl6.off()#打开854-Double pass
            self.ttl22.off()#打开854大功率        
            
            
            D=1-a/100
            
            self.mutate_dataset("FrequncyList", t, self.Zeeman_Frequency)
            self.mutate_dataset("D_List", t, D)
            
            t+=1
            
            self.Zeeman_Frequency+=self.Zeeman_Frequency_Step/1000

def analyze(self):

    try:
        name=time.strftime("%F")
        filename="E:/data/"+str(name) 
        os.mkdir(filename)
    except:
        pass
        
    D_List=self.get_dataset("D_List")
    FrequncyList=self.get_dataset("FrequncyList")
    
    
    name1=time.strftime("%H-%M-%S")+"-Zeeman"
    filename1=filename+"/"+str(name1)
    
    file=open(filename1+".txt","a")
    str4="Fre"
    str5="Jump"
    str6=str4+"     "+str5+"\n"
    file.write(str6)
    for i in range(self.length):
        str1=str(D_List[i])
        str2=str(FrequncyList[i])
        str3=str2+"     "+str1+"\n"
        file.write(str3)
    
    file.close()

we add the code part to the end of our experimental code,but it can only be carried out when all the experimental cycles are completed，how can we realize real-time data storage，i.e one data gained in one cycle can be storaged in one cycle?