From 5a0951cb35e42a2fff4abdef33d13ebe07b11aae 2012-09-20 19:48:55
From: Daniel Valdez <daniel.suarez@jro.igp.gob.pe>
Date: 2012-09-20 19:48:55
Subject: [PATCH] Version con Lectura de Pdata y RawData operando correctamente,tambien la Escritura de Rawdata.
Aun se estan realizando cambios en la Escritura de Pdata

---

diff --git a/schainpy2/Data/JROData.py b/schainpy2/Data/JROData.py
index f0e513d..4b52876 100644
--- a/schainpy2/Data/JROData.py
+++ b/schainpy2/Data/JROData.py
@@ -45,6 +45,13 @@ class JROData:
     nBaud = None
     
     code = None
+    
+    flagDecodeData = True #asumo q la data esta decodificada
+    
+    flagDeflipData = True #asumo q la data esta sin flip
+    
+    flagShiftFFT = False
+    
 
     def __init__(self):
         
diff --git a/schainpy2/IO/JRODataIO.py b/schainpy2/IO/JRODataIO.py
index 210cd9f..47a639f 100644
--- a/schainpy2/IO/JRODataIO.py
+++ b/schainpy2/IO/JRODataIO.py
@@ -488,6 +488,8 @@ class JRODataWriter(JRODataIO):
     
     blocksPerFile = None
     
+    nWriteBlocks = 0
+    
     def __init__(self, dataOutObj=None):
         raise ValueError, "Not implemented"
 
@@ -521,8 +523,8 @@ class JRODataWriter(JRODataIO):
         
 #        CALCULAR PARAMETROS
         
-        sizeLongHeader = 0#XXXX
-        self.basicHeaderObj.size = 24 + sizeLongHeader
+        sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
+        self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
         
         self.__writeBasicHeader()
         self.__wrSystemHeader()
@@ -541,7 +543,7 @@ class JRODataWriter(JRODataIO):
         if fp == None:
             fp = self.fp
             
-        self.dataOutObj.basicHeaderObj.write(fp)
+        self.basicHeaderObj.write(fp)
 
     
     def __wrSystemHeader(self, fp=None):
@@ -554,7 +556,7 @@ class JRODataWriter(JRODataIO):
         if fp == None:
             fp = self.fp
             
-        self.dataOutObj.systemHeaderObj.write(fp)
+        self.systemHeaderObj.write(fp)
 
     
     def __wrRadarControllerHeader(self, fp=None):
@@ -567,7 +569,7 @@ class JRODataWriter(JRODataIO):
         if fp == None:
             fp = self.fp
         
-        self.dataOutObj.radarControllerHeaderObj.write(fp)
+        self.radarControllerHeaderObj.write(fp)
 
         
     def __wrProcessingHeader(self, fp=None):
@@ -580,7 +582,7 @@ class JRODataWriter(JRODataIO):
         if fp == None:
             fp = self.fp
             
-        self.dataOutObj.processingHeaderObj.write(fp)
+        self.processingHeaderObj.write(fp)
     
     
     def setNextFile(self):
@@ -648,6 +650,8 @@ class JRODataWriter(JRODataIO):
         self.setFile = setFile
         self.flagIsNewFile = 1
         
+        self.getDataHeader()
+        
         print 'Writing the file: %s'%self.filename
         
         self.__writeFirstHeader()
@@ -732,18 +736,12 @@ class JRODataWriter(JRODataIO):
         
         self.blocksPerFile = blocksPerFile
         
+        if not(self.setNextFile()):
+            print "There isn't a next file"
+            return 0
         
-        
-        
-        
-        self.getDataHeader()
-
         self.setBlockDimension()
         
-        if not( self.setNextFile() ):
-            print "There isn't a next file"
-            return 0
-
         return 1
 
 
diff --git a/schainpy2/IO/JROHeader.py b/schainpy2/IO/JROHeader.py
index cf3645b..8dc735e 100644
--- a/schainpy2/IO/JROHeader.py
+++ b/schainpy2/IO/JROHeader.py
@@ -341,9 +341,9 @@ class ProcessingHeader(Header):
         self.deltaHeight = 0
         self.samplesWin = 0
         self.spectraComb = 0
