schain Commit - r1383:3e971ac8dea1 · Jicamarca Repository

Update2 for EW-Drifts

Percy Condor -

r1383:3e971ac8dea1

parent child

Context file:

r1383:3e971ac8dea1

Expand all files

The requested changes are too big and content was truncated. Show full diff

schainpy/admin.py +13 -13

                 __SCHAIN_SENDER_EMAIL = "MAILSERVER_ACCOUNT"
                 __SCHAIN_SENDER_PASS = "MAILSERVER_PASSWORD"
-                def __init__(self, initFile = None):
+                def __init__(self, initFile=None):
                     # Set configuration file
                     if (initFile == None):
                 Written by "Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe  Dec. 1, 2015
                 """
-                #constants
+                # constants
                 def __init__(self):
                     """__init__ initializes SchainNotify by getting some basic information from SchainDB and SchainSite.
                     self.__emailFromAddress = confObj.getSenderEmail()
                     self.__emailPass = confObj.getSenderPass()
                     self.__emailToAddress = confObj.getAdminEmail()
-                    self.__emailServer  = confObj.getEmailServer()
+                    self.__emailServer = confObj.getEmailServer()
                 def sendEmail(self, email_from, email_to, subject='Error running ...', message="", subtitle="", filename="", html_format=True):
                     msg.preamble = 'SChainPy'
                     if html_format:
-                        message = "<h1> %s </h1>" %subject + "<h3>" + subtitle.replace("\n", "</h3><h3>\n") + "</h3>" + message.replace("\n", "<br>\n")
+                        message = "<h1> %s </h1>" % subject + "<h3>" + subtitle.replace("\n", "</h3><h3>\n") + "</h3>" + message.replace("\n", "<br>\n")
                         message = "<html>\n" + message + '</html>'
                         # This is the textual part:
                     if filename and os.path.isfile(filename):
                         # This is the binary part(The Attachment):
-                        part = MIMEApplication(open(filename,"rb").read())
+                        part = MIMEApplication(open(filename, "rb").read())
                         part.add_header('Content-Disposition',
                                         'attachment',
                                         filename=os.path.basename(filename))
                         msg.attach(part)
                     return 1
-                def sendAlert(self, message, subject = "", subtitle="", filename=""):
+                def sendAlert(self, message, subject="", subtitle="", filename=""):
                     """sendAlert sends an email with the given message and optional title.
                     Inputs: message (string), and optional title (string)
                     if not self.__emailToAddress:
                         return 0
-                    print("***** Sending alert to %s *****" %self.__emailToAddress)
+                    print("***** Sending alert to %s *****" % self.__emailToAddress)
                     # set up message
-                    sent=self.sendEmail(email_from=self.__emailFromAddress,
+                    sent = self.sendEmail(email_from=self.__emailFromAddress,
                                        email_to=self.__emailToAddress,
                                        subject=subject,
                                        message=message,
                                        subtitle=subtitle,
                                        filename=filename)
                     if not sent:
                     return 1
-                def notify(self, email, message, subject = "", subtitle="", filename=""):
+                def notify(self, email, message, subject="", subtitle="", filename=""):
                     """notify sends an email with the given message and title to email.
                     Inputs: email (string), message (string), and subject (string)
                         email_to=email,
                         subject=subject,
                         message=message,
                         subtitle=subtitle,
                         filename=filename
                         )
                 test.sendAlert('This is a message from the python module SchainNotify', 'Test from SchainNotify')
-                print('Hopefully message sent - check.')
  No newline at end of file
+                print('Hopefully message sent - check.')

schainpy/cli/cli.py +1 -1

                     except Exception as e:
                         log.error('Module `{}` does not exists'.format(nextcommand), '')
                         allModules = getAll()
-                        similar = [t[0] for t in process.extract(nextcommand, allModules, limit=12) if t[1]>80]
+                        similar = [t[0] for t in process.extract(nextcommand, allModules, limit=12) if t[1] > 80]
                         log.success('Possible modules are: {}'.format(', '.join(similar)), '')
             def runschain(nextcommand):

schainpy/controller.py +6 -6

                 def removeOperation(self, id):
-                    i = [1 if x.id==id else 0 for x in self.operations]
+                    i = [1 if x.id == id else 0 for x in self.operations]
                     self.operations.pop(i.index(1))
                 def getOperation(self, id):
                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
-                            datatype = name.replace('Reader','')
+                            datatype = name.replace('Reader', '')
                         else:
                             name = '{}Reader'.format(datatype)
                     if datatype == None:
                         if 'Reader' in name:
-                            datatype = name.replace('Reader','')
+                            datatype = name.replace('Reader', '')
                         else:
                             datatype = name
                             name = '{}Reader'.format(name)
                         if '#_start_#' in msg:
                             procs += 1
                         elif '#_end_#' in msg:
-                            procs -=1
+                            procs -= 1
                         else:
                             err_msg = msg
                             subtitle += '[End time = %s]\n' % readUnitConfObj.parameters['endTime']
                         a = Alarm(
                             modes=self.alarm,
                             email=self.email,
                             message=message,
                             subject=subject,
                     self.runProcs()
                     log.success('{} Done (Time: {:4.2f}s)'.format(
                         self.name,
-                        time.time()-self.start_time), '')
+                        time.time() - self.start_time), '')

schainpy/model/data/BLTRheaderIO.py +146 -146

@@ -12,49 +12,49 import datetime
12	SPEED_OF_LIGHT = 299792458	12	SPEED_OF_LIGHT = 299792458
13	SPEED_OF_LIGHT = 3e8	13	SPEED_OF_LIGHT = 3e8
14		14
15	FILE_STRUCTURE = numpy.dtype([ #HEADER 48bytes	15	FILE_STRUCTURE = numpy.dtype([ # HEADER 48bytes
16	('FileMgcNumber','<u4'), #0x23020100	16	('FileMgcNumber', '<u4'), # 0x23020100
17	('nFDTdataRecors','<u4'), #No Of FDT data records in this file (0 or more)	17	('nFDTdataRecors', '<u4'), # No Of FDT data records in this file (0 or more)
18	('RadarUnitId','<u4'),	18	('RadarUnitId', '<u4'),
19	('SiteName','<s32'), #Null terminated	19	('SiteName', '<s32'), # Null terminated
20	])	20	])
21		21
22	RECORD_STRUCTURE = numpy.dtype([ #RECORD HEADER 180+20N bytes	22	RECORD_STRUCTURE = numpy.dtype([ # RECORD HEADER 180+20N bytes
23	('RecMgcNumber','<u4'), #0x23030001	23	('RecMgcNumber', '<u4'), # 0x23030001
24	('RecCounter','<u4'), #Record counter(0,1, ...)	24	('RecCounter', '<u4'), # Record counter(0,1, ...)
25	('Off2StartNxtRec','<u4'), #Offset to start of next record form start of this record	25	('Off2StartNxtRec', '<u4'), # Offset to start of next record form start of this record
26	('Off2StartData','<u4'), #Offset to start of data from start of this record	26	('Off2StartData', '<u4'), # Offset to start of data from start of this record
27	('EpTimeStamp','<i4'), #Epoch time stamp of start of acquisition (seconds)	27	('EpTimeStamp', '<i4'), # Epoch time stamp of start of acquisition (seconds)
28	('msCompTimeStamp','<u4'), #Millisecond component of time stamp (0,...,999)	28	('msCompTimeStamp', '<u4'), # Millisecond component of time stamp (0,...,999)
29	('ExpTagName','<s32'), #Experiment tag name (null terminated)	29	('ExpTagName', '<s32'), # Experiment tag name (null terminated)
30	('ExpComment','<s32'), #Experiment comment (null terminated)	30	('ExpComment', '<s32'), # Experiment comment (null terminated)
31	('SiteLatDegrees','<f4'), #Site latitude (from GPS) in degrees (positive implies North)	31	('SiteLatDegrees', '<f4'), # Site latitude (from GPS) in degrees (positive implies North)
32	('SiteLongDegrees','<f4'), #Site longitude (from GPS) in degrees (positive implies East)	32	('SiteLongDegrees', '<f4'), # Site longitude (from GPS) in degrees (positive implies East)
33	('RTCgpsStatus','<u4'), #RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)	33	('RTCgpsStatus', '<u4'), # RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
34	('TransmitFrec','<u4'), #Transmit frequency (Hz)	34	('TransmitFrec', '<u4'), # Transmit frequency (Hz)
35	('ReceiveFrec','<u4'), #Receive frequency	35	('ReceiveFrec', '<u4'), # Receive frequency
36	('FirstOsciFrec','<u4'), #First local oscillator frequency (Hz)	36	('FirstOsciFrec', '<u4'), # First local oscillator frequency (Hz)
37	('Polarisation','<u4'), #(0="O", 1="E", 2="linear 1", 3="linear2")	37	('Polarisation', '<u4'), # (0="O", 1="E", 2="linear 1", 3="linear2")
38	('ReceiverFiltSett','<u4'), #Receiver filter settings (0,1,2,3)	38	('ReceiverFiltSett', '<u4'), # Receiver filter settings (0,1,2,3)
39	('nModesInUse','<u4'), #Number of modes in use (1 or 2)	39	('nModesInUse', '<u4'), # Number of modes in use (1 or 2)
40	('DualModeIndex','<u4'), #Dual Mode index number for these data (0 or 1)	40	('DualModeIndex', '<u4'), # Dual Mode index number for these data (0 or 1)
41	('DualModeRange','<u4'), #Dual Mode range correction for these data (m)	41	('DualModeRange', '<u4'), # Dual Mode range correction for these data (m)
42	('nDigChannels','<u4'), #Number of digital channels acquired (2*N)	42	('nDigChannels', '<u4'), # Number of digital channels acquired (2*N)
43	('SampResolution','<u4'), #Sampling resolution (meters)	43	('SampResolution', '<u4'), # Sampling resolution (meters)
44	('nRangeGatesSamp','<u4'), #Number of range gates sampled	44	('nRangeGatesSamp', '<u4'), # Number of range gates sampled
45	('StartRangeSamp','<u4'), #Start range of sampling (meters)	45	('StartRangeSamp', '<u4'), # Start range of sampling (meters)
46	('PRFhz','<u4'), #PRF (Hz)	46	('PRFhz', '<u4'), # PRF (Hz)
47	('Integrations','<u4'), #Integrations	47	('Integrations', '<u4'), # Integrations
48	('nDataPointsTrsf','<u4'), #Number of data points transformed	48	('nDataPointsTrsf', '<u4'), # Number of data points transformed
49	('nReceiveBeams','<u4'), #Number of receive beams stored in file (1 or N)	49	('nReceiveBeams', '<u4'), # Number of receive beams stored in file (1 or N)
50	('nSpectAverages','<u4'), #Number of spectral averages	50	('nSpectAverages', '<u4'), # Number of spectral averages
51	('FFTwindowingInd','<u4'), #FFT windowing index (0 = no window)	51	('FFTwindowingInd', '<u4'), # FFT windowing index (0 = no window)
52	('BeamAngleAzim','<f4'), #Beam steer angle (azimuth) in degrees (clockwise from true North)	52	('BeamAngleAzim', '<f4'), # Beam steer angle (azimuth) in degrees (clockwise from true North)
53	('BeamAngleZen','<f4'), #Beam steer angle (zenith) in degrees (0=> vertical)	53	('BeamAngleZen', '<f4'), # Beam steer angle (zenith) in degrees (0=> vertical)
54	('AntennaCoord','<f24'), #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs	54	('AntennaCoord', '<f24'), # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
55	('RecPhaseCalibr','<f12'), #Receiver phase calibration (degrees) - N values	55	('RecPhaseCalibr', '<f12'), # Receiver phase calibration (degrees) - N values
56	('RecAmpCalibr','<f12'), #Receiver amplitude calibration (ratio relative to receiver one) - N values	56	('RecAmpCalibr', '<f12'), # Receiver amplitude calibration (ratio relative to receiver one) - N values
57	('ReceiverGaindB','<u12'), #Receiver gains in dB - N values	57	('ReceiverGaindB', '<u12'), # Receiver gains in dB - N values
58	])	58	])
59		59
60		60
@@ -82,39 +82,39 class Header(object):
82	keyList.sort()	82	keyList.sort()
83		83
84	for key in keyList:	84	for key in keyList:
85	message += "%s = %s" %(key, self.__dict__[key]) + "\n"	85	message += "%s = %s" % (key, self.__dict__[key]) + "\n"
86		86
87	if "size" not in keyList:	87	if "size" not in keyList:
88	attr = getattr(self, "size")	88	attr = getattr(self, "size")
89		89
90	if attr:	90	if attr:
91	message += "%s = %s" %("size", attr) + "\n"	91	message += "%s = %s" % ("size", attr) + "\n"
92		92
93	print(message)	93	print(message)
94		94
95	class FileHeader(Header):	95	class FileHeader(Header):
96		96
97	FileMgcNumber= None	97	FileMgcNumber = None
98	nFDTdataRecors=None #No Of FDT data records in this file (0 or more)	98	nFDTdataRecors = None # No Of FDT data records in this file (0 or more)
99	RadarUnitId= None	99	RadarUnitId = None
100	SiteName= None	100	SiteName = None
101		101
102	#__LOCALTIME = None	102	# __LOCALTIME = None
103		103
104	def __init__(self, useLocalTime=True):	104	def __init__(self, useLocalTime=True):
105		105
106	self.FileMgcNumber= 0 #0x23020100	106	self.FileMgcNumber = 0 # 0x23020100
107	self.nFDTdataRecors=0 #No Of FDT data records in this file (0 or more)	107	self.nFDTdataRecors = 0 # No Of FDT data records in this file (0 or more)
108	self.RadarUnitId= 0	108	self.RadarUnitId = 0
109	self.SiteName= ""	109	self.SiteName = ""
110	self.size = 48	110	self.size = 48
111		111
112	#self.useLocalTime = useLocalTime	112	# self.useLocalTime = useLocalTime
113		113
114	def read(self, fp):	114	def read(self, fp):
115		115
116	try:	116	try:
117	header = numpy.fromfile(fp, FILE_STRUCTURE,1)	117	header = numpy.fromfile(fp, FILE_STRUCTURE, 1)
118	''' numpy.fromfile(file, dtype, count, sep='')	118	''' numpy.fromfile(file, dtype, count, sep='')
119	file : file or str	119	file : file or str
120	Open file object or filename.	120	Open file object or filename.
@@ -139,13 +139,13 class FileHeader(Header):
139	print(eBasicHeader)	139	print(eBasicHeader)
140	return 0	140	return 0
141		141
142	self.FileMgcNumber= byte(header['FileMgcNumber'][0])	142	self.FileMgcNumber = byte(header['FileMgcNumber'][0])
143	self.nFDTdataRecors=int(header['nFDTdataRecors'][0]) #No Of FDT data records in this file (0 or more)	143	self.nFDTdataRecors = int(header['nFDTdataRecors'][0]) # No Of FDT data records in this file (0 or more)
144	self.RadarUnitId= int(header['RadarUnitId'][0])	144	self.RadarUnitId = int(header['RadarUnitId'][0])
145	self.SiteName= char(header['SiteName'][0])	145	self.SiteName = char(header['SiteName'][0])
146		146
147		147
148	if self.size <48:	148	if self.size < 48:
149	return 0	149	return 0
150		150
151	return 1	151	return 1
@@ -182,40 +182,40 class FileHeader(Header):
182		182
183	class RecordHeader(Header):	183	class RecordHeader(Header):
184		184
185	RecMgcNumber=None #0x23030001	185	RecMgcNumber = None # 0x23030001
186	RecCounter= None	186	RecCounter = None
187	Off2StartNxtRec= None	187	Off2StartNxtRec = None
188	EpTimeStamp= None	188	EpTimeStamp = None
189	msCompTimeStamp= None	189	msCompTimeStamp = None
190	ExpTagName= None	190	ExpTagName = None
191	ExpComment=None	191	ExpComment = None
192	SiteLatDegrees=None	192	SiteLatDegrees = None
193	SiteLongDegrees= None	193	SiteLongDegrees = None
194	RTCgpsStatus= None	194	RTCgpsStatus = None
195	TransmitFrec= None	195	TransmitFrec = None
196	ReceiveFrec= None	196	ReceiveFrec = None
197	FirstOsciFrec= None	197	FirstOsciFrec = None
198	Polarisation= None	198	Polarisation = None
199	ReceiverFiltSett= None	199	ReceiverFiltSett = None
200	nModesInUse= None	200	nModesInUse = None
201	DualModeIndex= None	201	DualModeIndex = None
202	DualModeRange= None	202	DualModeRange = None
203	nDigChannels= None	203	nDigChannels = None
204	SampResolution= None	204	SampResolution = None
205	nRangeGatesSamp= None	205	nRangeGatesSamp = None
206	StartRangeSamp= None	206	StartRangeSamp = None
207	PRFhz= None	207	PRFhz = None
208	Integrations= None	208	Integrations = None
209	nDataPointsTrsf= None	209	nDataPointsTrsf = None
210	nReceiveBeams= None	210	nReceiveBeams = None
211	nSpectAverages= None	211	nSpectAverages = None
212	FFTwindowingInd= None	212	FFTwindowingInd = None
213	BeamAngleAzim= None	213	BeamAngleAzim = None
214	BeamAngleZen= None	214	BeamAngleZen = None
215	AntennaCoord= None	215	AntennaCoord = None
216	RecPhaseCalibr= None	216	RecPhaseCalibr = None
217	RecAmpCalibr= None	217	RecAmpCalibr = None
218	ReceiverGaindB= None	218	ReceiverGaindB = None
219		219
220	'''size = None	220	'''size = None
221	nSamples = None	221	nSamples = None
@@ -224,20 +224,20 class RecordHeader(Header):
224	adcResolution = None	224	adcResolution = None
225	pciDioBusWidth = None'''	225	pciDioBusWidth = None'''
226		226
227	def __init__(self, RecMgcNumber=None, RecCounter= 0, Off2StartNxtRec= 0,	227	def __init__(self, RecMgcNumber=None, RecCounter=0, Off2StartNxtRec=0,
228	EpTimeStamp= 0, msCompTimeStamp= 0, ExpTagName= None,	228	EpTimeStamp=0, msCompTimeStamp=0, ExpTagName=None,
229	ExpComment=None, SiteLatDegrees=0, SiteLongDegrees= 0,	229	ExpComment=None, SiteLatDegrees=0, SiteLongDegrees=0,
230	RTCgpsStatus= 0, TransmitFrec= 0, ReceiveFrec= 0,	230	RTCgpsStatus=0, TransmitFrec=0, ReceiveFrec=0,
231	FirstOsciFrec= 0, Polarisation= 0, ReceiverFiltSett= 0,	231	FirstOsciFrec=0, Polarisation=0, ReceiverFiltSett=0,
232	nModesInUse= 0, DualModeIndex= 0, DualModeRange= 0,	232	nModesInUse=0, DualModeIndex=0, DualModeRange=0,
233	nDigChannels= 0, SampResolution= 0, nRangeGatesSamp= 0,	233	nDigChannels=0, SampResolution=0, nRangeGatesSamp=0,
234	StartRangeSamp= 0, PRFhz= 0, Integrations= 0,	234	StartRangeSamp=0, PRFhz=0, Integrations=0,
235	nDataPointsTrsf= 0, nReceiveBeams= 0, nSpectAverages= 0,	235	nDataPointsTrsf=0, nReceiveBeams=0, nSpectAverages=0,
236	FFTwindowingInd= 0, BeamAngleAzim= 0, BeamAngleZen= 0,	236	FFTwindowingInd=0, BeamAngleAzim=0, BeamAngleZen=0,
237	AntennaCoord= 0, RecPhaseCalibr= 0, RecAmpCalibr= 0,	237	AntennaCoord=0, RecPhaseCalibr=0, RecAmpCalibr=0,
238	ReceiverGaindB= 0):	238	ReceiverGaindB=0):
239		239
240	self.RecMgcNumber = RecMgcNumber #0x23030001	240	self.RecMgcNumber = RecMgcNumber # 0x23030001
241	self.RecCounter = RecCounter	241	self.RecCounter = RecCounter
242	self.Off2StartNxtRec = Off2StartNxtRec	242	self.Off2StartNxtRec = Off2StartNxtRec
243	self.EpTimeStamp = EpTimeStamp	243	self.EpTimeStamp = EpTimeStamp
@@ -275,15 +275,15 class RecordHeader(Header):
275		275
276	def read(self, fp):	276	def read(self, fp):
277		277
278	startFp = fp.tell() #The method tell() returns the current position of the file read/write pointer within the file.	278	startFp = fp.tell() # The method tell() returns the current position of the file read/write pointer within the file.
279		279
280	try:	280	try:
281	header = numpy.fromfile(fp,RECORD_STRUCTURE,1)	281	header = numpy.fromfile(fp, RECORD_STRUCTURE, 1)
282	except Exception as e:	282	except Exception as e:
283	print("System Header: " + e)	283	print("System Header: " + e)
284	return 0	284	return 0
285		285
286	self.RecMgcNumber = header['RecMgcNumber'][0] #0x23030001	286	self.RecMgcNumber = header['RecMgcNumber'][0] # 0x23030001
287	self.RecCounter = header['RecCounter'][0]	287	self.RecCounter = header['RecCounter'][0]
288	self.Off2StartNxtRec = header['Off2StartNxtRec'][0]	288	self.Off2StartNxtRec = header['Off2StartNxtRec'][0]
289	self.EpTimeStamp = header['EpTimeStamp'][0]	289	self.EpTimeStamp = header['EpTimeStamp'][0]
@@ -318,16 +318,16 class RecordHeader(Header):
318	self.RecAmpCalibr = header['RecAmpCalibr'][0]	318	self.RecAmpCalibr = header['RecAmpCalibr'][0]
319	self.ReceiverGaindB = header['ReceiverGaindB'][0]	319	self.ReceiverGaindB = header['ReceiverGaindB'][0]
320		320
321	Self.size = 180+20*3	321	Self.size = 180 + 20 * 3
322		322
323	endFp = self.size + startFp	323	endFp = self.size + startFp
324		324
325	if fp.tell() > endFp:	325	if fp.tell() > endFp:
326	sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)	326	sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name)
327	return 0	327	return 0
328		328
329	if fp.tell() < endFp:	329	if fp.tell() < endFp:
330	sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)	330	sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name)
331	return 0	331	return 0
332		332
333	return 1	333	return 1
@@ -335,38 +335,38 class RecordHeader(Header):
335	def write(self, fp):	335	def write(self, fp):
336		336
337	headerTuple = (self.RecMgcNumber,	337	headerTuple = (self.RecMgcNumber,
338	self.RecCounter,	338	self.RecCounter,
339	self.Off2StartNxtRec,	339	self.Off2StartNxtRec,
340	self.EpTimeStamp,	340	self.EpTimeStamp,
341	self.msCompTimeStamp,	341	self.msCompTimeStamp,
342	self.ExpTagName,	342	self.ExpTagName,
343	self.ExpComment,	343	self.ExpComment,
344	self.SiteLatDegrees,	344	self.SiteLatDegrees,
345	self.SiteLongDegrees,	345	self.SiteLongDegrees,
346	self.RTCgpsStatus,	346	self.RTCgpsStatus,
347	self.TransmitFrec,	347	self.TransmitFrec,
348	self.ReceiveFrec,	348	self.ReceiveFrec,
349	self.FirstOsciFrec,	349	self.FirstOsciFrec,
350	self.Polarisation,	350	self.Polarisation,
351	self.ReceiverFiltSett,	351	self.ReceiverFiltSett,
352	self.nModesInUse,	352	self.nModesInUse,
353	self.DualModeIndex,	353	self.DualModeIndex,
354	self.DualModeRange,	354	self.DualModeRange,
355	self.nDigChannels,	355	self.nDigChannels,
356	self.SampResolution,	356	self.SampResolution,
357	self.nRangeGatesSamp,	357	self.nRangeGatesSamp,
358	self.StartRangeSamp,	358	self.StartRangeSamp,
359	self.PRFhz,	359	self.PRFhz,
360	self.Integrations,	360	self.Integrations,
361	self.nDataPointsTrsf,	361	self.nDataPointsTrsf,
362	self.nReceiveBeams,	362	self.nReceiveBeams,
363	self.nSpectAverages,	363	self.nSpectAverages,
364	self.FFTwindowingInd,	364	self.FFTwindowingInd,
365	self.BeamAngleAzim,	365	self.BeamAngleAzim,
366	self.BeamAngleZen,	366	self.BeamAngleZen,
367	self.AntennaCoord,	367	self.AntennaCoord,
368	self.RecPhaseCalibr,	368	self.RecPhaseCalibr,
369	self.RecAmpCalibr,	369	self.RecAmpCalibr,
370	self.ReceiverGaindB)	370	self.ReceiverGaindB)
371		371
372	# self.size,self.nSamples,	372	# self.size,self.nSamples,
@@ -375,7 +375,7 class RecordHeader(Header):
375	# self.adcResolution,	375	# self.adcResolution,
376	# self.pciDioBusWidth	376	# self.pciDioBusWidth
377		377
378	header = numpy.array(headerTuple,RECORD_STRUCTURE)	378	header = numpy.array(headerTuple, RECORD_STRUCTURE)
379	header.tofile(fp)	379	header.tofile(fp)
380		380
381	return 1	381	return 1
@@ -394,11 +394,11 def get_dtype_index(numpy_dtype):
394		394
395	def get_numpy_dtype(index):	395	def get_numpy_dtype(index):
396		396
397	#dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])	397	# dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
398		398
399	return NUMPY_DTYPE_LIST[index]	399	return NUMPY_DTYPE_LIST[index]
400		400
401		401
402	def get_dtype_width(index):	402	def get_dtype_width(index):
403		403
404	return DTYPE_WIDTH[index] No newline at end of file	404	return DTYPE_WIDTH[index]

schainpy/model/data/__init__.py +1 -1

             from .jrodata import *
             from .jroheaderIO import *
-            from .jroamisr import *
  No newline at end of file
+            from .jroamisr import *

schainpy/model/data/jroamisr.py +26 -26

@@ -15,41 +15,41 class AMISR:
15	self.utctime = None	15	self.utctime = None
16	self.type = "AMISR"	16	self.type = "AMISR"
17		17
18	#propiedades para compatibilidad con Voltages	18	# propiedades para compatibilidad con Voltages
19	self.timeZone = 0#timezone like jroheader, difference in minutes between UTC and localtime	19	self.timeZone = 0 # timezone like jroheader, difference in minutes between UTC and localtime
20	self.dstFlag = 0#self.dataIn.dstFlag	20	self.dstFlag = 0 # self.dataIn.dstFlag
21	self.errorCount = 0#self.dataIn.errorCount	21	self.errorCount = 0 # self.dataIn.errorCount
22	self.useLocalTime = True#self.dataIn.useLocalTime	22	self.useLocalTime = True # self.dataIn.useLocalTime
23		23
24	self.radarControllerHeaderObj = None#self.dataIn.radarControllerHeaderObj.copy()	24	self.radarControllerHeaderObj = None # self.dataIn.radarControllerHeaderObj.copy()
25	self.systemHeaderObj = None#self.dataIn.systemHeaderObj.copy()	25	self.systemHeaderObj = None # self.dataIn.systemHeaderObj.copy()
26	self.channelList = [0]#self.dataIn.channelList esto solo aplica para el caso de AMISR	26	self.channelList = [0] # self.dataIn.channelList esto solo aplica para el caso de AMISR
27	self.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])	27	self.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
28		28
29	self.flagDiscontinuousBlock = None#self.dataIn.flagDiscontinuousBlock	29	self.flagDiscontinuousBlock = None # self.dataIn.flagDiscontinuousBlock
30	#self.utctime = #self.firstdatatime	30	# self.utctime = #self.firstdatatime
31	self.flagDecodeData = None#self.dataIn.flagDecodeData #asumo q la data esta decodificada	31	self.flagDecodeData = None # self.dataIn.flagDecodeData #asumo q la data esta decodificada
32	self.flagDeflipData = None#self.dataIn.flagDeflipData #asumo q la data esta sin flip	32	self.flagDeflipData = None # self.dataIn.flagDeflipData #asumo q la data esta sin flip
33		33
34	self.nCohInt = 1#self.dataIn.nCohInt	34	self.nCohInt = 1 # self.dataIn.nCohInt
35	self.nIncohInt = 1	35	self.nIncohInt = 1
36	self.ippSeconds = None#self.dataIn.ippSeconds, segun el filename/Setup/Tufile	36	self.ippSeconds = None # self.dataIn.ippSeconds, segun el filename/Setup/Tufile
37	self.windowOfFilter = None#self.dataIn.windowOfFilter	37	self.windowOfFilter = None # self.dataIn.windowOfFilter
38		38
39	self.timeInterval = None#self.dataIn.timeIntervalself.dataOut.nFFTPointsself.dataOut.nIncohInt	39	self.timeInterval = None # self.dataIn.timeIntervalself.dataOut.nFFTPointsself.dataOut.nIncohInt
40	self.frequency = None#self.dataIn.frequency	40	self.frequency = None # self.dataIn.frequency
41	self.realtime = 0#self.dataIn.realtime	41	self.realtime = 0 # self.dataIn.realtime
42		42
43	#actualizar en la lectura de datos	43	# actualizar en la lectura de datos
44	self.heightList = None#self.dataIn.heightList	44	self.heightList = None # self.dataIn.heightList
45	self.nProfiles = None#Number of samples or nFFTPoints	45	self.nProfiles = None # Number of samples or nFFTPoints
46	self.nRecords = None	46	self.nRecords = None
47	self.nBeams = None	47	self.nBeams = None
48	self.nBaud = None#self.dataIn.nBaud	48	self.nBaud = None # self.dataIn.nBaud
49	self.nCode = None#self.dataIn.nCode	49	self.nCode = None # self.dataIn.nCode
50	self.code = None#self.dataIn.code	50	self.code = None # self.dataIn.code
51		51
52	#consideracion para los Beams	52	# consideracion para los Beams
53	self.beamCodeDict = None	53	self.beamCodeDict = None
54	self.beamRangeDict = None	54	self.beamRangeDict = None
55	self.beamcode = None	55	self.beamcode = None

schainpy/model/data/jrodata.py +17 -17

                 def getFmaxTimeResponse(self):
-                    period = (10**-6) * self.getDeltaH() / (0.15)
+                    period = (10 ** -6) * self.getDeltaH() / (0.15)
                     PRF = 1. / (period * self.nCohInt)
             class Voltage(JROData):
-                dataPP_POW   = None
+                dataPP_POW = None
-                dataPP_DOP   = None
+                dataPP_DOP = None
                 dataPP_WIDTH = None
-                dataPP_SNR   = None
+                dataPP_SNR = None
                 def __init__(self):
                     '''
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'nProfiles', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp']
                 def getNoisebyHildebrand(self, channel=None):
                     self.ippFactor = 1
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
-                        'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp','nIncohInt', 'nFFTPoints', 'nProfiles']
+                        'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp', 'nIncohInt', 'nFFTPoints', 'nProfiles']
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
-                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
+                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
-                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
+                    freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                     velrange = deltav * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.)
                     if self.nmodes:
-                        return velrange/self.nmodes
+                        return velrange / self.nmodes
                     else:
                         return velrange
                     pwcode = 1
                     if self.flagDecodeData:
-                        pwcode = numpy.sum(self.code[0]**2)
+                        pwcode = numpy.sum(self.code[0] ** 2)
-                    #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
+                    # normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
                     return normFactor
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
-                        return self.nmodes*timeInterval
+                        return self.nmodes * timeInterval
                     else:
                         return timeInterval
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
-                        pwcode = numpy.sum(self.code[0]**2)
+                        pwcode = numpy.sum(self.code[0] ** 2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
-                            xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
+                            xx[fil, :] = vel[fil] ** numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                     meta = {}
                     meta['xrange'] = []
-                    dy = int(len(self.yrange)/self.MAXNUMY) + 1
+                    dy = int(len(self.yrange) / self.MAXNUMY) + 1
                     tmp = self.data[tm][self.key]
                     shape = tmp.shape
                     if len(shape) == 2:
                         data = self.roundFloats(self.data[tm][self.key][::, ::dy].tolist())
                     elif len(shape) == 3:
-                        dx = int(self.data[tm][self.key].shape[1]/self.MAXNUMX) + 1
+                        dx = int(self.data[tm][self.key].shape[1] / self.MAXNUMX) + 1
                         data = self.roundFloats(
                             self.data[tm][self.key][::, ::dx, ::dy].tolist())
                         meta['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())

schainpy/model/data/jroheaderIO.py +2 -2

                                 for j in range(len(code_selected) - 1, -1, -1):
                                     if code_selected[j] == 1:
                                         tempx[i] = tempx[i] + \
-**(len(code_selected) - 1 - j)
+** (len(code_selected) - 1 - j)
                                 start = start + 32
                                 end = end + 32
             def get_dtype_width(index):
-                return DTYPE_WIDTH[index]
  No newline at end of file
+                return DTYPE_WIDTH[index]

schainpy/model/graphics/jroplot_base.py +16 -16

             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
-                a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
+                a = 0.5 - numpy.cos((lat2 - lat1) * p) / 2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
-                theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
+                theta = numpy.arctan2(numpy.sin((lon2 - lon1) * p) * numpy.cos(lat2 * p), numpy.cos(lat1 * p)
-                                      * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
+                                      * numpy.sin(lat2 * p) - numpy.sin(lat1 * p) * numpy.cos(lat2 * p) * numpy.cos((lon2 - lon1) * p))
-                theta = -theta + numpy.pi/2
+                theta = -theta + numpy.pi / 2
-                return r*numpy.cos(theta), r*numpy.sin(theta)
+                return r * numpy.cos(theta), r * numpy.sin(theta)
             def km2deg(km):
                 Convert distance in km to degrees
                 '''
-                return numpy.rad2deg(km/EARTH_RADIUS)
+                return numpy.rad2deg(km / EARTH_RADIUS)
             def figpause(interval):
                                 xmax = self.xmax
                             else:
                                 xmin = self.tmin
-                                xmax = self.tmin + self.xrange*60*60
+                                xmax = self.tmin + self.xrange * 60 * 60
                                 ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
                                 ax.xaxis.set_major_locator(LinearLocator(9))
                             ymin = self.ymin if self.ymin is not None else numpy.nanmin(self.y[numpy.isfinite(self.y)])
                             ax.set_facecolor(self.bgcolor)
                             if self.xscale:
                                 ax.xaxis.set_major_formatter(FuncFormatter(
-                                    lambda x, pos: '{0:g}'.format(x*self.xscale)))
+                                    lambda x, pos: '{0:g}'.format(x * self.xscale)))
                             if self.yscale:
                                 ax.yaxis.set_major_formatter(FuncFormatter(
-                                    lambda x, pos: '{0:g}'.format(x*self.yscale)))
+                                    lambda x, pos: '{0:g}'.format(x * self.yscale)))
                             if self.xlabel is not None:
                                 ax.set_xlabel(self.xlabel)
                             if self.ylabel is not None:
                     Reset axes for redraw plots
                     '''
-                    for ax in self.axes+self.pf_axes+self.cb_axes:
+                    for ax in self.axes + self.pf_axes + self.cb_axes:
                         ax.clear()
                         ax.firsttime = True
                         if hasattr(ax, 'cbar') and ax.cbar:
                         figname = os.path.join(
                             self.save,
                             self.save_code,
                             '{}_{}.png'.format(
                                 self.save_code,
                                 self.getDateTime(self.data.max_time).strftime(
                                     '%Y%m%d_%H%M%S'
                     tm = getattr(dataOut, self.attr_time)
-                    if self.data and 'time' in self.xaxis and (tm - self.tmin) >= self.xrange*60*60:
+                    if self.data and 'time' in self.xaxis and (tm - self.tmin) >= self.xrange * 60 * 60:
                         self.save_time = tm
                         self.__plot()
-                        self.tmin += self.xrange*60*60
+                        self.tmin += self.xrange * 60 * 60
                         self.data.setup()
                         self.clear_figures()
                             if self.xmin is None:
                                 self.tmin = tm
                                 self.xmin = dt.hour
-                            minutes = (self.xmin-int(self.xmin)) * 60
+                            minutes = (self.xmin - int(self.xmin)) * 60
                             seconds = (minutes - int(minutes)) * 60
                             self.tmin = (dt.replace(hour=int(self.xmin), minute=int(minutes), second=int(seconds)) -
                                     datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.localtime:
                                 self.tmin += time.timezone
                     if self.throttle == 0:
                         self.__plot()
                     else:
-                        self.__throttle_plot(self.__plot)#, coerce=coerce)
+                        self.__throttle_plot(self.__plot)  # , coerce=coerce)
                 def close(self):

schainpy/model/graphics/jroplot_correlation.py +17 -17

                 def getSubplots(self):
-                    ncol = int(numpy.sqrt(self.nplots)+0.9)
+                    ncol = int(numpy.sqrt(self.nplots) + 0.9)
-                    nrow = int(self.nplots*1./ncol + 0.9)
+                    nrow = int(self.nplots * 1. / ncol + 0.9)
                     return nrow, ncol
                         colspan = 2
                         self.__nsubplots = 2
-                    self.createFigure(id = id,
+                    self.createFigure(id=id,
-                                      wintitle = wintitle,
+                                      wintitle=wintitle,
-                                      widthplot = self.WIDTH + self.WIDTHPROF,
+                                      widthplot=self.WIDTH + self.WIDTHPROF,
-                                      heightplot = self.HEIGHT + self.HEIGHTPROF,
+                                      heightplot=self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                             if counter >= self.nplots:
                                 break
-                            self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
+                            self.addAxes(nrow, ncol * ncolspan, y, x * ncolspan, colspan, 1)
                             if showprofile:
-                                self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
+                                self.addAxes(nrow, ncol * ncolspan, y, x * ncolspan + colspan, 1, 1)
                             counter += 1
                         return None
                     if realtime:
-                        if not(isRealtime(utcdatatime = dataOut.utctime)):
+                        if not(isRealtime(utcdatatime=dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     x = dataOut.getLagTRange(1)
                     y = dataOut.heightList
-                    z = copy.copy(dataOut.data_corr[:,:,0,:])
+                    z = copy.copy(dataOut.data_corr[:, :, 0, :])
                     for i in range(dataOut.data_corr.shape[0]):
-                        z[i,:,:] = z[i,:,:]/factor[i,:]
+                        z[i, :, :] = z[i, :, :] / factor[i, :]
                     zdB = numpy.abs(z)
                     avg = numpy.average(z, axis=1)
             #         avg = numpy.nanmean(z, axis=1)
             #         noise = dataOut.noise/factor
-                    #thisDatetime = dataOut.datatime
+                    # thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Correlation"
                     xlabel = "Lag T (s)"
                     self.setWinTitle(title)
                     for i in range(self.nplots):
-                        str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
+                        str_datetime = '%s %s' % (thisDatetime.strftime("%Y/%m/%d"), thisDatetime.strftime("%H:%M:%S"))
-                        title = "Channel %d and %d: : %s" %(dataOut.pairsList[i][0],dataOut.pairsList[i][1] , str_datetime)
+                        title = "Channel %d and %d: : %s" % (dataOut.pairsList[i][0], dataOut.pairsList[i][1] , str_datetime)
-                        axes = self.axesList[i*self.__nsubplots]
+                        axes = self.axesList[i * self.__nsubplots]
-                        axes.pcolor(x, y, zdB[i,:,:],
+                        axes.pcolor(x, y, zdB[i, :, :],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
-                              thisDatetime=thisDatetime)
  No newline at end of file
+                              thisDatetime=thisDatetime)

schainpy/model/graphics/jroplot_heispectra.py +4 -4

                     data = {}
                     meta = {}
-                    spc = 10*numpy.log10(dataOut.data_spc / dataOut.normFactor)
+                    spc = 10 * numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc_heis'] = spc
                     return data, meta
                     c = 3E8
                     deltaHeight = self.data.yrange[1] - self.data.yrange[0]
-                    x = numpy.arange(-1*len(self.data.yrange)/2., len(self.data.yrange)/2.)*(c/(2*deltaHeight*len(self.data.yrange)*1000))
+                    x = numpy.arange(-1 * len(self.data.yrange) / 2., len(self.data.yrange) / 2.) * (c / (2 * deltaHeight * len(self.data.yrange) * 1000))
                     self.y = self.data[-1]['spc_heis']
                     self.titles = []
                     for n, ax in enumerate(self.axes):
-                        ychannel = self.y[n,:]
+                        ychannel = self.y[n, :]
                         if ax.firsttime:
                             self.xmin = min(x) if self.xmin is None else self.xmin
                             self.xmax = max(x) if self.xmax is None else self.xmax
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc / dataOut.normFactor
-                    spc = 10*numpy.log10(numpy.average(spc, axis=1))
+                    spc = 10 * numpy.log10(numpy.average(spc, axis=1))
                     data['rti_heis'] = spc
                     return data, meta

schainpy/model/graphics/jroplot_parameters.py +17 -17

             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
-                a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
+                a = 0.5 - numpy.cos((lat2 - lat1) * p) / 2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
-                theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
+                theta = numpy.arctan2(numpy.sin((lon2 - lon1) * p) * numpy.cos(lat2 * p), numpy.cos(lat1 * p)
-                                      * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
+                                      * numpy.sin(lat2 * p) - numpy.sin(lat1 * p) * numpy.cos(lat2 * p) * numpy.cos((lon2 - lon1) * p))
-                theta = -theta + numpy.pi/2
+                theta = -theta + numpy.pi / 2
-                return r*numpy.cos(theta), r*numpy.sin(theta)
+                return r * numpy.cos(theta), r * numpy.sin(theta)
             def km2deg(km):
                 Convert distance in km to degrees
                 '''
-                return numpy.rad2deg(km/EARTH_RADIUS)
+                return numpy.rad2deg(km / EARTH_RADIUS)
                 def update(self, dataOut):
                     data = {
-                        'snr': 10*numpy.log10(dataOut.data_snr)
+                        'snr': 10 * numpy.log10(dataOut.data_snr)
                     }
                     return data, {}
                 def update(self, dataOut):
                     data = {
-                        'dop': 10*numpy.log10(dataOut.data_dop)
+                        'dop': 10 * numpy.log10(dataOut.data_dop)
                     }
                     return data, {}
                 def update(self, dataOut):
                     data = {
-                        'pow': 10*numpy.log10(dataOut.data_pow)
+                        'pow': 10 * numpy.log10(dataOut.data_pow)
                     }
                     return data, {}
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
-                            azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
+                            azimuths = -numpy.radians(self.data.yrange) + numpy.pi / 2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
-                            x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
+                            x, y = r * numpy.cos(theta) * numpy.cos(numpy.radians(self.data.meta['elevation'])), r * numpy.sin(
-                                theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
+                                theta) * numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
-                            x, y = r*numpy.cos(theta), r*numpy.sin(theta)
+                            x, y = r * numpy.cos(theta), r * numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
-                            ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
+                            ax.plt = ax.pcolormesh(# r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
-                            ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
+                            ax.plt = ax.pcolormesh(# r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
-                                self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
+                                self.lon + (km2deg(r)) * numpy.cos(60 * numpy.pi / 180),
-                                self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
+                                self.lat + (km2deg(r)) * numpy.sin(60 * numpy.pi / 180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')

schainpy/model/graphics/jroplot_spectra.py +47 -46

                 Plot for Spectra data
                 '''
-                CODE = 'spc'
+                CODE = 'spc_moments'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                     data = {}
                     meta = {}
-                    spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
+                    spc = 10 * numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                    data['noise'] = 10 * numpy.log10(dataOut.getNoise() / dataOut.normFactor)
-                    meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    meta['xrange'] = (dataOut.getFreqRange(1) / 1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'spc_moments':
                         data['moments'] = dataOut.moments
                     data = self.data[-1]
                     z = data['spc']
+                    #self.CODE = 'spc_moments'
                     for n, ax in enumerate(self.axes):
                         noise = data['noise'][n]
+                        print(n,self.CODE)
                         if self.CODE == 'spc_moments':
-                            mean = data['moments'][n, 1]
+                            mean = data['moments'][n,1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                     spc = dataOut.data_spc
                     cspc = dataOut.data_cspc
-                    meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    meta['xrange'] = (dataOut.getFreqRange(1) / 1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     meta['pairs'] = dataOut.pairsList
                     tmp = []
                     for n in range(len(self.data.pairs)):
                         pair = self.data.pairs[n]
-                        coh = cspc[n*2]
+                        coh = cspc[n * 2]
-                        phase = cspc[n*2+1]
+                        phase = cspc[n * 2 + 1]
                         ax = self.axes[2 * n]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.getPower()
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                    data['noise'] = 10 * numpy.log10(dataOut.getNoise() / dataOut.normFactor)
                     return data, meta
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
-                    self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
+                    self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                     data = {}
                     meta = {}
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
+                    data['noise'] = 10 * numpy.log10(dataOut.getNoise() / dataOut.normFactor).reshape(dataOut.nChannels, 1)
                     meta['yrange'] = numpy.array([])
                     return data, meta
                     x = self.data[-1][self.CODE]
-                    if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
+                    if self.xmin is None: self.xmin = numpy.nanmin(x) * 0.9
-                    if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
+                    if self.xmax is None: self.xmax = numpy.nanmax(x) * 1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                     data = {}
                     meta = {}
-                    spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
+                    spc = 10 * numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc'] = spc
-                    meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    meta['xrange'] = (dataOut.getFreqRange(1) / 1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     return data, meta
                     if self.height_index:
                         index = numpy.array(self.height_index)
                     else:
-                        index = numpy.arange(0, len(y), int((len(y))/9))
+                        index = numpy.arange(0, len(y), int((len(y)) / 9))
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                 def __init__(self):
                     Plot.__init__(self)
-                    self.timerange = 24*60*60
+                    self.timerange = 24 * 60 * 60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     colspan = 6
                     self.__nsubplots = 2
-                    self.createFigure(id = id,
+                    self.createFigure(id=id,
-                                      wintitle = wintitle,
+                                      wintitle=wintitle,
-                                      widthplot = self.WIDTH+self.WIDTHPROF,
+                                      widthplot=self.WIDTH + self.WIDTHPROF,
-                                      heightplot = self.HEIGHT+self.HEIGHTPROF,
+                                      heightplot=self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
-                    self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
+                    self.addAxes(nrow, ncol * ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
-                    f = open(filename_phase,'w+')
+                    f = open(filename_phase, 'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
-                    f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
+                    f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n')
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
-                    f=open(filename_phase,'a')
+                    f = open(filename_phase, 'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
-                    f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
+                    f.write(day + ' ' + month + ' ' + year + '  ' + hour + ' ' + minute + ' ' + second + '   ' + str(data[0]) + '   ' + str(data[1]) + '   ' + str(data[2]) + '   ' + str(data[3]) + '\n')
                     f.close()
                 def plot(self):
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
-                                raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
+                                raise ValueError("Pair %s is not in dataOut.pairsList" % (pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
-                            hmax_index = hmax_list[-1]+1
+                            hmax_index = hmax_list[-1] + 1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
-                    title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = wintitle + " Signal Phase"  # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
-                    #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
+                    # phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
-                        avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
+                        avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
-                        phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
+                        phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real) * 180 / numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         update_figfile = True
-                        #open file beacon phase
+                        # open file beacon phase
-                        path = '%s%03d' %(self.PREFIX, self.id)
+                        path = '%s%03d' % (self.PREFIX, self.id)
-                        beacon_file = os.path.join(path,'%s.txt'%self.name)
+                        beacon_file = os.path.join(path, '%s.txt' % self.name)
-                        self.filename_phase = os.path.join(figpath,beacon_file)
+                        self.filename_phase = os.path.join(figpath, beacon_file)
-                        #self.save_phase(self.filename_phase)
+                        # self.save_phase(self.filename_phase)
-                    #store data beacon phase
+                    # store data beacon phase
-                    #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
+                    # self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
-                    title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
+                    title = "Phase Plot %s" % (thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
-                    legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
+                    legendlabels = ["Pair (%d,%d)" % (pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
-                    if len(self.ydata)==0:
+                    if len(self.ydata) == 0:
-                        self.ydata = phase_beacon.reshape(-1,1)
+                        self.ydata = phase_beacon.reshape(-1, 1)
                     else:
-                        self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
+                        self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1, 1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
-                    return dataOut
  No newline at end of file
+                    return dataOut

schainpy/model/graphics/jroplot_voltage.py +64 -64

                 def plot_iq(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    yreal = y[channelIndexList,:].real
+                    yreal = y[channelIndexList, :].real
-                    yimag = y[channelIndexList,:].imag
+                    yimag = y[channelIndexList, :].imag
-                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity - IQ"
                     self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
                         if ax.firsttime:
                             self.xmin = min(x)
                             self.xmax = max(x)
-                            ax.plt_r = ax.plot(x, yreal[i,:], color='b')[0]
+                            ax.plt_r = ax.plot(x, yreal[i, :], color='b')[0]
-                            ax.plt_i = ax.plot(x, yimag[i,:], color='r')[0]
+                            ax.plt_i = ax.plot(x, yimag[i, :], color='r')[0]
                         else:
-                            ax.plt_r.set_data(x, yreal[i,:])
+                            ax.plt_r.set_data(x, yreal[i, :])
-                            ax.plt_i.set_data(x, yimag[i,:])
+                            ax.plt_i.set_data(x, yimag[i, :])
                 def plot_power(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
+                    y = y[channelIndexList, :] * numpy.conjugate(y[channelIndexList, :])
                     yreal = y.real
-                    yreal = 10*numpy.log10(yreal)
+                    yreal = 10 * numpy.log10(yreal)
                     self.y = yreal
-                    title = wintitle + " Power: %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = wintitle + " Power: %s" % (thisDatetime.strftime("%d-%b-%Y"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity [dB]"
                     self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        ychannel = yreal[i,:]
+                        ychannel = yreal[i, :]
                         if ax.firsttime:
                             self.xmin = min(x)
                 def plot_weatherpower(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    y      = y[channelIndexList,:]
+                    y = y[channelIndexList, :]
-                    yreal  = y.real
+                    yreal = y.real
-                    yreal  = 10*numpy.log10(yreal)
+                    yreal = 10 * numpy.log10(yreal)
                     self.y = yreal
-                    title  = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity"
-                    self.xmin   = min(x)
+                    self.xmin = min(x)
-                    self.xmax   = max(x)
+                    self.xmax = max(x)
-                    self.titles[0] =title
+                    self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title    = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        ychannel = yreal[i,:]
+                        ychannel = yreal[i, :]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(x, ychannel)[0]
                         else:
-                            #pass
+                            # pass
                             ax.plt_r.set_data(x, ychannel)
                 def plot_weathervelocity(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    x = x[channelIndexList,:]
+                    x = x[channelIndexList, :]
-                    yreal  = y
+                    yreal = y
                     self.y = yreal
-                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     self.xlabel = "Velocity (m/s)"
                     self.ylabel = "Range (Km)"
-                    self.xmin   = numpy.min(x)
+                    self.xmin = numpy.min(x)
-                    self.xmax   = numpy.max(x)
+                    self.xmax = numpy.max(x)
-                    self.titles[0] =title
+                    self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title    = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        xchannel    = x[i,:]
+                        xchannel = x[i, :]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(xchannel, yreal)[0]
                         else:
-                            #pass
+                            # pass
                             ax.plt_r.set_data(xchannel, yreal)
                 def plot_weatherspecwidth(self, x, y, channelIndexList, thisDatetime, wintitle):
-                    x = x[channelIndexList,:]
+                    x = x[channelIndexList, :]
-                    yreal  = y
+                    yreal = y
                     self.y = yreal
-                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    title = wintitle + " Scope: %s" % (thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     self.xlabel = "width "
                     self.ylabel = "Range (Km)"
-                    self.xmin   = numpy.min(x)
+                    self.xmin = numpy.min(x)
-                    self.xmax   = numpy.max(x)
+                    self.xmax = numpy.max(x)
-                    self.titles[0] =title
+                    self.titles[0] = title
-                    for i,ax in enumerate(self.axes):
+                    for i, ax in enumerate(self.axes):
-                        title    = "Channel %d" %(i)
+                        title = "Channel %d" % (i)
-                        xchannel    = x[i,:]
+                        xchannel = x[i, :]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(xchannel, yreal)[0]
                         else:
-                            #pass
+                            # pass
                             ax.plt_r.set_data(xchannel, yreal)
                 def plot(self):
                         for i in range(self.data.nProfiles):
-                            wintitle1 = " [Profile = %d] " %i
+                            wintitle1 = " [Profile = %d] " % i
-                            if self.CODE =="scope":
+                            if self.CODE == "scope":
                                 if self.type == "power":
                                     self.plot_power(self.data.yrange,
-                                                    scope[:,i,:],
+                                                    scope[:, i, :],
                                                     channels,
                                                     thisDatetime,
                                                     wintitle1
                                 if self.type == "iq":
                                     self.plot_iq(self.data.yrange,
-                                                 scope[:,i,:],
+                                                 scope[:, i, :],
                                                  channels,
                                                  thisDatetime,
                                                  wintitle1
                                                 )
-                            if self.CODE=="pp_power":
+                            if self.CODE == "pp_power":
                                 self.plot_weatherpower(self.data.yrange,
-                                           scope[:,i,:],
+                                           scope[:, i, :],
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
-                            if self.CODE=="pp_signal":
+                            if self.CODE == "pp_signal":
                                 self.plot_weatherpower(self.data.yrange,
-                                           scope[:,i,:],
+                                           scope[:, i, :],
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
-                            if self.CODE=="pp_velocity":
+                            if self.CODE == "pp_velocity":
-                                self.plot_weathervelocity(scope[:,i,:],
+                                self.plot_weathervelocity(scope[:, i, :],
                                            self.data.yrange,
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
-                            if self.CODE=="pp_spcwidth":
+                            if self.CODE == "pp_spcwidth":
-                                self.plot_weatherspecwidth(scope[:,i,:],
+                                self.plot_weatherspecwidth(scope[:, i, :],
                                            self.data.yrange,
                                            channels,
                                            thisDatetime,
                                            wintitle
                                            )
                     else:
-                        wintitle = " [Profile = %d] " %self.data.profileIndex
+                        wintitle = " [Profile = %d] " % self.data.profileIndex
-                        if self.CODE== "scope":
+                        if self.CODE == "scope":
                             if self.type == "power":
                                  self.plot_power(self.data.yrange,
                                             scope,
                                             thisDatetime,
                                             wintitle
                                             )
-                        if self.CODE=="pp_power":
+                        if self.CODE == "pp_power":
                             self.plot_weatherpower(self.data.yrange,
                                                 scope,
                                                 channels,
                                                 thisDatetime,
                                                 wintitle
                                                    )
-                        if self.CODE=="pp_signal":
+                        if self.CODE == "pp_signal":
                             self.plot_weatherpower(self.data.yrange,
                                                 scope,
                                                 channels,
                                                 thisDatetime,
                                                 wintitle
                                                    )
-                        if self.CODE=="pp_velocity":
+                        if self.CODE == "pp_velocity":
                             self.plot_weathervelocity(scope,
                                                    self.data.yrange,
                                                    channels,
                                                    thisDatetime,
                                                    wintitle
                                                    )
-                        if self.CODE=="pp_specwidth":
+                        if self.CODE == "pp_specwidth":
                             self.plot_weatherspecwidth(scope,
                                                    self.data.yrange,
                                                    channels,

schainpy/model/graphics/plotting_codes.py +12 -12

             '''
             @author: roj-idl71
             '''
-            #USED IN jroplot_spectra.py
+            # USED IN jroplot_spectra.py
-            RTI_CODE = 0            #Range time intensity (RTI).
+            RTI_CODE = 0  # Range time intensity (RTI).
-            SPEC_CODE = 1           #Spectra (and Cross-spectra) information.
+            SPEC_CODE = 1  # Spectra (and Cross-spectra) information.
-            CROSS_CODE = 2          #Cross-Correlation information.
+            CROSS_CODE = 2  # Cross-Correlation information.
-            COH_CODE = 3            #Coherence map.
+            COH_CODE = 3  # Coherence map.
-            BASE_CODE = 4           #Base lines graphic.
+            BASE_CODE = 4  # Base lines graphic.
-            ROW_CODE = 5            #Row Spectra.
+            ROW_CODE = 5  # Row Spectra.
-            TOTAL_CODE = 6          #Total Power.
+            TOTAL_CODE = 6  # Total Power.
-            DRIFT_CODE = 7          #Drifts graphics.
+            DRIFT_CODE = 7  # Drifts graphics.
-            HEIGHT_CODE = 8         #Height profile.
+            HEIGHT_CODE = 8  # Height profile.
-            PHASE_CODE = 9          #Signal Phase.
+            PHASE_CODE = 9  # Signal Phase.
             POWER_CODE = 16
             NOISE_CODE = 17
             BEACON_CODE = 18
-            #USED IN jroplot_parameters.py
+            # USED IN jroplot_parameters.py
             WIND_CODE = 22
             MSKYMAP_CODE = 23
             MPHASE_CODE = 24

schainpy/model/io/MIRAtest.py +42 -42

                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
-            #from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
+            # from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
-            #from schainpy.model.io.jroIO_bltr import BLTRReader
+            # from schainpy.model.io.jroIO_bltr import BLTRReader
             from numpy import imag, shape, NaN
             SRVI_STRUCTURE = numpy.dtype([
                                         ('frame_cnt', '<u4'),
-                                        ('time_t', '<u4'),   #
+                                        ('time_t', '<u4'),  #
-                                        ('tpow', '<f4'),     #
+                                        ('tpow', '<f4'),  #
-                                        ('npw1', '<f4'),     #
+                                        ('npw1', '<f4'),  #
-                                        ('npw2', '<f4'),     #
+                                        ('npw2', '<f4'),  #
-                                        ('cpw1', '<f4'),     #
+                                        ('cpw1', '<f4'),  #
-                                        ('pcw2', '<f4'),     #
+                                        ('pcw2', '<f4'),  #
-                                        ('ps_err', '<u4'),   #
+                                        ('ps_err', '<u4'),  #
-                                        ('te_err', '<u4'),   #
+                                        ('te_err', '<u4'),  #
-                                        ('rc_err', '<u4'),   #
+                                        ('rc_err', '<u4'),  #
-                                        ('grs1', '<u4'),     #
+                                        ('grs1', '<u4'),  #
-                                        ('grs2', '<u4'),     #
+                                        ('grs2', '<u4'),  #
-                                        ('azipos', '<f4'),     #
+                                        ('azipos', '<f4'),  #
-                                        ('azivel', '<f4'),     #
+                                        ('azivel', '<f4'),  #
-                                        ('elvpos', '<f4'),     #
+                                        ('elvpos', '<f4'),  #
-                                        ('elvvel', '<f4'),     #
+                                        ('elvvel', '<f4'),  #
                                         ('northAngle', '<f4'),
-                                        ('microsec', '<u4'),   #
+                                        ('microsec', '<u4'),  #
                                         ('azisetvel', '<f4'),  #
                                         ('elvsetpos', '<f4'),  #
-                                        ('RadarConst', '<f4'), ])   #
+                                        ('RadarConst', '<f4'), ])  #
             JUMP_STRUCTURE = numpy.dtype([
                                         ('jump', '<u140'),
             # RecCounter=0
             # Off2StartNxtRec=811248
             # print 'OffsetStartHeader ',self.OffsetStartHeader,'RecCounter ', self.RecCounter, 'Off2StartNxtRec ' , self.Off2StartNxtRec
-            #OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
+            # OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
-            #startFp.seek(OffRHeader, os.SEEK_SET)
+            # startFp.seek(OffRHeader, os.SEEK_SET)
             print('debe ser 48, RecCounter*811248', self.OffsetStartHeader, self.RecCounter, self.Off2StartNxtRec)
             print('Posicion del bloque:        ', OffRHeader)
             header = numpy.fromfile(startFp, SRVI_STRUCTURE, 1)
             self.frame_cnt = header['frame_cnt'][0]
-            self.time_t = header['frame_cnt'][0]   #
+            self.time_t = header['frame_cnt'][0]  #
-            self.tpow = header['frame_cnt'][0]     #
+            self.tpow = header['frame_cnt'][0]  #
-            self.npw1 = header['frame_cnt'][0]     #
+            self.npw1 = header['frame_cnt'][0]  #
-            self.npw2 = header['frame_cnt'][0]     #
+            self.npw2 = header['frame_cnt'][0]  #
-            self.cpw1 = header['frame_cnt'][0]     #
+            self.cpw1 = header['frame_cnt'][0]  #
-            self.pcw2 = header['frame_cnt'][0]     #
+            self.pcw2 = header['frame_cnt'][0]  #
-            self.ps_err = header['frame_cnt'][0]    #
+            self.ps_err = header['frame_cnt'][0]  #
-            self.te_err = header['frame_cnt'][0]    #
+            self.te_err = header['frame_cnt'][0]  #
-            self.rc_err = header['frame_cnt'][0]    #
+            self.rc_err = header['frame_cnt'][0]  #
-            self.grs1 = header['frame_cnt'][0]      #
+            self.grs1 = header['frame_cnt'][0]  #
-            self.grs2 = header['frame_cnt'][0]      #
+            self.grs2 = header['frame_cnt'][0]  #
-            self.azipos = header['frame_cnt'][0]     #
+            self.azipos = header['frame_cnt'][0]  #
-            self.azivel = header['frame_cnt'][0]     #
+            self.azivel = header['frame_cnt'][0]  #
-            self.elvpos = header['frame_cnt'][0]     #
+            self.elvpos = header['frame_cnt'][0]  #
-            self.elvvel = header['frame_cnt'][0]     #
+            self.elvvel = header['frame_cnt'][0]  #
-            self.northAngle = header['frame_cnt'][0]    #
+            self.northAngle = header['frame_cnt'][0]  #
-            self.microsec = header['frame_cnt'][0]      #
+            self.microsec = header['frame_cnt'][0]  #
-            self.azisetvel = header['frame_cnt'][0]     #
+            self.azisetvel = header['frame_cnt'][0]  #
-            self.elvsetpos = header['frame_cnt'][0]     #
+            self.elvsetpos = header['frame_cnt'][0]  #
-            self.RadarConst = header['frame_cnt'][0]    #
+            self.RadarConst = header['frame_cnt'][0]  #
             self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
             print('==============================================')
-            print('==============================================')
  No newline at end of file
+            print('==============================================')

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

             from .julIO_param import *
             from .pxIO_param import *
-            from .jroIO_simulator import *
  No newline at end of file
+            from .jroIO_simulator import *

schainpy/model/io/bltrIO_param.py +6 -6

                     self.isConfig = False
                     self.filename = None
                     self.status_value = 0
-                    self.datatime = datetime.datetime(1900,1,1)
+                    self.datatime = datetime.datetime(1900, 1, 1)
                     self.filefmt = "*********%Y%m%d******"
                 def setup(self, **kwargs):
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         self.readFirstHeader()
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                     self.rx_gains = self.header_rec['rx_gains']
                     self.time = self.header_rec['time'][0]
                     dt = datetime.datetime.utcfromtimestamp(self.time)
-                    if dt.date()>self.datatime.date():
+                    if dt.date() > self.datatime.date():
                         self.flagDiscontinuousBlock = 1
                     self.datatime = dt
                     self.getData()
-                    return
  No newline at end of file
+                    return

schainpy/model/io/bltrIO_spectra.py +15 -15

                     self.Off2StartData = int(header['Off2StartData'][0])
                     self.nUtime = header['nUtime'][0]
                     self.nMilisec = header['nMilisec'][0]
-                    self.ExpTagName = '' # str(header['ExpTagName'][0])
+                    self.ExpTagName = ''  # str(header['ExpTagName'][0])
-                    self.ExpComment = '' # str(header['ExpComment'][0])
+                    self.ExpComment = ''  # str(header['ExpComment'][0])
                     self.SiteLatDegrees = header['SiteLatDegrees'][0]
                     self.SiteLongDegrees = header['SiteLongDegrees'][0]
                     self.RTCgpsStatus = header['RTCgpsStatus'][0]
                     self.getData()
                 def setup(self,
                           path=None,
                           startDate=None,
                           endDate=None,
                             return
                     if self.mode == 1:
-                        self.rheader.read(self.BlockCounter+1)
+                        self.rheader.read(self.BlockCounter + 1)
                     elif self.mode == 0:
                         self.rheader.read(self.BlockCounter)
                     self.dataOut.nRdPairs = self.nRdPairs
                     self.dataOut.heightList = (self.rheader.StartRangeSamp + numpy.arange(self.nHeights) * self.rheader.SampResolution) / 1000.
                     self.dataOut.channelList = range(self.nChannels)
-                    self.dataOut.nProfiles=self.rheader.nProfiles
+                    self.dataOut.nProfiles = self.rheader.nProfiles
-                    self.dataOut.nIncohInt=self.rheader.nIncohInt
+                    self.dataOut.nIncohInt = self.rheader.nIncohInt
-                    self.dataOut.nCohInt=self.rheader.nCohInt
+                    self.dataOut.nCohInt = self.rheader.nCohInt
-                    self.dataOut.ippSeconds= 1/float(self.rheader.PRFhz)
+                    self.dataOut.ippSeconds = 1 / float(self.rheader.PRFhz)
-                    self.dataOut.PRF=self.rheader.PRFhz
+                    self.dataOut.PRF = self.rheader.PRFhz
-                    self.dataOut.nFFTPoints=self.rheader.nProfiles
+                    self.dataOut.nFFTPoints = self.rheader.nProfiles
-                    self.dataOut.utctime = self.rheader.nUtime + self.rheader.nMilisec/1000.
+                    self.dataOut.utctime = self.rheader.nUtime + self.rheader.nMilisec / 1000.
                     self.dataOut.timeZone = 0
                     self.dataOut.useLocalTime = False
                     self.dataOut.nmodes = 2
                         self.Off2StartNxtRec + self.Off2StartData
                     self.fp.seek(OffDATA, os.SEEK_SET)
-                    self.data_fft = numpy.fromfile(self.fp, [('complex','<c8')], self.nProfiles*self.nChannels*self.nHeights )
+                    self.data_fft = numpy.fromfile(self.fp, [('complex', '<c8')], self.nProfiles * self.nChannels * self.nHeights)
                     self.data_fft = self.data_fft.astype(numpy.dtype('complex'))
-                    self.data_block = numpy.reshape(self.data_fft,(self.nHeights, self.nChannels, self.nProfiles))
+                    self.data_block = numpy.reshape(self.data_fft, (self.nHeights, self.nChannels, self.nProfiles))
-                    self.data_block = numpy.transpose(self.data_block, (1,2,0))
+                    self.data_block = numpy.transpose(self.data_block, (1, 2, 0))
                     copy = self.data_block.copy()
                     spc = copy * numpy.conjugate(copy)
                     self.data_spc = numpy.absolute(spc)  # valor absoluto o magnitud
                     self.BlockCounter += 2
                     self.dataOut.data_spc = self.data_spc
-                    self.dataOut.data_cspc =self.data_cspc
+                    self.dataOut.data_cspc = self.data_cspc

schainpy/model/io/jroIO_amisr.py +117 -117

             class RadacHeader():
                 def __init__(self, fp):
                     header = 'Raw11/Data/RadacHeader'
-                    self.beamCodeByPulse = fp.get(header+'/BeamCode')
+                    self.beamCodeByPulse = fp.get(header + '/BeamCode')
                     self.beamCode = fp.get('Raw11/Data/Beamcodes')
-                    self.code = fp.get(header+'/Code')
+                    self.code = fp.get(header + '/Code')
-                    self.frameCount = fp.get(header+'/FrameCount')
+                    self.frameCount = fp.get(header + '/FrameCount')
-                    self.modeGroup = fp.get(header+'/ModeGroup')
+                    self.modeGroup = fp.get(header + '/ModeGroup')
-                    self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
+                    self.nsamplesPulse = fp.get(header + '/NSamplesPulse')
-                    self.pulseCount = fp.get(header+'/PulseCount')
+                    self.pulseCount = fp.get(header + '/PulseCount')
-                    self.radacTime = fp.get(header+'/RadacTime')
+                    self.radacTime = fp.get(header + '/RadacTime')
-                    self.timeCount = fp.get(header+'/TimeCount')
+                    self.timeCount = fp.get(header + '/TimeCount')
-                    self.timeStatus = fp.get(header+'/TimeStatus')
+                    self.timeStatus = fp.get(header + '/TimeStatus')
-                    self.nrecords = self.pulseCount.shape[0] #nblocks
+                    self.nrecords = self.pulseCount.shape[0]  # nblocks
-                    self.npulses = self.pulseCount.shape[1] #nprofile
+                    self.npulses = self.pulseCount.shape[1]  # nprofile
-                    self.nsamples = self.nsamplesPulse[0,0] #ngates
+                    self.nsamples = self.nsamplesPulse[0, 0]  # ngates
                     self.nbeams = self.beamCode.shape[1]
                 def getIndexRangeToPulse(self, idrecord=0):
-                    #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
+                    # indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
-                    #startPulseCountId = indexToZero[0][0]
+                    # startPulseCountId = indexToZero[0][0]
-                    #endPulseCountId = startPulseCountId - 1
+                    # endPulseCountId = startPulseCountId - 1
-                    #range1 = numpy.arange(startPulseCountId,self.npulses,1)
+                    # range1 = numpy.arange(startPulseCountId,self.npulses,1)
-                    #range2 = numpy.arange(0,startPulseCountId,1)
+                    # range2 = numpy.arange(0,startPulseCountId,1)
-                    #return range1, range2
+                    # return range1, range2
                     zero = 0
-                    npulse = max(self.pulseCount[0,:]+1)-1
+                    npulse = max(self.pulseCount[0, :] + 1) - 1
-                    looking_index = numpy.where(self.pulseCount.value[idrecord,:]==npulse)[0]
+                    looking_index = numpy.where(self.pulseCount.value[idrecord, :] == npulse)[0]
                     getLastIndex = looking_index[-1]
-                    index_data = numpy.arange(0,getLastIndex+1,1)
+                    index_data = numpy.arange(0, getLastIndex + 1, 1)
-                    index_buffer = numpy.arange(getLastIndex+1,self.npulses,1)
+                    index_buffer = numpy.arange(getLastIndex + 1, self.npulses, 1)
                     return index_data, index_buffer
             class AMISRReader(ProcessingUnit):
                     self.index_amisr_buffer = None
                     self.beamCodeByFrame = None
                     self.radacTimeByFrame = None
-                    #atributos originales tal y como esta en el archivo de datos
+                    # atributos originales tal y como esta en el archivo de datos
                     self.beamCodesFromFile = None
                     self.radacTimeFromFile = None
                     self.rangeFromFile = None
                     self.beamCodeDict = {}
                     self.beamRangeDict = {}
-                    #experiment cgf file
+                    # experiment cgf file
                     self.npulsesint_fromfile = None
                     self.recordsperfile_fromfile = None
                     self.nbeamcodes_fromfile = None
                     return dataObj
-                def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
+                def __setParameters(self, path='', startDate='', endDate='', startTime='', endTime='', walk=''):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                         self.status = 1
                     else:
                         self.status = 0
-                        print('Path:%s does not exists'%self.path)
+                        print('Path:%s does not exists' % self.path)
                     return
                         year = int(amisr_dirname_format[0:4])
                         month = int(amisr_dirname_format[4:6])
                         dom = int(amisr_dirname_format[6:8])
-                        thisDate = datetime.date(year,month,dom)
+                        thisDate = datetime.date(year, month, dom)
-                        if (thisDate>=self.startDate and thisDate <= self.endDate):
+                        if (thisDate >= self.startDate and thisDate <= self.endDate):
                             return amisr_dirname_format
                     except:
                         return None
-                def __findDataForDates(self,online=False):
+                def __findDataForDates(self, online=False):
                         return None
                     pat = '\d+.\d+'
-                    dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
+                    dirnameList = [re.search(pat, x) for x in os.listdir(self.path)]
-                    dirnameList = [x for x in dirnameList if x!=None]
+                    dirnameList = [x for x in dirnameList if x != None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = [x for x in dirnameList if x!=None]
+                        dirnameList = [x for x in dirnameList if x != None]
-                    if len(dirnameList)>0:
+                    if len(dirnameList) > 0:
                         self.status = 1
                         self.dirnameList = dirnameList
                         self.dirnameList.sort()
                         return None
                 def __getTimeFromData(self):
-                    startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
+                    startDateTime_Reader = datetime.datetime.combine(self.startDate, self.startTime)
-                    endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                    endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
-                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
+                    print('Filtering Files from %s to %s' % (startDateTime_Reader, endDateTime_Reader))
                     print('........................................')
                     filter_filenameList = []
                     self.filenameList.sort()
-                    for i in range(len(self.filenameList)-1):
+                    for i in range(len(self.filenameList) - 1):
                         filename = self.filenameList[i]
-                        fp = h5py.File(filename,'r')
+                        fp = h5py.File(filename, 'r')
                         time_str = fp.get('Time/RadacTimeString')
                         startDateTimeStr_File = time_str[0][0].split('.')[0]
                         junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        startDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         endDateTimeStr_File = time_str[-1][-1].split('.')[0]
                         junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        endDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         fp.close()
                         if self.timezone == 'lt':
-                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
+                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes=300)
-                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
+                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes=300)
-                        if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
+                        if (endDateTime_File >= startDateTime_Reader and endDateTime_File < endDateTime_Reader):
-                            #self.filenameList.remove(filename)
+                            # self.filenameList.remove(filename)
                             filter_filenameList.append(filename)
                     filter_filenameList.sort()
                     return 1
                 def __filterByGlob1(self, dirName):
-                    filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
+                    filter_files = glob.glob1(dirName, '*.*%s' % self.extension_file)
                     filterDict = {}
                     filterDict.setdefault(dirName)
                     filterDict[dirName] = filter_files
                 def __selectDataForTimes(self, online=False):
-                    #aun no esta implementado el filtro for tiempo
+                    # aun no esta implementado el filtro for tiempo
                     if not(self.status):
                         return None
-                    dirList = [os.path.join(self.path,x) for x in self.dirnameList]
+                    dirList = [os.path.join(self.path, x) for x in self.dirnameList]
                     fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
                     self.__getFilenameList(fileListInKeys, dirList)
                     if not(online):
-                        #filtro por tiempo
+                        # filtro por tiempo
                         if not(self.all):
                             self.__getTimeFromData()
-                        if len(self.filenameList)>0:
+                        if len(self.filenameList) > 0:
                             self.status = 1
                             self.filenameList.sort()
                         else:
                             return None
                     else:
-                        #get the last file - 1
+                        # get the last file - 1
                         self.filenameList = [self.filenameList[-2]]
                     new_dirnameList = []
                                         path,
                                         startDate,
                                         endDate,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print("%s" %(self.filenameList[i]))
+                        print("%s" % (self.filenameList[i]))
                     return
                         filename = self.filenameList[idFile]
-                        amisrFilePointer = h5py.File(filename,'r')
+                        amisrFilePointer = h5py.File(filename, 'r')
                         break
                     self.amisrFilePointer = amisrFilePointer
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         while self.__filename_online == filename:
-                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
+                            print('waiting %d seconds to get a new file...' % (self.__waitForNewFile))
                             sleep(self.__waitForNewFile)
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
                     self.__filename_online = filename
-                    self.amisrFilePointer = h5py.File(filename,'r')
+                    self.amisrFilePointer = h5py.File(filename, 'r')
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __readHeader(self):
                     self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
-                    #update values from experiment cfg file
+                    # update values from experiment cfg file
                     if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
                         self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
                     self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
                     self.radacHeaderObj.npulses = self.npulsesint_fromfile
                     self.radacHeaderObj.nsamples = self.ngates_fromfile
-                    #looking index list for data
+                    # looking index list for data
-                    start_index = self.radacHeaderObj.pulseCount[0,:][0]
+                    start_index = self.radacHeaderObj.pulseCount[0, :][0]
                     end_index = self.radacHeaderObj.npulses
                     range4data = list(range(start_index, end_index))
                     self.index4_schain_datablock = numpy.array(range4data)
                     buffer_start_index = 0
-                    buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0]
+                    buffer_end_index = self.radacHeaderObj.pulseCount[0, :][0]
                     range4buffer = list(range(buffer_start_index, buffer_end_index))
                     self.index4_buffer = numpy.array(range4buffer)
                     self.linear_pulseCount = numpy.array(range4data + range4buffer)
-                    self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1)
+                    self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0, :] + 1)
-                    #get tuning frequency
+                    # get tuning frequency
-                    frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
+                    frequency_h5file_dataset = self.amisrFilePointer.get('Rx' + '/TuningFrequency')
-                    self.frequency_h5file = frequency_h5file_dataset[0,0]
+                    self.frequency_h5file = frequency_h5file_dataset[0, 0]
                     self.flagIsNewFile = 1
                     beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap')
-                    for i in range(len(self.radacHeaderObj.beamCode[0,:])):
+                    for i in range(len(self.radacHeaderObj.beamCode[0, :])):
                         self.beamCodeDict.setdefault(i)
                         self.beamRangeDict.setdefault(i)
-                        beamcodeValue = self.radacHeaderObj.beamCode[0,i]
+                        beamcodeValue = self.radacHeaderObj.beamCode[0, i]
-                        beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0]
+                        beamcodeIndex = numpy.where(beamCodeMap[:, 0] == beamcodeValue)[0][0]
                         x = beamCodeMap[beamcodeIndex][1]
                         y = beamCodeMap[beamcodeIndex][2]
                         z = beamCodeMap[beamcodeIndex][3]
                         self.beamCodeDict[i] = [beamcodeValue, x, y, z]
-                    just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
+                    just4record0 = self.radacHeaderObj.beamCodeByPulse[0, :]
                     for i in range(len(list(self.beamCodeDict.values()))):
-                        xx = numpy.where(just4record0==list(self.beamCodeDict.values())[i][0])
+                        xx = numpy.where(just4record0 == list(self.beamCodeDict.values())[i][0])
                         indexPulseByBeam = self.linear_pulseCount[xx[0]]
                         self.beamRangeDict[i] = indexPulseByBeam
                     experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
-                    expFinder = glob.glob1(experimentCfgPath,'*.exp')
+                    expFinder = glob.glob1(experimentCfgPath, '*.exp')
-                    if len(expFinder)== 0:
+                    if len(expFinder) == 0:
                         self.status = 0
                         return None
-                    experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
+                    experimentFilename = os.path.join(experimentCfgPath, expFinder[0])
                     f = open(experimentFilename)
                     lines = f.readlines()
                     f.close()
-                    parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
+                    parmsList = ['npulsesint*', 'recordsperfile*', 'nbeamcodes*', 'ngates*']
                     filterList = [fnmatch.filter(lines, x) for x in parmsList]
-                    values = [re.sub(r'\D',"",x[0]) for x in filterList]
+                    values = [re.sub(r'\D', "", x[0]) for x in filterList]
                     self.npulsesint_fromfile = int(values[0])
                     self.recordsperfile_fromfile = int(values[1])
                     tufileFinder = fnmatch.filter(lines, 'tufile=*')
                     tufile = tufileFinder[0].split('=')[1].split('\n')[0]
                     tufile = tufile.split('\r')[0]
-                    tufilename = os.path.join(experimentCfgPath,tufile)
+                    tufilename = os.path.join(experimentCfgPath, tufile)
                     f = open(tufilename)
                     lines = f.readlines()
                     f.close()
-                    self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
+                    self.ippSeconds_fromfile = float(lines[1].split()[2]) / 1E6
                     self.status = 1
                         self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
-                def __setNextFile(self,online=False):
+                def __setNextFile(self, online=False):
                     if not(online):
                         newFile = self.__setNextFileOffline()
                     self.readDataBlock()
-                def setup(self,path=None,
+                def setup(self, path=None,
                                 startDate=None,
                                 endDate=None,
-                                startTime=datetime.time(0,0,0),
+                                startTime=datetime.time(0, 0, 0),
-                                endTime=datetime.time(23,59,59),
+                                endTime=datetime.time(23, 59, 59),
                                 walk=True,
                                 timezone='ut',
                                 all=0,
                     self.all = all
                     self.online = online
                     if not(online):
-                        #Busqueda de archivos offline
+                        # Busqueda de archivos offline
                         self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk)
                     else:
                         self.searchFilesOnLine(path, walk)
                     if not(self.filenameList):
-                        print("There is no files into the folder: %s"%(path))
+                        print("There is no files into the folder: %s" % (path))
                         sys.exit(-1)
             #         first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0]
             #         index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0]
-                    self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][0]
+                    self.profileIndex_offset = self.radacHeaderObj.pulseCount[0, :][0]
                     self.profileIndex = self.profileIndex_offset
                 def readRanges(self):
                     dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
-                    self.rangeFromFile = numpy.reshape(dataset.value,(-1))
+                    self.rangeFromFile = numpy.reshape(dataset.value, (-1))
                     return self.rangeFromFile
-                def readRadacTime(self,idrecord, range1, range2):
+                def readRadacTime(self, idrecord, range1, range2):
                     self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
                     radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
-                    #radacTimeByFrame = dataset[idrecord - 1,range1]
+                    # radacTimeByFrame = dataset[idrecord - 1,range1]
-                    #radacTimeByFrame = dataset[idrecord,range2]
+                    # radacTimeByFrame = dataset[idrecord,range2]
                     return radacTimeByFrame
                     beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
                     self.beamCodesFromFile = dataset.value
-                    #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
+                    # beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
-                    #beamcodeByFrame[range2] = dataset[idrecord, range2]
+                    # beamcodeByFrame[range2] = dataset[idrecord, range2]
                     beamcodeByFrame[range1] = dataset[idrecord, range1]
                     beamcodeByFrame[range2] = dataset[idrecord, range2]
                 def __setDataByFrame(self):
-                    ndata = 2 # porque es complejo
+                    ndata = 2  # porque es complejo
                     dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
                     return dataByFrame
                     return dataset
                 def __setDataBlock(self,):
-                    real = self.dataByFrame[:,:,0] #asumo que 0 es real
+                    real = self.dataByFrame[:, :, 0]  # asumo que 0 es real
-                    imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
+                    imag = self.dataByFrame[:, :, 1]  # asumo que 1 es imaginario
-                    datablock = real + imag*1j #armo el complejo
+                    datablock = real + imag * 1j  # armo el complejo
                     return datablock
-                def readSamples_version1(self,idrecord):
+                def readSamples_version1(self, idrecord):
-                    #estas tres primeras lineas solo se deben ejecutar una vez
+                    # estas tres primeras lineas solo se deben ejecutar una vez
                     if self.flagIsNewFile:
-                        #reading dataset
+                        # reading dataset
                         self.dataset = self.__readDataSet()
                         self.flagIsNewFile = 0
                     if idrecord == 0:
-                        self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:]
+                        self.dataByFrame[self.index4_schain_datablock, : , :] = self.dataset[0, self.index_amisr_sample, :, :]
                         self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample]
                         datablock = self.__setDataBlock()
                         if len(self.index_amisr_buffer) > 0:
-                            self.buffer = self.dataset[0, self.index_amisr_buffer,:,:]
+                            self.buffer = self.dataset[0, self.index_amisr_buffer, :, :]
                             self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer]
                         return datablock
                     if len(self.index_amisr_buffer) > 0:
-                        self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy()
+                        self.dataByFrame[self.index4_buffer, :, :] = self.buffer.copy()
                         self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy()
-                    self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:]
+                    self.dataByFrame[self.index4_schain_datablock, :, :] = self.dataset[idrecord, self.index_amisr_sample, :, :]
                     self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample]
                     datablock = self.__setDataBlock()
                     if len(self.index_amisr_buffer) > 0:
                     return datablock
-                def readSamples(self,idrecord):
+                def readSamples(self, idrecord):
                     if self.flagIsNewFile:
                         self.dataByFrame = self.__setDataByFrame()
                         self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
-                        #reading ranges
+                        # reading ranges
                         self.readRanges()
-                        #reading dataset
+                        # reading dataset
                         self.dataset = self.__readDataSet()
                     self.flagIsNewFile = 0
                 def readDataBlock(self):
                     self.datablock = self.readSamples_version1(self.idrecord_count)
-                    #self.datablock = self.readSamples(self.idrecord_count)
+                    # self.datablock = self.readSamples(self.idrecord_count)
-                    #print 'record:', self.idrecord_count
+                    # print 'record:', self.idrecord_count
                     self.idrecord_count += 1
                     self.profileIndex = 0
                     pass
                 def __hasNotDataInBuffer(self):
-                    #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
+                    # self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
                     if self.profileIndex >= self.radacHeaderObj.npulses:
                         return 1
                     return 0
                 def setObjProperties(self):
-                    self.dataOut.heightList = self.rangeFromFile/1000.0 #km
+                    self.dataOut.heightList = self.rangeFromFile / 1000.0  # km
                     self.dataOut.nProfiles = self.radacHeaderObj.npulses
                     self.dataOut.nRecords = self.radacHeaderObj.nrecords
                     self.dataOut.nBeams = self.radacHeaderObj.nbeams
                     self.dataOut.beamRangeDict = self.beamRangeDict
                     if self.timezone == 'lt':
-                        self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
+                        self.dataOut.timeZone = time.timezone / 60.  # get the timezone in minutes
                     else:
-                        self.dataOut.timeZone = 0 #by default time is UTC
+                        self.dataOut.timeZone = 0  # by default time is UTC
                 def getData(self):
                         self.readNextBlock()
-                    if self.datablock is None: # setear esta condicion cuando no hayan datos por leers
+                    if self.datablock is None:  # setear esta condicion cuando no hayan datos por leers
                         self.dataOut.flagNoData = True
                         return 0
-                    self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
+                    self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex, :], (1, -1))
                     self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
                     self.dataOut.profileIndex = self.profileIndex
                         self.setObjProperties()
                         self.isConfig = True
-                    self.getData()
  No newline at end of file
+                    self.getData()

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

                 # If endTime < startTime then endTime belongs to the next day
-                #<<<<<<<<<<<o                            o>>>>>>>>>>>
+                # <<<<<<<<<<<o                            o>>>>>>>>>>>
                 #-----------o----------------------------o-----------
                 #        endTime                    startTime
                 for i in range(fmt.count('%')):
                     x = fmt.index('%')
-                    d = DT_DIRECTIVES[fmt[x:x+2]]
+                    d = DT_DIRECTIVES[fmt[x:x + 2]]
-                    fmt = fmt.replace(fmt[x:x+2], s[x:x+d])
+                    fmt = fmt.replace(fmt[x:x + 2], s[x:x + d])
                 return fmt
             class Reader(object):
                             continue
                     return
                 def find_files(self, folders, ext, filefmt, startDate=None, endDate=None,
                                expLabel='', last=False):
                     for path in folders:
                                 continue
                 def searchFilesOffLine(self, path, startDate, endDate,
                                        expLabel, ext, walk,
                                        filefmt, folderfmt):
                     """Search files in offline mode for the given arguments
                         folders, ext, filefmt, startDate, endDate, expLabel)
                 def searchFilesOnLine(self, path, startDate, endDate,
                                       expLabel, ext, walk,
                                       filefmt, folderfmt):
                     """Search for the last file of the last folder
                     nextFile = True
                     nextDay = False
-                    for nFiles in range(self.nFiles+1):
+                    for nFiles in range(self.nFiles + 1):
                         for nTries in range(self.nTries):
                             fullfilename, filename = self.checkForRealPath(nextFile, nextDay)
                             if fullfilename is not None:
                     try:
                         filename = next(self.filenameList)
-                        self.fileIndex +=1
+                        self.fileIndex += 1
                     except StopIteration:
                         self.flagNoMoreFiles = 1
                         return 0
                         if prefixDir != None:
                             # formo el nombre del directorio xYYYYDDD (x=d o x=D)
                             if foldercounter == 0:
                                 thispath = os.path.join(self.path, "%s%04d%03d" %
                                                         (prefixDir, self.year, self.doy))
                             else:
                                 thispath = os.path.join(self.path, "%s%04d%03d_%02d" % (
                     self.processingHeaderObj.read(self.fp)
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
-                    #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
+                    # self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                         flag = False
                     if not self.online:
                         dt1 = basicHeaderObj.datatime
-                        pos = self.fileSize-processingHeaderObj.blockSize-24
+                        pos = self.fileSize - processingHeaderObj.blockSize - 24
-                        if pos<0:
+                        if pos < 0:
                             flag = False
                             log.error('Invalid size for file: {}'.format(self.filename), self.name)
                         else:
                             for nTries in range(self.nTries):
                                 fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                     self.endDate, self.expLabel, self.ext, self.walk,
                                     self.filefmt, self.folderfmt)
                                 try:
                                 log.warning(
                                     'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                         self.delay, self.path, nTries + 1),
                                     self.name)
                                 time.sleep(self.delay)
                             self.set = int(filename[8:11]) - 1
                         else:
                             log.log("Searching files in {}".format(self.path), self.name)
                             self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                     Operation.__init__(self)
                     self.__printInfo = True
-                def run(self, dataOut, headers = ['systemHeaderObj', 'radarControllerHeaderObj', 'processingHeaderObj']):
+                def run(self, dataOut, headers=['systemHeaderObj', 'radarControllerHeaderObj', 'processingHeaderObj']):
                     if self.__printInfo == False:
                         return

schainpy/model/io/jroIO_digitalRF.py +154 -154

                     ProcessingUnit.__init__(self)
-                    self.dataOut                  = Voltage()
+                    self.dataOut = Voltage()
-                    self.__printInfo              = True
+                    self.__printInfo = True
                     self.__flagDiscontinuousBlock = False
                     self.__bufferIndex = 9999999
-                    self.__codeType    = 0
+                    self.__codeType = 0
-                    self.__ippKm       = None
+                    self.__ippKm = None
-                    self.__nCode       = None
+                    self.__nCode = None
-                    self.__nBaud       = None
+                    self.__nBaud = None
-                    self.__code        = None
+                    self.__code = None
-                    self.dtype         = None
+                    self.dtype = None
-                    self.oldAverage    = None
+                    self.oldAverage = None
-                    self.path          = None
+                    self.path = None
                 def close(self):
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                                                                     nChannels=len(
                                                                         self.__channelList),
                                                                     adcResolution=14)
-                    self.dataOut.type  = "Voltage"
+                    self.dataOut.type = "Voltage"
-                    self.dataOut.data  = None
+                    self.dataOut.data = None
                     self.dataOut.dtype = self.dtype
                     # self.dataOut.nHeights = 0
-                    self.dataOut.nProfiles   = int(nProfiles)
+                    self.dataOut.nProfiles = int(nProfiles)
-                    self.dataOut.heightList  = self.__firstHeigth + \
+                    self.dataOut.heightList = self.__firstHeigth + \
                         numpy.arange(self.__nSamples, dtype=numpy.float) * \
                         self.__deltaHeigth
                     self.dataOut.channelList = list(range(self.__num_subchannels))
-                    self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights
+                    self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
                     # self.dataOut.channelIndexList = None
-                    self.dataOut.flagNoData      = True
+                    self.dataOut.flagNoData = True
                     self.dataOut.flagDataAsBlock = False
                     # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
-                    self.dataOut.utctime     = None
+                    self.dataOut.utctime = None
                     # timezone like jroheader, difference in minutes between UTC and localtime
-                    self.dataOut.timeZone    = self.__timezone / 60
+                    self.dataOut.timeZone = self.__timezone / 60
-                    self.dataOut.dstFlag     = 0
+                    self.dataOut.dstFlag = 0
-                    self.dataOut.errorCount  = 0
+                    self.dataOut.errorCount = 0
                     try:
                         self.dataOut.nCohInt = self.fixed_metadata_dict.get(
                         # asumo que la data esta sin flip
                         self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData']
-                        self.dataOut.flagShiftFFT   = self.fixed_metadata_dict['flagShiftFFT']
+                        self.dataOut.flagShiftFFT = self.fixed_metadata_dict['flagShiftFFT']
-                        self.dataOut.useLocalTime   = self.fixed_metadata_dict['useLocalTime']
+                        self.dataOut.useLocalTime = self.fixed_metadata_dict['useLocalTime']
                     except:
                         pass
                     # Time interval between profiles
                     # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
-                    self.dataOut.frequency  = self.__frequency
+                    self.dataOut.frequency = self.__frequency
-                    self.dataOut.realtime   = self.__online
+                    self.dataOut.realtime = self.__online
                 def findDatafiles(self, path, startDate=None, endDate=None):
                     except:
                         digitalReadObj = digital_rf.DigitalRFReader(path)
-                    channelNameList    = digitalReadObj.get_channels()
+                    channelNameList = digitalReadObj.get_channels()
                     if not channelNameList:
                         return []
-                    metadata_dict      = digitalReadObj.get_rf_file_metadata(channelNameList[0])
+                    metadata_dict = digitalReadObj.get_rf_file_metadata(channelNameList[0])
-                    sample_rate        = metadata_dict['sample_rate'][0]
+                    sample_rate = metadata_dict['sample_rate'][0]
                     this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
                     try:
-                        timezone       = this_metadata_file['timezone'].value
+                        timezone = this_metadata_file['timezone'].value
                     except:
-                        timezone       = 0
+                        timezone = 0
                     startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(
                         channelNameList[0]) / sample_rate - timezone
-                    startDatetime      = datetime.datetime.utcfromtimestamp(startUTCSecond)
+                    startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
-                    endDatatime        = datetime.datetime.utcfromtimestamp(endUTCSecond)
+                    endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
                     if not startDate:
-                        startDate      = startDatetime.date()
+                        startDate = startDatetime.date()
                     if not endDate:
-                        endDate        = endDatatime.date()
+                        endDate = endDatatime.date()
-                    dateList           = []
+                    dateList = []
-                    thisDatetime       = startDatetime
+                    thisDatetime = startDatetime
                     while(thisDatetime <= endDatatime):
-                        thisDate        = thisDatetime.date()
+                        thisDate = thisDatetime.date()
-                        if thisDate     < startDate:
+                        if thisDate < startDate:
                             continue
-                        if thisDate     > endDate:
+                        if thisDate > endDate:
                             break
                         dateList.append(thisDate)
                         online
                         delay
                     '''
-                    self.path           = path
+                    self.path = path
-                    self.nCohInt        = nCohInt
+                    self.nCohInt = nCohInt
                     self.flagDecodeData = flagDecodeData
-                    self.i              = 0
+                    self.i = 0
                     if not os.path.isdir(path):
                         raise ValueError("[Reading] Directory %s does not exist" % path)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(path)
-                    channelNameList         = self.digitalReadObj.get_channels()
+                    channelNameList = self.digitalReadObj.get_channels()
                     if not channelNameList:
                         raise ValueError("[Reading] Directory %s does not have any files" % path)
                     ##########  Reading metadata ######################
-                    top_properties           = self.digitalReadObj.get_properties(
+                    top_properties = self.digitalReadObj.get_properties(
                         channelNameList[channelList[0]])
-                    self.__num_subchannels   = top_properties['num_subchannels']
+                    self.__num_subchannels = top_properties['num_subchannels']
-                    self.__sample_rate       = 1.0 * \
+                    self.__sample_rate = 1.0 * \
                         top_properties['sample_rate_numerator'] / \
                         top_properties['sample_rate_denominator']
                     # self.__samples_per_file = top_properties['samples_per_file'][0]
-                    self.__deltaHeigth       = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
+                    self.__deltaHeigth = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
-                    this_metadata_file       = self.digitalReadObj.get_digital_metadata(
+                    this_metadata_file = self.digitalReadObj.get_digital_metadata(
                         channelNameList[channelList[0]])
-                    metadata_bounds          = this_metadata_file.get_bounds()
+                    metadata_bounds = this_metadata_file.get_bounds()
                     self.fixed_metadata_dict = this_metadata_file.read(
                         metadata_bounds[0])[metadata_bounds[0]]  # GET FIRST HEADER
                     try:
-                        self.__processingHeader      = self.fixed_metadata_dict['processingHeader']
+                        self.__processingHeader = self.fixed_metadata_dict['processingHeader']
                         self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
-                        self.__systemHeader          = self.fixed_metadata_dict['systemHeader']
+                        self.__systemHeader = self.fixed_metadata_dict['systemHeader']
-                        self.dtype                   = pickle.loads(self.fixed_metadata_dict['dtype'])
+                        self.dtype = pickle.loads(self.fixed_metadata_dict['dtype'])
                     except:
                         pass
                     self.__firstHeigth = 0
                     try:
-                        codeType       = self.__radarControllerHeader['codeType']
+                        codeType = self.__radarControllerHeader['codeType']
                     except:
-                        codeType       = 0
+                        codeType = 0
                     try:
                         if codeType:
                             nCode = self.__radarControllerHeader['nCode']
                             nBaud = self.__radarControllerHeader['nBaud']
-                            code  = self.__radarControllerHeader['code']
+                            code = self.__radarControllerHeader['code']
                     except:
                         pass
                         except:
                             ippKm = None
                     ####################################################
-                    self.__ippKm   = ippKm
+                    self.__ippKm = ippKm
                     startUTCSecond = None
-                    endUTCSecond   = None
+                    endUTCSecond = None
                     if startDate:
-                        startDatetime  = datetime.datetime.combine(startDate, startTime)
+                        startDatetime = datetime.datetime.combine(startDate, startTime)
                         startUTCSecond = (
                             startDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     if endDate:
-                        endDatetime   = datetime.datetime.combine(endDate, endTime)
+                        endDatetime = datetime.datetime.combine(endDate, endTime)
-                        endUTCSecond  = (endDatetime - datetime.datetime(1970,
+                        endUTCSecond = (endDatetime - datetime.datetime(1970,
 , 1)).total_seconds() + self.__timezone
                     start_index, end_index = self.digitalReadObj.get_bounds(
                     if not startUTCSecond:
                         startUTCSecond = start_index / self.__sample_rate
-                    if start_index     > startUTCSecond * self.__sample_rate:
+                    if start_index > startUTCSecond * self.__sample_rate:
                         startUTCSecond = start_index / self.__sample_rate
                     if not endUTCSecond:
-                        endUTCSecond   = end_index / self.__sample_rate
+                        endUTCSecond = end_index / self.__sample_rate
-                    if end_index       < endUTCSecond * self.__sample_rate:
+                    if end_index < endUTCSecond * self.__sample_rate:
-                        endUTCSecond   = end_index / self.__sample_rate
+                        endUTCSecond = end_index / self.__sample_rate
                     if not nSamples:
                         if not ippKm:
                             raise ValueError("[Reading] nSamples or ippKm should be defined")
-                        nSamples            = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
+                        nSamples = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
-                    channelBoundList        = []
+                    channelBoundList = []
                     channelNameListFiltered = []
                     for thisIndexChannel in channelList:
-                        thisChannelName        = channelNameList[thisIndexChannel]
+                        thisChannelName = channelNameList[thisIndexChannel]
                         start_index, end_index = self.digitalReadObj.get_bounds(
                             thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.profileIndex = 0
-                    self.i            = 0
+                    self.i = 0
-                    self.__delay      = delay
+                    self.__delay = delay
-                    self.__codeType   = codeType
+                    self.__codeType = codeType
-                    self.__nCode      = nCode
+                    self.__nCode = nCode
-                    self.__nBaud      = nBaud
+                    self.__nBaud = nBaud
-                    self.__code       = code
+                    self.__code = code
-                    self.__datapath         = path
+                    self.__datapath = path
-                    self.__online           = online
+                    self.__online = online
-                    self.__channelList      = channelList
+                    self.__channelList = channelList
-                    self.__channelNameList  = channelNameListFiltered
+                    self.__channelNameList = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
-                    self.__nSamples         = nSamples
+                    self.__nSamples = nSamples
-                    self.__samples_to_read  = int(nSamples)  # FIJO: AHORA 40
+                    self.__samples_to_read = int(nSamples)  # FIJO: AHORA 40
-                    self.__nChannels        = len(self.__channelList)
+                    self.__nChannels = len(self.__channelList)
-                    self.__startUTCSecond   = startUTCSecond
+                    self.__startUTCSecond = startUTCSecond
-                    self.__endUTCSecond     = endUTCSecond
+                    self.__endUTCSecond = endUTCSecond
-                    self.__timeInterval     = 1.0 * self.__samples_to_read / \
+                    self.__timeInterval = 1.0 * self.__samples_to_read / \
                         self.__sample_rate  # Time interval
                     if online:
                     # por que en el otro metodo lo primero q se hace es sumar samplestoread
                     self.__thisUnixSample = int(startUTCSecond * self.__sample_rate) - self.__samples_to_read
-                    self.__data_buffer    = numpy.zeros(
+                    self.__data_buffer = numpy.zeros(
                         (self.__num_subchannels, self.__samples_to_read), dtype=numpy.complex)
                     self.__setFileHeader()
                                                                         datetime.datetime.utcfromtimestamp(
                         endUTCSecond - self.__timezone)
                     ))
-                    self.oldAverage    = None
+                    self.oldAverage = None
-                    self.count         = 0
+                    self.count = 0
                     self.executionTime = 0
                 def __reload(self):
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(self.path)
-                    start_index, end_index  = self.digitalReadObj.get_bounds(
+                    start_index, end_index = self.digitalReadObj.get_bounds(
                         self.__channelNameList[self.__channelList[0]])
-                    if start_index          > self.__startUTCSecond * self.__sample_rate:
+                    if start_index > self.__startUTCSecond * self.__sample_rate:
                         self.__startUTCSecond = 1.0 * start_index / self.__sample_rate
-                    if end_index            > self.__endUTCSecond * self.__sample_rate:
+                    if end_index > self.__endUTCSecond * self.__sample_rate:
                         self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
                         print()
                         print("[Reading] New timerange found [%s, %s] " % (
                     return False
                 def timeit(self, toExecute):
-                    t0                  = time.time()
+                    t0 = time.time()
                     toExecute()
-                    self.executionTime  = time.time() - t0
+                    self.executionTime = time.time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
-                    self.oldAverage     = (self.executionTime + self.count *
+                    self.oldAverage = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
-                    self.count          = self.count + 1.0
+                    self.count = self.count + 1.0
                     return
                 def __readNextBlock(self, seconds=30, volt_scale=1):
                     # Set the next data
                     self.__flagDiscontinuousBlock = False
-                    self.__thisUnixSample        += self.__samples_to_read
+                    self.__thisUnixSample += self.__samples_to_read
                     if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                         print ("[Reading] There are no more data into selected time-range")
                     for thisChannelName in self.__channelNameList:  # TODO VARIOS CHANNELS?
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
-                                t0     = time()
+                                t0 = time()
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
-                                self.executionTime  = time() - t0
+                                self.executionTime = time() - t0
                                 if self.oldAverage is None:
                                     self.oldAverage = self.executionTime
-                                self.oldAverage     = (
+                                self.oldAverage = (
                                     self.executionTime + self.count * self.oldAverage) / (self.count + 1.0)
                                 self.count = self.count + 1.0
                                 break
                             self.__data_buffer[indexSubchannel, :] = result * volt_scale
-                            indexChannel+=1
+                            indexChannel += 1
-                            dataOk       = True
+                            dataOk = True
-                    self.__utctime       = self.__thisUnixSample / self.__sample_rate
+                    self.__utctime = self.__thisUnixSample / self.__sample_rate
                     if not dataOk:
                         return False
                                                                   self.__samples_to_read,
                                                                   self.__timeInterval))
-                    self.__bufferIndex   = 0
+                    self.__bufferIndex = 0
                     return True
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     '''
-                    #print("getdata")
+                    # print("getdata")
                     err_counter = 0
                     self.dataOut.flagNoData = True
                     if self.__isBufferEmpty():
-                        #print("hi")
+                        # print("hi")
                         self.__flagDiscontinuousBlock = False
                         while True:
-                            #print ("q ha pasado")
+                            # print ("q ha pasado")
                             if self.__readNextBlock():
                                 break
                             if self.__thisUnixSample > self.__endUTCSecond * self.__sample_rate:
                             print('[Reading] waiting %d seconds to read a new block' % seconds)
                             time.sleep(seconds)
-                    self.dataOut.data                   = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
+                    self.dataOut.data = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
-                    self.dataOut.utctime                = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
+                    self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
-                    self.dataOut.flagNoData             = False
+                    self.dataOut.flagNoData = False
                     self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
-                    self.dataOut.profileIndex           = self.profileIndex
+                    self.dataOut.profileIndex = self.profileIndex
                     self.__bufferIndex += self.__nSamples
-                    self.profileIndex  += 1
+                    self.profileIndex += 1
                     if self.profileIndex == self.dataOut.nProfiles:
                         self.profileIndex = 0
                     if not self.isConfig:
                         self.setup(**kwargs)
-                    #self.i = self.i+1
+                    # self.i = self.i+1
                     self.getData(seconds=self.__delay)
                     return
                     '''
                     Operation.__init__(self, **kwargs)
                     self.metadata_dict = {}
-                    self.dataOut       = None
+                    self.dataOut = None
-                    self.dtype         = None
+                    self.dtype = None
-                    self.oldAverage    = 0
+                    self.oldAverage = 0
                 def setHeader(self):
-                    self.metadata_dict['frequency']      = self.dataOut.frequency
+                    self.metadata_dict['frequency'] = self.dataOut.frequency
-                    self.metadata_dict['timezone']       = self.dataOut.timeZone
+                    self.metadata_dict['timezone'] = self.dataOut.timeZone
-                    self.metadata_dict['dtype']          = pickle.dumps(self.dataOut.dtype)
+                    self.metadata_dict['dtype'] = pickle.dumps(self.dataOut.dtype)
-                    self.metadata_dict['nProfiles']      = self.dataOut.nProfiles
+                    self.metadata_dict['nProfiles'] = self.dataOut.nProfiles
-                    self.metadata_dict['heightList']     = self.dataOut.heightList
+                    self.metadata_dict['heightList'] = self.dataOut.heightList
-                    self.metadata_dict['channelList']    = self.dataOut.channelList
+                    self.metadata_dict['channelList'] = self.dataOut.channelList
                     self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
                     self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
-                    self.metadata_dict['flagShiftFFT']   = self.dataOut.flagShiftFFT
+                    self.metadata_dict['flagShiftFFT'] = self.dataOut.flagShiftFFT
-                    self.metadata_dict['useLocalTime']   = self.dataOut.useLocalTime
+                    self.metadata_dict['useLocalTime'] = self.dataOut.useLocalTime
-                    self.metadata_dict['nCohInt']        = self.dataOut.nCohInt
+                    self.metadata_dict['nCohInt'] = self.dataOut.nCohInt
-                    self.metadata_dict['type']           = self.dataOut.type
+                    self.metadata_dict['type'] = self.dataOut.type
-                    self.metadata_dict['flagDataAsBlock']= getattr(
+                    self.metadata_dict['flagDataAsBlock'] = getattr(
                         self.dataOut, 'flagDataAsBlock', None)  # chequear
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                         dataOut: Input data will also be outputa data
                     '''
                     self.setHeader()
-                    self.__ippSeconds  = dataOut.ippSeconds
+                    self.__ippSeconds = dataOut.ippSeconds
-                    self.__deltaH      = dataOut.getDeltaH()
+                    self.__deltaH = dataOut.getDeltaH()
                     self.__sample_rate = 1e6 * 0.15 / self.__deltaH
-                    self.__dtype       = dataOut.dtype
+                    self.__dtype = dataOut.dtype
                     if len(dataOut.dtype) == 2:
                         self.__dtype = dataOut.dtype[0]
-                    self.__nSamples  = dataOut.systemHeaderObj.nSamples
+                    self.__nSamples = dataOut.systemHeaderObj.nSamples
                     self.__nProfiles = dataOut.nProfiles
                     if self.dataOut.type != 'Voltage':
                         self.arr_data = numpy.ones((self.__nSamples, len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
-                    file_cadence_millisecs  = 1000
+                    file_cadence_millisecs = 1000
-                    sample_rate_fraction    = Fraction(self.__sample_rate).limit_denominator()
+                    sample_rate_fraction = Fraction(self.__sample_rate).limit_denominator()
-                    sample_rate_numerator   = int(sample_rate_fraction.numerator)
+                    sample_rate_numerator = int(sample_rate_fraction.numerator)
                     sample_rate_denominator = int(sample_rate_fraction.denominator)
-                    start_global_index      = dataOut.utctime * self.__sample_rate
+                    start_global_index = dataOut.utctime * self.__sample_rate
-                    uuid              = 'prueba'
+                    uuid = 'prueba'
                     compression_level = 0
-                    checksum          = False
+                    checksum = False
-                    is_complex        = True
+                    is_complex = True
-                    num_subchannels   = len(dataOut.channelList)
+                    num_subchannels = len(dataOut.channelList)
-                    is_continuous     = True
+                    is_continuous = True
-                    marching_periods  = False
+                    marching_periods = False
                     self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
                                                                       fileCadence, start_global_index,
                                                                       sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                                       is_complex, num_subchannels, is_continuous, marching_periods)
-                    metadata_dir         = os.path.join(path, 'metadata')
+                    metadata_dir = os.path.join(path, 'metadata')
                     os.system('mkdir %s' % (metadata_dir))
                     self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                                     sample_rate_numerator, sample_rate_denominator,
                                                                                     metadataFile)
-                    self.isConfig      = True
+                    self.isConfig = True
                     self.currentSample = 0
-                    self.oldAverage    = 0
+                    self.oldAverage = 0
-                    self.count         = 0
+                    self.count = 0
                     return
                 def writeMetadata(self):
-                    start_idx                                   = self.__sample_rate * self.dataOut.utctime
+                    start_idx = self.__sample_rate * self.dataOut.utctime
-                    self.metadata_dict['processingHeader']      = self.dataOut.processingHeaderObj.getAsDict(
+                    self.metadata_dict['processingHeader'] = self.dataOut.processingHeaderObj.getAsDict(
                     )
                     self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict(
                     )
-                    self.metadata_dict['systemHeader']          = self.dataOut.systemHeaderObj.getAsDict(
+                    self.metadata_dict['systemHeader'] = self.dataOut.systemHeaderObj.getAsDict(
                     )
                     self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
                     return
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
-                    self.executionTime  = time() - t0
+                    self.executionTime = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
-                    self.oldAverage     = (self.executionTime + self.count *
+                    self.oldAverage = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
-                    self.count          = self.count + 1.0
+                    self.count = self.count + 1.0
                     return
                 def writeData(self):
                         raise 'Digital RF cannot be used with this data type'
                         for channel in self.dataOut.channelList:
                             for i in range(self.dataOut.nFFTPoints):
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['i'] = self.dataOut.data[channel][i].imag
                     else:
                         for i in range(self.dataOut.systemHeaderObj.nSamples):
                     self.writeData()
-                    ## self.currentSample += 1
+                    # # self.currentSample += 1
                     # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
                     # self.writeMetadata()
-                    ## if self.currentSample == self.__nProfiles: self.currentSample = 0
+                    # # if self.currentSample == self.__nProfiles: self.currentSample = 0
-                    return dataOut# en la version 2.7 no aparece este return
+                    return dataOut  # en la version 2.7 no aparece este return
                 def close(self):
                     print('[Writing] - Closing files ')

schainpy/model/io/jroIO_heispectra.py +114 -114

             class PyFits(object):
-                name=None
+                name = None
-                format=None
+                format = None
-                array =None
+                array = None
-                data =None
+                data = None
-                thdulist=None
+                thdulist = None
-                prihdr=None
+                prihdr = None
-                hdu=None
+                hdu = None
                 def __init__(self):
                     pass
-                def setColF(self,name,format,array):
+                def setColF(self, name, format, array):
-                    self.name=name
+                    self.name = name
-                    self.format=format
+                    self.format = format
-                    self.array=array
+                    self.array = array
-                    a1=numpy.array([self.array],dtype=numpy.float32)
+                    a1 = numpy.array([self.array], dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #        return self.col2
-                def writeData(self,name,format,data):
+                def writeData(self, name, format, data):
-                    self.name=name
+                    self.name = name
-                    self.format=format
+                    self.format = format
-                    self.data=data
+                    self.data = data
-                    a2=numpy.array([self.data],dtype=numpy.float32)
+                    a2 = numpy.array([self.data], dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
-                def cFImage(self,idblock,year,month,day,hour,minute,second):
+                def cFImage(self, idblock, year, month, day, hour, minute, second):
-                    self.hdu= pyfits.PrimaryHDU(idblock)
+                    self.hdu = pyfits.PrimaryHDU(idblock)
-                    self.hdu.header.set("Year",year)
+                    self.hdu.header.set("Year", year)
-                    self.hdu.header.set("Month",month)
+                    self.hdu.header.set("Month", month)
-                    self.hdu.header.set("Day",day)
+                    self.hdu.header.set("Day", day)
-                    self.hdu.header.set("Hour",hour)
+                    self.hdu.header.set("Hour", hour)
-                    self.hdu.header.set("Minute",minute)
+                    self.hdu.header.set("Minute", minute)
-                    self.hdu.header.set("Second",second)
+                    self.hdu.header.set("Second", second)
                     return self.hdu
-                def Ctable(self,colList):
+                def Ctable(self, colList):
-                    self.cols=pyfits.ColDefs(colList)
+                    self.cols = pyfits.ColDefs(colList)
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
-                def CFile(self,hdu,tbhdu):
+                def CFile(self, hdu, tbhdu):
-                    self.thdulist=pyfits.HDUList([hdu,tbhdu])
+                    self.thdulist = pyfits.HDUList([hdu, tbhdu])
-                def wFile(self,filename):
+                def wFile(self, filename):
                     if os.path.isfile(filename):
                         os.remove(filename)
                     self.thdulist.writeto(filename)
                     header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
                     header_data.header['CHANNELLIST'] = str(dataOut.channelList)
                     header_data.header['NCHANNELS'] = dataOut.nChannels
-                    #header_data.header['HEIGHTS'] = dataOut.heightList
+                    # header_data.header['HEIGHTS'] = dataOut.heightList
                     header_data.header['NHEIGHTS'] = dataOut.nHeights
                     header_data.header['IPPSECONDS'] = dataOut.ippSeconds
                     header_data.writeto(self.filename)
-                    self.addExtension(dataOut.heightList,'HEIGHTLIST')
+                    self.addExtension(dataOut.heightList, 'HEIGHTLIST')
                 def setup(self, dataOut, path, dataBlocksPerFile=100, metadatafile=None):
                 def addExtension(self, data, tagname):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=tagname)
-                    #extension.header['TAG'] = tagname
+                    # extension.header['TAG'] = tagname
                     self.fitsObj.append(extension)
                     self.write()
                     ext = self.ext
                     path = self.path
-                    timeTuple = time.localtime( self.dataOut.utctime)
+                    timeTuple = time.localtime(self.dataOut.utctime)
-                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
+                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
-                    fullpath = os.path.join( path, subfolder )
+                    fullpath = os.path.join(path, subfolder)
-                    if not( os.path.exists(fullpath) ):
+                    if not(os.path.exists(fullpath)):
                         os.mkdir(fullpath)
-                        self.setFile = -1 #inicializo mi contador de seteo
+                        self.setFile = -1  # inicializo mi contador de seteo
                     else:
-                        filesList = os.listdir( fullpath )
+                        filesList = os.listdir(fullpath)
-                        if len( filesList ) > 0:
+                        if len(filesList) > 0:
-                            filesList = sorted( filesList, key=str.lower )
+                            filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
-                            if isNumber( filen[8:11] ):
+                            if isNumber(filen[8:11]):
-                                self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
+                                self.setFile = int(filen[8:11])  # inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
-                            self.setFile = -1 #inicializo mi contador de seteo
+                            self.setFile = -1  # inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
-                                                    ext )
+                                                    ext)
-                    filename = os.path.join( path, subfolder, thisFile )
+                    filename = os.path.join(path, subfolder, thisFile)
                     self.blockIndex = 0
                     self.filename = filename
                     self.setFile = setFile
                     self.flagIsNewFile = 1
-                    print('Writing the file: %s'%self.filename)
+                    print('Writing the file: %s' % self.filename)
                     self.setFitsHeader(self.dataOut, self.metadatafile)
                     if self.blockIndex < self.dataBlocksPerFile:
                         return 1
-                    if not( self.setNextFile() ):
+                    if not(self.setNextFile()):
                         return 0
                     return 1
                 def writeNextBlock(self):
-                    if not( self.__setNewBlock() ):
+                    if not(self.__setNewBlock()):
                         return 0
                     self.writeBlock()
                     return 1
                 data = None
                 data_header_dict = None
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
-                    ProcessingUnit.__init__(self)#, **kwargs)
+                    ProcessingUnit.__init__(self)  # , **kwargs)
                     self.isConfig = False
                     self.ext = '.fits'
                     self.setFile = 0
                     self.nReadBlocks = 0
                     self.nTotalBlocks = 0
                     self.dataOut = self.createObjByDefault()
-                    self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
+                    self.maxTimeStep = 10  # deberia ser definido por el usuario usando el metodo setup()
                     self.blockIndex = 1
                 def createObjByDefault(self):
                 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
                     try:
-                        fitsObj = pyfits.open(filename,'readonly')
+                        fitsObj = pyfits.open(filename, 'readonly')
                     except:
-                        print("File %s can't be opened" %(filename))
+                        print("File %s can't be opened" % (filename))
                         return None
                     header = fitsObj[0].header
                     struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
-                    utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
+                    utc = time.mktime(struct_time) - time.timezone  # TIMEZONE debe ser un parametro del header FITS
                     ltc = utc
                     if useLocalTime:
             #                continue
                         fileSize = os.path.getsize(filename)
-                        fitsObj = pyfits.open(filename,'readonly')
+                        fitsObj = pyfits.open(filename, 'readonly')
                         break
                     self.flagIsNewFile = 1
                     self.fileSize = fileSize
                     self.fitsObj = fitsObj
                     self.blockIndex = 0
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                                         path,
                                         startDate,
                                         endDate,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         set=None,
                                         expLabel='',
                                         ext='.fits',
                     else:
                         dirList = []
                         for thisPath in os.listdir(path):
-                            if not os.path.isdir(os.path.join(path,thisPath)):
+                            if not os.path.isdir(os.path.join(path, thisPath)):
                                 continue
                             if not isRadarFolder(thisPath):
                                 continue
                             year = thisDate.timetuple().tm_year
                             doy = thisDate.timetuple().tm_yday
-                            matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
+                            matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year, doy) + '*')
                             if len(matchlist) == 0:
                                 thisDate += datetime.timedelta(1)
                                 continue
                             for match in matchlist:
-                                pathList.append(os.path.join(path,match,expLabel))
+                                pathList.append(os.path.join(path, match, expLabel))
                             thisDate += datetime.timedelta(1)
                     if pathList == []:
-                        print("Any folder was found for the date range: %s-%s" %(startDate, endDate))
+                        print("Any folder was found for the date range: %s-%s" % (startDate, endDate))
                         return None, None
-                    print("%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate))
+                    print("%d folder(s) was(were) found for the date range: %s - %s" % (len(pathList), startDate, endDate))
                     filenameList = []
                     datetimeList = []
                         thisPath = pathList[i]
-                        fileList = glob.glob1(thisPath, "*%s" %ext)
+                        fileList = glob.glob1(thisPath, "*%s" % ext)
                         fileList.sort()
                         for thisFile in fileList:
-                            filename = os.path.join(thisPath,thisFile)
+                            filename = os.path.join(thisPath, thisFile)
                             thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
                             if not(thisDatetime):
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
-                        print("Any file was found for the time range %s - %s" %(startTime, endTime))
+                        print("Any file was found for the time range %s - %s" % (startTime, endTime))
                         return None, None
-                    print("%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime))
+                    print("%d file(s) was(were) found for the time range: %s - %s" % (len(filenameList), startTime, endTime))
                     print()
                     for i in range(len(filenameList)):
-                        print("%s -> [%s]" %(filenameList[i], datetimeList[i].ctime()))
+                        print("%s -> [%s]" % (filenameList[i], datetimeList[i].ctime()))
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                 def setup(self, path=None,
                             startDate=None,
                             endDate=None,
-                            startTime=datetime.time(0,0,0),
+                            startTime=datetime.time(0, 0, 0),
-                            endTime=datetime.time(23,59,59),
+                            endTime=datetime.time(23, 59, 59),
                             set=0,
-                            expLabel = "",
+                            expLabel="",
-                            ext = None,
+                            ext=None,
-                            online = False,
+                            online=False,
-                            delay = 60,
+                            delay=60,
-                            walk = True):
+                            walk=True):
                     if path == None:
                         raise ValueError("The path is not valid")
                                                                            walk=walk)
                         if not(pathList):
-                            print("No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
+                            print("No *%s files into the folder %s \nfor the range: %s - %s" % (ext, path,
-                                                                    datetime.datetime.combine(startDate,startTime).ctime(),
+                                                                    datetime.datetime.combine(startDate, startTime).ctime(),
-                                                                    datetime.datetime.combine(endDate,endTime).ctime()))
+                                                                    datetime.datetime.combine(endDate, endTime).ctime()))
                             sys.exit(-1)
                     self.ext = ext
                     if not(self.setNextFile()):
-                        if (startDate!=None) and (endDate!=None):
+                        if (startDate != None) and (endDate != None):
-                            print("No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()))
+                            print("No files in range: %s - %s" % (datetime.datetime.combine(startDate, startTime).ctime(), datetime.datetime.combine(endDate, endTime).ctime()))
                         elif startDate != None:
-                            print("No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime()))
+                            print("No files in range: %s" % (datetime.datetime.combine(startDate, startTime).ctime()))
                         else:
                             print("No files")
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
-                    for nTries in range( self.nTries ):
+                    for nTries in range(self.nTries):
                         self.fp.close()
-                        self.fp = open( self.filename, 'rb' )
+                        self.fp = open(self.filename, 'rb')
-                        self.fp.seek( currentPointer )
+                        self.fp.seek(currentPointer)
-                        self.fileSize = os.path.getsize( self.filename )
+                        self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
-                        if ( currentSize >= neededSize ):
+                        if (currentSize >= neededSize):
                             self.__rdBasicHeader()
                             return 1
-                        print("\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1))
+                        print("\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
-                        sleep( self.delay )
+                        sleep(self.delay)
                     return 0
                 doypath = None
                 subfolder = None
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
-                    Operation.__init__(self)#, **kwargs)
+                    Operation.__init__(self)  # , **kwargs)
                     self.wrObj = PyFits()
             #        self.dataOut = dataOut
-                    self.nTotalBlocks=0
+                    self.nTotalBlocks = 0
             #        self.set = None
                     self.setFile = None
                     self.idblock = 0
                     False   :    no es un string numerico
                     """
                     try:
-                        float( str )
+                        float(str)
                         return True
                     except:
                         return False
                     self.dataOut = dataOut
                 def putData(self):
-                    name= time.localtime( self.dataOut.utctime)
+                    name = time.localtime(self.dataOut.utctime)
-                    ext=".fits"
+                    ext = ".fits"
                     if self.doypath == None:
-                       self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
+                       self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year, name.tm_yday, time.mktime(datetime.datetime.now().timetuple()))
-                       self.doypath = os.path.join( self.wrpath, self.subfolder )
+                       self.doypath = os.path.join(self.wrpath, self.subfolder)
                        os.mkdir(self.doypath)
                     if self.setFile == None:
             #           self.set = self.dataOut.set
                        self.setFile = 0
             #        if self.set != self.dataOut.set:
-            ##            self.set = self.dataOut.set
+            # #            self.set = self.dataOut.set
             #            self.setFile = 0
-                    #make the filename
+                    # make the filename
-                    thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
+                    thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year, name.tm_yday, self.setFile, ext)
-                    filename = os.path.join(self.wrpath,self.subfolder, thisFile)
+                    filename = os.path.join(self.wrpath, self.subfolder, thisFile)
-                    idblock = numpy.array([self.idblock],dtype="int64")
+                    idblock = numpy.array([self.idblock], dtype="int64")
-                    header=self.wrObj.cFImage(idblock=idblock,
+                    header = self.wrObj.cFImage(idblock=idblock,
                                             year=time.gmtime(self.dataOut.utctime).tm_year,
                                             month=time.gmtime(self.dataOut.utctime).tm_mon,
                                             day=time.gmtime(self.dataOut.utctime).tm_mday,
                                             minute=time.gmtime(self.dataOut.utctime).tm_min,
                                             second=time.gmtime(self.dataOut.utctime).tm_sec)
-                    c=3E8
+                    c = 3E8
                     deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
-                    freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
+                    freq = numpy.arange(-1 * self.dataOut.nHeights / 2., self.dataOut.nHeights / 2.) * (c / (2 * deltaHeight * 1000))
                     colList = []
-                    colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
+                    colFreq = self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints) + 'E', array=freq)
                     colList.append(colFreq)
-                    nchannel=self.dataOut.nChannels
+                    nchannel = self.dataOut.nChannels
                     for i in range(nchannel):
-                        col = self.wrObj.writeData(name="PCh"+str(i+1),
+                        col = self.wrObj.writeData(name="PCh" + str(i + 1),
-                                                     format=str(self.dataOut.nFFTPoints)+'E',
+                                                     format=str(self.dataOut.nFFTPoints) + 'E',
-                                                      data=10*numpy.log10(self.dataOut.data_spc[i,:]))
+                                                      data=10 * numpy.log10(self.dataOut.data_spc[i, :]))
                         colList.append(col)
-                    data=self.wrObj.Ctable(colList=colList)
+                    data = self.wrObj.Ctable(colList=colList)
-                    self.wrObj.CFile(header,data)
+                    self.wrObj.CFile(header, data)
                     self.wrObj.wFile(filename)
-                    #update the setFile
+                    # update the setFile
                     self.setFile += 1
                     self.idblock += 1
                         self.isConfig = True
                     self.putData()
-                    return dataOut
  No newline at end of file
+                    return dataOut

schainpy/model/io/jroIO_hf.py +253 -253

             @author: roj-com0419
             '''
-            import os,sys
+            import os, sys
-            import time,datetime
+            import time, datetime
             import h5py
             import numpy
             import fnmatch
                     False   :    no es un string numerico
                 """
                 try:
-                    float( str )
+                    float(str)
                     return True
                 except:
                     return False
                 for thisFile in fileList:
                     try:
-                        number= int(thisFile[6:16])
+                        number = int(thisFile[6:16])
                  #       year = int(thisFile[1:5])
                  #       doy  = int(thisFile[5:8])
                 if len(validFilelist) < 1:
                     return None
-                validFilelist = sorted( validFilelist, key=str.lower )
+                validFilelist = sorted(validFilelist, key=str.lower)
                 if set == None:
                     return validFilelist[-1]
-                print("set =" ,set)
+                print("set =" , set)
                 for thisFile in validFilelist:
                     if set <= int(thisFile[6:16]):
-                        print(thisFile,int(thisFile[6:16]))
+                        print(thisFile, int(thisFile[6:16]))
                         return thisFile
                 return validFilelist[-1]
-                myfile = fnmatch.filter(validFilelist,'*%10d*'%(set))
+                myfile = fnmatch.filter(validFilelist, '*%10d*' % (set))
-                #myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
+                # myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
-                if len(myfile)!= 0:
+                if len(myfile) != 0:
                     return myfile[0]
                 else:
-                    filename = '*%10.10d%s'%(set,ext.lower())
+                    filename = '*%10.10d%s' % (set, ext.lower())
-                    print('the filename %s does not exist'%filename)
+                    print('the filename %s does not exist' % filename)
                     print('...going to the last file: ')
                 if validFilelist:
-                    validFilelist = sorted( validFilelist, key=str.lower )
+                    validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
                 for thisFile in fileList:
                     try:
-                        number= int(thisFile[6:16])
+                        number = int(thisFile[6:16])
                     except:
                         print("There is a file or folder with different format")
                     if not isNumber(number):
             #        if not isNumber(doy):
             #            continue
-                    number= int(number)
+                    number = int(number)
             #        year = int(year)
             #        doy = int(doy)
                 if validFilelist:
-                    validFilelist = sorted( validFilelist, key=str.lower )
+                    validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
                 '''
                 classdocs
                 '''
-                path     = None
+                path = None
-                startDate= None
+                startDate = None
-                endDate  = None
+                endDate = None
-                startTime= None
+                startTime = None
-                endTime  = None
+                endTime = None
-                walk     = None
+                walk = None
                 isConfig = False
-                dataOut=None
+                dataOut = None
                 nTries = 3
-                ext      = ".hdf5"
+                ext = ".hdf5"
                 def __init__(self, **kwargs):
                     '''
                     '''
                     ProcessingUnit.__init__(self, **kwargs)
-                    self.isConfig =False
+                    self.isConfig = False
                     self.datablock = None
-                    self.filename_current=None
+                    self.filename_current = None
                     self.utc = 0
-                    self.ext='.hdf5'
+                    self.ext = '.hdf5'
                     self.flagIsNewFile = 1
                     #-------------------------------------------------
-                    self.fileIndex=None
+                    self.fileIndex = None
-                    self.profileIndex_offset=None
+                    self.profileIndex_offset = None
-                    self.filenameList=[]
+                    self.filenameList = []
-                    self.hfFilePointer= None
+                    self.hfFilePointer = None
                     self.filename_online = None
-                    self.status=True
+                    self.status = True
-                    self.flagNoMoreFiles= False
+                    self.flagNoMoreFiles = False
                     self.__waitForNewFile = 20
                     Return:
                         None
                     """
-                    pts2read =self.nChannels*self.nHeights*self.nProfiles
+                    pts2read = self.nChannels * self.nHeights * self.nProfiles
                     self.blocksize = pts2read
                 def __readHeader(self):
                     self.nProfiles = 100
                     self.nHeights = 1000
                     self.nChannels = 2
-                    self.__firstHeigth=0
+                    self.__firstHeigth = 0
-                    self.__nSamples=1000
+                    self.__nSamples = 1000
-                    self.__deltaHeigth=1.5
+                    self.__deltaHeigth = 1.5
-                    self.__sample_rate=1e5
+                    self.__sample_rate = 1e5
-                    #self.__frequency=2.72e6
+                    # self.__frequency=2.72e6
-                    #self.__frequency=3.64e6
+                    # self.__frequency=3.64e6
-                    self.__frequency=None
+                    self.__frequency = None
                     self.__online = False
-                    self.filename_next_set=None
+                    self.filename_next_set = None
-                    #print "Frequency of Operation:", self.__frequency
+                    # print "Frequency of Operation:", self.__frequency
-                def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
+                def __setParameters(self, path='', startDate='', endDate='', startTime='', endTime='', walk=''):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                 def __checkPath(self):
                     if os.path.exists(self.path):
-                        self.status=1
+                        self.status = 1
                     else:
-                        self.status=0
+                        self.status = 0
-                        print('Path %s does not exits'%self.path)
+                        print('Path %s does not exits' % self.path)
                         return
                     return
                 def __selDates(self, hf_dirname_format):
                     try:
-                        dir_hf_filename= self.path+"/"+hf_dirname_format
+                        dir_hf_filename = self.path + "/" + hf_dirname_format
-                        fp= h5py.File(dir_hf_filename,'r')
+                        fp = h5py.File(dir_hf_filename, 'r')
-                        hipoc=fp['t'].value
+                        hipoc = fp['t'].value
                         fp.close()
-                        date_time=datetime.datetime.utcfromtimestamp(hipoc)
+                        date_time = datetime.datetime.utcfromtimestamp(hipoc)
-                        year =int(date_time[0:4])
+                        year = int(date_time[0:4])
-                        month=int(date_time[5:7])
+                        month = int(date_time[5:7])
-                        dom  =int(date_time[8:10])
+                        dom = int(date_time[8:10])
-                        thisDate= datetime.date(year,month,dom)
+                        thisDate = datetime.date(year, month, dom)
-                        if (thisDate>=self.startDate and thisDate <= self.endDate):
+                        if (thisDate >= self.startDate and thisDate <= self.endDate):
                             return hf_dirname_format
                     except:
                         return None
-                def __findDataForDates(self,online=False):
+                def __findDataForDates(self, online=False):
                     if not(self.status):
                         return None
                     pat = '\d+.\d+'
-                    dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
+                    dirnameList = [re.search(pat, x) for x in os.listdir(self.path)]
-                    dirnameList = [x for x in dirnameList if x!=None]
+                    dirnameList = [x for x in dirnameList if x != None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = [x for x in dirnameList if x!=None]
+                        dirnameList = [x for x in dirnameList if x != None]
-                    if len(dirnameList)>0:
+                    if len(dirnameList) > 0:
                             self.status = 1
                             self.dirnameList = dirnameList
                             self.dirnameList.sort()
                         return None
                 def __getTimeFromData(self):
-                    startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
+                    startDateTime_Reader = datetime.datetime.combine(self.startDate, self.startTime)
-                    endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                    endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
-                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
+                    print('Filtering Files from %s to %s' % (startDateTime_Reader, endDateTime_Reader))
                     print('........................................')
-                    filter_filenameList=[]
+                    filter_filenameList = []
                     self.filenameList.sort()
-                    for i in range(len(self.filenameList)-1):
+                    for i in range(len(self.filenameList) - 1):
-                        filename=self.filenameList[i]
+                        filename = self.filenameList[i]
-                        dir_hf_filename= filename
+                        dir_hf_filename = filename
-                        fp= h5py.File(dir_hf_filename,'r')
+                        fp = h5py.File(dir_hf_filename, 'r')
-                        hipoc=fp['t'].value
+                        hipoc = fp['t'].value
-                        hipoc=hipoc+self.timezone
+                        hipoc = hipoc + self.timezone
-                        date_time=datetime.datetime.utcfromtimestamp(hipoc)
+                        date_time = datetime.datetime.utcfromtimestamp(hipoc)
                         fp.close()
-                        year =int(date_time[0:4])
+                        year = int(date_time[0:4])
-                        month=int(date_time[5:7])
+                        month = int(date_time[5:7])
-                        dom  =int(date_time[8:10])
+                        dom = int(date_time[8:10])
-                        hour =int(date_time[11:13])
+                        hour = int(date_time[11:13])
-                        min  =int(date_time[14:16])
+                        min = int(date_time[14:16])
-                        sec  =int(date_time[17:19])
+                        sec = int(date_time[17:19])
-                        this_time=datetime.datetime(year,month,dom,hour,min,sec)
+                        this_time = datetime.datetime(year, month, dom, hour, min, sec)
-                        if (this_time>=startDateTime_Reader and this_time <= endDateTime_Reader):
+                        if (this_time >= startDateTime_Reader and this_time <= endDateTime_Reader):
                             filter_filenameList.append(filename)
                     filter_filenameList.sort()
                     self.filenameList = filter_filenameList
                     return 1
                 def __getFilenameList(self):
-                    #print "hola"
+                    # print "hola"
-                    #print self.dirnameList
+                    # print self.dirnameList
-                    dirList = [os.path.join(self.path,x) for x in self.dirnameList]
+                    dirList = [os.path.join(self.path, x) for x in self.dirnameList]
-                    self.filenameList= dirList
+                    self.filenameList = dirList
-                    #print self.filenameList
+                    # print self.filenameList
-                    #print "pase",len(self.filenameList)
+                    # print "pase",len(self.filenameList)
                 def __selectDataForTimes(self, online=False):
                     if not(online):
                         if not(self.all):
                             self.__getTimeFromData()
-                        if len(self.filenameList)>0:
+                        if len(self.filenameList) > 0:
-                            self.status=1
+                            self.status = 1
                             self.filenameList.sort()
                         else:
-                            self.status=0
+                            self.status = 0
                             return None
                     else:
                         if self.set != None:
-                            filename=getFileFromSet(self.path,self.ext,self.set)
+                            filename = getFileFromSet(self.path, self.ext, self.set)
-                            if self.flag_nextfile==True:
+                            if self.flag_nextfile == True:
-                                self.dirnameList=[filename]
+                                self.dirnameList = [filename]
-                                fullfilename=self.path+"/"+filename
+                                fullfilename = self.path + "/" + filename
-                                self.filenameList=[fullfilename]
+                                self.filenameList = [fullfilename]
-                                self.filename_next_set=int(filename[6:16])+10
+                                self.filename_next_set = int(filename[6:16]) + 10
-                                self.flag_nextfile=False
+                                self.flag_nextfile = False
                             else:
                                 print(filename)
                                 print("PRIMERA CONDICION")
-                                #if self.filename_next_set== int(filename[6:16]):
+                                # if self.filename_next_set== int(filename[6:16]):
                                 print("TODO BIEN")
                                 if filename == None:
                                     raise ValueError("corregir")
-                                self.dirnameList=[filename]
+                                self.dirnameList = [filename]
-                                fullfilename=self.path+"/"+filename
+                                fullfilename = self.path + "/" + filename
-                                self.filenameList=[fullfilename]
+                                self.filenameList = [fullfilename]
-                                self.filename_next_set=int(filename[6:16])+10
+                                self.filename_next_set = int(filename[6:16]) + 10
-                                print("Setting next file",self.filename_next_set)
+                                print("Setting next file", self.filename_next_set)
-                                self.set=int(filename[6:16])
+                                self.set = int(filename[6:16])
                                 if True:
                                     pass
                                 else:
                                     print("ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO")
                         else:
-                            filename =getlastFileFromPath(self.path,self.ext)
+                            filename = getlastFileFromPath(self.path, self.ext)
-                            if self.flag_nextfile==True:
+                            if self.flag_nextfile == True:
-                                self.dirnameList=[filename]
+                                self.dirnameList = [filename]
-                                fullfilename=self.path+"/"+filename
+                                fullfilename = self.path + "/" + filename
-                                self.filenameList=[self.filenameList[-1]]
+                                self.filenameList = [self.filenameList[-1]]
-                                self.filename_next_set=int(filename[6:16])+10
+                                self.filename_next_set = int(filename[6:16]) + 10
-                                self.flag_nextfile=False
+                                self.flag_nextfile = False
                             else:
-                               filename=getFileFromSet(self.path,self.ext,self.set)
+                               filename = getFileFromSet(self.path, self.ext, self.set)
                                print(filename)
                                print("PRIMERA CONDICION")
-                                #if self.filename_next_set== int(filename[6:16]):
+                                # if self.filename_next_set== int(filename[6:16]):
                                print("TODO BIEN")
                                if filename == None:
                                    raise ValueError("corregir")
-                               self.dirnameList=[filename]
+                               self.dirnameList = [filename]
-                               fullfilename=self.path+"/"+filename
+                               fullfilename = self.path + "/" + filename
-                               self.filenameList=[fullfilename]
+                               self.filenameList = [fullfilename]
-                               self.filename_next_set=int(filename[6:16])+10
+                               self.filename_next_set = int(filename[6:16]) + 10
-                               print("Setting next file",self.filename_next_set)
+                               print("Setting next file", self.filename_next_set)
-                               self.set=int(filename[6:16])
+                               self.set = int(filename[6:16])
                                if True:
                                    pass
                                else:
                                         startDate,
                                         endDate,
                                         ext,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__checkPath()
                     self.__findDataForDates()
-                    #print self.dirnameList
+                    # print self.dirnameList
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print("%s"% (self.filenameList[i]))
+                        print("%s" % (self.filenameList[i]))
                     return
                 def searchFilesOnLine(self,
                                         path,
-                                        expLabel= "",
+                                        expLabel="",
                                         ext=None,
                                         startDate=None,
                                         endDate=None,
                     startDate = datetime.datetime.utcnow().date()
                     endDate = datetime.datetime.utcnow().date()
-                    self.__setParameters(path=path,startDate=startDate,endDate=endDate,walk=walk)
+                    self.__setParameters(path=path, startDate=startDate, endDate=endDate, walk=walk)
                     self.__checkPath()
-                    fullpath=path
+                    fullpath = path
-                    print("%s folder was found: " %(fullpath ))
+                    print("%s folder was found: " % (fullpath))
                     if set == None:
-                        self.set=None
+                        self.set = None
-                        filename =getlastFileFromPath(fullpath,ext)
+                        filename = getlastFileFromPath(fullpath, ext)
-                        startDate= datetime.datetime.utcnow().date
+                        startDate = datetime.datetime.utcnow().date
-                        endDate= datetime.datetime.utcnow().date()
+                        endDate = datetime.datetime.utcnow().date()
             #
                     else:
-                        filename= getFileFromSet(fullpath,ext,set)
+                        filename = getFileFromSet(fullpath, ext, set)
-                        startDate=None
+                        startDate = None
-                        endDate=None
+                        endDate = None
             #
                     if not (filename):
-                        return None,None,None,None,None
+                        return None, None, None, None, None
-                    #print "%s file was found" %(filename)
+                    # print "%s file was found" %(filename)
             #
             #         dir_hf_filename= self.path+"/"+filename
             #         dom  =int(date_time[8:10])
             #         set= int(filename[4:10])
             #         self.set=set-1
-                    #self.dirnameList=[filename]
+                    # self.dirnameList=[filename]
-                    filenameList= fullpath+"/"+filename
+                    filenameList = fullpath + "/" + filename
-                    self.dirnameList=[filename]
+                    self.dirnameList = [filename]
-                    self.filenameList=[filenameList]
+                    self.filenameList = [filenameList]
-                    self.flag_nextfile=True
+                    self.flag_nextfile = True
-                    #self.__findDataForDates(online=True)
+                    # self.__findDataForDates(online=True)
-                    #self.dirnameList=[self.dirnameList[-1]]
+                    # self.dirnameList=[self.dirnameList[-1]]
-                    #print self.dirnameList
+                    # print self.dirnameList
-                    #self.__selectDataForTimes(online=True)
+                    # self.__selectDataForTimes(online=True)
-                    #return fullpath,filename,year,month,dom,set
+                    # return fullpath,filename,year,month,dom,set
                     return
-                def __setNextFile(self,online=False):
+                def __setNextFile(self, online=False):
                     """
                     """
                     if not(online):
                 def __setNextFileOffline(self):
                     """
                     """
-                    idFile= self.fileIndex
+                    idFile = self.fileIndex
                     while(True):
                         idFile += 1
                         if not (idFile < len(self.filenameList)):
                             print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
-                        hfFilePointer =h5py.File(filename,'r')
+                        hfFilePointer = h5py.File(filename, 'r')
-                        epoc=hfFilePointer['t'].value
+                        epoc = hfFilePointer['t'].value
-                        #this_time=datetime.datetime(year,month,dom,hour,min,sec)
+                        # this_time=datetime.datetime(year,month,dom,hour,min,sec)
                         break
                     self.flagIsNewFile = 1
                     self.hfFilePointer = hfFilePointer
                     hfFilePointer.close()
-                    self.__t0=epoc
+                    self.__t0 = epoc
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __setNextFileOnline(self):
                     """
                     """
-                    print("SOY NONE",self.set)
+                    print("SOY NONE", self.set)
-                    if self.set==None:
+                    if self.set == None:
                         pass
                     else:
-                        self.set +=10
+                        self.set += 10
-                    filename = self.filenameList[0]#fullfilename
+                    filename = self.filenameList[0]  # fullfilename
                     if self.filename_online != None:
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         while self.filename_online == filename:
-                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
+                            print('waiting %d seconds to get a new file...' % (self.__waitForNewFile))
                             time.sleep(self.__waitForNewFile)
-                            #self.__findDataForDates(online=True)
+                            # self.__findDataForDates(online=True)
-                            self.set=self.filename_next_set
+                            self.set = self.filename_next_set
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
-                            sizeoffile=os.path.getsize(filename)
+                            sizeoffile = os.path.getsize(filename)
-                    #print filename
+                    # print filename
-                    sizeoffile=os.path.getsize(filename)
+                    sizeoffile = os.path.getsize(filename)
-                    if sizeoffile<1670240:
+                    if sizeoffile < 1670240:
-                        print("%s is not the rigth  size"%filename)
+                        print("%s is not the rigth  size" % filename)
-                        delay=50
+                        delay = 50
-                        print('waiting %d seconds for delay...'%(delay))
+                        print('waiting %d seconds for delay...' % (delay))
                         time.sleep(delay)
-                    sizeoffile=os.path.getsize(filename)
+                    sizeoffile = os.path.getsize(filename)
-                    if sizeoffile<1670240:
+                    if sizeoffile < 1670240:
-                        delay=50
+                        delay = 50
-                        print('waiting %d  more seconds for delay...'%(delay))
+                        print('waiting %d  more seconds for delay...' % (delay))
                         time.sleep(delay)
-                    sizeoffile=os.path.getsize(filename)
+                    sizeoffile = os.path.getsize(filename)
-                    if sizeoffile<1670240:
+                    if sizeoffile < 1670240:
-                        delay=50
+                        delay = 50
-                        print('waiting %d  more seconds for delay...'%(delay))
+                        print('waiting %d  more seconds for delay...' % (delay))
                         time.sleep(delay)
                     try:
-                        hfFilePointer=h5py.File(filename,'r')
+                        hfFilePointer = h5py.File(filename, 'r')
                     except:
-                        print("Error reading file %s"%filename)
+                        print("Error reading file %s" % filename)
-                    self.filename_online=filename
+                    self.filename_online = filename
-                    epoc=hfFilePointer['t'].value
+                    epoc = hfFilePointer['t'].value
-                    self.hfFilePointer=hfFilePointer
+                    self.hfFilePointer = hfFilePointer
                     hfFilePointer.close()
-                    self.__t0=epoc
+                    self.__t0 = epoc
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def __getExpParameters(self):
                         return None
                 def setup(self,
-                           path = None,
+                           path=None,
-                           startDate = None,
+                           startDate=None,
-                           endDate = None,
+                           endDate=None,
-                           startTime = datetime.time(0,0,0),
+                           startTime=datetime.time(0, 0, 0),
-                           endTime = datetime.time(23,59,59),
+                           endTime=datetime.time(23, 59, 59),
-                           set = None,
+                           set=None,
-                           expLabel = "",
+                           expLabel="",
-                           ext = None,
+                           ext=None,
                            all=0,
                            timezone=0,
-                           online = False,
+                           online=False,
-                           delay = 60,
+                           delay=60,
-                           walk = True):
+                           walk=True):
                     '''
                     In this method we should set all initial parameters.
                     '''
-                    if path==None:
+                    if path == None:
                         raise ValueError("The path is not valid")
-                    if ext==None:
+                    if ext == None:
                         ext = self.ext
-                    self.timezone= timezone
+                    self.timezone = timezone
-                    self.online= online
+                    self.online = online
-                    self.all=all
+                    self.all = all
-                    #if set==None:
+                    # if set==None:
-                    #print set
+                    # print set
                     if not(online):
                         print("Searching files in offline mode...")
                         self.searchFilesOffLine(path, startDate, endDate, ext, startTime, endTime, walk)
                     else:
                         print("Searching files in online mode...")
-                        self.searchFilesOnLine(path, walk,ext,set=set)
+                        self.searchFilesOnLine(path, walk, ext, set=set)
-                        if set==None:
+                        if set == None:
                             pass
                         else:
-                            self.set=set-10
+                            self.set = set - 10
             #             for nTries in range(self.nTries):
             #
                     if not(self.filenameList):
-                        print("There  is no files into the folder: %s"%(path))
+                        print("There  is no files into the folder: %s" % (path))
                         sys.exit(-1)
                     self.__getExpParameters()
                     self.__setLocalVariables()
                     self.__setHeaderDO()
-                    #self.profileIndex_offset= 0
+                    # self.profileIndex_offset= 0
-                    #self.profileIndex = self.profileIndex_offset
+                    # self.profileIndex = self.profileIndex_offset
                     self.isConfig = True
                 def __setLocalVariables(self):
-                    self.datablock = numpy.zeros((self.nChannels, self.nHeights,self.nProfiles), dtype = numpy.complex)
+                    self.datablock = numpy.zeros((self.nChannels, self.nHeights, self.nProfiles), dtype=numpy.complex)
                     #
                     #---------------------------------------------------------
-                    self.dataOut.systemHeaderObj.nProfiles=100
+                    self.dataOut.systemHeaderObj.nProfiles = 100
-                    self.dataOut.systemHeaderObj.nSamples=1000
+                    self.dataOut.systemHeaderObj.nSamples = 1000
-                    SAMPLING_STRUCTURE=[('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')]
+                    SAMPLING_STRUCTURE = [('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')]
-                    self.dataOut.radarControllerHeaderObj.samplingWindow=numpy.zeros((1,),SAMPLING_STRUCTURE)
+                    self.dataOut.radarControllerHeaderObj.samplingWindow = numpy.zeros((1,), SAMPLING_STRUCTURE)
-                    self.dataOut.radarControllerHeaderObj.samplingWindow['h0']=0
+                    self.dataOut.radarControllerHeaderObj.samplingWindow['h0'] = 0
-                    self.dataOut.radarControllerHeaderObj.samplingWindow['dh']=1.5
+                    self.dataOut.radarControllerHeaderObj.samplingWindow['dh'] = 1.5
-                    self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']=1000
+                    self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'] = 1000
-                    self.dataOut.radarControllerHeaderObj.nHeights=int(self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'])
+                    self.dataOut.radarControllerHeaderObj.nHeights = int(self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'])
                     self.dataOut.radarControllerHeaderObj.firstHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['h0']
                     self.dataOut.radarControllerHeaderObj.deltaHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['dh']
                     self.dataOut.radarControllerHeaderObj.samplesWin = self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']
-                    self.dataOut.radarControllerHeaderObj.nWindows=1
+                    self.dataOut.radarControllerHeaderObj.nWindows = 1
-                    self.dataOut.radarControllerHeaderObj.codetype=0
+                    self.dataOut.radarControllerHeaderObj.codetype = 0
-                    self.dataOut.radarControllerHeaderObj.numTaus=0
+                    self.dataOut.radarControllerHeaderObj.numTaus = 0
-                    #self.dataOut.radarControllerHeaderObj.Taus = numpy.zeros((1,),'<f4')
+                    # self.dataOut.radarControllerHeaderObj.Taus = numpy.zeros((1,),'<f4')
-                    #self.dataOut.radarControllerHeaderObj.nCode=numpy.zeros((1,), '<u4')
+                    # self.dataOut.radarControllerHeaderObj.nCode=numpy.zeros((1,), '<u4')
-                    #self.dataOut.radarControllerHeaderObj.nBaud=numpy.zeros((1,), '<u4')
+                    # self.dataOut.radarControllerHeaderObj.nBaud=numpy.zeros((1,), '<u4')
-                    #self.dataOut.radarControllerHeaderObj.code=numpy.zeros(0)
+                    # self.dataOut.radarControllerHeaderObj.code=numpy.zeros(0)
-                    self.dataOut.radarControllerHeaderObj.code_size=0
+                    self.dataOut.radarControllerHeaderObj.code_size = 0
-                    self.dataOut.nBaud=0
+                    self.dataOut.nBaud = 0
-                    self.dataOut.nCode=0
+                    self.dataOut.nCode = 0
-                    self.dataOut.nPairs=0
+                    self.dataOut.nPairs = 0
                     #---------------------------------------------------------
                     self.dataOut.data = None
-                    self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     self.dataOut.nProfiles = 1
-                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
+                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype=numpy.float) * self.__deltaHeigth
                     self.dataOut.channelList = list(range(self.nChannels))
-                    #self.dataOut.channelIndexList = None
+                    # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData = True
-                    #Set to TRUE if the data is discontinuous
+                    # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime = None
                     self.dataOut.blocksize = self.dataOut.nChannels * self.dataOut.nHeights
-                    self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
+                    self.dataOut.flagDecodeData = False  # asumo que la data esta decodificada
-                    self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
+                    self.dataOut.flagDeflipData = False  # asumo que la data esta sin flip
                     self.dataOut.flagShiftFFT = False
-                    self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate
+                    self.dataOut.ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
-                    #Time interval between profiles
+                    # Time interval between profiles
-                    #self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt
+                    # self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.__frequency
                 def __setNewBlock(self):
-                    if self.hfFilePointer==None:
+                    if self.hfFilePointer == None:
                         return 0
                     if self.flagIsNewFile:
                 def readBlock(self):
-                    fp=h5py.File(self.filename,'r')
+                    fp = h5py.File(self.filename, 'r')
-                                  #Puntero que apunta al archivo hdf5
+                                  # Puntero que apunta al archivo hdf5
-                    ch0=(fp['ch0']).value    #Primer canal (100,1000)--(perfiles,alturas)
+                    ch0 = (fp['ch0']).value  # Primer canal (100,1000)--(perfiles,alturas)
-                    ch1=(fp['ch1']).value    #Segundo canal (100,1000)--(perfiles,alturas)
+                    ch1 = (fp['ch1']).value  # Segundo canal (100,1000)--(perfiles,alturas)
                     fp.close()
-                    ch0= ch0.swapaxes(0,1)   #Primer canal (100,1000)--(alturas,perfiles)
+                    ch0 = ch0.swapaxes(0, 1)  # Primer canal (100,1000)--(alturas,perfiles)
-                    ch1= ch1.swapaxes(0,1)   #Segundo canal (100,1000)--(alturas,perfiles)
+                    ch1 = ch1.swapaxes(0, 1)  # Segundo canal (100,1000)--(alturas,perfiles)
-                    self.datablock = numpy.array([ch0,ch1])
+                    self.datablock = numpy.array([ch0, ch1])
-                    self.flagIsNewFile=0
+                    self.flagIsNewFile = 0
-                    self.profileIndex=0
+                    self.profileIndex = 0
                     return 1
                     if self.__hasNotDataInBuffer():
                         if not(self.readNextBlock()):
-                            self.dataOut.flagNodata=True
+                            self.dataOut.flagNodata = True
                             return 0
                     ##############################
                     ##############################
-                    self.dataOut.data = self.datablock[:,:,self.profileIndex]
+                    self.dataOut.data = self.datablock[:, :, self.profileIndex]
-                    self.dataOut.utctime = self.__t0 + self.dataOut.ippSeconds*self.profileIndex
+                    self.dataOut.utctime = self.__t0 + self.dataOut.ippSeconds * self.profileIndex
-                    self.dataOut.profileIndex= self.profileIndex
+                    self.dataOut.profileIndex = self.profileIndex
-                    self.dataOut.flagNoData=False
+                    self.dataOut.flagNoData = False
-                    self.profileIndex +=1
+                    self.profileIndex += 1
                     return self.dataOut.data
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
-                    self.getData()
  No newline at end of file
+                    self.getData()

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

                     self.__waitForNewFile = 20
                     self.__filename_online = None
-                    #Is really necessary create the output object in the initializer
+                    # Is really necessary create the output object in the initializer
                     self.dataOut = Voltage()
-                def setup(self,path=None,
+                def setup(self, path=None,
                                 startDate=None,
                                 endDate=None,
                                 startTime=None,
                                 endTime=None,
                                 walk=True,
                                 timezone='ut',
                                 all=0,
-                                code = None,
+                                code=None,
-                                nCode = 0,
+                                nCode=0,
-                                nBaud = 0,
+                                nBaud=0,
                                 online=False):
                     self.timezone = timezone
-                    #self.findFiles()
+                    # self.findFiles()
                     if not(online):
-                        #Busqueda de archivos offline
+                        # Busqueda de archivos offline
                         self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk)
                     else:
-                        self.searchFilesOnLine(path, startDate, endDate, startTime,endTime,walk)
+                        self.searchFilesOnLine(path, startDate, endDate, startTime, endTime, walk)
                     if not(self.filenameList):
-                        print("There is no files into the folder: %s"%(path))
+                        print("There is no files into the folder: %s" % (path))
                         sys.exit(-1)
                     pass
-                def readAMISRHeader(self,fp):
+                def readAMISRHeader(self, fp):
                     header = 'Raw11/Data/RadacHeader'
-                    self.beamCodeByPulse = fp.get(header+'/BeamCode') # LIST OF BEAMS PER PROFILE, TO BE USED ON REARRANGE
+                    self.beamCodeByPulse = fp.get(header + '/BeamCode')  # LIST OF BEAMS PER PROFILE, TO BE USED ON REARRANGE
-                    self.beamCode = fp.get('Raw11/Data/Beamcodes') # NUMBER OF CHANNELS AND IDENTIFY POSITION TO CREATE A FILE WITH THAT INFO
+                    self.beamCode = fp.get('Raw11/Data/Beamcodes')  # NUMBER OF CHANNELS AND IDENTIFY POSITION TO CREATE A FILE WITH THAT INFO
-                    #self.code = fp.get(header+'/Code') # NOT USE FOR THIS
+                    # self.code = fp.get(header+'/Code') # NOT USE FOR THIS
-                    self.frameCount = fp.get(header+'/FrameCount')# NOT USE FOR THIS
+                    self.frameCount = fp.get(header + '/FrameCount')  # NOT USE FOR THIS
-                    self.modeGroup = fp.get(header+'/ModeGroup')# NOT USE FOR THIS
+                    self.modeGroup = fp.get(header + '/ModeGroup')  # NOT USE FOR THIS
-                    self.nsamplesPulse = fp.get(header+'/NSamplesPulse')# TO GET NSA OR USING DATA FOR THAT
+                    self.nsamplesPulse = fp.get(header + '/NSamplesPulse')  # TO GET NSA OR USING DATA FOR THAT
-                    self.pulseCount = fp.get(header+'/PulseCount')# NOT USE FOR THIS
+                    self.pulseCount = fp.get(header + '/PulseCount')  # NOT USE FOR THIS
-                    self.radacTime = fp.get(header+'/RadacTime')# 1st TIME ON FILE ANDE CALCULATE THE REST WITH IPP*nindexprofile
+                    self.radacTime = fp.get(header + '/RadacTime')  # 1st TIME ON FILE ANDE CALCULATE THE REST WITH IPP*nindexprofile
-                    self.timeCount = fp.get(header+'/TimeCount')# NOT USE FOR THIS
+                    self.timeCount = fp.get(header + '/TimeCount')  # NOT USE FOR THIS
-                    self.timeStatus = fp.get(header+'/TimeStatus')# NOT USE FOR THIS
+                    self.timeStatus = fp.get(header + '/TimeStatus')  # NOT USE FOR THIS
                     self.rangeFromFile = fp.get('Raw11/Data/Samples/Range')
-                    self.frequency =  fp.get('Rx/Frequency')
+                    self.frequency = fp.get('Rx/Frequency')
                     txAus = fp.get('Raw11/Data/Pulsewidth')
-                    self.nblocks = self.pulseCount.shape[0] #nblocks
+                    self.nblocks = self.pulseCount.shape[0]  # nblocks
-                    self.nprofiles = self.pulseCount.shape[1] #nprofile
+                    self.nprofiles = self.pulseCount.shape[1]  # nprofile
-                    self.nsa = self.nsamplesPulse[0,0] #ngates
+                    self.nsa = self.nsamplesPulse[0, 0]  # ngates
                     self.nchannels = self.beamCode.shape[1]
-                    self.ippSeconds = (self.radacTime[0][1] -self.radacTime[0][0]) #Ipp in seconds
+                    self.ippSeconds = (self.radacTime[0][1] - self.radacTime[0][0])  # Ipp in seconds
-                    #self.__waitForNewFile = self.nblocks  # wait depending on the number of blocks since each block is 1 sec
+                    # self.__waitForNewFile = self.nblocks  # wait depending on the number of blocks since each block is 1 sec
-                    self.__waitForNewFile = self.nblocks * self.nprofiles * self.ippSeconds # wait until new file is created
+                    self.__waitForNewFile = self.nblocks * self.nprofiles * self.ippSeconds  # wait until new file is created
-                    #filling radar controller header parameters
+                    # filling radar controller header parameters
-                    self.__ippKm = self.ippSeconds *.15*1e6 # in km
+                    self.__ippKm = self.ippSeconds * .15 * 1e6  # in km
-                    self.__txA = (txAus.value)*.15 #(ipp[us]*.15km/1us) in km
+                    self.__txA = (txAus.value) * .15  # (ipp[us]*.15km/1us) in km
                     self.__txB = 0
-                    nWindows=1
+                    nWindows = 1
                     self.__nSamples = self.nsa
-                    self.__firstHeight = self.rangeFromFile[0][0]/1000 #in km
+                    self.__firstHeight = self.rangeFromFile[0][0] / 1000  # in km
-                    self.__deltaHeight = (self.rangeFromFile[0][1] - self.rangeFromFile[0][0])/1000
+                    self.__deltaHeight = (self.rangeFromFile[0][1] - self.rangeFromFile[0][0]) / 1000
-                    #for now until understand why the code saved is different (code included even though code not in tuf file)
+                    # for now until understand why the code saved is different (code included even though code not in tuf file)
-                    #self.__codeType = 0
+                    # self.__codeType = 0
                    # self.__nCode = None
                    # self.__nBaud = None
                     self.__code = self.code
                         self.__codeType = 1
                     self.__nCode = self.nCode
                     self.__nBaud = self.nBaud
-                    #self.__code = 0
+                    # self.__code = 0
-                    #filling system header parameters
+                    # filling system header parameters
                     self.__nSamples = self.nsa
-                    self.newProfiles = self.nprofiles/self.nchannels
+                    self.newProfiles = self.nprofiles / self.nchannels
                     self.__channelList = list(range(self.nchannels))
                     self.__frequency = self.frequency[0][0]
                     pass
-                def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
+                def __setParameters(self, path='', startDate='', endDate='', startTime='', endTime='', walk=''):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                         self.status = 1
                     else:
                         self.status = 0
-                        print('Path:%s does not exists'%self.path)
+                        print('Path:%s does not exists' % self.path)
                     return
                         year = int(amisr_dirname_format[0:4])
                         month = int(amisr_dirname_format[4:6])
                         dom = int(amisr_dirname_format[6:8])
-                        thisDate = datetime.date(year,month,dom)
+                        thisDate = datetime.date(year, month, dom)
-                        if (thisDate>=self.startDate and thisDate <= self.endDate):
+                        if (thisDate >= self.startDate and thisDate <= self.endDate):
                             return amisr_dirname_format
                     except:
                         return None
-                def __findDataForDates(self,online=False):
+                def __findDataForDates(self, online=False):
                     if not(self.status):
                         return None
                     pat = '\d+.\d+'
-                    dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
+                    dirnameList = [re.search(pat, x) for x in os.listdir(self.path)]
-                    dirnameList = [x for x in dirnameList if x!=None]
+                    dirnameList = [x for x in dirnameList if x != None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = [x for x in dirnameList if x!=None]
+                        dirnameList = [x for x in dirnameList if x != None]
-                    if len(dirnameList)>0:
+                    if len(dirnameList) > 0:
                         self.status = 1
                         self.dirnameList = dirnameList
                         self.dirnameList.sort()
                         return None
                 def __getTimeFromData(self):
-                    startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
+                    startDateTime_Reader = datetime.datetime.combine(self.startDate, self.startTime)
-                    endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                    endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
-                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
+                    print('Filtering Files from %s to %s' % (startDateTime_Reader, endDateTime_Reader))
                     print('........................................')
                     filter_filenameList = []
                     self.filenameList.sort()
-                    #for i in range(len(self.filenameList)-1):
+                    # for i in range(len(self.filenameList)-1):
                     for i in range(len(self.filenameList)):
                         filename = self.filenameList[i]
-                        fp = h5py.File(filename,'r')
+                        fp = h5py.File(filename, 'r')
                         time_str = fp.get('Time/RadacTimeString')
                         startDateTimeStr_File = time_str[0][0].split('.')[0]
                         junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        startDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         endDateTimeStr_File = time_str[-1][-1].split('.')[0]
                         junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                        endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                        endDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                         fp.close()
                         if self.timezone == 'lt':
-                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
+                            startDateTime_File = startDateTime_File - datetime.timedelta(minutes=300)
-                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
+                            endDateTime_File = endDateTime_File - datetime.timedelta(minutes=300)
-                        if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
+                        if (endDateTime_File >= startDateTime_Reader and endDateTime_File < endDateTime_Reader):
-                            #self.filenameList.remove(filename)
+                            # self.filenameList.remove(filename)
                             filter_filenameList.append(filename)
-                        if (endDateTime_File>=endDateTime_Reader):
+                        if (endDateTime_File >= endDateTime_Reader):
                             break
                     return 1
                 def __filterByGlob1(self, dirName):
-                    filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
+                    filter_files = glob.glob1(dirName, '*.*%s' % self.extension_file)
                     filter_files.sort()
                     filterDict = {}
                     filterDict.setdefault(dirName)
                 def __selectDataForTimes(self, online=False):
-                    #aun no esta implementado el filtro for tiempo
+                    # aun no esta implementado el filtro for tiempo
                     if not(self.status):
                         return None
-                    dirList = [os.path.join(self.path,x) for x in self.dirnameList]
+                    dirList = [os.path.join(self.path, x) for x in self.dirnameList]
                     fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
                     self.__getFilenameList(fileListInKeys, dirList)
                     if not(online):
-                        #filtro por tiempo
+                        # filtro por tiempo
                         if not(self.all):
                             self.__getTimeFromData()
-                        if len(self.filenameList)>0:
+                        if len(self.filenameList) > 0:
                             self.status = 1
                             self.filenameList.sort()
                         else:
                             return None
                     else:
-                        #get the last file - 1
+                        # get the last file - 1
                         self.filenameList = [self.filenameList[-2]]
                     new_dirnameList = []
                     self.dirnameList = new_dirnameList
                     return 1
-                def searchFilesOnLine(self, path, startDate, endDate, startTime=datetime.time(0,0,0),
+                def searchFilesOnLine(self, path, startDate, endDate, startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),walk=True):
+                                        endTime=datetime.time(23, 59, 59), walk=True):
-                    if endDate ==None:
+                    if endDate == None:
                      startDate = datetime.datetime.utcnow().date()
                      endDate = datetime.datetime.utcnow().date()
-                    self.__setParameters(path=path, startDate=startDate, endDate=endDate,startTime = startTime,endTime=endTime, walk=walk)
+                    self.__setParameters(path=path, startDate=startDate, endDate=endDate, startTime=startTime, endTime=endTime, walk=walk)
                     self.__checkPath()
                                         path,
                                         startDate,
                                         endDate,
-                                        startTime=datetime.time(0,0,0),
+                                        startTime=datetime.time(0, 0, 0),
-                                        endTime=datetime.time(23,59,59),
+                                        endTime=datetime.time(23, 59, 59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print("%s" %(self.filenameList[i]))
+                        print("%s" % (self.filenameList[i]))
                     return
                         filename = self.filenameList[idFile]
-                        amisrFilePointer = h5py.File(filename,'r')
+                        amisrFilePointer = h5py.File(filename, 'r')
                         break
                     self.amisrFilePointer = amisrFilePointer
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                         filename = self.filenameList[0]
                         wait = 0
                         while self.__filename_online == filename:
-                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
+                            print('waiting %d seconds to get a new file...' % (self.__waitForNewFile))
                             if wait == 5:
                                 return 0
                             sleep(self.__waitForNewFile)
                     self.__filename_online = filename
-                    self.amisrFilePointer = h5py.File(filename,'r')
+                    self.amisrFilePointer = h5py.File(filename, 'r')
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print("Setting the file: %s"%self.filename)
+                    print("Setting the file: %s" % self.filename)
                     return 1
                 def readData(self):
                     buffer = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
-                    re = buffer[:,:,:,0]
+                    re = buffer[:, :, :, 0]
-                    im = buffer[:,:,:,1]
+                    im = buffer[:, :, :, 1]
-                    dataset = re + im*1j
+                    dataset = re + im * 1j
                     self.radacTime = self.amisrFilePointer.get('Raw11/Data/RadacHeader/RadacTime')
-                    timeset = self.radacTime[:,0]
+                    timeset = self.radacTime[:, 0]
-                    return dataset,timeset
+                    return dataset, timeset
                 def reshapeData(self):
-                #self.beamCodeByPulse, self.beamCode, self.nblocks, self.nprofiles, self.nsa,
+                # self.beamCodeByPulse, self.beamCode, self.nblocks, self.nprofiles, self.nsa,
-                    channels = self.beamCodeByPulse[0,:]
+                    channels = self.beamCodeByPulse[0, :]
                     nchan = self.nchannels
-                    #self.newProfiles = self.nprofiles/nchan #must be defined on filljroheader
+                    # self.newProfiles = self.nprofiles/nchan #must be defined on filljroheader
                     nblocks = self.nblocks
                     nsamples = self.nsa
-                    #Dimensions : nChannels, nProfiles, nSamples
+                    # Dimensions : nChannels, nProfiles, nSamples
                     new_block = numpy.empty((nblocks, nchan, self.newProfiles, nsamples), dtype="complex64")
                     ############################################
                     for thisChannel in range(nchan):
-                        new_block[:,thisChannel,:,:] = self.dataset[:,numpy.where(channels==self.beamCode[0][thisChannel])[0],:]
+                        new_block[:, thisChannel, :, :] = self.dataset[:, numpy.where(channels == self.beamCode[0][thisChannel])[0], :]
-                    new_block = numpy.transpose(new_block, (1,0,2,3))
+                    new_block = numpy.transpose(new_block, (1, 0, 2, 3))
-                    new_block = numpy.reshape(new_block, (nchan,-1, nsamples))
+                    new_block = numpy.reshape(new_block, (nchan, -1, nsamples))
                     return new_block
                 def fillJROHeader(self):
-                    #fill radar controller header
+                    # fill radar controller header
                     self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ippKm=self.__ippKm,
                                                                                   txA=self.__txA,
                                                                                   txB=0,
                                                                                   deltaHeight=self.__deltaHeight,
                                                                                   codeType=self.__codeType,
                                                                                   nCode=self.__nCode, nBaud=self.__nBaud,
-                                                                                  code = self.__code,
+                                                                                  code=self.__code,
                                                                                   fClock=1)
-                    #fill system header
+                    # fill system header
                     self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                 nProfiles=self.newProfiles,
                                                                 nChannels=len(self.__channelList),
                     self.dataOut.data = None
-                    self.dataOut.dtype = numpy.dtype([('real','<i8'),('imag','<i8')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
             #        self.dataOut.nChannels = 0
             #        self.dataOut.nHeights = 0
-                    self.dataOut.nProfiles = self.newProfiles*self.nblocks
+                    self.dataOut.nProfiles = self.newProfiles * self.nblocks
-                    #self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
+                    # self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
-                    ranges = numpy.reshape(self.rangeFromFile.value,(-1))
+                    ranges = numpy.reshape(self.rangeFromFile.value, (-1))
-                    self.dataOut.heightList =  ranges/1000.0 #km
+                    self.dataOut.heightList = ranges / 1000.0  # km
                     self.dataOut.channelList = self.__channelList
                     self.dataOut.flagNoData = True
-                    #Set to TRUE if the data is discontinuous
+                    # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime = None
-                    #self.dataOut.timeZone = -5 #self.__timezone/60  #timezone like jroheader, difference in minutes between UTC and localtime
+                    # self.dataOut.timeZone = -5 #self.__timezone/60  #timezone like jroheader, difference in minutes between UTC and localtime
                     if self.timezone == 'lt':
-                        self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
+                        self.dataOut.timeZone = time.timezone / 60.  # get the timezone in minutes
                     else:
-                        self.dataOut.timeZone = 0 #by default time is UTC
+                        self.dataOut.timeZone = 0  # by default time is UTC
                     self.dataOut.dstFlag = 0
                     self.dataOut.nCohInt = 1
-                    self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
+                    self.dataOut.flagDecodeData = False  # asumo que la data esta decodificada
-                    self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
+                    self.dataOut.flagDeflipData = False  # asumo que la data esta sin flip
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.ippSeconds = self.ippSeconds
-                    #Time interval between profiles
+                    # Time interval between profiles
-                    #self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
+                    # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.__frequency
                     self.dataOut.realtime = self.online
                     pass
-                def readNextFile(self,online=False):
+                def readNextFile(self, online=False):
                     if not(online):
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
-                    #if self.__firstFile:
+                    # if self.__firstFile:
                     self.readAMISRHeader(self.amisrFilePointer)
                     self.createBuffers()
                     self.fillJROHeader()
-                    #self.__firstFile = False
+                    # self.__firstFile = False
-                    self.dataset,self.timeset = self.readData()
+                    self.dataset, self.timeset = self.readData()
-                    if self.endDate!=None:
+                    if self.endDate != None:
-                     endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
+                     endDateTime_Reader = datetime.datetime.combine(self.endDate, self.endTime)
                      time_str = self.amisrFilePointer.get('Time/RadacTimeString')
                      startDateTimeStr_File = time_str[0][0].split('.')[0]
                      junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
-                     startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
+                     startDateTime_File = datetime.datetime(junk.tm_year, junk.tm_mon, junk.tm_mday, junk.tm_hour, junk.tm_min, junk.tm_sec)
                      if self.timezone == 'lt':
-                      startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
+                      startDateTime_File = startDateTime_File - datetime.timedelta(minutes=300)
-                     if (startDateTime_File>endDateTime_Reader):
+                     if (startDateTime_File > endDateTime_Reader):
                          return 0
                     self.jrodataset = self.reshapeData()
                 def __hasNotDataInBuffer(self):
-                    if self.profileIndex >= (self.newProfiles*self.nblocks):
+                    if self.profileIndex >= (self.newProfiles * self.nblocks):
                         return 1
                     return 0
                             return 0
-                    if self.dataset is None: # setear esta condicion cuando no hayan datos por leers
+                    if self.dataset is None:  # setear esta condicion cuando no hayan datos por leers
                         self.dataOut.flagNoData = True
                         return 0
-                    #self.dataOut.data = numpy.reshape(self.jrodataset[self.profileIndex,:],(1,-1))
+                    # self.dataOut.data = numpy.reshape(self.jrodataset[self.profileIndex,:],(1,-1))
-                    self.dataOut.data = self.jrodataset[:,self.profileIndex,:]
+                    self.dataOut.data = self.jrodataset[:, self.profileIndex, :]
-                    #self.dataOut.utctime = self.jrotimeset[self.profileIndex]
+                    # self.dataOut.utctime = self.jrotimeset[self.profileIndex]
-                    #verificar basic header de jro data y ver si es compatible con este valor
+                    # verificar basic header de jro data y ver si es compatible con este valor
-                    #self.dataOut.utctime = self.timeset + (self.profileIndex * self.ippSeconds * self.nchannels)
+                    # self.dataOut.utctime = self.timeset + (self.profileIndex * self.ippSeconds * self.nchannels)
                     indexprof = numpy.mod(self.profileIndex, self.newProfiles)
-                    indexblock = self.profileIndex/self.newProfiles
+                    indexblock = self.profileIndex / self.newProfiles
-                    #print indexblock, indexprof
+                    # print indexblock, indexprof
                     self.dataOut.utctime = self.timeset[indexblock] + (indexprof * self.ippSeconds * self.nchannels)
                     self.dataOut.profileIndex = self.profileIndex
                     self.dataOut.flagNoData = False

schainpy/model/io/jroIO_madrigal.py +19 -19

                     self.flagNoMoreFiles = 0
                     self.filename = None
                     self.intervals = set()
-                    self.datatime = datetime.datetime(1900,1,1)
+                    self.datatime = datetime.datetime(1900, 1, 1)
                     self.format = None
                     self.filefmt = "***%Y%m%d*******"
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                     if self.ext == '.txt':
                         self.data = numpy.genfromtxt(self.fp, missing_values=('missing'))
                         self.nrecords = self.data.shape[0]
-                        self.ranges = numpy.unique(self.data[:,self.parameters.index(self.independentParam.lower())])
+                        self.ranges = numpy.unique(self.data[:, self.parameters.index(self.independentParam.lower())])
                         self.counter_records = 0
                     elif self.ext == '.hdf5':
                         self.data = self.fp['Data']
                                 if self.counter_records == self.nrecords:
                                     break
                                 continue
-                            self.intervals.add((datatime-self.datatime).seconds)
+                            self.intervals.add((datatime - self.datatime).seconds)
                             break
                     elif self.ext == '.hdf5':
                         datatime = datetime.datetime.utcfromtimestamp(
                             self.times[self.counter_records])
-                        dum = self.data['Table Layout'][self.data['Table Layout']['recno']==self.counter_records]
+                        dum = self.data['Table Layout'][self.data['Table Layout']['recno'] == self.counter_records]
-                        self.intervals.add((datatime-self.datatime).seconds)
+                        self.intervals.add((datatime - self.datatime).seconds)
-                        if datatime.date()>self.datatime.date():
+                        if datatime.date() > self.datatime.date():
                             self.flagDiscontinuousBlock = 1
                         self.datatime = datatime
                         self.counter_records += 1
                         if self.ext == '.txt':
                             x = self.parameters.index(param.lower())
                             y = self.parameters.index(self.independentParam.lower())
-                            ranges = self.buffer[:,y]
+                            ranges = self.buffer[:, y]
-                            #if self.ranges.size == ranges.size:
+                            # if self.ranges.size == ranges.size:
                             #    continue
                             index = numpy.where(numpy.in1d(self.ranges, ranges))[0]
-                            dummy[index] = self.buffer[:,x]
+                            dummy[index] = self.buffer[:, x]
                         else:
                             ranges = self.buffer[self.independentParam.lower()]
                             index = numpy.where(numpy.in1d(self.ranges, ranges))[0]
                         if isinstance(value, str):
                             if value not in self.independentParam:
-                                setattr(self.dataOut, value, dummy.reshape(1,-1))
+                                setattr(self.dataOut, value, dummy.reshape(1, -1))
                         elif isinstance(value, list):
                             self.output[value[0]][value[1]] = dummy
                             parameters[value[1]] = param
                         format      hdf5, cedar
                         blocks      number of blocks per file'''
-                __attrs__ = ['path', 'oneDDict', 'ind2DList', 'twoDDict','metadata', 'format', 'blocks']
+                __attrs__ = ['path', 'oneDDict', 'ind2DList', 'twoDDict', 'metadata', 'format', 'blocks']
                 missing = -32767
                 def __init__(self):
                     Create new cedar file object
                     '''
-                    self.mnemonic = MNEMONICS[self.kinst]   #TODO get mnemonic from madrigal
+                    self.mnemonic = MNEMONICS[self.kinst]  # TODO get mnemonic from madrigal
                     date = datetime.datetime.utcfromtimestamp(self.dataOut.utctime)
                     filename = '{}{}{}'.format(self.mnemonic,
                             if 'db' in value.lower():
                                 tmp = getattr(self.dataOut, value.replace('_db', ''))
                                 SNRavg = numpy.average(tmp, axis=0)
-                                tmp = 10*numpy.log10(SNRavg)
+                                tmp = 10 * numpy.log10(SNRavg)
                             else:
                                 tmp = getattr(self.dataOut, value)
                             out[key] = tmp.flatten()[:len(heights)]
                         startTime.hour,
                         startTime.minute,
                         startTime.second,
-                        startTime.microsecond/10000,
+                        startTime.microsecond / 10000,
                         endTime.year,
                         endTime.month,
                         endTime.day,
                         endTime.hour,
                         endTime.minute,
                         endTime.second,
-                        endTime.microsecond/10000,
+                        endTime.microsecond / 10000,
                         list(self.oneDDict.keys()),
                         list(self.twoDDict.keys()),
                         len(index),
                 def close(self):
                     if self.counter > 0:
-                        self.setHeader()
  No newline at end of file
+                        self.setHeader()

schainpy/model/io/jroIO_matlab.py +75 -75

             class matoffReader(ProcessingUnit):
-                index=None
+                index = None
-                list=None
+                list = None
-                firsttime=True
+                firsttime = True
-                utccounter=None
+                utccounter = None
-                utcfiletime=None
+                utcfiletime = None
-                utcmatcounter=0
+                utcmatcounter = 0
-                utcfirst=None
+                utcfirst = None
-                utclist=None
+                utclist = None
                 def __init__(self):
                     self.dataOut = Spectra()
                 def __setHeader(self, datastuff):
-                    self.dataOut.pairsList=[(0,1)]
+                    self.dataOut.pairsList = [(0, 1)]
-                    self.dataOut.channelList =  list(range(np.array(datastuff.get('power')).shape[1]))
+                    self.dataOut.channelList = list(range(np.array(datastuff.get('power')).shape[1]))
-                    self.dataOut.nProfiles = len(np.array(datastuff.get('vel')).flatten())     #this!
+                    self.dataOut.nProfiles = len(np.array(datastuff.get('vel')).flatten())  # this!
                     self.dataOut.nIncohInt = 20
-                    self.dataOut.nCohInt = 1 #this!
+                    self.dataOut.nCohInt = 1  # this!
-                    self.dataOut.ippSeconds = 0.004 #this!
+                    self.dataOut.ippSeconds = 0.004  # this!
                     self.dataOut.nFFTPoints = len(np.array(datastuff.get('vel')).flatten())
                     self.dataOut.timeZone = 0
                     self.dataOut.heightList = np.array(datastuff.get('hts')).flatten()
                 def __readFile(self, currentfile):
                     print("Reading from this file:" + currentfile)
-                    #filesplit=currentfile.split("\\")
+                    # filesplit=currentfile.split("\\")
-                    filesplit=currentfile.split("/")
+                    filesplit = currentfile.split("/")
-                    newsplit=filesplit[-2]
+                    newsplit = filesplit[-2]
-                    newnewsplit=newsplit.split(".")
+                    newnewsplit = newsplit.split(".")
-                    newnewsplit=[int(i) for i in newnewsplit]
+                    newnewsplit = [int(i) for i in newnewsplit]
-                    gooblist=datetime.datetime(newnewsplit[0],newnewsplit[1],newnewsplit[2],newnewsplit[3],newnewsplit[4],newnewsplit[5])
+                    gooblist = datetime.datetime(newnewsplit[0], newnewsplit[1], newnewsplit[2], newnewsplit[3], newnewsplit[4], newnewsplit[5])
-                    self.utcfirst=(gooblist-datetime.datetime(1970,1,1)).total_seconds()
+                    self.utcfirst = (gooblist - datetime.datetime(1970, 1, 1)).total_seconds()
-                    newsplit=filesplit[-1]
+                    newsplit = filesplit[-1]
-                    newnewsplit=newsplit.split(".")
+                    newnewsplit = newsplit.split(".")
-                    goobnum=newnewsplit[0]
+                    goobnum = newnewsplit[0]
-                    goobnum=int(goobnum)
+                    goobnum = int(goobnum)
-                    self.utcfirst=self.utcfirst+goobnum*2
+                    self.utcfirst = self.utcfirst + goobnum * 2
             #         if (currentfile[43:]=='0.mat'):
             #             self.utcmatcounter=0
             #             self.utcfirst=self.utclist[self.index]
             #         print self.utcmatcounter
                     print(self.utcfirst)
                     try:
-                        datastuff=sio.loadmat(currentfile)
+                        datastuff = sio.loadmat(currentfile)
                     except:
                         return None, None
-                    dataphase=datastuff.get('phase')
+                    dataphase = datastuff.get('phase')
-                    data3=datastuff.get('doppler0')
+                    data3 = datastuff.get('doppler0')
-                    data4=datastuff.get('doppler1')
+                    data4 = datastuff.get('doppler1')
-                    data3= np.array(data3)
+                    data3 = np.array(data3)
                     data4 = np.array(data4)
-                    datacoh=datastuff.get('coherence2')
+                    datacoh = datastuff.get('coherence2')
-                    datacohphase=datacoh*np.exp(-dataphase*1j)
+                    datacohphase = datacoh * np.exp(-dataphase * 1j)
             #         data31 = np.fliplr(data3)
             #         data41 = np.fliplr(data4)
-                    data31 = data3.reshape((1,data3.shape[0],data3.shape[1]))
+                    data31 = data3.reshape((1, data3.shape[0], data3.shape[1]))
-                    data41 = data4.reshape((1,data4.shape[0],data4.shape[1]))
+                    data41 = data4.reshape((1, data4.shape[0], data4.shape[1]))
-                    datacohphase1 = datacohphase.reshape((1,datacoh.shape[0],datacoh.shape[1]))
+                    datacohphase1 = datacohphase.reshape((1, datacoh.shape[0], datacoh.shape[1]))
-                    datastack = np.vstack((data31,data41))
+                    datastack = np.vstack((data31, data41))
                     self.__setHeader(datastuff)
                     return spc, cspc
-                def __findFiles(self, path, startDate=None, endDate=None,startTime=datetime.time(0,0,0), endTime=datetime.time(23,59,59)):
+                def __findFiles(self, path, startDate=None, endDate=None, startTime=datetime.time(0, 0, 0), endTime=datetime.time(23, 59, 59)):
                     if startDate == None:
-                        startDate = datetime.date(1970,1,1)
+                        startDate = datetime.date(1970, 1, 1)
                     if endDate == None:
-                        endDate = datetime.date(2050,1,1)
+                        endDate = datetime.date(2050, 1, 1)
-                    startsearch1=datetime.datetime.combine(startDate,startTime)
+                    startsearch1 = datetime.datetime.combine(startDate, startTime)
-                    startsearch2=(startsearch1-datetime.datetime(1970,1,1)).total_seconds()
+                    startsearch2 = (startsearch1 - datetime.datetime(1970, 1, 1)).total_seconds()
-                    endsearch1=datetime.datetime.combine(endDate,endTime)
+                    endsearch1 = datetime.datetime.combine(endDate, endTime)
-                    endsearch2=(endsearch1-datetime.datetime(1970,1,1)).total_seconds()
+                    endsearch2 = (endsearch1 - datetime.datetime(1970, 1, 1)).total_seconds()
                     dirList = listdir(path)
                     dirList = sorted(dirList)
-                    dirListFiltered=[]
+                    dirListFiltered = []
-                    fileListFiltered=[]
+                    fileListFiltered = []
-                    utclist=[]
+                    utclist = []
                     if not dirList:
                         print("No directories found")
                         return []
-                    #if self.online:
+                    # if self.online:
                     #    dirList= [dirList[-1]]
                     if self.online:
                         currentdate = datetime.datetime.now()
-                        strsplit1=currentdate.strftime('%Y.%m.%d')
+                        strsplit1 = currentdate.strftime('%Y.%m.%d')
-                        dirList = fnmatch.filter(dirList,strsplit1+'*')
+                        dirList = fnmatch.filter(dirList, strsplit1 + '*')
                     for thisDir in dirList:
                         if not os.path.isdir(os.path.join(path, thisDir)):
                             continue
-                        strsplit=thisDir.split('.')
+                        strsplit = thisDir.split('.')
-                        timeints=[int(i) for i in strsplit]
+                        timeints = [int(i) for i in strsplit]
-                        timelist=datetime.datetime(timeints[0],timeints[1],timeints[2],timeints[3],timeints[4],timeints[5])
+                        timelist = datetime.datetime(timeints[0], timeints[1], timeints[2], timeints[3], timeints[4], timeints[5])
-                        utctime=(timelist-datetime.datetime(1970,1,1)).total_seconds()
+                        utctime = (timelist - datetime.datetime(1970, 1, 1)).total_seconds()
                         if not self.online:
                             if (utctime > endsearch2):
                             continue
                         for k in range(len(fileList)):
-                            thisFile = str(k)+'.mat'
+                            thisFile = str(k) + '.mat'
                             if not os.path.isfile(os.path.join(pathFile, thisFile)):
                                 continue
                     return fileListFiltered
-                def __getNextOnlineFile(self, seconds = 40):
+                def __getNextOnlineFile(self, seconds=40):
                     filename = self.__getNextOfflineFile()
                         if nTries > 3:
                             break
-                        print("Waiting %d seconds ..." %seconds)
+                        print("Waiting %d seconds ..." % seconds)
                         time.sleep(40)
                     if not (len(filelist) > ncurrentfiles):
                     if self.index >= len(self.fileList):
                         return None
-                    filename=self.fileList[self.index]
+                    filename = self.fileList[self.index]
                     self.index += 1
                     return filename
                         filename = self.__getNextOfflineFile()
                     return filename
-                def setup(self, path, startDate=None, endDate=None,startTime=datetime.time(0,0,0), endTime=datetime.time(23,59,59)):
+                def setup(self, path, startDate=None, endDate=None, startTime=datetime.time(0, 0, 0), endTime=datetime.time(23, 59, 59)):
                     fileList = self.__findFiles(path, startDate, endDate, startTime, endTime)
                     if self.online:
-                        self.index = len(fileList) -1
+                        self.index = len(fileList) - 1
                     else:
                         self.index = 0
                     print("fin setup")
-                def run(self,path=None,startDate=None, endDate=None,
+                def run(self, path=None, startDate=None, endDate=None,
-                        startTime=datetime.time(0,0,0),
+                        startTime=datetime.time(0, 0, 0),
-                        endTime=datetime.time(23,59,59),
+                        endTime=datetime.time(23, 59, 59),
-                        walk=True,timezone='ut',
+                        walk=True, timezone='ut',
-                        all=0,online=False,ext=None,**kwargs):
+                        all=0, online=False, ext=None, **kwargs):
-                    self.path=path
+                    self.path = path
-                    self.ext=ext
+                    self.ext = ext
-                    self.startDate=startDate
+                    self.startDate = startDate
-                    self.endDate=endDate
+                    self.endDate = endDate
-                    self.startTime=startTime
+                    self.startTime = startTime
-                    self.endTime=endTime
+                    self.endTime = endTime
                     self.online = online
                     self.dataOut.flagNoData = True
-                    if (self.firsttime==True):
+                    if (self.firsttime == True):
                         self.setup(path, startDate, endDate, startTime, endTime)
-                        self.firsttime=False
+                        self.firsttime = False
                     if not self.fileList:
                     spc, cspc = self.__readFile(currentfile)
-                    if spc!=None:
+                    if spc != None:
                         self.dataOut.data_spc = spc
                         self.dataOut.data_cspc = cspc
                         self.dataOut.flagNoData = False
                     return 1
-  No newline at end of file

schainpy/model/io/jroIO_mira35c.py +55 -55

                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
-            #from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
+            # from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
-            #from schainpy.model.io.jroIO_bltr import BLTRReader
+            # from schainpy.model.io.jroIO_bltr import BLTRReader
             from numpy import imag, shape, NaN, empty
             class SRVIHeader(Header):
-                def __init__(self,     SignatureSRVI1=0,     SizeOfDataBlock1=0,     DataBlockTitleSRVI1=0,    SizeOfSRVI1=0):
+                def __init__(self, SignatureSRVI1=0, SizeOfDataBlock1=0, DataBlockTitleSRVI1=0, SizeOfSRVI1=0):
                     self.SignatureSRVI1 = SignatureSRVI1
                     self.SizeOfDataBlock1 = SizeOfDataBlock1
             SRVI_STRUCTURE = numpy.dtype([
                                         ('frame_cnt', '<u4'),
-                                        ('time_t', '<u4'),   #
+                                        ('time_t', '<u4'),  #
-                                        ('tpow', '<f4'),     #
+                                        ('tpow', '<f4'),  #
-                                        ('npw1', '<f4'),     #
+                                        ('npw1', '<f4'),  #
-                                        ('npw2', '<f4'),     #
+                                        ('npw2', '<f4'),  #
-                                        ('cpw1', '<f4'),     #
+                                        ('cpw1', '<f4'),  #
-                                        ('pcw2', '<f4'),     #
+                                        ('pcw2', '<f4'),  #
-                                        ('ps_err', '<u4'),   #
+                                        ('ps_err', '<u4'),  #
-                                        ('te_err', '<u4'),   #
+                                        ('te_err', '<u4'),  #
-                                        ('rc_err', '<u4'),   #
+                                        ('rc_err', '<u4'),  #
-                                        ('grs1', '<u4'),     #
+                                        ('grs1', '<u4'),  #
-                                        ('grs2', '<u4'),     #
+                                        ('grs2', '<u4'),  #
-                                        ('azipos', '<f4'),     #
+                                        ('azipos', '<f4'),  #
-                                        ('azivel', '<f4'),     #
+                                        ('azivel', '<f4'),  #
-                                        ('elvpos', '<f4'),     #
+                                        ('elvpos', '<f4'),  #
-                                        ('elvvel', '<f4'),     #
+                                        ('elvvel', '<f4'),  #
                                         ('northAngle', '<f4'),
-                                        ('microsec', '<u4'),   #
+                                        ('microsec', '<u4'),  #
                                         ('azisetvel', '<f4'),  #
                                         ('elvsetpos', '<f4'),  #
-                                        ('RadarConst', '<f4'), ])   #
+                                        ('RadarConst', '<f4'), ])  #
             class RecordHeader(Header):
-                def __init__(self,     frame_cnt=0,  time_t=0,  tpow=0,   npw1=0,   npw2=0,
+                def __init__(self, frame_cnt=0, time_t=0, tpow=0, npw1=0, npw2=0,
-                             cpw1=0,   pcw2=0,       ps_err=0,   te_err=0,   rc_err=0,   grs1=0,
+                             cpw1=0, pcw2=0, ps_err=0, te_err=0, rc_err=0, grs1=0,
-                             grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,
+                             grs2=0, azipos=0, azivel=0, elvpos=0, elvvel=0, northangle=0,
-                             microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0, RecCounter=0, Off2StartNxtRec=0):
+                             microsec=0, azisetvel=0, elvsetpos=0, RadarConst=0, RecCounter=0, Off2StartNxtRec=0):
                     self.frame_cnt = frame_cnt
                     self.dwell = time_t
                     # startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-                    #OffRHeader= 1180 + self.RecCounter*(self.Off2StartNxtRec)
+                    # OffRHeader= 1180 + self.RecCounter*(self.Off2StartNxtRec)
-                    #startFp.seek(OffRHeader, os.SEEK_SET)
+                    # startFp.seek(OffRHeader, os.SEEK_SET)
                     # print 'Posicion del bloque:        ',OffRHeader
                     header = numpy.fromfile(fp, SRVI_STRUCTURE, 1)
                     self.frame_cnt = header['frame_cnt'][0]
-                    self.time_t = header['time_t'][0]   #
+                    self.time_t = header['time_t'][0]  #
-                    self.tpow = header['tpow'][0]     #
+                    self.tpow = header['tpow'][0]  #
-                    self.npw1 = header['npw1'][0]     #
+                    self.npw1 = header['npw1'][0]  #
-                    self.npw2 = header['npw2'][0]     #
+                    self.npw2 = header['npw2'][0]  #
-                    self.cpw1 = header['cpw1'][0]     #
+                    self.cpw1 = header['cpw1'][0]  #
-                    self.pcw2 = header['pcw2'][0]     #
+                    self.pcw2 = header['pcw2'][0]  #
-                    self.ps_err = header['ps_err'][0]    #
+                    self.ps_err = header['ps_err'][0]  #
-                    self.te_err = header['te_err'][0]    #
+                    self.te_err = header['te_err'][0]  #
-                    self.rc_err = header['rc_err'][0]    #
+                    self.rc_err = header['rc_err'][0]  #
-                    self.grs1 = header['grs1'][0]      #
+                    self.grs1 = header['grs1'][0]  #
-                    self.grs2 = header['grs2'][0]      #
+                    self.grs2 = header['grs2'][0]  #
-                    self.azipos = header['azipos'][0]     #
+                    self.azipos = header['azipos'][0]  #
-                    self.azivel = header['azivel'][0]     #
+                    self.azivel = header['azivel'][0]  #
-                    self.elvpos = header['elvpos'][0]     #
+                    self.elvpos = header['elvpos'][0]  #
-                    self.elvvel = header['elvvel'][0]     #
+                    self.elvvel = header['elvvel'][0]  #
-                    self.northAngle = header['northAngle'][0]    #
+                    self.northAngle = header['northAngle'][0]  #
-                    self.microsec = header['microsec'][0]      #
+                    self.microsec = header['microsec'][0]  #
-                    self.azisetvel = header['azisetvel'][0]     #
+                    self.azisetvel = header['azisetvel'][0]  #
-                    self.elvsetpos = header['elvsetpos'][0]     #
+                    self.elvsetpos = header['elvsetpos'][0]  #
-                    self.RadarConst = header['RadarConst'][0]    #
+                    self.RadarConst = header['RadarConst'][0]  #
                     # 84
                     # print 'Pointer fp RECheader', fp.tell()
-                    #self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
+                    # self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
-                    #self.RHsize = 180+20*self.nChannels
+                    # self.RHsize = 180+20*self.nChannels
-                    #self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
+                    # self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
                     # print 'Datasize',self.Datasize
-                    #endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
+                    # endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
                     print('==============================================')
                         self.Num_inCoh = self.fheader.PPARavc
                         self.dataOut.PRF = self.fheader.PPARprf
-                        self.dataOut.frequency = 34.85 * 10**9
+                        self.dataOut.frequency = 34.85 * 10 ** 9
                         self.Lambda = SPEED_OF_LIGHT / self.dataOut.frequency
                         self.dataOut.ippSeconds = 1. / float(self.dataOut.PRF)
-                        pulse_width = self.fheader.PPARpdr * 10**-9
+                        pulse_width = self.fheader.PPARpdr * 10 ** -9
                         self.__deltaHeigth = 0.5 * SPEED_OF_LIGHT * pulse_width
                         self.data_spc = numpy.zeros((self.Num_Hei, self.Num_Bins, 2))
                     # print 'SHAPE', self.dataOut_spc.shape
                     # For nyquist correction:
                     # fix = 20 # ~3m/s
-                    #shift = self.Num_Bins/2 + fix
+                    # shift = self.Num_Bins/2 + fix
-                    #self.data_spc = numpy.array([ self.data_spc[: , self.Num_Bins-shift+1: , :] , self.data_spc[: , 0:self.Num_Bins-shift , :]])
+                    # self.data_spc = numpy.array([ self.data_spc[: , self.Num_Bins-shift+1: , :] , self.data_spc[: , 0:self.Num_Bins-shift , :]])
                     '''Block Reading, the Block Data is received and Reshape is used to give it
                     shape.
                     '''
-                    self.PointerReader = self.fp.tell()
  No newline at end of file
+                    self.PointerReader = self.fp.tell()

schainpy/model/io/jroIO_param.py +25 -25

                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                 setFile = None
                 fp = None
                 firsttime = True
-                #Configurations
+                # Configurations
                 blocksPerFile = None
                 blockIndex = None
                 dataOut = None
-                #Data Arrays
+                # Data Arrays
                 dataList = None
                 metadataList = None
                 currentDay = None
                     timeDiff = currentTime - self.lastTime
-                    #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
+                    # Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
                     if dataDay != self.currentDay:
                         self.currentDay = dataDay
                         return True
-                    elif timeDiff > 3*60*60:
+                    elif timeDiff > 3 * 60 * 60:
                         self.lastTime = currentTime
                         return True
                     else:
                     self.dataOut = dataOut
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description)
                     setFile = self.setFile
                     timeTuple = time.localtime(self.dataOut.utctime)
-                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
+                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     if os.path.exists(fullpath):
                         filesList = os.listdir(fullpath)
                         filesList = [k for k in filesList if k.startswith(self.optchar)]
-                        if len( filesList ) > 0:
+                        if len(filesList) > 0:
                             filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber(filen[8:11]):
-                                setFile = int(filen[8:11]) #inicializo mi contador de seteo al seteo del ultimo file
+                                setFile = int(filen[8:11])  # inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 setFile = -1
                         else:
-                            setFile = -1 #inicializo mi contador de seteo
+                            setFile = -1  # inicializo mi contador de seteo
                     else:
                         os.makedirs(fullpath)
-                        setFile = -1 #inicializo mi contador de seteo
+                        setFile = -1  # inicializo mi contador de seteo
                     if self.setType is None:
                         setFile += 1
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
-                                                       ext )
+                                                       ext)
                     else:
-                        setFile = timeTuple.tm_hour*60+timeTuple.tm_min
+                        setFile = timeTuple.tm_hour * 60 + timeTuple.tm_min
                         file = '%s%4.4d%3.3d%04d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
-                                                       ext )
+                                                       ext)
-                    self.filename = os.path.join( path, subfolder, file )
+                    self.filename = os.path.join(path, subfolder, file)
-                    #Setting HDF5 File
+                    # Setting HDF5 File
                     self.fp = h5py.File(self.filename, 'w')
-                    #write metadata
+                    # write metadata
                     self.writeMetadata(self.fp)
-                    #Write data
+                    # Write data
                     self.writeData(self.fp)
                 def getLabel(self, name, x=None):
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 self.getLabel(dsInfo['variable']),
-                                (self.blocksPerFile, ),
+                                (self.blocksPerFile,),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                                 sgrp = grp
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     self.getLabel(dsInfo['variable'], i),
-                                    (self.blocksPerFile, ) + dsInfo['shape'][1:],
+                                    (self.blocksPerFile,) + dsInfo['shape'][1:],
                                     chunks=True,
                                     dtype=dsInfo['dtype'])
                                 dtsets.append(ds)

schainpy/model/io/jroIO_simulator.py +295 -295

This diff has been collapsed as it changes many lines, (590 lines changed) Show them Hide them
	@@ -1,47 +1,47
	1	import numpy,math,random,time	1	import numpy, math, random, time
	2	#---------------1 Heredamos JRODatareader	2	#---------------1 Heredamos JRODatareader
	3	from schainpy.model.io.jroIO_base import *	3	from schainpy.model.io.jroIO_base import *
	4	#---------------2 Heredamos las propiedades de ProcessingUnit	4	#---------------2 Heredamos las propiedades de ProcessingUnit
	5	from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator	5	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
	6	#---------------3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader	6	#---------------3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
	7	from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader	7	from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
	8	#---------------4 Importaremos el objeto Voltge	8	#---------------4 Importaremos el objeto Voltge
	9	from schainpy.model.data.jrodata import Voltage	9	from schainpy.model.data.jrodata import Voltage
	10		10
	11	class SimulatorReader(JRODataReader, ProcessingUnit):	11	class SimulatorReader(JRODataReader, ProcessingUnit):
	12	incIntFactor = 1	12	incIntFactor = 1
	13	nFFTPoints = 0	13	nFFTPoints = 0
	14	FixPP_IncInt = 1	14	FixPP_IncInt = 1
	15	FixRCP_IPP = 1000	15	FixRCP_IPP = 1000
	16	FixPP_CohInt = 1	16	FixPP_CohInt = 1
	17	Tau_0 = 250	17	Tau_0 = 250
	18	AcqH0_0 = 70	18	AcqH0_0 = 70
	19	H0 = AcqH0_0	19	H0 = AcqH0_0
	20	AcqDH_0 = 1.25	20	AcqDH_0 = 1.25
	21	DH0 = AcqDH_0	21	DH0 = AcqDH_0
	22	Bauds = 32	22	Bauds = 32
	23	BaudWidth = None	23	BaudWidth = None
	24	FixRCP_TXA = 40	24	FixRCP_TXA = 40
	25	FixRCP_TXB = 70	25	FixRCP_TXB = 70
	26	fAngle = 2.0math.pi(1/16)	26	fAngle = 2.0 * math.pi * (1 / 16)
	27	DC_level = 500	27	DC_level = 500
	28	stdev = 8	28	stdev = 8
	29	Num_Codes = 2	29	Num_Codes = 2
	30	#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])	30	# code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
	31	#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])	31	# code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
	32	#Dyn_snCode = numpy.array([Num_Codes,Bauds])	32	# Dyn_snCode = numpy.array([Num_Codes,Bauds])
	33	Dyn_snCode = None	33	Dyn_snCode = None
	34	Samples = 200	34	Samples = 200
	35	channels = 2	35	channels = 2
	36	pulses = None	36	pulses = None
	37	Reference = None	37	Reference = None
	38	pulse_size = None	38	pulse_size = None
	39	prof_gen = None	39	prof_gen = None
	40	Fdoppler = 100	40	Fdoppler = 100
	41	Hdoppler = 36	41	Hdoppler = 36
	42	Adoppler = 300	42	Adoppler = 300
	43	frequency = 9345	43	frequency = 9345
	44	nTotalReadFiles = 1000	44	nTotalReadFiles = 1000
	45		45
	46	def __init__(self):	46	def __init__(self):
	47	"""	47	"""
	@@ -56,19 +56,19 class SimulatorReader(JRODataReader, ProcessingUnit):
	56	ProcessingUnit.__init__(self)	56	ProcessingUnit.__init__(self)
	57	print(" [ START ] init - Metodo Simulator Reader")	57	print(" [ START ] init - Metodo Simulator Reader")
	58		58
	59	self.isConfig = False	59	self.isConfig = False
	60	self.basicHeaderObj = BasicHeader(LOCALTIME)	60	self.basicHeaderObj = BasicHeader(LOCALTIME)
	61	self.systemHeaderObj = SystemHeader()	61	self.systemHeaderObj = SystemHeader()
	62	self.radarControllerHeaderObj = RadarControllerHeader()	62	self.radarControllerHeaderObj = RadarControllerHeader()
	63	self.processingHeaderObj = ProcessingHeader()	63	self.processingHeaderObj = ProcessingHeader()
	64	self.profileIndex = 2**32-1	64	self.profileIndex = 2 ** 32 - 1
	65	self.dataOut = Voltage()	65	self.dataOut = Voltage()
	66	#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])	66	# code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
	67	code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])	67	code0 = numpy.array([1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1])
	68	#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])	68	# code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
	69	code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])	69	code1 = numpy.array([1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1])
	70	#self.Dyn_snCode = numpy.array([code0,code1])	70	# self.Dyn_snCode = numpy.array([code0,code1])
	71	self.Dyn_snCode = None	71	self.Dyn_snCode = None
	72		72
	73	def set_kwargs(self, **kwargs):	73	def set_kwargs(self, **kwargs):
	74	for key, value in kwargs.items():	74	for key, value in kwargs.items():
	@@ -76,13 +76,13 class SimulatorReader(JRODataReader, ProcessingUnit):
	76		76
	77	def __hasNotDataInBuffer(self):	77	def __hasNotDataInBuffer(self):
	78		78
	79	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:	79	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock * self.nTxs:
	80	if self.nReadBlocks>0:	80	if self.nReadBlocks > 0:
	81	tmp = self.dataOut.utctime	81	tmp = self.dataOut.utctime
	82	tmp_utc = int(self.dataOut.utctime)	82	tmp_utc = int(self.dataOut.utctime)
	83	tmp_milisecond = int((tmp-tmp_utc)*1000)	83	tmp_milisecond = int((tmp - tmp_utc) * 1000)
	84	self.basicHeaderObj.utc = tmp_utc	84	self.basicHeaderObj.utc = tmp_utc
	85	self.basicHeaderObj.miliSecond= tmp_milisecond	85	self.basicHeaderObj.miliSecond = tmp_milisecond
	86	return 1	86	return 1
	87	return 0	87	return 0
	88		88
	@@ -90,14 +90,14 class SimulatorReader(JRODataReader, ProcessingUnit):
	90	"""Set the next file to be readed open it and parse de file header"""	90	"""Set the next file to be readed open it and parse de file header"""
	91		91
	92	if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):	92	if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
	93	self.nReadFiles=self.nReadFiles+1	93	self.nReadFiles = self.nReadFiles + 1
	94	if self.nReadFiles > self.nTotalReadFiles:	94	if self.nReadFiles > self.nTotalReadFiles:
	95	self.flagNoMoreFiles=1	95	self.flagNoMoreFiles = 1
	96	raise schainpy.admin.SchainWarning('No more files to read')	96	raise schainpy.admin.SchainWarning('No more files to read')
	97		97
	98	print('------------------- [Opening file] ------------------------------',self.nReadFiles)	98	print('------------------- [Opening file] ------------------------------', self.nReadFiles)
	99	self.nReadBlocks = 0	99	self.nReadBlocks = 0
	100	#if self.nReadBlocks==0:	100	# if self.nReadBlocks==0:
	101	# self.readFirstHeader()	101	# self.readFirstHeader()
	102		102
	103	def __setNewBlock(self):	103	def __setNewBlock(self):
	@@ -113,43 +113,43 class SimulatorReader(JRODataReader, ProcessingUnit):
	113	self.getBasicHeader()	113	self.getBasicHeader()
	114	break	114	break
	115	if self.verbose:	115	if self.verbose:
	116	print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,	116	print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
	117	self.processingHeaderObj.dataBlocksPerFile,	117	self.processingHeaderObj.dataBlocksPerFile,
	118	self.dataOut.datatime.ctime()) )	118	self.dataOut.datatime.ctime()))
	119	return 1	119	return 1
	120		120
	121	def getFirstHeader(self):	121	def getFirstHeader(self):
	122	self.getBasicHeader()	122	self.getBasicHeader()
	123	self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()	123	self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
	124	self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()	124	self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
	125	self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()	125	self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
	126	self.dataOut.dtype = self.dtype	126	self.dataOut.dtype = self.dtype
	127		127
	128	self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock	128	self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
	129	self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight	129	self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
	130	self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))	130	self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
	131	self.dataOut.nCohInt = self.processingHeaderObj.nCohInt	131	self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
	132	# asumo q la data no esta decodificada	132	# asumo q la data no esta decodificada
	133	self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode	133	self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
	134	# asumo q la data no esta sin flip	134	# asumo q la data no esta sin flip
	135	self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip	135	self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
	136	self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft	136	self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
	137	self.dataOut.frequency = self.frequency	137	self.dataOut.frequency = self.frequency
	138		138
	139	def getBasicHeader(self):	139	def getBasicHeader(self):
	140	self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \	140	self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
	141	1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds	141	1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
	142		142
	143	self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock	143	self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
	144	self.dataOut.timeZone = self.basicHeaderObj.timeZone	144	self.dataOut.timeZone = self.basicHeaderObj.timeZone
	145	self.dataOut.dstFlag = self.basicHeaderObj.dstFlag	145	self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
	146	self.dataOut.errorCount = self.basicHeaderObj.errorCount	146	self.dataOut.errorCount = self.basicHeaderObj.errorCount
	147	self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime	147	self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
	148	self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs	148	self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
	149		149
	150	def readFirstHeader(self):	150	def readFirstHeader(self):
	151		151
	152	datatype = int(numpy.log2((self.processingHeaderObj.processFlags &	152	datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
	153	PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))	153	PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
	154	if datatype == 0:	154	if datatype == 0:
	155	datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])	155	datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
	@@ -169,53 +169,53 class SimulatorReader(JRODataReader, ProcessingUnit):
	169	self.dtype = datatype_str	169	self.dtype = datatype_str
	170		170
	171		171
	172	def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,	172	def set_RCH(self, expType=2, nTx=1, ipp=None, txA=0, txB=0,
	173	nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,	173	nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
	174	numTaus=0, line6Function=0, line5Function=0, fClock=None,	174	numTaus=0, line6Function=0, line5Function=0, fClock=None,
	175	prePulseBefore=0, prePulseAfter=0,	175	prePulseBefore=0, prePulseAfter=0,
	176	codeType=0, nCode=0, nBaud=0, code=None,	176	codeType=0, nCode=0, nBaud=0, code=None,
	177	flip1=0, flip2=0,Taus=0):	177	flip1=0, flip2=0, Taus=0):
	178	self.radarControllerHeaderObj.expType = expType	178	self.radarControllerHeaderObj.expType = expType
	179	self.radarControllerHeaderObj.nTx = nTx	179	self.radarControllerHeaderObj.nTx = nTx
	180	self.radarControllerHeaderObj.ipp = float(ipp)	180	self.radarControllerHeaderObj.ipp = float(ipp)
	181	self.radarControllerHeaderObj.txA = float(txA)	181	self.radarControllerHeaderObj.txA = float(txA)
	182	self.radarControllerHeaderObj.txB = float(txB)	182	self.radarControllerHeaderObj.txB = float(txB)
	183	self.radarControllerHeaderObj.rangeIpp = b'A\n'#ipp	183	self.radarControllerHeaderObj.rangeIpp = b'A\n' # ipp
	184	self.radarControllerHeaderObj.rangeTxA = b''	184	self.radarControllerHeaderObj.rangeTxA = b''
	185	self.radarControllerHeaderObj.rangeTxB = b''	185	self.radarControllerHeaderObj.rangeTxB = b''
	186		186
	187	self.radarControllerHeaderObj.nHeights = int(nHeights)	187	self.radarControllerHeaderObj.nHeights = int(nHeights)
	188	self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])	188	self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])
	189	self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight])	189	self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight])
	190	self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights])	190	self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights])
	191		191
	192		192
	193	self.radarControllerHeaderObj.nWindows = nWindows	193	self.radarControllerHeaderObj.nWindows = nWindows
	194	self.radarControllerHeaderObj.numTaus = numTaus	194	self.radarControllerHeaderObj.numTaus = numTaus
	195	self.radarControllerHeaderObj.codeType = codeType	195	self.radarControllerHeaderObj.codeType = codeType
	196	self.radarControllerHeaderObj.line6Function = line6Function	196	self.radarControllerHeaderObj.line6Function = line6Function
	197	self.radarControllerHeaderObj.line5Function = line5Function	197	self.radarControllerHeaderObj.line5Function = line5Function
	198	#self.radarControllerHeaderObj.fClock = fClock	198	# self.radarControllerHeaderObj.fClock = fClock
	199	self.radarControllerHeaderObj.prePulseBefore= prePulseBefore	199	self.radarControllerHeaderObj.prePulseBefore = prePulseBefore
	200	self.radarControllerHeaderObj.prePulseAfter = prePulseAfter	200	self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
	201		201
	202	self.radarControllerHeaderObj.flip1 = flip1	202	self.radarControllerHeaderObj.flip1 = flip1
	203	self.radarControllerHeaderObj.flip2 = flip2	203	self.radarControllerHeaderObj.flip2 = flip2
	204		204
	205	self.radarControllerHeaderObj.code_size = 0	205	self.radarControllerHeaderObj.code_size = 0
	206	if self.radarControllerHeaderObj.codeType != 0:	206	if self.radarControllerHeaderObj.codeType != 0:
	207	self.radarControllerHeaderObj.nCode = nCode	207	self.radarControllerHeaderObj.nCode = nCode
	208	self.radarControllerHeaderObj.nBaud = nBaud	208	self.radarControllerHeaderObj.nBaud = nBaud
	209	self.radarControllerHeaderObj.code = code	209	self.radarControllerHeaderObj.code = code
	210	self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4	210	self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4
	211		211
	212	if fClock is None and deltaHeight is not None:	212	if fClock is None and deltaHeight is not None:
	213	self.fClock = 0.15 / (deltaHeight * 1e-6)	213	self.fClock = 0.15 / (deltaHeight * 1e-6)
	214	self.radarControllerHeaderObj.fClock = self.fClock	214	self.radarControllerHeaderObj.fClock = self.fClock
	215	if numTaus==0:	215	if numTaus == 0:
	216	self.radarControllerHeaderObj.Taus = numpy.array(0,'<f4')	216	self.radarControllerHeaderObj.Taus = numpy.array(0, '<f4')
	217	else:	217	else:
	218	self.radarControllerHeaderObj.Taus = numpy.array(Taus,'<f4')	218	self.radarControllerHeaderObj.Taus = numpy.array(Taus, '<f4')
	219		219
	220	def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,	220	def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
	221	dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,	221	dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
	@@ -224,177 +224,177 class SimulatorReader(JRODataReader, ProcessingUnit):
	224	code=0, nBaud=None, shif_fft=False, flag_dc=False,	224	code=0, nBaud=None, shif_fft=False, flag_dc=False,
	225	flag_cspc=False, flag_decode=False, flag_deflip=False):	225	flag_cspc=False, flag_decode=False, flag_deflip=False):
	226		226
	227	self.processingHeaderObj.dtype = dtype	227	self.processingHeaderObj.dtype = dtype
	228	self.processingHeaderObj.profilesPerBlock = profilesPerBlock	228	self.processingHeaderObj.profilesPerBlock = profilesPerBlock
	229	self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile	229	self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
	230	self.processingHeaderObj.nWindows = nWindows	230	self.processingHeaderObj.nWindows = nWindows
	231	self.processingHeaderObj.processFlags = processFlags	231	self.processingHeaderObj.processFlags = processFlags
	232	self.processingHeaderObj.nCohInt = nCohInt	232	self.processingHeaderObj.nCohInt = nCohInt
	233	self.processingHeaderObj.nIncohInt = nIncohInt	233	self.processingHeaderObj.nIncohInt = nIncohInt
	234	self.processingHeaderObj.totalSpectra = totalSpectra	234	self.processingHeaderObj.totalSpectra = totalSpectra
	235		235
	236	self.processingHeaderObj.nHeights = int(nHeights)	236	self.processingHeaderObj.nHeights = int(nHeights)
	237	self.processingHeaderObj.firstHeight = firstHeight#numpy.array([firstHeight])#firstHeight	237	self.processingHeaderObj.firstHeight = firstHeight # numpy.array([firstHeight])#firstHeight
	238	self.processingHeaderObj.deltaHeight = deltaHeight#numpy.array([deltaHeight])#deltaHeight	238	self.processingHeaderObj.deltaHeight = deltaHeight # numpy.array([deltaHeight])#deltaHeight
	239	self.processingHeaderObj.samplesWin = nHeights#numpy.array([nHeights])#nHeights	239	self.processingHeaderObj.samplesWin = nHeights # numpy.array([nHeights])#nHeights
	240		240
	241	def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):	241	def set_BH(self, utc=0, miliSecond=0, timeZone=0):
	242	self.basicHeaderObj.utc = utc	242	self.basicHeaderObj.utc = utc
	243	self.basicHeaderObj.miliSecond = miliSecond	243	self.basicHeaderObj.miliSecond = miliSecond
	244	self.basicHeaderObj.timeZone = timeZone	244	self.basicHeaderObj.timeZone = timeZone
	245		245
	246	def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):	246	def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=32):
	247	#self.systemHeaderObj.size = size	247	# self.systemHeaderObj.size = size
	248	self.systemHeaderObj.nSamples = nSamples	248	self.systemHeaderObj.nSamples = nSamples
	249	self.systemHeaderObj.nProfiles = nProfiles	249	self.systemHeaderObj.nProfiles = nProfiles
	250	self.systemHeaderObj.nChannels = nChannels	250	self.systemHeaderObj.nChannels = nChannels
	251	self.systemHeaderObj.adcResolution = adcResolution	251	self.systemHeaderObj.adcResolution = adcResolution
	252	self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth	252	self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth
	253		253
	254	def init_acquisition(self):	254	def init_acquisition(self):
	255		255
	256	if self.nFFTPoints != 0:	256	if self.nFFTPoints != 0:
	257	self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints	257	self.incIntFactor = m_nProfilesperBlock / self.nFFTPoints
	258	if (self.FixPP_IncInt > self.incIntFactor):	258	if (self.FixPP_IncInt > self.incIntFactor):
	259	self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor	259	self.incIntFactor = self.FixPP_IncInt / self.incIntFactor
	260	elif(self.FixPP_IncInt< self.incIntFactor):	260	elif(self.FixPP_IncInt < self.incIntFactor):
	261	print("False alert...")	261	print("False alert...")
	262		262
	263	ProfilesperBlock = self.processingHeaderObj.profilesPerBlock	263	ProfilesperBlock = self.processingHeaderObj.profilesPerBlock
	264		264
	265	self.timeperblock =int(((self.FixRCP_IPP	265	self.timeperblock = int(((self.FixRCP_IPP
	266	*ProfilesperBlock	266	* ProfilesperBlock
	267	*self.FixPP_CohInt	267	* self.FixPP_CohInt
	268	*self.incIntFactor)	268	* self.incIntFactor)
	269	/150.0)	269	/ 150.0)
	270	*0.9	270	* 0.9
	271	+0.5)	271	+ 0.5)
	272	# para cada canal	272	# para cada canal
	273	self.profiles = ProfilesperBlock*self.FixPP_CohInt	273	self.profiles = ProfilesperBlock * self.FixPP_CohInt
	274	self.profiles = ProfilesperBlock	274	self.profiles = ProfilesperBlock
	275	self.Reference = int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)	275	self.Reference = int((self.Tau_0 - self.AcqH0_0) / (self.AcqDH_0) + 0.5)
	276	self.BaudWidth = int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )	276	self.BaudWidth = int((self.FixRCP_TXA / self.AcqDH_0) / self.Bauds + 0.5)
	277		277
	278	if (self.BaudWidth==0):	278	if (self.BaudWidth == 0):
	279	self.BaudWidth=1	279	self.BaudWidth = 1
	280		280
	281	def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):	281	def init_pulse(self, Num_Codes=Num_Codes, Bauds=Bauds, BaudWidth=BaudWidth, Dyn_snCode=Dyn_snCode):
	282		282
	283	Num_Codes = Num_Codes	283	Num_Codes = Num_Codes
	284	Bauds = Bauds	284	Bauds = Bauds
	285	BaudWidth = BaudWidth	285	BaudWidth = BaudWidth
	286	Dyn_snCode = Dyn_snCode	286	Dyn_snCode = Dyn_snCode
	287		287
	288	if Dyn_snCode:	288	if Dyn_snCode:
	289	print("EXISTE")	289	print("EXISTE")
	290	else:	290	else:
	291	print("No existe")	291	print("No existe")
	292		292
	293	if Dyn_snCode: # if Bauds:	293	if Dyn_snCode: # if Bauds:
	294	pulses = list(range(0,Num_Codes))	294	pulses = list(range(0, Num_Codes))
	295	num_codes = Num_Codes	295	num_codes = Num_Codes
	296	for i in range(num_codes):	296	for i in range(num_codes):
	297	pulse_size = Bauds*BaudWidth	297	pulse_size = Bauds * BaudWidth
	298	pulses[i] = numpy.zeros(pulse_size)	298	pulses[i] = numpy.zeros(pulse_size)
	299	for j in range(Bauds):	299	for j in range(Bauds):
	300	for k in range(BaudWidth):	300	for k in range(BaudWidth):
	301	pulses[i][jBaudWidth+k] = int(Dyn_snCode[i][j]600)	301	pulses[i][j * BaudWidth + k] = int(Dyn_snCode[i][j] * 600)
	302	else:	302	else:
	303	print("sin code")	303	print("sin code")
	304	pulses = list(range(1))	304	pulses = list(range(1))
	305	if self.AcqDH_0>0.149:	305	if self.AcqDH_0 > 0.149:
	306	pulse_size = int(self.FixRCP_TXB/0.15+0.5)	306	pulse_size = int(self.FixRCP_TXB / 0.15 + 0.5)
	307	else:	307	else:
	308	pulse_size = int((self.FixRCP_TXB/self.AcqDH_0)+0.5) #0.0375	308	pulse_size = int((self.FixRCP_TXB / self.AcqDH_0) + 0.5) # 0.0375
	309	pulses[0] = numpy.ones(pulse_size)	309	pulses[0] = numpy.ones(pulse_size)
	310	pulses = 600*pulses[0]	310	pulses = 600 * pulses[0]
	311		311
	312	return pulses,pulse_size	312	return pulses, pulse_size
	313		313
	314	def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,	314	def jro_GenerateBlockOfData(self, Samples=Samples, DC_level=DC_level, stdev=stdev,
	315	Reference= Reference,pulses= pulses,	315	Reference=Reference, pulses=pulses,
	316	Num_Codes= Num_Codes,pulse_size=pulse_size,	316	Num_Codes=Num_Codes, pulse_size=pulse_size,
	317	prof_gen= prof_gen,H0 = H0,DH0=DH0,	317	prof_gen=prof_gen, H0=H0, DH0=DH0,
	318	Adoppler=Adoppler,Fdoppler= Fdoppler,Hdoppler=Hdoppler):	318	Adoppler=Adoppler, Fdoppler=Fdoppler, Hdoppler=Hdoppler):
	319	Samples = Samples	319	Samples = Samples
	320	DC_level = DC_level	320	DC_level = DC_level
	321	stdev = stdev	321	stdev = stdev
	322	m_nR = Reference	322	m_nR = Reference
	323	pulses = pulses	323	pulses = pulses
	324	num_codes = Num_Codes	324	num_codes = Num_Codes
	325	ps = pulse_size	325	ps = pulse_size
	326	prof_gen = prof_gen	326	prof_gen = prof_gen
	327	channels = self.channels	327	channels = self.channels
	328	H0 = H0	328	H0 = H0
	329	DH0 = DH0	329	DH0 = DH0
	330	ippSec = self.radarControllerHeaderObj.ippSeconds	330	ippSec = self.radarControllerHeaderObj.ippSeconds
	331	Fdoppler = self.Fdoppler	331	Fdoppler = self.Fdoppler
	332	Hdoppler = self.Hdoppler	332	Hdoppler = self.Hdoppler
	333	Adoppler = self.Adoppler	333	Adoppler = self.Adoppler
	334		334
	335	self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)	335	self.datablock = numpy.zeros([channels, prof_gen, Samples], dtype=numpy.complex64)
	336	for i in range(channels):	336	for i in range(channels):
	337	for k in range(prof_gen):	337	for k in range(prof_gen):
	338	#-----------------------NOISE---------------	338	#-----------------------NOISE---------------
	339	Noise_r = numpy.random.normal(DC_level,stdev,Samples)	339	Noise_r = numpy.random.normal(DC_level, stdev, Samples)
	340	Noise_i = numpy.random.normal(DC_level,stdev,Samples)	340	Noise_i = numpy.random.normal(DC_level, stdev, Samples)
	341	Noise = numpy.zeros(Samples,dtype=complex)	341	Noise = numpy.zeros(Samples, dtype=complex)
	342	Noise.real = Noise_r	342	Noise.real = Noise_r
	343	Noise.imag = Noise_i	343	Noise.imag = Noise_i
	344	#-----------------------PULSOS--------------	344	#-----------------------PULSOS--------------
	345	Pulso = numpy.zeros(pulse_size,dtype=complex)	345	Pulso = numpy.zeros(pulse_size, dtype=complex)
	346	Pulso.real = pulses[k%num_codes]	346	Pulso.real = pulses[k % num_codes]
	347	Pulso.imag = pulses[k%num_codes]	347	Pulso.imag = pulses[k % num_codes]
	348	#--------------------- PULSES+NOISE----------	348	#--------------------- PULSES+NOISE----------
	349	InBuffer = numpy.zeros(Samples,dtype=complex)	349	InBuffer = numpy.zeros(Samples, dtype=complex)
	350	InBuffer[m_nR:m_nR+ps] = Pulso	350	InBuffer[m_nR:m_nR + ps] = Pulso
	351	InBuffer = InBuffer+Noise	351	InBuffer = InBuffer + Noise
	352	#--------------------- ANGLE -------------------------------	352	#--------------------- ANGLE -------------------------------
	353	InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps](math.cos( self.fAngle)5)	353	InBuffer.real[m_nR:m_nR + ps] = InBuffer.real[m_nR:m_nR + ps] * (math.cos(self.fAngle) * 5)
	354	InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps](math.sin( self.fAngle)5)	354	InBuffer.imag[m_nR:m_nR + ps] = InBuffer.imag[m_nR:m_nR + ps] * (math.sin(self.fAngle) * 5)
	355	InBuffer=InBuffer	355	InBuffer = InBuffer
	356	self.datablock[i][k]= InBuffer	356	self.datablock[i][k] = InBuffer
	357		357
	358	#----------------DOPPLER SIGNAL...............................................	358	#----------------DOPPLER SIGNAL...............................................
	359	time_vec = numpy.linspace(0,(prof_gen-1)ippSec,int(prof_gen))+self.nReadBlocksippSecprof_gen+(self.nReadFiles-1)ippSec*prof_gen	359	time_vec = numpy.linspace(0, (prof_gen - 1) * ippSec, int(prof_gen)) + self.nReadBlocks * ippSec * prof_gen + (self.nReadFiles - 1) * ippSec * prof_gen
	360	fd = Fdoppler #+(600.0/120)*self.nReadBlocks	360	fd = Fdoppler # +(600.0/120)*self.nReadBlocks
	361	d_signal = Adopplernumpy.array(numpy.exp(1.0j2.0math.pifd*time_vec),dtype=numpy.complex64)	361	d_signal = Adoppler * numpy.array(numpy.exp(1.0j * 2.0 * math.pi * fd * time_vec), dtype=numpy.complex64)
	362	#-------------Senal con ancho espectral--------------------	362	#-------------Senal con ancho espectral--------------------
	363	if prof_gen%2==0:	363	if prof_gen % 2 == 0:
	364	min = int(prof_gen/2.0-1.0)	364	min = int(prof_gen / 2.0 - 1.0)
	365	max = int(prof_gen/2.0)	365	max = int(prof_gen / 2.0)
	366	else:	366	else:
	367	min = int(prof_gen/2.0)	367	min = int(prof_gen / 2.0)
	368	max = int(prof_gen/2.0)	368	max = int(prof_gen / 2.0)
	369	specw_sig = numpy.linspace(-min,max,prof_gen)	369	specw_sig = numpy.linspace(-min, max, prof_gen)
	370	w = 4	370	w = 4
	371	A = 20	371	A = 20
	372	specw_sig = specw_sig/w	372	specw_sig = specw_sig / w
	373	specw_sig = numpy.sinc(specw_sig)	373	specw_sig = numpy.sinc(specw_sig)
	374	specw_sig = A*numpy.array(specw_sig,dtype=numpy.complex64)	374	specw_sig = A * numpy.array(specw_sig, dtype=numpy.complex64)
	375	#------------------ DATABLOCK + DOPPLER--------------------	375	#------------------ DATABLOCK + DOPPLER--------------------
	376	HD=int(Hdoppler/self.AcqDH_0)	376	HD = int(Hdoppler / self.AcqDH_0)
	377	for i in range(12):	377	for i in range(12):
	378	self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ d_signal# RESULT	378	self.datablock[0, :, HD + i] = self.datablock[0, :, HD + i] + d_signal # RESULT
	379	#------------------ DATABLOCK + DOPPLER*Sinc(x)--------------------	379	#------------------ DATABLOCK + DOPPLER*Sinc(x)--------------------
	380	HD=int(Hdoppler/self.AcqDH_0)	380	HD = int(Hdoppler / self.AcqDH_0)
	381	HD=int(HD/2)	381	HD = int(HD / 2)
	382	for i in range(12):	382	for i in range(12):
	383	self.datablock[0,:,HD+i]=self.datablock[0,:,HD+i]+ specw_sig*d_signal# RESULT	383	self.datablock[0, :, HD + i] = self.datablock[0, :, HD + i] + specw_sig * d_signal # RESULT
	384		384
	385	def readBlock(self):	385	def readBlock(self):
	386		386
	387	self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,	387	self.jro_GenerateBlockOfData(Samples=self.samples, DC_level=self.DC_level,
	388	stdev=self.stdev,Reference= self.Reference,	388	stdev=self.stdev, Reference=self.Reference,
	389	pulses = self.pulses,Num_Codes=self.Num_Codes,	389	pulses=self.pulses, Num_Codes=self.Num_Codes,
	390	pulse_size=self.pulse_size,prof_gen=self.profiles,	390	pulse_size=self.pulse_size, prof_gen=self.profiles,
	391	H0=self.H0,DH0=self.DH0)	391	H0=self.H0, DH0=self.DH0)
	392		392
	393	self.profileIndex = 0	393	self.profileIndex = 0
	394	self.flagIsNewFile = 0	394	self.flagIsNewFile = 0
	395	self.flagIsNewBlock = 1	395	self.flagIsNewBlock = 1
	396	self.nTotalBlocks += 1	396	self.nTotalBlocks += 1
	397	self.nReadBlocks += 1	397	self.nReadBlocks += 1
	398		398
	399	return 1	399	return 1
	400		400
	@@ -404,11 +404,11 class SimulatorReader(JRODataReader, ProcessingUnit):
	404	self.dataOut.flagNodata = True	404	self.dataOut.flagNodata = True
	405	return 0	405	return 0
	406	self.flagDiscontinuousBlock = 0	406	self.flagDiscontinuousBlock = 0
	407	self.flagIsNewBlock = 0	407	self.flagIsNewBlock = 0
	408	if self.__hasNotDataInBuffer(): # aqui es verdad	408	if self.__hasNotDataInBuffer(): # aqui es verdad
	409	if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header	409	if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header
	410	return 0	410	return 0
	411	self.getFirstHeader() # atributo	411	self.getFirstHeader() # atributo
	412		412
	413	if not self.getByBlock:	413	if not self.getByBlock:
	414	self.dataOut.flagDataAsBlock = False	414	self.dataOut.flagDataAsBlock = False
	@@ -423,36 +423,36 class SimulatorReader(JRODataReader, ProcessingUnit):
	423	return self.dataOut.data	423	return self.dataOut.data
	424		424
	425		425
	426	def setup(self,frequency=49.92e6,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,	426	def setup(self, frequency=49.92e6, incIntFactor=1, nFFTPoints=0, FixPP_IncInt=1, FixRCP_IPP=1000,
	427	FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,	427	FixPP_CohInt=1, Tau_0=250, AcqH0_0=70 , AcqDH_0=1.25, Bauds=32,
	428	FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = ~~2.0~~math.pi(1/16),DC_level= 50,	428	FixRCP_TXA=40, FixRCP_TXB=50, fAngle=2.0 * math.pi * (1 / 16), DC_level=50,
	429	stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,	429	stdev=8, Num_Codes=1 , Dyn_snCode=None, samples=200,
	430	channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,	430	channels=2, Fdoppler=20, Hdoppler=36, Adoppler=500,
	431	profilesPerBlock=300,dataBlocksPerFile=120,nTotalReadFiles=10000,	431	profilesPerBlock=300, dataBlocksPerFile=120, nTotalReadFiles=10000,
	432	**kwargs):	432	**kwargs):
	433		433
	434	self.set_kwargs(**kwargs)	434	self.set_kwargs(**kwargs)
	435	self.nReadBlocks = 0	435	self.nReadBlocks = 0
	436	self.nReadFiles = 1	436	self.nReadFiles = 1
	437	print('------------------- [Opening file: ] ------------------------------',self.nReadFiles)	437	print('------------------- [Opening file: ] ------------------------------', self.nReadFiles)
	438		438
	439	tmp = time.time()	439	tmp = time.time()
	440	tmp_utc = int(tmp)	440	tmp_utc = int(tmp)
	441	tmp_milisecond = int((tmp-tmp_utc)*1000)	441	tmp_milisecond = int((tmp - tmp_utc) * 1000)
	442	print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))	442	print(" SETUP -basicHeaderObj.utc", datetime.datetime.utcfromtimestamp(tmp))
	443	if Dyn_snCode is None:	443	if Dyn_snCode is None:
	444	Num_Codes=1	444	Num_Codes = 1
	445	Bauds =1	445	Bauds = 1
	446		446
	447		447
	448		448
	449	self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )	449	self.set_BH(utc=tmp_utc, miliSecond=tmp_milisecond, timeZone=300)
	450	self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,	450	self.set_RCH(expType=0, nTx=150, ipp=FixRCP_IPP, txA=FixRCP_TXA, txB=FixRCP_TXB,
	451	nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,	451	nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
	452	numTaus=1, line6Function=0, line5Function=0, fClock=None,	452	numTaus=1, line6Function=0, line5Function=0, fClock=None,
	453	prePulseBefore=0, prePulseAfter=0,	453	prePulseBefore=0, prePulseAfter=0,
	454	codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,	454	codeType=0, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
	455	flip1=0, flip2=0,Taus=Tau_0)	455	flip1=0, flip2=0, Taus=Tau_0)
	456		456
	457	self.set_PH(dtype=0, blockSize=0, profilesPerBlock=profilesPerBlock,	457	self.set_PH(dtype=0, blockSize=0, profilesPerBlock=profilesPerBlock,
	458	dataBlocksPerFile=dataBlocksPerFile, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,	458	dataBlocksPerFile=dataBlocksPerFile, nWindows=1, processFlags=numpy.array([1024]), nCohInt=1,
	@@ -465,54 +465,54 class SimulatorReader(JRODataReader, ProcessingUnit):
	465		465
	466	self.readFirstHeader()	466	self.readFirstHeader()
	467		467
	468	self.frequency = frequency	468	self.frequency = frequency
	469	self.incIntFactor = incIntFactor	469	self.incIntFactor = incIntFactor
	470	self.nFFTPoints = nFFTPoints	470	self.nFFTPoints = nFFTPoints
	471	self.FixPP_IncInt = FixPP_IncInt	471	self.FixPP_IncInt = FixPP_IncInt
	472	self.FixRCP_IPP = FixRCP_IPP	472	self.FixRCP_IPP = FixRCP_IPP
	473	self.FixPP_CohInt = FixPP_CohInt	473	self.FixPP_CohInt = FixPP_CohInt
	474	self.Tau_0 = Tau_0	474	self.Tau_0 = Tau_0
	475	self.AcqH0_0 = AcqH0_0	475	self.AcqH0_0 = AcqH0_0
	476	self.H0 = AcqH0_0	476	self.H0 = AcqH0_0
	477	self.AcqDH_0 = AcqDH_0	477	self.AcqDH_0 = AcqDH_0
	478	self.DH0 = AcqDH_0	478	self.DH0 = AcqDH_0
	479	self.Bauds = Bauds	479	self.Bauds = Bauds
	480	self.FixRCP_TXA = FixRCP_TXA	480	self.FixRCP_TXA = FixRCP_TXA
	481	self.FixRCP_TXB = FixRCP_TXB	481	self.FixRCP_TXB = FixRCP_TXB
	482	self.fAngle = fAngle	482	self.fAngle = fAngle
	483	self.DC_level = DC_level	483	self.DC_level = DC_level
	484	self.stdev = stdev	484	self.stdev = stdev
	485	self.Num_Codes = Num_Codes	485	self.Num_Codes = Num_Codes
	486	self.Dyn_snCode = Dyn_snCode	486	self.Dyn_snCode = Dyn_snCode
	487	self.samples = samples	487	self.samples = samples
	488	self.channels = channels	488	self.channels = channels
	489	self.profiles = None	489	self.profiles = None
	490	self.m_nReference = None	490	self.m_nReference = None
	491	self.Baudwidth = None	491	self.Baudwidth = None
	492	self.Fdoppler = Fdoppler	492	self.Fdoppler = Fdoppler
	493	self.Hdoppler = Hdoppler	493	self.Hdoppler = Hdoppler
	494	self.Adoppler = Adoppler	494	self.Adoppler = Adoppler
	495	self.nTotalReadFiles = int(nTotalReadFiles)	495	self.nTotalReadFiles = int(nTotalReadFiles)
	496		496
	497	print("IPP ", self.FixRCP_IPP)	497	print("IPP ", self.FixRCP_IPP)
	498	print("Tau_0 ",self.Tau_0)	498	print("Tau_0 ", self.Tau_0)
	499	print("AcqH0_0",self.AcqH0_0)	499	print("AcqH0_0", self.AcqH0_0)
	500	print("samples,window ",self.samples)	500	print("samples,window ", self.samples)
	501	print("AcqDH_0",AcqDH_0)	501	print("AcqDH_0", AcqDH_0)
	502	print("FixRCP_TXA",self.FixRCP_TXA)	502	print("FixRCP_TXA", self.FixRCP_TXA)
	503	print("FixRCP_TXB",self.FixRCP_TXB)	503	print("FixRCP_TXB", self.FixRCP_TXB)
	504	print("Dyn_snCode",Dyn_snCode)	504	print("Dyn_snCode", Dyn_snCode)
	505	print("Fdoppler", Fdoppler)	505	print("Fdoppler", Fdoppler)
	506	print("Hdoppler",Hdoppler)	506	print("Hdoppler", Hdoppler)
	507	print("Vdopplermax",Fdoppler*(3.0e8/self.frequency)/2.0)	507	print("Vdopplermax", Fdoppler * (3.0e8 / self.frequency) / 2.0)
	508	print("nTotalReadFiles", nTotalReadFiles)	508	print("nTotalReadFiles", nTotalReadFiles)
	509		509
	510	self.init_acquisition()	510	self.init_acquisition()
	511	self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)	511	self.pulses, self.pulse_size = self.init_pulse(Num_Codes=self.Num_Codes, Bauds=self.Bauds, BaudWidth=self.BaudWidth, Dyn_snCode=Dyn_snCode)
	512	print(" [ END ] - SETUP metodo")	512	print(" [ END ] - SETUP metodo")
	513	return	513	return
	514		514
	515	def run(self,**kwargs): # metodo propio	515	def run(self, **kwargs): # metodo propio
	516	if not(self.isConfig):	516	if not(self.isConfig):
	517	self.setup(**kwargs)	517	self.setup(**kwargs)
	518	self.isConfig = True	518	self.isConfig = True

schainpy/model/io/jroIO_spectra.py +42 -42

                 """
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     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]:
+                        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.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
                     fpointer = self.fp.tell()
-                    spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
+                    spc = numpy.fromfile(self.fp, self.dtype[0], self.pts2read_SelfSpectra)
-                    spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
+                    spc = spc.reshape((self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock))  # transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
-                        cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
+                        cspc = numpy.fromfile(self.fp, self.dtype, self.pts2read_CrossSpectra)
-                        cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
+                        cspc = cspc.reshape((self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock))  # transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
-                        dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
+                        dc = numpy.fromfile(self.fp, self.dtype, self.pts2read_DCchannels)  # int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
-                        dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
+                        dc = dc.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights))  # transforma a un arreglo 2D
                     if not self.processingHeaderObj.shif_fft:
-                        #desplaza a la derecha en el eje 2 determinadas posiciones
+                        # desplaza a la derecha en el eje 2 determinadas posiciones
-                        shift = int(self.processingHeaderObj.profilesPerBlock/2)
+                        shift = int(self.processingHeaderObj.profilesPerBlock / 2)
-                        spc = numpy.roll( spc, shift , axis=2 )
+                        spc = numpy.roll(spc, shift , axis=2)
                         if self.processingHeaderObj.flag_cspc:
-                            #desplaza a la derecha en el eje 2 determinadas posiciones
+                            # desplaza a la derecha en el eje 2 determinadas posiciones
-                            cspc = numpy.roll( cspc, shift, axis=2 )
+                            cspc = numpy.roll(cspc, shift, axis=2)
-                    #Dimensions : nChannels, nProfiles, nSamples
+                    # Dimensions : nChannels, nProfiles, nSamples
-                    spc = numpy.transpose( spc, (0,2,1) )
+                    spc = numpy.transpose(spc, (0, 2, 1))
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
-                        cspc = numpy.transpose( cspc, (0,2,1) )
+                        cspc = numpy.transpose(cspc, (0, 2, 1))
-                        self.data_cspc = cspc['real'] + cspc['imag']*1j
+                        self.data_cspc = cspc['real'] + cspc['imag'] * 1j
                     else:
                         self.data_cspc = None
                     if self.processingHeaderObj.flag_dc:
-                        self.data_dc = dc['real'] + dc['imag']*1j
+                        self.data_dc = dc['real'] + dc['imag'] * 1j
                     else:
                         self.data_dc = None
                     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
+                    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 = list(range(self.systemHeaderObj.nChannels))
-                    self.dataOut.flagShiftFFT = True    #Data is always shifted
+                    self.dataOut.flagShiftFFT = True  # Data is always shifted
-                    self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
+                    self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode  # asumo q la data no esta decodificada
-                    self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data esta sin flip
+                    self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip  # asumo q la data esta sin flip
                 def getData(self):
                     """
                     if self.__hasNotDataInBuffer():
-                        if not( self.readNextBlock() ):
+                        if not(self.readNextBlock()):
                             self.dataOut.flagNoData = True
                             return 0
-                    #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
+                    # data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_spc is None:
                         self.dataOut.flagNoData = True
                     Return: None
                     """
-                    spc = numpy.transpose( self.data_spc, (0,2,1) )
+                    spc = numpy.transpose(self.data_spc, (0, 2, 1))
                     if not self.processingHeaderObj.shif_fft:
-                        spc = numpy.roll( spc, int(self.processingHeaderObj.profilesPerBlock/2), axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
+                        spc = numpy.roll(spc, int(self.processingHeaderObj.profilesPerBlock / 2), axis=2)  # desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data = data.astype(self.dtype[0])
                     data.tofile(self.fp)
                     if self.data_cspc is not None:
-                        cspc = numpy.transpose( self.data_cspc, (0,2,1) )
+                        cspc = numpy.transpose(self.data_cspc, (0, 2, 1))
-                        data = numpy.zeros( numpy.shape(cspc), self.dtype )
+                        data = numpy.zeros(numpy.shape(cspc), self.dtype)
-                        #print 'data.shape', self.shape_cspc_Buffer
+                        # print 'data.shape', self.shape_cspc_Buffer
                         if not self.processingHeaderObj.shif_fft:
-                            cspc = numpy.roll( cspc, int(self.processingHeaderObj.profilesPerBlock/2), axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
+                            cspc = numpy.roll(cspc, int(self.processingHeaderObj.profilesPerBlock / 2), axis=2)  # desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                     if self.data_dc is not None:
                         dc = self.data_dc
-                        data = numpy.zeros( numpy.shape(dc), self.dtype )
+                        data = numpy.zeros(numpy.shape(dc), self.dtype)
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                     pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
                     pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
-                    blocksize = (pts2write_SelfSpectra*dtype_width)
+                    blocksize = (pts2write_SelfSpectra * dtype_width)
                     if self.dataOut.data_cspc is not None:
                         pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
-                        blocksize += (pts2write_CrossSpectra*dtype_width*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*dtype_width*2)
+                        blocksize += (pts2write_DCchannels * dtype_width * 2)
             #         blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
-                    self.processingHeaderObj.dtype = 1 # Spectra
+                    self.processingHeaderObj.dtype = 1  # Spectra
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     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.nWindows = 1  # podria ser 1 o self.dataOut.processingHeaderObj.nWindows
-                    self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
+                    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
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
-                    self.setBasicHeader()
  No newline at end of file
+                    self.setBasicHeader()

schainpy/model/io/jroIO_usrp.py +67 -67

                 def __getCurrentSecond(self):
-                    return self.__thisUnixSample/self.__sample_rate
+                    return self.__thisUnixSample / self.__sample_rate
                 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
                     '''
                     In this method will be initialized every parameter of dataOut object (header, no data)
                     '''
-                    ippSeconds = 1.0*self.__nSamples/self.__sample_rate
+                    ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
-                    nProfiles = 1.0/ippSeconds  #Number of profiles in one second
+                    nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ipp=self.__ippKm,
                                                                                   txA=0,
                                                                                   deltaHeight=self.__deltaHeigth,
                                                                                   codeType=self.__codeType,
                                                                                   nCode=self.__nCode, nBaud=self.__nBaud,
-                                                                                  code = self.__code)
+                                                                                  code=self.__code)
                     self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                 nProfiles=nProfiles,
                     self.dataOut.data = None
-                    self.dataOut.dtype = numpy.dtype([('real','<i8'),('imag','<i8')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
             #        self.dataOut.nChannels = 0
                     self.dataOut.nProfiles = nProfiles
-                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
+                    self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype=numpy.float) * self.__deltaHeigth
                     self.dataOut.channelList = self.__channelList
                     self.dataOut.flagNoData = True
-                    #Set to TRUE if the data is discontinuous
+                    # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime = None
-                    self.dataOut.timeZone = self.__timezone/60  #timezone like jroheader, difference in minutes between UTC and localtime
+                    self.dataOut.timeZone = self.__timezone / 60  # timezone like jroheader, difference in minutes between UTC and localtime
                     self.dataOut.dstFlag = 0
                     self.dataOut.nCohInt = 1
-                    self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
+                    self.dataOut.flagDecodeData = False  # asumo que la data esta decodificada
-                    self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
+                    self.dataOut.flagDeflipData = False  # asumo que la data esta sin flip
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.ippSeconds = ippSeconds
-                    #Time interval between profiles
+                    # Time interval between profiles
-                    #self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
+                    # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.__frequency
                     except:
                         timezone = 0
-                    startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(channelNameList[0])/sample_rate - timezone
+                    startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(channelNameList[0]) / sample_rate - timezone
                     startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
                     endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
                     thisDatetime = startDatetime
-                    while(thisDatetime<=endDatatime):
+                    while(thisDatetime <= endDatatime):
                         thisDate = thisDatetime.date()
                     return dateList
-                def setup(self, path = None,
+                def setup(self, path=None,
-                                startDate = None,
+                                startDate=None,
-                                endDate = None,
+                                endDate=None,
-                                startTime = datetime.time(0,0,0),
+                                startTime=datetime.time(0, 0, 0),
-                                endTime = datetime.time(23,59,59),
+                                endTime=datetime.time(23, 59, 59),
-                                channelList = None,
+                                channelList=None,
-                                nSamples = None,
+                                nSamples=None,
-                                ippKm = 60,
+                                ippKm=60,
-                                online = False,
+                                online=False,
-                                delay = 60,
+                                delay=60,
-                                buffer_size = 1024,
+                                buffer_size=1024,
                                 **kwargs):
                     '''
                     In this method we should set all initial parameters.
                     '''
                     if not os.path.isdir(path):
-                        raise ValueError("[Reading] Directory %s does not exist" %path)
+                        raise ValueError("[Reading] Directory %s does not exist" % path)
                     try:
                         self.digitalReadObj = digital_rf_hdf5.read_hdf5(path, load_all_metadata=True)
                     channelNameList = self.digitalReadObj.get_channels()
                     if not channelNameList:
-                        raise ValueError("[Reading] Directory %s does not have any files" %path)
+                        raise ValueError("[Reading] Directory %s does not have any files" % path)
                     if not channelList:
                         channelList = list(range(len(channelNameList)))
                     self.__sample_rate = metadata_dict['sample_rate'][0]
             #         self.__samples_per_file = metadata_dict['samples_per_file'][0]
-                    self.__deltaHeigth = 1e6*0.15/self.__sample_rate
+                    self.__deltaHeigth = 1e6 * 0.15 / self.__sample_rate
                     this_metadata_file = self.digitalReadObj.get_metadata(channelNameList[channelList[0]])
                     if not ippKm:
                         try:
-                            #seconds to km
+                            # seconds to km
-                            ippKm = 1e6*0.15*this_metadata_file['ipp'].value
+                            ippKm = 1e6 * 0.15 * this_metadata_file['ipp'].value
                         except:
                             ippKm = None
                     if startDate:
                         startDatetime = datetime.datetime.combine(startDate, startTime)
-                        startUTCSecond = (startDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
+                        startUTCSecond = (startDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     if endDate:
                         endDatetime = datetime.datetime.combine(endDate, endTime)
-                        endUTCSecond = (endDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
+                        endUTCSecond = (endDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     start_index, end_index = self.digitalReadObj.get_bounds(channelNameList[channelList[0]])
                     if not startUTCSecond:
-                        startUTCSecond = start_index/self.__sample_rate
+                        startUTCSecond = start_index / self.__sample_rate
-                    if start_index > startUTCSecond*self.__sample_rate:
+                    if start_index > startUTCSecond * self.__sample_rate:
-                        startUTCSecond = start_index/self.__sample_rate
+                        startUTCSecond = start_index / self.__sample_rate
                     if not endUTCSecond:
-                        endUTCSecond = end_index/self.__sample_rate
+                        endUTCSecond = end_index / self.__sample_rate
-                    if end_index < endUTCSecond*self.__sample_rate:
+                    if end_index < endUTCSecond * self.__sample_rate:
-                        endUTCSecond = end_index/self.__sample_rate
+                        endUTCSecond = end_index / self.__sample_rate
                     if not nSamples:
                         if not ippKm:
                             raise ValueError("[Reading] nSamples or ippKm should be defined")
-                        nSamples = int(ippKm / (1e6*0.15/self.__sample_rate))
+                        nSamples = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
                     channelBoundList = []
                     channelNameListFiltered = []
                     for thisIndexChannel in channelList:
-                        thisChannelName =  channelNameList[thisIndexChannel]
+                        thisChannelName = channelNameList[thisIndexChannel]
                         start_index, end_index = self.digitalReadObj.get_bounds(thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.__channelNameList = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
                     self.__nSamples = nSamples
-                    self.__samples_to_read = int(buffer_size*nSamples)
+                    self.__samples_to_read = int(buffer_size * nSamples)
                     self.__nChannels = len(self.__channelList)
                     self.__startUTCSecond = startUTCSecond
                     self.__endUTCSecond = endUTCSecond
-                    self.__timeInterval = 1.0 * self.__samples_to_read/self.__sample_rate #Time interval
+                    self.__timeInterval = 1.0 * self.__samples_to_read / self.__sample_rate  # Time interval
                     if online:
             #             self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
                         startUTCSecond = numpy.floor(endUTCSecond)
-                    self.__thisUnixSample = int(startUTCSecond*self.__sample_rate) - self.__samples_to_read
+                    self.__thisUnixSample = int(startUTCSecond * self.__sample_rate) - self.__samples_to_read
-                    self.__data_buffer = numpy.zeros((self.__nChannels, self.__samples_to_read), dtype = numpy.complex)
+                    self.__data_buffer = numpy.zeros((self.__nChannels, self.__samples_to_read), dtype=numpy.complex)
                     self.__setFileHeader()
                     self.isConfig = True
-                    print("[Reading] USRP Data was found from %s to %s " %(
+                    print("[Reading] USRP Data was found from %s to %s " % (
                                                                   datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                                                                   datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                                                                   ))
-                    print("[Reading] Starting process from %s to %s" %(datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
+                    print("[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                        datetime.datetime.utcfromtimestamp(endUTCSecond - self.__timezone)
                                                                        ))
                     start_index, end_index = self.digitalReadObj.get_bounds(self.__channelNameList[self.__channelList[0]])
-                    if start_index > self.__startUTCSecond*self.__sample_rate:
+                    if start_index > self.__startUTCSecond * self.__sample_rate:
-                        self.__startUTCSecond = 1.0*start_index/self.__sample_rate
+                        self.__startUTCSecond = 1.0 * start_index / self.__sample_rate
-                    if end_index > self.__endUTCSecond*self.__sample_rate:
+                    if end_index > self.__endUTCSecond * self.__sample_rate:
-                        self.__endUTCSecond = 1.0*end_index/self.__sample_rate
+                        self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
                         print()
-                        print("[Reading] New timerange found [%s, %s] " %(
+                        print("[Reading] New timerange found [%s, %s] " % (
                                                                   datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                                                                   datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                                                                   ))
                     return False
-                def __readNextBlock(self, seconds=30, volt_scale = 218776):
+                def __readNextBlock(self, seconds=30, volt_scale=218776):
                     '''
                     '''
-                    #Set the next data
+                    # Set the next data
                     self.__flagDiscontinuousBlock = False
                     self.__thisUnixSample += self.__samples_to_read
-                    if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
+                    if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                         print("[Reading] There are no more data into selected time-range")
                         self.__reload()
-                        if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
+                        if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
-                            self.__thisUnixSample -=  self.__samples_to_read
+                            self.__thisUnixSample -= self.__samples_to_read
                             return False
                     indexChannel = 0
                                                                           thisChannelName)
                         except IOError as e:
-                            #read next profile
+                            # read next profile
                             self.__flagDiscontinuousBlock = True
-                            print("[Reading] %s" %datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
+                            print("[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
                             break
                         if result.shape[0] != self.__samples_to_read:
                             self.__flagDiscontinuousBlock = True
-                            print("[Reading] %s: Too few samples were found, just %d/%d  samples" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
+                            print("[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                             result.shape[0],
                                                                                             self.__samples_to_read))
                             break
-                        self.__data_buffer[indexChannel,:] = result*volt_scale
+                        self.__data_buffer[indexChannel, :] = result * volt_scale
                         indexChannel += 1
                         dataOk = True
-                    self.__utctime = self.__thisUnixSample/self.__sample_rate
+                    self.__utctime = self.__thisUnixSample / self.__sample_rate
                     if not dataOk:
                         return False
-                    print("[Reading] %s: %d samples <> %f sec" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
+                    print("[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                      self.__samples_to_read,
                                                                      self.__timeInterval))
                             if self.__readNextBlock():
                                 break
-                            if self.__thisUnixSample > self.__endUTCSecond*self.__sample_rate:
+                            if self.__thisUnixSample > self.__endUTCSecond * self.__sample_rate:
                                 return False
                             if self.__flagDiscontinuousBlock:
                             if err_counter > nTries:
                                 return False
-                            print('[Reading] waiting %d seconds to read a new block' %seconds)
+                            print('[Reading] waiting %d seconds to read a new block' % seconds)
                             sleep(seconds)
-                    self.dataOut.data = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex+self.__nSamples]
+                    self.dataOut.data = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
-                    self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex)/self.__sample_rate
+                    self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
                     self.dataOut.flagNoData = False
                     self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
                     self.dataOut.profileIndex = self.profileIndex
                 while True:
                     readObj.run(path='/Volumes/DATA/haystack/passive_radar/')
             #         readObj.printInfo()
-                    readObj.printNumberOfBlock()
  No newline at end of file
+                    readObj.printNumberOfBlock()

schainpy/model/io/jroIO_usrp_api.py +5 -5

             #     __isBufferEmpty = True
-                __DATAKEYLIST = ['data','utctime','flagNoData']
+                __DATAKEYLIST = ['data', 'utctime', 'flagNoData']
                 def __init__(self, serializer='msgpack'):
                         return None
                     myMetadataSerial = obj2Serial(self.dataOut,
-                                                  serializer = self.__serializer)
+                                                  serializer=self.__serializer)
                     return myMetadataSerial
                         print(".", end=' ')
                         self.__mySerial = obj2Serial(self.dataOut,
-                                                     keyList = self.__DATAKEYLIST,
+                                                     keyList=self.__DATAKEYLIST,
-                                                     serializer = self.__serializer)
+                                                     serializer=self.__serializer)
                         self.__isBufferEmpty = False
             #             print self.profileIndex
                     print("Closing thread")
-                    return
  No newline at end of file
+                    return

schainpy/model/io/jroIO_voltage.py +8 -8

                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.lastUTTime = 0
-                    self.profileIndex = 2**32 - 1
+                    self.profileIndex = 2 ** 32 - 1
                     self.dataOut = Voltage()
                     self.selBlocksize = None
                     self.selBlocktime = None
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
-                    #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
+                    # self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                                 blockIndex = self.selBlocksize - datasize
                                 datablock1 = self.datablock[:, :blockIndex, :]
                                 buffer[:, datasize:datasize +
                                        datablock1.shape[1], :] = datablock1
                                 datasize += datablock1.shape[1]
                 shapeBuffer = None
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Return: None
                     """
-                    Operation.__init__(self)#, **kwargs)
+                    Operation.__init__(self)  # , **kwargs)
                     self.nTotalBlocks = 0
                     dtype_width = self.getDtypeWidth()
                     blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels *
                                     self.profilesPerBlock * dtype_width * 2)
                     return blocksize
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
                     self.setBasicHeader()
-  No newline at end of file

schainpy/model/io/julIO_param.py +19 -19

                 ('navg', 'f'),
                 ('fh', 'f'),
                 ('dh', 'f'),
                 ('nheights', 'f'),
                 ('ipp', 'f')
             ])
                           path=None,
                           startDate=None,
                           endDate=None,
                           ext=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           timezone=0,
                             continue
                         year, month, day = int(year), int(month), int(day)
-                        dateFile = datetime.date(year+2000, month, day)
+                        dateFile = datetime.date(year + 2000, month, day)
                         if (startDate > dateFile) or (endDate < dateFile):
                             continue
                         nheights = int(self.header_rec['nheights'])
                         hours = float(self.header_rec['hours'][0])
                         heights = numpy.arange(nheights) * self.dH + self.header_rec['h0']
-                        datatime = datetime.datetime(self.year, 1, 1) + datetime.timedelta(days=self.doy-1, hours=hours)
+                        datatime = datetime.datetime(self.year, 1, 1) + datetime.timedelta(days=self.doy - 1, hours=hours)
                         return heights, datatime
                     else:
                         return False
                     Parse data
                     '''
-                    buffer = numpy.fromfile(self.fp, 'f', 8*N).reshape(N, 8)
+                    buffer = numpy.fromfile(self.fp, 'f', 8 * N).reshape(N, 8)
                     pow0 = buffer[:, 0]
                     pow1 = buffer[:, 1]
-                    acf0 = (buffer[:,2] + buffer[:,3]*1j) / pow0
+                    acf0 = (buffer[:, 2] + buffer[:, 3] * 1j) / pow0
-                    acf1 = (buffer[:,4] + buffer[:,5]*1j) / pow1
+                    acf1 = (buffer[:, 4] + buffer[:, 5] * 1j) / pow1
-                    dccf = (buffer[:,6] + buffer[:,7]*1j) / (pow0*pow1)
+                    dccf = (buffer[:, 6] + buffer[:, 7] * 1j) / (pow0 * pow1)
-                    ### SNR
+                    # ## SNR
                     sno = (pow0 + pow1 - self.header_rec['snr']) / self.header_rec['snr']
                     sno10 = numpy.log10(sno)
                     # dsno = 1.0 / numpy.sqrt(self.header_file['nint'] * self.header_file['navg']) * (1 + (1 / sno))
-                    ### Vertical Drift
+                    # ## Vertical Drift
-                    sp = numpy.sqrt(numpy.abs(acf0)*numpy.abs(acf1))
+                    sp = numpy.sqrt(numpy.abs(acf0) * numpy.abs(acf1))
                     sp[numpy.where(numpy.abs(sp) >= 1.0)] = numpy.sqrt(0.9999)
-                    vzo = -numpy.arctan2(acf0.imag + acf1.imag,acf0.real + acf1.real)*1.5E5*1.5/(self.ipp*numpy.pi)
+                    vzo = -numpy.arctan2(acf0.imag + acf1.imag, acf0.real + acf1.real) * 1.5E5 * 1.5 / (self.ipp * numpy.pi)
-                    dvzo = numpy.sqrt(1.0 - sp*sp)*0.338*1.5E5/(numpy.sqrt(self.header_file['nint']*self.header_file['navg'])*sp*self.ipp)
+                    dvzo = numpy.sqrt(1.0 - sp * sp) * 0.338 * 1.5E5 / (numpy.sqrt(self.header_file['nint'] * self.header_file['navg']) * sp * self.ipp)
                     err = numpy.where(dvzo <= 0.1)
                     dvzo[err] = 0.1
-                    #Zonal Drifts
+                    # Zonal Drifts
-                    dt = self.header_file['nint']*self.ipp / 1.5E5
+                    dt = self.header_file['nint'] * self.ipp / 1.5E5
                     coh = numpy.sqrt(numpy.abs(dccf))
                     err = numpy.where(coh >= 1.0)
                     coh[err] = numpy.sqrt(0.99999)
                     err = numpy.where(coh <= 0.1)
                     coh[err] = numpy.sqrt(0.1)
-                    vxo = numpy.arctan2(dccf.imag, dccf.real)*self.header_rec['h0']*1.0E3/(self.kd*dt)
+                    vxo = numpy.arctan2(dccf.imag, dccf.real) * self.header_rec['h0'] * 1.0E3 / (self.kd * dt)
-                    dvxo = numpy.sqrt(1.0 - coh*coh)*self.header_rec['h0']*1.0E3/(numpy.sqrt(self.header_file['nint']*self.header_file['navg'])*coh*self.kd*dt)
+                    dvxo = numpy.sqrt(1.0 - coh * coh) * self.header_rec['h0'] * 1.0E3 / (numpy.sqrt(self.header_file['nint'] * self.header_file['navg']) * coh * self.kd * dt)
                     err = numpy.where(dvxo <= 0.1)
                     dvxo[err] = 0.1
                     self.dataOut.data_snr = self.buffer[4].reshape(1, -1)
                     self.dataOut.heightList = self.heights
-                    self.dataOut.data_param = self.buffer[0:4,]
+                    self.dataOut.data_param = self.buffer[0:4, ]
                     self.dataOut.utctimeInit = self.time
                     self.dataOut.utctime = self.time
                     self.dataOut.useLocalTime = True
                     self.set_output()
-                    return 1
  No newline at end of file
+                    return 1

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

                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
-                    self.datatime = datetime.datetime(1900,1,1)
+                    self.datatime = datetime.datetime(1900, 1, 1)
                     self.walk = walk
                     self.nTries = kwargs.get('nTries', 10)
                     self.online = kwargs.get('online', False)

schainpy/model/proc/bltrproc_parameters.py +73 -73

                     self.dataOut.heightList = self.dataOut.height[0]
                     self.dataOut.data_snr = self.dataOut.data_snr[mode]
                     SNRavg = numpy.average(self.dataOut.data_snr, axis=0)
-                    SNRavgdB = 10*numpy.log10(SNRavg)
+                    SNRavgdB = 10 * numpy.log10(SNRavg)
                     self.dataOut.data_snr_avg_db = SNRavgdB.reshape(1, *SNRavgdB.shape)
                     # Censoring Data
                         nvalues_valid = len(numpy.where(numpy.isfinite(value_temp[h]))[0])
                         minvalid = npoints
-                        #only if valid values greater than the minimum required (10%)
+                        # only if valid values greater than the minimum required (10%)
                         if nvalues_valid > minvalid:
                             if method == 0:
-                                #SMOOTH
+                                # SMOOTH
                                 w = value_temp[h] - self.Smooth(input=value_temp[h], width=npoints, edge_truncate=1)
                             if method == 1:
-                                #MEDIAN
+                                # MEDIAN
-                                w = value_temp[h] - self.Median(input=value_temp[h], width = npoints)
+                                w = value_temp[h] - self.Median(input=value_temp[h], width=npoints)
-                            dw = numpy.std(w[numpy.where(numpy.isfinite(w))],ddof = 1)
+                            dw = numpy.std(w[numpy.where(numpy.isfinite(w))], ddof=1)
-                            threshold = dw*factor
+                            threshold = dw * factor
-                            value_temp[numpy.where(w > threshold),h] = numpy.nan
+                            value_temp[numpy.where(w > threshold), h] = numpy.nan
-                            value_temp[numpy.where(w < -1*threshold),h] = numpy.nan
+                            value_temp[numpy.where(w < -1 * threshold), h] = numpy.nan
-                    #At the end
+                    # At the end
                     if svalue2 == 'inHeight':
                         value_temp = numpy.transpose(value_temp)
-                    output_array[:,m] = value_temp
+                    output_array[:, m] = value_temp
                     if svalue == 'zonal':
                         self.dataOut.data_output[0] = output_array
                     return self.dataOut.data_output
-                def Median(self,input,width):
+                def Median(self, input, width):
                     '''
                     Inputs:
                         input - Velocity array
                     '''
-                    if numpy.mod(width,2) == 1:
+                    if numpy.mod(width, 2) == 1:
                         pc = int((width - 1) / 2)
                     cont = 0
                     output = []
                     for i in range(len(input)):
                         if i >= pc and i < len(input) - pc:
-                            new2 = input[i-pc:i+pc+1]
+                            new2 = input[i - pc:i + pc + 1]
                             temp = numpy.where(numpy.isfinite(new2))
                             new = new2[temp]
                             value = numpy.median(new)
                             output.append(value)
                     output = numpy.array(output)
-                    output = numpy.hstack((input[0:pc],output))
+                    output = numpy.hstack((input[0:pc], output))
-                    output = numpy.hstack((output,input[-pc:len(input)]))
+                    output = numpy.hstack((output, input[-pc:len(input)]))
                     return output
-                def Smooth(self,input,width,edge_truncate = None):
+                def Smooth(self, input, width, edge_truncate=None):
                     '''
                     Inputs:
                         input - Velocity array
                     '''
-                    if numpy.mod(width,2) == 0:
+                    if numpy.mod(width, 2) == 0:
                         real_width = width + 1
                         nzeros = width / 2
                     else:
                         real_width = width
                         nzeros = (width - 1) / 2
-                    half_width = int(real_width)/2
+                    half_width = int(real_width) / 2
                     length = len(input)
-                    gate = numpy.ones(real_width,dtype='float')
+                    gate = numpy.ones(real_width, dtype='float')
                     norm_of_gate = numpy.sum(gate)
                     nan_process = 0
                         input[nan_id] = 0.
                     if edge_truncate == True:
-                        output = numpy.convolve(input/norm_of_gate,gate,mode='same')
+                        output = numpy.convolve(input / norm_of_gate, gate, mode='same')
                     elif edge_truncate == False or edge_truncate == None:
-                        output = numpy.convolve(input/norm_of_gate,gate,mode='valid')
+                        output = numpy.convolve(input / norm_of_gate, gate, mode='valid')
-                        output = numpy.hstack((input[0:half_width],output))
+                        output = numpy.hstack((input[0:half_width], output))
-                        output = numpy.hstack((output,input[len(input)-half_width:len(input)]))
+                        output = numpy.hstack((output, input[len(input) - half_width:len(input)]))
                     if nan_process:
-                        pb = numpy.convolve(pb/norm_of_gate,gate,mode='valid')
+                        pb = numpy.convolve(pb / norm_of_gate, gate, mode='valid')
-                        pb = numpy.hstack((numpy.zeros(half_width),pb))
+                        pb = numpy.hstack((numpy.zeros(half_width), pb))
-                        pb = numpy.hstack((pb,numpy.zeros(half_width)))
+                        pb = numpy.hstack((pb, numpy.zeros(half_width)))
                         output[numpy.where(pb > 0.9999)] = numpy.nan
                         input[nan_id] = numpy.nan
                     return output
-                def Average(self,aver=0,nhaver=1):
+                def Average(self, aver=0, nhaver=1):
                     '''
                     Inputs:
                         aver - Indicates the time period over which is averaged or consensus data
                     lat_huancayo = -12.04
                     lat_porcuya = -5.8
-                    if '%2.2f'%self.dataOut.lat == '%2.2f'%lat_piura:
+                    if '%2.2f' % self.dataOut.lat == '%2.2f' % lat_piura:
                         hcm = 3.
                         if self.dataOut.year == 2003 :
                             if self.dataOut.doy >= 25 and self.dataOut.doy < 64:
                                 nhpoints = 12
-                    elif '%2.2f'%self.dataOut.lat == '%2.2f'%lat_huancayo:
+                    elif '%2.2f' % self.dataOut.lat == '%2.2f' % lat_huancayo:
                         hcm = 3.
                         if self.dataOut.year == 2003 :
                             if self.dataOut.doy >= 25 and self.dataOut.doy < 64:
                                 nhpoints = 12
-                    elif '%2.2f'%self.dataOut.lat == '%2.2f'%lat_porcuya:
+                    elif '%2.2f' % self.dataOut.lat == '%2.2f' % lat_porcuya:
-                        hcm = 5.#2
+                        hcm = 5.  # 2
                     pdata = 0.2
-                    taver = [1,2,3,4,6,8,12,24]
+                    taver = [1, 2, 3, 4, 6, 8, 12, 24]
                     t0 = 0
                     tf = 24
-                    ntime =(tf-t0)/taver[aver]
+                    ntime = (tf - t0) / taver[aver]
                     ti = numpy.arange(ntime)
                     tf = numpy.arange(ntime) + taver[aver]
                     old_height = self.dataOut.heightList
                     if nhaver > 1:
-                        num_hei = len(self.dataOut.heightList)/nhaver/self.dataOut.nmodes
+                        num_hei = len(self.dataOut.heightList) / nhaver / self.dataOut.nmodes
-                        deltha = 0.05*nhaver
+                        deltha = 0.05 * nhaver
-                        minhvalid = pdata*nhaver
+                        minhvalid = pdata * nhaver
                         for im in range(self.dataOut.nmodes):
-                            new_height = numpy.arange(num_hei)*deltha + self.dataOut.height[im,0] + deltha/2.
+                            new_height = numpy.arange(num_hei) * deltha + self.dataOut.height[im, 0] + deltha / 2.
                     data_fHeigths_List = []
                     for i in range(ntime):
                         height = old_height
-                        start = datetime.datetime(self.dataOut.year,self.dataOut.month,self.dataOut.day) + datetime.timedelta(hours = int(ti[i])) - datetime.timedelta(hours = 5)
+                        start = datetime.datetime(self.dataOut.year, self.dataOut.month, self.dataOut.day) + datetime.timedelta(hours=int(ti[i])) - datetime.timedelta(hours=5)
-                        stop = datetime.datetime(self.dataOut.year,self.dataOut.month,self.dataOut.day) + datetime.timedelta(hours = int(tf[i])) - datetime.timedelta(hours = 5)
+                        stop = datetime.datetime(self.dataOut.year, self.dataOut.month, self.dataOut.day) + datetime.timedelta(hours=int(tf[i])) - datetime.timedelta(hours=5)
                         limit_sec1 = time.mktime(start.timetuple())
                                 time_select.append(val_sec)
-                        time_select = numpy.array(time_select,dtype = 'int')
+                        time_select = numpy.array(time_select, dtype='int')
-                        minvalid = numpy.ceil(pdata*nhpoints)
+                        minvalid = numpy.ceil(pdata * nhpoints)
-                        zon_aver = numpy.zeros([self.dataOut.nranges,self.dataOut.nmodes],dtype='f4') + numpy.nan
+                        zon_aver = numpy.zeros([self.dataOut.nranges, self.dataOut.nmodes], dtype='f4') + numpy.nan
-                        mer_aver = numpy.zeros([self.dataOut.nranges,self.dataOut.nmodes],dtype='f4') + numpy.nan
+                        mer_aver = numpy.zeros([self.dataOut.nranges, self.dataOut.nmodes], dtype='f4') + numpy.nan
-                        ver_aver = numpy.zeros([self.dataOut.nranges,self.dataOut.nmodes],dtype='f4') + numpy.nan
+                        ver_aver = numpy.zeros([self.dataOut.nranges, self.dataOut.nmodes], dtype='f4') + numpy.nan
                         if nhaver > 1:
-                            new_zon_aver = numpy.zeros([num_hei,self.dataOut.nmodes],dtype='f4') + numpy.nan
+                            new_zon_aver = numpy.zeros([num_hei, self.dataOut.nmodes], dtype='f4') + numpy.nan
-                            new_mer_aver = numpy.zeros([num_hei,self.dataOut.nmodes],dtype='f4') + numpy.nan
+                            new_mer_aver = numpy.zeros([num_hei, self.dataOut.nmodes], dtype='f4') + numpy.nan
-                            new_ver_aver = numpy.zeros([num_hei,self.dataOut.nmodes],dtype='f4') + numpy.nan
+                            new_ver_aver = numpy.zeros([num_hei, self.dataOut.nmodes], dtype='f4') + numpy.nan
                         if len(time_select) > minvalid:
                             time_average = self.f_timesec[time_select]
                             for im in range(self.dataOut.nmodes):
                                 for ih in range(self.dataOut.nranges):
-                                    if numpy.sum(numpy.isfinite(self.f_zon[time_select,ih,im])) >= minvalid:
+                                    if numpy.sum(numpy.isfinite(self.f_zon[time_select, ih, im])) >= minvalid:
-                                        zon_aver[ih,im] = numpy.nansum(self.f_zon[time_select,ih,im]) / numpy.sum(numpy.isfinite(self.f_zon[time_select,ih,im]))
+                                        zon_aver[ih, im] = numpy.nansum(self.f_zon[time_select, ih, im]) / numpy.sum(numpy.isfinite(self.f_zon[time_select, ih, im]))
-                                    if numpy.sum(numpy.isfinite(self.f_mer[time_select,ih,im])) >= minvalid:
+                                    if numpy.sum(numpy.isfinite(self.f_mer[time_select, ih, im])) >= minvalid:
-                                        mer_aver[ih,im] = numpy.nansum(self.f_mer[time_select,ih,im]) / numpy.sum(numpy.isfinite(self.f_mer[time_select,ih,im]))
+                                        mer_aver[ih, im] = numpy.nansum(self.f_mer[time_select, ih, im]) / numpy.sum(numpy.isfinite(self.f_mer[time_select, ih, im]))
-                                    if numpy.sum(numpy.isfinite(self.f_ver[time_select,ih,im])) >= minvalid:
+                                    if numpy.sum(numpy.isfinite(self.f_ver[time_select, ih, im])) >= minvalid:
-                                        ver_aver[ih,im] = numpy.nansum(self.f_ver[time_select,ih,im]) / numpy.sum(numpy.isfinite(self.f_ver[time_select,ih,im]))
+                                        ver_aver[ih, im] = numpy.nansum(self.f_ver[time_select, ih, im]) / numpy.sum(numpy.isfinite(self.f_ver[time_select, ih, im]))
                                 if nhaver > 1:
                                     for ih in range(num_hei):
-                                        hvalid = numpy.arange(nhaver) + nhaver*ih
+                                        hvalid = numpy.arange(nhaver) + nhaver * ih
-                                        if numpy.sum(numpy.isfinite(zon_aver[hvalid,im])) >= minvalid:
+                                        if numpy.sum(numpy.isfinite(zon_aver[hvalid, im])) >= minvalid:
-                                            new_zon_aver[ih,im] = numpy.nansum(zon_aver[hvalid,im]) /  numpy.sum(numpy.isfinite(zon_aver[hvalid,im]))
+                                            new_zon_aver[ih, im] = numpy.nansum(zon_aver[hvalid, im]) / numpy.sum(numpy.isfinite(zon_aver[hvalid, im]))
-                                        if numpy.sum(numpy.isfinite(mer_aver[hvalid,im])) >= minvalid:
+                                        if numpy.sum(numpy.isfinite(mer_aver[hvalid, im])) >= minvalid:
-                                            new_mer_aver[ih,im] = numpy.nansum(mer_aver[hvalid,im]) /  numpy.sum(numpy.isfinite(mer_aver[hvalid,im]))
+                                            new_mer_aver[ih, im] = numpy.nansum(mer_aver[hvalid, im]) / numpy.sum(numpy.isfinite(mer_aver[hvalid, im]))
-                                        if numpy.sum(numpy.isfinite(ver_aver[hvalid,im])) >= minvalid:
+                                        if numpy.sum(numpy.isfinite(ver_aver[hvalid, im])) >= minvalid:
-                                            new_ver_aver[ih,im] = numpy.nansum(ver_aver[hvalid,im]) /  numpy.sum(numpy.isfinite(ver_aver[hvalid,im]))
+                                            new_ver_aver[ih, im] = numpy.nansum(ver_aver[hvalid, im]) / numpy.sum(numpy.isfinite(ver_aver[hvalid, im]))
                             if nhaver > 1:
                                 zon_aver = new_zon_aver
                                 mer_aver = new_mer_aver
                             minute = startTime.tm_min
                             second = startTime.tm_sec
-                            startDTList.append(datetime.datetime(year,month,day,hour,minute,second))
+                            startDTList.append(datetime.datetime(year, month, day, hour, minute, second))
                             o_height = numpy.array([])
                                 for im in range(self.dataOut.nmodes):
                                     if im == 0:
-                                        h_select = numpy.where(numpy.bitwise_and(height[0,:] >=0,height[0,:] <= hcm,numpy.isfinite(height[0,:])))
+                                        h_select = numpy.where(numpy.bitwise_and(height[0, :] >= 0, height[0, :] <= hcm, numpy.isfinite(height[0, :])))
                                     else:
-                                        h_select = numpy.where(numpy.bitwise_and(height[1,:] > hcm,height[1,:] < 20,numpy.isfinite(height[1,:])))
+                                        h_select = numpy.where(numpy.bitwise_and(height[1, :] > hcm, height[1, :] < 20, numpy.isfinite(height[1, :])))
                                     ht = h_select[0]
-                                    o_height = numpy.hstack((o_height,height[im,ht]))
+                                    o_height = numpy.hstack((o_height, height[im, ht]))
-                                    o_zon_aver = numpy.hstack((o_zon_aver,zon_aver[ht,im]))
+                                    o_zon_aver = numpy.hstack((o_zon_aver, zon_aver[ht, im]))
-                                    o_mer_aver = numpy.hstack((o_mer_aver,mer_aver[ht,im]))
+                                    o_mer_aver = numpy.hstack((o_mer_aver, mer_aver[ht, im]))
-                                    o_ver_aver = numpy.hstack((o_ver_aver,ver_aver[ht,im]))
+                                    o_ver_aver = numpy.hstack((o_ver_aver, ver_aver[ht, im]))
                                 data_fHeigths_List.append(o_height)
                                 data_fZonal_List.append(o_zon_aver)
                             else:
-                                h_select = numpy.where(numpy.bitwise_and(height[0,:] <= hcm,numpy.isfinite(height[0,:])))
+                                h_select = numpy.where(numpy.bitwise_and(height[0, :] <= hcm, numpy.isfinite(height[0, :])))
                                 ht = h_select[0]
-                                o_height = numpy.hstack((o_height,height[im,ht]))
+                                o_height = numpy.hstack((o_height, height[im, ht]))
-                                o_zon_aver = numpy.hstack((o_zon_aver,zon_aver[ht,im]))
+                                o_zon_aver = numpy.hstack((o_zon_aver, zon_aver[ht, im]))
-                                o_mer_aver = numpy.hstack((o_mer_aver,mer_aver[ht,im]))
+                                o_mer_aver = numpy.hstack((o_mer_aver, mer_aver[ht, im]))
-                                o_ver_aver = numpy.hstack((o_ver_aver,ver_aver[ht,im]))
+                                o_ver_aver = numpy.hstack((o_ver_aver, ver_aver[ht, im]))
                                 data_fHeigths_List.append(o_height)
                                 data_fZonal_List.append(o_zon_aver)

schainpy/model/proc/jroproc_amisr.py +10 -10

                 def run(self, dataOut):
                     if not self.__isPrinted:
-                        print('Number of Records by File: %d'%dataOut.nRecords)
+                        print('Number of Records by File: %d' % dataOut.nRecords)
-                        print('Number of Pulses: %d'%dataOut.nProfiles)
+                        print('Number of Pulses: %d' % dataOut.nProfiles)
-                        print('Number of Pulses by Frame: %d'%dataOut.npulseByFrame)
+                        print('Number of Pulses by Frame: %d' % dataOut.npulseByFrame)
-                        print('Number of Samples by Pulse: %d'%len(dataOut.heightList))
+                        print('Number of Samples by Pulse: %d' % len(dataOut.heightList))
-                        print('Ipp Seconds: %f'%dataOut.ippSeconds)
+                        print('Ipp Seconds: %f' % dataOut.ippSeconds)
-                        print('Number of Beams: %d'%dataOut.nBeams)
+                        print('Number of Beams: %d' % dataOut.nBeams)
                         print('BeamCodes:')
-                        beamStrList = ['Beam %d -> Code=%d, azimuth=%2.2f,  zenith=%2.2f, gain=%2.2f'%(k,v[0],v[1],v[2],v[3]) for k,v in list(dataOut.beamCodeDict.items())]
+                        beamStrList = ['Beam %d -> Code=%d, azimuth=%2.2f,  zenith=%2.2f, gain=%2.2f' % (k, v[0], v[1], v[2], v[3]) for k, v in list(dataOut.beamCodeDict.items())]
                         for b in beamStrList:
                             print(b)
                         self.__isPrinted = True
                     if not(self.__isConfig):
                         nchannels = len(list(dataOut.beamRangeDict.keys()))
                         nsamples = dataOut.nHeights
-                        self.buffer = numpy.zeros((nchannels, nsamples), dtype = 'complex128')
+                        self.buffer = numpy.zeros((nchannels, nsamples), dtype='complex128')
                         dataOut.beam.codeList = [dataOut.beamCodeDict[x][0] for x in range(nchannels)]
                         dataOut.beam.azimuthList = [dataOut.beamCodeDict[x][1] for x in range(nchannels)]
                         dataOut.beam.zenithList = [dataOut.beamCodeDict[x][2] for x in range(nchannels)]
                     for i in range(self.buffer.shape[0]):
                         if dataOut.profileIndex in dataOut.beamRangeDict[i]:
-                            self.buffer[i,:] = dataOut.data
+                            self.buffer[i, :] = dataOut.data
                             break
                         self.__isConfig = False
                         dataOut.flagNoData = False
                     pass
-  No newline at end of file

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

                     def close(self):
                         BaseClass.close(self)
-                        log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
+                        log.success('Done...(Time:{:4.2f} secs)'.format(time.time() - self.start_time), self.name)
                 return MPClass

schainpy/model/proc/jroproc_correlation.py +31 -31

                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
-                    self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
             #         self.dataOut.nHeights = self.dataIn.nHeights
             #         self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
             #        self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.firstdatatime
-                    self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
+                    self.dataOut.flagDecodeData = self.dataIn.flagDecodeData  # asumo q la data esta decodificada
-                    self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
+                    self.dataOut.flagDeflipData = self.dataIn.flagDeflipData  # asumo q la data esta sin flip
                     self.dataOut.nCohInt = self.dataIn.nCohInt
             #        self.dataOut.nIncohInt = 1
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     nChannel = jspectra.shape[0]
                     for i in range(nChannel):
-                        jspectra_tmp = jspectra[i,:,:]
+                        jspectra_tmp = jspectra[i, :, :]
-                        jspectra_DC = numpy.mean(jspectra_tmp,axis = 0)
+                        jspectra_DC = numpy.mean(jspectra_tmp, axis=0)
                         jspectra_tmp = jspectra_tmp - jspectra_DC
-                        jspectra[i,:,:] = jspectra_tmp
+                        jspectra[i, :, :] = jspectra_tmp
                     return jspectra
-                def removeNoise(self, mode = 2):
+                def removeNoise(self, mode=2):
                     indR = numpy.where(self.dataOut.lagR == 0)[0][0]
                     indT = numpy.where(self.dataOut.lagT == 0)[0][0]
-                    jspectra = self.dataOut.data_corr[:,:,indR,:]
+                    jspectra = self.dataOut.data_corr[:, :, indR, :]
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = indT
-                    ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
+                    ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     NPot = self.dataOut.getNoise(mode)
-                    jspectra[:,freq_dc,:] = jspectra[:,freq_dc,:] - NPot
+                    jspectra[:, freq_dc, :] = jspectra[:, freq_dc, :] - NPot
-                    SPot = jspectra[:,freq_dc,:]
+                    SPot = jspectra[:, freq_dc, :]
                     pairsAutoCorr = self.dataOut.getPairsAutoCorr()
             #         self.dataOut.signalPotency = SPot
                     self.dataOut.noise = NPot
-                    self.dataOut.SNR = (SPot/NPot)[pairsAutoCorr]
+                    self.dataOut.SNR = (SPot / NPot)[pairsAutoCorr]
-                    self.dataOut.data_corr[:,:,indR,:] = jspectra
+                    self.dataOut.data_corr[:, :, indR, :] = jspectra
                     return 1
-                def run(self, lags=None, mode = 'time',  pairsList=None, fullBuffer=False, nAvg = 1, removeDC = False, splitCF=False):
+                def run(self, lags=None, mode='time', pairsList=None, fullBuffer=False, nAvg=1, removeDC=False, splitCF=False):
                     self.dataOut.flagNoData = True
             #             acf_pairs = numpy.arange(len(ccfList),len(pairsList))
                         self.__updateObjFromVoltage()
                         #----------------------------------------------------------------------
-                        #Creating temporal buffers
+                        # Creating temporal buffers
                         if fullBuffer:
-                            tmp = numpy.zeros((len(pairsList), len(lags), nProfiles, nHeights), dtype = 'complex')*numpy.nan
+                            tmp = numpy.zeros((len(pairsList), len(lags), nProfiles, nHeights), dtype='complex') * numpy.nan
                         elif mode == 'time':
                             if lags == None:
-                                lags = numpy.arange(-nProfiles+1, nProfiles)
+                                lags = numpy.arange(-nProfiles + 1, nProfiles)
-                            tmp = numpy.zeros((len(pairsList), len(lags), nHeights),dtype='complex')
+                            tmp = numpy.zeros((len(pairsList), len(lags), nHeights), dtype='complex')
                         elif mode == 'height':
                             if lags == None:
-                                lags = numpy.arange(-nHeights+1, nHeights)
+                                lags = numpy.arange(-nHeights + 1, nHeights)
-                            tmp = numpy.zeros(len(pairsList), (len(lags), nProfiles),dtype='complex')
+                            tmp = numpy.zeros(len(pairsList), (len(lags), nProfiles), dtype='complex')
-                        #For loop
+                        # For loop
                         for l in range(len(pairsList)):
                             ch0 = pairsList[l][0]
                                 if idx >= 0:
                                     if mode == 'time':
-                                        ccf0 = data_pre[ch0,:nProfiles-idx,:]*numpy.conj(data_pre[ch1,idx:,:]) #time
+                                        ccf0 = data_pre[ch0, :nProfiles - idx, :] * numpy.conj(data_pre[ch1, idx:, :])  # time
                                     else:
-                                        ccf0 = data_pre[ch0,:,nHeights-idx]*numpy.conj(data_pre[ch1,:,idx:])   #heights
+                                        ccf0 = data_pre[ch0, :, nHeights - idx] * numpy.conj(data_pre[ch1, :, idx:])  # heights
                                 else:
                                     if mode == 'time':
-                                        ccf0 = data_pre[ch0,-idx:,:]*numpy.conj(data_pre[ch1,:nProfiles+idx,:])  #time
+                                        ccf0 = data_pre[ch0, -idx:, :] * numpy.conj(data_pre[ch1, :nProfiles + idx, :])  # time
                                     else:
-                                        ccf0 = data_pre[ch0,:,-idx:]*numpy.conj(data_pre[ch1,:,:nHeights+idx])   #heights
+                                        ccf0 = data_pre[ch0, :, -idx:] * numpy.conj(data_pre[ch1, :, :nHeights + idx])  # heights
                                 if fullBuffer:
-                                    tmp[l,i,:ccf0.shape[0],:] = ccf0
+                                    tmp[l, i, :ccf0.shape[0], :] = ccf0
                                 else:
-                                    tmp[l,i,:] = numpy.sum(ccf0, axis=0)
+                                    tmp[l, i, :] = numpy.sum(ccf0, axis=0)
                         #-----------------------------------------------------------------
                         if fullBuffer:
-                            tmp = numpy.sum(numpy.reshape(tmp,(tmp.shape[0],tmp.shape[1],tmp.shape[2]/nAvg,nAvg,tmp.shape[3])),axis=3)
+                            tmp = numpy.sum(numpy.reshape(tmp, (tmp.shape[0], tmp.shape[1], tmp.shape[2] / nAvg, nAvg, tmp.shape[3])), axis=3)
                             self.dataOut.nAvg = nAvg
                         self.dataOut.data_cf = tmp
                         self.dataOut.pairsList = pairsList
                         self.dataOut.nPairs = len(pairsList)
-                        #Se Calcula los factores de Normalizacion
+                        # Se Calcula los factores de Normalizacion
                         if mode == 'time':
-                            delta = self.dataIn.ippSeconds*self.dataIn.nCohInt
+                            delta = self.dataIn.ippSeconds * self.dataIn.nCohInt
                         else:
                             delta = self.dataIn.heightList[1] - self.dataIn.heightList[0]
-                        self.dataOut.lagRange = numpy.array(lags)*delta
+                        self.dataOut.lagRange = numpy.array(lags) * delta
             #             self.dataOut.nCohInt = self.dataIn.nCohInt*nAvg
                         self.dataOut.flagNoData = False
             #             a = self.dataOut.normFactor

schainpy/model/proc/jroproc_heispectra.py +24 -24

             class SpectraHeisProc(ProcessingUnit):
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
-                    ProcessingUnit.__init__(self)#, **kwargs)
+                    ProcessingUnit.__init__(self)  # , **kwargs)
             #        self.buffer = None
             #        self.firstdatatime = None
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
-                    self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()#
+                    self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()  #
-                    self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()#
+                    self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()  #
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
             #        self.dataOut.dtype = self.dataIn.dtype
-                    self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
+                    self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
             #        self.dataOut.nHeights = self.dataIn.nHeights
             #        self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.dataIn.utctime
             #        self.dataOut.utctime = self.firstdatatime
-                    self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
+                    self.dataOut.flagDecodeData = self.dataIn.flagDecodeData  # asumo q la data esta decodificada
-                    self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
+                    self.dataOut.flagDeflipData = self.dataIn.flagDeflipData  # asumo q la data esta sin flip
             #        self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                 def __getFft(self):
                     fft_volt = numpy.fft.fft(self.dataIn.data, axis=1)
-                    fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
+                    fft_volt = numpy.fft.fftshift(fft_volt, axes=(1,))
-                    spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))/(self.dataOut.nFFTPoints)
+                    spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt)) / (self.dataOut.nFFTPoints)
                     self.dataOut.data_spc = spc
                 def run(self):
                         return
-                    raise ValueError("The type object %s is not valid"%(self.dataIn.type))
+                    raise ValueError("The type object %s is not valid" % (self.dataIn.type))
                 def selectChannels(self, channelList):
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
+                            raise ValueError("The value %d in channelIndexList is not valid" % channelIndex)
-                    data_spc = self.dataOut.data_spc[channelIndexList,:]
+                    data_spc = self.dataOut.data_spc[channelIndexList, :]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                 isConfig = False
                 __profIndex = 0
-                __withOverapping  = False
+                __withOverapping = False
                 __byTime = False
                 __initime = None
                 n = None
-                def __init__(self):#, **kwargs):
+                def __init__(self):  # , **kwargs):
-                    Operation.__init__(self)#, **kwargs)
+                    Operation.__init__(self)  # , **kwargs)
             #         self.isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                         self.n = n
                         self.__byTime = False
                     else:
-                        self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
+                        self.__integrationtime = timeInterval  # * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                         self.__profIndex += 1
                         return
-                    #Overlapping data
+                    # Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
-                    #If the buffer is empty then it takes the data value
+                    # If the buffer is empty then it takes the data value
                     if self.__buffer is None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
-                    #If the buffer length is lower than n then stakcing the data value
+                    # If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
-                    #If the buffer length is equal to n then replacing the last buffer value with the data value
+                    # If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
-                    self.__buffer[self.n-1] = data
+                    self.__buffer[self.n - 1] = data
                     self.__profIndex = self.n
                     return
                         return data, n
-                    #Integration with Overlapping
+                    # Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     n = self.__profIndex
                     avgdatatime = self.__initime
-                    deltatime = datatime -self.__lastdatatime
+                    deltatime = datatime - self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
             #            dataOut.timeInterval = self.__timeInterval*self.n
                         dataOut.flagNoData = False
-                    return dataOut
  No newline at end of file
+                    return dataOut

schainpy/model/proc/jroproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_spectra.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_spectra_acf.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_spectra_lags.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_voltage.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/pxproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/utils/jroutils_ftp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/utils/jroutils_publish.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/utils/scp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/JASMET30_MetDet.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/JASMET30_PhaseCal.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/JASMET30_Winds.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/PPD.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/USRP_PLOT_THOR.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/julia_mp.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/optimun_offset.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/pedestal_client.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/pedestal_server.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_001.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_002.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0001.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim00010.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0002.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0003.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0004.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0005.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0006.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0007.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0008.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/test_sim0009.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/wr_integrador.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

setup.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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