schain Commit - r344:ff2597a84a69 · Jicamarca Repository

-Se ha cambiado la forma de calcular los segundos en tiempo local con el parametro Timezone tomado del archivo leido....

Miguel Valdez -

r344:ff2597a84a69

parent child

Context file:

r344:ff2597a84a69

Collapse all files

schainpy/model/jrodata.py +25 -3

                  flagTimeBlock = False
+                 useLocalTime = False
                  utctime = None
+                 timeZone = None
+                 dstFlag = None
+                 errorCount = None
                  blocksize = None
                  nCode = None
                      return heis
+                 def getltctime(self):
+                     if self.useLocalTime:
+                          return self.utctime - self.timeZone*60
+                     return self.utctime
                  def getDatatime(self):
-                     datatime = datetime.datetime.utcfromtimestamp(self.utctime)
+                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                      return datatime
                  def getTimeRange(self):
                      datatime = []
-                     datatime.append(self.utctime)
-                     datatime.append(self.utctime + self.timeInterval)
+                     datatime.append(self.ltctime)
+                     datatime.append(self.ltctime + self.timeInterval)
                      datatime = numpy.array(datatime)
                  nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                  noise = property(getNoise, "I'm the 'nHeights' property.")
                  datatime = property(getDatatime, "I'm the 'datatime' property")
+                 ltctime = property(getltctime, "I'm the 'ltctime' property")
              class Voltage(JROData):
                      self.utctime = None
+                     self.timeZone = None
+                     self.dstFlag = None
+                     self.errorCount = None
                      self.nCohInt = None
                      self.blocksize = None

schainpy/model/jrodataIO.py +140 -132

              import numpy
              import fnmatch
              import time, datetime
+             try:
              import pyfits
+             except:
+                 print "pyfits module has not been imported, it should be installed to save files in fits format"
              from jrodata import *
              from jroheaderIO import *
              from jroprocessing import *
-             LOCALTIME = -18000
+             LOCALTIME = True #-18000
              def isNumber(str):
                  """
                  __printInfo = True
+                 profileIndex = None
                  def __init__(self):
                      """
                      return self.dataOut
+                 def getBasicHeader(self):
+                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
+                     self.dataOut.flagTimeBlock = self.flagTimeBlock
+                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
+                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
+                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
+                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
+                 def getFirstHeader(self):
+                     raise ValueError, "This method has not been implemented"
                  def getData():
                      raise ValueError, "This method has not been implemented"
                  def putData(self):
                      raise ValueError, "No implemented"
-                 def getDataHeader(self):
+                 def setBasicHeader(self):
+                     self.basicHeaderObj.size = self.basicHeaderSize #bytes
+                     self.basicHeaderObj.version = self.versionFile
+                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
+                     utc = numpy.floor(self.dataOut.utctime)
+                     milisecond  = (self.dataOut.utctime - utc)* 1000.0
+                     self.basicHeaderObj.utc = utc
+                     self.basicHeaderObj.miliSecond = milisecond
+                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
+                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
+                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
+                 def setFirstHeader(self):
                      """
                      Obtiene una copia del First Header
                      raise ValueError, "No implemented"
-                 def getBasicHeader(self):
-                     self.basicHeaderObj.size = self.basicHeaderSize #bytes
-                     self.basicHeaderObj.version = self.versionFile
-                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
-                     utc = numpy.floor(self.dataOut.utctime)
-                     milisecond  = (self.dataOut.utctime - utc)* 1000.0
-                     self.basicHeaderObj.utc = utc
-                     self.basicHeaderObj.miliSecond = milisecond
-                     self.basicHeaderObj.timeZone = 0
-                     self.basicHeaderObj.dstFlag = 0
-                     self.basicHeaderObj.errorCount = 0
                  def __writeFirstHeader(self):
                      """
                      Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                      self.setFile = setFile
                      self.flagIsNewFile = 1
-                     self.getDataHeader()
+                     self.setFirstHeader()
                      print 'Writing the file: %s'%self.filename
                      return 1
-                 def getData(self):
-                     """
-                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
-                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
-                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
-                     Ademas incrementa el contador del buffer en 1.
-                     Return:
-                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
-                                      buffer. Si no hay mas archivos a leer retorna None.
-                     Variables afectadas:
-                         self.dataOut
-                         self.profileIndex
-                     Affected:
-                         self.dataOut
-                         self.profileIndex
-                         self.flagTimeBlock
-                         self.flagIsNewBlock
-                     """
-                     if self.flagNoMoreFiles:
-                         self.dataOut.flagNoData = True
-                         print 'Process finished'
-                         return 0
-                     self.flagTimeBlock = 0
-                     self.flagIsNewBlock = 0
-                     if self.__hasNotDataInBuffer():
-                         if not( self.readNextBlock() ):
-                             return 0
+                 def getFirstHeader(self):
-                         self.dataOut.dtype = self.dtype
-                         self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
-                         self.dataOut.flagTimeBlock = self.flagTimeBlock
-                         self.dataOut.ippSeconds = self.ippSeconds
-                         self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
-                         self.dataOut.flagShiftFFT = False
+                 def getData(self):
+                     """
+                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
+                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
+                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
-             #            self.updateDataHeader()
+                     Ademas incrementa el contador del buffer en 1.
-                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
+                     Return:
+                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
+                                      buffer. Si no hay mas archivos a leer retorna None.
-                     if self.datablock == None:
+                     Variables afectadas:
+                         self.dataOut
+                         self.profileIndex
+                     Affected:
+                         self.dataOut
+                         self.profileIndex
+                         self.flagTimeBlock
+                         self.flagIsNewBlock
+                     """
+                     if self.flagNoMoreFiles:
                          self.dataOut.flagNoData = True
+                         print 'Process finished'
                          return 0
-                     self.dataOut.data = self.datablock[:,self.profileIndex,:]
+                     self.flagTimeBlock = 0
+                     self.flagIsNewBlock = 0
-                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
+                     if self.__hasNotDataInBuffer():
-                     self.profileIndex += 1
+                         if not( self.readNextBlock() ):
+                             return 0
+                         self.getFirstHeader()
+                     if self.datablock == None:
+                         self.dataOut.flagNoData = True
+                         return 0
+                     self.dataOut.data = self.datablock[:,self.profileIndex,:]
                      self.dataOut.flagNoData = False
-             #        print self.profileIndex, self.dataOut.utctime
-             #        if self.profileIndex == 800:
-             #            a=1
+                     self.getBasicHeader()
+                     self.profileIndex += 1
                      return self.dataOut.data
                          self.setNextFile()
                      if self.profileIndex == 0:
-                         self.getBasicHeader()
+                         self.setBasicHeader()
                      self.datablock[:,self.profileIndex,:] = self.dataOut.data
                      if self.hasAllDataInBuffer():
                          #if self.flagIsNewFile:
                          self.writeNextBlock()
-             #            self.getDataHeader()
+             #            self.setFirstHeader()
                      return 1
                      return blocksize
-                 def getDataHeader(self):
+                 def setFirstHeader(self):
                      """
                      Obtiene una copia del First Header
                      self.systemHeaderObj.nChannels = self.dataOut.nChannels
                      self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
-                     self.getBasicHeader()
+                     self.setBasicHeader()
                      processingHeaderSize = 40 # bytes
                      self.processingHeaderObj.dtype = 0 # Voltage
                  rdPairList = []
                  def __init__(self):
                      """
                      Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                      self.dataOut = self.createObjByDefault()
+                     self.profileIndex = 1 #Always
                  def createObjByDefault(self):
                      return 1
