schain-jc Commit - r1090:36f30f86830d

fixing merge conflicts

jespinoza -

r1090:36f30f86830d

parent child

Context file:

r1090:36f30f86830d

Expand all files

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 +15 0

@@ -0,0 +1,15
	1	Lectura
	2	200samples -> 0.47m HDD 1000''
	3	200samples -> 6 HDD 100ms file 100s folder
	4	200samples -> 0.48ms HDD 100ms file 1000s folder
	5	200samples -> 116ms HDD 5000ms file 100s folder
	6	200samples -> 182 HDD 10000ms file 100s folder
	7	200samples -> 143 HDD 10000ms file 100s folder SSD
	8
	9	Escritura
	10	200samples -> 0.78m HDD 100ms file 1000s folder
	11	200samples -> 0.066m HDD 100ms file 1000s folder
	12	200samples -> 0.30 HDD 100ms file 100s folder
	13	200samples -> 0.23 HDD 5000ms file 100s folder
	14	200samples -> 0.176 HDD 10000ms file 100s folder
	15

schainpy/scripts/testDigitalRF.py created 644 +117 0

@@ -0,0 +1,117
	1	#!/usr/bin/env python
	2	'''
	3	Created on Jul 7, 2014
	4
	5	@author: roj-idl71
	6	'''
	7	import os, sys
	8
	9	from schainpy.controller import Project
	10
	11	def main():
	12
	13	desc = "Testing USRP data reader"
	14	filename = "schain.xml"
	15	figpath = "./"
	16	remotefolder = "/home/wmaster/graficos"
	17
	18	#this controller object save all user configuration and then execute each module
	19	#with their parameters.
	20	controllerObj = Project()
	21
	22	controllerObj.setup(id = '191', name='test01', description=desc)
	23
	24	#Creating a reader object with its parameters
	25	#schainpy.model.io.jroIO_usrp.USRPReader.setup()
	26	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRF',
	27	path='/home/nanosat/data/',
	28	startDate='2000/07/03',
	29	endDate='2017/07/03',
	30	startTime='00:00:00',
	31	endTime='23:59:59',
	32	online=0)
	33
	34	# procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage',
	35	# inputId=readUnitConfObj.getId())
	36
	37	# opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
	38	# opObj10.addParameter(name='minHei', value='0', format='float')
	39	# opObj10.addParameter(name='maxHei', value='8', format='float')
	40
	41	# opObj10 = procUnitConfObj0.addOperation(name='setH0')
	42	# opObj10.addParameter(name='h0', value='5.4', format='float')
	43
	44	# opObj10 = procUnitConfObj0.addOperation(name='Decoder', optype='external')
	45	# opObj10.addParameter(name='code', value='1,-1', format='intlist')
	46	# opObj10.addParameter(name='nCode', value='2', format='float')
	47	# opObj10.addParameter(name='nBaud', value='1', format='float')
	48
	49	# opObj10 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
	50	# opObj10.addParameter(name='n', value='128', format='float')
	51
	52	# opObj11 = procUnitConfObj0.addOperation(name='Scope', optype='external')
	53	# opObj11.addParameter(name='id', value='121', format='int')
	54	# opObj11.addParameter(name='wintitle', value='Scope', format='str')
	55
	56	# procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra',
	57	# inputId=procUnitConfObj0.getId())
	58
	59	# #Creating a processing object with its parameters
	60	# #schainpy.model.proc.jroproc_spectra.SpectraProc.run()
	61	# #If you need to add more parameters can use the "addParameter method"
	62	# procUnitConfObj1.addParameter(name='nFFTPoints', value='8', format='int')
	63	# procUnitConfObj1.addParameter(name='pairsList', value='(0,1)', format='pairslist')
	64
	65	# opObj10 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
	66	# opObj10.addParameter(name='n', value='2', format='float')
	67	#
	68	#Using internal methods
	69	#schainpy.model.proc.jroproc_spectra.SpectraProc.selectChannels()
	70	# opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
	71	# opObj10.addParameter(name='channelList', value='0,1', format='intlist')
	72
	73	#Using internal methods
	74	#schainpy.model.proc.jroproc_spectra.SpectraProc.selectHeights()
	75	# opObj10 = procUnitConfObj1.addOperation(name='selectHeights')
	76	# opObj10.addParameter(name='minHei', value='90', format='float')
	77	# opObj10.addParameter(name='maxHei', value='180', format='float')
	78
	79	#Using external methods (new modules)
	80	# #schainpy.model.proc.jroproc_spectra.IncohInt.setup()
	81	# opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='other')
	82	# opObj12.addParameter(name='n', value='1', format='int')
	83
	84	#Using external methods (new modules)
	85	#schainpy.model.graphics.jroplot_spectra.SpectraPlot.setup()
	86	# opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
	87	# opObj11.addParameter(name='id', value='11', format='int')
	88	# opObj11.addParameter(name='wintitle', value='SpectraPlot', format='str')
	89	# opObj11.addParameter(name='zmin', value='0', format='int')
	90	# opObj11.addParameter(name='zmax', value='90', format='int')
	91	# opObj11.addParameter(name='save', value='1', format='int')
	92	# opObj11.addParameter(name='xmin', value='-20', format='float')
	93	# opObj11.addParameter(name='xmax', value='20', format='float')
	94
	95	#Using external methods (new modules)
	96	#schainpy.model.graphics.jroplot_spectra.RTIPlot.setup()
	97	# opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
	98	# opObj11.addParameter(name='id', value='30', format='int')
	99	# opObj11.addParameter(name='wintitle', value='RTI', format='str')
	100	# # opObj11.addParameter(name='zmin', value='0', format='int')
	101	# # opObj11.addParameter(name='zmax', value='90', format='int')
	102	# opObj11.addParameter(name='showprofile', value='1', format='int')
	103	# opObj11.addParameter(name='timerange', value=str(26060), format='int')
	104	# opObj11.addParameter(name='xmin', value='19.5', format='float')
	105	# opObj11.addParameter(name='xmax', value='20', format='float')
	106
	107	# opObj11 = procUnitConfObj1.addOperation(name='CrossSpectraPlot', optype='other')
	108	# opObj11.addParameter(name='id', value='3', format='int')
	109	# opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
	110	# opObj11.addParameter(name='zmin', value='30', format='int')
	111	# opObj11.addParameter(name='zmax', value='120', format='int')
	112	# opObj11.addParameter(name='pairsList', value='(0,1)', format='pairslist')
	113
	114	controllerObj.start()
	115
	116	if __name__ == '__main__':
	117	main()

schainpy/scripts/testDigitalRFWriter.py created 644 +98 0

@@ -0,0 +1,98
	1	import os, sys
	2
	3	from schainpy.controller import Project
	4
	5	if __name__ == '__main__':
	6
	7	desc = "Segundo Test"
	8	filename = "schain.xml"
	9
	10	controllerObj = Project()
	11
	12	controllerObj.setup(id = '191', name='test01', description=desc)
	13
	14	readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
	15	path='/home/nanosat/data/John',
	16	startDate='2010/10/28',
	17	endDate='2017/10/28',
	18	startTime='00:00:00',
	19	endTime='23:59:59',
	20	online=0,
	21	walk=0)
	22
	23	opObj00 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	24
	25	procUnitConfObj0 = controllerObj.addProcUnit(datatype='VoltageProc',
	26	inputId=readUnitConfObj.getId())
	27
	28	# opObj11 = procUnitConfObj0.addOperation(name='Scope', optype='external')
	29	# opObj11.addParameter(name='id', value='121', format='int')
	30	# opObj11.addParameter(name='wintitle', value='Scope', format='str')
	31
	32	opObj10 = procUnitConfObj0.addOperation(name='DigitalRFWriter', optype='other')
	33	opObj10.addParameter(name='path', value='/home/nanosat/data/digitalrf', format='str')
	34	# opObj10.addParameter(name='minHei', value='0', format='float')
	35	# opObj10.addParameter(name='maxHei', value='8', format='float')
	36
	37	# opObj10 = procUnitConfObj0.addOperation(name='filterByHeights')
	38	# opObj10.addParameter(name='window', value='2', format='float')
	39
	40	# opObj10 = procUnitConfObj0.addOperation(name='Decoder', optype='external')
	41	# opObj10.addParameter(name='code', value='1,-1', format='intlist')
	42	# opObj10.addParameter(name='nCode', value='2', format='float')
	43	# opObj10.addParameter(name='nBaud', value='1', format='float')
	44
	45
	46	# opObj10 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
	47	# opObj10.addParameter(name='n', value='1296', format='float')
	48
	49	# procUnitConfObj1 = controllerObj.addProcUnit(datatype='SpectraProc',
	50	# inputId=procUnitConfObj0.getId())
	51
	52	#Creating a processing object with its parameters
	53	#schainpy.model.proc.jroproc_spectra.SpectraProc.run()
	54	#If you need to add more parameters can use the "addParameter method"
	55	# procUnitConfObj1.addParameter(name='nFFTPoints', value='128', format='int')
	56
	57	# opObj10 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
	58	# opObj10.addParameter(name='n', value='2', format='float')
	59
	60	#Using internal methods
	61	#schainpy.model.proc.jroproc_spectra.SpectraProc.selectChannels()
	62	# opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
	63	# opObj10.addParameter(name='channelList', value='0,1', format='intlist')
	64
	65	#Using internal methods
	66	#schainpy.model.proc.jroproc_spectra.SpectraProc.selectHeights()
	67	# opObj10 = procUnitConfObj1.addOperation(name='selectHeights')
	68	# opObj10.addParameter(name='minHei', value='90', format='float')
	69	# opObj10.addParameter(name='maxHei', value='180', format='float')
	70
	71	#Using external methods (new modules)
	72	# #schainpy.model.proc.jroproc_spectra.IncohInt.setup()
	73	# opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='other')
	74	# opObj12.addParameter(name='n', value='1', format='int')
	75
	76	#Using external methods (new modules)
	77	#schainpy.model.graphics.jroplot_spectra.SpectraPlot.setup()
	78	# opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
	79	# opObj11.addParameter(name='id', value='11', format='int')
	80	# opObj11.addParameter(name='wintitle', value='SpectraPlot', format='str')
	81	# opObj11.addParameter(name='zmin', value='-60', format='int')
	82	# opObj11.addParameter(name='zmax', value='10', format='int')
	83	# opObj11.addParameter(name='save', value='1', format='int')
	84
	85	# #Using external methods (new modules)
	86	# #schainpy.model.graphics.jroplot_spectra.RTIPlot.setup()
	87	# opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
	88	# opObj11.addParameter(name='id', value='30', format='int')
	89	# opObj11.addParameter(name='wintitle', value='RTI', format='str')
	90	# opObj11.addParameter(name='zmin', value='-60', format='int')
	91	# opObj11.addParameter(name='zmax', value='-10', format='int')
	92	# opObj11.addParameter(name='showprofile', value='1', format='int')
	93	# # opObj11.addParameter(name='timerange', value=str(56060*60), format='int')
	94	# opObj11.addParameter(name='xmin', value='14', format='float')
	95	# opObj11.addParameter(name='xmax', value='23.9', format='float')
	96	# opObj11.addParameter(name='save', value='1', format='int')
	97
	98	controllerObj.start()

schainpy/utils/trash created 644 +1 0

	@@ -0,0 +1,1
				1	You should install "digital_rf_hdf5" module if you want to read USRP data

.gitignore +4 -4

             # 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

@@ -1,4 +1,4
1	# schaing	1	# schain
2		2
3	Command Line Interface for SIGNAL CHAIN - jro	3	Command Line Interface for SIGNAL CHAIN - jro
4		4

schaincli/cli.py +26 -15

             @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':
                 else:
                     log.error('Command {} is not defined'.format(command))
             def check_module(possible, instance):
                 def check(x):
                     try:
                     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()
             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
                 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)

schaincli/templates.py +52 -37

@@ -1,11 +1,10
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}",
@@ -16,60 +15,76 readUnitConf = controller.addReadUnit(datatype='VoltageReader',
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.
             ### 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.

schainpy/controller.py +41 -26

                 'Spectra': '.pdata'
             }
             def MPProject(project, n=cpu_count()):
                 '''
                 Project wrapper to run schain in n processes
                     time.sleep(3)
             class ParameterConf():
                 id = None
                     print 'Parameter[%s]: name = %s, value = %s, format = %s' % (self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.parmConfObjList) + 1
                     return value
                 def getKwargs(self):
                     kwargs = {}
                 def createObject(self, plotter_queue=None):
                     if self.type == 'self':
                         raise ValueError, 'This operation type cannot be created'
                 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)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def getKwargs(self):
                     opObj = self.opConfObjList[0]
                         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)
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = 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 'Reader' in datatype:
                             name = datatype
                             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:
                     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.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
                             self.startTime = opConfObj.getParameterValue('startTime')
                             self.endTime = opConfObj.getParameterValue('endTime')
             class Project(Process):
                 id = None
                         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
                     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
                     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()
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
-                    procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
+                    procUnitElementList = self.projectElement.iter(
+                        ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                     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())

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

                         indexDatatype = 2
                     if 'usrp' in self.datatype.lower():
                         indexDatatype = 3
                     return indexDatatype
                 def getExt(self):
                         ext = '.fits'
                     if self.datatype.lower() == 'usrp':
                         ext = '.hdf5'
                     return ext
                 def set(self, project_name, datatype, ext, dpath, online,

schainpy/model/__init__.py +1 -1

             # 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

                     return fmax
                 def getFmax(self):
                     PRF = 1./(self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):

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

             import numpy
             import copy
             import datetime
+            import inspect
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
                     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"
                 dstFlag = None
                 errorCount = None
                 datatime = None
+                structure = BASIC_STRUCTURE
                 __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
                 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
                 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,
             #         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.line5Function = line5Function
                     self.fClock = fClock
                     self.prePulseBefore = prePulseBefore
-                    self.prePulserAfter = prePulseAfter
+                    self.prePulseAfter = prePulseAfter
                     self.nHeights = nHeights
                     self.firstHeight = firstHeight
                     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]
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
-                                   self.prePulserAfter,
+                                   self.prePulseAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                 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.flag_decode = False
                     self.flag_deflip = False
                     self.length = 0
                 def read(self, fp):
                     self.length = 0
                     try:

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

                 HEIGHTPROF = None
                 PREFIX = 'corr'
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1

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

             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')]
                     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)
                                 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)
                     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")
                     if self.data:
                         self.__plot()
             class PlotSpectraData(PlotData):
                 '''
                 Plot for Spectra data
                                                    )
                             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':
                                                    )
                         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:
                     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
                                                    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:
                                                    )
                             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
                     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):
                     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, :]
                                                                                                  dt2,
                                                                                                  len(x))
                     self.ax.set_title(title, size=8)
                     self.saveTime = self.max_time
             class PlotParamData(PlotRTIData):
                 '''
                 Plot for data_param object

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

                 HEIGHTPROF = None
                 PREFIX = 'spc'
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                 PREFIX = 'rtinoise'
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1

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

                     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

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

                 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):
                     """

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

             import matplotlib
             if 'linux' in sys.platform:
-                matplotlib.use("GTK3Agg")
+                matplotlib.use("TkAgg")
             if 'darwin' in sys.platform:
                 matplotlib.use('TKAgg')
             # 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()
                 return fig
             def closeFigure(show=False, fig=None):
                 #     matplotlib.pyplot.ioff()
                 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()
                                                       rowspan=rowspan,
                                                       polar=polar)
-                axes.grid(True)
                 matplotlib.pyplot.ion()
                 return axes
             def setAxesText(ax, text):
                 ax.annotate(text,
                             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:
                     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)
                 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)
                 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)
                 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'):
                 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:
                 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():
             def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
-                ax = iplot.get_axes()
+                ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                     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:
                 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])
                 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))
                 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%",
             #     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]
                 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':
                 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 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 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
                                       ('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
                                       ('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.SPARprc = None
             header = numpy.fromfile(fp, FILE_HEADER, 1)
             '''      numpy.fromfile(file, dtype, count, sep='')
                 file : file or str
             SPARprc = header['SPARprc'][0]
             SRVI_STRUCTURE = numpy.dtype([
-                                        ('frame_cnt','<u4'),#
+                                        ('frame_cnt', '<u4'),
                                         ('time_t', '<u4'),   #
                                         ('tpow', '<f4'),     #
                                         ('npw1', '<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,
             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.
             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]     #
             print '=============================================='
             print '=============================================='
-  No newline at end of file

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

             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 *

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

                 ('sea_algorithm', '<u4')
             ])
             class BLTRParamReader(JRODataReader, ProcessingUnit):
                 '''
                 Boundary Layer and Tropospheric Radar (BLTR) reader, Wind velocities and SNR from *.sswma files
                     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()
                          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')
                     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
                     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

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

             import numpy
             import fnmatch
             import inspect
-            import time, datetime
+            import time
+            import datetime
             import traceback
             import zmq
             LOCALTIME = True
             def isNumber(cad):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 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.
                 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.
                 """
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                 # If endTime < startTime then endTime belongs to the next day
                 #<<<<<<<<<<<o                            o>>>>>>>>>>>
                 #-----------o----------------------------o-----------
                 #        endTime                    startTime
                 return thisDatetime
             def isFolderInDateRange(folder, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 return 1
             def isFileInDateRange(filename, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 return 1
             def getFileFromSet(path, ext, set):
                 validFilelist = []
                 fileList = os.listdir(path)
                     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]
                 return None
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 return None
             def checkForRealPath(path, foldercounter, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un 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
                 return fullfilename, filename
             def isRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                 return 1
             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                 return 1
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def getDateFromRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             class JRODataIO:
                 c = 3E8
                 def getAllowedArgs(self):
                     return inspect.getargspec(self.run).args
             class JRODataReader(JRODataIO):
                 online = 0
                 selBlocktime = None
                 def __init__(self):
                     """
                     This class is used to find data files
                     """
                     pass
                 def createObjByDefault(self):
                     """
                     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 skip == 0:
                                 skippedFileList = []
                             else:
-                                skippedFileList = fileList[cursor*skip: cursor*skip + skip]
+                                skippedFileList = fileList[cursor *
+                                                           skip: cursor * skip + skip]
                         else:
                             skippedFileList = fileList
                             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
                     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.
                         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:
                         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:
                                     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
                             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
                         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
                         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):
                     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
                             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())
                     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:
                     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()
                             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
                         self.nTxs = nTxs
                         self.startTime = startTime
                         self.endTime = endTime
+                        self.endDate = endDate
+                        self.startDate = startDate
                         # Added-----------------
                         self.selBlocksize = blocksize
                         self.selBlocktime = blocktime
                 #         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.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError
                     else:
                         self.getFromServer()
             class JRODataWriter(JRODataIO):
                 """
                 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
             #        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)
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                             # 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 = 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)
                     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 re
             import h5py
             import numpy
-            import matplotlib.pyplot as plt
             import pylab as plb
             from scipy.optimize import curve_fit
                 def __init__(self):
                     raise NotImplementedError
                 def read(self):
                     raise NotImplementedError
                     # 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 = ""
                     print 'puntero file header', startFp.tell()
                     print ' '
                     '''      numpy.fromfile(file, dtype, count, sep='')
                         file : file or str
                         Open file object or filename.
                 '''
                     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.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)
                     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'),
             ])
                     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 'puntero Record Header', startFp.tell()
                     print ' '
                     startFp.seek(OffRHeader, os.SEEK_SET)
                     print ' '
                     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
                 walk = None
                 isConfig = False
                 fileList = None
                 # metadata
                 data = None
                 utctime = None
                 def __init__(self, **kwargs):
                     # Eliminar de la base la herencia
                     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.
                     '''
                     # 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:
                     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.
                     self.getData()
                     # print 'running'
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                     pass
                 def getData(self):
                     '''
                     Before starting this function, you should check that there is still an unread file,
                     # 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
                     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
                 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):
                         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.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)
                         # 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):
                             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)
                             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)
                                 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
                                 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
             #
             #                 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 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 import imag, shape, NaN, empty
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def read(self):
                     raise NotImplementedError
             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
                                       ('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
                                       ('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 = str(header['Hname'][0])
                     self.Htime = str(header['Htime'][0])
                     self.Hoper = str(header['Hoper'][0])
                                    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)
                     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):
             SRVI_STRUCTURE = numpy.dtype([
-                                        ('frame_cnt','<u4'),#
+                                        ('frame_cnt', '<u4'),
                                         ('time_t', '<u4'),   #
                                         ('tpow', '<f4'),     #
                                         ('npw1', '<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
                     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]     #
                     print '=============================================='
                     return 1
             class MIRA35CReader (ProcessingUnit, FileHeaderMIRA35c, SRVIHeader, RecordHeader):
                 path = None
                 walk = None
                 isConfig = False
                 fileList = None
                 # metadata
                 data = None
                 utctime = None
                 def __init__(self, **kwargs):
                     # Eliminar de la base la herencia
                     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.
                     '''
                     # 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:
                     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.
                     self.getData()
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                     pass
                 def getData(self):
                     '''
                     Before starting this function, you should check that there is still an unread file,
                     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
                     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")
                         '''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
                         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:
                         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.
                     else:
                         self.FirstPoint = 1180
                     self.srviHeader = SRVIHeader()
                     self.srviHeader.SRVIread(self.fp)  # Se obtiene la cabecera del SRVI
                         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
                     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.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')
                     #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

             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)
                                     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
                     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,
                                           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)
                     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]))
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     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.dataOut.flagNoData = True
                             return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_spc is 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
                     Return: None
                     """
-                    Operation.__init__(self)
+                    Operation.__init__(self, **kwargs)
                     self.isConfig = False
                     self.data_cspc = None
                     self.data_dc = None
                     self.fp = None
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         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
             #         if self.data_cspc is not None:
             #             self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                     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()
                     return 1
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     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):

schainpy/model/io/jroIO_voltage.py +62 -43

             from StringIO import StringIO
             # from _sha import blocksize
             class VoltageReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                     return 0
                 def getBlockDimension(self):
                     """
                         Obtiene la cantidad de puntos a leer por cada bloque de datos
                         Return:
                             None
                     """
-                    pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
+                    pts2read = self.processingHeaderObj.profilesPerBlock * \
+                        self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                         readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                     try:
-                        junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                        junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                             self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
-                            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                            junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                                 self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #             return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     if self.nTxs > 1:
                         self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     # Time interval and code are propierties of dataOut. Its value depends of radarControllerHeaderObj.
                     #         self.dataOut.timeInterval = self.radarControllerHeaderObj.ippSeconds * self.processingHeaderObj.nCohInt
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
-                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) *self.processingHeaderObj.deltaHeight +  self.processingHeaderObj.firstHeight
+                    self.dataOut.heightList = numpy.arange(
+                        self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
-                    self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode #asumo q la data no esta decodificada
+                    # asumo q la data no esta decodificada
+                    self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
-                    self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip #asumo q la data no esta sin flip
+                    # asumo q la data no esta sin flip
+                    self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
                         return
                     if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1. / self.nTxs) != 0:
-                        raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" %(1./self.nTxs, self.processingHeaderObj.profilesPerBlock)
+                        raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % (
+. / self.nTxs, self.processingHeaderObj.profilesPerBlock)
                     if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
-                        raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" %(self.nTxs, self.processingHeaderObj.nHeights)
+                        raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" % (
+                            self.nTxs, self.processingHeaderObj.nHeights)
-                    self.datablock = self.datablock.reshape((self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock*self.nTxs, self.processingHeaderObj.nHeights/self.nTxs))
+                    self.datablock = self.datablock.reshape(
+                        (self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, self.processingHeaderObj.nHeights / self.nTxs))
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock * self.nTxs
-                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights/self.nTxs) *self.processingHeaderObj.deltaHeight +  self.processingHeaderObj.firstHeight
+                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights / self.nTxs) * \
+                        self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     return
                     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:
                     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 getFromServer(self):
                     self.flagDiscontinuousBlock = 0
                     self.profileIndex = 0
                     timestamp = self.basicHeaderObj.get_datatime()
                     print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
                     current_pointer_location = self.blockPointer
-                    junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
+                    junk = numpy.fromstring(
+                        block[self.blockPointer:], self.dtype, self.blocksize)
                     try:
-                        junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                        junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                             self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     except:
                         # print "The read block (%3d) has not enough data" %self.nReadBlocks
                         if self.waitDataBlock(pointer_location=current_pointer_location):
-                            junk = numpy.fromstring( block[self.blockPointer:], self.dtype, self.blocksize )
+                            junk = numpy.fromstring(
-                            junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
+                                block[self.blockPointer:], self.dtype, self.blocksize)
+                            junk = junk.reshape((self.processingHeaderObj.profilesPerBlock,
+                                                 self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels))
                     #               return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
-                    if self.selBlocksize == None: self.selBlocksize = self.dataOut.nProfiles
+                    if self.selBlocksize == None:
+                        self.selBlocksize = self.dataOut.nProfiles
                     if self.selBlocktime != None:
                         if self.dataOut.nCohInt is not None:
                             nCohInt = self.dataOut.nCohInt
                         else:
                             nCohInt = 1
-                        self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
+                        self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
-                    self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
+                            nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
+                    self.dataOut.data = self.datablock[:,
+                                                       self.profileIndex:self.profileIndex + self.selBlocksize, :]
                     datasize = self.dataOut.data.shape[1]
                     if datasize < self.selBlocksize:
-                        buffer = numpy.zeros((self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype = 'complex')
+                        buffer = numpy.zeros(
+                            (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                         buffer[:, :datasize, :] = self.dataOut.data
                         self.dataOut.data = buffer
                         self.profileIndex = blockIndex
                         """
                             Return a block
                         """
-                        if self.selBlocksize == None:   self.selBlocksize = self.dataOut.nProfiles
+                        if self.selBlocksize == None:
+                            self.selBlocksize = self.dataOut.nProfiles
                         if self.selBlocktime != None:
                             if self.dataOut.nCohInt is not None:
                                 nCohInt = self.dataOut.nCohInt
                             else:
                                 nCohInt = 1
-                            self.selBlocksize = int(self.dataOut.nProfiles*round(self.selBlocktime/(nCohInt*self.dataOut.ippSeconds*self.dataOut.nProfiles)))
+                            self.selBlocksize = int(self.dataOut.nProfiles * round(self.selBlocktime / (
+                                nCohInt * self.dataOut.ippSeconds * self.dataOut.nProfiles)))
-                        self.dataOut.data = self.datablock[:,self.profileIndex:self.profileIndex+self.selBlocksize,:]
+                        self.dataOut.data = self.datablock[:,
+                                                           self.profileIndex:self.profileIndex + self.selBlocksize, :]
                         self.profileIndex += self.selBlocksize
                         datasize = self.dataOut.data.shape[1]
                         if datasize < self.selBlocksize:
-                            buffer = numpy.zeros((self.dataOut.data.shape[0],self.selBlocksize,self.dataOut.data.shape[2]), dtype = 'complex')
+                            buffer = numpy.zeros(
+                                (self.dataOut.data.shape[0], self.selBlocksize, self.dataOut.data.shape[2]), dtype='complex')
                             buffer[:, :datasize, :] = self.dataOut.data
                             while datasize < self.selBlocksize:  # Not enough profiles to fill the block
                                 blockIndex = self.selBlocksize - datasize
                                 datablock1 = self.datablock[:, :blockIndex, :]
-                                buffer[:,datasize:datasize+datablock1.shape[1],:] = datablock1
+                                buffer[:, datasize:datasize +
+                                       datablock1.shape[1], :] = datablock1
                                 datasize += datablock1.shape[1]
                             self.dataOut.data = buffer
                     self.getBasicHeader()
-                    #print self.basicHeaderObj.printInfo()
-                    #print self.systemHeaderObj.printInfo()
-                    #print self.radarControllerHeaderObj.printInfo()
-                    #print self.processingHeaderObj.printInfo()
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
                 shapeBuffer = None
                 def __init__(self, **kwargs):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     dtype_width = self.getDtypeWidth()
-                    blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.profilesPerBlock * dtype_width * 2)
+                    blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels *
+                                    self.profilesPerBlock * dtype_width * 2)
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
+                    # podria ser 1 o self.dataOut.processingHeaderObj.nWindows
+                    self.processingHeaderObj.nWindows = 1
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
-                    self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
+                    # Cuando la data de origen es de tipo Voltage
-                    self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
+                    self.processingHeaderObj.nIncohInt = 1
+                    # Cuando la data de origen es de tipo Voltage
+                    self.processingHeaderObj.totalSpectra = 0
                     if self.dataOut.code is not None:
                         self.processingHeaderObj.code = self.dataOut.code
                     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.deltaHeight = self.dataOut.heightList[1] - \
+                            self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights

schainpy/model/proc/jroproc_amisr.py +8 -6

             from schainpy.model.data.jroamisr import AMISR
             class AMISRProc(ProcessingUnit):
-                def __init__(self):
+                def __init__(self, **kwargs):
-                    ProcessingUnit.__init__(self)
+                    ProcessingUnit.__init__(self, **kwargs)
                     self.objectDict = {}
                     self.dataOut = AMISR()
             class PrintInfo(Operation):
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Operation.__init__(self, **kwargs)
                     self.__isPrinted = False
                 def run(self, dataOut):
                 profileIndex = None
                 nProfiles = None
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                     self.__isConfig = False
             class ProfileToChannels(Operation):
-                def __init__(self):
+                def __init__(self, **kwargs):
+                    Operation.__init__(self, **kwargs)
                     self.__isConfig = False
                     self.__counter_chan = 0
                     self.buffer = None

schainpy/model/proc/jroproc_parameters.py +4 -5

             import time
             #from sklearn.cluster import KMeans
-            import matplotlib.pyplot as plt
             from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
             from jroproc_base import ProcessingUnit, Operation
                 n = None
-                def __init__(self):
+                def __init__(self, **kwargs):
-                    Operation.__init__(self)
+                    Operation.__init__(self, **kwargs)
                 def __calculateCosDir(self, elev, azim):
                     zen = (90 - elev)*numpy.pi/180
             class EWDriftsEstimation(Operation):
-                def __init__(self):
+                def __init__(self, **kwargs):
-                    Operation.__init__(self)
+                    Operation.__init__(self, **kwargs)
                 def __correctValues(self, heiRang, phi, velRadial, SNR):
                     listPhi = phi.tolist()

schainpy/model/proc/jroproc_spectra.py 0 -3

                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndex]
                     self.dataOut.pairsList = pairs
-                    self.dataOut.pairsIndexList = pairsIndex
                     return
                     return self.__initime, avgdata_spc, avgdata_cspc, avgdata_dc
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if n==1:
                         return
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False

schainpy/scripts/schain.xml 0 0

NO CONTENT: modified file

schainpy/utils/log.py +3 -2

             import click
             def warning(message, tag='Warning'):
                 click.echo(click.style('[{}] {}'.format(tag, message), fg='yellow'))
                 pass
             def makelogger(tag, bg='reset', fg='reset'):
                 def func(message):
-                    click.echo(click.style('[{}] {}'.format(tag.upper(), message),
+                    click.echo(click.style('[{}] {}'.format(
-                               bg=bg, fg=fg))
+                        tag.upper(), message), bg=bg, fg=fg))
                 return func

setup.py +1 -1

             from setuptools.command.build_ext import build_ext as _build_ext
             from schainpy import __version__
             class build_ext(_build_ext):
                 def finalize_options(self):
                     _build_ext.finalize_options(self)
                       "zmq",
                       "fuzzywuzzy",
                       "click",
-                                      "colorama",
                       "python-Levenshtein"
                   ],
                   )

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