-        self.nCode = 0
-        self.code = 0
-        self.nBaud = 0
+        self.nCode = None
+        self.code = None
+        self.nBaud = None
         self.shif_fft = False
         self.flag_dc = False
         self.flag_cspc = False
diff --git a/schainpy2/IO/SpectraIO.py b/schainpy2/IO/SpectraIO.py
index 3fe513f..2f54c04 100644
--- a/schainpy2/IO/SpectraIO.py
+++ b/schainpy2/IO/SpectraIO.py
@@ -203,12 +203,12 @@ class SpectraReader(JRODataReader):
         self.nRdPairs = 0
         self.rdPairList = []
         
-        for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ):
+        for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
             if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
-                self.nRdChannels = self.nRdChannels + 1   #par de canales iguales 
+                self.nRdChannels = self.nRdChannels + 1 #par de canales iguales 
             else:
                 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
-                self.rdPairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
+                self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
 
         pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
 
@@ -369,6 +369,8 @@ class SpectraReader(JRODataReader):
         
         self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc #+ self.profileIndex * self.ippSeconds
         
+        self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
+        
 #        self.profileIndex += 1
         
         self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
@@ -385,11 +387,29 @@ class SpectraWriter(JRODataWriter):
     de los datos siempre se realiza por bloques. 
     """
     
+    ext = ".pdata"
+    
+    optchar = "P"
     
     shape_spc_Buffer = None
+    
     shape_cspc_Buffer = None
+    
     shape_dc_Buffer = None
-    dataOutObj = None
+    
+    data_spc = None
+    
+    data_cspc = None
+    
+    data_dc = None
+        
+    wrPairList = []
+    
+    nWrPairs = 0
+    
+    nWrChannels = 0
+    
+#    dataOutObj = None
     
     def __init__(self, dataOutObj=None):
         """ 
@@ -411,50 +431,55 @@ class SpectraWriter(JRODataWriter):
             raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
 
         self.dataOutObj = dataOutObj
-
-        self.ext = ".pdata"
-        
-        self.optchar = "P"
-        
-        self.shape_spc_Buffer = None
-        self.shape_cspc_Buffer = None
-        self.shape_dc_Buffer = None
-
-        self.data_spc = None
-        self.data_cspc = None
-        self.data_dc = None
-
-        ####################################
-
-        self.fp = None
         
-        self.nWriteBlocks = 0
+        self.nTotalBlocks = 0
         
-        self.flagIsNewFile = 1
+        self.nWrChannels = self.dataOutObj.nChannels
         
-        self.nTotalBlocks = 0 
+#        if len(pairList) > 0:
+#            self.wrPairList = pairList
+#            
+#            self.nWrPairs = len(pairList)
         
-        self.flagIsNewBlock = 0
+        self.wrPairList = self.dataOutObj.pairList
         
-        self.flagNoMoreFiles = 0
-
-        self.setFile = None
+        self.nWrPairs = self.dataOutObj.nPairs
         
-        self.dtype = None
         
-        self.path = None
         
-        self.noMoreFiles = 0
         
-        self.filename = None
-        
-        self.basicHeaderObj = BasicHeader()
-    
-        self.systemHeaderObj = SystemHeader()
-    
-        self.radarControllerHeaderObj = RadarControllerHeader()
-    
-        self.processingHeaderObj = ProcessingHeader()
+
+#        self.data_spc = None
+#        self.data_cspc = None
+#        self.data_dc = None
+
+#        self.fp = None
+
+#        self.flagIsNewFile = 1
+#        
+#        self.nTotalBlocks = 0 
+#        
+#        self.flagIsNewBlock = 0
+#        
+#        self.flagNoMoreFiles = 0
+#
+#        self.setFile = None
+#        
+#        self.dtype = None
+#        
+#        self.path = None
+#        
+#        self.noMoreFiles = 0
+#        
+#        self.filename = None
+#        
+#        self.basicHeaderObj = BasicHeader()
+#    
+#        self.systemHeaderObj = SystemHeader()
+#    
+#        self.radarControllerHeaderObj = RadarControllerHeader()
+#    
+#        self.processingHeaderObj = ProcessingHeader()
 
         
     def hasAllDataInBuffer(self):
@@ -571,4 +596,153 @@ class SpectraWriter(JRODataWriter):
             #print 'Process finished'
             return 0
         
-        return 1
\ No newline at end of file
+        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.dataOutObj.dtype == dtypeList[index]:
+                dtypeValue = datatypeValueList[index]
+                break
+        
+        processFlags += dtypeValue
+        
+        if self.dataOutObj.flagDecodeData:
+            processFlags += PROCFLAG.DECODE_DATA
+        
+        if self.dataOutObj.flagDeflipData:
+            processFlags += PROCFLAG.DEFLIP_DATA
+        
+        if self.dataOutObj.code != None:
+            processFlags += PROCFLAG.DEFINE_PROCESS_CODE
+        
+        if self.dataOutObj.nIncohInt > 1:
+            processFlags += PROCFLAG.INCOHERENT_INTEGRATION
+            
+        if self.dataOutObj.data_dc != 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.dataOutObj.dtype == dtypeList[index]:
+                datatypeValue = datatypeValueList[index]
+                break
+        
+        
+        pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
+        
+        pts2write_SelfSpectra = int(self.nWrChannels * pts2write)
+        blocksize = pts2write_SelfSpectra
+        
+        if self.dataOutObj.data_cspc != None:
+            pts2write_CrossSpectra = int(self.nWrPairs * pts2write)
+            blocksize += pts2write_CrossSpectra
+        
+        if self.dataOutObj.data_dc != None:
+            pts2write_DCchannels = int(self.nWrChannels * self.dataOutObj.nHeights)
+            blocksize += pts2write_DCchannels
+        
+        blocksize = blocksize * datatypeValue * 2
+
+        return blocksize
+    
+    
+    def getBasicHeader(self):
+        self.basicHeaderObj.size = self.basicHeaderSize #bytes
+        self.basicHeaderObj.version = self.versionFile
+        self.basicHeaderObj.dataBlock = self.nTotalBlocks
+        
+        utc = numpy.floor(self.dataOutObj.dataUtcTime)
+        milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
+        
+        self.basicHeaderObj.utc = utc
+        self.basicHeaderObj.miliSecond = milisecond
+        self.basicHeaderObj.timeZone = 0
+        self.basicHeaderObj.dstFlag = 0
+        self.basicHeaderObj.errorCount = 0
+    
+    def getDataHeader(self):
+        
+        """
+        Obtiene una copia del First Header
+         
+        Affected:
+            self.systemHeaderObj
+            self.radarControllerHeaderObj
+            self.dtype
+
+        Return: 
+            None
+        """
+        
+        self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+        self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+        
+        self.getBasicHeader()
+        
+        processingHeaderSize = 40 # bytes    
+        self.processingHeaderObj.dtype = 0 # Voltage
+        self.processingHeaderObj.blockSize = self.__getBlockSize()
+        self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
+        self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
+        self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
+        self.processingHeaderObj.processFlags = self.__getProcessFlags()
+        self.processingHeaderObj.nCohInt = self.dataOutObj.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
+        
+        if self.dataOutObj.code != None:
+            self.processingHeaderObj.code = self.dataOutObj.code
+            self.processingHeaderObj.nCode = self.dataOutObj.nCode
+            self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+            codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+            processingHeaderSize += codesize
+        
+        if self.processingHeaderObj.nWindows != 0:
+            self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+            self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+            self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+            self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+            processingHeaderSize += 12
+            
+        self.processingHeaderObj.size = processingHeaderSize    
+            
+    
\ No newline at end of file
diff --git a/schainpy2/IO/VoltageIO.py b/schainpy2/IO/VoltageIO.py
index 3f65443..9983a54 100644
--- a/schainpy2/IO/VoltageIO.py
+++ b/schainpy2/IO/VoltageIO.py
@@ -298,6 +298,15 @@ class VoltageReader(JRODataReader):
         
         self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
         
+        self.dataOutObj.flagShiftFFT = False
+        
+        if self.processingHeaderObj.code != None:
+            self.dataOutObj.nCode = self.processingHeaderObj.nCode
+            
+            self.dataOutObj.nBaud = self.processingHeaderObj.nBaud
+            
+            self.dataOutObj.code = self.processingHeaderObj.code
+        
         self.profileIndex += 1
         
         self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
@@ -338,7 +347,10 @@ class VoltageWriter(JRODataWriter):
             raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
 
         self.dataOutObj = dataOutObj
+        
+        self.nTotalBlocks = 0
 
+        self.profileIndex = 0
 
     def hasAllDataInBuffer(self):
         if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
@@ -423,14 +435,17 @@ class VoltageWriter(JRODataWriter):
             self.profileIndex = 0
             self.setNextFile()
         
+        if self.profileIndex == 0:
+            self.getBasicHeader()
+        
         self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
         
         self.profileIndex += 1
         
         if self.hasAllDataInBuffer():
             #if self.flagIsNewFile: 
-            self.getDataHeader()
             self.writeNextBlock()
+#            self.getDataHeader()
         
         if self.flagNoMoreFiles:
             #print 'Process finished'
@@ -438,7 +453,7 @@ class VoltageWriter(JRODataWriter):
         
         return 1
     
-    def __getProcessFlag(self):
+    def __getProcessFlags(self):
         
         processFlags = 0
         
@@ -462,7 +477,7 @@ class VoltageWriter(JRODataWriter):
         
         
         for index in range(len(dtypeList)):
-            if dtypeList == self.dataOutObj.dtype:
+            if self.dataOutObj.dtype == dtypeList[index]:
                 dtypeValue = datatypeValueList[index]
                 break
         
@@ -474,12 +489,19 @@ class VoltageWriter(JRODataWriter):
         if self.dataOutObj.flagDeflipData:
             processFlags += PROCFLAG.DEFLIP_DATA
         
+        if self.dataOutObj.code != None:
+            processFlags += PROCFLAG.DEFINE_PROCESS_CODE
+        
         if self.dataOutObj.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')])
@@ -489,15 +511,30 @@ class VoltageWriter(JRODataWriter):
         dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
         
         dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
-        datatypeValueList
+        datatypeValueList = [1,2,4,8,4,8]
         for index in range(len(dtypeList)):
-            if dtypeList == self.dataOutObj.dtype:
-                datatypeValue = index
+            if self.dataOutObj.dtype == dtypeList[index]:
+                datatypeValue = datatypeValueList[index]
                 break
         
-        self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2
+        blocksize = int(self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2)
+        
+        return blocksize
+    
+    
+    def getBasicHeader(self):
+        self.basicHeaderObj.size = self.basicHeaderSize #bytes
+        self.basicHeaderObj.version = self.versionFile
+        self.basicHeaderObj.dataBlock = self.nTotalBlocks
         
+        utc = numpy.floor(self.dataOutObj.dataUtcTime)
+        milisecond  = (self.dataOutObj.dataUtcTime - utc)* 1000.0
         
+        self.basicHeaderObj.utc = utc
+        self.basicHeaderObj.miliSecond = milisecond
+        self.basicHeaderObj.timeZone = 0
+        self.basicHeaderObj.dstFlag = 0
+        self.basicHeaderObj.errorCount = 0
     
     def getDataHeader(self):
         
