diff --git a/schainpy/model/data/jroheaderIO.py b/schainpy/model/data/jroheaderIO.py
index f6d5d0b..68b7c46 100644
--- a/schainpy/model/data/jroheaderIO.py
+++ b/schainpy/model/data/jroheaderIO.py
@@ -7,6 +7,9 @@ import numpy
 import copy
 import datetime
 
+SPEED_OF_LIGHT = 299792458
+SPEED_OF_LIGHT = 3e8
+
 BASIC_STRUCTURE = numpy.dtype([
                           ('nSize','<u4'),
                           ('nVersion','<u2'),
@@ -222,12 +225,12 @@ class RadarControllerHeader(Header):
     rangeTxA = None
     rangeTxB = None
     
-    __C = 3e8
+    __size = None
         
     def __init__(self, expType=2, nTx=1,
                  ippKm=None, txA=0, txB=0,
                  nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
-                 numTaus=0, line6Function=0, line5Function=0, fClock=0,
+                 numTaus=0, line6Function=0, line5Function=0, fClock=None,
                  prePulseBefore=0, prePulseAfter=0,
                  codeType=0, nCode=0, nBaud=0, code=None,
                  flip1=0, flip2=0):
@@ -265,6 +268,8 @@ class RadarControllerHeader(Header):
         self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
 #         self.dynamic = numpy.array([],numpy.dtype('byte'))
         
+        if self.fClock is None and self.deltaHeight is not None:
+            self.fClock = 0.15/(deltaHeight*1e-6)   #0.15Km / (height * 1u)
 
     def read(self, fp):
         
@@ -272,7 +277,7 @@ class RadarControllerHeader(Header):
             startFp = fp.tell()
             header = numpy.fromfile(fp,RADAR_STRUCTURE,1)
             
-            self.size = int(header['nSize'][0])
+            size = int(header['nSize'][0])
             self.expType = int(header['nExpType'][0])
             self.nTx = int(header['nNTx'][0])
             self.ipp = float(header['fIpp'][0])
@@ -290,7 +295,7 @@ class RadarControllerHeader(Header):
             self.rangeTxA = header['sRangeTxA'][0]
             self.rangeTxB = header['sRangeTxB'][0]
             # jump Dynamic Radar Controller Header
-#             jumpFp =  self.size - 116
+#             jumpFp =  size - 116
 #             self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
             #pointer backward to dynamic header and read
 #             backFp = fp.tell() - jumpFp
@@ -319,13 +324,13 @@ class RadarControllerHeader(Header):
                 self.code = 2.0*self.code - 1.0
                 self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
                 
-            if self.line5Function == RCfunction.FLIP:
-                self.flip1 = numpy.fromfile(fp,'<u4',1)
-
-            if self.line6Function == RCfunction.FLIP:
-                self.flip2 = numpy.fromfile(fp,'<u4',1)
+#             if self.line5Function == RCfunction.FLIP:
+#                 self.flip1 = numpy.fromfile(fp,'<u4',1)
+# 
+#             if self.line6Function == RCfunction.FLIP:
+#                 self.flip2 = numpy.fromfile(fp,'<u4',1)
                 
-            endFp = self.size + startFp
+            endFp = size + startFp
             jumpFp =  endFp - fp.tell()
             if jumpFp > 0:
                 fp.seek(jumpFp)
@@ -337,6 +342,7 @@ class RadarControllerHeader(Header):
         return 1
     
     def write(self, fp):
+        
         headerTuple = (self.size,
                        self.expType,
                        self.nTx,
@@ -358,9 +364,6 @@ class RadarControllerHeader(Header):
         header = numpy.array(headerTuple,RADAR_STRUCTURE)
         header.tofile(fp)
         
-        #dynamic = self.dynamic
-        #dynamic.tofile(fp)
-        
         sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
         samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
         samplingWindow.tofile(fp)
@@ -390,18 +393,18 @@ class RadarControllerHeader(Header):
                 tempx = tempx.astype('u4')
                 tempx.tofile(fp)
             
-        if self.line5Function == RCfunction.FLIP:
-            self.flip1.tofile(fp)
-
-        if self.line6Function == RCfunction.FLIP:
-            self.flip2.tofile(fp)
+#         if self.line5Function == RCfunction.FLIP:
+#             self.flip1.tofile(fp)
+# 
+#         if self.line6Function == RCfunction.FLIP:
+#             self.flip2.tofile(fp)
         
         return 1
 
     def get_ippSeconds(self):
         '''
         '''
-        ippSeconds = 2.0 * 1000 * self.ipp / self.__C
+        ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
         
         return ippSeconds
     
@@ -409,11 +412,27 @@ class RadarControllerHeader(Header):
         '''
         '''
         
-        self.ipp = ippSeconds * self.__C / (2.0*1000)
+        self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0*1000)
+        
+        return
+    
+    def get_size(self):
+        
+        self.__size = 116 + 12*self.nWindows + 4*self.numTaus
+        
+        if self.codeType != 0:
+            self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
+        
+        return self.__size
+    
+    def set_size(self, value):
+        
+        self.__size = value
         
         return
     
     ippSeconds = property(get_ippSeconds, set_ippSeconds)
+    size = property(get_size, set_size)
 
 class ProcessingHeader(Header):
     
@@ -581,6 +600,7 @@ class nCodeType:
     CODE_BINARY28=17
 
 class PROCFLAG:    
+    
     COHERENT_INTEGRATION = numpy.uint32(0x00000001)
     DECODE_DATA = numpy.uint32(0x00000002) 
     SPECTRA_CALC = numpy.uint32(0x00000004)
@@ -615,4 +635,45 @@ class PROCFLAG:
     OPERATION_MASK = numpy.uint32(0x0000003F)
     DATATYPE_MASK = numpy.uint32(0x00000FC0)
     DATAARRANGE_MASK = numpy.uint32(0x00007000)
-    ACQ_SYS_MASK = numpy.uint32(0x001C0000)
\ No newline at end of file
+    ACQ_SYS_MASK = numpy.uint32(0x001C0000)
+    
+dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
+dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
+dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
+dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
+dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
+dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
+
+NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
+
+PROCFLAG_DTYPE_LIST =  [PROCFLAG.DATATYPE_CHAR, 
+                       PROCFLAG.DATATYPE_SHORT, 
+                       PROCFLAG.DATATYPE_LONG, 
+                       PROCFLAG.DATATYPE_INT64, 
+                       PROCFLAG.DATATYPE_FLOAT, 
+                       PROCFLAG.DATATYPE_DOUBLE]
+
+DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
+
+def get_dtype_index(numpy_dtype):
+    
+    index = None
+    
+    for i in range(len(NUMPY_DTYPE_LIST)):
+        if numpy_dtype == NUMPY_DTYPE_LIST[i]:
+            index = i
+            break
+    
+    return index
+
+def get_numpy_dtype(index):
+    
+    return NUMPY_DTYPE_LIST[index]
+
+def get_procflag_dtype(index):
+    
+    return PROCFLAG_DTYPE_LIST[index]
+
+def get_dtype_width(index):
+    
+    return DTYPE_WIDTH[index]
\ No newline at end of file
diff --git a/schainpy/model/io/jroIO_base.py b/schainpy/model/io/jroIO_base.py
index 3ba5eb5..6677054 100644
--- a/schainpy/model/io/jroIO_base.py
+++ b/schainpy/model/io/jroIO_base.py
@@ -19,6 +19,7 @@ except:
     from time import sleep
     
 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
+from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
 
 LOCALTIME = True
 
@@ -365,6 +366,13 @@ class JRODataIO:
         
         raise ValueError, "Not implemented"
 
+    def getDtypeWidth(self):
+        
+        dtype_index = get_dtype_index(self.dtype)
+        dtype_width = get_dtype_width(dtype_index)
+        
+        return dtype_width
+    
 class JRODataReader(JRODataIO):
     
     nReadBlocks = 0
@@ -872,12 +880,16 @@ class JRODataReader(JRODataIO):
         return 1
 
     def readNextBlock(self):
+        
         if not(self.__setNewBlock()):
             return 0
 
         if not(self.readBlock()):
             return 0
-
+        
+        print "[Reading] Block No. %d/%d -> %s" %(self.basicHeaderObj.dataBlock+1,
+                                                  self.processingHeaderObj.dataBlocksPerFile,
+                                                  self.dataOut.datatime.ctime())
         return 1
 
     def __readFirstHeader(self):
@@ -1128,7 +1140,8 @@ class JRODataReader(JRODataIO):
 
             sys.exit(-1)
 
-#        self.updateDataHeader()
+        self.getBasicHeader()
+        
         if last_set != None:
             self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
         return
@@ -1183,7 +1196,10 @@ class JRODataReader(JRODataIO):
     def printNumberOfBlock(self):
         
         if self.flagIsNewBlock:
-            print "[Reading] Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())
+            print "[Reading] Block No. %d/%d -> %s" %(self.basicHeaderObj.dataBlock+1,
+                                                      self.processingHeaderObj.dataBlocksPerFile,
+                                                      self.dataOut.datatime.ctime())
+            
             self.dataOut.blocknow = self.basicHeaderObj.dataBlock
 
     def printInfo(self):
@@ -1248,6 +1264,36 @@ class JRODataWriter(JRODataIO):
         raise ValueError, "No implemented"
 
     
+    def getProcessFlags(self):
+        
+        processFlags = 0
+        
+        dtype_index = get_dtype_index(self.dtype)
+        procflag_dtype = get_procflag_dtype(dtype_index)
+        
+        processFlags += procflag_dtype
+        
+        if self.dataOut.flagDecodeData:
+            processFlags += PROCFLAG.DECODE_DATA
+        
+        if self.dataOut.flagDeflipData:
+            processFlags += PROCFLAG.DEFLIP_DATA
+        
+        if self.dataOut.code is not None:
+            processFlags += PROCFLAG.DEFINE_PROCESS_CODE
+        
+        if self.dataOut.nCohInt > 1:
+            processFlags += PROCFLAG.COHERENT_INTEGRATION
+        
+        if self.dataOut.type == "Spectra":
+            if self.dataOut.nIncohInt > 1:
+                processFlags += PROCFLAG.INCOHERENT_INTEGRATION
+                
+            if self.dataOut.data_dc is not None:
+                processFlags += PROCFLAG.SAVE_CHANNELS_DC
+            
+        return processFlags
+    
     def setBasicHeader(self):
         
         self.basicHeaderObj.size = self.basicHeaderSize #bytes
@@ -1301,7 +1347,7 @@ class JRODataWriter(JRODataIO):
         self.radarControllerHeaderObj.write(self.fp)
         self.processingHeaderObj.write(self.fp)
         
-        self.dtype = self.dataOut.dtype
+        
 
     def __setNewBlock(self):
         """
@@ -1339,7 +1385,9 @@ class JRODataWriter(JRODataIO):
             return 0
         
         self.writeBlock()
-
+        
+        print "[Writing] Block No. %d/%d" %(self.blockIndex, self.processingHeaderObj.dataBlocksPerFile)
+        
         return 1        
 
     def setNextFile(self):
@@ -1409,20 +1457,27 @@ class JRODataWriter(JRODataIO):
         
         self.setFirstHeader()
         
-        print '[Writing] file: %s'%self.filename
+        print '[Writing] Opening file: %s'%self.filename
         
         self.__writeFirstHeader()
         
         return 1
     
-    def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=0, ext=None):
+    def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=0, ext=None, datatype=2):
         """
         Setea el tipo de formato en la cual sera guardada la data y escribe el First Header 
             
         Inputs:
-            path      :    el path destino en el cual se escribiran los files a crear
-            format    :    formato en el cual sera salvado un file
-            set       :    el setebo del file
+            path                :    directory where data will be saved
+            profilesPerBlock    :    number of profiles per block 
+            set                 :    file set
+            datatype            :    An integer number that defines data type:
+                                        0 : int8  (1 byte)
+                                        1 : int16 (2 bytes)
+                                        2 : int32 (4 bytes)
+                                        3 : int64 (8 bytes)
+                                        4 : float (4 bytes)
+                                        5 : double (8 bytes)
             
         Return:
             0    :    Si no realizo un buen seteo
@@ -1446,6 +1501,12 @@ class JRODataWriter(JRODataIO):
         
         self.dataOut = dataOut
         
+        #By default
+        self.dtype = self.dataOut.dtype
+        
+        if datatype is not None:
+            self.dtype = get_numpy_dtype(datatype)
+        
         if not(self.setNextFile()):
             print "[Writing] There isn't a next file"
             return 0
diff --git a/schainpy/model/io/jroIO_spectra.py b/schainpy/model/io/jroIO_spectra.py
index 084108f..fb858a0 100644
--- a/schainpy/model/io/jroIO_spectra.py
+++ b/schainpy/model/io/jroIO_spectra.py
@@ -273,7 +273,8 @@ class SpectraReader(JRODataReader, ProcessingUnit):
                 cspc = numpy.roll( cspc, shift, axis=2 )
             
 #            self.processingHeaderObj.shif_fft = True
-
+        
+        #Dimensions : nChannels, nProfiles, nSamples
         spc = numpy.transpose( spc, (0,2,1) )
         self.data_spc = spc
         
@@ -298,6 +299,8 @@ class SpectraReader(JRODataReader, ProcessingUnit):
     
     def getFirstHeader(self):
         
+        self.getBasicHeader()
+        
         self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
         
         self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
@@ -599,89 +602,27 @@ class SpectraWriter(JRODataWriter, Operation):
         
         return 1
     
-    
-    def __getProcessFlags(self):
-        
-        processFlags = 0
-        
-        dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
-        dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
-        dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
-        dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
-        dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
-        dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
-        
-        dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
-        
-        
-        
-        datatypeValueList =  [PROCFLAG.DATATYPE_CHAR, 
-                           PROCFLAG.DATATYPE_SHORT, 
-                           PROCFLAG.DATATYPE_LONG, 
-                           PROCFLAG.DATATYPE_INT64, 
-                           PROCFLAG.DATATYPE_FLOAT, 
-                           PROCFLAG.DATATYPE_DOUBLE]
-        
-        
-        for index in range(len(dtypeList)):
-            if self.dataOut.dtype == dtypeList[index]:
-                dtypeValue = datatypeValueList[index]
-                break
-        
-        processFlags += dtypeValue
-        
-        if self.dataOut.flagDecodeData:
-            processFlags += PROCFLAG.DECODE_DATA
-        
-        if self.dataOut.flagDeflipData:
-            processFlags += PROCFLAG.DEFLIP_DATA
-        
-        if self.dataOut.code is not None:
-            processFlags += PROCFLAG.DEFINE_PROCESS_CODE
-        
-        if self.dataOut.nIncohInt > 1:
-            processFlags += PROCFLAG.INCOHERENT_INTEGRATION
-            
-        if self.dataOut.data_dc is not None:
-            processFlags += PROCFLAG.SAVE_CHANNELS_DC
-        
-        return processFlags
-    
-    
     def __getBlockSize(self):
         '''
         Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
         '''
         
-        dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
-        dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
-        dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
-        dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
-        dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
-        dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
-        
-        dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
-        datatypeValueList = [1,2,4,8,4,8]
-        for index in range(len(dtypeList)):
-            if self.dataOut.dtype == dtypeList[index]:
-                datatypeValue = datatypeValueList[index]
-                break
-        
+        dtype_width = self.getDtypeWidth()
         
         pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
         
         pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
-        blocksize = (pts2write_SelfSpectra*datatypeValue)
+        blocksize = (pts2write_SelfSpectra*dtype_width)
         
         if self.dataOut.data_cspc is not None:
             pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
-            blocksize += (pts2write_CrossSpectra*datatypeValue*2)
+            blocksize += (pts2write_CrossSpectra*dtype_width*2)
         
         if self.dataOut.data_dc is not None:
             pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
-            blocksize += (pts2write_DCchannels*datatypeValue*2)
+            blocksize += (pts2write_DCchannels*dtype_width*2)
         
-        blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
+#         blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
 
         return blocksize
     
@@ -714,7 +655,7 @@ class SpectraWriter(JRODataWriter, Operation):
         self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
         self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
         self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
-        self.processingHeaderObj.processFlags = self.__getProcessFlags()
+        self.processingHeaderObj.processFlags = self.getProcessFlags()
         self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
         self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt 
         self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
diff --git a/schainpy/model/io/jroIO_voltage.py b/schainpy/model/io/jroIO_voltage.py
index 5ffd46a..f2219ee 100644
--- a/schainpy/model/io/jroIO_voltage.py
+++ b/schainpy/model/io/jroIO_voltage.py
@@ -224,6 +224,8 @@ class VoltageReader(JRODataReader, ProcessingUnit):
                 junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
                 junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
 #             return 0
+
+        #Dimensions : nChannels, nProfiles, nSamples
         
         junk = numpy.transpose(junk, (2,0,1))
         self.datablock = junk['real'] + junk['imag']*1j
@@ -240,6 +242,8 @@ class VoltageReader(JRODataReader, ProcessingUnit):
 
     def getFirstHeader(self):
         
+        self.getBasicHeader()
+        
         self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
         
         self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
@@ -419,7 +423,7 @@ class VoltageWriter(JRODataWriter, Operation):
 
         self.flagIsNewFile = 1
         
-        self.nTotalBlocks = 0 
+        self.blockIndex = 0 
         
         self.flagIsNewBlock = 0
 
@@ -536,71 +540,14 @@ class VoltageWriter(JRODataWriter, Operation):
         
         return 1
     
-    def __getProcessFlags(self):
-        
-        processFlags = 0
-        
-        dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
-        dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
-        dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
-        dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
-        dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
-        dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
-        
-        dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
-        
-        
-        
-        datatypeValueList =  [PROCFLAG.DATATYPE_CHAR, 
-                           PROCFLAG.DATATYPE_SHORT, 
-                           PROCFLAG.DATATYPE_LONG, 
-                           PROCFLAG.DATATYPE_INT64, 
-                           PROCFLAG.DATATYPE_FLOAT, 
-                           PROCFLAG.DATATYPE_DOUBLE]
-        
-        
-        for index in range(len(dtypeList)):
-            if self.dataOut.dtype == dtypeList[index]:
-                dtypeValue = datatypeValueList[index]
-                break
-        
-        processFlags += dtypeValue
-        
-        if self.dataOut.flagDecodeData:
-            processFlags += PROCFLAG.DECODE_DATA
-        
-        if self.dataOut.flagDeflipData:
-            processFlags += PROCFLAG.DEFLIP_DATA
-        
-        if self.dataOut.code is not None:
-            processFlags += PROCFLAG.DEFINE_PROCESS_CODE
-        
-        if self.dataOut.nCohInt > 1:
-            processFlags += PROCFLAG.COHERENT_INTEGRATION
-        
-        return processFlags
-    
-    
     def __getBlockSize(self):
         '''
         Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
         '''
         
-        dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
-        dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
-        dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
-        dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
-        dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
-        dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
-        
-        dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
-        datatypeValueList = [1,2,4,8,4,8]
-        for index in range(len(dtypeList)):
-            if self.dataOut.dtype == dtypeList[index]:
-                datatypeValue = datatypeValueList[index]
-                break
+        dtype_width = self.getDtypeWidth()
         
-        blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * datatypeValue * 2)
+        blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
         
         return blocksize
     
@@ -630,7 +577,7 @@ class VoltageWriter(JRODataWriter, Operation):
         self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
         self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
         self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
-        self.processingHeaderObj.processFlags = self.__getProcessFlags()
+        self.processingHeaderObj.processFlags = self.getProcessFlags()
         self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
         self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
         self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage