schain Commit - r1404:b1b398996ebb · Jicamarca Repository

Lectura y procesamiento de spectra desde HDF5

joabAM -

r1404:b1b398996ebb

parent child

Context file:

r1404:b1b398996ebb

Collapse all files

schainpy/model/data/jrodata.py +4 0

                     self.ippFactor = 1
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
+                    self.codeList = []
+                    self.azimuthList = []
+                    self.elevationList = []
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp','nIncohInt', 'nFFTPoints', 'nProfiles']
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
+                    self.radarControllerHeaderObj.set_ippSeconds(0)
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                     self.timeZone = 0

schainpy/model/graphics/jroplot_base.py 0 -1

                         'interval': dataOut.timeInterval,
                         'channels': dataOut.channelList
                     }
                     data, meta = self.update(dataOut)
                     metadata.update(meta)
                     self.data.update(data, timestamp, metadata)

schainpy/model/graphics/jroplot_parameters.py 0 -1

                     data = {
                         'pow': 10*numpy.log10(dataOut.data_pow)
                     }
-                    #print("data",data)
                     return data, {}
             class SpectralWidthPlot(RTIPlot):

schainpy/model/graphics/jroplot_spectra.py +8 -4

             from schainpy.model.graphics.jroplot_base import Plot, plt, log
             from itertools import combinations
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.ylabel = 'Range [km]'
+                def update_list(self,dataOut):
+                    if len(self.channelList) == 0:
+                        self.channelList = dataOut.channelList
                 def update(self, dataOut):
-                    if self.channelList == None:
+                    self.update_list(dataOut)
-                        self.channelList = dataOut.channelList
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data = self.data[-1]
                     cspc = data['cspc']
-                    #print(self.crossPairs)
                     for n in range(len(self.data.pairs)):
-                        #pair = self.data.pairs[n]
                         pair = self.crossPairs[n]
                         coh = cspc[n*2]
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                 def update(self, dataOut):
                     self.update_list(dataOut)
                     data = {}

schainpy/model/io/jroIO_base.py +1 -1

                     """Check if the given datetime is in range"""
                     startDateTime= datetime.datetime.combine(startDate,startTime)
                     endDateTime = datetime.datetime.combine(endDate,endTime)
-                    #print("dt eval: ", dt, startDateTime,endDateTime)
                     if startDateTime <= dt <= endDateTime:
                         return True
                     return False

schainpy/model/io/jroIO_kamisr.py +1 -1

                     self.profileIndex += 1
-                    return self.dataOut.data
+                    return self.dataOut.data #retorno necesario??
                 def run(self, **kwargs):

schainpy/model/io/jroIO_param.py +16 -20

                 def __init__(self):
                     ProcessingUnit.__init__(self)
-                    self.dataOut = Parameters()
                     self.ext = ".hdf5"
                     self.optchar = "D"
                     self.meta = {}
                     self.folderfmt = "*%Y%j"
                     self.utcoffset = 0
+                    self.dataOut = Parameters()
+                    self.dataOut.error=False            ## NOTE: Importante definir esto antes inicio
+                    self.dataOut.flagNoData = True
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             pathname, filename = os.path.split(fullpath)
-                            #print(pathname,filename)
                             try:
                                 fullpath = next(fullpath)
                     self.setNextFile()
-                    return
                 def readFirstHeader(self):
                     self.__readData()
                     self.__setBlockList()
-                    if 'type' in self.meta:
-                        ##print("Creting dataOut...")
-                        self.dataOut = eval(self.meta['type'])()
-                        ##print(vars(self.dataOut))
                     for attr in self.meta:
-                        ##print("attr: ", attr)
-                        ##print(type(self.dataOut).__name__)
-                        setattr(self.dataOut, attr, self.meta[attr])
+                        setattr(self.dataOut, attr, self.meta[attr])
+                    self.dataOut.error=False
+                    self.dataOut.flagNoData = False
                     self.blockIndex = 0
                     return
                     if not self.isDateTimeInRange(self.startFileDatetime, self.startDate, self.endDate, self.startTime, self.endTime):
                         self.dataOut.flagNoData = True
                         self.blockIndex = self.blocksPerFile
-                        #self.dataOut.error = True      TERMINA EL PROGRAMA, removido
+                        self.dataOut.error = True     # TERMINA EL PROGRAMA
                         return
                     for attr in self.data:
-                        #print("attr ",attr)
                         if self.data[attr].ndim == 1:
                             setattr(self.dataOut, attr, self.data[attr][self.blockIndex])
                         else:
                             self.blockIndex,
                             self.blocksPerFile),self.name)
+                    if self.blockIndex == self.blocksPerFile:
+                        self.setNextFile()
                     self.dataOut.flagNoData = False
-                    self.dataOut.error = False
-                    return
                 def run(self, **kwargs):
                         self.setup(**kwargs)
                         self.isConfig = True
-                    if self.blockIndex == self.blocksPerFile:
-                        self.setNextFile()
                     self.getData()
-                    return
             @MPDecorator
             class HDFWriter(Operation):
                 """Operation to write HDF5 files.
                     if (self.blockIndex == self.blocksPerFile) or self.timeFlag():
                         self.closeFile()
                         self.setNextFile()
-                        print("breaking file")
                     for i, ds in enumerate(self.ds):
                         attr, ch = self.data[i]

schainpy/model/proc/jroproc_base.py +2 0

                     self.dataIn = unit.dataOut
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                             self.dataOut.error = self.dataIn.error
                             self.dataOut.flagNoData = True
                     except:
                         err = traceback.format_exc()
                         if 'SchainWarning' in err:
                             log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), self.name)

schainpy/model/proc/jroproc_parameters.py +1 -1

                         # self.dataOut.normFactor = self.dataIn.normFactor
                         self.dataOut.pairsList = self.dataIn.pairsList
                         self.dataOut.groupList = self.dataIn.pairsList
                         self.dataOut.flagNoData = False
                         if hasattr(self.dataIn, 'ChanDist'): #Distances of receiver channels
                     if self.dataIn.type == "Parameters":
                         self.dataOut.copy(self.dataIn)
                         self.dataOut.flagNoData = False
-                        self.prin("DAta In")
                         return True
                     self.__updateObjFromInput()

schainpy/model/proc/jroproc_spectra.py +10 -9

             from schainpy.utils import log
             from scipy.optimize import curve_fit
+            SPEED_OF_LIGHT = 299792458
             class SpectraProc(ProcessingUnit):
                     self.dataOut.azimuthList = self.dataIn.azimuthList
                     self.dataOut.elevationList = self.dataIn.elevationList
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     self.dataOut.flagShiftFFT = False
                 def run(self, nProfiles=None, nFFTPoints=None, pairsList=None, ippFactor=None, shift_fft=False):
-                    #print("spectra run")
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                         if shift_fft:
                         if pairsList:
                             self.__selectPairs(pairsList)
                     elif self.dataIn.type == "Voltage":
                         self.dataOut.flagNoData = True
                     self.currentTime = self.__initime
                     self.pairsArray = numpy.array(dataOut.pairsList)
                     self.factor_stdv = factor_stdv
-                    #print("CHANNELS: ",[x for x in self.channels])
                     if n != None :
                         self.byProfiles = True
                 def run(self, dataOut,min_hei=None,max_hei=None, n=None, timeInterval=10,factor_stdv=2.5):
-                    #print (dataOut.utctime)
                     if not self.isConfig :
-                        #print("Setting config")
                         self.setup(dataOut, min_hei,max_hei,n,timeInterval,factor_stdv)
-                        #print("Config Done")
                     tini=dataOut.utctime
                     if self.byProfiles:
                             self.__dataReady = True
                     else:
                         if (tini - self.__initime) >= self.__integrationtime:
-                            #print(tini - self.__initime,self.__profIndex)
                             self.__dataReady = True
                             self.__initime = tini
                     #if (tini.tm_min % 2) == 0 and (tini.tm_sec < 5 and self.fint==0):
                     if self.__dataReady:
-                        #print("Data ready",self.__profIndex)
                         self.__profIndex = 0
                         jspc = self.buffer
                         jcspc = self.buffer2
                         buffer_cspc=numpy.copy(self.__buffer_cspc[:,:,:,k])
                         outliers_IDs_cspc=[]
                         cspc_outliers_exist=False
-                        #print("AQUIII")
                         for i in range(self.nChannels):#dataOut.nChannels):
                             buffer1=numpy.copy(self.__buffer_spc[:,i,:,k])

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