schain-jc Commit - r1090:36f30f86830d

fixing merge conflicts

jespinoza -

r1090:36f30f86830d

parent child

Context file:

r1090:36f30f86830d

Expand all files

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

schainpy/model/io/jroIO_digitalRF.py created 644 +751 0

This diff has been collapsed as it changes many lines, (751 lines changed) Show them Hide them
	@@ -0,0 +1,751
		1
		2	'''
		3	Created on Jul 3, 2014
		4
		5	@author: roj-idl71
		6	'''
		7	# SUBCHANNELS EN VEZ DE CHANNELS
		8	# BENCHMARKS -> PROBLEMAS CON ARCHIVOS GRANDES -> INCONSTANTE EN EL TIEMPO
		9	# ACTUALIZACION DE VERSION
		10	# HEADERS
		11	# MODULO DE ESCRITURA
		12	# METADATA
		13
		14	import os
		15	import datetime
		16	import numpy
		17	import timeit
		18	from profilehooks import coverage, profile
		19	from fractions import Fraction
		20
		21	try:
		22	from gevent import sleep
		23	except:
		24	from time import sleep
		25
		26	from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
		27	from schainpy.model.data.jrodata import Voltage
		28	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
		29	from time import time
		30
		31	import cPickle
		32	try:
		33	import digital_rf
		34	except:
		35	print 'You should install "digital_rf" module if you want to read Digital RF data'
		36
		37	class DigitalRFReader(ProcessingUnit):
		38	'''
		39	classdocs
		40	'''
		41
		42	def __init__(self, **kwargs):
		43	'''
		44	Constructor
		45	'''
		46
		47	ProcessingUnit.__init__(self, **kwargs)
		48
		49	self.dataOut = Voltage()
		50	self.__printInfo = True
		51	self.__flagDiscontinuousBlock = False
		52	self.__bufferIndex = 9999999
		53	self.__ippKm = None
		54	self.__codeType = 0
		55	self.__nCode = None
		56	self.__nBaud = None
		57	self.__code = None
		58	self.dtype = None
		59
		60	def close(self):
		61	print 'Average of writing to digital rf format is ', self.oldAverage * 1000
		62	return
		63
		64	def __getCurrentSecond(self):
		65
		66	return self.__thisUnixSample/self.__sample_rate
		67
		68	thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
		69
		70	def __setFileHeader(self):
		71	'''
		72	In this method will be initialized every parameter of dataOut object (header, no data)
		73	'''
		74	ippSeconds = 1.0*self.__nSamples/self.__sample_rate
		75
		76	nProfiles = 1.0/ippSeconds # Number of profiles in one second
		77
		78	try:
		79	self.dataOut.radarControllerHeaderObj = RadarControllerHeader(self.__radarControllerHeader)
		80	except:
		81	self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
		82	txA=0,
		83	txB=0,
		84	nWindows=1,
		85	nHeights=self.__nSamples,
		86	firstHeight=self.__firstHeigth,
		87	deltaHeight=self.__deltaHeigth,
		88	codeType=self.__codeType,
		89	nCode=self.__nCode, nBaud=self.__nBaud,
		90	code = self.__code)
		91
		92	try:
		93	self.dataOut.systemHeaderObj = SystemHeader(self.__systemHeader)
		94	except:
		95	self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
		96	nProfiles=nProfiles,
		97	nChannels=len(self.__channelList),
		98	adcResolution=14)
		99	self.dataOut.type = "Voltage"
		100
		101	self.dataOut.data = None
		102
		103	self.dataOut.dtype = self.dtype
		104
		105	# self.dataOut.nChannels = 0
		106
		107	# self.dataOut.nHeights = 0
		108
		109	self.dataOut.nProfiles = int(nProfiles)
		110
		111	self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
		112
		113	self.dataOut.channelList = range(self.__num_subchannels)
		114
		115	self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
		116
		117	# self.dataOut.channelIndexList = None
		118
		119	self.dataOut.flagNoData = True
		120
		121	self.dataOut.flagDataAsBlock = False
		122	# Set to TRUE if the data is discontinuous
		123	self.dataOut.flagDiscontinuousBlock = False
		124
		125	self.dataOut.utctime = None
		126
		127	self.dataOut.timeZone = self.__timezone/60 # timezone like jroheader, difference in minutes between UTC and localtime
		128
		129	self.dataOut.dstFlag = 0
		130
		131	self.dataOut.errorCount = 0
		132
		133	try:
		134	self.dataOut.nCohInt = self.fixed_metadata_dict.get('nCohInt', 1)
		135
		136	self.dataOut.flagDecodeData = self.fixed_metadata_dict['flagDecodeData'] # asumo que la data esta decodificada
		137
		138	self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData'] # asumo que la data esta sin flip
		139
		140	self.dataOut.flagShiftFFT = self.fixed_metadata_dict['flagShiftFFT']
		141
		142	self.dataOut.useLocalTime = self.fixed_metadata_dict['useLocalTime']
		143	except:
		144	pass
		145
		146
		147	self.dataOut.ippSeconds = ippSeconds
		148
		149	# Time interval between profiles
		150	# self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
		151
		152	self.dataOut.frequency = self.__frequency
		153
		154	self.dataOut.realtime = self.__online
		155
		156	def findDatafiles(self, path, startDate=None, endDate=None):
		157
		158	if not os.path.isdir(path):
		159	return []
		160
		161	try:
		162	digitalReadObj = digital_rf.DigitalRFReader(path, load_all_metadata=True)
		163	except:
		164	digitalReadObj = digital_rf.DigitalRFReader(path)
		165
		166	channelNameList = digitalReadObj.get_channels()
		167
		168	if not channelNameList:
		169	return []
		170
		171	metadata_dict = digitalReadObj.get_rf_file_metadata(channelNameList[0])
		172
		173	sample_rate = metadata_dict['sample_rate'][0]
		174
		175	this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
		176
		177	try:
		178	timezone = this_metadata_file['timezone'].value
		179	except:
		180	timezone = 0
		181
		182	startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(channelNameList[0])/sample_rate - timezone
		183
		184	startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
		185	endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
		186
		187	if not startDate:
		188	startDate = startDatetime.date()
		189
		190	if not endDate:
		191	endDate = endDatatime.date()
		192
		193	dateList = []
		194
		195	thisDatetime = startDatetime
		196
		197	while(thisDatetime<=endDatatime):
		198
		199	thisDate = thisDatetime.date()
		200
		201	if thisDate < startDate:
		202	continue
		203
		204	if thisDate > endDate:
		205	break
		206
		207	dateList.append(thisDate)
		208	thisDatetime += datetime.timedelta(1)
		209
		210	return dateList
		211
		212	def setup(self, path = None,
		213	startDate = None,
		214	endDate = None,
		215	startTime = datetime.time(0,0,0),
		216	endTime = datetime.time(23,59,59),
		217	channelList = None,
		218	nSamples = None,
		219	online = False,
		220	delay = 60,
		221	buffer_size = 1024,
		222	ippKm=None,
		223	**kwargs):
		224	'''
		225	In this method we should set all initial parameters.
		226
		227	Inputs:
		228	path
		229	startDate
		230	endDate
		231	startTime
		232	endTime
		233	set
		234	expLabel
		235	ext
		236	online
		237	delay
		238	'''
		239	self.i = 0
		240	if not os.path.isdir(path):
		241	raise ValueError, "[Reading] Directory %s does not exist" %path
		242
		243	try:
		244	self.digitalReadObj = digital_rf.DigitalRFReader(path, load_all_metadata=True)
		245	except:
		246	self.digitalReadObj = digital_rf.DigitalRFReader(path)
		247
		248	channelNameList = self.digitalReadObj.get_channels()
		249
		250	if not channelNameList:
		251	raise ValueError, "[Reading] Directory %s does not have any files" %path
		252
		253	if not channelList:
		254	channelList = range(len(channelNameList))
		255
		256
		257	########## Reading metadata ######################
		258
		259	top_properties = self.digitalReadObj.get_properties(channelNameList[channelList[0]])
		260
		261
		262	self.__num_subchannels = top_properties['num_subchannels']
		263	self.__sample_rate = 1.0 * top_properties['sample_rate_numerator'] / top_properties['sample_rate_denominator']
		264	# self.__samples_per_file = top_properties['samples_per_file'][0]
		265	self.__deltaHeigth = 1e6*0.15/self.__sample_rate ## why 0.15?
		266
		267	this_metadata_file = self.digitalReadObj.get_digital_metadata(channelNameList[channelList[0]])
		268	metadata_bounds = this_metadata_file.get_bounds()
		269	self.fixed_metadata_dict = this_metadata_file.read(metadata_bounds[0])[metadata_bounds[0]] ## GET FIRST HEADER
		270
		271	try:
		272	self.__processingHeader = self.fixed_metadata_dict['processingHeader']
		273	self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
		274	self.__systemHeader = self.fixed_metadata_dict['systemHeader']
		275	self.dtype = cPickle.loads(self.fixed_metadata_dict['dtype'])
		276	except:
		277	pass
		278
		279
		280	self.__frequency = None
		281
		282	self.__frequency = self.fixed_metadata_dict.get('frequency', 1)
		283
		284	self.__timezone = self.fixed_metadata_dict.get('timezone', 300)
		285
		286
		287	try:
		288	nSamples = self.fixed_metadata_dict['nSamples']
		289	except:
		290	nSamples = None
		291
		292	self.__firstHeigth = 0
		293
		294	try:
		295	codeType = self.__radarControllerHeader['codeType']
		296	except:
		297	codeType = 0
		298
		299	nCode = 1
		300	nBaud = 1
		301	code = numpy.ones((nCode, nBaud), dtype=numpy.int)
		302
		303	try:
		304	if codeType:
		305	nCode = self.__radarControllerHeader['nCode']
		306	nBaud = self.__radarControllerHeader['nBaud']
		307	code = self.__radarControllerHeader['code']
		308	except:
		309	pass
		310
		311
		312	if not ippKm:
		313	try:
		314	# seconds to km
		315	ippKm = self.__radarControllerHeader['ipp']
		316	except:
		317	ippKm = None
		318	####################################################
		319	self.__ippKm = ippKm
		320	startUTCSecond = None
		321	endUTCSecond = None
		322
		323	if startDate:
		324	startDatetime = datetime.datetime.combine(startDate, startTime)
		325	startUTCSecond = (startDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
		326
		327	if endDate:
		328	endDatetime = datetime.datetime.combine(endDate, endTime)
		329	endUTCSecond = (endDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
		330
		331	start_index, end_index = self.digitalReadObj.get_bounds(channelNameList[channelList[0]])
		332
		333	if not startUTCSecond:
		334	startUTCSecond = start_index/self.__sample_rate
		335
		336	if start_index > startUTCSecond*self.__sample_rate:
		337	startUTCSecond = start_index/self.__sample_rate
		338
		339	if not endUTCSecond:
		340	endUTCSecond = end_index/self.__sample_rate
		341
		342	if end_index < endUTCSecond*self.__sample_rate:
		343	endUTCSecond = end_index/self.__sample_rate
		344	if not nSamples:
		345	if not ippKm:
		346	raise ValueError, "[Reading] nSamples or ippKm should be defined"
		347	nSamples = int(ippKm / (1e6*0.15/self.__sample_rate))
		348	channelBoundList = []
		349	channelNameListFiltered = []
		350
		351	for thisIndexChannel in channelList:
		352	thisChannelName = channelNameList[thisIndexChannel]
		353	start_index, end_index = self.digitalReadObj.get_bounds(thisChannelName)
		354	channelBoundList.append((start_index, end_index))
		355	channelNameListFiltered.append(thisChannelName)
		356
		357	self.profileIndex = 0
		358	self.i= 0
		359	self.__delay = delay
		360
		361	self.__codeType = codeType
		362	self.__nCode = nCode
		363	self.__nBaud = nBaud
		364	self.__code = code
		365
		366	self.__datapath = path
		367	self.__online = online
		368	self.__channelList = channelList
		369	self.__channelNameList = channelNameListFiltered
		370	self.__channelBoundList = channelBoundList
		371	self.__nSamples = nSamples
		372	self.__samples_to_read = long(nSamples) # FIJO: AHORA 40
		373	self.__nChannels = len(self.__channelList)
		374
		375	self.__startUTCSecond = startUTCSecond
		376	self.__endUTCSecond = endUTCSecond
		377
		378	self.__timeInterval = 1.0 * self.__samples_to_read/self.__sample_rate # Time interval
		379
		380	if online:
		381	# self.__thisUnixSample = int(endUTCSecondself.__sample_rate - 4self.__samples_to_read)
		382	startUTCSecond = numpy.floor(endUTCSecond)
		383
		384	self.__thisUnixSample = long(startUTCSecond*self.__sample_rate) - self.__samples_to_read ## por que en el otro metodo lo primero q se hace es sumar samplestoread
		385
		386	self.__data_buffer = numpy.zeros((self.__num_subchannels, self.__samples_to_read), dtype = numpy.complex)
		387
		388	self.__setFileHeader()
		389	self.isConfig = True
		390
		391	print "[Reading] Digital RF Data was found from %s to %s " %(
		392	datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
		393	datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
		394	)
		395
		396	print "[Reading] Starting process from %s to %s" %(datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
		397	datetime.datetime.utcfromtimestamp(endUTCSecond - self.__timezone)
		398	)
		399	self.oldAverage = None
		400	self.count = 0
		401	self.executionTime = 0
		402	def __reload(self):
		403	# print
		404	# print "%s not in range [%s, %s]" %(
		405	# datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
		406	# datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
		407	# datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
		408	# )
		409	print "[Reading] reloading metadata ..."
		410
		411	try:
		412	self.digitalReadObj.reload(complete_update=True)
		413	except:
		414	self.digitalReadObj.reload()
		415
		416	start_index, end_index = self.digitalReadObj.get_bounds(self.__channelNameList[self.__channelList[0]])
		417
		418	if start_index > self.__startUTCSecond*self.__sample_rate:
		419	self.__startUTCSecond = 1.0*start_index/self.__sample_rate
		420
		421	if end_index > self.__endUTCSecond*self.__sample_rate:
		422	self.__endUTCSecond = 1.0*end_index/self.__sample_rate
		423	print
		424	print "[Reading] New timerange found [%s, %s] " %(
		425	datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
		426	datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
		427	)
		428
		429	return True
		430
		431	return False
		432
		433	def timeit(self, toExecute):
		434	t0 = time()
		435	toExecute()
		436	self.executionTime = time() - t0
		437	if self.oldAverage is None: self.oldAverage = self.executionTime
		438	self.oldAverage = (self.executionTime + self.count*self.oldAverage) / (self.count + 1.0)
		439	self.count = self.count + 1.0
		440	return
		441
		442	def __readNextBlock(self, seconds=30, volt_scale = 1):
		443	'''
		444	'''
		445
		446	# Set the next data
		447	self.__flagDiscontinuousBlock = False
		448	self.__thisUnixSample += self.__samples_to_read
		449
		450	if self.__thisUnixSample + 2self.__samples_to_read > self.__endUTCSecondself.__sample_rate:
		451	print "[Reading] There are no more data into selected time-range"
		452	if self.__online:
		453	self.__reload()
		454	else:
		455	return False
		456
		457	if self.__thisUnixSample + 2self.__samples_to_read > self.__endUTCSecondself.__sample_rate:
		458	return False
		459	self.__thisUnixSample -= self.__samples_to_read
		460
		461	indexChannel = 0
		462
		463	dataOk = False
		464	for thisChannelName in self.__channelNameList: ##TODO VARIOS CHANNELS?
		465	for indexSubchannel in range(self.__num_subchannels):
		466	try:
		467	t0 = time()
		468	result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
		469	self.__samples_to_read,
		470	thisChannelName, sub_channel=indexSubchannel)
		471	self.executionTime = time() - t0
		472	if self.oldAverage is None: self.oldAverage = self.executionTime
		473	self.oldAverage = (self.executionTime + self.count*self.oldAverage) / (self.count + 1.0)
		474	self.count = self.count + 1.0
		475
		476	except IOError, e:
		477	#read next profile
		478	self.__flagDiscontinuousBlock = True
		479	print "[Reading] %s" %datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e
		480	break
		481
		482	if result.shape[0] != self.__samples_to_read:
		483	self.__flagDiscontinuousBlock = True
		484	print "[Reading] %s: Too few samples were found, just %d/%d samples" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
		485	result.shape[0],
		486	self.__samples_to_read)
		487	break
		488
		489	self.__data_buffer[indexSubchannel,:] = result*volt_scale
		490
		491	indexChannel += 1
		492
		493	dataOk = True
		494
		495	self.__utctime = self.__thisUnixSample/self.__sample_rate
		496
		497	if not dataOk:
		498	return False
		499
		500	print "[Reading] %s: %d samples <> %f sec" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
		501	self.__samples_to_read,
		502	self.__timeInterval)
		503
		504	self.__bufferIndex = 0
		505
		506	return True
		507
		508	def __isBufferEmpty(self):
		509	return self.__bufferIndex > self.__samples_to_read - self.__nSamples #40960 - 40
		510
		511	def getData(self, seconds=30, nTries=5):
		512
		513	'''
		514	This method gets the data from files and put the data into the dataOut object
		515
		516	In addition, increase el the buffer counter in one.
		517
		518	Return:
		519	data : retorna un perfil de voltages (alturas * canales) copiados desde el
		520	buffer. Si no hay mas archivos a leer retorna None.
		521
		522	Affected:
		523	self.dataOut
		524	self.profileIndex
		525	self.flagDiscontinuousBlock
		526	self.flagIsNewBlock
		527	'''
		528
		529	err_counter = 0
		530	self.dataOut.flagNoData = True
		531
		532	if self.__isBufferEmpty():
		533	self.__flagDiscontinuousBlock = False
		534
		535	while True:
		536	if self.__readNextBlock():
		537	break
		538	if self.__thisUnixSample > self.__endUTCSecond*self.__sample_rate:
		539	return False
		540
		541	if self.__flagDiscontinuousBlock:
		542	print '[Reading] discontinuous block found ... continue with the next block'
		543	continue
		544
		545	if not self.__online:
		546	return False
		547
		548	err_counter += 1
		549	if err_counter > nTries:
		550	return False
		551
		552	print '[Reading] waiting %d seconds to read a new block' %seconds
		553	sleep(seconds)
		554
		555	self.dataOut.data = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex+self.__nSamples]
		556	self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex)/self.__sample_rate
		557	self.dataOut.flagNoData = False
		558	self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
		559	self.dataOut.profileIndex = self.profileIndex
		560
		561	self.__bufferIndex += self.__nSamples
		562	self.profileIndex += 1
		563
		564	if self.profileIndex == self.dataOut.nProfiles:
		565	self.profileIndex = 0
		566
		567	return True
		568
		569	def printInfo(self):
		570	'''
		571	'''
		572	if self.__printInfo == False:
		573	return
		574
		575	# self.systemHeaderObj.printInfo()
		576	# self.radarControllerHeaderObj.printInfo()
		577
		578	self.__printInfo = False
		579
		580	def printNumberOfBlock(self):
		581	'''
		582	'''
		583	return
		584	# print self.profileIndex
		585
		586
		587	def run(self, **kwargs):
		588	'''
		589	This method will be called many times so here you should put all your code
		590	'''
		591
		592	if not self.isConfig:
		593	self.setup(**kwargs)
		594	#self.i = self.i+1
		595	self.getData(seconds=self.__delay)
		596
		597	return
		598
		599	class DigitalRFWriter(Operation):
		600	'''
		601	classdocs
		602	'''
		603
		604	def __init__(self, **kwargs):
		605	'''
		606	Constructor
		607	'''
		608	Operation.__init__(self, **kwargs)
		609	self.metadata_dict = {}
		610	self.dataOut = None
		611	self.dtype = None
		612
		613	def setHeader(self):
		614
		615	self.metadata_dict['frequency'] = self.dataOut.frequency
		616	self.metadata_dict['timezone'] = self.dataOut.timeZone
		617	self.metadata_dict['dtype'] = cPickle.dumps(self.dataOut.dtype)
		618	self.metadata_dict['nProfiles'] = self.dataOut.nProfiles
		619	self.metadata_dict['heightList'] = self.dataOut.heightList
		620	self.metadata_dict['channelList'] = self.dataOut.channelList
		621	self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
		622	self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
		623	self.metadata_dict['flagShiftFFT'] = self.dataOut.flagShiftFFT
		624	self.metadata_dict['flagDataAsBlock'] = self.dataOut.flagDataAsBlock
		625	self.metadata_dict['useLocalTime'] = self.dataOut.useLocalTime
		626	self.metadata_dict['nCohInt'] = self.dataOut.nCohInt
		627
		628	return
		629
		630	def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
		631	'''
		632	In this method we should set all initial parameters.
		633	Input:
		634	dataOut: Input data will also be outputa data
		635	'''
		636	self.setHeader()
		637	self.__ippSeconds = dataOut.ippSeconds
		638	self.__deltaH = dataOut.getDeltaH()
		639	self.__sample_rate = 1e6*0.15/self.__deltaH
		640	self.__dtype = dataOut.dtype
		641	if len(dataOut.dtype) == 2:
		642	self.__dtype = dataOut.dtype[0]
		643	self.__nSamples = dataOut.systemHeaderObj.nSamples
		644	self.__nProfiles = dataOut.nProfiles
		645	self.__blocks_per_file = dataOut.processingHeaderObj.dataBlocksPerFile
		646
		647	self.arr_data = arr_data = numpy.ones((self.__nSamples, len(self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
		648
		649	file_cadence_millisecs = long(1.0 * self.__blocks_per_file * self.__nProfiles * self.__nSamples / self.__sample_rate) * 1000
		650	sub_cadence_secs = file_cadence_millisecs / 500
		651
		652	sample_rate_fraction = Fraction(self.__sample_rate).limit_denominator()
		653	sample_rate_numerator = long(sample_rate_fraction.numerator)
		654	sample_rate_denominator = long(sample_rate_fraction.denominator)
		655	start_global_index = dataOut.utctime * self.__sample_rate
		656
		657	uuid = 'prueba'
		658	compression_level = 1
		659	checksum = False
		660	is_complex = True
		661	num_subchannels = len(dataOut.channelList)
		662	is_continuous = True
		663	marching_periods = False
		664
		665	self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
		666	fileCadence, start_global_index,
		667	sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
		668	is_complex, num_subchannels, is_continuous, marching_periods)
		669
		670	metadata_dir = os.path.join(path, 'metadata')
		671	os.system('mkdir %s' % (metadata_dir))
		672
		673	self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1, ##236, file_cadence_millisecs / 1000
		674	sample_rate_numerator, sample_rate_denominator,
		675	metadataFile)
		676
		677
		678	self.isConfig = True
		679	self.currentSample = 0
		680	self.oldAverage = 0
		681	self.count = 0
		682	return
		683
		684	def writeMetadata(self):
		685	print '[Writing] - Writing metadata'
		686	start_idx = self.__sample_rate * self.dataOut.utctime
		687
		688	self.metadata_dict['processingHeader'] = self.dataOut.processingHeaderObj.getAsDict()
		689	self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict()
		690	self.metadata_dict['systemHeader'] = self.dataOut.systemHeaderObj.getAsDict()
		691	self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
		692	return
		693
		694
		695	def timeit(self, toExecute):
		696	t0 = time()
		697	toExecute()
		698	self.executionTime = time() - t0
		699	if self.oldAverage is None: self.oldAverage = self.executionTime
		700	self.oldAverage = (self.executionTime + self.count*self.oldAverage) / (self.count + 1.0)
		701	self.count = self.count + 1.0
		702	return
		703
		704
		705	def writeData(self):
		706	for i in range(self.dataOut.systemHeaderObj.nSamples):
		707	for channel in self.dataOut.channelList:
		708	self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
		709	self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
		710
		711	def f(): return self.digitalWriteObj.rf_write(self.arr_data)
		712	self.timeit(f)
		713
		714	return
		715
		716	def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=100, dirCadence=25, metadataCadence=1, **kwargs):
		717	'''
		718	This method will be called many times so here you should put all your code
		719	Inputs:
		720	dataOut: object with the data
		721	'''
		722	# print dataOut.__dict__
		723	self.dataOut = dataOut
		724	if not self.isConfig:
		725	self.setup(dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, **kwargs)
		726	self.writeMetadata()
		727
		728	self.writeData()
		729
		730	## self.currentSample += 1
		731	## if self.dataOut.flagDataAsBlock or self.currentSample == 1:
		732	## self.writeMetadata()
		733	## if self.currentSample == self.__nProfiles: self.currentSample = 0
		734
		735	def close(self):
		736	print '[Writing] - Closing files '
		737	print 'Average of writing to digital rf format is ', self.oldAverage * 1000
		738	try:
		739	self.digitalWriteObj.close()
		740	except:
		741	pass
		742
		743	# raise
		744	if __name__ == '__main__':
		745
		746	readObj = DigitalRFReader()
		747
		748	while True:
		749	readObj.run(path='/home/jchavez/jicamarca/mocked_data/')
		750	# readObj.printInfo()
		751	# readObj.printNumberOfBlock()

schainpy/model/io/testDigitalRf.txt created 644 0 0

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

schainpy/scripts/testDigitalRF.py created 644 0 0

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

schainpy/scripts/testDigitalRFWriter.py created 644 0 0

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

schainpy/utils/trash created 644 0 0

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

.gitignore +4 -4

             # Byte-compiled / optimized / DLL files
             __pycache__/
             *.py[cod]
             *$py.class
             # C extensions
             *.so
             # Distribution / packaging
             .Python
             env/
             build/
             develop-eggs/
             dist/
             downloads/
             eggs/
             .eggs/
             lib/
             lib64/
             parts/
             sdist/
             var/
             wheels/
             *.egg-info/
             .installed.cfg
             *.egg
             # PyInstaller
             #  Usually these files are written by a python script from a template
             #  before PyInstaller builds the exe, so as to inject date/other infos into it.
             *.manifest
             *.spec
             # Installer logs
             pip-log.txt
             pip-delete-this-directory.txt
             # Unit test / coverage reports
             htmlcov/
             .tox/
             .coverage
             .coverage.*
             .cache
             nosetests.xml
             coverage.xml
             *,cover
             .hypothesis/
             # Translations
             *.mo
             *.pot
             # Django stuff:
             *.log
             local_settings.py
             # Flask stuff:
             instance/
             .webassets-cache
             # Scrapy stuff:
             .scrapy
             # Sphinx documentation
             docs/_build/
             # PyBuilder
             target/
             # Jupyter Notebook
             .ipynb_checkpoints
             # pyenv
             .python-version
             # celery beat schedule file
             celerybeat-schedule
             # SageMath parsed files
             *.sage.py
             # dotenv
             .env
             # virtualenv
             .venv
             venv/
             ENV/
             # Spyder project settings
             .spyderproject
             .spyproject
             # Rope project settings
             .ropeproject
             # mkdocs documentation
             /site
             # eclipse
             .project
             .pydevproject
             # vscode
             .vscode
-            schainpy/scripts/
             schaingui/node_modules/
+            schainpy/scripts/
             .svn/
             *.png
             *.pyc
-            *.xml
+            schainpy/scripts
-            *.log
+            .vscode
             trash
+            *.log

schaincli/README.md +1 -1

-            # schaing
+            # schain
             Command Line Interface for SIGNAL CHAIN - jro
             # Usage
             To use it:
                 $ schain-cli --help

schaincli/cli.py +26 -15

             import click
             import schainpy
             import subprocess
             import os
             import sys
             import glob
             save_stdout = sys.stdout
             sys.stdout = open('trash', 'w')
             from multiprocessing import cpu_count
             from schaincli import templates
             from schainpy.controller import Project
             from schainpy.model import Operation, ProcessingUnit
             from schainpy.utils import log
             from importlib import import_module
             from pydoc import locate
             from fuzzywuzzy import process
             from schainpy.utils import paramsFinder
             sys.stdout = save_stdout
             def print_version(ctx, param, value):
                 if not value or ctx.resilient_parsing:
                     return
                 click.echo(schainpy.__version__)
                 ctx.exit()
             cliLogger = log.makelogger('schain cli')
             PREFIX = 'experiment'
             @click.command()
             @click.option('--version', '-v', is_flag=True, callback=print_version, help='SChain version', type=str)
-            @click.option('--xml', '-x', default=None, help='run an XML file', type=click.Path(exists=True, resolve_path=True))
             @click.argument('command', default='run', required=True)
             @click.argument('nextcommand', default=None, required=False, type=str)
-            def main(command, nextcommand, version, xml):
+            def main(command, nextcommand, version):
                 """COMMAND LINE INTERFACE FOR SIGNAL CHAIN - JICAMARCA RADIO OBSERVATORY \n
                     Available commands.\n
                     --xml: runs a schain XML generated file\n
                     run: runs any python script starting 'experiment_'\n
                     generate: generates a template schain script\n
                     search: return avilable operations, procs or arguments of the give operation/proc\n"""
-                if xml is not None:
+                if command == 'xml':
-                    runFromXML(xml)
+                    runFromXML(nextcommand)
                 elif command == 'generate':
                     generate()
                 elif command == 'test':
                     test()
                 elif command == 'run':
                     runschain(nextcommand)
                 elif command == 'search':
                     search(nextcommand)
                 else:
                     log.error('Command {} is not defined'.format(command))
             def check_module(possible, instance):
                 def check(x):
                     try:
                         instancia = locate('schainpy.model.{}'.format(x))
                         return isinstance(instancia(), instance)
                     except Exception as e:
                         return False
                 clean = clean_modules(possible)
                 return [x for x in clean if check(x)]
             def clean_modules(module):
                 noEndsUnder = [x for x in module if not x.endswith('__')]
                 noStartUnder = [x for x in noEndsUnder if not x.startswith('__')]
                 noFullUpper = [x for x in noStartUnder if not x.isupper()]
                 return noFullUpper
             def search(nextcommand):
                 if nextcommand is None:
                     log.error('There is no Operation/ProcessingUnit to search')
                 elif nextcommand == 'procs':
                     procs = paramsFinder.getProcs()
-                    log.success('Current ProcessingUnits are:\n\033[1m{}\033[0m'.format('\n'.join(procs)))
+                    log.success(
+                        'Current ProcessingUnits are:\n\033[1m{}\033[0m'.format('\n'.join(procs)))
                 elif nextcommand == 'operations':
                     operations = paramsFinder.getOperations()
-                    log.success('Current Operations are:\n\033[1m{}\033[0m'.format('\n'.join(operations)))
+                    log.success('Current Operations are:\n\033[1m{}\033[0m'.format(
+                        '\n'.join(operations)))
                 else:
                     try:
                         args = paramsFinder.getArgs(nextcommand)
-                        log.warning('Use this feature with caution. It may not return all the allowed arguments')
+                        log.warning(
+                            'Use this feature with caution. It may not return all the allowed arguments')
                         if len(args) == 0:
                             log.success('{} has no arguments'.format(nextcommand))
                         else:
-                            log.success('Showing arguments of {} are:\n\033[1m{}\033[0m'.format(nextcommand, '\n'.join(args)))
+                            log.success('Showing {} arguments:\n\033[1m{}\033[0m'.format(
+                                nextcommand, '\n'.join(args)))
                     except Exception as e:
                         log.error('Module {} does not exists'.format(nextcommand))
                         allModules = paramsFinder.getAll()
                         similar = process.extractOne(nextcommand, allModules)[0]
                         log.success('Showing {} instead'.format(similar))
                         search(similar)
             def runschain(nextcommand):
                 if nextcommand is None:
                     currentfiles = glob.glob('./{}_*.py'.format(PREFIX))
                     numberfiles = len(currentfiles)
                     if numberfiles > 1:
                         log.error('There is more than one file to run')
                     elif numberfiles == 1:
                         subprocess.call(['python ' + currentfiles[0]], shell=True)
                     else:
                         log.error('There is no file to run')
                 else:
                     try:
                         subprocess.call(['python ' + nextcommand], shell=True)
                     except Exception as e:
                         log.error("I cannot run the file. Does it exists?")
             def basicInputs():
                 inputs = {}
-                inputs['desc'] = click.prompt('Enter a description', default="A schain project", type=str)
+                inputs['desc'] = click.prompt(
-                inputs['name'] = click.prompt('Name of the project', default="project", type=str)
+                    'Enter a description', default="A schain project", type=str)
-                inputs['path'] = click.prompt('Data path', default=os.getcwd(), type=click.Path(exists=True, resolve_path=True))
+                inputs['name'] = click.prompt(
-                inputs['startDate'] = click.prompt('Start date', default='1970/01/01', type=str)
+                    'Name of the project', default="project", type=str)
-                inputs['endDate'] = click.prompt('End date', default='2017/12/31', type=str)
+                inputs['path'] = click.prompt('Data path', default=os.getcwd(
-                inputs['startHour'] = click.prompt('Start hour', default='00:00:00', type=str)
+                ), type=click.Path(exists=True, resolve_path=True))
+                inputs['startDate'] = click.prompt(
+                    'Start date', default='1970/01/01', type=str)
+                inputs['endDate'] = click.prompt(
+                    'End date', default='2017/12/31', type=str)
+                inputs['startHour'] = click.prompt(
+                    'Start hour', default='00:00:00', type=str)
                 inputs['endHour'] = click.prompt('End hour', default='23:59:59', type=str)
                 inputs['figpath'] = inputs['path'] + '/figs'
                 return inputs
             def generate():
                 inputs = basicInputs()
                 inputs['multiprocess'] = click.confirm('Is this a multiprocess script?')
                 if inputs['multiprocess']:
-                    inputs['nProcess'] = click.prompt('How many process?', default=cpu_count(), type=int)
+                    inputs['nProcess'] = click.prompt(
+                        'How many process?', default=cpu_count(), type=int)
                     current = templates.multiprocess.format(**inputs)
                 else:
                     current = templates.basic.format(**inputs)
                 scriptname = '{}_{}.py'.format(PREFIX, inputs['name'])
                 script = open(scriptname, 'w')
                 try:
                     script.write(current)
                     log.success('Script {} generated'.format(scriptname))
                 except Exception as e:
                     log.error('I cannot create the file. Do you have writing permissions?')
             def test():
                 log.warning('testing')
             def runFromXML(filename):
                 controller = Project()
                 if not controller.readXml(filename):
                     return
                 controller.start()
                 return

schaincli/templates.py +52 -37

@@ -1,75 +1,90
1	basic = '''from schainpy.controller import Project	1	basic = '''from schainpy.controller import Project
2		2
3	desc = "{desc}"	3	desc = "{desc}"
		4	project = Project()
		5	project.setup(id='200', name="{name}", description=desc)
4		6
5	controller = Project()	7	voltage_reader = project.addReadUnit(datatype='VoltageReader',
6	controller.setup(id='191', name="{name}", description=desc)
7
8	readUnitConf = controller.addReadUnit(datatype='VoltageReader',
9	path="{path}",	8	path="{path}",
10	startDate="{startDate}",	9	startDate="{startDate}",
11	endDate="{endDate}",	10	endDate="{endDate}",
12	startTime="{startHour}",	11	startTime="{startHour}",
13	endTime="{endHour}",	12	endTime="{endHour}",
14	online=0,	13	online=0,
15	verbose=1,	14	verbose=1,
16	walk=1,	15	walk=1,
17	)	16	)
18		17
19	~~procUnitConf1 = controller~~.addProcUnit(datatype='VoltageProc', inputId=~~readUnitConf~~.getId())	18	voltage_proc = project.addProcUnit(datatype='VoltageProc', inputId=voltage_reader.getId())
20		19
21	~~opObj11 = procUnitConf1~~.addOperation(name='ProfileSelector', optype='other')	20	profile = voltage_proc.addOperation(name='ProfileSelector', optype='other')
22	~~opObj11~~.addParameter(name='profileRangeList', value='120,183', format='intlist')	21	profile.addParameter(name='profileRangeList', value='120,183', format='intlist')
23		22
24	~~opObj11 = procUnitConf1~~.addOperation(name='RTIPlot', optype='other')	23	rti = voltage_proc.addOperation(name='RTIPlot', optype='other')
25	~~opObj11~~.addParameter(name='wintitle', value='Jicamarca Radio Observatory', format='str')	24	rti.addParameter(name='wintitle', value='Jicamarca Radio Observatory', format='str')
26	~~opObj11~~.addParameter(name='showprofile', value='0', format='int')	25	rti.addParameter(name='showprofile', value='0', format='int')
27	~~opObj11~~.addParameter(name='xmin', value='0', format='int')	26	rti.addParameter(name='xmin', value='0', format='int')
28	~~opObj11~~.addParameter(name='xmax', value='24', format='int')	27	rti.addParameter(name='xmax', value='24', format='int')
29	~~opObj11~~.addParameter(name='figpath', value="{figpath}", format='str')	28	rti.addParameter(name='figpath', value="{figpath}", format='str')
30	~~opObj11~~.addParameter(name='wr_period', value='5', format='int')	29	rti.addParameter(name='wr_period', value='5', format='int')
31	~~opObj11~~.addParameter(name='exp_code', value='22', format='int')	30	rti.addParameter(name='exp_code', value='22', format='int')
32		31
33		32
34	controller.start()	33	controller.start()
35	'''	34	'''
36		35
37	multiprocess = '''from schainpy.controller import Project, ~~multiSchain~~	36	multiprocess = '''from schainpy.controller import Project, MPProject
38		37	from time import sleep
39	desc = "{desc}"	38	desc = "{desc}"
40		39
41	def fiber(cursor, skip, q, day):	40	####################
42	controller = Project()	41	# PLOTTER RECEIVER #
43	controller.setup(id='191', name="{name}", description=desc)	42	####################
		43	plotter = Project()
		44	plotter.setup(id='100', name='receiver', description=desc)
		45
		46	receiver_plot = plotter.addProcUnit(name='PlotterReceiver')
		47	receiver_plot.addParameter(name='throttle', value=20, format='int')
		48	receiver_plot.addParameter(name='plottypes', value='rti', format='str')
		49
		50	rti = receiver_plot.addOperation(name='PlotRTIData', optype='other')
		51	rti.addParameter(name='zmin', value='-40.0', format='float')
		52	rti.addParameter(name='zmax', value='100.0', format='float')
		53	rti.addParameter(name='decimation', value='200', format='int')
		54	rti.addParameter(name='xmin', value='0.0', format='int')
		55	rti.addParameter(name='colormap', value='jet', format='str')
		56
		57	plotter.start()
44		58
45	readUnitConf = controller.addReadUnit(datatype='SpectraReader',	59	sleep(2)
		60
		61	################
		62	# DATA EMITTER #
		63	################
		64	project = Project()
		65	project.setup(id='200', name="{name}", description=desc)
		66
		67	spectra_reader = project.addReadUnit(datatype='SpectraReader',
46	path="{path}",	68	path="{path}",
47	startDate=~~day~~,	69	startDate={startDate},
48	endDate=~~day~~,	70	endDate={endDate},
49	startTime="{startHour}",	71	startTime="{startHour}",
50	endTime="{endHour}",	72	endTime="{endHour}",
51	online=0,	73	online=0,
52	queue=q,
53	cursor=cursor,
54	skip=skip,
55	verbose=1,	74	verbose=1,
56	walk=1,	75	walk=1,
57	)	76	)
58		77
59	~~procUnitConf1 = controller~~.addProcUnit(datatype='Spectra', inputId=~~readUnitConf~~.getId())	78	spectra_proc = project.addProcUnit(datatype='Spectra', inputId=spectra_reader.getId())
60
61	procUnitConf2 = controller.addProcUnit(datatype='ParametersProc', inputId=readUnitConf.getId())
62	opObj11 = procUnitConf2.addOperation(name='SpectralMoments', optype='other')
63		79
64	opObj12 = procUnitConf2.addOperation(name='PublishData', optype='other')	80	parameters_proc = project.addProcUnit(datatype='ParametersProc', inputId=spectra_proc.getId())
65	opObj12.addParameter(name='zeromq', value=1, format='int')	81	moments = parameters_proc.addOperation(name='SpectralMoments', optype='other')
66	opObj12.addParameter(name='verbose', value=0, format='bool')
67
68	controller.start()
69		82
		83	publish = parameters_proc.addOperation(name='PublishData', optype='other')
		84	publish.addParameter(name='zeromq', value=1, format='int')
		85	publish.addParameter(name='verbose', value=0, format='bool')
70		86
71	if __name__ == '__main__':	87	MPProject(project, 16)
72	multiSchain(fiber, nProcess={nProcess}, startDate="{startDate}", endDate="{endDate}")
73		88
74		89
75	'''	90	'''

schainpy/CHANGELOG.md +2 -2

             ## CHANGELOG:
             ### 2.3
-            * Added high order function `multiSchain` for multiprocessing scripts.
+            * Added high order function `MPProject` for multiprocessing scripts.
             * Added two new Processing Units `PublishData` and `ReceiverData` for receiving and sending dataOut through multiple ways (tcp, ipc, inproc).
             * Added a new graphics Processing Unit `PlotterReceiver`. It is decoupled from normal processing sequence with support for data generated by multiprocessing scripts.
             * Added support for sending realtime graphic to web server.
             * GUI command `schain` is now `schainGUI`.
             * Added a CLI tool named `schain`.
             	* Scripts templates can be now generated with `schain generate`.
             	* Now it is possible to search Processing Units and Operations with `schain search [module]` to get the right name and its allowed parameters.
             	* `schain xml` to run xml scripts.
             * Added suggestions when parameters are poorly written.
             * `Controller.start()` now runs in a different process than the process calling it.
             * Added `schainpy.utils.log` for log standarization.
             * Running script on online mode no longer ignores date and hour. Issue #1109.
             * Added support for receving voltage data directly from JARS (tcp, ipc).
             * Updated README for MAC OS GUI installation.
             * Setup now installs numpy.
             ### 2.2.6
             * Graphics generated by the GUI are now the same as generated by scripts. Issue #1074.
             * Added support for C extensions.
-            * function `hildebrand_sehkon` optimized with a C wrapper.
+            * Function `hildebrand_sehkon` optimized with a C wrapper.
             * Numpy version updated.
             * Migration to GIT.
             ### 2.2.5:
             * splitProfiles and combineProfiles modules were added to VoltageProc and Signal Chain GUI.
             * nProfiles of USRP data (hdf5) is the number of profiles thera are in one second.
             * jroPlotter works directly with data objects instead of dictionaries
             * script "schain" was added to Signal Chain installer
             ### 2.2.4.1:
             * jroIO_usrp.py is update to read Sandra's data
             * decimation in Spectra and RTI plots is always enabled.
             * time* window option added to GUI
             ### 2.2.4:
             * jroproc_spectra_lags.py added to schainpy
             * Bug fixed in schainGUI: ProcUnit was created with the same id in some cases.
             * Bug fixed in jroHeaderIO: Header size validation.
             ### 2.2.3.1:
             * Filtering block by time has been added.
             * Bug fixed plotting RTI, CoherenceMap and others using xmin and xmax parameters. The first day worked
             properly but the next days did not.
             ### 2.2.3:
             * Bug fixed in GUI: Error getting(reading) Code value
             * Bug fixed in GUI: Flip option always needs channelList field
             * Bug fixed in jrodata: when one branch modified a value in "dataOut" (example: dataOut.code) this value
             was modified for every branch (because this was a reference). It was modified in data.copy()
             * Bug fixed in jroproc_voltage.profileSelector(): rangeList replaces to profileRangeList.
             ### 2.2.2:
             * VoltageProc: ProfileSelector, Reshape, Decoder with nTxs!=1 and getblock=True was tested
             * Rawdata and testRawdata.py added to Signal Chain project
             ### 2.2.1:
             * Bugs fixed in GUI
             * Views were improved in GUI
             * Support to MST* ISR experiments
             * Bug fixed getting noise using hyldebrant. (minimum number of points > 20%)
             * handleError added to jroplotter.py
             ### 2.2.0:
             * GUI: use of external plotter
             * Compatible with matplotlib 1.5.0
             ### 2.1.5:
             * serializer module added to Signal Chain
             * jroplotter.py added to Signal Chain
             ### 2.1.4.2:
             * A new Plotter Class was added
             * Project.start() does not accept filename as a parameter anymore
             ### 2.1.4.1:
             * Send notifications when an error different to ValueError is detected
             ### 2.1.4:
             * Sending error notifications to signal chain administrator
             * Login to email server added
             ### 2.1.3.3:
             * Colored Button Icons were added to GUI
             ### 2.1.3.2:
             * GUI: user interaction enhanced
             * controller_api.py: Safe access to ControllerThead
             ### 2.1.3.1:
             * GUI: every icon were resized
             * jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
             ### 2.1.3:
             * jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
             * jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
             					 Bug fixed selecting heights by block (selecting profiles instead heights)
             * jroproc_voltage.py: New feature added: decoding data by block using FFT.
             * jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits instance instead schainpy.mode.data.jrodata.Fits.
             * jroIO_heispectra.py: Channel index list does not exist.
             ### 2.1.2:
             * jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
             				  Server thread opens and closes remote server each time file list is sent
             * jroplot_spectra.py: Noise path was not being created when noise data is saved.
             * jroIO_base.py: startTime can be greater than endTime. Example: SpreadF [18:00 *  07:00]

schainpy/controller.py +41 -26

             '''
             Created on September , 2012
             @author:
             '''
             import sys
             import ast
             import datetime
             import traceback
             import math
             import time
             from multiprocessing import Process, cpu_count
             from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
             from xml.dom import minidom
             import schainpy
             import schainpy.admin
             from schainpy.model import *
             from schainpy.utils import log
             DTYPES = {
                 'Voltage': '.r',
                 'Spectra': '.pdata'
             }
             def MPProject(project, n=cpu_count()):
                 '''
                 Project wrapper to run schain in n processes
                 '''
                 rconf = project.getReadUnitObj()
                 op = rconf.getOperationObj('run')
                 dt1 = op.getParameterValue('startDate')
                 dt2 = op.getParameterValue('endDate')
                 days = (dt2 - dt1).days
                 for day in range(days + 1):
                     skip = 0
                     cursor = 0
                     processes = []
                     dt = dt1 + datetime.timedelta(day)
                     dt_str = dt.strftime('%Y/%m/%d')
                     reader = JRODataReader()
                     paths, files = reader.searchFilesOffLine(path=rconf.path,
                                                              startDate=dt,
                                                              endDate=dt,
                                                              ext=DTYPES[rconf.datatype])
                     nFiles = len(files)
                     if nFiles == 0:
                         continue
                     skip = int(math.ceil(nFiles / n))
                     while nFiles > cursor * skip:
                         rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor,
                                      skip=skip)
                         p = project.clone()
                         p.start()
                         processes.append(p)
                         cursor += 1
                     def beforeExit(exctype, value, trace):
                         for process in processes:
                             process.terminate()
                             process.join()
                         print traceback.print_tb(trace)
                     sys.excepthook = beforeExit
                     for process in processes:
                         process.join()
                         process.terminate()
                     time.sleep(3)
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'obj':
                         return value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
                         raise ValueError, '%s: This parameter value is empty' % self.name
                     if format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
                         '''
                         Example:
                             value = (0,1,2)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [int(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'floatlist':
                         '''
                         Example:
                             value = (0.5, 1.4, 2.7)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [float(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
                         '''
                         Example:
                             value = (0,1),(1,2)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             raise ValueError, '%s has to be a tuple or list of pairs' % value
                         if type(new_value[0]) not in (tuple, list):
                             if len(new_value) != 2:
                                 raise ValueError, '%s has to be a tuple or list of pairs' % value
                             new_value = [new_value]
                         for thisPair in new_value:
                             if len(thisPair) != 2:
                                 raise ValueError, '%s has to be a tuple or list of pairs' % value
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'multilist':
                         '''
                         Example:
                             value = (0,1,2),(3,4,5)
                         '''
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
                             multiList = ast.literal_eval('(' + value + ')')
                         self.__formated_value = multiList
                         return self.__formated_value
                     if format == 'bool':
                         value = int(value)
                     if format == 'int':
                         value = float(value)
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     if format == 'obj':
                         self.value = value
                     else:
                         self.value = str(value)
                     self.format = str.lower(format)
                     self.getValue()
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     if self.name not in ('queue',):
                         parmElement = SubElement(opElement, self.ELEMENTNAME)
                         parmElement.set('id', str(self.id))
                         parmElement.set('name', self.name)
                         parmElement.set('value', self.value)
                         parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     # Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
                     print 'Parameter[%s]: name = %s, value = %s, format = %s' % (self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                 name = None
                 priority = None
                 type = None
                 parmConfObjList = []
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.parmConfObjList) + 1
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id) * 10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
                 #         if not parameterObj:
                 #             return None
                     value = parameterObj.getValue()
                     return value
                 def getKwargs(self):
                     kwargs = {}
                     for parmConfObj in self.parmConfObjList:
                         if self.name == 'run' and parmConfObj.name == 'datatype':
                             continue
                         kwargs[parmConfObj.name] = parmConfObj.getValue()
                     return kwargs
                 def setup(self, id, name, priority, type):
                     self.id = str(id)
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     if value is None:
                         return None
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
                 def makeXml(self, procUnitElement):
                     opElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     # Compatible with old signal chain version
                     # Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.iter(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         # Compatible with old signal chain version
                         # If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
                     print '%s[%s]: name = %s, type = %s, priority = %s' % (self.ELEMENTNAME,
                                                                            self.id,
                                                                            self.name,
                                                                            self.type,
                                                                            self.priority)
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self, plotter_queue=None):
                     if self.type == 'self':
                         raise ValueError, 'This operation type cannot be created'
                     if self.type == 'plotter':
                         if not plotter_queue:
                             raise ValueError, 'plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)'
                         opObj = Plotter(self.name, plotter_queue)
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         kwargs = self.getKwargs()
                         opObj = className(**kwargs)
                     return opObj
             class ProcUnitConf():
                 id = None
                 name = None
                 datatype = None
                 inputId = None
                 parentId = None
                 opConfObjList = []
                 procUnitObj = None
                 opObjList = []
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList) + 1
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id, parentId=parentId):
                     new_id = int(parentId) * 10 + (int(self.id) % 10)
                     new_inputId = int(parentId) * 10 + (int(self.inputId) % 10)
                     # If this proc unit has not inputs
                     if self.inputId == '0':
                         new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id) * 10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, id, name, datatype, inputId, parentId=None):
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
                         raise ValueError, 'datatype or name should be defined'
                     if name == None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' % (datatype)
                     if datatype == None:
                         datatype = name.replace('Proc', '')
                     self.id = str(id)
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.parentId = parentId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
                     Add parameters to 'run' operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     id = self.__getNewId()
                     priority = self.__getPriority()
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
                 def makeXml(self, projectElement):
                     procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
                     procUnitElement.set('id', str(self.id))
                     procUnitElement.set('name', self.name)
                     procUnitElement.set('datatype', self.datatype)
                     procUnitElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(procUnitElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     if self.ELEMENTNAME == 'ReadUnit':
                         self.datatype = self.datatype.replace('Reader', '')
                     if self.ELEMENTNAME == 'ProcUnit':
                         self.datatype = self.datatype.replace('Proc', '')
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
                     print '%s[%s]: name = %s, datatype = %s, inputId = %s' % (self.ELEMENTNAME,
                                                                               self.id,
                                                                               self.name,
                                                                               self.datatype,
                                                                               self.inputId)
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def getKwargs(self):
                     opObj = self.opConfObjList[0]
                     kwargs = opObj.getKwargs()
                     return kwargs
                 def createObjects(self, plotter_queue=None):
                     className = eval(self.name)
                     kwargs = self.getKwargs()
                     procUnitObj = className(**kwargs)
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self' and self.name == 'run':
                             continue
                         elif opConfObj.type == 'self':
-                            procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
+                            procUnitObj.addOperationKwargs(
+                                opConfObj.id, **opConfObj.getKwargs())
                             continue
                         opObj = opConfObj.createObject(plotter_queue)
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj
                     return procUnitObj
                 def run(self):
                     is_ok = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
                                 continue
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
                         sts = self.procUnitObj.call(opType=opConfObj.type,
                                                     opName=opConfObj.name,
                                                     opId=opConfObj.id)
                         is_ok = is_ok or sts
                     return is_ok
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.parentId = None
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, datatype, path='', startDate='', endDate='',
                           startTime='', endTime='', parentId=None, server=None, **kwargs):
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
                         raise ValueError, 'datatype or name should be defined'
                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
                             datatype = name.replace('Reader','')
                         else:
                             name = '{}Reader'.format(datatype)
                     if datatype == None:
                         if 'Reader' in name:
                             datatype = name.replace('Reader','')
                         else:
                             datatype = name
                             name = '{}Reader'.format(name)
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     if path != '':
                         self.path = os.path.abspath(path)
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.server = server
                     self.addRunOperation(**kwargs)
                 def update(self, **kwargs):
                     if 'datatype' in kwargs:
                         datatype = kwargs.pop('datatype')
                         if 'Reader' in datatype:
                             self.name = datatype
                         else:
                             self.name = '%sReader' % (datatype)
                         self.datatype = self.name.replace('Reader', '')
-                    attrs = ('path', 'startDate', 'endDate', 'startTime', 'endTime', 'parentId')
+                    attrs = ('path', 'startDate', 'endDate',
+                             'startTime', 'endTime', 'parentId')
                     for attr in attrs:
                         if attr in kwargs:
                             setattr(self, attr, kwargs.pop(attr))
                     self.inputId = '0'
                     self.updateRunOperation(**kwargs)
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name='run', optype='self')
                     if self.server is None:
-                        opObj.addParameter(name='datatype', value=self.datatype, format='str')
+                        opObj.addParameter(
+                            name='datatype', value=self.datatype, format='str')
                         opObj.addParameter(name='path', value=self.path, format='str')
-                        opObj.addParameter(name='startDate', value=self.startDate, format='date')
+                        opObj.addParameter(
-                        opObj.addParameter(name='endDate', value=self.endDate, format='date')
+                            name='startDate', value=self.startDate, format='date')
-                        opObj.addParameter(name='startTime', value=self.startTime, format='time')
+                        opObj.addParameter(
-                        opObj.addParameter(name='endTime', value=self.endTime, format='time')
+                            name='endDate', value=self.endDate, format='date')
+                        opObj.addParameter(
+                            name='startTime', value=self.startTime, format='time')
+                        opObj.addParameter(
+                            name='endTime', value=self.endTime, format='time')
                         for key, value in kwargs.items():
-                            opObj.addParameter(name=key, value=value, format=type(value).__name__)
+                            opObj.addParameter(name=key, value=value,
+                                               format=type(value).__name__)
                     else:
                         opObj.addParameter(name='server', value=self.server, format='str')
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj = self.getOperationObj(name='run')
                     opObj.removeParameters()
                     opObj.addParameter(name='datatype', value=self.datatype, format='str')
                     opObj.addParameter(name='path', value=self.path, format='str')
-                    opObj.addParameter(name='startDate', value=self.startDate, format='date')
+                    opObj.addParameter(
+                        name='startDate', value=self.startDate, format='date')
                     opObj.addParameter(name='endDate', value=self.endDate, format='date')
-                    opObj.addParameter(name='startTime', value=self.startTime, format='time')
+                    opObj.addParameter(
+                        name='startTime', value=self.startTime, format='time')
                     opObj.addParameter(name='endTime', value=self.endTime, format='time')
                     for key, value in kwargs.items():
-                        opObj.addParameter(name=key, value=value, format=type(value).__name__)
+                        opObj.addParameter(name=key, value=value,
+                                           format=type(value).__name__)
                     return opObj
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     if self.ELEMENTNAME == 'ReadUnit':
                         self.datatype = self.datatype.replace('Reader', '')
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                         if opConfObj.name == 'run':
                             self.path = opConfObj.getParameterValue('path')
                             self.startDate = opConfObj.getParameterValue('startDate')
                             self.endDate = opConfObj.getParameterValue('endDate')
                             self.startTime = opConfObj.getParameterValue('startTime')
                             self.endTime = opConfObj.getParameterValue('endTime')
             class Project(Process):
                 id = None
                 # name = None
                 description = None
                 filename = None
                 procUnitConfObjDict = None
                 ELEMENTNAME = 'Project'
                 plotterQueue = None
                 def __init__(self, plotter_queue=None):
                     Process.__init__(self)
                     self.id = None
                     # self.name = None
                     self.description = None
                     self.plotterQueue = plotter_queue
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                     idList = self.procUnitConfObjDict.keys()
                     id = int(self.id) * 10
                     while True:
                         id += 1
                         if str(id) in idList:
                             continue
                         break
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id) * 10 + n)
                         procUnitConfObj.updateId(idProcUnit, parentId=self.id)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
                 def setup(self, id, name='', description=''):
                     print
                     print '*' * 60
                     print '   Starting SIGNAL CHAIN PROCESSING v%s ' % schainpy.__version__
                     print '*' * 60
                     print
                     self.id = str(id)
                     self.description = description
                 def update(self, name, description):
                     self.description = description
                 def clone(self):
                     p = Project()
                     p.procUnitConfObjDict = self.procUnitConfObjDict
                     return p
                 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
                     if id is None:
                         idReadUnit = self.__getNewId()
                     else:
                         idReadUnit = str(id)
                     readUnitConfObj = ReadUnitConf()
-                    readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
+                    readUnitConfObj.setup(idReadUnit, name, datatype,
+                                          parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
-                    procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
+                    procUnitConfObj.setup(idProcUnit, name, datatype,
+                                          inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in self.procUnitConfObjDict.keys():
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.getElementName() == 'ReadUnit':
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return self.procUnitConfObjDict.items()
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename=None):
                     if filename == None:
                         if self.filename:
                             filename = self.filename
                         else:
                             filename = 'schain.xml'
                     if not filename:
                         print 'filename has not been defined. Use setFilename(filename) for do it.'
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.access(os.path.dirname(abs_file), os.W_OK):
                         print 'No write permission on %s' % os.path.dirname(abs_file)
                         return 0
                     if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
                         print 'File %s already exists and it could not be overwriten' % abs_file
                         return 0
                     self.makeXml()
                     ElementTree(self.projectElement).write(abs_file, method='xml')
                     self.filename = abs_file
                     return 1
                 def readXml(self, filename=None):
                     if not filename:
                         print 'filename is not defined'
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.path.isfile(abs_file):
                         print '%s file does not exist' % abs_file
                         return 0
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     try:
                         self.projectElement = ElementTree().parse(abs_file)
                     except:
                         print 'Error reading %s, verify file format' % filename
                         return 0
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
-                    readUnitElementList = self.projectElement.iter(ReadUnitConf().getElementName())
+                    readUnitElementList = self.projectElement.iter(
+                        ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement)
                         if readUnitConfObj.parentId == None:
                             readUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
-                    procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
+                    procUnitElementList = self.projectElement.iter(
+                        ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         if procUnitConfObj.parentId == None:
                             procUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     self.filename = abs_file
                     return 1
                 def printattr(self):
                     print 'Project[%s]: name = %s, description = %s' % (self.id,
                                                                         self.name,
                                                                         self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects(self.plotterQueue)
                 def __connect(self, objIN, thisObj):
                     thisObj.setInput(objIN.getOutputObj())
                 def connectObjects(self):
                     for thisPUConfObj in self.procUnitConfObjDict.values():
                         inputId = thisPUConfObj.getInputId()
                         if int(inputId) == 0:
                             continue
                         # Get input object
                         puConfINObj = self.procUnitConfObjDict[inputId]
                         puObjIN = puConfINObj.getProcUnitObj()
                         # Get current object
                         thisPUObj = thisPUConfObj.getProcUnitObj()
                         self.__connect(puObjIN, thisPUObj)
                 def __handleError(self, procUnitConfObj, send_email=False):
                     import socket
                     err = traceback.format_exception(sys.exc_info()[0],
                                                      sys.exc_info()[1],
                                                      sys.exc_info()[2])
                     print '***** Error occurred in %s *****' % (procUnitConfObj.name)
                     print '***** %s' % err[-1]
                     message = ''.join(err)
                     sys.stderr.write(message)
                     if not send_email:
                         return
-                    subject =  'SChain v%s: Error running %s\n' %(schainpy.__version__, procUnitConfObj.name)
+                    subject = 'SChain v%s: Error running %s\n' % (
+                        schainpy.__version__, procUnitConfObj.name)
-                    subtitle = '%s: %s\n' %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
+                    subtitle = '%s: %s\n' % (
-                    subtitle += 'Hostname: %s\n' %socket.gethostbyname(socket.gethostname())
+                        procUnitConfObj.getElementName(), procUnitConfObj.name)
+                    subtitle += 'Hostname: %s\n' % socket.gethostbyname(
+                        socket.gethostname())
                     subtitle += 'Working directory: %s\n' % os.path.abspath('./')
                     subtitle += 'Configuration file: %s\n' % self.filename
                     subtitle += 'Time: %s\n' % str(datetime.datetime.now())
                     readUnitConfObj = self.getReadUnitObj()
                     if readUnitConfObj:
                         subtitle += '\nInput parameters:\n'
                         subtitle += '[Data path = %s]\n' % readUnitConfObj.path
                         subtitle += '[Data type = %s]\n' % readUnitConfObj.datatype
                         subtitle += '[Start date = %s]\n' % readUnitConfObj.startDate
                         subtitle += '[End date = %s]\n' % readUnitConfObj.endDate
                         subtitle += '[Start time = %s]\n' % readUnitConfObj.startTime
                         subtitle += '[End time = %s]\n' % readUnitConfObj.endTime
                     adminObj = schainpy.admin.SchainNotify()
                     adminObj.sendAlert(message=message,
                                        subject=subject,
                                        subtitle=subtitle,
                                        filename=self.filename)
                 def isPaused(self):
                     return 0
                 def isStopped(self):
                     return 0
                 def runController(self):
                     '''
                     returns 0 when this process has been stopped, 1 otherwise
                     '''
                     if self.isPaused():
                         print 'Process suspended'
                         while True:
                             time.sleep(0.1)
                             if not self.isPaused():
                                 break
                             if self.isStopped():
                                 break
                         print 'Process reinitialized'
                     if self.isStopped():
                         print 'Process stopped'
                         return 0
                     return 1
                 def setFilename(self, filename):
                     self.filename = filename
                 def setPlotterQueue(self, plotter_queue):
                     raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
                 def getPlotterQueue(self):
                     raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
                 def useExternalPlotter(self):
                     raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
                 def run(self):
                     log.success('Starting {}'.format(self.name))
                     self.createObjects()
                     self.connectObjects()
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         is_ok = False
                         for procKey in keyList:
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
                             try:
                                 sts = procUnitConfObj.run()
                                 is_ok = is_ok or sts
                             except KeyboardInterrupt:
                                 is_ok = False
                                 break
                             except ValueError, e:
                                 time.sleep(0.5)
                                 self.__handleError(procUnitConfObj, send_email=True)
                                 is_ok = False
                                 break
                             except:
                                 time.sleep(0.5)
                                 self.__handleError(procUnitConfObj)
                                 is_ok = False
                                 break
                         # If every process unit finished so end process
                         if not(is_ok):
                             break
                         if not self.runController():
                             break
                     # Closing every process
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
                     log.success('{} finished'.format(self.name))

schainpy/gui/viewcontroller/parametersModel.py 0 -2

             """
             Classes to save parameters from Windows.
             -Project window
             -Voltage window
             -Spectra window
             -SpectraHeis window
             -Correlation window
             """
             class ProjectParms():
                 parmsOk = False
                 name = None
                 description = None
                 datatype = None
                 ext = None
                 dpath = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime  = None
                 online  = None
                 delay = None
                 walk  = None
                 expLabel = None
                 set = None
                 ippKm = None
                 def __init__(self):
                     self.parmsOk = True
                     self.description = ''
                     self.expLabel = ''
                     self.set = ''
                     self.ippKm = ''
                     self.walk = None
                     self.delay = ''
                 def getDatatypeIndex(self):
                     indexDatatype = None
                     if 'voltage' in self.datatype.lower():
                         indexDatatype = 0
                     if 'spectra' in self.datatype.lower():
                         indexDatatype = 1
                     if 'fits' in self.datatype.lower():
                         indexDatatype = 2
                     if 'usrp' in self.datatype.lower():
                         indexDatatype = 3
                     return indexDatatype
                 def getExt(self):
                     ext = None
                     if self.datatype.lower() == 'voltage':
                         ext = '.r'
                     if self.datatype.lower() == 'spectra':
                         ext = '.pdata'
                     if self.datatype.lower() == 'fits':
                         ext = '.fits'
                     if self.datatype.lower() == 'usrp':
                         ext = '.hdf5'
                     return ext
                 def set(self, project_name, datatype, ext, dpath, online,
                         startDate=None, endDate=None, startTime=None, endTime=None,
                         delay=None, walk=None, set=None, ippKm=None, parmsOk=True, expLabel=''):
                     name = project_name
                     datatype = datatype
                     ext = ext
                     dpath = dpath
                     startDate = startDate
                     endDate = endDate
                     startTime = startTime
                     endTime  = endTime
                     online  = online
                     delay = delay
                     walk  = walk
                     set = set
                     ippKm = ippKm
                     expLabel = expLabel
                     self.parmsOk = parmsOk
                 def isValid(self):
                     return self.parmsOk

schainpy/model/__init__.py +1 -1

             #from schainpy.model.data.jrodata import *
             # from schainpy.model.io.jrodataIO import *
             # from schainpy.model.proc.jroprocessing import *
             # from schainpy.model.graphics.jroplot import *
             # from schainpy.model.utils.jroutils import *
             # from schainpy.serializer import *
+            from graphics import *
             from data import *
             from io import *
             from proc import *
-            from graphics import *
             from utils import *

schainpy/model/data/jrodata.py 0 -2

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import copy
             import numpy
             import datetime
             from jroheaderIO import SystemHeader, RadarControllerHeader
             from schainpy import cSchain
             def getNumpyDtype(dataTypeCode):
                 if dataTypeCode == 0:
                     numpyDtype = numpy.dtype([('real','<i1'),('imag','<i1')])
                 elif dataTypeCode == 1:
                     numpyDtype = numpy.dtype([('real','<i2'),('imag','<i2')])
                 elif dataTypeCode == 2:
                     numpyDtype = numpy.dtype([('real','<i4'),('imag','<i4')])
                 elif dataTypeCode == 3:
                     numpyDtype = numpy.dtype([('real','<i8'),('imag','<i8')])
                 elif dataTypeCode == 4:
                     numpyDtype = numpy.dtype([('real','<f4'),('imag','<f4')])
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real','<f8'),('imag','<f8')])
                 else:
                     raise ValueError, 'dataTypeCode was not defined'
                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real','<i1'),('imag','<i1')]):
                     datatype = 0
                 elif numpyDtype == numpy.dtype([('real','<i2'),('imag','<i2')]):
                     datatype = 1
                 elif numpyDtype == numpy.dtype([('real','<i4'),('imag','<i4')]):
                     datatype = 2
                 elif numpyDtype == numpy.dtype([('real','<i8'),('imag','<i8')]):
                     datatype = 3
                 elif numpyDtype == numpy.dtype([('real','<f4'),('imag','<f4')]):
                     datatype = 4
                 elif numpyDtype == numpy.dtype([('real','<f8'),('imag','<f8')]):
                     datatype = 5
                 else:
                     datatype = None
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     -1        :    any error
                     anoise    :    noise's level
                 """
                 sortdata = numpy.sort(data, axis=None)
             #     lenOfData = len(sortdata)
             #     nums_min = lenOfData*0.2
             #
             #     if nums_min <= 5:
             #         nums_min = 5
             #
             #     sump = 0.
             #
             #     sumq = 0.
             #
             #     j = 0
             #
             #     cont = 1
             #
             #     while((cont==1)and(j<lenOfData)):
             #
             #         sump += sortdata[j]
             #
             #         sumq += sortdata[j]**2
             #
             #         if j > nums_min:
             #             rtest = float(j)/(j-1) + 1.0/navg
             #             if ((sumq*j) > (rtest*sump**2)):
             #                 j = j - 1
             #                 sump  = sump - sortdata[j]
             #                 sumq =  sumq - sortdata[j]**2
             #                 cont = 0
             #
             #         j += 1
             #
             #     lnoise = sump /j
             #
             #     return lnoise
                 return cSchain.hildebrand_sekhon(sortdata, navg)
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         attribute = inputObj.__dict__[key]
                         #If this attribute is a tuple or list
                         if type(inputObj.__dict__[key]) in (tuple, list):
                             self.__dict__[key] = attribute[:]
                             continue
                         #If this attribute is another object or instance
                         if hasattr(attribute, '__dict__'):
                             self.__dict__[key] = attribute.copy()
                             continue
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
             class JROData(GenericData):
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 datatype = None #dtype but in string
             #     dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
             #     nCode = None
             #
             #     nBaud = None
             #
             #     code = None
                 flagDecodeData = False #asumo q la data no esta decodificada
                 flagDeflipData = False #asumo q la data no esta sin flip
                 flagShiftFFT = False
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
             #     noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 def getNoise(self):
                     raise NotImplementedError
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getDeltaH(self):
                     delta = self.heightList[1] - self.heightList[0]
                     return delta
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval+1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
                     period = (10**-6)*self.getDeltaH()/(0.15)
                     PRF = 1./(period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1./(self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
                     _lambda = self.C/self.frequency
                     vmax = self.getFmax() * _lambda/2
                     return vmax
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     return
                 def get_dtype(self):
                     '''
                     '''
                     return getNumpyDtype(self.datatype)
                 def set_dtype(self, numpyDtype):
                     '''
                     '''
                     self.datatype = getDataTypeCode(numpyDtype)
                 def get_code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 def set_code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                     return
                 def get_ncode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 def set_ncode(self, nCode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = nCode
                     return
                 def get_nbaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 def set_nbaud(self, nBaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nBaud
                     return
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 dtype = property(get_dtype, set_dtype)
             #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 code = property(get_code, set_code)
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False    #Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                 def getNoisebyHildebrand(self, channel = None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel,:].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type = 1, channel = None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return noise
                 def getPower(self, channel = None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10*numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt
                     return timeInterval
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 #data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data cspc es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data dc es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 #data power
                 data_pwr = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None #se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 profileIndex = 0
                 plotting = "spectra"
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     #self.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,xmin_index:xmax_index,ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         return self.noise_estimation #this was estimated by getNoise Operation defined in jroproc_spectra.py
                     else:
                         noise = self.getNoisebyHildebrand(xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints*self.ippFactor)
                     freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 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
                     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
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
                     velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) #- deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return range(self.nPairs)
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #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
                 def getFlagCspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles
                     return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     z = self.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     return 10*numpy.log10(avg)
                 def getCoherence(self, pairsList=None, phase=False):
                     z = []
                     if pairsList is None:
                         pairsIndexList = self.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         if phase:
                             data = numpy.arctan2(avgcoherenceComplex.imag,
                                                  avgcoherenceComplex.real)*180/numpy.pi
                         else:
                             data = numpy.abs(avgcoherenceComplex)
                         z.append(data)
                     return numpy.array(z)
                 def setValue(self, value):
                     print "This property should not be initialized"
                     return
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
                 pairsIndexList = property(getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, setValue, "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, setValue, "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
             #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt*self.nCohInt*pwcode
                     return normFactor
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNoise(self, type = 1):
                     #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Correlation(JROData):
                 noise = None
                 SNR = None
                 #--------------------------------------------------
                 mode = None
                 split = False
                 data_cf = None
                 lags = None
                 lagRange = None
                 pairsList = None
                 normFactor = None
                 #--------------------------------------------------
             #     calculateVelocity = None
                 nLags = None
                 nPairs = None
                 nAvg = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode = 2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:,:,indR,:]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1]/2
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
                         ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2,-1,1,2])
                         xx = numpy.zeros([4,4])
                         for fil in range(4):
                             xx[fil,:] = vel[fil]**numpy.asarray(range(4))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0,:]
                         for ich in range(num_chan):
                             yy = jspectra[ich,ind_vel,:]
                             jspectra[ich,freq_dc,:] = numpy.dot(xx_aux,yy)
                             junkid = jspectra[ich,freq_dc,:]<=0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
                     noise = jspectra0[:,freq_dc,:] - jspectra[:,freq_dc,:]
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nProfiles
                     return timeInterval
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         #Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 def getNormFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs,self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs==ch0,:,:], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs==ch1,:,:], axis=1)
                         normFactor[p,:] = numpy.sqrt(ch0_max*ch1_max)
                     return normFactor
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
                 experimentInfo = None   #Information about the experiment
                 #Information from previous data
                 inputUnit = None        #Type of data to be processed
                 operation = None        #Type of operation to parametrize
                 #normFactor = None       #Normalization Factor
                 groupList = None        #List of Pairs, Groups, etc
                 #Parameters
                 data_param = None       #Parameters obtained
                 data_pre = None         #Data Pre Parametrization
                 data_SNR = None         #Signal to Noise Ratio
             #     heightRange = None      #Heights
                 abscissaList = None    #Abscissa, can be velocities, lags or time
             #    noise = None            #Noise Potency
                 utctimeInit = None      #Initial UTC time
                 paramInterval = None    #Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 #Fitting
                 data_error = None       #Error of the estimation
                 constants = None
                 library = None
                 #Output signal
                 outputInterval = None     #Time interval to calculate output signal in seconds
                 data_output = None       #Out signal
                 nAvg = None
                 noise_estimation = None
                 GauSPC = None #Fit gaussian SPC
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone*60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getTimeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print "This property should not be initialized"
                     return
                 def getNoise(self):
                     return self.spc_noise
                 timeInterval = property(getTimeInterval)
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")

schainpy/model/data/jroheaderIO.py +39 -14

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
             import sys
             import numpy
             import copy
             import datetime
+            import inspect
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             BASIC_STRUCTURE = numpy.dtype([
                                       ('nSize','<u4'),
                                       ('nVersion','<u2'),
                                       ('nDataBlockId','<u4'),
                                       ('nUtime','<u4'),
                                       ('nMilsec','<u2'),
                                       ('nTimezone','<i2'),
                                       ('nDstflag','<i2'),
                                       ('nErrorCount','<u4')
                                       ])
             SYSTEM_STRUCTURE = numpy.dtype([
                                         ('nSize','<u4'),
                                         ('nNumSamples','<u4'),
                                         ('nNumProfiles','<u4'),
                                         ('nNumChannels','<u4'),
                                         ('nADCResolution','<u4'),
                                         ('nPCDIOBusWidth','<u4'),
                                         ])
             RADAR_STRUCTURE = numpy.dtype([
                                          ('nSize','<u4'),
                                          ('nExpType','<u4'),
                                          ('nNTx','<u4'),
                                          ('fIpp','<f4'),
                                          ('fTxA','<f4'),
                                          ('fTxB','<f4'),
                                          ('nNumWindows','<u4'),
                                          ('nNumTaus','<u4'),
                                          ('nCodeType','<u4'),
                                          ('nLine6Function','<u4'),
                                          ('nLine5Function','<u4'),
                                          ('fClock','<f4'),
                                          ('nPrePulseBefore','<u4'),
                                          ('nPrePulseAfter','<u4'),
                                          ('sRangeIPP','<a20'),
                                          ('sRangeTxA','<a20'),
                                          ('sRangeTxB','<a20'),
                                          ])
             SAMPLING_STRUCTURE = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
             PROCESSING_STRUCTURE = numpy.dtype([
                                            ('nSize','<u4'),
                                            ('nDataType','<u4'),
                                            ('nSizeOfDataBlock','<u4'),
                                            ('nProfilesperBlock','<u4'),
                                            ('nDataBlocksperFile','<u4'),
                                            ('nNumWindows','<u4'),
                                            ('nProcessFlags','<u4'),
                                            ('nCoherentIntegrations','<u4'),
                                            ('nIncoherentIntegrations','<u4'),
                                            ('nTotalSpectra','<u4')
                                            ])
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def copy(self):
                     return copy.deepcopy(self)
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
+                def getAllowedArgs(self):
+                    args = inspect.getargspec(self.__init__).args
+                    try:
+                        args.remove('self')
+                    except:
+                        pass
+                    return args
+                def getAsDict(self):
+                    args = self.getAllowedArgs()
+                    asDict = {}
+                    for x in args:
+                        asDict[x] = self[x]
+                    return asDict
+                def __getitem__(self, name):
+                    return getattr(self, name)
                 def printInfo(self):
                     message = "#"*50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#"*50 + "\n"
                     keyList = self.__dict__.keys()
                     keyList.sort()
                     for key in keyList:
                         message += "%s = %s" %(key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
                             message += "%s = %s" %("size", attr) + "\n"
                     print message
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 ltc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 datatime = None
+                structure = BASIC_STRUCTURE
                 __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
                     self.size = 24
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.useLocalTime = useLocalTime
                 def read(self, fp):
                     self.length = 0
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
                         else:
                             header = numpy.fromstring(fp, BASIC_STRUCTURE,1)
                     except Exception, e:
                         print "BasicHeader: "
                         print e
                         return 0
                     self.size = int(header['nSize'][0])
                     self.version = int(header['nVersion'][0])
                     self.dataBlock = int(header['nDataBlockId'][0])
                     self.utc = int(header['nUtime'][0])
                     self.miliSecond = int(header['nMilsec'][0])
                     self.timeZone = int(header['nTimezone'][0])
                     self.dstFlag = int(header['nDstflag'][0])
                     self.errorCount = int(header['nErrorCount'][0])
                     if self.size < 24:
                         return 0
                     self.length = header.nbytes
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
                     header = numpy.array(headerTuple, BASIC_STRUCTURE)
                     header.tofile(fp)
                     return 1
                 def get_ltc(self):
                     return self.utc - self.timeZone*60
                 def set_ltc(self, value):
                     self.utc = value + self.timeZone*60
                 def get_datatime(self):
                     return datetime.datetime.utcfromtimestamp(self.ltc)
                 ltc = property(get_ltc, set_ltc)
                 datatime = property(get_datatime)
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
+                structure = SYSTEM_STRUCTURE
-                def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWith=0):
+                def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
                     self.size = 24
                     self.nSamples = nSamples
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.adcResolution = adcResolution
-                    self.pciDioBusWidth = pciDioBusWith
+                    self.pciDioBusWidth = pciDioBusWidth
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception, e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, SYSTEM_STRUCTURE,1)
                         else:
                             header = numpy.fromstring(fp, SYSTEM_STRUCTURE,1)
                     except Exception, e:
                         print "System Header: " + str(e)
                         return 0
                     self.size = header['nSize'][0]
                     self.nSamples = header['nNumSamples'][0]
                     self.nProfiles = header['nNumProfiles'][0]
                     self.nChannels = header['nNumChannels'][0]
                     self.adcResolution = header['nADCResolution'][0]
                     self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
                     if startFp is not None:
                         endFp = self.size + startFp
                         if fp.tell() > endFp:
                             sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
                             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
                             return 0
                     self.length = header.nbytes
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
                     header = numpy.array(headerTuple,SYSTEM_STRUCTURE)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
-                prePulserAfter = None
+                prePulseAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
+                structure = RADAR_STRUCTURE
                 __size = None
                 def __init__(self, expType=2, nTx=1,
-                             ippKm=None, txA=0, txB=0,
+                             ipp=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=0, nBaud=0, code=None,
                              flip1=0, flip2=0):
             #         self.size = 116
                     self.expType = expType
                     self.nTx = nTx
-                    self.ipp = ippKm
+                    self.ipp = ipp
                     self.txA = txA
                     self.txB = txB
-                    self.rangeIpp = ippKm
+                    self.rangeIpp = ipp
                     self.rangeTxA = txA
                     self.rangeTxB = txB
                     self.nWindows = nWindows
                     self.numTaus = numTaus
                     self.codeType = codeType
                     self.line6Function = line6Function
                     self.line5Function = line5Function
                     self.fClock = fClock
                     self.prePulseBefore = prePulseBefore
-                    self.prePulserAfter = prePulseAfter
+                    self.prePulseAfter = prePulseAfter
                     self.nHeights = nHeights
                     self.firstHeight = firstHeight
                     self.deltaHeight = deltaHeight
                     self.samplesWin = nHeights
                     self.nCode = nCode
                     self.nBaud = nBaud
                     self.code = code
                     self.flip1 = flip1
                     self.flip2 = flip2
                     self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
             #         self.dynamic = numpy.array([],numpy.dtype('byte'))
                     if self.fClock is None and self.deltaHeight is not None:
                         self.fClock = 0.15/(deltaHeight*1e-6)   #0.15Km / (height * 1u)
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception, e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, RADAR_STRUCTURE,1)
                         else:
                             header = numpy.fromstring(fp, RADAR_STRUCTURE,1)
                         self.length += header.nbytes
                     except Exception, e:
                         print "RadarControllerHeader: " + str(e)
                         return 0
                     size = int(header['nSize'][0])
                     self.expType = int(header['nExpType'][0])
                     self.nTx = int(header['nNTx'][0])
                     self.ipp = float(header['fIpp'][0])
                     self.txA = float(header['fTxA'][0])
                     self.txB = float(header['fTxB'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.numTaus = int(header['nNumTaus'][0])
                     self.codeType = int(header['nCodeType'][0])
                     self.line6Function = int(header['nLine6Function'][0])
                     self.line5Function = int(header['nLine5Function'][0])
                     self.fClock = float(header['fClock'][0])
                     self.prePulseBefore = int(header['nPrePulseBefore'][0])
-                    self.prePulserAfter = int(header['nPrePulseAfter'][0])
+                    self.prePulseAfter = int(header['nPrePulseAfter'][0])
                     self.rangeIpp = header['sRangeIPP'][0]
                     self.rangeTxA = header['sRangeTxA'][0]
                     self.rangeTxB = header['sRangeTxB'][0]
                     try:
                         if hasattr(fp, 'read'):
                             samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
                             samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception, e:
                         print "RadarControllerHeader: " + str(e)
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = samplingWindow['h0']
                     self.deltaHeight = samplingWindow['dh']
                     self.samplesWin = samplingWindow['nsa']
                     try:
                         if hasattr(fp, 'read'):
                             self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
                         else:
                             self.Taus = numpy.fromstring(fp[self.length:], '<f4', self.numTaus)
                         self.length += self.Taus.nbytes
                     except Exception, e:
                         print "RadarControllerHeader: " + str(e)
                         return 0
                     self.code_size = 0
                     if self.codeType != 0:
                         try:
                             if hasattr(fp, 'read'):
                                 self.nCode = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
                                 self.nBaud = numpy.fromfile(fp, '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                             else:
                                 self.nCode = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nCode.nbytes
                                 self.nBaud = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
                         except Exception, e:
                             print "RadarControllerHeader: " + str(e)
                             return 0
                         code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
                         for ic in range(self.nCode):
                             try:
                                 if hasattr(fp, 'read'):
                                     temp = numpy.fromfile(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
                                 else:
                                     temp = numpy.fromstring(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
                                 self.length += temp.nbytes
                             except Exception, e:
                                 print "RadarControllerHeader: " + str(e)
                                 return 0
                             for ib in range(self.nBaud-1,-1,-1):
                                 code[ic,ib] = temp[ib/32]%2
                                 temp[ib/32] = temp[ib/32]/2
                         self.code = 2.0*code - 1.0
                         self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
             #             if self.line5Function == RCfunction.FLIP:
             #                 self.flip1 = numpy.fromfile(fp,'<u4',1)
             #
             #             if self.line6Function == RCfunction.FLIP:
             #                 self.flip2 = numpy.fromfile(fp,'<u4',1)
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() != endFp:
                 #             fp.seek(endFp)
                             print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" %(fp.name, fp.tell()-startFp, size)
                 #             return 0
                         if fp.tell() > endFp:
                             sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
                 #             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.expType,
                                    self.nTx,
                                    self.ipp,
                                    self.txA,
                                    self.txB,
                                    self.nWindows,
                                    self.numTaus,
                                    self.codeType,
                                    self.line6Function,
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
-                                   self.prePulserAfter,
+                                   self.prePulseAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple,RADAR_STRUCTURE)
                     header.tofile(fp)
                     sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                     samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
                     samplingWindow.tofile(fp)
                     if self.numTaus > 0:
                         self.Taus.tofile(fp)
                     if self.codeType !=0:
                         nCode = numpy.array(self.nCode, '<u4')
                         nCode.tofile(fp)
                         nBaud = numpy.array(self.nBaud, '<u4')
                         nBaud.tofile(fp)
                         code1 = (self.code + 1.0)/2.
                         for ic in range(self.nCode):
                             tempx = numpy.zeros(numpy.ceil(self.nBaud/32.))
                             start = 0
                             end = 32
                             for i in range(len(tempx)):
                                 code_selected = code1[ic,start:end]
                                 for j in range(len(code_selected)-1,-1,-1):
                                     if code_selected[j] == 1:
                                         tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
                                 start = start + 32
                                 end = end + 32
                             tempx = tempx.astype('u4')
                             tempx.tofile(fp)
             #         if self.line5Function == RCfunction.FLIP:
             #             self.flip1.tofile(fp)
             #
             #         if self.line6Function == RCfunction.FLIP:
             #             self.flip2.tofile(fp)
                     return 1
                 def get_ippSeconds(self):
                     '''
                     '''
                     ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
                     return ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0*1000)
                     return
                 def get_size(self):
                     self.__size = 116 + 12*self.nWindows + 4*self.numTaus
                     if self.codeType != 0:
                         self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
                     return self.__size
                 def set_size(self, value):
                     raise IOError, "size is a property and it cannot be set, just read"
                     return
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 size = property(get_size, set_size)
             class ProcessingHeader(Header):
             #     size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
+                structure = PROCESSING_STRUCTURE
                 flag_dc = None
                 flag_cspc = None
-                def __init__(self):
+                def __init__(self, dtype=0, blockSize=0, profilesPerBlock=0, dataBlocksPerFile=0, nWindows=0,processFlags=0, nCohInt=0,
+                            nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
+                            code=0, nBaud=None, shif_fft=False, flag_dc=False, flag_cspc=False, flag_decode=False, flag_deflip=False
+                            ):
             #         self.size = 0
-                    self.dtype = 0
+                    self.dtype = dtype
-                    self.blockSize = 0
+                    self.blockSize = blockSize
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.nHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
                     self.nCode = None
                     self.code = None
                     self.nBaud = None
                     self.shif_fft = False
                     self.flag_dc = False
                     self.flag_cspc = False
                     self.flag_decode = False
                     self.flag_deflip = False
                     self.length = 0
                 def read(self, fp):
                     self.length = 0
                     try:
                         startFp = fp.tell()
                     except Exception, e:
                         startFp = None
                         pass
                     try:
                         if hasattr(fp, 'read'):
                             header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1)
                         self.length += header.nbytes
                     except Exception, e:
                         print "ProcessingHeader: " + str(e)
                         return 0
                     size = int(header['nSize'][0])
                     self.dtype = int(header['nDataType'][0])
                     self.blockSize = int(header['nSizeOfDataBlock'][0])
                     self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                     self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.processFlags = header['nProcessFlags']
                     self.nCohInt = int(header['nCoherentIntegrations'][0])
                     self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                     self.totalSpectra = int(header['nTotalSpectra'][0])
                     try:
                         if hasattr(fp, 'read'):
                             samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
                         else:
                             samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
                     except Exception, e:
                         print "ProcessingHeader: " + str(e)
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = float(samplingWindow['h0'][0])
                     self.deltaHeight = float(samplingWindow['dh'][0])
                     self.samplesWin = samplingWindow['nsa'][0]
                     try:
                         if hasattr(fp, 'read'):
                             self.spectraComb = numpy.fromfile(fp, 'u1', 2*self.totalSpectra)
                         else:
                             self.spectraComb = numpy.fromstring(fp[self.length:], 'u1', 2*self.totalSpectra)
                         self.length += self.spectraComb.nbytes
                     except Exception, e:
                         print "ProcessingHeader: " + str(e)
                         return 0
                     if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                         self.nCode = int(numpy.fromfile(fp,'<u4',1))
                         self.nBaud = int(numpy.fromfile(fp,'<u4',1))
                         self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
                     if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
                         exp_name_len = int(numpy.fromfile(fp,'<u4',1))
                         exp_name = numpy.fromfile(fp,'u1',exp_name_len+1)
                     if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
                         self.shif_fft = True
                     else:
                         self.shif_fft = False
                     if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
                         self.flag_dc = True
                     else:
                         self.flag_dc = False
                     if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
                         self.flag_decode = True
                     else:
                         self.flag_decode = False
                     if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
                         self.flag_deflip = True
                     else:
                         self.flag_deflip = False
                     nChannels = 0
                     nPairs = 0
                     pairList = []
                     for i in range( 0, self.totalSpectra*2, 2 ):
                         if self.spectraComb[i] == self.spectraComb[i+1]:
                             nChannels = nChannels + 1   #par de canales iguales
                         else:
                             nPairs = nPairs + 1 #par de canales diferentes
                             pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
                     self.flag_cspc = False
                     if nPairs > 0:
                         self.flag_cspc = True
                     if startFp is not None:
                         endFp = size + startFp
                         if fp.tell() > endFp:
                             sys.stderr.write("Warning: Processing header size is lower than it has to be")
                             return 0
                         if fp.tell() < endFp:
                             sys.stderr.write("Warning: Processing header size is greater than it is considered")
                     return 1
                 def write(self, fp):
                     #Clear DEFINE_PROCESS_CODE
                     self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
                     headerTuple = (self.size,
                                    self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple,PROCESSING_STRUCTURE)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
                         samplingWindow.tofile(fp)
                     if self.totalSpectra != 0:
             #             spectraComb = numpy.array([],numpy.dtype('u1'))
                         spectraComb = self.spectraComb
                         spectraComb.tofile(fp)
             #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
             #             nCode.tofile(fp)
             #
             #             nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
             #             nBaud.tofile(fp)
             #
             #             code = self.code.reshape(self.nCode*self.nBaud)
             #             code = code.astype(numpy.dtype('<f4'))
             #             code.tofile(fp)
                     return 1
                 def get_size(self):
                     self.__size = 40 + 12*self.nWindows + 2*self.totalSpectra
             #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #             self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
             #             self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
                     return self.__size
                 def set_size(self, value):
                     raise IOError, "size is a property and it cannot be set, just read"
                     return
                 size = property(get_size, set_size)
             class RCfunction:
                 NONE=0
                 FLIP=1
                 CODE=2
                 SAMPLING=3
                 LIN6DIV256=4
                 SYNCHRO=5
             class nCodeType:
                 NONE=0
                 USERDEFINE=1
                 BARKER2=2
                 BARKER3=3
                 BARKER4=4
                 BARKER5=5
                 BARKER7=6
                 BARKER11=7
                 BARKER13=8
                 AC128=9
                 COMPLEMENTARYCODE2=10
                 COMPLEMENTARYCODE4=11
                 COMPLEMENTARYCODE8=12
                 COMPLEMENTARYCODE16=13
                 COMPLEMENTARYCODE32=14
                 COMPLEMENTARYCODE64=15
                 COMPLEMENTARYCODE128=16
                 CODE_BINARY28=17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)
                 SPECTRA_CALC = numpy.uint32(0x00000004)
                 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
                 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
                 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
                 DATATYPE_CHAR = numpy.uint32(0x00000040)
                 DATATYPE_SHORT = numpy.uint32(0x00000080)
                 DATATYPE_LONG = numpy.uint32(0x00000100)
                 DATATYPE_INT64 = numpy.uint32(0x00000200)
                 DATATYPE_FLOAT = numpy.uint32(0x00000400)
                 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
                 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
                 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
                 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
                 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
                 DEFLIP_DATA = numpy.uint32(0x00010000)
                 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
                 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
                 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
                 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
                 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
                 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
                 EXP_NAME_ESP = numpy.uint32(0x00200000)
                 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
                 OPERATION_MASK = numpy.uint32(0x0000003F)
                 DATATYPE_MASK = numpy.uint32(0x00000FC0)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
             dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
             dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
             dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
             dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
             dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
             dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
             NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
             PROCFLAG_DTYPE_LIST =  [PROCFLAG.DATATYPE_CHAR,
                                    PROCFLAG.DATATYPE_SHORT,
                                    PROCFLAG.DATATYPE_LONG,
                                    PROCFLAG.DATATYPE_INT64,
                                    PROCFLAG.DATATYPE_FLOAT,
                                    PROCFLAG.DATATYPE_DOUBLE]
             DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
             def get_dtype_index(numpy_dtype):
                 index = None
                 for i in range(len(NUMPY_DTYPE_LIST)):
                     if numpy_dtype == NUMPY_DTYPE_LIST[i]:
                         index = i
                         break
                 return index
             def get_numpy_dtype(index):
                 return NUMPY_DTYPE_LIST[index]
             def get_procflag_dtype(index):
                 return PROCFLAG_DTYPE_LIST[index]
             def get_dtype_width(index):
                 return DTYPE_WIDTH[index]

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

             import os
             import datetime
             import numpy
             import copy
             from schainpy.model import *
             from figure import Figure, isRealtime
             class CorrelationPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'corr'
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 280
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = 1
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return None
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print 'Skipping this plot function'
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     lenfactor = factor.shape[1]
                     x = dataOut.getLagTRange(1)
                     y = dataOut.getHeiRange()
                     z = copy.copy(dataOut.data_corr[:,:,0,:])
                     for i in range(dataOut.data_corr.shape[0]):
                         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 = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Correlation"
                     xlabel = "Lag T (s)"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = dataOut.data_corr.shape[0]
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0
                         if zmax == None: zmax = 1
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         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)
                         axes = self.axesList[i*self.__nsubplots]
                         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='')
             #             if self.__showprofile:
             #                 axes = self.axesList[i*self.__nsubplots +1]
             #                 axes.pline(avgdB[i], y,
             #                         xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
             #                         xlabel='dB', ylabel='', title='',
             #                         ytick_visible=False,
             #                         grid='x')
             #
             #                 noiseline = numpy.repeat(noisedB[i], len(y))
             #                 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)

schainpy/model/graphics/jroplot_data.py +30 -15

             import os
             import time
             import glob
             import datetime
             from multiprocessing import Process
             import zmq
             import numpy
             import matplotlib
             import matplotlib.pyplot as plt
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
             from schainpy.model.proc.jroproc_base import Operation
             from schainpy.utils import log
             jet_values = matplotlib.pyplot.get_cmap("jet", 100)(numpy.arange(100))[10:90]
-            blu_values = matplotlib.pyplot.get_cmap("seismic_r", 20)(numpy.arange(20))[10:15]
+            blu_values = matplotlib.pyplot.get_cmap(
-            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list("jro", numpy.vstack((blu_values, jet_values)))
+                "seismic_r", 20)(numpy.arange(20))[10:15]
+            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
+                "jro", numpy.vstack((blu_values, jet_values)))
             matplotlib.pyplot.register_cmap(cmap=ncmap)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'RdBu_r', 'seismic')]
             def figpause(interval):
                 backend = plt.rcParams['backend']
                 if backend in matplotlib.rcsetup.interactive_bk:
                     figManager = matplotlib._pylab_helpers.Gcf.get_active()
                     if figManager is not None:
                         canvas = figManager.canvas
                         if canvas.figure.stale:
                             canvas.draw()
                         canvas.start_event_loop(interval)
                         return
             class PlotData(Operation, Process):
                 '''
                 Base class for Schain plotting operations
                 '''
                 CODE = 'Figure'
                 colormap = 'jro'
                 bgcolor = 'white'
                 CONFLATE = False
                 __MAXNUMX = 80
                 __missing = 1E30
                 def __init__(self, **kwargs):
                     Operation.__init__(self, plot=True, **kwargs)
                     Process.__init__(self)
                     self.kwargs['code'] = self.CODE
                     self.mp = False
                     self.data = None
                     self.isConfig = False
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.localtime = kwargs.pop('localtime', True)
                     self.show = kwargs.get('show', True)
                     self.save = kwargs.get('save', False)
                     self.colormap = kwargs.get('colormap', self.colormap)
                     self.colormap_coh = kwargs.get('colormap_coh', 'jet')
                     self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
                     self.colormaps = kwargs.get('colormaps', None)
                     self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
                     self.showprofile = kwargs.get('showprofile', False)
                     self.title = kwargs.get('wintitle', self.CODE.upper())
                     self.cb_label = kwargs.get('cb_label', None)
                     self.cb_labels = kwargs.get('cb_labels', None)
                     self.xaxis = kwargs.get('xaxis', 'frequency')
                     self.zmin = kwargs.get('zmin', None)
                     self.zmax = kwargs.get('zmax', None)
                     self.zlimits = kwargs.get('zlimits', None)
                     self.xmin = kwargs.get('xmin', None)
                     self.xmax = kwargs.get('xmax', None)
                     self.xrange = kwargs.get('xrange', 24)
                     self.ymin = kwargs.get('ymin', None)
                     self.ymax = kwargs.get('ymax', None)
                     self.xlabel = kwargs.get('xlabel', None)
                     self.__MAXNUMY = kwargs.get('decimation', 100)
                     self.showSNR = kwargs.get('showSNR', False)
                     self.oneFigure = kwargs.get('oneFigure', True)
                     self.width = kwargs.get('width', None)
                     self.height = kwargs.get('height', None)
                     self.colorbar = kwargs.get('colorbar', True)
                     self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
                     self.titles = ['' for __ in range(16)]
                 def __fmtTime(self, x, pos):
                     '''
                     '''
                     return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
                 def __setup(self):
                     '''
                     Common setup for all figures, here figures and axes are created
                     '''
                     self.setup()
                     self.time_label = 'LT' if self.localtime else 'UTC'
                     if self.data.localtime:
                         self.getDateTime = datetime.datetime.fromtimestamp
                     else:
                         self.getDateTime = datetime.datetime.utcfromtimestamp
                     if self.width is None:
                         self.width = 8
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.pf_axes = []
                     self.cmaps = []
                     size = '15%' if self.ncols == 1 else '30%'
                     pad = '4%' if self.ncols == 1 else '8%'
                     if self.oneFigure:
                         if self.height is None:
                             self.height = 1.4 * self.nrows + 1
                         fig = plt.figure(figsize=(self.width, self.height),
                                          edgecolor='k',
                                          facecolor='w')
                         self.figures.append(fig)
                         for n in range(self.nplots):
                             ax = fig.add_subplot(self.nrows, self.ncols, n + 1)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     else:
                         if self.height is None:
                             self.height = 3
                         for n in range(self.nplots):
                             fig = plt.figure(figsize=(self.width, self.height),
                                              edgecolor='k',
                                              facecolor='w')
                             ax = fig.add_subplot(1, 1, 1)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.figures.append(fig)
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     for n in range(self.nrows):
                         if self.colormaps is not None:
                             cmap = plt.get_cmap(self.colormaps[n])
                         else:
                             cmap = plt.get_cmap(self.colormap)
                         cmap.set_bad(self.bgcolor, 1.)
                         self.cmaps.append(cmap)
                     for fig in self.figures:
                         fig.canvas.mpl_connect('key_press_event', self.OnKeyPress)
                         fig.canvas.mpl_connect('scroll_event', self.OnBtnScroll)
                         fig.canvas.mpl_connect('button_press_event', self.onBtnPress)
                         fig.canvas.mpl_connect('motion_notify_event', self.onMotion)
                         fig.canvas.mpl_connect('button_release_event', self.onBtnRelease)
                         if self.show:
                             fig.show()
                 def OnKeyPress(self, event):
                     '''
                     Event for pressing keys (up, down) change colormap
                     '''
                     ax = event.inaxes
                     if ax in self.axes:
                         if event.key == 'down':
                             ax.index += 1
                         elif event.key == 'up':
                             ax.index -= 1
                         if ax.index < 0:
                             ax.index = len(CMAPS) - 1
                         elif ax.index == len(CMAPS):
                             ax.index = 0
                         cmap = CMAPS[ax.index]
                         ax.cbar.set_cmap(cmap)
                         ax.cbar.draw_all()
                         ax.plt.set_cmap(cmap)
                         ax.cbar.patch.figure.canvas.draw()
                         self.colormap = cmap.name
                 def OnBtnScroll(self, event):
                     '''
                     Event for scrolling, scale figure
                     '''
                     cb_ax = event.inaxes
                     if cb_ax in [ax.cbar.ax for ax in self.axes]:
                         ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
                         pt = ax.cbar.ax.bbox.get_points()[:,1]
                         nrm = ax.cbar.norm
                         vmin, vmax, p0, p1, pS = (nrm.vmin, nrm.vmax, pt[0], pt[1], event.y)
                         scale = 2 if event.step == 1 else 0.5
                         point = vmin + (vmax - vmin) / (p1 - p0)*(pS - p0)
                         ax.cbar.norm.vmin = point - scale*(point - vmin)
                         ax.cbar.norm.vmax = point - scale*(point - vmax)
                         ax.plt.set_norm(ax.cbar.norm)
                         ax.cbar.draw_all()
                         ax.cbar.patch.figure.canvas.draw()
                 def onBtnPress(self, event):
                     '''
                     Event for mouse button press
                     '''
                     cb_ax = event.inaxes
                     if cb_ax is None:
                         return
                     if cb_ax in [ax.cbar.ax for ax in self.axes]:
                         cb_ax.press = event.x, event.y
                     else:
                         cb_ax.press = None
                 def onMotion(self, event):
                     '''
                     Event for move inside colorbar
                     '''
                     cb_ax = event.inaxes
                     if cb_ax is None:
                         return
                     if cb_ax not in [ax.cbar.ax for ax in self.axes]:
                         return
                     if  cb_ax.press is None:
                         return
                     ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
                     xprev, yprev = cb_ax.press
                     dx = event.x - xprev
                     dy = event.y - yprev
                     cb_ax.press = event.x, event.y
                     scale = ax.cbar.norm.vmax - ax.cbar.norm.vmin
                     perc = 0.03
                     if event.button == 1:
                         ax.cbar.norm.vmin -= (perc*scale)*numpy.sign(dy)
                         ax.cbar.norm.vmax -= (perc*scale)*numpy.sign(dy)
                     elif event.button == 3:
                         ax.cbar.norm.vmin -= (perc*scale)*numpy.sign(dy)
                         ax.cbar.norm.vmax += (perc*scale)*numpy.sign(dy)
                     ax.cbar.draw_all()
                     ax.plt.set_norm(ax.cbar.norm)
                     ax.cbar.patch.figure.canvas.draw()
                 def onBtnRelease(self, event):
                     '''
                     Event for mouse button release
                     '''
                     cb_ax = event.inaxes
                     if cb_ax is not None:
                         cb_ax.press = None
                 def __add_axes(self, ax, size='30%', pad='8%'):
                     '''
                     Add new axes to the given figure
                     '''
                     divider = make_axes_locatable(ax)
                     nax = divider.new_horizontal(size=size, pad=pad)
                     ax.figure.add_axes(nax)
                     return nax
                     self.setup()
                 def setup(self):
                     '''
                     This method should be implemented in the child class, the following
                     attributes should be set:
                     self.nrows: number of rows
                     self.ncols: number of cols
                     self.nplots: number of plots (channels or pairs)
                     self.ylabel: label for Y axes
                     self.titles: list of axes title
                     '''
                     raise(NotImplementedError, 'Implement this method in child class')
                 def fill_gaps(self, x_buffer, y_buffer, z_buffer):
                     '''
                     Create a masked array for missing data
                     '''
                     if x_buffer.shape[0] < 2:
                         return x_buffer, y_buffer, z_buffer
                     deltas = x_buffer[1:] - x_buffer[0:-1]
                     x_median = numpy.median(deltas)
                     index = numpy.where(deltas > 5 * x_median)
                     if len(index[0]) != 0:
                         z_buffer[::, index[0], ::] = self.__missing
                         z_buffer = numpy.ma.masked_inside(z_buffer,
 .99 * self.__missing,
 .01 * self.__missing)
                     return x_buffer, y_buffer, z_buffer
                 def decimate(self):
                     # dx = int(len(self.x)/self.__MAXNUMX) + 1
                     dy = int(len(self.y) / self.__MAXNUMY) + 1
                     # x = self.x[::dx]
                     x = self.x
                     y = self.y[::dy]
                     z = self.z[::, ::, ::dy]
                     return x, y, z
                 def format(self):
                     '''
                     Set min and max values, labels, ticks and titles
                     '''
                     if self.xmin is None:
                         xmin = self.min_time
                     else:
                         if self.xaxis is 'time':
                             dt = self.getDateTime(self.min_time)
                             xmin = (dt.replace(hour=int(self.xmin), minute=0, second=0) - datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.data.localtime:
                                 xmin += time.timezone
                         else:
                             xmin = self.xmin
                     if self.xmax is None:
                         xmax = xmin + self.xrange * 60 * 60
                     else:
                         if self.xaxis is 'time':
                             dt = self.getDateTime(self.max_time)
                             xmax = (dt.replace(hour=int(self.xmax), minute=0, second=0) - datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.data.localtime:
                                 xmax += time.timezone
                         else:
                             xmax = self.xmax
                     ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
                     ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
                     Y = numpy.array([10, 20, 50, 100, 200, 500, 1000, 2000])
                     i = 1 if numpy.where(ymax < Y)[0][0] < 0 else numpy.where(ymax < Y)[0][0]
                     ystep = Y[i-1]/5
+                    ystep = 200 if ymax >= 800 else 100 if ymax >= 400 else 50 if ymax >= 200 else 20
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_facecolor(self.bgcolor)
                             ax.yaxis.set_major_locator(MultipleLocator(ystep))
                             if self.xaxis is 'time':
                                 ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
                                 ax.xaxis.set_major_locator(LinearLocator(9))
                             if self.xlabel is not None:
                                 ax.set_xlabel(self.xlabel)
                             ax.set_ylabel(self.ylabel)
                             ax.firsttime = False
                             if self.showprofile:
                                 self.pf_axes[n].set_ylim(ymin, ymax)
                                 self.pf_axes[n].set_xlim(self.zmin, self.zmax)
                                 self.pf_axes[n].set_xlabel('dB')
                                 self.pf_axes[n].grid(b=True, axis='x')
-                                [tick.set_visible(False) for tick in self.pf_axes[n].get_yticklabels()]
+                                [tick.set_visible(False)
+                                 for tick in self.pf_axes[n].get_yticklabels()]
                             if self.colorbar:
                                 ax.cbar = plt.colorbar(ax.plt, ax=ax, pad=0.02, aspect=10)
                                 ax.cbar.ax.tick_params(labelsize=8)
                                 ax.cbar.ax.press = None
                                 if self.cb_label:
                                     ax.cbar.set_label(self.cb_label, size=8)
                                 elif self.cb_labels:
                                     ax.cbar.set_label(self.cb_labels[n], size=8)
                         ax.set_title('{} - {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.max_time).strftime('%H:%M:%S'),
                                 self.time_label),
                             size=8)
                         ax.set_xlim(xmin, xmax)
                         ax.set_ylim(ymin, ymax)
                 def __plot(self):
                     '''
                     '''
                     log.success('Plotting', self.name)
                     self.plot()
                     self.format()
                     for n, fig in enumerate(self.figures):
                         if self.nrows == 0 or self.nplots == 0:
                             log.warning('No data', self.name)
                             continue
                         fig.tight_layout()
                         fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
                                                                              self.getDateTime(self.max_time).strftime('%Y/%m/%d')))
                         # fig.canvas.draw()
                         if self.save and self.data.ended:
                             channels = range(self.nrows)
                             if self.oneFigure:
                                 label = ''
                             else:
                                 label = '_{}'.format(channels[n])
                             figname = os.path.join(
                                 self.save,
                                 '{}{}_{}.png'.format(
                                     self.CODE,
                                     label,
                                     self.getDateTime(self.saveTime).strftime('%y%m%d_%H%M%S')
                                 )
                             )
                             print 'Saving figure: {}'.format(figname)
                             fig.savefig(figname)
                 def plot(self):
                     '''
                     '''
                     raise(NotImplementedError, 'Implement this method in child class')
                 def run(self):
                     log.success('Starting', self.name)
                     context = zmq.Context()
                     receiver = context.socket(zmq.SUB)
                     receiver.setsockopt(zmq.SUBSCRIBE, '')
                     receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)
                     if 'server' in self.kwargs['parent']:
-                        receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
+                        receiver.connect(
+                            'ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
                     else:
                         receiver.connect("ipc:///tmp/zmq.plots")
                     while True:
                         try:
                             self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)
                             if self.data.localtime and self.localtime:
                                 self.times = self.data.times
                             elif self.data.localtime and not self.localtime:
                                 self.times = self.data.times + time.timezone
                             elif not self.data.localtime and self.localtime:
                                 self.times = self.data.times - time.timezone
                             else:
                                 self.times = self.data.times
                             self.min_time = self.times[0]
                             self.max_time = self.times[-1]
                             if self.isConfig is False:
                                 self.__setup()
                                 self.isConfig = True
                             self.__plot()
                         except zmq.Again as e:
                             log.log('Waiting for data...')
                             if self.data:
                                 figpause(self.data.throttle)
                             else:
                                 time.sleep(2)
                 def close(self):
                     if self.data:
                         self.__plot()
             class PlotSpectraData(PlotData):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jro'
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols
                     self.height = 3 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width += 0.8 * self.ncols
                     self.ylabel = 'Range [Km]'
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'spc_mean':
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     z = self.data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         if self.CODE == 'spc_mean':
                             mean = self.data['mean'][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
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
-                                ax.plt_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], y)[0]
+                                ax.plt_profile = self.pf_axes[n].plot(
+                                    self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_mean':
                                 ax.plt_mean = ax.plot(mean, y, color='k')[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_mean':
                                 ax.plt_mean.set_data(mean, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
                         self.saveTime = self.max_time
             class PlotCrossSpectraData(PlotData):
                 CODE = 'cspc'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.4 * self.ncols
                     self.height = 3 * self.nrows
                     self.ylabel = 'Range [Km]'
                     self.showprofile = False
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     spc = self.data['spc']
                     cspc = self.data['cspc']
                     for n in range(self.nrows):
                         noise = self.data['noise'][n][-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
                         ax3 = self.axes[4 * n + 3]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
                             ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
                         ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc[pair[1]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
-                        self.titles.append('Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
+                        self.titles.append(
+                            'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
                         self.saveTime = self.max_time
             class PlotSpectraMeanData(PlotSpectraData):
                 '''
                 Plot for Spectra and Mean
                 '''
                 CODE = 'spc_mean'
                 colormap = 'jro'
             class PlotRTIData(PlotData):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jro'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [Km]'
                     self.cb_label = 'dB'
-                    self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
+                    self.titles = ['{} Channel {}'.format(
+                        self.CODE.upper(), x) for x in range(self.nrows)]
                 def plot(self):
                     self.x = self.times
                     self.y = self.data.heights
                     self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     for n, ax in enumerate(self.axes):
                         x, y, z = self.fill_gaps(*self.decimate())
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
-                                ax.plot_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], self.y)[0]
+                                ax.plot_profile = self.pf_axes[n].plot(
+                                    self.data['rti'][n][-1], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
-                                ax.plot_noise.set_data(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y)
+                                ax.plot_noise.set_data(numpy.repeat(
+                                    self.data['noise'][n][-1], len(self.y)), self.y)
                     self.saveTime = self.min_time
             class PlotCOHData(PlotRTIData):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [Km]'
                     if self.CODE == 'coh':
                         self.cb_label = ''
-                        self.titles = ['Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
+                        self.titles = [
+                            'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
-                        self.titles = ['Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
+                        self.titles = [
+                            'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
             class PlotPHASEData(PlotCOHData):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
             class PlotNoiseData(PlotData):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.titles = ['Noise']
                     self.colorbar = False
                 def plot(self):
                     x = self.times
                     xmin = self.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data[self.CODE]
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
                     self.ymax = numpy.nanmax(Y) + 5
                     self.saveTime = self.min_time
             class PlotSNRData(PlotRTIData):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
             class PlotDOPData(PlotRTIData):
                 '''
                 Plot for DOPPLER Data
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
             class PlotSkyMapData(PlotData):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'met'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     if self.figure is None:
                         self.figure = plt.figure(figsize=(self.width, self.height),
                                                  edgecolor='k',
                                                  facecolor='w')
                     else:
                         self.figure.clf()
-                    self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
+                    self.ax = plt.subplot2grid(
+                        (self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
                     self.ax.firsttime = True
                 def plot(self):
-                    arrayParameters = numpy.concatenate([self.data['param'][t] for t in self.times])
+                    arrayParameters = numpy.concatenate(
+                        [self.data['param'][t] for t in self.times])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     if self.ax.firsttime:
                         self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]
                         self.ax.set_ylim(0, 90)
                         self.ax.set_yticks(numpy.arange(0, 90, 20))
                         self.ax.set_xlabel(self.xlabel)
                         self.ax.set_ylabel(self.ylabel)
                         self.ax.yaxis.labelpad = 40
                         self.ax.firsttime = False
                     else:
                         self.ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.ax.set_title(title, size=8)
                     self.saveTime = self.max_time
             class PlotParamData(PlotRTIData):
                 '''
                 Plot for data_param object
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     if self.showSNR:
                         self.nrows += 1
                         self.nplots += 1
                     self.ylabel = 'Height [Km]'
                     self.titles = self.data.parameters \
                         if self.data.parameters else ['Param {}'.format(x) for x in xrange(self.nrows)]
                     if self.showSNR:
                         self.titles.append('SNR')
                 def plot(self):
                     self.data.normalize_heights()
                     self.x = self.times
                     self.y = self.data.heights
                     if self.showSNR:
                         self.z = numpy.concatenate(
                             (self.data[self.CODE], self.data['snr'])
                         )
                     else:
                         self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     for n, ax in enumerate(self.axes):
                         x, y, z = self.fill_gaps(*self.decimate())
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T*self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T*self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                     self.saveTime = self.min_time
             class PlotOutputData(PlotParamData):
                 '''
                 Plot data_output object
                 '''
                 CODE = 'output'
                 colormap = 'seismic'

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

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from figure import Figure, isRealtime
             from plotting_codes import *
             class SpectraHeisScope(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 230
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show = show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if dataOut.realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print 'Skipping this plot function'
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
             #        x = dataOut.heightList
                     c   =  3E8
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     #deberia cambiar para el caso de 1Mhz y 100KHz
                     x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
                     #para 1Mhz descomentar la siguiente linea
                     #x= x/(10000.0)
             #        y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
             #        y = y.real
                     factor = dataOut.normFactor
                     data = dataOut.data_spc / factor
                     datadB = 10.*numpy.log10(data)
                     y = datadB
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = ""
                     #para 1Mhz descomentar la siguiente linea
                     #xlabel = "Frequency x 10000"
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         ychannel = y[i,:]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[channelIndexList[i]], numpy.max(ychannel), str_datetime)
                         axes = self.axesList[i]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class RTIfromSpectraHeis(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'rtinoise'
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 820
                     self.HEIGHT = 200
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.xdata = None
                     self.ydata = None
                     self.figfile = None
                     self.PLOT_CODE = RTI_CODE
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show = show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if timerange != None:
                         self.timerange = timerange
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     data = dataOut.data_spc / factor
                     data = numpy.average(data,axis=1)
                     datadB = 10*numpy.log10(data)
             #        factor = dataOut.normFactor
             #        noise = dataOut.getNoise()/factor
             #        noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.tmin, self.tmax = self.getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(datadB)
                         if ymax == None: ymax = numpy.nanmax(datadB)
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                     self.setWinTitle(title)
             #        title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     title = "RTI - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     legendlabels = ["channel %d"%idchannel for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = datadB[channelIndexList].reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.tmin, xmax=self.tmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
                                 XAxisAsTime=True
                                 )
                     self.draw()
                     update_figfile = False
                     if dataOut.ltctime >= self.tmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)

schainpy/model/graphics/jroplot_spectra.py +2 -2

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from figure import Figure, isRealtime, isTimeInHourRange
             from plotting_codes import *
             class SpectraPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
-                    self.WIDTH = 250
+                    self.WIDTH = 300
-                    self.HEIGHT = 250
+                    self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency", colormap='jet', normFactor=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print 'Skipping this plot function'
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList" %channel
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.getNoise()/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class CrossSpectraPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTH = None
                 HEIGHT = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cspc'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 4
                     self.counter_imagwr = 0
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                     self.PLOT_CODE = CROSS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = 4
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", pairsList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         coh_min=None, coh_max=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None,
                         xaxis='frequency'):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %str(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if not pairsIndexList:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[:,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     noisedB = 10*numpy.log10(noise)
                     if coh_min == None:
                         coh_min = 0.0
                     if coh_max == None:
                         coh_max = 1.0
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
             #         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=False,
                                    show=show)
                         avg = numpy.abs(numpy.average(z, axis=1))
                         avgdB = 10*numpy.log10(avg)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         chan_index0 = dataOut.channelList.index(pair[0])
                         chan_index1 = dataOut.channelList.index(pair[1])
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[chan_index0], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index0,:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[chan_index1], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index1,:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots+1]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[chan_index0,:,:]*dataOut.data_spc[chan_index1,:,:])
                         coherence = numpy.abs(coherenceComplex)
             #            phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
                         phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
                         title = "Coherence Ch%d * Ch%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+2]
                         axes0.pcolor(x, y, coherence,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=coh_min, zmax=coh_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=coherence_cmap, cblabel='')
                         title = "Phase Ch%d * Ch%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+3]
                         axes0.pcolor(x, y, phase,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=phase_cmap, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class RTIPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'rti'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, colormap='jet',
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #colormap = kwargs.get('colormap', 'jet')
                     if HEIGHT is not None:
                         self.HEIGHT  = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
             #         factor = dataOut.normFactor
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10.*numpy.log10(avg)
                     # avgdB = dataOut.getPower()
                     thisDatetime = dataOut.datatime
             #         thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         noise = dataOut.noise/factor
                         noisedB = 10*numpy.log10(noise)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         axes = self.axesList[i*self.__nsubplots]
                         zdB = avgdB[index].reshape((1,-1))
                         axes.pcolorbuffer(x, y, zdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap=colormap)
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
             class CoherenceMap(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cmap'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = COH_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.counter_imagwr = 0
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots*2
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0.
                         if zmax == None: zmax = 1.
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         coherence = numpy.abs(avgcoherenceComplex)
                         z = coherence.reshape((1,-1))
                         counter = 0
                         title = "Coherence Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(coherence, y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=5,
                                     grid='x')
                         counter += 1
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         z = phase.reshape((1,-1))
                         title = "Phase Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2 + counter]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(phase, y,
                                     xmin=phase_min, xmax=phase_max, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=4,
                                     grid='x')
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
             class PowerProfilePlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spcprofile'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 300
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     #for voltage
                     if dataOut.type == 'Voltage':
                         x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                         x = x.real
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                     #for spectra
                     if dataOut.type == 'Spectra':
                         x = dataOut.data_spc[channelIndexList,:,:]/factor
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                         x = numpy.average(x, axis=1)
                     xdB = 10*numpy.log10(x)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "dB"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if xmin == None: xmin = numpy.nanmin(xdB)*0.9
                         if xmax == None: xmax = numpy.nanmax(xdB)*1.1
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["channel %d"%x for x in channelList]
                     axes.pmultiline(xdB, y,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class SpectraCutPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc_cut'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 700
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None,
                         xaxis="frequency"):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     hei_index = numpy.arange(25)*3 + 20
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange()/1000.
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Frequency (kHz)"
                         ylabel = "Power (dB)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange()
                         zdB = z[0,:,hei_index]
                         xlabel = "Time (ms)"
                         ylabel = "ACF"
                     else:
                         x = dataOut.getVelRange()
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Velocity (m/s)"
                         ylabel = "Power (dB)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Range Cuts %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)*0.9
                         if xmax == None: xmax = numpy.nanmax(x)*1.1
                         if ymin == None: ymin = numpy.nanmin(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Spectra Cuts: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["Range = %dKm" %y[i] for i in hei_index]
                     axes.pmultilineyaxis( x, zdB,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class Noise(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'noise'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = NOISE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def openfile(self, filename):
                     dirname = os.path.dirname(filename)
                     if not os.path.exists(dirname):
                         os.mkdir(dirname)
                     f = open(filename,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
                     f.write('DD MM YYYY  HH MM SS   Channel0    Channel1    Channel2    Channel3\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     data_msg = ''
                     for i in range(len(data)):
                         data_msg += str(data[i]) + '  '
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   ' + data_msg + '\n')
                     f.close()
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     noise = dataOut.noise[channelIndexList]/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Intensity (dB)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.floor(numpy.nanmin(noisedB)) - 10.0
                         if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         noise_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_noise = os.path.join(figpath,noise_file)
                     self.setWinTitle(title)
                     title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["channel %d"%(idchannel) for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = noisedB.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, noisedB.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     #store data beacon phase
                     if save:
                         self.save_data(self.filename_noise, noisedB, thisDatetime)
             class BeaconPhase(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     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.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     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.close()
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
             #         if len(pairsIndexList) > 4:
             #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     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_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)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         #print "Phase %d%d" %(pair[0], pair[1])
                         #print phase[dataOut.beacon_heiIndexList]
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     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]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)

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

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from figure import Figure
             class Scope(Figure):
                 isConfig = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.WIDTH = 300
                     self.HEIGHT = 200
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     self.createFigure(id=id,
                                       wintitle=wintitle,
                                       show=show)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                 def plot_iq(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     yreal = y[channelIndexList,:].real
                     yimag = y[channelIndexList,:].imag
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity - IQ"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = min(numpy.nanmin(yreal),numpy.nanmin(yimag))
                         if ymax == None: ymax = max(numpy.nanmax(yreal),numpy.nanmax(yimag))
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         axes.pline(x, yreal[i,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                         axes.addpline(x, yimag[i,:], idline=1, color="red", linestyle="solid", lw=2)
                 def plot_power(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
                     yreal = y.real
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(yreal)
                         if ymax == None: ymax = numpy.nanmax(yreal)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = yreal[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, show=True, wr_period=1,
-                        ftp=False, server=None, folder=None, username=None, password=None, type='power'):
+                        ftp=False, server=None, folder=None, username=None, password=None, type='power', **kwargs):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     if dataOut.flagDataAsBlock:
                         for i in range(dataOut.nProfiles):
                             wintitle1 = wintitle + " [Profile = %d] " %i
                             if type == "power":
                                 self.plot_power(dataOut.heightList,
                                                 dataOut.data[:,i,:],
                                                 id,
                                                 channelIndexList,
                                                 thisDatetime,
                                                 wintitle1,
                                                 show,
                                                 xmin,
                                                 xmax,
                                                 ymin,
                                                 ymax)
                             if type == "iq":
                                 self.plot_iq(dataOut.heightList,
                                              dataOut.data[:,i,:],
                                              id,
                                              channelIndexList,
                                              thisDatetime,
                                              wintitle1,
                                              show,
                                              xmin,
                                              xmax,
                                              ymin,
                                              ymax)
                             self.draw()
                             str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                             figfile = self.getFilename(name = str_datetime) + "_" + str(i)
                             self.save(figpath=figpath,
                                       figfile=figfile,
                                       save=save,
                                       ftp=ftp,
                                       wr_period=wr_period,
                                       thisDatetime=thisDatetime)
                     else:
                         wintitle += " [Profile = %d] " %dataOut.profileIndex
                         if type == "power":
                             self.plot_power(dataOut.heightList,
                                             dataOut.data,
                                             id,
                                             channelIndexList,
                                             thisDatetime,
                                             wintitle,
                                             show,
                                             xmin,
                                             xmax,
                                             ymin,
                                             ymax)
                         if type == "iq":
                             self.plot_iq(dataOut.heightList,
                                          dataOut.data,
                                          id,
                                          channelIndexList,
                                          thisDatetime,
                                          wintitle,
                                          show,
                                          xmin,
                                          xmax,
                                          ymin,
                                          ymax)
                     self.draw()
                     str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") + "_" + str(dataOut.profileIndex)
                     figfile = self.getFilename(name = str_datetime)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)

schainpy/model/graphics/mpldriver.py +50 -36

             import numpy
             import datetime
             import sys
             import matplotlib
             if 'linux' in sys.platform:
-                matplotlib.use("GTK3Agg")
+                matplotlib.use("TkAgg")
             if 'darwin' in sys.platform:
                 matplotlib.use('TKAgg')
             # Qt4Agg', 'GTK', 'GTKAgg', 'ps', 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg', 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg', 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX'
             import matplotlib.pyplot
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import FuncFormatter, LinearLocator
             ###########################################
             # Actualizacion de las funciones del driver
             ###########################################
             # create jro colormap
             jet_values = matplotlib.pyplot.get_cmap("jet", 100)(numpy.arange(100))[10:90]
-            blu_values = matplotlib.pyplot.get_cmap("seismic_r", 20)(numpy.arange(20))[10:15]
+            blu_values = matplotlib.pyplot.get_cmap(
-            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list("jro", numpy.vstack((blu_values, jet_values)))
+                "seismic_r", 20)(numpy.arange(20))[10:15]
+            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
+                "jro", numpy.vstack((blu_values, jet_values)))
             matplotlib.pyplot.register_cmap(cmap=ncmap)
             def createFigure(id, wintitle, width, height, facecolor="w", show=True, dpi=80):
                 matplotlib.pyplot.ioff()
-                fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor, figsize=(1.0*width/dpi, 1.0*height/dpi))
+                fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor, figsize=(
+.0 * width / dpi, 1.0 * height / dpi))
                 fig.canvas.manager.set_window_title(wintitle)
             #     fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 if show:
                     matplotlib.pyplot.show()
                 return fig
             def closeFigure(show=False, fig=None):
                 #     matplotlib.pyplot.ioff()
                 #     matplotlib.pyplot.pause(0)
                 if show:
                     matplotlib.pyplot.show()
                 if fig != None:
                     matplotlib.pyplot.close(fig)
             #         matplotlib.pyplot.pause(0)
             #         matplotlib.pyplot.ion()
                     return
                 matplotlib.pyplot.close("all")
             #     matplotlib.pyplot.pause(0)
             #     matplotlib.pyplot.ion()
                 return
             def saveFigure(fig, filename):
                 #     matplotlib.pyplot.ioff()
                 fig.savefig(filename, dpi=matplotlib.pyplot.gcf().dpi)
             #     matplotlib.pyplot.ion()
             def clearFigure(fig):
                 fig.clf()
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTitle(fig, title):
                 fig.suptitle(title)
             def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan, polar=False):
                 matplotlib.pyplot.ioff()
                 matplotlib.pyplot.figure(fig.number)
                 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
                                                       (xpos, ypos),
                                                       colspan=colspan,
                                                       rowspan=rowspan,
                                                       polar=polar)
-                axes.grid(True)
                 matplotlib.pyplot.ion()
                 return axes
             def setAxesText(ax, text):
                 ax.annotate(text,
                             xy=(.1, .99),
                             xycoords='figure fraction',
                             horizontalalignment='left',
                             verticalalignment='top',
                             fontsize=10)
             def printLabels(ax, xlabel, ylabel, title):
                 ax.set_xlabel(xlabel, size=11)
                 ax.set_ylabel(ylabel, size=11)
                 ax.set_title(title, size=8)
             def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None, color='blue'):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 ######################################################
                 if (xmax - xmin) <= 1:
                     xtickspos = numpy.linspace(xmin, xmax, nxticks)
                     xtickspos = numpy.array([float("%.1f" % i) for i in xtickspos])
                     ax.set_xticks(xtickspos)
                 else:
-                    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
+                    xtickspos = numpy.arange(nxticks) * \
+                        int((xmax - xmin) / (nxticks)) + int(xmin)
             #         xtickspos = numpy.arange(nxticks)*float(xmax-xmin)/float(nxticks) + int(xmin)
                     ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ######################################################
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ax.plot(x, y, color=color)
                 iplot = ax.lines[-1]
                 ######################################################
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def set_linedata(ax, x, y, idline):
                 ax.lines[idline].set_data(x, y)
             def pline(iplot, x, y, xlabel='', ylabel='', title=''):
-                ax = iplot.get_axes()
+                ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def addpline(ax, x, y, color, linestyle, lw):
                 ax.plot(x, y, color=color, linestyle=linestyle, lw=lw)
             def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
                              xlabel='', ylabel='', title='', ticksize=9,
                              colormap='jet', cblabel='', cbsize="5%",
                              XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 divider = make_axes_locatable(ax)
                 ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
                 fig = ax.get_figure()
                 fig.add_axes(ax_cb)
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 z = numpy.ma.masked_invalid(z)
                 cmap = matplotlib.pyplot.get_cmap(colormap)
-                cmap.set_bad('white',1.)
+                cmap.set_bad('black', 1.)
                 imesh = ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax, cmap=cmap)
                 cb = matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                 cb.set_label(cblabel)
             #    for tl in ax_cb.get_yticklabels():
             #        tl.set_visible(True)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in cb.ax.get_yticklabels():
                     tick.set_fontsize(ticksize)
                 ax_cb.yaxis.tick_right()
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return imesh
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return imesh
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
-                    func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
+                    def func(x, pos): return ('%s') % (
+                        datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
-                ax.grid(True)
                 matplotlib.pyplot.ion()
                 return imesh
-            def pcolor(imesh, z, xlabel='', ylabel='', title=''):
-                z = numpy.ma.masked_invalid(z)
+            def pcolor(imesh, z, xlabel='', ylabel='', title=''):
-                cmap=matplotlib.pyplot.get_cmap('jet')
-                cmap.set_bad('white',1.)
                 z = z.T
-                ax = imesh.get_axes()
+                ax = imesh.axes
                 printLabels(ax, xlabel, ylabel, title)
                 imesh.set_array(z.ravel())
-                ax.grid(True)
             def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
-                z = numpy.ma.masked_invalid(z)
-                cmap=matplotlib.pyplot.get_cmap(colormap)
+                ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax,
-                cmap.set_bad('white',1.)
+                              cmap=matplotlib.pyplot.get_cmap(colormap))
-                ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
-                ax.grid(True)
             def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.collections.remove(ax.collections[0])
                 z = numpy.ma.masked_invalid(z)
                 cmap = matplotlib.pyplot.get_cmap(colormap)
-                cmap.set_bad('white',1.)
+                cmap.set_bad('black', 1.)
                 ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax, cmap=cmap)
-                ax.grid(True)
             def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                                  ticksize=9, xtick_visible=True, ytick_visible=True,
                                  nxticks=4, nyticks=10,
                                  grid=None):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 lines = ax.plot(x.T, y)
                 leg = ax.legend(lines, legendlabels, loc='upper right')
                 leg.get_frame().set_alpha(0.5)
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
-                xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
+                xtickspos = numpy.arange(nxticks) * \
+                    int((xmax - xmin) / (nxticks)) + int(xmin)
                 ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
-                ax = iplot.get_axes()
+                ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x[i, :], y)
             def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                                       ticksize=9, xtick_visible=True, ytick_visible=True,
                                       nxticks=4, nyticks=10, marker='.', markersize=10, linestyle="None",
                                       grid=None, XAxisAsTime=False):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
             #    lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
                 lines = ax.plot(x, y.T)
             #     leg = ax.legend(lines, legendlabels, loc=2, bbox_to_anchor=(1.01, 1.00), numpoints=1, handlelength=1.5, \
             #                     handletextpad=0.5, borderpad=0.5, labelspacing=0.5, borderaxespad=0.)
                 leg = ax.legend(lines, legendlabels,
                                 loc='upper right', bbox_to_anchor=(1.16, 1), borderaxespad=0)
-                for label in leg.get_texts(): label.set_fontsize(9)
+                for label in leg.get_texts():
+                    label.set_fontsize(9)
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
             #    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
             #    ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
-                    func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
+                    def func(x, pos): return ('%s') % (
+                        datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
-                ax = iplot.get_axes()
+                ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x, y[i, :])
             def createPolar(ax, x, y,
                             xlabel='', ylabel='', title='', ticksize=9,
                             colormap='jet', cblabel='', cbsize="5%",
                             XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 ax.plot(x, y, 'bo', markersize=5)
             #     ax.set_rmax(90)
                 ax.set_ylim(0, 90)
                 ax.set_yticks(numpy.arange(0, 90, 20))
             #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center' ,size='11')
             #     ax.text(0, 50, ylabel, rotation='vertical', va ='center', ha = 'left' ,size='11')
             #     ax.text(100, 100, 'example', ha='left', va='center', rotation='vertical')
-                ax.yaxis.labelpad = 230
+                ax.yaxis.labelpad = 40
                 printLabels(ax, xlabel, ylabel, title)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
             #     if grid != None:
             #         ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def polar(iplot, x, y, xlabel='', ylabel='', title=''):
-                ax = iplot.get_axes()
+                ax = iplot.axes
             #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center',size='11')
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def draw(fig):
                 if type(fig) == 'int':
                     raise ValueError, "Error drawing: Fig parameter should be a matplotlib figure object figure"
                 fig.canvas.draw()
             def pause(interval=0.000001):
                 matplotlib.pyplot.pause(interval)

schainpy/model/io/MIRAtest.py +48 -38

-            import os, sys
+            import os
+            import sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
-            import matplotlib.pyplot as plt
-            import pylab as plb
             from scipy.optimize import curve_fit
             from scipy import asarray as ar, exp
             from scipy import stats
             from duplicity.path import Path
             from numpy.ma.core import getdata
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
             #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 numpy import imag, shape, NaN
-            startFp = open('/home/erick/Documents/MIRA35C/20160117/20160117_0000.zspc',"rb")
+            startFp = open(
+                '/home/erick/Documents/MIRA35C/20160117/20160117_0000.zspc', "rb")
             FILE_HEADER = numpy.dtype([  # HEADER 1024bytes
                                       ('Hname', numpy.str_, 32),  # Original file name
-                                      ('Htime',numpy.str_,32),      #Date and time when the file was created
+                                      # Date and time when the file was created
-                                      ('Hoper',numpy.str_,64),      #Name of operator who created the file
+                                      ('Htime', numpy.str_, 32),
-                                      ('Hplace',numpy.str_,128),    #Place where the measurements was carried out
+                                      # Name of operator who created the file
-                                      ('Hdescr',numpy.str_,256),    #Description of measurements
+                                      ('Hoper', numpy.str_, 64),
+                                      # Place where the measurements was carried out
+                                      ('Hplace', numpy.str_, 128),
+                                      # Description of measurements
+                                      ('Hdescr', numpy.str_, 256),
                                       ('Hdummy', numpy.str_, 512),  # Reserved space
                                       # Main chunk
                                       ('Msign', '<i4'),  # Main chunk signature FZKF or NUIG
                                       ('MsizeData', '<i4'),  # Size of data block main chunk
                                       # Processing DSP parameters
                                       ('PPARsign', '<i4'),  # PPAR signature
                                       ('PPARsize', '<i4'),  # PPAR size of block
                                       ('PPARprf', '<i4'),  # Pulse repetition frequency
                                       ('PPARpdr', '<i4'),  # Pulse duration
                                       ('PPARsft', '<i4'),  # FFT length
-                                      ('PPARavc','<i4'),        #Number of spectral (in-coherent) averages
+                                      # Number of spectral (in-coherent) averages
-                                      ('PPARihp','<i4'),        #Number of lowest range gate for moment estimation
+                                      ('PPARavc', '<i4'),
-                                      ('PPARchg','<i4'),        #Count for gates for moment estimation
+                                      # Number of lowest range gate for moment estimation
-                                      ('PPARpol','<i4'),        #switch on/off polarimetric measurements. Should be 1.
+                                      ('PPARihp', '<i4'),
+                                      # Count for gates for moment estimation
+                                      ('PPARchg', '<i4'),
+                                      # switch on/off polarimetric measurements. Should be 1.
+                                      ('PPARpol', '<i4'),
                                       # Service DSP parameters
-                                      ('SPARatt','<i4'),       #STC attenuation on the lowest ranges on/off
+                                      # STC attenuation on the lowest ranges on/off
+                                      ('SPARatt', '<i4'),
                                       ('SPARtx', '<i4'),  # OBSOLETE
                                       ('SPARaddGain0', '<f4'),  # OBSOLETE
                                       ('SPARaddGain1', '<f4'),  # OBSOLETE
-                                      ('SPARwnd','<i4'),     #Debug only. It normal mode it is 0.
+                                      # Debug only. It normal mode it is 0.
-                                      ('SPARpos','<i4'),     #Delay between sync pulse and tx pulse for phase corr, ns
+                                      ('SPARwnd', '<i4'),
-                                      ('SPARadd','<i4'),     #"add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
+                                      # Delay between sync pulse and tx pulse for phase corr, ns
-                                      ('SPARlen','<i4'),     #Time for measuring txn pulse phase. OBSOLETE
+                                      ('SPARpos', '<i4'),
+                                      # "add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
+                                      ('SPARadd', '<i4'),
+                                      # Time for measuring txn pulse phase. OBSOLETE
+                                      ('SPARlen', '<i4'),
                                       ('SPARcal', '<i4'),  # OBSOLETE
                                       ('SPARnos', '<i4'),  # OBSOLETE
                                       ('SPARof0', '<i4'),  # detection threshold
                                       ('SPARof1', '<i4'),  # OBSOLETE
                                       ('SPARswt', '<i4'),  # 2nd moment estimation threshold
                                       ('SPARsum', '<i4'),  # OBSOLETE
                                       ('SPARosc', '<i4'),  # flag Oscillosgram mode
                                       ('SPARtst', '<i4'),  # OBSOLETE
                                       ('SPARcor', '<i4'),  # OBSOLETE
                                       ('SPARofs', '<i4'),  # OBSOLETE
-                                      ('SPARhsn','<i4'),     #Hildebrand div noise detection on noise gate
+                                      # Hildebrand div noise detection on noise gate
-                                      ('SPARhsa','<f4'),     #Hildebrand div noise detection on all gates
+                                      ('SPARhsn', '<i4'),
+                                      # Hildebrand div noise detection on all gates
+                                      ('SPARhsa', '<f4'),
                                       ('SPARcalibPow_M', '<f4'),  # OBSOLETE
                                       ('SPARcalibSNR_M', '<f4'),  # OBSOLETE
                                       ('SPARcalibPow_S', '<f4'),  # OBSOLETE
                                       ('SPARcalibSNR_S', '<f4'),  # OBSOLETE
-                                      ('SPARrawGate1','<i4'),     #Lowest range gate for spectra saving Raw_Gate1 >=5
+                                      # Lowest range gate for spectra saving Raw_Gate1 >=5
-                                      ('SPARrawGate2','<i4'),     #Number of range gates with atmospheric signal
+                                      ('SPARrawGate1', '<i4'),
-                                      ('SPARraw','<i4'),          #flag - IQ or spectra saving on/off
+                                      # Number of range gates with atmospheric signal
+                                      ('SPARrawGate2', '<i4'),
+                                      # flag - IQ or spectra saving on/off
+                                      ('SPARraw', '<i4'),
                                       ('SPARprc', '<i4'), ])  # flag - Moment estimation switched on/off
             self.Hname = None
             self.Htime = None
             self.Hoper = None
             self.Hplace = None
             self.Hdescr = None
             self.Hdummy = None
             self.Msign = None
             self.MsizeData = None
             self.PPARsign = None
             self.PPARsize = None
             self.PPARprf = None
             self.PPARpdr = None
             self.PPARsft = None
             self.PPARavc = None
             self.PPARihp = None
             self.PPARchg = None
             self.PPARpol = None
             # Service DSP parameters
             self.SPARatt = None
             self.SPARtx = None
             self.SPARaddGain0 = None
             self.SPARaddGain1 = None
             self.SPARwnd = None
             self.SPARpos = None
             self.SPARadd = None
             self.SPARlen = None
             self.SPARcal = None
             self.SPARnos = None
             self.SPARof0 = None
             self.SPARof1 = None
             self.SPARswt = None
             self.SPARsum = None
             self.SPARosc = None
             self.SPARtst = None
             self.SPARcor = None
             self.SPARofs = None
             self.SPARhsn = None
             self.SPARhsa = None
             self.SPARcalibPow_M = None
             self.SPARcalibSNR_M = None
             self.SPARcalibPow_S = None
             self.SPARcalibSNR_S = None
             self.SPARrawGate1 = None
             self.SPARrawGate2 = None
             self.SPARraw = None
             self.SPARprc = None
             header = numpy.fromfile(fp, FILE_HEADER, 1)
             '''      numpy.fromfile(file, dtype, count, sep='')
                 file : file or str
                 Open file object or filename.
                 dtype : data-type
                 Data type of the returned array. For binary files, it is used to determine
                 the size and byte-order of the items in the file.
                 count : int
                 Number of items to read. -1 means all items (i.e., the complete file).
                 sep : str
                 Separator between items if file is a text file. Empty ("") separator means
                 the file should be treated as binary. Spaces (" ") in the separator match zero
                 or more whitespace characters. A separator consisting only of spaces must match
                 at least one whitespace.
             '''
             Hname = str(header['Hname'][0])
             Htime = str(header['Htime'][0])
             Hoper = str(header['Hoper'][0])
             Hplace = str(header['Hplace'][0])
             Hdescr = str(header['Hdescr'][0])
             Hdummy = str(header['Hdummy'][0])
             Msign = header['Msign'][0]
             MsizeData = header['MsizeData'][0]
             PPARsign = header['PPARsign'][0]
             PPARsize = header['PPARsize'][0]
             PPARprf = header['PPARprf'][0]
             PPARpdr = header['PPARpdr'][0]
             PPARsft = header['PPARsft'][0]
             PPARavc = header['PPARavc'][0]
             PPARihp = header['PPARihp'][0]
             PPARchg = header['PPARchg'][0]
             PPARpol = header['PPARpol'][0]
             # Service DSP parameters
             SPARatt = header['SPARatt'][0]
             SPARtx = header['SPARtx'][0]
             SPARaddGain0 = header['SPARaddGain0'][0]
             SPARaddGain1 = header['SPARaddGain1'][0]
             SPARwnd = header['SPARwnd'][0]
             SPARpos = header['SPARpos'][0]
             SPARadd = header['SPARadd'][0]
             SPARlen = header['SPARlen'][0]
             SPARcal = header['SPARcal'][0]
             SPARnos = header['SPARnos'][0]
             SPARof0 = header['SPARof0'][0]
             SPARof1 = header['SPARof1'][0]
             SPARswt = header['SPARswt'][0]
             SPARsum = header['SPARsum'][0]
             SPARosc = header['SPARosc'][0]
             SPARtst = header['SPARtst'][0]
             SPARcor = header['SPARcor'][0]
             SPARofs = header['SPARofs'][0]
             SPARhsn = header['SPARhsn'][0]
             SPARhsa = header['SPARhsa'][0]
             SPARcalibPow_M = header['SPARcalibPow_M'][0]
             SPARcalibSNR_M = header['SPARcalibSNR_M'][0]
             SPARcalibPow_S = header['SPARcalibPow_S'][0]
             SPARcalibSNR_S = header['SPARcalibSNR_S'][0]
             SPARrawGate1 = header['SPARrawGate1'][0]
             SPARrawGate2 = header['SPARrawGate2'][0]
             SPARraw = header['SPARraw'][0]
             SPARprc = header['SPARprc'][0]
             SRVI_STRUCTURE = numpy.dtype([
-                                        ('frame_cnt','<u4'),#
+                                        ('frame_cnt', '<u4'),
                                         ('time_t', '<u4'),   #
                                         ('tpow', '<f4'),     #
                                         ('npw1', '<f4'),     #
                                         ('npw2', '<f4'),     #
                                         ('cpw1', '<f4'),     #
                                         ('pcw2', '<f4'),     #
                                         ('ps_err', '<u4'),   #
                                         ('te_err', '<u4'),   #
                                         ('rc_err', '<u4'),   #
                                         ('grs1', '<u4'),     #
                                         ('grs2', '<u4'),     #
                                         ('azipos', '<f4'),     #
                                         ('azivel', '<f4'),     #
                                         ('elvpos', '<f4'),     #
                                         ('elvvel', '<f4'),     #
-                                        ('northAngle','<f4'), #
+                                        ('northAngle', '<f4'),
                                         ('microsec', '<u4'),   #
                                         ('azisetvel', '<f4'),  #
                                         ('elvsetpos', '<f4'),  #
                                         ('RadarConst', '<f4'), ])   #
             JUMP_STRUCTURE = numpy.dtype([
-                                        ('jump','<u140'),#
+                                        ('jump', '<u140'),
-                                        ('SizeOfDataBlock1',numpy.str_,32),#
+                                        ('SizeOfDataBlock1', numpy.str_, 32),
-                                        ('jump','<i4'),#
+                                        ('jump', '<i4'),
-                                        ('DataBlockTitleSRVI1',numpy.str_,32),#
+                                        ('DataBlockTitleSRVI1', numpy.str_, 32),
-                                        ('SizeOfSRVI1','<i4'),])#
+                                        ('SizeOfSRVI1', '<i4'), ])
             # 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,
             # grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,
             # microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0
             frame_cnt = frame_cnt
             dwell = time_t
             tpow = tpow
             npw1 = npw1
             npw2 = npw2
             cpw1 = cpw1
             pcw2 = pcw2
             ps_err = ps_err
             te_err = te_err
             rc_err = rc_err
             grs1 = grs1
             grs2 = grs2
             azipos = azipos
             azivel = azivel
             elvpos = elvpos
             elvvel = elvvel
             northAngle = northAngle
             microsec = microsec
             azisetvel = azisetvel
             elvsetpos = elvsetpos
             RadarConst5 = RadarConst
             # print fp
             # startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
             # startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
             # RecCounter=0
             # Off2StartNxtRec=811248
             # print 'OffsetStartHeader ',self.OffsetStartHeader,'RecCounter ', self.RecCounter, 'Off2StartNxtRec ' , self.Off2StartNxtRec
             #OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
             #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.frame_cnt = header['frame_cnt'][0]
             self.time_t = header['frame_cnt'][0]   #
             self.tpow = header['frame_cnt'][0]     #
             self.npw1 = header['frame_cnt'][0]     #
             self.npw2 = header['frame_cnt'][0]     #
             self.cpw1 = header['frame_cnt'][0]     #
             self.pcw2 = header['frame_cnt'][0]     #
             self.ps_err = header['frame_cnt'][0]    #
             self.te_err = header['frame_cnt'][0]    #
             self.rc_err = header['frame_cnt'][0]    #
             self.grs1 = header['frame_cnt'][0]      #
             self.grs2 = header['frame_cnt'][0]      #
             self.azipos = header['frame_cnt'][0]     #
             self.azivel = header['frame_cnt'][0]     #
             self.elvpos = header['frame_cnt'][0]     #
             self.elvvel = header['frame_cnt'][0]     #
             self.northAngle = header['frame_cnt'][0]    #
             self.microsec = header['frame_cnt'][0]      #
             self.azisetvel = header['frame_cnt'][0]     #
             self.elvsetpos = header['frame_cnt'][0]     #
             self.RadarConst = header['frame_cnt'][0]    #
             self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
             self.RHsize = 180 + 20 * self.nChannels
             self.Datasize = self.nProfiles * self.nChannels * self.nHeights * 2 * 4
             # print 'Datasize',self.Datasize
             endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
             print '=============================================='
             print '=============================================='
-  No newline at end of file

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

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             from jroIO_voltage import *
             from jroIO_spectra import *
             from jroIO_heispectra import *
             from jroIO_usrp import *
+            from jroIO_digitalRF import *
             from jroIO_kamisr import *
             from jroIO_param import *
             from jroIO_hf import *
             from jroIO_madrigal import *
             from bltrIO_param import *
             from jroIO_bltr import *
             from jroIO_mira35c import *

schainpy/model/io/bltrIO_param.py +7 -4

             '''
             Created on Nov 9, 2016
             @author: roj- LouVD
             '''
             import os
             import sys
             import time
             import glob
             import datetime
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit
             from schainpy.model.data.jrodata import Parameters
             from schainpy.model.io.jroIO_base import JRODataReader, isNumber
             from schainpy.utils import log
             FILE_HEADER_STRUCTURE = numpy.dtype([
                 ('FMN', '<u4'),
                 ('nrec', '<u4'),
                 ('fr_offset', '<u4'),
                 ('id', '<u4'),
                 ('site', 'u1', (32,))
             ])
             REC_HEADER_STRUCTURE = numpy.dtype([
                 ('rmn', '<u4'),
                 ('rcounter', '<u4'),
                 ('nr_offset', '<u4'),
                 ('tr_offset', '<u4'),
                 ('time', '<u4'),
                 ('time_msec', '<u4'),
                 ('tag', 'u1', (32,)),
                 ('comments', 'u1', (32,)),
                 ('lat', '<f4'),
                 ('lon', '<f4'),
                 ('gps_status', '<u4'),
                 ('freq', '<u4'),
                 ('freq0', '<u4'),
                 ('nchan', '<u4'),
                 ('delta_r', '<u4'),
                 ('nranges', '<u4'),
                 ('r0', '<u4'),
                 ('prf', '<u4'),
                 ('ncoh', '<u4'),
                 ('npoints', '<u4'),
                 ('polarization', '<i4'),
                 ('rx_filter', '<u4'),
                 ('nmodes', '<u4'),
                 ('dmode_index', '<u4'),
                 ('dmode_rngcorr', '<u4'),
                 ('nrxs', '<u4'),
                 ('acf_length', '<u4'),
                 ('acf_lags', '<u4'),
                 ('sea_to_atmos', '<f4'),
                 ('sea_notch', '<u4'),
                 ('lh_sea', '<u4'),
                 ('hh_sea', '<u4'),
                 ('nbins_sea', '<u4'),
                 ('min_snr', '<f4'),
                 ('min_cc', '<f4'),
                 ('max_time_diff', '<f4')
             ])
             DATA_STRUCTURE = numpy.dtype([
                 ('range', '<u4'),
                 ('status', '<u4'),
                 ('zonal', '<f4'),
                 ('meridional', '<f4'),
                 ('vertical', '<f4'),
                 ('zonal_a', '<f4'),
                 ('meridional_a', '<f4'),
                 ('corrected_fading', '<f4'),  # seconds
                 ('uncorrected_fading', '<f4'),  # seconds
                 ('time_diff', '<f4'),
                 ('major_axis', '<f4'),
                 ('axial_ratio', '<f4'),
                 ('orientation', '<f4'),
                 ('sea_power', '<u4'),
                 ('sea_algorithm', '<u4')
             ])
             class BLTRParamReader(JRODataReader, ProcessingUnit):
                 '''
                 Boundary Layer and Tropospheric Radar (BLTR) reader, Wind velocities and SNR from *.sswma files
                 '''
                 ext = '.sswma'
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     self.dataOut = Parameters()
                     self.counter_records = 0
                     self.flagNoMoreFiles = 0
                     self.isConfig = False
                     self.filename = None
                 def setup(self,
                           path=None,
                           startDate=None,
                           endDate=None,
                           ext=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           timezone=0,
                           status_value=0,
                           **kwargs):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.status_value = status_value
                     self.datatime = datetime.datetime(1900,1,1)
                     if self.path is None:
                         raise ValueError, "The path is not valid"
                     if ext is None:
                         ext = self.ext
                     self.search_files(self.path, startDate, endDate, ext)
                     self.timezone = timezone
                     self.fileIndex = 0
                     if not self.fileList:
-                        raise  Warning, "There is no files matching these date in the folder: %s. \n Check 'startDate' and 'endDate' "%(path)
+                        raise Warning, "There is no files matching these date in the folder: %s. \n Check 'startDate' and 'endDate' " % (
+                            path)
                     self.setNextFile()
                 def search_files(self, path, startDate, endDate, ext):
                     '''
                      Searching for BLTR rawdata file in path
                      Creating a list of file to proces included in [startDate,endDate]
                      Input:
                          path - Path to find BLTR rawdata files
                          startDate - Select file from this date
                          enDate - Select file until this date
                          ext - Extension of the file to read
                     '''
                     log.success('Searching files in {} '.format(path), 'BLTRParamReader')
                     foldercounter = 0
                     fileList0 = glob.glob1(path, "*%s" % ext)
                     fileList0.sort()
                     self.fileList = []
                     self.dateFileList = []
                     for thisFile in fileList0:
                         year = thisFile[-14:-10]
                         if not isNumber(year):
                             continue
                         month = thisFile[-10:-8]
                         if not isNumber(month):
                             continue
                         day = thisFile[-8:-6]
                         if not isNumber(day):
                             continue
                         year, month, day = int(year), int(month), int(day)
                         dateFile = datetime.date(year, month, day)
                         if (startDate > dateFile) or (endDate < dateFile):
                             continue
                         self.fileList.append(thisFile)
                         self.dateFileList.append(dateFile)
                     return
                 def setNextFile(self):
                     file_id = self.fileIndex
                     if file_id == len(self.fileList):
                         log.success('No more files in the folder', 'BLTRParamReader')
                         self.flagNoMoreFiles = 1
                         return 0
                     log.success('Opening {}'.format(self.fileList[file_id]), 'BLTRParamReader')
                     filename = os.path.join(self.path, self.fileList[file_id])
                     dirname, name = os.path.split(filename)
-                    self.siteFile = name.split('.')[0]  # 'peru2' ---> Piura  -   'peru1' ---> Huancayo or Porcuya
+                    # 'peru2' ---> Piura  -   'peru1' ---> Huancayo or Porcuya
+                    self.siteFile = name.split('.')[0]
                     if self.filename is not None:
                         self.fp.close()
                     self.filename = filename
                     self.fp = open(self.filename, 'rb')
                     self.header_file = numpy.fromfile(self.fp, FILE_HEADER_STRUCTURE, 1)
                     self.nrecords = self.header_file['nrec'][0]
                     self.sizeOfFile = os.path.getsize(self.filename)
                     self.counter_records = 0
                     self.flagIsNewFile = 0
                     self.fileIndex += 1
                     return 1
                 def readNextBlock(self):
                     while True:
                         if self.counter_records == self.nrecords:
                             self.flagIsNewFile = 1
                             if not self.setNextFile():
                                 return 0
                         self.readBlock()
                         if (self.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or \
                            (self.datatime > datetime.datetime.combine(self.endDate, self.endTime)):
                             log.warning(
                                 'Reading Record No. {}/{} -> {} [Skipping]'.format(
                                     self.counter_records,
                                     self.nrecords,
                                     self.datatime.ctime()),
                                 'BLTRParamReader')
                             continue
                         break
                     log.log('Reading Record No. {}/{} -> {}'.format(
                         self.counter_records,
                         self.nrecords,
                         self.datatime.ctime()), 'BLTRParamReader')
                     return 1
                 def readBlock(self):
                     pointer = self.fp.tell()
                     header_rec = numpy.fromfile(self.fp, REC_HEADER_STRUCTURE, 1)
                     self.nchannels = header_rec['nchan'][0] / 2
                     self.kchan = header_rec['nrxs'][0]
                     self.nmodes = header_rec['nmodes'][0]
                     self.nranges = header_rec['nranges'][0]
                     self.fp.seek(pointer)
                     self.height = numpy.empty((self.nmodes, self.nranges))
                     self.snr = numpy.empty((self.nmodes, self.nchannels, self.nranges))
                     self.buffer = numpy.empty((self.nmodes, 3, self.nranges))
                     self.flagDiscontinuousBlock = 0
                     for mode in range(self.nmodes):
                         self.readHeader()
                         data = self.readData()
                         self.height[mode] = (data[0] - self.correction) / 1000.
                         self.buffer[mode] = data[1]
                         self.snr[mode] = data[2]
                     self.counter_records = self.counter_records + self.nmodes
                     return
                 def readHeader(self):
                     '''
                     RecordHeader of BLTR rawdata file
                     '''
                     header_structure = numpy.dtype(
                         REC_HEADER_STRUCTURE.descr + [
                             ('antenna_coord', 'f4', (2, self.nchannels)),
                             ('rx_gains', 'u4', (self.nchannels,)),
                             ('rx_analysis', 'u4', (self.nchannels,))
                         ]
                     )
                     self.header_rec = numpy.fromfile(self.fp, header_structure, 1)
                     self.lat = self.header_rec['lat'][0]
                     self.lon = self.header_rec['lon'][0]
                     self.delta = self.header_rec['delta_r'][0]
                     self.correction = self.header_rec['dmode_rngcorr'][0]
                     self.imode = self.header_rec['dmode_index'][0]
                     self.antenna = self.header_rec['antenna_coord']
                     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():
                         self.flagDiscontinuousBlock = 1
                     self.datatime = dt
                 def readData(self):
                     '''
                     Reading and filtering data block record of BLTR rawdata file, filtering is according to status_value.
                     Input:
                         status_value - Array data is set to NAN for values that are not equal to status_value
                     '''
                     data_structure = numpy.dtype(
                         DATA_STRUCTURE.descr + [
                             ('rx_saturation', 'u4', (self.nchannels,)),
                             ('chan_offset', 'u4', (2 * self.nchannels,)),
                             ('rx_amp', 'u4', (self.nchannels,)),
                             ('rx_snr', 'f4', (self.nchannels,)),
                             ('cross_snr', 'f4', (self.kchan,)),
                             ('sea_power_relative', 'f4', (self.kchan,))]
                     )
                     data = numpy.fromfile(self.fp, data_structure, self.nranges)
                     height = data['range']
-                    winds = numpy.array((data['zonal'], data['meridional'], data['vertical']))
+                    winds = numpy.array(
+                        (data['zonal'], data['meridional'], data['vertical']))
                     snr = data['rx_snr'].T
                     winds[numpy.where(winds == -9999.)] = numpy.nan
                     winds[:, numpy.where(data['status'] != self.status_value)] = numpy.nan
                     snr[numpy.where(snr == -9999.)] = numpy.nan
                     snr[:, numpy.where(data['status'] != self.status_value)] = numpy.nan
                     snr = numpy.power(10, snr / 10)
                     return height, winds, snr
                 def set_output(self):
                     '''
                     Storing data from databuffer to dataOut object
                     '''
                     self.dataOut.data_SNR = self.snr
                     self.dataOut.height = self.height
                     self.dataOut.data = self.buffer
                     self.dataOut.utctimeInit = self.time
                     self.dataOut.utctime = self.dataOut.utctimeInit
                     self.dataOut.useLocalTime = False
                     self.dataOut.paramInterval = 157
                     self.dataOut.timezone = self.timezone
                     self.dataOut.site = self.siteFile
                     self.dataOut.nrecords = self.nrecords / self.nmodes
                     self.dataOut.sizeOfFile = self.sizeOfFile
                     self.dataOut.lat = self.lat
                     self.dataOut.lon = self.lon
                     self.dataOut.channelList = range(self.nchannels)
                     self.dataOut.kchan = self.kchan
                     self.dataOut.delta = self.delta
                     self.dataOut.correction = self.correction
                     self.dataOut.nmodes = self.nmodes
                     self.dataOut.imode = self.imode
                     self.dataOut.antenna = self.antenna
                     self.dataOut.rx_gains = self.rx_gains
                     self.dataOut.flagNoData = False
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                 def getData(self):
                     '''
                     Storing data from databuffer to dataOut object
                     '''
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         log.success('No file left to process', 'BLTRParamReader')
                         return 0
                     if not self.readNextBlock():
                         self.dataOut.flagNoData = True
                         return 0
                     self.set_output()
                     return 1

schainpy/model/io/jroIO_base.py +69 -46

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import os
             import sys
             import glob
             import time
             import numpy
             import fnmatch
             import inspect
-            import time, datetime
+            import time
+            import datetime
             import traceback
             import zmq
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
             LOCALTIME = True
             def isNumber(cad):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float(cad)
                     return True
                 except:
                     return False
             def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print "The file %s can't be opened" % (filename)
                     return 0
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" % (filename)
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
-            def isTimeInRange(thisTime, startTime, endTime):
+            def isTimeInRange(thisTime, startTime, endTime):
                 if endTime >= startTime:
                     if (thisTime < startTime) or (thisTime > endTime):
                         return 0
                     return 1
                 else:
                     if (thisTime < startTime) and (thisTime > endTime):
                         return 0
                     return 1
             def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print "The file %s can't be opened" % (filename)
                     return None
                 firstBasicHeaderObj = BasicHeader(LOCALTIME)
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 lastBasicHeaderObj = BasicHeader(LOCALTIME)
                 sts = firstBasicHeaderObj.read(fp)
                 if not(sts):
                     print "[Reading] Skipping the file %s because it has not a valid header" % (filename)
                     return None
                 if not systemHeaderObj.read(fp):
                     return None
                 if not radarControllerHeaderObj.read(fp):
                     return None
                 if not processingHeaderObj.read(fp):
                     return None
                 filesize = os.path.getsize(filename)
                 offset = processingHeaderObj.blockSize + 24  # header size
                 if filesize <= offset:
                     print "[Reading] %s: This file has not enough data" % filename
                     return None
                 fp.seek(-offset, 2)
                 sts = lastBasicHeaderObj.read(fp)
                 fp.close()
                 thisDatetime = lastBasicHeaderObj.datatime
                 thisTime_last_block = thisDatetime.time()
                 thisDatetime = firstBasicHeaderObj.datatime
                 thisDate = thisDatetime.date()
                 thisTime_first_block = thisDatetime.time()
                 # General case
                 #           o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
                 #-----------o----------------------------o-----------
                 #       startTime                     endTime
                 if endTime >= startTime:
                     if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
                         return None
                     return thisDatetime
                 # If endTime < startTime then endTime belongs to the next day
                 #<<<<<<<<<<<o                            o>>>>>>>>>>>
                 #-----------o----------------------------o-----------
                 #        endTime                    startTime
                 if (thisDate == startDate) and (thisTime_last_block < startTime):
                     return None
                 if (thisDate == endDate) and (thisTime_first_block > endTime):
                     return None
                 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
                     return None
                 return thisDatetime
             def isFolderInDateRange(folder, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     folder            :    nombre completo del directorio.
                                            Su formato deberia ser "/path_root/?YYYYDDD"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el directorio no tiene el formato adecuado
                 """
                 basename = os.path.basename(folder)
                 if not isRadarFolder(basename):
                     print "The folder %s has not the rigth format" % folder
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFolder(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def isFileInDateRange(filename, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                                            Su formato deberia ser "?YYYYDDDsss"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                                                 sss     :    set
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no tiene el formato adecuado
                 """
                 basename = os.path.basename(filename)
                 if not isRadarFile(basename):
                     print "The filename %s has not the rigth format" % filename
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFile(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def getFileFromSet(path, ext, set):
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
                         year = int(thisFile[1:5])
                         doy = int(thisFile[5:8])
                     except:
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
-                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:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s' % (year, doy, set, ext.lower())
                     print 'the filename %s does not exist' % filename
                     print '...going to the last file: '
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     year = thisFile[1:5]
                     if not isNumber(year):
                         continue
                     doy = thisFile[5:8]
                     if not isNumber(doy):
                         continue
                     year = int(year)
                     doy = int(doy)
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def checkForRealPath(path, foldercounter, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
                 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
                 el path exacto de un determinado file.
                 Example    :
                     nombre correcto del file es  .../.../D2009307/P2009307367.ext
                     Entonces la funcion prueba con las siguientes combinaciones
                         .../.../y2009307367.ext
                         .../.../Y2009307367.ext
                         .../.../x2009307/y2009307367.ext
                         .../.../x2009307/Y2009307367.ext
                         .../.../X2009307/y2009307367.ext
                         .../.../X2009307/Y2009307367.ext
                     siendo para este caso, la ultima combinacion de letras, identica al file buscado
                 Return:
                     Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
                     caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
                     para el filename
                 """
                 fullfilename = None
                 find_flag = False
                 filename = None
                 prefixDirList = [None, 'd', 'D']
                 if ext.lower() == ".r":  # voltage
                     prefixFileList = ['d', 'D']
                 elif ext.lower() == ".pdata":  # spectra
                     prefixFileList = ['p', 'P']
                 else:
                     return None, filename
                 # barrido por las combinaciones posibles
                 for prefixDir in prefixDirList:
                     thispath = path
                     if prefixDir != None:
                         # formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         if foldercounter == 0:
-                            thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
+                            thispath = os.path.join(path, "%s%04d%03d" %
+                                                    (prefixDir, year, doy))
                         else:
-                            thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
+                            thispath = os.path.join(path, "%s%04d%03d_%02d" % (
+                                prefixDir, year, doy, foldercounter))
                     for prefixFile in prefixFileList:  # barrido por las dos combinaciones posibles de "D"
-                        filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
+                        # formo el nombre del file xYYYYDDDSSS.ext
-                        fullfilename = os.path.join( thispath, filename ) #formo el path completo
+                        filename = "%s%04d%03d%03d%s" % (prefixFile, year, doy, set, ext)
+                        fullfilename = os.path.join(
+                            thispath, filename)  # formo el path completo
                         if os.path.exists(fullfilename):  # verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return fullfilename, filename
             def isRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return 0
                 return 1
             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return 0
                 return 1
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def getDateFromRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             class JRODataIO:
                 c = 3E8
                 isConfig = False
                 basicHeaderObj = None
                 systemHeaderObj = None
                 radarControllerHeaderObj = None
                 processingHeaderObj = None
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 flagIsNewFile = 1
                 flagDiscontinuousBlock = 0
                 flagIsNewBlock = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
             #     ippSeconds = None
                 fileSizeByHeader = None
                 fileIndex = None
                 profileIndex = None
                 blockIndex = None
                 nTotalBlocks = None
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOut = None
                 blocksize = None
                 getByBlock = False
                 def __init__(self):
                     raise NotImplementedError
                 def run(self):
                     raise NotImplementedError
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def getAllowedArgs(self):
                     return inspect.getargspec(self.run).args
             class JRODataReader(JRODataIO):
                 online = 0
                 realtime = 0
                 nReadBlocks = 0
                 delay = 10  # number of seconds waiting a new file
                 nTries = 3  # quantity tries
                 nFiles = 3  # number of files for searching
                 path = None
                 foldercounter = 0
                 flagNoMoreFiles = 0
                 datetimeList = []
                 __isFirstTimeOnline = 1
                 __printInfo = True
                 profileIndex = None
                 nTxs = 1
                 txIndex = None
                 # Added--------------------
                 selBlocksize = None
                 selBlocktime = None
                 def __init__(self):
                     """
                     This class is used to find data files
                     Example:
                         reader = JRODataReader()
                         fileList = reader.findDataFiles()
                     """
                     pass
                 def createObjByDefault(self):
                     """
                     """
                     raise NotImplementedError
                 def getBlockDimension(self):
                     raise NotImplementedError
                 def searchFilesOffLine(self,
                                        path,
                                        startDate=None,
                                        endDate=None,
                                        startTime=datetime.time(0, 0, 0),
                                        endTime=datetime.time(23, 59, 59),
                                        set=None,
                                        expLabel='',
                                        ext='.r',
                                        cursor=None,
                                        skip=None,
                                        walk=True):
                     self.filenameList = []
                     self.datetimeList = []
                     pathList = []
-                    dateList, pathList = self.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True)
+                    dateList, pathList = self.findDatafiles(
+                        path, startDate, endDate, expLabel, ext, walk, include_path=True)
                     if dateList == []:
                         return [], []
                     if len(dateList) > 1:
                         print "[Reading] Data found for date range [%s - %s]: total days = %d" % (startDate, endDate, len(dateList))
                     else:
                         print "[Reading] Data found for date range [%s - %s]: date = %s" % (startDate, endDate, dateList[0])
                     filenameList = []
                     datetimeList = []
                     for thisPath in pathList:
                         fileList = glob.glob1(thisPath, "*%s" % ext)
                         fileList.sort()
                         skippedFileList = []
                         if cursor is not None and skip is not None:
                             if skip == 0:
                                 skippedFileList = []
                             else:
-                                skippedFileList = fileList[cursor*skip: cursor*skip + skip]
+                                skippedFileList = fileList[cursor *
+                                                           skip: cursor * skip + skip]
                         else:
                             skippedFileList = fileList
                         for file in skippedFileList:
                             filename = os.path.join(thisPath, file)
                             if not isFileInDateRange(filename, startDate, endDate):
                                 continue
-                            thisDatetime = isFileInTimeRange(filename, startDate, endDate, startTime, endTime)
+                            thisDatetime = isFileInTimeRange(
+                                filename, startDate, endDate, startTime, endTime)
                             if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
                         print "[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" % (startTime, endTime, ext, path)
                         return [], []
                     print "[Reading] %d file(s) was(were) found in time range: %s - %s" % (len(filenameList), startTime, endTime)
                     print
                     # for i in range(len(filenameList)):
                     #     print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                     return pathList, filenameList
                 def __searchFilesOnLine(self, path, expLabel="", ext=None, walk=True, set=None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path           :    carpeta donde estan contenidos los files que contiene data
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     Return:
                         directory   :    eL directorio donde esta el file encontrado
                         filename    :    el ultimo file de una determinada carpeta
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                     """
                     if not os.path.isdir(path):
                         return None, None, None, None, None, None
                     dirList = []
                     if not walk:
                         fullpath = path
                         foldercounter = 0
                     else:
                         # Filtra solo los directorios
                         for thisPath in os.listdir(path):
                             if not os.path.isdir(os.path.join(path, thisPath)):
                                 continue
                             if not isRadarFolder(thisPath):
                                 continue
                             dirList.append(thisPath)
                         if not(dirList):
                             return None, None, None, None, None, None
                         dirList = sorted(dirList, key=str.lower)
                         doypath = dirList[-1]
-                        foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
+                        foldercounter = int(doypath.split('_')[1]) if len(
+                            doypath.split('_')) > 1 else 0
                         fullpath = os.path.join(path, doypath, expLabel)
                     print "[Reading] %s folder was found: " % (fullpath)
                     if set == None:
                         filename = getlastFileFromPath(fullpath, ext)
                     else:
                         filename = getFileFromSet(fullpath, ext, set)
                     if not(filename):
                         return None, None, None, None, None, None
                     print "[Reading] %s file was found" % (filename)
                     if not(self.__verifyFile(os.path.join(fullpath, filename))):
                         return None, None, None, None, None, None
                     year = int(filename[1:5])
                     doy = int(filename[5:8])
                     set = int(filename[8:11])
                     return fullpath, foldercounter, filename, year, doy, set
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
             #                 print "[Reading] No more Files"
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename, 'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
             #         print "[Reading] Setting the file: %s"%self.filename
                     return 1
                 def __setNextFileOnline(self):
                     """
                     Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
                     no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
                     siguientes.
                     Affected:
                         self.flagIsNewFile
                         self.filename
                         self.fileSize
                         self.fp
                         self.set
                         self.flagNoMoreFiles
                     Return:
 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
 : si el file fue abierto con exito y esta listo a ser leido
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     nFiles = 0
                     fileOk_flag = False
                     firstTime_flag = True
                     self.set += 1
                     if self.set > 999:
                         self.set = 0
                         self.foldercounter += 1
                     # busca el 1er file disponible
-                    fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
+                    fullfilename, filename = checkForRealPath(
+                        self.path, self.foldercounter, self.year, self.doy, self.set, self.ext)
                     if fullfilename:
                         if self.__verifyFile(fullfilename, False):
                             fileOk_flag = True
                     # si no encuentra un file entonces espera y vuelve a buscar
                     if not(fileOk_flag):
-                        for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
+                        # busco en los siguientes self.nFiles+1 files posibles
+                        for nFiles in range(self.nFiles + 1):
                             if firstTime_flag:  # si es la 1era vez entonces hace el for self.nTries veces
                                 tries = self.nTries
                             else:
                                 tries = 1  # si no es la 1era vez entonces solo lo hace una vez
                             for nTries in range(tries):
                                 if firstTime_flag:
                                     print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % (self.delay, filename, nTries + 1)
                                     sleep(self.delay)
                                 else:
                                     print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
-                                fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
+                                fullfilename, filename = checkForRealPath(
+                                    self.path, self.foldercounter, self.year, self.doy, self.set, self.ext)
                                 if fullfilename:
                                     if self.__verifyFile(fullfilename):
                                         fileOk_flag = True
                                         break
                             if fileOk_flag:
                                 break
                             firstTime_flag = False
                             print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename
                             self.set += 1
-                            if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
+                            # si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
+                            if nFiles == (self.nFiles - 1):
                                 self.set = 0
                                 self.doy += 1
                                 self.foldercounter = 0
                     if fileOk_flag:
                         self.fileSize = os.path.getsize(fullfilename)
                         self.filename = fullfilename
                         self.flagIsNewFile = 1
-                        if self.fp != None: self.fp.close()
+                        if self.fp != None:
+                            self.fp.close()
                         self.fp = open(fullfilename, 'rb')
                         self.flagNoMoreFiles = 0
             #             print '[Reading] Setting the file: %s' % fullfilename
                     else:
                         self.fileSize = 0
                         self.filename = None
                         self.flagIsNewFile = 0
                         self.fp = None
                         self.flagNoMoreFiles = 1
             #             print '[Reading] No more files to read'
                     return fileOk_flag
                 def setNextFile(self):
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         print '[Reading] No more files to read'
                         return 0
                     if self.verbose:
                         print '[Reading] Setting the file: %s' % self.filename
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             self.basicHeaderObj.read(self.fp)
                             return 1
                         if self.fileSize == self.fileSizeByHeader:
                             #                self.flagEoF = True
                             return 0
                         print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1)
                         sleep(self.delay)
                     return 0
                 def waitDataBlock(self, pointer_location):
                     currentPointer = pointer_location
                     neededSize = self.processingHeaderObj.blockSize  # + self.basicHeaderSize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             return 1
                         print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1)
                         sleep(self.delay)
                     return 0
                 def __jumpToLastBlock(self):
                     if not(self.__isFirstTimeOnline):
                         return
                     csize = self.fileSize - self.fp.tell()
                     blocksize = self.processingHeaderObj.blockSize
                     # salta el primer bloque de datos
                     if csize > self.processingHeaderObj.blockSize:
                         self.fp.seek(self.fp.tell() + blocksize)
                     else:
                         return
                     csize = self.fileSize - self.fp.tell()
                     neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     while True:
                         if self.fp.tell() < self.fileSize:
                             self.fp.seek(self.fp.tell() + neededsize)
                         else:
                             self.fp.seek(self.fp.tell() - neededsize)
                             break
             #        csize = self.fileSize - self.fp.tell()
             #        neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
             #        factor = int(csize/neededsize)
             #        if factor > 0:
             #            self.fp.seek(self.fp.tell() + factor*neededsize)
                     self.flagIsNewFile = 0
                     self.__isFirstTimeOnline = 0
                 def __setNewBlock(self):
                     # if self.server is None:
                     if self.fp == None:
                         return 0
             #         if self.online:
             #             self.__jumpToLastBlock()
                     if self.flagIsNewFile:
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.realtime:
                         self.flagDiscontinuousBlock = 1
                         if not(self.setNextFile()):
                             return 0
                         else:
                             return 1
                     # if self.server is None:
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.basicHeaderObj.read(self.fp)
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     # else:
                     #     self.basicHeaderObj.read(self.zHeader)
                     #     self.lastUTTime = self.basicHeaderObj.utc
                     #     return 1
                     if self.__waitNewBlock():
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     # if self.server is None:
                     if not(self.setNextFile()):
                         return 0
-                    deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
+                    deltaTime = self.basicHeaderObj.utc - self.lastUTTime
                     self.lastUTTime = self.basicHeaderObj.utc
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
                     # Skip block out of startTime and endTime
                     while True:
                         if not(self.__setNewBlock()):
                             return 0
                         if not(self.readBlock()):
                             return 0
                         self.getBasicHeader()
+                        if (self.dataOut.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or (self.dataOut.datatime > datetime.datetime.combine(self.endDate, self.endTime)):
-                        if not isTimeInRange(self.dataOut.datatime.time(), self.startTime, self.endTime):
                             print "[Reading] Block No. %d/%d -> %s [Skipping]" % (self.nReadBlocks,
                                                                                   self.processingHeaderObj.dataBlocksPerFile,
                                                                                   self.dataOut.datatime.ctime())
                             continue
                         break
                     if self.verbose:
                         print "[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
                                                                    self.processingHeaderObj.dataBlocksPerFile,
                                                                    self.dataOut.datatime.ctime())
                     return 1
                 def __readFirstHeader(self):
                     self.basicHeaderObj.read(self.fp)
                     self.systemHeaderObj.read(self.fp)
                     self.radarControllerHeaderObj.read(self.fp)
                     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))
+                    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')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dtype = datatype_str
                     #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)
+                    self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
+                        self.firstHeaderSize + self.basicHeaderSize * \
+                        (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def __verifyFile(self, filename, msgFlag=True):
                     msg = None
                     try:
                         fp = open(filename, 'rb')
                     except IOError:
                         if msgFlag:
                             print "[Reading] File %s can't be opened" % (filename)
                         return False
                     currentPosition = fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         basicHeaderObj = BasicHeader(LOCALTIME)
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         if not(basicHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not(systemHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not(radarControllerHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not(processingHeaderObj.read(fp)):
                             fp.close()
                             return False
                         neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
                     else:
                         msg = "[Reading] Skipping the file %s due to it hasn't enough data" % filename
                     fp.close()
                     fileSize = os.path.getsize(filename)
                     currentSize = fileSize - currentPosition
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
                             print msg
                         return False
                     return True
                 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
                     path_empty = True
                     dateList = []
                     pathList = []
                     multi_path = path.split(',')
                     if not walk:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             fileList = glob.glob1(single_path, "*" + ext)
                             if not fileList:
                                 continue
                             path_empty = False
                             fileList.sort()
                             for thisFile in fileList:
                                 if not os.path.isfile(os.path.join(single_path, thisFile)):
                                     continue
                                 if not isRadarFile(thisFile):
                                     continue
                                 if not isFileInDateRange(thisFile, startDate, endDate):
                                     continue
                                 thisDate = getDateFromRadarFile(thisFile)
                                 if thisDate in dateList:
                                     continue
                                 dateList.append(thisDate)
                                 pathList.append(single_path)
                     else:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             dirList = []
                             for thisPath in os.listdir(single_path):
                                 if not os.path.isdir(os.path.join(single_path, thisPath)):
                                     continue
                                 if not isRadarFolder(thisPath):
                                     continue
                                 if not isFolderInDateRange(thisPath, startDate, endDate):
                                     continue
                                 dirList.append(thisPath)
                             if not dirList:
                                 continue
                             dirList.sort()
                             for thisDir in dirList:
                                 datapath = os.path.join(single_path, thisDir, expLabel)
                                 fileList = glob.glob1(datapath, "*" + ext)
                                 if not fileList:
                                     continue
                                 path_empty = False
                                 thisDate = getDateFromRadarFolder(thisDir)
                                 pathList.append(datapath)
                                 dateList.append(thisDate)
                     dateList.sort()
                     if walk:
                         pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
                     else:
                         pattern_path = multi_path[0]
                     if path_empty:
                         print "[Reading] No *%s files in %s for %s to %s" % (ext, pattern_path, startDate, endDate)
                     else:
                         if not dateList:
                             print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" % (startDate, endDate, ext, path)
                     if include_path:
                         return dateList, pathList
                     return dateList
                 def setup(self,
                           path=None,
                           startDate=None,
                           endDate=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           set=None,
                           expLabel="",
                           ext=None,
                           online=False,
                           delay=60,
                           walk=True,
                           getblock=False,
                           nTxs=1,
                           realtime=False,
                           blocksize=None,
                           blocktime=None,
                           skip=None,
                           cursor=None,
                           warnings=True,
                           verbose=True,
                           server=None,
                           format=None,
                           oneDDict=None,
                           twoDDict=None,
                           ind2DList=None):
                     if server is not None:
                         if 'tcp://' in server:
                             address = server
                         else:
                             address = 'ipc:///tmp/%s' % server
                         self.server = address
                         self.context = zmq.Context()
                         self.receiver = self.context.socket(zmq.PULL)
                         self.receiver.connect(self.server)
                         time.sleep(0.5)
                         print '[Starting] ReceiverData from {}'.format(self.server)
                     else:
                         self.server = None
                         if path == None:
                             raise ValueError, "[Reading] The path is not valid"
                         if ext == None:
                             ext = self.ext
                         if online:
                             print "[Reading] Searching files in online mode..."
                             for nTries in range(self.nTries):
-                                fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
+                                fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(
+                                    path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
                                 if fullpath:
                                     break
                                 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries + 1)
                                 sleep(self.delay)
                             if not(fullpath):
                                 print "[Reading] There 'isn't any valid file in %s" % path
                                 return
                             self.year = year
                             self.doy = doy
                             self.set = set - 1
                             self.path = path
                             self.foldercounter = foldercounter
                             last_set = None
                         else:
                             print "[Reading] Searching files in offline mode ..."
                             pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                              startTime=startTime, endTime=endTime,
                                                                              set=set, expLabel=expLabel, ext=ext,
                                                                              walk=walk, cursor=cursor,
                                                                              skip=skip)
                             if not(pathList):
                                 self.fileIndex = -1
                                 self.pathList = []
                                 self.filenameList = []
                                 return
                             self.fileIndex = -1
                             self.pathList = pathList
                             self.filenameList = filenameList
                             file_name = os.path.basename(filenameList[-1])
                             basename, ext = os.path.splitext(file_name)
                             last_set = int(basename[-3:])
                         self.online = online
                         self.realtime = realtime
                         self.delay = delay
                         ext = ext.lower()
                         self.ext = ext
                         self.getByBlock = getblock
                         self.nTxs = nTxs
                         self.startTime = startTime
                         self.endTime = endTime
+                        self.endDate = endDate
+                        self.startDate = startDate
                         # Added-----------------
                         self.selBlocksize = blocksize
                         self.selBlocktime = blocktime
                         # Verbose-----------
                         self.verbose = verbose
                         self.warnings = warnings
                         if not(self.setNextFile()):
                             if (startDate != None) and (endDate != None):
                                 print "[Reading] No files in range: %s - %s" % (datetime.datetime.combine(startDate, startTime).ctime(), datetime.datetime.combine(endDate, endTime).ctime())
                             elif startDate != None:
                                 print "[Reading] No files in range: %s" % (datetime.datetime.combine(startDate, startTime).ctime())
                             else:
                                 print "[Reading] No files"
                                 self.fileIndex = -1
                                 self.pathList = []
                                 self.filenameList = []
                                 return
                 #         self.getBasicHeader()
                         if last_set != None:
-                            self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
+                            self.dataOut.last_block = last_set * \
+                                self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
                     return
                 def getBasicHeader(self):
-                    self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
+                    self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
+. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
             #         self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError
                 def getData(self):
                     raise NotImplementedError
                 def hasNotDataInBuffer(self):
                     raise NotImplementedError
                 def readBlock(self):
                     raise NotImplementedError
                 def isEndProcess(self):
                     return self.flagNoMoreFiles
                 def printReadBlocks(self):
                     print "[Reading] Number of read blocks per file %04d" % self.nReadBlocks
                 def printTotalBlocks(self):
                     print "[Reading] Number of read blocks %04d" % self.nTotalBlocks
                 def printNumberOfBlock(self):
                     'SPAM!'
             #         if self.flagIsNewBlock:
             #             print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
             #                                                       self.processingHeaderObj.dataBlocksPerFile,
             #                                                       self.dataOut.datatime.ctime())
                 def printInfo(self):
                     if self.__printInfo == False:
                         return
                     self.basicHeaderObj.printInfo()
                     self.systemHeaderObj.printInfo()
                     self.radarControllerHeaderObj.printInfo()
                     self.processingHeaderObj.printInfo()
                     self.__printInfo = False
                 def run(self,
                         path=None,
                         startDate=None,
                         endDate=None,
                         startTime=datetime.time(0, 0, 0),
                         endTime=datetime.time(23, 59, 59),
                         set=None,
                         expLabel="",
                         ext=None,
                         online=False,
                         delay=60,
                         walk=True,
                         getblock=False,
                         nTxs=1,
                         realtime=False,
                         blocksize=None,
                         blocktime=None,
                         skip=None,
                         cursor=None,
                         warnings=True,
                         server=None,
                         verbose=True,
                         format=None,
                         oneDDict=None,
                         twoDDict=None,
                         ind2DList=None, **kwargs):
                     if not(self.isConfig):
                         self.setup(path=path,
                                    startDate=startDate,
                                    endDate=endDate,
                                    startTime=startTime,
                                    endTime=endTime,
                                    set=set,
                                    expLabel=expLabel,
                                    ext=ext,
                                    online=online,
                                    delay=delay,
                                    walk=walk,
                                    getblock=getblock,
                                    nTxs=nTxs,
                                    realtime=realtime,
                                    blocksize=blocksize,
                                    blocktime=blocktime,
                                    skip=skip,
                                    cursor=cursor,
                                    warnings=warnings,
                                    server=server,
                                    verbose=verbose,
                                    format=format,
                                    oneDDict=oneDDict,
                                    twoDDict=twoDDict,
                                    ind2DList=ind2DList)
                         self.isConfig = True
                     if server is None:
                         self.getData()
                     else:
                         self.getFromServer()
             class JRODataWriter(JRODataIO):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 blockIndex = 0
                 path = None
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 fileDate = None
                 def __init__(self, dataOut=None):
                     raise NotImplementedError
                 def hasAllDataInBuffer(self):
                     raise NotImplementedError
                 def setBlockDimension(self):
                     raise NotImplementedError
                 def writeBlock(self):
                     raise NotImplementedError
                 def putData(self):
                     raise NotImplementedError
                 def getProcessFlags(self):
                     processFlags = 0
                     dtype_index = get_dtype_index(self.dtype)
                     procflag_dtype = get_procflag_dtype(dtype_index)
                     processFlags += procflag_dtype
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code is not None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     if self.dataOut.type == "Spectra":
                         if self.dataOut.nIncohInt > 1:
                             processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                         if self.dataOut.data_dc is not None:
                             processFlags += PROCFLAG.SAVE_CHANNELS_DC
                         if self.dataOut.flagShiftFFT:
                             processFlags += PROCFLAG.SHIFT_FFT_DATA
                     return processFlags
                 def setBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize  # bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond = (self.dataOut.utctime - utc) * 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise NotImplementedError
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
             #        CALCULAR PARAMETROS
-                    sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
+                    sizeLongHeader = self.systemHeaderObj.size + \
+                        self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.basicHeaderObj.write(self.fp)
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not(self.__setNewBlock()):
                         return 0
                     self.writeBlock()
                     print "[Writing] Block No. %d/%d" % (self.blockIndex,
                                                          self.processingHeaderObj.dataBlocksPerFile)
                     return 1
                 def setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     timeTuple = time.localtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     setFile = self.setFile
                     if not(os.path.exists(fullpath)):
                         os.mkdir(fullpath)
                         setFile = -1  # inicializo mi contador de seteo
                     else:
                         filesList = os.listdir(fullpath)
                         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
+                                # inicializo mi contador de seteo al seteo del ultimo file
+                                setFile = int(filen[8:11])
                             else:
                                 setFile = -1
                         else:
                             setFile = -1  # inicializo mi contador de seteo
                     setFile += 1
                     # If this is a new day it resets some values
                     if self.dataOut.datatime.date() > self.fileDate:
                         setFile = 0
                         self.nTotalBlocks = 0
-                    filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
+                    filen = '%s%4.4d%3.3d%3.3d%s' % (
+                        self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext)
                     filename = os.path.join(path, subfolder, filen)
                     fp = open(filename, 'wb')
                     self.blockIndex = 0
                     # guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.fileDate = self.dataOut.datatime.date()
                     self.setFirstHeader()
                     print '[Writing] Opening file: %s' % self.filename
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path                :    directory where data will be saved
                         profilesPerBlock    :    number of profiles per block
                         set                 :    initial file set
                         datatype            :    An integer number that defines data type:
 : int8  (1 byte)
 : int16 (2 bytes)
 : int32 (4 bytes)
 : int64 (8 bytes)
 : float32 (4 bytes)
 : double64 (8 bytes)
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     self.ext = ext.lower()
                     self.path = path
                     if set is None:
                         self.setFile = -1
                     else:
                         self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     self.fileDate = self.dataOut.datatime.date()
                     # By default
                     self.dtype = self.dataOut.dtype
                     if datatype is not None:
                         self.dtype = get_numpy_dtype(datatype)
                     if not(self.setNextFile()):
                         print "[Writing] There isn't a next file"
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
                     if not(self.isConfig):
-                        self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock, set=set, ext=ext, datatype=datatype, **kwargs)
+                        self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock,
+                                   set=set, ext=ext, datatype=datatype, **kwargs)
                         self.isConfig = True
                     self.putData()

schainpy/model/io/jroIO_bltr.py +133 -105

-            import os, sys
+            import os
+            import sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
-            import matplotlib.pyplot as plt
             import pylab as plb
             from scipy.optimize import curve_fit
             from scipy import asarray as ar, exp
             from scipy import stats
             from numpy.ma.core import getdata
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
             #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 numpy import imag, shape, NaN
             from jroIO_base import JRODataReader
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
                 def printInfo(self):
                     message = "#" * 50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
                     keyList = self.__dict__.keys()
                     keyList.sort()
                     for key in keyList:
                         message += "%s = %s" % (key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
                             message += "%s = %s" % ("size", attr) + "\n"
                     # print message
             FILE_STRUCTURE = numpy.dtype([  # HEADER 48bytes
                 ('FileMgcNumber', '<u4'),  # 0x23020100
-                                      ('nFDTdataRecors','<u4'),     #No Of FDT data records in this file (0 or more)
+                # No Of FDT data records in this file (0 or more)
+                ('nFDTdataRecors', '<u4'),
                 ('OffsetStartHeader', '<u4'),
                 ('RadarUnitId', '<u4'),
                 ('SiteName', numpy.str_, 32),  # Null terminated
             ])
             class FileHeaderBLTR(Header):
                 def __init__(self):
                     self.FileMgcNumber = 0  # 0x23020100
-                    self.nFDTdataRecors=0     #No Of FDT data records in this file (0 or more)
+                    # No Of FDT data records in this file (0 or more)
+                    self.nFDTdataRecors = 0
                     self.RadarUnitId = 0
                     self.OffsetStartHeader = 0
                     self.SiteName = ""
                     self.size = 48
                 def FHread(self, fp):
                     # try:
                     startFp = open(fp, "rb")
                     header = numpy.fromfile(startFp, FILE_STRUCTURE, 1)
                     print ' '
                     print 'puntero file header', startFp.tell()
                     print ' '
                     '''      numpy.fromfile(file, dtype, count, sep='')
                         file : file or str
                         Open file object or filename.
                         dtype : data-type
                         Data type of the returned array. For binary files, it is used to determine
                         the size and byte-order of the items in the file.
                         count : int
                         Number of items to read. -1 means all items (i.e., the complete file).
                         sep : str
                         Separator between items if file is a text file. Empty ("") separator means
                         the file should be treated as binary. Spaces (" ") in the separator match zero
                         or more whitespace characters. A separator consisting only of spaces must match
                         at least one whitespace.
                 '''
                     self.FileMgcNumber = hex(header['FileMgcNumber'][0])
-                    self.nFDTdataRecors=int(header['nFDTdataRecors'][0])     #No Of FDT data records in this file (0 or more)
+                    # No Of FDT data records in this file (0 or more)
+                    self.nFDTdataRecors = int(header['nFDTdataRecors'][0])
                     self.RadarUnitId = int(header['RadarUnitId'][0])
                     self.OffsetStartHeader = int(header['OffsetStartHeader'][0])
                     self.SiteName = str(header['SiteName'][0])
                     # print 'Numero de bloques', self.nFDTdataRecors
                     if self.size < 48:
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.FileMgcNumber,
                                    self.nFDTdataRecors,
                                    self.RadarUnitId,
                                    self.SiteName,
                                    self.size)
                     header = numpy.array(headerTuple, FILE_STRUCTURE)
                     #        numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
                     header.tofile(fp)
                     ''' ndarray.tofile(fid, sep, format)    Write array to a file as text or binary (default).
                     fid : file or str
                     An open file object, or a string containing a filename.
                     sep : str
                     Separator between array items for text output. If "" (empty), a binary file is written,
                     equivalent to file.write(a.tobytes()).
                     format : str
                     Format string for text file output. Each entry in the array is formatted to text by
                     first converting it to the closest Python type, and then using "format" % item.
                     '''
                     return 1
             RECORD_STRUCTURE = numpy.dtype([  # RECORD HEADER 180+20N bytes
                 ('RecMgcNumber', '<u4'),  # 0x23030001
                 ('RecCounter', '<u4'),  # Record counter(0,1, ...)
-                                        ('Off2StartNxtRec','<u4'),  #Offset to start of next record form start of this record
+                # Offset to start of next record form start of this record
-                                        ('Off2StartData','<u4'),    #Offset to start of data from start of this record
+                                        ('Off2StartNxtRec', '<u4'),
-                                        ('nUtime','<i4'),      #Epoch time stamp of start of acquisition (seconds)
+                                        # Offset to start of data from start of this record
-                                        ('nMilisec','<u4'),      #Millisecond component of time stamp (0,...,999)
+                                        ('Off2StartData', '<u4'),
-                                        ('ExpTagName',numpy.str_,32),      #Experiment tag name (null terminated)
+                                        # Epoch time stamp of start of acquisition (seconds)
-                                        ('ExpComment',numpy.str_,32),      #Experiment comment (null terminated)
+                                        ('nUtime', '<i4'),
-                                        ('SiteLatDegrees','<f4'),   #Site latitude (from GPS) in degrees (positive implies North)
+                                        # Millisecond component of time stamp (0,...,999)
-                                        ('SiteLongDegrees','<f4'),  #Site longitude (from GPS) in degrees (positive implies East)
+                                        ('nMilisec', '<u4'),
-                                        ('RTCgpsStatus','<u4'),     #RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
+                                        # Experiment tag name (null terminated)
+                                        ('ExpTagName', numpy.str_, 32),
+                                        # Experiment comment (null terminated)
+                                        ('ExpComment', numpy.str_, 32),
+                                        # Site latitude (from GPS) in degrees (positive implies North)
+                                        ('SiteLatDegrees', '<f4'),
+                                        # Site longitude (from GPS) in degrees (positive implies East)
+                                        ('SiteLongDegrees', '<f4'),
+                                        # RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
+                                        ('RTCgpsStatus', '<u4'),
                                         ('TransmitFrec', '<u4'),  # Transmit frequency (Hz)
                                         ('ReceiveFrec', '<u4'),  # Receive frequency
-                                        ('FirstOsciFrec','<u4'),    #First local oscillator frequency (Hz)
+                                        # First local oscillator frequency (Hz)
-                                        ('Polarisation','<u4'),     #(0="O", 1="E", 2="linear 1", 3="linear2")
+                                        ('FirstOsciFrec', '<u4'),
-                                        ('ReceiverFiltSett','<u4'), #Receiver filter settings (0,1,2,3)
+                                        # (0="O", 1="E", 2="linear 1", 3="linear2")
-                                        ('nModesInUse','<u4'),      #Number of modes in use (1 or 2)
+                                        ('Polarisation', '<u4'),
-                                        ('DualModeIndex','<u4'),    #Dual Mode index number for these data (0 or 1)
+                                        # Receiver filter settings (0,1,2,3)
-                                        ('DualModeRange','<u4'),    #Dual Mode range correction for these data (m)
+                                        ('ReceiverFiltSett', '<u4'),
-                                        ('nDigChannels','<u4'),     #Number of digital channels acquired (2*N)
+                                        # Number of modes in use (1 or 2)
-                                        ('SampResolution','<u4'),   #Sampling resolution (meters)
+                                        ('nModesInUse', '<u4'),
-                                        ('nHeights','<u4'),         #Number of range gates sampled
+                                        # Dual Mode index number for these data (0 or 1)
-                                        ('StartRangeSamp','<u4'),   #Start range of sampling (meters)
+                                        ('DualModeIndex', '<u4'),
+                                        # Dual Mode range correction for these data (m)
+                                        ('DualModeRange', '<u4'),
+                                        # Number of digital channels acquired (2*N)
+                                        ('nDigChannels', '<u4'),
+                                        # Sampling resolution (meters)
+                                        ('SampResolution', '<u4'),
+                                        # Number of range gates sampled
+                                        ('nHeights', '<u4'),
+                                        # Start range of sampling (meters)
+                                        ('StartRangeSamp', '<u4'),
                                         ('PRFhz', '<u4'),  # PRF (Hz)
                                         ('nCohInt', '<u4'),  # Integrations
-                                        ('nProfiles','<u4'),        #Number of data points transformed
+                                        # Number of data points transformed
-                                        ('nChannels','<u4'),        #Number of receive beams stored in file (1 or N)
+                                        ('nProfiles', '<u4'),
+                                        # Number of receive beams stored in file (1 or N)
+                                        ('nChannels', '<u4'),
                                         ('nIncohInt', '<u4'),  # Number of spectral averages
-                                        ('FFTwindowingInd','<u4'),  #FFT windowing index (0 = no window)
+                                        # FFT windowing index (0 = no window)
-                                        ('BeamAngleAzim','<f4'),    #Beam steer angle (azimuth) in degrees (clockwise from true North)
+                                        ('FFTwindowingInd', '<u4'),
-                                        ('BeamAngleZen','<f4'),     #Beam steer angle (zenith) in degrees (0=> vertical)
+                                        # Beam steer angle (azimuth) in degrees (clockwise from true North)
-                                        ('AntennaCoord0','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        ('BeamAngleAzim', '<f4'),
-                                        ('AntennaAngl0','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        # Beam steer angle (zenith) in degrees (0=> vertical)
-                                        ('AntennaCoord1','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        ('BeamAngleZen', '<f4'),
-                                        ('AntennaAngl1','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('AntennaCoord2','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        ('AntennaCoord0', '<f4'),
-                                        ('AntennaAngl2','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                                        # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('RecPhaseCalibr0','<f4'),  #Receiver phase calibration (degrees) - N values
+                                        ('AntennaAngl0', '<f4'),
-                                        ('RecPhaseCalibr1','<f4'),  #Receiver phase calibration (degrees) - N values
+                                        # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('RecPhaseCalibr2','<f4'),  #Receiver phase calibration (degrees) - N values
+                                        ('AntennaCoord1', '<f4'),
-                                        ('RecAmpCalibr0','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('RecAmpCalibr1','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        ('AntennaAngl1', '<f4'),
-                                        ('RecAmpCalibr2','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('ReceiverGaindB0','<i4'),  #Receiver gains in dB - N values
+                                        ('AntennaCoord2', '<f4'),
-                                        ('ReceiverGaindB1','<i4'),  #Receiver gains in dB - N values
+                                        # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                                        ('ReceiverGaindB2','<i4'),  #Receiver gains in dB - N values
+                                        ('AntennaAngl2', '<f4'),
+                                        # Receiver phase calibration (degrees) - N values
+                                        ('RecPhaseCalibr0', '<f4'),
+                                        # Receiver phase calibration (degrees) - N values
+                                        ('RecPhaseCalibr1', '<f4'),
+                                        # Receiver phase calibration (degrees) - N values
+                                        ('RecPhaseCalibr2', '<f4'),
+                                        # Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        ('RecAmpCalibr0', '<f4'),
+                                        # Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        ('RecAmpCalibr1', '<f4'),
+                                        # Receiver amplitude calibration (ratio relative to receiver one) - N values
+                                        ('RecAmpCalibr2', '<f4'),
+                                        # Receiver gains in dB - N values
+                                        ('ReceiverGaindB0', '<i4'),
+                                        # Receiver gains in dB - N values
+                                        ('ReceiverGaindB1', '<i4'),
+                                        # Receiver gains in dB - N values
+                                        ('ReceiverGaindB2', '<i4'),
             ])
             class RecordHeaderBLTR(Header):
                 def __init__(self,      RecMgcNumber=None,   RecCounter=0,      Off2StartNxtRec=811248,
                              nUtime=0,           nMilisec=0,        ExpTagName=None,
                              ExpComment=None,     SiteLatDegrees=0,   SiteLongDegrees=0,
                              RTCgpsStatus=0,     TransmitFrec=0,    ReceiveFrec=0,
                              FirstOsciFrec=0,    Polarisation=0,    ReceiverFiltSett=0,
                              nModesInUse=0,      DualModeIndex=0,   DualModeRange=0,
                              nDigChannels=0,     SampResolution=0,  nHeights=0,
                              StartRangeSamp=0,   PRFhz=0,           nCohInt=0,
                              nProfiles=0,        nChannels=0,       nIncohInt=0,
                              FFTwindowingInd=0,  BeamAngleAzim=0,   BeamAngleZen=0,
                              AntennaCoord0=0,     AntennaCoord1=0,    AntennaCoord2=0,
                              RecPhaseCalibr0=0,  RecPhaseCalibr1=0, RecPhaseCalibr2=0,
                              RecAmpCalibr0=0,    RecAmpCalibr1=0,   RecAmpCalibr2=0,
                              AntennaAngl0=0,      AntennaAngl1=0,     AntennaAngl2=0,
                              ReceiverGaindB0=0,  ReceiverGaindB1=0, ReceiverGaindB2=0, Off2StartData=0,    OffsetStartHeader=0):
                     self.RecMgcNumber = RecMgcNumber  # 0x23030001
                     self.RecCounter = RecCounter
                     self.Off2StartNxtRec = Off2StartNxtRec
                     self.Off2StartData = Off2StartData
                     self.nUtime = nUtime
                     self.nMilisec = nMilisec
                     self.ExpTagName = ExpTagName
                     self.ExpComment = ExpComment
                     self.SiteLatDegrees = SiteLatDegrees
                     self.SiteLongDegrees = SiteLongDegrees
                     self.RTCgpsStatus = RTCgpsStatus
                     self.TransmitFrec = TransmitFrec
                     self.ReceiveFrec = ReceiveFrec
                     self.FirstOsciFrec = FirstOsciFrec
                     self.Polarisation = Polarisation
                     self.ReceiverFiltSett = ReceiverFiltSett
                     self.nModesInUse = nModesInUse
                     self.DualModeIndex = DualModeIndex
                     self.DualModeRange = DualModeRange
                     self.nDigChannels = nDigChannels
                     self.SampResolution = SampResolution
                     self.nHeights = nHeights
                     self.StartRangeSamp = StartRangeSamp
                     self.PRFhz = PRFhz
                     self.nCohInt = nCohInt
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.nIncohInt = nIncohInt
                     self.FFTwindowingInd = FFTwindowingInd
                     self.BeamAngleAzim = BeamAngleAzim
                     self.BeamAngleZen = BeamAngleZen
                     self.AntennaCoord0 = AntennaCoord0
                     self.AntennaAngl0 = AntennaAngl0
                     self.AntennaAngl1 = AntennaAngl1
                     self.AntennaAngl2 = AntennaAngl2
                     self.AntennaCoord1 = AntennaCoord1
                     self.AntennaCoord2 = AntennaCoord2
                     self.RecPhaseCalibr0 = RecPhaseCalibr0
                     self.RecPhaseCalibr1 = RecPhaseCalibr1
                     self.RecPhaseCalibr2 = RecPhaseCalibr2
                     self.RecAmpCalibr0 = RecAmpCalibr0
                     self.RecAmpCalibr1 = RecAmpCalibr1
                     self.RecAmpCalibr2 = RecAmpCalibr2
                     self.ReceiverGaindB0 = ReceiverGaindB0
                     self.ReceiverGaindB1 = ReceiverGaindB1
                     self.ReceiverGaindB2 = ReceiverGaindB2
                     self.OffsetStartHeader = 48
                 def RHread(self, fp):
                     # print fp
                     # startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-                    startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
+                    # The method tell() returns the current position of the file read/write pointer within the file.
+                    startFp = open(fp, "rb")
                     # RecCounter=0
                     # Off2StartNxtRec=811248
                     OffRHeader = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
                     print ' '
                     print 'puntero Record Header', startFp.tell()
                     print ' '
                     startFp.seek(OffRHeader, os.SEEK_SET)
                     print ' '
                     print 'puntero Record Header con seek', startFp.tell()
                     print ' '
                     # print 'Posicion del bloque:        ',OffRHeader
                     header = numpy.fromfile(startFp, RECORD_STRUCTURE, 1)
                     print ' '
                     print 'puntero Record Header con seek', startFp.tell()
                     print ' '
                     print ' '
                     #
                     # print 'puntero Record Header despues de seek', header.tell()
                     print ' '
                     self.RecMgcNumber = hex(header['RecMgcNumber'][0])  # 0x23030001
                     self.RecCounter = int(header['RecCounter'][0])
                     self.Off2StartNxtRec = int(header['Off2StartNxtRec'][0])
                     self.Off2StartData = int(header['Off2StartData'][0])
                     self.nUtime = header['nUtime'][0]
                     self.nMilisec = header['nMilisec'][0]
                     self.ExpTagName = str(header['ExpTagName'][0])
                     self.ExpComment = str(header['ExpComment'][0])
                     self.SiteLatDegrees = header['SiteLatDegrees'][0]
                     self.SiteLongDegrees = header['SiteLongDegrees'][0]
                     self.RTCgpsStatus = header['RTCgpsStatus'][0]
                     self.TransmitFrec = header['TransmitFrec'][0]
                     self.ReceiveFrec = header['ReceiveFrec'][0]
                     self.FirstOsciFrec = header['FirstOsciFrec'][0]
                     self.Polarisation = header['Polarisation'][0]
                     self.ReceiverFiltSett = header['ReceiverFiltSett'][0]
                     self.nModesInUse = header['nModesInUse'][0]
                     self.DualModeIndex = header['DualModeIndex'][0]
                     self.DualModeRange = header['DualModeRange'][0]
                     self.nDigChannels = header['nDigChannels'][0]
                     self.SampResolution = header['SampResolution'][0]
                     self.nHeights = header['nHeights'][0]
                     self.StartRangeSamp = header['StartRangeSamp'][0]
                     self.PRFhz = header['PRFhz'][0]
                     self.nCohInt = header['nCohInt'][0]
                     self.nProfiles = header['nProfiles'][0]
                     self.nChannels = header['nChannels'][0]
                     self.nIncohInt = header['nIncohInt'][0]
                     self.FFTwindowingInd = header['FFTwindowingInd'][0]
                     self.BeamAngleAzim = header['BeamAngleAzim'][0]
                     self.BeamAngleZen = header['BeamAngleZen'][0]
                     self.AntennaCoord0 = header['AntennaCoord0'][0]
                     self.AntennaAngl0 = header['AntennaAngl0'][0]
                     self.AntennaCoord1 = header['AntennaCoord1'][0]
                     self.AntennaAngl1 = header['AntennaAngl1'][0]
                     self.AntennaCoord2 = header['AntennaCoord2'][0]
                     self.AntennaAngl2 = header['AntennaAngl2'][0]
                     self.RecPhaseCalibr0 = header['RecPhaseCalibr0'][0]
                     self.RecPhaseCalibr1 = header['RecPhaseCalibr1'][0]
                     self.RecPhaseCalibr2 = header['RecPhaseCalibr2'][0]
                     self.RecAmpCalibr0 = header['RecAmpCalibr0'][0]
                     self.RecAmpCalibr1 = header['RecAmpCalibr1'][0]
                     self.RecAmpCalibr2 = header['RecAmpCalibr2'][0]
                     self.ReceiverGaindB0 = header['ReceiverGaindB0'][0]
                     self.ReceiverGaindB1 = header['ReceiverGaindB1'][0]
                     self.ReceiverGaindB2 = header['ReceiverGaindB2'][0]
                     self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
                     self.RHsize = 180 + 20 * self.nChannels
                     self.Datasize = self.nProfiles * self.nChannels * self.nHeights * 2 * 4
                     # print 'Datasize',self.Datasize
                     endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
                     print '=============================================='
                     print 'RecMgcNumber         ', self.RecMgcNumber
                     print 'RecCounter           ', self.RecCounter
                     print 'Off2StartNxtRec      ', self.Off2StartNxtRec
                     print 'Off2StartData        ', self.Off2StartData
                     print 'Range Resolution     ', self.SampResolution
                     print 'First Height         ', self.StartRangeSamp
                     print 'PRF (Hz)             ', self.PRFhz
                     print 'Heights (K)          ', self.nHeights
                     print 'Channels (N)         ', self.nChannels
                     print 'Profiles (J)         ', self.nProfiles
                     print 'iCoh                 ', self.nCohInt
                     print 'iInCoh               ', self.nIncohInt
                     print 'BeamAngleAzim        ', self.BeamAngleAzim
                     print 'BeamAngleZen         ', self.BeamAngleZen
                     # print 'ModoEnUso            ',self.DualModeIndex
                     # print 'UtcTime              ',self.nUtime
                     # print 'MiliSec              ',self.nMilisec
                     # print 'Exp TagName          ',self.ExpTagName
                     # print 'Exp Comment          ',self.ExpComment
                     # print 'FFT Window Index     ',self.FFTwindowingInd
                     # print 'N Dig. Channels      ',self.nDigChannels
                     print 'Size de bloque       ', self.RHsize
                     print 'DataSize             ', self.Datasize
                     print 'BeamAngleAzim        ', self.BeamAngleAzim
                     # print 'AntennaCoord0        ',self.AntennaCoord0
                     # print 'AntennaAngl0         ',self.AntennaAngl0
                     # print 'AntennaCoord1        ',self.AntennaCoord1
                     # print 'AntennaAngl1         ',self.AntennaAngl1
                     # print 'AntennaCoord2        ',self.AntennaCoord2
                     # print 'AntennaAngl2         ',self.AntennaAngl2
                     print 'RecPhaseCalibr0      ', self.RecPhaseCalibr0
                     print 'RecPhaseCalibr1      ', self.RecPhaseCalibr1
                     print 'RecPhaseCalibr2      ', self.RecPhaseCalibr2
                     print 'RecAmpCalibr0        ', self.RecAmpCalibr0
                     print 'RecAmpCalibr1        ', self.RecAmpCalibr1
                     print 'RecAmpCalibr2        ', self.RecAmpCalibr2
                     print 'ReceiverGaindB0      ', self.ReceiverGaindB0
                     print 'ReceiverGaindB1      ', self.ReceiverGaindB1
                     print 'ReceiverGaindB2      ', self.ReceiverGaindB2
                     print '=============================================='
                     if OffRHeader > endFp:
-                        sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp)
+                        sys.stderr.write(
+                            "Warning %s: Size value read from System Header is lower than it has to be\n" % fp)
                         return 0
                     if OffRHeader < endFp:
-                        sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp)
+                        sys.stderr.write(
+                            "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp)
                         return 0
                     return 1
             class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODataReader):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 walk = None
                 isConfig = False
                 fileList = None
                 # metadata
                 TimeZone = None
                 Interval = None
                 heightList = None
                 # data
                 data = None
                 utctime = None
                 def __init__(self, **kwargs):
                     # Eliminar de la base la herencia
                     ProcessingUnit.__init__(self, **kwargs)
                     #self.isConfig = False
                     #self.pts2read_SelfSpectra = 0
                     #self.pts2read_CrossSpectra = 0
                     #self.pts2read_DCchannels = 0
                     #self.datablock = None
                     self.utc = None
                     self.ext = ".fdt"
                     self.optchar = "P"
                     self.fpFile = None
                     self.fp = None
                     self.BlockCounter = 0
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.fileSelector = 0
                     self.Off2StartNxtRec = 0
                     self.RecCounter = 0
                     self.flagNoMoreFiles = 0
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_output = None
                     self.path = None
                     self.OffsetStartHeader = 0
                     self.Off2StartData = 0
                     self.ipp = 0
                     self.nFDTdataRecors = 0
                     self.blocksize = 0
                     self.dataOut = Spectra()
                     self.profileIndex = 1  # Always
                     self.dataOut.flagNoData = False
                     self.dataOut.nRdPairs = 0
                     self.dataOut.pairsList = []
                     self.dataOut.data_spc = None
                     self.dataOut.noise = []
                     self.dataOut.velocityX = []
                     self.dataOut.velocityY = []
                     self.dataOut.velocityV = []
                 def Files2Read(self, fp):
                     '''
                     Function that indicates the number of .fdt files that exist in the folder to be read.
                     It also creates an organized list with the names of the files to read.
                     '''
                     # self.__checkPath()
-                    ListaData=os.listdir(fp)    #Gets the list of files within the fp address
+                    # Gets the list of files within the fp address
-                    ListaData=sorted(ListaData) #Sort the list of files from least to largest by names
+                    ListaData = os.listdir(fp)
+                    # Sort the list of files from least to largest by names
+                    ListaData = sorted(ListaData)
                     nFiles = 0  # File Counter
                     FileList = []  # A list is created that will contain the .fdt files
                     for IndexFile in ListaData:
                         if '.fdt' in IndexFile:
                             FileList.append(IndexFile)
                             nFiles += 1
                     # print 'Files2Read'
                     # print 'Existen '+str(nFiles)+' archivos .fdt'
                     self.filenameList = FileList  # List of files from least to largest by names
                 def run(self, **kwargs):
                     '''
                     This method will be the one that will initiate the data entry, will be called constantly.
                     You should first verify that your Setup () is set up and then continue to acquire
                     the data to be processed with getData ().
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
                     # print 'running'
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                           startTime=None,
                           endTime=None,
                           walk=True,
                           timezone='utc',
                           code=None,
                           online=False,
                           ReadMode=None,
                           **kwargs):
                     self.isConfig = True
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                     self.ReadMode = int(ReadMode)
                     pass
                 def getData(self):
                     '''
                     Before starting this function, you should check that there is still an unread file,
                     If there are still blocks to read or if the data block is empty.
                     You should call the file "read".
                     '''
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'NoData se vuelve true'
                         return 0
                     self.fp = self.path
                     self.Files2Read(self.fp)
                     self.readFile(self.fp)
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_output = self.data_output
                     print 'self.dataOut.data_output', shape(self.dataOut.data_output)
                     # self.removeDC()
                     return self.dataOut.data_spc
                 def readFile(self, fp):
                     '''
                     You must indicate if you are reading in Online or Offline mode and load the
                     The parameters for this file reading mode.
                     Then you must do 2 actions:
 . Get the BLTR FileHeader.
 . Start reading the first block.
                     '''
                     # The address of the folder is generated the name of the .fdt file that will be read
                     print "File:    ", self.fileSelector + 1
                     if self.fileSelector < len(self.filenameList):
-                        self.fpFile=str(fp)+'/'+str(self.filenameList[self.fileSelector])
+                        self.fpFile = str(fp) + '/' + \
+                            str(self.filenameList[self.fileSelector])
                         # print self.fpFile
                         fheader = FileHeaderBLTR()
                         fheader.FHread(self.fpFile)  # Bltr FileHeader Reading
                         self.nFDTdataRecors = fheader.nFDTdataRecors
                         self.readBlock()  # Block reading
                     else:
                         print 'readFile FlagNoData becomes true'
                         self.flagNoMoreFiles = True
                         self.dataOut.flagNoData = True
                         return 0
                 def getVelRange(self, extrapoints=0):
                     Lambda = SPEED_OF_LIGHT / 50000000
-                                PRF = self.dataOut.PRF#1./(self.dataOut.ippSeconds * self.dataOut.nCohInt)
+                    # 1./(self.dataOut.ippSeconds * self.dataOut.nCohInt)
+                    PRF = self.dataOut.PRF
                     Vmax = -Lambda / (4. * (1. / PRF) * self.dataOut.nCohInt * 2.)
                     deltafreq = PRF / (self.nProfiles)
                     deltavel = (Vmax * 2) / (self.nProfiles)
-                                freqrange = deltafreq*(numpy.arange(self.nProfiles)-self.nProfiles/2.) - deltafreq/2
+                    freqrange = deltafreq * \
-                                velrange = deltavel*(numpy.arange(self.nProfiles)-self.nProfiles/2.)
+                        (numpy.arange(self.nProfiles) - self.nProfiles / 2.) - deltafreq / 2
+                    velrange = deltavel * \
+                        (numpy.arange(self.nProfiles) - self.nProfiles / 2.)
                     return velrange
                 def readBlock(self):
                     '''
                     It should be checked if the block has data, if it is not passed to the next file.
                     Then the following is done:
 . Read the RecordHeader
 . Fill the buffer with the current block number.
                     '''
                     if self.BlockCounter < self.nFDTdataRecors - 2:
                         print self.nFDTdataRecors, 'CONDICION!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
                         if self.ReadMode == 1:
                             rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter + 1)
                         elif self.ReadMode == 0:
                             rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter)
                         rheader.RHread(self.fpFile)  # Bltr FileHeader Reading
                         self.OffsetStartHeader = rheader.OffsetStartHeader
                         self.RecCounter = rheader.RecCounter
                         self.Off2StartNxtRec = rheader.Off2StartNxtRec
                         self.Off2StartData = rheader.Off2StartData
                         self.nProfiles = rheader.nProfiles
                         self.nChannels = rheader.nChannels
                         self.nHeights = rheader.nHeights
                         self.frequency = rheader.TransmitFrec
                         self.DualModeIndex = rheader.DualModeIndex
                         self.pairsList = [(0, 1), (0, 2), (1, 2)]
                         self.dataOut.pairsList = self.pairsList
                         self.nRdPairs = len(self.dataOut.pairsList)
                         self.dataOut.nRdPairs = self.nRdPairs
                         self.__firstHeigth = rheader.StartRangeSamp
                         self.__deltaHeigth = rheader.SampResolution
-                        self.dataOut.heightList= self.__firstHeigth + numpy.array(range(self.nHeights))*self.__deltaHeigth
+                        self.dataOut.heightList = self.__firstHeigth + \
+                            numpy.array(range(self.nHeights)) * self.__deltaHeigth
                         self.dataOut.channelList = range(self.nChannels)
                         self.dataOut.nProfiles = rheader.nProfiles
                         self.dataOut.nIncohInt = rheader.nIncohInt
                         self.dataOut.nCohInt = rheader.nCohInt
                         self.dataOut.ippSeconds = 1 / float(rheader.PRFhz)
                         self.dataOut.PRF = rheader.PRFhz
                         self.dataOut.nFFTPoints = rheader.nProfiles
                         self.dataOut.utctime = rheader.nUtime
                         self.dataOut.timeZone = 0
-                        self.dataOut.normFactor= self.dataOut.nProfiles*self.dataOut.nIncohInt*self.dataOut.nCohInt
+                        self.dataOut.normFactor = self.dataOut.nProfiles * \
-                        self.dataOut.outputInterval= self.dataOut.ippSeconds * self.dataOut.nCohInt * self.dataOut.nIncohInt * self.nProfiles
+                            self.dataOut.nIncohInt * self.dataOut.nCohInt
+                        self.dataOut.outputInterval = self.dataOut.ippSeconds * \
+                            self.dataOut.nCohInt * self.dataOut.nIncohInt * self.nProfiles
                         self.data_output = numpy.ones([3, rheader.nHeights]) * numpy.NaN
                         print 'self.data_output', shape(self.data_output)
                         self.dataOut.velocityX = []
                         self.dataOut.velocityY = []
                         self.dataOut.velocityV = []
                         '''Block Reading, the Block Data is received and Reshape is used to give it
                         shape.
                         '''
                         # Procedure to take the pointer to where the date block starts
                         startDATA = open(self.fpFile, "rb")
