def delete_employees(self, employee_ids): os.chdir(self._save_path) for id in employee_ids: try: os.remove("{}.emp".format(id)) except: IO.stdErr("Could not delete employee {}".format(id))
def update_employee(self, employee): """ updates the record for the supplied Employee object if no employee record with the supplied employee id exists, nothing happens. use save_employee for this. @params: employee: The Employee object for which to update the record @return: - """ lines = [] updated = False with open(self._file) as source: for line in source: if line.startswith(CSV_COMMENT): lines.append(line) continue split = line.split(",") if split[0] == employee.employee_id: lines.append(employee.get_csv_line()) updated = True continue lines.append(line) with open(self._file, "w") as target: for line in lines: target.write(line) if not updated: IO.stdErr("Could not find the supplied employee to update")
def update_employee(self, employee): os.chdir(self._save_path) target_file = "{}.emp".format(employee.employee_id) if not os.path.isfile(target_file): IO.stdErr("Could not find the supplied employee to update") return self.save_employees([employee])
def prepare_to_move_files(self, zip_dict, conf): # if not os.path.exists(conf.classified_folder): os.mkdir(conf.classified_folder) # move_list = [] unzip_list = [] # manager for manager in self.manager_list: ma_path = os.path.join(conf.classified_folder, manager.name) # module for module in manager.module_list: mo_path = os.path.join(ma_path, module.name) # line for line in module.line_list: line_folder = IOHelper.Naming.valid_name( line.name) # line num is not specified li_path = os.path.join(mo_path, line_folder) # ini, server side do not need ini if conf.write_ini: ini = IOHelper.INI() line.report_list = sorted(line.report_list) ini.write(li_path + '\\error_package.ini', line.report_list) # for i, report_id in enumerate(line.report_list): # move small portion of zip files to folder if 0 < conf.num_zip_move <= i: continue # src # dict struct: id->(folder, zip) src = zip_dict[report_id][1] # dst dfn = IOHelper.DumpFileName(conf) zip_fname = dfn.zip_name_from_id(report_id) dst = os.path.join(li_path, zip_fname) # print(dst, len(line.report_list)) # add to move list move_list.append((src, dst)) if 0 <= conf.num_zip_extract <= i: continue # add to unzip list unzip_list.append(dst) return move_list, unzip_list
def save_employees(self, employees): for emp in employees: try: file_name = "{}.emp".format(emp.employee_id) file_path = os.path.join(self._save_path, file_name) pickle.dump(emp, open(file_path, "wb")) except: err_text = "Could not serialise {}" IO.stdErr(err_text.format(emp.employee_id))
def __init__(self, base_path): #ensure base path exists if not os.path.exists(base_path): IOHelper.create_directory(base_path) #make instance paths self.inst_path = os.path.join(base_path, IOHelper.generate_uuid()) self.in_path = os.path.join(self.inst_path, "in") self.out_path = os.path.join(self.inst_path, "out")
def delete_employees(self, employee_ids): c = 'DELETE FROM employees WHERE id="{}"' for id in employee_ids: command = c.format(id) try: self._execute_command(command) except Exception as err: IO.stdErr("There was an error deleting employee {}".format(id)) print(str(err))
def update_employee(self, emp): c = 'UPDATE employees SET gender = "{}", age = {}, sales = {},' \ + ' bmi = "{}", salary = {}, birthday = "{}" WHERE id ="{}"' command = c.format(emp.gender, emp.age, emp.sales, emp.bmi, emp.salary, emp.birthday, emp.employee_id) try: self._execute_command(command) except Exception as err: IO.stdErr("There was an error deleting employee {}".format(id)) print(str(err))
def save_employees(self, employees): c = 'INSERT INTO employees VALUES ("{}", "{}", "{}", "{}", "{}", "{}", "{}")' for e in employees: command = c.format(e.employee_id, e.gender, e.age, e.sales, e.bmi, e.salary, e.get_birthday_string()) try: self._execute_command(command) except Exception as err: IO.stdErr("There was an error deleting employee {}".format(id)) print(str(err))
def GetConfiguration(): try: if IOHelper.IsInRaspberry(): f = urllib.request.urlopen(RemoteConfigurationFile) mybytes = f.read() configurationFileContent = mybytes.decode("utf8") else: configurationFileContent = IOHelper.ReadFromFile(LocalConfigurationFile) configuration = Configuration.from_json(json.loads(configurationFileContent)) return configuration except: raise return None
def main(): file = IOHelper().checkArg(sys.argv) if (len(file) < 1): print("Missing file") exit(1) d = Dataset() d.loadFile(file[0]) fig, axes = plt.subplots(figsize=(18, 10)) fig.tight_layout() for index in range(6, 19): mean = d.mean(d.getFeature(index)) std = d.standardDeviation(d.getFeature(index), mean) if mean >= -10 and mean <= 10 and std >= -10 and std <= 10: addFeatureOnSubplot(index, d.getFeature(index), d.getName(index), 1) elif mean >= -500 and mean <= 500 and std >= -500 and std <= 500: addFeatureOnSubplot(index, d.getFeature(index), d.getName(index), 2) elif mean >= -2000 and mean <= 2000 and std >= -2000 and std <= 2000: addFeatureOnSubplot(index, d.getFeature(index), d.getName(index), 3) else: addFeatureOnSubplot(index, d.getFeature(index), d.getName(index), 4) # plt.title(d.getName(index)) plt.savefig('scatter_plot.png') plt.show()
def parse_webpage(url_base, start_idx, end_idx): # download webpages try: vd = IOHelper.VisualizeDownload(url_base) page_info = vd.go() except Exception as e: write_information("failed to get web page!") return [] # decode to utf-8 page_info = page_info.decode('utf-8') # print(page_info) # find all report names p_name = re.compile(r'>(error_report_([\d]*).zip)<') id_list = p_name.findall(page_info) # currently unsorted # print(id_list) id_list = sorted(id_list, key=lambda x: int(x[1])) write_information( 'totally <%d> files found on server, ranging from %s to %s' % (len(id_list), id_list[0][1], id_list[-1][1])) # create file list new_id_list = [] for report in id_list: idx = int(report[1]) if start_idx >= 0 and idx < start_idx: continue if end_idx >= 0 and idx > end_idx: continue new_id_list.append(idx) return new_id_list
def main(): file = IOHelper().checkArg(sys.argv) if (len(file) < 1): print("Missing file") exit(1) d = Dataset() d.loadFile(file[0]) fig, axes = plt.subplots(figsize=(18, 10)) fig.tight_layout() start = 6 width = 13 widthStart = 0 widthEnd = widthStart + width ystart = start for i in range(width): drawOneSub(d, start, ystart, range(widthStart, widthEnd)) widthStart += width widthEnd += width start += 1 print("") # plt.title(d.getName(index)) plt.savefig('scatter_plot.png') plt.show()
def get_all_employees(self): os.chdir(self._save_path) all_files = glob("*.emp") employees = [] for f in all_files: try: new_emp = pickle.load(open(f, "rb")) if type(new_emp).__name__ == "Employee": employees.append(new_emp) else: err_text = "File {} does not contain an employee object." IO.stdErr(err_text.format(f)) except: err_text = "Could not read file: {}" IO.stdErr(err_text.format(f)) return employees
def get_devices(): report = listed_command("adb devices -l") devices = [] if len(report) > 1: for lines in report[1:]: if lines != "": deviceIP = IOHelper.until_1st_space(lines) info = IOHelper.after_1st_space(lines).split(" ") product = info[1].split(":")[1] model = info[2].split(":")[1] tp_id = info[1].split(":")[1] devices.append( RemoteDevice(deviceIP=deviceIP, product=product, model=model, transport_id=tp_id)) return devices
def write_excel(self, fname): print("modifications: ") print(self.modify_rule) rules = self.get_raw_rules() ex = IOHelper.XLS() ex.write(fname, self.data, rules)
def process(self, report_id, f_info): f_datetime = None f_size = None if f_info: f_datetime = f_info[0] f_size = f_info[1] # dfn = IOHelper.DumpFileName(self.conf) filename = dfn.zip_name_from_id(report_id) self.zip_path = os.path.join(self.zip_folder, filename) self.unzip_dir = os.path.join(self.unzip_folder, filename.split('.')[0]) dmp_path = os.path.join(self.unzip_dir, self.dump_name) xml_path = os.path.join(self.unzip_dir, self.dump_xml) self.remove_overdue(self.zip_path, self.unzip_dir, xml_path) self.status_valid = True # 下载文件 res = self.try_download(filename, self.zip_path) if not self.status_valid: self.status_valid = True return False if not res: return False # 修改文件时间 res = self.try_modifytime(filename, self.zip_path, f_datetime) if not self.status_valid: self.status_valid = True return False if not res: return False # 解压 res = self.try_unzip(filename, self.zip_path, self.unzip_dir) if not self.status_valid: self.status_valid = True return False if not res: return False # 分析 res = self.try_analyze(filename, self.zip_path, self.unzip_dir, dmp_path, xml_path) if not self.status_valid: self.status_valid = True return False if not res: return False return True
def get_classified_file(self): report_list = [] dfn = IOHelper.DumpFileName(self.conf) for root, dirs, files in os.walk(self.conf.classified_folder): for file in files: if file.startswith( self.conf.folder_prefix) and file.endswith(".zip"): report_list.append(dfn.get_report_id(file.split('.')[0])) write_information('totally %d classified files' % len(report_list)) return sorted(report_list)
def load(self, fpath): f = codecs.open(fpath, 'r', 'utf-8') for line in f.readlines(): data = line.split() if len(data) < 3: continue record = IOHelper.xls_record() record.module = data[0] record.manager = data[1] record.line = data[2] self.invalid_list.append(record)
def main(): file = IOHelper().checkArg(sys.argv) if (len(file) < 1): print("Missing file") exit(1) d = Dataset() d.loadFile(file[0]) d.printFeatureHeader() d.printAllFeature()
def main(): nbOutput = 4 file = IOHelper().checkArg(sys.argv) if (len(file) < 2): print("Missing file") exit(1) d = Dataset() d.loadFile(file[0]) featuresId = range(7, 19) # nbInput = len(featuresId) X = generateDataset(d, featuresId) X, nbInput = d.featureExpand(d, X) X = d.featureRescale(d, X) allWeight, AllOutput = csvToArray(file[1]) allclassifier = MultiClassifier(nbInput, AllOutput) allclassifier.initWeight(allWeight) with open('houses.csv', 'w') as file: file.write("Index,Hogwarts House\n") for i, d in enumerate(X): name = allclassifier.predict(d) file.write(str(i) + "," + name + "\n")
def get_all_employees(self): command = "SELECT * FROM employees" lines = self._execute_command(command) employees = [] for l in lines: try: parameters = {} parameters["empid"] = IC.convert_input(l[0], "empid") parameters["gender"] = IC.convert_input(l[1], "gender") parameters["age"] = IC.convert_input(l[2], "age") parameters["sales"] = IC.convert_input(l[3], "sales") parameters["bmi"] = IC.convert_input(l[4], "bmi") parameters["salary"] = IC.convert_input(l[5], "salary") parameters["birthday"] = IC.convert_input(l[6], "birthday") employees.append(employee.create_employee(parameters)) except Exception as err: IO.stdErr("Error in translating database row: " + str(l)) IO.stdErr(str(err)) print(parameters) return employees
def create_folders(self): """create folders for new record""" for record in self.data: if record.update_folder: # no corresponding folder for this record, create it folder = record.to_folder(self.config.classified_folder) if not os.path.exists(folder): os.mkdirs(folder) # write ini file for current folder ini = IOHelper.INI() ini.write(os.path.join(folder, 'error_package.ini'), record.report_list) # move zip files to current folder report_list = record.report_list[0:conf.num_zip_move] fm = IOHelper.FileMover(self.config) move_list = fm.move(conf.zip_folder, folder, report_list) zip_list = [pair[1] for pair in move_list] fm.unzip_files(zip_list) record.update_folder = False
def to_records(self): records = [] for manager in self.manager_list: for module in manager.module_list: for line in module.line_list: rec = IOHelper.xls_record() rec.line = line.name rec.module = module.name rec.manager = manager.name rec.num = len(line.report_list) rec.report_list = line.report_list records.append(rec) return records
def get_raw_rules(self): raw_rules = [] for k, v in self.modify_rule.items(): raw_rule = IOHelper.xls_record() raw_rule.module = k[0] # module # raw_rule.version version ignored raw_rule.manager = k[1] # manager raw_rule.line = k[2] # line # raw_rule.num num ignored # raw_rule.remark remark ignored raw_rule.modify_code = v[0] # modify code raw_rule.modify_info = v[1] # modify info raw_rules.append(raw_rule) return raw_rules
def fetch_analyze(conf, md, repeat_num=-1, interval=5, ignore_classified=False, remove_after_use=False): # if not prepare_log(conf): # write_information('prepare log failed!') # return if not prepare_dll(conf): write_information('prepare dll failed!') write_information('dll path: %s' % conf.dumpload_dll) return if not prepare_symbol(conf): write_information('prepare symbol failed!') write_information('symbol path: %s' % conf.symbol_folder) return js = JobAssigner(conf, md) write_information('system started...') count = 0 while True: if 0 < repeat_num and repeat_num <= count: break if count > 99990: count = 0 write_information("<The %s time>" % count) count += 1 # 清理之前失效的临时文件夹 if remove_after_use: dc = IOHelper.DirCleaner(conf) # dc.clean_zip() dc.clean_unzip() js.go(conf.thread_num, conf.idx_beg, conf.idx_end, enquire_webpage=conf.retrieve_webpage, ignore_classified=ignore_classified, remove_after_use=remove_after_use) time.sleep(interval) return js.report_list
def record_from_str(self, s): # vs string structure # module.dll ! classname :: otherinfo 行 lineidx + 0x89 字节 # GlobalEnvironment.dll!CGlobalEnvLite::ReleaseObject() 行200 + 0x5 字节 record = IOHelper.xls_record() record.module, clas, func, idx = IOHelper.VSDbgNaming.get_mod_clas_func_idx( s) record.manager = self.md.which_manager(record.module, clas) fname = IOHelper.WinDbgNaming.name_from_clas_func_idx(clas, func, idx) record.line = fname[:80] # print("new record:") # print(record) return record
def get_all_employees(self): """ reads the file this object was initiated with and returns all contained employees as Employee objects in a list @params: - @return: list of Employee objects, may be empty """ employees = [] errors = [] # using file as a resource so I dont forget to close it with open(self._file) as source: skipped_first = False for line in source: if not skipped_first: skipped_first = True continue if line.startswith(CSV_COMMENT): #print("Encountered comment: " + line) continue try: #print("reading line: " + line) split = line.split(",") # TODO: HIGH: validate data emp_id = IC.convert_input(split[0], "empid") gender = IC.convert_input(split[1], "gender") sales = IC.convert_input(split[2], "sales") bmi = IC.convert_input(split[3], "bmi") salary = IC.convert_input(split[4], "salary") bday = IC.convert_input(split[5], "birthday") age = IC.convert_input(split[6], "age") attributes = { "empid": emp_id, "gender": gender, "sales": sales, "bmi": bmi, "salary": salary, "birthday": bday, "age": age } # TODO: high: catch ValueError from employee creation employees.append(employee.create_employee(attributes)) except Exception as err: errors.append("Error when reading line: {}".format(line)) [IO.stdErr(e) for e in errors] return employees
def get_update_detail(self): # changes = {} for idx, record in enumerate(self.data): new_record = copy.deepcopy(record) k = (record.module, record.manager, record.line) if not self.modify_rule.get(k): # good record, no need to update continue code, info = self.modify_rule[k] # the modify code by modify rule must be negative! if code == -1: # delete # make the new record an empty one new_record = IOHelper.xls_record() elif code == -2: # rename # load new information from dump symbol new_record = self.record_from_str(info) new_record.num = record.num new_record.report_list = record.report_list changes[idx] = new_record return changes
def main_routine (wd="./",cfg="./python/parameter.cfg",cnt=11,delay=27.725,sptype=0,phase=0.0): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] dt = float(time['delta_t']) filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] ### read data ### ### plotting Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2Read = sp.dot(alphaR.conj(),cavityRead) Reg2DownRead = Reg2Down + Reg2Read Reg2UpRead = Reg2Up + Reg2Read FuncInfo = sp.zeros([3,cnt]) FuncInfoPhase = sp.zeros([3,cnt]) FuncShiftRead = sp.zeros([3,cnt,functime.size],complex) denom = sp.zeros([3]) # denom[0] = cumtrapz( sp.absolute(Reg2DownRead[ti:tf])**2, x=None, dx=dt )[-1] # denom[1] = cumtrapz( sp.absolute(Reg2UpRead[ti:tf])**2, x=None, dx=dt )[-1] denom[0] = cumtrapz( sp.absolute(Reg2UpRead[ti:tf]+Reg2DownRead[ti:tf])**2, x=None, dx=dt )[-1] denom[1] = cumtrapz( sp.real(Reg2UpRead[ti:tf]+Reg2DownRead[ti:tf]), x=None, dx=dt )[-1] denom[2] = cumtrapz( sp.imag(Reg2UpRead[ti:tf]+Reg2DownRead[ti:tf]), x=None, dx=dt )[-1] # denom[0] = sp.absolute[denom[0]] # denom[1] = sp.absolute[denom[1]] # denom[2] = sp.absolute[denom[2]] for i in sp.arange(0.0,cnt): myDelay = i/(cnt-1.0)*delay shift=sp.absolute(time['read'][:]-(functime[0]-myDelay)).argmin()-1 print myDelay,functime[0],functime[0]-myDelay,shift,time['read'][shift] # FuncShiftRead[0,i,:] = Reg2DownRead[shift:shift+functime.size] FuncShiftRead[0,i,:] = sp.exp(-1j*phase*sp.pi)*Reg2Down[shift:shift+functime.size] + Reg2Read[shift:shift+functime.size] FuncShiftRead[1,i,:] = Reg2UpRead [ti:tf] FuncShiftRead[2,i,:] = FuncShiftRead[0,i,:] + FuncShiftRead[1,i,:] FuncInfo[0,i] = cumtrapz( sp.absolute(FuncShiftRead[2,i,:])**2, x=None, dx=dt )[-1] FuncInfo[0,i] /= sp.absolute(denom[0]) FuncInfo[1,i] = cumtrapz( sp.real(FuncShiftRead[2,i,:]), x=None, dx=dt )[-1] FuncInfo[1,i] /= sp.absolute(denom[1]) FuncInfo[2,i] = cumtrapz( sp.imag(FuncShiftRead[2,i,:]), x=None, dx=dt )[-1] FuncInfo[2,i] /= sp.absolute(denom[2]) # FuncInfoIntegrand = sp.absolute(FuncSuperRead[i,:]) * sp.absolute(Reg2UpRead[ti:tf]) # FuncInfo[i,1] = cumtrapz( FuncInfoIntegrand, x=None, dx=dt )[-1]/denom[1] # FuncInfoIntegrand = FuncSuperRead[i,:].conj() * Reg2UpRead[ti:tf] # FuncInfoPhase[i,0] = cumtrapz( FuncInfoIntegrand.real, x=None, dx=dt )[-1]/denom[1] # FuncInfoPhase[i,1] = cumtrapz( FuncInfoIntegrand.imag, x=None, dx=dt )[-1]/denom[1] xx, yy = sp.meshgrid(functime,sp.linspace(0.0,delay,cnt)) xx0 = sp.linspace(0.0,delay,cnt) # zzR = FuncSuperRead.real/FuncSuperRead.real.max() # zzI = FuncSuperRead.imag/FuncSuperRead.imag.max() zz0A = sp.absolute(FuncShiftRead[0,:,:])**2/((sp.absolute(FuncShiftRead[0:1,:,:])**2).max()) zz1A = sp.absolute(FuncShiftRead[1,:,:])**2/((sp.absolute(FuncShiftRead[0:1,:,:])**2).max()) zzDA = sp.absolute(FuncShiftRead[2,:,:])**2/((sp.absolute(FuncShiftRead[0:1,:,:])**2).max()) zmin = -1.5 zmax = +1.0 fs = 20 fig = plt.figure() if sptype==0: # 3d plotting fig0 = fig.add_subplot(231, projection='3d') fig0.plot_surface(xx, yy, zz0A, rstride=1, cstride=5, cmap="Blues", alpha=0.5,zorder=11.0,vmin=-1, vmax=1) fig0.contourf(xx, yy, zz0A, zdir='z', offset=zmin, cmap="Blues", vmin=-1, vmax=1,zorder=1.0) fig0.set_zlim(zmin,zmax) fig0.set_title("a) normalized $|A_0(t-\Delta t)|^2$",fontsize=fs) fig0.set_xlabel("$t$ in ns",fontsize=fs) fig0.set_ylabel("$\Delta t$ in ns.",fontsize=fs) fig1 = fig.add_subplot(232, projection='3d') fig1.plot_surface(xx, yy, zz1A, rstride=1, cstride=5, cmap="Reds", alpha=0.5,zorder=11.0,vmin=-1, vmax=1) fig1.contourf(xx, yy, zz1A, zdir='z', offset=zmin, cmap="Reds", vmin=-1, vmax=1,zorder=1.0) fig1.set_zlim(zmin,zmax) fig1.set_title("b) normalized $|A_1(t)|^2$",fontsize=fs) fig1.set_xlabel("$t$ in ns",fontsize=fs) fig1.set_ylabel("$\Delta t$ in ns.",fontsize=fs) fig2 = fig.add_subplot(233, projection='3d') fig2.plot_surface(xx, yy, zzDA, rstride=1, cstride=5, cmap="Greens", alpha=0.5,zorder=11.0,vmin=-1, vmax=4) fig2.contourf(xx, yy, zzDA, zdir='z', offset=zmin, cmap="Greens", vmin=-1, vmax=4,zorder=1.0) fig2.set_zlim(zmin,4*zmax) fig2.set_title("c) normalized $|A_0(t-\Delta t)-A_1(t)|^2$",fontsize=fs) fig2.set_xlabel("$t$ in ns",fontsize=fs) fig2.set_ylabel("$\Delta t$ in ns.",fontsize=fs) else : pltId=(cnt-1)/2 yMax = round(max(max(zzDA[0,:]),max(zzDA[pltId,:]),max(zzDA[-1,:]))) + 0.5 yMin = min(min(zzDA[0,:]),min(zzDA[pltId,:]),min(zzDA[-1,:])) plt.subplot2grid((2,3),(0,0)) plt.title("a) no delay, $\Delta t=0$",fontsize=fs) plt.plot(functime,zzDA[0,:],linewidth="2",color="black") plt.xlabel("$t$ in ns",fontsize=fs) plt.ylabel("$|A_0(t-\Delta t) + A_1(t)|^2$ in a.u.",fontsize=fs) plt.xlim(min(functime),max(functime)) plt.ylim(yMin,yMax) plt.subplot2grid((2,3),(0,1)) plt.title("b) medium delay, $\Delta t=\Delta t_{max}/2=$"+"{:}ns".format(pltId/(cnt-1.0)*delay),fontsize=fs) plt.plot(functime,zzDA[pltId,:],linewidth="2",color="black") plt.xlabel("$t$ in ns",fontsize=fs) plt.xlim(min(functime),max(functime)) plt.ylim(yMin,yMax) plt.subplot2grid((2,3),(0,2)) plt.title("c) maximal delay, $\Delta t=\Delta t_{max}=$"+"{:}ns".format(delay),fontsize=fs) plt.plot(functime,zzDA[-1,:],linewidth="2",color="black") plt.xlabel("$t$ in ns",fontsize=fs) plt.xlim(min(functime),max(functime)) plt.ylim(yMin,yMax) plt.subplot2grid((2,3),(1,0)) plt.plot(xx0,FuncInfo[1,:],linewidth="2",color="red") plt.title("d) area under $Re[A_0(t-\Delta t)+A_1(t)]$",fontsize=fs) plt.xlabel("$\Delta t$ in ns",fontsize=fs) plt.xlim(min(xx0),max(xx0)) plt.subplot2grid((2,3),(1,1)) plt.plot(xx0,FuncInfo[2,:],linewidth="2",color="magenta") plt.title("e) area under $Im[A_0(t-\Delta t)+A_1(t)]$",fontsize=fs) plt.xlabel("$\Delta t$ in ns",fontsize=fs) plt.xlim(min(xx0),max(xx0)) plt.subplot2grid((2,3),(1,2)) plt.plot(xx0,FuncInfo[0,:],linewidth="2",color="green") plt.title("f) area under $|A_0(t-\Delta t)+A_1(t)|^2$",fontsize=fs) plt.xlabel("$\Delta t$ in ns",fontsize=fs) plt.xlim(min(xx0),max(xx0)) # FuncInfoPhase[:,0]-=min(FuncInfoPhase[:,0]) # FuncInfoPhase[:,0]/=0.5*max(sp.absolute(FuncInfoPhase[:,0])) # FuncInfoPhase[:,0]-=1.0 # FuncInfoPhase[:,1]-=min(FuncInfoPhase[:,1]) # FuncInfoPhase[:,1]/=0.5*max(sp.absolute(FuncInfoPhase[:,1])) # FuncInfoPhase[:,1]-=1.0 # plt.subplot2grid((2,3),(1,2),colspan=1,rowspan=1) # plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfoPhase[:,0],linewidth="2",color="red") # plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfoPhase[:,1],linewidth="2",color="magenta") # plt.title("f) $O_{\mathbb{C}}$ scaled & translated, $(O_{\mathbb{C}}($'$1$'$)-I_R)/I_0$",fontsize=fs) ## plt.title("$\\frac{1}{N}\int_{T_{{\cal F}1}}^{T_{{\cal F}2}}dt\,A_0(t;\phi_0)^*\cdot A_1(t)$ scaled & translated",fontsize=fs) # plt.xlabel("$\phi_0/\pi$",fontsize=fs) # plt.ylim(-1,1) ## myPhase = sp.zeros([cnt,2]) ## for i in sp.arange(0,cnt): ## myPhase[i,0]=acos(FuncInfoPhase[i,0])/sp.pi ## myPhase[i,1]=acos(FuncInfoPhase[i,1])/sp.pi ## plt.subplot2grid((2,3),(1,2),colspan=1,rowspan=1) ## plt.plot(sp.linspace(0.0,2.0,cnt),myPhase[:,0]) ## plt.plot(sp.linspace(0.0,2.0,cnt),myPhase[:,1]) # ## fig0.plot(memo_times[:], fitness[:,conf[pltId]], zs=tmax, zdir='y',lw=1.5, color="green") plt.show()
def main_routine (wd="./",cfg="./python/spinanalysis.cfg",myMap="jet",generate=1,plottype=0,w1=2400,w2=2450,w3=2500,w4=2550,w5=2600,cut=0,nano=1): ### read config file ### print ("load from config file: " + cfg) cfg=IOHelper.loadSpin(wd,cfg) omega_c = float(cfg['NVSETUP']['{omega_c}']) ### read config file ### if (generate==1): cmd = "./scripts/ifort-spinAnalysis.sh " + wd print ("compile fortran routines: "+cmd) call(cmd.split()) print ("### call SpinAnalysis") cmd=wd+"SpinAnalysis" analysis = Popen(cmd.split(), stdin=PIPE) # run fortran program with piped standard input output = analysis.communicate()[0] # generateInput.wait() filebase ="./thesis/dat/decay/sin_drive_00h_A0_0.0_0.0i_" filename= filebase+"cavity.dat" time,__,cavityR,cavityI = sp.loadtxt(filename).T cavity = cavityR + 1j*cavityI filename= filebase+"spin.dat" times,__, spinR, spinI = sp.loadtxt(filename).T spin = spinR + 1j*spinI tott = int(cfg['MESpin']['{timecnt_analysis}']) timeBinSpin = int(cfg['MESpin']['{timebin_spin}']) filename = filebase + "spin_%#07.2fns.dat" % (times[-1]) omega,__,__ = sp.loadtxt(filename).T spin2d = sp.zeros([sp.size(times),sp.size(omega)],complex) omega_c = float(cfg['NVSETUP']['{omega_c}']) omega *= omega_c print "### load data ..." myMin = 0 myMax = 0 for t in sp.linspace(0,sp.size(times)-1,sp.size(times)): filename = filebase + "spin_%#07.2fns.dat" % (times[t]) __,spinSlideR,spinSlideI = sp.loadtxt(filename).T spin2d[t,:]=spinSlideR+1j*spinSlideI if (min(min(spinSlideR),min(spinSlideI)) < myMin): myMin = min(min(spinSlideR),min(spinSlideI)) if (max(max(spinSlideR),max(spinSlideI)) > myMax): myMax = max(max(spinSlideR),max(spinSlideI)) # print "{0:05.2f}".format(int(t)) # do t=1,tott,timeBinSpin # tmp = nint(mytime(t)*1d2) # write(timerange,"(I0.4,F0.2,A)") int(tmp/1d2),tmp/1d2-int(tmp/1d2),"ns" # write(*,"(1A1,A,I,A,I,$)") char(13),"--- spin dynamics at "//trim(timerange)//":", t, " of ", size(mytime) myMax = max(sp.absolute(myMin),sp.absolute(myMax)) myMin = -myMax fs=20 label_size = 20 plt.rcParams['xtick.labelsize'] = label_size plt.rcParams['ytick.labelsize'] = label_size if (nano==1): timelabel = "ns" else : time *= 1e-3 times *= 1e-3 cut *= 1e-3 timelabel = "$\mu$s" if (plottype == 0): plt.plot(time,sp.absolute(cavity)**2, color="green",linewidth=2.0, label="cavity-amplitude") plt.plot(times,sp.absolute(spin)**2, color="red",linewidth=2.0, label="collective spin-wave") plt.plot([cut,cut],[omega[-1],omega[1]],"k--") plt.ylabel("$|A(t)|^2$; $|S_x(t)|^2$",fontsize=fs) plt.xlabel("$t$ in "+timelabel,fontsize=fs) plt.legend() elif (plottype == 1): plt.subplot(1,3,1) plt.plot(times,sp.real(spin2d[:,w1])) plt.plot(times,sp.real(spin2d[:,w2])) plt.plot(times,sp.real(spin2d[:,w3])) plt.plot(times,sp.real(spin2d[:,w4])) plt.plot(times,sp.real(spin2d[:,w5])) plt.ylabel("$|B_k(t)|^2$",fontsize=fs) plt.title("Real part") plt.xlabel("$t$ in "+timelabel,fontsize=fs) plt.subplot(1,3,2) plt.plot(times,sp.imag(spin2d[:,w1])) plt.plot(times,sp.imag(spin2d[:,w2])) plt.plot(times,sp.imag(spin2d[:,w3])) plt.plot(times,sp.imag(spin2d[:,w4])) plt.plot(times,sp.imag(spin2d[:,w5])) plt.title("Imaginary part") plt.xlabel("$t$ in "+timelabel,fontsize=fs) plt.subplot(1,3,3) plt.plot(times,sp.absolute(spin2d[:,w1]+spin2d[:,w2]+spin2d[:,w3]+spin2d[:,w4]+spin2d[:,w5])**2/5.0) plt.title("Collective spin") plt.xlabel("$t$ in "+timelabel,fontsize=fs) elif (plottype == 2): ### prepare colormap ################################################################### fig0_colors=sp.linspace(myMin,myMax,100) ### prepare colormap ################################################################### c = mcolors.ColorConverter().to_rgb if (myMap == "custom"): cm = make_colormap([c('cyan'), c('black'), 0.499, c('black'), 0.501, c('black'), c('magenta')]) else: cm = plt.cm.get_cmap(myMap) otick = [round_sig(0.995*omega_c,4), round_sig(0.9975*omega_c,4), round_sig(omega_c,4), round_sig(1.0025*omega_c,4), round_sig(1.005*omega_c,4)] fig = plt.figure() fig0 = fig.add_subplot(121) fig0.invert_yaxis() fig0.contourf(times,omega,spin2d.real.T,fig0_colors,cmap=cm,vmin=myMin*0.6,vmax=myMax*0.6) fig0.plot([cut,cut],[omega[-1],omega[1]],color="white") fig0.set_xlabel("$t$ in "+timelabel, fontsize=fs) fig0.set_xlim(times[0],times[-1]) fig0.set_ylabel("$\omega$ in GHz", fontsize=fs) fig0.set_ylim([otick[0],otick[-1]]) fig0.set_yticks(otick) fig0.tick_params(direction='out') fig0.title("a) Real part") fig1 = fig.add_subplot(122) fig1.invert_yaxis() cp1=fig1.contourf(times,omega,spin2d.imag.T,fig0_colors,cmap=cm,vmin=myMin*0.6,vmax=myMax*0.6) fig1.plot([cut,cut],[omega[-1],omega[1]],color="white") fig1.set_xlabel("$t$ in "+timelabel, fontsize=fs) fig1.set_xlim(times[0],times[-1]) fig1.set_ylim([otick[0],otick[-1]]) fig1.set_yticks(otick) fig1.axes.yaxis.set_ticklabels([]) fig1.tick_params(direction='out') fig1.title("b) Imaginary part") cbtick = [-round_sig(myMax*0.99,2), -round_sig(myMax/2,2), 0.0, round_sig(myMax/2,2), round_sig(myMax*0.99,2)] cb =plt.colorbar(cp1,label="Spin-wave amplitude",ticks=cbtick) ax = cb.ax text = ax.yaxis.label font = font_manager.FontProperties(size=fs) text.set_font_properties(font) cb.update_ticks() plt.show ()
def main_routine (wd="./",cfg="./python/parameter.cfg",start=-1,cut1=1000.0,cut2=1000.0,cut3=1000.0,stop=-1,test=0,plotType=0,impose=0,par1=0.0,par2=0.0): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) cavityDownStore,cavityDownRead =IOHelper.harmonics_storage("down",**cfg) cavityUpStore ,cavityUpRead =IOHelper.harmonics_storage("up",**cfg) time =IOHelper.time_storage(**cfg) time['write'][:] *= 1e9 time['store'][:] *= 1e9 time['read'] [:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] filename =IOHelper.getVectorMemory(**cfg) reGamma,imGamma=sp.loadtxt(filename).T #sp.random.random_sample([dimH])+0j alphaS =reGamma[0:nStore]-1j*imGamma[0:nStore] beta =reGamma[-1] -1j*imGamma[-1] ### read data ### ### plotting cavityDownReg1 = sp.dot(alphaD.conj(),cavityWrite) cavityDownReg2 = sp.dot(alphaS.conj(),cavityDownStore[0:nStore][:])+beta.conj()*cavityDownStore[-2][:]+cavityDownStore[-1][:] cavityDownReg3 = sp.dot(alphaS.conj(),cavityDownRead [0:nStore][:])+beta.conj()*cavityDownRead [-2][:]+cavityDownRead [-1][:] cavityUpReg1 = sp.dot(alphaU.conj(),cavityWrite) cavityUpReg2 = sp.dot(alphaS.conj(),cavityUpStore[0:nStore][:])+beta.conj()*cavityUpStore[-2][:]+cavityUpStore[-1][:] cavityUpReg3 = sp.dot(alphaS.conj(),cavityUpRead [0:nStore][:])+beta.conj()*cavityUpRead [-2][:]+cavityUpRead [-1][:] cavitySuperReg1 = superimpose(cavityDownReg1,cavityUpReg1,par1,par2) cavitySuperReg2 = superimpose(cavityDownReg2,cavityUpReg2,par1,par2) cavitySuperReg3 = superimpose(cavityDownReg3,cavityUpReg3,par1,par2) cavityCheckReg1 = superimpose(sp.dot(alphaD.conj(),cavityWrite),sp.dot(alphaU.conj(),cavityWrite),par1,par2) cavityCheckReg2 = sp.dot(alphaS.conj(),cavityUpStore[0:nStore][:])+beta.conj()*cavityUpStore[-2][:]+superimpose(cavityDownStore[-1],cavityUpStore[-1],par1,par2) cavityCheckReg3 = sp.dot(alphaS.conj(),cavityUpRead [0:nStore][:])+beta.conj()*cavityUpRead [-2][:]+superimpose(cavityDownRead[-1],cavityUpRead[-1],par1,par2) ReadDownReg2 = sp.dot(alphaD.conj(),cavityMemo) + sp.dot(alphaR.conj(),cavityRead) ReadUpReg2 = sp.dot(alphaU.conj(),cavityMemo) + sp.dot(alphaR.conj(),cavityRead) ReadSuperReg2 = superimpose(ReadDownReg2,ReadUpReg2,par1,par2) ReadDownReg2 *= beta.conj() ReadUpReg2 *= beta.conj() ReadSuperReg2 *= beta.conj() fs = 20 plt.subplot(4,3,1) plt.title("state '0', $A(t)$",fontsize=fs) plt.plot(functime,ReadDownReg2[ti:tf].real,color="darkgray",linewidth=2) plt.plot(functime,cavityDownReg3[ti:tf].real,color="blue",linewidth=2) plt.xlim([min(functime),max(functime)]) plt.ylabel("real part",fontsize=fs) plt.subplot(4,3,4) plt.plot(functime,ReadDownReg2[ti:tf].imag,color="darkgray",linewidth=2) plt.plot(functime,cavityDownReg3[ti:tf].imag,color="blue",linewidth=2) plt.xlim([min(functime),max(functime)]) plt.ylabel("imag part",fontsize=fs) plt.subplot(4,3,2) plt.title("state '1', $A(t)$",fontsize=fs) plt.plot(functime,ReadUpReg2[ti:tf].real,color="darkgray",linewidth=2) plt.plot(functime,cavityUpReg3[ti:tf].real,color="red",linewidth=2) plt.xlim([min(functime),max(functime)]) plt.subplot(4,3,5) plt.plot(functime,ReadUpReg2[ti:tf].imag,color="darkgray",linewidth=2) plt.plot(functime,cavityUpReg3[ti:tf].imag,color="red",linewidth=2) plt.xlim([min(functime),max(functime)]) plt.subplot(4,3,3) if (impose != 1): plt.title("$\\alpha_{S}$",fontsize=fs) plt.bar(sp.arange(1,nStore+1,1),alphaS.real,color="green") else : plt.title("superposition, $A(t)$",fontsize=fs) plt.plot(functime,ReadSuperReg2[ti:tf].real,color="darkgray",linewidth=2) plt.plot(functime,cavitySuperReg3[ti:tf].real,color="green",linewidth=2) plt.xlim([min(functime),max(functime)]) plt.subplot(4,3,6) if (impose != 1): plt.bar(sp.arange(1,nStore+1,1),alphaS.imag,color="green") else : plt.plot(functime,ReadSuperReg2[ti:tf].imag,color="darkgray",linewidth=2) plt.plot(functime,cavitySuperReg3[ti:tf].imag,color="green",linewidth=2) plt.xlim([min(functime),max(functime)]) plt.subplot2grid((4,3),(2,0),colspan=3,rowspan=2) cavityCheckReg1,cavityCheckReg2,cavityCheckReg3 = pltFunction(cavityCheckReg1,cavityCheckReg2,cavityCheckReg3,plotType) cavitySuperReg1,cavitySuperReg2,cavitySuperReg3 = pltFunction(cavitySuperReg1,cavitySuperReg2,cavitySuperReg3,plotType) cavityDownReg1, cavityDownReg2, cavityDownReg3 = pltFunction(cavityDownReg1, cavityDownReg2, cavityDownReg3, plotType) cavityUpReg1, cavityUpReg2, cavityUpReg3 = pltFunction(cavityUpReg1, cavityUpReg2, cavityUpReg3, plotType) if (test==1): print ("### compile fortran routines") cmd = "./scripts/ifort-memoryHarmonics.sh " + wd call(cmd.split()) print ("### call memoryOptimized") cmd=wd+"memoryOptimized" call(cmd.split()) print ("### call memorySuperimposed") cmd=wd+"memorySuperimposed" generateSuperposition = Popen(cmd.split(), stdin=PIPE) # run fortran program with piped standard input cmd = "echo {:}".format(par1) # communication with fortran-routine: chose superposition parameter generateInput = Popen(cmd.split(), stdout=generateSuperposition.stdin) # send action to fortran program output = generateSuperposition.communicate()[0] generateInput.wait() filename = cfg['FILES']['{prefix}']+cfg['FILES']['{name_readwrite}']+\ cfg['FILES']['{name_storage}']+cfg['FILES']['{name_optimized}'] mytimeU,__,A_Re_U,A_Im_U = sp.loadtxt(filename+"cavity_up_stored" +cfg['FILES']['{postfix}']).T mytimeD,__,A_Re_D,A_Im_D = sp.loadtxt(filename+"cavity_down_stored" +cfg['FILES']['{postfix}']).T mytimeS,__,A_Re_S,A_Im_S = sp.loadtxt(filename+"cavity_super_stored"+cfg['FILES']['{postfix}']).T cavityMode_U,cavityMode_D,cavityMode_S = pltFunction(A_Re_U+1j*A_Im_U, A_Re_D+1j*A_Im_D, A_Re_S+1j*A_Im_S,plotType) cavityMaxDown = max(max(cavityDownReg1),max(cavityDownReg2),max(cavityDownReg3)) cavityMaxUp = max(max(cavityUpReg1),max(cavityUpReg2),max(cavityUpReg3)) cavityMaxSuper= max(max(cavitySuperReg1),max(cavitySuperReg2),max(cavitySuperReg3)) cavityMax = max(cavityMaxDown,cavityMaxUp,cavityMaxSuper) cavityMinDown = min(min(cavityDownReg1),min(cavityDownReg2),min(cavityDownReg3)) cavityMinUp = min(min(cavityUpReg1),min(cavityUpReg2),min(cavityUpReg3)) cavityMinSuper= max(min(cavitySuperReg1),min(cavitySuperReg2),min(cavitySuperReg3)) cavityMin = min(cavityMinDown,cavityMinUp,cavityMinSuper) plt.plot(time['write'],cavityDownReg1,color="blue",linewidth=2) plt.plot(time['store'],cavityDownReg2,color="blue",linewidth=2) plt.plot(time['read'] ,cavityDownReg3,color="blue",linewidth=2,label="state '0'") plt.plot(time['write'],cavityUpReg1,color="red",linewidth=2) plt.plot(time['store'],cavityUpReg2,color="red",linewidth=2) plt.plot(time['read'] ,cavityUpReg3,color="red",linewidth=2,label="state '1'") if (impose == 1): plt.plot(time['write'],cavitySuperReg1,color="green",linewidth=2) plt.plot(time['store'],cavitySuperReg2,color="green",linewidth=2) plt.plot(time['read'] ,cavitySuperReg3,color="green",linewidth=2,label="super state") if (test == 1): plt.plot(mytimeD,cavityMode_D,label="state '0' test",color="cyan") plt.plot(mytimeU,cavityMode_U,label="state '1' test",color="magenta") if (impose == 1): plt.plot(time['write'],cavityCheckReg1,color="orange") plt.plot(time['store'],cavityCheckReg2,color="orange") plt.plot(time['read'] ,cavityCheckReg3,color="orange",label="super state") plt.plot(mytimeS,cavityMode_S,label="super state test",color="brown") # plt.legend() plt.xlabel('time in ns',fontsize=fs) plt.ylabel('$|A(t)|^2$',fontsize=fs) if start != -1 and stop != -1: plt.xlim([start,stop]) else: plt.xlim([min(time['write']),max(time['read'])]) plt.ylim([cavityMin*1.1,cavityMax*1.1]) plt.fill_between(functime, cavityMax*1.1, cavityMin*1.1, color='lightgray', facecolor='lightgray', alpha=0.5) plt.plot([time['store'][0],time['store'][0]], [cavityMin*1.1,cavityMax*1.1], 'k--') plt.plot([time['read'] [0],time['read'] [0]], [cavityMin*1.1,cavityMax*1.1], 'k--') plt.plot([cut1,cut1],[0,cavityMax*1.1],linewidth=2.0) plt.plot([cut2,cut2],[0,cavityMax*1.1],linewidth=2.0) plt.plot([cut3,cut3],[0,cavityMax*1.1],linewidth=2.0) plt.show()
def main_routine (wd="./",cfg="./python/parameter.cfg",thetaCnt=11,phiCnt=11,p3d=0,myMap="rainbow"): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] dt = float(time['delta_t']) filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] # /float(cfg['OCConstraints']['{amplitude_up}']) alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] # /float(cfg['OCConstraints']['{amplitude_down}']) alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] # /float(cfg['OCConstraints']['{amplitude_read}']) ### read data ### ### plotting Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2Read = sp.dot(alphaR.conj(),cavityRead) Reg2DownRead = Reg2Down + Reg2Read Reg2UpRead = Reg2Up + Reg2Read FuncInfoOlap = sp.zeros([2,thetaCnt,phiCnt],complex) I00 = cumtrapz( (Reg2Down[ti:tf].conj() * Reg2Down[ti:tf]).real, x=None, dx=dt )[-1] I0R = 1j*cumtrapz( (Reg2Read[ti:tf].conj() * Reg2Down[ti:tf]).imag, x=None, dx=dt )[-1] I0R += cumtrapz( (Reg2Read[ti:tf].conj() * Reg2Down[ti:tf]).real, x=None, dx=dt )[-1] I11 = cumtrapz( (Reg2Up [ti:tf].conj() * Reg2Up [ti:tf]).real, x=None, dx=dt )[-1] I1R = 1j*cumtrapz( (Reg2Read[ti:tf].conj() * Reg2Up [ti:tf]).imag, x=None, dx=dt )[-1] I1R += cumtrapz( (Reg2Read[ti:tf].conj() * Reg2Up [ti:tf]).real, x=None, dx=dt )[-1] fs = 20 for i in sp.arange(0.0,thetaCnt): theta = i/(thetaCnt-1.0) # from 0 to 1 * pi for j in sp.arange(0.0,phiCnt): phi = j/(phiCnt-1.0)*2.0 # from 0 to 2 * pi FuncCavity = sp.cos(theta*sp.pi)*Reg2Down[ti:tf] + sp.sin(theta*sp.pi)*sp.exp(-1j*phi*sp.pi)*Reg2Up[ti:tf] FuncCavity[:] += Reg2Read [ti:tf] # plt.title("state $\\theat={0:}$, $\\phi={1:}$".format(theta,phi),fontsize=fs) # plt.plot(time['read'][ti:tf],sp.absolute(FuncCavity)**2,color="green",linewidth=2) # plt.plot(time['read'][ti:tf],sp.absolute(Reg2DownRead[ti:tf])**2,color="blue",linewidth=2) # plt.plot(time['read'][ti:tf],sp.absolute(Reg2UpRead[ti:tf])**2,color="red",linewidth=2) # plt.ylabel("$A(t)$",fontsize=fs) # plt.xlim([time['read'][ti],time['read'][tf]]) # plt.show() FuncInfoOlap [0,i,j] = cumtrapz( (FuncCavity[:].conj() * Reg2Down[ti:tf]).real, x=None, dx=dt )[-1] FuncInfoOlap [0,i,j] += 1j*cumtrapz( (FuncCavity[:].conj() * Reg2Down[ti:tf]).imag, x=None, dx=dt )[-1] FuncInfoOlap [0,i,j] = (FuncInfoOlap [0,i,j]-I0R)/I00 FuncInfoOlap [1,i,j] = cumtrapz( (FuncCavity[:].conj() * Reg2Up[ti:tf]).real, x=None, dx=dt )[-1] FuncInfoOlap [1,i,j] += 1j*cumtrapz( (FuncCavity[:].conj() * Reg2Up[ti:tf]).imag, x=None, dx=dt )[-1] FuncInfoOlap [1,i,j] = (FuncInfoOlap [1,i,j]-I1R)/I11 xx, yy = sp.meshgrid(sp.linspace(0.0,2.0,phiCnt),sp.linspace(0.0,1.0,thetaCnt)) zmin = 0.0 zmax = +1.0 zzOlapR0 = FuncInfoOlap [0,:,:].real zzOlapI0 = FuncInfoOlap [0,:,:].imag print zzOlapI0 zzOlapR1 = FuncInfoOlap [1,:,:].real zzOlapI1 = FuncInfoOlap [1,:,:].imag fig = plt.figure() fig1 = fig.add_subplot(221, projection='3d') fig1.plot_surface(xx, yy, zzOlapR0, rstride=5, cstride=5, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapR0.min(), vmax=zzOlapR0.max()) fig1.set_zlim(-1,1) fig1.set_title("a) Re$[(\\tilde O($\"$0$\"$)-\\tilde {\cal I}_{0R})/\\tilde {\cal I}_{00}]\\approx\cos(\\theta)$",fontsize=fs) fig1.set_ylabel("$\\theta/\pi$",fontsize=fs) fig1.set_xlabel("$\phi / \pi$",fontsize=fs) fig1 = fig.add_subplot(223, projection='3d') fig1.plot_surface(xx, yy, zzOlapI0, rstride=5, cstride=5, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapI0.min(), vmax=zzOlapI0.max()) fig1.set_zlim(-0.01,0.01) fig1.set_title("c) Im$[(\\tilde O($\"$0$\"$)-\\tilde {\cal I}_{0R})/\\tilde {\cal I}_{00}]\\approx0$",fontsize=fs) fig1.set_ylabel("$\\theta/\pi$",fontsize=fs) fig1.set_xlabel("$\phi/\pi$",fontsize=fs) fig1 = fig.add_subplot(222, projection='3d') fig1.plot_surface(xx, yy, zzOlapR1, rstride=5, cstride=5, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapR1.min(), vmax=zzOlapR1.max()) fig1.set_zlim(-1,1) fig1.set_title("b) Re$[(\\tilde O($\"$1$\"$)-\\tilde {\cal I}_{1R})/\\tilde {\cal I}_{11}]\\approx\sin(\\theta)\cdot\cos(\phi)$",fontsize=fs) fig1.set_ylabel("$\\theta/\pi$",fontsize=fs) fig1.set_xlabel("$\phi / \pi$",fontsize=fs) fig1 = fig.add_subplot(224, projection='3d') fig1.plot_surface(xx, yy, zzOlapI1, rstride=5, cstride=5, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapI1.min(), vmax=zzOlapI1.max()) fig1.set_zlim(-1,1) # fig1.set_title("a) Re$[(O_{\mathbb{C}}("0")-\\tilde {\¢al I}_{0R})/\\tilde {\¢al I}_{00}]$",fontsize=fs) fig1.set_title("d) Im$[(\\tilde O($\"$1$\"$)-\\tilde {\cal I}_{1R})/\\tilde {\cal I}_{11}]\\approx\sin(\\theta)\cdot\sin(\phi)$",fontsize=fs) fig1.set_ylabel("$\\theta/\pi$",fontsize=fs) fig1.set_xlabel("$\phi/\pi$",fontsize=fs) plt.show()
def main_routine (baseDir="./",configPath="./python/parameter.cfg",generationType="r"): print "#################################################################" print "#################################################################" print "### optimal control #############################################" print "### preparation of smallest overlap functional ##################" print "#################################################################" print "#################################################################" ### globals for functional variation global time, cavityRead, cavityMemo, \ nRead, nDown, nUp, nWrite, dimH, \ cfg, \ h0, hc_up, hc_down, hs_up, hs_down, hsep, \ weight_up, weight_down, sepZeroWeight, \ normUp, normDown, normRead, \ hole, \ iteration tmpDir=baseDir+"tmp/" # parser.add_argument("--cfg" , help="config path") ### check for arguments, g: generate data, r: read data ### ### read config file ### print ("load from config file: " + configPath) configParser = cp.ConfigParser() configParser.read(configPath) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) nRead =int(cfg['OCFourier']['{read_harmonic}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite nTimeRead =int(cfg['OCTime']['{read_timecnt}']) dimH =nRead + 2*nWrite normRead =float(cfg['OCConstraints']['{amplitude_read}']) normDown =float(cfg['OCConstraints']['{amplitude_down}']) normUp =float(cfg['OCConstraints']['{amplitude_up}']) name_readwrite = IOHelper.getNameReadWrite(**cfg) name_vector = IOHelper.getVectorOverlap(**cfg) ### read config file ### ### prepare data with fortran ### cmd = "mkdir -p " + tmpDir print (tmpDir) call(cmd.split()) replace_in_file('./python/py.parNvCenter.F95' , tmpDir +'parNvCenter.F95', **cfg['NVSETUP']) replace_in_file('./python/py.parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['OCFourier']) replace_in_file(tmpDir +'parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['OCConstraints']) replace_in_file(tmpDir +'parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['OCTime']) replace_in_file(tmpDir +'parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['FILES']) #write config file with open(cfg['FILES']['{prefix}']+"parameter.cfg", 'wb') as configfile: configParser.write(configfile) cmd = "mv "+tmpDir+"parSmallestOverlap.F95 "+baseDir+"srcOptCntrl/parSmallestOverlap.F95" call(cmd.split()) cmd = "mv "+tmpDir+"parNvCenter.F95 "+baseDir+"srcNv/parNvCenter.F95" call(cmd.split()) print ("compile fortran routines") cmd = "./scripts/ifort-generateHarmonics.sh " + baseDir call(cmd.split()) print ("invoke " +baseDir +"generateHarmonics") cmd = baseDir+"generateHarmonics" generateHarmonics = Popen(cmd.split(), stdin=PIPE) cmd = "echo " + generationType generateInput = Popen(cmd.split(), stdout=generateHarmonics.stdin) output = generateHarmonics.communicate()[0] generateInput.wait() ### prepare data with fortran ### ### read data for functional variation ### __,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) h0,hs_down,hs_up,hc_down,hc_up,hsep=IOHelper.read_MtrxOverlap(**cfg['FILES']) hole =IOHelper.read_HoleData(**cfg['FILES']) ### read data for functional variation ### ### functional variation ### print ("\nstart minimization: ") varMax = 20 varStep = 1 success = False #constraints for constraintWeightDown and constraintWeightUp funcTime =float(time['tfunc']) weight_down=float(cfg ['OCConstraints']['{temporal_weight_down}'])*funcTime/2.0 weight_up =float(cfg ['OCConstraints']['{temporal_weight_up}'])*funcTime/2.0 minContraints= ( {'type' : 'ineq', 'fun' : constraintNormRead }, {'type' : 'eq', 'fun' : constraintNormDown }, {'type' : 'eq', 'fun' : constraintNormUp }, {'type' : 'eq', 'fun' : constraintWeightDown }, {'type' : 'eq', 'fun' : constraintWeightUp }, # {'type' : 'eq', 'fun' : constraintRealMaxCoefficient }, {'type' : 'ineq', 'fun' : constraintZeroStartDown }, {'type' : 'ineq', 'fun' : constraintZeroStartUp }, {'type' : 'ineq', 'fun' : constraintPartialOverlap }, {'type' : 'ineq', 'fun' : constraintStoreUp }, {'type' : 'ineq', 'fun' : constraintStoreDownIneq }, # # {'type' : 'ineq', 'fun' : constraintSeperateZero }, # {'type' : 'eq', 'fun' : constraintStoreDown }, # {'type' : 'eq', 'fun' : constraintHoleValue }, # {'type' : 'eq', 'fun' : constraintHoleSlope }, # {'type' : 'eq', 'fun' : constraintHoleCurv }, ) while varStep < varMax and not success : gamma0=initGamma0() x,x0 =initx(gamma0) # print (" calculate sepzero to initialize vector x (method=SLSQP):") # iteration=1 # res=minimize(seperateZeroStore, #seperateZero, # smallestAbsoluteOverlap, # x0, #res.x, # method='SLSQP', # constraints=sepzeroContraints, # tol=cfg['OCConstraints']['{tol_sepzero}'], # options={'maxiter' : 25000, 'disp' : True}, # callback=monitor # ) # x0=res.x # sepZeroWeight = res.fun # funcTime =float(time['tfunc']) # weight=float(cfg ['OCConstraints']['{temporal_weight_limit}']) # sepZeroWeight=weight*funcTime/2e0 print (" calculate smallest overlap of absolute values (method=SLSQP):") iteration=1 res=minimize(seperateZero, #smallestOverlapSeperateZero, # smallestOverlapSeperatePeaks, #smallestComplxOverlap, # smallestAbsoluteOverlap, # smallestOverlapSeperateZeroPartial, # x0, method='SLSQP', constraints=minContraints, tol=cfg['OCConstraints']['{tol_classic}'], options={'maxiter' : 25000, 'disp' : True}, callback=monitor ) success=res.success gamma=getGamma(res.x) print ("") print (" current norm(aplhaR) = " +str(sp.linalg.norm(gamma[ :nRead]))) print (" current norm(aplhaD) = " +str(sp.linalg.norm(gamma[nRead:nDown]))) print (" current norm(aplhaU) = " +str(sp.linalg.norm(gamma[nDown:nUp ]))) print (" current partial Olap = " +str(partialOverlap(res.x))) # print (" current hole(value) = " +str(constraintHoleValue(res.x))) # print (" current hole(slope) = " +str(constraintHoleSlope(res.x))) # print (" current hole(value) = " +str(constraintHoleCurv(res.x))) varStep+=1 if (success): print ("\ndone with minimization, succeeded:") else: print ("\ndone with minimization, no success:") sp.savetxt(name_vector,sp.array([gamma.real,gamma.conj().imag]).T) # [real(gamma), imag(gamma)].conj() cmd=baseDir+"generateOptimized" call(cmd.split())
def main_routine (wd="./",cfg="./python/parameter.cfg",generationType="p",\ toMinimize =2,\ cavityMatch=1,\ silent=0,\ useBeta=0,\ cutoff=10000,dimGrid=11,id0=0,id1=1,id2=2,pltId='funval',pltLim=1000,pltBins=40,myCmap="brg"): print "#################################################################" print "#################################################################" print "### optimal control #############################################" print "### memory pulse evaluation #####################################" print "#################################################################" print "#################################################################" ### globals for functional variation global cons, fun, dim, conf conf['toMinimize'] =toMinimize conf['cavityMatch']=cavityMatch conf['silent'] =silent if (useBeta == 0): conf['useBeta'] = False else: conf['useBeta'] = True conf['id0'] =id0 conf['id1'] =id1 conf['id2'] =id2 conf['cutoff'] =cutoff ### globals for functional variation ### generate working environment ### print ("### working directory: " + wd) tmpDir = wd+"tmp/" cmd = "mkdir -p " + tmpDir call(cmd.split()) ### generate working environment ### ### read config file ### print ("### load config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() conf['MEConstraints'] = cfg['MEConstraints'].copy() conf['FITNESS']= cfg['FITNESS'].copy() conf['FITNESS']['{mutationrate}']=sp.zeros([conf['entries']]) conf['FITNESS']['{mutationrate}'][conf['funval']] =cfg['FITNESS']['{mut_functional}'] conf['FITNESS']['{mutationrate}'][conf['fidelity_down']]=cfg['FITNESS']['{mut_fidelity_down}'] conf['FITNESS']['{mutationrate}'][conf['fidelity_up']] =cfg['FITNESS']['{mut_fidelity_up}'] conf['FITNESS']['{mutationrate}'][conf['memolap']] =cfg['FITNESS']['{mut_memolap}'] conf['FITNESS']['{mutationrate}'][conf['alpha']] =cfg['FITNESS']['{mut_alpha}'] conf['FITNESS']['{mutationrate}'][conf['beta']] =cfg['FITNESS']['{mut_beta}'] conf['FITNESS']['{mutationrate}'][conf['success']] =cfg['FITNESS']['{mut_success}'] cons['alpha_norm']=float(cfg['MEConstraints']["{storage_amplitude}"]) cons['beta_low'] =float(cfg['MEConstraints']["{limit_low_beta}"]) cons['beta_top'] =float(cfg['MEConstraints']["{limit_top_beta}"]) cons['chi2_Tol'] =float(cfg['MEConstraints']['{tol_chi2}']) dim['alpha']=int(cfg['MEFourier']['{storage_harmonic}']) dim['total']=dim['alpha']+3 prefix =cfg['FILES']['{prefix}'] postfix =cfg['FILES']['{postfix}'] name_optimized=cfg['FILES']['{name_optimized}'] name_spin =cfg['FILES']['{name_spin}'] name_cavity =cfg['FILES']['{name_cavity}'] cfg['dim_grid'] =dimGrid name_readwrite=IOHelper.getNameReadWrite(**cfg) name_storage =IOHelper.getNameStorage (**cfg) name_varinit =IOHelper.getNameInitialVariation (**cfg) myTime =IOHelper.functionaltimes_readwrite(**cfg) # reads time and updates cfg: # cfg['METime']['{fidelity_ti}'] = myTime['idx_ti'] # cfg['METime']['{fidelity_tf}'] = myTime['idx_tf'] gridPhi =sp.linspace(0.0, 2.0*sp.pi, num=2*dimGrid-1) gridTheta =sp.linspace(0.0, sp.pi, num=dimGrid) minfun =sp.zeros([len(gridPhi),len(gridTheta),conf['entries']+3]) if (generationType == "p"): print "## read from file: " + name_varinit raw = sp.loadtxt(name_varinit) minfun = raw.reshape(len(gridPhi),len(gridTheta),conf['entries']+3) for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): minfun[i,j,conf['fitness']] = MemoryPulseFunctional.fitnessFunction(minfun[i,j,:]) else: ### prepare and complie fortran routines ### print ("### prepare fortran routines") replace_in_file('./python/py.parNvCenter.F95' , tmpDir +'parNvCenter.F95' , **cfg['NVSETUP']) replace_in_file('./python/py.parMemoryPulse.F95', tmpDir +'parMemoryPulse.F95', **cfg['MEFourier']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['OCFourier']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['MESpin']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['MEConstraints']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['OCConstraints']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['METime']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['OCTime']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['FILES']) #write config file with open(prefix+"parameter.cfg", 'wb') as configfile: configParser.write(configfile) ### read config file ### print ("### compile fortran routines") cmd = "mv "+tmpDir+"parMemoryPulse.F95 "+wd+"srcOptCntrl/parMemoryPulse.F95" call(cmd.split()) cmd = "mv "+tmpDir+"parNvCenter.F95 "+wd+"srcNv/parNvCenter.F95" call(cmd.split()) cmd = "./scripts/ifort-memoryHarmonics.sh " + wd call(cmd.split()) print ("### invoke fortran routines") print ("### generation Type: " + generationType) cmd = wd+"memoryHarmonics" # location of executable fortran program generateHarmonics = Popen(cmd.split(), stdin=PIPE) # run fortran program with piped standard input cmd = "echo " + generationType # communication with fortran-routine: chose action -> read or generate generateInput = Popen(cmd.split(), stdout=generateHarmonics.stdin) # send action to fortran program output = generateHarmonics.communicate()[0] generateInput.wait() ### prepare and complie fortran routines ### ### read data for functional variation ### cons['cavityT2_down'], \ cons['cavityT2_up'] = IOHelper.read_CavityMemory (**cfg['FILES']) fun ['mtrxBeta_up'], \ cons['vecT2_up'] , \ cons['fidelity_up'], \ cons['mtrxMemOlap'] = IOHelper.read_MtrxMemory("up", **cfg['FILES']) fun ['mtrxBeta_down'], \ cons['vecT2_down'] , \ cons['fidelity_down'], \ __ = IOHelper.read_MtrxMemory("down", **cfg['FILES']) ### read data for functional variation ### ### functional variation ### print ("\n### start minimization: ") print ("### on initial "+ str(sp.shape(minfun)[0])+"x"+str(sp.shape(minfun)[1]) + "-grid (phi,theta) on sphere") mincnt=0 cntPhi =0 t0=0 tcnt=len(gridTheta) for phi in gridPhi[0:len(gridPhi)-1]: theta_i=0 if(cntPhi > 0): t0=1 tcnt=len(gridTheta)-1 theta_i=1 ### parallel evaluation with <cpu_count()> cores ################################### pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) results = [ pool.apply_async(evaluateSphericalVariation, args=(phi,theta,cntPhi,cntTheta)) for theta,cntTheta in zip(gridTheta[t0:tcnt],sp.arange(t0,tcnt,1)) ] for p in results: myResult,i,j =p.get() minfun[i,j,:]=myResult #kill multiprocessing pool !!! pool.terminate() ### parallel evaluation with <cpu_count()> cores ################################### ### sequentiell evaluateion 1 core ################################################# # for theta in gridTheta[t0:tcnt]: # minfun[cntPhi,theta_i,:],__,__=MemoryPulseFunctional.evaluateSphericalVariation (phi,theta,cntPhi,theta_i) # theta_i+=1 ### sequentiell evaluateion 1 core ################################################# cntPhi=cntPhi+1 # end for phi minfun[ :, 0,:]=minfun[0, 0,:] # theta=0 : same vector on unit-sphere minfun[ :,-1,:]=minfun[0,-1,:] # theta=pi : same vector on unit-sphere minfun[-1, :,:]=minfun[0, :,:] # periodic print "\n### write to file: " + name_varinit sp.savetxt(name_varinit,minfun.reshape((len(gridPhi)*len(gridTheta),conf['entries']+3)),\ header=' alpha0['+str(id0)+']; alpha0['+str(id1)+']; alpha0['+str(id2)+'];'\ +' fitness; success; norm[alpha]; abs[beta]; memolap; fidelity_up; fidelity_down; minfun') print "#################################################################" print "#################################################################" font = { 'fontsize' : 26, } mytitle=MemoryPulseFunctional.getName(pltId) ### prepare surface_plot ############################################################### x = outer(cos(gridPhi), sin(gridTheta)) y = outer(sin(gridPhi), sin(gridTheta)) z = outer(ones(size(gridPhi)), cos(gridTheta)) myDensity=sp.zeros([len(gridPhi),len(gridTheta)]) for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): if (minfun[i,j,conf[pltId]] >= pltLim): myDensity[i,j] = pltLim+1 else: myDensity[i,j] = minfun[i,j,conf[pltId]] # "afmhot", "hot", "terrain", "brg" cm = plt.cm.get_cmap(myCmap) myColors = cm(myDensity/pltLim) ### prepare surface_plot ############################################################### ### prepare colormap ################################################################### fig0_colors=sp.linspace(0,pltLim,pltBins) ### prepare colormap ################################################################### ### prepare histogram ################################################################## yHist,xHist = sp.histogram(myDensity.flatten(),pltBins) # xSpan = pltxHist.max()-xHist.min() # Color = [cm(((ix-xHist.min())/xSpan)) for ix in xHist] Color = [cm(((ix)/pltLim)) for ix in xHist] ### prepare histogram ################################################################## ### calculate fittest solutions ######################################################## cntFit = 0 for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): if minfun[i,j,conf['fitness']] != 0.0 : cntFit+=1 if (minfun[i,j,conf[pltId]] >= pltLim): myDensity[i,j] = pltLim else: myDensity[i,j] = minfun[i,j,conf[pltId]] if (cntFit > 0): fitAlpha =sp.zeros([cntFit,int(cfg['MEFourier']['{storage_harmonic}'])]) cntFit = 0 for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): if minfun[i,j,conf['fitness']] != 0.0 : print minfun[i,j,3:] fitAlpha[cntFit,conf['id0']]=minfun[i,j,0] fitAlpha[cntFit,conf['id1']]=minfun[i,j,1] fitAlpha[cntFit,conf['id2']]=minfun[i,j,2] cntFit+=1 name_fittest=IOHelper.getNameInitialFittest(**cfg) print "\n### write fittest to file: " + name_fittest sp.savetxt(name_fittest,fitAlpha,\ header='# alpha0[0] ... alpha0[n]') print "### fitness counter: {0:} of {1:}".format(cntFit,sp.shape(minfun)[0]*sp.shape(minfun)[1]) ### calculate fittest solutions ######################################################## fig = plt.figure() ### plot surface_plot ################################################################## fig3D = fig.add_subplot(131, projection='3d') surf = fig3D.plot_surface(x, y, z, rstride=1, cstride=1,facecolors=myColors) fig3D.plot(cos(gridPhi), sin(gridPhi), zs=0, zdir='z',lw=0.5, color="black") fig3D.plot(cos(gridPhi), sin(gridPhi), zs=0, zdir='x',lw=0.5, color="black") fig3D.set_xlabel("$\\alpha_{:}$".format(id0), **font) fig3D.set_ylabel("$\\alpha_{:}$".format(id1), **font) fig3D.set_zlabel("$\\alpha_{:}$".format(id2), **font) fig3D.set_title("a) 4d-plot of "+mytitle, fontsize = 20) ### plot surface_plot ################################################################## ### plot colormap ###################################################################### fig0 = fig.add_subplot(132) fig0.invert_yaxis() cp0=fig0.contourf(gridPhi/sp.pi,gridTheta/sp.pi,minfun[:,:,conf[pltId]].T,fig0_colors,cmap=cm) plt.colorbar(cp0) fig0.set_xlabel("$\phi/\pi$", **font) fig0.set_ylabel("$\\theta/\pi$", **font) fig0.set_title("b) map of "+mytitle, fontsize = 20) ### plot colormap ###################################################################### ### plot histogram ##################################################################### figBar=fig.add_subplot(133) figBar.bar(xHist[:-1],yHist,color=Color,width=xHist[1]-xHist[0]) figBar.set_xlim([0,pltLim]) figBar.set_ylim([0,max(yHist[0:len(yHist)-1])]) figBar.set_xlabel(mytitle, fontsize=20) figBar.set_ylabel("count", fontsize=20) figBar.set_title("c) histogram", fontsize = 20) ### plot histogram ##################################################################### plt.show()
def upload_textarea(request,spath): ext_allowed = ['gif', 'jpg', 'jpeg', 'png','bmp'] max_size = 2621440 today = datetime.datetime.today() #save_dir = 'image/%d/%d/%d/' % (today.year, today.month, today.day) spath = spath+'/' save_path = os.path.join(settings.MEDIA_ROOT, spath) save_url = os.path.join(settings.MEDIA_URL, spath) #print save_dir, save_path, save_url if request.method == 'POST': file = request.FILES['imgFile'] if not file.name: return HttpResponse(json.dumps( { 'error': 1, 'message': u'请选择要上传的文件' } )) ext = file.name.split('.').pop() if ext not in ext_allowed: return HttpResponse(json.dumps( { 'error': 1, 'message': u'请上传后缀为%s的文件' % ext_allowed} )) if file.size > max_size: return HttpResponse(json.dumps( { 'error': 1, 'message': u'上传的文件大小不能超过2.5MB'} )) if not os.path.isdir(save_path): os.makedirs(save_path) file_name_no_ext = str(uuid.uuid1()) #new_file = '%s.%s' % (int(time.time()), ext) new_file = '%s.%s' % (file_name_no_ext, ext) destination = open(save_path+new_file, 'wb+') for chunk in file.chunks(): destination.write(chunk) destination.close() import IOHelper file_md5 = IOHelper.GetFileMD5(save_path+new_file) edit_new_file = '%s.%s' % (file_md5, ext) if os.path.exists(save_path+edit_new_file): #如果该文件的MD5已存在,则删除 os.remove(save_path+new_file) else: #否则改名 os.rename(save_path+new_file, save_path+edit_new_file) if settings.FILE_SAVE_DISK_TYPE == 1: #保存到七牛云 from QiNiuHelper import SaveFileToQiNiu status,qiniu_text = SaveFileToQiNiu(settings.BASE_DIR + save_url+edit_new_file,True) if status == 0: return HttpResponse(json.dumps( { 'error': 0, 'message':qiniu_text } )) else: return HttpResponse(json.dumps( { 'error': 0, 'url': 'http://'+qiniu_text} )) else: return HttpResponse(json.dumps( { 'error': 0, 'url': '/'+save_url+edit_new_file} )) # TODO we should show the uploaded file and the manager url save_url+new_file #return HttpResponse("Upload Succsefull to URL:%s" % (save_url+new_file) ) #return HttpResponse(json.dumps( # {'error':0,'message':save_url+new_file} #)) else: raise Http404
def main_routine (wd="./",cfg="./python/parameter.cfg",thetaCnt=11,phiCnt=11,bloch=0,myMap="jet",minOlap=0,fortranCheck=0,gridR=5,gridC=5): ### read config file ### print ("load from config file: " + cfg) cfg=IOHelper.loadCfg(wd,cfg) #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] dt = float(time['delta_t']) filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] ### read data ### ### plotting Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2Read = sp.dot(alphaR.conj(),cavityRead) Reg2DownRead = Reg2Down + Reg2Read Reg2UpRead = Reg2Up + Reg2Read spos = sp.zeros([2,thetaCnt,phiCnt],complex) FuncInfoOlap = sp.zeros([2,thetaCnt,phiCnt],complex) gamma = sp.zeros([thetaCnt,phiCnt],complex) delta = sp.zeros([thetaCnt,phiCnt],complex) # I00 = 1j*cumtrapz( (Reg2Down[ti:tf].conj() * Reg2Down[ti:tf]).imag, x=None, dx=dt )[-1] I00 = cumtrapz( (Reg2Down[ti:tf] * Reg2Down[ti:tf].conj()).real, x=None, dx=dt )[-1] I01 = 1j*cumtrapz( (Reg2Up [ti:tf] * Reg2Down[ti:tf].conj()).imag, x=None, dx=dt )[-1] I01 += cumtrapz( (Reg2Up [ti:tf] * Reg2Down[ti:tf].conj()).real, x=None, dx=dt )[-1] I0R = 1j*cumtrapz( (Reg2Read[ti:tf] * Reg2Down[ti:tf].conj()).imag, x=None, dx=dt )[-1] I0R += cumtrapz( (Reg2Read[ti:tf] * Reg2Down[ti:tf].conj()).real, x=None, dx=dt )[-1] # I11 = 1j*cumtrapz( (Reg2Up [ti:tf].conj() * Reg2Up [ti:tf]).imag, x=None, dx=dt )[-1] I11 = cumtrapz( (Reg2Up [ti:tf] * Reg2Up [ti:tf].conj()).real, x=None, dx=dt )[-1] I10 = 1j*cumtrapz( (Reg2Down[ti:tf] * Reg2Up [ti:tf].conj()).imag, x=None, dx=dt )[-1] I10 += cumtrapz( (Reg2Down[ti:tf] * Reg2Up [ti:tf].conj()).real, x=None, dx=dt )[-1] I1R = 1j*cumtrapz( (Reg2Read[ti:tf] * Reg2Up [ti:tf].conj()).imag, x=None, dx=dt )[-1] I1R += cumtrapz( (Reg2Read[ti:tf] * Reg2Up [ti:tf].conj()).real, x=None, dx=dt )[-1] for i in sp.arange(0.0,thetaCnt): theta = i/(thetaCnt-1.0) # from 0 to 1 * pi for j in sp.arange(0.0,phiCnt): phi = j/(phiCnt-1.0)*2.0 # from 0 to 2 * pi spos[0,i,j] = sp.cos(theta*sp.pi/2.0) spos[1,i,j] = sp.sin(theta*sp.pi/2.0)*sp.exp(1j*phi*sp.pi) if fortranCheck == 1: cmd = "./scripts/ifort-checkBloch.sh " + wd print ("compile fortran routines: "+cmd) call(cmd.split()) print ("### call checkBloch") cmd=wd+"checkBloch" generateSuperposition = Popen(cmd.split(), stdin=PIPE) # run fortran program with piped standard input cmd = "echo {:}".format(thetaCnt) # communication with fortran-routine: chose superposition parameter generateInput = Popen(cmd.split(), stdout=generateSuperposition.stdin) # send action to fortran program cmd = "echo {:}".format(phiCnt) # communication with fortran-routine: chose superposition parameter generateInput = Popen(cmd.split(), stdout=generateSuperposition.stdin) # send action to fortran program output = generateSuperposition.communicate()[0] generateInput.wait() FuncInfoOlap [0,:,:],FuncInfoOlap [1,:,:]=IOHelper.read_MtrxProjection(thetaCnt,phiCnt,**cfg['FILES']) else: for i in sp.arange(0.0,thetaCnt): for j in sp.arange(0.0,phiCnt): FuncCavity = spos[0,i,j]*Reg2Down[ti:tf] + spos[1,i,j]*Reg2Up[ti:tf] FuncCavity[:] += Reg2Read [ti:tf] FuncInfoOlap [0,i,j] = cumtrapz( (FuncCavity[:] * Reg2Down[ti:tf].conj()).real, x=None, dx=dt )[-1] FuncInfoOlap [0,i,j] += 1j*cumtrapz( (FuncCavity[:] * Reg2Down[ti:tf].conj()).imag, x=None, dx=dt )[-1] FuncInfoOlap [1,i,j] = cumtrapz( (FuncCavity[:] * Reg2Up[ti:tf].conj()).real, x=None, dx=dt )[-1] FuncInfoOlap [1,i,j] += 1j*cumtrapz( (FuncCavity[:] * Reg2Up[ti:tf].conj()).imag, x=None, dx=dt )[-1] if minOlap==0: gamma[:,:]=((FuncInfoOlap [0,:,:]-I0R)*I11+(I1R-FuncInfoOlap [1,:,:])*I01)/(I11*I00-I01*I10) delta[:,:]=((FuncInfoOlap [1,:,:]-I1R)*I00+(I0R-FuncInfoOlap [0,:,:])*I10)/(I11*I00-I01*I10) else : gamma[:,:]= (FuncInfoOlap [0,:,:]-I0R)/I00 delta[:,:]= (FuncInfoOlap [1,:,:]-I1R)/I11 fs = 22 label_size = 12 plt.rcParams['xtick.labelsize'] = label_size plt.rcParams['ytick.labelsize'] = label_size plt.rcParams['xtick.major.pad']='20' plt.rcParams['ytick.major.pad']='20' fig = plt.figure() if bloch == 0: xx, yy = sp.meshgrid(sp.linspace(0.0,2.0,phiCnt),sp.linspace(0.0,1.0,thetaCnt)) zmin = 0.0 zmax = +1.0 zzOlapR0 = gamma [:,:].real zzOlapI0 = gamma [:,:].imag zzErr0 = sp.absolute(gamma[:,:]-spos[0,:,:]) zzOlapR1 = delta [:,:].real zzOlapI1 = delta [:,:].imag zzErr1 = sp.absolute(delta[:,:]-spos[1,:,:]) fig1 = fig.add_subplot(321, projection='3d') fig1.plot_surface(xx, yy, zzOlapR0, rstride=gridR, cstride=gridC, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapR0.min(), vmax=zzOlapR0.max()) fig1.set_zlim(0,1) # fig1.set_title("Re$[\,\gamma_R\,]\\approx\cos(\\theta/2)$",fontsize=fs) fig1.set_title("Re$[\,\gamma_R\,]$",fontsize=fs) fig1.set_ylabel("$\\theta_W/\pi$",fontsize=fs) fig1.set_xlabel("$\phi_W / \pi$",fontsize=fs) fig1 = fig.add_subplot(323, projection='3d') fig1.plot_surface(xx, yy, zzOlapI0, rstride=gridR, cstride=gridC, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapI0.min(), vmax=zzOlapI0.max()) # fig1.set_zlim(-0.01,0.01) # fig1.set_title("Im$[\,\gamma_R\,]\\approx\cos(\\theta/2)$",fontsize=fs) fig1.set_title("Im$[\,\gamma_R\,]$",fontsize=fs) fig1.set_ylabel("$\\theta_W/\pi$",fontsize=fs) fig1.set_xlabel("$\phi_W/\pi$",fontsize=fs) fig1 = fig.add_subplot(322, projection='3d') fig1.plot_surface(xx, yy, zzOlapR1, rstride=gridR, cstride=gridC, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapR1.min(), vmax=zzOlapR1.max()) fig1.set_zlim(-1,1) # fig1.set_title("Re$[\,\delta_R\,]\\approx\sin(\\theta/2)\cos(\phi)$",fontsize=fs) fig1.set_title("Re$[\,\delta_R\,]$",fontsize=fs) fig1.set_ylabel("$\\theta_W/\pi$",fontsize=fs) fig1.set_xlabel("$\phi_W / \pi$",fontsize=fs) fig1 = fig.add_subplot(324, projection='3d') fig1.plot_surface(xx, yy, zzOlapI1, rstride=gridR, cstride=gridC, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzOlapI1.min(), vmax=zzOlapI1.max()) fig1.set_zlim(-1,1) # fig1.set_title("Im$[\,\delta_R\,]\\approx\sin(\\theta/2)\sin(\phi)$",fontsize=fs) fig1.set_title("Im$[\,\delta_R\,]$",fontsize=fs) fig1.set_ylabel("$\\theta_W/\pi$",fontsize=fs) fig1.set_xlabel("$\phi_W/\pi$",fontsize=fs) fig1 = fig.add_subplot(325, projection='3d') fig1.plot_surface(xx, yy, zzErr0, rstride=gridR, cstride=gridC, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzErr0.min(), vmax=zzErr0.max()) # fig1.set_zlim(-1,1) # fig1.set_title("Re$[\,\delta_R\,]\\approx\sin(\\theta/2)\cos(\phi)$",fontsize=fs) fig1.set_title("$\epsilon_\gamma$",fontsize=fs) fig1.set_ylabel("$\\theta_W/\pi$",fontsize=fs) fig1.set_xlabel("$\phi_W / \pi$",fontsize=fs) fig1 = fig.add_subplot(326, projection='3d') fig1.plot_surface(xx, yy, zzErr1, rstride=gridR, cstride=gridC, cmap=myMap, alpha=0.5,zorder=11.0,vmin=zzErr1.min(), vmax=zzErr1.max()) # fig1.set_zlim(-1,1) # fig1.set_title("Re$[\,\delta_R\,]\\approx\sin(\\theta/2)\cos(\phi)$",fontsize=fs) fig1.set_title("$\epsilon_\delta$",fontsize=fs) fig1.set_ylabel("$\\theta_W/\pi$",fontsize=fs) fig1.set_xlabel("$\phi_W / \pi$",fontsize=fs) else: # x_expect = 2e0*sp.real(FuncInfoOlap [0,:,:]*FuncInfoOlap [1,:,:]) # x = 2e0*sp.real(spos[0,:,:].conj()*spos [1,:,:]) y = 2e0*sp.real(spos[0,:,:].conj()*spos [1,:,:]/1.0j) z = sp.absolute(spos[0,:,:])**2 -sp.absolute(spos [1,:,:])**2 xprime = 2e0*sp.real(gamma [:,:].conj()*delta [:,:]) yprime = 2e0*sp.real(gamma [:,:].conj()*delta [:,:]/1.0j) zprime = sp.absolute(gamma [:,:])**2 -sp.absolute(delta [:,:])**2 myDensity = sp.sqrt(sp.absolute(x-xprime)**2 + sp.absolute(y-yprime)**2 + sp.absolute(z-zprime)**2) # myDensity = 1.0 - (x*xprime + y*yprime + z*zprime) cm = plt.cm.get_cmap(myMap) myMin = myDensity.min() myMax = max(sp.absolute(myDensity.max()),sp.absolute(myDensity.min())) myColors = cm(myDensity/myMax) m = plt.cm.ScalarMappable(cmap=myMap) fig3D = fig.add_subplot(1, 1, 1, projection='3d') surf = fig3D.plot_surface(xprime, yprime, zprime, rstride=1, cstride=1, linewidth=1, color="black", facecolors=myColors,shade=False,antialiased=True, vmin=myMin, vmax=myMax) # fig3D.plot_wireframe(x*1.01, y*1.01, z*1.01, rstride=1, cstride=1,alpha=1,linewidth=1,color="black") tick2=(myMin+myMax)/2.0 tick1=round_sig(myMin+(myMax-myMin)*0.1,2) tick3=round_sig(myMax-(myMax-myMin)*0.1,2) tick2=round_sig(tick2,2) print "### error boundaries:", tick1,tick2,tick3 m.set_array(myDensity) cb= plt.colorbar(m,shrink=0.5,aspect=7,ticks=([tick1,tick2,tick3])) cb.formatter.set_scientific(True) cb.formatter.set_powerlimits((0, 0)) cb.update_ticks() fig3D.set_xlabel("$\langle \sigma_x(\gamma^\prime,\delta^\prime) \\rangle$", fontsize=fs) fig3D.set_ylabel("$\langle \sigma_y(\gamma^\prime,\delta^\prime) \\rangle$", fontsize=fs) fig3D.set_zlabel("$\langle \sigma_z(\gamma^\prime,\delta^\prime) \\rangle$", fontsize=fs) fig3D.set_xticks([-1,0,1]) fig3D.set_xlim([-1.01,1.01]) fig3D.xaxis._axinfo['label']['space_factor'] = 2.0 fig3D.set_yticks([-1,0,1]) fig3D.set_ylim([-1.01,1.01]) fig3D.yaxis._axinfo['label']['space_factor'] = 2.0 fig3D.set_zticks([-1,0,1]) fig3D.set_zlim([-1.01,1.01]) fig3D.zaxis._axinfo['label']['space_factor'] = 2.0 plt.show()
def main_routine (writeBase=8.0,writeCnt=1,readBase=2.0,readCnt=1,datPath="dat/",prefix="pa",destPath="../parallel/",gentype="c",funcCfg=0): """ Parameters: ----------- --writeBase: maximum value of writing time interval in multiples of Pi/{base_rabi}. (float) --wirteCnt: number of different writing intervals from 1.0 to writeBase times Pi/{base_rabi} (int) --readBase: maximum value of reading time interval in multiples of Pi/{base_rabi}. (float) --readCnt: number of different reading intervals from 1.0 to readBase times Pi/{base_rabi} (int) --destPath: directory where output files are generated (for every parameter setting of writeBase/writeCnt, readBase/readCnt a corresponding subdirectory is created) (string) --gentype : type of data generation --> g : generate data with modNv r : read data with modNv and c : collect data and produce 3d plot of reading area """ dWrite = sp.array(range(0,writeCnt)) dRead = sp.array(range(0,readCnt)) if (writeCnt == 1): write_base = sp.ones([readCnt])*writeBase else: write_base = (1.0+(writeBase-1.0)/float(writeCnt-1)*dWrite[:]) if (readCnt == 1): read_base = sp.ones([writeCnt])*readBase else: read_base = (1.0+(readBase-1.0)/float(readCnt-1)*dRead[:]) print read_base # print (write_base) # print (read_base) if (gentype=="g" or gentype=="r"): # generate pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) results = [ pool.apply_async(run_single_job, args=(wb,rb,datPath,prefix,destPath,gentype,funcCfg)) for wb,rb in zip(write_base, read_base) ] results = [ p.get() for p in results ] pool.terminate() elif (gentype=="c"): # collect configPath="./python/parameter.cfg" print ("load from config file: " + configPath) configParser = cp.ConfigParser() configParser.read(configPath) cfg=configParser.__dict__['_sections'].copy() nRead =int(cfg['OCFourier']['{read_harmonic}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) timeCntWrite = int(cfg['OCTime']['{write_timecnt}']) timeCntRead = int(cfg['OCTime']['{read_timecnt}']) timeCnt = timeCntRead+timeCntWrite omega_c=float(cfg['NVSETUP']['{omega_c}'])*2.0*sp.pi omega_r=float(cfg['OCFourier']['{base_rabi}'])/1e6 tUnit =sp.pi/(2.0*sp.pi*1e3*omega_r) filelist=[] div =10.0 # readCnt = 17 cavity=sp.zeros((2,readCnt,timeCntRead)) time =sp.zeros(timeCnt) wb=write_base[-1] # choose last element errCnt=[] name_optimized=cfg['FILES']['{name_optimized}'] name_readwrite=IOHelper.getNameReadWrite(**cfg) for rb in range(readCnt): newDir=dest(destPath,wb,read_base[rb]) cfg['FILES']['{prefix}'] = newDir+datPath+prefix+name_readwrite+name_optimized try: filename=cfg['FILES']['{prefix}']+"cavityMode_read_down"+cfg['FILES']['{postfix}'] print filename time,real,imag = sp.loadtxt(filename).T cavity[0,rb,:] = real[timeCntWrite:timeCntWrite+timeCntRead]**2+imag[timeCntWrite:timeCntWrite+timeCntRead]**2 except: errCnt.append("down: {:8.4f}\n".format(read_base[rb])) try: filename=cfg['FILES']['{prefix}']+"cavityMode_read_up"+cfg['FILES']['{postfix}'] time,real,imag = sp.loadtxt(filename).T cavity[1,rb,:] = real[timeCntWrite:timeCntWrite+timeCntRead]**2+imag[timeCntWrite:timeCntWrite+timeCntRead]**2 except: errCnt.append("up: {:8.4f}\n".format(read_base[rb])) if (len(errCnt) != 0): print ("can't read some files:\n" + str(errCnt)) print ("generating color map") # read funtional times t2, t3 newDir=dest(destPath,wb,read_base.max()) cfg['FILES']['{prefix}']=newDir+datPath+prefix functime =IOHelper.functionaltimes_readwrite(**cfg) ti=float(functime['ti'])/omega_c/tUnit # in nano seconds ti_i = int(functime['idx_ti'])-1 tf=float(functime['tf'])/omega_c/tUnit # in nano seconds tf_i = int(functime['idx_tf']) functimeX =sp.array([1.0,readBase]) functimeY =sp.array([(tf+ti)/2.0,tf]) cutShortX =sp.array([1.0,1.0]) cutLargeX =sp.array([readBase,readBase]) cutShortY =sp.array([writeBase,writeBase+readBase/2.0]) cutLargeY =sp.array([writeBase,writeBase+readBase]) functimeZ =sp.array([-1.5,-1.5]) functimeYMid=sp.array([ti + (tf-ti)/4.0,ti+ (tf-ti)/2.0]) # read funtional times t2, t3 # define the grid over which the function should be plotted (xx and yy are matrices) xx, yy = sp.meshgrid(sp.linspace(1.0,readBase,readCnt), sp.linspace(ti,tf,tf_i-ti_i)) zz0 = cavity[0,:,ti_i:tf_i].T/cavity[:,:,ti_i:tf_i].max() zz1 = cavity[1,:,ti_i:tf_i].T/cavity[:,:,ti_i:tf_i].max() # xx, yy = sp.meshgrid(sp.linspace(1.0,readBase,readCnt), # sp.linspace(time[timeCntRead/div]/tUnit,time[-1]/tUnit,timeCntRead/div)) # zz1 = cavity[0,:,:].T/cavity[:,:,:].max() # zz1 = cavity[1,:,:].T/cavity[:,:,:].max() font = { 'fontsize' : 26, 'verticalalignment' : 'top', 'horizontalalignment' : 'center' } # cm('font', **font) # rc('text', usetex=True) fig = plt.figure() # ax = fig.gca(projection='3d') fig0 = fig.add_subplot(121, projection='3d') fig0.plot_surface(xx, yy, zz0, rstride=10, cstride=5, cmap=cm.Blues, alpha=0.5,zorder=11.0,vmin=-0.25, vmax=1) fig0.contourf(xx, yy, zz0, zdir='z', offset=-1.5, cmap=cm.Blues,vmin=-0.25, vmax=1) fig0.plot(functimeX, functimeY, functimeZ,'k--',zorder=10.0) fig0.plot(functimeX, functimeYMid, functimeZ,'k--',zorder=10.0) fig0.plot(cutShortX, cutShortY, functimeZ,'m-',linewidth=2.5,zorder=10.0) fig0.plot(cutLargeX, cutLargeY, functimeZ,'g-',linewidth=2.5,zorder=10.0) fig0.set_title("a) state \"0\"", **font) fig0.set_xlabel("$\Delta T_{\cal F} \, / \, \\frac{T_R}{2}$", **font) fig0.set_ylabel("$t \, / \, \\frac{T_R}{2}$", **font) fig0.set_zlabel("$\left|A(t)\\right|^2 \, / \, \left|A_{max}(t)\\right|^2$", **font) fig0.set_zlim(-1.5, 1.0) fig1 = fig.add_subplot(122, projection='3d') fig1.plot_surface(xx, yy, zz1, rstride=10, cstride=5, cmap=cm.Reds, alpha=0.5,zorder=11.0,vmin=-0.25, vmax=1) fig1.contourf(xx, yy, zz1, zdir='z', offset=-1.5, cmap=cm.Reds,vmin=-0.25, vmax=1) fig1.plot(functimeX, functimeY, functimeZ,'k--',zorder=10.0) fig1.plot(functimeX, functimeYMid, functimeZ,'k--',zorder=10.0) fig1.plot(cutShortX, cutShortY, functimeZ,'m-',linewidth=2.5,zorder=10.0) fig1.plot(cutLargeX, cutLargeY, functimeZ,'g-',linewidth=2.5,zorder=10.0) fig1.set_title("b) state \"1\"", **font) fig1.set_xlabel("$\Delta T_{\cal F} \, / \, \\frac{T_R}{2}$", **font) fig1.set_ylabel("$t \, / \, \\frac{T_R}{2}$", **font) fig1.set_zlabel("$\left|A(t)\\right|^2 \, / \, \left|A_{max}(t)\\right|^2$", **font) fig1.set_zlim(-1.5, 1.0) # plt.subplot(1, 2, 1) # plt.pcolor(xx,yy,zz0) # plt.axis([xx.min(),xx.max(),yy.min(),yy.max()]) # plt.plot(functimeX,functimeY, 'w', linewidth=2) # plt.plot(functimeX,functimeYMid, 'w-', linewidth=2) # plt.title("time bin state \"0\"") # plt.xlabel("$T_{functional} \, / \, \\frac{\pi}{\Omega_R[MHz]}$", **font) # plt.ylabel("$t \, / \, \\frac{\pi}{\Omega_R[MHz]}$", **font) # plt.subplot(1, 2, 2) # plt.pcolor(xx,yy,zz1) # plt.axis([xx.min(),xx.max(),ti,tf]) # plt.plot(functimeX,functimeY, 'w', linewidth=2) # plt.plot(functimeX,functimeYMid, 'w-', linewidth=2) # plt.title("time bin sstate \"1\"") # plt.xlabel("$T_{functional} \, / \, \\frac{\pi}{\Omega_R[MHz]}$", **font) # plt.colorbar(label="$\left|A_{0,/1}(t)\\right|^2 \, / \, max(\left|A(t))\\right|^2$") plt.show() else: print ("option unkown: gentype="+gentype)
def main_routine (wd="./",cfg="./python/parameter.cfg",cnt=11,sptype=1,myCmap="RdYlBu"): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] dt = float(time['delta_t']) filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] ### read data ### ### plotting Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2Read = sp.dot(alphaR.conj(),cavityRead) Reg2DownRead = Reg2Down + Reg2Read Reg2UpRead = Reg2Up + Reg2Read FuncInfo = sp.zeros([cnt,2]) FuncInfoPhase = sp.zeros([cnt,2]) FuncSuperRead = sp.zeros([cnt,functime.size],complex) denom = sp.zeros([2]) denom[0] = cumtrapz( sp.absolute(Reg2DownRead[ti:tf])**2, x=None, dx=dt )[-1] denom[1] = cumtrapz( sp.absolute(Reg2UpRead[ti:tf])**2, x=None, dx=dt )[-1] for i in sp.arange(0.0,cnt): phi = i*2.0/(cnt-1.0) Reg1Super = superimpose(Reg1Down,Reg1Up,phi,sptype) Reg2Super = superimpose(Reg2Down,Reg2Up,phi,sptype) Reg2SuperRead = Reg2Super + Reg2Read FuncSuperRead[i,:] = Reg2SuperRead[ti:tf] FuncInfoIntegrand = sp.absolute(FuncSuperRead[i,:]) * sp.absolute(Reg2DownRead[ti:tf]) FuncInfo[i,0] = cumtrapz( FuncInfoIntegrand, x=None, dx=dt )[-1]/denom[0] FuncInfoIntegrand = sp.absolute(FuncSuperRead[i,:]) * sp.absolute(Reg2UpRead[ti:tf]) FuncInfo[i,1] = cumtrapz( FuncInfoIntegrand, x=None, dx=dt )[-1]/denom[1] FuncInfoIntegrand = FuncSuperRead[i,:].conj() * Reg2UpRead[ti:tf] FuncInfoPhase[i,0] = cumtrapz( FuncInfoIntegrand.real, x=None, dx=dt )[-1]/denom[1] FuncInfoPhase[i,1] = cumtrapz( FuncInfoIntegrand.imag, x=None, dx=dt )[-1]/denom[1] xx, yy = sp.meshgrid(functime,sp.linspace(0.0,2.0,cnt)) zzR = FuncSuperRead.real/FuncSuperRead.real.max() zzI = FuncSuperRead.imag/FuncSuperRead.imag.max() zzA = sp.absolute(FuncSuperRead)**2/((sp.absolute(FuncSuperRead)**2).max()) zmin = -1.5 zmax = +1.0 fs = 20 cm = plt.cm.get_cmap(myCmap) myColors = cm(zzR) fig = plt.figure() fig0 = fig.add_subplot(231, projection='3d') fig0.plot_surface(xx, yy, zzA, rstride=10, cstride=5, cmap=cm, alpha=0.5,zorder=11.0,vmin=-1, vmax=1) fig0.contourf(xx, yy, zzA, zdir='z', offset=zmin, cmap=cm, vmin=-1, vmax=1,zorder=1.0) fig0.set_zlim(zmin,zmax) fig0.set_title("a) normalized $|A_0(t;\phi_0)|^2$",fontsize=fs) fig0.set_xlabel("$t$ in ns",fontsize=fs) fig0.set_ylabel("$\phi_0/\pi$",fontsize=fs) fig1 = fig.add_subplot(232, projection='3d') fig1.plot_surface(xx, yy, zzR, rstride=10, cstride=5, cmap=cm, alpha=0.5,zorder=11.0,vmin=-1, vmax=1) fig1.contourf(xx, yy, zzR, zdir='z', offset=zmin, cmap=cm, vmin=-1, vmax=1,zorder=1.0) fig1.set_zlim(zmin,zmax) fig1.set_title("b) normalized $Re[\,A_0(t;\phi_0)\,]$",fontsize=fs) fig1.set_xlabel("$t$ in ns",fontsize=fs) fig1.set_ylabel("$\phi_0/\pi$",fontsize=fs) fig2 = fig.add_subplot(233, projection='3d') fig2.plot_surface(xx, yy, zzI, rstride=10, cstride=5, cmap=cm, alpha=0.5,zorder=11.0,vmin=-1, vmax=1) fig2.contourf(xx, yy, zzI, zdir='z', offset=zmin, cmap=cm, vmin=-1, vmax=1,zorder=1.0) fig2.set_zlim(zmin,zmax) fig2.set_title("c) normalized $Im[\,A_0(t;\phi_0)\,]$",fontsize=fs) fig2.set_xlabel("$t$ in ns",fontsize=fs) fig2.set_ylabel("$\phi_0/\pi$",fontsize=fs) plt.subplot2grid((2,3),(1,0),colspan=1,rowspan=1) plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfo[:,0],label="overlap with $i=$'$0$'",linewidth="2",color="blue") plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfo[:,1],label="overlap with $i=$'$1$'",linewidth="2",color="red") plt.ylim(0,1.1) plt.xlabel("$\phi_0/\pi$",fontsize=fs) plt.legend(bbox_to_anchor=(0.52, 0.0), loc=3, borderaxespad=0.) plt.title("d) classical overlap, $O_{\mathbb{R}}(i)$",fontsize=fs) # plt.title("$\\frac{1}{N}\int_{T_{{\cal F}1}}^{T_{{\cal F}2}}dt\,|A_0(t;\phi_0)|\cdot|A_i(t)|$",fontsize=fs) # FuncInfoPhase[:,0]-=min(FuncInfoPhase[:,0]) # FuncInfoPhase[:,0]/=0.5*max(sp.absolute(FuncInfoPhase[:,0])) # FuncInfoPhase[:,0]-=1.0 # FuncInfoPhase[:,1]-=min(FuncInfoPhase[:,1]) # FuncInfoPhase[:,1]/=0.5*max(sp.absolute(FuncInfoPhase[:,1])) # FuncInfoPhase[:,1]-=1.0 plt.subplot2grid((2,3),(1,1),colspan=1,rowspan=1) plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfoPhase[:,0],label="Re[ $O_{\mathbb{C}}($'$1$'$)$ ]",linewidth="2",color="red") plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfoPhase[:,1],label="Im[ $O_{\mathbb{C}}($'$1$'$)$ ]",linewidth="2",color="magenta") plt.title("e) complex overlap, $O_{\mathbb{C}}($'$1$'$)$",fontsize=fs) # plt.title("$\\frac{1}{N}\int_{T_{{\cal F}1}}^{T_{{\cal F}2}}dt\,A_0(t;\phi_0)^*\cdot A_1(t)$",fontsize=fs) plt.xlabel("$\phi_0/\pi$",fontsize=fs) plt.legend(bbox_to_anchor=(0.66, 0.0), loc=3, borderaxespad=0.) plt.ylim(-1,1.1) FuncInfoPhase[:,0]-=min(FuncInfoPhase[:,0]) FuncInfoPhase[:,0]/=0.5*max(sp.absolute(FuncInfoPhase[:,0])) FuncInfoPhase[:,0]-=1.0 FuncInfoPhase[:,1]-=min(FuncInfoPhase[:,1]) FuncInfoPhase[:,1]/=0.5*max(sp.absolute(FuncInfoPhase[:,1])) FuncInfoPhase[:,1]-=1.0 # plt.subplot2grid((2,3),(1,2),colspan=1,rowspan=1) # plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfoPhase[:,0],linewidth="2",color="red") # plt.plot(sp.linspace(0.0,2.0,cnt),FuncInfoPhase[:,1],linewidth="2",color="magenta") # plt.title("f) $O_{\mathbb{C}}$ scaled & translated, $(O_{\mathbb{C}}($'$1$'$)-I_R)/I_0$",fontsize=fs) # plt.xlabel("$\phi_0/\pi$",fontsize=fs) # plt.ylim(-1,1) plt.show()
def main_routine (wd="./",cfg="./python/parameter.cfg",gammaCnt=11,bloch=0,myMap="custom",project=0): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] dt = float(time['delta_t']) filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] ### read data ### ### plotting Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2Read = sp.dot(alphaR.conj(),cavityRead) Reg2DownRead = Reg2Down + Reg2Read Reg2UpRead = Reg2Up + Reg2Read myDensity = sp.zeros([functime.size,gammaCnt]) FuncCavity = sp.zeros([functime.size,gammaCnt],complex) spos = sp.zeros([2,gammaCnt]) FuncInfoOlap = sp.zeros([2,gammaCnt],complex) I00 = cumtrapz( sp.real(Reg2DownRead[ti:tf] * Reg2DownRead[ti:tf].conj()), x=None, dx=dt )[-1] I11 = cumtrapz( sp.real(Reg2UpRead[ti:tf] * Reg2UpRead[ti:tf].conj()), x=None, dx=dt )[-1] for g in sp.arange(0.0,gammaCnt): gamma = g/(gammaCnt-1.0) myDensity[:,g]=1.0-gamma spos[0,g] = gamma spos[1,g] = 1.0-gamma FuncCavity[:,g] = spos[0,g]*Reg2Down[ti:tf] + spos[1,g]*Reg2Up[ti:tf] FuncCavity[:,g] += Reg2Read [ti:tf] FuncInfoOlap [0,g] = cumtrapz( (FuncCavity[:,g] * Reg2DownRead[ti:tf].conj()).real, x=None, dx=dt )[-1] FuncInfoOlap [0,g] += 1j*cumtrapz( (FuncCavity[:,g] * Reg2DownRead[ti:tf].conj()).imag, x=None, dx=dt )[-1] FuncInfoOlap [0,g] /= I00 FuncInfoOlap [0,g] = sp.absolute(FuncInfoOlap [0,g]) FuncInfoOlap [1,g] = cumtrapz( (FuncCavity[:,g] * Reg2UpRead[ti:tf].conj()).real, x=None, dx=dt )[-1] FuncInfoOlap [1,g] += 1j*cumtrapz( (FuncCavity[:,g] * Reg2UpRead[ti:tf].conj()).imag, x=None, dx=dt )[-1] FuncInfoOlap [1,g] /= I11 FuncInfoOlap [1,g] = sp.absolute(FuncInfoOlap [1,g]) # FuncInfoOlap [0,g] = cumtrapz( sp.absolute(FuncCavity[:,g]) * sp.absolute(Reg2DownRead[ti:tf].conj()), x=None, dx=dt )[-1] # FuncInfoOlap [0,g] /= I00 # FuncInfoOlap [1,g] = cumtrapz( sp.absolute(FuncCavity[:,g]) * sp.absolute(Reg2UpRead[ti:tf].conj()), x=None, dx=dt )[-1] # FuncInfoOlap [1,g] /= I11 fig = plt.figure() fs = 22 label_size = 20 plt.rcParams['xtick.labelsize'] = label_size plt.rcParams['ytick.labelsize'] = label_size xx, yy = sp.meshgrid(sp.linspace(0.0,1.0,gammaCnt),functime) zmax = (sp.absolute(FuncCavity)**2).max() c = mcolors.ColorConverter().to_rgb if myMap =="custom" : cm = make_colormap( [c('blue'), c('purple'), c('red')]) else: cm = plt.cm.get_cmap(myMap) myColors = cm(myDensity) fig1 = fig.add_subplot(111, projection='3d') fig1.plot(spos[0,:], FuncInfoOlap [0,:].real, zs=functime[ project], zdir='y',lw=2.5, color="blue",label="$\gamma^{\prime}$",zorder=0.1) fig1.plot(spos[0,:], FuncInfoOlap [1,:].real, zs=functime[ project], zdir='y',lw=2.5, color="red" ,label="$\delta^{\prime}$",zorder=0.1) fig1.plot_surface(xx, yy, sp.absolute(FuncCavity)**2/zmax,rstride=1, cstride=1,alpha=1,facecolors=myColors, antialiased=False) fig1.plot_wireframe(xx, yy, sp.absolute(FuncCavity)**2/zmax, rstride=15, cstride=3,alpha=1,linewidth=1,color="black") fig1.legend(fontsize=fs) fig1.set_zlim(0,1.1) fig1.set_ylim(functime[0],functime[-1]) fig1.set_xticks([0,0.5,1]) fig1.set_yticks([55,75,95]) fig1.set_zticks([0,0.5,1]) fig1.set_xlim(0,1) fig1.set_zlabel("$|A(t)|^2$",fontsize=fs) fig1.set_ylabel("$t$ in ns",fontsize=fs) fig1.set_xlabel("$\gamma$",fontsize=fs) fig1.xaxis._axinfo['label']['space_factor'] = 2.0 fig1.yaxis._axinfo['label']['space_factor'] = 2.0 fig1.zaxis._axinfo['label']['space_factor'] = 2.0 # m.set_array(myDensity) # plt.colorbar(m,shrink=0.5,aspect=7) plt.show()
#if(movie_released): # key_words.append(movie_name+ " " + movie_language + " Movie Review"); # Call method to perform training #print "Systems is learning and getting trained to predict :) :)....\n" #--------------------------------------- STEP 2: TWITTER DATA--------------------------------------------- twitter_data = {} is_tweet_from_file = False # check if data is already present or should be fetched if (IOHelper.checkIfFileExists('../Data/TwitterDataContainer', key_word + '.csv')): print "Data already present !! Skipping data fetch from twitter" twitter_data[0] = IOHelper.readCsvToStringList('../Data/TwitterDataContainer/'+ key_word + '.csv') print "Completed fetching tweets from file !!\n\n" is_tweet_from_file = True else: # Fetch data from twitter #print "Fetching tweets from Twitter for keyword = ' " + key_word +" '. Please wait.....\n" print "Fetching tweets from Twitter for keyword = ' " + movie_name + " Movie" +" '. Please wait.....\n" #twitter_data[0] = get_tweets(key_word, 100) twitter_data[0] = get_tweets(movie_name+' Movie', 15) print "Completed fetching tweets from Twitter !!\n\n" #--------------------------------------- STEP 3: YOUTUBE DATA---------------------------------------------
def main_routine (wd="./",cfg="./python/parameter.cfg",delayCnt=11,delay=27.725,phaseCnt=11,sType=1,p3d=0,AMap="Blues",RMap="Reds",IMap="Greens"): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] dt = float(time['delta_t']) filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] ### read data ### ### plotting Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2Read = sp.dot(alphaR.conj(),cavityRead) Reg2DownRead = Reg2Down + Reg2Read Reg2UpRead = Reg2Up + Reg2Read # FuncInfo = sp.zeros([3,delayCnt,phaseCnt]) # FuncInfoPhase = sp.zeros([3,delayCnt,phaseCnt]) # FuncShiftRead = sp.zeros([3,delayCnt,phaseCnt,functime.size],complex) FuncShiftRead = sp.zeros([delayCnt,phaseCnt,functime.size],complex) FuncInfoOlap = sp.zeros([3,delayCnt,phaseCnt]) FuncInfoArea = sp.zeros([3,delayCnt,phaseCnt]) for i in sp.arange(0.0,delayCnt): myDelay = i/(delayCnt-1.0)*delay shift=sp.absolute(time['read'][:]-(functime[0]-myDelay)).argmin()-1 for j in sp.arange(0.0,phaseCnt): phi = j*2.0*sp.pi/(phaseCnt-1.0) FuncShiftRead[i,j,:] = sp.exp(-1j*phi)*Reg2Down[shift:shift+functime.size] + Reg2Read[shift:shift+functime.size] FuncShiftRead[i,j,:] += Reg2UpRead [ti:tf] # ????? why ?????? FuncInfoIntegrand = sp.absolute(FuncShiftRead[i,j,:])*sp.absolute(Reg2UpRead[ti:tf]) FuncInfoOlap [0,i,j] = cumtrapz( FuncInfoIntegrand, x=None, dx=dt )[-1] FuncInfoIntegrand = FuncShiftRead[i,j,:].conj() * Reg2UpRead[ti:tf] FuncInfoOlap [1,i,j] = cumtrapz( FuncInfoIntegrand.real, x=None, dx=dt )[-1] FuncInfoOlap [2,i,j] = cumtrapz( FuncInfoIntegrand.imag, x=None, dx=dt )[-1] FuncInfoArea [0,i,j] = cumtrapz( sp.absolute(FuncShiftRead[i,j,:])**2, x=None, dx=dt )[-1] FuncInfoArea [1,i,j] = cumtrapz( sp.real (FuncShiftRead[i,j,:]) , x=None, dx=dt )[-1] FuncInfoArea [2,i,j] = cumtrapz( sp.imag (FuncShiftRead[i,j,:]) , x=None, dx=dt )[-1] xx, yy = sp.meshgrid(sp.linspace(0.0,2.0*sp.pi,phaseCnt),sp.linspace(0.0,delay,delayCnt)) zzOlap2 = FuncInfoOlap[0,:,:]#/(sp.absolute(FuncInfoOlap[0,:,:]).max()) zzOlapR = FuncInfoOlap[1,:,:]#/(sp.absolute(FuncInfoOlap[1,:,:]).max()) zzOlapI = FuncInfoOlap[2,:,:]#/(sp.absolute(FuncInfoOlap[2,:,:]).max()) zzArea2 = FuncInfoArea[0,:,:]#/(sp.absolute(FuncInfoArea[0,:,:]).max()) zzAreaR = FuncInfoArea[1,:,:]#/(sp.absolute(FuncInfoArea[1,:,:]).max()) zzAreaI = FuncInfoArea[2,:,:]#/(sp.absolute(FuncInfoArea[2,:,:]).max()) zmin = 0.0 zmax = +1.0 fs = 20 fig = plt.figure() fig1 = fig.add_subplot(231, projection='3d') fig1.plot_surface(xx, yy, zzOlapR, rstride=5, cstride=5, cmap=RMap, alpha=0.5,zorder=11.0,vmin=zzOlapR.min(), vmax=zzOlapR.max()) # fig1.contourf(xx, yy, zzOlapR, zdir='z', offset=zmin, cmap=RMap, vmin=-1, vmax=1,zorder=1.0) fig1.set_zlim(zzOlapR.min(),zzOlap2.max()) fig1.set_title("a) Re$(O_{\mathbb{C}}(e^{-i\Phi_0}A_0(t-\Delta t)+A_1(t);A_1(t)))$",fontsize=fs) fig1.set_ylabel("$\Delta t$ in ns",fontsize=fs) fig1.set_xlabel("$\Phi_0/\pi$",fontsize=fs) fig2 = fig.add_subplot(232, projection='3d') fig2.plot_surface(xx, yy, zzOlapI, rstride=5, cstride=5, cmap=IMap, alpha=0.5,zorder=11.0,vmin=zzOlapI.min(), vmax=zzOlapI.max()) # fig2.contourf(xx, yy, zzOlapI, zdir='z', offset=zmin, cmap=IMap, vmin=-1, vmax=1,zorder=1.0) fig2.set_zlim(zzOlapI.min(),zzOlapI.max()) fig2.set_title("b) Im$(O_{\mathbb{C}}(e^{-i\Phi_0}A_0(t-\Delta t)+A_1(t);A_1(t)))$",fontsize=fs) fig2.set_ylabel("$\Delta t$ in ns",fontsize=fs) fig2.set_xlabel("$\Phi_0/\pi$",fontsize=fs) fig0 = fig.add_subplot(233, projection='3d') fig0.plot_surface(xx, yy, zzOlap2, rstride=5, cstride=5, cmap=AMap, alpha=0.5,zorder=11.0,vmin=zzOlap2.min(), vmax=zzOlap2.max()) # fig0.contourf(xx, yy, zzOlap2, zdir='z', offset=zmin, cmap=AMap, vmin=0, vmax=1,zorder=1.0) fig0.set_zlim(zzOlap2.min(),zzOlap2.max()) fig0.set_title("c) $O_{\mathbb{R}}(e^{-i\Phi_0}A_0(t-\Delta t)+A_1(t);A_1(t))$",fontsize=fs) fig0.set_ylabel("$\Delta t$ in ns",fontsize=fs) fig0.set_xlabel("$\Phi_0/\pi$",fontsize=fs) fig4 = fig.add_subplot(234, projection='3d') fig4.plot_surface(xx, yy, zzAreaR, rstride=5, cstride=5, cmap=RMap, alpha=0.5,zorder=11.0,vmin=zzAreaR.min(), vmax=zzAreaR.max()) # fig4.contourf(xx, yy, zzAreaR, zdir='z', offset=zmin, cmap=RMap, vmin=-1, vmax=1,zorder=1.0) fig4.set_zlim(zzAreaR.min(),zzAreaR.max()) fig4.set_title("d) Area under Re$(e^{-i\Phi_0}A_0(t-\Delta t)+A_1(t))$",fontsize=fs) fig4.set_ylabel("$\Delta t$ in ns",fontsize=fs) fig4.set_xlabel("$\Phi_0/\pi$",fontsize=fs) fig5 = fig.add_subplot(235, projection='3d') fig5.plot_surface(xx, yy, zzAreaI, rstride=5, cstride=5, cmap=IMap, alpha=0.5,zorder=11.0,vmin=zzAreaI.min(), vmax=zzAreaI.max()) # fig5.contourf(xx, yy, zzAreaI, zdir='z', offset=zmin, cmap=IMap, vmin=-1, vmax=1,zorder=1.0) fig5.set_zlim(zzAreaI.min(),zzAreaI.max()) fig5.set_title("e) Area under Im$(e^{-i\Phi_0}A_0(t-\Delta t)+A_1(t))$",fontsize=fs) fig5.set_ylabel("$\Delta t$ in ns",fontsize=fs) fig5.set_xlabel("$\Phi_0/\pi$",fontsize=fs) fig3 = fig.add_subplot(236, projection='3d') fig3.plot_surface(xx, yy, zzArea2, rstride=5, cstride=5, cmap=AMap, alpha=0.5,zorder=11.0,vmin=zzArea2.min(), vmax=zzArea2.max()) # fig3.contourf(xx, yy, zzArea2, zdir='z', offset=zmin, cmap=AMap, vmin=0, vmax=1,zorder=1.0) fig3.set_zlim(zzArea2.min(),zzArea2.max()) fig3.set_title("f) Area under $|e^{-i\Phi_0}A_0(t-\Delta t)+A_1(t)|^2$",fontsize=fs) fig3.set_ylabel("$\Delta t$ in ns",fontsize=fs) fig3.set_xlabel("$\Phi_0/\pi$",fontsize=fs) plt.show()
def main_routine (wd="./",cfg="./python/parameter.cfg",start=-1,cut1=1000.0,cut2=1000.0,cut3=1000.0,stop=-1,test=0,plotType=0,impose=0,par1=0.0,par2=0.0): ### read config file ### print ("load from config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) omega_c = float(cfg['NVSETUP']['{omega_c}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nRead =int(cfg['OCFourier']['{read_harmonic}']) nStore=int(cfg['MEFourier']['{storage_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite ### read config file ### ### read data ### cavityWrite,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) time['write'][:] *= 1e9 time['read'][:] *= 1e9 ti = int(time['idx_ti']) tf = int(time['idx_tf']) functime = time['read'][ti:tf] filename =IOHelper.getVectorOverlap(**cfg) reGamma,imGamma=sp.loadtxt(filename).T alphaR =reGamma[0:nRead] -1j*imGamma[0:nRead] alphaD =reGamma[nRead:nDown]-1j*imGamma[nRead:nDown] alphaU =reGamma[nDown:nUp] -1j*imGamma[nDown:nUp] ### read data ### ### plotting Reg1Down = sp.dot(alphaD.conj(),cavityWrite) Reg2Down = sp.dot(alphaD.conj(),cavityMemo) Reg2DownRead = Reg2Down + sp.dot(alphaR.conj(),cavityRead) Reg1Up = sp.dot(alphaU.conj(),cavityWrite) Reg2Up = sp.dot(alphaU.conj(),cavityMemo) Reg2UpRead = Reg2Up + sp.dot(alphaR.conj(),cavityRead) Reg1Super = superimpose(Reg1Down,Reg1Up,par1,par2) Reg2Super = superimpose(Reg2Down,Reg2Up,par1,par2) Reg2SuperRead = Reg2Super + sp.dot(alphaR.conj(),cavityRead) Reg2Read = sp.dot(alphaR.conj(),cavityRead) minT = min(functime) # min(time['read']) maxT = max(functime) # min(time['read']) minYComplete = -0.6 maxYComplete = 0.6 minYInfo = -0.6 maxYInfo = 0.4 minYRead = -0.4 maxYRead = 0.6 fs = 25 plt.subplot(5,3,1) plt.title("state '0'",fontsize=fs) plt.plot(time['read'],Reg2DownRead.real,color="blue",linewidth=2) plt.plot(time['read'],Reg2DownRead.imag,color="lightblue",linewidth=2) plt.ylabel("$A(t)$",fontsize=fs) plt.ylim([minYComplete,maxYComplete]) plt.xlim([minT,maxT]) plt.subplot(5,3,2) plt.title("state '1'",fontsize=fs) plt.plot(time['read'],Reg2UpRead.real,color="red",linewidth=2) plt.plot(time['read'],Reg2UpRead.imag,color="orange",linewidth=2) plt.ylim([minYComplete,maxYComplete]) plt.xlim([minT,maxT]) plt.subplot(5,3,3) plt.title("phaseshift $\phi_0=${:}$\pi$".format(par1),fontsize=fs) plt.plot(time['read'],Reg2SuperRead.real,color="green",linewidth=2) plt.plot(time['read'],Reg2SuperRead.imag,color="lightgreen",linewidth=2) plt.ylim([minYComplete,maxYComplete]) plt.xlim([minT,maxT]) plt.subplot(5,3,4) plt.plot(time['read'],sp.absolute(Reg2DownRead)**2,color="blue",linewidth=2) plt.ylabel("$|A(t)|^2$",fontsize=fs) plt.ylim([0,(max(sp.absolute(minYComplete),sp.absolute(maxYComplete)))]) plt.xlim([minT,maxT]) plt.subplot(5,3,5) plt.plot(time['read'],sp.absolute(Reg2UpRead)**2,color="red",linewidth=2) plt.ylim([0,(max(sp.absolute(minYComplete),sp.absolute(maxYComplete)))]) plt.xlim([minT,maxT]) plt.subplot(5,3,6) plt.plot(time['read'],sp.absolute(Reg2SuperRead)**2,color="green",linewidth=2) plt.ylim([0,(max(sp.absolute(minYComplete),sp.absolute(maxYComplete)))]) plt.xlim([minT,maxT]) plt.subplot(5,3,7) plt.plot(time['read'],Reg2Down.real,color="blue",linewidth=2) plt.plot(time['read'],Reg2Down.imag,color="lightblue",linewidth=2) plt.ylabel("$\\tilde{A}(t)$",fontsize=fs) plt.ylim([minYInfo,maxYInfo]) plt.xlim([minT,maxT]) plt.subplot(5,3,8) plt.plot(time['read'],Reg2Up.real,color="red",linewidth=2) plt.plot(time['read'],Reg2Up.imag,color="orange",linewidth=2) plt.ylim([minYInfo,maxYInfo]) plt.xlim([minT,maxT]) plt.subplot(5,3,9) plt.plot(time['read'],Reg2Super.real,color="green",linewidth=2) plt.plot(time['read'],Reg2Super.imag,color="lightgreen",linewidth=2) plt.ylim([minYInfo,maxYInfo]) plt.xlim([minT,maxT]) plt.subplot(5,3,10) plt.plot(time['read'],sp.absolute(Reg2Down)**2,color="blue",linewidth=2) plt.ylabel("$|\\tilde{A}(t)|^2$",fontsize=fs) plt.ylim([0,(max(sp.absolute(minYInfo),sp.absolute(maxYInfo)))]) plt.xlim([minT,maxT]) plt.subplot(5,3,11) plt.plot(time['read'],sp.absolute(Reg2Up)**2,color="red",linewidth=2) plt.ylim([0,(max(sp.absolute(minYInfo),sp.absolute(maxYInfo)))]) plt.xlim([minT,maxT]) plt.subplot(5,3,12) plt.plot(time['read'],sp.absolute(Reg2Super)**2,color="green",linewidth=2) plt.ylim([0,(max(sp.absolute(minYInfo),sp.absolute(maxYInfo)))]) plt.xlim([minT,maxT]) plt.subplot(5,3,13) plt.plot(time['read'],Reg2Read.real,linewidth=2,color="black") plt.plot(time['read'],Reg2Read.imag,linewidth=2,color="darkgray") plt.ylim([minYRead,maxYRead]) plt.xlim([minT,maxT]) plt.ylabel("$\\tilde{A}_R(t)$",fontsize=fs) plt.xlabel("$t$ in ns",fontsize=fs) plt.subplot(5,3,14) plt.plot(time['read'],Reg2Read.real,linewidth=2,color="black") plt.plot(time['read'],Reg2Read.imag,linewidth=2,color="darkgray") plt.ylim([minYRead,maxYRead]) plt.xlim([minT,maxT]) plt.xlabel("$t$ in ns",fontsize=fs) plt.subplot(5,3,15) plt.plot(time['read'],Reg2Read.real,linewidth=2,color="black") plt.plot(time['read'],Reg2Read.imag,linewidth=2,color="darkgray") plt.ylim([minYRead,maxYRead]) plt.xlim([minT,maxT]) plt.xlabel("$t$ in ns",fontsize=fs) # plt.subplot(4,3,5) # plt.plot(functime,ReadUpReg2[ti:tf].imag,color="darkgray",linewidth=2) # plt.plot(functime,cavityUpReg3[ti:tf].imag,color="red",linewidth=2) # plt.xlim([min(functime),max(functime)]) # plt.subplot(4,3,3) # if (impose != 1): # plt.title("$\\alpha_{S}$") # plt.bar(sp.arange(1,nStore+1,1),alphaS.real,color="green") # else : # plt.title("superposition, $A(t)$") # plt.plot(functime,ReadSuperReg2[ti:tf].real,color="darkgray",linewidth=2) # plt.plot(functime,cavitySuperReg3[ti:tf].real,color="green",linewidth=2) # plt.xlim([min(functime),max(functime)]) # plt.subplot(4,3,6) # if (impose != 1): # plt.bar(sp.arange(1,nStore+1,1),alphaS.imag,color="green") # else : # plt.plot(functime,ReadSuperReg2[ti:tf].imag,color="darkgray",linewidth=2) # plt.plot(functime,cavitySuperReg3[ti:tf].imag,color="green",linewidth=2) # plt.xlim([min(functime),max(functime)]) # plt.subplot2grid((4,3),(2,0),colspan=3,rowspan=2) # cavityCheckReg1,cavityCheckReg2,cavityCheckReg3 = pltFunction(cavityCheckReg1,cavityCheckReg2,cavityCheckReg3,plotType) # cavitySuperReg1,cavitySuperReg2,cavitySuperReg3 = pltFunction(cavitySuperReg1,cavitySuperReg2,cavitySuperReg3,plotType) # cavityDownReg1, cavityDownReg2, cavityDownReg3 = pltFunction(cavityDownReg1, cavityDownReg2, cavityDownReg3, plotType) # cavityUpReg1, cavityUpReg2, cavityUpReg3 = pltFunction(cavityUpReg1, cavityUpReg2, cavityUpReg3, plotType) # if (test==1): # print ("### compile fortran routines") # cmd = "./scripts/ifort-memoryHarmonics.sh " + wd # call(cmd.split()) # print ("### call memoryOptimized") # cmd=wd+"memoryOptimized" # call(cmd.split()) # print ("### call memorySuperimposed") # cmd=wd+"memorySuperimposed" # generateSuperposition = Popen(cmd.split(), stdin=PIPE) # run fortran program with piped standard input # cmd = "echo {:}".format(par1) # communication with fortran-routine: chose superposition parameter # generateInput = Popen(cmd.split(), stdout=generateSuperposition.stdin) # send action to fortran program # output = generateSuperposition.communicate()[0] # generateInput.wait() # filename = cfg['FILES']['{prefix}']+cfg['FILES']['{name_readwrite}']+\ # cfg['FILES']['{name_storage}']+cfg['FILES']['{name_optimized}'] # mytimeU,__,A_Re_U,A_Im_U = sp.loadtxt(filename+"cavity_up_stored" +cfg['FILES']['{postfix}']).T # mytimeD,__,A_Re_D,A_Im_D = sp.loadtxt(filename+"cavity_down_stored" +cfg['FILES']['{postfix}']).T # mytimeS,__,A_Re_S,A_Im_S = sp.loadtxt(filename+"cavity_super_stored"+cfg['FILES']['{postfix}']).T # cavityMode_U,cavityMode_D,cavityMode_S = pltFunction(A_Re_U+1j*A_Im_U, A_Re_D+1j*A_Im_D, A_Re_S+1j*A_Im_S,plotType) # cavityMaxDown = max(max(cavityDownReg1),max(cavityDownReg2),max(cavityDownReg3)) # cavityMaxUp = max(max(cavityUpReg1),max(cavityUpReg2),max(cavityUpReg3)) # cavityMaxSuper= max(max(cavitySuperReg1),max(cavitySuperReg2),max(cavitySuperReg3)) # cavityMax = max(cavityMaxDown,cavityMaxUp,cavityMaxSuper) # cavityMinDown = min(min(cavityDownReg1),min(cavityDownReg2),min(cavityDownReg3)) # cavityMinUp = min(min(cavityUpReg1),min(cavityUpReg2),min(cavityUpReg3)) # cavityMinSuper= max(min(cavitySuperReg1),min(cavitySuperReg2),min(cavitySuperReg3)) # cavityMin = min(cavityMinDown,cavityMinUp,cavityMinSuper) # plt.plot(time['write'],cavityDownReg1,color="blue",linewidth=2) # plt.plot(time['store'],cavityDownReg2,color="blue",linewidth=2) # plt.plot(time['read'] ,cavityDownReg3,color="blue",linewidth=2,label="state '0'") # plt.plot(time['write'],cavityUpReg1,color="red",linewidth=2) # plt.plot(time['store'],cavityUpReg2,color="red",linewidth=2) # plt.plot(time['read'] ,cavityUpReg3,color="red",linewidth=2,label="state '1'") # if (impose == 1): # plt.plot(time['write'],cavitySuperReg1,color="green",linewidth=2) # plt.plot(time['store'],cavitySuperReg2,color="green",linewidth=2) # plt.plot(time['read'] ,cavitySuperReg3,color="green",linewidth=2,label="super state") # if (test == 1): # plt.plot(mytimeD,cavityMode_D,label="state '0' test",color="cyan") # plt.plot(mytimeU,cavityMode_U,label="state '1' test",color="magenta") # if (impose == 1): # plt.plot(time['write'],cavityCheckReg1,color="orange") # plt.plot(time['store'],cavityCheckReg2,color="orange") # plt.plot(time['read'] ,cavityCheckReg3,color="orange",label="super state") # plt.plot(mytimeS,cavityMode_S,label="super state test",color="brown") ## plt.legend() # plt.xlabel('time in ns') # plt.ylabel('$|A(t)|^2$') # # if start != -1 and stop != -1: # plt.xlim([start,stop]) # else: # plt.xlim([min(time['write']),max(time['read'])]) # plt.ylim([cavityMin*1.1,cavityMax*1.1]) # plt.fill_between(functime, cavityMax*1.1, cavityMin*1.1, color='lightgray', facecolor='lightgray', alpha=0.5) # plt.plot([time['store'][0],time['store'][0]], [cavityMin*1.1,cavityMax*1.1], 'k--') # plt.plot([time['read'] [0],time['read'] [0]], [cavityMin*1.1,cavityMax*1.1], 'k--') # plt.plot([cut1,cut1],[0,cavityMax*1.1],linewidth=2.0) # plt.plot([cut2,cut2],[0,cavityMax*1.1],linewidth=2.0) # plt.plot([cut3,cut3],[0,cavityMax*1.1],linewidth=2.0) plt.show()