@@ -513,35 +550,35 @@ class VoltageWriter(JRODataWriter):
             None
         """
         
-#        CALCULAR PARAMETROS
-        
         self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
         self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
         
-        self.basicHeaderObj.size = self.basicHeaderSize #bytes
-        self.basicHeaderObj.version = self.versionFile
-        self.basicHeaderObj.dataBlock = self.nTotalBlocks
-        self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
-        self.basicHeaderObj.miliSecond = 0
-        self.basicHeaderObj.timeZone = 0
-        self.basicHeaderObj.dstFlag = 0
-        self.basicHeaderObj.errorCount = 0
+        self.getBasicHeader()
         
-        staticProcessingHeaderSize = 40 # bytes
-        dynProcessingHeaderSize = 0 # bytes
-        
-        self.processingHeaderObj.size = staticProcessingHeaderSize + dynProcessingHeaderSize
+        processingHeaderSize = 40 # bytes    
         self.processingHeaderObj.dtype = 0 # Voltage
-#        self.processingHeaderObj.dtype = self.dataOutObj.dtype
-        self.processingHeaderObj.blockSize = 0 # debe calcular el size en bytes del bloque de datos:
-        # usar funcion getBlockSize
-        self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nProfiles
+        self.processingHeaderObj.blockSize = self.__getBlockSize()
+        self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
         self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-        self.processingHeaderObj.numWindows = 1
+        self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
         self.processingHeaderObj.processFlags = self.__getProcessFlags()
-        self.processingHeaderObj.coherentInt = self.dataOutObj.nCohInt
-        self.processingHeaderObj.incoherentInt = 1 # Cuando la data de origen sea de tipo Voltage
-        self.processingHeaderObj.totalSpectra = 0
-        
-        self.dtype = self.dataOutObj.dtype
-        
\ No newline at end of file
+        self.processingHeaderObj.nCohInt = self.dataOutObj.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
+        
+        if self.dataOutObj.code != None:
+            self.processingHeaderObj.code = self.dataOutObj.code
+            self.processingHeaderObj.nCode = self.dataOutObj.nCode
+            self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+            codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+            processingHeaderSize += codesize
+        
+        if self.processingHeaderObj.nWindows != 0:
+            self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+            self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+            self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+            self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+            processingHeaderSize += 12
+            
+        self.processingHeaderObj.size = processingHeaderSize    
+            
\ No newline at end of file
diff --git a/schainpy2/Processing/SpectraProcessor.py b/schainpy2/Processing/SpectraProcessor.py
new file mode 100644
index 0000000..30f4f94
--- /dev/null
+++ b/schainpy2/Processing/SpectraProcessor.py
@@ -0,0 +1,388 @@
+'''
+Created on Feb 7, 2012
+
+@author $Author: murco $
+@version $Id: SpectraProcessor.py 119 2012-09-05 17:06:09Z murco $
+'''
+import os, sys
+import numpy
+import time
+
+path = os.path.split(os.getcwd())[0]
+sys.path.append(path)
+
+from Data.Spectra import Spectra
+from IO.SpectraIO import SpectraWriter
+#from Graphics.SpectraPlot import Spectrum
+#from JRONoise import Noise
+
+class SpectraProcessor:
+    '''
+    classdocs
+    '''
+    
+    dataInObj = None        
+    
+    dataOutObj = None
+        
+    noiseObj = None
+    
+    integratorObjList = []
+    
+    writerObjList = []
+    
+    integratorObjIndex = None
+    
+    writerObjIndex = None
+    
+    profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
+    
+#    integratorObjList = []
+#    
+#    decoderObjList = []
+#    
+#    writerObjList = []
+#    
+#    plotterObjList = []
+#    
+#    integratorObjIndex = None
+#    
+#    decoderObjIndex = None
+#    
+#    writerObjIndex = None
+#    
+#    plotterObjIndex = None
+#    
+#    buffer = None
+#    
+#    profIndex = 0
+#    
+#    nFFTPoints = None
+#    
+#    nChannels = None
+#    
+#    nHeights = None
+#    
+#    nPairs = None
+#    
+#    pairList = None
+
+    
+    def __init__(self):
+        '''
+        Constructor
+        '''
+        
+        self.integratorObjIndex = None
+        self.writerObjIndex = None
+        self.integratorObjList = []
+        self.writerObjList = []
+        self.noiseObj = None
+        self.buffer = None
+        self.profIndex = 0
+        
+    def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
+        
+        if dataInObj == None:
+            raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
+        
+        if dataInObj.type == "Voltage":
+            if nFFTPoints == None:
+                raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
+        else:
+            nFFTPoints = dataInObj.nFFTPoints
+        
+        self.dataInObj = dataInObj        
+        
+        if dataOutObj == None:
+            dataOutObj = Spectra()
+            
+        self.dataOutObj = dataOutObj
+        
+#        self.noiseObj = Noise() #aun no se incluye el objeto Noise()
+        
+        ##########################################
+#        self.nFFTPoints = nFFTPoints
+#        self.nChannels = self.dataInObj.nChannels
+#        self.nHeights = self.dataInObj.nHeights
+#        self.pairList = pairList
+#        if pairList != None:
+#            self.nPairs = len(pairList)
+#        else:
+#            self.nPairs = 0
+#        
+#        self.dataOutObj.heightList = self.dataInObj.heightList
+#        self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
+#        self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
+#        self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
+#        self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
+#        self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
+#        
+#        self.dataOutObj.dataType = self.dataInObj.dataType
+#        self.dataOutObj.nPairs = self.nPairs
+#        self.dataOutObj.nChannels = self.nChannels
+#        self.dataOutObj.nProfiles = self.nFFTPoints
+#        self.dataOutObj.nHeights = self.nHeights
+#        self.dataOutObj.nFFTPoints = self.nFFTPoints
+#        #self.dataOutObj.data = None
+#        
+#        self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
+#        self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
+#        
+#        self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs 
+#        self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
+#        self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
+#        self.dataOutObj.m_ProcessingHeader.shif_fft = True
+#        
+#        spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
+#        k = 0
+#        for i in range( 0,self.nChannels*2,2 ):
+#            spectraComb[i]   = k 
+#            spectraComb[i+1] = k
+#            k += 1
+#        
+#        k *= 2
+#
+#        if self.pairList != None:
+#            
+#            for pair in self.pairList:
+#                spectraComb[k]   = pair[0] 
+#                spectraComb[k+1] = pair[1]
+#                k += 2    
+#            
+#        self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
+        
+        return self.dataOutObj
+    
+    def init(self):
+#        
+#        self.nHeights = self.dataInObj.nHeights
+#        self.dataOutObj.nHeights = self.nHeights
+#        self.dataOutObj.heightList = self.dataInObj.heightList
+#        
+        
+        self.integratorObjIndex = 0
+        self.writerObjIndex = 0
+        
+        if self.dataInObj.type == "Voltage":
+            
+            if self.buffer == None:
+                self.buffer = numpy.zeros((self.nChannels,
+                                           self.nFFTPoints,
+                                           self.dataInObj.nHeights), 
+                                          dtype='complex')
+            
+            self.buffer[:,self.profIndex,:] = self.dataInObj.data
+            self.profIndex += 1
+            
+            if self.profIndex == self.nFFTPoints:
+                self.__getFft()
+                self.dataOutObj.flagNoData = False
+                
+                self.buffer = None
+                self.profIndex = 0
+                return
+            
+            self.dataOutObj.flagNoData = True
+            
+            return
+        
+        #Other kind of data
+        if self.dataInObj.type == "Spectra":
+            self.dataOutObj.copy(self.dataInObj)
+            self.dataOutObj.flagNoData = False
+            return
+        
+        raise ValueError, "The datatype is not valid"
+
+    def __getFft(self):
+        """
+        Convierte valores de Voltaje a Spectra
+        
+        Affected:
+            self.dataOutObj.data_spc
+            self.dataOutObj.data_cspc
+            self.dataOutObj.data_dc
+            self.dataOutObj.heightList
+            self.dataOutObj.m_BasicHeader
+            self.dataOutObj.m_ProcessingHeader
+            self.dataOutObj.m_RadarControllerHeader
+            self.dataOutObj.m_SystemHeader
+            self.profIndex  
+            self.buffer
+            self.dataOutObj.flagNoData
+            self.dataOutObj.dataType
+            self.dataOutObj.nPairs
+            self.dataOutObj.nChannels
+            self.dataOutObj.nProfiles
+            self.dataOutObj.m_SystemHeader.numChannels
+            self.dataOutObj.m_ProcessingHeader.totalSpectra 
+            self.dataOutObj.m_ProcessingHeader.profilesPerBlock
+            self.dataOutObj.m_ProcessingHeader.numHeights
+            self.dataOutObj.m_ProcessingHeader.spectraComb
+            self.dataOutObj.m_ProcessingHeader.shif_fft
+        """
+        
+        if self.dataInObj.flagNoData:
+            return 0
+            
+        fft_volt = numpy.fft.fft(self.buffer,axis=1)
+        dc = fft_volt[:,0,:]
+        
+        #calculo de self-spectra
+        fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
+        spc = fft_volt * numpy.conjugate(fft_volt)
+        spc = spc.real
+        
+        blocksize = 0
+        blocksize += dc.size
+        blocksize += spc.size
+        
+        cspc = None
+        pairIndex = 0
+        if self.pairList != None:
+            #calculo de cross-spectra
+            cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
+            for pair in self.pairList:
+                cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
+                pairIndex += 1
+            blocksize += cspc.size
+        
+        self.dataOutObj.data_spc = spc
+        self.dataOutObj.data_cspc = cspc
+        self.dataOutObj.data_dc = dc
+        self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
+        self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
+        
+#        self.getNoise()
+        
+    def addWriter(self, wrpath, profilesPerBlock, blocksPerFile):
+        objWriter = SpectraWriter(self.dataOutObj, pairList)
+        objWriter.setup(wrpath, profilesPerBlock, blocksPerFile)
+        self.writerObjList.append(objWriter)
+                    
+    def addIntegrator(self,N,timeInterval):
+        
+        objIncohInt = IncoherentIntegration(N,timeInterval)
+        self.integratorObjList.append(objIncohInt)
+    
+    def writeData(self, wrpath, profilesPerBlock, blocksPerFile):
+        if self.dataOutObj.flagNoData:
+                return 0
+            
+        if len(self.writerObjList) <= self.writerObjIndex:
+            self.addWriter(wrpath, profilesPerBlock, blocksPerFile)
+        
+        self.writerObjList[self.writerObjIndex].putData()
+        
+        self.writerObjIndex += 1
+                
+    def integrator(self, N=None, timeInterval=None):
+        
+        if self.dataOutObj.flagNoData:
+                return 0
+        
+        if len(self.integratorObjList) <= self.integratorObjIndex:
+            self.addIntegrator(N,timeInterval)
+        
+        myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
+        myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
+        
+        if myIncohIntObj.isReady:
+            self.dataOutObj.data_spc = myIncohIntObj.data
+            self.dataOutObj.nAvg = myIncohIntObj.navg
+            self.dataOutObj.m_ProcessingHeader.incoherentInt = self.dataInObj.m_ProcessingHeader.incoherentInt*myIncohIntObj.navg
+            #print "myIncohIntObj.navg: ",myIncohIntObj.navg
+            self.dataOutObj.flagNoData = False
+            
+            """Calcular el ruido"""
+            self.getNoise()
+        else:
+            self.dataOutObj.flagNoData = True
+        
+        self.integratorObjIndex += 1
+        
+        
+        
+
+class IncoherentIntegration:
+
+    integ_counter = None
+    data = None
+    navg = None
+    buffer = None
+    nIncohInt = None
+    
+    def __init__(self, N = None, timeInterval = None):
+        """
+        N 
+        timeInterval - interval time [min], integer value
+        """
+        
+        self.data = None
+        self.navg = None
+        self.buffer = None
+        self.timeOut = None
+        self.exitCondition = False
+        self.isReady = False
+        self.nIncohInt = N
+        self.integ_counter = 0
+        if timeInterval!=None:
+            self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
+        
+        if ((timeInterval==None) and (N==None)):
+             print 'N = None ; timeInterval = None'
+             sys.exit(0)
+        elif timeInterval == None:
+            self.timeFlag = False
+        else:
+            self.timeFlag = True
+            
+            
+    def exe(self,data,timeOfData):
+        """
+        data
+        
+        timeOfData [seconds]
+        """
+
+        if self.timeFlag:
+            if self.timeOut == None:
+                self.timeOut = timeOfData + self.timeIntervalInSeconds
+            
+            if timeOfData < self.timeOut:
+                if self.buffer == None:
+                    self.buffer = data
+                else:
+                    self.buffer = self.buffer + data
+                self.integ_counter += 1
+            else:
+                self.exitCondition = True
+                
+        else:
+            if self.integ_counter < self.nIncohInt:
+                if self.buffer == None:
+                    self.buffer = data
+                else:
+                    self.buffer = self.buffer + data
+            
+                self.integ_counter += 1
+
+            if self.integ_counter == self.nIncohInt:
+                self.exitCondition = True
+                
+        if self.exitCondition:
+            self.data = self.buffer
+            self.navg = self.integ_counter
+            self.isReady = True
+            self.buffer = None
+            self.timeOut = None
+            self.integ_counter = 0
+            self.exitCondition = False
+            
+            if self.timeFlag:
+                self.buffer = data
+                self.timeOut = timeOfData + self.timeIntervalInSeconds
+        else:
+            self.isReady = False
+            
\ No newline at end of file
diff --git a/schainpy2/testSchainExp.py b/schainpy2/testSchainExp.py
index cc46307..6dff19e 100644
--- a/schainpy2/testSchainExp.py
+++ b/schainpy2/testSchainExp.py
@@ -21,16 +21,24 @@ class TestSChain():
 
     def setValues(self):
         self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
+        self.startDate = datetime.date(2011,11,28)
+        self.endDate = datetime.date(2011,11,30)
         
+#        self.path = "/Users/danielangelsuarezmunoz/Data/Imaging_rawdata"
+#        self.startDate = datetime.date(2011,10,4)
+#        self.endDate = datetime.date(2011,10,4)
+
+        # Probando los escritos por Signal Chain
+        self.path = "/Users/danielangelsuarezmunoz/Data/testWR"
         self.startDate = datetime.date(2011,11,28)
         self.endDate = datetime.date(2011,11,30)
         
         self.startTime = datetime.time(0,0,0)
         self.endTime = datetime.time(23,59,59)
         
-        self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
+        self.wrpath = "/Users/danielangelsuarezmunoz/Data/testWR"
         self.profilesPerBlock = 40
-        self.blocksPerFile = 50 
+        self.blocksPerFile = 50
     
     def createObjects(self):        
         
@@ -56,16 +64,17 @@ class TestSChain():
         while(True):
             self.readerObj.getData()
             
-            self.voltObjProc.init()
-            
-            self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
+#            self.voltObjProc.init()
+#            
+#            self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
                    
             if self.readerObj.flagNoMoreFiles:
                 break
             
             if self.readerObj.flagIsNewBlock:
-                print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
-                                                  datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
+#                print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
+                print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, 
+                                                  datetime.datetime.utcfromtimestamp(self.readerObj.basicHeaderObj.utc + self.readerObj.basicHeaderObj.miliSecond/1000.0),)
 
     
 if __name__ == '__main__':
diff --git a/schainpy2/testSchainSpecExp.py b/schainpy2/testSchainSpecExp.py
index c71eb25..530ac56 100644
--- a/schainpy2/testSchainSpecExp.py
+++ b/schainpy2/testSchainSpecExp.py
@@ -5,11 +5,10 @@ import time, datetime
 path = os.path.split(os.getcwd())[0]
 sys.path.append(path)
 
-from Data.Voltage import Voltage
+
 from Data.Spectra import Spectra
-from IO.VoltageIO import *
 from IO.SpectraIO import *
-from Processing.VoltageProcessor import *
+from Processing.SpectraProcessor import *
 
 
 
@@ -26,19 +25,24 @@ class TestSChain:
         self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
         self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
         
-        self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
-        
         self.startDate = datetime.date(2012,3,1)
         self.endDate = datetime.date(2012,3,30)
         
         self.startTime = datetime.time(0,0,0)
         self.endTime = datetime.time(14,1,1)
+        
+        # paramatros para Escritura de Pdata
+        self.wrpath = "/Users/danielangelsuarezmunoz/Data/testWR_pdata"
+        self.profilesPerBlock = 16
+        self.blocksPerFile = 5
+#        self.pairList = [(0,1),(0,2)]
+        
     
     def createObjects(self):        
         
         self.readerObj = SpectraReader()
 
-        self.voltObj1 = self.readerObj.setup(
+        self.specObj1 = self.readerObj.setup(
                                    path = self.path,
                                    startDate = self.startDate,
                                    endDate = self.endDate,
@@ -46,6 +50,10 @@ class TestSChain:
                                    endTime = self.endTime,
                                    expLabel = '',
                                    online = 0) 
+        # new lines
+        self.specObjProc = SpectraProcessor()
+        
+        self.specObj2 = self.specObjProc.setup(dataInObj = self.specObj1)
         
         
 
@@ -55,13 +63,17 @@ class TestSChain:
 
         while(True):
             self.readerObj.getData()
+            
+            self.specObjProc.init()
+            
+            self.specObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
                    
             if self.readerObj.flagNoMoreFiles:
                 break
             
             if self.readerObj.flagIsNewBlock:
                 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
-                                                  datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
+                                                  datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc))
 
     
 if __name__ == '__main__':