+                 def getFirstHeader(self):
+                     self.dataOut.dtype = self.dtype
+                     self.dataOut.nPairs = self.nRdPairs
+                     self.dataOut.pairsList = self.rdPairList
+                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
+                     self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
+                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
+                     self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
+                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
+                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
+                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
+                     self.dataOut.ippSeconds = self.ippSeconds
+                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
+                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
+                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
+                     self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
+                     self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip
+                     if self.processingHeaderObj.code != None:
+                         self.dataOut.nCode = self.processingHeaderObj.nCode
+                         self.dataOut.nBaud = self.processingHeaderObj.nBaud
+                         self.dataOut.code = self.processingHeaderObj.code
+                         self.dataOut.flagDecodeData = True
                  def getData(self):
                      """
                              self.dataOut.flagNoData = True
-                             return 0
-             #            self.updateDataHeader()
                      #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                      if self.data_dc == None:
                          self.dataOut.flagNoData = True
                          return 0
+                     self.getBasicHeader()
+                     self.getFirstHeader()
                      self.dataOut.data_spc = self.data_spc
                      self.dataOut.data_cspc = self.data_cspc
                      self.dataOut.data_dc = self.data_dc
-                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                      self.dataOut.flagNoData = False
-                     self.dataOut.dtype = self.dtype
-             #        self.dataOut.nChannels = self.nRdChannels
-                     self.dataOut.nPairs = self.nRdPairs
-                     self.dataOut.pairsList = self.rdPairList
-             #        self.dataOut.nHeights = self.processingHeaderObj.nHeights
-                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
-                     self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
-                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
-                     self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
-                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
-                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
-                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
-             #        self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
-                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
-                     self.dataOut.ippSeconds = self.ippSeconds
-                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
-             #        self.profileIndex += 1
-                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
-                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
-                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
-                     self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
-                     self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip
-                     if self.processingHeaderObj.code != None:
-                             self.dataOut.nCode = self.processingHeaderObj.nCode
-                             self.dataOut.nBaud = self.processingHeaderObj.nBaud
-                             self.dataOut.code = self.processingHeaderObj.code
-                             self.dataOut.flagDecodeData = True
                      return self.dataOut.data_spc
                          self.setNextFile()
                      if self.flagIsNewFile == 0:
-                         self.getBasicHeader()
+                         self.setBasicHeader()
                      self.data_spc = self.dataOut.data_spc.copy()
                      self.data_cspc = self.dataOut.data_cspc.copy()
                      # #self.processingHeaderObj.dataBlocksPerFile)
                      if self.hasAllDataInBuffer():
-             #            self.getDataHeader()
+             #            self.setFirstHeader()
                          self.writeNextBlock()
                      return 1
                      return blocksize
-                 def getDataHeader(self):
+                 def setFirstHeader(self):
                      """
                      Obtiene una copia del First Header
                      self.systemHeaderObj.nChannels = self.dataOut.nChannels
                      self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
-                     self.getBasicHeader()
+                     self.setBasicHeader()
                      processingHeaderSize = 40 # bytes
                      self.processingHeaderObj.dtype = 1 # Spectra
                      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
+                     self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
                      if self.processingHeaderObj.totalSpectra > 0:
                          channelList = []

schainpy/model/jroheaderIO.py +9 -5

                  version = None
                  dataBlock = None
                  utc = None
+                 ltc = None
                  miliSecond = None
                  timeZone = None
                  dstFlag = None
                  __LOCALTIME = None
-                 def __init__(self, localtime=0):
+                 def __init__(self, useLocalTime=True):
                      self.size = 0
                      self.version = 0
                                            ('nErrorCount','<u4')
                                            ])
-                     self.__LOCALTIME = localtime
+                     self.useLocalTime = useLocalTime
                  def read(self, fp):
                      try:
                          self.dstFlag = int(header['nDstflag'][0])
                          self.errorCount = int(header['nErrorCount'][0])
-                         self.utc += self.__LOCALTIME
+                         self.ltc = self.utc
-                         self.datatime = datetime.datetime.utcfromtimestamp(self.utc)
+                         if self.useLocalTime:
+                             self.ltc -= self.timeZone*60
+                         self.datatime = datetime.datetime.utcfromtimestamp(self.ltc)
                      except Exception, e:
                          print "BasicHeader: "
                      return 1
                  def write(self, fp):
-                     self.utc -= self.__LOCALTIME
                      headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
                      header = numpy.array(headerTuple,self.struct)
                      header.tofile(fp)

schainpy/model/jroprocessing.py +6 0

                  def __updateObjFromInput(self):
+                     self.dataOut.timeZone = self.dataIn.timeZone
+                     self.dataOut.dstFlag = self.dataIn.dstFlag
+                     self.dataOut.errorCount = self.dataIn.errorCount
+                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                      self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                      self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                      self.dataOut.channelList = self.dataIn.channelList
                      self.dataOut.data_cspc = cspc
                      self.dataOut.data_dc = dc
                      self.dataOut.blockSize = blocksize
+                     self.dataOut.flagShiftFFT = True
                  def init(self, nFFTPoints=None, pairsList=None):

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages