diff --git a/schainpy/model/data/jrodata.py b/schainpy/model/data/jrodata.py
index 39a5287..029ad5f 100644
--- a/schainpy/model/data/jrodata.py
+++ b/schainpy/model/data/jrodata.py
@@ -362,6 +362,7 @@ class Voltage(JROData):
     data = None
     data_intensity = None
     data_velocity = None
+    data_specwidth = None
     def __init__(self):
         '''
         Constructor
@@ -1268,6 +1269,10 @@ class PlotterData(object):
                 buffer = dataOut.data_velocity
                 self.flagDataAsBlock = dataOut.flagDataAsBlock
                 self.nProfiles = dataOut.nProfiles
+            if plot == 'pp_specwidth':
+                buffer = dataOut.data_specwidth
+                self.flagDataAsBlock = dataOut.flagDataAsBlock
+                self.nProfiles = dataOut.nProfiles
 
             if plot == 'spc':
                 self.data['spc'] = buffer
diff --git a/schainpy/model/io/jroIO_simulator.py b/schainpy/model/io/jroIO_simulator.py
index bc2bbe1..874843f 100644
--- a/schainpy/model/io/jroIO_simulator.py
+++ b/schainpy/model/io/jroIO_simulator.py
@@ -32,7 +32,7 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
     #Dyn_snCode                     = numpy.array([Num_Codes,Bauds])
     Dyn_snCode                     = None
     Samples                        = 200
-    channels                       = 5
+    channels                       = 2
     pulses                         = None
     Reference                      = None
     pulse_size                     = None
@@ -91,12 +91,14 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
 
         if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
             self.nReadFiles=self.nReadFiles+1
-            if self.nReadFiles ==self.nTotalReadFiles:
+            if self.nReadFiles > self.nTotalReadFiles:
                 self.flagNoMoreFiles=1
                 raise schainpy.admin.SchainWarning('No more files to read')
 
             print('------------------- [Opening file] ------------------------------',self.nReadFiles)
             self.nReadBlocks  = 0
+        #if self.nReadBlocks==0:
+        #    self.readFirstHeader()
 
     def __setNewBlock(self):
         self.setNextFile()
@@ -121,6 +123,7 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
         self.dataOut.processingHeaderObj      = self.processingHeaderObj.copy()
         self.dataOut.systemHeaderObj          = self.systemHeaderObj.copy()
         self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+        self.dataOut.dtype       = self.dtype
 
         self.dataOut.nProfiles   = self.processingHeaderObj.profilesPerBlock
         self.dataOut.heightList  = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
@@ -144,20 +147,42 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
         self.dataOut.useLocalTime           = self.basicHeaderObj.useLocalTime
         self.dataOut.ippSeconds             = self.radarControllerHeaderObj.ippSeconds / self.nTxs
 
+    def readFirstHeader(self):
+
+        datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
+                                   PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
+        if datatype == 0:
+            datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
+        elif datatype == 1:
+            datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
+        elif datatype == 2:
+            datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
+        elif datatype == 3:
+            datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
+        elif datatype == 4:
+            datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
+        elif datatype == 5:
+            datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
+        else:
+            raise ValueError('Data type was not defined')
+
+        self.dtype = datatype_str
+
+
     def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
                  nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                  numTaus=0, line6Function=0, line5Function=0, fClock=None,
                  prePulseBefore=0, prePulseAfter=0,
                  codeType=0, nCode=0, nBaud=0, code=None,
-                 flip1=0, flip2=0):
+                 flip1=0, flip2=0,Taus=0):
         self.radarControllerHeaderObj.expType       = expType
         self.radarControllerHeaderObj.nTx           = nTx
         self.radarControllerHeaderObj.ipp           = float(ipp)
         self.radarControllerHeaderObj.txA           = float(txA)
         self.radarControllerHeaderObj.txB           = float(txB)
-        self.radarControllerHeaderObj.rangeIPP      = ipp
-        self.radarControllerHeaderObj.rangeTxA      = txA
-        self.radarControllerHeaderObj.rangeTxB      = txB
+        self.radarControllerHeaderObj.rangeIpp      = b'A\n'#ipp
+        self.radarControllerHeaderObj.rangeTxA      = b''
+        self.radarControllerHeaderObj.rangeTxB      = b''
 
         self.radarControllerHeaderObj.nHeights      = int(nHeights)
         self.radarControllerHeaderObj.firstHeight   = numpy.array([firstHeight])
@@ -170,20 +195,27 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
         self.radarControllerHeaderObj.codeType      = codeType
         self.radarControllerHeaderObj.line6Function = line6Function
         self.radarControllerHeaderObj.line5Function = line5Function
-        self.radarControllerHeaderObj.fclock        = fClock
+        #self.radarControllerHeaderObj.fClock        = fClock
         self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
         self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
 
-        self.radarControllerHeaderObj.nCode         = nCode
-        self.radarControllerHeaderObj.nBaud         = nBaud
-        self.radarControllerHeaderObj.code          = code
         self.radarControllerHeaderObj.flip1         = flip1
         self.radarControllerHeaderObj.flip2         = flip2
 
-        self.radarControllerHeaderObj.code_size     = int(numpy.ceil(nBaud / 32.)) * nCode * 4
+        self.radarControllerHeaderObj.code_size     = 0
+        if self.radarControllerHeaderObj.codeType  != 0:
+            self.radarControllerHeaderObj.nCode         = nCode
+            self.radarControllerHeaderObj.nBaud         = nBaud
+            self.radarControllerHeaderObj.code          = code
+            self.radarControllerHeaderObj.code_size     = int(numpy.ceil(nBaud / 32.)) * nCode * 4
 
         if fClock is None and deltaHeight is not None:
             self.fClock = 0.15 / (deltaHeight * 1e-6)
+            self.radarControllerHeaderObj.fClock     = self.fClock
+        if numTaus==0:
+            self.radarControllerHeaderObj.Taus       =  numpy.array(0,'<f4')
+        else:
+            self.radarControllerHeaderObj.Taus       = numpy.array(Taus,'<f4')
 
     def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
                   dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
@@ -192,23 +224,27 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
                   code=0, nBaud=None, shif_fft=False, flag_dc=False,
                   flag_cspc=False, flag_decode=False, flag_deflip=False):
 
+        self.processingHeaderObj.dtype             = dtype
         self.processingHeaderObj.profilesPerBlock  = profilesPerBlock
         self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
         self.processingHeaderObj.nWindows          = nWindows
+        self.processingHeaderObj.processFlags      = processFlags
         self.processingHeaderObj.nCohInt           = nCohInt
         self.processingHeaderObj.nIncohInt         = nIncohInt
         self.processingHeaderObj.totalSpectra      = totalSpectra
+
         self.processingHeaderObj.nHeights          = int(nHeights)
-        self.processingHeaderObj.firstHeight       = firstHeight
-        self.processingHeaderObj.deltaHeight       = deltaHeight
-        self.processingHeaderObj.samplesWin        = nHeights
+        self.processingHeaderObj.firstHeight       = firstHeight#numpy.array([firstHeight])#firstHeight
+        self.processingHeaderObj.deltaHeight       = deltaHeight#numpy.array([deltaHeight])#deltaHeight
+        self.processingHeaderObj.samplesWin        = nHeights#numpy.array([nHeights])#nHeights
 
     def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
         self.basicHeaderObj.utc                    = utc
         self.basicHeaderObj.miliSecond             = miliSecond
         self.basicHeaderObj.timeZone               = timeZone
 
-    def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
+    def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):
+        #self.systemHeaderObj.size           = size
         self.systemHeaderObj.nSamples       = nSamples
         self.systemHeaderObj.nProfiles      = nProfiles
         self.systemHeaderObj.nChannels      = nChannels
@@ -325,10 +361,27 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
         time_vec   = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen
         fd         = Fdoppler #+(600.0/120)*self.nReadBlocks
         d_signal   = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
-        #·················· DATABLOCK + DOPPLER············...........................
+        #·············Señal con ancho espectral····················
+        #specw_sig             =  numpy.zeros(int(prof_gen),dtype=complex)
+        #specw_sig.real[200:200+100] = 1*numpy.ones(100)
+        #specw_sig.imag[200:200+100] = 1*numpy.ones(100)
+        # w=2
+        specw_sig  = numpy.linspace(-149,150,300)
+        w          = 3
+        A          = 10
+        specw_sig   = specw_sig/w
+        specw_sig   = numpy.sinc(specw_sig)
+        specw_sig   =  A*numpy.array(specw_sig,dtype=numpy.complex64)
+        #·················· DATABLOCK + DOPPLER····················
         HD=int(Hdoppler/self.AcqDH_0)
         for  i in range(12):
-            self.datablock[:,:,HD+i]=self.datablock[:,:,HD+i]+ d_signal # RESULT
+            self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT
+
+        HD=int(Hdoppler/self.AcqDH_0)
+        HD=int(HD/2)
+        for  i in range(12):
+            self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT
+
         '''
         a= numpy.zeros(10)
         for i in range(10):
