diff --git a/schainpy/controller.py b/schainpy/controller.py index 8514d8e..c62f55d 100644 --- a/schainpy/controller.py +++ b/schainpy/controller.py @@ -57,7 +57,7 @@ def MPProject(project, n=cpu_count()): nFiles = len(files) if nFiles == 0: continue - skip = int(math.ceil(nFiles / n)) + skip = int(math.ceil(nFiles / n)) while nFiles > cursor * skip: rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor, skip=skip) @@ -81,11 +81,11 @@ def MPProject(project, n=cpu_count()): 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.connect('ipc:///tmp/schain_{}_pub'.format(self.id)) receiver.setsockopt(zmq.SUBSCRIBE, self.id.encode()) msg = receiver.recv_multipart()[1] context.terminate() @@ -262,7 +262,7 @@ class ParameterConf(): parmElement.set('name', self.name) parmElement.set('value', self.value) parmElement.set('format', self.format) - + def readXml(self, parmElement): self.id = parmElement.get('id') @@ -417,7 +417,7 @@ class OperationConf(): self.name = opElement.get('name') self.type = opElement.get('type') self.priority = opElement.get('priority') - self.project_id = str(project_id) + self.project_id = str(project_id) # Compatible with old signal chain version # Use of 'run' method instead 'init' @@ -476,7 +476,7 @@ class ProcUnitConf(): self.id = None self.datatype = None self.name = None - self.inputId = None + self.inputId = None self.opConfObjList = [] self.procUnitObj = None self.opObjDict = {} @@ -497,7 +497,7 @@ class ProcUnitConf(): return self.id - def updateId(self, new_id): + def updateId(self, new_id): ''' new_id = int(parentId) * 10 + (int(self.id) % 10) new_inputId = int(parentId) * 10 + (int(self.inputId) % 10) @@ -556,7 +556,7 @@ class ProcUnitConf(): 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') @@ -581,7 +581,7 @@ class ProcUnitConf(): self.lock = lock self.opConfObjList = [] - self.addOperation(name='run', optype='self') + self.addOperation(name='run', optype='self') def removeOperations(self): @@ -677,30 +677,32 @@ class ProcUnitConf(): ''' 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: @@ -732,8 +734,8 @@ class ReadUnitConf(ProcUnitConf): def getElementName(self): - return self.ELEMENTNAME - + return self.ELEMENTNAME + def setup(self, project_id, id, name, datatype, err_queue, path='', startDate='', endDate='', startTime='', endTime='', server=None, **kwargs): @@ -745,8 +747,9 @@ class ReadUnitConf(ProcUnitConf): 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: @@ -773,7 +776,7 @@ class ReadUnitConf(ProcUnitConf): self.startTime = startTime self.endTime = endTime self.server = server - self.err_queue = err_queue + self.err_queue = err_queue self.addRunOperation(**kwargs) def update(self, **kwargs): @@ -804,7 +807,7 @@ class ReadUnitConf(ProcUnitConf): def addRunOperation(self, **kwargs): - opObj = self.addOperation(name='run', optype='self') + opObj = self.addOperation(name='run', optype='self') if self.server is None: opObj.addParameter( @@ -822,6 +825,13 @@ class ReadUnitConf(ProcUnitConf): 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') @@ -942,7 +952,7 @@ class Project(Process): print('*' * 19) print(' ') self.id = str(id) - self.description = description + self.description = description self.email = email self.alarm = alarm if name: @@ -977,7 +987,7 @@ class Project(Process): 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): @@ -994,7 +1004,7 @@ class Project(Process): idProcUnit = self.__getNewId() procUnitConfObj = ProcUnitConf() - input_proc = self.procUnitConfObjDict[inputId] + input_proc = self.procUnitConfObjDict[inputId] procUnitConfObj.setup(self.id, idProcUnit, name, datatype, inputId, self.err_queue, input_proc.lock) self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj @@ -1152,14 +1162,14 @@ class Project(Process): 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: @@ -1168,11 +1178,11 @@ class Project(Process): procs -=1 else: err_msg = msg - - if procs == 0 or 'Traceback' in err_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: @@ -1181,9 +1191,9 @@ class Project(Process): log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), name) else: log.error(err, name) - else: + else: name, err = self.name, err_msg - + time.sleep(2) for conf in self.procUnitConfObjDict.values(): @@ -1191,7 +1201,7 @@ class Project(Process): if confop.type == 'external': confop.opObj.terminate() conf.procUnitObj.terminate() - + ctx.term() message = ''.join(err) @@ -1217,7 +1227,7 @@ class Project(Process): subtitle += '[End time = %s]\n' % readUnitConfObj.endTime a = Alarm( - modes=self.alarm, + modes=self.alarm, email=self.email, message=message, subject=subject, @@ -1266,7 +1276,7 @@ class Project(Process): 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)) @@ -1282,9 +1292,9 @@ class Project(Process): def run(self): log.success('Starting {}: {}'.format(self.name, self.id), tag='') - self.start_time = time.time() - self.createObjects() - self.setProxy() + self.start_time = time.time() + self.createObjects() + self.setProxy() log.success('{} Done (Time: {}s)'.format( self.name, time.time()-self.start_time), '') diff --git a/schainpy/model/graphics/jroplot_voltage.py b/schainpy/model/graphics/jroplot_voltage.py index be5c0c1..2b2e922 100644 --- a/schainpy/model/graphics/jroplot_voltage.py +++ b/schainpy/model/graphics/jroplot_voltage.py @@ -177,9 +177,10 @@ class Scope_(Figure): channelIndexList.append(dataOut.channelList.index(channel)) thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0]) - ### print("***************** PLOTEO **************************") - ### print(dataOut.nProfiles) - ### print(dataOut.heightList.shape) + #print("***************** PLOTEO **************************") + #print(dataOut.nProfiles) + #print(dataOut.heightList.shape) + #print(dataOut.data.shape) if dataOut.flagDataAsBlock: for i in range(dataOut.nProfiles): diff --git a/schainpy/model/io/__init__.py b/schainpy/model/io/__init__.py index 4bb334f..2a62005 100644 --- a/schainpy/model/io/__init__.py +++ b/schainpy/model/io/__init__.py @@ -20,4 +20,6 @@ from .bltrIO_spectra import * 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 * diff --git a/schainpy/model/io/jroIO_base.py b/schainpy/model/io/jroIO_base.py index 6a7d23a..359b1ea 100644 --- a/schainpy/model/io/jroIO_base.py +++ b/schainpy/model/io/jroIO_base.py @@ -383,7 +383,7 @@ def isRadarFolder(folder): def isRadarFile(file): - try: + try: year = int(file[1:5]) doy = int(file[5:8]) set = int(file[8:11]) @@ -394,10 +394,10 @@ def isRadarFile(file): def getDateFromRadarFile(file): - try: + try: year = int(file[1:5]) doy = int(file[5:8]) - set = int(file[8:11]) + set = int(file[8:11]) except: return None @@ -416,7 +416,7 @@ def getDateFromRadarFolder(folder): return thisDate def parse_format(s, fmt): - + for i in range(fmt.count('%')): x = fmt.index('%') d = DT_DIRECTIVES[fmt[x:x+2]] @@ -483,7 +483,7 @@ class Reader(object): def run(self): - raise NotImplementedError + raise NotImplementedError def getAllowedArgs(self): if hasattr(self, '__attrs__'): @@ -495,19 +495,19 @@ class Reader(object): 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(',') + 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() + 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: @@ -516,38 +516,38 @@ class Reader(object): log.log('Skiping folder {}'.format(folder), self.name) continue return - - def find_files(self, folders, ext, filefmt, startDate=None, endDate=None, + + def find_files(self, folders, ext, filefmt, startDate=None, endDate=None, expLabel='', last=False): - - for path in folders: + + for path in folders: files = glob.glob1(path, '*{}'.format(ext)) files.sort() if last: - if files: + 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: + 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() + 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 + continue def searchFilesOffLine(self, path, startDate, endDate, - expLabel, ext, walk, + expLabel, ext, walk, filefmt, folderfmt): """Search files in offline mode for the given arguments @@ -560,12 +560,12 @@ class Reader(object): path, startDate, endDate, folderfmt) else: folders = path.split(',') - + return self.find_files( - folders, ext, filefmt, startDate, endDate, expLabel) + folders, ext, filefmt, startDate, endDate, expLabel) def searchFilesOnLine(self, path, startDate, endDate, - expLabel, ext, walk, + expLabel, ext, walk, filefmt, folderfmt): """Search for the last file of the last folder @@ -578,13 +578,13 @@ class Reader(object): 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) @@ -593,13 +593,13 @@ class Reader(object): while True: if self.fp != None: - self.fp.close() + 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') @@ -608,10 +608,10 @@ class Reader(object): 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() @@ -624,7 +624,7 @@ class Reader(object): self.filename self.fp self.filesize - + Return: boolean @@ -632,7 +632,7 @@ class Reader(object): nextFile = True nextDay = False - for nFiles in range(self.nFiles+1): + for nFiles in range(self.nFiles+1): for nTries in range(self.nTries): fullfilename, filename = self.checkForRealPath(nextFile, nextDay) if fullfilename is not None: @@ -642,18 +642,18 @@ class Reader(object): self.name) time.sleep(self.delay) nextFile = False - continue - + continue + if fullfilename is not None: break - + self.nTries = 1 - nextFile = True + nextFile = True if nFiles == (self.nFiles - 1): log.log('Trying with next day...', self.name) nextDay = True - self.nTries = 3 + self.nTries = 3 if fullfilename: self.fileSize = os.path.getsize(fullfilename) @@ -665,18 +665,18 @@ class Reader(object): self.flagNoMoreFiles = 0 self.fileIndex += 1 return 1 - else: + 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 + return 0 self.filename = filename self.fileSize = os.path.getsize(filename) @@ -684,22 +684,22 @@ class Reader(object): 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 """ @@ -710,7 +710,7 @@ class Reader(object): """Check if the next file to be readed exists""" raise NotImplementedError - + def readFirstHeader(self): """Parse the file header""" @@ -753,8 +753,9 @@ class JRODataReader(Reader): Return: str -- fullpath of the file """ - - + + + if nextFile: self.set += 1 if nextDay: @@ -766,7 +767,7 @@ class JRODataReader(Reader): prefixFileList = ['d', 'D'] elif self.ext.lower() == ".pdata": # spectra prefixFileList = ['p', 'P'] - + # barrido por las combinaciones posibles for prefixDir in prefixDirList: thispath = self.path @@ -786,9 +787,9 @@ class JRODataReader(Reader): if os.path.exists(fullfilename): return fullfilename, filename - - return None, filename - + + return None, filename + def __waitNewBlock(self): """ Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma. @@ -857,9 +858,11 @@ class JRODataReader(Reader): def __setNewBlock(self): if self.fp == None: - return 0 - - if self.flagIsNewFile: + return 0 + + #print("DIME COMO ARRANCA",self.flagIsNewFile) + #print("DIME COMO VA",self.nReadBlocks) + if self.flagIsNewFile: self.lastUTTime = self.basicHeaderObj.utc return 1 @@ -872,12 +875,12 @@ class JRODataReader(Reader): 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 @@ -896,6 +899,7 @@ class JRODataReader(Reader): return 1 def readNextBlock(self): + #print("nReadBlocks",self.nReadBlocks) while True: self.__setNewBlock() @@ -917,6 +921,7 @@ class JRODataReader(Reader): print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks, self.processingHeaderObj.dataBlocksPerFile, self.dataOut.datatime.ctime())) + return 1 def readFirstHeader(self): @@ -965,7 +970,7 @@ class JRODataReader(Reader): print("[Reading] File %s can't be opened" % (filename)) return False - + if self.waitDataBlock(0): basicHeaderObj = BasicHeader(LOCALTIME) systemHeaderObj = SystemHeader() @@ -986,10 +991,10 @@ class JRODataReader(Reader): if not(processingHeaderObj.read(fp)): fp.close() - return False + return False if not self.online: - dt1 = basicHeaderObj.datatime + dt1 = basicHeaderObj.datatime fp.seek(self.fileSize-processingHeaderObj.blockSize-24) if not(basicHeaderObj.read(fp)): fp.close() @@ -997,10 +1002,10 @@ class JRODataReader(Reader): 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 + return False fp.close() - + return True def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False): @@ -1107,11 +1112,11 @@ class JRODataReader(Reader): 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 @@ -1133,44 +1138,51 @@ class JRODataReader(Reader): for nTries in range(self.nTries): fullpath = self.searchFilesOnLine(self.path, self.startDate, - self.endDate, self.expLabel, self.ext, self.walk, + 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.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)) + '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 + 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.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 / \ 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds + #print(self.profileIndex,self.dataOut.utctime) self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock @@ -1238,8 +1250,8 @@ class JRODataReader(Reader): """ Arguments: - path : - startDate : + path : + startDate : endDate : startTime : endTime : @@ -1308,7 +1320,7 @@ class JRODataWriter(Reader): dtype_width = get_dtype_width(dtype_index) return dtype_width - + def getProcessFlags(self): processFlags = 0 @@ -1346,9 +1358,9 @@ class JRODataWriter(Reader): self.basicHeaderObj.size = self.basicHeaderSize # bytes self.basicHeaderObj.version = self.versionFile - self.basicHeaderObj.dataBlock = self.nTotalBlocks + self.basicHeaderObj.dataBlock = self.nTotalBlocks utc = numpy.floor(self.dataOut.utctime) - milisecond = (self.dataOut.utctime - utc) * 1000.0 + milisecond = (self.dataOut.utctime - utc) * 1000.0 self.basicHeaderObj.utc = utc self.basicHeaderObj.miliSecond = milisecond self.basicHeaderObj.timeZone = self.dataOut.timeZone @@ -1435,7 +1447,7 @@ class JRODataWriter(Reader): return 1 - def setNextFile(self): + def setNewxtFile(self): """Determina el siguiente file que sera escrito Affected: @@ -1489,9 +1501,9 @@ class JRODataWriter(Reader): 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) + self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext) filename = os.path.join(path, subfolder, filen) @@ -1539,11 +1551,11 @@ class JRODataWriter(Reader): self.ext = ext.lower() self.path = path - + if set is None: self.setFile = -1 else: - self.setFile = set - 1 + self.setFile = set - 1 self.blocksPerFile = blocksPerFile self.profilesPerBlock = profilesPerBlock diff --git a/schainpy/model/io/jroIO_simulator.py b/schainpy/model/io/jroIO_simulator.py new file mode 100644 index 0000000..ac2f454 --- /dev/null +++ b/schainpy/model/io/jroIO_simulator.py @@ -0,0 +1,485 @@ +import numpy,math,random,time +import zmq +import tempfile +from io import StringIO +########## 1 Heredamos JRODatareader +from schainpy.model.io.jroIO_base import * +########## 2 Heredamos las propiedades de ProcessingUnit +from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator +########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader +from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader +########## 4 Importaremos el objeto Voltge +from schainpy.model.data.jrodata import Voltage + +@MPDecorator +class SimulatorReader(JRODataReader, ProcessingUnit): + incIntFactor = 1 + nFFTPoints = 0 + FixPP_IncInt = 1 + FixRCP_IPP = 1000 + FixPP_CohInt = 1 + Tau_0 = 250 + AcqH0_0 = 70 + H0 = AcqH0_0 + AcqDH_0 = 1.25 + DH0 = AcqDH_0 + Bauds = 32 + BaudWidth = None + FixRCP_TXA = 40 + FixRCP_TXB = 70 + fAngle = 2.0*math.pi*(1/16) + DC_level = 500 + stdev = 8 + Num_Codes = 2 + #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]) + #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]) + #Dyn_snCode = numpy.array([Num_Codes,Bauds]) + Dyn_snCode = None + Samples = 200 + channels = 5 + pulses = None + Reference = None + pulse_size = None + prof_gen = None + Fdoppler = 100 + Hdoppler = 36 + def __init__(self): + """ + Inicializador de la clases SimulatorReader para + generar datos de voltage simulados. + Input: + dataOut: Objeto de la clase Voltage. + Este Objeto sera utilizado apra almacenar + un perfil de datos cada vez qe se haga psiversho + un requerimiento (getData) + """ + ProcessingUnit.__init__(self) + print(" [ START ] init - Metodo Simulator Reader") + + self.isConfig = False + self.basicHeaderObj = BasicHeader(LOCALTIME) + self.systemHeaderObj = SystemHeader() + self.radarControllerHeaderObj = RadarControllerHeader() + self.processingHeaderObj = ProcessingHeader() + self.profileIndex = 2**32-1 + self.dataOut = Voltage() + #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]) + 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]) + #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]) + 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]) + #self.Dyn_snCode = numpy.array([code0,code1]) + self.Dyn_snCode = None + print(" [ END ] init - Metodo simulator Reader" ) + + + def __hasNotDataInBuffer(self): + + if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs: + if self.nReadBlocks>0: + tmp = self.dataOut.utctime + tmp_utc = int(self.dataOut.utctime) + tmp_milisecond = int((tmp-tmp_utc)*1000) + self.basicHeaderObj.utc = tmp_utc + self.basicHeaderObj.miliSecond= tmp_milisecond + return 1 + return 0 + + + def setNextFile(self): + """Set the next file to be readed open it and parse de file header""" + + if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile): + print('------------------- [Opening file] ------------------------------') + self.nReadBlocks = 0 + + def __setNewBlock(self): + + self.setNextFile() + if self.flagIsNewFile: + return 1 + + def readNextBlock(self): + while True: + self.__setNewBlock() + if not(self.readBlock()): + return 0 + self.getBasicHeader() + break + if self.verbose: + print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks, + self.processingHeaderObj.dataBlocksPerFile, + self.dataOut.datatime.ctime()) ) + 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() + #ADD NEW + 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 getBasicHeader(self): + + self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \ + 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds + + self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock + + self.dataOut.timeZone = self.basicHeaderObj.timeZone + + self.dataOut.dstFlag = self.basicHeaderObj.dstFlag + + self.dataOut.errorCount = self.basicHeaderObj.errorCount + + self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime + + self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs + + def reshapeData(self): + if self.nTxs==1: + return + + def readBlock(self): + + self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level, + stdev=self.stdev,Reference= self.Reference, + pulses = self.pulses,Num_Codes=self.Num_Codes, + pulse_size=self.pulse_size,prof_gen=self.profiles, + H0=self.H0,DH0=self.DH0) + + self.profileIndex = 0 + self.flagIsNewFile = 0 + self.flagIsNewBlock = 1 + self.nTotalBlocks += 1 + self.nReadBlocks += 1 + + return 1 + + + def getData(self): ### metodo propio de VoltageReader + + if self.flagNoMoreFiles: + self.dataOut.flagNodata = True + self.flagDiscontinuousBlock = 0 + self.flagIsNewBlock = 0 + if self.__hasNotDataInBuffer(): # aqui es verdad + if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header + return 0 + self.getFirstHeader() # atributo + self.reshapeData() # nTxx1 =1 return , n + + if not self.getByBlock: + self.dataOut.flagDataAsBlock = False + self.dataOut.data = self.datablock[:, self.profileIndex, :] + self.dataOut.profileIndex = self.profileIndex + self.profileIndex += 1 + else: + pass + self.dataOut.flagNoData = False + self.getBasicHeader() + self.dataOut.realtime = self.online + return self.dataOut.data + + def set_kwargs(self, **kwargs): + for key, value in kwargs.items(): + setattr(self, key, value) + + def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0, + nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None, + numTaus=0, line6Function=0, line5Function=0, fClock=None, + prePulseBefore=0, prePulseAfter=0, + codeType=0, nCode=0, nBaud=0, code=None, + flip1=0, flip2=0): + + self.radarControllerHeaderObj.expType = expType + self.radarControllerHeaderObj.nTx = nTx + self.radarControllerHeaderObj.ipp = float(ipp) + self.radarControllerHeaderObj.txA = float(txA) + self.radarControllerHeaderObj.txB = float(txB) + self.radarControllerHeaderObj.rangeIPP = ipp + self.radarControllerHeaderObj.rangeTxA = txA + self.radarControllerHeaderObj.rangeTxB = txB + + self.radarControllerHeaderObj.nHeights = int(nHeights) + self.radarControllerHeaderObj.firstHeight = numpy.array([firstHeight]) + self.radarControllerHeaderObj.deltaHeight = numpy.array([deltaHeight]) + self.radarControllerHeaderObj.samplesWin = numpy.array([nHeights]) + + + self.radarControllerHeaderObj.nWindows = nWindows + self.radarControllerHeaderObj.numTaus = numTaus + self.radarControllerHeaderObj.codeType = codeType + self.radarControllerHeaderObj.line6Function = line6Function + self.radarControllerHeaderObj.line5Function = line5Function + self.radarControllerHeaderObj.fclock = fClock + self.radarControllerHeaderObj.prePulseBefore= prePulseBefore + self.radarControllerHeaderObj.prePulseAfter = prePulseAfter + + self.radarControllerHeaderObj.nCode = nCode + self.radarControllerHeaderObj.nBaud = nBaud + self.radarControllerHeaderObj.code = code + self.radarControllerHeaderObj.flip1 = flip1 + self.radarControllerHeaderObj.flip2 = flip2 + + self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4 + + if fClock is None and deltaHeight is not None: + self.fClock = 0.15 / (deltaHeight * 1e-6) + + def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0, + dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0, + nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, + deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0, + code=0, nBaud=None, shif_fft=False, flag_dc=False, + flag_cspc=False, flag_decode=False, flag_deflip=False): + + self.processingHeaderObj.profilesPerBlock = profilesPerBlock + self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile + self.processingHeaderObj.nWindows = nWindows + self.processingHeaderObj.nCohInt = nCohInt + self.processingHeaderObj.nIncohInt = nIncohInt + self.processingHeaderObj.totalSpectra = totalSpectra + self.processingHeaderObj.nHeights = int(nHeights) + self.processingHeaderObj.firstHeight = firstHeight + self.processingHeaderObj.deltaHeight = deltaHeight + self.processingHeaderObj.samplesWin = nHeights + + def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0): + self.basicHeaderObj.utc = utc + self.basicHeaderObj.miliSecond = miliSecond + self.basicHeaderObj.timeZone = timeZone + + def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0): + self.systemHeaderObj.nSamples = nSamples + self.systemHeaderObj.nProfiles = nProfiles + self.systemHeaderObj.nChannels = nChannels + self.systemHeaderObj.adcResolution = adcResolution + self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth + + def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000, + FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32, + FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 500, + stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,channels=1,Fdoppler=20,Hdoppler=36, + **kwargs): + + self.set_kwargs(**kwargs) + self.nReadBlocks = 0 + tmp = time.time() + tmp_utc = int(tmp) + tmp_milisecond = int((tmp-tmp_utc)*1000) + print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp)) + if Dyn_snCode is None: + Num_Codes=1 + Bauds =1 + + + + self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 ) + + self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB, + nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0, + numTaus=1, line6Function=0, line5Function=0, fClock=None, + prePulseBefore=0, prePulseAfter=0, + codeType=14, nCode=Num_Codes, nBaud=32, code=Dyn_snCode, + flip1=0, flip2=0) + + self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300, + dataBlocksPerFile=120, nWindows=1, processFlags=0, nCohInt=1, + nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0, + deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0, + code=0, nBaud=None, shif_fft=False, flag_dc=False, + flag_cspc=False, flag_decode=False, flag_deflip=False) + + self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels) + + self.incIntFactor = incIntFactor + self.nFFTPoints = nFFTPoints + self.FixPP_IncInt = FixPP_IncInt + self.FixRCP_IPP = FixRCP_IPP + self.FixPP_CohInt = FixPP_CohInt + self.Tau_0 = Tau_0 + self.AcqH0_0 = AcqH0_0 + self.H0 = AcqH0_0 + self.AcqDH_0 = AcqDH_0 + self.DH0 = AcqDH_0 + self.Bauds = Bauds + self.FixRCP_TXA = FixRCP_TXA + self.FixRCP_TXB = FixRCP_TXB + self.fAngle = fAngle + self.DC_level = DC_level + self.stdev = stdev + self.Num_Codes = Num_Codes + self.Dyn_snCode = Dyn_snCode + self.samples = samples + self.channels = channels + self.profiles = None + self.m_nReference = None + self.Baudwidth = None + self.Fdoppler = Fdoppler + self.Hdoppler = Hdoppler + + print("IPP ", self.FixRCP_IPP) + print("Tau_0 ",self.Tau_0) + print("AcqH0_0",self.AcqH0_0) + print("samples,window ",self.samples) + print("AcqDH_0",AcqDH_0) + print("FixRCP_TXA",self.FixRCP_TXA) + print("FixRCP_TXB",self.FixRCP_TXB) + print("Dyn_snCode",Dyn_snCode) + print("Fdoppler", Fdoppler) + print("Hdoppler",Hdoppler) + + self.init_acquisition() + self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode) + print(" [ END ] - SETUP metodo") + return + + def run(self,**kwargs): # metodo propio + if not(self.isConfig): + self.setup(**kwargs) + self.isConfig = True + self.getData() + +################################################################## +###### Aqui ingresamos las clases y metodos propios del simulador +################################################################## + +############################################# +############## INIT_ACQUISITION############## +############################################# + def init_acquisition(self): + + if self.nFFTPoints != 0: + self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints + if (self.FixPP_IncInt > self.incIntFactor): + self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor + elif(self.FixPP_IncInt< self.incIntFactor): + print("False alert...") + + ProfilesperBlock = self.processingHeaderObj.profilesPerBlock + + self.timeperblock =int(((self.FixRCP_IPP + *ProfilesperBlock + *self.FixPP_CohInt + *self.incIntFactor) + /150.0) + *0.9 + +0.5) + # para cada canal + self.profiles = ProfilesperBlock*self.FixPP_CohInt + self.profiles = ProfilesperBlock + self.Reference = int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5) + self.BaudWidth = int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 ) + + if (self.BaudWidth==0): + self.BaudWidth=1 +################################################################# +####################### init_pulse ############################## +################################################################ + + def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode): + + Num_Codes = Num_Codes + Bauds = Bauds + BaudWidth = BaudWidth + Dyn_snCode = Dyn_snCode + + if Dyn_snCode: + print("EXISTE") + else: + print("No existe") + + if Dyn_snCode: # if Bauds: + pulses = list(range(0,Num_Codes)) + num_codes = Num_Codes + for i in range(num_codes): + pulse_size = Bauds*BaudWidth + pulses[i] = numpy.zeros(pulse_size) + for j in range(Bauds): + for k in range(BaudWidth): + pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600) + else: + print("sin code") + pulses = list(range(1)) + pulse_size = int(self.FixRCP_TXB/0.15+0.5) + pulses[0] = numpy.ones(pulse_size) + pulses = 600*pulses[0] + + return pulses,pulse_size + +################################################################# +##################### Generate block data +################################################################ + + def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev, + Reference= Reference,pulses= pulses, + Num_Codes= Num_Codes,pulse_size=pulse_size, + prof_gen= prof_gen,H0 = H0,DH0=DH0,Fdoppler= Fdoppler,Hdoppler=Hdoppler): + Samples = Samples + DC_level = DC_level + stdev = stdev + m_nR = Reference + pulses = pulses + num_codes = Num_Codes + ps = pulse_size + prof_gen = prof_gen + channels = self.channels + H0 = H0 + DH0 = DH0 + ippSec = self.radarControllerHeaderObj.ippSeconds + Fdoppler = self.Fdoppler + Hdoppler = self.Hdoppler + + self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64) + for i in range(channels): + for k in range(prof_gen): + #·······················NOISE··············· + Noise_r = numpy.random.normal(DC_level,stdev,Samples) + Noise_i = numpy.random.normal(DC_level,stdev,Samples) + Noise = numpy.zeros(Samples,dtype=complex) + Noise.real = Noise_r + Noise.imag = Noise_i + #·······················PULSOS·············· + Pulso = numpy.zeros(pulse_size,dtype=complex) + Pulso.real = pulses[k%num_codes] + Pulso.imag = pulses[k%num_codes] + #····················· PULSES+NOISE·········· + InBuffer = numpy.zeros(Samples,dtype=complex) + InBuffer[m_nR:m_nR+ps] = Pulso + InBuffer = Noise+ InBuffer + #····················· ANGLE ······························· + + + + + InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5) + InBuffer=InBuffer + self.datablock[i][k]= InBuffer + #plot_cts(InBuffer,H0=H0,DH0=DH0 + + + #wave_fft(x=InBuffer,plot_show=True) + #time.sleep(1) + #················DOPPLER SIGNAL............................................... + time_vec = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen + fd = Fdoppler #+(600.0/120)*self.nReadBlocks + d_signal = 650*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64) + #·················· DATABLOCK + DOPPLER············........................... + HD=int(Hdoppler/self.AcqDH_0) + self.datablock[0,:,HD]=self.datablock[0,:,HD]+ d_signal # RESULT + ''' + a= numpy.zeros(10) + for i in range(10): + a[i]=i+self.nReadBlocks+20 + for i in a: + self.datablock[0,:,int(i)]=self.datablock[0,:,int(i)]+ d_signal # RESULT + ''' diff --git a/schainpy/model/io/jroIO_simulator.py~ b/schainpy/model/io/jroIO_simulator.py~ new file mode 100644 index 0000000..c3aa23f --- /dev/null +++ b/schainpy/model/io/jroIO_simulator.py~ @@ -0,0 +1,336 @@ +import numpy,math +import zmq +import tempfile +from io import StringIO +########## 1 Heredamos JRODatareader +from schainpy.model.io.jroIO_base import * +########## 2 Heredamos las propiedades de ProcessingUnit +from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator +########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader +from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader +########## 4 Importaremos el objeto Voltge +from schainpy.model.data.jrodata import Voltage + +@MPDecorator +class SimulatorReader(JRODataReader, ProcessingUnit): + incIntFactor = 1 + nFFTPoints = 0 + FixPP_IncInt = 1 + FixRCP_IPP = 1000 + FixPP_CohInt = 1 + Tau_0 = 250 + AcqH0_0 = 70 + H0 = AcqH0_0 + AcqDH_0 = 1.25 + DH0 = AcqDH_0 + Bauds = 32 + FixRCP_TXA = 40 + + fAngle = 2.0*math.pi*(1/16) + DC_level = 500 + stdev = 8 + Num_codes = 2 + 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]) + 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]) + Dyn_sncode = numpy.array([Num_codes,Bauds]) + samples = 200 + channels = 1 + + + def __init__(self): + """ + Inicializador de la clases SimulatorReader para + generar datos de voltage simulados. + Input: + dataOut: Objeto de la clase Voltage. + Este Objeto sera utilizado apra almacenar + un perfil de datos cada vez qe se haga psiversho + un requerimiento (getData) + """ + ProcessingUnit.__init__(self) + print(" [ START ] init - Metodo Simulator Reader") + self.isConfig = False + self.basicHeaderObj = BasicHeader(LOCALTIME) + self.systemHeaderObj = SystemHeader() + self.radarControlHeaderObj = RadarControllerHeader() + self.processingHeaderObj = ProcessingHeader() + self.profileIndex = 2**32-1 + self.dataOut = Voltage() + #self.server = "simulate" + print(" [ END ] init - Metodo simulator Reader" ) + + + def __hasNotDataInBuffer(self): + if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs: + return 1 + return 0 + + def __setNewBlock(self): + if self.flagIsNewFile: + #self.lastUTTime = self.basicHeaderObj.utc + return 1 + + def readNextBlock(self): + while True: + self.__setNewBlock() + print (" [ START ] readNexBlock") + if not(self.readBlock()): + return 0 + self.getBasicHeader() + break + if self.verbose: + print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlock, + self.processingHeaderObj.dataBlocksPerfile, + self.dataOut.datatime.ctime()) ) + 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() + + def getBasicHeader(self): + self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \ + 1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds + + self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock + + self.dataOut.timeZone = self.basicHeaderObj.timeZone + + self.dataOut.dstFlag = self.basicHeaderObj.dstFlag + + self.dataOut.errorCount = self.basicHeaderObj.errorCount + + self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime + + self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs + + def reshapeData(self): + if self.nTxs==1: + return + + def readBlock(self): + self.init_acquisition() + pulses, num_codes, pulse_size = self.init_pulse() + self.jro_GenerateBlockOfData() + self.profileIndex = 0 + + self.flagIsNewFile = 0 + self.flagIsNewBlock = 1 + + self.nTotalBlocks += 1 + self.nReadBlocks += 1 + + return 1 + + + def getData(self): ### metodo propio de VoltageReader + + if self.flagNoMoreFiles: + self.dataOut.flagNodata= True + self.flagDiscontinuousBlock=0 + self.flagIsNewBlock = 0 + if self.__hasNotDataInBuffer(): # aqui es verdad + if not(self.readNextBlock()): # return 1 y por eso el if not salta a getBasic Header + return 0 + self.getFirstHeader() # atributo + self.reshapeData() # nTxx1 =1 return , n + + if not self.getByBlock: + self.dataOut.flagDataAsBlock = False + self.dataOut.data = self.datablock[:, self.profileIndex, :] + self.dataOut.profileIndex = self.profileIndex + + self.profileIndex += 1 + else: + pass + self.getBasicHeader() + self.dataOut.realtime = self.searchFilesOnline + + return self.dataOut.data + + + def set_kwargs(self, **kwargs): + + for key, value in kwargs.items(): + print(" set_kwargs ",key,value) + setattr(self, key, value) + + + def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=100, + FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32, + FixRCP_TXA = 40, fAngle = 2.0*math.pi*(1/16),DC_level= 500, stdev= 8, + Num_codes = None , Dyn_snCode = None, samples=200,channels=1, + **kwargs): + print(" [ START ] - SETUP metodo") + self.set_kwargs(**kwargs) + self.processingHeaderObj.profilesPerBlock = 100 + self.incIntFactor = incIntFactor + self.nFFTPoints = nFFTPoints + self.FixPP_IncInt = FixPP_IncInt + self.FixRCP_IPP = FixRCP_IPP + self.FixPP_CohInt = FixPP_CohInt + self.Tau_0 = Tau_0 + self.AcqH0_0 = AcqH0_0 + self.H0 = AcqH0_0 + self.AcqDH_0 = AcqDH_0 + self.DH0 = AcqDH_0 + self.Bauds = Bauds + self.FixRCP_TXA = FixRCP_TXA + + self.fAngle = fAngle + self.DC_level = DC_level + self.stdev = stdev + self.Num_codes = Num_codes + #self.code0 = code0 + #self.code1 = code1 + self.Dyn_snCode = Dyn_snCode + self.samples = samples + self.channels = channels + + print(" [ END ] - SETUP metodo") + return + + def run(self,**kwargs): # metodo propio + + print(" [ START ] Metodo RUN: ", self.server) + if not(self.isConfig): + self.setup(**kwargs) + self.isConfig = True + import time + time.sleep(3) + #if self.server is None: + self.getData() + #else: + # self.getFromServer() +################################################################## +###### Aqui ingresamos las clases y metodos propios del simulador +################################################################## + +############################################# +############## INIT_ACQUISITION############## +############################################# + def init_acquisition(self): + + if self.nFFTPoints != 0: + self.incIntfactor = m_nProfilesperBlock/self.nFFTPoints + if (self.FixPP_IncInt > self.incIntfactor): + self.incIntfactor = self.FixPP_IncInt/ self.incIntfactor + elif(self.FixPP_IncInt< self.incIntfactor): + print("False alert...") + + ProfilesperBLock = self.processingHeaderObj.profilesPerBlock + + self.timeperblock =int(((self.FixRCP_m_fIPP + *m_nProfilesperBlock + *self.FixPP_CohInt + *self.incIntfactor) + /150.0) + *0.9 + +0.5) + # para cada canal + prof_gen = m_nProfilesperBlock*FixPP_m_n_CoherentIntegrations + prof_gen = m_nProfilesperBlock + + + m_nReference = int((Dyn_sfTau_0-Dyn_sfAcqH0_0)/(Dyn_sfAcqDH_0)+0.5) + print(m_nReference) + BaudWidth = int((FixRCP_m_fTXA/Dyn_sfAcqDH_0)/m_nBauds + 0.5 ) + print(BaudWidth) + if (BaudWidth==0): + BaudWidth=1 + + +################################################################# +##################### init_pulse +################################################################ + + def init_pulse(m_nNum_Codes,m_nBauds,BaudWidth,Dyn_snCode): + fAngle = 2.0*math.pi*(1/16) + DC_level = 500 + stdev = 8 + m_nNum_Codes= m_nNum_Codes + m_nBauds = m_nBauds + BaudWidth = BaudWidth + Dyn_snCode = Dyn_snCode + + if m_nBauds: + pulses = list(range(0,m_nNum_Codes)) + num_codes = m_nNum_Codes + for i in range(num_codes): + pulse_size = m_nBauds*BaudWidth + pulses[i] = numpy.zeros(pulse_size) + for j in range(m_nBauds): + for k in range(BaudWidth): + pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600) + else: + pulses = list(range(1)) + pulse_size = int(FixRCP_m_fTXB/0.15+0.5) + pulses[0] = numpy.ones(pulse_size) + pulses = 600*pulses[0] + return pulses,num_codes,pulse_size + +################################################################# +##################### Generate block data +################################################################ +# m_nChannels +# prof_gen +# fAngle = 2.0*math.pi*(1/16) +# DC_level = 500 +# stdev +# num_codes +#fAngle = 2.0*math.pi*(1/16) +#num_codes = 8 + + + def jro_GenerateBlockOfData(m_nSamples,DC_level,stdev,m_nReference,pulses,num_codes,pulse_size,prof_gen,H0,DH0): + m_nSamples = m_nSamples + DC_level = DC_level + stdev = stdev + m_nR = m_nReference + pulses = pulses + num_codes = num_codes + ps = pulse_size + prof_gen = prof_gen + H0 = H0 + DH0 = DH0 + fAngle = 2.0*math.pi*(1/16) + + # NOISE + Seed_r=random.seed(2) + Noise_r = numpy.random.normal(DC_level,stdev,m_nSamples) + Seed_i=random.seed(3) + Noise_i = numpy.random.normal(DC_level,stdev,m_nSamples) + Noise = numpy.zeros(m_nSamples,dtype=complex) + Noise.real = Noise_r + Noise.imag = Noise_i + Pulso = numpy.zeros(pulse_size,dtype=complex) + + #DOPPLER + x = m_nSamples + time_space = (DH0*numpy.linspace(0, x-1,num=x) +H0) + time_vec = time_space*(1.0e-3/150.0) + fd = 10 + d_signal = numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64) + + + + for i in range(m_nChannels): + for k in range(prof_gen): + Pulso.real = pulses[k%num_codes] + Pulso.imag = pulses[k%num_codes] + InBuffer = numpy.zeros(m_nSamples,dtype=complex) + InBuffer[m_nR:m_nR+ps] = Pulso + InBuffer = Noise+ InBuffer + InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( fAngle)*5) + InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( fAngle)*5) + InBuffer=InBuffer + #print(InBuffer[:10]) + #print(InBuffer.shape) + plot_cts(InBuffer,H0=H0,DH0=DH0) + #wave_fft(x=InBuffer,plot_show=True) + #time.sleep(1) + diff --git a/schainpy/model/io/jroIO_voltage.py b/schainpy/model/io/jroIO_voltage.py index 86f857e..d799b75 100644 --- a/schainpy/model/io/jroIO_voltage.py +++ b/schainpy/model/io/jroIO_voltage.py @@ -65,7 +65,7 @@ class VoltageReader(JRODataReader, ProcessingUnit): 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. @@ -285,7 +285,7 @@ class VoltageReader(JRODataReader, ProcessingUnit): 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 @@ -677,4 +677,4 @@ class VoltageWriter(JRODataWriter, Operation): self.processingHeaderObj.processFlags = self.getProcessFlags() self.setBasicHeader() - \ No newline at end of file + diff --git a/schainpy/model/proc/jroproc_base.py b/schainpy/model/proc/jroproc_base.py index 75e7ffe..439d4fc 100644 --- a/schainpy/model/proc/jroproc_base.py +++ b/schainpy/model/proc/jroproc_base.py @@ -304,7 +304,6 @@ def MPDecorator(BaseClass): Run fuction for read units ''' while True: - try: BaseClass.run(self, **self.kwargs) except: