schain Commit - r1290:a2308e7c2e9e · Jicamarca Repository

simulador y pruebas de librerias

avaldez -

r1290:a2308e7c2e9e

parent child

Context file:

r1290:a2308e7c2e9e

schainpy/model/io/jroIO_simulator.py created 644 +485 0

@@ -0,0 +1,485
	1	import numpy,math,random,time
	2	import zmq
	3	import tempfile
	4	from io import StringIO
	5	########## 1 Heredamos JRODatareader
	6	from schainpy.model.io.jroIO_base import *
	7	########## 2 Heredamos las propiedades de ProcessingUnit
	8	from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
	9	########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
	10	from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
	11	########## 4 Importaremos el objeto Voltge
	12	from schainpy.model.data.jrodata import Voltage
	13
	14	@MPDecorator
	15	class SimulatorReader(JRODataReader, ProcessingUnit):
	16	incIntFactor = 1
	17	nFFTPoints = 0
	18	FixPP_IncInt = 1
	19	FixRCP_IPP = 1000
	20	FixPP_CohInt = 1
	21	Tau_0 = 250
	22	AcqH0_0 = 70
	23	H0 = AcqH0_0
	24	AcqDH_0 = 1.25
	25	DH0 = AcqDH_0
	26	Bauds = 32
	27	BaudWidth = None
	28	FixRCP_TXA = 40
	29	FixRCP_TXB = 70
	30	fAngle = 2.0math.pi(1/16)
	31	DC_level = 500
	32	stdev = 8
	33	Num_Codes = 2
	34	#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
	35	#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
	36	#Dyn_snCode = numpy.array([Num_Codes,Bauds])
	37	Dyn_snCode = None
	38	Samples = 200
	39	channels = 5
	40	pulses = None
	41	Reference = None
	42	pulse_size = None
	43	prof_gen = None
	44	Fdoppler = 100
	45	Hdoppler = 36
	46	def __init__(self):
	47	"""
	48	Inicializador de la clases SimulatorReader para
	49	generar datos de voltage simulados.
	50	Input:
	51	dataOut: Objeto de la clase Voltage.
	52	Este Objeto sera utilizado apra almacenar
	53	un perfil de datos cada vez qe se haga psiversho
	54	un requerimiento (getData)
	55	"""
	56	ProcessingUnit.__init__(self)
	57	print(" [ START ] init - Metodo Simulator Reader")
	58
	59	self.isConfig = False
	60	self.basicHeaderObj = BasicHeader(LOCALTIME)
	61	self.systemHeaderObj = SystemHeader()
	62	self.radarControllerHeaderObj = RadarControllerHeader()
	63	self.processingHeaderObj = ProcessingHeader()
	64	self.profileIndex = 2**32-1
	65	self.dataOut = Voltage()
	66	#code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
	67	code0 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])
	68	#code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
	69	code1 = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])
	70	#self.Dyn_snCode = numpy.array([code0,code1])
	71	self.Dyn_snCode = None
	72	print(" [ END ] init - Metodo simulator Reader" )
	73
	74
	75	def __hasNotDataInBuffer(self):
	76
	77	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
	78	if self.nReadBlocks>0:
	79	tmp = self.dataOut.utctime
	80	tmp_utc = int(self.dataOut.utctime)
	81	tmp_milisecond = int((tmp-tmp_utc)*1000)
	82	self.basicHeaderObj.utc = tmp_utc
	83	self.basicHeaderObj.miliSecond= tmp_milisecond
	84	return 1
	85	return 0
	86
	87
	88	def setNextFile(self):
	89	"""Set the next file to be readed open it and parse de file header"""
	90
	91	if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
	92	print('------------------- [Opening file] ------------------------------')
	93	self.nReadBlocks = 0
	94
	95	def __setNewBlock(self):
	96
	97	self.setNextFile()
	98	if self.flagIsNewFile:
	99	return 1
	100
	101	def readNextBlock(self):
	102	while True:
	103	self.__setNewBlock()
	104	if not(self.readBlock()):
	105	return 0
	106	self.getBasicHeader()
	107	break
	108	if self.verbose:
	109	print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
	110	self.processingHeaderObj.dataBlocksPerFile,
	111	self.dataOut.datatime.ctime()) )
	112	return 1
	113
	114	def getFirstHeader(self):
	115	self.getBasicHeader()
	116	self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
	117	self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
	118	self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
	119	#ADD NEW
	120	self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
	121	self.dataOut.heightList = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
	122	self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
	123	self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
	124	# asumo q la data no esta decodificada
	125	self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
	126	# asumo q la data no esta sin flip
	127	self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
	128	self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
	129
	130	def getBasicHeader(self):
	131
	132	self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
	133	1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
	134
	135	self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
	136
	137	self.dataOut.timeZone = self.basicHeaderObj.timeZone
	138
	139	self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
	140
	141	self.dataOut.errorCount = self.basicHeaderObj.errorCount
	142
	143	self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
	144
	145	self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
	146
	147	def reshapeData(self):
	148	if self.nTxs==1:
	149	return
	150
	151	def readBlock(self):
	152
	153	self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,
	154	stdev=self.stdev,Reference= self.Reference,
	155	pulses = self.pulses,Num_Codes=self.Num_Codes,
	156	pulse_size=self.pulse_size,prof_gen=self.profiles,
	157	H0=self.H0,DH0=self.DH0)
	158
	159	self.profileIndex = 0
	160	self.flagIsNewFile = 0
	161	self.flagIsNewBlock = 1
	162	self.nTotalBlocks += 1
	163	self.nReadBlocks += 1
	164
	165	return 1
	166
	167
	168	def getData(self): ### metodo propio de VoltageReader
	169
	170	if self.flagNoMoreFiles:
	171	self.dataOut.flagNodata = True
	172	self.flagDiscontinuousBlock = 0
	173	self.flagIsNewBlock = 0
	174	if self.__hasNotDataInBuffer(): # aqui es verdad
	175	if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header
	176	return 0
	177	self.getFirstHeader() # atributo
	178	self.reshapeData() # nTxx1 =1 return , n
	179
	180	if not self.getByBlock:
	181	self.dataOut.flagDataAsBlock = False
	182	self.dataOut.data = self.datablock[:, self.profileIndex, :]
	183	self.dataOut.profileIndex = self.profileIndex
	184	self.profileIndex += 1
	185	else:
	186	pass
	187	self.dataOut.flagNoData = False
	188	self.getBasicHeader()
	189	self.dataOut.realtime = self.online
	190	return self.dataOut.data
	191
	192	def set_kwargs(self, **kwargs):
	193	for key, value in kwargs.items():
	194	setattr(self, key, value)
	195
	196	def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
	197	nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
	198	numTaus=0, line6Function=0, line5Function=0, fClock=None,
	199	prePulseBefore=0, prePulseAfter=0,
	200	codeType=0, nCode=0, nBaud=0, code=None,
	201	flip1=0, flip2=0):
	202
	203	self.radarControllerHeaderObj.expType = expType
	204	self.radarControllerHeaderObj.nTx = nTx
	205	self.radarControllerHeaderObj.ipp = float(ipp)
	206	self.radarControllerHeaderObj.txA = float(txA)
	207	self.radarControllerHeaderObj.txB = float(txB)
	208	self.radarControllerHeaderObj.rangeIPP = ipp
	209	self.radarControllerHeaderObj.rangeTxA = txA
	210	self.radarControllerHeaderObj.rangeTxB = txB
	211
	212	self.radarControllerHeaderObj.nHeights = int(nHeights)
	213	self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight])
	214	self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight])
	215	self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights])
	216
	217
	218	self.radarControllerHeaderObj.nWindows = nWindows
	219	self.radarControllerHeaderObj.numTaus = numTaus
	220	self.radarControllerHeaderObj.codeType = codeType
	221	self.radarControllerHeaderObj.line6Function = line6Function
	222	self.radarControllerHeaderObj.line5Function = line5Function
	223	self.radarControllerHeaderObj.fclock = fClock
	224	self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
	225	self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
	226
	227	self.radarControllerHeaderObj.nCode = nCode
	228	self.radarControllerHeaderObj.nBaud = nBaud
	229	self.radarControllerHeaderObj.code = code
	230	self.radarControllerHeaderObj.flip1 = flip1
	231	self.radarControllerHeaderObj.flip2 = flip2
	232
	233	self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4
	234
	235	if fClock is None and deltaHeight is not None:
	236	self.fClock = 0.15 / (deltaHeight * 1e-6)
	237
	238	def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
	239	dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
	240	nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0,
	241	deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
	242	code=0, nBaud=None, shif_fft=False, flag_dc=False,
	243	flag_cspc=False, flag_decode=False, flag_deflip=False):
	244
	245	self.processingHeaderObj.profilesPerBlock = profilesPerBlock
	246	self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
	247	self.processingHeaderObj.nWindows = nWindows
	248	self.processingHeaderObj.nCohInt = nCohInt
	249	self.processingHeaderObj.nIncohInt = nIncohInt
	250	self.processingHeaderObj.totalSpectra = totalSpectra
	251	self.processingHeaderObj.nHeights = int(nHeights)
	252	self.processingHeaderObj.firstHeight = firstHeight
	253	self.processingHeaderObj.deltaHeight = deltaHeight
	254	self.processingHeaderObj.samplesWin = nHeights
	255
	256	def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
	257	self.basicHeaderObj.utc = utc
	258	self.basicHeaderObj.miliSecond = miliSecond
	259	self.basicHeaderObj.timeZone = timeZone
	260
	261	def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
	262	self.systemHeaderObj.nSamples = nSamples
	263	self.systemHeaderObj.nProfiles = nProfiles
	264	self.systemHeaderObj.nChannels = nChannels
	265	self.systemHeaderObj.adcResolution = adcResolution
	266	self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth
	267
	268	def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,
	269	FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
	270	FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0math.pi(1/16),DC_level= 500,
	271	stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,channels=1,Fdoppler=20,Hdoppler=36,
	272	**kwargs):
	273
	274	self.set_kwargs(**kwargs)
	275	self.nReadBlocks = 0
	276	tmp = time.time()
	277	tmp_utc = int(tmp)
	278	tmp_milisecond = int((tmp-tmp_utc)*1000)
	279	print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))
	280	if Dyn_snCode is None:
	281	Num_Codes=1
	282	Bauds =1
	283
	284
	285
	286	self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
	287
	288	self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
	289	nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
	290	numTaus=1, line6Function=0, line5Function=0, fClock=None,
	291	prePulseBefore=0, prePulseAfter=0,
	292	codeType=14, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
	293	flip1=0, flip2=0)
	294
	295	self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
	296	dataBlocksPerFile=120, nWindows=1, processFlags=0, nCohInt=1,
	297	nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
	298	deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
	299	code=0, nBaud=None, shif_fft=False, flag_dc=False,
	300	flag_cspc=False, flag_decode=False, flag_deflip=False)
	301
	302	self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
	303
	304	self.incIntFactor = incIntFactor
	305	self.nFFTPoints = nFFTPoints
	306	self.FixPP_IncInt = FixPP_IncInt
	307	self.FixRCP_IPP = FixRCP_IPP
	308	self.FixPP_CohInt = FixPP_CohInt
	309	self.Tau_0 = Tau_0
	310	self.AcqH0_0 = AcqH0_0
	311	self.H0 = AcqH0_0
	312	self.AcqDH_0 = AcqDH_0
	313	self.DH0 = AcqDH_0
	314	self.Bauds = Bauds
	315	self.FixRCP_TXA = FixRCP_TXA
	316	self.FixRCP_TXB = FixRCP_TXB
	317	self.fAngle = fAngle
	318	self.DC_level = DC_level
	319	self.stdev = stdev
	320	self.Num_Codes = Num_Codes
	321	self.Dyn_snCode = Dyn_snCode
	322	self.samples = samples
	323	self.channels = channels
	324	self.profiles = None
	325	self.m_nReference = None
	326	self.Baudwidth = None
	327	self.Fdoppler = Fdoppler
	328	self.Hdoppler = Hdoppler
	329
	330	print("IPP ", self.FixRCP_IPP)
	331	print("Tau_0 ",self.Tau_0)
	332	print("AcqH0_0",self.AcqH0_0)
	333	print("samples,window ",self.samples)
	334	print("AcqDH_0",AcqDH_0)
	335	print("FixRCP_TXA",self.FixRCP_TXA)
	336	print("FixRCP_TXB",self.FixRCP_TXB)
	337	print("Dyn_snCode",Dyn_snCode)
	338	print("Fdoppler", Fdoppler)
	339	print("Hdoppler",Hdoppler)
	340
	341	self.init_acquisition()
	342	self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)
	343	print(" [ END ] - SETUP metodo")
	344	return
	345
	346	def run(self,**kwargs): # metodo propio
	347	if not(self.isConfig):
	348	self.setup(**kwargs)
	349	self.isConfig = True
	350	self.getData()
	351
	352	##################################################################
	353	###### Aqui ingresamos las clases y metodos propios del simulador
	354	##################################################################
	355
	356	#############################################
	357	############## INIT_ACQUISITION##############
	358	#############################################
	359	def init_acquisition(self):
	360
	361	if self.nFFTPoints != 0:
	362	self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints
	363	if (self.FixPP_IncInt > self.incIntFactor):
	364	self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor
	365	elif(self.FixPP_IncInt< self.incIntFactor):
	366	print("False alert...")
	367
	368	ProfilesperBlock = self.processingHeaderObj.profilesPerBlock
	369
	370	self.timeperblock =int(((self.FixRCP_IPP
	371	*ProfilesperBlock
	372	*self.FixPP_CohInt
	373	*self.incIntFactor)
	374	/150.0)
	375	*0.9
	376	+0.5)
	377	# para cada canal
	378	self.profiles = ProfilesperBlock*self.FixPP_CohInt
	379	self.profiles = ProfilesperBlock
	380	self.Reference = int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)
	381	self.BaudWidth = int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )
	382
	383	if (self.BaudWidth==0):
	384	self.BaudWidth=1
	385	#################################################################
	386	####################### init_pulse ##############################
	387	################################################################
	388
	389	def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):
	390
	391	Num_Codes = Num_Codes
	392	Bauds = Bauds
	393	BaudWidth = BaudWidth
	394	Dyn_snCode = Dyn_snCode
	395
	396	if Dyn_snCode:
	397	print("EXISTE")
	398	else:
	399	print("No existe")
	400
	401	if Dyn_snCode: # if Bauds:
	402	pulses = list(range(0,Num_Codes))
	403	num_codes = Num_Codes
	404	for i in range(num_codes):
	405	pulse_size = Bauds*BaudWidth
	406	pulses[i] = numpy.zeros(pulse_size)
	407	for j in range(Bauds):
	408	for k in range(BaudWidth):
	409	pulses[i][jBaudWidth+k] = int(Dyn_snCode[i][j]600)
	410	else:
	411	print("sin code")
	412	pulses = list(range(1))
	413	pulse_size = int(self.FixRCP_TXB/0.15+0.5)
	414	pulses[0] = numpy.ones(pulse_size)
	415	pulses = 600*pulses[0]
	416
	417	return pulses,pulse_size
	418
	419	#################################################################
	420	##################### Generate block data
	421	################################################################
	422
	423	def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,
	424	Reference= Reference,pulses= pulses,
	425	Num_Codes= Num_Codes,pulse_size=pulse_size,
	426	prof_gen= prof_gen,H0 = H0,DH0=DH0,Fdoppler= Fdoppler,Hdoppler=Hdoppler):
	427	Samples = Samples
	428	DC_level = DC_level
	429	stdev = stdev
	430	m_nR = Reference
	431	pulses = pulses
	432	num_codes = Num_Codes
	433	ps = pulse_size
	434	prof_gen = prof_gen
	435	channels = self.channels
	436	H0 = H0
	437	DH0 = DH0
	438	ippSec = self.radarControllerHeaderObj.ippSeconds
	439	Fdoppler = self.Fdoppler
	440	Hdoppler = self.Hdoppler
	441
	442	self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)
	443	for i in range(channels):
	444	for k in range(prof_gen):
	445	#·······················NOISE···············
	446	Noise_r = numpy.random.normal(DC_level,stdev,Samples)
	447	Noise_i = numpy.random.normal(DC_level,stdev,Samples)
	448	Noise = numpy.zeros(Samples,dtype=complex)
	449	Noise.real = Noise_r
	450	Noise.imag = Noise_i
	451	#·······················PULSOS··············
	452	Pulso = numpy.zeros(pulse_size,dtype=complex)
	453	Pulso.real = pulses[k%num_codes]
	454	Pulso.imag = pulses[k%num_codes]
	455	#····················· PULSES+NOISE··········
	456	InBuffer = numpy.zeros(Samples,dtype=complex)
	457	InBuffer[m_nR:m_nR+ps] = Pulso
	458	InBuffer = Noise+ InBuffer
	459	#····················· ANGLE ·······························
	460
	461
	462
	463
	464	InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps](math.sin( self.fAngle)5)
	465	InBuffer=InBuffer
	466	self.datablock[i][k]= InBuffer
	467	#plot_cts(InBuffer,H0=H0,DH0=DH0
	468
	469
	470	#wave_fft(x=InBuffer,plot_show=True)
	471	#time.sleep(1)
	472	#················DOPPLER SIGNAL...............................................
	473	time_vec = numpy.linspace(0,(prof_gen-1)ippSec,int(prof_gen))+self.nReadBlocksippSec*prof_gen
	474	fd = Fdoppler #+(600.0/120)*self.nReadBlocks
	475	d_signal = 650numpy.array(numpy.exp(1.0j2.0math.pifd*time_vec),dtype=numpy.complex64)
	476	#·················· DATABLOCK + DOPPLER············...........................
	477	HD=int(Hdoppler/self.AcqDH_0)
	478	self.datablock[0,:,HD]=self.datablock[0,:,HD]+ d_signal # RESULT
	479	'''
	480	a= numpy.zeros(10)
	481	for i in range(10):
	482	a[i]=i+self.nReadBlocks+20
	483	for i in a:
	484	self.datablock[0,:,int(i)]=self.datablock[0,:,int(i)]+ d_signal # RESULT
	485	'''