@@ -401,16 +454,15 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
 
 
         self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
-
         self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
                  nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
                  numTaus=1, line6Function=0, line5Function=0, fClock=None,
                  prePulseBefore=0, prePulseAfter=0,
-                 codeType=14, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
-                 flip1=0, flip2=0)
+                 codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
+                 flip1=0, flip2=0,Taus=Tau_0)
 
         self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
-                      dataBlocksPerFile=120, nWindows=1, processFlags=0, nCohInt=1,
+                      dataBlocksPerFile=120, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
                       nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
                       deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
                       code=0, nBaud=None, shif_fft=False, flag_dc=False,
@@ -418,6 +470,7 @@ class SimulatorReader(JRODataReader, ProcessingUnit):
 
         self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
 
+        self.readFirstHeader()
 
         self.frequency                      = frequency
         self.incIntFactor                   = incIntFactor
diff --git a/schainpy/model/proc/jroproc_voltage.py b/schainpy/model/proc/jroproc_voltage.py
index 8e99b76..4bc8b1f 100644
--- a/schainpy/model/proc/jroproc_voltage.py
+++ b/schainpy/model/proc/jroproc_voltage.py
@@ -1293,8 +1293,7 @@ class PulsePairVoltage(Operation):
     __initime      = None
     __lastdatatime = None
     __buffer       = None
-    __buffer2      = []
-    __buffer3      = None
+    noise          = None
     __dataReady    = False
     n              = None
     __nch          = 0
@@ -1314,10 +1313,8 @@ class PulsePairVoltage(Operation):
         self.__lastdatatime   = 0
         self.__dataReady      = False
         self.__buffer         = 0
-        self.__buffer2        = []
-        self.__buffer3        = 0
         self.__profIndex      = 0
-
+        self.noise            = None
         self.__nch            = dataOut.nChannels
         self.__nHeis          = dataOut.nHeights
         self.removeDC         = removeDC
@@ -1341,6 +1338,9 @@ class PulsePairVoltage(Operation):
                                            n,
                                            dataOut.nHeights),
                                           dtype='complex')
+        self.noise  = numpy.zeros([self.__nch,self.__nHeis])
+        for i in range(self.__nch):
+            self.noise[i]=dataOut.getNoise(channel=i)
 
     def putData(self,data):
         '''
@@ -1362,58 +1362,82 @@ class PulsePairVoltage(Operation):
             dc= numpy.tile(tmp,[1,self.__nProf,1])
             self.__buffer = self.__buffer -  dc
 
-        data_intensity   = numpy.sum(self.__buffer*numpy.conj(self.__buffer),1)/(self.n*self.nCohInt)#*self.nCohInt)
-        pair1            = self.__buffer[:,1:,:]*numpy.conjugate(self.__buffer[:,:-1,:])
-        angle            = numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
-        #print(angle.shape)#print("__ANGLE__") #print("angle",angle[:,:10])
-        data_velocity    = (self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(numpy.sum(pair1,1))#self.ippSec*self.nCohInt
+        lag_0            = numpy.sum(self.__buffer*numpy.conj(self.__buffer),1)
+        data_intensity   = lag_0/(self.n*self.nCohInt)#*self.nCohInt)
+
+        pair1            = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
+        lag_1            = numpy.sum(pair1,1)
+        #angle            = numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
+        data_velocity    = (-1.0*self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(lag_1)#self.ippSec*self.nCohInt
+
+        lag_0            = lag_0.real/(self.n)
+        lag_1            = lag_1/(self.n-1)
+        R1               = numpy.abs(lag_1)
+        S                = (lag_0-self.noise)
+        #k = R1/S
+        #k = 1-k
+        #k =numpy.absolute(k)
+        #k =numpy.sqrt(k)
+        L                = S/R1
+        #print("L",L[0])
+        L                = numpy.where(L<0,1,L)
+        L                = numpy.log(L)
+        tmp              = numpy.sqrt(numpy.absolute(L))
+        data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*tmp*numpy.sign(L)
+        #data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec))*k
         n                = self.__profIndex
 
         self.__buffer    = numpy.zeros((self.__nch, self.__nProf,self.__nHeis),  dtype='complex')
         self.__profIndex = 0
-        return data_intensity,data_velocity,n
+        return data_intensity,data_velocity,data_specwidth,n
 
     def pulsePairbyProfiles(self,data):
 
         self.__dataReady     =  False
         data_intensity       =  None
         data_velocity        =  None
+        data_specwidth       =  None
         self.putData(data)
         if self.__profIndex  == self.n:
-            data_intensity, data_velocity, n   = self.pushData()
+            #self.noise  = numpy.zeros([self.__nch,self.__nHeis])
+            #for i in range(self.__nch):
+            #    self.noise[i]=data.getNoise(channel=i)
+            #print(self.noise.shape)
+            data_intensity, data_velocity,data_specwidth, n   = self.pushData()
             self.__dataReady                   = True
 
-        return data_intensity, data_velocity
+        return data_intensity, data_velocity,data_specwidth
 
     def pulsePairOp(self, data, datatime= None):
 
         if self.__initime == None:
             self.__initime = datatime
 
-        data_intensity, data_velocity = self.pulsePairbyProfiles(data)
+        data_intensity, data_velocity,data_specwidth = self.pulsePairbyProfiles(data)
         self.__lastdatatime           = datatime
 
         if data_intensity is None:
-            return None, None, None
+            return None, None,None, None
 
         avgdatatime    = self.__initime
         deltatime      = datatime - self.__lastdatatime
         self.__initime = datatime
 
-        return data_intensity, data_velocity, avgdatatime
+        return data_intensity, data_velocity,data_specwidth,avgdatatime
 
     def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
 
         if not self.isConfig:
             self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
             self.isConfig   = True
-        data_intensity, data_velocity, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime)
+        data_intensity, data_velocity,data_specwidth, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime)
         dataOut.flagNoData                         = True
 
         if self.__dataReady:
             dataOut.nCohInt        *= self.n
             dataOut.data_intensity  = data_intensity #valor para intensidad
             dataOut.data_velocity   = data_velocity  #valor para velocidad
+            dataOut.data_specwidth  = data_specwidth
             dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
             dataOut.utctime         = avgdatatime
             dataOut.flagNoData      = False