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 +47 -37

                     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)
                     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()
                         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 = 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'
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                     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)
                         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')
                     self.lock = lock
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(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:
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='',
                           startTime='', endTime='', server=None, **kwargs):
                     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:
                     self.startTime = startTime
                     self.endTime = endTime
                     self.server = server
                     self.err_queue = err_queue
                     self.addRunOperation(**kwargs)
                 def update(self, **kwargs):
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name='run', optype='self')
                     if self.server is None:
                         opObj.addParameter(
                         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')
                     print('*' * 19)
                     print(' ')
                     self.id = str(id)
                     self.description = description
                     self.email = email
                     self.alarm = alarm
                     if name:
                     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):
                     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
                     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
                         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.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():
                             if confop.type == 'external':
                                 confop.opObj.terminate()
                         conf.procUnitObj.terminate()
                     ctx.term()
                     message = ''.join(err)
                             subtitle += '[End time = %s]\n' % readUnitConfObj.endTime
                         a = Alarm(
                             modes=self.alarm,
                             email=self.email,
                             message=message,
                             subject=subject,
                     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))
                 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

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

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

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

schainpy/model/io/jroIO_base.py +97 -85

             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return None
                 return thisDate
             def parse_format(s, fmt):
                 for i in range(fmt.count('%')):
                     x = fmt.index('%')
                     d = DT_DIRECTIVES[fmt[x:x+2]]
                 def run(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                     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)
                             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
                             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
                     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)
                     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')
                                     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.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:
                                 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.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.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
                     """
                     """Check if the next file to be readed exists"""
                     raise NotImplementedError
                 def readFirstHeader(self):
                     """Parse the file header"""
                     Return:
                         str -- fullpath of the file
                     """
                     if nextFile:
                         self.set += 1
                     if nextDay:
                         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 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.
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
-                    if self.flagIsNewFile:
+                    #print("DIME COMO ARRANCA",self.flagIsNewFile)
+                    #print("DIME COMO VA",self.nReadBlocks)
+                    if self.flagIsNewFile:
                         self.lastUTTime = self.basicHeaderObj.utc
                         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
                     return 1
                 def readNextBlock(self):
+                    #print("nReadBlocks",self.nReadBlocks)
                     while True:
                         self.__setNewBlock()
                         print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
                                                                    self.processingHeaderObj.dataBlocksPerFile,
                                                                    self.dataOut.datatime.ctime()))
                     return 1
                 def readFirstHeader(self):
                             print("[Reading] File %s can't be opened" % (filename))
                         return False
                     if self.waitDataBlock(0):
                         basicHeaderObj = BasicHeader(LOCALTIME)
                         systemHeaderObj = SystemHeader()
                         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()
                             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):
                     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
                             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
                     """
                     Arguments:
                         path        :
                         startDate   :
                         endDate     :
                         startTime   :
                         endTime     :
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def getProcessFlags(self):
                     processFlags = 0
                     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
                     return 1
-                def setNextFile(self):
+                def setNewxtFile(self):
                     """Determina el siguiente file que sera escrito
                     Affected:
                     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)
                     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

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

                         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.
                     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
                     self.processingHeaderObj.processFlags = self.getProcessFlags()
                     self.setBasicHeader()
-  No newline at end of file

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

                         Run fuction for read units
                         '''
                         while True:
                             try:
                                 BaseClass.run(self, **self.kwargs)
                             except:

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