utils.py
791 lines
| 28.2 KiB
| text/x-python
|
PythonLexer
Fiorella Quino
|
r275 | ''' | |
| ''' | |||
| import json | |||
|
Fiorella Quino
|
r276 | import os | |
| import math | |||
|
Fiorella Quino
|
r275 | ||
| from apps.main.utils import Params | |||
| DECODE_TYPE = {'DECODING_TIME_DOMAIN': 1, 'DECODING_FREQ_DOMAIN': 2, 'DECODING_INV_FREQ_DOMAIN': 3} | |||
| def parse_range(s): | |||
| vars = ('TXA,', 'A,', 'TXB,', 'B,', 'TXA', 'TXB', 'A', 'B') | |||
| for var in vars: | |||
| if var in s: | |||
| s = s.replace(var, '') | |||
| if 'A' in var: | |||
| ref = 'TXA' | |||
| else: | |||
| ref = 'TXB' | |||
| return ref, s | |||
| return '0', s | |||
| class RacpFile(object): | |||
| ''' | |||
| Class to handle Radar controller configuration files | |||
| ''' | |||
| def __init__(self, f=None): | |||
| #print dir(f) | |||
| self.data = {} | |||
| self.lines = [] | |||
| self.line = '' | |||
| if isinstance(f, str): | |||
| self.f = open(f) | |||
| self.name = f.split('/')[-1] | |||
| elif hasattr(f, 'read'): | |||
| self.f = f | |||
| self.name = f.name.split('/')[-1] | |||
| else: | |||
| self.f = f | |||
| self.name = None | |||
| if self.f: | |||
| if 'racp' in self.name: | |||
| self.parse_racp() | |||
| elif 'dat' in self.name: | |||
| self.parse_dat() | |||
| elif 'json' in self.name: | |||
| self.data = json.load(self.f) | |||
| self.f.close() | |||
| def get_line_parameters(self, data, line): | |||
| line_params = {} | |||
| for label in data: | |||
| if 'L%d' % line in label or '(Line %d)' % line in label or 'Line%d' % line in label: | |||
| line_params[label] = data[label] | |||
| return line_params | |||
| def parse_racp(self): | |||
| data = {} | |||
| raw_data = [s.strip() for s in self.f.readlines()] | |||
| for line in raw_data: | |||
| if line and '=' in line: | |||
| label, value = line.strip().split('=') | |||
| data[label] = value | |||
| self.data['id'] = '1' | |||
| self.data['device_type'] = 'jars' | |||
| self.data['experiment_type'] = data['EXPERIMENT TYPE'] | |||
| self.data['header_version'] = data['HEADER VERSION'] | |||
| self.data['name'] = data['EXPERIMENT NAME'] | |||
| self.data['ipp'] = float(data['IPP']) | |||
| self.data['ntx'] = int(data['NTX']) | |||
| #----Jars parameters---- | |||
| self.data['cards_number'] = data['Number of Cards'] | |||
| self.data['channels_number'] = data['Number of Channels'] | |||
| channels = '' | |||
| for i in range(0,20): | |||
| try: | |||
| channels += data['Channel('+str(i)+')']+',' | |||
| except: | |||
| break | |||
| if channels: | |||
| channels = channels[:-1] | |||
| self.data['channels'] = channels | |||
| data_type = 0 | |||
| if data['DATATYPE'] == 'FLOAT': | |||
| data_type = 1 | |||
| self.data['data_type'] = data_type | |||
| self.data['profiles_block'] = data['PROFILES PER BLOCK'] | |||
| self.data['acq_profiles'] = data['ACQUIRED PROFILES'] | |||
| self.data['ftp_interval'] = data['FTP INTERVAL'] | |||
| self.data['cohe_integr_str'] = data['COHERENT INTEGRATION STRIDE'] | |||
| self.data['cohe_integr'] = 1 | |||
| if 'COHERENT INTEGRATIONS' in data: | |||
| if int(data['COHERENT INTEGRATIONS']) != 0: | |||
| self.data['cohe_integr'] = int(data['COHERENT INTEGRATIONS']) | |||
| self.data['exp_type'] = 0 | |||
| if data['EXPERIMENT TYPE'] != 'EXP_RAW_DATA': | |||
| self.data['exp_type'] = 1 | |||
| self.data['fftpoints'] = data['FFTPOINTS'] | |||
| self.data['incohe_integr'] = data['INCOHERENT INTEGRATIONS'] | |||
| self.data['spectral_number'] = data['TOTAL SPECTRAL COMBINATIONS'] | |||
| spectral = '' | |||
| for i in range(0,100): | |||
| try: | |||
| spectral += '['+data['SPEC_COMB('+str(i)+')']+'],' | |||
| except: | |||
| break | |||
| self.data['spectral'] = spectral | |||
| self.data['save_ch_dc'] = False | |||
| if 'SAVE CHANNELS DC' in data: | |||
| self.data['save_ch_dc'] = True | |||
| else: | |||
| self.data['raw_data_blocks'] = data['RAW DATA BLOCKS'] | |||
| self.data['decode_data'] = 0 | |||
| self.data['post_coh_int'] = False | |||
| if 'DECODE DATA' in data: | |||
| self.data['decode_data'] = DECODE_TYPE[data['DECODING TYPE']] | |||
| if 'POST COHERENT INTEGRATIONS' in data: | |||
| self.data['post_coh_int'] = True | |||
| self.data['create_directory'] = False | |||
| if data['CREATE DIRECTORY PER DAY'] == 'YES': | |||
| self.data['create_directory'] = True | |||
| self.data['include_expname'] = False | |||
| if data['INCLUDE EXPNAME IN DIRECTORY'] == 'YES': | |||
| self.data['include_expname'] = True | |||
| self.data['save_data'] = False | |||
| if data['SAVE DATA'] == 'YES': | |||
| self.data['save_data'] = True | |||
| #----Jars parameters---- | |||
| if 'CLOCK DIVIDER' in data: | |||
| self.data['clock_divider'] = int(data['CLOCK DIVIDER']) | |||
| else: | |||
| self.data['clock_divider'] = 1 | |||
| self.data['clock_in'] = float(data['RELOJ'])*self.data['clock_divider'] | |||
| self.data['clock'] = float(data['RELOJ']) | |||
| self.data['time_before'] = int(data['TR_BEFORE']) | |||
| self.data['time_after'] = int(data['TR_AFTER']) | |||
| if 'SYNCHRO DELAY' in data: | |||
| self.data['sync'] = int(data['SYNCHRO DELAY']) | |||
| else: | |||
| self.data['sync'] = 0 | |||
| self.data['lines'] = [] | |||
| if 'SAMPLING REFERENCE' in data: | |||
| if data['SAMPLING REFERENCE']=='MIDDLE OF FIRST BAUD': | |||
| self.data['sampling_reference'] = 'first_baud' | |||
| elif data['SAMPLING REFERENCE']=='MIDDLE OF FIRST SUB-BAUD': | |||
| self.data['sampling_reference'] = 'sub_baud' | |||
| else: | |||
| self.data['sampling_reference'] = 'none' | |||
| self.data['lines'].append('10') | |||
| #Add TX's lines | |||
| if 'TXA' in data: | |||
| line = {'line_type':'tx', 'id':'11', 'name':'TXA', | |||
| 'params':{'pulse_width':data['TXA'], 'delays':'0', 'range':'0'}} | |||
| if 'Pulse selection_TXA' in data: | |||
| line['params']['range'] = data['Pulse selection_TXA'] | |||
| self.data['lines'].append('11') | |||
| self.lines.append(line) | |||
| if 'TXB' in data: | |||
| line = {'line_type':'tx', 'id':'12', 'name':'TXB', | |||
| 'params':{'pulse_width':data['TXB'], 'delays':'0', 'range':'0'}} | |||
| if 'Pulse selection_TXB' in data: | |||
| line['params']['range'] = data['Pulse selection_TXB'] | |||
| if 'Number of Taus' in data: | |||
| delays = [data['TAU({0})'.format(i)] for i in range(int(data['Number of Taus']))] | |||
| line['params']['delays'] = ','.join(delays) | |||
| self.data['lines'].append('12') | |||
| self.lines.append(line) | |||
| #Add TR line | |||
| line = {'line_type':'tr', 'id':'10', 'name':'TR', | |||
| 'params':{'TX_ref':'0', 'range':'0'}} | |||
| if 'Pulse selection_TR' in data: | |||
| ref, rng = parse_range(data['Pulse selection_TR']) | |||
| line['params']['range'] = rng if rng else '0' | |||
| if ref=='TXA': | |||
| line['params']['TX_ref'] = '11' | |||
| elif ref=='TXB': | |||
| line['params']['TX_ref'] = '12' | |||
| self.lines.append(line) | |||
| #Add Other lines (4-6) | |||
| for n in range(4, 7): | |||
| id = '{:2d}'.format(10*n) | |||
| params = self.get_line_parameters(data, n) | |||
| labels = params.keys() | |||
| if 'L%d_FLIP' % n in labels: | |||
| line = {'line_type':'flip', 'id':id, | |||
| 'params':{'number_of_flips':data['L%d_FLIP' % n]}} | |||
| elif 'Code Type' in data and n==4: | |||
| line = {'line_type':'codes', 'id':id, 'params':{'code':data['Code Type']}} | |||
| if data['L%d_REFERENCE' % n]=='TXA': | |||
| line['params']['TX_ref'] = '11' | |||
| else: | |||
| line['params']['TX_ref'] = '12' | |||
| if 'Number of Codes' in data: | |||
| line['params']['codes'] = [data['COD({})'.format(x)] for x in range(int(data['Number of Codes']))] | |||
| elif 'Code Type (Line %d)' % n in labels: | |||
| line = {'line_type':'codes', 'id':id, 'params':{'code':data['Code Type (Line %d)' % n]}} | |||
| if data['L%d_REFERENCE' % n]=='TXA': | |||
| line['params']['TX_ref'] = '11' | |||
| else: | |||
| line['params']['TX_ref'] = '12' | |||
| if 'Number of Codes (Line %d)' % n in data: | |||
| line['params']['codes'] = [data['L{}_COD({})'.format(n, x)] for x in range(int(data['Number of Codes (Line %d)' % n]))] | |||
| elif 'Sampling Windows (Line %d)' % n in data: | |||
| line = {'line_type':'windows', 'id':id, 'params':{}} | |||
| if data['L%d_REFERENCE' % n]=='TXA': | |||
| line['params']['TX_ref'] = '11' | |||
| else: | |||
| line['params']['TX_ref'] = '12' | |||
| windows = [] | |||
| for w in range(int(data['Sampling Windows (Line %d)' % n])): | |||
| windows.append({'first_height':float(data['L%d_H0(%d)' % (n, w)]), | |||
| 'resolution':float(data['L%d_DH(%d)' % (n, w)]), | |||
| 'number_of_samples':int(float(data['L%d_NSA(%d)' % (n, w)])), | |||
| 'last_height':float(data['L%d_DH(%d)' % (n, w)])*(int(float(data['L%d_NSA(%d)' % (n, w)]))-1)+float(data['L%d_H0(%d)' % (n, w)]) | |||
| } | |||
| ) | |||
| line['params']['params'] = windows | |||
| elif 'Line%d' % n in labels and data['Line%d' % n]=='Synchro': | |||
| line = {'line_type':'sync', 'id':id, 'params':{'invert':0}} | |||
| elif 'L%d Number Of Portions' % n in labels: | |||
| line = {'line_type':'prog_pulses', 'id':id, 'params':{}} | |||
| if 'L%s Portions IPP Periodic' % n in data: | |||
| line['params']['periodic'] = '1' if data['L%s Portions IPP Periodic' % n]=='YES' else '0' | |||
| portions = [] | |||
| x = raw_data.index('L%d Number Of Portions=%s' % (n, data['L%d Number Of Portions' % n])) | |||
| for w in range(int(data['L%d Number Of Portions' % n])): | |||
| begin = float(raw_data[x+1+2*w].split('=')[-1]) | |||
| end = float(raw_data[x+2+2*w].split('=')[-1]) | |||
| portions.append({'begin':int(begin), | |||
| 'end':int(end)} | |||
| ) | |||
| line['params']['params'] = portions | |||
| elif 'FLIP1' in data and n==5: | |||
| line = {'line_type':'flip', 'id':id, 'params':{'number_of_flips':data['FLIP1']}} | |||
| elif 'FLIP2' in data and n==6: | |||
| line = {'line_type':'flip', 'id':id, 'params':{'number_of_flips':data['FLIP2']}} | |||
| else: | |||
| line = {'line_type':'none', 'id':id, 'params':{}} | |||
| self.data['lines'].append(id) | |||
| self.lines.append(line) | |||
| #Add line 7 (windows) | |||
| if 'Sampling Windows' in data: | |||
| line = {'line_type':'windows', 'id':'17', 'params':{}} | |||
| if data['L7_REFERENCE']=='TXA': | |||
| line['params']['TX_ref'] = '11' | |||
| else: | |||
| line['params']['TX_ref'] = '12' | |||
| windows = [] | |||
| x = raw_data.index('Sampling Windows=%s' % data['Sampling Windows']) | |||
| for w in range(int(data['Sampling Windows'])): | |||
| h0 = raw_data[x+1+3*w].split('=')[-1] | |||
| nsa = raw_data[x+2+3*w].split('=')[-1] | |||
| dh = raw_data[x+3+3*w].split('=')[-1] | |||
| windows.append({'first_height':float(h0), | |||
| 'number_of_samples':int(nsa), | |||
| 'resolution':float(dh), | |||
| 'last_height':float(h0)+float(dh)*(int(nsa)-1)} | |||
| ) | |||
| line['params']['params'] = windows | |||
| self.data['lines'].append('17') | |||
| self.lines.append(line) | |||
| #Add line 8 (synchro inverted) | |||
| self.data['lines'].append('18') | |||
| self.lines.append({'line_type':'sync', 'id':'18', 'params':{'invert':1}}) | |||
| return | |||
| def parse_dat(self): | |||
| pass | |||
| def to_dict(self): | |||
| out = Params() | |||
| out.add(self.data, 'configurations') | |||
| for line_data in self.lines: | |||
| out.add(line_data, 'lines') | |||
|
Fiorella Quino
|
r276 | return out.data | |
| def parse_line(n, data, lines): | |||
| line_text = '' | |||
| line_type = data['lines']['byId'][lines[n]]['line_type'] | |||
| num = n+1 | |||
| if line_type == 'windows': | |||
| if num == 7: | |||
| reference = data['lines']['byId'][lines[n]]['params']['TX_ref'] | |||
| windows = data['lines']['byId'][lines[n]]['params']['params'] | |||
| if windows: | |||
| dh = str(float(windows[0]['resolution'])) | |||
| else: | |||
| dh = '' | |||
| line_text = 'Sampling Windows={}\n'.format(len(windows)) | |||
| cnt = 0 | |||
| for window in windows: | |||
| line_text += ('H0({cnt})={first_height}\n' | |||
| 'NSA({cnt})={number_of_samples}\n' | |||
| 'DH({cnt})={dh}\n'.format( | |||
| cnt=cnt, | |||
| first_height=window['first_height'], | |||
| number_of_samples=int(window['number_of_samples']), | |||
| dh=dh | |||
| ) | |||
| ) | |||
| cnt += 1 | |||
| else: | |||
| reference = data['lines']['byId'][lines[n]]['params']['TX_ref'] | |||
| windows = data['lines']['byId'][lines[n]]['params']['params'] | |||
| if windows: | |||
| dh = str(float(windows[0]['resolution'])) | |||
| else: | |||
| dh = '' | |||
| line_text = 'Sampling Windows (Line {})={}\n'.format(num, len(windows)) | |||
| cnt = 0 | |||
| for window in windows: | |||
| line_text += ('L{num}_H0({cnt})={first_height}\n' | |||
| 'L{num}_NSA({cnt})={number_of_samples}\n' | |||
| 'L{num}_DH({cnt})={dh}\n'.format( | |||
| num=num, | |||
| cnt=cnt, | |||
| first_height=window['first_height'], | |||
| number_of_samples=int(window['number_of_samples']), | |||
| dh=dh | |||
| ) | |||
| ) | |||
| cnt += 1 | |||
| line_text += 'L{}_REFERENCE={}\n'.format( | |||
| num, | |||
| data['lines']['byId'][reference]['name'] | |||
| ) | |||
| elif line_type == 'sync': | |||
| line_text = 'Line{}=Synchro\n'.format(num) | |||
| elif line_type == 'flip': | |||
| line_text = 'L{}_FLIP={}\n'.format( | |||
| num, | |||
| data['lines']['byId'][lines[n]]['params']['number_of_flips'] | |||
| ) | |||
| elif line_type == 'prog_pulses': | |||
| periodic = data['lines']['byId'][lines[n]]['params']['periodic'] | |||
| if periodic == '0': | |||
| periodic = 'NO' | |||
| else: | |||
| periodic = 'YES' | |||
| portions = data['lines']['byId'][lines[n]]['params']['params'] | |||
| line_text = 'L{} Number Of Portions={}\n'.format(num, len(portions)) | |||
| for i, portion in enumerate(portions): | |||
| line_text += 'PORTION_BEGIN({cnt})={begin}\nPORTION_END({cnt})={end}\n'.format( | |||
| cnt=i, | |||
| begin=int(portion['begin']), | |||
| end=int(portion['end']), | |||
| ) | |||
| line_text += 'L{} Portions IPP Periodic={}\n'.format(num, periodic) | |||
| elif line_type == 'none': | |||
| line_text = '' | |||
| else: | |||
| reference = data['lines']['byId'][lines[n]]['params']['TX_ref'] | |||
| code_type = data['lines']['byId'][lines[n]]['params']['code'] | |||
| codes = data['lines']['byId'][lines[n]]['params']['codes'] | |||
| if num == 4: | |||
| line_text = 'Code Type={}\n'.format(code_type) | |||
| line_text += 'Number of Codes={}\nCode Width={}\n'.format( | |||
| len(codes), | |||
| len(codes[0]) | |||
| ) | |||
| cnt = 0 | |||
| for code in codes: | |||
| line_text += 'COD({})={}\n'.format(cnt, code) | |||
| cnt += 1 | |||
| else: | |||
| line_text = 'Code Type (Line {})={}\n'.format(num, code_type) | |||
| line_text += 'Number of Codes (Line {})={}\nCode Width (Line {})={}\n'.format( | |||
| num, | |||
| len(codes), | |||
| num, | |||
| len(codes[0]) | |||
| ) | |||
| cnt = 0 | |||
| for code in codes: | |||
| line_text += 'L{}_COD({})={}\n'.format(num,cnt, code) | |||
| cnt += 1 | |||
| line_text += 'L{}_REFERENCE={}\n'.format( | |||
| num, | |||
| data['lines']['byId'][reference]['name'] | |||
| ) | |||
| return line_text | |||
| def create_jarsfiles(json_data): | |||
| """ | |||
| Function to create *.racp and *.jars files with json_data | |||
| """ | |||
| #global EXPNAME | |||
| data = json.loads(json_data) | |||
| exp_id = data['experiments']['allIds'][0] | |||
| experiment = data['experiments']['byId'][exp_id] | |||
| name = experiment['name'] | |||
| #EXPNAME = name | |||
| folder_name = name#os.path.join(PATH, name) | |||
| #print 'Experiment: ' + name + ' received...' | |||
| #if not os.path.exists(folder_name): | |||
| # os.makedirs(folder_name) | |||
| #print 'Folder OK' | |||
| #if not os.path.exists(folder_name+'/DATA'): | |||
| # os.mkdir(folder_name+'/DATA') | |||
| #try: | |||
| # racp_file = open(folder_name+'/'+name+'_jars.racp', 'w') | |||
| #except: | |||
| # return 0, 'Error creating .racp file' | |||
| #try: | |||
| # json_file = open(folder_name+'/'+name+'_jars.json', 'w') | |||
| #except: | |||
| # return 0, 'Error creating .json file' | |||
| #json_file.write(json_data) | |||
| #json_file.close() | |||
| conf_ids = data['configurations']['allIds'] | |||
| rc_id = [pk for pk in conf_ids \ | |||
| if data['configurations']['byId'][pk]['device_type'] == 'rc'][0] | |||
| jars_id = [pk for pk in conf_ids \ | |||
| if data['configurations']['byId'][pk]['device_type'] == 'jars'][0] | |||
| rc = data['configurations']['byId'][rc_id] | |||
| jars = data['configurations']['byId'][jars_id] | |||
| if rc['mix'] == 'True': | |||
| mix_text = '*******Mixed Experiment*******************\n' | |||
| mix_text += '*******System parameters******************\n' | |||
| else: | |||
| mix_text = '' | |||
| exp_type = jars['exp_type'] | |||
| if exp_type == 0: | |||
| exp_type = 'EXP_RAW_DATA' | |||
| else: | |||
| exp_type = 'EXP_PROCESS_SPECTRA' | |||
| racp_text = 'EXPERIMENT TYPE={}\nEXPERIMENT NAME={}\nHEADER VERSION=1103\n'.format( | |||
| exp_type, | |||
| name | |||
| ) | |||
| racp_text += '*****Radar Controller Parameters**********\n{}'.format(mix_text) | |||
| racp_text += 'IPP={}\n'.format(float(rc['ipp'])) | |||
| racp_text += 'NTX={}\n'.format(rc['ntx']) | |||
| racp_text += 'TXA={}\n'.format( | |||
| data['lines']['byId'][rc['lines'][1]]['params']['pulse_width'] | |||
| ) | |||
| racp_text += 'TXB={}\n'.format( | |||
| data['lines']['byId'][rc['lines'][2]]['params']['pulse_width'] | |||
| ) | |||
| idTR = data['lines']['byId'][rc['lines'][0]]['params']['TX_ref'] | |||
| rangeTR = data['lines']['byId'][rc['lines'][0]]['params']['range'] | |||
| if rangeTR != '0': | |||
| racp_text += 'Pulse selection_TR={}\n'.format(rangeTR) | |||
| elif idTR != '0': | |||
| racp_text += 'Pulse selection_TR={}\n'.format( | |||
| data['lines']['byId'][idTR]['name'][-1] | |||
| ) | |||
| print 'TR OK' | |||
| rangeTXA = data['lines']['byId'][rc['lines'][1]]['params']['range'] | |||
| if rangeTXA != '0': | |||
| racp_text += 'Pulse selection_TXA={}\n'.format(rangeTXA) | |||
| rangeTXB = data['lines']['byId'][rc['lines'][2]]['params']['range'] | |||
| if rangeTXB != '0': #if rangeTXB == '0': | |||
| racp_text += 'Pulse selection_TXB={}\n'.format(rangeTXB) | |||
| print 'Pulse selection OK' | |||
| for n in range(3, 6): | |||
| racp_text += parse_line(n, data, rc['lines']) | |||
| taus = data['lines']['byId'][rc['lines'][2]]['params']['delays'].split(',') | |||
| if taus != '0': | |||
| racp_text += 'Number of Taus={}\n'.format(len(taus)) | |||
| for n, tau in enumerate(taus): | |||
| racp_text += 'TAU({})={}\n'.format(n, tau) | |||
| print 'Taus OK' | |||
| racp_text += parse_line(6, data, rc['lines']) | |||
| racp_text += 'SAMPLING REFERENCE=MIDDLE OF FIRST SUB-BAUD\n' | |||
| racp_text += 'RELOJ={}\n'.format(int(rc['clock'])) | |||
| racp_text += 'CLOCK DIVIDER={}\n'.format(int(rc['clock_divider'])) | |||
| racp_text += 'TR_BEFORE={}\n'.format(rc['time_before']) | |||
| racp_text += 'TR_AFTER={}\n'.format(rc['time_after']) | |||
| racp_text += 'WINDOW IN LINE 5&6=NO\n' | |||
| racp_text += '******System Parameters*******************\n' | |||
| racp_text += 'Number of Cards={}\n'.format(jars['cards_number']) | |||
| for i in range(jars['cards_number']): | |||
| racp_text += 'Card({})={}\n'.format(i, i) | |||
| channels = jars['channels'].split(',') | |||
| if channels: | |||
| racp_text += 'Number of Channels={}\n'.format(len(channels)) | |||
| for i, channel in enumerate(channels): | |||
| racp_text += 'Channel({})={}\n'.format(i, channel) | |||
| print 'Channels OK' | |||
| if exp_type == 'EXP_RAW_DATA': | |||
| racp_text += 'RAW DATA DIRECTORY={}\n'.format(os.path.join(folder_name, 'DATA')) | |||
| else: | |||
| racp_text += 'PROCESS DATA DIRECTORY={}\n'.format(os.path.join(folder_name, 'DATA')) | |||
| if jars['create_directory']: | |||
| racp_text += 'CREATE DIRECTORY PER DAY=YES'+'\n' | |||
| else: | |||
| racp_text += 'CREATE DIRECTORY PER DAY=NO'+'\n' | |||
| if jars['include_expname']: | |||
| racp_text += 'INCLUDE EXPNAME IN DIRECTORY=YES'+'\n' | |||
| else: | |||
| racp_text += 'INCLUDE EXPNAME IN DIRECTORY=NO'+'\n' | |||
| racp_text += '******System Parameters*******************\n' | |||
| racp_text += 'ADC Resolution=8\n' | |||
| racp_text += 'PCI DIO BusWidth=32\n' | |||
| if exp_type == 'EXP_RAW_DATA': | |||
| racp_text += 'RAW DATA BLOCKS={}\n'.format(jars['raw_data_blocks']) | |||
| spectra_text = '' | |||
| else: | |||
| racp_text += 'PROCESS DATA BLOCKS=100\n' | |||
| spectra_text = '------------------------------------------\n' | |||
| if jars['fftpoints'] > 1: | |||
| spectra_text += 'FFTPOINTS={}\n'.format(jars['fftpoints']) | |||
| if jars['incohe_integr']: | |||
| spectra_text += 'INCOHERENT INTEGRATIONS={}\n'.format(jars['incohe_integr']) | |||
| if jars['save_ch_dc']: | |||
| spectra_text += 'SAVE CHANNELS DC=YES\n' | |||
| spectral = json.loads(jars['spectral'][:-1]) | |||
| if spectral: | |||
| spectra_text += '------------------------------------------\n' | |||
| spectra_text += 'TOTAL SPECTRAL COMBINATIONS={}\n'.format(len(spectral)) | |||
| for i, spc in enumerate(spectral): | |||
| spectra_text += 'SPEC_COMB({})={},{}\n'.format(i, *spc) | |||
| racp_text += '******Process Parameters******************\n' | |||
| data_type = jars['data_type'] | |||
| if data_type == 0: | |||
| racp_text += 'DATATYPE=SHORT\n' | |||
| elif data_type == 1: | |||
| racp_text += 'DATATYPE=FLOAT\n' | |||
| print 'Datatype OK' | |||
| racp_text += 'DATA ARRANGE=CONTIGUOUS_CH\n' | |||
| if jars['cohe_integr'] > 1: | |||
| racp_text += 'COHERENT INTEGRATIONS={}\n'.format(jars['cohe_integr']) | |||
| decode_text = '' | |||
| decode_data = jars['decode_data'] | |||
| if decode_data !=0: | |||
| decode_text = 'DECODE DATA=YES\n' | |||
| decode_text += 'DECODING TYPE={}\n'.format(DECODE_TYPE[decode_data]) | |||
| if jars['post_coh_int'] == True: | |||
| decode_text += 'POST COHERENT INTEGRATIONS=YES\n' | |||
| decode_text += '------------------------------------------\n' | |||
| print 'Decode OK' | |||
| racp_text += 'COHERENT INTEGRATION STRIDE={}\n'.format(jars['cohe_integr_str']) | |||
| racp_text += '------------------------------------------\n' | |||
| racp_text += 'ACQUIRED PROFILES={}\n'.format(jars['acq_profiles']) | |||
| racp_text += 'PROFILES PER BLOCK={}\n'.format(jars['profiles_block']) | |||
| racp_text += spectra_text | |||
| racp_text += '------------------------------------------\n' | |||
| racp_text += decode_text | |||
| racp_text += 'BEGIN ON START=NO\n' | |||
| racp_text += 'BEGIN_TIME={}\n'.format(experiment['start_time'][:-3]) | |||
| racp_text += 'END_TIME={}\n'.format(experiment['end_time'][:-3]) | |||
| racp_text += 'GENERATE ACQUISITION LINK=YES\n' | |||
| racp_text += 'VIEW RAW DATA=YES\n' | |||
| racp_text += 'REFRESH RATE=1\n' | |||
| racp_text += '------------------------------------------\n' | |||
| racp_text += 'SEND STATUS TO FTP=YES\n' | |||
| racp_text += 'FTP SERVER=jro.igp.gob.pe\n' | |||
| racp_text += 'FTP USER=wmaster\n' | |||
| racp_text += 'FTP PASSWD=PKQLX20\n' | |||
| racp_text += 'FTP DIR=/users/database/on-line/\n' | |||
| racp_text += 'FTP FILE=status.txt\n' | |||
| racp_text += 'FTP INTERVAL={}\n'.format(jars['ftp_interval']) | |||
| racp_text += 'SAVE STATUS AND BLOCK=YES\n' | |||
| racp_text += 'GENERATE RTI=YES\n' | |||
| racp_text += 'RTI Inc.Int.=1\n' | |||
| racp_text += 'SEND RTI AND BLOCK=YES\n' | |||
| racp_text += '------------------------------------------\n' | |||
| racp_text += 'COMPORT CONFIG=Com1 CBR_9600 TWOSTOPBITS NOPARITY\n' | |||
| racp_text += 'JAM CONFIGURE FILE=dmasg_pprofiles_pch_64_pdigi_6clk.jam\n' | |||
| racp_text += 'ACQUISITION SYSTEM=JARS\n' | |||
| racp_text += '************JARS CONFIGURATION PARAMETERS************\n' | |||
| #-------------------------JARS FILTER--------------------------------------- | |||
| filter_parms = jars['filter_parms'] | |||
| if filter_parms.__class__.__name__ == 'unicode': | |||
| filter_parms = eval(filter_parms) | |||
| elif filter_parms.__class__.__name__ == 'str': | |||
| filter_parms = eval(filter_parms) | |||
| if filter_parms.__class__.__name__ == 'str': | |||
| filter_parms = eval(filter_parms) | |||
| print 'Filter loaded OK' | |||
| try: | |||
| fclock = float(filter_parms['clock']) | |||
| fch = float(filter_parms['fch']) | |||
| m_dds = float(filter_parms['mult']) | |||
| M_CIC2 = float(filter_parms['filter_2']) | |||
| M_CIC5 = float(filter_parms['filter_5']) | |||
| M_RCF = float(filter_parms['filter_fir']) | |||
| print 'Filter parameters float OK' | |||
| except: | |||
| fclock = eval(filter_parms['clock']) | |||
| fch = eval(filter_parms['fch']) | |||
| m_dds = eval(filter_parms['mult']) | |||
| M_CIC2 = eval(filter_parms['filter_2']) | |||
| M_CIC5 = eval(filter_parms['filter_5']) | |||
| M_RCF = eval(filter_parms['filter_fir']) | |||
| print 'Filter parameters eval OK' | |||
| filter_text = 'Loading\n' | |||
| filter_text += 'Impulse file found -> C:\jars\F1MHZ_8_MATCH.imp\n' | |||
| filter_text += 'Autoscale off\n' | |||
| filter_text += 'Initialize Printer Port\n' | |||
| filter_text += 'Chip Hardware Reset\n' | |||
| filter_text += '300h -> 1\n' | |||
| filter_text += '301h -> 6\n' | |||
| filter_text += '302h -> 11111111111111111111111111111111\n' | |||
| if abs(fch) < (fclock/2): | |||
| nco = (2**32)*((fch/fclock))#%1) | |||
| nco_i = long(nco) | |||
| else: | |||
| nco = (2**32)*(fclock-fch)/(fclock) | |||
| nco_i = long(nco) | |||
| filter_text += '303h -> {}\n'.format(nco_i) | |||
| filter_text += '304h -> 0\n' | |||
| input_level = 1 | |||
| S_CIC2 = math.ceil(math.log((M_CIC2**2)*input_level)/math.log(2)) | |||
| if S_CIC2 < 0: | |||
| S_CIC2 = 0 | |||
| if S_CIC2 > 7: | |||
| S_CIC2 = 7 | |||
| filter_text += '305h -> {}\n'.format(int(S_CIC2)) | |||
| filter_text += '306h -> {}\n'.format(int(M_CIC2-1)) | |||
| OL_CIC2 = input_level/(2.0**S_CIC2) | |||
| S_CIC5 = math.ceil(math.log((M_CIC5**5)*OL_CIC2)/math.log(2))-5 | |||
| if S_CIC5 < 0: | |||
| S_CIC5 = 0 | |||
| if S_CIC5 > 7: | |||
| S_CIC5 = 7 | |||
| OL_CIC5 = ((M_CIC5**5)/(2**(S_CIC5+5)))*OL_CIC2 | |||
| filter_text += '307h -> {}\n'.format(int(S_CIC5)) | |||
| filter_text += '308h -> {}\n'.format(int(M_CIC5-1)) | |||
| Gain = 1 | |||
| S_RCF = int(4.0-math.log(Gain)/math.log(2)) | |||
| if S_RCF < 0: | |||
| S_RCF = 0 | |||
| if S_RCF > 7: | |||
| S_RCF = 7 | |||
| filter_text += '309h -> {}\n'.format(S_RCF) | |||
| filter_text += '30Ah -> {}\n'.format(int(M_RCF-1)) | |||
| Offset = 0 | |||
| filter_text += '30Bh -> {}\n'.format(Offset) | |||
| ntaps = int(M_RCF) | |||
| filter_text += '30Ch -> {}\n'.format(ntaps-1) | |||
| filter_text += '30Dh -> 0\n' | |||
| fsamp = fclock/(M_CIC2*M_CIC5*M_RCF) | |||
| tap = int(2.0*((2**19)-1)/(ntaps*OL_CIC5)) | |||
| for p in range(0, ntaps): | |||
| filter_text += ' {} -> {}\n'.format(p, int(math.ceil(tap)))#filter_text += ' {} -> {}\n'.format(p, int(math.ceil(hn))) | |||
| filter_text += 'RCF Gain -> .999996185302734\n' | |||
| filter_text += 'Chip Restarted:\n' | |||
| filter_text += '300h -> 1\n' | |||
| filter_text += '300h -> 0' | |||
| filter_name = '{}_{}MHz_clock{}MHz_F{}MHz_{}_{}_{}.jars'.format( | |||
| abs(fch), | |||
| int((abs(fch)-abs(int(fch)))*1000), | |||
| fclock, | |||
| round(fsamp,3), | |||
| M_CIC2, | |||
| M_CIC5, | |||
| M_RCF | |||
| ) | |||
| #jars_file = open(os.path.join(folder_name, filter_name), 'wb') | |||
| #jars_file.write(filter_text) | |||
| #jars_file.close() | |||
| print 'Filter .jars has been created' | |||
| racp_text += 'JARS_FILTER={}\n'.format(os.path.join(folder_name, filter_name)) | |||
| racp_text += 'MARK WIDTH=2\n' | |||
| racp_text += 'GENERATE OWN SAMPLING WINDOW=NO\n' | |||
| if jars['save_data']: | |||
| racp_text += 'SAVE DATA=YES\n' | |||
| else: | |||
| racp_text += 'SAVE DATA=NO\n' | |||
| racp_text += 'RC_STOP_SEQUENCE=255,0\n' | |||
| racp_text += 'RC_START_SEQUENCE=255,24\n' | |||
| #racp_file.write(racp_text) | |||
| #racp_file.close() | |||
| return racp_text, filter_text |