-                        OffDATA= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec+self.Off2StartData
+                        OffDATA = self.OffsetStartHeader + self.RecCounter * \
+                            self.Off2StartNxtRec + self.Off2StartData
                         startDATA.seek(OffDATA, os.SEEK_SET)
                         def moving_average(x, N=2):
                             return numpy.convolve(x, numpy.ones((N,)) / N)[(N - 1):]
                         def gaus(xSamples, a, x0, sigma):
                             return a * exp(-(xSamples - x0)**2 / (2 * sigma**2))
                         def Find(x, value):
                             for index in range(len(x)):
                                 if x[index] == value:
                                     return index
                         def pol2cart(rho, phi):
                             x = rho * numpy.cos(phi)
                             y = rho * numpy.sin(phi)
                             return(x, y)
                         if self.DualModeIndex == self.ReadMode:
-                            self.data_fft = numpy.fromfile( startDATA, [('complex','<c8')],self.nProfiles*self.nChannels*self.nHeights )
+                            self.data_fft = numpy.fromfile(
+                                startDATA, [('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))
                             copy = self.data_block.copy()
                             spc = copy * numpy.conjugate(copy)
-                            self.data_spc = numpy.absolute(spc) # valor absoluto o magnitud
+                            self.data_spc = numpy.absolute(
+                                spc)  # valor absoluto o magnitud
                             factor = self.dataOut.normFactor
                             z = self.data_spc.copy()  # /factor
                             z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                             #zdB = 10*numpy.log10(z)
                             print ' '
                             print 'Z: '
                             print shape(z)
                             print ' '
                             print ' '
                             self.dataOut.data_spc = self.data_spc
-                            self.noise = self.dataOut.getNoise(ymin_index=80, ymax_index=132)#/factor
+                            self.noise = self.dataOut.getNoise(
+                                ymin_index=80, ymax_index=132)  # /factor
                             #noisedB = 10*numpy.log10(self.noise)
                             ySamples = numpy.ones([3, self.nProfiles])
                             phase = numpy.ones([3, self.nProfiles])
-                            CSPCSamples=numpy.ones([3,self.nProfiles],dtype=numpy.complex_)
+                            CSPCSamples = numpy.ones(
+                                [3, self.nProfiles], dtype=numpy.complex_)
                             coherence = numpy.ones([3, self.nProfiles])
                             PhaseSlope = numpy.ones(3)
                             PhaseInter = numpy.ones(3)
                             '''****** Getting CrossSpectra ******'''
                             cspc = self.data_block.copy()
                             self.data_cspc = self.data_block.copy()
                             xFrec = self.getVelRange(1)
                             VelRange = self.getVelRange(1)
                             self.dataOut.VelRange = VelRange
                             # print ' '
                             # print ' '
                             # print 'xFrec',xFrec
                             # print ' '
                             # print ' '
                             # Height=35
                             for i in range(self.nRdPairs):
                                 chan_index0 = self.dataOut.pairsList[i][0]
                                 chan_index1 = self.dataOut.pairsList[i][1]
-                                self.data_cspc[i,:,:]=cspc[chan_index0,:,:] * numpy.conjugate(cspc[chan_index1,:,:])
+                                self.data_cspc[i, :, :] = cspc[chan_index0, :,
+                                                               :] * numpy.conjugate(cspc[chan_index1, :, :])
                                 '''Getting Eij and Nij'''
-                                (AntennaX0,AntennaY0)=pol2cart(rheader.AntennaCoord0, rheader.AntennaAngl0*numpy.pi/180)
+                                (AntennaX0, AntennaY0) = pol2cart(
-                                (AntennaX1,AntennaY1)=pol2cart(rheader.AntennaCoord1, rheader.AntennaAngl1*numpy.pi/180)
+                                    rheader.AntennaCoord0, rheader.AntennaAngl0 * numpy.pi / 180)
-                                (AntennaX2,AntennaY2)=pol2cart(rheader.AntennaCoord2, rheader.AntennaAngl2*numpy.pi/180)
+                                (AntennaX1, AntennaY1) = pol2cart(
+                                    rheader.AntennaCoord1, rheader.AntennaAngl1 * numpy.pi / 180)
+                                (AntennaX2, AntennaY2) = pol2cart(
+                                    rheader.AntennaCoord2, rheader.AntennaAngl2 * numpy.pi / 180)
                                 E01 = AntennaX0 - AntennaX1
                                 N01 = AntennaY0 - AntennaY1
                                 E02 = AntennaX0 - AntennaX2
                                 N02 = AntennaY0 - AntennaY2
                                 E12 = AntennaX1 - AntennaX2
                                 N12 = AntennaY1 - AntennaY2
-                                self.ChanDist= numpy.array([[E01, N01],[E02,N02],[E12,N12]])
+                                self.ChanDist = numpy.array(
+                                    [[E01, N01], [E02, N02], [E12, N12]])
                                 self.dataOut.ChanDist = self.ChanDist
             #                 for Height in range(self.nHeights):
             #
             #                     for i in range(self.nRdPairs):
             #
             #                         '''****** Line of Data SPC ******'''
             #                         zline=z[i,:,Height]
             #
             #                         '''****** DC is removed ******'''
             #                         DC=Find(zline,numpy.amax(zline))
             #                         zline[DC]=(zline[DC-1]+zline[DC+1])/2
             #
             #
             #                         '''****** SPC is normalized ******'''
             #                         FactNorm= zline.copy() / numpy.sum(zline.copy())
             #                         FactNorm= FactNorm/numpy.sum(FactNorm)
             #
             #                         SmoothSPC=moving_average(FactNorm,N=3)
             #
             #                         xSamples = ar(range(len(SmoothSPC)))
             #                         ySamples[i] = SmoothSPC-self.noise[i]
             #
             #                     for i in range(self.nRdPairs):
             #
             #                         '''****** Line of Data CSPC ******'''
             #                         cspcLine=self.data_cspc[i,:,Height].copy()
             #
             #
             #
             #                         '''****** CSPC is normalized ******'''
             #                         chan_index0 = self.dataOut.pairsList[i][0]
             #                         chan_index1 = self.dataOut.pairsList[i][1]
             #                         CSPCFactor= numpy.sum(ySamples[chan_index0]) * numpy.sum(ySamples[chan_index1])
             #
             #
             #                         CSPCNorm= cspcLine.copy() / numpy.sqrt(CSPCFactor)
             #
             #
             #                         CSPCSamples[i] = CSPCNorm-self.noise[i]
             #                         coherence[i] = numpy.abs(CSPCSamples[i]) / numpy.sqrt(CSPCFactor)
             #
             #                         '''****** DC is removed ******'''
             #                         DC=Find(coherence[i],numpy.amax(coherence[i]))
             #                         coherence[i][DC]=(coherence[i][DC-1]+coherence[i][DC+1])/2
             #                         coherence[i]= moving_average(coherence[i],N=2)
             #
             #                         phase[i] = moving_average( numpy.arctan2(CSPCSamples[i].imag, CSPCSamples[i].real),N=1)#*180/numpy.pi
             #
             #
             #                     '''****** Getting fij width ******'''
             #
             #                     yMean=[]
             #                     yMean2=[]
             #
             #                     for j in range(len(ySamples[1])):
             #                         yMean=numpy.append(yMean,numpy.average([ySamples[0,j],ySamples[1,j],ySamples[2,j]]))
             #
             #                     '''******* Getting fitting Gaussian ******'''
             #                     meanGauss=sum(xSamples*yMean) / len(xSamples)
             #                     sigma=sum(yMean*(xSamples-meanGauss)**2) / len(xSamples)
             #                     #print 'Height',Height,'SNR', meanGauss/sigma**2
             #
             #                     if (abs(meanGauss/sigma**2) > 0.0001) :
             #
             #                         try:
             #                             popt,pcov = curve_fit(gaus,xSamples,yMean,p0=[1,meanGauss,sigma])
             #
             #                             if numpy.amax(popt)>numpy.amax(yMean)*0.3:
             #                                 FitGauss=gaus(xSamples,*popt)
             #
             #                             else:
             #                                 FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
             #                                 print 'Verificador:     Dentro', Height
             #                         except RuntimeError:
             #
             #                             try:
             #                                 for j in range(len(ySamples[1])):
             #                                     yMean2=numpy.append(yMean2,numpy.average([ySamples[1,j],ySamples[2,j]]))
             #                                 popt,pcov = curve_fit(gaus,xSamples,yMean2,p0=[1,meanGauss,sigma])
             #                                 FitGauss=gaus(xSamples,*popt)
             #                                 print 'Verificador:     Exepcion1', Height
             #                             except RuntimeError:
             #
             #                                 try:
             #                                     popt,pcov = curve_fit(gaus,xSamples,ySamples[1],p0=[1,meanGauss,sigma])
             #                                     FitGauss=gaus(xSamples,*popt)
             #                                     print 'Verificador:     Exepcion2', Height
             #                                 except RuntimeError:
             #                                     FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
             #                                     print 'Verificador:     Exepcion3', Height
             #                     else:
             #                         FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
             #                         #print 'Verificador:     Fuera', Height
             #
             #
             #
             #                     Maximun=numpy.amax(yMean)
             #                     eMinus1=Maximun*numpy.exp(-1)
             #
             #                     HWpos=Find(FitGauss,min(FitGauss, key=lambda value:abs(value-eMinus1)))
             #                     HalfWidth= xFrec[HWpos]
             #                     GCpos=Find(FitGauss, numpy.amax(FitGauss))
             #                     Vpos=Find(FactNorm, numpy.amax(FactNorm))
             #                     #Vpos=numpy.sum(FactNorm)/len(FactNorm)
             #                     #Vpos=Find(FactNorm, min(FactNorm, key=lambda value:abs(value- numpy.mean(FactNorm) )))
             #                     #print 'GCpos',GCpos, numpy.amax(FitGauss), 'HWpos',HWpos
             #                     '''****** Getting Fij ******'''
             #
             #                     GaussCenter=xFrec[GCpos]
             #                     if (GaussCenter<0 and HalfWidth>0) or (GaussCenter>0 and HalfWidth<0):
             #                         Fij=abs(GaussCenter)+abs(HalfWidth)+0.0000001
             #                     else:
             #                         Fij=abs(GaussCenter-HalfWidth)+0.0000001
             #
             #                     '''****** Getting Frecuency range of significant data ******'''
             #
             #                     Rangpos=Find(FitGauss,min(FitGauss, key=lambda value:abs(value-Maximun*0.10)))
             #
             #                     if Rangpos<GCpos:
             #                         Range=numpy.array([Rangpos,2*GCpos-Rangpos])
             #                     else:
             #                         Range=numpy.array([2*GCpos-Rangpos,Rangpos])
             #
             #                     FrecRange=xFrec[Range[0]:Range[1]]
             #
             #                     #print 'FrecRange', FrecRange
             #                     '''****** Getting SCPC Slope ******'''
             #
             #                     for i in range(self.nRdPairs):
             #
             #                         if len(FrecRange)>5 and len(FrecRange)<self.nProfiles*0.5:
             #                             PhaseRange=moving_average(phase[i,Range[0]:Range[1]],N=3)
             #
             #                             slope, intercept, r_value, p_value, std_err = stats.linregress(FrecRange,PhaseRange)
             #                             PhaseSlope[i]=slope
             #                             PhaseInter[i]=intercept
             #                         else:
             #                             PhaseSlope[i]=0
             #                             PhaseInter[i]=0
             #
             #         #                     plt.figure(i+15)
             #         #                     plt.title('FASE ( CH%s*CH%s )' %(self.dataOut.pairsList[i][0],self.dataOut.pairsList[i][1]))
             #         #                     plt.xlabel('Frecuencia (KHz)')
             #         #                     plt.ylabel('Magnitud')
             #         #                     #plt.subplot(311+i)
             #         #                     plt.plot(FrecRange,PhaseRange,'b')
             #         #                     plt.plot(FrecRange,FrecRange*PhaseSlope[i]+PhaseInter[i],'r')
             #
             #                         #plt.axis([-0.6, 0.2, -3.2, 3.2])
             #
             #
             #                     '''Getting constant C'''
             #                     cC=(Fij*numpy.pi)**2
             #
             # #                     '''Getting Eij and Nij'''
             # #                     (AntennaX0,AntennaY0)=pol2cart(rheader.AntennaCoord0, rheader.AntennaAngl0*numpy.pi/180)
             # #                     (AntennaX1,AntennaY1)=pol2cart(rheader.AntennaCoord1, rheader.AntennaAngl1*numpy.pi/180)
             # #                     (AntennaX2,AntennaY2)=pol2cart(rheader.AntennaCoord2, rheader.AntennaAngl2*numpy.pi/180)
             # #
             # #                     E01=AntennaX0-AntennaX1
             # #                     N01=AntennaY0-AntennaY1
             # #
             # #                     E02=AntennaX0-AntennaX2
             # #                     N02=AntennaY0-AntennaY2
             # #
             # #                     E12=AntennaX1-AntennaX2
             # #                     N12=AntennaY1-AntennaY2
             #
             #                     '''****** Getting constants F and G ******'''
             #                     MijEijNij=numpy.array([[E02,N02], [E12,N12]])
             #                     MijResult0=(-PhaseSlope[1]*cC) / (2*numpy.pi)
             #                     MijResult1=(-PhaseSlope[2]*cC) / (2*numpy.pi)
             #                     MijResults=numpy.array([MijResult0,MijResult1])
             #                     (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
             #
             #                     '''****** Getting constants A, B and H ******'''
             #                     W01=numpy.amax(coherence[0])
             #                     W02=numpy.amax(coherence[1])
             #                     W12=numpy.amax(coherence[2])
             #
             #                     WijResult0=((cF*E01+cG*N01)**2)/cC - numpy.log(W01 / numpy.sqrt(numpy.pi/cC))
             #                     WijResult1=((cF*E02+cG*N02)**2)/cC - numpy.log(W02 / numpy.sqrt(numpy.pi/cC))
             #                     WijResult2=((cF*E12+cG*N12)**2)/cC - numpy.log(W12 / numpy.sqrt(numpy.pi/cC))
             #
             #                     WijResults=numpy.array([WijResult0, WijResult1, WijResult2])
             #
             #                     WijEijNij=numpy.array([ [E01**2, N01**2, 2*E01*N01] , [E02**2, N02**2, 2*E02*N02] , [E12**2, N12**2, 2*E12*N12] ])
             #                     (cA,cB,cH) = numpy.linalg.solve(WijEijNij, WijResults)
             #
             #                     VxVy=numpy.array([[cA,cH],[cH,cB]])
             #
             #                     VxVyResults=numpy.array([-cF,-cG])
             #                     (Vx,Vy) = numpy.linalg.solve(VxVy, VxVyResults)
             #                     Vzon = Vy
             #                     Vmer = Vx
             #                     Vmag=numpy.sqrt(Vzon**2+Vmer**2)
             #                     Vang=numpy.arctan2(Vmer,Vzon)
             #
             #                     if abs(Vy)<100 and abs(Vy)> 0.:
             #                         self.dataOut.velocityX=numpy.append(self.dataOut.velocityX, Vzon) #Vmag
             #                         #print 'Vmag',Vmag
             #                     else:
             #                         self.dataOut.velocityX=numpy.append(self.dataOut.velocityX, NaN)
             #
             #                     if abs(Vx)<100 and abs(Vx) > 0.:
             #                         self.dataOut.velocityY=numpy.append(self.dataOut.velocityY, Vmer) #Vang
             #                         #print 'Vang',Vang
             #                     else:
             #                         self.dataOut.velocityY=numpy.append(self.dataOut.velocityY, NaN)
             #
             #                     if abs(GaussCenter)<2:
             #                         self.dataOut.velocityV=numpy.append(self.dataOut.velocityV, xFrec[Vpos])
             #
             #                     else:
             #                         self.dataOut.velocityV=numpy.append(self.dataOut.velocityV, NaN)
             #
             #
             # #                 print '********************************************'
             # #                 print 'HalfWidth    ', HalfWidth
             # #                 print 'Maximun      ', Maximun
             # #                 print 'eMinus1      ', eMinus1
             # #                 print 'Rangpos      ', Rangpos
             # #                 print 'GaussCenter  ',GaussCenter
             # #                 print 'E01          ',E01
             # #                 print 'N01          ',N01
             # #                 print 'E02          ',E02
             # #                 print 'N02          ',N02
             # #                 print 'E12          ',E12
             # #                 print 'N12          ',N12
             #                 #print 'self.dataOut.velocityX          ', self.dataOut.velocityX
             # #                 print 'Fij          ', Fij
             # #                 print 'cC           ', cC
             # #                 print 'cF           ', cF
             # #                 print 'cG           ', cG
             # #                 print 'cA           ', cA
             # #                 print 'cB           ', cB
             # #                 print 'cH           ', cH
             # #                 print 'Vx           ', Vx
             # #                 print 'Vy           ', Vy
             # #                 print 'Vmag         ', Vmag
             # #                 print 'Vang         ', Vang*180/numpy.pi
             # #                 print 'PhaseSlope   ',PhaseSlope[0]
             # #                 print 'PhaseSlope   ',PhaseSlope[1]
             # #                 print 'PhaseSlope   ',PhaseSlope[2]
             # #                 print '********************************************'
             #                 #print 'data_output',shape(self.dataOut.velocityX), shape(self.dataOut.velocityY)
             #
             #                 #print 'self.dataOut.velocityX', len(self.dataOut.velocityX)
             #                 #print 'self.dataOut.velocityY', len(self.dataOut.velocityY)
             #                 #print 'self.dataOut.velocityV', self.dataOut.velocityV
             #
             #                 self.data_output[0]=numpy.array(self.dataOut.velocityX)
             #                 self.data_output[1]=numpy.array(self.dataOut.velocityY)
             #                 self.data_output[2]=numpy.array(self.dataOut.velocityV)
             #
             #                 prin= self.data_output[0][~numpy.isnan(self.data_output[0])]
             #                 print ' '
             #                 print 'VmagAverage',numpy.mean(prin)
             #                 print ' '
             # #                 plt.figure(5)
             # #                 plt.subplot(211)
             # #                 plt.plot(self.dataOut.velocityX,'yo:')
             # #                 plt.subplot(212)
             # #                 plt.plot(self.dataOut.velocityY,'yo:')
             #
             # #                 plt.figure(1)
             # # #                 plt.subplot(121)
             # # #                plt.plot(xFrec,ySamples[0],'k',label='Ch0')
             # # #                 plt.plot(xFrec,ySamples[1],'g',label='Ch1')
             # # #                 plt.plot(xFrec,ySamples[2],'r',label='Ch2')
             # # #                 plt.plot(xFrec,FitGauss,'yo:',label='fit')
             # # #                 plt.legend()
             # #                 plt.title('DATOS A ALTURA DE 2850 METROS')
             # #
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # # #                 plt.subplot(122)
             # # #                 plt.title('Fit for Time Constant')
             # #                 #plt.plot(xFrec,zline)
             # #                 #plt.plot(xFrec,SmoothSPC,'g')
             # #                 plt.plot(xFrec,FactNorm)
             # #                 plt.axis([-4, 4, 0, 0.15])
             # # #                 plt.xlabel('SelfSpectra KHz')
             # #
             # #                 plt.figure(10)
             # # #                 plt.subplot(121)
             # #                 plt.plot(xFrec,ySamples[0],'b',label='Ch0')
             # #                 plt.plot(xFrec,ySamples[1],'y',label='Ch1')
             # #                 plt.plot(xFrec,ySamples[2],'r',label='Ch2')
             # # #                plt.plot(xFrec,FitGauss,'yo:',label='fit')
             # #                 plt.legend()
             # #                 plt.title('SELFSPECTRA EN CANALES')
             # #
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # # #                 plt.subplot(122)
             # # #                 plt.title('Fit for Time Constant')
             # #                 #plt.plot(xFrec,zline)
             # #                 #plt.plot(xFrec,SmoothSPC,'g')
             # # #                plt.plot(xFrec,FactNorm)
             # # #                plt.axis([-4, 4, 0, 0.15])
             # # #                 plt.xlabel('SelfSpectra KHz')
             # #
             # #                 plt.figure(9)
             # #
             # #
             # #                 plt.title('DATOS SUAVIZADOS')
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # #                 plt.plot(xFrec,SmoothSPC,'g')
             # #
             # #                 #plt.plot(xFrec,FactNorm)
             # #                 plt.axis([-4, 4, 0, 0.15])
             # # #                 plt.xlabel('SelfSpectra KHz')
             # # #
             # #                 plt.figure(2)
             # # #                 #plt.subplot(121)
             # #                 plt.plot(xFrec,yMean,'r',label='Mean SelfSpectra')
             # #                 plt.plot(xFrec,FitGauss,'yo:',label='Ajuste Gaussiano')
             # # #                 plt.plot(xFrec[Rangpos],FitGauss[Find(FitGauss,min(FitGauss, key=lambda value:abs(value-Maximun*0.1)))],'bo')
             # # #                 #plt.plot(xFrec,phase)
             # # #                 plt.xlabel('Suavizado, promediado KHz')
             # #                 plt.title('SELFSPECTRA PROMEDIADO')
             # # #                 #plt.subplot(122)
             # # #                 #plt.plot(xSamples,zline)
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # #                 plt.legend()
             # # #
             # # #                 plt.figure(3)
             # # #                 plt.subplot(311)
             # # #                 #plt.plot(xFrec,phase[0])
             # # #                 plt.plot(xFrec,phase[0],'g')
             # # #                 plt.subplot(312)
             # # #                 plt.plot(xFrec,phase[1],'g')
             # # #                 plt.subplot(313)
             # # #                 plt.plot(xFrec,phase[2],'g')
             # # #                 #plt.plot(xFrec,phase[2])
             # # #
             # # #                 plt.figure(4)
             # # #
             # # #                 plt.plot(xSamples,coherence[0],'b')
             # # #                 plt.plot(xSamples,coherence[1],'r')
             # # #                 plt.plot(xSamples,coherence[2],'g')
             # #                 plt.show()
             # # #
             # # #                 plt.clf()
             # # #                 plt.cla()
             # # #                 plt.close()
             #
             #                 print ' '
                         self.BlockCounter += 2
                     else:
                         self.fileSelector += 1
                         self.BlockCounter = 0
                         print "Next File"

schainpy/model/io/jroIO_mira35c.py +92 -93

-            import os, sys
+            import os
+            import sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
-            import matplotlib.pyplot as plt
-            import pylab as plb
             from scipy.optimize import curve_fit
             from scipy import asarray as ar, exp
             from scipy import stats
             from numpy.ma.core import getdata
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
             #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 numpy import imag, shape, NaN, empty
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
                 def printInfo(self):
                     message = "#" * 50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
                     keyList = self.__dict__.keys()
                     keyList.sort()
                     for key in keyList:
                         message += "%s = %s" % (key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
                             message += "%s = %s" % ("size", attr) + "\n"
                     # print message
             FILE_HEADER = numpy.dtype([  # HEADER 1024bytes
                                       ('Hname', 'a32'),  # Original file name
-                                      ('Htime',numpy.str_,32),      #Date and time when the file was created
+                                      # Date and time when the file was created
-                                      ('Hoper',numpy.str_,64),      #Name of operator who created the file
+                                      ('Htime', numpy.str_, 32),
-                                      ('Hplace',numpy.str_,128),    #Place where the measurements was carried out
+                                      # Name of operator who created the file
-                                      ('Hdescr',numpy.str_,256),    #Description of measurements
+                                      ('Hoper', numpy.str_, 64),
+                                      # Place where the measurements was carried out
+                                      ('Hplace', numpy.str_, 128),
+                                      # Description of measurements
+                                      ('Hdescr', numpy.str_, 256),
                                       ('Hdummy', numpy.str_, 512),  # Reserved space
                                       # Main chunk 8bytes
-                                      ('Msign',numpy.str_,4),       #Main chunk signature FZKF or NUIG
+                                      # Main chunk signature FZKF or NUIG
+                                      ('Msign', numpy.str_, 4),
                                       ('MsizeData', '<i4'),  # Size of data block main chunk
                                       # Processing DSP parameters 36bytes
                                       ('PPARsign', numpy.str_, 4),  # PPAR signature
                                       ('PPARsize', '<i4'),  # PPAR size of block
                                       ('PPARprf', '<i4'),  # Pulse repetition frequency
                                       ('PPARpdr', '<i4'),  # Pulse duration
                                       ('PPARsft', '<i4'),  # FFT length
-                                      ('PPARavc','<i4'),        #Number of spectral (in-coherent) averages
+                                      # Number of spectral (in-coherent) averages
-                                      ('PPARihp','<i4'),        #Number of lowest range gate for moment estimation
+                                      ('PPARavc', '<i4'),
-                                      ('PPARchg','<i4'),        #Count for gates for moment estimation
+                                      # Number of lowest range gate for moment estimation
-                                      ('PPARpol','<i4'),        #switch on/off polarimetric measurements. Should be 1.
+                                      ('PPARihp', '<i4'),
+                                      # Count for gates for moment estimation
+                                      ('PPARchg', '<i4'),
+                                      # switch on/off polarimetric measurements. Should be 1.
+                                      ('PPARpol', '<i4'),
                                       # Service DSP parameters 112bytes
-                                      ('SPARatt','<i4'),       #STC attenuation on the lowest ranges on/off
+                                      # STC attenuation on the lowest ranges on/off
+                                      ('SPARatt', '<i4'),
                                       ('SPARtx', '<i4'),  # OBSOLETE
                                       ('SPARaddGain0', '<f4'),  # OBSOLETE
                                       ('SPARaddGain1', '<f4'),  # OBSOLETE
-                                      ('SPARwnd','<i4'),     #Debug only. It normal mode it is 0.
+                                      # Debug only. It normal mode it is 0.
-                                      ('SPARpos','<i4'),     #Delay between sync pulse and tx pulse for phase corr, ns
+                                      ('SPARwnd', '<i4'),
-                                      ('SPARadd','<i4'),     #"add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
+                                      # Delay between sync pulse and tx pulse for phase corr, ns
-                                      ('SPARlen','<i4'),     #Time for measuring txn pulse phase. OBSOLETE
+                                      ('SPARpos', '<i4'),
+                                      # "add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
+                                      ('SPARadd', '<i4'),
+                                      # Time for measuring txn pulse phase. OBSOLETE
+                                      ('SPARlen', '<i4'),
                                       ('SPARcal', '<i4'),  # OBSOLETE
                                       ('SPARnos', '<i4'),  # OBSOLETE
                                       ('SPARof0', '<i4'),  # detection threshold
                                       ('SPARof1', '<i4'),  # OBSOLETE
                                       ('SPARswt', '<i4'),  # 2nd moment estimation threshold
                                       ('SPARsum', '<i4'),  # OBSOLETE
                                       ('SPARosc', '<i4'),  # flag Oscillosgram mode
                                       ('SPARtst', '<i4'),  # OBSOLETE
                                       ('SPARcor', '<i4'),  # OBSOLETE
                                       ('SPARofs', '<i4'),  # OBSOLETE
-                                      ('SPARhsn','<i4'),     #Hildebrand div noise detection on noise gate
+                                      # Hildebrand div noise detection on noise gate
-                                      ('SPARhsa','<f4'),     #Hildebrand div noise detection on all gates
+                                      ('SPARhsn', '<i4'),
+                                      # Hildebrand div noise detection on all gates
+                                      ('SPARhsa', '<f4'),
                                       ('SPARcalibPow_M', '<f4'),  # OBSOLETE
                                       ('SPARcalibSNR_M', '<f4'),  # OBSOLETE
                                       ('SPARcalibPow_S', '<f4'),  # OBSOLETE
                                       ('SPARcalibSNR_S', '<f4'),  # OBSOLETE
-                                      ('SPARrawGate1','<i4'),     #Lowest range gate for spectra saving Raw_Gate1 >=5
+                                      # Lowest range gate for spectra saving Raw_Gate1 >=5
-                                      ('SPARrawGate2','<i4'),     #Number of range gates with atmospheric signal
+                                      ('SPARrawGate1', '<i4'),
-                                      ('SPARraw','<i4'),          #flag - IQ or spectra saving on/off
+                                      # Number of range gates with atmospheric signal
+                                      ('SPARrawGate2', '<i4'),
+                                      # flag - IQ or spectra saving on/off
+                                      ('SPARraw', '<i4'),
                                       ('SPARprc', '<i4'), ])  # flag - Moment estimation switched on/off
             class FileHeaderMIRA35c(Header):
                 def __init__(self):
                     self.Hname = None
                     self.Htime = None
                     self.Hoper = None
                     self.Hplace = None
                     self.Hdescr = None
                     self.Hdummy = None
                     self.Msign = None
                     self.MsizeData = None
                     self.PPARsign = None
                     self.PPARsize = None
                     self.PPARprf = None
                     self.PPARpdr = None
                     self.PPARsft = None
                     self.PPARavc = None
                     self.PPARihp = None
                     self.PPARchg = None
                     self.PPARpol = None
                     # Service DSP parameters
                     self.SPARatt = None
                     self.SPARtx = None
                     self.SPARaddGain0 = None
                     self.SPARaddGain1 = None
                     self.SPARwnd = None
                     self.SPARpos = None
                     self.SPARadd = None
                     self.SPARlen = None
                     self.SPARcal = None
                     self.SPARnos = None
                     self.SPARof0 = None
                     self.SPARof1 = None
                     self.SPARswt = None
                     self.SPARsum = None
                     self.SPARosc = None
                     self.SPARtst = None
                     self.SPARcor = None
                     self.SPARofs = None
                     self.SPARhsn = None
                     self.SPARhsa = None
                     self.SPARcalibPow_M = None
                     self.SPARcalibSNR_M = None
                     self.SPARcalibPow_S = None
                     self.SPARcalibSNR_S = None
                     self.SPARrawGate1 = None
                     self.SPARrawGate2 = None
                     self.SPARraw = None
                     self.SPARprc = None
                     self.FHsize = 1180
                 def FHread(self, fp):
                     header = numpy.fromfile(fp, FILE_HEADER, 1)
                     '''      numpy.fromfile(file, dtype, count, sep='')
                         file : file or str
                         Open file object or filename.
                         dtype : data-type
                         Data type of the returned array. For binary files, it is used to determine
                         the size and byte-order of the items in the file.
                         count : int
                         Number of items to read. -1 means all items (i.e., the complete file).
                         sep : str
                         Separator between items if file is a text file. Empty ("") separator means
                         the file should be treated as binary. Spaces (" ") in the separator match zero
                         or more whitespace characters. A separator consisting only of spaces must match
                         at least one whitespace.
                 '''
                     self.Hname = str(header['Hname'][0])
                     self.Htime = str(header['Htime'][0])
                     self.Hoper = str(header['Hoper'][0])
                     self.Hplace = str(header['Hplace'][0])
                     self.Hdescr = str(header['Hdescr'][0])
                     self.Hdummy = str(header['Hdummy'][0])
                     # 1024
                     self.Msign = str(header['Msign'][0])
                     self.MsizeData = header['MsizeData'][0]
                     # 8
                     self.PPARsign = str(header['PPARsign'][0])
                     self.PPARsize = header['PPARsize'][0]
                     self.PPARprf = header['PPARprf'][0]
                     self.PPARpdr = header['PPARpdr'][0]
                     self.PPARsft = header['PPARsft'][0]
                     self.PPARavc = header['PPARavc'][0]
                     self.PPARihp = header['PPARihp'][0]
                     self.PPARchg = header['PPARchg'][0]
                     self.PPARpol = header['PPARpol'][0]
                     # Service DSP parameters
                     # 36
                     self.SPARatt = header['SPARatt'][0]
                     self.SPARtx = header['SPARtx'][0]
                     self.SPARaddGain0 = header['SPARaddGain0'][0]
                     self.SPARaddGain1 = header['SPARaddGain1'][0]
                     self.SPARwnd = header['SPARwnd'][0]
                     self.SPARpos = header['SPARpos'][0]
                     self.SPARadd = header['SPARadd'][0]
                     self.SPARlen = header['SPARlen'][0]
                     self.SPARcal = header['SPARcal'][0]
                     self.SPARnos = header['SPARnos'][0]
                     self.SPARof0 = header['SPARof0'][0]
                     self.SPARof1 = header['SPARof1'][0]
                     self.SPARswt = header['SPARswt'][0]
                     self.SPARsum = header['SPARsum'][0]
                     self.SPARosc = header['SPARosc'][0]
                     self.SPARtst = header['SPARtst'][0]
                     self.SPARcor = header['SPARcor'][0]
                     self.SPARofs = header['SPARofs'][0]
                     self.SPARhsn = header['SPARhsn'][0]
                     self.SPARhsa = header['SPARhsa'][0]
                     self.SPARcalibPow_M = header['SPARcalibPow_M'][0]
                     self.SPARcalibSNR_M = header['SPARcalibSNR_M'][0]
                     self.SPARcalibPow_S = header['SPARcalibPow_S'][0]
                     self.SPARcalibSNR_S = header['SPARcalibSNR_S'][0]
                     self.SPARrawGate1 = header['SPARrawGate1'][0]
                     self.SPARrawGate2 = header['SPARrawGate2'][0]
                     self.SPARraw = header['SPARraw'][0]
                     self.SPARprc = header['SPARprc'][0]
                     # 112
                     # 1180
                     # print 'Pointer fp header', fp.tell()
                     # print ' '
                     # print 'SPARrawGate'
                     # print self.SPARrawGate2 - self.SPARrawGate1
                     # print ' '
                     # print 'Hname'
                     # print self.Hname
                     # print ' '
                     # print 'Msign'
                     # print self.Msign
                 def write(self, fp):
                     headerTuple = (self.Hname,
                                    self.Htime,
                                    self.Hoper,
                                    self.Hplace,
                                    self.Hdescr,
                                    self.Hdummy)
                     header = numpy.array(headerTuple, FILE_HEADER)
                     #        numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
                     header.tofile(fp)
                     ''' ndarray.tofile(fid, sep, format)    Write array to a file as text or binary (default).
                     fid : file or str
                     An open file object, or a string containing a filename.
                     sep : str
                     Separator between array items for text output. If "" (empty), a binary file is written,
                     equivalent to file.write(a.tobytes()).
                     format : str
                     Format string for text file output. Each entry in the array is formatted to text by
                     first converting it to the closest Python type, and then using "format" % item.
                     '''
                     return 1
             SRVI_HEADER = numpy.dtype([
-                                     ('SignatureSRVI1',numpy.str_,4),#
+                                     ('SignatureSRVI1', numpy.str_, 4),
-                                     ('SizeOfDataBlock1','<i4'),#
+                                     ('SizeOfDataBlock1', '<i4'),
-                                     ('DataBlockTitleSRVI1',numpy.str_,4),#
+                                     ('DataBlockTitleSRVI1', numpy.str_, 4),
-                                     ('SizeOfSRVI1','<i4'),])#
+                                     ('SizeOfSRVI1', '<i4'), ])
             class SRVIHeader(Header):
                 def __init__(self,     SignatureSRVI1=0,     SizeOfDataBlock1=0,     DataBlockTitleSRVI1=0,    SizeOfSRVI1=0):
                     self.SignatureSRVI1 = SignatureSRVI1
                     self.SizeOfDataBlock1 = SizeOfDataBlock1
                     self.DataBlockTitleSRVI1 = DataBlockTitleSRVI1
                     self.SizeOfSRVI1 = SizeOfSRVI1
                     self.SRVIHsize = 16
                 def SRVIread(self, fp):
                     header = numpy.fromfile(fp, SRVI_HEADER, 1)
                     self.SignatureSRVI1 = str(header['SignatureSRVI1'][0])
                     self.SizeOfDataBlock1 = header['SizeOfDataBlock1'][0]
                     self.DataBlockTitleSRVI1 = str(header['DataBlockTitleSRVI1'][0])
                     self.SizeOfSRVI1 = header['SizeOfSRVI1'][0]
                     # 16
                     print 'Pointer fp SRVIheader', fp.tell()
             SRVI_STRUCTURE = numpy.dtype([
-                                        ('frame_cnt','<u4'),#
+                                        ('frame_cnt', '<u4'),
                                         ('time_t', '<u4'),   #
                                         ('tpow', '<f4'),     #
                                         ('npw1', '<f4'),     #
                                         ('npw2', '<f4'),     #
                                         ('cpw1', '<f4'),     #
                                         ('pcw2', '<f4'),     #
                                         ('ps_err', '<u4'),   #
                                         ('te_err', '<u4'),   #
                                         ('rc_err', '<u4'),   #
                                         ('grs1', '<u4'),     #
                                         ('grs2', '<u4'),     #
                                         ('azipos', '<f4'),     #
                                         ('azivel', '<f4'),     #
                                         ('elvpos', '<f4'),     #
                                         ('elvvel', '<f4'),     #
-                                        ('northAngle','<f4'), #
+                                        ('northAngle', '<f4'),
                                         ('microsec', '<u4'),   #
                                         ('azisetvel', '<f4'),  #
                                         ('elvsetpos', '<f4'),  #
                                         ('RadarConst', '<f4'), ])   #
             class RecordHeader(Header):
                 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,
                              grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,
                              microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0, RecCounter=0, Off2StartNxtRec=0):
                     self.frame_cnt = frame_cnt
                     self.dwell = time_t
                     self.tpow = tpow
                     self.npw1 = npw1
                     self.npw2 = npw2
                     self.cpw1 = cpw1
                     self.pcw2 = pcw2
                     self.ps_err = ps_err
                     self.te_err = te_err
                     self.rc_err = rc_err
                     self.grs1 = grs1
                     self.grs2 = grs2
                     self.azipos = azipos
                     self.azivel = azivel
                     self.elvpos = elvpos
                     self.elvvel = elvvel
                     self.northAngle = northangle
                     self.microsec = microsec
                     self.azisetvel = azisetvel
                     self.elvsetpos = elvsetpos
                     self.RadarConst = RadarConst
                     self.RHsize = 84
                     self.RecCounter = RecCounter
                     self.Off2StartNxtRec = Off2StartNxtRec
                 def RHread(self, fp):
                     # 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)
                     #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.frame_cnt = header['frame_cnt'][0]
                     self.time_t = header['time_t'][0]   #
                     self.tpow = header['tpow'][0]     #
                     self.npw1 = header['npw1'][0]     #
                     self.npw2 = header['npw2'][0]     #
                     self.cpw1 = header['cpw1'][0]     #
                     self.pcw2 = header['pcw2'][0]     #
                     self.ps_err = header['ps_err'][0]    #
                     self.te_err = header['te_err'][0]    #
                     self.rc_err = header['rc_err'][0]    #
                     self.grs1 = header['grs1'][0]      #
                     self.grs2 = header['grs2'][0]      #
                     self.azipos = header['azipos'][0]     #
                     self.azivel = header['azivel'][0]     #
                     self.elvpos = header['elvpos'][0]     #
                     self.elvvel = header['elvvel'][0]     #
                     self.northAngle = header['northAngle'][0]    #
                     self.microsec = header['microsec'][0]      #
                     self.azisetvel = header['azisetvel'][0]     #
                     self.elvsetpos = header['elvsetpos'][0]     #
                     self.RadarConst = header['RadarConst'][0]    #
                     # 84
                     # print 'Pointer fp RECheader', fp.tell()
                     #self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
                     #self.RHsize = 180+20*self.nChannels
                     #self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
                     # print 'Datasize',self.Datasize
                     #endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
                     print '=============================================='
                     print '=============================================='
                     return 1
             class MIRA35CReader (ProcessingUnit, FileHeaderMIRA35c, SRVIHeader, RecordHeader):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 walk = None
                 isConfig = False
                 fileList = None
                 # metadata
                 TimeZone = None
                 Interval = None
                 heightList = None
                 # data
                 data = None
                 utctime = None
                 def __init__(self, **kwargs):
                     # Eliminar de la base la herencia
                     ProcessingUnit.__init__(self, **kwargs)
                     self.PointerReader = 0
                     self.FileHeaderFlag = False
                     self.utc = None
                     self.ext = ".zspca"
                     self.optchar = "P"
                     self.fpFile = None
                     self.fp = None
                     self.BlockCounter = 0
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.fileSelector = 0
                     self.Off2StartNxtRec = 0
                     self.RecCounter = 0
                     self.flagNoMoreFiles = 0
                     self.data_spc = None
                     # self.data_cspc=None
                     self.data_output = None
                     self.path = None
                     self.OffsetStartHeader = 0
                     self.Off2StartData = 0
                     self.ipp = 0
                     self.nFDTdataRecors = 0
                     self.blocksize = 0
                     self.dataOut = Spectra()
                     self.profileIndex = 1  # Always
                     self.dataOut.flagNoData = False
                     self.dataOut.nRdPairs = 0
                     self.dataOut.pairsList = []
                     self.dataOut.data_spc = None
                     self.dataOut.normFactor = 1
                     self.nextfileflag = True
                     self.dataOut.RadarConst = 0
                     self.dataOut.HSDV = []
                     self.dataOut.NPW = []
                     self.dataOut.COFA = []
                     self.dataOut.noise = 0
                 def Files2Read(self, fp):
                     '''
                     Function that indicates the number of .fdt files that exist in the folder to be read.
                     It also creates an organized list with the names of the files to read.
                     '''
                     # self.__checkPath()
-                    ListaData=os.listdir(fp)    #Gets the list of files within the fp address
+                    # Gets the list of files within the fp address
-                    ListaData=sorted(ListaData) #Sort the list of files from least to largest by names
+                    ListaData = os.listdir(fp)
+                    # Sort the list of files from least to largest by names
+                    ListaData = sorted(ListaData)
                     nFiles = 0  # File Counter
                     FileList = []  # A list is created that will contain the .fdt files
                     for IndexFile in ListaData:
                         if '.zspca' in IndexFile and '.gz' not in IndexFile:
                             FileList.append(IndexFile)
                             nFiles += 1
                     # print 'Files2Read'
                     # print 'Existen '+str(nFiles)+' archivos .fdt'
                     self.filenameList = FileList  # List of files from least to largest by names
                 def run(self, **kwargs):
                     '''
                     This method will be the one that will initiate the data entry, will be called constantly.
                     You should first verify that your Setup () is set up and then continue to acquire
                     the data to be processed with getData ().
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                           startTime=None,
                           endTime=None,
                           walk=True,
                           timezone='utc',
                           code=None,
                           online=False,
                           ReadMode=None, **kwargs):
                     self.isConfig = True
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                     # self.ReadMode=int(ReadMode)
                     pass
                 def getData(self):
                     '''
                     Before starting this function, you should check that there is still an unread file,
                     If there are still blocks to read or if the data block is empty.
                     You should call the file "read".
                     '''
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'NoData se vuelve true'
                         return 0
                     self.fp = self.path
                     self.Files2Read(self.fp)
                     self.readFile(self.fp)
                     self.dataOut.data_spc = self.dataOut_spc  # self.data_spc.copy()
                     self.dataOut.RadarConst = self.RadarConst
                     self.dataOut.data_output = self.data_output
                     self.dataOut.noise = self.dataOut.getNoise()
                     # print 'ACAAAAAA', self.dataOut.noise
                     self.dataOut.data_spc = self.dataOut.data_spc + self.dataOut.noise
                     # print 'self.dataOut.noise',self.dataOut.noise
                     return self.dataOut.data_spc
                 def readFile(self, fp):
                     '''
                     You must indicate if you are reading in Online or Offline mode and load the
                     The parameters for this file reading mode.
                     Then you must do 2 actions:
 . Get the BLTR FileHeader.
 . Start reading the first block.
                     '''
                     # The address of the folder is generated the name of the .fdt file that will be read
                     print "File:    ", self.fileSelector + 1
                     if self.fileSelector < len(self.filenameList):
-                        self.fpFile=str(fp)+'/'+str(self.filenameList[self.fileSelector])
+                        self.fpFile = str(fp) + '/' + \
+                            str(self.filenameList[self.fileSelector])
                         if self.nextfileflag == True:
                             self.fp = open(self.fpFile, "rb")
                             self.nextfileflag == False
                         '''HERE STARTING THE FILE READING'''
                         self.fheader = FileHeaderMIRA35c()
                         self.fheader.FHread(self.fp)  # Bltr FileHeader Reading
                         self.SPARrawGate1 = self.fheader.SPARrawGate1
                         self.SPARrawGate2 = self.fheader.SPARrawGate2
                         self.Num_Hei = self.SPARrawGate2 - self.SPARrawGate1
                         self.Num_Bins = self.fheader.PPARsft
                         self.dataOut.nFFTPoints = self.fheader.PPARsft
                         self.Num_inCoh = self.fheader.PPARavc
                         self.dataOut.PRF = self.fheader.PPARprf
                         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
                         self.__deltaHeigth = 0.5 * SPEED_OF_LIGHT * pulse_width
-                        self.data_spc = numpy.zeros((self.Num_Hei, self.Num_Bins,2))#
+                        self.data_spc = numpy.zeros((self.Num_Hei, self.Num_Bins, 2))
                         self.dataOut.HSDV = numpy.zeros((self.Num_Hei, 2))
                         self.Ze = numpy.zeros(self.Num_Hei)
                         self.ETA = numpy.zeros(([2, self.Num_Hei]))
                         self.readBlock()  # Block reading
                     else:
                         print 'readFile FlagNoData becomes true'
                         self.flagNoMoreFiles = True
                         self.dataOut.flagNoData = True
                         self.FileHeaderFlag == True
                         return 0
                 def readBlock(self):
                     '''
                     It should be checked if the block has data, if it is not passed to the next file.
                     Then the following is done:
 . Read the RecordHeader
 . Fill the buffer with the current block number.
                     '''
                     if self.PointerReader > 1180:
                         self.fp.seek(self.PointerReader, os.SEEK_SET)
                         self.FirstPoint = self.PointerReader
                     else:
                         self.FirstPoint = 1180
                     self.srviHeader = SRVIHeader()
                     self.srviHeader.SRVIread(self.fp)  # Se obtiene la cabecera del SRVI
                     self.blocksize = self.srviHeader.SizeOfDataBlock1  # Se obtiene el tamao del bloque
                     if self.blocksize == 148:
                         print 'blocksize == 148 bug'
                         jump = numpy.fromfile(self.fp, [('jump', numpy.str_, 140)], 1)
-                        self.srviHeader.SRVIread(self.fp) #Se obtiene la cabecera del SRVI
+                        # Se obtiene la cabecera del SRVI
+                        self.srviHeader.SRVIread(self.fp)
                     if not self.srviHeader.SizeOfSRVI1:
                         self.fileSelector += 1
                         self.nextfileflag == True
                         self.FileHeaderFlag == True
                     self.recordheader = RecordHeader()
                     self.recordheader.RHread(self.fp)
                     self.RadarConst = self.recordheader.RadarConst
                     dwell = self.recordheader.time_t
                     npw1 = self.recordheader.npw1
                     npw2 = self.recordheader.npw2
                     self.dataOut.channelList = range(1)
                     self.dataOut.nIncohInt = self.Num_inCoh
                     self.dataOut.nProfiles = self.Num_Bins
                     self.dataOut.nCohInt = 1
                     self.dataOut.windowOfFilter = 1
                     self.dataOut.utctime = dwell
                     self.dataOut.timeZone = 0
                     self.dataOut.outputInterval = self.dataOut.getTimeInterval()
-                    self.dataOut.heightList = self.SPARrawGate1*self.__deltaHeigth + numpy.array(range(self.Num_Hei))*self.__deltaHeigth
+                    self.dataOut.heightList = self.SPARrawGate1 * self.__deltaHeigth + \
+                        numpy.array(range(self.Num_Hei)) * self.__deltaHeigth
                     self.HSDVsign = numpy.fromfile(self.fp, [('HSDV', numpy.str_, 4)], 1)
                     self.SizeHSDV = numpy.fromfile(self.fp, [('SizeHSDV', '<i4')], 1)
-                    self.HSDV_Co = numpy.fromfile( self.fp, [('HSDV_Co','<f4')],self.Num_Hei)
+                    self.HSDV_Co = numpy.fromfile(
-                    self.HSDV_Cx = numpy.fromfile( self.fp, [('HSDV_Cx','<f4')],self.Num_Hei)
+                        self.fp, [('HSDV_Co', '<f4')], self.Num_Hei)
+                    self.HSDV_Cx = numpy.fromfile(
+                        self.fp, [('HSDV_Cx', '<f4')], self.Num_Hei)
                     self.COFAsign = numpy.fromfile(self.fp, [('COFA', numpy.str_, 4)], 1)
                     self.SizeCOFA = numpy.fromfile(self.fp, [('SizeCOFA', '<i4')], 1)
-                    self.COFA_Co = numpy.fromfile( self.fp, [('COFA_Co','<f4')],self.Num_Hei)
+                    self.COFA_Co = numpy.fromfile(
-                    self.COFA_Cx = numpy.fromfile( self.fp, [('COFA_Cx','<f4')],self.Num_Hei)
+                        self.fp, [('COFA_Co', '<f4')], self.Num_Hei)
+                    self.COFA_Cx = numpy.fromfile(
+                        self.fp, [('COFA_Cx', '<f4')], self.Num_Hei)
-                    self.ZSPCsign = numpy.fromfile(self.fp, [('ZSPCsign',numpy.str_,4)],1)
+                    self.ZSPCsign = numpy.fromfile(
+                        self.fp, [('ZSPCsign', numpy.str_, 4)], 1)
                     self.SizeZSPC = numpy.fromfile(self.fp, [('SizeZSPC', '<i4')], 1)
                     self.dataOut.HSDV[0] = self.HSDV_Co[:][0]
                     self.dataOut.HSDV[1] = self.HSDV_Cx[:][0]
                     for irg in range(self.Num_Hei):
-                        nspc = numpy.fromfile(self.fp, [('nspc','int16')],1)[0][0] #    Number of spectral sub pieces containing significant power
+                        # Number of spectral sub pieces containing significant power
+                        nspc = numpy.fromfile(self.fp, [('nspc', 'int16')], 1)[0][0]
                         for k in range(nspc):
-                            binIndex = numpy.fromfile(self.fp, [('binIndex','int16')],1)[0][0] #    Index of the spectral bin where the piece is beginning
+                            # Index of the spectral bin where the piece is beginning
-                            nbins = numpy.fromfile(self.fp, [('nbins','int16')],1)[0][0] #    Number of bins of the piece
+                            binIndex = numpy.fromfile(
+                                self.fp, [('binIndex', 'int16')], 1)[0][0]
+                            nbins = numpy.fromfile(self.fp, [('nbins', 'int16')], 1)[
+][0]  # Number of bins of the piece
                             # Co_Channel
-                            jbin = numpy.fromfile(self.fp, [('jbin','uint16')],nbins)[0][0] #  Spectrum piece to be normaliced
+                            jbin = numpy.fromfile(self.fp, [('jbin', 'uint16')], nbins)[
-                            jmax = numpy.fromfile(self.fp, [('jmax','float32')],1)[0][0] #     Maximun piece to be normaliced
+][0]  # Spectrum piece to be normaliced
+                            jmax = numpy.fromfile(self.fp, [('jmax', 'float32')], 1)[
+][0]  # Maximun piece to be normaliced
-                            self.data_spc[irg,binIndex:binIndex+nbins,0] = self.data_spc[irg,binIndex:binIndex+nbins,0]+jbin/65530.*jmax
+                            self.data_spc[irg, binIndex:binIndex + nbins, 0] = self.data_spc[irg,
+                                                                                             binIndex:binIndex + nbins, 0] + jbin / 65530. * jmax
                             # Cx_Channel
-                            jbin = numpy.fromfile(self.fp, [('jbin','uint16')],nbins)[0][0]
+                            jbin = numpy.fromfile(
+                                self.fp, [('jbin', 'uint16')], nbins)[0][0]
                             jmax = numpy.fromfile(self.fp, [('jmax', 'float32')], 1)[0][0]
+                            self.data_spc[irg, binIndex:binIndex + nbins, 1] = self.data_spc[irg,
-                            self.data_spc[irg,binIndex:binIndex+nbins,1] = self.data_spc[irg,binIndex:binIndex+nbins,1]+jbin/65530.*jmax
+                                                                                             binIndex:binIndex + nbins, 1] + jbin / 65530. * jmax
                     for bin in range(self.Num_Bins):
-                        self.data_spc[:,bin,0] = self.data_spc[:,bin,0] - self.dataOut.HSDV[:,0]
+                        self.data_spc[:, bin, 0] = self.data_spc[:,
+                                                                 bin, 0] - self.dataOut.HSDV[:, 0]
-                        self.data_spc[:,bin,1] = self.data_spc[:,bin,1] - self.dataOut.HSDV[:,1]
+                        self.data_spc[:, bin, 1] = self.data_spc[:,
+                                                                 bin, 1] - self.dataOut.HSDV[:, 1]
                     numpy.set_printoptions(threshold='nan')
                     self.data_spc = numpy.where(self.data_spc > 0., self.data_spc, 0)
                     self.dataOut.COFA = numpy.array([self.COFA_Co, self.COFA_Cx])
                     print ' '
                     print 'SPC', numpy.shape(self.dataOut.data_spc)
                     # print 'SPC',self.dataOut.data_spc
                     noinor1 = 713031680
                     noinor2 = 30
                     npw1 = 1  # 0**(npw1/10) * noinor1 * noinor2
                     npw2 = 1  # 0**(npw2/10) * noinor1 * noinor2
                     self.dataOut.NPW = numpy.array([npw1, npw2])
                     print ' '
                     self.data_spc = numpy.transpose(self.data_spc, (2, 1, 0))
                     self.data_spc = numpy.fft.fftshift(self.data_spc, axes=1)
                     self.data_spc = numpy.fliplr(self.data_spc)
                     self.data_spc = numpy.where(self.data_spc > 0., self.data_spc, 0)
                     self.dataOut_spc = numpy.ones([1, self.Num_Bins, self.Num_Hei])
                     self.dataOut_spc[0, :, :] = self.data_spc[0, :, :]
                     # print 'SHAPE', self.dataOut_spc.shape
                     # For nyquist correction:
                     # fix = 20 # ~3m/s
                     #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 , :]])
                     '''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

schainpy/model/io/jroIO_spectra.py +4 -23

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import numpy
             from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Spectra
             class SpectraReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.data_spc
                         print readerObj.data_cspc
                         print readerObj.data_dc
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 ext = ".pdata"
                 optchar = "P"
                 dataOut = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
                 def __init__(self, **kwargs):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         dataOut    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
                         self.dataOut
                     Return      : None
                     """
                     #Eliminar de la base la herencia
                     ProcessingUnit.__init__(self, **kwargs)
             #         self.isConfig = False
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.datablock = None
                     self.utc = None
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.delay  = 60   #seconds
                     self.nTries = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.__isFirstTimeOnline = 1
             #         self.ippSeconds = 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                     self.dataOut = self.createObjByDefault()
                     self.profileIndex = 1 #Always
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
                         self.dataOut.nChannels
                         self.dataOut.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
                     for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
                             self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
                             self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     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
                     if self.processingHeaderObj.flag_cspc:
                         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
                     if self.processingHeaderObj.flag_dc:
                         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
                     if not(self.processingHeaderObj.shif_fft):
                         #desplaza a la derecha en el eje 2 determinadas posiciones
                         shift = int(self.processingHeaderObj.profilesPerBlock/2)
                         spc = numpy.roll( spc, shift , axis=2 )
                         if self.processingHeaderObj.flag_cspc:
                             #desplaza a la derecha en el eje 2 determinadas posiciones
                             cspc = numpy.roll( cspc, shift, axis=2 )
                     #Dimensions : nChannels, nProfiles, nSamples
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         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
                     else:
                         self.data_dc = None
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getFirstHeader(self):
                     self.getBasicHeader()
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
             #         self.dataOut.ippSeconds = self.ippSeconds
             #         self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.processingHeaderObj.profilesPerBlock
                     self.dataOut.dtype = self.dtype
             #         self.dataOut.nPairs = self.nPairs
                     self.dataOut.pairsList = self.rdPairList
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.flagShiftFFT = True    #Data is always shifted
                     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
                 def getData(self):
                     """
                     First method to execute before "RUN" is called.
                     Copia el buffer de lectura a la clase "Spectra",
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
                         self.dataOut
                         self.flagDiscontinuousBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             self.dataOut.flagNoData = True
                             return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_spc is None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.getBasicHeader()
                     self.getFirstHeader()
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_dc = self.data_dc
                     self.dataOut.flagNoData = False
                     self.dataOut.realtime = self.online
                     return self.dataOut.data_spc
             class SpectraWriter(JRODataWriter, Operation):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".pdata"
                 optchar = "P"
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
             #    dataOut = None
-                def __init__(self):
+                def __init__(self, **kwargs):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
-                    Operation.__init__(self)
+                    Operation.__init__(self, **kwargs)
                     self.isConfig = False
                     self.nTotalBlocks = 0
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shape_spc_Buffer = (self.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     self.shape_dc_Buffer = (self.dataOut.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.processingHeaderObj.shif_fft ):
                         spc = numpy.roll( spc, 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:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.processingHeaderObj.shif_fft ):
                             cspc = numpy.roll( cspc, 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))
                         data.tofile(self.fp)
                     if self.data_dc is not None:
                         data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
                         dc = self.data_dc
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
             #         self.data_spc.fill(0)
             #
             #         if self.data_dc is not None:
             #             self.data_dc.fill(0)
             #
             #         if self.data_cspc is not None:
             #             self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                     self.blockIndex += 1
             #         print "[Writing] Block = %d04" %self.blockIndex
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagDiscontinuousBlock:
                         self.data_spc.fill(0)
+                        if self.dataOut.data_cspc is not None:
                             self.data_cspc.fill(0)
+                        if self.dataOut.data_dc is not None:
                             self.data_dc.fill(0)
                         self.setNextFile()
                     if self.flagIsNewFile == 0:
                         self.setBasicHeader()
                     self.data_spc = self.dataOut.data_spc.copy()
                     if self.dataOut.data_cspc is not None:
                         self.data_cspc = self.dataOut.data_cspc.copy()
                     if self.dataOut.data_dc is not None:
                         self.data_dc = self.dataOut.data_dc.copy()
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.setFirstHeader()
                         self.writeNextBlock()
                     return 1
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     '''
                     dtype_width = self.getDtypeWidth()
                     pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
                     pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     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)
                     if self.dataOut.data_dc is not None:
                         pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
                         blocksize += (pts2write_DCchannels*dtype_width*2)
             #         blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     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.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         if self.dataOut.nPairs > 0:
                             for pair in self.dataOut.pairsList:
                                 pairsList.append(pair[0])
                                 pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb, dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                     if self.dataOut.code is not None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
                     self.setBasicHeader()

schainpy/model/io/jroIO_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/jroproc_amisr.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_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/scripts/schain.xml 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/utils/log.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

schaincli/asdasd.py removed 0 -34

NO CONTENT: file was removed

schainpy/model/graphics/mpldriver2.py removed 0 -469

NO CONTENT: file was removed

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