schainpy/model/io/jroIO_simulator.py~ created 644 +336 0

@@ -0,0 +1,336
	1	import numpy,math
	2	import zmq
	3	import tempfile
	4	from io import StringIO
	5	########## 1 Heredamos JRODatareader
	6	from schainpy.model.io.jroIO_base import *
	7	########## 2 Heredamos las propiedades de ProcessingUnit
	8	from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
	9	########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
	10	from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
	11	########## 4 Importaremos el objeto Voltge
	12	from schainpy.model.data.jrodata import Voltage
	13
	14	@MPDecorator
	15	class SimulatorReader(JRODataReader, ProcessingUnit):
	16	incIntFactor = 1
	17	nFFTPoints = 0
	18	FixPP_IncInt = 1
	19	FixRCP_IPP = 1000
	20	FixPP_CohInt = 1
	21	Tau_0 = 250
	22	AcqH0_0 = 70
	23	H0 = AcqH0_0
	24	AcqDH_0 = 1.25
	25	DH0 = AcqDH_0
	26	Bauds = 32
	27	FixRCP_TXA = 40
	28
	29	fAngle = 2.0math.pi(1/16)
	30	DC_level = 500
	31	stdev = 8
	32	Num_codes = 2
	33	code0 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
	34	code1 = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
	35	Dyn_sncode = numpy.array([Num_codes,Bauds])
	36	samples = 200
	37	channels = 1
	38
	39
	40	def __init__(self):
	41	"""
	42	Inicializador de la clases SimulatorReader para
	43	generar datos de voltage simulados.
	44	Input:
	45	dataOut: Objeto de la clase Voltage.
	46	Este Objeto sera utilizado apra almacenar
	47	un perfil de datos cada vez qe se haga psiversho
	48	un requerimiento (getData)
	49	"""
	50	ProcessingUnit.__init__(self)
	51	print(" [ START ] init - Metodo Simulator Reader")
	52	self.isConfig = False
	53	self.basicHeaderObj = BasicHeader(LOCALTIME)
	54	self.systemHeaderObj = SystemHeader()
	55	self.radarControlHeaderObj = RadarControllerHeader()
	56	self.processingHeaderObj = ProcessingHeader()
	57	self.profileIndex = 2**32-1
	58	self.dataOut = Voltage()
	59	#self.server = "simulate"
	60	print(" [ END ] init - Metodo simulator Reader" )
	61
	62
	63	def __hasNotDataInBuffer(self):
	64	if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
	65	return 1
	66	return 0
	67
	68	def __setNewBlock(self):
	69	if self.flagIsNewFile:
	70	#self.lastUTTime = self.basicHeaderObj.utc
	71	return 1
	72
	73	def readNextBlock(self):
	74	while True:
	75	self.__setNewBlock()
	76	print (" [ START ] readNexBlock")
	77	if not(self.readBlock()):
	78	return 0
	79	self.getBasicHeader()
	80	break
	81	if self.verbose:
	82	print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlock,
	83	self.processingHeaderObj.dataBlocksPerfile,
	84	self.dataOut.datatime.ctime()) )
	85	return 1
	86
	87	def getFirstHeader(self):
	88	self.getBasicHeader()
	89	self.dataOut.processingHeaderObj= self.processingHeaderObj.copy()
	90
	91	self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
	92
	93	self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
	94
	95	def getBasicHeader(self):
	96	self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
	97	1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
	98
	99	self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
	100
	101	self.dataOut.timeZone = self.basicHeaderObj.timeZone
	102
	103	self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
	104
	105	self.dataOut.errorCount = self.basicHeaderObj.errorCount
	106
	107	self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
	108
	109	self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
	110
	111	def reshapeData(self):
	112	if self.nTxs==1:
	113	return
	114
	115	def readBlock(self):
	116	self.init_acquisition()
	117	pulses, num_codes, pulse_size = self.init_pulse()
	118	self.jro_GenerateBlockOfData()
	119	self.profileIndex = 0
	120
	121	self.flagIsNewFile = 0
	122	self.flagIsNewBlock = 1
	123
	124	self.nTotalBlocks += 1
	125	self.nReadBlocks += 1
	126
	127	return 1
	128
	129
	130	def getData(self): ### metodo propio de VoltageReader
	131
	132	if self.flagNoMoreFiles:
	133	self.dataOut.flagNodata= True
	134	self.flagDiscontinuousBlock=0
	135	self.flagIsNewBlock = 0
	136	if self.__hasNotDataInBuffer(): # aqui es verdad
	137	if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header
	138	return 0
	139	self.getFirstHeader() # atributo
	140	self.reshapeData() # nTxx1 =1 return , n
	141
	142	if not self.getByBlock:
	143	self.dataOut.flagDataAsBlock = False
	144	self.dataOut.data = self.datablock[:, self.profileIndex, :]
	145	self.dataOut.profileIndex = self.profileIndex
	146
	147	self.profileIndex += 1
	148	else:
	149	pass
	150	self.getBasicHeader()
	151	self.dataOut.realtime = self.searchFilesOnline
	152
	153	return self.dataOut.data
	154
	155
	156	def set_kwargs(self, **kwargs):
	157
	158	for key, value in kwargs.items():
	159	print(" set_kwargs ",key,value)
	160	setattr(self, key, value)
	161
	162
	163	def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=100,
	164	FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
	165	FixRCP_TXA = 40, fAngle = 2.0math.pi(1/16),DC_level= 500, stdev= 8,
	166	Num_codes = None , Dyn_snCode = None, samples=200,channels=1,
	167	**kwargs):
	168	print(" [ START ] - SETUP metodo")
	169	self.set_kwargs(**kwargs)
	170	self.processingHeaderObj.profilesPerBlock = 100
	171	self.incIntFactor = incIntFactor
	172	self.nFFTPoints = nFFTPoints
	173	self.FixPP_IncInt = FixPP_IncInt
	174	self.FixRCP_IPP = FixRCP_IPP
	175	self.FixPP_CohInt = FixPP_CohInt
	176	self.Tau_0 = Tau_0
	177	self.AcqH0_0 = AcqH0_0
	178	self.H0 = AcqH0_0
	179	self.AcqDH_0 = AcqDH_0
	180	self.DH0 = AcqDH_0
	181	self.Bauds = Bauds
	182	self.FixRCP_TXA = FixRCP_TXA
	183
	184	self.fAngle = fAngle
	185	self.DC_level = DC_level
	186	self.stdev = stdev
	187	self.Num_codes = Num_codes
	188	#self.code0 = code0
	189	#self.code1 = code1
	190	self.Dyn_snCode = Dyn_snCode
	191	self.samples = samples
	192	self.channels = channels
	193
	194	print(" [ END ] - SETUP metodo")
	195	return
	196
	197	def run(self,**kwargs): # metodo propio
	198
	199	print(" [ START ] Metodo RUN: ", self.server)
	200	if not(self.isConfig):
	201	self.setup(**kwargs)
	202	self.isConfig = True
	203	import time
	204	time.sleep(3)
	205	#if self.server is None:
	206	self.getData()
	207	#else:
	208	# self.getFromServer()
	209	##################################################################
	210	###### Aqui ingresamos las clases y metodos propios del simulador
	211	##################################################################
	212
	213	#############################################
	214	############## INIT_ACQUISITION##############
	215	#############################################
	216	def init_acquisition(self):
	217
	218	if self.nFFTPoints != 0:
	219	self.incIntfactor = m_nProfilesperBlock/self.nFFTPoints
	220	if (self.FixPP_IncInt > self.incIntfactor):
	221	self.incIntfactor = self.FixPP_IncInt/ self.incIntfactor
	222	elif(self.FixPP_IncInt< self.incIntfactor):
	223	print("False alert...")
	224
	225	ProfilesperBLock = self.processingHeaderObj.profilesPerBlock
	226
	227	self.timeperblock =int(((self.FixRCP_m_fIPP
	228	*m_nProfilesperBlock
	229	*self.FixPP_CohInt
	230	*self.incIntfactor)
	231	/150.0)
	232	*0.9
	233	+0.5)
	234	# para cada canal
	235	prof_gen = m_nProfilesperBlock*FixPP_m_n_CoherentIntegrations
	236	prof_gen = m_nProfilesperBlock
	237
	238
	239	m_nReference = int((Dyn_sfTau_0-Dyn_sfAcqH0_0)/(Dyn_sfAcqDH_0)+0.5)
	240	print(m_nReference)
	241	BaudWidth = int((FixRCP_m_fTXA/Dyn_sfAcqDH_0)/m_nBauds + 0.5 )
	242	print(BaudWidth)
	243	if (BaudWidth==0):
	244	BaudWidth=1
	245
	246
	247	#################################################################
	248	##################### init_pulse
	249	################################################################
	250
	251	def init_pulse(m_nNum_Codes,m_nBauds,BaudWidth,Dyn_snCode):
	252	fAngle = 2.0math.pi(1/16)
	253	DC_level = 500
	254	stdev = 8
	255	m_nNum_Codes= m_nNum_Codes
	256	m_nBauds = m_nBauds
	257	BaudWidth = BaudWidth
	258	Dyn_snCode = Dyn_snCode
	259
	260	if m_nBauds:
	261	pulses = list(range(0,m_nNum_Codes))
	262	num_codes = m_nNum_Codes
	263	for i in range(num_codes):
	264	pulse_size = m_nBauds*BaudWidth
	265	pulses[i] = numpy.zeros(pulse_size)
	266	for j in range(m_nBauds):
	267	for k in range(BaudWidth):
	268	pulses[i][jBaudWidth+k] = int(Dyn_snCode[i][j]600)
	269	else:
	270	pulses = list(range(1))
	271	pulse_size = int(FixRCP_m_fTXB/0.15+0.5)
	272	pulses[0] = numpy.ones(pulse_size)
	273	pulses = 600*pulses[0]
	274	return pulses,num_codes,pulse_size
	275
	276	#################################################################
	277	##################### Generate block data
	278	################################################################
	279	# m_nChannels
	280	# prof_gen
	281	# fAngle = 2.0math.pi(1/16)
	282	# DC_level = 500
	283	# stdev
	284	# num_codes
	285	#fAngle = 2.0math.pi(1/16)
	286	#num_codes = 8
	287
	288
	289	def jro_GenerateBlockOfData(m_nSamples,DC_level,stdev,m_nReference,pulses,num_codes,pulse_size,prof_gen,H0,DH0):
	290	m_nSamples = m_nSamples
	291	DC_level = DC_level
	292	stdev = stdev
	293	m_nR = m_nReference
	294	pulses = pulses
	295	num_codes = num_codes
	296	ps = pulse_size
	297	prof_gen = prof_gen
	298	H0 = H0
	299	DH0 = DH0
	300	fAngle = 2.0math.pi(1/16)
	301
	302	# NOISE
	303	Seed_r=random.seed(2)
	304	Noise_r = numpy.random.normal(DC_level,stdev,m_nSamples)
	305	Seed_i=random.seed(3)
	306	Noise_i = numpy.random.normal(DC_level,stdev,m_nSamples)
	307	Noise = numpy.zeros(m_nSamples,dtype=complex)
	308	Noise.real = Noise_r
	309	Noise.imag = Noise_i
	310	Pulso = numpy.zeros(pulse_size,dtype=complex)
	311
	312	#DOPPLER
	313	x = m_nSamples
	314	time_space = (DH0*numpy.linspace(0, x-1,num=x) +H0)
	315	time_vec = time_space*(1.0e-3/150.0)
	316	fd = 10
	317	d_signal = numpy.array(numpy.exp(1.0j2.0math.pifdtime_vec),dtype=numpy.complex64)
	318
	319
	320
	321	for i in range(m_nChannels):
	322	for k in range(prof_gen):
	323	Pulso.real = pulses[k%num_codes]
	324	Pulso.imag = pulses[k%num_codes]
	325	InBuffer = numpy.zeros(m_nSamples,dtype=complex)
	326	InBuffer[m_nR:m_nR+ps] = Pulso
	327	InBuffer = Noise+ InBuffer
	328	InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps](math.cos( fAngle)5)
	329	InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps](math.sin( fAngle)5)
	330	InBuffer=InBuffer
	331	#print(InBuffer[:10])
	332	#print(InBuffer.shape)
	333	plot_cts(InBuffer,H0=H0,DH0=DH0)
	334	#wave_fft(x=InBuffer,plot_show=True)
	335	#time.sleep(1)
	336

schainpy/controller.py +11 -1

             '''
             Updated on January , 2018, for multiprocessing purposes
             Author: Sergio Cortez
             Created on September , 2012
             '''
             from platform import python_version
             import sys
             import ast
             import datetime
             import traceback
             import math
             import time
             import zmq
             from multiprocessing import Process, Queue, Event, Value, cpu_count
             from threading import Thread
             from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
             from xml.dom import minidom
             from schainpy.admin import Alarm, SchainWarning
             from schainpy.model import *
             from schainpy.utils import log
             DTYPES = {
                 'Voltage': '.r',
                 'Spectra': '.pdata'
             }
             def MPProject(project, n=cpu_count()):
                 '''
                 Project wrapper to run schain in n processes
                 '''
                 rconf = project.getReadUnitObj()
                 op = rconf.getOperationObj('run')
                 dt1 = op.getParameterValue('startDate')
                 dt2 = op.getParameterValue('endDate')
                 tm1 = op.getParameterValue('startTime')
                 tm2 = op.getParameterValue('endTime')
                 days = (dt2 - dt1).days
                 for day in range(days + 1):
                     skip = 0
                     cursor = 0
                     processes = []
                     dt = dt1 + datetime.timedelta(day)
                     dt_str = dt.strftime('%Y/%m/%d')
                     reader = JRODataReader()
                     paths, files = reader.searchFilesOffLine(path=rconf.path,
                                                              startDate=dt,
                                                              endDate=dt,
                                                              startTime=tm1,
                                                              endTime=tm2,
                                                              ext=DTYPES[rconf.datatype])
                     nFiles = len(files)
                     if nFiles == 0:
                         continue
                     skip = int(math.ceil(nFiles / n))
                     while nFiles > cursor * skip:
                         rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor,
                                      skip=skip)
                         p = project.clone()
                         p.start()
                         processes.append(p)
                         cursor += 1
                     def beforeExit(exctype, value, trace):
                         for process in processes:
                             process.terminate()
                             process.join()
                         print(traceback.print_tb(trace))
                     sys.excepthook = beforeExit
                     for process in processes:
                         process.join()
                         process.terminate()
                     time.sleep(3)
             def wait(context):
                 time.sleep(1)
                 c = zmq.Context()
                 receiver = c.socket(zmq.SUB)
                 receiver.connect('ipc:///tmp/schain_{}_pub'.format(self.id))
                 receiver.setsockopt(zmq.SUBSCRIBE, self.id.encode())
                 msg = receiver.recv_multipart()[1]
                 context.terminate()
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'obj':
                         return value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
                         raise ValueError('%s: This parameter value is empty' % self.name)
                     if format == 'list':
                         strList = [s.strip() for s in value.split(',')]
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
                         '''
                         Example:
                             value = (0,1,2)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [int(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'floatlist':
                         '''
                         Example:
                             value = (0.5, 1.4, 2.7)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [float(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
                         '''
                         Example:
                             value = (0,1),(1,2)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             raise ValueError('%s has to be a tuple or list of pairs' % value)
                         if type(new_value[0]) not in (tuple, list):
                             if len(new_value) != 2:
                                 raise ValueError('%s has to be a tuple or list of pairs' % value)
                             new_value = [new_value]
                         for thisPair in new_value:
                             if len(thisPair) != 2:
                                 raise ValueError('%s has to be a tuple or list of pairs' % value)
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'multilist':
                         '''
                         Example:
                             value = (0,1,2),(3,4,5)
                         '''
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
                             multiList = ast.literal_eval('(' + value + ')')
                         self.__formated_value = multiList
                         return self.__formated_value
                     if format == 'bool':
                         value = int(value)
                     if format == 'int':
                         value = float(value)
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     if format == 'obj':
                         self.value = value
                     else:
                         self.value = str(value)
                     self.format = str.lower(format)
                     self.getValue()
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     if self.name not in ('queue',):
                         parmElement = SubElement(opElement, self.ELEMENTNAME)
                         parmElement.set('id', str(self.id))
                         parmElement.set('name', self.name)
                         parmElement.set('value', self.value)
                         parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     # Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
                     print('Parameter[%s]: name = %s, value = %s, format = %s, project_id = %s' % (self.id, self.name, self.value, self.format, self.project_id))
             class OperationConf():
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.topic = None
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.parmConfObjList) + 1
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id) * 10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
                 #         if not parameterObj:
                 #             return None
                     value = parameterObj.getValue()
                     return value
                 def getKwargs(self):
                     kwargs = {}
                     for parmConfObj in self.parmConfObjList:
                         if self.name == 'run' and parmConfObj.name == 'datatype':
                             continue
                         kwargs[parmConfObj.name] = parmConfObj.getValue()
                     return kwargs
                 def setup(self, id, name, priority, type, project_id, err_queue, lock):
                     self.id = str(id)
                     self.project_id = project_id
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.err_queue = err_queue
                     self.lock = lock
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     if value is None:
                         return None
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
                 def makeXml(self, procUnitElement):
                     opElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement, project_id):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     self.project_id = str(project_id)
                     # Compatible with old signal chain version
                     # Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.iter(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         # Compatible with old signal chain version
                         # If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
                     print('%s[%s]: name = %s, type = %s, priority = %s, project_id = %s' % (self.ELEMENTNAME,
                                                                            self.id,
                                                                            self.name,
                                                                            self.type,
                                                                            self.priority,
                                                                            self.project_id))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self):
                     className = eval(self.name)
                     if self.type == 'other':
                         opObj = className()
                     elif self.type == 'external':
                         kwargs = self.getKwargs()
                         opObj = className(self.id, self.id, self.project_id, self.err_queue, self.lock, 'Operation', **kwargs)
                         opObj.start()
                         self.opObj = opObj
                     return opObj
             class ProcUnitConf():
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList) + 1
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     '''
                     new_id = int(parentId) * 10 + (int(self.id) % 10)
                     new_inputId = int(parentId) * 10 + (int(self.inputId) % 10)
                     # If this proc unit has not inputs
                     #if self.inputId == '0':
                         #new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id) * 10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     #self.inputId = str(new_inputId)
                     '''
                     n = 1
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, project_id, id, name, datatype, inputId, err_queue, lock):
                     '''
                         id sera el topico a publicar
                         inputId sera el topico a subscribirse
                     '''
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
                         raise ValueError('datatype or name should be defined')
                     #Definir una condicion para inputId cuando sea 0
                     if name == None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' % (datatype)
                     if datatype == None:
                         datatype = name.replace('Proc', '')
                     self.id = str(id)
                     self.project_id = project_id
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.err_queue = err_queue
                     self.lock = lock
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
                     Add parameters to 'run' operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     '''
                         Actualizacion - > proceso comunicacion
                         En el caso de optype='self', elminar. DEfinir comuncacion IPC -> Topic
                         definir el tipoc de socket o comunicacion ipc++
                     '''
                     id = self.__getNewId()
                     priority = self.__getPriority() # Sin mucho sentido, pero puede usarse
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype, project_id=self.project_id, err_queue=self.err_queue, lock=self.lock)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
                 def makeXml(self, projectElement):
                     procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
                     procUnitElement.set('id', str(self.id))
                     procUnitElement.set('name', self.name)
                     procUnitElement.set('datatype', self.datatype)
                     procUnitElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(procUnitElement)
                 def readXml(self, upElement, project_id):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     self.project_id = str(project_id)
                     if self.ELEMENTNAME == 'ReadUnit':
                         self.datatype = self.datatype.replace('Reader', '')
                     if self.ELEMENTNAME == 'ProcUnit':
                         self.datatype = self.datatype.replace('Proc', '')
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement, project_id)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
                     print('%s[%s]: name = %s, datatype = %s, inputId = %s, project_id = %s' % (self.ELEMENTNAME,
                                                                               self.id,
                                                                               self.name,
                                                                               self.datatype,
                                                                               self.inputId,
                                                                               self.project_id))
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def getKwargs(self):
                     opObj = self.opConfObjList[0]
                     kwargs = opObj.getKwargs()
                     return kwargs
                 def createObjects(self):
                     '''
                     Instancia de unidades de procesamiento.
                     '''
+                    #print(" [ CREATE OBJ ] :",self.name)
                     className = eval(self.name)
                     kwargs = self.getKwargs()
+                    #print (" [ kwargs ] : ", kwargs)
                     procUnitObj = className(self.id, self.inputId, self.project_id, self.err_queue, self.lock, 'ProcUnit', **kwargs)
                     log.success('creating process...', self.name)
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self' and opConfObj.name == 'run':
                             continue
                         elif opConfObj.type == 'self':
                             opObj = getattr(procUnitObj, opConfObj.name)
                         else:
                             opObj = opConfObj.createObject()
                         log.success('adding operation: {}, type:{}'.format(
                             opConfObj.name,
                             opConfObj.type), self.name)
                         procUnitObj.addOperation(opConfObj, opObj)
                     procUnitObj.start()
                     self.procUnitObj = procUnitObj
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.lock = Event()
                     self.lock.set()
                     self.lock.n = Value('d', 0)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',
                           startTime='', endTime='', server=None, **kwargs):
                     '''
                     *****el id del proceso sera el Topico
                     Adicion de {topic}, si no esta presente -> error
                     kwargs deben ser trasmitidos en la instanciacion
                     '''
                     # Compatible with old signal chain version
+                    #print (" [INSIDE] : setup ReadUnit", kwargs)
                     if datatype == None and name == None:
                         raise ValueError('datatype or name should be defined')
                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
                             datatype = name.replace('Reader','')
                         else:
                             name = '{}Reader'.format(datatype)
                     if datatype == None:
                         if 'Reader' in name:
                             datatype = name.replace('Reader','')
                         else:
                             datatype = name
                             name = '{}Reader'.format(name)
                     self.id = id
                     self.project_id = project_id
                     self.name = name
                     self.datatype = datatype
                     if path != '':
                         self.path = os.path.abspath(path)
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.server = server
                     self.err_queue = err_queue
                     self.addRunOperation(**kwargs)
                 def update(self, **kwargs):
                     if 'datatype' in kwargs:
                         datatype = kwargs.pop('datatype')
                         if 'Reader' in datatype:
                             self.name = datatype
                         else:
                             self.name = '%sReader' % (datatype)
                         self.datatype = self.name.replace('Reader', '')
                     attrs = ('path', 'startDate', 'endDate',
                              'startTime', 'endTime')
                     for attr in attrs:
                         if attr in kwargs:
                             setattr(self, attr, kwargs.pop(attr))
                     self.updateRunOperation(**kwargs)
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name='run', optype='self')
                     if self.server is None:
                         opObj.addParameter(
                             name='datatype', value=self.datatype, format='str')
                         opObj.addParameter(name='path', value=self.path, format='str')
                         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='endTime', value=self.endTime, format='time')
                         for key, value in list(kwargs.items()):
                             opObj.addParameter(name=key, value=value,
                                                format=type(value).__name__)
+                    elif self.server== "simulate":
+                        #print(" [ INSIDE ] : AROperation simulate -True simulate")
+                        opObj.addParameter(
+                            name='datatype', value=self.datatype, format='str')
+                        for key, value in list(kwargs.items()):
+                            opObj.addParameter(name=key, value=value,
+                                               format=type(value).__name__)
                     else:
                         opObj.addParameter(name='server', value=self.server, format='str')
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj = self.getOperationObj(name='run')
                     opObj.removeParameters()
                     opObj.addParameter(name='datatype', value=self.datatype, format='str')
                     opObj.addParameter(name='path', value=self.path, format='str')
                     opObj.addParameter(
                         name='startDate', value=self.startDate, format='date')
                     opObj.addParameter(name='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 list(kwargs.items()):
                         opObj.addParameter(name=key, value=value,
                                            format=type(value).__name__)
                     return opObj
                 def readXml(self, upElement, project_id):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.project_id = str(project_id)  #yong
                     if self.ELEMENTNAME == 'ReadUnit':
                         self.datatype = self.datatype.replace('Reader', '')
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement, project_id)
                         self.opConfObjList.append(opConfObj)
                         if opConfObj.name == 'run':
                             self.path = opConfObj.getParameterValue('path')
                             self.startDate = opConfObj.getParameterValue('startDate')
                             self.endDate = opConfObj.getParameterValue('endDate')
                             self.startTime = opConfObj.getParameterValue('startTime')
                             self.endTime = opConfObj.getParameterValue('endTime')
             class Project(Process):
                 ELEMENTNAME = 'Project'
                 def __init__(self):
                     Process.__init__(self)
                     self.id = None
                     self.filename = None
                     self.description = None
                     self.email = None
                     self.alarm = None
                     self.procUnitConfObjDict = {}
                     self.err_queue = Queue()
                 def __getNewId(self):
                     idList = list(self.procUnitConfObjDict.keys())
                     id = int(self.id) * 10
                     while True:
                         id += 1
                         if str(id) in idList:
                             continue
                         break
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = list(self.procUnitConfObjDict.keys())
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id) * 10 + n)
                         procUnitConfObj.updateId(idProcUnit)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
                 def setup(self, id=1, name='', description='', email=None, alarm=[]):
                     print(' ')
                     print('*' * 60)
                     print('*  Starting SIGNAL CHAIN PROCESSING (Multiprocessing) v%s *' % schainpy.__version__)
                     print('*' * 60)
                     print("*  Python " + python_version() + "  *")
                     print('*' * 19)
                     print(' ')
                     self.id = str(id)
                     self.description = description
                     self.email = email
                     self.alarm = alarm
                     if name:
                         self.name = '{} ({})'.format(Process.__name__, name)
                 def update(self, **kwargs):
                     for key, value in list(kwargs.items()):
                         setattr(self, key, value)
                 def clone(self):
                     p = Project()
                     p.procUnitConfObjDict = self.procUnitConfObjDict
                     return p
                 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
                     '''
                     Actualizacion:
                         Se agrego un nuevo argumento: topic -relativo a la forma de comunicar los procesos simultaneos
                         * El id del proceso sera el topico al que se deben subscribir los procUnits para recibir la informacion(data)
                     '''
                     if id is None:
                         idReadUnit = self.__getNewId()
                     else:
                         idReadUnit = str(id)
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(self.id, idReadUnit, name, datatype, self.err_queue, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     '''
                     Actualizacion:
                         Se agrego dos nuevos argumentos: topic_read (lee data de otro procUnit) y topic_write(escribe o envia data a otro procUnit)
                         Deberia reemplazar a "inputId"
                         ** A fin de mantener el inputID, este sera la representaacion del topicoal que deben subscribirse. El ID propio de la intancia
                         (proceso) sera el topico de la publicacion, todo sera asignado de manera dinamica.
                     '''
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     input_proc = self.procUnitConfObjDict[inputId]
                     procUnitConfObj.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue, input_proc.lock)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in list(self.procUnitConfObjDict.keys()):
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in list(self.procUnitConfObjDict.values()):
                         if obj.getElementName() == 'ReadUnit':
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in list(self.procUnitConfObjDict.values()):
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return list(self.procUnitConfObjDict.items())
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in list(self.procUnitConfObjDict.values()):
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename=None):
                     if filename == None:
                         if self.filename:
                             filename = self.filename
                         else:
                             filename = 'schain.xml'
                     if not filename:
                         print('filename has not been defined. Use setFilename(filename) for do it.')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.access(os.path.dirname(abs_file), os.W_OK):
                         print('No write permission on %s' % os.path.dirname(abs_file))
                         return 0
                     if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
                         print('File %s already exists and it could not be overwriten' % abs_file)
                         return 0
                     self.makeXml()
                     ElementTree(self.projectElement).write(abs_file, method='xml')
                     self.filename = abs_file
                     return 1
                 def readXml(self, filename=None):
                     if not filename:
                         print('filename is not defined')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.path.isfile(abs_file):
                         print('%s file does not exist' % abs_file)
                         return 0
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     try:
                         self.projectElement = ElementTree().parse(abs_file)
                     except:
                         print('Error reading %s, verify file format' % filename)
                         return 0
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
                     readUnitElementList = self.projectElement.iter(
                         ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement, self.id)
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.iter(
                         ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement, self.id)
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     self.filename = abs_file
                     return 1
                 def __str__(self):
                     print('Project: name = %s, description = %s, id = %s' % (
                                                                         self.name,
                                                                         self.description,
                                                                         self.id))
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         print(procUnitConfObj)
                 def createObjects(self):
                     keys = list(self.procUnitConfObjDict.keys())
                     keys.sort()
                     for key in keys:
                         self.procUnitConfObjDict[key].createObjects()
                 def monitor(self):
                     t = Thread(target=self.__monitor, args=(self.err_queue, self.ctx))
                     t.start()
                 def __monitor(self, queue, ctx):
                     import socket
                     procs = 0
                     err_msg = ''
                     while True:
                         msg = queue.get()
                         if '#_start_#' in msg:
                             procs += 1
                         elif '#_end_#' in msg:
                             procs -=1
                         else:
                             err_msg = msg
                         if procs == 0 or 'Traceback' in err_msg:
                             break
                         time.sleep(0.1)
                     if '|' in err_msg:
                         name, err = err_msg.split('|')
                         if 'SchainWarning' in err:
                             log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), name)
                         elif 'SchainError' in err:
                             log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name)
                         else:
                             log.error(err, name)
                     else:
                         name, err = self.name, err_msg
                     time.sleep(2)
                     for conf in self.procUnitConfObjDict.values():
                         for confop in conf.opConfObjList:
                             if confop.type == 'external':
                                 confop.opObj.terminate()
                         conf.procUnitObj.terminate()
                     ctx.term()
                     message = ''.join(err)
                     if err_msg:
                         subject = 'SChain v%s: Error running %s\n' % (
                             schainpy.__version__, self.name)
                         subtitle = 'Hostname: %s\n' % socket.gethostbyname(
                             socket.gethostname())
                         subtitle += 'Working directory: %s\n' % os.path.abspath('./')
                         subtitle += 'Configuration file: %s\n' % self.filename
                         subtitle += 'Time: %s\n' % str(datetime.datetime.now())
                         readUnitConfObj = self.getReadUnitObj()
                         if readUnitConfObj:
                             subtitle += '\nInput parameters:\n'
                             subtitle += '[Data path = %s]\n' % readUnitConfObj.path
                             subtitle += '[Data type = %s]\n' % readUnitConfObj.datatype
                             subtitle += '[Start date = %s]\n' % readUnitConfObj.startDate
                             subtitle += '[End date = %s]\n' % readUnitConfObj.endDate
                             subtitle += '[Start time = %s]\n' % readUnitConfObj.startTime
                             subtitle += '[End time = %s]\n' % readUnitConfObj.endTime
                         a = Alarm(
                             modes=self.alarm,
                             email=self.email,
                             message=message,
                             subject=subject,
                             subtitle=subtitle,
                             filename=self.filename
                         )
                         a.start()
                 def isPaused(self):
                     return 0
                 def isStopped(self):
                     return 0
                 def runController(self):
                     '''
                     returns 0 when this process has been stopped, 1 otherwise
                     '''
                     if self.isPaused():
                         print('Process suspended')
                         while True:
                             time.sleep(0.1)
                             if not self.isPaused():
                                 break
                             if self.isStopped():
                                 break
                         print('Process reinitialized')
                     if self.isStopped():
                         print('Process stopped')
                         return 0
                     return 1
                 def setFilename(self, filename):
                     self.filename = filename
                 def setProxy(self):
                     if not os.path.exists('/tmp/schain'):
                         os.mkdir('/tmp/schain')
                     self.ctx = zmq.Context()
                     xpub = self.ctx.socket(zmq.XPUB)
                     xpub.bind('ipc:///tmp/schain/{}_pub'.format(self.id))
                     xsub = self.ctx.socket(zmq.XSUB)
                     xsub.bind('ipc:///tmp/schain/{}_sub'.format(self.id))
                     self.monitor()
                     try:
                         zmq.proxy(xpub, xsub)
                     except zmq.ContextTerminated:
                         xpub.close()
                         xsub.close()
                 def run(self):
                     log.success('Starting {}: {}'.format(self.name, self.id), tag='')
                     self.start_time = time.time()
                     self.createObjects()
                     self.setProxy()
                     log.success('{} Done (Time: {}s)'.format(
                         self.name,
                         time.time()-self.start_time), '')

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

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

schainpy/model/io/__init__.py +2 0

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

schainpy/model/io/jroIO_base.py +14 -2

             """
             Created on Jul 2, 2014
             @author: roj-idl71
             """
             import os
             import sys
             import glob
             import time
             import numpy
             import fnmatch
             import inspect
             import time
             import datetime
             import zmq
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
             from schainpy.utils import log
             import schainpy.admin
             LOCALTIME = True
             DT_DIRECTIVES = {
                 '%Y': 4,
                 '%y': 2,
                 '%m': 2,
                 '%d': 2,
                 '%j': 3,
                 '%H': 2,
                 '%M': 2,
                 '%S': 2,
                 '%f': 6
             }
             def isNumber(cad):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float(cad)
                     return True
                 except:
                     return False
             def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print("The file %s can't be opened" % (filename))
                     return 0
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print("Skipping the file %s because it has not a valid header" % (filename))
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def isTimeInRange(thisTime, startTime, endTime):
                 if endTime >= startTime:
                     if (thisTime < startTime) or (thisTime > endTime):
                         return 0
                     return 1
                 else:
                     if (thisTime < startTime) and (thisTime > endTime):
                         return 0
                     return 1
             def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print("The file %s can't be opened" % (filename))
                     return None
                 firstBasicHeaderObj = BasicHeader(LOCALTIME)
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 lastBasicHeaderObj = BasicHeader(LOCALTIME)
                 sts = firstBasicHeaderObj.read(fp)
                 if not(sts):
                     print("[Reading] Skipping the file %s because it has not a valid header" % (filename))
                     return None
                 if not systemHeaderObj.read(fp):
                     return None
                 if not radarControllerHeaderObj.read(fp):
                     return None
                 if not processingHeaderObj.read(fp):
                     return None
                 filesize = os.path.getsize(filename)
                 offset = processingHeaderObj.blockSize + 24  # header size
                 if filesize <= offset:
                     print("[Reading] %s: This file has not enough data" % filename)
                     return None
                 fp.seek(-offset, 2)
                 sts = lastBasicHeaderObj.read(fp)
                 fp.close()
                 thisDatetime = lastBasicHeaderObj.datatime
                 thisTime_last_block = thisDatetime.time()
                 thisDatetime = firstBasicHeaderObj.datatime
                 thisDate = thisDatetime.date()
                 thisTime_first_block = thisDatetime.time()
                 # General case
                 #           o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
                 #-----------o----------------------------o-----------
                 #       startTime                     endTime
                 if endTime >= startTime:
                     if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
                         return None
                     return thisDatetime
                 # If endTime < startTime then endTime belongs to the next day
                 #<<<<<<<<<<<o                            o>>>>>>>>>>>
                 #-----------o----------------------------o-----------
                 #        endTime                    startTime
                 if (thisDate == startDate) and (thisTime_last_block < startTime):
                     return None
                 if (thisDate == endDate) and (thisTime_first_block > endTime):
                     return None
                 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
                     return None
                 return thisDatetime
             def isFolderInDateRange(folder, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     folder            :    nombre completo del directorio.
                                            Su formato deberia ser "/path_root/?YYYYDDD"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el directorio no tiene el formato adecuado
                 """
                 basename = os.path.basename(folder)
                 if not isRadarFolder(basename):
                     print("The folder %s has not the rigth format" % folder)
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFolder(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def isFileInDateRange(filename, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                                            Su formato deberia ser "?YYYYDDDsss"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                                                 sss     :    set
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no tiene el formato adecuado
                 """
                 basename = os.path.basename(filename)
                 if not isRadarFile(basename):
                     print("The filename %s has not the rigth format" % filename)
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFile(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def getFileFromSet(path, ext, set):
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
                         year = int(thisFile[1:5])
                         doy = int(thisFile[5:8])
                     except:
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 myfile = fnmatch.filter(
                     validFilelist, '*%4.4d%3.3d%3.3d*' % (year, doy, set))
                 if len(myfile) != 0:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s' % (year, doy, set, ext.lower())
                     print('the filename %s does not exist' % filename)
                     print('...going to the last file: ')
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     year = thisFile[1:5]
                     if not isNumber(year):
                         continue
                     doy = thisFile[5:8]
                     if not isNumber(doy):
                         continue
                     year = int(year)
                     doy = int(doy)
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def isRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return 0
                 return 1
             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return 0
                 return 1
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def getDateFromRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def parse_format(s, fmt):
                 for i in range(fmt.count('%')):
                     x = fmt.index('%')
                     d = DT_DIRECTIVES[fmt[x:x+2]]
                     fmt = fmt.replace(fmt[x:x+2], s[x:x+d])
                 return fmt
             class Reader(object):
                 c = 3E8
                 isConfig = False
                 dtype = None
                 pathList = []
                 filenameList = []
                 datetimeList = []
                 filename = None
                 ext = None
                 flagIsNewFile = 1
                 flagDiscontinuousBlock = 0
                 flagIsNewBlock = 0
                 flagNoMoreFiles = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
                 fileSizeByHeader = None
                 fileIndex = -1
                 profileIndex = None
                 blockIndex = 0
                 nTotalBlocks = 0
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOut = None
                 getByBlock = False
                 path = None
                 startDate = None
                 endDate = None
                 startTime = datetime.time(0, 0, 0)
                 endTime = datetime.time(23, 59, 59)
                 set = None
                 expLabel = ""
                 online = False
                 delay = 60
                 nTries = 3  # quantity tries
                 nFiles = 3  # number of files for searching
                 walk = True
                 getblock = False
                 nTxs = 1
                 realtime = False
                 blocksize = 0
                 blocktime = None
                 warnings = True
                 verbose = True
                 server = None
                 format = None
                 oneDDict = None
                 twoDDict = None
                 independentParam = None
                 filefmt = None
                 folderfmt = None
                 open_file = open
                 open_mode = 'rb'
                 def run(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def find_folders(self, path, startDate, endDate, folderfmt, last=False):
                     folders = [x for f in path.split(',')
                                for x in os.listdir(f) if os.path.isdir(os.path.join(f, x))]
                     folders.sort()
                     if last:
                         folders = [folders[-1]]
                     for folder in folders:
                         try:
                             dt = datetime.datetime.strptime(parse_format(folder, folderfmt), folderfmt).date()
                             if dt >= startDate and dt <= endDate:
                                 yield os.path.join(path, folder)
                             else:
                                 log.log('Skiping folder {}'.format(folder), self.name)
                         except Exception as e:
                             log.log('Skiping folder {}'.format(folder), self.name)
                             continue
                     return
                 def find_files(self, folders, ext, filefmt, startDate=None, endDate=None,
                                expLabel='', last=False):
                     for path in folders:
                         files = glob.glob1(path, '*{}'.format(ext))
                         files.sort()
                         if last:
                             if files:
                                 fo = files[-1]
                                 try:
                                     dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                     yield os.path.join(path, expLabel, fo)
                                 except Exception as e:
                                     pass
                                 return
                             else:
                                 return
                         for fo in files:
                             try:
                                 dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                 if dt >= startDate and dt <= endDate:
                                     yield os.path.join(path, expLabel, fo)
                                 else:
                                     log.log('Skiping file {}'.format(fo), self.name)
                             except Exception as e:
                                 log.log('Skiping file {}'.format(fo), self.name)
                                 continue
                 def searchFilesOffLine(self, path, startDate, endDate,
                                        expLabel, ext, walk,
                                        filefmt, folderfmt):
                     """Search files in offline mode for the given arguments
                     Return:
                         Generator of files
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel)
                 def searchFilesOnLine(self, path, startDate, endDate,
                                       expLabel, ext, walk,
                                       filefmt, folderfmt):
                     """Search for the last file of the last folder
                     Arguments:
                         path        :    carpeta donde estan contenidos los files que contiene data
                         expLabel    :    Nombre del subexperimento (subfolder)
                         ext         :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     Return:
                         generator with the full path of last filename
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt, last=True)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel, last=True)
                 def setNextFile(self):
                     """Set the next file to be readed open it and parse de file header"""
                     while True:
                         if self.fp != None:
                             self.fp.close()
                         if self.online:
                             newFile = self.setNextFileOnline()
                         else:
                             newFile = self.setNextFileOffline()
                         if not(newFile):
                             if self.online:
                                 raise schainpy.admin.SchainError('Time to wait for new files reach')
                             else:
                                 if self.fileIndex == -1:
                                     raise schainpy.admin.SchainWarning('No files found in the given path')
                                 else:
                                     raise schainpy.admin.SchainWarning('No more files to read')
                         if self.verifyFile(self.filename):
                             break
                     log.log('Opening file: %s' % self.filename, self.name)
                     self.readFirstHeader()
                     self.nReadBlocks = 0
                 def setNextFileOnline(self):
                     """Check for the next file to be readed in online mode.
                     Set:
                         self.filename
                         self.fp
                         self.filesize
                     Return:
                         boolean
                     """
                     nextFile = True
                     nextDay = False
                     for nFiles in range(self.nFiles+1):
                         for nTries in range(self.nTries):
                             fullfilename, filename = self.checkForRealPath(nextFile, nextDay)
                             if fullfilename is not None:
                                 break
                             log.warning(
                                 "Waiting %0.2f sec for the next file: \"%s\" , try %02d ..." % (self.delay, filename, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                             nextFile = False
                             continue
                         if fullfilename is not None:
                             break
                         self.nTries = 1
                         nextFile = True
                         if nFiles == (self.nFiles - 1):
                             log.log('Trying with next day...', self.name)
                             nextDay = True
                             self.nTries = 3
                     if fullfilename:
                         self.fileSize = os.path.getsize(fullfilename)
                         self.filename = fullfilename
                         self.flagIsNewFile = 1
                         if self.fp != None:
                             self.fp.close()
                         self.fp = self.open_file(fullfilename, self.open_mode)
                         self.flagNoMoreFiles = 0
                         self.fileIndex += 1
                         return 1
                     else:
                         return 0
                 def setNextFileOffline(self):
                     """Open the next file to be readed in offline mode"""
                     try:
                         filename = next(self.filenameList)
                         self.fileIndex +=1
                     except StopIteration:
                         self.flagNoMoreFiles = 1
                         return 0
                     self.filename = filename
                     self.fileSize = os.path.getsize(filename)
                     self.fp = self.open_file(filename, self.open_mode)
                     self.flagIsNewFile = 1
                     return 1
                 @staticmethod
                 def isDateTimeInRange(dt, startDate, endDate, startTime, endTime):
                     """Check if the given datetime is in range"""
                     if startDate <= dt.date() <= endDate:
                         if startTime <= dt.time() <= endTime:
                             return True
                     return False
                 def verifyFile(self, filename):
                     """Check for a valid file
                     Arguments:
                         filename -- full path filename
                     Return:
                         boolean
                     """
                     return True
                 def checkForRealPath(self, nextFile, nextDay):
                     """Check if the next file to be readed exists"""
                     raise NotImplementedError
                 def readFirstHeader(self):
                     """Parse the file header"""
                     pass
             class JRODataReader(Reader):
                 utc = 0
                 nReadBlocks = 0
                 foldercounter = 0
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 __isFirstTimeOnline = 1
                 __printInfo = True
                 filefmt = "*%Y%j***"
                 folderfmt = "*%Y%j"
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def checkForRealPath(self, nextFile, nextDay):
                     """Check if the next file to be readed exists.
                     Example    :
                         nombre correcto del file es  .../.../D2009307/P2009307367.ext
                         Entonces la funcion prueba con las siguientes combinaciones
                             .../.../y2009307367.ext
                             .../.../Y2009307367.ext
                             .../.../x2009307/y2009307367.ext
                             .../.../x2009307/Y2009307367.ext
                             .../.../X2009307/y2009307367.ext
                             .../.../X2009307/Y2009307367.ext
                         siendo para este caso, la ultima combinacion de letras, identica al file buscado
                     Return:
                         str -- fullpath of the file
                     """
                     if nextFile:
                         self.set += 1
                     if nextDay:
                         self.set = 0
                         self.doy += 1
                     foldercounter = 0
                     prefixDirList = [None, 'd', 'D']
                     if self.ext.lower() == ".r":  # voltage
                         prefixFileList = ['d', 'D']
                     elif self.ext.lower() == ".pdata":  # spectra
                         prefixFileList = ['p', 'P']
                     # barrido por las combinaciones posibles
                     for prefixDir in prefixDirList:
                         thispath = self.path
                         if prefixDir != None:
                             # formo el nombre del directorio xYYYYDDD (x=d o x=D)
                             if foldercounter == 0:
                                 thispath = os.path.join(self.path, "%s%04d%03d" %
                                                         (prefixDir, self.year, self.doy))
                             else:
                                 thispath = os.path.join(self.path, "%s%04d%03d_%02d" % (
                                     prefixDir, self.year, self.doy, foldercounter))
                         for prefixFile in prefixFileList:  # barrido por las dos combinaciones posibles de "D"
                             # formo el nombre del file xYYYYDDDSSS.ext
                             filename = "%s%04d%03d%03d%s" % (prefixFile, self.year, self.doy, self.set, self.ext)
                             fullfilename = os.path.join(
                                 thispath, filename)
                             if os.path.exists(fullfilename):
                                 return fullfilename, filename
                     return None, filename
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             self.basicHeaderObj.read(self.fp)
                             return 1
                         if self.fileSize == self.fileSizeByHeader:
                             #                self.flagEoF = True
                             return 0
                         print("[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
                         time.sleep(self.delay)
                     return 0
                 def waitDataBlock(self, pointer_location, blocksize=None):
                     currentPointer = pointer_location
                     if blocksize is None:
                         neededSize = self.processingHeaderObj.blockSize  # + self.basicHeaderSize
                     else:
                         neededSize = blocksize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             return 1
                         log.warning(
                             "Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1),
                             self.name
                             )
                         time.sleep(self.delay)
                     return 0
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
+                    #print("DIME COMO ARRANCA",self.flagIsNewFile)
+                    #print("DIME COMO VA",self.nReadBlocks)
                     if self.flagIsNewFile:
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.realtime:
                         self.flagDiscontinuousBlock = 1
                         if not(self.setNextFile()):
                             return 0
                         else:
                             return 1
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.basicHeaderObj.read(self.fp)
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.__waitNewBlock():
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime
                     self.lastUTTime = self.basicHeaderObj.utc
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
+                    #print("nReadBlocks",self.nReadBlocks)
                     while True:
                         self.__setNewBlock()
                         if not(self.readBlock()):
                             return 0
                         self.getBasicHeader()
                         if not self.isDateTimeInRange(self.dataOut.datatime, self.startDate, self.endDate, self.startTime, self.endTime):
                             print("[Reading] Block No. %d/%d -> %s [Skipping]" % (self.nReadBlocks,
                                                                                   self.processingHeaderObj.dataBlocksPerFile,
                                                                                   self.dataOut.datatime.ctime()))
                             continue
                         break
                     if self.verbose:
                         print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
                                                                    self.processingHeaderObj.dataBlocksPerFile,
                                                                    self.dataOut.datatime.ctime()))
                     return 1
                 def readFirstHeader(self):
                     self.basicHeaderObj.read(self.fp)
                     self.systemHeaderObj.read(self.fp)
                     self.radarControllerHeaderObj.read(self.fp)
                     self.processingHeaderObj.read(self.fp)
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def verifyFile(self, filename, msgFlag=True):
                     msg = None
                     try:
                         fp = open(filename, 'rb')
                     except IOError:
                         if msgFlag:
                             print("[Reading] File %s can't be opened" % (filename))
                         return False
                     if self.waitDataBlock(0):
                         basicHeaderObj = BasicHeader(LOCALTIME)
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         if not(basicHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not(systemHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not(radarControllerHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not(processingHeaderObj.read(fp)):
                             fp.close()
                             return False
                         if not self.online:
                             dt1 = basicHeaderObj.datatime
                             fp.seek(self.fileSize-processingHeaderObj.blockSize-24)
                             if not(basicHeaderObj.read(fp)):
                                 fp.close()
                                 return False
                             dt2 = basicHeaderObj.datatime
                             if not self.isDateTimeInRange(dt1, self.startDate, self.endDate, self.startTime, self.endTime) and not \
                                    self.isDateTimeInRange(dt2, self.startDate, self.endDate, self.startTime, self.endTime):
                                 return False
                     fp.close()
                     return True
                 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
                     path_empty = True
                     dateList = []
                     pathList = []
                     multi_path = path.split(',')
                     if not walk:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             fileList = glob.glob1(single_path, "*" + ext)
                             if not fileList:
                                 continue
                             path_empty = False
                             fileList.sort()
                             for thisFile in fileList:
                                 if not os.path.isfile(os.path.join(single_path, thisFile)):
                                     continue
                                 if not isRadarFile(thisFile):
                                     continue
                                 if not isFileInDateRange(thisFile, startDate, endDate):
                                     continue
                                 thisDate = getDateFromRadarFile(thisFile)
                                 if thisDate in dateList or single_path in pathList:
                                     continue
                                 dateList.append(thisDate)
                                 pathList.append(single_path)
                     else:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             dirList = []
                             for thisPath in os.listdir(single_path):
                                 if not os.path.isdir(os.path.join(single_path, thisPath)):
                                     continue
                                 if not isRadarFolder(thisPath):
                                     continue
                                 if not isFolderInDateRange(thisPath, startDate, endDate):
                                     continue
                                 dirList.append(thisPath)
                             if not dirList:
                                 continue
                             dirList.sort()
                             for thisDir in dirList:
                                 datapath = os.path.join(single_path, thisDir, expLabel)
                                 fileList = glob.glob1(datapath, "*" + ext)
                                 if not fileList:
                                     continue
                                 path_empty = False
                                 thisDate = getDateFromRadarFolder(thisDir)
                                 pathList.append(datapath)
                                 dateList.append(thisDate)
                     dateList.sort()
                     if walk:
                         pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
                     else:
                         pattern_path = multi_path[0]
                     if path_empty:
                         raise schainpy.admin.SchainError("[Reading] No *%s files in %s for %s to %s" % (ext, pattern_path, startDate, endDate))
                     else:
                         if not dateList:
                             raise schainpy.admin.SchainError("[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" % (startDate, endDate, ext, path))
                     if include_path:
                         return dateList, pathList
                     return dateList
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.server is not None:
                         if 'tcp://' in self.server:
                             address = server
                         else:
                             address = 'ipc:///tmp/%s' % self.server
                         self.server = address
                         self.context = zmq.Context()
                         self.receiver = self.context.socket(zmq.PULL)
                         self.receiver.connect(self.server)
                         time.sleep(0.5)
                         print('[Starting] ReceiverData from {}'.format(self.server))
                     else:
                         self.server = None
                         if self.path == None:
                             raise ValueError("[Reading] The path is not valid")
                         if self.online:
                             log.log("[Reading] Searching files in online mode...", self.name)
                             for nTries in range(self.nTries):
                                 fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                     self.endDate, self.expLabel, self.ext, self.walk,
                                     self.filefmt, self.folderfmt)
                                 try:
                                     fullpath = next(fullpath)
                                 except:
                                     fullpath = None
                                 if fullpath:
                                     break
                                 log.warning(
                                     'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                         self.delay, self.path, nTries + 1),
                                     self.name)
                                 time.sleep(self.delay)
                             if not(fullpath):
                                 raise schainpy.admin.SchainError(
                                     'There isn\'t any valid file in {}'.format(self.path))
                             pathname, filename = os.path.split(fullpath)
                             self.year = int(filename[1:5])
                             self.doy = int(filename[5:8])
                             self.set = int(filename[8:11]) - 1
                         else:
                             log.log("Searching files in {}".format(self.path), self.name)
                             self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                     return
                 def getBasicHeader(self):
+                    '''
+                    print("1",self.radarControllerHeaderObj.ippSeconds)
+                    print("2",self.profileIndex)
+                    print("3",self.basicHeaderObj.miliSecond)
+                    print("4",self.basicHeaderObj.utc)
+                    print("5",self.nTxs)
+                    '''
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
 . + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
+                    #print(self.profileIndex,self.dataOut.utctime)
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
              #         self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError
                 def getData(self):
                     raise NotImplementedError
                 def hasNotDataInBuffer(self):
                     raise NotImplementedError
                 def readBlock(self):
                     raise NotImplementedError
                 def isEndProcess(self):
                     return self.flagNoMoreFiles
                 def printReadBlocks(self):
                     print("[Reading] Number of read blocks per file %04d" % self.nReadBlocks)
                 def printTotalBlocks(self):
                     print("[Reading] Number of read blocks %04d" % self.nTotalBlocks)
                 def printNumberOfBlock(self):
                     'SPAM!'
              #         if self.flagIsNewBlock:
              #             print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
              #                                                       self.processingHeaderObj.dataBlocksPerFile,
              #                                                       self.dataOut.datatime.ctime())
                 def printInfo(self):
                     if self.__printInfo == False:
                         return
                     self.basicHeaderObj.printInfo()
                     self.systemHeaderObj.printInfo()
                     self.radarControllerHeaderObj.printInfo()
                     self.processingHeaderObj.printInfo()
                     self.__printInfo = False
                 def run(self, **kwargs):
                     """
                     Arguments:
                         path        :
                         startDate   :
                         endDate     :
                         startTime   :
                         endTime     :
                         set         :
                         expLabel    :
                         ext         :
                         online      :
                         delay       :
                         walk        :
                         getblock    :
                         nTxs        :
                         realtime    :
                         blocksize   :
                         blocktime   :
                         skip        :
                         cursor      :
                         warnings    :
                         server      :
                         verbose     :
                         format      :
                         oneDDict    :
                         twoDDict    :
                         independentParam    :
                     """
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.server is None:
                         self.getData()
                     else:
                         self.getFromServer()
             class JRODataWriter(Reader):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 fileDate = None
                 def __init__(self, dataOut=None):
                     raise NotImplementedError
                 def hasAllDataInBuffer(self):
                     raise NotImplementedError
                 def setBlockDimension(self):
                     raise NotImplementedError
                 def writeBlock(self):
                     raise NotImplementedError
                 def putData(self):
                     raise NotImplementedError
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def getProcessFlags(self):
                     processFlags = 0
                     dtype_index = get_dtype_index(self.dtype)
                     procflag_dtype = get_procflag_dtype(dtype_index)
                     processFlags += procflag_dtype
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code is not None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     if self.dataOut.type == "Spectra":
                         if self.dataOut.nIncohInt > 1:
                             processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                         if self.dataOut.data_dc is not None:
                             processFlags += PROCFLAG.SAVE_CHANNELS_DC
                         if self.dataOut.flagShiftFFT:
                             processFlags += PROCFLAG.SHIFT_FFT_DATA
                     return processFlags
                 def setBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize  # bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond = (self.dataOut.utctime - utc) * 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise NotImplementedError
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
             #        CALCULAR PARAMETROS
                     sizeLongHeader = self.systemHeaderObj.size + \
                         self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.basicHeaderObj.write(self.fp)
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not(self.__setNewBlock()):
                         return 0
                     self.writeBlock()
                     print("[Writing] Block No. %d/%d" % (self.blockIndex,
                                                          self.processingHeaderObj.dataBlocksPerFile))
                     return 1
-                def setNextFile(self):
+                def setNewxtFile(self):
                     """Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     if not os.path.exists(path):
                         os.mkdir(path)
                     timeTuple = time.localtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     setFile = self.setFile
                     if not(os.path.exists(fullpath)):
                         os.mkdir(fullpath)
                         setFile = -1  # inicializo mi contador de seteo
                     else:
                         filesList = os.listdir(fullpath)
                         if len(filesList) > 0:
                             filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber(filen[8:11]):
                                 # inicializo mi contador de seteo al seteo del ultimo file
                                 setFile = int(filen[8:11])
                             else:
                                 setFile = -1
                         else:
                             setFile = -1  # inicializo mi contador de seteo
                     setFile += 1
                     # If this is a new day it resets some values
                     if self.dataOut.datatime.date() > self.fileDate:
                         setFile = 0
                         self.nTotalBlocks = 0
                     filen = '{}{:04d}{:03d}{:03d}{}'.format(
                             self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext)
                     filename = os.path.join(path, subfolder, filen)
                     fp = open(filename, 'wb')
                     self.blockIndex = 0
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.fileDate = self.dataOut.datatime.date()
                     self.setFirstHeader()
                     print('[Writing] Opening file: %s' % self.filename)
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path                :    directory where data will be saved
                         profilesPerBlock    :    number of profiles per block
                         set                 :    initial file set
                         datatype            :    An integer number that defines data type:
 : int8  (1 byte)
 : int16 (2 bytes)
 : int32 (4 bytes)
 : int64 (8 bytes)
 : float32 (4 bytes)
 : double64 (8 bytes)
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     self.ext = ext.lower()
                     self.path = path
                     if set is None:
                         self.setFile = -1
                     else:
                         self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     self.fileDate = self.dataOut.datatime.date()
                     self.dtype = self.dataOut.dtype
                     if datatype is not None:
                         self.dtype = get_numpy_dtype(datatype)
                     if not(self.setNextFile()):
                         print("[Writing] There isn't a next file")
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, path, blocksPerFile=100, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock,
                                    set=set, ext=ext, datatype=datatype, **kwargs)
                         self.isConfig = True
                     self.dataOut = dataOut
                     self.putData()
                     return self.dataOut

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

             '''
             Created on Jul 2, 2014
             @author: roj-idl71
             '''
             import numpy
             from .jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Voltage
             import zmq
             import tempfile
             from io import StringIO
             # from _sha import blocksize
             @MPDecorator
             class VoltageReader(JRODataReader, ProcessingUnit):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         dataOut    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
-                                          si el buffer esta vacio se hara un nuevo proceso de lectura de un
+                                          si el buffer esta vacio se hara un nuevo proceso de lectura de unX
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.dataOut
                     Return:
                         None
                     """
                     ProcessingUnit.__init__(self)
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.lastUTTime = 0
                     self.profileIndex = 2**32 - 1
                     self.dataOut = Voltage()
                     self.selBlocksize = None
                     self.selBlocktime = None
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock * self.nTxs:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                         Obtiene la cantidad de puntos a leer por cada bloque de datos
                         Affected:
                             self.blocksize
                         Return:
                             None
                     """
                     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
                         (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                         (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                         es seteado a 0
                         Inputs:
                             None
                         Return:
                             None
                         Affected:
                             self.profileIndex
                             self.datablock
                             self.flagIsNewFile
                             self.flagIsNewBlock
                             self.nTotalBlocks
                         Exceptions:
                             Si un bloque leido no es un bloque valido
                     """
                     # if self.server is not None:
                     #     self.zBlock = self.receiver.recv()
                     #     self.zHeader = self.zBlock[:24]
                     #     self.zDataBlock = self.zBlock[24:]
                     #     junk = numpy.fromstring(self.zDataBlock, numpy.dtype([('real','<i4'),('imag','<i4')]))
                     #     self.processingHeaderObj.profilesPerBlock = 240
                     #     self.processingHeaderObj.nHeights = 248
                     #     self.systemHeaderObj.nChannels
                     # else:
                     current_pointer_location = self.fp.tell()
                     junk = numpy.fromfile(self.fp, self.dtype, self.blocksize)
                     try:
                         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))
                     #             return 0
                     # Dimensions : nChannels, nProfiles, nSamples
                     junk = numpy.transpose(junk, (2, 0, 1))
                     self.datablock = junk['real'] + junk['imag'] * 1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getFirstHeader(self):
                     self.getBasicHeader()
                     self.dataOut.processingHeaderObj = self.processingHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     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
                     #
                     #         if self.radarControllerHeaderObj.code is not None:
                     #
                     #             self.dataOut.nCode = self.radarControllerHeaderObj.nCode
                     #
                     #             self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
                     #
                     #             self.dataOut.code = self.radarControllerHeaderObj.code
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.heightList = numpy.arange(
                         self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     # asumo q la data no esta decodificada
                     self.dataOut.flagDecodeData = self.processingHeaderObj.flag_decode
                     # asumo q la data no esta sin flip
                     self.dataOut.flagDeflipData = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
                 def reshapeData(self):
                     if self.nTxs < 0:
                         return
                     if self.nTxs == 1:
                         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)" % (
 . / 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))
                     self.datablock = self.datablock.reshape(
                         (self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, int(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.radarControllerHeaderObj.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                     return
                 def readFirstHeaderFromServer(self):
                     self.getFirstHeader()
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.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
                     self.flagIsNewBlock = 1
-                    self.dataOut.flagNoData = False
+                    self.dataOut.flagNoata = False
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     self.blockPointer = 0
                     block = self.receiver.recv()
                     self.basicHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.basicHeaderObj.length
                     self.systemHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.systemHeaderObj.length
                     self.radarControllerHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.radarControllerHeaderObj.length
                     self.processingHeaderObj.read(block[self.blockPointer:])
                     self.blockPointer += self.processingHeaderObj.length
                     self.readFirstHeaderFromServer()
                     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)
                     try:
                         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 = 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.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.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[:, :datasize, :] = self.dataOut.data
                         self.dataOut.data = buffer
                         self.profileIndex = blockIndex
                     self.dataOut.flagDataAsBlock = True
                     self.flagIsNewBlock = 1
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
                 def getData(self):
                     """
                         getData obtiene una unidad de datos del buffer de lectura, un perfil,  y la copia al objeto self.dataOut
                         del tipo "Voltage" con todos los parametros asociados a este (metadata). cuando no hay datos
                         en el buffer de lectura es necesario hacer una nueva lectura de los bloques de datos usando
                         "readNextBlock"
                         Ademas incrementa el contador del buffer "self.profileIndex" en 1.
                         Return:
                             Si el flag self.getByBlock ha sido seteado el bloque completo es copiado a self.dataOut y el self.profileIndex
                             es igual al total de perfiles leidos desde el archivo.
                             Si self.getByBlock == False:
                                 self.dataOut.data = buffer[:, thisProfile, :]
                                 shape = [nChannels, nHeis]
                             Si self.getByBlock == True:
                                 self.dataOut.data = buffer[:, :, :]
                                 shape = [nChannels, nProfiles, nHeis]
                         Variables afectadas:
                             self.dataOut
                             self.profileIndex
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not(self.readNextBlock()):
                             return 0
                         self.getFirstHeader()
                         self.reshapeData()
                     if self.datablock is None:
                         self.dataOut.flagNoData = True
                         return 0
                     if not self.getByBlock:
                         """
                             Return profile by profile
                             If nTxs > 1 then one profile is divided by nTxs and number of total
                             blocks is increased by nTxs (nProfiles *= nTxs)
                         """
                         self.dataOut.flagDataAsBlock = False
                         self.dataOut.data = self.datablock[:, self.profileIndex, :]
                         self.dataOut.profileIndex = self.profileIndex
                         self.profileIndex += 1
                     else:
                         """
                             Return a block
                         """
                         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.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[:, :datasize, :] = self.dataOut.data
                             while datasize < self.selBlocksize:  # Not enough profiles to fill the block
                                 if not(self.readNextBlock()):
                                     return 0
                                 self.getFirstHeader()
                                 self.reshapeData()
                                 if self.datablock is None:
                                     self.dataOut.flagNoData = True
                                     return 0
                                 # stack data
                                 blockIndex = self.selBlocksize - datasize
                                 datablock1 = self.datablock[:, :blockIndex, :]
                                 buffer[:, datasize:datasize +
                                        datablock1.shape[1], :] = datablock1
                                 datasize += datablock1.shape[1]
                             self.dataOut.data = buffer
                             self.profileIndex = blockIndex
                         self.dataOut.flagDataAsBlock = True
                         self.dataOut.nProfiles = self.dataOut.data.shape[1]
                     self.dataOut.flagNoData = False
                     self.getBasicHeader()
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
             @MPDecorator
             class VoltageWriter(JRODataWriter, Operation):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
                 def __init__(self):#, **kwargs):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
                     Operation.__init__(self)#, **kwargs)
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
                     self.isConfig = False
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.blockIndex = 0
                     self.flagIsNewBlock = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.filename = None
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                   self.processingHeaderObj.profilesPerBlock,
                                                   self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex64'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros(self.shapeBuffer, self.dtype)
                     junk = numpy.transpose(self.datablock, (1, 2, 0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape((-1))
                     data.tofile(self.fp)
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
             #         print "[Writing] Block = %04d" %self.blockIndex
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagDiscontinuousBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.setBasicHeader()
                     self.datablock[:, self.profileIndex, :] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         # if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.setFirstHeader()
                     return 1
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
                     '''
                     dtype_width = self.getDtypeWidth()
                     blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels *
                                     self.profilesPerBlock * dtype_width * 2)
                     return blocksize
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.processingHeaderObj.dtype = 0  # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     # podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.nWindows = 1
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     # 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
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - \
                             self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
                     self.setBasicHeader()

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

             '''
             Updated for multiprocessing
             Author : Sergio Cortez
             Jan 2018
             Abstract:
                 Base class for processing units and operations. A decorator provides multiprocessing features and interconnect the processes created.
                 The argument (kwargs) sent from the controller is parsed and filtered via the decorator for each processing unit or operation instantiated.
                 The decorator handle also the methods inside the processing unit to be called from the main script (not as operations) (OPERATION -> type ='self').
             Based on:
                 $Author: murco $
                 $Id: jroproc_base.py 1 2012-11-12 18:56:07Z murco $
             '''
             import os
             import sys
             import inspect
             import zmq
             import time
             import pickle
             import traceback
             try:
                 from queue import Queue
             except:
                 from Queue import Queue
             from threading import Thread
             from multiprocessing import Process
             from schainpy.utils import log
             class ProcessingUnit(object):
                 """
                 Update - Jan 2018 - MULTIPROCESSING
                 All the "call" methods present in the previous base were removed.
                 The majority of operations are independant processes, thus
                 the decorator is in charge of communicate the operation processes
                 with the proccessing unit via IPC.
                 The constructor does not receive any argument. The remaining methods
                 are related with the operations to execute.
                 """
                 proc_type = 'processing'
                 __attrs__ = []
                 def __init__(self):
                     self.dataIn = None
                     self.dataOut = None
                     self.isConfig = False
                     self.operations = []
                     self.plots = []
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def addOperation(self, conf, operation):
                     """
                     This method is used in the controller, and update the dictionary containing the operations to execute. The dict
                     posses the id of the operation process (IPC purposes)
                         Agrega un objeto del tipo "Operation" (opObj) a la lista de objetos "self.objectList" y retorna el
                         identificador asociado a este objeto.
                         Input:
                             object    :    objeto de la clase "Operation"
                         Return:
                             objId    :    identificador del objeto, necesario para comunicar con master(procUnit)
                     """
                     self.operations.append(
                         (operation, conf.type, conf.id, conf.getKwargs()))
                     if 'plot' in self.name.lower():
                         self.plots.append(operation.CODE)
                 def getOperationObj(self, objId):
                     if objId not in list(self.operations.keys()):
                         return None
                     return self.operations[objId]
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     raise NotImplementedError
                 def setup(self):
                     raise NotImplementedError
                 def run(self):
                     raise NotImplementedError
                 def close(self):
                     return
             class Operation(object):
                 """
                 Update - Jan 2018 - MULTIPROCESSING
                 Most of the methods remained the same. The decorator parse the arguments and executed the run() method for each process.
                 The constructor doe snot receive any argument, neither the baseclass.
                     Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                     y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                     acumulacion dentro de esta clase
                     Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
                 proc_type = 'operation'
                 __attrs__ = []
                 def __init__(self):
                     self.id = None
                     self.isConfig = False
                     if not hasattr(self, 'name'):
                         self.name = self.__class__.__name__
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def setup(self):
                     self.isConfig = True
                     raise NotImplementedError
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los
                     atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     if not self.isConfig:
                         self.setup(**kwargs)
                     raise NotImplementedError
                 def close(self):
                     return
             class InputQueue(Thread):
                 '''
                 Class to hold input data for Proccessing Units and external Operations,
                 '''
                 def __init__(self, project_id, inputId, lock=None):
                     Thread.__init__(self)
                     self.queue = Queue()
                     self.project_id = project_id
                     self.inputId = inputId
                     self.lock = lock
                     self.islocked = False
                     self.size = 0
                 def run(self):
                     c = zmq.Context()
                     self.receiver = c.socket(zmq.SUB)
                     self.receiver.connect(
                         'ipc:///tmp/schain/{}_pub'.format(self.project_id))
                     self.receiver.setsockopt(zmq.SUBSCRIBE, self.inputId.encode())
                     while True:
                         obj = self.receiver.recv_multipart()[1]
                         self.size += sys.getsizeof(obj)
                         self.queue.put(obj)
                 def get(self):
                     if not self.islocked and self.size/1000000 > 512:
                         self.lock.n.value += 1
                         self.islocked = True
                         self.lock.clear()
                     elif self.islocked and self.size/1000000 <= 512:
                         self.islocked = False
                         self.lock.n.value -= 1
                         if self.lock.n.value == 0:
                             self.lock.set()
                     obj = self.queue.get()
                     self.size -= sys.getsizeof(obj)
                     return pickle.loads(obj)
             def MPDecorator(BaseClass):
                 """
                 Multiprocessing class decorator
                 This function add multiprocessing features to a BaseClass. Also, it handle
                 the communication beetween processes (readers, procUnits and operations).
                 """
                 class MPClass(BaseClass, Process):
                     def __init__(self, *args, **kwargs):
                         super(MPClass, self).__init__()
                         Process.__init__(self)
                         self.operationKwargs = {}
                         self.args = args
                         self.kwargs = kwargs
                         self.sender = None
                         self.receiver = None
                         self.i = 0
                         self.t = time.time()
                         self.name = BaseClass.__name__
                         self.__doc__ = BaseClass.__doc__
                         if 'plot' in self.name.lower() and not self.name.endswith('_'):
                             self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
                         self.start_time = time.time()
                         self.id = args[0]
                         self.inputId = args[1]
                         self.project_id = args[2]
                         self.err_queue = args[3]
                         self.lock = args[4]
                         self.typeProc = args[5]
                         self.err_queue.put('#_start_#')
                         if self.inputId is not None:
                             self.queue = InputQueue(self.project_id, self.inputId, self.lock)
                     def subscribe(self):
                         '''
                         Start the zmq socket receiver and subcribe to input ID.
                         '''
                         self.queue.start()
                     def listen(self):
                         '''
                         This function waits for objects
                         '''
                         return self.queue.get()
                     def set_publisher(self):
                         '''
                         This function create a zmq socket for publishing objects.
                         '''
                         time.sleep(0.5)
                         c = zmq.Context()
                         self.sender = c.socket(zmq.PUB)
                         self.sender.connect(
                             'ipc:///tmp/schain/{}_sub'.format(self.project_id))
                     def publish(self, data, id):
                         '''
                         This function publish an object, to an specific topic.
                         It blocks publishing when receiver queue is full to avoid data loss
                         '''
                         if self.inputId is None:
                             self.lock.wait()
                         self.sender.send_multipart([str(id).encode(), pickle.dumps(data)])
                     def runReader(self):
                         '''
                         Run fuction for read units
                         '''
                         while True:
                             try:
                                 BaseClass.run(self, **self.kwargs)
                             except:
                                 err = traceback.format_exc()
                                 if 'No more files' in err:
                                     log.warning('No more files to read', self.name)
                                 else:
                                     self.err_queue.put('{}|{}'.format(self.name, err))
                                 self.dataOut.error = True
                             for op, optype, opId, kwargs in self.operations:
                                 if optype == 'self' and not self.dataOut.flagNoData:
                                     op(**kwargs)
                                 elif optype == 'other' and not self.dataOut.flagNoData:
                                     self.dataOut = op.run(self.dataOut, **self.kwargs)
                                 elif optype == 'external':
                                     self.publish(self.dataOut, opId)
                             if self.dataOut.flagNoData and not self.dataOut.error:
                                 continue
                             self.publish(self.dataOut, self.id)
                             if self.dataOut.error:
                                 break
                         time.sleep(0.5)
                     def runProc(self):
                         '''
                         Run function for proccessing units
                         '''
                         while True:
                             self.dataIn = self.listen()
                             if self.dataIn.flagNoData and self.dataIn.error is None:
                                 continue
                             elif not self.dataIn.error:
                                 try:
                                     BaseClass.run(self, **self.kwargs)
                                 except:
                                     self.err_queue.put('{}|{}'.format(self.name, traceback.format_exc()))
                                     self.dataOut.error = True
                             elif self.dataIn.error:
                                 self.dataOut.error = self.dataIn.error
                                 self.dataOut.flagNoData = True
                             for op, optype, opId, kwargs in self.operations:
                                 if optype == 'self' and not self.dataOut.flagNoData:
                                     op(**kwargs)
                                 elif optype == 'other' and not self.dataOut.flagNoData:
                                     self.dataOut = op.run(self.dataOut, **kwargs)
                                 elif optype == 'external' and not self.dataOut.flagNoData:
                                     self.publish(self.dataOut, opId)
                             self.publish(self.dataOut, self.id)
                             for op, optype, opId, kwargs in self.operations:
                                 if optype == 'external' and self.dataOut.error:
                                     self.publish(self.dataOut, opId)
                             if self.dataOut.error:
                                 break
                         time.sleep(0.5)
                     def runOp(self):
                         '''
                         Run function for external operations (this operations just receive data
                         ex: plots, writers, publishers)
                         '''
                         while True:
                             dataOut = self.listen()
                             if not dataOut.error:
                                 try:
                                     BaseClass.run(self, dataOut, **self.kwargs)
                                 except:
                                     self.err_queue.put('{}|{}'.format(self.name, traceback.format_exc()))
                                     dataOut.error = True
                             else:
                                 break
                     def run(self):
                         if self.typeProc is "ProcUnit":
                             if self.inputId is not None:
                                 self.subscribe()
                             self.set_publisher()
                             if 'Reader' not in BaseClass.__name__:
                                 self.runProc()
                             else:
                                 self.runReader()
                         elif self.typeProc is "Operation":
                             self.subscribe()
                             self.runOp()
                         else:
                             raise ValueError("Unknown type")
                         self.close()
                     def close(self):
                         BaseClass.close(self)
                         self.err_queue.put('#_end_#')
                         if self.sender:
                             self.sender.close()
                         if self.receiver:
                             self.receiver.close()
                         log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
                 return MPClass

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