jroIO_dat.py
683 lines
| 24.3 KiB
| text/x-python
|
PythonLexer
| r1377 | ''' | |||
| Created on Jun 9, 2020 | ||||
| @author: Roberto Flores | ||||
| ''' | ||||
| import os | ||||
| import sys | ||||
| import time | ||||
| import struct | ||||
| import datetime | ||||
| import numpy | ||||
| import schainpy.admin | ||||
| from schainpy.model.io.jroIO_base import LOCALTIME, Reader | ||||
| from schainpy.model.data.jroheaderIO import BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader | ||||
| from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator | ||||
| from schainpy.model.data.jrodata import Voltage, Parameters | ||||
| from schainpy.utils import log | ||||
| class DatReader(Reader, ProcessingUnit): | ||||
| def __init__(self): | ||||
| ProcessingUnit.__init__(self) | ||||
| self.basicHeaderObj = BasicHeader(LOCALTIME) | ||||
| self.systemHeaderObj = SystemHeader() | ||||
| self.radarControllerHeaderObj = RadarControllerHeader() | ||||
| self.processingHeaderObj = ProcessingHeader() | ||||
| self.dataOut = Parameters() | ||||
| #print(self.basicHeaderObj.timezone) | ||||
| #self.counter_block=0 | ||||
| self.format='dat' | ||||
| self.flagNoMoreFiles = 0 | ||||
| self.filename = None | ||||
| self.intervals = set() | ||||
| #self.datatime = datetime.datetime(1900,1,1) | ||||
| self.filefmt = "***%Y%m%d*******" | ||||
| self.padding=numpy.zeros(1,'int32') | ||||
| self.hsize=numpy.zeros(1,'int32') | ||||
| self.bufsize=numpy.zeros(1,'int32') | ||||
| self.nr=numpy.zeros(1,'int32') | ||||
| self.ngates=numpy.zeros(1,'int32') ### ### ### 2 | ||||
| self.time1=numpy.zeros(1,'uint64') # pos 3 | ||||
| self.time2=numpy.zeros(1,'uint64') # pos 4 | ||||
| self.lcounter=numpy.zeros(1,'int32') | ||||
| self.groups=numpy.zeros(1,'int32') | ||||
| self.system=numpy.zeros(4,'int8') # pos 7 | ||||
| self.h0=numpy.zeros(1,'float32') | ||||
| self.dh=numpy.zeros(1,'float32') | ||||
| self.ipp=numpy.zeros(1,'float32') | ||||
| self.process=numpy.zeros(1,'int32') | ||||
| self.tx=numpy.zeros(1,'int32') | ||||
| self.ngates1=numpy.zeros(1,'int32') ### ### ### 13 | ||||
| self.time0=numpy.zeros(1,'uint64') # pos 14 | ||||
| self.nlags=numpy.zeros(1,'int32') | ||||
| self.nlags1=numpy.zeros(1,'int32') | ||||
| self.txb=numpy.zeros(1,'float32') ### ### ### 17 | ||||
| self.time3=numpy.zeros(1,'uint64') # pos 18 | ||||
| self.time4=numpy.zeros(1,'uint64') # pos 19 | ||||
| self.h0_=numpy.zeros(1,'float32') | ||||
| self.dh_=numpy.zeros(1,'float32') | ||||
| self.ipp_=numpy.zeros(1,'float32') | ||||
| self.txa_=numpy.zeros(1,'float32') | ||||
| self.pad=numpy.zeros(100,'int32') | ||||
| self.nbytes=numpy.zeros(1,'int32') | ||||
| self.limits=numpy.zeros(1,'int32') | ||||
| self.ngroups=numpy.zeros(1,'int32') ### ### ### 27 | ||||
| #Make the header list | ||||
| #header=[hsize,bufsize,nr,ngates,time1,time2,lcounter,groups,system,h0,dh,ipp,process,tx,padding,ngates1,time0,nlags,nlags1,padding,txb,time3,time4,h0_,dh_,ipp_,txa_,pad,nbytes,limits,padding,ngroups] | ||||
| self.header=[self.hsize,self.bufsize,self.nr,self.ngates,self.time1,self.time2,self.lcounter,self.groups,self.system,self.h0,self.dh,self.ipp,self.process,self.tx,self.ngates1,self.padding,self.time0,self.nlags,self.nlags1,self.padding,self.txb,self.time3,self.time4,self.h0_,self.dh_,self.ipp_,self.txa_,self.pad,self.nbytes,self.limits,self.padding,self.ngroups] | ||||
| def setup(self, **kwargs): | ||||
| self.set_kwargs(**kwargs) | ||||
| if self.path is None: | ||||
| raise ValueError('The path is not valid') | ||||
| self.open_file = open | ||||
| self.open_mode = 'rb' | ||||
| if self.format is None: | ||||
| raise ValueError('The format is not valid') | ||||
| elif self.format.lower() in ('dat'): | ||||
| self.ext = '.dat' | ||||
| elif self.format.lower() in ('out'): | ||||
| self.ext = '.out' | ||||
| 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) | ||||
| #print(self.path) | ||||
| #print(self.filenameList) | ||||
| #input() | ||||
| self.setNextFile() | ||||
| def readFirstHeader(self): | ||||
| '''Read header and data''' | ||||
| #self.flag_same_file=1 | ||||
| self.counter_block=0 | ||||
| self.parseHeader() | ||||
| self.parseData() | ||||
| self.blockIndex = 0 | ||||
| return | ||||
| def parseHeader(self): | ||||
| ''' | ||||
| ''' | ||||
| for i in range(len(self.header)): | ||||
| for j in range(len(self.header[i])): | ||||
| #print("len(header[i]) ",len(header[i])) | ||||
| #input() | ||||
| temp=self.fp.read(int(self.header[i].itemsize)) | ||||
| if isinstance(self.header[i][0], numpy.int32): | ||||
| #print(struct.unpack('i', temp)[0]) | ||||
| self.header[i][0]=struct.unpack('i', temp)[0] | ||||
| if isinstance(self.header[i][0], numpy.uint64): | ||||
| self.header[i][0]=struct.unpack('q', temp)[0] | ||||
| if isinstance(self.header[i][0], numpy.int8): | ||||
| self.header[i][0]=struct.unpack('B', temp)[0] | ||||
| if isinstance(self.header[i][0], numpy.float32): | ||||
| self.header[i][0]=struct.unpack('f', temp)[0] | ||||
| self.fp.seek(0,0) | ||||
| if int(self.header[1][0])==int(81864): | ||||
| self.experiment='DP' | ||||
| elif int(self.header[1][0])==int(185504): | ||||
| self.experiment='HP' | ||||
| self.total_blocks=os.stat(self.filename).st_size//self.header[1][0] | ||||
| def parseData(self): | ||||
| ''' | ||||
| ''' | ||||
| if self.experiment=='DP': | ||||
| self.header[15][0]=66 | ||||
| self.header[18][0]=16 | ||||
| self.header[17][0]=11 | ||||
| self.header[2][0]=2 | ||||
| self.noise=numpy.zeros(self.header[2][0],'float32') #self.header[2][0] | ||||
| #tmpx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kax=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kay=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kbx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kax2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kay2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kbx2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kby2=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kaxbx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kaxby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kaybx=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kayby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kaxay=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.kbxby=numpy.zeros((self.header[15][0],self.header[17][0],2),'float32') | ||||
| self.output_LP_real=numpy.zeros((self.header[18][0],200,self.header[2][0]),'float32') | ||||
| self.output_LP_imag=numpy.zeros((self.header[18][0],200,self.header[2][0]),'float32') | ||||
| self.final_cross_products=[self.kax,self.kay,self.kbx,self.kby,self.kax2,self.kay2,self.kbx2,self.kby2,self.kaxbx,self.kaxby,self.kaybx,self.kayby,self.kaxay,self.kbxby] | ||||
| #self.final_cross_products=[tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx,tmpx] | ||||
| #print("pos: ",self.fp.tell()) | ||||
| def readNextBlock(self): | ||||
| while True: | ||||
| self.flagDiscontinuousBlock = 0 | ||||
| #print(os.stat(self.filename).st_size) | ||||
| #print(os.stat(self.filename).st_size//self.header[1][0]) | ||||
| #os.stat(self.fp) | ||||
| if self.counter_block == self.total_blocks: | ||||
| self.setNextFile() | ||||
| self.readBlock() | ||||
| #self.counter_block+=1 | ||||
| if (self.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or \ | ||||
| (self.datatime > datetime.datetime.combine(self.endDate, self.endTime)): | ||||
| #print(self.datatime) | ||||
| #print(datetime.datetime.combine(self.startDate, self.startTime)) | ||||
| #print(datetime.datetime.combine(self.endDate, self.endTime)) | ||||
| #print("warning") | ||||
| log.warning( | ||||
| 'Reading Block No. {}/{} -> {} [Skipping]'.format( | ||||
| self.counter_block, | ||||
| self.total_blocks, | ||||
| self.datatime.ctime()), | ||||
| 'DATReader') | ||||
| continue | ||||
| break | ||||
| log.log( | ||||
| 'Reading Block No. {}/{} -> {}'.format( | ||||
| self.counter_block, | ||||
| self.total_blocks, | ||||
| self.datatime.ctime()), | ||||
| 'DATReader') | ||||
| return 1 | ||||
| def readBlock(self): | ||||
| ''' | ||||
| ''' | ||||
| self.npos=self.counter_block*self.header[1][0] | ||||
| #print(self.counter_block) | ||||
| self.fp.seek(self.npos, 0) | ||||
| self.counter_block+=1 | ||||
| #print("fpos1: ",self.fp.tell()) | ||||
| self.read_header() | ||||
| #put by hand because old files didn't save it in the header | ||||
| if self.experiment=='DP': | ||||
| self.header[15][0]=66 | ||||
| self.header[18][0]=16 | ||||
| self.header[17][0]=11 | ||||
| self.header[2][0]=2 | ||||
| ######################################### | ||||
| if self.experiment=="HP": | ||||
| self.long_pulse_products() | ||||
| self.read_cross_products() | ||||
| self.read_noise() | ||||
| return | ||||
| def read_header(self): | ||||
| for i in range(len(self.header)): | ||||
| for j in range(len(self.header[i])): | ||||
| #print("len(header[i]) ",len(header[i])) | ||||
| #input() | ||||
| temp=self.fp.read(int(self.header[i].itemsize)) | ||||
| #if(b''==temp): | ||||
| # self.setNextFile() | ||||
| # self.flag_same_file=0 | ||||
| if isinstance(self.header[i][0], numpy.int32): | ||||
| #print(struct.unpack('i', temp)[0]) | ||||
| self.header[i][0]=struct.unpack('i', temp)[0] | ||||
| if isinstance(self.header[i][0], numpy.uint64): | ||||
| self.header[i][0]=struct.unpack('q', temp)[0] | ||||
| if isinstance(self.header[i][0], numpy.int8): | ||||
| self.header[i][0]=struct.unpack('B', temp)[0] | ||||
| if isinstance(self.header[i][0], numpy.float32): | ||||
| self.header[i][0]=struct.unpack('f', temp)[0] | ||||
| #else: | ||||
| # continue | ||||
| #self.fp.seek(self.npos_aux, 0) | ||||
| # break | ||||
| #print("fpos2: ",self.fp.tell()) | ||||
| #log.success('Parameters found: {}'.format(self.parameters), | ||||
| # 'DATReader') | ||||
| #print("Success") | ||||
| #self.TimeBlockSeconds_for_dp_power = self.header[4][0]#-((self.dataOut.nint-1)*self.dataOut.NAVG*2) | ||||
| #print(dataOut.TimeBlockSeconds_for_dp_power) | ||||
| #self.datatime=datetime.datetime.fromtimestamp(self.header[4][0]).strftime("%Y-%m-%d %H:%M:%S") | ||||
| #print(self.header[4][0]) | ||||
| self.datatime=datetime.datetime.fromtimestamp(self.header[4][0]) | ||||
| #print(self.header[1][0]) | ||||
| def long_pulse_products(self): | ||||
| temp=self.fp.read(self.header[18][0]*self.header[2][0]*200*8) | ||||
| ii=0 | ||||
| for l in range(self.header[18][0]): #lag | ||||
| for r in range(self.header[2][0]): # channels | ||||
| for k in range(200): #RANGE## generalizar | ||||
| self.output_LP_real[l,k,r]=struct.unpack('f', temp[ii:ii+4])[0] | ||||
| ii=ii+4 | ||||
| self.output_LP_imag[l,k,r]=struct.unpack('f', temp[ii:ii+4])[0] | ||||
| ii=ii+4 | ||||
| #print(self.output_LP_real[1,1,1]) | ||||
| #print(self.output_LP_imag[1,1,1]) | ||||
| def read_cross_products(self): | ||||
| for ind in range(len(self.final_cross_products)): #final cross products | ||||
| temp=self.fp.read(self.header[17][0]*2*self.header[15][0]*4) #*4 bytes | ||||
| #if(b''==temp): | ||||
| # self.setNextFile() | ||||
| # self.flag_same_file=0 | ||||
| ii=0 | ||||
| #print("kabxys.shape ",kabxys.shape) | ||||
| #print(kabxys) | ||||
| #print("fpos3: ",self.fp.tell()) | ||||
| for l in range(self.header[17][0]): #lag | ||||
| #print("fpos3: ",self.fp.tell()) | ||||
| for fl in range(2): # unflip and flip | ||||
| for k in range(self.header[15][0]): #RANGE | ||||
| #print("fpos3: ",self.fp.tell()) | ||||
| self.final_cross_products[ind][k,l,fl]=struct.unpack('f', temp[ii:ii+4])[0] | ||||
| ii=ii+4 | ||||
| #print("fpos2: ",self.fp.tell()) | ||||
| def read_noise(self): | ||||
| temp=self.fp.read(self.header[2][0]*4) #*4 bytes self.header[2][0] | ||||
| for ii in range(self.header[2][0]): #self.header[2][0] | ||||
| self.noise[ii]=struct.unpack('f', temp[ii*4:(ii+1)*4])[0] | ||||
| #print("fpos5: ",self.fp.tell()) | ||||
| def set_output(self): | ||||
| ''' | ||||
| Storing data from buffer to dataOut object | ||||
| ''' | ||||
| #print("fpos2: ",self.fp.tell()) | ||||
| ##self.dataOut.header = self.header | ||||
| #this is put by hand because it isn't saved in the header | ||||
| if self.experiment=='DP': | ||||
| self.dataOut.NRANGE=0 | ||||
| self.dataOut.NSCAN=132 | ||||
| self.dataOut.heightList=self.header[10][0]*(numpy.arange(self.header[15][0])) | ||||
| elif self.experiment=='HP': | ||||
| self.dataOut.output_LP=self.output_LP_real+1.j*self.output_LP_imag | ||||
| self.dataOut.NRANGE=200 | ||||
| self.dataOut.NSCAN=128 | ||||
| self.dataOut.heightList=self.header[10][0]*(numpy.arange(90)) #NEEEDS TO BE GENERALIZED | ||||
| ######################################### | ||||
| #print(self.dataOut.output_LP[1,1,1]) | ||||
| self.dataOut.MAXNRANGENDT=self.header[3][0] | ||||
| self.dataOut.NDP=self.header[15][0] | ||||
| self.dataOut.DPL=self.header[17][0] | ||||
| self.dataOut.DH=self.header[10][0] | ||||
| self.dataOut.NAVG=self.header[7][0] | ||||
| self.dataOut.H0=self.header[9][0] | ||||
| self.dataOut.NR=self.header[2][0] | ||||
| self.dataOut.NLAG=self.header[18][0] | ||||
| #self.dataOut.tmpx=self.tmpx | ||||
| #self.dataOut.timeZone = 5 | ||||
| #self.dataOut.final_cross_products=self.final_cross_products | ||||
| self.dataOut.kax=self.kax | ||||
| #print(self.dataOut.kax[1,1,1]) | ||||
| self.dataOut.kay=self.kay | ||||
| self.dataOut.kbx=self.kbx | ||||
| self.dataOut.kby=self.kby | ||||
| self.dataOut.kax2=self.kax2 | ||||
| self.dataOut.kay2=self.kay2 | ||||
| self.dataOut.kbx2=self.kbx2 | ||||
| self.dataOut.kby2=self.kby2 | ||||
| self.dataOut.kaxbx=self.kaxbx | ||||
| self.dataOut.kaxby=self.kaxby | ||||
| self.dataOut.kaybx=self.kaybx | ||||
| self.dataOut.kayby=self.kayby | ||||
| self.dataOut.kaxay=self.kaxay | ||||
| self.dataOut.kbxby=self.kbxby | ||||
| self.dataOut.noise_final=self.noise | ||||
| #print("NOISE",self.noise) | ||||
| self.dataOut.useLocalTime=True | ||||
| #self.dataOut.experiment=self.experiment | ||||
| #print(self.datatime) | ||||
| #print(self.dataOut.datatime) | ||||
| #self.dataOut.utctime = (self.datatime - datetime.datetime(1970, 1, 1)).total_seconds() | ||||
| #self.dataOut.utctimeInit = self.dataOut.utctime | ||||
| self.dataOut.lt=self.datatime.hour | ||||
| #print(RadarControllerHeader().ippSeconds) | ||||
| #print(RadarControllerHeader().ipp) | ||||
| #self.dataOut.utctime=time.gmtime(self.header[4][0])- datetime.datetime(1970, 1, 1) | ||||
| #self.dataOut.utctime=self.dataOut.utctime.total_seconds() | ||||
| #time1 = self.header[4][0] # header.time1 | ||||
| #print("time1: ",time1) | ||||
| #print(self.header[4][0]) | ||||
| #date = time.ctime(time1) | ||||
| #print("DADSADA",time.strptime(date)) | ||||
| #print("date_before: ",date) | ||||
| #bd_time=time.gmtime(time1) | ||||
| #print(time.mktime(bd_time)) | ||||
| #self.dataOut.utctime=time.mktime(bd_time) | ||||
| self.dataOut.utctime = self.header[4][0] | ||||
| #self.dataOut.datatime=a | ||||
| #print(datetime.datetime.utcfromtimestamp(self.dataOut.utctime)) | ||||
| #self.dataOut.TimeBlockDate=self.datatime.ctime() | ||||
| self.dataOut.TimeBlockSeconds=time.mktime(time.strptime(self.dataOut.datatime.ctime())) | ||||
| #self.dataOut.heightList = self.ranges | ||||
| #self.dataOut.utctime = (self.datatime - datetime.datetime(1970, 1, 1)).total_seconds() | ||||
| #self.dataOut.utctimeInit = self.dataOut.utctime | ||||
| #self.dataOut.paramInterval = min(self.intervals) | ||||
| #self.dataOut.useLocalTime = False | ||||
| self.dataOut.flagNoData = False | ||||
| self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock | ||||
| #print(self.dataOut.channelIndexList) | ||||
| self.dataOut.channelList=list(range(0,self.header[2][0])) | ||||
| #print(self.dataOut.channelList) | ||||
| #print(self.datatime) | ||||
| #print(self.dataOut.final_cross_products[0]) | ||||
| #self.dataOut.heightList=self.header[10][0]*(numpy.arange(self.header[15][0])) | ||||
| #print(numpy.shape(self.dataOut.heightList)) | ||||
| def getData(self): | ||||
| ''' | ||||
| Storing data from databuffer to dataOut object | ||||
| ''' | ||||
| if not self.readNextBlock(): | ||||
| self.dataOut.flagNoData = True | ||||
| return 0 | ||||
| self.set_output() | ||||
| return 1 | ||||
| def run(self, **kwargs): | ||||
| if not(self.isConfig): | ||||
| self.setup(**kwargs) | ||||
| self.isConfig = True | ||||
| #print("fpos1: ",self.fp.tell()) | ||||
| self.getData() | ||||
| return | ||||
| @MPDecorator | ||||
| class DatWriter(Operation): | ||||
| def __init__(self): | ||||
| Operation.__init__(self) | ||||
| #self.dataOut = Voltage() | ||||
| self.counter = 0 | ||||
| self.path = None | ||||
| self.fp = None | ||||
| return | ||||
| #self.ext= '.dat' | ||||
| def run(self, dataOut, path, format='dat', experiment=None, **kwargs): | ||||
| print(dataOut.flagNoData) | ||||
| print(dataOut.datatime.ctime()) | ||||
| print(dataOut.TimeBlockDate) | ||||
| input() | ||||
| #if dataOut.flag_save: | ||||
| self.experiment=experiment | ||||
| self.path=path | ||||
| if self.experiment=='DP': | ||||
| dataOut.header[1][0]=81864 | ||||
| elif self.experiment=='HP': | ||||
| dataOut.header[1][0]=185504#173216 | ||||
| #dataOut.header[1][0]=bufsize | ||||
| self.dataOut = dataOut | ||||
| #print(self.dataOut.nint) | ||||
| #self.bufsize=bufsize | ||||
| if format == 'dat': | ||||
| self.ext = '.dat' | ||||
| if format == 'out': | ||||
| self.ext = '.out' | ||||
| self.putData() | ||||
| return | ||||
| def setFile(self): | ||||
| ''' | ||||
| Create new out file object | ||||
| ''' | ||||
| #self.dataOut.TimeBlockSeconds=time.mktime(time.strptime(self.dataOut.TimeBlockDate)) | ||||
| date = datetime.datetime.fromtimestamp(self.dataOut.TimeBlockSeconds) | ||||
| #print("date",date) | ||||
| filename = '{}{}{}'.format('jro', | ||||
| date.strftime('%Y%m%d_%H%M%S'), | ||||
| self.ext) | ||||
| #print(filename) | ||||
| #print(self.path) | ||||
| self.fullname = os.path.join(self.path, filename) | ||||
| if os.path.isfile(self.fullname) : | ||||
| log.warning( | ||||
| 'Destination file {} already exists, previous file deleted.'.format( | ||||
| self.fullname), | ||||
| 'DatWriter') | ||||
| os.remove(self.fullname) | ||||
| try: | ||||
| log.success( | ||||
| 'Creating file: {}'.format(self.fullname), | ||||
| 'DatWriter') | ||||
| if not os.path.exists(self.path): | ||||
| os.makedirs(self.path) | ||||
| #self.fp = madrigal.cedar.MadrigalCedarFile(self.fullname, True) | ||||
| self.fp = open(self.fullname,'wb') | ||||
| except ValueError as e: | ||||
| log.error( | ||||
| 'Impossible to create *.out file', | ||||
| 'DatWriter') | ||||
| return | ||||
| return 1 | ||||
| def writeBlock(self): | ||||
| #self.dataOut.paramInterval=2 | ||||
| #startTime = datetime.datetime.utcfromtimestamp(self.dataOut.utctime) | ||||
| #print(startTime) | ||||
| #endTime = startTime + datetime.timedelta(seconds=self.dataOut.paramInterval) | ||||
| self.dataOut.header[0].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[1].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[2].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[3].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[4].astype('uint64').tofile(self.fp) | ||||
| self.dataOut.header[5].astype('uint64').tofile(self.fp) | ||||
| self.dataOut.header[6].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[7].astype('int32').tofile(self.fp) | ||||
| #print(dataOut.header[7]) | ||||
| self.dataOut.header[8].astype('int8').tofile(self.fp) | ||||
| self.dataOut.header[9].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[10].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[11].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[12].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[13].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[14].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[15].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[16].astype('uint64').tofile(self.fp) | ||||
| self.dataOut.header[17].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[18].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[19].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[20].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[21].astype('uint64').tofile(self.fp) | ||||
| self.dataOut.header[22].astype('uint64').tofile(self.fp) | ||||
| self.dataOut.header[23].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[24].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[25].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[26].astype('float32').tofile(self.fp) | ||||
| self.dataOut.header[27].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[28].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[29].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[30].astype('int32').tofile(self.fp) | ||||
| self.dataOut.header[31].astype('int32').tofile(self.fp) | ||||
| #print("tell before 1 ",self.fp.tell()) | ||||
| #input() | ||||
| if self.experiment=="HP": | ||||
| #print("INSIDE") | ||||
| #tmp=numpy.zeros(1,dtype='complex64') | ||||
| #print("tmp ",tmp) | ||||
| #input() | ||||
| #print(dataOut.NLAG) | ||||
| #print(dataOut.NR) | ||||
| #print(dataOut.NRANGE) | ||||
| for l in range(self.dataOut.NLAG): #lag | ||||
| for r in range(self.dataOut.NR): # unflip and flip | ||||
| for k in range(self.dataOut.NRANGE): #RANGE | ||||
| self.dataOut.output_LP.real[l,k,r].astype('float32').tofile(self.fp) | ||||
| self.dataOut.output_LP.imag[l,k,r].astype('float32').tofile(self.fp) | ||||
| #print("tell before 2 ",self.outputfile.tell()) | ||||
| #print(self.dataOut.output_LP[1,1,1]) | ||||
| #print(self.dataOut.kax) | ||||
| final_cross_products=[self.dataOut.kax,self.dataOut.kay,self.dataOut.kbx,self.dataOut.kby, | ||||
| self.dataOut.kax2,self.dataOut.kay2,self.dataOut.kbx2,self.dataOut.kby2, | ||||
| self.dataOut.kaxbx,self.dataOut.kaxby,self.dataOut.kaybx,self.dataOut.kayby, | ||||
| self.dataOut.kaxay,self.dataOut.kbxby] | ||||
| #print(self.dataOut.kax) | ||||
| #print("tell before crossp saving ",self.outputfile.tell()) | ||||
| for kabxys in final_cross_products: | ||||
| for l in range(self.dataOut.DPL): #lag | ||||
| for fl in range(2): # unflip and flip | ||||
| for k in range(self.dataOut.NDT): #RANGE | ||||
| kabxys[k,l,fl].astype('float32').tofile(self.fp) | ||||
| #print("tell before noise saving ",self.outputfile.tell()) | ||||
| for nch in range(self.dataOut.NR): | ||||
| self.dataOut.noise_final[nch].astype('float32').tofile(self.fp) | ||||
| #print("tell before noise saving ",self.fp.tell()) | ||||
| #input() | ||||
| log.log( | ||||
| 'Writing {} blocks'.format( | ||||
| self.counter+1), | ||||
| 'DatWriter') | ||||
| def putData(self): | ||||
| #print("flagNoData",self.dataOut.flagNoData) | ||||
| #print("flagDiscontinuousBlock",self.dataOut.flagDiscontinuousBlock) | ||||
| #print(self.dataOut.flagNoData) | ||||
| if self.dataOut.flagNoData: | ||||
| return 0 | ||||
| if self.dataOut.flagDiscontinuousBlock: | ||||
| self.counter = 0 | ||||
| if self.counter == 0: | ||||
| self.setFile() | ||||
| #if self.experiment=="HP": | ||||
| #if self.dataOut.debris_activated==0: | ||||
| #self.writeBlock() | ||||
| #self.counter += 1 | ||||
| #else: | ||||
| self.writeBlock() | ||||
| self.counter += 1 | ||||
| def close(self): | ||||
| if self.counter > 0: | ||||
| self.fp.close() | ||||
| log.success('Closing file {}'.format(self.fullname), 'DatWriter') | ||||
